PackageManagerService.java revision 33d3c53da021f0d044028860ace0f4ad817273f5 
1/*
2 * Copyright (C) 2006 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.Manifest.permission.GRANT_REVOKE_PERMISSIONS;
20import static android.Manifest.permission.READ_EXTERNAL_STORAGE;
21import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
22import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
23import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
24import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
25import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
26import static android.content.pm.PackageManager.INSTALL_EXTERNAL;
27import static android.content.pm.PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
28import static android.content.pm.PackageManager.INSTALL_FAILED_CONFLICTING_PROVIDER;
29import static android.content.pm.PackageManager.INSTALL_FAILED_DEXOPT;
30import static android.content.pm.PackageManager.INSTALL_FAILED_DUPLICATE_PACKAGE;
31import static android.content.pm.PackageManager.INSTALL_FAILED_DUPLICATE_PERMISSION;
32import static android.content.pm.PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
33import static android.content.pm.PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
34import static android.content.pm.PackageManager.INSTALL_FAILED_INVALID_APK;
35import static android.content.pm.PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
36import static android.content.pm.PackageManager.INSTALL_FAILED_MISSING_SHARED_LIBRARY;
37import static android.content.pm.PackageManager.INSTALL_FAILED_PACKAGE_CHANGED;
38import static android.content.pm.PackageManager.INSTALL_FAILED_REPLACE_COULDNT_DELETE;
39import static android.content.pm.PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
40import static android.content.pm.PackageManager.INSTALL_FAILED_TEST_ONLY;
41import static android.content.pm.PackageManager.INSTALL_FAILED_UID_CHANGED;
42import static android.content.pm.PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
43import static android.content.pm.PackageManager.INSTALL_FAILED_USER_RESTRICTED;
44import static android.content.pm.PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
45import static android.content.pm.PackageManager.INSTALL_FORWARD_LOCK;
46import static android.content.pm.PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES;
47import static android.content.pm.PackageParser.isApkFile;
48import static android.os.Process.PACKAGE_INFO_GID;
49import static android.os.Process.SYSTEM_UID;
50import static android.system.OsConstants.O_CREAT;
51import static android.system.OsConstants.O_RDWR;
52import static com.android.internal.app.IntentForwarderActivity.FORWARD_INTENT_TO_MANAGED_PROFILE;
53import static com.android.internal.app.IntentForwarderActivity.FORWARD_INTENT_TO_USER_OWNER;
54import static com.android.internal.content.NativeLibraryHelper.LIB64_DIR_NAME;
55import static com.android.internal.content.NativeLibraryHelper.LIB_DIR_NAME;
56import static com.android.internal.util.ArrayUtils.appendInt;
57import static com.android.internal.util.ArrayUtils.removeInt;
58
59import android.util.ArrayMap;
60
61import com.android.internal.R;
62import com.android.internal.app.IMediaContainerService;
63import com.android.internal.app.ResolverActivity;
64import com.android.internal.content.NativeLibraryHelper;
65import com.android.internal.content.PackageHelper;
66import com.android.internal.os.IParcelFileDescriptorFactory;
67import com.android.internal.util.ArrayUtils;
68import com.android.internal.util.FastPrintWriter;
69import com.android.internal.util.FastXmlSerializer;
70import com.android.internal.util.IndentingPrintWriter;
71import com.android.server.EventLogTags;
72import com.android.server.IntentResolver;
73import com.android.server.LocalServices;
74import com.android.server.ServiceThread;
75import com.android.server.SystemConfig;
76import com.android.server.Watchdog;
77import com.android.server.pm.Settings.DatabaseVersion;
78import com.android.server.storage.DeviceStorageMonitorInternal;
79
80import org.xmlpull.v1.XmlSerializer;
81
82import android.app.ActivityManager;
83import android.app.ActivityManagerNative;
84import android.app.AppGlobals;
85import android.app.IActivityManager;
86import android.app.admin.IDevicePolicyManager;
87import android.app.backup.IBackupManager;
88import android.app.usage.UsageStats;
89import android.app.usage.UsageStatsManager;
90import android.content.BroadcastReceiver;
91import android.content.ComponentName;
92import android.content.Context;
93import android.content.IIntentReceiver;
94import android.content.Intent;
95import android.content.IntentFilter;
96import android.content.IntentSender;
97import android.content.IntentSender.SendIntentException;
98import android.content.ServiceConnection;
99import android.content.pm.ActivityInfo;
100import android.content.pm.ApplicationInfo;
101import android.content.pm.FeatureInfo;
102import android.content.pm.IPackageDataObserver;
103import android.content.pm.IPackageDeleteObserver;
104import android.content.pm.IPackageDeleteObserver2;
105import android.content.pm.IPackageInstallObserver2;
106import android.content.pm.IPackageInstaller;
107import android.content.pm.IPackageManager;
108import android.content.pm.IPackageMoveObserver;
109import android.content.pm.IPackageStatsObserver;
110import android.content.pm.InstrumentationInfo;
111import android.content.pm.KeySet;
112import android.content.pm.ManifestDigest;
113import android.content.pm.PackageCleanItem;
114import android.content.pm.PackageInfo;
115import android.content.pm.PackageInfoLite;
116import android.content.pm.PackageInstaller;
117import android.content.pm.PackageManager;
118import android.content.pm.PackageManager.LegacyPackageDeleteObserver;
119import android.content.pm.PackageParser.ActivityIntentInfo;
120import android.content.pm.PackageParser.PackageLite;
121import android.content.pm.PackageParser.PackageParserException;
122import android.content.pm.PackageParser;
123import android.content.pm.PackageStats;
124import android.content.pm.PackageUserState;
125import android.content.pm.ParceledListSlice;
126import android.content.pm.PermissionGroupInfo;
127import android.content.pm.PermissionInfo;
128import android.content.pm.ProviderInfo;
129import android.content.pm.ResolveInfo;
130import android.content.pm.ServiceInfo;
131import android.content.pm.Signature;
132import android.content.pm.UserInfo;
133import android.content.pm.VerificationParams;
134import android.content.pm.VerifierDeviceIdentity;
135import android.content.pm.VerifierInfo;
136import android.content.res.Resources;
137import android.hardware.display.DisplayManager;
138import android.net.Uri;
139import android.os.Binder;
140import android.os.Build;
141import android.os.Bundle;
142import android.os.Environment;
143import android.os.Environment.UserEnvironment;
144import android.os.storage.IMountService;
145import android.os.storage.StorageManager;
146import android.os.Debug;
147import android.os.FileUtils;
148import android.os.Handler;
149import android.os.IBinder;
150import android.os.Looper;
151import android.os.Message;
152import android.os.Parcel;
153import android.os.ParcelFileDescriptor;
154import android.os.Process;
155import android.os.RemoteException;
156import android.os.SELinux;
157import android.os.ServiceManager;
158import android.os.SystemClock;
159import android.os.SystemProperties;
160import android.os.UserHandle;
161import android.os.UserManager;
162import android.security.KeyStore;
163import android.security.SystemKeyStore;
164import android.system.ErrnoException;
165import android.system.Os;
166import android.system.StructStat;
167import android.text.TextUtils;
168import android.text.format.DateUtils;
169import android.util.ArraySet;
170import android.util.AtomicFile;
171import android.util.DisplayMetrics;
172import android.util.EventLog;
173import android.util.ExceptionUtils;
174import android.util.Log;
175import android.util.LogPrinter;
176import android.util.PrintStreamPrinter;
177import android.util.Slog;
178import android.util.SparseArray;
179import android.util.SparseBooleanArray;
180import android.view.Display;
181
182import java.io.BufferedInputStream;
183import java.io.BufferedOutputStream;
184import java.io.BufferedReader;
185import java.io.File;
186import java.io.FileDescriptor;
187import java.io.FileInputStream;
188import java.io.FileNotFoundException;
189import java.io.FileOutputStream;
190import java.io.FileReader;
191import java.io.FilenameFilter;
192import java.io.IOException;
193import java.io.InputStream;
194import java.io.PrintWriter;
195import java.nio.charset.StandardCharsets;
196import java.security.NoSuchAlgorithmException;
197import java.security.PublicKey;
198import java.security.cert.CertificateEncodingException;
199import java.security.cert.CertificateException;
200import java.text.SimpleDateFormat;
201import java.util.ArrayList;
202import java.util.Arrays;
203import java.util.Collection;
204import java.util.Collections;
205import java.util.Comparator;
206import java.util.Date;
207import java.util.Iterator;
208import java.util.List;
209import java.util.Map;
210import java.util.Objects;
211import java.util.Set;
212import java.util.concurrent.atomic.AtomicBoolean;
213import java.util.concurrent.atomic.AtomicLong;
214
215import dalvik.system.DexFile;
216import dalvik.system.StaleDexCacheError;
217import dalvik.system.VMRuntime;
218
219import libcore.io.IoUtils;
220import libcore.util.EmptyArray;
221
222/**
223 * Keep track of all those .apks everywhere.
224 *
225 * This is very central to the platform's security; please run the unit
226 * tests whenever making modifications here:
227 *
228mmm frameworks/base/tests/AndroidTests
229adb install -r -f out/target/product/passion/data/app/AndroidTests.apk
230adb shell am instrument -w -e class com.android.unit_tests.PackageManagerTests com.android.unit_tests/android.test.InstrumentationTestRunner
231 *
232 * {@hide}
233 */
234public class PackageManagerService extends IPackageManager.Stub {
235    static final String TAG = "PackageManager";
236    static final boolean DEBUG_SETTINGS = false;
237    static final boolean DEBUG_PREFERRED = false;
238    static final boolean DEBUG_UPGRADE = false;
239    private static final boolean DEBUG_INSTALL = false;
240    private static final boolean DEBUG_REMOVE = false;
241    private static final boolean DEBUG_BROADCASTS = false;
242    private static final boolean DEBUG_SHOW_INFO = false;
243    private static final boolean DEBUG_PACKAGE_INFO = false;
244    private static final boolean DEBUG_INTENT_MATCHING = false;
245    private static final boolean DEBUG_PACKAGE_SCANNING = false;
246    private static final boolean DEBUG_VERIFY = false;
247    private static final boolean DEBUG_DEXOPT = false;
248    private static final boolean DEBUG_ABI_SELECTION = false;
249
250    private static final int RADIO_UID = Process.PHONE_UID;
251    private static final int LOG_UID = Process.LOG_UID;
252    private static final int NFC_UID = Process.NFC_UID;
253    private static final int BLUETOOTH_UID = Process.BLUETOOTH_UID;
254    private static final int SHELL_UID = Process.SHELL_UID;
255
256    // Cap the size of permission trees that 3rd party apps can define
257    private static final int MAX_PERMISSION_TREE_FOOTPRINT = 32768;     // characters of text
258
259    // Suffix used during package installation when copying/moving
260    // package apks to install directory.
261    private static final String INSTALL_PACKAGE_SUFFIX = "-";
262
263    static final int SCAN_NO_DEX = 1<<1;
264    static final int SCAN_FORCE_DEX = 1<<2;
265    static final int SCAN_UPDATE_SIGNATURE = 1<<3;
266    static final int SCAN_NEW_INSTALL = 1<<4;
267    static final int SCAN_NO_PATHS = 1<<5;
268    static final int SCAN_UPDATE_TIME = 1<<6;
269    static final int SCAN_DEFER_DEX = 1<<7;
270    static final int SCAN_BOOTING = 1<<8;
271    static final int SCAN_TRUSTED_OVERLAY = 1<<9;
272    static final int SCAN_DELETE_DATA_ON_FAILURES = 1<<10;
273    static final int SCAN_REPLACING = 1<<11;
274
275    static final int REMOVE_CHATTY = 1<<16;
276
277    /**
278     * Timeout (in milliseconds) after which the watchdog should declare that
279     * our handler thread is wedged.  The usual default for such things is one
280     * minute but we sometimes do very lengthy I/O operations on this thread,
281     * such as installing multi-gigabyte applications, so ours needs to be longer.
282     */
283    private static final long WATCHDOG_TIMEOUT = 1000*60*10;     // ten minutes
284
285    /**
286     * Wall-clock timeout (in milliseconds) after which we *require* that an fstrim
287     * be run on this device.  We use the value in the Settings.Global.MANDATORY_FSTRIM_INTERVAL
288     * settings entry if available, otherwise we use the hardcoded default.  If it's been
289     * more than this long since the last fstrim, we force one during the boot sequence.
290     *
291     * This backstops other fstrim scheduling:  if the device is alive at midnight+idle,
292     * one gets run at the next available charging+idle time.  This final mandatory
293     * no-fstrim check kicks in only of the other scheduling criteria is never met.
294     */
295    private static final long DEFAULT_MANDATORY_FSTRIM_INTERVAL = 3 * DateUtils.DAY_IN_MILLIS;
296
297    /**
298     * Whether verification is enabled by default.
299     */
300    private static final boolean DEFAULT_VERIFY_ENABLE = true;
301
302    /**
303     * The default maximum time to wait for the verification agent to return in
304     * milliseconds.
305     */
306    private static final long DEFAULT_VERIFICATION_TIMEOUT = 10 * 1000;
307
308    /**
309     * The default response for package verification timeout.
310     *
311     * This can be either PackageManager.VERIFICATION_ALLOW or
312     * PackageManager.VERIFICATION_REJECT.
313     */
314    private static final int DEFAULT_VERIFICATION_RESPONSE = PackageManager.VERIFICATION_ALLOW;
315
316    static final String DEFAULT_CONTAINER_PACKAGE = "com.android.defcontainer";
317
318    static final ComponentName DEFAULT_CONTAINER_COMPONENT = new ComponentName(
319            DEFAULT_CONTAINER_PACKAGE,
320            "com.android.defcontainer.DefaultContainerService");
321
322    private static final String PACKAGE_MIME_TYPE = "application/vnd.android.package-archive";
323
324    private static final String VENDOR_OVERLAY_DIR = "/vendor/overlay";
325
326    private static String sPreferredInstructionSet;
327
328    final ServiceThread mHandlerThread;
329
330    private static final String IDMAP_PREFIX = "/data/resource-cache/";
331    private static final String IDMAP_SUFFIX = "@idmap";
332
333    final PackageHandler mHandler;
334
335    /**
336     * Messages for {@link #mHandler} that need to wait for system ready before
337     * being dispatched.
338     */
339    private ArrayList<Message> mPostSystemReadyMessages;
340
341    final int mSdkVersion = Build.VERSION.SDK_INT;
342
343    final Context mContext;
344    final boolean mFactoryTest;
345    final boolean mOnlyCore;
346    final boolean mLazyDexOpt;
347    final long mDexOptLRUThresholdInMills;
348    final DisplayMetrics mMetrics;
349    final int mDefParseFlags;
350    final String[] mSeparateProcesses;
351    final boolean mIsUpgrade;
352
353    // This is where all application persistent data goes.
354    final File mAppDataDir;
355
356    // This is where all application persistent data goes for secondary users.
357    final File mUserAppDataDir;
358
359    /** The location for ASEC container files on internal storage. */
360    final String mAsecInternalPath;
361
362    // Used for privilege escalation. MUST NOT BE CALLED WITH mPackages
363    // LOCK HELD.  Can be called with mInstallLock held.
364    final Installer mInstaller;
365
366    /** Directory where installed third-party apps stored */
367    final File mAppInstallDir;
368
369    /**
370     * Directory to which applications installed internally have their
371     * 32 bit native libraries copied.
372     */
373    private File mAppLib32InstallDir;
374
375    // Directory containing the private parts (e.g. code and non-resource assets) of forward-locked
376    // apps.
377    final File mDrmAppPrivateInstallDir;
378
379    // ----------------------------------------------------------------
380
381    // Lock for state used when installing and doing other long running
382    // operations.  Methods that must be called with this lock held have
383    // the suffix "LI".
384    final Object mInstallLock = new Object();
385
386    // ----------------------------------------------------------------
387
388    // Keys are String (package name), values are Package.  This also serves
389    // as the lock for the global state.  Methods that must be called with
390    // this lock held have the prefix "LP".
391    final ArrayMap<String, PackageParser.Package> mPackages =
392            new ArrayMap<String, PackageParser.Package>();
393
394    // Tracks available target package names -> overlay package paths.
395    final ArrayMap<String, ArrayMap<String, PackageParser.Package>> mOverlays =
396        new ArrayMap<String, ArrayMap<String, PackageParser.Package>>();
397
398    final Settings mSettings;
399    boolean mRestoredSettings;
400
401    // System configuration read by SystemConfig.
402    final int[] mGlobalGids;
403    final SparseArray<ArraySet<String>> mSystemPermissions;
404    final ArrayMap<String, FeatureInfo> mAvailableFeatures;
405
406    // If mac_permissions.xml was found for seinfo labeling.
407    boolean mFoundPolicyFile;
408
409    // If a recursive restorecon of /data/data/<pkg> is needed.
410    private boolean mShouldRestoreconData = SELinuxMMAC.shouldRestorecon();
411
412    public static final class SharedLibraryEntry {
413        public final String path;
414        public final String apk;
415
416        SharedLibraryEntry(String _path, String _apk) {
417            path = _path;
418            apk = _apk;
419        }
420    }
421
422    // Currently known shared libraries.
423    final ArrayMap<String, SharedLibraryEntry> mSharedLibraries =
424            new ArrayMap<String, SharedLibraryEntry>();
425
426    // All available activities, for your resolving pleasure.
427    final ActivityIntentResolver mActivities =
428            new ActivityIntentResolver();
429
430    // All available receivers, for your resolving pleasure.
431    final ActivityIntentResolver mReceivers =
432            new ActivityIntentResolver();
433
434    // All available services, for your resolving pleasure.
435    final ServiceIntentResolver mServices = new ServiceIntentResolver();
436
437    // All available providers, for your resolving pleasure.
438    final ProviderIntentResolver mProviders = new ProviderIntentResolver();
439
440    // Mapping from provider base names (first directory in content URI codePath)
441    // to the provider information.
442    final ArrayMap<String, PackageParser.Provider> mProvidersByAuthority =
443            new ArrayMap<String, PackageParser.Provider>();
444
445    // Mapping from instrumentation class names to info about them.
446    final ArrayMap<ComponentName, PackageParser.Instrumentation> mInstrumentation =
447            new ArrayMap<ComponentName, PackageParser.Instrumentation>();
448
449    // Mapping from permission names to info about them.
450    final ArrayMap<String, PackageParser.PermissionGroup> mPermissionGroups =
451            new ArrayMap<String, PackageParser.PermissionGroup>();
452
453    // Packages whose data we have transfered into another package, thus
454    // should no longer exist.
455    final ArraySet<String> mTransferedPackages = new ArraySet<String>();
456
457    // Broadcast actions that are only available to the system.
458    final ArraySet<String> mProtectedBroadcasts = new ArraySet<String>();
459
460    /** List of packages waiting for verification. */
461    final SparseArray<PackageVerificationState> mPendingVerification
462            = new SparseArray<PackageVerificationState>();
463
464    /** Set of packages associated with each app op permission. */
465    final ArrayMap<String, ArraySet<String>> mAppOpPermissionPackages = new ArrayMap<>();
466
467    final PackageInstallerService mInstallerService;
468
469    ArraySet<PackageParser.Package> mDeferredDexOpt = null;
470
471    // Cache of users who need badging.
472    SparseBooleanArray mUserNeedsBadging = new SparseBooleanArray();
473
474    /** Token for keys in mPendingVerification. */
475    private int mPendingVerificationToken = 0;
476
477    volatile boolean mSystemReady;
478    volatile boolean mSafeMode;
479    volatile boolean mHasSystemUidErrors;
480
481    ApplicationInfo mAndroidApplication;
482    final ActivityInfo mResolveActivity = new ActivityInfo();
483    final ResolveInfo mResolveInfo = new ResolveInfo();
484    ComponentName mResolveComponentName;
485    PackageParser.Package mPlatformPackage;
486    ComponentName mCustomResolverComponentName;
487
488    boolean mResolverReplaced = false;
489
490    // Set of pending broadcasts for aggregating enable/disable of components.
491    static class PendingPackageBroadcasts {
492        // for each user id, a map of <package name -> components within that package>
493        final SparseArray<ArrayMap<String, ArrayList<String>>> mUidMap;
494
495        public PendingPackageBroadcasts() {
496            mUidMap = new SparseArray<ArrayMap<String, ArrayList<String>>>(2);
497        }
498
499        public ArrayList<String> get(int userId, String packageName) {
500            ArrayMap<String, ArrayList<String>> packages = getOrAllocate(userId);
501            return packages.get(packageName);
502        }
503
504        public void put(int userId, String packageName, ArrayList<String> components) {
505            ArrayMap<String, ArrayList<String>> packages = getOrAllocate(userId);
506            packages.put(packageName, components);
507        }
508
509        public void remove(int userId, String packageName) {
510            ArrayMap<String, ArrayList<String>> packages = mUidMap.get(userId);
511            if (packages != null) {
512                packages.remove(packageName);
513            }
514        }
515
516        public void remove(int userId) {
517            mUidMap.remove(userId);
518        }
519
520        public int userIdCount() {
521            return mUidMap.size();
522        }
523
524        public int userIdAt(int n) {
525            return mUidMap.keyAt(n);
526        }
527
528        public ArrayMap<String, ArrayList<String>> packagesForUserId(int userId) {
529            return mUidMap.get(userId);
530        }
531
532        public int size() {
533            // total number of pending broadcast entries across all userIds
534            int num = 0;
535            for (int i = 0; i< mUidMap.size(); i++) {
536                num += mUidMap.valueAt(i).size();
537            }
538            return num;
539        }
540
541        public void clear() {
542            mUidMap.clear();
543        }
544
545        private ArrayMap<String, ArrayList<String>> getOrAllocate(int userId) {
546            ArrayMap<String, ArrayList<String>> map = mUidMap.get(userId);
547            if (map == null) {
548                map = new ArrayMap<String, ArrayList<String>>();
549                mUidMap.put(userId, map);
550            }
551            return map;
552        }
553    }
554    final PendingPackageBroadcasts mPendingBroadcasts = new PendingPackageBroadcasts();
555
556    // Service Connection to remote media container service to copy
557    // package uri's from external media onto secure containers
558    // or internal storage.
559    private IMediaContainerService mContainerService = null;
560
561    static final int SEND_PENDING_BROADCAST = 1;
562    static final int MCS_BOUND = 3;
563    static final int END_COPY = 4;
564    static final int INIT_COPY = 5;
565    static final int MCS_UNBIND = 6;
566    static final int START_CLEANING_PACKAGE = 7;
567    static final int FIND_INSTALL_LOC = 8;
568    static final int POST_INSTALL = 9;
569    static final int MCS_RECONNECT = 10;
570    static final int MCS_GIVE_UP = 11;
571    static final int UPDATED_MEDIA_STATUS = 12;
572    static final int WRITE_SETTINGS = 13;
573    static final int WRITE_PACKAGE_RESTRICTIONS = 14;
574    static final int PACKAGE_VERIFIED = 15;
575    static final int CHECK_PENDING_VERIFICATION = 16;
576
577    static final int WRITE_SETTINGS_DELAY = 10*1000;  // 10 seconds
578
579    // Delay time in millisecs
580    static final int BROADCAST_DELAY = 10 * 1000;
581
582    static UserManagerService sUserManager;
583
584    // Stores a list of users whose package restrictions file needs to be updated
585    private ArraySet<Integer> mDirtyUsers = new ArraySet<Integer>();
586
587    final private DefaultContainerConnection mDefContainerConn =
588            new DefaultContainerConnection();
589    class DefaultContainerConnection implements ServiceConnection {
590        public void onServiceConnected(ComponentName name, IBinder service) {
591            if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceConnected");
592            IMediaContainerService imcs =
593                IMediaContainerService.Stub.asInterface(service);
594            mHandler.sendMessage(mHandler.obtainMessage(MCS_BOUND, imcs));
595        }
596
597        public void onServiceDisconnected(ComponentName name) {
598            if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceDisconnected");
599        }
600    };
601
602    // Recordkeeping of restore-after-install operations that are currently in flight
603    // between the Package Manager and the Backup Manager
604    class PostInstallData {
605        public InstallArgs args;
606        public PackageInstalledInfo res;
607
608        PostInstallData(InstallArgs _a, PackageInstalledInfo _r) {
609            args = _a;
610            res = _r;
611        }
612    };
613    final SparseArray<PostInstallData> mRunningInstalls = new SparseArray<PostInstallData>();
614    int mNextInstallToken = 1;  // nonzero; will be wrapped back to 1 when ++ overflows
615
616    private final String mRequiredVerifierPackage;
617
618    private final PackageUsage mPackageUsage = new PackageUsage();
619
620    private class PackageUsage {
621        private static final int WRITE_INTERVAL
622            = (DEBUG_DEXOPT) ? 0 : 30*60*1000; // 30m in ms
623
624        private final Object mFileLock = new Object();
625        private final AtomicLong mLastWritten = new AtomicLong(0);
626        private final AtomicBoolean mBackgroundWriteRunning = new AtomicBoolean(false);
627
628        private boolean mIsHistoricalPackageUsageAvailable = true;
629
630        boolean isHistoricalPackageUsageAvailable() {
631            return mIsHistoricalPackageUsageAvailable;
632        }
633
634        void write(boolean force) {
635            if (force) {
636                writeInternal();
637                return;
638            }
639            if (SystemClock.elapsedRealtime() - mLastWritten.get() < WRITE_INTERVAL
640                && !DEBUG_DEXOPT) {
641                return;
642            }
643            if (mBackgroundWriteRunning.compareAndSet(false, true)) {
644                new Thread("PackageUsage_DiskWriter") {
645                    @Override
646                    public void run() {
647                        try {
648                            writeInternal();
649                        } finally {
650                            mBackgroundWriteRunning.set(false);
651                        }
652                    }
653                }.start();
654            }
655        }
656
657        private void writeInternal() {
658            synchronized (mPackages) {
659                synchronized (mFileLock) {
660                    AtomicFile file = getFile();
661                    FileOutputStream f = null;
662                    try {
663                        f = file.startWrite();
664                        BufferedOutputStream out = new BufferedOutputStream(f);
665                        FileUtils.setPermissions(file.getBaseFile().getPath(), 0640, SYSTEM_UID, PACKAGE_INFO_GID);
666                        StringBuilder sb = new StringBuilder();
667                        for (PackageParser.Package pkg : mPackages.values()) {
668                            if (pkg.mLastPackageUsageTimeInMills == 0) {
669                                continue;
670                            }
671                            sb.setLength(0);
672                            sb.append(pkg.packageName);
673                            sb.append(' ');
674                            sb.append((long)pkg.mLastPackageUsageTimeInMills);
675                            sb.append('\n');
676                            out.write(sb.toString().getBytes(StandardCharsets.US_ASCII));
677                        }
678                        out.flush();
679                        file.finishWrite(f);
680                    } catch (IOException e) {
681                        if (f != null) {
682                            file.failWrite(f);
683                        }
684                        Log.e(TAG, "Failed to write package usage times", e);
685                    }
686                }
687            }
688            mLastWritten.set(SystemClock.elapsedRealtime());
689        }
690
691        void readLP() {
692            synchronized (mFileLock) {
693                AtomicFile file = getFile();
694                BufferedInputStream in = null;
695                try {
696                    in = new BufferedInputStream(file.openRead());
697                    StringBuffer sb = new StringBuffer();
698                    while (true) {
699                        String packageName = readToken(in, sb, ' ');
700                        if (packageName == null) {
701                            break;
702                        }
703                        String timeInMillisString = readToken(in, sb, '\n');
704                        if (timeInMillisString == null) {
705                            throw new IOException("Failed to find last usage time for package "
706                                                  + packageName);
707                        }
708                        PackageParser.Package pkg = mPackages.get(packageName);
709                        if (pkg == null) {
710                            continue;
711                        }
712                        long timeInMillis;
713                        try {
714                            timeInMillis = Long.parseLong(timeInMillisString.toString());
715                        } catch (NumberFormatException e) {
716                            throw new IOException("Failed to parse " + timeInMillisString
717                                                  + " as a long.", e);
718                        }
719                        pkg.mLastPackageUsageTimeInMills = timeInMillis;
720                    }
721                } catch (FileNotFoundException expected) {
722                    mIsHistoricalPackageUsageAvailable = false;
723                } catch (IOException e) {
724                    Log.w(TAG, "Failed to read package usage times", e);
725                } finally {
726                    IoUtils.closeQuietly(in);
727                }
728            }
729            mLastWritten.set(SystemClock.elapsedRealtime());
730        }
731
732        private String readToken(InputStream in, StringBuffer sb, char endOfToken)
733                throws IOException {
734            sb.setLength(0);
735            while (true) {
736                int ch = in.read();
737                if (ch == -1) {
738                    if (sb.length() == 0) {
739                        return null;
740                    }
741                    throw new IOException("Unexpected EOF");
742                }
743                if (ch == endOfToken) {
744                    return sb.toString();
745                }
746                sb.append((char)ch);
747            }
748        }
749
750        private AtomicFile getFile() {
751            File dataDir = Environment.getDataDirectory();
752            File systemDir = new File(dataDir, "system");
753            File fname = new File(systemDir, "package-usage.list");
754            return new AtomicFile(fname);
755        }
756    }
757
758    class PackageHandler extends Handler {
759        private boolean mBound = false;
760        final ArrayList<HandlerParams> mPendingInstalls =
761            new ArrayList<HandlerParams>();
762
763        private boolean connectToService() {
764            if (DEBUG_SD_INSTALL) Log.i(TAG, "Trying to bind to" +
765                    " DefaultContainerService");
766            Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
767            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
768            if (mContext.bindServiceAsUser(service, mDefContainerConn,
769                    Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
770                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
771                mBound = true;
772                return true;
773            }
774            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
775            return false;
776        }
777
778        private void disconnectService() {
779            mContainerService = null;
780            mBound = false;
781            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
782            mContext.unbindService(mDefContainerConn);
783            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
784        }
785
786        PackageHandler(Looper looper) {
787            super(looper);
788        }
789
790        public void handleMessage(Message msg) {
791            try {
792                doHandleMessage(msg);
793            } finally {
794                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
795            }
796        }
797
798        void doHandleMessage(Message msg) {
799            switch (msg.what) {
800                case INIT_COPY: {
801                    HandlerParams params = (HandlerParams) msg.obj;
802                    int idx = mPendingInstalls.size();
803                    if (DEBUG_INSTALL) Slog.i(TAG, "init_copy idx=" + idx + ": " + params);
804                    // If a bind was already initiated we dont really
805                    // need to do anything. The pending install
806                    // will be processed later on.
807                    if (!mBound) {
808                        // If this is the only one pending we might
809                        // have to bind to the service again.
810                        if (!connectToService()) {
811                            Slog.e(TAG, "Failed to bind to media container service");
812                            params.serviceError();
813                            return;
814                        } else {
815                            // Once we bind to the service, the first
816                            // pending request will be processed.
817                            mPendingInstalls.add(idx, params);
818                        }
819                    } else {
820                        mPendingInstalls.add(idx, params);
821                        // Already bound to the service. Just make
822                        // sure we trigger off processing the first request.
823                        if (idx == 0) {
824                            mHandler.sendEmptyMessage(MCS_BOUND);
825                        }
826                    }
827                    break;
828                }
829                case MCS_BOUND: {
830                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_bound");
831                    if (msg.obj != null) {
832                        mContainerService = (IMediaContainerService) msg.obj;
833                    }
834                    if (mContainerService == null) {
835                        // Something seriously wrong. Bail out
836                        Slog.e(TAG, "Cannot bind to media container service");
837                        for (HandlerParams params : mPendingInstalls) {
838                            // Indicate service bind error
839                            params.serviceError();
840                        }
841                        mPendingInstalls.clear();
842                    } else if (mPendingInstalls.size() > 0) {
843                        HandlerParams params = mPendingInstalls.get(0);
844                        if (params != null) {
845                            if (params.startCopy()) {
846                                // We are done...  look for more work or to
847                                // go idle.
848                                if (DEBUG_SD_INSTALL) Log.i(TAG,
849                                        "Checking for more work or unbind...");
850                                // Delete pending install
851                                if (mPendingInstalls.size() > 0) {
852                                    mPendingInstalls.remove(0);
853                                }
854                                if (mPendingInstalls.size() == 0) {
855                                    if (mBound) {
856                                        if (DEBUG_SD_INSTALL) Log.i(TAG,
857                                                "Posting delayed MCS_UNBIND");
858                                        removeMessages(MCS_UNBIND);
859                                        Message ubmsg = obtainMessage(MCS_UNBIND);
860                                        // Unbind after a little delay, to avoid
861                                        // continual thrashing.
862                                        sendMessageDelayed(ubmsg, 10000);
863                                    }
864                                } else {
865                                    // There are more pending requests in queue.
866                                    // Just post MCS_BOUND message to trigger processing
867                                    // of next pending install.
868                                    if (DEBUG_SD_INSTALL) Log.i(TAG,
869                                            "Posting MCS_BOUND for next work");
870                                    mHandler.sendEmptyMessage(MCS_BOUND);
871                                }
872                            }
873                        }
874                    } else {
875                        // Should never happen ideally.
876                        Slog.w(TAG, "Empty queue");
877                    }
878                    break;
879                }
880                case MCS_RECONNECT: {
881                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_reconnect");
882                    if (mPendingInstalls.size() > 0) {
883                        if (mBound) {
884                            disconnectService();
885                        }
886                        if (!connectToService()) {
887                            Slog.e(TAG, "Failed to bind to media container service");
888                            for (HandlerParams params : mPendingInstalls) {
889                                // Indicate service bind error
890                                params.serviceError();
891                            }
892                            mPendingInstalls.clear();
893                        }
894                    }
895                    break;
896                }
897                case MCS_UNBIND: {
898                    // If there is no actual work left, then time to unbind.
899                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_unbind");
900
901                    if (mPendingInstalls.size() == 0 && mPendingVerification.size() == 0) {
902                        if (mBound) {
903                            if (DEBUG_INSTALL) Slog.i(TAG, "calling disconnectService()");
904
905                            disconnectService();
906                        }
907                    } else if (mPendingInstalls.size() > 0) {
908                        // There are more pending requests in queue.
909                        // Just post MCS_BOUND message to trigger processing
910                        // of next pending install.
911                        mHandler.sendEmptyMessage(MCS_BOUND);
912                    }
913
914                    break;
915                }
916                case MCS_GIVE_UP: {
917                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_giveup too many retries");
918                    mPendingInstalls.remove(0);
919                    break;
920                }
921                case SEND_PENDING_BROADCAST: {
922                    String packages[];
923                    ArrayList<String> components[];
924                    int size = 0;
925                    int uids[];
926                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
927                    synchronized (mPackages) {
928                        if (mPendingBroadcasts == null) {
929                            return;
930                        }
931                        size = mPendingBroadcasts.size();
932                        if (size <= 0) {
933                            // Nothing to be done. Just return
934                            return;
935                        }
936                        packages = new String[size];
937                        components = new ArrayList[size];
938                        uids = new int[size];
939                        int i = 0;  // filling out the above arrays
940
941                        for (int n = 0; n < mPendingBroadcasts.userIdCount(); n++) {
942                            int packageUserId = mPendingBroadcasts.userIdAt(n);
943                            Iterator<Map.Entry<String, ArrayList<String>>> it
944                                    = mPendingBroadcasts.packagesForUserId(packageUserId)
945                                            .entrySet().iterator();
946                            while (it.hasNext() && i < size) {
947                                Map.Entry<String, ArrayList<String>> ent = it.next();
948                                packages[i] = ent.getKey();
949                                components[i] = ent.getValue();
950                                PackageSetting ps = mSettings.mPackages.get(ent.getKey());
951                                uids[i] = (ps != null)
952                                        ? UserHandle.getUid(packageUserId, ps.appId)
953                                        : -1;
954                                i++;
955                            }
956                        }
957                        size = i;
958                        mPendingBroadcasts.clear();
959                    }
960                    // Send broadcasts
961                    for (int i = 0; i < size; i++) {
962                        sendPackageChangedBroadcast(packages[i], true, components[i], uids[i]);
963                    }
964                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
965                    break;
966                }
967                case START_CLEANING_PACKAGE: {
968                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
969                    final String packageName = (String)msg.obj;
970                    final int userId = msg.arg1;
971                    final boolean andCode = msg.arg2 != 0;
972                    synchronized (mPackages) {
973                        if (userId == UserHandle.USER_ALL) {
974                            int[] users = sUserManager.getUserIds();
975                            for (int user : users) {
976                                mSettings.addPackageToCleanLPw(
977                                        new PackageCleanItem(user, packageName, andCode));
978                            }
979                        } else {
980                            mSettings.addPackageToCleanLPw(
981                                    new PackageCleanItem(userId, packageName, andCode));
982                        }
983                    }
984                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
985                    startCleaningPackages();
986                } break;
987                case POST_INSTALL: {
988                    if (DEBUG_INSTALL) Log.v(TAG, "Handling post-install for " + msg.arg1);
989                    PostInstallData data = mRunningInstalls.get(msg.arg1);
990                    mRunningInstalls.delete(msg.arg1);
991                    boolean deleteOld = false;
992
993                    if (data != null) {
994                        InstallArgs args = data.args;
995                        PackageInstalledInfo res = data.res;
996
997                        if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
998                            res.removedInfo.sendBroadcast(false, true, false);
999                            Bundle extras = new Bundle(1);
1000                            extras.putInt(Intent.EXTRA_UID, res.uid);
1001                            // Determine the set of users who are adding this
1002                            // package for the first time vs. those who are seeing
1003                            // an update.
1004                            int[] firstUsers;
1005                            int[] updateUsers = new int[0];
1006                            if (res.origUsers == null || res.origUsers.length == 0) {
1007                                firstUsers = res.newUsers;
1008                            } else {
1009                                firstUsers = new int[0];
1010                                for (int i=0; i<res.newUsers.length; i++) {
1011                                    int user = res.newUsers[i];
1012                                    boolean isNew = true;
1013                                    for (int j=0; j<res.origUsers.length; j++) {
1014                                        if (res.origUsers[j] == user) {
1015                                            isNew = false;
1016                                            break;
1017                                        }
1018                                    }
1019                                    if (isNew) {
1020                                        int[] newFirst = new int[firstUsers.length+1];
1021                                        System.arraycopy(firstUsers, 0, newFirst, 0,
1022                                                firstUsers.length);
1023                                        newFirst[firstUsers.length] = user;
1024                                        firstUsers = newFirst;
1025                                    } else {
1026                                        int[] newUpdate = new int[updateUsers.length+1];
1027                                        System.arraycopy(updateUsers, 0, newUpdate, 0,
1028                                                updateUsers.length);
1029                                        newUpdate[updateUsers.length] = user;
1030                                        updateUsers = newUpdate;
1031                                    }
1032                                }
1033                            }
1034                            sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
1035                                    res.pkg.applicationInfo.packageName,
1036                                    extras, null, null, firstUsers);
1037                            final boolean update = res.removedInfo.removedPackage != null;
1038                            if (update) {
1039                                extras.putBoolean(Intent.EXTRA_REPLACING, true);
1040                            }
1041                            sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
1042                                    res.pkg.applicationInfo.packageName,
1043                                    extras, null, null, updateUsers);
1044                            if (update) {
1045                                sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED,
1046                                        res.pkg.applicationInfo.packageName,
1047                                        extras, null, null, updateUsers);
1048                                sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED,
1049                                        null, null,
1050                                        res.pkg.applicationInfo.packageName, null, updateUsers);
1051
1052                                // treat asec-hosted packages like removable media on upgrade
1053                                if (isForwardLocked(res.pkg) || isExternal(res.pkg)) {
1054                                    if (DEBUG_INSTALL) {
1055                                        Slog.i(TAG, "upgrading pkg " + res.pkg
1056                                                + " is ASEC-hosted -> AVAILABLE");
1057                                    }
1058                                    int[] uidArray = new int[] { res.pkg.applicationInfo.uid };
1059                                    ArrayList<String> pkgList = new ArrayList<String>(1);
1060                                    pkgList.add(res.pkg.applicationInfo.packageName);
1061                                    sendResourcesChangedBroadcast(true, true,
1062                                            pkgList,uidArray, null);
1063                                }
1064                            }
1065                            if (res.removedInfo.args != null) {
1066                                // Remove the replaced package's older resources safely now
1067                                deleteOld = true;
1068                            }
1069
1070                            // Log current value of "unknown sources" setting
1071                            EventLog.writeEvent(EventLogTags.UNKNOWN_SOURCES_ENABLED,
1072                                getUnknownSourcesSettings());
1073                        }
1074                        // Force a gc to clear up things
1075                        Runtime.getRuntime().gc();
1076                        // We delete after a gc for applications  on sdcard.
1077                        if (deleteOld) {
1078                            synchronized (mInstallLock) {
1079                                res.removedInfo.args.doPostDeleteLI(true);
1080                            }
1081                        }
1082                        if (args.observer != null) {
1083                            try {
1084                                Bundle extras = extrasForInstallResult(res);
1085                                args.observer.onPackageInstalled(res.name, res.returnCode,
1086                                        res.returnMsg, extras);
1087                            } catch (RemoteException e) {
1088                                Slog.i(TAG, "Observer no longer exists.");
1089                            }
1090                        }
1091                    } else {
1092                        Slog.e(TAG, "Bogus post-install token " + msg.arg1);
1093                    }
1094                } break;
1095                case UPDATED_MEDIA_STATUS: {
1096                    if (DEBUG_SD_INSTALL) Log.i(TAG, "Got message UPDATED_MEDIA_STATUS");
1097                    boolean reportStatus = msg.arg1 == 1;
1098                    boolean doGc = msg.arg2 == 1;
1099                    if (DEBUG_SD_INSTALL) Log.i(TAG, "reportStatus=" + reportStatus + ", doGc = " + doGc);
1100                    if (doGc) {
1101                        // Force a gc to clear up stale containers.
1102                        Runtime.getRuntime().gc();
1103                    }
1104                    if (msg.obj != null) {
1105                        @SuppressWarnings("unchecked")
1106                        Set<AsecInstallArgs> args = (Set<AsecInstallArgs>) msg.obj;
1107                        if (DEBUG_SD_INSTALL) Log.i(TAG, "Unloading all containers");
1108                        // Unload containers
1109                        unloadAllContainers(args);
1110                    }
1111                    if (reportStatus) {
1112                        try {
1113                            if (DEBUG_SD_INSTALL) Log.i(TAG, "Invoking MountService call back");
1114                            PackageHelper.getMountService().finishMediaUpdate();
1115                        } catch (RemoteException e) {
1116                            Log.e(TAG, "MountService not running?");
1117                        }
1118                    }
1119                } break;
1120                case WRITE_SETTINGS: {
1121                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1122                    synchronized (mPackages) {
1123                        removeMessages(WRITE_SETTINGS);
1124                        removeMessages(WRITE_PACKAGE_RESTRICTIONS);
1125                        mSettings.writeLPr();
1126                        mDirtyUsers.clear();
1127                    }
1128                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1129                } break;
1130                case WRITE_PACKAGE_RESTRICTIONS: {
1131                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1132                    synchronized (mPackages) {
1133                        removeMessages(WRITE_PACKAGE_RESTRICTIONS);
1134                        for (int userId : mDirtyUsers) {
1135                            mSettings.writePackageRestrictionsLPr(userId);
1136                        }
1137                        mDirtyUsers.clear();
1138                    }
1139                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1140                } break;
1141                case CHECK_PENDING_VERIFICATION: {
1142                    final int verificationId = msg.arg1;
1143                    final PackageVerificationState state = mPendingVerification.get(verificationId);
1144
1145                    if ((state != null) && !state.timeoutExtended()) {
1146                        final InstallArgs args = state.getInstallArgs();
1147                        final Uri originUri = Uri.fromFile(args.origin.resolvedFile);
1148
1149                        Slog.i(TAG, "Verification timed out for " + originUri);
1150                        mPendingVerification.remove(verificationId);
1151
1152                        int ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
1153
1154                        if (getDefaultVerificationResponse() == PackageManager.VERIFICATION_ALLOW) {
1155                            Slog.i(TAG, "Continuing with installation of " + originUri);
1156                            state.setVerifierResponse(Binder.getCallingUid(),
1157                                    PackageManager.VERIFICATION_ALLOW_WITHOUT_SUFFICIENT);
1158                            broadcastPackageVerified(verificationId, originUri,
1159                                    PackageManager.VERIFICATION_ALLOW,
1160                                    state.getInstallArgs().getUser());
1161                            try {
1162                                ret = args.copyApk(mContainerService, true);
1163                            } catch (RemoteException e) {
1164                                Slog.e(TAG, "Could not contact the ContainerService");
1165                            }
1166                        } else {
1167                            broadcastPackageVerified(verificationId, originUri,
1168                                    PackageManager.VERIFICATION_REJECT,
1169                                    state.getInstallArgs().getUser());
1170                        }
1171
1172                        processPendingInstall(args, ret);
1173                        mHandler.sendEmptyMessage(MCS_UNBIND);
1174                    }
1175                    break;
1176                }
1177                case PACKAGE_VERIFIED: {
1178                    final int verificationId = msg.arg1;
1179
1180                    final PackageVerificationState state = mPendingVerification.get(verificationId);
1181                    if (state == null) {
1182                        Slog.w(TAG, "Invalid verification token " + verificationId + " received");
1183                        break;
1184                    }
1185
1186                    final PackageVerificationResponse response = (PackageVerificationResponse) msg.obj;
1187
1188                    state.setVerifierResponse(response.callerUid, response.code);
1189
1190                    if (state.isVerificationComplete()) {
1191                        mPendingVerification.remove(verificationId);
1192
1193                        final InstallArgs args = state.getInstallArgs();
1194                        final Uri originUri = Uri.fromFile(args.origin.resolvedFile);
1195
1196                        int ret;
1197                        if (state.isInstallAllowed()) {
1198                            ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
1199                            broadcastPackageVerified(verificationId, originUri,
1200                                    response.code, state.getInstallArgs().getUser());
1201                            try {
1202                                ret = args.copyApk(mContainerService, true);
1203                            } catch (RemoteException e) {
1204                                Slog.e(TAG, "Could not contact the ContainerService");
1205                            }
1206                        } else {
1207                            ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
1208                        }
1209
1210                        processPendingInstall(args, ret);
1211
1212                        mHandler.sendEmptyMessage(MCS_UNBIND);
1213                    }
1214
1215                    break;
1216                }
1217            }
1218        }
1219    }
1220
1221    Bundle extrasForInstallResult(PackageInstalledInfo res) {
1222        Bundle extras = null;
1223        switch (res.returnCode) {
1224            case PackageManager.INSTALL_FAILED_DUPLICATE_PERMISSION: {
1225                extras = new Bundle();
1226                extras.putString(PackageManager.EXTRA_FAILURE_EXISTING_PERMISSION,
1227                        res.origPermission);
1228                extras.putString(PackageManager.EXTRA_FAILURE_EXISTING_PACKAGE,
1229                        res.origPackage);
1230                break;
1231            }
1232        }
1233        return extras;
1234    }
1235
1236    void scheduleWriteSettingsLocked() {
1237        if (!mHandler.hasMessages(WRITE_SETTINGS)) {
1238            mHandler.sendEmptyMessageDelayed(WRITE_SETTINGS, WRITE_SETTINGS_DELAY);
1239        }
1240    }
1241
1242    void scheduleWritePackageRestrictionsLocked(int userId) {
1243        if (!sUserManager.exists(userId)) return;
1244        mDirtyUsers.add(userId);
1245        if (!mHandler.hasMessages(WRITE_PACKAGE_RESTRICTIONS)) {
1246            mHandler.sendEmptyMessageDelayed(WRITE_PACKAGE_RESTRICTIONS, WRITE_SETTINGS_DELAY);
1247        }
1248    }
1249
1250    public static final PackageManagerService main(Context context, Installer installer,
1251            boolean factoryTest, boolean onlyCore) {
1252        PackageManagerService m = new PackageManagerService(context, installer,
1253                factoryTest, onlyCore);
1254        ServiceManager.addService("package", m);
1255        return m;
1256    }
1257
1258    static String[] splitString(String str, char sep) {
1259        int count = 1;
1260        int i = 0;
1261        while ((i=str.indexOf(sep, i)) >= 0) {
1262            count++;
1263            i++;
1264        }
1265
1266        String[] res = new String[count];
1267        i=0;
1268        count = 0;
1269        int lastI=0;
1270        while ((i=str.indexOf(sep, i)) >= 0) {
1271            res[count] = str.substring(lastI, i);
1272            count++;
1273            i++;
1274            lastI = i;
1275        }
1276        res[count] = str.substring(lastI, str.length());
1277        return res;
1278    }
1279
1280    private static void getDefaultDisplayMetrics(Context context, DisplayMetrics metrics) {
1281        DisplayManager displayManager = (DisplayManager) context.getSystemService(
1282                Context.DISPLAY_SERVICE);
1283        displayManager.getDisplay(Display.DEFAULT_DISPLAY).getMetrics(metrics);
1284    }
1285
1286    public PackageManagerService(Context context, Installer installer,
1287            boolean factoryTest, boolean onlyCore) {
1288        EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START,
1289                SystemClock.uptimeMillis());
1290
1291        if (mSdkVersion <= 0) {
1292            Slog.w(TAG, "**** ro.build.version.sdk not set!");
1293        }
1294
1295        mContext = context;
1296        mFactoryTest = factoryTest;
1297        mOnlyCore = onlyCore;
1298        mLazyDexOpt = "eng".equals(SystemProperties.get("ro.build.type"));
1299        mMetrics = new DisplayMetrics();
1300        mSettings = new Settings(context);
1301        mSettings.addSharedUserLPw("android.uid.system", Process.SYSTEM_UID,
1302                ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1303        mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID,
1304                ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1305        mSettings.addSharedUserLPw("android.uid.log", LOG_UID,
1306                ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1307        mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID,
1308                ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1309        mSettings.addSharedUserLPw("android.uid.bluetooth", BLUETOOTH_UID,
1310                ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1311        mSettings.addSharedUserLPw("android.uid.shell", SHELL_UID,
1312                ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1313
1314        // TODO: add a property to control this?
1315        long dexOptLRUThresholdInMinutes;
1316        if (mLazyDexOpt) {
1317            dexOptLRUThresholdInMinutes = 30; // only last 30 minutes of apps for eng builds.
1318        } else {
1319            dexOptLRUThresholdInMinutes = 7 * 24 * 60; // apps used in the 7 days for users.
1320        }
1321        mDexOptLRUThresholdInMills = dexOptLRUThresholdInMinutes * 60 * 1000;
1322
1323        String separateProcesses = SystemProperties.get("debug.separate_processes");
1324        if (separateProcesses != null && separateProcesses.length() > 0) {
1325            if ("*".equals(separateProcesses)) {
1326                mDefParseFlags = PackageParser.PARSE_IGNORE_PROCESSES;
1327                mSeparateProcesses = null;
1328                Slog.w(TAG, "Running with debug.separate_processes: * (ALL)");
1329            } else {
1330                mDefParseFlags = 0;
1331                mSeparateProcesses = separateProcesses.split(",");
1332                Slog.w(TAG, "Running with debug.separate_processes: "
1333                        + separateProcesses);
1334            }
1335        } else {
1336            mDefParseFlags = 0;
1337            mSeparateProcesses = null;
1338        }
1339
1340        mInstaller = installer;
1341
1342        getDefaultDisplayMetrics(context, mMetrics);
1343
1344        SystemConfig systemConfig = SystemConfig.getInstance();
1345        mGlobalGids = systemConfig.getGlobalGids();
1346        mSystemPermissions = systemConfig.getSystemPermissions();
1347        mAvailableFeatures = systemConfig.getAvailableFeatures();
1348
1349        synchronized (mInstallLock) {
1350        // writer
1351        synchronized (mPackages) {
1352            mHandlerThread = new ServiceThread(TAG,
1353                    Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
1354            mHandlerThread.start();
1355            mHandler = new PackageHandler(mHandlerThread.getLooper());
1356            Watchdog.getInstance().addThread(mHandler, WATCHDOG_TIMEOUT);
1357
1358            File dataDir = Environment.getDataDirectory();
1359            mAppDataDir = new File(dataDir, "data");
1360            mAppInstallDir = new File(dataDir, "app");
1361            mAppLib32InstallDir = new File(dataDir, "app-lib");
1362            mAsecInternalPath = new File(dataDir, "app-asec").getPath();
1363            mUserAppDataDir = new File(dataDir, "user");
1364            mDrmAppPrivateInstallDir = new File(dataDir, "app-private");
1365
1366            sUserManager = new UserManagerService(context, this,
1367                    mInstallLock, mPackages);
1368
1369            // Propagate permission configuration in to package manager.
1370            ArrayMap<String, SystemConfig.PermissionEntry> permConfig
1371                    = systemConfig.getPermissions();
1372            for (int i=0; i<permConfig.size(); i++) {
1373                SystemConfig.PermissionEntry perm = permConfig.valueAt(i);
1374                BasePermission bp = mSettings.mPermissions.get(perm.name);
1375                if (bp == null) {
1376                    bp = new BasePermission(perm.name, "android", BasePermission.TYPE_BUILTIN);
1377                    mSettings.mPermissions.put(perm.name, bp);
1378                }
1379                if (perm.gids != null) {
1380                    bp.gids = appendInts(bp.gids, perm.gids);
1381                }
1382            }
1383
1384            ArrayMap<String, String> libConfig = systemConfig.getSharedLibraries();
1385            for (int i=0; i<libConfig.size(); i++) {
1386                mSharedLibraries.put(libConfig.keyAt(i),
1387                        new SharedLibraryEntry(libConfig.valueAt(i), null));
1388            }
1389
1390            mFoundPolicyFile = SELinuxMMAC.readInstallPolicy();
1391
1392            mRestoredSettings = mSettings.readLPw(this, sUserManager.getUsers(false),
1393                    mSdkVersion, mOnlyCore);
1394
1395            String customResolverActivity = Resources.getSystem().getString(
1396                    R.string.config_customResolverActivity);
1397            if (TextUtils.isEmpty(customResolverActivity)) {
1398                customResolverActivity = null;
1399            } else {
1400                mCustomResolverComponentName = ComponentName.unflattenFromString(
1401                        customResolverActivity);
1402            }
1403
1404            long startTime = SystemClock.uptimeMillis();
1405
1406            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SYSTEM_SCAN_START,
1407                    startTime);
1408
1409            // Set flag to monitor and not change apk file paths when
1410            // scanning install directories.
1411            final int scanFlags = SCAN_NO_PATHS | SCAN_DEFER_DEX | SCAN_BOOTING;
1412
1413            final ArraySet<String> alreadyDexOpted = new ArraySet<String>();
1414
1415            /**
1416             * Add everything in the in the boot class path to the
1417             * list of process files because dexopt will have been run
1418             * if necessary during zygote startup.
1419             */
1420            final String bootClassPath = System.getenv("BOOTCLASSPATH");
1421            final String systemServerClassPath = System.getenv("SYSTEMSERVERCLASSPATH");
1422
1423            if (bootClassPath != null) {
1424                String[] bootClassPathElements = splitString(bootClassPath, ':');
1425                for (String element : bootClassPathElements) {
1426                    alreadyDexOpted.add(element);
1427                }
1428            } else {
1429                Slog.w(TAG, "No BOOTCLASSPATH found!");
1430            }
1431
1432            if (systemServerClassPath != null) {
1433                String[] systemServerClassPathElements = splitString(systemServerClassPath, ':');
1434                for (String element : systemServerClassPathElements) {
1435                    alreadyDexOpted.add(element);
1436                }
1437            } else {
1438                Slog.w(TAG, "No SYSTEMSERVERCLASSPATH found!");
1439            }
1440
1441            final List<String> allInstructionSets = getAllInstructionSets();
1442            final String[] dexCodeInstructionSets =
1443                getDexCodeInstructionSets(allInstructionSets.toArray(new String[allInstructionSets.size()]));
1444
1445            /**
1446             * Ensure all external libraries have had dexopt run on them.
1447             */
1448            if (mSharedLibraries.size() > 0) {
1449                // NOTE: For now, we're compiling these system "shared libraries"
1450                // (and framework jars) into all available architectures. It's possible
1451                // to compile them only when we come across an app that uses them (there's
1452                // already logic for that in scanPackageLI) but that adds some complexity.
1453                for (String dexCodeInstructionSet : dexCodeInstructionSets) {
1454                    for (SharedLibraryEntry libEntry : mSharedLibraries.values()) {
1455                        final String lib = libEntry.path;
1456                        if (lib == null) {
1457                            continue;
1458                        }
1459
1460                        try {
1461                            byte dexoptRequired = DexFile.isDexOptNeededInternal(lib, null,
1462                                                                                 dexCodeInstructionSet,
1463                                                                                 false);
1464                            if (dexoptRequired != DexFile.UP_TO_DATE) {
1465                                alreadyDexOpted.add(lib);
1466
1467                                // The list of "shared libraries" we have at this point is
1468                                if (dexoptRequired == DexFile.DEXOPT_NEEDED) {
1469                                    mInstaller.dexopt(lib, Process.SYSTEM_UID, true, dexCodeInstructionSet);
1470                                } else {
1471                                    mInstaller.patchoat(lib, Process.SYSTEM_UID, true, dexCodeInstructionSet);
1472                                }
1473                            }
1474                        } catch (FileNotFoundException e) {
1475                            Slog.w(TAG, "Library not found: " + lib);
1476                        } catch (IOException e) {
1477                            Slog.w(TAG, "Cannot dexopt " + lib + "; is it an APK or JAR? "
1478                                    + e.getMessage());
1479                        }
1480                    }
1481                }
1482            }
1483
1484            File frameworkDir = new File(Environment.getRootDirectory(), "framework");
1485
1486            // Gross hack for now: we know this file doesn't contain any
1487            // code, so don't dexopt it to avoid the resulting log spew.
1488            alreadyDexOpted.add(frameworkDir.getPath() + "/framework-res.apk");
1489
1490            // Gross hack for now: we know this file is only part of
1491            // the boot class path for art, so don't dexopt it to
1492            // avoid the resulting log spew.
1493            alreadyDexOpted.add(frameworkDir.getPath() + "/core-libart.jar");
1494
1495            /**
1496             * And there are a number of commands implemented in Java, which
1497             * we currently need to do the dexopt on so that they can be
1498             * run from a non-root shell.
1499             */
1500            String[] frameworkFiles = frameworkDir.list();
1501            if (frameworkFiles != null) {
1502                // TODO: We could compile these only for the most preferred ABI. We should
1503                // first double check that the dex files for these commands are not referenced
1504                // by other system apps.
1505                for (String dexCodeInstructionSet : dexCodeInstructionSets) {
1506                    for (int i=0; i<frameworkFiles.length; i++) {
1507                        File libPath = new File(frameworkDir, frameworkFiles[i]);
1508                        String path = libPath.getPath();
1509                        // Skip the file if we already did it.
1510                        if (alreadyDexOpted.contains(path)) {
1511                            continue;
1512                        }
1513                        // Skip the file if it is not a type we want to dexopt.
1514                        if (!path.endsWith(".apk") && !path.endsWith(".jar")) {
1515                            continue;
1516                        }
1517                        try {
1518                            byte dexoptRequired = DexFile.isDexOptNeededInternal(path, null,
1519                                                                                 dexCodeInstructionSet,
1520                                                                                 false);
1521                            if (dexoptRequired == DexFile.DEXOPT_NEEDED) {
1522                                mInstaller.dexopt(path, Process.SYSTEM_UID, true, dexCodeInstructionSet);
1523                            } else if (dexoptRequired == DexFile.PATCHOAT_NEEDED) {
1524                                mInstaller.patchoat(path, Process.SYSTEM_UID, true, dexCodeInstructionSet);
1525                            }
1526                        } catch (FileNotFoundException e) {
1527                            Slog.w(TAG, "Jar not found: " + path);
1528                        } catch (IOException e) {
1529                            Slog.w(TAG, "Exception reading jar: " + path, e);
1530                        }
1531                    }
1532                }
1533            }
1534
1535            // Collect vendor overlay packages.
1536            // (Do this before scanning any apps.)
1537            // For security and version matching reason, only consider
1538            // overlay packages if they reside in VENDOR_OVERLAY_DIR.
1539            File vendorOverlayDir = new File(VENDOR_OVERLAY_DIR);
1540            scanDirLI(vendorOverlayDir, PackageParser.PARSE_IS_SYSTEM
1541                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags | SCAN_TRUSTED_OVERLAY, 0);
1542
1543            // Find base frameworks (resource packages without code).
1544            scanDirLI(frameworkDir, PackageParser.PARSE_IS_SYSTEM
1545                    | PackageParser.PARSE_IS_SYSTEM_DIR
1546                    | PackageParser.PARSE_IS_PRIVILEGED,
1547                    scanFlags | SCAN_NO_DEX, 0);
1548
1549            // Collected privileged system packages.
1550            final File privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app");
1551            scanDirLI(privilegedAppDir, PackageParser.PARSE_IS_SYSTEM
1552                    | PackageParser.PARSE_IS_SYSTEM_DIR
1553                    | PackageParser.PARSE_IS_PRIVILEGED, scanFlags, 0);
1554
1555            // Collect ordinary system packages.
1556            final File systemAppDir = new File(Environment.getRootDirectory(), "app");
1557            scanDirLI(systemAppDir, PackageParser.PARSE_IS_SYSTEM
1558                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);
1559
1560            // Collect all vendor packages.
1561            File vendorAppDir = new File("/vendor/app");
1562            try {
1563                vendorAppDir = vendorAppDir.getCanonicalFile();
1564            } catch (IOException e) {
1565                // failed to look up canonical path, continue with original one
1566            }
1567            scanDirLI(vendorAppDir, PackageParser.PARSE_IS_SYSTEM
1568                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);
1569
1570            // Collect all OEM packages.
1571            final File oemAppDir = new File(Environment.getOemDirectory(), "app");
1572            scanDirLI(oemAppDir, PackageParser.PARSE_IS_SYSTEM
1573                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);
1574
1575            if (DEBUG_UPGRADE) Log.v(TAG, "Running installd update commands");
1576            mInstaller.moveFiles();
1577
1578            // Prune any system packages that no longer exist.
1579            final List<String> possiblyDeletedUpdatedSystemApps = new ArrayList<String>();
1580            final ArrayMap<String, File> expectingBetter = new ArrayMap<>();
1581            if (!mOnlyCore) {
1582                Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
1583                while (psit.hasNext()) {
1584                    PackageSetting ps = psit.next();
1585
1586                    /*
1587                     * If this is not a system app, it can't be a
1588                     * disable system app.
1589                     */
1590                    if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0) {
1591                        continue;
1592                    }
1593
1594                    /*
1595                     * If the package is scanned, it's not erased.
1596                     */
1597                    final PackageParser.Package scannedPkg = mPackages.get(ps.name);
1598                    if (scannedPkg != null) {
1599                        /*
1600                         * If the system app is both scanned and in the
1601                         * disabled packages list, then it must have been
1602                         * added via OTA. Remove it from the currently
1603                         * scanned package so the previously user-installed
1604                         * application can be scanned.
1605                         */
1606                        if (mSettings.isDisabledSystemPackageLPr(ps.name)) {
1607                            logCriticalInfo(Log.WARN, "Expecting better updated system app for "
1608                                    + ps.name + "; removing system app.  Last known codePath="
1609                                    + ps.codePathString + ", installStatus=" + ps.installStatus
1610                                    + ", versionCode=" + ps.versionCode + "; scanned versionCode="
1611                                    + scannedPkg.mVersionCode);
1612                            removePackageLI(ps, true);
1613                            expectingBetter.put(ps.name, ps.codePath);
1614                        }
1615
1616                        continue;
1617                    }
1618
1619                    if (!mSettings.isDisabledSystemPackageLPr(ps.name)) {
1620                        psit.remove();
1621                        logCriticalInfo(Log.WARN, "System package " + ps.name
1622                                + " no longer exists; wiping its data");
1623                        removeDataDirsLI(ps.name);
1624                    } else {
1625                        final PackageSetting disabledPs = mSettings.getDisabledSystemPkgLPr(ps.name);
1626                        if (disabledPs.codePath == null || !disabledPs.codePath.exists()) {
1627                            possiblyDeletedUpdatedSystemApps.add(ps.name);
1628                        }
1629                    }
1630                }
1631            }
1632
1633            //look for any incomplete package installations
1634            ArrayList<PackageSetting> deletePkgsList = mSettings.getListOfIncompleteInstallPackagesLPr();
1635            //clean up list
1636            for(int i = 0; i < deletePkgsList.size(); i++) {
1637                //clean up here
1638                cleanupInstallFailedPackage(deletePkgsList.get(i));
1639            }
1640            //delete tmp files
1641            deleteTempPackageFiles();
1642
1643            // Remove any shared userIDs that have no associated packages
1644            mSettings.pruneSharedUsersLPw();
1645
1646            if (!mOnlyCore) {
1647                EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_DATA_SCAN_START,
1648                        SystemClock.uptimeMillis());
1649                scanDirLI(mAppInstallDir, 0, scanFlags, 0);
1650
1651                scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,
1652                        scanFlags, 0);
1653
1654                /**
1655                 * Remove disable package settings for any updated system
1656                 * apps that were removed via an OTA. If they're not a
1657                 * previously-updated app, remove them completely.
1658                 * Otherwise, just revoke their system-level permissions.
1659                 */
1660                for (String deletedAppName : possiblyDeletedUpdatedSystemApps) {
1661                    PackageParser.Package deletedPkg = mPackages.get(deletedAppName);
1662                    mSettings.removeDisabledSystemPackageLPw(deletedAppName);
1663
1664                    String msg;
1665                    if (deletedPkg == null) {
1666                        msg = "Updated system package " + deletedAppName
1667                                + " no longer exists; wiping its data";
1668                        removeDataDirsLI(deletedAppName);
1669                    } else {
1670                        msg = "Updated system app + " + deletedAppName
1671                                + " no longer present; removing system privileges for "
1672                                + deletedAppName;
1673
1674                        deletedPkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_SYSTEM;
1675
1676                        PackageSetting deletedPs = mSettings.mPackages.get(deletedAppName);
1677                        deletedPs.pkgFlags &= ~ApplicationInfo.FLAG_SYSTEM;
1678                    }
1679                    logCriticalInfo(Log.WARN, msg);
1680                }
1681
1682                /**
1683                 * Make sure all system apps that we expected to appear on
1684                 * the userdata partition actually showed up. If they never
1685                 * appeared, crawl back and revive the system version.
1686                 */
1687                for (int i = 0; i < expectingBetter.size(); i++) {
1688                    final String packageName = expectingBetter.keyAt(i);
1689                    if (!mPackages.containsKey(packageName)) {
1690                        final File scanFile = expectingBetter.valueAt(i);
1691
1692                        logCriticalInfo(Log.WARN, "Expected better " + packageName
1693                                + " but never showed up; reverting to system");
1694
1695                        final int reparseFlags;
1696                        if (FileUtils.contains(privilegedAppDir, scanFile)) {
1697                            reparseFlags = PackageParser.PARSE_IS_SYSTEM
1698                                    | PackageParser.PARSE_IS_SYSTEM_DIR
1699                                    | PackageParser.PARSE_IS_PRIVILEGED;
1700                        } else if (FileUtils.contains(systemAppDir, scanFile)) {
1701                            reparseFlags = PackageParser.PARSE_IS_SYSTEM
1702                                    | PackageParser.PARSE_IS_SYSTEM_DIR;
1703                        } else if (FileUtils.contains(vendorAppDir, scanFile)) {
1704                            reparseFlags = PackageParser.PARSE_IS_SYSTEM
1705                                    | PackageParser.PARSE_IS_SYSTEM_DIR;
1706                        } else if (FileUtils.contains(oemAppDir, scanFile)) {
1707                            reparseFlags = PackageParser.PARSE_IS_SYSTEM
1708                                    | PackageParser.PARSE_IS_SYSTEM_DIR;
1709                        } else {
1710                            Slog.e(TAG, "Ignoring unexpected fallback path " + scanFile);
1711                            continue;
1712                        }
1713
1714                        mSettings.enableSystemPackageLPw(packageName);
1715
1716                        try {
1717                            scanPackageLI(scanFile, reparseFlags, scanFlags, 0, null);
1718                        } catch (PackageManagerException e) {
1719                            Slog.e(TAG, "Failed to parse original system package: "
1720                                    + e.getMessage());
1721                        }
1722                    }
1723                }
1724            }
1725
1726            // Now that we know all of the shared libraries, update all clients to have
1727            // the correct library paths.
1728            updateAllSharedLibrariesLPw();
1729
1730            for (SharedUserSetting setting : mSettings.getAllSharedUsersLPw()) {
1731                // NOTE: We ignore potential failures here during a system scan (like
1732                // the rest of the commands above) because there's precious little we
1733                // can do about it. A settings error is reported, though.
1734                adjustCpuAbisForSharedUserLPw(setting.packages, null /* scanned package */,
1735                        false /* force dexopt */, false /* defer dexopt */);
1736            }
1737
1738            // Now that we know all the packages we are keeping,
1739            // read and update their last usage times.
1740            mPackageUsage.readLP();
1741
1742            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,
1743                    SystemClock.uptimeMillis());
1744            Slog.i(TAG, "Time to scan packages: "
1745                    + ((SystemClock.uptimeMillis()-startTime)/1000f)
1746                    + " seconds");
1747
1748            // If the platform SDK has changed since the last time we booted,
1749            // we need to re-grant app permission to catch any new ones that
1750            // appear.  This is really a hack, and means that apps can in some
1751            // cases get permissions that the user didn't initially explicitly
1752            // allow...  it would be nice to have some better way to handle
1753            // this situation.
1754            final boolean regrantPermissions = mSettings.mInternalSdkPlatform
1755                    != mSdkVersion;
1756            if (regrantPermissions) Slog.i(TAG, "Platform changed from "
1757                    + mSettings.mInternalSdkPlatform + " to " + mSdkVersion
1758                    + "; regranting permissions for internal storage");
1759            mSettings.mInternalSdkPlatform = mSdkVersion;
1760
1761            updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL
1762                    | (regrantPermissions
1763                            ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL)
1764                            : 0));
1765
1766            // If this is the first boot, and it is a normal boot, then
1767            // we need to initialize the default preferred apps.
1768            if (!mRestoredSettings && !onlyCore) {
1769                mSettings.readDefaultPreferredAppsLPw(this, 0);
1770            }
1771
1772            // If this is first boot after an OTA, and a normal boot, then
1773            // we need to clear code cache directories.
1774            mIsUpgrade = !Build.FINGERPRINT.equals(mSettings.mFingerprint);
1775            if (mIsUpgrade && !onlyCore) {
1776                Slog.i(TAG, "Build fingerprint changed; clearing code caches");
1777                for (String pkgName : mSettings.mPackages.keySet()) {
1778                    deleteCodeCacheDirsLI(pkgName);
1779                }
1780                mSettings.mFingerprint = Build.FINGERPRINT;
1781            }
1782
1783            // All the changes are done during package scanning.
1784            mSettings.updateInternalDatabaseVersion();
1785
1786            // can downgrade to reader
1787            mSettings.writeLPr();
1788
1789            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_READY,
1790                    SystemClock.uptimeMillis());
1791
1792
1793            mRequiredVerifierPackage = getRequiredVerifierLPr();
1794        } // synchronized (mPackages)
1795        } // synchronized (mInstallLock)
1796
1797        mInstallerService = new PackageInstallerService(context, this, mAppInstallDir);
1798
1799        // Now after opening every single application zip, make sure they
1800        // are all flushed.  Not really needed, but keeps things nice and
1801        // tidy.
1802        Runtime.getRuntime().gc();
1803    }
1804
1805    @Override
1806    public boolean isFirstBoot() {
1807        return !mRestoredSettings;
1808    }
1809
1810    @Override
1811    public boolean isOnlyCoreApps() {
1812        return mOnlyCore;
1813    }
1814
1815    @Override
1816    public boolean isUpgrade() {
1817        return mIsUpgrade;
1818    }
1819
1820    private String getRequiredVerifierLPr() {
1821        final Intent verification = new Intent(Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
1822        final List<ResolveInfo> receivers = queryIntentReceivers(verification, PACKAGE_MIME_TYPE,
1823                PackageManager.GET_DISABLED_COMPONENTS, 0 /* TODO: Which userId? */);
1824
1825        String requiredVerifier = null;
1826
1827        final int N = receivers.size();
1828        for (int i = 0; i < N; i++) {
1829            final ResolveInfo info = receivers.get(i);
1830
1831            if (info.activityInfo == null) {
1832                continue;
1833            }
1834
1835            final String packageName = info.activityInfo.packageName;
1836
1837            final PackageSetting ps = mSettings.mPackages.get(packageName);
1838            if (ps == null) {
1839                continue;
1840            }
1841
1842            final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
1843            if (!gp.grantedPermissions
1844                    .contains(android.Manifest.permission.PACKAGE_VERIFICATION_AGENT)) {
1845                continue;
1846            }
1847
1848            if (requiredVerifier != null) {
1849                throw new RuntimeException("There can be only one required verifier");
1850            }
1851
1852            requiredVerifier = packageName;
1853        }
1854
1855        return requiredVerifier;
1856    }
1857
1858    @Override
1859    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
1860            throws RemoteException {
1861        try {
1862            return super.onTransact(code, data, reply, flags);
1863        } catch (RuntimeException e) {
1864            if (!(e instanceof SecurityException) && !(e instanceof IllegalArgumentException)) {
1865                Slog.wtf(TAG, "Package Manager Crash", e);
1866            }
1867            throw e;
1868        }
1869    }
1870
1871    void cleanupInstallFailedPackage(PackageSetting ps) {
1872        logCriticalInfo(Log.WARN, "Cleaning up incompletely installed app: " + ps.name);
1873
1874        removeDataDirsLI(ps.name);
1875        if (ps.codePath != null) {
1876            if (ps.codePath.isDirectory()) {
1877                FileUtils.deleteContents(ps.codePath);
1878            }
1879            ps.codePath.delete();
1880        }
1881        if (ps.resourcePath != null && !ps.resourcePath.equals(ps.codePath)) {
1882            if (ps.resourcePath.isDirectory()) {
1883                FileUtils.deleteContents(ps.resourcePath);
1884            }
1885            ps.resourcePath.delete();
1886        }
1887        mSettings.removePackageLPw(ps.name);
1888    }
1889
1890    static int[] appendInts(int[] cur, int[] add) {
1891        if (add == null) return cur;
1892        if (cur == null) return add;
1893        final int N = add.length;
1894        for (int i=0; i<N; i++) {
1895            cur = appendInt(cur, add[i]);
1896        }
1897        return cur;
1898    }
1899
1900    static int[] removeInts(int[] cur, int[] rem) {
1901        if (rem == null) return cur;
1902        if (cur == null) return cur;
1903        final int N = rem.length;
1904        for (int i=0; i<N; i++) {
1905            cur = removeInt(cur, rem[i]);
1906        }
1907        return cur;
1908    }
1909
1910    PackageInfo generatePackageInfo(PackageParser.Package p, int flags, int userId) {
1911        if (!sUserManager.exists(userId)) return null;
1912        final PackageSetting ps = (PackageSetting) p.mExtras;
1913        if (ps == null) {
1914            return null;
1915        }
1916        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
1917        final PackageUserState state = ps.readUserState(userId);
1918        return PackageParser.generatePackageInfo(p, gp.gids, flags,
1919                ps.firstInstallTime, ps.lastUpdateTime, gp.grantedPermissions,
1920                state, userId);
1921    }
1922
1923    @Override
1924    public boolean isPackageAvailable(String packageName, int userId) {
1925        if (!sUserManager.exists(userId)) return false;
1926        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "is package available");
1927        synchronized (mPackages) {
1928            PackageParser.Package p = mPackages.get(packageName);
1929            if (p != null) {
1930                final PackageSetting ps = (PackageSetting) p.mExtras;
1931                if (ps != null) {
1932                    final PackageUserState state = ps.readUserState(userId);
1933                    if (state != null) {
1934                        return PackageParser.isAvailable(state);
1935                    }
1936                }
1937            }
1938        }
1939        return false;
1940    }
1941
1942    @Override
1943    public PackageInfo getPackageInfo(String packageName, int flags, int userId) {
1944        if (!sUserManager.exists(userId)) return null;
1945        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get package info");
1946        // reader
1947        synchronized (mPackages) {
1948            PackageParser.Package p = mPackages.get(packageName);
1949            if (DEBUG_PACKAGE_INFO)
1950                Log.v(TAG, "getPackageInfo " + packageName + ": " + p);
1951            if (p != null) {
1952                return generatePackageInfo(p, flags, userId);
1953            }
1954            if((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) {
1955                return generatePackageInfoFromSettingsLPw(packageName, flags, userId);
1956            }
1957        }
1958        return null;
1959    }
1960
1961    @Override
1962    public String[] currentToCanonicalPackageNames(String[] names) {
1963        String[] out = new String[names.length];
1964        // reader
1965        synchronized (mPackages) {
1966            for (int i=names.length-1; i>=0; i--) {
1967                PackageSetting ps = mSettings.mPackages.get(names[i]);
1968                out[i] = ps != null && ps.realName != null ? ps.realName : names[i];
1969            }
1970        }
1971        return out;
1972    }
1973
1974    @Override
1975    public String[] canonicalToCurrentPackageNames(String[] names) {
1976        String[] out = new String[names.length];
1977        // reader
1978        synchronized (mPackages) {
1979            for (int i=names.length-1; i>=0; i--) {
1980                String cur = mSettings.mRenamedPackages.get(names[i]);
1981                out[i] = cur != null ? cur : names[i];
1982            }
1983        }
1984        return out;
1985    }
1986
1987    @Override
1988    public int getPackageUid(String packageName, int userId) {
1989        if (!sUserManager.exists(userId)) return -1;
1990        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get package uid");
1991        // reader
1992        synchronized (mPackages) {
1993            PackageParser.Package p = mPackages.get(packageName);
1994            if(p != null) {
1995                return UserHandle.getUid(userId, p.applicationInfo.uid);
1996            }
1997            PackageSetting ps = mSettings.mPackages.get(packageName);
1998            if((ps == null) || (ps.pkg == null) || (ps.pkg.applicationInfo == null)) {
1999                return -1;
2000            }
2001            p = ps.pkg;
2002            return p != null ? UserHandle.getUid(userId, p.applicationInfo.uid) : -1;
2003        }
2004    }
2005
2006    @Override
2007    public int[] getPackageGids(String packageName) {
2008        // reader
2009        synchronized (mPackages) {
2010            PackageParser.Package p = mPackages.get(packageName);
2011            if (DEBUG_PACKAGE_INFO)
2012                Log.v(TAG, "getPackageGids" + packageName + ": " + p);
2013            if (p != null) {
2014                final PackageSetting ps = (PackageSetting)p.mExtras;
2015                return ps.getGids();
2016            }
2017        }
2018        // stupid thing to indicate an error.
2019        return new int[0];
2020    }
2021
2022    static final PermissionInfo generatePermissionInfo(
2023            BasePermission bp, int flags) {
2024        if (bp.perm != null) {
2025            return PackageParser.generatePermissionInfo(bp.perm, flags);
2026        }
2027        PermissionInfo pi = new PermissionInfo();
2028        pi.name = bp.name;
2029        pi.packageName = bp.sourcePackage;
2030        pi.nonLocalizedLabel = bp.name;
2031        pi.protectionLevel = bp.protectionLevel;
2032        return pi;
2033    }
2034
2035    @Override
2036    public PermissionInfo getPermissionInfo(String name, int flags) {
2037        // reader
2038        synchronized (mPackages) {
2039            final BasePermission p = mSettings.mPermissions.get(name);
2040            if (p != null) {
2041                return generatePermissionInfo(p, flags);
2042            }
2043            return null;
2044        }
2045    }
2046
2047    @Override
2048    public List<PermissionInfo> queryPermissionsByGroup(String group, int flags) {
2049        // reader
2050        synchronized (mPackages) {
2051            ArrayList<PermissionInfo> out = new ArrayList<PermissionInfo>(10);
2052            for (BasePermission p : mSettings.mPermissions.values()) {
2053                if (group == null) {
2054                    if (p.perm == null || p.perm.info.group == null) {
2055                        out.add(generatePermissionInfo(p, flags));
2056                    }
2057                } else {
2058                    if (p.perm != null && group.equals(p.perm.info.group)) {
2059                        out.add(PackageParser.generatePermissionInfo(p.perm, flags));
2060                    }
2061                }
2062            }
2063
2064            if (out.size() > 0) {
2065                return out;
2066            }
2067            return mPermissionGroups.containsKey(group) ? out : null;
2068        }
2069    }
2070
2071    @Override
2072    public PermissionGroupInfo getPermissionGroupInfo(String name, int flags) {
2073        // reader
2074        synchronized (mPackages) {
2075            return PackageParser.generatePermissionGroupInfo(
2076                    mPermissionGroups.get(name), flags);
2077        }
2078    }
2079
2080    @Override
2081    public List<PermissionGroupInfo> getAllPermissionGroups(int flags) {
2082        // reader
2083        synchronized (mPackages) {
2084            final int N = mPermissionGroups.size();
2085            ArrayList<PermissionGroupInfo> out
2086                    = new ArrayList<PermissionGroupInfo>(N);
2087            for (PackageParser.PermissionGroup pg : mPermissionGroups.values()) {
2088                out.add(PackageParser.generatePermissionGroupInfo(pg, flags));
2089            }
2090            return out;
2091        }
2092    }
2093
2094    private ApplicationInfo generateApplicationInfoFromSettingsLPw(String packageName, int flags,
2095            int userId) {
2096        if (!sUserManager.exists(userId)) return null;
2097        PackageSetting ps = mSettings.mPackages.get(packageName);
2098        if (ps != null) {
2099            if (ps.pkg == null) {
2100                PackageInfo pInfo = generatePackageInfoFromSettingsLPw(packageName,
2101                        flags, userId);
2102                if (pInfo != null) {
2103                    return pInfo.applicationInfo;
2104                }
2105                return null;
2106            }
2107            return PackageParser.generateApplicationInfo(ps.pkg, flags,
2108                    ps.readUserState(userId), userId);
2109        }
2110        return null;
2111    }
2112
2113    private PackageInfo generatePackageInfoFromSettingsLPw(String packageName, int flags,
2114            int userId) {
2115        if (!sUserManager.exists(userId)) return null;
2116        PackageSetting ps = mSettings.mPackages.get(packageName);
2117        if (ps != null) {
2118            PackageParser.Package pkg = ps.pkg;
2119            if (pkg == null) {
2120                if ((flags & PackageManager.GET_UNINSTALLED_PACKAGES) == 0) {
2121                    return null;
2122                }
2123                // Only data remains, so we aren't worried about code paths
2124                pkg = new PackageParser.Package(packageName);
2125                pkg.applicationInfo.packageName = packageName;
2126                pkg.applicationInfo.flags = ps.pkgFlags | ApplicationInfo.FLAG_IS_DATA_ONLY;
2127                pkg.applicationInfo.privateFlags = ps.pkgPrivateFlags;
2128                pkg.applicationInfo.dataDir =
2129                        getDataPathForPackage(packageName, 0).getPath();
2130                pkg.applicationInfo.primaryCpuAbi = ps.primaryCpuAbiString;
2131                pkg.applicationInfo.secondaryCpuAbi = ps.secondaryCpuAbiString;
2132            }
2133            return generatePackageInfo(pkg, flags, userId);
2134        }
2135        return null;
2136    }
2137
2138    @Override
2139    public ApplicationInfo getApplicationInfo(String packageName, int flags, int userId) {
2140        if (!sUserManager.exists(userId)) return null;
2141        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get application info");
2142        // writer
2143        synchronized (mPackages) {
2144            PackageParser.Package p = mPackages.get(packageName);
2145            if (DEBUG_PACKAGE_INFO) Log.v(
2146                    TAG, "getApplicationInfo " + packageName
2147                    + ": " + p);
2148            if (p != null) {
2149                PackageSetting ps = mSettings.mPackages.get(packageName);
2150                if (ps == null) return null;
2151                // Note: isEnabledLP() does not apply here - always return info
2152                return PackageParser.generateApplicationInfo(
2153                        p, flags, ps.readUserState(userId), userId);
2154            }
2155            if ("android".equals(packageName)||"system".equals(packageName)) {
2156                return mAndroidApplication;
2157            }
2158            if ((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) {
2159                return generateApplicationInfoFromSettingsLPw(packageName, flags, userId);
2160            }
2161        }
2162        return null;
2163    }
2164
2165
2166    @Override
2167    public void freeStorageAndNotify(final long freeStorageSize, final IPackageDataObserver observer) {
2168        mContext.enforceCallingOrSelfPermission(
2169                android.Manifest.permission.CLEAR_APP_CACHE, null);
2170        // Queue up an async operation since clearing cache may take a little while.
2171        mHandler.post(new Runnable() {
2172            public void run() {
2173                mHandler.removeCallbacks(this);
2174                int retCode = -1;
2175                synchronized (mInstallLock) {
2176                    retCode = mInstaller.freeCache(freeStorageSize);
2177                    if (retCode < 0) {
2178                        Slog.w(TAG, "Couldn't clear application caches");
2179                    }
2180                }
2181                if (observer != null) {
2182                    try {
2183                        observer.onRemoveCompleted(null, (retCode >= 0));
2184                    } catch (RemoteException e) {
2185                        Slog.w(TAG, "RemoveException when invoking call back");
2186                    }
2187                }
2188            }
2189        });
2190    }
2191
2192    @Override
2193    public void freeStorage(final long freeStorageSize, final IntentSender pi) {
2194        mContext.enforceCallingOrSelfPermission(
2195                android.Manifest.permission.CLEAR_APP_CACHE, null);
2196        // Queue up an async operation since clearing cache may take a little while.
2197        mHandler.post(new Runnable() {
2198            public void run() {
2199                mHandler.removeCallbacks(this);
2200                int retCode = -1;
2201                synchronized (mInstallLock) {
2202                    retCode = mInstaller.freeCache(freeStorageSize);
2203                    if (retCode < 0) {
2204                        Slog.w(TAG, "Couldn't clear application caches");
2205                    }
2206                }
2207                if(pi != null) {
2208                    try {
2209                        // Callback via pending intent
2210                        int code = (retCode >= 0) ? 1 : 0;
2211                        pi.sendIntent(null, code, null,
2212                                null, null);
2213                    } catch (SendIntentException e1) {
2214                        Slog.i(TAG, "Failed to send pending intent");
2215                    }
2216                }
2217            }
2218        });
2219    }
2220
2221    void freeStorage(long freeStorageSize) throws IOException {
2222        synchronized (mInstallLock) {
2223            if (mInstaller.freeCache(freeStorageSize) < 0) {
2224                throw new IOException("Failed to free enough space");
2225            }
2226        }
2227    }
2228
2229    @Override
2230    public ActivityInfo getActivityInfo(ComponentName component, int flags, int userId) {
2231        if (!sUserManager.exists(userId)) return null;
2232        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get activity info");
2233        synchronized (mPackages) {
2234            PackageParser.Activity a = mActivities.mActivities.get(component);
2235
2236            if (DEBUG_PACKAGE_INFO) Log.v(TAG, "getActivityInfo " + component + ": " + a);
2237            if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {
2238                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2239                if (ps == null) return null;
2240                return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),
2241                        userId);
2242            }
2243            if (mResolveComponentName.equals(component)) {
2244                return PackageParser.generateActivityInfo(mResolveActivity, flags,
2245                        new PackageUserState(), userId);
2246            }
2247        }
2248        return null;
2249    }
2250
2251    @Override
2252    public boolean activitySupportsIntent(ComponentName component, Intent intent,
2253            String resolvedType) {
2254        synchronized (mPackages) {
2255            PackageParser.Activity a = mActivities.mActivities.get(component);
2256            if (a == null) {
2257                return false;
2258            }
2259            for (int i=0; i<a.intents.size(); i++) {
2260                if (a.intents.get(i).match(intent.getAction(), resolvedType, intent.getScheme(),
2261                        intent.getData(), intent.getCategories(), TAG) >= 0) {
2262                    return true;
2263                }
2264            }
2265            return false;
2266        }
2267    }
2268
2269    @Override
2270    public ActivityInfo getReceiverInfo(ComponentName component, int flags, int userId) {
2271        if (!sUserManager.exists(userId)) return null;
2272        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get receiver info");
2273        synchronized (mPackages) {
2274            PackageParser.Activity a = mReceivers.mActivities.get(component);
2275            if (DEBUG_PACKAGE_INFO) Log.v(
2276                TAG, "getReceiverInfo " + component + ": " + a);
2277            if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {
2278                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2279                if (ps == null) return null;
2280                return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),
2281                        userId);
2282            }
2283        }
2284        return null;
2285    }
2286
2287    @Override
2288    public ServiceInfo getServiceInfo(ComponentName component, int flags, int userId) {
2289        if (!sUserManager.exists(userId)) return null;
2290        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get service info");
2291        synchronized (mPackages) {
2292            PackageParser.Service s = mServices.mServices.get(component);
2293            if (DEBUG_PACKAGE_INFO) Log.v(
2294                TAG, "getServiceInfo " + component + ": " + s);
2295            if (s != null && mSettings.isEnabledLPr(s.info, flags, userId)) {
2296                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2297                if (ps == null) return null;
2298                return PackageParser.generateServiceInfo(s, flags, ps.readUserState(userId),
2299                        userId);
2300            }
2301        }
2302        return null;
2303    }
2304
2305    @Override
2306    public ProviderInfo getProviderInfo(ComponentName component, int flags, int userId) {
2307        if (!sUserManager.exists(userId)) return null;
2308        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get provider info");
2309        synchronized (mPackages) {
2310            PackageParser.Provider p = mProviders.mProviders.get(component);
2311            if (DEBUG_PACKAGE_INFO) Log.v(
2312                TAG, "getProviderInfo " + component + ": " + p);
2313            if (p != null && mSettings.isEnabledLPr(p.info, flags, userId)) {
2314                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2315                if (ps == null) return null;
2316                return PackageParser.generateProviderInfo(p, flags, ps.readUserState(userId),
2317                        userId);
2318            }
2319        }
2320        return null;
2321    }
2322
2323    @Override
2324    public String[] getSystemSharedLibraryNames() {
2325        Set<String> libSet;
2326        synchronized (mPackages) {
2327            libSet = mSharedLibraries.keySet();
2328            int size = libSet.size();
2329            if (size > 0) {
2330                String[] libs = new String[size];
2331                libSet.toArray(libs);
2332                return libs;
2333            }
2334        }
2335        return null;
2336    }
2337
2338    @Override
2339    public FeatureInfo[] getSystemAvailableFeatures() {
2340        Collection<FeatureInfo> featSet;
2341        synchronized (mPackages) {
2342            featSet = mAvailableFeatures.values();
2343            int size = featSet.size();
2344            if (size > 0) {
2345                FeatureInfo[] features = new FeatureInfo[size+1];
2346                featSet.toArray(features);
2347                FeatureInfo fi = new FeatureInfo();
2348                fi.reqGlEsVersion = SystemProperties.getInt("ro.opengles.version",
2349                        FeatureInfo.GL_ES_VERSION_UNDEFINED);
2350                features[size] = fi;
2351                return features;
2352            }
2353        }
2354        return null;
2355    }
2356
2357    @Override
2358    public boolean hasSystemFeature(String name) {
2359        synchronized (mPackages) {
2360            return mAvailableFeatures.containsKey(name);
2361        }
2362    }
2363
2364    private void checkValidCaller(int uid, int userId) {
2365        if (UserHandle.getUserId(uid) == userId || uid == Process.SYSTEM_UID || uid == 0)
2366            return;
2367
2368        throw new SecurityException("Caller uid=" + uid
2369                + " is not privileged to communicate with user=" + userId);
2370    }
2371
2372    @Override
2373    public int checkPermission(String permName, String pkgName) {
2374        synchronized (mPackages) {
2375            PackageParser.Package p = mPackages.get(pkgName);
2376            if (p != null && p.mExtras != null) {
2377                PackageSetting ps = (PackageSetting)p.mExtras;
2378                if (ps.sharedUser != null) {
2379                    if (ps.sharedUser.grantedPermissions.contains(permName)) {
2380                        return PackageManager.PERMISSION_GRANTED;
2381                    }
2382                } else if (ps.grantedPermissions.contains(permName)) {
2383                    return PackageManager.PERMISSION_GRANTED;
2384                }
2385            }
2386        }
2387        return PackageManager.PERMISSION_DENIED;
2388    }
2389
2390    @Override
2391    public int checkUidPermission(String permName, int uid) {
2392        synchronized (mPackages) {
2393            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2394            if (obj != null) {
2395                GrantedPermissions gp = (GrantedPermissions)obj;
2396                if (gp.grantedPermissions.contains(permName)) {
2397                    return PackageManager.PERMISSION_GRANTED;
2398                }
2399            } else {
2400                ArraySet<String> perms = mSystemPermissions.get(uid);
2401                if (perms != null && perms.contains(permName)) {
2402                    return PackageManager.PERMISSION_GRANTED;
2403                }
2404            }
2405        }
2406        return PackageManager.PERMISSION_DENIED;
2407    }
2408
2409    /**
2410     * Checks if the request is from the system or an app that has INTERACT_ACROSS_USERS
2411     * or INTERACT_ACROSS_USERS_FULL permissions, if the userid is not for the caller.
2412     * @param checkShell TODO(yamasani):
2413     * @param message the message to log on security exception
2414     */
2415    void enforceCrossUserPermission(int callingUid, int userId, boolean requireFullPermission,
2416            boolean checkShell, String message) {
2417        if (userId < 0) {
2418            throw new IllegalArgumentException("Invalid userId " + userId);
2419        }
2420        if (checkShell) {
2421            enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, callingUid, userId);
2422        }
2423        if (userId == UserHandle.getUserId(callingUid)) return;
2424        if (callingUid != Process.SYSTEM_UID && callingUid != 0) {
2425            if (requireFullPermission) {
2426                mContext.enforceCallingOrSelfPermission(
2427                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
2428            } else {
2429                try {
2430                    mContext.enforceCallingOrSelfPermission(
2431                            android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
2432                } catch (SecurityException se) {
2433                    mContext.enforceCallingOrSelfPermission(
2434                            android.Manifest.permission.INTERACT_ACROSS_USERS, message);
2435                }
2436            }
2437        }
2438    }
2439
2440    void enforceShellRestriction(String restriction, int callingUid, int userHandle) {
2441        if (callingUid == Process.SHELL_UID) {
2442            if (userHandle >= 0
2443                    && sUserManager.hasUserRestriction(restriction, userHandle)) {
2444                throw new SecurityException("Shell does not have permission to access user "
2445                        + userHandle);
2446            } else if (userHandle < 0) {
2447                Slog.e(TAG, "Unable to check shell permission for user " + userHandle + "\n\t"
2448                        + Debug.getCallers(3));
2449            }
2450        }
2451    }
2452
2453    private BasePermission findPermissionTreeLP(String permName) {
2454        for(BasePermission bp : mSettings.mPermissionTrees.values()) {
2455            if (permName.startsWith(bp.name) &&
2456                    permName.length() > bp.name.length() &&
2457                    permName.charAt(bp.name.length()) == '.') {
2458                return bp;
2459            }
2460        }
2461        return null;
2462    }
2463
2464    private BasePermission checkPermissionTreeLP(String permName) {
2465        if (permName != null) {
2466            BasePermission bp = findPermissionTreeLP(permName);
2467            if (bp != null) {
2468                if (bp.uid == UserHandle.getAppId(Binder.getCallingUid())) {
2469                    return bp;
2470                }
2471                throw new SecurityException("Calling uid "
2472                        + Binder.getCallingUid()
2473                        + " is not allowed to add to permission tree "
2474                        + bp.name + " owned by uid " + bp.uid);
2475            }
2476        }
2477        throw new SecurityException("No permission tree found for " + permName);
2478    }
2479
2480    static boolean compareStrings(CharSequence s1, CharSequence s2) {
2481        if (s1 == null) {
2482            return s2 == null;
2483        }
2484        if (s2 == null) {
2485            return false;
2486        }
2487        if (s1.getClass() != s2.getClass()) {
2488            return false;
2489        }
2490        return s1.equals(s2);
2491    }
2492
2493    static boolean comparePermissionInfos(PermissionInfo pi1, PermissionInfo pi2) {
2494        if (pi1.icon != pi2.icon) return false;
2495        if (pi1.logo != pi2.logo) return false;
2496        if (pi1.protectionLevel != pi2.protectionLevel) return false;
2497        if (!compareStrings(pi1.name, pi2.name)) return false;
2498        if (!compareStrings(pi1.nonLocalizedLabel, pi2.nonLocalizedLabel)) return false;
2499        // We'll take care of setting this one.
2500        if (!compareStrings(pi1.packageName, pi2.packageName)) return false;
2501        // These are not currently stored in settings.
2502        //if (!compareStrings(pi1.group, pi2.group)) return false;
2503        //if (!compareStrings(pi1.nonLocalizedDescription, pi2.nonLocalizedDescription)) return false;
2504        //if (pi1.labelRes != pi2.labelRes) return false;
2505        //if (pi1.descriptionRes != pi2.descriptionRes) return false;
2506        return true;
2507    }
2508
2509    int permissionInfoFootprint(PermissionInfo info) {
2510        int size = info.name.length();
2511        if (info.nonLocalizedLabel != null) size += info.nonLocalizedLabel.length();
2512        if (info.nonLocalizedDescription != null) size += info.nonLocalizedDescription.length();
2513        return size;
2514    }
2515
2516    int calculateCurrentPermissionFootprintLocked(BasePermission tree) {
2517        int size = 0;
2518        for (BasePermission perm : mSettings.mPermissions.values()) {
2519            if (perm.uid == tree.uid) {
2520                size += perm.name.length() + permissionInfoFootprint(perm.perm.info);
2521            }
2522        }
2523        return size;
2524    }
2525
2526    void enforcePermissionCapLocked(PermissionInfo info, BasePermission tree) {
2527        // We calculate the max size of permissions defined by this uid and throw
2528        // if that plus the size of 'info' would exceed our stated maximum.
2529        if (tree.uid != Process.SYSTEM_UID) {
2530            final int curTreeSize = calculateCurrentPermissionFootprintLocked(tree);
2531            if (curTreeSize + permissionInfoFootprint(info) > MAX_PERMISSION_TREE_FOOTPRINT) {
2532                throw new SecurityException("Permission tree size cap exceeded");
2533            }
2534        }
2535    }
2536
2537    boolean addPermissionLocked(PermissionInfo info, boolean async) {
2538        if (info.labelRes == 0 && info.nonLocalizedLabel == null) {
2539            throw new SecurityException("Label must be specified in permission");
2540        }
2541        BasePermission tree = checkPermissionTreeLP(info.name);
2542        BasePermission bp = mSettings.mPermissions.get(info.name);
2543        boolean added = bp == null;
2544        boolean changed = true;
2545        int fixedLevel = PermissionInfo.fixProtectionLevel(info.protectionLevel);
2546        if (added) {
2547            enforcePermissionCapLocked(info, tree);
2548            bp = new BasePermission(info.name, tree.sourcePackage,
2549                    BasePermission.TYPE_DYNAMIC);
2550        } else if (bp.type != BasePermission.TYPE_DYNAMIC) {
2551            throw new SecurityException(
2552                    "Not allowed to modify non-dynamic permission "
2553                    + info.name);
2554        } else {
2555            if (bp.protectionLevel == fixedLevel
2556                    && bp.perm.owner.equals(tree.perm.owner)
2557                    && bp.uid == tree.uid
2558                    && comparePermissionInfos(bp.perm.info, info)) {
2559                changed = false;
2560            }
2561        }
2562        bp.protectionLevel = fixedLevel;
2563        info = new PermissionInfo(info);
2564        info.protectionLevel = fixedLevel;
2565        bp.perm = new PackageParser.Permission(tree.perm.owner, info);
2566        bp.perm.info.packageName = tree.perm.info.packageName;
2567        bp.uid = tree.uid;
2568        if (added) {
2569            mSettings.mPermissions.put(info.name, bp);
2570        }
2571        if (changed) {
2572            if (!async) {
2573                mSettings.writeLPr();
2574            } else {
2575                scheduleWriteSettingsLocked();
2576            }
2577        }
2578        return added;
2579    }
2580
2581    @Override
2582    public boolean addPermission(PermissionInfo info) {
2583        synchronized (mPackages) {
2584            return addPermissionLocked(info, false);
2585        }
2586    }
2587
2588    @Override
2589    public boolean addPermissionAsync(PermissionInfo info) {
2590        synchronized (mPackages) {
2591            return addPermissionLocked(info, true);
2592        }
2593    }
2594
2595    @Override
2596    public void removePermission(String name) {
2597        synchronized (mPackages) {
2598            checkPermissionTreeLP(name);
2599            BasePermission bp = mSettings.mPermissions.get(name);
2600            if (bp != null) {
2601                if (bp.type != BasePermission.TYPE_DYNAMIC) {
2602                    throw new SecurityException(
2603                            "Not allowed to modify non-dynamic permission "
2604                            + name);
2605                }
2606                mSettings.mPermissions.remove(name);
2607                mSettings.writeLPr();
2608            }
2609        }
2610    }
2611
2612    private static void checkGrantRevokePermissions(PackageParser.Package pkg, BasePermission bp) {
2613        int index = pkg.requestedPermissions.indexOf(bp.name);
2614        if (index == -1) {
2615            throw new SecurityException("Package " + pkg.packageName
2616                    + " has not requested permission " + bp.name);
2617        }
2618        boolean isNormal =
2619                ((bp.protectionLevel&PermissionInfo.PROTECTION_MASK_BASE)
2620                        == PermissionInfo.PROTECTION_NORMAL);
2621        boolean isDangerous =
2622                ((bp.protectionLevel&PermissionInfo.PROTECTION_MASK_BASE)
2623                        == PermissionInfo.PROTECTION_DANGEROUS);
2624        boolean isDevelopment =
2625                ((bp.protectionLevel&PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0);
2626
2627        if (!isNormal && !isDangerous && !isDevelopment) {
2628            throw new SecurityException("Permission " + bp.name
2629                    + " is not a changeable permission type");
2630        }
2631
2632        if (isNormal || isDangerous) {
2633            if (pkg.requestedPermissionsRequired.get(index)) {
2634                throw new SecurityException("Can't change " + bp.name
2635                        + ". It is required by the application");
2636            }
2637        }
2638    }
2639
2640    @Override
2641    public void grantPermission(String packageName, String permissionName) {
2642        mContext.enforceCallingOrSelfPermission(
2643                android.Manifest.permission.GRANT_REVOKE_PERMISSIONS, null);
2644        synchronized (mPackages) {
2645            final PackageParser.Package pkg = mPackages.get(packageName);
2646            if (pkg == null) {
2647                throw new IllegalArgumentException("Unknown package: " + packageName);
2648            }
2649            final BasePermission bp = mSettings.mPermissions.get(permissionName);
2650            if (bp == null) {
2651                throw new IllegalArgumentException("Unknown permission: " + permissionName);
2652            }
2653
2654            checkGrantRevokePermissions(pkg, bp);
2655
2656            final PackageSetting ps = (PackageSetting) pkg.mExtras;
2657            if (ps == null) {
2658                return;
2659            }
2660            final GrantedPermissions gp = (ps.sharedUser != null) ? ps.sharedUser : ps;
2661            if (gp.grantedPermissions.add(permissionName)) {
2662                if (ps.haveGids) {
2663                    gp.gids = appendInts(gp.gids, bp.gids);
2664                }
2665                mSettings.writeLPr();
2666            }
2667        }
2668    }
2669
2670    @Override
2671    public void revokePermission(String packageName, String permissionName) {
2672        int changedAppId = -1;
2673
2674        synchronized (mPackages) {
2675            final PackageParser.Package pkg = mPackages.get(packageName);
2676            if (pkg == null) {
2677                throw new IllegalArgumentException("Unknown package: " + packageName);
2678            }
2679            if (pkg.applicationInfo.uid != Binder.getCallingUid()) {
2680                mContext.enforceCallingOrSelfPermission(
2681                        android.Manifest.permission.GRANT_REVOKE_PERMISSIONS, null);
2682            }
2683            final BasePermission bp = mSettings.mPermissions.get(permissionName);
2684            if (bp == null) {
2685                throw new IllegalArgumentException("Unknown permission: " + permissionName);
2686            }
2687
2688            checkGrantRevokePermissions(pkg, bp);
2689
2690            final PackageSetting ps = (PackageSetting) pkg.mExtras;
2691            if (ps == null) {
2692                return;
2693            }
2694            final GrantedPermissions gp = (ps.sharedUser != null) ? ps.sharedUser : ps;
2695            if (gp.grantedPermissions.remove(permissionName)) {
2696                gp.grantedPermissions.remove(permissionName);
2697                if (ps.haveGids) {
2698                    gp.gids = removeInts(gp.gids, bp.gids);
2699                }
2700                mSettings.writeLPr();
2701                changedAppId = ps.appId;
2702            }
2703        }
2704
2705        if (changedAppId >= 0) {
2706            // We changed the perm on someone, kill its processes.
2707            IActivityManager am = ActivityManagerNative.getDefault();
2708            if (am != null) {
2709                final int callingUserId = UserHandle.getCallingUserId();
2710                final long ident = Binder.clearCallingIdentity();
2711                try {
2712                    //XXX we should only revoke for the calling user's app permissions,
2713                    // but for now we impact all users.
2714                    //am.killUid(UserHandle.getUid(callingUserId, changedAppId),
2715                    //        "revoke " + permissionName);
2716                    int[] users = sUserManager.getUserIds();
2717                    for (int user : users) {
2718                        am.killUid(UserHandle.getUid(user, changedAppId),
2719                                "revoke " + permissionName);
2720                    }
2721                } catch (RemoteException e) {
2722                } finally {
2723                    Binder.restoreCallingIdentity(ident);
2724                }
2725            }
2726        }
2727    }
2728
2729    @Override
2730    public boolean isProtectedBroadcast(String actionName) {
2731        synchronized (mPackages) {
2732            return mProtectedBroadcasts.contains(actionName);
2733        }
2734    }
2735
2736    @Override
2737    public int checkSignatures(String pkg1, String pkg2) {
2738        synchronized (mPackages) {
2739            final PackageParser.Package p1 = mPackages.get(pkg1);
2740            final PackageParser.Package p2 = mPackages.get(pkg2);
2741            if (p1 == null || p1.mExtras == null
2742                    || p2 == null || p2.mExtras == null) {
2743                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2744            }
2745            return compareSignatures(p1.mSignatures, p2.mSignatures);
2746        }
2747    }
2748
2749    @Override
2750    public int checkUidSignatures(int uid1, int uid2) {
2751        // Map to base uids.
2752        uid1 = UserHandle.getAppId(uid1);
2753        uid2 = UserHandle.getAppId(uid2);
2754        // reader
2755        synchronized (mPackages) {
2756            Signature[] s1;
2757            Signature[] s2;
2758            Object obj = mSettings.getUserIdLPr(uid1);
2759            if (obj != null) {
2760                if (obj instanceof SharedUserSetting) {
2761                    s1 = ((SharedUserSetting)obj).signatures.mSignatures;
2762                } else if (obj instanceof PackageSetting) {
2763                    s1 = ((PackageSetting)obj).signatures.mSignatures;
2764                } else {
2765                    return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2766                }
2767            } else {
2768                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2769            }
2770            obj = mSettings.getUserIdLPr(uid2);
2771            if (obj != null) {
2772                if (obj instanceof SharedUserSetting) {
2773                    s2 = ((SharedUserSetting)obj).signatures.mSignatures;
2774                } else if (obj instanceof PackageSetting) {
2775                    s2 = ((PackageSetting)obj).signatures.mSignatures;
2776                } else {
2777                    return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2778                }
2779            } else {
2780                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2781            }
2782            return compareSignatures(s1, s2);
2783        }
2784    }
2785
2786    /**
2787     * Compares two sets of signatures. Returns:
2788     * <br />
2789     * {@link PackageManager#SIGNATURE_NEITHER_SIGNED}: if both signature sets are null,
2790     * <br />
2791     * {@link PackageManager#SIGNATURE_FIRST_NOT_SIGNED}: if the first signature set is null,
2792     * <br />
2793     * {@link PackageManager#SIGNATURE_SECOND_NOT_SIGNED}: if the second signature set is null,
2794     * <br />
2795     * {@link PackageManager#SIGNATURE_MATCH}: if the two signature sets are identical,
2796     * <br />
2797     * {@link PackageManager#SIGNATURE_NO_MATCH}: if the two signature sets differ.
2798     */
2799    static int compareSignatures(Signature[] s1, Signature[] s2) {
2800        if (s1 == null) {
2801            return s2 == null
2802                    ? PackageManager.SIGNATURE_NEITHER_SIGNED
2803                    : PackageManager.SIGNATURE_FIRST_NOT_SIGNED;
2804        }
2805
2806        if (s2 == null) {
2807            return PackageManager.SIGNATURE_SECOND_NOT_SIGNED;
2808        }
2809
2810        if (s1.length != s2.length) {
2811            return PackageManager.SIGNATURE_NO_MATCH;
2812        }
2813
2814        // Since both signature sets are of size 1, we can compare without HashSets.
2815        if (s1.length == 1) {
2816            return s1[0].equals(s2[0]) ?
2817                    PackageManager.SIGNATURE_MATCH :
2818                    PackageManager.SIGNATURE_NO_MATCH;
2819        }
2820
2821        ArraySet<Signature> set1 = new ArraySet<Signature>();
2822        for (Signature sig : s1) {
2823            set1.add(sig);
2824        }
2825        ArraySet<Signature> set2 = new ArraySet<Signature>();
2826        for (Signature sig : s2) {
2827            set2.add(sig);
2828        }
2829        // Make sure s2 contains all signatures in s1.
2830        if (set1.equals(set2)) {
2831            return PackageManager.SIGNATURE_MATCH;
2832        }
2833        return PackageManager.SIGNATURE_NO_MATCH;
2834    }
2835
2836    /**
2837     * If the database version for this type of package (internal storage or
2838     * external storage) is less than the version where package signatures
2839     * were updated, return true.
2840     */
2841    private boolean isCompatSignatureUpdateNeeded(PackageParser.Package scannedPkg) {
2842        return (isExternal(scannedPkg) && mSettings.isExternalDatabaseVersionOlderThan(
2843                DatabaseVersion.SIGNATURE_END_ENTITY))
2844                || (!isExternal(scannedPkg) && mSettings.isInternalDatabaseVersionOlderThan(
2845                        DatabaseVersion.SIGNATURE_END_ENTITY));
2846    }
2847
2848    /**
2849     * Used for backward compatibility to make sure any packages with
2850     * certificate chains get upgraded to the new style. {@code existingSigs}
2851     * will be in the old format (since they were stored on disk from before the
2852     * system upgrade) and {@code scannedSigs} will be in the newer format.
2853     */
2854    private int compareSignaturesCompat(PackageSignatures existingSigs,
2855            PackageParser.Package scannedPkg) {
2856        if (!isCompatSignatureUpdateNeeded(scannedPkg)) {
2857            return PackageManager.SIGNATURE_NO_MATCH;
2858        }
2859
2860        ArraySet<Signature> existingSet = new ArraySet<Signature>();
2861        for (Signature sig : existingSigs.mSignatures) {
2862            existingSet.add(sig);
2863        }
2864        ArraySet<Signature> scannedCompatSet = new ArraySet<Signature>();
2865        for (Signature sig : scannedPkg.mSignatures) {
2866            try {
2867                Signature[] chainSignatures = sig.getChainSignatures();
2868                for (Signature chainSig : chainSignatures) {
2869                    scannedCompatSet.add(chainSig);
2870                }
2871            } catch (CertificateEncodingException e) {
2872                scannedCompatSet.add(sig);
2873            }
2874        }
2875        /*
2876         * Make sure the expanded scanned set contains all signatures in the
2877         * existing one.
2878         */
2879        if (scannedCompatSet.equals(existingSet)) {
2880            // Migrate the old signatures to the new scheme.
2881            existingSigs.assignSignatures(scannedPkg.mSignatures);
2882            // The new KeySets will be re-added later in the scanning process.
2883            synchronized (mPackages) {
2884                mSettings.mKeySetManagerService.removeAppKeySetDataLPw(scannedPkg.packageName);
2885            }
2886            return PackageManager.SIGNATURE_MATCH;
2887        }
2888        return PackageManager.SIGNATURE_NO_MATCH;
2889    }
2890
2891    private boolean isRecoverSignatureUpdateNeeded(PackageParser.Package scannedPkg) {
2892        if (isExternal(scannedPkg)) {
2893            return mSettings.isExternalDatabaseVersionOlderThan(
2894                    DatabaseVersion.SIGNATURE_MALFORMED_RECOVER);
2895        } else {
2896            return mSettings.isInternalDatabaseVersionOlderThan(
2897                    DatabaseVersion.SIGNATURE_MALFORMED_RECOVER);
2898        }
2899    }
2900
2901    private int compareSignaturesRecover(PackageSignatures existingSigs,
2902            PackageParser.Package scannedPkg) {
2903        if (!isRecoverSignatureUpdateNeeded(scannedPkg)) {
2904            return PackageManager.SIGNATURE_NO_MATCH;
2905        }
2906
2907        String msg = null;
2908        try {
2909            if (Signature.areEffectiveMatch(existingSigs.mSignatures, scannedPkg.mSignatures)) {
2910                logCriticalInfo(Log.INFO, "Recovered effectively matching certificates for "
2911                        + scannedPkg.packageName);
2912                return PackageManager.SIGNATURE_MATCH;
2913            }
2914        } catch (CertificateException e) {
2915            msg = e.getMessage();
2916        }
2917
2918        logCriticalInfo(Log.INFO,
2919                "Failed to recover certificates for " + scannedPkg.packageName + ": " + msg);
2920        return PackageManager.SIGNATURE_NO_MATCH;
2921    }
2922
2923    @Override
2924    public String[] getPackagesForUid(int uid) {
2925        uid = UserHandle.getAppId(uid);
2926        // reader
2927        synchronized (mPackages) {
2928            Object obj = mSettings.getUserIdLPr(uid);
2929            if (obj instanceof SharedUserSetting) {
2930                final SharedUserSetting sus = (SharedUserSetting) obj;
2931                final int N = sus.packages.size();
2932                final String[] res = new String[N];
2933                final Iterator<PackageSetting> it = sus.packages.iterator();
2934                int i = 0;
2935                while (it.hasNext()) {
2936                    res[i++] = it.next().name;
2937                }
2938                return res;
2939            } else if (obj instanceof PackageSetting) {
2940                final PackageSetting ps = (PackageSetting) obj;
2941                return new String[] { ps.name };
2942            }
2943        }
2944        return null;
2945    }
2946
2947    @Override
2948    public String getNameForUid(int uid) {
2949        // reader
2950        synchronized (mPackages) {
2951            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2952            if (obj instanceof SharedUserSetting) {
2953                final SharedUserSetting sus = (SharedUserSetting) obj;
2954                return sus.name + ":" + sus.userId;
2955            } else if (obj instanceof PackageSetting) {
2956                final PackageSetting ps = (PackageSetting) obj;
2957                return ps.name;
2958            }
2959        }
2960        return null;
2961    }
2962
2963    @Override
2964    public int getUidForSharedUser(String sharedUserName) {
2965        if(sharedUserName == null) {
2966            return -1;
2967        }
2968        // reader
2969        synchronized (mPackages) {
2970            final SharedUserSetting suid = mSettings.getSharedUserLPw(sharedUserName, 0, 0, false);
2971            if (suid == null) {
2972                return -1;
2973            }
2974            return suid.userId;
2975        }
2976    }
2977
2978    @Override
2979    public int getFlagsForUid(int uid) {
2980        synchronized (mPackages) {
2981            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2982            if (obj instanceof SharedUserSetting) {
2983                final SharedUserSetting sus = (SharedUserSetting) obj;
2984                return sus.pkgFlags;
2985            } else if (obj instanceof PackageSetting) {
2986                final PackageSetting ps = (PackageSetting) obj;
2987                return ps.pkgFlags;
2988            }
2989        }
2990        return 0;
2991    }
2992
2993    @Override
2994    public int getPrivateFlagsForUid(int uid) {
2995        synchronized (mPackages) {
2996            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2997            if (obj instanceof SharedUserSetting) {
2998                final SharedUserSetting sus = (SharedUserSetting) obj;
2999                return sus.pkgPrivateFlags;
3000            } else if (obj instanceof PackageSetting) {
3001                final PackageSetting ps = (PackageSetting) obj;
3002                return ps.pkgPrivateFlags;
3003            }
3004        }
3005        return 0;
3006    }
3007
3008    @Override
3009    public boolean isUidPrivileged(int uid) {
3010        uid = UserHandle.getAppId(uid);
3011        // reader
3012        synchronized (mPackages) {
3013            Object obj = mSettings.getUserIdLPr(uid);
3014            if (obj instanceof SharedUserSetting) {
3015                final SharedUserSetting sus = (SharedUserSetting) obj;
3016                final Iterator<PackageSetting> it = sus.packages.iterator();
3017                while (it.hasNext()) {
3018                    if (it.next().isPrivileged()) {
3019                        return true;
3020                    }
3021                }
3022            } else if (obj instanceof PackageSetting) {
3023                final PackageSetting ps = (PackageSetting) obj;
3024                return ps.isPrivileged();
3025            }
3026        }
3027        return false;
3028    }
3029
3030    @Override
3031    public String[] getAppOpPermissionPackages(String permissionName) {
3032        synchronized (mPackages) {
3033            ArraySet<String> pkgs = mAppOpPermissionPackages.get(permissionName);
3034            if (pkgs == null) {
3035                return null;
3036            }
3037            return pkgs.toArray(new String[pkgs.size()]);
3038        }
3039    }
3040
3041    @Override
3042    public ResolveInfo resolveIntent(Intent intent, String resolvedType,
3043            int flags, int userId) {
3044        if (!sUserManager.exists(userId)) return null;
3045        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "resolve intent");
3046        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
3047        return chooseBestActivity(intent, resolvedType, flags, query, userId);
3048    }
3049
3050    @Override
3051    public void setLastChosenActivity(Intent intent, String resolvedType, int flags,
3052            IntentFilter filter, int match, ComponentName activity) {
3053        final int userId = UserHandle.getCallingUserId();
3054        if (DEBUG_PREFERRED) {
3055            Log.v(TAG, "setLastChosenActivity intent=" + intent
3056                + " resolvedType=" + resolvedType
3057                + " flags=" + flags
3058                + " filter=" + filter
3059                + " match=" + match
3060                + " activity=" + activity);
3061            filter.dump(new PrintStreamPrinter(System.out), "    ");
3062        }
3063        intent.setComponent(null);
3064        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
3065        // Find any earlier preferred or last chosen entries and nuke them
3066        findPreferredActivity(intent, resolvedType,
3067                flags, query, 0, false, true, false, userId);
3068        // Add the new activity as the last chosen for this filter
3069        addPreferredActivityInternal(filter, match, null, activity, false, userId,
3070                "Setting last chosen");
3071    }
3072
3073    @Override
3074    public ResolveInfo getLastChosenActivity(Intent intent, String resolvedType, int flags) {
3075        final int userId = UserHandle.getCallingUserId();
3076        if (DEBUG_PREFERRED) Log.v(TAG, "Querying last chosen activity for " + intent);
3077        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
3078        return findPreferredActivity(intent, resolvedType, flags, query, 0,
3079                false, false, false, userId);
3080    }
3081
3082    private ResolveInfo chooseBestActivity(Intent intent, String resolvedType,
3083            int flags, List<ResolveInfo> query, int userId) {
3084        if (query != null) {
3085            final int N = query.size();
3086            if (N == 1) {
3087                return query.get(0);
3088            } else if (N > 1) {
3089                final boolean debug = ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
3090                // If there is more than one activity with the same priority,
3091                // then let the user decide between them.
3092                ResolveInfo r0 = query.get(0);
3093                ResolveInfo r1 = query.get(1);
3094                if (DEBUG_INTENT_MATCHING || debug) {
3095                    Slog.v(TAG, r0.activityInfo.name + "=" + r0.priority + " vs "
3096                            + r1.activityInfo.name + "=" + r1.priority);
3097                }
3098                // If the first activity has a higher priority, or a different
3099                // default, then it is always desireable to pick it.
3100                if (r0.priority != r1.priority
3101                        || r0.preferredOrder != r1.preferredOrder
3102                        || r0.isDefault != r1.isDefault) {
3103                    return query.get(0);
3104                }
3105                // If we have saved a preference for a preferred activity for
3106                // this Intent, use that.
3107                ResolveInfo ri = findPreferredActivity(intent, resolvedType,
3108                        flags, query, r0.priority, true, false, debug, userId);
3109                if (ri != null) {
3110                    return ri;
3111                }
3112                if (userId != 0) {
3113                    ri = new ResolveInfo(mResolveInfo);
3114                    ri.activityInfo = new ActivityInfo(ri.activityInfo);
3115                    ri.activityInfo.applicationInfo = new ApplicationInfo(
3116                            ri.activityInfo.applicationInfo);
3117                    ri.activityInfo.applicationInfo.uid = UserHandle.getUid(userId,
3118                            UserHandle.getAppId(ri.activityInfo.applicationInfo.uid));
3119                    return ri;
3120                }
3121                return mResolveInfo;
3122            }
3123        }
3124        return null;
3125    }
3126
3127    private ResolveInfo findPersistentPreferredActivityLP(Intent intent, String resolvedType,
3128            int flags, List<ResolveInfo> query, boolean debug, int userId) {
3129        final int N = query.size();
3130        PersistentPreferredIntentResolver ppir = mSettings.mPersistentPreferredActivities
3131                .get(userId);
3132        // Get the list of persistent preferred activities that handle the intent
3133        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Looking for presistent preferred activities...");
3134        List<PersistentPreferredActivity> pprefs = ppir != null
3135                ? ppir.queryIntent(intent, resolvedType,
3136                        (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId)
3137                : null;
3138        if (pprefs != null && pprefs.size() > 0) {
3139            final int M = pprefs.size();
3140            for (int i=0; i<M; i++) {
3141                final PersistentPreferredActivity ppa = pprefs.get(i);
3142                if (DEBUG_PREFERRED || debug) {
3143                    Slog.v(TAG, "Checking PersistentPreferredActivity ds="
3144                            + (ppa.countDataSchemes() > 0 ? ppa.getDataScheme(0) : "<none>")
3145                            + "\n  component=" + ppa.mComponent);
3146                    ppa.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3147                }
3148                final ActivityInfo ai = getActivityInfo(ppa.mComponent,
3149                        flags | PackageManager.GET_DISABLED_COMPONENTS, userId);
3150                if (DEBUG_PREFERRED || debug) {
3151                    Slog.v(TAG, "Found persistent preferred activity:");
3152                    if (ai != null) {
3153                        ai.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3154                    } else {
3155                        Slog.v(TAG, "  null");
3156                    }
3157                }
3158                if (ai == null) {
3159                    // This previously registered persistent preferred activity
3160                    // component is no longer known. Ignore it and do NOT remove it.
3161                    continue;
3162                }
3163                for (int j=0; j<N; j++) {
3164                    final ResolveInfo ri = query.get(j);
3165                    if (!ri.activityInfo.applicationInfo.packageName
3166                            .equals(ai.applicationInfo.packageName)) {
3167                        continue;
3168                    }
3169                    if (!ri.activityInfo.name.equals(ai.name)) {
3170                        continue;
3171                    }
3172                    //  Found a persistent preference that can handle the intent.
3173                    if (DEBUG_PREFERRED || debug) {
3174                        Slog.v(TAG, "Returning persistent preferred activity: " +
3175                                ri.activityInfo.packageName + "/" + ri.activityInfo.name);
3176                    }
3177                    return ri;
3178                }
3179            }
3180        }
3181        return null;
3182    }
3183
3184    ResolveInfo findPreferredActivity(Intent intent, String resolvedType, int flags,
3185            List<ResolveInfo> query, int priority, boolean always,
3186            boolean removeMatches, boolean debug, int userId) {
3187        if (!sUserManager.exists(userId)) return null;
3188        // writer
3189        synchronized (mPackages) {
3190            if (intent.getSelector() != null) {
3191                intent = intent.getSelector();
3192            }
3193            if (DEBUG_PREFERRED) intent.addFlags(Intent.FLAG_DEBUG_LOG_RESOLUTION);
3194
3195            // Try to find a matching persistent preferred activity.
3196            ResolveInfo pri = findPersistentPreferredActivityLP(intent, resolvedType, flags, query,
3197                    debug, userId);
3198
3199            // If a persistent preferred activity matched, use it.
3200            if (pri != null) {
3201                return pri;
3202            }
3203
3204            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
3205            // Get the list of preferred activities that handle the intent
3206            if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Looking for preferred activities...");
3207            List<PreferredActivity> prefs = pir != null
3208                    ? pir.queryIntent(intent, resolvedType,
3209                            (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId)
3210                    : null;
3211            if (prefs != null && prefs.size() > 0) {
3212                boolean changed = false;
3213                try {
3214                    // First figure out how good the original match set is.
3215                    // We will only allow preferred activities that came
3216                    // from the same match quality.
3217                    int match = 0;
3218
3219                    if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Figuring out best match...");
3220
3221                    final int N = query.size();
3222                    for (int j=0; j<N; j++) {
3223                        final ResolveInfo ri = query.get(j);
3224                        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Match for " + ri.activityInfo
3225                                + ": 0x" + Integer.toHexString(match));
3226                        if (ri.match > match) {
3227                            match = ri.match;
3228                        }
3229                    }
3230
3231                    if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Best match: 0x"
3232                            + Integer.toHexString(match));
3233
3234                    match &= IntentFilter.MATCH_CATEGORY_MASK;
3235                    final int M = prefs.size();
3236                    for (int i=0; i<M; i++) {
3237                        final PreferredActivity pa = prefs.get(i);
3238                        if (DEBUG_PREFERRED || debug) {
3239                            Slog.v(TAG, "Checking PreferredActivity ds="
3240                                    + (pa.countDataSchemes() > 0 ? pa.getDataScheme(0) : "<none>")
3241                                    + "\n  component=" + pa.mPref.mComponent);
3242                            pa.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3243                        }
3244                        if (pa.mPref.mMatch != match) {
3245                            if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Skipping bad match "
3246                                    + Integer.toHexString(pa.mPref.mMatch));
3247                            continue;
3248                        }
3249                        // If it's not an "always" type preferred activity and that's what we're
3250                        // looking for, skip it.
3251                        if (always && !pa.mPref.mAlways) {
3252                            if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Skipping mAlways=false entry");
3253                            continue;
3254                        }
3255                        final ActivityInfo ai = getActivityInfo(pa.mPref.mComponent,
3256                                flags | PackageManager.GET_DISABLED_COMPONENTS, userId);
3257                        if (DEBUG_PREFERRED || debug) {
3258                            Slog.v(TAG, "Found preferred activity:");
3259                            if (ai != null) {
3260                                ai.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3261                            } else {
3262                                Slog.v(TAG, "  null");
3263                            }
3264                        }
3265                        if (ai == null) {
3266                            // This previously registered preferred activity
3267                            // component is no longer known.  Most likely an update
3268                            // to the app was installed and in the new version this
3269                            // component no longer exists.  Clean it up by removing
3270                            // it from the preferred activities list, and skip it.
3271                            Slog.w(TAG, "Removing dangling preferred activity: "
3272                                    + pa.mPref.mComponent);
3273                            pir.removeFilter(pa);
3274                            changed = true;
3275                            continue;
3276                        }
3277                        for (int j=0; j<N; j++) {
3278                            final ResolveInfo ri = query.get(j);
3279                            if (!ri.activityInfo.applicationInfo.packageName
3280                                    .equals(ai.applicationInfo.packageName)) {
3281                                continue;
3282                            }
3283                            if (!ri.activityInfo.name.equals(ai.name)) {
3284                                continue;
3285                            }
3286
3287                            if (removeMatches) {
3288                                pir.removeFilter(pa);
3289                                changed = true;
3290                                if (DEBUG_PREFERRED) {
3291                                    Slog.v(TAG, "Removing match " + pa.mPref.mComponent);
3292                                }
3293                                break;
3294                            }
3295
3296                            // Okay we found a previously set preferred or last chosen app.
3297                            // If the result set is different from when this
3298                            // was created, we need to clear it and re-ask the
3299                            // user their preference, if we're looking for an "always" type entry.
3300                            if (always && !pa.mPref.sameSet(query)) {
3301                                Slog.i(TAG, "Result set changed, dropping preferred activity for "
3302                                        + intent + " type " + resolvedType);
3303                                if (DEBUG_PREFERRED) {
3304                                    Slog.v(TAG, "Removing preferred activity since set changed "
3305                                            + pa.mPref.mComponent);
3306                                }
3307                                pir.removeFilter(pa);
3308                                // Re-add the filter as a "last chosen" entry (!always)
3309                                PreferredActivity lastChosen = new PreferredActivity(
3310                                        pa, pa.mPref.mMatch, null, pa.mPref.mComponent, false);
3311                                pir.addFilter(lastChosen);
3312                                changed = true;
3313                                return null;
3314                            }
3315
3316                            // Yay! Either the set matched or we're looking for the last chosen
3317                            if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Returning preferred activity: "
3318                                    + ri.activityInfo.packageName + "/" + ri.activityInfo.name);
3319                            return ri;
3320                        }
3321                    }
3322                } finally {
3323                    if (changed) {
3324                        if (DEBUG_PREFERRED) {
3325                            Slog.v(TAG, "Preferred activity bookkeeping changed; writing restrictions");
3326                        }
3327                        scheduleWritePackageRestrictionsLocked(userId);
3328                    }
3329                }
3330            }
3331        }
3332        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "No preferred activity to return");
3333        return null;
3334    }
3335
3336    /*
3337     * Returns if intent can be forwarded from the sourceUserId to the targetUserId
3338     */
3339    @Override
3340    public boolean canForwardTo(Intent intent, String resolvedType, int sourceUserId,
3341            int targetUserId) {
3342        mContext.enforceCallingOrSelfPermission(
3343                android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
3344        List<CrossProfileIntentFilter> matches =
3345                getMatchingCrossProfileIntentFilters(intent, resolvedType, sourceUserId);
3346        if (matches != null) {
3347            int size = matches.size();
3348            for (int i = 0; i < size; i++) {
3349                if (matches.get(i).getTargetUserId() == targetUserId) return true;
3350            }
3351        }
3352        return false;
3353    }
3354
3355    private List<CrossProfileIntentFilter> getMatchingCrossProfileIntentFilters(Intent intent,
3356            String resolvedType, int userId) {
3357        CrossProfileIntentResolver resolver = mSettings.mCrossProfileIntentResolvers.get(userId);
3358        if (resolver != null) {
3359            return resolver.queryIntent(intent, resolvedType, false, userId);
3360        }
3361        return null;
3362    }
3363
3364    @Override
3365    public List<ResolveInfo> queryIntentActivities(Intent intent,
3366            String resolvedType, int flags, int userId) {
3367        if (!sUserManager.exists(userId)) return Collections.emptyList();
3368        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "query intent activities");
3369        ComponentName comp = intent.getComponent();
3370        if (comp == null) {
3371            if (intent.getSelector() != null) {
3372                intent = intent.getSelector();
3373                comp = intent.getComponent();
3374            }
3375        }
3376
3377        if (comp != null) {
3378            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3379            final ActivityInfo ai = getActivityInfo(comp, flags, userId);
3380            if (ai != null) {
3381                final ResolveInfo ri = new ResolveInfo();
3382                ri.activityInfo = ai;
3383                list.add(ri);
3384            }
3385            return list;
3386        }
3387
3388        // reader
3389        synchronized (mPackages) {
3390            final String pkgName = intent.getPackage();
3391            if (pkgName == null) {
3392                List<CrossProfileIntentFilter> matchingFilters =
3393                        getMatchingCrossProfileIntentFilters(intent, resolvedType, userId);
3394                // Check for results that need to skip the current profile.
3395                ResolveInfo resolveInfo  = querySkipCurrentProfileIntents(matchingFilters, intent,
3396                        resolvedType, flags, userId);
3397                if (resolveInfo != null) {
3398                    List<ResolveInfo> result = new ArrayList<ResolveInfo>(1);
3399                    result.add(resolveInfo);
3400                    return result;
3401                }
3402                // Check for cross profile results.
3403                resolveInfo = queryCrossProfileIntents(
3404                        matchingFilters, intent, resolvedType, flags, userId);
3405
3406                // Check for results in the current profile.
3407                List<ResolveInfo> result = mActivities.queryIntent(
3408                        intent, resolvedType, flags, userId);
3409                if (resolveInfo != null) {
3410                    result.add(resolveInfo);
3411                    Collections.sort(result, mResolvePrioritySorter);
3412                }
3413                return result;
3414            }
3415            final PackageParser.Package pkg = mPackages.get(pkgName);
3416            if (pkg != null) {
3417                return mActivities.queryIntentForPackage(intent, resolvedType, flags,
3418                        pkg.activities, userId);
3419            }
3420            return new ArrayList<ResolveInfo>();
3421        }
3422    }
3423
3424    private ResolveInfo querySkipCurrentProfileIntents(
3425            List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
3426            int flags, int sourceUserId) {
3427        if (matchingFilters != null) {
3428            int size = matchingFilters.size();
3429            for (int i = 0; i < size; i ++) {
3430                CrossProfileIntentFilter filter = matchingFilters.get(i);
3431                if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) != 0) {
3432                    // Checking if there are activities in the target user that can handle the
3433                    // intent.
3434                    ResolveInfo resolveInfo = checkTargetCanHandle(filter, intent, resolvedType,
3435                            flags, sourceUserId);
3436                    if (resolveInfo != null) {
3437                        return resolveInfo;
3438                    }
3439                }
3440            }
3441        }
3442        return null;
3443    }
3444
3445    // Return matching ResolveInfo if any for skip current profile intent filters.
3446    private ResolveInfo queryCrossProfileIntents(
3447            List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
3448            int flags, int sourceUserId) {
3449        if (matchingFilters != null) {
3450            // Two {@link CrossProfileIntentFilter}s can have the same targetUserId and
3451            // match the same intent. For performance reasons, it is better not to
3452            // run queryIntent twice for the same userId
3453            SparseBooleanArray alreadyTriedUserIds = new SparseBooleanArray();
3454            int size = matchingFilters.size();
3455            for (int i = 0; i < size; i++) {
3456                CrossProfileIntentFilter filter = matchingFilters.get(i);
3457                int targetUserId = filter.getTargetUserId();
3458                if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) == 0
3459                        && !alreadyTriedUserIds.get(targetUserId)) {
3460                    // Checking if there are activities in the target user that can handle the
3461                    // intent.
3462                    ResolveInfo resolveInfo = checkTargetCanHandle(filter, intent, resolvedType,
3463                            flags, sourceUserId);
3464                    if (resolveInfo != null) return resolveInfo;
3465                    alreadyTriedUserIds.put(targetUserId, true);
3466                }
3467            }
3468        }
3469        return null;
3470    }
3471
3472    private ResolveInfo checkTargetCanHandle(CrossProfileIntentFilter filter, Intent intent,
3473            String resolvedType, int flags, int sourceUserId) {
3474        List<ResolveInfo> resultTargetUser = mActivities.queryIntent(intent,
3475                resolvedType, flags, filter.getTargetUserId());
3476        if (resultTargetUser != null && !resultTargetUser.isEmpty()) {
3477            return createForwardingResolveInfo(filter, sourceUserId, filter.getTargetUserId());
3478        }
3479        return null;
3480    }
3481
3482    private ResolveInfo createForwardingResolveInfo(IntentFilter filter,
3483            int sourceUserId, int targetUserId) {
3484        ResolveInfo forwardingResolveInfo = new ResolveInfo();
3485        String className;
3486        if (targetUserId == UserHandle.USER_OWNER) {
3487            className = FORWARD_INTENT_TO_USER_OWNER;
3488        } else {
3489            className = FORWARD_INTENT_TO_MANAGED_PROFILE;
3490        }
3491        ComponentName forwardingActivityComponentName = new ComponentName(
3492                mAndroidApplication.packageName, className);
3493        ActivityInfo forwardingActivityInfo = getActivityInfo(forwardingActivityComponentName, 0,
3494                sourceUserId);
3495        if (targetUserId == UserHandle.USER_OWNER) {
3496            forwardingActivityInfo.showUserIcon = UserHandle.USER_OWNER;
3497            forwardingResolveInfo.noResourceId = true;
3498        }
3499        forwardingResolveInfo.activityInfo = forwardingActivityInfo;
3500        forwardingResolveInfo.priority = 0;
3501        forwardingResolveInfo.preferredOrder = 0;
3502        forwardingResolveInfo.match = 0;
3503        forwardingResolveInfo.isDefault = true;
3504        forwardingResolveInfo.filter = filter;
3505        forwardingResolveInfo.targetUserId = targetUserId;
3506        return forwardingResolveInfo;
3507    }
3508
3509    @Override
3510    public List<ResolveInfo> queryIntentActivityOptions(ComponentName caller,
3511            Intent[] specifics, String[] specificTypes, Intent intent,
3512            String resolvedType, int flags, int userId) {
3513        if (!sUserManager.exists(userId)) return Collections.emptyList();
3514        enforceCrossUserPermission(Binder.getCallingUid(), userId, false,
3515                false, "query intent activity options");
3516        final String resultsAction = intent.getAction();
3517
3518        List<ResolveInfo> results = queryIntentActivities(intent, resolvedType, flags
3519                | PackageManager.GET_RESOLVED_FILTER, userId);
3520
3521        if (DEBUG_INTENT_MATCHING) {
3522            Log.v(TAG, "Query " + intent + ": " + results);
3523        }
3524
3525        int specificsPos = 0;
3526        int N;
3527
3528        // todo: note that the algorithm used here is O(N^2).  This
3529        // isn't a problem in our current environment, but if we start running
3530        // into situations where we have more than 5 or 10 matches then this
3531        // should probably be changed to something smarter...
3532
3533        // First we go through and resolve each of the specific items
3534        // that were supplied, taking care of removing any corresponding
3535        // duplicate items in the generic resolve list.
3536        if (specifics != null) {
3537            for (int i=0; i<specifics.length; i++) {
3538                final Intent sintent = specifics[i];
3539                if (sintent == null) {
3540                    continue;
3541                }
3542
3543                if (DEBUG_INTENT_MATCHING) {
3544                    Log.v(TAG, "Specific #" + i + ": " + sintent);
3545                }
3546
3547                String action = sintent.getAction();
3548                if (resultsAction != null && resultsAction.equals(action)) {
3549                    // If this action was explicitly requested, then don't
3550                    // remove things that have it.
3551                    action = null;
3552                }
3553
3554                ResolveInfo ri = null;
3555                ActivityInfo ai = null;
3556
3557                ComponentName comp = sintent.getComponent();
3558                if (comp == null) {
3559                    ri = resolveIntent(
3560                        sintent,
3561                        specificTypes != null ? specificTypes[i] : null,
3562                            flags, userId);
3563                    if (ri == null) {
3564                        continue;
3565                    }
3566                    if (ri == mResolveInfo) {
3567                        // ACK!  Must do something better with this.
3568                    }
3569                    ai = ri.activityInfo;
3570                    comp = new ComponentName(ai.applicationInfo.packageName,
3571                            ai.name);
3572                } else {
3573                    ai = getActivityInfo(comp, flags, userId);
3574                    if (ai == null) {
3575                        continue;
3576                    }
3577                }
3578
3579                // Look for any generic query activities that are duplicates
3580                // of this specific one, and remove them from the results.
3581                if (DEBUG_INTENT_MATCHING) Log.v(TAG, "Specific #" + i + ": " + ai);
3582                N = results.size();
3583                int j;
3584                for (j=specificsPos; j<N; j++) {
3585                    ResolveInfo sri = results.get(j);
3586                    if ((sri.activityInfo.name.equals(comp.getClassName())
3587                            && sri.activityInfo.applicationInfo.packageName.equals(
3588                                    comp.getPackageName()))
3589                        || (action != null && sri.filter.matchAction(action))) {
3590                        results.remove(j);
3591                        if (DEBUG_INTENT_MATCHING) Log.v(
3592                            TAG, "Removing duplicate item from " + j
3593                            + " due to specific " + specificsPos);
3594                        if (ri == null) {
3595                            ri = sri;
3596                        }
3597                        j--;
3598                        N--;
3599                    }
3600                }
3601
3602                // Add this specific item to its proper place.
3603                if (ri == null) {
3604                    ri = new ResolveInfo();
3605                    ri.activityInfo = ai;
3606                }
3607                results.add(specificsPos, ri);
3608                ri.specificIndex = i;
3609                specificsPos++;
3610            }
3611        }
3612
3613        // Now we go through the remaining generic results and remove any
3614        // duplicate actions that are found here.
3615        N = results.size();
3616        for (int i=specificsPos; i<N-1; i++) {
3617            final ResolveInfo rii = results.get(i);
3618            if (rii.filter == null) {
3619                continue;
3620            }
3621
3622            // Iterate over all of the actions of this result's intent
3623            // filter...  typically this should be just one.
3624            final Iterator<String> it = rii.filter.actionsIterator();
3625            if (it == null) {
3626                continue;
3627            }
3628            while (it.hasNext()) {
3629                final String action = it.next();
3630                if (resultsAction != null && resultsAction.equals(action)) {
3631                    // If this action was explicitly requested, then don't
3632                    // remove things that have it.
3633                    continue;
3634                }
3635                for (int j=i+1; j<N; j++) {
3636                    final ResolveInfo rij = results.get(j);
3637                    if (rij.filter != null && rij.filter.hasAction(action)) {
3638                        results.remove(j);
3639                        if (DEBUG_INTENT_MATCHING) Log.v(
3640                            TAG, "Removing duplicate item from " + j
3641                            + " due to action " + action + " at " + i);
3642                        j--;
3643                        N--;
3644                    }
3645                }
3646            }
3647
3648            // If the caller didn't request filter information, drop it now
3649            // so we don't have to marshall/unmarshall it.
3650            if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) {
3651                rii.filter = null;
3652            }
3653        }
3654
3655        // Filter out the caller activity if so requested.
3656        if (caller != null) {
3657            N = results.size();
3658            for (int i=0; i<N; i++) {
3659                ActivityInfo ainfo = results.get(i).activityInfo;
3660                if (caller.getPackageName().equals(ainfo.applicationInfo.packageName)
3661                        && caller.getClassName().equals(ainfo.name)) {
3662                    results.remove(i);
3663                    break;
3664                }
3665            }
3666        }
3667
3668        // If the caller didn't request filter information,
3669        // drop them now so we don't have to
3670        // marshall/unmarshall it.
3671        if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) {
3672            N = results.size();
3673            for (int i=0; i<N; i++) {
3674                results.get(i).filter = null;
3675            }
3676        }
3677
3678        if (DEBUG_INTENT_MATCHING) Log.v(TAG, "Result: " + results);
3679        return results;
3680    }
3681
3682    @Override
3683    public List<ResolveInfo> queryIntentReceivers(Intent intent, String resolvedType, int flags,
3684            int userId) {
3685        if (!sUserManager.exists(userId)) return Collections.emptyList();
3686        ComponentName comp = intent.getComponent();
3687        if (comp == null) {
3688            if (intent.getSelector() != null) {
3689                intent = intent.getSelector();
3690                comp = intent.getComponent();
3691            }
3692        }
3693        if (comp != null) {
3694            List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3695            ActivityInfo ai = getReceiverInfo(comp, flags, userId);
3696            if (ai != null) {
3697                ResolveInfo ri = new ResolveInfo();
3698                ri.activityInfo = ai;
3699                list.add(ri);
3700            }
3701            return list;
3702        }
3703
3704        // reader
3705        synchronized (mPackages) {
3706            String pkgName = intent.getPackage();
3707            if (pkgName == null) {
3708                return mReceivers.queryIntent(intent, resolvedType, flags, userId);
3709            }
3710            final PackageParser.Package pkg = mPackages.get(pkgName);
3711            if (pkg != null) {
3712                return mReceivers.queryIntentForPackage(intent, resolvedType, flags, pkg.receivers,
3713                        userId);
3714            }
3715            return null;
3716        }
3717    }
3718
3719    @Override
3720    public ResolveInfo resolveService(Intent intent, String resolvedType, int flags, int userId) {
3721        List<ResolveInfo> query = queryIntentServices(intent, resolvedType, flags, userId);
3722        if (!sUserManager.exists(userId)) return null;
3723        if (query != null) {
3724            if (query.size() >= 1) {
3725                // If there is more than one service with the same priority,
3726                // just arbitrarily pick the first one.
3727                return query.get(0);
3728            }
3729        }
3730        return null;
3731    }
3732
3733    @Override
3734    public List<ResolveInfo> queryIntentServices(Intent intent, String resolvedType, int flags,
3735            int userId) {
3736        if (!sUserManager.exists(userId)) return Collections.emptyList();
3737        ComponentName comp = intent.getComponent();
3738        if (comp == null) {
3739            if (intent.getSelector() != null) {
3740                intent = intent.getSelector();
3741                comp = intent.getComponent();
3742            }
3743        }
3744        if (comp != null) {
3745            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3746            final ServiceInfo si = getServiceInfo(comp, flags, userId);
3747            if (si != null) {
3748                final ResolveInfo ri = new ResolveInfo();
3749                ri.serviceInfo = si;
3750                list.add(ri);
3751            }
3752            return list;
3753        }
3754
3755        // reader
3756        synchronized (mPackages) {
3757            String pkgName = intent.getPackage();
3758            if (pkgName == null) {
3759                return mServices.queryIntent(intent, resolvedType, flags, userId);
3760            }
3761            final PackageParser.Package pkg = mPackages.get(pkgName);
3762            if (pkg != null) {
3763                return mServices.queryIntentForPackage(intent, resolvedType, flags, pkg.services,
3764                        userId);
3765            }
3766            return null;
3767        }
3768    }
3769
3770    @Override
3771    public List<ResolveInfo> queryIntentContentProviders(
3772            Intent intent, String resolvedType, int flags, int userId) {
3773        if (!sUserManager.exists(userId)) return Collections.emptyList();
3774        ComponentName comp = intent.getComponent();
3775        if (comp == null) {
3776            if (intent.getSelector() != null) {
3777                intent = intent.getSelector();
3778                comp = intent.getComponent();
3779            }
3780        }
3781        if (comp != null) {
3782            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3783            final ProviderInfo pi = getProviderInfo(comp, flags, userId);
3784            if (pi != null) {
3785                final ResolveInfo ri = new ResolveInfo();
3786                ri.providerInfo = pi;
3787                list.add(ri);
3788            }
3789            return list;
3790        }
3791
3792        // reader
3793        synchronized (mPackages) {
3794            String pkgName = intent.getPackage();
3795            if (pkgName == null) {
3796                return mProviders.queryIntent(intent, resolvedType, flags, userId);
3797            }
3798            final PackageParser.Package pkg = mPackages.get(pkgName);
3799            if (pkg != null) {
3800                return mProviders.queryIntentForPackage(
3801                        intent, resolvedType, flags, pkg.providers, userId);
3802            }
3803            return null;
3804        }
3805    }
3806
3807    @Override
3808    public ParceledListSlice<PackageInfo> getInstalledPackages(int flags, int userId) {
3809        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3810
3811        enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false, "get installed packages");
3812
3813        // writer
3814        synchronized (mPackages) {
3815            ArrayList<PackageInfo> list;
3816            if (listUninstalled) {
3817                list = new ArrayList<PackageInfo>(mSettings.mPackages.size());
3818                for (PackageSetting ps : mSettings.mPackages.values()) {
3819                    PackageInfo pi;
3820                    if (ps.pkg != null) {
3821                        pi = generatePackageInfo(ps.pkg, flags, userId);
3822                    } else {
3823                        pi = generatePackageInfoFromSettingsLPw(ps.name, flags, userId);
3824                    }
3825                    if (pi != null) {
3826                        list.add(pi);
3827                    }
3828                }
3829            } else {
3830                list = new ArrayList<PackageInfo>(mPackages.size());
3831                for (PackageParser.Package p : mPackages.values()) {
3832                    PackageInfo pi = generatePackageInfo(p, flags, userId);
3833                    if (pi != null) {
3834                        list.add(pi);
3835                    }
3836                }
3837            }
3838
3839            return new ParceledListSlice<PackageInfo>(list);
3840        }
3841    }
3842
3843    private void addPackageHoldingPermissions(ArrayList<PackageInfo> list, PackageSetting ps,
3844            String[] permissions, boolean[] tmp, int flags, int userId) {
3845        int numMatch = 0;
3846        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
3847        for (int i=0; i<permissions.length; i++) {
3848            if (gp.grantedPermissions.contains(permissions[i])) {
3849                tmp[i] = true;
3850                numMatch++;
3851            } else {
3852                tmp[i] = false;
3853            }
3854        }
3855        if (numMatch == 0) {
3856            return;
3857        }
3858        PackageInfo pi;
3859        if (ps.pkg != null) {
3860            pi = generatePackageInfo(ps.pkg, flags, userId);
3861        } else {
3862            pi = generatePackageInfoFromSettingsLPw(ps.name, flags, userId);
3863        }
3864        // The above might return null in cases of uninstalled apps or install-state
3865        // skew across users/profiles.
3866        if (pi != null) {
3867            if ((flags&PackageManager.GET_PERMISSIONS) == 0) {
3868                if (numMatch == permissions.length) {
3869                    pi.requestedPermissions = permissions;
3870                } else {
3871                    pi.requestedPermissions = new String[numMatch];
3872                    numMatch = 0;
3873                    for (int i=0; i<permissions.length; i++) {
3874                        if (tmp[i]) {
3875                            pi.requestedPermissions[numMatch] = permissions[i];
3876                            numMatch++;
3877                        }
3878                    }
3879                }
3880            }
3881            list.add(pi);
3882        }
3883    }
3884
3885    @Override
3886    public ParceledListSlice<PackageInfo> getPackagesHoldingPermissions(
3887            String[] permissions, int flags, int userId) {
3888        if (!sUserManager.exists(userId)) return null;
3889        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3890
3891        // writer
3892        synchronized (mPackages) {
3893            ArrayList<PackageInfo> list = new ArrayList<PackageInfo>();
3894            boolean[] tmpBools = new boolean[permissions.length];
3895            if (listUninstalled) {
3896                for (PackageSetting ps : mSettings.mPackages.values()) {
3897                    addPackageHoldingPermissions(list, ps, permissions, tmpBools, flags, userId);
3898                }
3899            } else {
3900                for (PackageParser.Package pkg : mPackages.values()) {
3901                    PackageSetting ps = (PackageSetting)pkg.mExtras;
3902                    if (ps != null) {
3903                        addPackageHoldingPermissions(list, ps, permissions, tmpBools, flags,
3904                                userId);
3905                    }
3906                }
3907            }
3908
3909            return new ParceledListSlice<PackageInfo>(list);
3910        }
3911    }
3912
3913    @Override
3914    public ParceledListSlice<ApplicationInfo> getInstalledApplications(int flags, int userId) {
3915        if (!sUserManager.exists(userId)) return null;
3916        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3917
3918        // writer
3919        synchronized (mPackages) {
3920            ArrayList<ApplicationInfo> list;
3921            if (listUninstalled) {
3922                list = new ArrayList<ApplicationInfo>(mSettings.mPackages.size());
3923                for (PackageSetting ps : mSettings.mPackages.values()) {
3924                    ApplicationInfo ai;
3925                    if (ps.pkg != null) {
3926                        ai = PackageParser.generateApplicationInfo(ps.pkg, flags,
3927                                ps.readUserState(userId), userId);
3928                    } else {
3929                        ai = generateApplicationInfoFromSettingsLPw(ps.name, flags, userId);
3930                    }
3931                    if (ai != null) {
3932                        list.add(ai);
3933                    }
3934                }
3935            } else {
3936                list = new ArrayList<ApplicationInfo>(mPackages.size());
3937                for (PackageParser.Package p : mPackages.values()) {
3938                    if (p.mExtras != null) {
3939                        ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags,
3940                                ((PackageSetting)p.mExtras).readUserState(userId), userId);
3941                        if (ai != null) {
3942                            list.add(ai);
3943                        }
3944                    }
3945                }
3946            }
3947
3948            return new ParceledListSlice<ApplicationInfo>(list);
3949        }
3950    }
3951
3952    public List<ApplicationInfo> getPersistentApplications(int flags) {
3953        final ArrayList<ApplicationInfo> finalList = new ArrayList<ApplicationInfo>();
3954
3955        // reader
3956        synchronized (mPackages) {
3957            final Iterator<PackageParser.Package> i = mPackages.values().iterator();
3958            final int userId = UserHandle.getCallingUserId();
3959            while (i.hasNext()) {
3960                final PackageParser.Package p = i.next();
3961                if (p.applicationInfo != null
3962                        && (p.applicationInfo.flags&ApplicationInfo.FLAG_PERSISTENT) != 0
3963                        && (!mSafeMode || isSystemApp(p))) {
3964                    PackageSetting ps = mSettings.mPackages.get(p.packageName);
3965                    if (ps != null) {
3966                        ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags,
3967                                ps.readUserState(userId), userId);
3968                        if (ai != null) {
3969                            finalList.add(ai);
3970                        }
3971                    }
3972                }
3973            }
3974        }
3975
3976        return finalList;
3977    }
3978
3979    @Override
3980    public ProviderInfo resolveContentProvider(String name, int flags, int userId) {
3981        if (!sUserManager.exists(userId)) return null;
3982        // reader
3983        synchronized (mPackages) {
3984            final PackageParser.Provider provider = mProvidersByAuthority.get(name);
3985            PackageSetting ps = provider != null
3986                    ? mSettings.mPackages.get(provider.owner.packageName)
3987                    : null;
3988            return ps != null
3989                    && mSettings.isEnabledLPr(provider.info, flags, userId)
3990                    && (!mSafeMode || (provider.info.applicationInfo.flags
3991                            &ApplicationInfo.FLAG_SYSTEM) != 0)
3992                    ? PackageParser.generateProviderInfo(provider, flags,
3993                            ps.readUserState(userId), userId)
3994                    : null;
3995        }
3996    }
3997
3998    /**
3999     * @deprecated
4000     */
4001    @Deprecated
4002    public void querySyncProviders(List<String> outNames, List<ProviderInfo> outInfo) {
4003        // reader
4004        synchronized (mPackages) {
4005            final Iterator<Map.Entry<String, PackageParser.Provider>> i = mProvidersByAuthority
4006                    .entrySet().iterator();
4007            final int userId = UserHandle.getCallingUserId();
4008            while (i.hasNext()) {
4009                Map.Entry<String, PackageParser.Provider> entry = i.next();
4010                PackageParser.Provider p = entry.getValue();
4011                PackageSetting ps = mSettings.mPackages.get(p.owner.packageName);
4012
4013                if (ps != null && p.syncable
4014                        && (!mSafeMode || (p.info.applicationInfo.flags
4015                                &ApplicationInfo.FLAG_SYSTEM) != 0)) {
4016                    ProviderInfo info = PackageParser.generateProviderInfo(p, 0,
4017                            ps.readUserState(userId), userId);
4018                    if (info != null) {
4019                        outNames.add(entry.getKey());
4020                        outInfo.add(info);
4021                    }
4022                }
4023            }
4024        }
4025    }
4026
4027    @Override
4028    public List<ProviderInfo> queryContentProviders(String processName,
4029            int uid, int flags) {
4030        ArrayList<ProviderInfo> finalList = null;
4031        // reader
4032        synchronized (mPackages) {
4033            final Iterator<PackageParser.Provider> i = mProviders.mProviders.values().iterator();
4034            final int userId = processName != null ?
4035                    UserHandle.getUserId(uid) : UserHandle.getCallingUserId();
4036            while (i.hasNext()) {
4037                final PackageParser.Provider p = i.next();
4038                PackageSetting ps = mSettings.mPackages.get(p.owner.packageName);
4039                if (ps != null && p.info.authority != null
4040                        && (processName == null
4041                                || (p.info.processName.equals(processName)
4042                                        && UserHandle.isSameApp(p.info.applicationInfo.uid, uid)))
4043                        && mSettings.isEnabledLPr(p.info, flags, userId)
4044                        && (!mSafeMode
4045                                || (p.info.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0)) {
4046                    if (finalList == null) {
4047                        finalList = new ArrayList<ProviderInfo>(3);
4048                    }
4049                    ProviderInfo info = PackageParser.generateProviderInfo(p, flags,
4050                            ps.readUserState(userId), userId);
4051                    if (info != null) {
4052                        finalList.add(info);
4053                    }
4054                }
4055            }
4056        }
4057
4058        if (finalList != null) {
4059            Collections.sort(finalList, mProviderInitOrderSorter);
4060        }
4061
4062        return finalList;
4063    }
4064
4065    @Override
4066    public InstrumentationInfo getInstrumentationInfo(ComponentName name,
4067            int flags) {
4068        // reader
4069        synchronized (mPackages) {
4070            final PackageParser.Instrumentation i = mInstrumentation.get(name);
4071            return PackageParser.generateInstrumentationInfo(i, flags);
4072        }
4073    }
4074
4075    @Override
4076    public List<InstrumentationInfo> queryInstrumentation(String targetPackage,
4077            int flags) {
4078        ArrayList<InstrumentationInfo> finalList =
4079            new ArrayList<InstrumentationInfo>();
4080
4081        // reader
4082        synchronized (mPackages) {
4083            final Iterator<PackageParser.Instrumentation> i = mInstrumentation.values().iterator();
4084            while (i.hasNext()) {
4085                final PackageParser.Instrumentation p = i.next();
4086                if (targetPackage == null
4087                        || targetPackage.equals(p.info.targetPackage)) {
4088                    InstrumentationInfo ii = PackageParser.generateInstrumentationInfo(p,
4089                            flags);
4090                    if (ii != null) {
4091                        finalList.add(ii);
4092                    }
4093                }
4094            }
4095        }
4096
4097        return finalList;
4098    }
4099
4100    private void createIdmapsForPackageLI(PackageParser.Package pkg) {
4101        ArrayMap<String, PackageParser.Package> overlays = mOverlays.get(pkg.packageName);
4102        if (overlays == null) {
4103            Slog.w(TAG, "Unable to create idmap for " + pkg.packageName + ": no overlay packages");
4104            return;
4105        }
4106        for (PackageParser.Package opkg : overlays.values()) {
4107            // Not much to do if idmap fails: we already logged the error
4108            // and we certainly don't want to abort installation of pkg simply
4109            // because an overlay didn't fit properly. For these reasons,
4110            // ignore the return value of createIdmapForPackagePairLI.
4111            createIdmapForPackagePairLI(pkg, opkg);
4112        }
4113    }
4114
4115    private boolean createIdmapForPackagePairLI(PackageParser.Package pkg,
4116            PackageParser.Package opkg) {
4117        if (!opkg.mTrustedOverlay) {
4118            Slog.w(TAG, "Skipping target and overlay pair " + pkg.baseCodePath + " and " +
4119                    opkg.baseCodePath + ": overlay not trusted");
4120            return false;
4121        }
4122        ArrayMap<String, PackageParser.Package> overlaySet = mOverlays.get(pkg.packageName);
4123        if (overlaySet == null) {
4124            Slog.e(TAG, "was about to create idmap for " + pkg.baseCodePath + " and " +
4125                    opkg.baseCodePath + " but target package has no known overlays");
4126            return false;
4127        }
4128        final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
4129        // TODO: generate idmap for split APKs
4130        if (mInstaller.idmap(pkg.baseCodePath, opkg.baseCodePath, sharedGid) != 0) {
4131            Slog.e(TAG, "Failed to generate idmap for " + pkg.baseCodePath + " and "
4132                    + opkg.baseCodePath);
4133            return false;
4134        }
4135        PackageParser.Package[] overlayArray =
4136            overlaySet.values().toArray(new PackageParser.Package[0]);
4137        Comparator<PackageParser.Package> cmp = new Comparator<PackageParser.Package>() {
4138            public int compare(PackageParser.Package p1, PackageParser.Package p2) {
4139                return p1.mOverlayPriority - p2.mOverlayPriority;
4140            }
4141        };
4142        Arrays.sort(overlayArray, cmp);
4143
4144        pkg.applicationInfo.resourceDirs = new String[overlayArray.length];
4145        int i = 0;
4146        for (PackageParser.Package p : overlayArray) {
4147            pkg.applicationInfo.resourceDirs[i++] = p.baseCodePath;
4148        }
4149        return true;
4150    }
4151
4152    private void scanDirLI(File dir, int parseFlags, int scanFlags, long currentTime) {
4153        final File[] files = dir.listFiles();
4154        if (ArrayUtils.isEmpty(files)) {
4155            Log.d(TAG, "No files in app dir " + dir);
4156            return;
4157        }
4158
4159        if (DEBUG_PACKAGE_SCANNING) {
4160            Log.d(TAG, "Scanning app dir " + dir + " scanFlags=" + scanFlags
4161                    + " flags=0x" + Integer.toHexString(parseFlags));
4162        }
4163
4164        for (File file : files) {
4165            final boolean isPackage = (isApkFile(file) || file.isDirectory())
4166                    && !PackageInstallerService.isStageName(file.getName());
4167            if (!isPackage) {
4168                // Ignore entries which are not packages
4169                continue;
4170            }
4171            try {
4172                scanPackageLI(file, parseFlags | PackageParser.PARSE_MUST_BE_APK,
4173                        scanFlags, currentTime, null);
4174            } catch (PackageManagerException e) {
4175                Slog.w(TAG, "Failed to parse " + file + ": " + e.getMessage());
4176
4177                // Delete invalid userdata apps
4178                if ((parseFlags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
4179                        e.error == PackageManager.INSTALL_FAILED_INVALID_APK) {
4180                    logCriticalInfo(Log.WARN, "Deleting invalid package at " + file);
4181                    if (file.isDirectory()) {
4182                        FileUtils.deleteContents(file);
4183                    }
4184                    file.delete();
4185                }
4186            }
4187        }
4188    }
4189
4190    private static File getSettingsProblemFile() {
4191        File dataDir = Environment.getDataDirectory();
4192        File systemDir = new File(dataDir, "system");
4193        File fname = new File(systemDir, "uiderrors.txt");
4194        return fname;
4195    }
4196
4197    static void reportSettingsProblem(int priority, String msg) {
4198        logCriticalInfo(priority, msg);
4199    }
4200
4201    static void logCriticalInfo(int priority, String msg) {
4202        Slog.println(priority, TAG, msg);
4203        EventLogTags.writePmCriticalInfo(msg);
4204        try {
4205            File fname = getSettingsProblemFile();
4206            FileOutputStream out = new FileOutputStream(fname, true);
4207            PrintWriter pw = new FastPrintWriter(out);
4208            SimpleDateFormat formatter = new SimpleDateFormat();
4209            String dateString = formatter.format(new Date(System.currentTimeMillis()));
4210            pw.println(dateString + ": " + msg);
4211            pw.close();
4212            FileUtils.setPermissions(
4213                    fname.toString(),
4214                    FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IROTH,
4215                    -1, -1);
4216        } catch (java.io.IOException e) {
4217        }
4218    }
4219
4220    private void collectCertificatesLI(PackageParser pp, PackageSetting ps,
4221            PackageParser.Package pkg, File srcFile, int parseFlags)
4222            throws PackageManagerException {
4223        if (ps != null
4224                && ps.codePath.equals(srcFile)
4225                && ps.timeStamp == srcFile.lastModified()
4226                && !isCompatSignatureUpdateNeeded(pkg)
4227                && !isRecoverSignatureUpdateNeeded(pkg)) {
4228            long mSigningKeySetId = ps.keySetData.getProperSigningKeySet();
4229            if (ps.signatures.mSignatures != null
4230                    && ps.signatures.mSignatures.length != 0
4231                    && mSigningKeySetId != PackageKeySetData.KEYSET_UNASSIGNED) {
4232                // Optimization: reuse the existing cached certificates
4233                // if the package appears to be unchanged.
4234                pkg.mSignatures = ps.signatures.mSignatures;
4235                KeySetManagerService ksms = mSettings.mKeySetManagerService;
4236                synchronized (mPackages) {
4237                    pkg.mSigningKeys = ksms.getPublicKeysFromKeySetLPr(mSigningKeySetId);
4238                }
4239                return;
4240            }
4241
4242            Slog.w(TAG, "PackageSetting for " + ps.name
4243                    + " is missing signatures.  Collecting certs again to recover them.");
4244        } else {
4245            Log.i(TAG, srcFile.toString() + " changed; collecting certs");
4246        }
4247
4248        try {
4249            pp.collectCertificates(pkg, parseFlags);
4250            pp.collectManifestDigest(pkg);
4251        } catch (PackageParserException e) {
4252            throw PackageManagerException.from(e);
4253        }
4254    }
4255
4256    /*
4257     *  Scan a package and return the newly parsed package.
4258     *  Returns null in case of errors and the error code is stored in mLastScanError
4259     */
4260    private PackageParser.Package scanPackageLI(File scanFile, int parseFlags, int scanFlags,
4261            long currentTime, UserHandle user) throws PackageManagerException {
4262        if (DEBUG_INSTALL) Slog.d(TAG, "Parsing: " + scanFile);
4263        parseFlags |= mDefParseFlags;
4264        PackageParser pp = new PackageParser();
4265        pp.setSeparateProcesses(mSeparateProcesses);
4266        pp.setOnlyCoreApps(mOnlyCore);
4267        pp.setDisplayMetrics(mMetrics);
4268
4269        if ((scanFlags & SCAN_TRUSTED_OVERLAY) != 0) {
4270            parseFlags |= PackageParser.PARSE_TRUSTED_OVERLAY;
4271        }
4272
4273        final PackageParser.Package pkg;
4274        try {
4275            pkg = pp.parsePackage(scanFile, parseFlags);
4276        } catch (PackageParserException e) {
4277            throw PackageManagerException.from(e);
4278        }
4279
4280        PackageSetting ps = null;
4281        PackageSetting updatedPkg;
4282        // reader
4283        synchronized (mPackages) {
4284            // Look to see if we already know about this package.
4285            String oldName = mSettings.mRenamedPackages.get(pkg.packageName);
4286            if (pkg.mOriginalPackages != null && pkg.mOriginalPackages.contains(oldName)) {
4287                // This package has been renamed to its original name.  Let's
4288                // use that.
4289                ps = mSettings.peekPackageLPr(oldName);
4290            }
4291            // If there was no original package, see one for the real package name.
4292            if (ps == null) {
4293                ps = mSettings.peekPackageLPr(pkg.packageName);
4294            }
4295            // Check to see if this package could be hiding/updating a system
4296            // package.  Must look for it either under the original or real
4297            // package name depending on our state.
4298            updatedPkg = mSettings.getDisabledSystemPkgLPr(ps != null ? ps.name : pkg.packageName);
4299            if (DEBUG_INSTALL && updatedPkg != null) Slog.d(TAG, "updatedPkg = " + updatedPkg);
4300        }
4301        boolean updatedPkgBetter = false;
4302        // First check if this is a system package that may involve an update
4303        if (updatedPkg != null && (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
4304            // If new package is not located in "/system/priv-app" (e.g. due to an OTA),
4305            // it needs to drop FLAG_PRIVILEGED.
4306            if (locationIsPrivileged(scanFile)) {
4307                updatedPkg.pkgPrivateFlags |= ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;
4308            } else {
4309                updatedPkg.pkgPrivateFlags &= ~ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;
4310            }
4311
4312            if (ps != null && !ps.codePath.equals(scanFile)) {
4313                // The path has changed from what was last scanned...  check the
4314                // version of the new path against what we have stored to determine
4315                // what to do.
4316                if (DEBUG_INSTALL) Slog.d(TAG, "Path changing from " + ps.codePath);
4317                if (pkg.mVersionCode <= ps.versionCode) {
4318                    // The system package has been updated and the code path does not match
4319                    // Ignore entry. Skip it.
4320                    Slog.i(TAG, "Package " + ps.name + " at " + scanFile
4321                            + " ignored: updated version " + ps.versionCode
4322                            + " better than this " + pkg.mVersionCode);
4323                    if (!updatedPkg.codePath.equals(scanFile)) {
4324                        Slog.w(PackageManagerService.TAG, "Code path for hidden system pkg : "
4325                                + ps.name + " changing from " + updatedPkg.codePathString
4326                                + " to " + scanFile);
4327                        updatedPkg.codePath = scanFile;
4328                        updatedPkg.codePathString = scanFile.toString();
4329                        updatedPkg.resourcePath = scanFile;
4330                        updatedPkg.resourcePathString = scanFile.toString();
4331                    }
4332                    updatedPkg.pkg = pkg;
4333                    throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE, null);
4334                } else {
4335                    // The current app on the system partition is better than
4336                    // what we have updated to on the data partition; switch
4337                    // back to the system partition version.
4338                    // At this point, its safely assumed that package installation for
4339                    // apps in system partition will go through. If not there won't be a working
4340                    // version of the app
4341                    // writer
4342                    synchronized (mPackages) {
4343                        // Just remove the loaded entries from package lists.
4344                        mPackages.remove(ps.name);
4345                    }
4346
4347                    logCriticalInfo(Log.WARN, "Package " + ps.name + " at " + scanFile
4348                            + " reverting from " + ps.codePathString
4349                            + ": new version " + pkg.mVersionCode
4350                            + " better than installed " + ps.versionCode);
4351
4352                    InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
4353                            ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
4354                            getAppDexInstructionSets(ps));
4355                    synchronized (mInstallLock) {
4356                        args.cleanUpResourcesLI();
4357                    }
4358                    synchronized (mPackages) {
4359                        mSettings.enableSystemPackageLPw(ps.name);
4360                    }
4361                    updatedPkgBetter = true;
4362                }
4363            }
4364        }
4365
4366        if (updatedPkg != null) {
4367            // An updated system app will not have the PARSE_IS_SYSTEM flag set
4368            // initially
4369            parseFlags |= PackageParser.PARSE_IS_SYSTEM;
4370
4371            // An updated privileged app will not have the PARSE_IS_PRIVILEGED
4372            // flag set initially
4373            if ((updatedPkg.pkgPrivateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0) {
4374                parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
4375            }
4376        }
4377
4378        // Verify certificates against what was last scanned
4379        collectCertificatesLI(pp, ps, pkg, scanFile, parseFlags);
4380
4381        /*
4382         * A new system app appeared, but we already had a non-system one of the
4383         * same name installed earlier.
4384         */
4385        boolean shouldHideSystemApp = false;
4386        if (updatedPkg == null && ps != null
4387                && (parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) != 0 && !isSystemApp(ps)) {
4388            /*
4389             * Check to make sure the signatures match first. If they don't,
4390             * wipe the installed application and its data.
4391             */
4392            if (compareSignatures(ps.signatures.mSignatures, pkg.mSignatures)
4393                    != PackageManager.SIGNATURE_MATCH) {
4394                logCriticalInfo(Log.WARN, "Package " + ps.name + " appeared on system, but"
4395                        + " signatures don't match existing userdata copy; removing");
4396                deletePackageLI(pkg.packageName, null, true, null, null, 0, null, false);
4397                ps = null;
4398            } else {
4399                /*
4400                 * If the newly-added system app is an older version than the
4401                 * already installed version, hide it. It will be scanned later
4402                 * and re-added like an update.
4403                 */
4404                if (pkg.mVersionCode <= ps.versionCode) {
4405                    shouldHideSystemApp = true;
4406                    logCriticalInfo(Log.INFO, "Package " + ps.name + " appeared at " + scanFile
4407                            + " but new version " + pkg.mVersionCode + " better than installed "
4408                            + ps.versionCode + "; hiding system");
4409                } else {
4410                    /*
4411                     * The newly found system app is a newer version that the
4412                     * one previously installed. Simply remove the
4413                     * already-installed application and replace it with our own
4414                     * while keeping the application data.
4415                     */
4416                    logCriticalInfo(Log.WARN, "Package " + ps.name + " at " + scanFile
4417                            + " reverting from " + ps.codePathString + ": new version "
4418                            + pkg.mVersionCode + " better than installed " + ps.versionCode);
4419                    InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
4420                            ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
4421                            getAppDexInstructionSets(ps));
4422                    synchronized (mInstallLock) {
4423                        args.cleanUpResourcesLI();
4424                    }
4425                }
4426            }
4427        }
4428
4429        // The apk is forward locked (not public) if its code and resources
4430        // are kept in different files. (except for app in either system or
4431        // vendor path).
4432        // TODO grab this value from PackageSettings
4433        if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
4434            if (ps != null && !ps.codePath.equals(ps.resourcePath)) {
4435                parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
4436            }
4437        }
4438
4439        // TODO: extend to support forward-locked splits
4440        String resourcePath = null;
4441        String baseResourcePath = null;
4442        if ((parseFlags & PackageParser.PARSE_FORWARD_LOCK) != 0 && !updatedPkgBetter) {
4443            if (ps != null && ps.resourcePathString != null) {
4444                resourcePath = ps.resourcePathString;
4445                baseResourcePath = ps.resourcePathString;
4446            } else {
4447                // Should not happen at all. Just log an error.
4448                Slog.e(TAG, "Resource path not set for pkg : " + pkg.packageName);
4449            }
4450        } else {
4451            resourcePath = pkg.codePath;
4452            baseResourcePath = pkg.baseCodePath;
4453        }
4454
4455        // Set application objects path explicitly.
4456        pkg.applicationInfo.setCodePath(pkg.codePath);
4457        pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
4458        pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
4459        pkg.applicationInfo.setResourcePath(resourcePath);
4460        pkg.applicationInfo.setBaseResourcePath(baseResourcePath);
4461        pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
4462
4463        // Note that we invoke the following method only if we are about to unpack an application
4464        PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanFlags
4465                | SCAN_UPDATE_SIGNATURE, currentTime, user);
4466
4467        /*
4468         * If the system app should be overridden by a previously installed
4469         * data, hide the system app now and let the /data/app scan pick it up
4470         * again.
4471         */
4472        if (shouldHideSystemApp) {
4473            synchronized (mPackages) {
4474                /*
4475                 * We have to grant systems permissions before we hide, because
4476                 * grantPermissions will assume the package update is trying to
4477                 * expand its permissions.
4478                 */
4479                grantPermissionsLPw(pkg, true, pkg.packageName);
4480                mSettings.disableSystemPackageLPw(pkg.packageName);
4481            }
4482        }
4483
4484        return scannedPkg;
4485    }
4486
4487    private static String fixProcessName(String defProcessName,
4488            String processName, int uid) {
4489        if (processName == null) {
4490            return defProcessName;
4491        }
4492        return processName;
4493    }
4494
4495    private void verifySignaturesLP(PackageSetting pkgSetting, PackageParser.Package pkg)
4496            throws PackageManagerException {
4497        if (pkgSetting.signatures.mSignatures != null) {
4498            // Already existing package. Make sure signatures match
4499            boolean match = compareSignatures(pkgSetting.signatures.mSignatures, pkg.mSignatures)
4500                    == PackageManager.SIGNATURE_MATCH;
4501            if (!match) {
4502                match = compareSignaturesCompat(pkgSetting.signatures, pkg)
4503                        == PackageManager.SIGNATURE_MATCH;
4504            }
4505            if (!match) {
4506                match = compareSignaturesRecover(pkgSetting.signatures, pkg)
4507                        == PackageManager.SIGNATURE_MATCH;
4508            }
4509            if (!match) {
4510                throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
4511                        + pkg.packageName + " signatures do not match the "
4512                        + "previously installed version; ignoring!");
4513            }
4514        }
4515
4516        // Check for shared user signatures
4517        if (pkgSetting.sharedUser != null && pkgSetting.sharedUser.signatures.mSignatures != null) {
4518            // Already existing package. Make sure signatures match
4519            boolean match = compareSignatures(pkgSetting.sharedUser.signatures.mSignatures,
4520                    pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;
4521            if (!match) {
4522                match = compareSignaturesCompat(pkgSetting.sharedUser.signatures, pkg)
4523                        == PackageManager.SIGNATURE_MATCH;
4524            }
4525            if (!match) {
4526                match = compareSignaturesRecover(pkgSetting.sharedUser.signatures, pkg)
4527                        == PackageManager.SIGNATURE_MATCH;
4528            }
4529            if (!match) {
4530                throw new PackageManagerException(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
4531                        "Package " + pkg.packageName
4532                        + " has no signatures that match those in shared user "
4533                        + pkgSetting.sharedUser.name + "; ignoring!");
4534            }
4535        }
4536    }
4537
4538    /**
4539     * Enforces that only the system UID or root's UID can call a method exposed
4540     * via Binder.
4541     *
4542     * @param message used as message if SecurityException is thrown
4543     * @throws SecurityException if the caller is not system or root
4544     */
4545    private static final void enforceSystemOrRoot(String message) {
4546        final int uid = Binder.getCallingUid();
4547        if (uid != Process.SYSTEM_UID && uid != 0) {
4548            throw new SecurityException(message);
4549        }
4550    }
4551
4552    @Override
4553    public void performBootDexOpt() {
4554        enforceSystemOrRoot("Only the system can request dexopt be performed");
4555
4556        // Before everything else, see whether we need to fstrim.
4557        try {
4558            IMountService ms = PackageHelper.getMountService();
4559            if (ms != null) {
4560                final boolean isUpgrade = isUpgrade();
4561                boolean doTrim = isUpgrade;
4562                if (doTrim) {
4563                    Slog.w(TAG, "Running disk maintenance immediately due to system update");
4564                } else {
4565                    final long interval = android.provider.Settings.Global.getLong(
4566                            mContext.getContentResolver(),
4567                            android.provider.Settings.Global.FSTRIM_MANDATORY_INTERVAL,
4568                            DEFAULT_MANDATORY_FSTRIM_INTERVAL);
4569                    if (interval > 0) {
4570                        final long timeSinceLast = System.currentTimeMillis() - ms.lastMaintenance();
4571                        if (timeSinceLast > interval) {
4572                            doTrim = true;
4573                            Slog.w(TAG, "No disk maintenance in " + timeSinceLast
4574                                    + "; running immediately");
4575                        }
4576                    }
4577                }
4578                if (doTrim) {
4579                    if (!isFirstBoot()) {
4580                        try {
4581                            ActivityManagerNative.getDefault().showBootMessage(
4582                                    mContext.getResources().getString(
4583                                            R.string.android_upgrading_fstrim), true);
4584                        } catch (RemoteException e) {
4585                        }
4586                    }
4587                    ms.runMaintenance();
4588                }
4589            } else {
4590                Slog.e(TAG, "Mount service unavailable!");
4591            }
4592        } catch (RemoteException e) {
4593            // Can't happen; MountService is local
4594        }
4595
4596        final ArraySet<PackageParser.Package> pkgs;
4597        synchronized (mPackages) {
4598            pkgs = mDeferredDexOpt;
4599            mDeferredDexOpt = null;
4600        }
4601
4602        if (pkgs != null) {
4603            // Sort apps by importance for dexopt ordering. Important apps are given more priority
4604            // in case the device runs out of space.
4605            ArrayList<PackageParser.Package> sortedPkgs = new ArrayList<PackageParser.Package>();
4606            // Give priority to core apps.
4607            for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
4608                PackageParser.Package pkg = it.next();
4609                if (pkg.coreApp) {
4610                    if (DEBUG_DEXOPT) {
4611                        Log.i(TAG, "Adding core app " + sortedPkgs.size() + ": " + pkg.packageName);
4612                    }
4613                    sortedPkgs.add(pkg);
4614                    it.remove();
4615                }
4616            }
4617            // Give priority to system apps that listen for pre boot complete.
4618            Intent intent = new Intent(Intent.ACTION_PRE_BOOT_COMPLETED);
4619            ArraySet<String> pkgNames = getPackageNamesForIntent(intent);
4620            for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
4621                PackageParser.Package pkg = it.next();
4622                if (pkgNames.contains(pkg.packageName)) {
4623                    if (DEBUG_DEXOPT) {
4624                        Log.i(TAG, "Adding pre boot system app " + sortedPkgs.size() + ": " + pkg.packageName);
4625                    }
4626                    sortedPkgs.add(pkg);
4627                    it.remove();
4628                }
4629            }
4630            // Give priority to system apps.
4631            for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
4632                PackageParser.Package pkg = it.next();
4633                if (isSystemApp(pkg) && !isUpdatedSystemApp(pkg)) {
4634                    if (DEBUG_DEXOPT) {
4635                        Log.i(TAG, "Adding system app " + sortedPkgs.size() + ": " + pkg.packageName);
4636                    }
4637                    sortedPkgs.add(pkg);
4638                    it.remove();
4639                }
4640            }
4641            // Give priority to updated system apps.
4642            for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
4643                PackageParser.Package pkg = it.next();
4644                if (isUpdatedSystemApp(pkg)) {
4645                    if (DEBUG_DEXOPT) {
4646                        Log.i(TAG, "Adding updated system app " + sortedPkgs.size() + ": " + pkg.packageName);
4647                    }
4648                    sortedPkgs.add(pkg);
4649                    it.remove();
4650                }
4651            }
4652            // Give priority to apps that listen for boot complete.
4653            intent = new Intent(Intent.ACTION_BOOT_COMPLETED);
4654            pkgNames = getPackageNamesForIntent(intent);
4655            for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
4656                PackageParser.Package pkg = it.next();
4657                if (pkgNames.contains(pkg.packageName)) {
4658                    if (DEBUG_DEXOPT) {
4659                        Log.i(TAG, "Adding boot app " + sortedPkgs.size() + ": " + pkg.packageName);
4660                    }
4661                    sortedPkgs.add(pkg);
4662                    it.remove();
4663                }
4664            }
4665            // Filter out packages that aren't recently used.
4666            filterRecentlyUsedApps(pkgs);
4667            // Add all remaining apps.
4668            for (PackageParser.Package pkg : pkgs) {
4669                if (DEBUG_DEXOPT) {
4670                    Log.i(TAG, "Adding app " + sortedPkgs.size() + ": " + pkg.packageName);
4671                }
4672                sortedPkgs.add(pkg);
4673            }
4674
4675            // If we want to be lazy, filter everything that wasn't recently used.
4676            if (mLazyDexOpt) {
4677                filterRecentlyUsedApps(sortedPkgs);
4678            }
4679
4680            int i = 0;
4681            int total = sortedPkgs.size();
4682            File dataDir = Environment.getDataDirectory();
4683            long lowThreshold = StorageManager.from(mContext).getStorageLowBytes(dataDir);
4684            if (lowThreshold == 0) {
4685                throw new IllegalStateException("Invalid low memory threshold");
4686            }
4687            for (PackageParser.Package pkg : sortedPkgs) {
4688                long usableSpace = dataDir.getUsableSpace();
4689                if (usableSpace < lowThreshold) {
4690                    Log.w(TAG, "Not running dexopt on remaining apps due to low memory: " + usableSpace);
4691                    break;
4692                }
4693                performBootDexOpt(pkg, ++i, total);
4694            }
4695        }
4696    }
4697
4698    private void filterRecentlyUsedApps(Collection<PackageParser.Package> pkgs) {
4699        // Filter out packages that aren't recently used.
4700        //
4701        // The exception is first boot of a non-eng device (aka !mLazyDexOpt), which
4702        // should do a full dexopt.
4703        if (mLazyDexOpt || (!isFirstBoot() && mPackageUsage.isHistoricalPackageUsageAvailable())) {
4704            int total = pkgs.size();
4705            int skipped = 0;
4706            long now = System.currentTimeMillis();
4707            for (Iterator<PackageParser.Package> i = pkgs.iterator(); i.hasNext();) {
4708                PackageParser.Package pkg = i.next();
4709                long then = pkg.mLastPackageUsageTimeInMills;
4710                if (then + mDexOptLRUThresholdInMills < now) {
4711                    if (DEBUG_DEXOPT) {
4712                        Log.i(TAG, "Skipping dexopt of " + pkg.packageName + " last resumed: " +
4713                              ((then == 0) ? "never" : new Date(then)));
4714                    }
4715                    i.remove();
4716                    skipped++;
4717                }
4718            }
4719            if (DEBUG_DEXOPT) {
4720                Log.i(TAG, "Skipped optimizing " + skipped + " of " + total);
4721            }
4722        }
4723    }
4724
4725    private ArraySet<String> getPackageNamesForIntent(Intent intent) {
4726        List<ResolveInfo> ris = null;
4727        try {
4728            ris = AppGlobals.getPackageManager().queryIntentReceivers(
4729                    intent, null, 0, UserHandle.USER_OWNER);
4730        } catch (RemoteException e) {
4731        }
4732        ArraySet<String> pkgNames = new ArraySet<String>();
4733        if (ris != null) {
4734            for (ResolveInfo ri : ris) {
4735                pkgNames.add(ri.activityInfo.packageName);
4736            }
4737        }
4738        return pkgNames;
4739    }
4740
4741    private void performBootDexOpt(PackageParser.Package pkg, int curr, int total) {
4742        if (DEBUG_DEXOPT) {
4743            Log.i(TAG, "Optimizing app " + curr + " of " + total + ": " + pkg.packageName);
4744        }
4745        if (!isFirstBoot()) {
4746            try {
4747                ActivityManagerNative.getDefault().showBootMessage(
4748                        mContext.getResources().getString(R.string.android_upgrading_apk,
4749                                curr, total), true);
4750            } catch (RemoteException e) {
4751            }
4752        }
4753        PackageParser.Package p = pkg;
4754        synchronized (mInstallLock) {
4755            performDexOptLI(p, null /* instruction sets */, false /* force dex */,
4756                            false /* defer */, true /* include dependencies */);
4757        }
4758    }
4759
4760    @Override
4761    public boolean performDexOptIfNeeded(String packageName, String instructionSet) {
4762        return performDexOpt(packageName, instructionSet, false);
4763    }
4764
4765    private static String getPrimaryInstructionSet(ApplicationInfo info) {
4766        if (info.primaryCpuAbi == null) {
4767            return getPreferredInstructionSet();
4768        }
4769
4770        return VMRuntime.getInstructionSet(info.primaryCpuAbi);
4771    }
4772
4773    public boolean performDexOpt(String packageName, String instructionSet, boolean backgroundDexopt) {
4774        boolean dexopt = mLazyDexOpt || backgroundDexopt;
4775        boolean updateUsage = !backgroundDexopt;  // Don't update usage if this is just a backgroundDexopt
4776        if (!dexopt && !updateUsage) {
4777            // We aren't going to dexopt or update usage, so bail early.
4778            return false;
4779        }
4780        PackageParser.Package p;
4781        final String targetInstructionSet;
4782        synchronized (mPackages) {
4783            p = mPackages.get(packageName);
4784            if (p == null) {
4785                return false;
4786            }
4787            if (updateUsage) {
4788                p.mLastPackageUsageTimeInMills = System.currentTimeMillis();
4789            }
4790            mPackageUsage.write(false);
4791            if (!dexopt) {
4792                // We aren't going to dexopt, so bail early.
4793                return false;
4794            }
4795
4796            targetInstructionSet = instructionSet != null ? instructionSet :
4797                    getPrimaryInstructionSet(p.applicationInfo);
4798            if (p.mDexOptPerformed.contains(targetInstructionSet)) {
4799                return false;
4800            }
4801        }
4802
4803        synchronized (mInstallLock) {
4804            final String[] instructionSets = new String[] { targetInstructionSet };
4805            return performDexOptLI(p, instructionSets, false /* force dex */, false /* defer */,
4806                    true /* include dependencies */) == DEX_OPT_PERFORMED;
4807        }
4808    }
4809
4810    public ArraySet<String> getPackagesThatNeedDexOpt() {
4811        ArraySet<String> pkgs = null;
4812        synchronized (mPackages) {
4813            for (PackageParser.Package p : mPackages.values()) {
4814                if (DEBUG_DEXOPT) {
4815                    Log.i(TAG, p.packageName + " mDexOptPerformed=" + p.mDexOptPerformed.toArray());
4816                }
4817                if (!p.mDexOptPerformed.isEmpty()) {
4818                    continue;
4819                }
4820                if (pkgs == null) {
4821                    pkgs = new ArraySet<String>();
4822                }
4823                pkgs.add(p.packageName);
4824            }
4825        }
4826        return pkgs;
4827    }
4828
4829    public void shutdown() {
4830        mPackageUsage.write(true);
4831    }
4832
4833    private void performDexOptLibsLI(ArrayList<String> libs, String[] instructionSets,
4834             boolean forceDex, boolean defer, ArraySet<String> done) {
4835        for (int i=0; i<libs.size(); i++) {
4836            PackageParser.Package libPkg;
4837            String libName;
4838            synchronized (mPackages) {
4839                libName = libs.get(i);
4840                SharedLibraryEntry lib = mSharedLibraries.get(libName);
4841                if (lib != null && lib.apk != null) {
4842                    libPkg = mPackages.get(lib.apk);
4843                } else {
4844                    libPkg = null;
4845                }
4846            }
4847            if (libPkg != null && !done.contains(libName)) {
4848                performDexOptLI(libPkg, instructionSets, forceDex, defer, done);
4849            }
4850        }
4851    }
4852
4853    static final int DEX_OPT_SKIPPED = 0;
4854    static final int DEX_OPT_PERFORMED = 1;
4855    static final int DEX_OPT_DEFERRED = 2;
4856    static final int DEX_OPT_FAILED = -1;
4857
4858    private int performDexOptLI(PackageParser.Package pkg, String[] targetInstructionSets,
4859            boolean forceDex, boolean defer, ArraySet<String> done) {
4860        final String[] instructionSets = targetInstructionSets != null ?
4861                targetInstructionSets : getAppDexInstructionSets(pkg.applicationInfo);
4862
4863        if (done != null) {
4864            done.add(pkg.packageName);
4865            if (pkg.usesLibraries != null) {
4866                performDexOptLibsLI(pkg.usesLibraries, instructionSets, forceDex, defer, done);
4867            }
4868            if (pkg.usesOptionalLibraries != null) {
4869                performDexOptLibsLI(pkg.usesOptionalLibraries, instructionSets, forceDex, defer, done);
4870            }
4871        }
4872
4873        if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_HAS_CODE) == 0) {
4874            return DEX_OPT_SKIPPED;
4875        }
4876
4877        final boolean vmSafeMode = (pkg.applicationInfo.flags & ApplicationInfo.FLAG_VM_SAFE_MODE) != 0;
4878
4879        final List<String> paths = pkg.getAllCodePathsExcludingResourceOnly();
4880        boolean performedDexOpt = false;
4881        // There are three basic cases here:
4882        // 1.) we need to dexopt, either because we are forced or it is needed
4883        // 2.) we are defering a needed dexopt
4884        // 3.) we are skipping an unneeded dexopt
4885        final String[] dexCodeInstructionSets = getDexCodeInstructionSets(instructionSets);
4886        for (String dexCodeInstructionSet : dexCodeInstructionSets) {
4887            if (!forceDex && pkg.mDexOptPerformed.contains(dexCodeInstructionSet)) {
4888                continue;
4889            }
4890
4891            for (String path : paths) {
4892                try {
4893                    // This will return DEXOPT_NEEDED if we either cannot find any odex file for this
4894                    // patckage or the one we find does not match the image checksum (i.e. it was
4895                    // compiled against an old image). It will return PATCHOAT_NEEDED if we can find a
4896                    // odex file and it matches the checksum of the image but not its base address,
4897                    // meaning we need to move it.
4898                    final byte isDexOptNeeded = DexFile.isDexOptNeededInternal(path,
4899                            pkg.packageName, dexCodeInstructionSet, defer);
4900                    if (forceDex || (!defer && isDexOptNeeded == DexFile.DEXOPT_NEEDED)) {
4901                        Log.i(TAG, "Running dexopt on: " + path + " pkg="
4902                                + pkg.applicationInfo.packageName + " isa=" + dexCodeInstructionSet
4903                                + " vmSafeMode=" + vmSafeMode);
4904                        final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
4905                        final int ret = mInstaller.dexopt(path, sharedGid, !isForwardLocked(pkg),
4906                                pkg.packageName, dexCodeInstructionSet, vmSafeMode);
4907
4908                        if (ret < 0) {
4909                            // Don't bother running dexopt again if we failed, it will probably
4910                            // just result in an error again. Also, don't bother dexopting for other
4911                            // paths & ISAs.
4912                            return DEX_OPT_FAILED;
4913                        }
4914
4915                        performedDexOpt = true;
4916                    } else if (!defer && isDexOptNeeded == DexFile.PATCHOAT_NEEDED) {
4917                        Log.i(TAG, "Running patchoat on: " + pkg.applicationInfo.packageName);
4918                        final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
4919                        final int ret = mInstaller.patchoat(path, sharedGid, !isForwardLocked(pkg),
4920                                pkg.packageName, dexCodeInstructionSet);
4921
4922                        if (ret < 0) {
4923                            // Don't bother running patchoat again if we failed, it will probably
4924                            // just result in an error again. Also, don't bother dexopting for other
4925                            // paths & ISAs.
4926                            return DEX_OPT_FAILED;
4927                        }
4928
4929                        performedDexOpt = true;
4930                    }
4931
4932                    // We're deciding to defer a needed dexopt. Don't bother dexopting for other
4933                    // paths and instruction sets. We'll deal with them all together when we process
4934                    // our list of deferred dexopts.
4935                    if (defer && isDexOptNeeded != DexFile.UP_TO_DATE) {
4936                        if (mDeferredDexOpt == null) {
4937                            mDeferredDexOpt = new ArraySet<PackageParser.Package>();
4938                        }
4939                        mDeferredDexOpt.add(pkg);
4940                        return DEX_OPT_DEFERRED;
4941                    }
4942                } catch (FileNotFoundException e) {
4943                    Slog.w(TAG, "Apk not found for dexopt: " + path);
4944                    return DEX_OPT_FAILED;
4945                } catch (IOException e) {
4946                    Slog.w(TAG, "IOException reading apk: " + path, e);
4947                    return DEX_OPT_FAILED;
4948                } catch (StaleDexCacheError e) {
4949                    Slog.w(TAG, "StaleDexCacheError when reading apk: " + path, e);
4950                    return DEX_OPT_FAILED;
4951                } catch (Exception e) {
4952                    Slog.w(TAG, "Exception when doing dexopt : ", e);
4953                    return DEX_OPT_FAILED;
4954                }
4955            }
4956
4957            // At this point we haven't failed dexopt and we haven't deferred dexopt. We must
4958            // either have either succeeded dexopt, or have had isDexOptNeededInternal tell us
4959            // it isn't required. We therefore mark that this package doesn't need dexopt unless
4960            // it's forced. performedDexOpt will tell us whether we performed dex-opt or skipped
4961            // it.
4962            pkg.mDexOptPerformed.add(dexCodeInstructionSet);
4963        }
4964
4965        // If we've gotten here, we're sure that no error occurred and that we haven't
4966        // deferred dex-opt. We've either dex-opted one more paths or instruction sets or
4967        // we've skipped all of them because they are up to date. In both cases this
4968        // package doesn't need dexopt any longer.
4969        return performedDexOpt ? DEX_OPT_PERFORMED : DEX_OPT_SKIPPED;
4970    }
4971
4972    private static String[] getAppDexInstructionSets(ApplicationInfo info) {
4973        if (info.primaryCpuAbi != null) {
4974            if (info.secondaryCpuAbi != null) {
4975                return new String[] {
4976                        VMRuntime.getInstructionSet(info.primaryCpuAbi),
4977                        VMRuntime.getInstructionSet(info.secondaryCpuAbi) };
4978            } else {
4979                return new String[] {
4980                        VMRuntime.getInstructionSet(info.primaryCpuAbi) };
4981            }
4982        }
4983
4984        return new String[] { getPreferredInstructionSet() };
4985    }
4986
4987    private static String[] getAppDexInstructionSets(PackageSetting ps) {
4988        if (ps.primaryCpuAbiString != null) {
4989            if (ps.secondaryCpuAbiString != null) {
4990                return new String[] {
4991                        VMRuntime.getInstructionSet(ps.primaryCpuAbiString),
4992                        VMRuntime.getInstructionSet(ps.secondaryCpuAbiString) };
4993            } else {
4994                return new String[] {
4995                        VMRuntime.getInstructionSet(ps.primaryCpuAbiString) };
4996            }
4997        }
4998
4999        return new String[] { getPreferredInstructionSet() };
5000    }
5001
5002    private static String getPreferredInstructionSet() {
5003        if (sPreferredInstructionSet == null) {
5004            sPreferredInstructionSet = VMRuntime.getInstructionSet(Build.SUPPORTED_ABIS[0]);
5005        }
5006
5007        return sPreferredInstructionSet;
5008    }
5009
5010    private static List<String> getAllInstructionSets() {
5011        final String[] allAbis = Build.SUPPORTED_ABIS;
5012        final List<String> allInstructionSets = new ArrayList<String>(allAbis.length);
5013
5014        for (String abi : allAbis) {
5015            final String instructionSet = VMRuntime.getInstructionSet(abi);
5016            if (!allInstructionSets.contains(instructionSet)) {
5017                allInstructionSets.add(instructionSet);
5018            }
5019        }
5020
5021        return allInstructionSets;
5022    }
5023
5024    /**
5025     * Returns the instruction set that should be used to compile dex code. In the presence of
5026     * a native bridge this might be different than the one shared libraries use.
5027     */
5028    private static String getDexCodeInstructionSet(String sharedLibraryIsa) {
5029        String dexCodeIsa = SystemProperties.get("ro.dalvik.vm.isa." + sharedLibraryIsa);
5030        return (dexCodeIsa.isEmpty() ? sharedLibraryIsa : dexCodeIsa);
5031    }
5032
5033    private static String[] getDexCodeInstructionSets(String[] instructionSets) {
5034        ArraySet<String> dexCodeInstructionSets = new ArraySet<String>(instructionSets.length);
5035        for (String instructionSet : instructionSets) {
5036            dexCodeInstructionSets.add(getDexCodeInstructionSet(instructionSet));
5037        }
5038        return dexCodeInstructionSets.toArray(new String[dexCodeInstructionSets.size()]);
5039    }
5040
5041    /**
5042     * Returns deduplicated list of supported instructions for dex code.
5043     */
5044    public static String[] getAllDexCodeInstructionSets() {
5045        String[] supportedInstructionSets = new String[Build.SUPPORTED_ABIS.length];
5046        for (int i = 0; i < supportedInstructionSets.length; i++) {
5047            String abi = Build.SUPPORTED_ABIS[i];
5048            supportedInstructionSets[i] = VMRuntime.getInstructionSet(abi);
5049        }
5050        return getDexCodeInstructionSets(supportedInstructionSets);
5051    }
5052
5053    @Override
5054    public void forceDexOpt(String packageName) {
5055        enforceSystemOrRoot("forceDexOpt");
5056
5057        PackageParser.Package pkg;
5058        synchronized (mPackages) {
5059            pkg = mPackages.get(packageName);
5060            if (pkg == null) {
5061                throw new IllegalArgumentException("Missing package: " + packageName);
5062            }
5063        }
5064
5065        synchronized (mInstallLock) {
5066            final String[] instructionSets = new String[] {
5067                    getPrimaryInstructionSet(pkg.applicationInfo) };
5068            final int res = performDexOptLI(pkg, instructionSets, true, false, true);
5069            if (res != DEX_OPT_PERFORMED) {
5070                throw new IllegalStateException("Failed to dexopt: " + res);
5071            }
5072        }
5073    }
5074
5075    private int performDexOptLI(PackageParser.Package pkg, String[] instructionSets,
5076                                boolean forceDex, boolean defer, boolean inclDependencies) {
5077        ArraySet<String> done;
5078        if (inclDependencies && (pkg.usesLibraries != null || pkg.usesOptionalLibraries != null)) {
5079            done = new ArraySet<String>();
5080            done.add(pkg.packageName);
5081        } else {
5082            done = null;
5083        }
5084        return performDexOptLI(pkg, instructionSets,  forceDex, defer, done);
5085    }
5086
5087    private boolean verifyPackageUpdateLPr(PackageSetting oldPkg, PackageParser.Package newPkg) {
5088        if ((oldPkg.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0) {
5089            Slog.w(TAG, "Unable to update from " + oldPkg.name
5090                    + " to " + newPkg.packageName
5091                    + ": old package not in system partition");
5092            return false;
5093        } else if (mPackages.get(oldPkg.name) != null) {
5094            Slog.w(TAG, "Unable to update from " + oldPkg.name
5095                    + " to " + newPkg.packageName
5096                    + ": old package still exists");
5097            return false;
5098        }
5099        return true;
5100    }
5101
5102    File getDataPathForUser(int userId) {
5103        return new File(mUserAppDataDir.getAbsolutePath() + File.separator + userId);
5104    }
5105
5106    private File getDataPathForPackage(String packageName, int userId) {
5107        /*
5108         * Until we fully support multiple users, return the directory we
5109         * previously would have. The PackageManagerTests will need to be
5110         * revised when this is changed back..
5111         */
5112        if (userId == 0) {
5113            return new File(mAppDataDir, packageName);
5114        } else {
5115            return new File(mUserAppDataDir.getAbsolutePath() + File.separator + userId
5116                + File.separator + packageName);
5117        }
5118    }
5119
5120    private int createDataDirsLI(String packageName, int uid, String seinfo) {
5121        int[] users = sUserManager.getUserIds();
5122        int res = mInstaller.install(packageName, uid, uid, seinfo);
5123        if (res < 0) {
5124            return res;
5125        }
5126        for (int user : users) {
5127            if (user != 0) {
5128                res = mInstaller.createUserData(packageName,
5129                        UserHandle.getUid(user, uid), user, seinfo);
5130                if (res < 0) {
5131                    return res;
5132                }
5133            }
5134        }
5135        return res;
5136    }
5137
5138    private int removeDataDirsLI(String packageName) {
5139        int[] users = sUserManager.getUserIds();
5140        int res = 0;
5141        for (int user : users) {
5142            int resInner = mInstaller.remove(packageName, user);
5143            if (resInner < 0) {
5144                res = resInner;
5145            }
5146        }
5147
5148        return res;
5149    }
5150
5151    private int deleteCodeCacheDirsLI(String packageName) {
5152        int[] users = sUserManager.getUserIds();
5153        int res = 0;
5154        for (int user : users) {
5155            int resInner = mInstaller.deleteCodeCacheFiles(packageName, user);
5156            if (resInner < 0) {
5157                res = resInner;
5158            }
5159        }
5160        return res;
5161    }
5162
5163    private void addSharedLibraryLPw(ArraySet<String> usesLibraryFiles, SharedLibraryEntry file,
5164            PackageParser.Package changingLib) {
5165        if (file.path != null) {
5166            usesLibraryFiles.add(file.path);
5167            return;
5168        }
5169        PackageParser.Package p = mPackages.get(file.apk);
5170        if (changingLib != null && changingLib.packageName.equals(file.apk)) {
5171            // If we are doing this while in the middle of updating a library apk,
5172            // then we need to make sure to use that new apk for determining the
5173            // dependencies here.  (We haven't yet finished committing the new apk
5174            // to the package manager state.)
5175            if (p == null || p.packageName.equals(changingLib.packageName)) {
5176                p = changingLib;
5177            }
5178        }
5179        if (p != null) {
5180            usesLibraryFiles.addAll(p.getAllCodePaths());
5181        }
5182    }
5183
5184    private void updateSharedLibrariesLPw(PackageParser.Package pkg,
5185            PackageParser.Package changingLib) throws PackageManagerException {
5186        if (pkg.usesLibraries != null || pkg.usesOptionalLibraries != null) {
5187            final ArraySet<String> usesLibraryFiles = new ArraySet<>();
5188            int N = pkg.usesLibraries != null ? pkg.usesLibraries.size() : 0;
5189            for (int i=0; i<N; i++) {
5190                final SharedLibraryEntry file = mSharedLibraries.get(pkg.usesLibraries.get(i));
5191                if (file == null) {
5192                    throw new PackageManagerException(INSTALL_FAILED_MISSING_SHARED_LIBRARY,
5193                            "Package " + pkg.packageName + " requires unavailable shared library "
5194                            + pkg.usesLibraries.get(i) + "; failing!");
5195                }
5196                addSharedLibraryLPw(usesLibraryFiles, file, changingLib);
5197            }
5198            N = pkg.usesOptionalLibraries != null ? pkg.usesOptionalLibraries.size() : 0;
5199            for (int i=0; i<N; i++) {
5200                final SharedLibraryEntry file = mSharedLibraries.get(pkg.usesOptionalLibraries.get(i));
5201                if (file == null) {
5202                    Slog.w(TAG, "Package " + pkg.packageName
5203                            + " desires unavailable shared library "
5204                            + pkg.usesOptionalLibraries.get(i) + "; ignoring!");
5205                } else {
5206                    addSharedLibraryLPw(usesLibraryFiles, file, changingLib);
5207                }
5208            }
5209            N = usesLibraryFiles.size();
5210            if (N > 0) {
5211                pkg.usesLibraryFiles = usesLibraryFiles.toArray(new String[N]);
5212            } else {
5213                pkg.usesLibraryFiles = null;
5214            }
5215        }
5216    }
5217
5218    private static boolean hasString(List<String> list, List<String> which) {
5219        if (list == null) {
5220            return false;
5221        }
5222        for (int i=list.size()-1; i>=0; i--) {
5223            for (int j=which.size()-1; j>=0; j--) {
5224                if (which.get(j).equals(list.get(i))) {
5225                    return true;
5226                }
5227            }
5228        }
5229        return false;
5230    }
5231
5232    private void updateAllSharedLibrariesLPw() {
5233        for (PackageParser.Package pkg : mPackages.values()) {
5234            try {
5235                updateSharedLibrariesLPw(pkg, null);
5236            } catch (PackageManagerException e) {
5237                Slog.e(TAG, "updateAllSharedLibrariesLPw failed: " + e.getMessage());
5238            }
5239        }
5240    }
5241
5242    private ArrayList<PackageParser.Package> updateAllSharedLibrariesLPw(
5243            PackageParser.Package changingPkg) {
5244        ArrayList<PackageParser.Package> res = null;
5245        for (PackageParser.Package pkg : mPackages.values()) {
5246            if (hasString(pkg.usesLibraries, changingPkg.libraryNames)
5247                    || hasString(pkg.usesOptionalLibraries, changingPkg.libraryNames)) {
5248                if (res == null) {
5249                    res = new ArrayList<PackageParser.Package>();
5250                }
5251                res.add(pkg);
5252                try {
5253                    updateSharedLibrariesLPw(pkg, changingPkg);
5254                } catch (PackageManagerException e) {
5255                    Slog.e(TAG, "updateAllSharedLibrariesLPw failed: " + e.getMessage());
5256                }
5257            }
5258        }
5259        return res;
5260    }
5261
5262    /**
5263     * Derive the value of the {@code cpuAbiOverride} based on the provided
5264     * value and an optional stored value from the package settings.
5265     */
5266    private static String deriveAbiOverride(String abiOverride, PackageSetting settings) {
5267        String cpuAbiOverride = null;
5268
5269        if (NativeLibraryHelper.CLEAR_ABI_OVERRIDE.equals(abiOverride)) {
5270            cpuAbiOverride = null;
5271        } else if (abiOverride != null) {
5272            cpuAbiOverride = abiOverride;
5273        } else if (settings != null) {
5274            cpuAbiOverride = settings.cpuAbiOverrideString;
5275        }
5276
5277        return cpuAbiOverride;
5278    }
5279
5280    private PackageParser.Package scanPackageLI(PackageParser.Package pkg, int parseFlags,
5281            int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {
5282        boolean success = false;
5283        try {
5284            final PackageParser.Package res = scanPackageDirtyLI(pkg, parseFlags, scanFlags,
5285                    currentTime, user);
5286            success = true;
5287            return res;
5288        } finally {
5289            if (!success && (scanFlags & SCAN_DELETE_DATA_ON_FAILURES) != 0) {
5290                removeDataDirsLI(pkg.packageName);
5291            }
5292        }
5293    }
5294
5295    private PackageParser.Package scanPackageDirtyLI(PackageParser.Package pkg, int parseFlags,
5296            int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {
5297        final File scanFile = new File(pkg.codePath);
5298        if (pkg.applicationInfo.getCodePath() == null ||
5299                pkg.applicationInfo.getResourcePath() == null) {
5300            // Bail out. The resource and code paths haven't been set.
5301            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
5302                    "Code and resource paths haven't been set correctly");
5303        }
5304
5305        if ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
5306            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
5307        } else {
5308            // Only allow system apps to be flagged as core apps.
5309            pkg.coreApp = false;
5310        }
5311
5312        if ((parseFlags&PackageParser.PARSE_IS_PRIVILEGED) != 0) {
5313            pkg.applicationInfo.privateFlags |= ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;
5314        }
5315
5316        if (mCustomResolverComponentName != null &&
5317                mCustomResolverComponentName.getPackageName().equals(pkg.packageName)) {
5318            setUpCustomResolverActivity(pkg);
5319        }
5320
5321        if (pkg.packageName.equals("android")) {
5322            synchronized (mPackages) {
5323                if (mAndroidApplication != null) {
5324                    Slog.w(TAG, "*************************************************");
5325                    Slog.w(TAG, "Core android package being redefined.  Skipping.");
5326                    Slog.w(TAG, " file=" + scanFile);
5327                    Slog.w(TAG, "*************************************************");
5328                    throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
5329                            "Core android package being redefined.  Skipping.");
5330                }
5331
5332                // Set up information for our fall-back user intent resolution activity.
5333                mPlatformPackage = pkg;
5334                pkg.mVersionCode = mSdkVersion;
5335                mAndroidApplication = pkg.applicationInfo;
5336
5337                if (!mResolverReplaced) {
5338                    mResolveActivity.applicationInfo = mAndroidApplication;
5339                    mResolveActivity.name = ResolverActivity.class.getName();
5340                    mResolveActivity.packageName = mAndroidApplication.packageName;
5341                    mResolveActivity.processName = "system:ui";
5342                    mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
5343                    mResolveActivity.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NEVER;
5344                    mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
5345                    mResolveActivity.theme = R.style.Theme_Holo_Dialog_Alert;
5346                    mResolveActivity.exported = true;
5347                    mResolveActivity.enabled = true;
5348                    mResolveInfo.activityInfo = mResolveActivity;
5349                    mResolveInfo.priority = 0;
5350                    mResolveInfo.preferredOrder = 0;
5351                    mResolveInfo.match = 0;
5352                    mResolveComponentName = new ComponentName(
5353                            mAndroidApplication.packageName, mResolveActivity.name);
5354                }
5355            }
5356        }
5357
5358        if (DEBUG_PACKAGE_SCANNING) {
5359            if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5360                Log.d(TAG, "Scanning package " + pkg.packageName);
5361        }
5362
5363        if (mPackages.containsKey(pkg.packageName)
5364                || mSharedLibraries.containsKey(pkg.packageName)) {
5365            throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
5366                    "Application package " + pkg.packageName
5367                    + " already installed.  Skipping duplicate.");
5368        }
5369
5370        // Initialize package source and resource directories
5371        File destCodeFile = new File(pkg.applicationInfo.getCodePath());
5372        File destResourceFile = new File(pkg.applicationInfo.getResourcePath());
5373
5374        SharedUserSetting suid = null;
5375        PackageSetting pkgSetting = null;
5376
5377        if (!isSystemApp(pkg)) {
5378            // Only system apps can use these features.
5379            pkg.mOriginalPackages = null;
5380            pkg.mRealPackage = null;
5381            pkg.mAdoptPermissions = null;
5382        }
5383
5384        // writer
5385        synchronized (mPackages) {
5386            if (pkg.mSharedUserId != null) {
5387                suid = mSettings.getSharedUserLPw(pkg.mSharedUserId, 0, 0, true);
5388                if (suid == null) {
5389                    throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5390                            "Creating application package " + pkg.packageName
5391                            + " for shared user failed");
5392                }
5393                if (DEBUG_PACKAGE_SCANNING) {
5394                    if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5395                        Log.d(TAG, "Shared UserID " + pkg.mSharedUserId + " (uid=" + suid.userId
5396                                + "): packages=" + suid.packages);
5397                }
5398            }
5399
5400            // Check if we are renaming from an original package name.
5401            PackageSetting origPackage = null;
5402            String realName = null;
5403            if (pkg.mOriginalPackages != null) {
5404                // This package may need to be renamed to a previously
5405                // installed name.  Let's check on that...
5406                final String renamed = mSettings.mRenamedPackages.get(pkg.mRealPackage);
5407                if (pkg.mOriginalPackages.contains(renamed)) {
5408                    // This package had originally been installed as the
5409                    // original name, and we have already taken care of
5410                    // transitioning to the new one.  Just update the new
5411                    // one to continue using the old name.
5412                    realName = pkg.mRealPackage;
5413                    if (!pkg.packageName.equals(renamed)) {
5414                        // Callers into this function may have already taken
5415                        // care of renaming the package; only do it here if
5416                        // it is not already done.
5417                        pkg.setPackageName(renamed);
5418                    }
5419
5420                } else {
5421                    for (int i=pkg.mOriginalPackages.size()-1; i>=0; i--) {
5422                        if ((origPackage = mSettings.peekPackageLPr(
5423                                pkg.mOriginalPackages.get(i))) != null) {
5424                            // We do have the package already installed under its
5425                            // original name...  should we use it?
5426                            if (!verifyPackageUpdateLPr(origPackage, pkg)) {
5427                                // New package is not compatible with original.
5428                                origPackage = null;
5429                                continue;
5430                            } else if (origPackage.sharedUser != null) {
5431                                // Make sure uid is compatible between packages.
5432                                if (!origPackage.sharedUser.name.equals(pkg.mSharedUserId)) {
5433                                    Slog.w(TAG, "Unable to migrate data from " + origPackage.name
5434                                            + " to " + pkg.packageName + ": old uid "
5435                                            + origPackage.sharedUser.name
5436                                            + " differs from " + pkg.mSharedUserId);
5437                                    origPackage = null;
5438                                    continue;
5439                                }
5440                            } else {
5441                                if (DEBUG_UPGRADE) Log.v(TAG, "Renaming new package "
5442                                        + pkg.packageName + " to old name " + origPackage.name);
5443                            }
5444                            break;
5445                        }
5446                    }
5447                }
5448            }
5449
5450            if (mTransferedPackages.contains(pkg.packageName)) {
5451                Slog.w(TAG, "Package " + pkg.packageName
5452                        + " was transferred to another, but its .apk remains");
5453            }
5454
5455            // Just create the setting, don't add it yet. For already existing packages
5456            // the PkgSetting exists already and doesn't have to be created.
5457            pkgSetting = mSettings.getPackageLPw(pkg, origPackage, realName, suid, destCodeFile,
5458                    destResourceFile, pkg.applicationInfo.nativeLibraryRootDir,
5459                    pkg.applicationInfo.primaryCpuAbi,
5460                    pkg.applicationInfo.secondaryCpuAbi,
5461                    pkg.applicationInfo.flags, pkg.applicationInfo.privateFlags,
5462                    user, false);
5463            if (pkgSetting == null) {
5464                throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5465                        "Creating application package " + pkg.packageName + " failed");
5466            }
5467
5468            if (pkgSetting.origPackage != null) {
5469                // If we are first transitioning from an original package,
5470                // fix up the new package's name now.  We need to do this after
5471                // looking up the package under its new name, so getPackageLP
5472                // can take care of fiddling things correctly.
5473                pkg.setPackageName(origPackage.name);
5474
5475                // File a report about this.
5476                String msg = "New package " + pkgSetting.realName
5477                        + " renamed to replace old package " + pkgSetting.name;
5478                reportSettingsProblem(Log.WARN, msg);
5479
5480                // Make a note of it.
5481                mTransferedPackages.add(origPackage.name);
5482
5483                // No longer need to retain this.
5484                pkgSetting.origPackage = null;
5485            }
5486
5487            if (realName != null) {
5488                // Make a note of it.
5489                mTransferedPackages.add(pkg.packageName);
5490            }
5491
5492            if (mSettings.isDisabledSystemPackageLPr(pkg.packageName)) {
5493                pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
5494            }
5495
5496            if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
5497                // Check all shared libraries and map to their actual file path.
5498                // We only do this here for apps not on a system dir, because those
5499                // are the only ones that can fail an install due to this.  We
5500                // will take care of the system apps by updating all of their
5501                // library paths after the scan is done.
5502                updateSharedLibrariesLPw(pkg, null);
5503            }
5504
5505            if (mFoundPolicyFile) {
5506                SELinuxMMAC.assignSeinfoValue(pkg);
5507            }
5508
5509            pkg.applicationInfo.uid = pkgSetting.appId;
5510            pkg.mExtras = pkgSetting;
5511            if (!pkgSetting.keySetData.isUsingUpgradeKeySets() || pkgSetting.sharedUser != null) {
5512                try {
5513                    verifySignaturesLP(pkgSetting, pkg);
5514                    // We just determined the app is signed correctly, so bring
5515                    // over the latest parsed certs.
5516                    pkgSetting.signatures.mSignatures = pkg.mSignatures;
5517                } catch (PackageManagerException e) {
5518                    if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
5519                        throw e;
5520                    }
5521                    // The signature has changed, but this package is in the system
5522                    // image...  let's recover!
5523                    pkgSetting.signatures.mSignatures = pkg.mSignatures;
5524                    // However...  if this package is part of a shared user, but it
5525                    // doesn't match the signature of the shared user, let's fail.
5526                    // What this means is that you can't change the signatures
5527                    // associated with an overall shared user, which doesn't seem all
5528                    // that unreasonable.
5529                    if (pkgSetting.sharedUser != null) {
5530                        if (compareSignatures(pkgSetting.sharedUser.signatures.mSignatures,
5531                                              pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {
5532                            throw new PackageManagerException(
5533                                    INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
5534                                            "Signature mismatch for shared user : "
5535                                            + pkgSetting.sharedUser);
5536                        }
5537                    }
5538                    // File a report about this.
5539                    String msg = "System package " + pkg.packageName
5540                        + " signature changed; retaining data.";
5541                    reportSettingsProblem(Log.WARN, msg);
5542                }
5543            } else {
5544                if (!checkUpgradeKeySetLP(pkgSetting, pkg)) {
5545                    throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
5546                            + pkg.packageName + " upgrade keys do not match the "
5547                            + "previously installed version");
5548                } else {
5549                    // We just determined the app is signed correctly, so bring
5550                    // over the latest parsed certs.
5551                    pkgSetting.signatures.mSignatures = pkg.mSignatures;
5552                }
5553            }
5554            // Verify that this new package doesn't have any content providers
5555            // that conflict with existing packages.  Only do this if the
5556            // package isn't already installed, since we don't want to break
5557            // things that are installed.
5558            if ((scanFlags & SCAN_NEW_INSTALL) != 0) {
5559                final int N = pkg.providers.size();
5560                int i;
5561                for (i=0; i<N; i++) {
5562                    PackageParser.Provider p = pkg.providers.get(i);
5563                    if (p.info.authority != null) {
5564                        String names[] = p.info.authority.split(";");
5565                        for (int j = 0; j < names.length; j++) {
5566                            if (mProvidersByAuthority.containsKey(names[j])) {
5567                                PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
5568                                final String otherPackageName =
5569                                        ((other != null && other.getComponentName() != null) ?
5570                                                other.getComponentName().getPackageName() : "?");
5571                                throw new PackageManagerException(
5572                                        INSTALL_FAILED_CONFLICTING_PROVIDER,
5573                                                "Can't install because provider name " + names[j]
5574                                                + " (in package " + pkg.applicationInfo.packageName
5575                                                + ") is already used by " + otherPackageName);
5576                            }
5577                        }
5578                    }
5579                }
5580            }
5581
5582            if (pkg.mAdoptPermissions != null) {
5583                // This package wants to adopt ownership of permissions from
5584                // another package.
5585                for (int i = pkg.mAdoptPermissions.size() - 1; i >= 0; i--) {
5586                    final String origName = pkg.mAdoptPermissions.get(i);
5587                    final PackageSetting orig = mSettings.peekPackageLPr(origName);
5588                    if (orig != null) {
5589                        if (verifyPackageUpdateLPr(orig, pkg)) {
5590                            Slog.i(TAG, "Adopting permissions from " + origName + " to "
5591                                    + pkg.packageName);
5592                            mSettings.transferPermissionsLPw(origName, pkg.packageName);
5593                        }
5594                    }
5595                }
5596            }
5597        }
5598
5599        final String pkgName = pkg.packageName;
5600
5601        final long scanFileTime = scanFile.lastModified();
5602        final boolean forceDex = (scanFlags & SCAN_FORCE_DEX) != 0;
5603        pkg.applicationInfo.processName = fixProcessName(
5604                pkg.applicationInfo.packageName,
5605                pkg.applicationInfo.processName,
5606                pkg.applicationInfo.uid);
5607
5608        File dataPath;
5609        if (mPlatformPackage == pkg) {
5610            // The system package is special.
5611            dataPath = new File(Environment.getDataDirectory(), "system");
5612
5613            pkg.applicationInfo.dataDir = dataPath.getPath();
5614
5615        } else {
5616            // This is a normal package, need to make its data directory.
5617            dataPath = getDataPathForPackage(pkg.packageName, 0);
5618
5619            boolean uidError = false;
5620            if (dataPath.exists()) {
5621                int currentUid = 0;
5622                try {
5623                    StructStat stat = Os.stat(dataPath.getPath());
5624                    currentUid = stat.st_uid;
5625                } catch (ErrnoException e) {
5626                    Slog.e(TAG, "Couldn't stat path " + dataPath.getPath(), e);
5627                }
5628
5629                // If we have mismatched owners for the data path, we have a problem.
5630                if (currentUid != pkg.applicationInfo.uid) {
5631                    boolean recovered = false;
5632                    if (currentUid == 0) {
5633                        // The directory somehow became owned by root.  Wow.
5634                        // This is probably because the system was stopped while
5635                        // installd was in the middle of messing with its libs
5636                        // directory.  Ask installd to fix that.
5637                        int ret = mInstaller.fixUid(pkgName, pkg.applicationInfo.uid,
5638                                pkg.applicationInfo.uid);
5639                        if (ret >= 0) {
5640                            recovered = true;
5641                            String msg = "Package " + pkg.packageName
5642                                    + " unexpectedly changed to uid 0; recovered to " +
5643                                    + pkg.applicationInfo.uid;
5644                            reportSettingsProblem(Log.WARN, msg);
5645                        }
5646                    }
5647                    if (!recovered && ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
5648                            || (scanFlags&SCAN_BOOTING) != 0)) {
5649                        // If this is a system app, we can at least delete its
5650                        // current data so the application will still work.
5651                        int ret = removeDataDirsLI(pkgName);
5652                        if (ret >= 0) {
5653                            // TODO: Kill the processes first
5654                            // Old data gone!
5655                            String prefix = (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
5656                                    ? "System package " : "Third party package ";
5657                            String msg = prefix + pkg.packageName
5658                                    + " has changed from uid: "
5659                                    + currentUid + " to "
5660                                    + pkg.applicationInfo.uid + "; old data erased";
5661                            reportSettingsProblem(Log.WARN, msg);
5662                            recovered = true;
5663
5664                            // And now re-install the app.
5665                            ret = createDataDirsLI(pkgName, pkg.applicationInfo.uid,
5666                                                   pkg.applicationInfo.seinfo);
5667                            if (ret == -1) {
5668                                // Ack should not happen!
5669                                msg = prefix + pkg.packageName
5670                                        + " could not have data directory re-created after delete.";
5671                                reportSettingsProblem(Log.WARN, msg);
5672                                throw new PackageManagerException(
5673                                        INSTALL_FAILED_INSUFFICIENT_STORAGE, msg);
5674                            }
5675                        }
5676                        if (!recovered) {
5677                            mHasSystemUidErrors = true;
5678                        }
5679                    } else if (!recovered) {
5680                        // If we allow this install to proceed, we will be broken.
5681                        // Abort, abort!
5682                        throw new PackageManagerException(INSTALL_FAILED_UID_CHANGED,
5683                                "scanPackageLI");
5684                    }
5685                    if (!recovered) {
5686                        pkg.applicationInfo.dataDir = "/mismatched_uid/settings_"
5687                            + pkg.applicationInfo.uid + "/fs_"
5688                            + currentUid;
5689                        pkg.applicationInfo.nativeLibraryDir = pkg.applicationInfo.dataDir;
5690                        pkg.applicationInfo.nativeLibraryRootDir = pkg.applicationInfo.dataDir;
5691                        String msg = "Package " + pkg.packageName
5692                                + " has mismatched uid: "
5693                                + currentUid + " on disk, "
5694                                + pkg.applicationInfo.uid + " in settings";
5695                        // writer
5696                        synchronized (mPackages) {
5697                            mSettings.mReadMessages.append(msg);
5698                            mSettings.mReadMessages.append('\n');
5699                            uidError = true;
5700                            if (!pkgSetting.uidError) {
5701                                reportSettingsProblem(Log.ERROR, msg);
5702                            }
5703                        }
5704                    }
5705                }
5706                pkg.applicationInfo.dataDir = dataPath.getPath();
5707                if (mShouldRestoreconData) {
5708                    Slog.i(TAG, "SELinux relabeling of " + pkg.packageName + " issued.");
5709                    mInstaller.restoreconData(pkg.packageName, pkg.applicationInfo.seinfo,
5710                                pkg.applicationInfo.uid);
5711                }
5712            } else {
5713                if (DEBUG_PACKAGE_SCANNING) {
5714                    if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5715                        Log.v(TAG, "Want this data dir: " + dataPath);
5716                }
5717                //invoke installer to do the actual installation
5718                int ret = createDataDirsLI(pkgName, pkg.applicationInfo.uid,
5719                                           pkg.applicationInfo.seinfo);
5720                if (ret < 0) {
5721                    // Error from installer
5722                    throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5723                            "Unable to create data dirs [errorCode=" + ret + "]");
5724                }
5725
5726                if (dataPath.exists()) {
5727                    pkg.applicationInfo.dataDir = dataPath.getPath();
5728                } else {
5729                    Slog.w(TAG, "Unable to create data directory: " + dataPath);
5730                    pkg.applicationInfo.dataDir = null;
5731                }
5732            }
5733
5734            pkgSetting.uidError = uidError;
5735        }
5736
5737        final String path = scanFile.getPath();
5738        final String codePath = pkg.applicationInfo.getCodePath();
5739        final String cpuAbiOverride = deriveAbiOverride(pkg.cpuAbiOverride, pkgSetting);
5740        if (isSystemApp(pkg) && !isUpdatedSystemApp(pkg)) {
5741            setBundledAppAbisAndRoots(pkg, pkgSetting);
5742
5743            // If we haven't found any native libraries for the app, check if it has
5744            // renderscript code. We'll need to force the app to 32 bit if it has
5745            // renderscript bitcode.
5746            if (pkg.applicationInfo.primaryCpuAbi == null
5747                    && pkg.applicationInfo.secondaryCpuAbi == null
5748                    && Build.SUPPORTED_64_BIT_ABIS.length >  0) {
5749                NativeLibraryHelper.Handle handle = null;
5750                try {
5751                    handle = NativeLibraryHelper.Handle.create(scanFile);
5752                    if (NativeLibraryHelper.hasRenderscriptBitcode(handle)) {
5753                        pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
5754                    }
5755                } catch (IOException ioe) {
5756                    Slog.w(TAG, "Error scanning system app : " + ioe);
5757                } finally {
5758                    IoUtils.closeQuietly(handle);
5759                }
5760            }
5761
5762            setNativeLibraryPaths(pkg);
5763        } else {
5764            // TODO: We can probably be smarter about this stuff. For installed apps,
5765            // we can calculate this information at install time once and for all. For
5766            // system apps, we can probably assume that this information doesn't change
5767            // after the first boot scan. As things stand, we do lots of unnecessary work.
5768
5769            // Give ourselves some initial paths; we'll come back for another
5770            // pass once we've determined ABI below.
5771            setNativeLibraryPaths(pkg);
5772
5773            final boolean isAsec = isForwardLocked(pkg) || isExternal(pkg);
5774            final String nativeLibraryRootStr = pkg.applicationInfo.nativeLibraryRootDir;
5775            final boolean useIsaSpecificSubdirs = pkg.applicationInfo.nativeLibraryRootRequiresIsa;
5776
5777            NativeLibraryHelper.Handle handle = null;
5778            try {
5779                handle = NativeLibraryHelper.Handle.create(scanFile);
5780                // TODO(multiArch): This can be null for apps that didn't go through the
5781                // usual installation process. We can calculate it again, like we
5782                // do during install time.
5783                //
5784                // TODO(multiArch): Why do we need to rescan ASEC apps again ? It seems totally
5785                // unnecessary.
5786                final File nativeLibraryRoot = new File(nativeLibraryRootStr);
5787
5788                // Null out the abis so that they can be recalculated.
5789                pkg.applicationInfo.primaryCpuAbi = null;
5790                pkg.applicationInfo.secondaryCpuAbi = null;
5791                if (isMultiArch(pkg.applicationInfo)) {
5792                    // Warn if we've set an abiOverride for multi-lib packages..
5793                    // By definition, we need to copy both 32 and 64 bit libraries for
5794                    // such packages.
5795                    if (pkg.cpuAbiOverride != null
5796                            && !NativeLibraryHelper.CLEAR_ABI_OVERRIDE.equals(pkg.cpuAbiOverride)) {
5797                        Slog.w(TAG, "Ignoring abiOverride for multi arch application.");
5798                    }
5799
5800                    int abi32 = PackageManager.NO_NATIVE_LIBRARIES;
5801                    int abi64 = PackageManager.NO_NATIVE_LIBRARIES;
5802                    if (Build.SUPPORTED_32_BIT_ABIS.length > 0) {
5803                        if (isAsec) {
5804                            abi32 = NativeLibraryHelper.findSupportedAbi(handle, Build.SUPPORTED_32_BIT_ABIS);
5805                        } else {
5806                            abi32 = NativeLibraryHelper.copyNativeBinariesForSupportedAbi(handle,
5807                                    nativeLibraryRoot, Build.SUPPORTED_32_BIT_ABIS,
5808                                    useIsaSpecificSubdirs);
5809                        }
5810                    }
5811
5812                    maybeThrowExceptionForMultiArchCopy(
5813                            "Error unpackaging 32 bit native libs for multiarch app.", abi32);
5814
5815                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0) {
5816                        if (isAsec) {
5817                            abi64 = NativeLibraryHelper.findSupportedAbi(handle, Build.SUPPORTED_64_BIT_ABIS);
5818                        } else {
5819                            abi64 = NativeLibraryHelper.copyNativeBinariesForSupportedAbi(handle,
5820                                    nativeLibraryRoot, Build.SUPPORTED_64_BIT_ABIS,
5821                                    useIsaSpecificSubdirs);
5822                        }
5823                    }
5824
5825                    maybeThrowExceptionForMultiArchCopy(
5826                            "Error unpackaging 64 bit native libs for multiarch app.", abi64);
5827
5828                    if (abi64 >= 0) {
5829                        pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[abi64];
5830                    }
5831
5832                    if (abi32 >= 0) {
5833                        final String abi = Build.SUPPORTED_32_BIT_ABIS[abi32];
5834                        if (abi64 >= 0) {
5835                            pkg.applicationInfo.secondaryCpuAbi = abi;
5836                        } else {
5837                            pkg.applicationInfo.primaryCpuAbi = abi;
5838                        }
5839                    }
5840                } else {
5841                    String[] abiList = (cpuAbiOverride != null) ?
5842                            new String[] { cpuAbiOverride } : Build.SUPPORTED_ABIS;
5843
5844                    // Enable gross and lame hacks for apps that are built with old
5845                    // SDK tools. We must scan their APKs for renderscript bitcode and
5846                    // not launch them if it's present. Don't bother checking on devices
5847                    // that don't have 64 bit support.
5848                    boolean needsRenderScriptOverride = false;
5849                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0 && cpuAbiOverride == null &&
5850                            NativeLibraryHelper.hasRenderscriptBitcode(handle)) {
5851                        abiList = Build.SUPPORTED_32_BIT_ABIS;
5852                        needsRenderScriptOverride = true;
5853                    }
5854
5855                    final int copyRet;
5856                    if (isAsec) {
5857                        copyRet = NativeLibraryHelper.findSupportedAbi(handle, abiList);
5858                    } else {
5859                        copyRet = NativeLibraryHelper.copyNativeBinariesForSupportedAbi(handle,
5860                                nativeLibraryRoot, abiList, useIsaSpecificSubdirs);
5861                    }
5862
5863                    if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES) {
5864                        throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
5865                                "Error unpackaging native libs for app, errorCode=" + copyRet);
5866                    }
5867
5868                    if (copyRet >= 0) {
5869                        pkg.applicationInfo.primaryCpuAbi = abiList[copyRet];
5870                    } else if (copyRet == PackageManager.NO_NATIVE_LIBRARIES && cpuAbiOverride != null) {
5871                        pkg.applicationInfo.primaryCpuAbi = cpuAbiOverride;
5872                    } else if (needsRenderScriptOverride) {
5873                        pkg.applicationInfo.primaryCpuAbi = abiList[0];
5874                    }
5875                }
5876            } catch (IOException ioe) {
5877                Slog.e(TAG, "Unable to get canonical file " + ioe.toString());
5878            } finally {
5879                IoUtils.closeQuietly(handle);
5880            }
5881
5882            // Now that we've calculated the ABIs and determined if it's an internal app,
5883            // we will go ahead and populate the nativeLibraryPath.
5884            setNativeLibraryPaths(pkg);
5885
5886            if (DEBUG_INSTALL) Slog.i(TAG, "Linking native library dir for " + path);
5887            final int[] userIds = sUserManager.getUserIds();
5888            synchronized (mInstallLock) {
5889                // Create a native library symlink only if we have native libraries
5890                // and if the native libraries are 32 bit libraries. We do not provide
5891                // this symlink for 64 bit libraries.
5892                if (pkg.applicationInfo.primaryCpuAbi != null &&
5893                        !VMRuntime.is64BitAbi(pkg.applicationInfo.primaryCpuAbi)) {
5894                    final String nativeLibPath = pkg.applicationInfo.nativeLibraryDir;
5895                    for (int userId : userIds) {
5896                        if (mInstaller.linkNativeLibraryDirectory(pkg.packageName, nativeLibPath, userId) < 0) {
5897                            throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
5898                                    "Failed linking native library dir (user=" + userId + ")");
5899                        }
5900                    }
5901                }
5902            }
5903        }
5904
5905        // This is a special case for the "system" package, where the ABI is
5906        // dictated by the zygote configuration (and init.rc). We should keep track
5907        // of this ABI so that we can deal with "normal" applications that run under
5908        // the same UID correctly.
5909        if (mPlatformPackage == pkg) {
5910            pkg.applicationInfo.primaryCpuAbi = VMRuntime.getRuntime().is64Bit() ?
5911                    Build.SUPPORTED_64_BIT_ABIS[0] : Build.SUPPORTED_32_BIT_ABIS[0];
5912        }
5913
5914        pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
5915        pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
5916        pkgSetting.cpuAbiOverrideString = cpuAbiOverride;
5917        // Copy the derived override back to the parsed package, so that we can
5918        // update the package settings accordingly.
5919        pkg.cpuAbiOverride = cpuAbiOverride;
5920
5921        if (DEBUG_ABI_SELECTION) {
5922            Slog.d(TAG, "Resolved nativeLibraryRoot for " + pkg.applicationInfo.packageName
5923                    + " to root=" + pkg.applicationInfo.nativeLibraryRootDir + ", isa="
5924                    + pkg.applicationInfo.nativeLibraryRootRequiresIsa);
5925        }
5926
5927        // Push the derived path down into PackageSettings so we know what to
5928        // clean up at uninstall time.
5929        pkgSetting.legacyNativeLibraryPathString = pkg.applicationInfo.nativeLibraryRootDir;
5930
5931        if (DEBUG_ABI_SELECTION) {
5932            Log.d(TAG, "Abis for package[" + pkg.packageName + "] are" +
5933                    " primary=" + pkg.applicationInfo.primaryCpuAbi +
5934                    " secondary=" + pkg.applicationInfo.secondaryCpuAbi);
5935        }
5936
5937        if ((scanFlags&SCAN_BOOTING) == 0 && pkgSetting.sharedUser != null) {
5938            // We don't do this here during boot because we can do it all
5939            // at once after scanning all existing packages.
5940            //
5941            // We also do this *before* we perform dexopt on this package, so that
5942            // we can avoid redundant dexopts, and also to make sure we've got the
5943            // code and package path correct.
5944            adjustCpuAbisForSharedUserLPw(pkgSetting.sharedUser.packages,
5945                    pkg, forceDex, (scanFlags & SCAN_DEFER_DEX) != 0);
5946        }
5947
5948        if ((scanFlags & SCAN_NO_DEX) == 0) {
5949            if (performDexOptLI(pkg, null /* instruction sets */, forceDex,
5950                    (scanFlags & SCAN_DEFER_DEX) != 0, false) == DEX_OPT_FAILED) {
5951                throw new PackageManagerException(INSTALL_FAILED_DEXOPT, "scanPackageLI");
5952            }
5953        }
5954
5955        if (mFactoryTest && pkg.requestedPermissions.contains(
5956                android.Manifest.permission.FACTORY_TEST)) {
5957            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_FACTORY_TEST;
5958        }
5959
5960        ArrayList<PackageParser.Package> clientLibPkgs = null;
5961
5962        // writer
5963        synchronized (mPackages) {
5964            if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
5965                // Only system apps can add new shared libraries.
5966                if (pkg.libraryNames != null) {
5967                    for (int i=0; i<pkg.libraryNames.size(); i++) {
5968                        String name = pkg.libraryNames.get(i);
5969                        boolean allowed = false;
5970                        if (isUpdatedSystemApp(pkg)) {
5971                            // New library entries can only be added through the
5972                            // system image.  This is important to get rid of a lot
5973                            // of nasty edge cases: for example if we allowed a non-
5974                            // system update of the app to add a library, then uninstalling
5975                            // the update would make the library go away, and assumptions
5976                            // we made such as through app install filtering would now
5977                            // have allowed apps on the device which aren't compatible
5978                            // with it.  Better to just have the restriction here, be
5979                            // conservative, and create many fewer cases that can negatively
5980                            // impact the user experience.
5981                            final PackageSetting sysPs = mSettings
5982                                    .getDisabledSystemPkgLPr(pkg.packageName);
5983                            if (sysPs.pkg != null && sysPs.pkg.libraryNames != null) {
5984                                for (int j=0; j<sysPs.pkg.libraryNames.size(); j++) {
5985                                    if (name.equals(sysPs.pkg.libraryNames.get(j))) {
5986                                        allowed = true;
5987                                        allowed = true;
5988                                        break;
5989                                    }
5990                                }
5991                            }
5992                        } else {
5993                            allowed = true;
5994                        }
5995                        if (allowed) {
5996                            if (!mSharedLibraries.containsKey(name)) {
5997                                mSharedLibraries.put(name, new SharedLibraryEntry(null, pkg.packageName));
5998                            } else if (!name.equals(pkg.packageName)) {
5999                                Slog.w(TAG, "Package " + pkg.packageName + " library "
6000                                        + name + " already exists; skipping");
6001                            }
6002                        } else {
6003                            Slog.w(TAG, "Package " + pkg.packageName + " declares lib "
6004                                    + name + " that is not declared on system image; skipping");
6005                        }
6006                    }
6007                    if ((scanFlags&SCAN_BOOTING) == 0) {
6008                        // If we are not booting, we need to update any applications
6009                        // that are clients of our shared library.  If we are booting,
6010                        // this will all be done once the scan is complete.
6011                        clientLibPkgs = updateAllSharedLibrariesLPw(pkg);
6012                    }
6013                }
6014            }
6015        }
6016
6017        // We also need to dexopt any apps that are dependent on this library.  Note that
6018        // if these fail, we should abort the install since installing the library will
6019        // result in some apps being broken.
6020        if (clientLibPkgs != null) {
6021            if ((scanFlags & SCAN_NO_DEX) == 0) {
6022                for (int i = 0; i < clientLibPkgs.size(); i++) {
6023                    PackageParser.Package clientPkg = clientLibPkgs.get(i);
6024                    if (performDexOptLI(clientPkg, null /* instruction sets */, forceDex,
6025                            (scanFlags & SCAN_DEFER_DEX) != 0, false) == DEX_OPT_FAILED) {
6026                        throw new PackageManagerException(INSTALL_FAILED_DEXOPT,
6027                                "scanPackageLI failed to dexopt clientLibPkgs");
6028                    }
6029                }
6030            }
6031        }
6032
6033        // Request the ActivityManager to kill the process(only for existing packages)
6034        // so that we do not end up in a confused state while the user is still using the older
6035        // version of the application while the new one gets installed.
6036        if ((scanFlags & SCAN_REPLACING) != 0) {
6037            killApplication(pkg.applicationInfo.packageName,
6038                        pkg.applicationInfo.uid, "update pkg");
6039        }
6040
6041        // Also need to kill any apps that are dependent on the library.
6042        if (clientLibPkgs != null) {
6043            for (int i=0; i<clientLibPkgs.size(); i++) {
6044                PackageParser.Package clientPkg = clientLibPkgs.get(i);
6045                killApplication(clientPkg.applicationInfo.packageName,
6046                        clientPkg.applicationInfo.uid, "update lib");
6047            }
6048        }
6049
6050        // writer
6051        synchronized (mPackages) {
6052            // We don't expect installation to fail beyond this point
6053
6054            // Add the new setting to mSettings
6055            mSettings.insertPackageSettingLPw(pkgSetting, pkg);
6056            // Add the new setting to mPackages
6057            mPackages.put(pkg.applicationInfo.packageName, pkg);
6058            // Make sure we don't accidentally delete its data.
6059            final Iterator<PackageCleanItem> iter = mSettings.mPackagesToBeCleaned.iterator();
6060            while (iter.hasNext()) {
6061                PackageCleanItem item = iter.next();
6062                if (pkgName.equals(item.packageName)) {
6063                    iter.remove();
6064                }
6065            }
6066
6067            // Take care of first install / last update times.
6068            if (currentTime != 0) {
6069                if (pkgSetting.firstInstallTime == 0) {
6070                    pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = currentTime;
6071                } else if ((scanFlags&SCAN_UPDATE_TIME) != 0) {
6072                    pkgSetting.lastUpdateTime = currentTime;
6073                }
6074            } else if (pkgSetting.firstInstallTime == 0) {
6075                // We need *something*.  Take time time stamp of the file.
6076                pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = scanFileTime;
6077            } else if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) != 0) {
6078                if (scanFileTime != pkgSetting.timeStamp) {
6079                    // A package on the system image has changed; consider this
6080                    // to be an update.
6081                    pkgSetting.lastUpdateTime = scanFileTime;
6082                }
6083            }
6084
6085            // Add the package's KeySets to the global KeySetManagerService
6086            KeySetManagerService ksms = mSettings.mKeySetManagerService;
6087            try {
6088                // Old KeySetData no longer valid.
6089                ksms.removeAppKeySetDataLPw(pkg.packageName);
6090                ksms.addSigningKeySetToPackageLPw(pkg.packageName, pkg.mSigningKeys);
6091                if (pkg.mKeySetMapping != null) {
6092                    for (Map.Entry<String, ArraySet<PublicKey>> entry :
6093                            pkg.mKeySetMapping.entrySet()) {
6094                        if (entry.getValue() != null) {
6095                            ksms.addDefinedKeySetToPackageLPw(pkg.packageName,
6096                                                          entry.getValue(), entry.getKey());
6097                        }
6098                    }
6099                    if (pkg.mUpgradeKeySets != null) {
6100                        for (String upgradeAlias : pkg.mUpgradeKeySets) {
6101                            ksms.addUpgradeKeySetToPackageLPw(pkg.packageName, upgradeAlias);
6102                        }
6103                    }
6104                }
6105            } catch (NullPointerException e) {
6106                Slog.e(TAG, "Could not add KeySet to " + pkg.packageName, e);
6107            } catch (IllegalArgumentException e) {
6108                Slog.e(TAG, "Could not add KeySet to malformed package" + pkg.packageName, e);
6109            }
6110
6111            int N = pkg.providers.size();
6112            StringBuilder r = null;
6113            int i;
6114            for (i=0; i<N; i++) {
6115                PackageParser.Provider p = pkg.providers.get(i);
6116                p.info.processName = fixProcessName(pkg.applicationInfo.processName,
6117                        p.info.processName, pkg.applicationInfo.uid);
6118                mProviders.addProvider(p);
6119                p.syncable = p.info.isSyncable;
6120                if (p.info.authority != null) {
6121                    String names[] = p.info.authority.split(";");
6122                    p.info.authority = null;
6123                    for (int j = 0; j < names.length; j++) {
6124                        if (j == 1 && p.syncable) {
6125                            // We only want the first authority for a provider to possibly be
6126                            // syncable, so if we already added this provider using a different
6127                            // authority clear the syncable flag. We copy the provider before
6128                            // changing it because the mProviders object contains a reference
6129                            // to a provider that we don't want to change.
6130                            // Only do this for the second authority since the resulting provider
6131                            // object can be the same for all future authorities for this provider.
6132                            p = new PackageParser.Provider(p);
6133                            p.syncable = false;
6134                        }
6135                        if (!mProvidersByAuthority.containsKey(names[j])) {
6136                            mProvidersByAuthority.put(names[j], p);
6137                            if (p.info.authority == null) {
6138                                p.info.authority = names[j];
6139                            } else {
6140                                p.info.authority = p.info.authority + ";" + names[j];
6141                            }
6142                            if (DEBUG_PACKAGE_SCANNING) {
6143                                if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
6144                                    Log.d(TAG, "Registered content provider: " + names[j]
6145                                            + ", className = " + p.info.name + ", isSyncable = "
6146                                            + p.info.isSyncable);
6147                            }
6148                        } else {
6149                            PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
6150                            Slog.w(TAG, "Skipping provider name " + names[j] +
6151                                    " (in package " + pkg.applicationInfo.packageName +
6152                                    "): name already used by "
6153                                    + ((other != null && other.getComponentName() != null)
6154                                            ? other.getComponentName().getPackageName() : "?"));
6155                        }
6156                    }
6157                }
6158                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6159                    if (r == null) {
6160                        r = new StringBuilder(256);
6161                    } else {
6162                        r.append(' ');
6163                    }
6164                    r.append(p.info.name);
6165                }
6166            }
6167            if (r != null) {
6168                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Providers: " + r);
6169            }
6170
6171            N = pkg.services.size();
6172            r = null;
6173            for (i=0; i<N; i++) {
6174                PackageParser.Service s = pkg.services.get(i);
6175                s.info.processName = fixProcessName(pkg.applicationInfo.processName,
6176                        s.info.processName, pkg.applicationInfo.uid);
6177                mServices.addService(s);
6178                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6179                    if (r == null) {
6180                        r = new StringBuilder(256);
6181                    } else {
6182                        r.append(' ');
6183                    }
6184                    r.append(s.info.name);
6185                }
6186            }
6187            if (r != null) {
6188                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Services: " + r);
6189            }
6190
6191            N = pkg.receivers.size();
6192            r = null;
6193            for (i=0; i<N; i++) {
6194                PackageParser.Activity a = pkg.receivers.get(i);
6195                a.info.processName = fixProcessName(pkg.applicationInfo.processName,
6196                        a.info.processName, pkg.applicationInfo.uid);
6197                mReceivers.addActivity(a, "receiver");
6198                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6199                    if (r == null) {
6200                        r = new StringBuilder(256);
6201                    } else {
6202                        r.append(' ');
6203                    }
6204                    r.append(a.info.name);
6205                }
6206            }
6207            if (r != null) {
6208                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Receivers: " + r);
6209            }
6210
6211            N = pkg.activities.size();
6212            r = null;
6213            for (i=0; i<N; i++) {
6214                PackageParser.Activity a = pkg.activities.get(i);
6215                a.info.processName = fixProcessName(pkg.applicationInfo.processName,
6216                        a.info.processName, pkg.applicationInfo.uid);
6217                mActivities.addActivity(a, "activity");
6218                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6219                    if (r == null) {
6220                        r = new StringBuilder(256);
6221                    } else {
6222                        r.append(' ');
6223                    }
6224                    r.append(a.info.name);
6225                }
6226            }
6227            if (r != null) {
6228                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Activities: " + r);
6229            }
6230
6231            N = pkg.permissionGroups.size();
6232            r = null;
6233            for (i=0; i<N; i++) {
6234                PackageParser.PermissionGroup pg = pkg.permissionGroups.get(i);
6235                PackageParser.PermissionGroup cur = mPermissionGroups.get(pg.info.name);
6236                if (cur == null) {
6237                    mPermissionGroups.put(pg.info.name, pg);
6238                    if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6239                        if (r == null) {
6240                            r = new StringBuilder(256);
6241                        } else {
6242                            r.append(' ');
6243                        }
6244                        r.append(pg.info.name);
6245                    }
6246                } else {
6247                    Slog.w(TAG, "Permission group " + pg.info.name + " from package "
6248                            + pg.info.packageName + " ignored: original from "
6249                            + cur.info.packageName);
6250                    if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6251                        if (r == null) {
6252                            r = new StringBuilder(256);
6253                        } else {
6254                            r.append(' ');
6255                        }
6256                        r.append("DUP:");
6257                        r.append(pg.info.name);
6258                    }
6259                }
6260            }
6261            if (r != null) {
6262                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Permission Groups: " + r);
6263            }
6264
6265            N = pkg.permissions.size();
6266            r = null;
6267            for (i=0; i<N; i++) {
6268                PackageParser.Permission p = pkg.permissions.get(i);
6269                ArrayMap<String, BasePermission> permissionMap =
6270                        p.tree ? mSettings.mPermissionTrees
6271                        : mSettings.mPermissions;
6272                p.group = mPermissionGroups.get(p.info.group);
6273                if (p.info.group == null || p.group != null) {
6274                    BasePermission bp = permissionMap.get(p.info.name);
6275
6276                    // Allow system apps to redefine non-system permissions
6277                    if (bp != null && !Objects.equals(bp.sourcePackage, p.info.packageName)) {
6278                        final boolean currentOwnerIsSystem = (bp.perm != null
6279                                && isSystemApp(bp.perm.owner));
6280                        if (isSystemApp(p.owner)) {
6281                            if (bp.type == BasePermission.TYPE_BUILTIN && bp.perm == null) {
6282                                // It's a built-in permission and no owner, take ownership now
6283                                bp.packageSetting = pkgSetting;
6284                                bp.perm = p;
6285                                bp.uid = pkg.applicationInfo.uid;
6286                                bp.sourcePackage = p.info.packageName;
6287                            } else if (!currentOwnerIsSystem) {
6288                                String msg = "New decl " + p.owner + " of permission  "
6289                                        + p.info.name + " is system; overriding " + bp.sourcePackage;
6290                                reportSettingsProblem(Log.WARN, msg);
6291                                bp = null;
6292                            }
6293                        }
6294                    }
6295
6296                    if (bp == null) {
6297                        bp = new BasePermission(p.info.name, p.info.packageName,
6298                                BasePermission.TYPE_NORMAL);
6299                        permissionMap.put(p.info.name, bp);
6300                    }
6301
6302                    if (bp.perm == null) {
6303                        if (bp.sourcePackage == null
6304                                || bp.sourcePackage.equals(p.info.packageName)) {
6305                            BasePermission tree = findPermissionTreeLP(p.info.name);
6306                            if (tree == null
6307                                    || tree.sourcePackage.equals(p.info.packageName)) {
6308                                bp.packageSetting = pkgSetting;
6309                                bp.perm = p;
6310                                bp.uid = pkg.applicationInfo.uid;
6311                                bp.sourcePackage = p.info.packageName;
6312                                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6313                                    if (r == null) {
6314                                        r = new StringBuilder(256);
6315                                    } else {
6316                                        r.append(' ');
6317                                    }
6318                                    r.append(p.info.name);
6319                                }
6320                            } else {
6321                                Slog.w(TAG, "Permission " + p.info.name + " from package "
6322                                        + p.info.packageName + " ignored: base tree "
6323                                        + tree.name + " is from package "
6324                                        + tree.sourcePackage);
6325                            }
6326                        } else {
6327                            Slog.w(TAG, "Permission " + p.info.name + " from package "
6328                                    + p.info.packageName + " ignored: original from "
6329                                    + bp.sourcePackage);
6330                        }
6331                    } else if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6332                        if (r == null) {
6333                            r = new StringBuilder(256);
6334                        } else {
6335                            r.append(' ');
6336                        }
6337                        r.append("DUP:");
6338                        r.append(p.info.name);
6339                    }
6340                    if (bp.perm == p) {
6341                        bp.protectionLevel = p.info.protectionLevel;
6342                    }
6343                } else {
6344                    Slog.w(TAG, "Permission " + p.info.name + " from package "
6345                            + p.info.packageName + " ignored: no group "
6346                            + p.group);
6347                }
6348            }
6349            if (r != null) {
6350                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Permissions: " + r);
6351            }
6352
6353            N = pkg.instrumentation.size();
6354            r = null;
6355            for (i=0; i<N; i++) {
6356                PackageParser.Instrumentation a = pkg.instrumentation.get(i);
6357                a.info.packageName = pkg.applicationInfo.packageName;
6358                a.info.sourceDir = pkg.applicationInfo.sourceDir;
6359                a.info.publicSourceDir = pkg.applicationInfo.publicSourceDir;
6360                a.info.splitSourceDirs = pkg.applicationInfo.splitSourceDirs;
6361                a.info.splitPublicSourceDirs = pkg.applicationInfo.splitPublicSourceDirs;
6362                a.info.dataDir = pkg.applicationInfo.dataDir;
6363
6364                // TODO: Update instrumentation.nativeLibraryDir as well ? Does it
6365                // need other information about the application, like the ABI and what not ?
6366                a.info.nativeLibraryDir = pkg.applicationInfo.nativeLibraryDir;
6367                mInstrumentation.put(a.getComponentName(), a);
6368                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
6369                    if (r == null) {
6370                        r = new StringBuilder(256);
6371                    } else {
6372                        r.append(' ');
6373                    }
6374                    r.append(a.info.name);
6375                }
6376            }
6377            if (r != null) {
6378                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Instrumentation: " + r);
6379            }
6380
6381            if (pkg.protectedBroadcasts != null) {
6382                N = pkg.protectedBroadcasts.size();
6383                for (i=0; i<N; i++) {
6384                    mProtectedBroadcasts.add(pkg.protectedBroadcasts.get(i));
6385                }
6386            }
6387
6388            pkgSetting.setTimeStamp(scanFileTime);
6389
6390            // Create idmap files for pairs of (packages, overlay packages).
6391            // Note: "android", ie framework-res.apk, is handled by native layers.
6392            if (pkg.mOverlayTarget != null) {
6393                // This is an overlay package.
6394                if (pkg.mOverlayTarget != null && !pkg.mOverlayTarget.equals("android")) {
6395                    if (!mOverlays.containsKey(pkg.mOverlayTarget)) {
6396                        mOverlays.put(pkg.mOverlayTarget,
6397                                new ArrayMap<String, PackageParser.Package>());
6398                    }
6399                    ArrayMap<String, PackageParser.Package> map = mOverlays.get(pkg.mOverlayTarget);
6400                    map.put(pkg.packageName, pkg);
6401                    PackageParser.Package orig = mPackages.get(pkg.mOverlayTarget);
6402                    if (orig != null && !createIdmapForPackagePairLI(orig, pkg)) {
6403                        throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
6404                                "scanPackageLI failed to createIdmap");
6405                    }
6406                }
6407            } else if (mOverlays.containsKey(pkg.packageName) &&
6408                    !pkg.packageName.equals("android")) {
6409                // This is a regular package, with one or more known overlay packages.
6410                createIdmapsForPackageLI(pkg);
6411            }
6412        }
6413
6414        return pkg;
6415    }
6416
6417    /**
6418     * Adjusts ABIs for a set of packages belonging to a shared user so that they all match.
6419     * i.e, so that all packages can be run inside a single process if required.
6420     *
6421     * Optionally, callers can pass in a parsed package via {@code newPackage} in which case
6422     * this function will either try and make the ABI for all packages in {@code packagesForUser}
6423     * match {@code scannedPackage} or will update the ABI of {@code scannedPackage} to match
6424     * the ABI selected for {@code packagesForUser}. This variant is used when installing or
6425     * updating a package that belongs to a shared user.
6426     *
6427     * NOTE: We currently only match for the primary CPU abi string. Matching the secondary
6428     * adds unnecessary complexity.
6429     */
6430    private void adjustCpuAbisForSharedUserLPw(Set<PackageSetting> packagesForUser,
6431            PackageParser.Package scannedPackage, boolean forceDexOpt, boolean deferDexOpt) {
6432        String requiredInstructionSet = null;
6433        if (scannedPackage != null && scannedPackage.applicationInfo.primaryCpuAbi != null) {
6434            requiredInstructionSet = VMRuntime.getInstructionSet(
6435                     scannedPackage.applicationInfo.primaryCpuAbi);
6436        }
6437
6438        PackageSetting requirer = null;
6439        for (PackageSetting ps : packagesForUser) {
6440            // If packagesForUser contains scannedPackage, we skip it. This will happen
6441            // when scannedPackage is an update of an existing package. Without this check,
6442            // we will never be able to change the ABI of any package belonging to a shared
6443            // user, even if it's compatible with other packages.
6444            if (scannedPackage == null || !scannedPackage.packageName.equals(ps.name)) {
6445                if (ps.primaryCpuAbiString == null) {
6446                    continue;
6447                }
6448
6449                final String instructionSet = VMRuntime.getInstructionSet(ps.primaryCpuAbiString);
6450                if (requiredInstructionSet != null && !instructionSet.equals(requiredInstructionSet)) {
6451                    // We have a mismatch between instruction sets (say arm vs arm64) warn about
6452                    // this but there's not much we can do.
6453                    String errorMessage = "Instruction set mismatch, "
6454                            + ((requirer == null) ? "[caller]" : requirer)
6455                            + " requires " + requiredInstructionSet + " whereas " + ps
6456                            + " requires " + instructionSet;
6457                    Slog.w(TAG, errorMessage);
6458                }
6459
6460                if (requiredInstructionSet == null) {
6461                    requiredInstructionSet = instructionSet;
6462                    requirer = ps;
6463                }
6464            }
6465        }
6466
6467        if (requiredInstructionSet != null) {
6468            String adjustedAbi;
6469            if (requirer != null) {
6470                // requirer != null implies that either scannedPackage was null or that scannedPackage
6471                // did not require an ABI, in which case we have to adjust scannedPackage to match
6472                // the ABI of the set (which is the same as requirer's ABI)
6473                adjustedAbi = requirer.primaryCpuAbiString;
6474                if (scannedPackage != null) {
6475                    scannedPackage.applicationInfo.primaryCpuAbi = adjustedAbi;
6476                }
6477            } else {
6478                // requirer == null implies that we're updating all ABIs in the set to
6479                // match scannedPackage.
6480                adjustedAbi =  scannedPackage.applicationInfo.primaryCpuAbi;
6481            }
6482
6483            for (PackageSetting ps : packagesForUser) {
6484                if (scannedPackage == null || !scannedPackage.packageName.equals(ps.name)) {
6485                    if (ps.primaryCpuAbiString != null) {
6486                        continue;
6487                    }
6488
6489                    ps.primaryCpuAbiString = adjustedAbi;
6490                    if (ps.pkg != null && ps.pkg.applicationInfo != null) {
6491                        ps.pkg.applicationInfo.primaryCpuAbi = adjustedAbi;
6492                        Slog.i(TAG, "Adjusting ABI for : " + ps.name + " to " + adjustedAbi);
6493
6494                        if (performDexOptLI(ps.pkg, null /* instruction sets */, forceDexOpt,
6495                                deferDexOpt, true) == DEX_OPT_FAILED) {
6496                            ps.primaryCpuAbiString = null;
6497                            ps.pkg.applicationInfo.primaryCpuAbi = null;
6498                            return;
6499                        } else {
6500                            mInstaller.rmdex(ps.codePathString,
6501                                             getDexCodeInstructionSet(getPreferredInstructionSet()));
6502                        }
6503                    }
6504                }
6505            }
6506        }
6507    }
6508
6509    private void setUpCustomResolverActivity(PackageParser.Package pkg) {
6510        synchronized (mPackages) {
6511            mResolverReplaced = true;
6512            // Set up information for custom user intent resolution activity.
6513            mResolveActivity.applicationInfo = pkg.applicationInfo;
6514            mResolveActivity.name = mCustomResolverComponentName.getClassName();
6515            mResolveActivity.packageName = pkg.applicationInfo.packageName;
6516            mResolveActivity.processName = pkg.applicationInfo.packageName;
6517            mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
6518            mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS |
6519                    ActivityInfo.FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS;
6520            mResolveActivity.theme = 0;
6521            mResolveActivity.exported = true;
6522            mResolveActivity.enabled = true;
6523            mResolveInfo.activityInfo = mResolveActivity;
6524            mResolveInfo.priority = 0;
6525            mResolveInfo.preferredOrder = 0;
6526            mResolveInfo.match = 0;
6527            mResolveComponentName = mCustomResolverComponentName;
6528            Slog.i(TAG, "Replacing default ResolverActivity with custom activity: " +
6529                    mResolveComponentName);
6530        }
6531    }
6532
6533    private static String calculateBundledApkRoot(final String codePathString) {
6534        final File codePath = new File(codePathString);
6535        final File codeRoot;
6536        if (FileUtils.contains(Environment.getRootDirectory(), codePath)) {
6537            codeRoot = Environment.getRootDirectory();
6538        } else if (FileUtils.contains(Environment.getOemDirectory(), codePath)) {
6539            codeRoot = Environment.getOemDirectory();
6540        } else if (FileUtils.contains(Environment.getVendorDirectory(), codePath)) {
6541            codeRoot = Environment.getVendorDirectory();
6542        } else {
6543            // Unrecognized code path; take its top real segment as the apk root:
6544            // e.g. /something/app/blah.apk => /something
6545            try {
6546                File f = codePath.getCanonicalFile();
6547                File parent = f.getParentFile();    // non-null because codePath is a file
6548                File tmp;
6549                while ((tmp = parent.getParentFile()) != null) {
6550                    f = parent;
6551                    parent = tmp;
6552                }
6553                codeRoot = f;
6554                Slog.w(TAG, "Unrecognized code path "
6555                        + codePath + " - using " + codeRoot);
6556            } catch (IOException e) {
6557                // Can't canonicalize the code path -- shenanigans?
6558                Slog.w(TAG, "Can't canonicalize code path " + codePath);
6559                return Environment.getRootDirectory().getPath();
6560            }
6561        }
6562        return codeRoot.getPath();
6563    }
6564
6565    /**
6566     * Derive and set the location of native libraries for the given package,
6567     * which varies depending on where and how the package was installed.
6568     */
6569    private void setNativeLibraryPaths(PackageParser.Package pkg) {
6570        final ApplicationInfo info = pkg.applicationInfo;
6571        final String codePath = pkg.codePath;
6572        final File codeFile = new File(codePath);
6573        final boolean bundledApp = isSystemApp(info) && !isUpdatedSystemApp(info);
6574        final boolean asecApp = isForwardLocked(info) || isExternal(info);
6575
6576        info.nativeLibraryRootDir = null;
6577        info.nativeLibraryRootRequiresIsa = false;
6578        info.nativeLibraryDir = null;
6579        info.secondaryNativeLibraryDir = null;
6580
6581        if (isApkFile(codeFile)) {
6582            // Monolithic install
6583            if (bundledApp) {
6584                // If "/system/lib64/apkname" exists, assume that is the per-package
6585                // native library directory to use; otherwise use "/system/lib/apkname".
6586                final String apkRoot = calculateBundledApkRoot(info.sourceDir);
6587                final boolean is64Bit = VMRuntime.is64BitInstructionSet(
6588                        getPrimaryInstructionSet(info));
6589
6590                // This is a bundled system app so choose the path based on the ABI.
6591                // if it's a 64 bit abi, use lib64 otherwise use lib32. Note that this
6592                // is just the default path.
6593                final String apkName = deriveCodePathName(codePath);
6594                final String libDir = is64Bit ? LIB64_DIR_NAME : LIB_DIR_NAME;
6595                info.nativeLibraryRootDir = Environment.buildPath(new File(apkRoot), libDir,
6596                        apkName).getAbsolutePath();
6597
6598                if (info.secondaryCpuAbi != null) {
6599                    final String secondaryLibDir = is64Bit ? LIB_DIR_NAME : LIB64_DIR_NAME;
6600                    info.secondaryNativeLibraryDir = Environment.buildPath(new File(apkRoot),
6601                            secondaryLibDir, apkName).getAbsolutePath();
6602                }
6603            } else if (asecApp) {
6604                info.nativeLibraryRootDir = new File(codeFile.getParentFile(), LIB_DIR_NAME)
6605                        .getAbsolutePath();
6606            } else {
6607                final String apkName = deriveCodePathName(codePath);
6608                info.nativeLibraryRootDir = new File(mAppLib32InstallDir, apkName)
6609                        .getAbsolutePath();
6610            }
6611
6612            info.nativeLibraryRootRequiresIsa = false;
6613            info.nativeLibraryDir = info.nativeLibraryRootDir;
6614        } else {
6615            // Cluster install
6616            info.nativeLibraryRootDir = new File(codeFile, LIB_DIR_NAME).getAbsolutePath();
6617            info.nativeLibraryRootRequiresIsa = true;
6618
6619            info.nativeLibraryDir = new File(info.nativeLibraryRootDir,
6620                    getPrimaryInstructionSet(info)).getAbsolutePath();
6621
6622            if (info.secondaryCpuAbi != null) {
6623                info.secondaryNativeLibraryDir = new File(info.nativeLibraryRootDir,
6624                        VMRuntime.getInstructionSet(info.secondaryCpuAbi)).getAbsolutePath();
6625            }
6626        }
6627    }
6628
6629    /**
6630     * Calculate the abis and roots for a bundled app. These can uniquely
6631     * be determined from the contents of the system partition, i.e whether
6632     * it contains 64 or 32 bit shared libraries etc. We do not validate any
6633     * of this information, and instead assume that the system was built
6634     * sensibly.
6635     */
6636    private void setBundledAppAbisAndRoots(PackageParser.Package pkg,
6637                                           PackageSetting pkgSetting) {
6638        final String apkName = deriveCodePathName(pkg.applicationInfo.getCodePath());
6639
6640        // If "/system/lib64/apkname" exists, assume that is the per-package
6641        // native library directory to use; otherwise use "/system/lib/apkname".
6642        final String apkRoot = calculateBundledApkRoot(pkg.applicationInfo.sourceDir);
6643        setBundledAppAbi(pkg, apkRoot, apkName);
6644        // pkgSetting might be null during rescan following uninstall of updates
6645        // to a bundled app, so accommodate that possibility.  The settings in
6646        // that case will be established later from the parsed package.
6647        //
6648        // If the settings aren't null, sync them up with what we've just derived.
6649        // note that apkRoot isn't stored in the package settings.
6650        if (pkgSetting != null) {
6651            pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
6652            pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
6653        }
6654    }
6655
6656    /**
6657     * Deduces the ABI of a bundled app and sets the relevant fields on the
6658     * parsed pkg object.
6659     *
6660     * @param apkRoot the root of the installed apk, something like {@code /system} or {@code /oem}
6661     *        under which system libraries are installed.
6662     * @param apkName the name of the installed package.
6663     */
6664    private static void setBundledAppAbi(PackageParser.Package pkg, String apkRoot, String apkName) {
6665        final File codeFile = new File(pkg.codePath);
6666
6667        final boolean has64BitLibs;
6668        final boolean has32BitLibs;
6669        if (isApkFile(codeFile)) {
6670            // Monolithic install
6671            has64BitLibs = (new File(apkRoot, new File(LIB64_DIR_NAME, apkName).getPath())).exists();
6672            has32BitLibs = (new File(apkRoot, new File(LIB_DIR_NAME, apkName).getPath())).exists();
6673        } else {
6674            // Cluster install
6675            final File rootDir = new File(codeFile, LIB_DIR_NAME);
6676            if (!ArrayUtils.isEmpty(Build.SUPPORTED_64_BIT_ABIS)
6677                    && !TextUtils.isEmpty(Build.SUPPORTED_64_BIT_ABIS[0])) {
6678                final String isa = VMRuntime.getInstructionSet(Build.SUPPORTED_64_BIT_ABIS[0]);
6679                has64BitLibs = (new File(rootDir, isa)).exists();
6680            } else {
6681                has64BitLibs = false;
6682            }
6683            if (!ArrayUtils.isEmpty(Build.SUPPORTED_32_BIT_ABIS)
6684                    && !TextUtils.isEmpty(Build.SUPPORTED_32_BIT_ABIS[0])) {
6685                final String isa = VMRuntime.getInstructionSet(Build.SUPPORTED_32_BIT_ABIS[0]);
6686                has32BitLibs = (new File(rootDir, isa)).exists();
6687            } else {
6688                has32BitLibs = false;
6689            }
6690        }
6691
6692        if (has64BitLibs && !has32BitLibs) {
6693            // The package has 64 bit libs, but not 32 bit libs. Its primary
6694            // ABI should be 64 bit. We can safely assume here that the bundled
6695            // native libraries correspond to the most preferred ABI in the list.
6696
6697            pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6698            pkg.applicationInfo.secondaryCpuAbi = null;
6699        } else if (has32BitLibs && !has64BitLibs) {
6700            // The package has 32 bit libs but not 64 bit libs. Its primary
6701            // ABI should be 32 bit.
6702
6703            pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6704            pkg.applicationInfo.secondaryCpuAbi = null;
6705        } else if (has32BitLibs && has64BitLibs) {
6706            // The application has both 64 and 32 bit bundled libraries. We check
6707            // here that the app declares multiArch support, and warn if it doesn't.
6708            //
6709            // We will be lenient here and record both ABIs. The primary will be the
6710            // ABI that's higher on the list, i.e, a device that's configured to prefer
6711            // 64 bit apps will see a 64 bit primary ABI,
6712
6713            if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_MULTIARCH) == 0) {
6714                Slog.e(TAG, "Package: " + pkg + " has multiple bundled libs, but is not multiarch.");
6715            }
6716
6717            if (VMRuntime.is64BitInstructionSet(getPreferredInstructionSet())) {
6718                pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6719                pkg.applicationInfo.secondaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6720            } else {
6721                pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6722                pkg.applicationInfo.secondaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6723            }
6724        } else {
6725            pkg.applicationInfo.primaryCpuAbi = null;
6726            pkg.applicationInfo.secondaryCpuAbi = null;
6727        }
6728    }
6729
6730    private void killApplication(String pkgName, int appId, String reason) {
6731        // Request the ActivityManager to kill the process(only for existing packages)
6732        // so that we do not end up in a confused state while the user is still using the older
6733        // version of the application while the new one gets installed.
6734        IActivityManager am = ActivityManagerNative.getDefault();
6735        if (am != null) {
6736            try {
6737                am.killApplicationWithAppId(pkgName, appId, reason);
6738            } catch (RemoteException e) {
6739            }
6740        }
6741    }
6742
6743    void removePackageLI(PackageSetting ps, boolean chatty) {
6744        if (DEBUG_INSTALL) {
6745            if (chatty)
6746                Log.d(TAG, "Removing package " + ps.name);
6747        }
6748
6749        // writer
6750        synchronized (mPackages) {
6751            mPackages.remove(ps.name);
6752            final PackageParser.Package pkg = ps.pkg;
6753            if (pkg != null) {
6754                cleanPackageDataStructuresLILPw(pkg, chatty);
6755            }
6756        }
6757    }
6758
6759    void removeInstalledPackageLI(PackageParser.Package pkg, boolean chatty) {
6760        if (DEBUG_INSTALL) {
6761            if (chatty)
6762                Log.d(TAG, "Removing package " + pkg.applicationInfo.packageName);
6763        }
6764
6765        // writer
6766        synchronized (mPackages) {
6767            mPackages.remove(pkg.applicationInfo.packageName);
6768            cleanPackageDataStructuresLILPw(pkg, chatty);
6769        }
6770    }
6771
6772    void cleanPackageDataStructuresLILPw(PackageParser.Package pkg, boolean chatty) {
6773        int N = pkg.providers.size();
6774        StringBuilder r = null;
6775        int i;
6776        for (i=0; i<N; i++) {
6777            PackageParser.Provider p = pkg.providers.get(i);
6778            mProviders.removeProvider(p);
6779            if (p.info.authority == null) {
6780
6781                /* There was another ContentProvider with this authority when
6782                 * this app was installed so this authority is null,
6783                 * Ignore it as we don't have to unregister the provider.
6784                 */
6785                continue;
6786            }
6787            String names[] = p.info.authority.split(";");
6788            for (int j = 0; j < names.length; j++) {
6789                if (mProvidersByAuthority.get(names[j]) == p) {
6790                    mProvidersByAuthority.remove(names[j]);
6791                    if (DEBUG_REMOVE) {
6792                        if (chatty)
6793                            Log.d(TAG, "Unregistered content provider: " + names[j]
6794                                    + ", className = " + p.info.name + ", isSyncable = "
6795                                    + p.info.isSyncable);
6796                    }
6797                }
6798            }
6799            if (DEBUG_REMOVE && chatty) {
6800                if (r == null) {
6801                    r = new StringBuilder(256);
6802                } else {
6803                    r.append(' ');
6804                }
6805                r.append(p.info.name);
6806            }
6807        }
6808        if (r != null) {
6809            if (DEBUG_REMOVE) Log.d(TAG, "  Providers: " + r);
6810        }
6811
6812        N = pkg.services.size();
6813        r = null;
6814        for (i=0; i<N; i++) {
6815            PackageParser.Service s = pkg.services.get(i);
6816            mServices.removeService(s);
6817            if (chatty) {
6818                if (r == null) {
6819                    r = new StringBuilder(256);
6820                } else {
6821                    r.append(' ');
6822                }
6823                r.append(s.info.name);
6824            }
6825        }
6826        if (r != null) {
6827            if (DEBUG_REMOVE) Log.d(TAG, "  Services: " + r);
6828        }
6829
6830        N = pkg.receivers.size();
6831        r = null;
6832        for (i=0; i<N; i++) {
6833            PackageParser.Activity a = pkg.receivers.get(i);
6834            mReceivers.removeActivity(a, "receiver");
6835            if (DEBUG_REMOVE && chatty) {
6836                if (r == null) {
6837                    r = new StringBuilder(256);
6838                } else {
6839                    r.append(' ');
6840                }
6841                r.append(a.info.name);
6842            }
6843        }
6844        if (r != null) {
6845            if (DEBUG_REMOVE) Log.d(TAG, "  Receivers: " + r);
6846        }
6847
6848        N = pkg.activities.size();
6849        r = null;
6850        for (i=0; i<N; i++) {
6851            PackageParser.Activity a = pkg.activities.get(i);
6852            mActivities.removeActivity(a, "activity");
6853            if (DEBUG_REMOVE && chatty) {
6854                if (r == null) {
6855                    r = new StringBuilder(256);
6856                } else {
6857                    r.append(' ');
6858                }
6859                r.append(a.info.name);
6860            }
6861        }
6862        if (r != null) {
6863            if (DEBUG_REMOVE) Log.d(TAG, "  Activities: " + r);
6864        }
6865
6866        N = pkg.permissions.size();
6867        r = null;
6868        for (i=0; i<N; i++) {
6869            PackageParser.Permission p = pkg.permissions.get(i);
6870            BasePermission bp = mSettings.mPermissions.get(p.info.name);
6871            if (bp == null) {
6872                bp = mSettings.mPermissionTrees.get(p.info.name);
6873            }
6874            if (bp != null && bp.perm == p) {
6875                bp.perm = null;
6876                if (DEBUG_REMOVE && chatty) {
6877                    if (r == null) {
6878                        r = new StringBuilder(256);
6879                    } else {
6880                        r.append(' ');
6881                    }
6882                    r.append(p.info.name);
6883                }
6884            }
6885            if ((p.info.protectionLevel&PermissionInfo.PROTECTION_FLAG_APPOP) != 0) {
6886                ArraySet<String> appOpPerms = mAppOpPermissionPackages.get(p.info.name);
6887                if (appOpPerms != null) {
6888                    appOpPerms.remove(pkg.packageName);
6889                }
6890            }
6891        }
6892        if (r != null) {
6893            if (DEBUG_REMOVE) Log.d(TAG, "  Permissions: " + r);
6894        }
6895
6896        N = pkg.requestedPermissions.size();
6897        r = null;
6898        for (i=0; i<N; i++) {
6899            String perm = pkg.requestedPermissions.get(i);
6900            BasePermission bp = mSettings.mPermissions.get(perm);
6901            if (bp != null && (bp.protectionLevel&PermissionInfo.PROTECTION_FLAG_APPOP) != 0) {
6902                ArraySet<String> appOpPerms = mAppOpPermissionPackages.get(perm);
6903                if (appOpPerms != null) {
6904                    appOpPerms.remove(pkg.packageName);
6905                    if (appOpPerms.isEmpty()) {
6906                        mAppOpPermissionPackages.remove(perm);
6907                    }
6908                }
6909            }
6910        }
6911        if (r != null) {
6912            if (DEBUG_REMOVE) Log.d(TAG, "  Permissions: " + r);
6913        }
6914
6915        N = pkg.instrumentation.size();
6916        r = null;
6917        for (i=0; i<N; i++) {
6918            PackageParser.Instrumentation a = pkg.instrumentation.get(i);
6919            mInstrumentation.remove(a.getComponentName());
6920            if (DEBUG_REMOVE && chatty) {
6921                if (r == null) {
6922                    r = new StringBuilder(256);
6923                } else {
6924                    r.append(' ');
6925                }
6926                r.append(a.info.name);
6927            }
6928        }
6929        if (r != null) {
6930            if (DEBUG_REMOVE) Log.d(TAG, "  Instrumentation: " + r);
6931        }
6932
6933        r = null;
6934        if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
6935            // Only system apps can hold shared libraries.
6936            if (pkg.libraryNames != null) {
6937                for (i=0; i<pkg.libraryNames.size(); i++) {
6938                    String name = pkg.libraryNames.get(i);
6939                    SharedLibraryEntry cur = mSharedLibraries.get(name);
6940                    if (cur != null && cur.apk != null && cur.apk.equals(pkg.packageName)) {
6941                        mSharedLibraries.remove(name);
6942                        if (DEBUG_REMOVE && chatty) {
6943                            if (r == null) {
6944                                r = new StringBuilder(256);
6945                            } else {
6946                                r.append(' ');
6947                            }
6948                            r.append(name);
6949                        }
6950                    }
6951                }
6952            }
6953        }
6954        if (r != null) {
6955            if (DEBUG_REMOVE) Log.d(TAG, "  Libraries: " + r);
6956        }
6957    }
6958
6959    private static boolean hasPermission(PackageParser.Package pkgInfo, String perm) {
6960        for (int i=pkgInfo.permissions.size()-1; i>=0; i--) {
6961            if (pkgInfo.permissions.get(i).info.name.equals(perm)) {
6962                return true;
6963            }
6964        }
6965        return false;
6966    }
6967
6968    static final int UPDATE_PERMISSIONS_ALL = 1<<0;
6969    static final int UPDATE_PERMISSIONS_REPLACE_PKG = 1<<1;
6970    static final int UPDATE_PERMISSIONS_REPLACE_ALL = 1<<2;
6971
6972    private void updatePermissionsLPw(String changingPkg,
6973            PackageParser.Package pkgInfo, int flags) {
6974        // Make sure there are no dangling permission trees.
6975        Iterator<BasePermission> it = mSettings.mPermissionTrees.values().iterator();
6976        while (it.hasNext()) {
6977            final BasePermission bp = it.next();
6978            if (bp.packageSetting == null) {
6979                // We may not yet have parsed the package, so just see if
6980                // we still know about its settings.
6981                bp.packageSetting = mSettings.mPackages.get(bp.sourcePackage);
6982            }
6983            if (bp.packageSetting == null) {
6984                Slog.w(TAG, "Removing dangling permission tree: " + bp.name
6985                        + " from package " + bp.sourcePackage);
6986                it.remove();
6987            } else if (changingPkg != null && changingPkg.equals(bp.sourcePackage)) {
6988                if (pkgInfo == null || !hasPermission(pkgInfo, bp.name)) {
6989                    Slog.i(TAG, "Removing old permission tree: " + bp.name
6990                            + " from package " + bp.sourcePackage);
6991                    flags |= UPDATE_PERMISSIONS_ALL;
6992                    it.remove();
6993                }
6994            }
6995        }
6996
6997        // Make sure all dynamic permissions have been assigned to a package,
6998        // and make sure there are no dangling permissions.
6999        it = mSettings.mPermissions.values().iterator();
7000        while (it.hasNext()) {
7001            final BasePermission bp = it.next();
7002            if (bp.type == BasePermission.TYPE_DYNAMIC) {
7003                if (DEBUG_SETTINGS) Log.v(TAG, "Dynamic permission: name="
7004                        + bp.name + " pkg=" + bp.sourcePackage
7005                        + " info=" + bp.pendingInfo);
7006                if (bp.packageSetting == null && bp.pendingInfo != null) {
7007                    final BasePermission tree = findPermissionTreeLP(bp.name);
7008                    if (tree != null && tree.perm != null) {
7009                        bp.packageSetting = tree.packageSetting;
7010                        bp.perm = new PackageParser.Permission(tree.perm.owner,
7011                                new PermissionInfo(bp.pendingInfo));
7012                        bp.perm.info.packageName = tree.perm.info.packageName;
7013                        bp.perm.info.name = bp.name;
7014                        bp.uid = tree.uid;
7015                    }
7016                }
7017            }
7018            if (bp.packageSetting == null) {
7019                // We may not yet have parsed the package, so just see if
7020                // we still know about its settings.
7021                bp.packageSetting = mSettings.mPackages.get(bp.sourcePackage);
7022            }
7023            if (bp.packageSetting == null) {
7024                Slog.w(TAG, "Removing dangling permission: " + bp.name
7025                        + " from package " + bp.sourcePackage);
7026                it.remove();
7027            } else if (changingPkg != null && changingPkg.equals(bp.sourcePackage)) {
7028                if (pkgInfo == null || !hasPermission(pkgInfo, bp.name)) {
7029                    Slog.i(TAG, "Removing old permission: " + bp.name
7030                            + " from package " + bp.sourcePackage);
7031                    flags |= UPDATE_PERMISSIONS_ALL;
7032                    it.remove();
7033                }
7034            }
7035        }
7036
7037        // Now update the permissions for all packages, in particular
7038        // replace the granted permissions of the system packages.
7039        if ((flags&UPDATE_PERMISSIONS_ALL) != 0) {
7040            for (PackageParser.Package pkg : mPackages.values()) {
7041                if (pkg != pkgInfo) {
7042                    grantPermissionsLPw(pkg, (flags&UPDATE_PERMISSIONS_REPLACE_ALL) != 0,
7043                            changingPkg);
7044                }
7045            }
7046        }
7047
7048        if (pkgInfo != null) {
7049            grantPermissionsLPw(pkgInfo, (flags&UPDATE_PERMISSIONS_REPLACE_PKG) != 0, changingPkg);
7050        }
7051    }
7052
7053    private void grantPermissionsLPw(PackageParser.Package pkg, boolean replace,
7054            String packageOfInterest) {
7055        final PackageSetting ps = (PackageSetting) pkg.mExtras;
7056        if (ps == null) {
7057            return;
7058        }
7059        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
7060        ArraySet<String> origPermissions = gp.grantedPermissions;
7061        boolean changedPermission = false;
7062
7063        if (replace) {
7064            ps.permissionsFixed = false;
7065            if (gp == ps) {
7066                origPermissions = new ArraySet<String>(gp.grantedPermissions);
7067                gp.grantedPermissions.clear();
7068                gp.gids = mGlobalGids;
7069            }
7070        }
7071
7072        if (gp.gids == null) {
7073            gp.gids = mGlobalGids;
7074        }
7075
7076        final int N = pkg.requestedPermissions.size();
7077        for (int i=0; i<N; i++) {
7078            final String name = pkg.requestedPermissions.get(i);
7079            final boolean required = pkg.requestedPermissionsRequired.get(i);
7080            final BasePermission bp = mSettings.mPermissions.get(name);
7081            if (DEBUG_INSTALL) {
7082                if (gp != ps) {
7083                    Log.i(TAG, "Package " + pkg.packageName + " checking " + name + ": " + bp);
7084                }
7085            }
7086
7087            if (bp == null || bp.packageSetting == null) {
7088                if (packageOfInterest == null || packageOfInterest.equals(pkg.packageName)) {
7089                    Slog.w(TAG, "Unknown permission " + name
7090                            + " in package " + pkg.packageName);
7091                }
7092                continue;
7093            }
7094
7095            final String perm = bp.name;
7096            boolean allowed;
7097            boolean allowedSig = false;
7098            if ((bp.protectionLevel&PermissionInfo.PROTECTION_FLAG_APPOP) != 0) {
7099                // Keep track of app op permissions.
7100                ArraySet<String> pkgs = mAppOpPermissionPackages.get(bp.name);
7101                if (pkgs == null) {
7102                    pkgs = new ArraySet<>();
7103                    mAppOpPermissionPackages.put(bp.name, pkgs);
7104                }
7105                pkgs.add(pkg.packageName);
7106            }
7107            final int level = bp.protectionLevel & PermissionInfo.PROTECTION_MASK_BASE;
7108            if (level == PermissionInfo.PROTECTION_NORMAL
7109                    || level == PermissionInfo.PROTECTION_DANGEROUS) {
7110                // We grant a normal or dangerous permission if any of the following
7111                // are true:
7112                // 1) The permission is required
7113                // 2) The permission is optional, but was granted in the past
7114                // 3) The permission is optional, but was requested by an
7115                //    app in /system (not /data)
7116                //
7117                // Otherwise, reject the permission.
7118                allowed = (required || origPermissions.contains(perm)
7119                        || (isSystemApp(ps) && !isUpdatedSystemApp(ps)));
7120            } else if (bp.packageSetting == null) {
7121                // This permission is invalid; skip it.
7122                allowed = false;
7123            } else if (level == PermissionInfo.PROTECTION_SIGNATURE) {
7124                allowed = grantSignaturePermission(perm, pkg, bp, origPermissions);
7125                if (allowed) {
7126                    allowedSig = true;
7127                }
7128            } else {
7129                allowed = false;
7130            }
7131            if (DEBUG_INSTALL) {
7132                if (gp != ps) {
7133                    Log.i(TAG, "Package " + pkg.packageName + " granting " + perm);
7134                }
7135            }
7136            if (allowed) {
7137                if (!isSystemApp(ps) && ps.permissionsFixed) {
7138                    // If this is an existing, non-system package, then
7139                    // we can't add any new permissions to it.
7140                    if (!allowedSig && !gp.grantedPermissions.contains(perm)) {
7141                        // Except...  if this is a permission that was added
7142                        // to the platform (note: need to only do this when
7143                        // updating the platform).
7144                        allowed = isNewPlatformPermissionForPackage(perm, pkg);
7145                    }
7146                }
7147                if (allowed) {
7148                    if (!gp.grantedPermissions.contains(perm)) {
7149                        changedPermission = true;
7150                        gp.grantedPermissions.add(perm);
7151                        gp.gids = appendInts(gp.gids, bp.gids);
7152                    } else if (!ps.haveGids) {
7153                        gp.gids = appendInts(gp.gids, bp.gids);
7154                    }
7155                } else {
7156                    if (packageOfInterest == null || packageOfInterest.equals(pkg.packageName)) {
7157                        Slog.w(TAG, "Not granting permission " + perm
7158                                + " to package " + pkg.packageName
7159                                + " because it was previously installed without");
7160                    }
7161                }
7162            } else {
7163                if (gp.grantedPermissions.remove(perm)) {
7164                    changedPermission = true;
7165                    gp.gids = removeInts(gp.gids, bp.gids);
7166                    Slog.i(TAG, "Un-granting permission " + perm
7167                            + " from package " + pkg.packageName
7168                            + " (protectionLevel=" + bp.protectionLevel
7169                            + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags)
7170                            + ")");
7171                } else if ((bp.protectionLevel&PermissionInfo.PROTECTION_FLAG_APPOP) == 0) {
7172                    // Don't print warning for app op permissions, since it is fine for them
7173                    // not to be granted, there is a UI for the user to decide.
7174                    if (packageOfInterest == null || packageOfInterest.equals(pkg.packageName)) {
7175                        Slog.w(TAG, "Not granting permission " + perm
7176                                + " to package " + pkg.packageName
7177                                + " (protectionLevel=" + bp.protectionLevel
7178                                + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags)
7179                                + ")");
7180                    }
7181                }
7182            }
7183        }
7184
7185        if ((changedPermission || replace) && !ps.permissionsFixed &&
7186                !isSystemApp(ps) || isUpdatedSystemApp(ps)){
7187            // This is the first that we have heard about this package, so the
7188            // permissions we have now selected are fixed until explicitly
7189            // changed.
7190            ps.permissionsFixed = true;
7191        }
7192        ps.haveGids = true;
7193    }
7194
7195    private boolean isNewPlatformPermissionForPackage(String perm, PackageParser.Package pkg) {
7196        boolean allowed = false;
7197        final int NP = PackageParser.NEW_PERMISSIONS.length;
7198        for (int ip=0; ip<NP; ip++) {
7199            final PackageParser.NewPermissionInfo npi
7200                    = PackageParser.NEW_PERMISSIONS[ip];
7201            if (npi.name.equals(perm)
7202                    && pkg.applicationInfo.targetSdkVersion < npi.sdkVersion) {
7203                allowed = true;
7204                Log.i(TAG, "Auto-granting " + perm + " to old pkg "
7205                        + pkg.packageName);
7206                break;
7207            }
7208        }
7209        return allowed;
7210    }
7211
7212    private boolean grantSignaturePermission(String perm, PackageParser.Package pkg,
7213                                          BasePermission bp, ArraySet<String> origPermissions) {
7214        boolean allowed;
7215        allowed = (compareSignatures(
7216                bp.packageSetting.signatures.mSignatures, pkg.mSignatures)
7217                        == PackageManager.SIGNATURE_MATCH)
7218                || (compareSignatures(mPlatformPackage.mSignatures, pkg.mSignatures)
7219                        == PackageManager.SIGNATURE_MATCH);
7220        if (!allowed && (bp.protectionLevel
7221                & PermissionInfo.PROTECTION_FLAG_SYSTEM) != 0) {
7222            if (isSystemApp(pkg)) {
7223                // For updated system applications, a system permission
7224                // is granted only if it had been defined by the original application.
7225                if (isUpdatedSystemApp(pkg)) {
7226                    final PackageSetting sysPs = mSettings
7227                            .getDisabledSystemPkgLPr(pkg.packageName);
7228                    final GrantedPermissions origGp = sysPs.sharedUser != null
7229                            ? sysPs.sharedUser : sysPs;
7230
7231                    if (origGp.grantedPermissions.contains(perm)) {
7232                        // If the original was granted this permission, we take
7233                        // that grant decision as read and propagate it to the
7234                        // update.
7235                        if (sysPs.isPrivileged()) {
7236                            allowed = true;
7237                        }
7238                    } else {
7239                        // The system apk may have been updated with an older
7240                        // version of the one on the data partition, but which
7241                        // granted a new system permission that it didn't have
7242                        // before.  In this case we do want to allow the app to
7243                        // now get the new permission if the ancestral apk is
7244                        // privileged to get it.
7245                        if (sysPs.pkg != null && sysPs.isPrivileged()) {
7246                            for (int j=0;
7247                                    j<sysPs.pkg.requestedPermissions.size(); j++) {
7248                                if (perm.equals(
7249                                        sysPs.pkg.requestedPermissions.get(j))) {
7250                                    allowed = true;
7251                                    break;
7252                                }
7253                            }
7254                        }
7255                    }
7256                } else {
7257                    allowed = isPrivilegedApp(pkg);
7258                }
7259            }
7260        }
7261        if (!allowed && (bp.protectionLevel
7262                & PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0) {
7263            // For development permissions, a development permission
7264            // is granted only if it was already granted.
7265            allowed = origPermissions.contains(perm);
7266        }
7267        return allowed;
7268    }
7269
7270    final class ActivityIntentResolver
7271            extends IntentResolver<PackageParser.ActivityIntentInfo, ResolveInfo> {
7272        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
7273                boolean defaultOnly, int userId) {
7274            if (!sUserManager.exists(userId)) return null;
7275            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
7276            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
7277        }
7278
7279        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
7280                int userId) {
7281            if (!sUserManager.exists(userId)) return null;
7282            mFlags = flags;
7283            return super.queryIntent(intent, resolvedType,
7284                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
7285        }
7286
7287        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
7288                int flags, ArrayList<PackageParser.Activity> packageActivities, int userId) {
7289            if (!sUserManager.exists(userId)) return null;
7290            if (packageActivities == null) {
7291                return null;
7292            }
7293            mFlags = flags;
7294            final boolean defaultOnly = (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0;
7295            final int N = packageActivities.size();
7296            ArrayList<PackageParser.ActivityIntentInfo[]> listCut =
7297                new ArrayList<PackageParser.ActivityIntentInfo[]>(N);
7298
7299            ArrayList<PackageParser.ActivityIntentInfo> intentFilters;
7300            for (int i = 0; i < N; ++i) {
7301                intentFilters = packageActivities.get(i).intents;
7302                if (intentFilters != null && intentFilters.size() > 0) {
7303                    PackageParser.ActivityIntentInfo[] array =
7304                            new PackageParser.ActivityIntentInfo[intentFilters.size()];
7305                    intentFilters.toArray(array);
7306                    listCut.add(array);
7307                }
7308            }
7309            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
7310        }
7311
7312        public final void addActivity(PackageParser.Activity a, String type) {
7313            final boolean systemApp = isSystemApp(a.info.applicationInfo);
7314            mActivities.put(a.getComponentName(), a);
7315            if (DEBUG_SHOW_INFO)
7316                Log.v(
7317                TAG, "  " + type + " " +
7318                (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel : a.info.name) + ":");
7319            if (DEBUG_SHOW_INFO)
7320                Log.v(TAG, "    Class=" + a.info.name);
7321            final int NI = a.intents.size();
7322            for (int j=0; j<NI; j++) {
7323                PackageParser.ActivityIntentInfo intent = a.intents.get(j);
7324                if (!systemApp && intent.getPriority() > 0 && "activity".equals(type)) {
7325                    intent.setPriority(0);
7326                    Log.w(TAG, "Package " + a.info.applicationInfo.packageName + " has activity "
7327                            + a.className + " with priority > 0, forcing to 0");
7328                }
7329                if (DEBUG_SHOW_INFO) {
7330                    Log.v(TAG, "    IntentFilter:");
7331                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7332                }
7333                if (!intent.debugCheck()) {
7334                    Log.w(TAG, "==> For Activity " + a.info.name);
7335                }
7336                addFilter(intent);
7337            }
7338        }
7339
7340        public final void removeActivity(PackageParser.Activity a, String type) {
7341            mActivities.remove(a.getComponentName());
7342            if (DEBUG_SHOW_INFO) {
7343                Log.v(TAG, "  " + type + " "
7344                        + (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel
7345                                : a.info.name) + ":");
7346                Log.v(TAG, "    Class=" + a.info.name);
7347            }
7348            final int NI = a.intents.size();
7349            for (int j=0; j<NI; j++) {
7350                PackageParser.ActivityIntentInfo intent = a.intents.get(j);
7351                if (DEBUG_SHOW_INFO) {
7352                    Log.v(TAG, "    IntentFilter:");
7353                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7354                }
7355                removeFilter(intent);
7356            }
7357        }
7358
7359        @Override
7360        protected boolean allowFilterResult(
7361                PackageParser.ActivityIntentInfo filter, List<ResolveInfo> dest) {
7362            ActivityInfo filterAi = filter.activity.info;
7363            for (int i=dest.size()-1; i>=0; i--) {
7364                ActivityInfo destAi = dest.get(i).activityInfo;
7365                if (destAi.name == filterAi.name
7366                        && destAi.packageName == filterAi.packageName) {
7367                    return false;
7368                }
7369            }
7370            return true;
7371        }
7372
7373        @Override
7374        protected ActivityIntentInfo[] newArray(int size) {
7375            return new ActivityIntentInfo[size];
7376        }
7377
7378        @Override
7379        protected boolean isFilterStopped(PackageParser.ActivityIntentInfo filter, int userId) {
7380            if (!sUserManager.exists(userId)) return true;
7381            PackageParser.Package p = filter.activity.owner;
7382            if (p != null) {
7383                PackageSetting ps = (PackageSetting)p.mExtras;
7384                if (ps != null) {
7385                    // System apps are never considered stopped for purposes of
7386                    // filtering, because there may be no way for the user to
7387                    // actually re-launch them.
7388                    return (ps.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0
7389                            && ps.getStopped(userId);
7390                }
7391            }
7392            return false;
7393        }
7394
7395        @Override
7396        protected boolean isPackageForFilter(String packageName,
7397                PackageParser.ActivityIntentInfo info) {
7398            return packageName.equals(info.activity.owner.packageName);
7399        }
7400
7401        @Override
7402        protected ResolveInfo newResult(PackageParser.ActivityIntentInfo info,
7403                int match, int userId) {
7404            if (!sUserManager.exists(userId)) return null;
7405            if (!mSettings.isEnabledLPr(info.activity.info, mFlags, userId)) {
7406                return null;
7407            }
7408            final PackageParser.Activity activity = info.activity;
7409            if (mSafeMode && (activity.info.applicationInfo.flags
7410                    &ApplicationInfo.FLAG_SYSTEM) == 0) {
7411                return null;
7412            }
7413            PackageSetting ps = (PackageSetting) activity.owner.mExtras;
7414            if (ps == null) {
7415                return null;
7416            }
7417            ActivityInfo ai = PackageParser.generateActivityInfo(activity, mFlags,
7418                    ps.readUserState(userId), userId);
7419            if (ai == null) {
7420                return null;
7421            }
7422            final ResolveInfo res = new ResolveInfo();
7423            res.activityInfo = ai;
7424            if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) {
7425                res.filter = info;
7426            }
7427            res.priority = info.getPriority();
7428            res.preferredOrder = activity.owner.mPreferredOrder;
7429            //System.out.println("Result: " + res.activityInfo.className +
7430            //                   " = " + res.priority);
7431            res.match = match;
7432            res.isDefault = info.hasDefault;
7433            res.labelRes = info.labelRes;
7434            res.nonLocalizedLabel = info.nonLocalizedLabel;
7435            if (userNeedsBadging(userId)) {
7436                res.noResourceId = true;
7437            } else {
7438                res.icon = info.icon;
7439            }
7440            res.system = isSystemApp(res.activityInfo.applicationInfo);
7441            return res;
7442        }
7443
7444        @Override
7445        protected void sortResults(List<ResolveInfo> results) {
7446            Collections.sort(results, mResolvePrioritySorter);
7447        }
7448
7449        @Override
7450        protected void dumpFilter(PrintWriter out, String prefix,
7451                PackageParser.ActivityIntentInfo filter) {
7452            out.print(prefix); out.print(
7453                    Integer.toHexString(System.identityHashCode(filter.activity)));
7454                    out.print(' ');
7455                    filter.activity.printComponentShortName(out);
7456                    out.print(" filter ");
7457                    out.println(Integer.toHexString(System.identityHashCode(filter)));
7458        }
7459
7460        @Override
7461        protected Object filterToLabel(PackageParser.ActivityIntentInfo filter) {
7462            return filter.activity;
7463        }
7464
7465        protected void dumpFilterLabel(PrintWriter out, String prefix, Object label, int count) {
7466            PackageParser.Activity activity = (PackageParser.Activity)label;
7467            out.print(prefix); out.print(
7468                    Integer.toHexString(System.identityHashCode(activity)));
7469                    out.print(' ');
7470                    activity.printComponentShortName(out);
7471            if (count > 1) {
7472                out.print(" ("); out.print(count); out.print(" filters)");
7473            }
7474            out.println();
7475        }
7476
7477//        List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) {
7478//            final Iterator<ResolveInfo> i = resolveInfoList.iterator();
7479//            final List<ResolveInfo> retList = Lists.newArrayList();
7480//            while (i.hasNext()) {
7481//                final ResolveInfo resolveInfo = i.next();
7482//                if (isEnabledLP(resolveInfo.activityInfo)) {
7483//                    retList.add(resolveInfo);
7484//                }
7485//            }
7486//            return retList;
7487//        }
7488
7489        // Keys are String (activity class name), values are Activity.
7490        private final ArrayMap<ComponentName, PackageParser.Activity> mActivities
7491                = new ArrayMap<ComponentName, PackageParser.Activity>();
7492        private int mFlags;
7493    }
7494
7495    private final class ServiceIntentResolver
7496            extends IntentResolver<PackageParser.ServiceIntentInfo, ResolveInfo> {
7497        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
7498                boolean defaultOnly, int userId) {
7499            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
7500            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
7501        }
7502
7503        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
7504                int userId) {
7505            if (!sUserManager.exists(userId)) return null;
7506            mFlags = flags;
7507            return super.queryIntent(intent, resolvedType,
7508                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
7509        }
7510
7511        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
7512                int flags, ArrayList<PackageParser.Service> packageServices, int userId) {
7513            if (!sUserManager.exists(userId)) return null;
7514            if (packageServices == null) {
7515                return null;
7516            }
7517            mFlags = flags;
7518            final boolean defaultOnly = (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0;
7519            final int N = packageServices.size();
7520            ArrayList<PackageParser.ServiceIntentInfo[]> listCut =
7521                new ArrayList<PackageParser.ServiceIntentInfo[]>(N);
7522
7523            ArrayList<PackageParser.ServiceIntentInfo> intentFilters;
7524            for (int i = 0; i < N; ++i) {
7525                intentFilters = packageServices.get(i).intents;
7526                if (intentFilters != null && intentFilters.size() > 0) {
7527                    PackageParser.ServiceIntentInfo[] array =
7528                            new PackageParser.ServiceIntentInfo[intentFilters.size()];
7529                    intentFilters.toArray(array);
7530                    listCut.add(array);
7531                }
7532            }
7533            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
7534        }
7535
7536        public final void addService(PackageParser.Service s) {
7537            mServices.put(s.getComponentName(), s);
7538            if (DEBUG_SHOW_INFO) {
7539                Log.v(TAG, "  "
7540                        + (s.info.nonLocalizedLabel != null
7541                        ? s.info.nonLocalizedLabel : s.info.name) + ":");
7542                Log.v(TAG, "    Class=" + s.info.name);
7543            }
7544            final int NI = s.intents.size();
7545            int j;
7546            for (j=0; j<NI; j++) {
7547                PackageParser.ServiceIntentInfo intent = s.intents.get(j);
7548                if (DEBUG_SHOW_INFO) {
7549                    Log.v(TAG, "    IntentFilter:");
7550                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7551                }
7552                if (!intent.debugCheck()) {
7553                    Log.w(TAG, "==> For Service " + s.info.name);
7554                }
7555                addFilter(intent);
7556            }
7557        }
7558
7559        public final void removeService(PackageParser.Service s) {
7560            mServices.remove(s.getComponentName());
7561            if (DEBUG_SHOW_INFO) {
7562                Log.v(TAG, "  " + (s.info.nonLocalizedLabel != null
7563                        ? s.info.nonLocalizedLabel : s.info.name) + ":");
7564                Log.v(TAG, "    Class=" + s.info.name);
7565            }
7566            final int NI = s.intents.size();
7567            int j;
7568            for (j=0; j<NI; j++) {
7569                PackageParser.ServiceIntentInfo intent = s.intents.get(j);
7570                if (DEBUG_SHOW_INFO) {
7571                    Log.v(TAG, "    IntentFilter:");
7572                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7573                }
7574                removeFilter(intent);
7575            }
7576        }
7577
7578        @Override
7579        protected boolean allowFilterResult(
7580                PackageParser.ServiceIntentInfo filter, List<ResolveInfo> dest) {
7581            ServiceInfo filterSi = filter.service.info;
7582            for (int i=dest.size()-1; i>=0; i--) {
7583                ServiceInfo destAi = dest.get(i).serviceInfo;
7584                if (destAi.name == filterSi.name
7585                        && destAi.packageName == filterSi.packageName) {
7586                    return false;
7587                }
7588            }
7589            return true;
7590        }
7591
7592        @Override
7593        protected PackageParser.ServiceIntentInfo[] newArray(int size) {
7594            return new PackageParser.ServiceIntentInfo[size];
7595        }
7596
7597        @Override
7598        protected boolean isFilterStopped(PackageParser.ServiceIntentInfo filter, int userId) {
7599            if (!sUserManager.exists(userId)) return true;
7600            PackageParser.Package p = filter.service.owner;
7601            if (p != null) {
7602                PackageSetting ps = (PackageSetting)p.mExtras;
7603                if (ps != null) {
7604                    // System apps are never considered stopped for purposes of
7605                    // filtering, because there may be no way for the user to
7606                    // actually re-launch them.
7607                    return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0
7608                            && ps.getStopped(userId);
7609                }
7610            }
7611            return false;
7612        }
7613
7614        @Override
7615        protected boolean isPackageForFilter(String packageName,
7616                PackageParser.ServiceIntentInfo info) {
7617            return packageName.equals(info.service.owner.packageName);
7618        }
7619
7620        @Override
7621        protected ResolveInfo newResult(PackageParser.ServiceIntentInfo filter,
7622                int match, int userId) {
7623            if (!sUserManager.exists(userId)) return null;
7624            final PackageParser.ServiceIntentInfo info = (PackageParser.ServiceIntentInfo)filter;
7625            if (!mSettings.isEnabledLPr(info.service.info, mFlags, userId)) {
7626                return null;
7627            }
7628            final PackageParser.Service service = info.service;
7629            if (mSafeMode && (service.info.applicationInfo.flags
7630                    &ApplicationInfo.FLAG_SYSTEM) == 0) {
7631                return null;
7632            }
7633            PackageSetting ps = (PackageSetting) service.owner.mExtras;
7634            if (ps == null) {
7635                return null;
7636            }
7637            ServiceInfo si = PackageParser.generateServiceInfo(service, mFlags,
7638                    ps.readUserState(userId), userId);
7639            if (si == null) {
7640                return null;
7641            }
7642            final ResolveInfo res = new ResolveInfo();
7643            res.serviceInfo = si;
7644            if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) {
7645                res.filter = filter;
7646            }
7647            res.priority = info.getPriority();
7648            res.preferredOrder = service.owner.mPreferredOrder;
7649            //System.out.println("Result: " + res.activityInfo.className +
7650            //                   " = " + res.priority);
7651            res.match = match;
7652            res.isDefault = info.hasDefault;
7653            res.labelRes = info.labelRes;
7654            res.nonLocalizedLabel = info.nonLocalizedLabel;
7655            res.icon = info.icon;
7656            res.system = isSystemApp(res.serviceInfo.applicationInfo);
7657            return res;
7658        }
7659
7660        @Override
7661        protected void sortResults(List<ResolveInfo> results) {
7662            Collections.sort(results, mResolvePrioritySorter);
7663        }
7664
7665        @Override
7666        protected void dumpFilter(PrintWriter out, String prefix,
7667                PackageParser.ServiceIntentInfo filter) {
7668            out.print(prefix); out.print(
7669                    Integer.toHexString(System.identityHashCode(filter.service)));
7670                    out.print(' ');
7671                    filter.service.printComponentShortName(out);
7672                    out.print(" filter ");
7673                    out.println(Integer.toHexString(System.identityHashCode(filter)));
7674        }
7675
7676        @Override
7677        protected Object filterToLabel(PackageParser.ServiceIntentInfo filter) {
7678            return filter.service;
7679        }
7680
7681        protected void dumpFilterLabel(PrintWriter out, String prefix, Object label, int count) {
7682            PackageParser.Service service = (PackageParser.Service)label;
7683            out.print(prefix); out.print(
7684                    Integer.toHexString(System.identityHashCode(service)));
7685                    out.print(' ');
7686                    service.printComponentShortName(out);
7687            if (count > 1) {
7688                out.print(" ("); out.print(count); out.print(" filters)");
7689            }
7690            out.println();
7691        }
7692
7693//        List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) {
7694//            final Iterator<ResolveInfo> i = resolveInfoList.iterator();
7695//            final List<ResolveInfo> retList = Lists.newArrayList();
7696//            while (i.hasNext()) {
7697//                final ResolveInfo resolveInfo = (ResolveInfo) i;
7698//                if (isEnabledLP(resolveInfo.serviceInfo)) {
7699//                    retList.add(resolveInfo);
7700//                }
7701//            }
7702//            return retList;
7703//        }
7704
7705        // Keys are String (activity class name), values are Activity.
7706        private final ArrayMap<ComponentName, PackageParser.Service> mServices
7707                = new ArrayMap<ComponentName, PackageParser.Service>();
7708        private int mFlags;
7709    };
7710
7711    private final class ProviderIntentResolver
7712            extends IntentResolver<PackageParser.ProviderIntentInfo, ResolveInfo> {
7713        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
7714                boolean defaultOnly, int userId) {
7715            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
7716            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
7717        }
7718
7719        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
7720                int userId) {
7721            if (!sUserManager.exists(userId))
7722                return null;
7723            mFlags = flags;
7724            return super.queryIntent(intent, resolvedType,
7725                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
7726        }
7727
7728        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
7729                int flags, ArrayList<PackageParser.Provider> packageProviders, int userId) {
7730            if (!sUserManager.exists(userId))
7731                return null;
7732            if (packageProviders == null) {
7733                return null;
7734            }
7735            mFlags = flags;
7736            final boolean defaultOnly = (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0;
7737            final int N = packageProviders.size();
7738            ArrayList<PackageParser.ProviderIntentInfo[]> listCut =
7739                    new ArrayList<PackageParser.ProviderIntentInfo[]>(N);
7740
7741            ArrayList<PackageParser.ProviderIntentInfo> intentFilters;
7742            for (int i = 0; i < N; ++i) {
7743                intentFilters = packageProviders.get(i).intents;
7744                if (intentFilters != null && intentFilters.size() > 0) {
7745                    PackageParser.ProviderIntentInfo[] array =
7746                            new PackageParser.ProviderIntentInfo[intentFilters.size()];
7747                    intentFilters.toArray(array);
7748                    listCut.add(array);
7749                }
7750            }
7751            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
7752        }
7753
7754        public final void addProvider(PackageParser.Provider p) {
7755            if (mProviders.containsKey(p.getComponentName())) {
7756                Slog.w(TAG, "Provider " + p.getComponentName() + " already defined; ignoring");
7757                return;
7758            }
7759
7760            mProviders.put(p.getComponentName(), p);
7761            if (DEBUG_SHOW_INFO) {
7762                Log.v(TAG, "  "
7763                        + (p.info.nonLocalizedLabel != null
7764                                ? p.info.nonLocalizedLabel : p.info.name) + ":");
7765                Log.v(TAG, "    Class=" + p.info.name);
7766            }
7767            final int NI = p.intents.size();
7768            int j;
7769            for (j = 0; j < NI; j++) {
7770                PackageParser.ProviderIntentInfo intent = p.intents.get(j);
7771                if (DEBUG_SHOW_INFO) {
7772                    Log.v(TAG, "    IntentFilter:");
7773                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7774                }
7775                if (!intent.debugCheck()) {
7776                    Log.w(TAG, "==> For Provider " + p.info.name);
7777                }
7778                addFilter(intent);
7779            }
7780        }
7781
7782        public final void removeProvider(PackageParser.Provider p) {
7783            mProviders.remove(p.getComponentName());
7784            if (DEBUG_SHOW_INFO) {
7785                Log.v(TAG, "  " + (p.info.nonLocalizedLabel != null
7786                        ? p.info.nonLocalizedLabel : p.info.name) + ":");
7787                Log.v(TAG, "    Class=" + p.info.name);
7788            }
7789            final int NI = p.intents.size();
7790            int j;
7791            for (j = 0; j < NI; j++) {
7792                PackageParser.ProviderIntentInfo intent = p.intents.get(j);
7793                if (DEBUG_SHOW_INFO) {
7794                    Log.v(TAG, "    IntentFilter:");
7795                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7796                }
7797                removeFilter(intent);
7798            }
7799        }
7800
7801        @Override
7802        protected boolean allowFilterResult(
7803                PackageParser.ProviderIntentInfo filter, List<ResolveInfo> dest) {
7804            ProviderInfo filterPi = filter.provider.info;
7805            for (int i = dest.size() - 1; i >= 0; i--) {
7806                ProviderInfo destPi = dest.get(i).providerInfo;
7807                if (destPi.name == filterPi.name
7808                        && destPi.packageName == filterPi.packageName) {
7809                    return false;
7810                }
7811            }
7812            return true;
7813        }
7814
7815        @Override
7816        protected PackageParser.ProviderIntentInfo[] newArray(int size) {
7817            return new PackageParser.ProviderIntentInfo[size];
7818        }
7819
7820        @Override
7821        protected boolean isFilterStopped(PackageParser.ProviderIntentInfo filter, int userId) {
7822            if (!sUserManager.exists(userId))
7823                return true;
7824            PackageParser.Package p = filter.provider.owner;
7825            if (p != null) {
7826                PackageSetting ps = (PackageSetting) p.mExtras;
7827                if (ps != null) {
7828                    // System apps are never considered stopped for purposes of
7829                    // filtering, because there may be no way for the user to
7830                    // actually re-launch them.
7831                    return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0
7832                            && ps.getStopped(userId);
7833                }
7834            }
7835            return false;
7836        }
7837
7838        @Override
7839        protected boolean isPackageForFilter(String packageName,
7840                PackageParser.ProviderIntentInfo info) {
7841            return packageName.equals(info.provider.owner.packageName);
7842        }
7843
7844        @Override
7845        protected ResolveInfo newResult(PackageParser.ProviderIntentInfo filter,
7846                int match, int userId) {
7847            if (!sUserManager.exists(userId))
7848                return null;
7849            final PackageParser.ProviderIntentInfo info = filter;
7850            if (!mSettings.isEnabledLPr(info.provider.info, mFlags, userId)) {
7851                return null;
7852            }
7853            final PackageParser.Provider provider = info.provider;
7854            if (mSafeMode && (provider.info.applicationInfo.flags
7855                    & ApplicationInfo.FLAG_SYSTEM) == 0) {
7856                return null;
7857            }
7858            PackageSetting ps = (PackageSetting) provider.owner.mExtras;
7859            if (ps == null) {
7860                return null;
7861            }
7862            ProviderInfo pi = PackageParser.generateProviderInfo(provider, mFlags,
7863                    ps.readUserState(userId), userId);
7864            if (pi == null) {
7865                return null;
7866            }
7867            final ResolveInfo res = new ResolveInfo();
7868            res.providerInfo = pi;
7869            if ((mFlags & PackageManager.GET_RESOLVED_FILTER) != 0) {
7870                res.filter = filter;
7871            }
7872            res.priority = info.getPriority();
7873            res.preferredOrder = provider.owner.mPreferredOrder;
7874            res.match = match;
7875            res.isDefault = info.hasDefault;
7876            res.labelRes = info.labelRes;
7877            res.nonLocalizedLabel = info.nonLocalizedLabel;
7878            res.icon = info.icon;
7879            res.system = isSystemApp(res.providerInfo.applicationInfo);
7880            return res;
7881        }
7882
7883        @Override
7884        protected void sortResults(List<ResolveInfo> results) {
7885            Collections.sort(results, mResolvePrioritySorter);
7886        }
7887
7888        @Override
7889        protected void dumpFilter(PrintWriter out, String prefix,
7890                PackageParser.ProviderIntentInfo filter) {
7891            out.print(prefix);
7892            out.print(
7893                    Integer.toHexString(System.identityHashCode(filter.provider)));
7894            out.print(' ');
7895            filter.provider.printComponentShortName(out);
7896            out.print(" filter ");
7897            out.println(Integer.toHexString(System.identityHashCode(filter)));
7898        }
7899
7900        @Override
7901        protected Object filterToLabel(PackageParser.ProviderIntentInfo filter) {
7902            return filter.provider;
7903        }
7904
7905        protected void dumpFilterLabel(PrintWriter out, String prefix, Object label, int count) {
7906            PackageParser.Provider provider = (PackageParser.Provider)label;
7907            out.print(prefix); out.print(
7908                    Integer.toHexString(System.identityHashCode(provider)));
7909                    out.print(' ');
7910                    provider.printComponentShortName(out);
7911            if (count > 1) {
7912                out.print(" ("); out.print(count); out.print(" filters)");
7913            }
7914            out.println();
7915        }
7916
7917        private final ArrayMap<ComponentName, PackageParser.Provider> mProviders
7918                = new ArrayMap<ComponentName, PackageParser.Provider>();
7919        private int mFlags;
7920    };
7921
7922    private static final Comparator<ResolveInfo> mResolvePrioritySorter =
7923            new Comparator<ResolveInfo>() {
7924        public int compare(ResolveInfo r1, ResolveInfo r2) {
7925            int v1 = r1.priority;
7926            int v2 = r2.priority;
7927            //System.out.println("Comparing: q1=" + q1 + " q2=" + q2);
7928            if (v1 != v2) {
7929                return (v1 > v2) ? -1 : 1;
7930            }
7931            v1 = r1.preferredOrder;
7932            v2 = r2.preferredOrder;
7933            if (v1 != v2) {
7934                return (v1 > v2) ? -1 : 1;
7935            }
7936            if (r1.isDefault != r2.isDefault) {
7937                return r1.isDefault ? -1 : 1;
7938            }
7939            v1 = r1.match;
7940            v2 = r2.match;
7941            //System.out.println("Comparing: m1=" + m1 + " m2=" + m2);
7942            if (v1 != v2) {
7943                return (v1 > v2) ? -1 : 1;
7944            }
7945            if (r1.system != r2.system) {
7946                return r1.system ? -1 : 1;
7947            }
7948            return 0;
7949        }
7950    };
7951
7952    private static final Comparator<ProviderInfo> mProviderInitOrderSorter =
7953            new Comparator<ProviderInfo>() {
7954        public int compare(ProviderInfo p1, ProviderInfo p2) {
7955            final int v1 = p1.initOrder;
7956            final int v2 = p2.initOrder;
7957            return (v1 > v2) ? -1 : ((v1 < v2) ? 1 : 0);
7958        }
7959    };
7960
7961    static final void sendPackageBroadcast(String action, String pkg,
7962            Bundle extras, String targetPkg, IIntentReceiver finishedReceiver,
7963            int[] userIds) {
7964        IActivityManager am = ActivityManagerNative.getDefault();
7965        if (am != null) {
7966            try {
7967                if (userIds == null) {
7968                    userIds = am.getRunningUserIds();
7969                }
7970                for (int id : userIds) {
7971                    final Intent intent = new Intent(action,
7972                            pkg != null ? Uri.fromParts("package", pkg, null) : null);
7973                    if (extras != null) {
7974                        intent.putExtras(extras);
7975                    }
7976                    if (targetPkg != null) {
7977                        intent.setPackage(targetPkg);
7978                    }
7979                    // Modify the UID when posting to other users
7980                    int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
7981                    if (uid > 0 && UserHandle.getUserId(uid) != id) {
7982                        uid = UserHandle.getUid(id, UserHandle.getAppId(uid));
7983                        intent.putExtra(Intent.EXTRA_UID, uid);
7984                    }
7985                    intent.putExtra(Intent.EXTRA_USER_HANDLE, id);
7986                    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
7987                    if (DEBUG_BROADCASTS) {
7988                        RuntimeException here = new RuntimeException("here");
7989                        here.fillInStackTrace();
7990                        Slog.d(TAG, "Sending to user " + id + ": "
7991                                + intent.toShortString(false, true, false, false)
7992                                + " " + intent.getExtras(), here);
7993                    }
7994                    am.broadcastIntent(null, intent, null, finishedReceiver,
7995                            0, null, null, null, android.app.AppOpsManager.OP_NONE,
7996                            finishedReceiver != null, false, id);
7997                }
7998            } catch (RemoteException ex) {
7999            }
8000        }
8001    }
8002
8003    /**
8004     * Check if the external storage media is available. This is true if there
8005     * is a mounted external storage medium or if the external storage is
8006     * emulated.
8007     */
8008    private boolean isExternalMediaAvailable() {
8009        return mMediaMounted || Environment.isExternalStorageEmulated();
8010    }
8011
8012    @Override
8013    public PackageCleanItem nextPackageToClean(PackageCleanItem lastPackage) {
8014        // writer
8015        synchronized (mPackages) {
8016            if (!isExternalMediaAvailable()) {
8017                // If the external storage is no longer mounted at this point,
8018                // the caller may not have been able to delete all of this
8019                // packages files and can not delete any more.  Bail.
8020                return null;
8021            }
8022            final ArrayList<PackageCleanItem> pkgs = mSettings.mPackagesToBeCleaned;
8023            if (lastPackage != null) {
8024                pkgs.remove(lastPackage);
8025            }
8026            if (pkgs.size() > 0) {
8027                return pkgs.get(0);
8028            }
8029        }
8030        return null;
8031    }
8032
8033    void schedulePackageCleaning(String packageName, int userId, boolean andCode) {
8034        final Message msg = mHandler.obtainMessage(START_CLEANING_PACKAGE,
8035                userId, andCode ? 1 : 0, packageName);
8036        if (mSystemReady) {
8037            msg.sendToTarget();
8038        } else {
8039            if (mPostSystemReadyMessages == null) {
8040                mPostSystemReadyMessages = new ArrayList<>();
8041            }
8042            mPostSystemReadyMessages.add(msg);
8043        }
8044    }
8045
8046    void startCleaningPackages() {
8047        // reader
8048        synchronized (mPackages) {
8049            if (!isExternalMediaAvailable()) {
8050                return;
8051            }
8052            if (mSettings.mPackagesToBeCleaned.isEmpty()) {
8053                return;
8054            }
8055        }
8056        Intent intent = new Intent(PackageManager.ACTION_CLEAN_EXTERNAL_STORAGE);
8057        intent.setComponent(DEFAULT_CONTAINER_COMPONENT);
8058        IActivityManager am = ActivityManagerNative.getDefault();
8059        if (am != null) {
8060            try {
8061                am.startService(null, intent, null, UserHandle.USER_OWNER);
8062            } catch (RemoteException e) {
8063            }
8064        }
8065    }
8066
8067    @Override
8068    public void installPackage(String originPath, IPackageInstallObserver2 observer,
8069            int installFlags, String installerPackageName, VerificationParams verificationParams,
8070            String packageAbiOverride) {
8071        installPackageAsUser(originPath, observer, installFlags, installerPackageName, verificationParams,
8072                packageAbiOverride, UserHandle.getCallingUserId());
8073    }
8074
8075    @Override
8076    public void installPackageAsUser(String originPath, IPackageInstallObserver2 observer,
8077            int installFlags, String installerPackageName, VerificationParams verificationParams,
8078            String packageAbiOverride, int userId) {
8079        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES, null);
8080
8081        final int callingUid = Binder.getCallingUid();
8082        enforceCrossUserPermission(callingUid, userId, true, true, "installPackageAsUser");
8083
8084        if (isUserRestricted(userId, UserManager.DISALLOW_INSTALL_APPS)) {
8085            try {
8086                if (observer != null) {
8087                    observer.onPackageInstalled("", INSTALL_FAILED_USER_RESTRICTED, null, null);
8088                }
8089            } catch (RemoteException re) {
8090            }
8091            return;
8092        }
8093
8094        if ((callingUid == Process.SHELL_UID) || (callingUid == Process.ROOT_UID)) {
8095            installFlags |= PackageManager.INSTALL_FROM_ADB;
8096
8097        } else {
8098            // Caller holds INSTALL_PACKAGES permission, so we're less strict
8099            // about installerPackageName.
8100
8101            installFlags &= ~PackageManager.INSTALL_FROM_ADB;
8102            installFlags &= ~PackageManager.INSTALL_ALL_USERS;
8103        }
8104
8105        UserHandle user;
8106        if ((installFlags & PackageManager.INSTALL_ALL_USERS) != 0) {
8107            user = UserHandle.ALL;
8108        } else {
8109            user = new UserHandle(userId);
8110        }
8111
8112        verificationParams.setInstallerUid(callingUid);
8113
8114        final File originFile = new File(originPath);
8115        final OriginInfo origin = OriginInfo.fromUntrustedFile(originFile);
8116
8117        final Message msg = mHandler.obtainMessage(INIT_COPY);
8118        msg.obj = new InstallParams(origin, observer, installFlags,
8119                installerPackageName, verificationParams, user, packageAbiOverride);
8120        mHandler.sendMessage(msg);
8121    }
8122
8123    void installStage(String packageName, File stagedDir, String stagedCid,
8124            IPackageInstallObserver2 observer, PackageInstaller.SessionParams params,
8125            String installerPackageName, int installerUid, UserHandle user) {
8126        final VerificationParams verifParams = new VerificationParams(null, params.originatingUri,
8127                params.referrerUri, installerUid, null);
8128
8129        final OriginInfo origin;
8130        if (stagedDir != null) {
8131            origin = OriginInfo.fromStagedFile(stagedDir);
8132        } else {
8133            origin = OriginInfo.fromStagedContainer(stagedCid);
8134        }
8135
8136        final Message msg = mHandler.obtainMessage(INIT_COPY);
8137        msg.obj = new InstallParams(origin, observer, params.installFlags,
8138                installerPackageName, verifParams, user, params.abiOverride);
8139        mHandler.sendMessage(msg);
8140    }
8141
8142    private void sendPackageAddedForUser(String packageName, PackageSetting pkgSetting, int userId) {
8143        Bundle extras = new Bundle(1);
8144        extras.putInt(Intent.EXTRA_UID, UserHandle.getUid(userId, pkgSetting.appId));
8145
8146        sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
8147                packageName, extras, null, null, new int[] {userId});
8148        try {
8149            IActivityManager am = ActivityManagerNative.getDefault();
8150            final boolean isSystem =
8151                    isSystemApp(pkgSetting) || isUpdatedSystemApp(pkgSetting);
8152            if (isSystem && am.isUserRunning(userId, false)) {
8153                // The just-installed/enabled app is bundled on the system, so presumed
8154                // to be able to run automatically without needing an explicit launch.
8155                // Send it a BOOT_COMPLETED if it would ordinarily have gotten one.
8156                Intent bcIntent = new Intent(Intent.ACTION_BOOT_COMPLETED)
8157                        .addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES)
8158                        .setPackage(packageName);
8159                am.broadcastIntent(null, bcIntent, null, null, 0, null, null, null,
8160                        android.app.AppOpsManager.OP_NONE, false, false, userId);
8161            }
8162        } catch (RemoteException e) {
8163            // shouldn't happen
8164            Slog.w(TAG, "Unable to bootstrap installed package", e);
8165        }
8166    }
8167
8168    @Override
8169    public boolean setApplicationHiddenSettingAsUser(String packageName, boolean hidden,
8170            int userId) {
8171        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USERS, null);
8172        PackageSetting pkgSetting;
8173        final int uid = Binder.getCallingUid();
8174        enforceCrossUserPermission(uid, userId, true, true,
8175                "setApplicationHiddenSetting for user " + userId);
8176
8177        if (hidden && isPackageDeviceAdmin(packageName, userId)) {
8178            Slog.w(TAG, "Not hiding package " + packageName + ": has active device admin");
8179            return false;
8180        }
8181
8182        long callingId = Binder.clearCallingIdentity();
8183        try {
8184            boolean sendAdded = false;
8185            boolean sendRemoved = false;
8186            // writer
8187            synchronized (mPackages) {
8188                pkgSetting = mSettings.mPackages.get(packageName);
8189                if (pkgSetting == null) {
8190                    return false;
8191                }
8192                if (pkgSetting.getHidden(userId) != hidden) {
8193                    pkgSetting.setHidden(hidden, userId);
8194                    mSettings.writePackageRestrictionsLPr(userId);
8195                    if (hidden) {
8196                        sendRemoved = true;
8197                    } else {
8198                        sendAdded = true;
8199                    }
8200                }
8201            }
8202            if (sendAdded) {
8203                sendPackageAddedForUser(packageName, pkgSetting, userId);
8204                return true;
8205            }
8206            if (sendRemoved) {
8207                killApplication(packageName, UserHandle.getUid(userId, pkgSetting.appId),
8208                        "hiding pkg");
8209                sendApplicationHiddenForUser(packageName, pkgSetting, userId);
8210            }
8211        } finally {
8212            Binder.restoreCallingIdentity(callingId);
8213        }
8214        return false;
8215    }
8216
8217    private void sendApplicationHiddenForUser(String packageName, PackageSetting pkgSetting,
8218            int userId) {
8219        final PackageRemovedInfo info = new PackageRemovedInfo();
8220        info.removedPackage = packageName;
8221        info.removedUsers = new int[] {userId};
8222        info.uid = UserHandle.getUid(userId, pkgSetting.appId);
8223        info.sendBroadcast(false, false, false);
8224    }
8225
8226    /**
8227     * Returns true if application is not found or there was an error. Otherwise it returns
8228     * the hidden state of the package for the given user.
8229     */
8230    @Override
8231    public boolean getApplicationHiddenSettingAsUser(String packageName, int userId) {
8232        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USERS, null);
8233        enforceCrossUserPermission(Binder.getCallingUid(), userId, true,
8234                false, "getApplicationHidden for user " + userId);
8235        PackageSetting pkgSetting;
8236        long callingId = Binder.clearCallingIdentity();
8237        try {
8238            // writer
8239            synchronized (mPackages) {
8240                pkgSetting = mSettings.mPackages.get(packageName);
8241                if (pkgSetting == null) {
8242                    return true;
8243                }
8244                return pkgSetting.getHidden(userId);
8245            }
8246        } finally {
8247            Binder.restoreCallingIdentity(callingId);
8248        }
8249    }
8250
8251    /**
8252     * @hide
8253     */
8254    @Override
8255    public int installExistingPackageAsUser(String packageName, int userId) {
8256        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES,
8257                null);
8258        PackageSetting pkgSetting;
8259        final int uid = Binder.getCallingUid();
8260        enforceCrossUserPermission(uid, userId, true, true, "installExistingPackage for user "
8261                + userId);
8262        if (isUserRestricted(userId, UserManager.DISALLOW_INSTALL_APPS)) {
8263            return PackageManager.INSTALL_FAILED_USER_RESTRICTED;
8264        }
8265
8266        long callingId = Binder.clearCallingIdentity();
8267        try {
8268            boolean sendAdded = false;
8269            Bundle extras = new Bundle(1);
8270
8271            // writer
8272            synchronized (mPackages) {
8273                pkgSetting = mSettings.mPackages.get(packageName);
8274                if (pkgSetting == null) {
8275                    return PackageManager.INSTALL_FAILED_INVALID_URI;
8276                }
8277                if (!pkgSetting.getInstalled(userId)) {
8278                    pkgSetting.setInstalled(true, userId);
8279                    pkgSetting.setHidden(false, userId);
8280                    mSettings.writePackageRestrictionsLPr(userId);
8281                    sendAdded = true;
8282                }
8283            }
8284
8285            if (sendAdded) {
8286                sendPackageAddedForUser(packageName, pkgSetting, userId);
8287            }
8288        } finally {
8289            Binder.restoreCallingIdentity(callingId);
8290        }
8291
8292        return PackageManager.INSTALL_SUCCEEDED;
8293    }
8294
8295    boolean isUserRestricted(int userId, String restrictionKey) {
8296        Bundle restrictions = sUserManager.getUserRestrictions(userId);
8297        if (restrictions.getBoolean(restrictionKey, false)) {
8298            Log.w(TAG, "User is restricted: " + restrictionKey);
8299            return true;
8300        }
8301        return false;
8302    }
8303
8304    @Override
8305    public void verifyPendingInstall(int id, int verificationCode) throws RemoteException {
8306        mContext.enforceCallingOrSelfPermission(
8307                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
8308                "Only package verification agents can verify applications");
8309
8310        final Message msg = mHandler.obtainMessage(PACKAGE_VERIFIED);
8311        final PackageVerificationResponse response = new PackageVerificationResponse(
8312                verificationCode, Binder.getCallingUid());
8313        msg.arg1 = id;
8314        msg.obj = response;
8315        mHandler.sendMessage(msg);
8316    }
8317
8318    @Override
8319    public void extendVerificationTimeout(int id, int verificationCodeAtTimeout,
8320            long millisecondsToDelay) {
8321        mContext.enforceCallingOrSelfPermission(
8322                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
8323                "Only package verification agents can extend verification timeouts");
8324
8325        final PackageVerificationState state = mPendingVerification.get(id);
8326        final PackageVerificationResponse response = new PackageVerificationResponse(
8327                verificationCodeAtTimeout, Binder.getCallingUid());
8328
8329        if (millisecondsToDelay > PackageManager.MAXIMUM_VERIFICATION_TIMEOUT) {
8330            millisecondsToDelay = PackageManager.MAXIMUM_VERIFICATION_TIMEOUT;
8331        }
8332        if (millisecondsToDelay < 0) {
8333            millisecondsToDelay = 0;
8334        }
8335        if ((verificationCodeAtTimeout != PackageManager.VERIFICATION_ALLOW)
8336                && (verificationCodeAtTimeout != PackageManager.VERIFICATION_REJECT)) {
8337            verificationCodeAtTimeout = PackageManager.VERIFICATION_REJECT;
8338        }
8339
8340        if ((state != null) && !state.timeoutExtended()) {
8341            state.extendTimeout();
8342
8343            final Message msg = mHandler.obtainMessage(PACKAGE_VERIFIED);
8344            msg.arg1 = id;
8345            msg.obj = response;
8346            mHandler.sendMessageDelayed(msg, millisecondsToDelay);
8347        }
8348    }
8349
8350    private void broadcastPackageVerified(int verificationId, Uri packageUri,
8351            int verificationCode, UserHandle user) {
8352        final Intent intent = new Intent(Intent.ACTION_PACKAGE_VERIFIED);
8353        intent.setDataAndType(packageUri, PACKAGE_MIME_TYPE);
8354        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
8355        intent.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
8356        intent.putExtra(PackageManager.EXTRA_VERIFICATION_RESULT, verificationCode);
8357
8358        mContext.sendBroadcastAsUser(intent, user,
8359                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT);
8360    }
8361
8362    private ComponentName matchComponentForVerifier(String packageName,
8363            List<ResolveInfo> receivers) {
8364        ActivityInfo targetReceiver = null;
8365
8366        final int NR = receivers.size();
8367        for (int i = 0; i < NR; i++) {
8368            final ResolveInfo info = receivers.get(i);
8369            if (info.activityInfo == null) {
8370                continue;
8371            }
8372
8373            if (packageName.equals(info.activityInfo.packageName)) {
8374                targetReceiver = info.activityInfo;
8375                break;
8376            }
8377        }
8378
8379        if (targetReceiver == null) {
8380            return null;
8381        }
8382
8383        return new ComponentName(targetReceiver.packageName, targetReceiver.name);
8384    }
8385
8386    private List<ComponentName> matchVerifiers(PackageInfoLite pkgInfo,
8387            List<ResolveInfo> receivers, final PackageVerificationState verificationState) {
8388        if (pkgInfo.verifiers.length == 0) {
8389            return null;
8390        }
8391
8392        final int N = pkgInfo.verifiers.length;
8393        final List<ComponentName> sufficientVerifiers = new ArrayList<ComponentName>(N + 1);
8394        for (int i = 0; i < N; i++) {
8395            final VerifierInfo verifierInfo = pkgInfo.verifiers[i];
8396
8397            final ComponentName comp = matchComponentForVerifier(verifierInfo.packageName,
8398                    receivers);
8399            if (comp == null) {
8400                continue;
8401            }
8402
8403            final int verifierUid = getUidForVerifier(verifierInfo);
8404            if (verifierUid == -1) {
8405                continue;
8406            }
8407
8408            if (DEBUG_VERIFY) {
8409                Slog.d(TAG, "Added sufficient verifier " + verifierInfo.packageName
8410                        + " with the correct signature");
8411            }
8412            sufficientVerifiers.add(comp);
8413            verificationState.addSufficientVerifier(verifierUid);
8414        }
8415
8416        return sufficientVerifiers;
8417    }
8418
8419    private int getUidForVerifier(VerifierInfo verifierInfo) {
8420        synchronized (mPackages) {
8421            final PackageParser.Package pkg = mPackages.get(verifierInfo.packageName);
8422            if (pkg == null) {
8423                return -1;
8424            } else if (pkg.mSignatures.length != 1) {
8425                Slog.i(TAG, "Verifier package " + verifierInfo.packageName
8426                        + " has more than one signature; ignoring");
8427                return -1;
8428            }
8429
8430            /*
8431             * If the public key of the package's signature does not match
8432             * our expected public key, then this is a different package and
8433             * we should skip.
8434             */
8435
8436            final byte[] expectedPublicKey;
8437            try {
8438                final Signature verifierSig = pkg.mSignatures[0];
8439                final PublicKey publicKey = verifierSig.getPublicKey();
8440                expectedPublicKey = publicKey.getEncoded();
8441            } catch (CertificateException e) {
8442                return -1;
8443            }
8444
8445            final byte[] actualPublicKey = verifierInfo.publicKey.getEncoded();
8446
8447            if (!Arrays.equals(actualPublicKey, expectedPublicKey)) {
8448                Slog.i(TAG, "Verifier package " + verifierInfo.packageName
8449                        + " does not have the expected public key; ignoring");
8450                return -1;
8451            }
8452
8453            return pkg.applicationInfo.uid;
8454        }
8455    }
8456
8457    @Override
8458    public void finishPackageInstall(int token) {
8459        enforceSystemOrRoot("Only the system is allowed to finish installs");
8460
8461        if (DEBUG_INSTALL) {
8462            Slog.v(TAG, "BM finishing package install for " + token);
8463        }
8464
8465        final Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
8466        mHandler.sendMessage(msg);
8467    }
8468
8469    /**
8470     * Get the verification agent timeout.
8471     *
8472     * @return verification timeout in milliseconds
8473     */
8474    private long getVerificationTimeout() {
8475        return android.provider.Settings.Global.getLong(mContext.getContentResolver(),
8476                android.provider.Settings.Global.PACKAGE_VERIFIER_TIMEOUT,
8477                DEFAULT_VERIFICATION_TIMEOUT);
8478    }
8479
8480    /**
8481     * Get the default verification agent response code.
8482     *
8483     * @return default verification response code
8484     */
8485    private int getDefaultVerificationResponse() {
8486        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8487                android.provider.Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE,
8488                DEFAULT_VERIFICATION_RESPONSE);
8489    }
8490
8491    /**
8492     * Check whether or not package verification has been enabled.
8493     *
8494     * @return true if verification should be performed
8495     */
8496    private boolean isVerificationEnabled(int userId, int installFlags) {
8497        if (!DEFAULT_VERIFY_ENABLE) {
8498            return false;
8499        }
8500
8501        boolean ensureVerifyAppsEnabled = isUserRestricted(userId, UserManager.ENSURE_VERIFY_APPS);
8502
8503        // Check if installing from ADB
8504        if ((installFlags & PackageManager.INSTALL_FROM_ADB) != 0) {
8505            // Do not run verification in a test harness environment
8506            if (ActivityManager.isRunningInTestHarness()) {
8507                return false;
8508            }
8509            if (ensureVerifyAppsEnabled) {
8510                return true;
8511            }
8512            // Check if the developer does not want package verification for ADB installs
8513            if (android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8514                    android.provider.Settings.Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1) == 0) {
8515                return false;
8516            }
8517        }
8518
8519        if (ensureVerifyAppsEnabled) {
8520            return true;
8521        }
8522
8523        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8524                android.provider.Settings.Global.PACKAGE_VERIFIER_ENABLE, 1) == 1;
8525    }
8526
8527    /**
8528     * Get the "allow unknown sources" setting.
8529     *
8530     * @return the current "allow unknown sources" setting
8531     */
8532    private int getUnknownSourcesSettings() {
8533        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8534                android.provider.Settings.Global.INSTALL_NON_MARKET_APPS,
8535                -1);
8536    }
8537
8538    @Override
8539    public void setInstallerPackageName(String targetPackage, String installerPackageName) {
8540        final int uid = Binder.getCallingUid();
8541        // writer
8542        synchronized (mPackages) {
8543            PackageSetting targetPackageSetting = mSettings.mPackages.get(targetPackage);
8544            if (targetPackageSetting == null) {
8545                throw new IllegalArgumentException("Unknown target package: " + targetPackage);
8546            }
8547
8548            PackageSetting installerPackageSetting;
8549            if (installerPackageName != null) {
8550                installerPackageSetting = mSettings.mPackages.get(installerPackageName);
8551                if (installerPackageSetting == null) {
8552                    throw new IllegalArgumentException("Unknown installer package: "
8553                            + installerPackageName);
8554                }
8555            } else {
8556                installerPackageSetting = null;
8557            }
8558
8559            Signature[] callerSignature;
8560            Object obj = mSettings.getUserIdLPr(uid);
8561            if (obj != null) {
8562                if (obj instanceof SharedUserSetting) {
8563                    callerSignature = ((SharedUserSetting)obj).signatures.mSignatures;
8564                } else if (obj instanceof PackageSetting) {
8565                    callerSignature = ((PackageSetting)obj).signatures.mSignatures;
8566                } else {
8567                    throw new SecurityException("Bad object " + obj + " for uid " + uid);
8568                }
8569            } else {
8570                throw new SecurityException("Unknown calling uid " + uid);
8571            }
8572
8573            // Verify: can't set installerPackageName to a package that is
8574            // not signed with the same cert as the caller.
8575            if (installerPackageSetting != null) {
8576                if (compareSignatures(callerSignature,
8577                        installerPackageSetting.signatures.mSignatures)
8578                        != PackageManager.SIGNATURE_MATCH) {
8579                    throw new SecurityException(
8580                            "Caller does not have same cert as new installer package "
8581                            + installerPackageName);
8582                }
8583            }
8584
8585            // Verify: if target already has an installer package, it must
8586            // be signed with the same cert as the caller.
8587            if (targetPackageSetting.installerPackageName != null) {
8588                PackageSetting setting = mSettings.mPackages.get(
8589                        targetPackageSetting.installerPackageName);
8590                // If the currently set package isn't valid, then it's always
8591                // okay to change it.
8592                if (setting != null) {
8593                    if (compareSignatures(callerSignature,
8594                            setting.signatures.mSignatures)
8595                            != PackageManager.SIGNATURE_MATCH) {
8596                        throw new SecurityException(
8597                                "Caller does not have same cert as old installer package "
8598                                + targetPackageSetting.installerPackageName);
8599                    }
8600                }
8601            }
8602
8603            // Okay!
8604            targetPackageSetting.installerPackageName = installerPackageName;
8605            scheduleWriteSettingsLocked();
8606        }
8607    }
8608
8609    private void processPendingInstall(final InstallArgs args, final int currentStatus) {
8610        // Queue up an async operation since the package installation may take a little while.
8611        mHandler.post(new Runnable() {
8612            public void run() {
8613                mHandler.removeCallbacks(this);
8614                 // Result object to be returned
8615                PackageInstalledInfo res = new PackageInstalledInfo();
8616                res.returnCode = currentStatus;
8617                res.uid = -1;
8618                res.pkg = null;
8619                res.removedInfo = new PackageRemovedInfo();
8620                if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
8621                    args.doPreInstall(res.returnCode);
8622                    synchronized (mInstallLock) {
8623                        installPackageLI(args, res);
8624                    }
8625                    args.doPostInstall(res.returnCode, res.uid);
8626                }
8627
8628                // A restore should be performed at this point if (a) the install
8629                // succeeded, (b) the operation is not an update, and (c) the new
8630                // package has not opted out of backup participation.
8631                final boolean update = res.removedInfo.removedPackage != null;
8632                final int flags = (res.pkg == null) ? 0 : res.pkg.applicationInfo.flags;
8633                boolean doRestore = !update
8634                        && ((flags & ApplicationInfo.FLAG_ALLOW_BACKUP) != 0);
8635
8636                // Set up the post-install work request bookkeeping.  This will be used
8637                // and cleaned up by the post-install event handling regardless of whether
8638                // there's a restore pass performed.  Token values are >= 1.
8639                int token;
8640                if (mNextInstallToken < 0) mNextInstallToken = 1;
8641                token = mNextInstallToken++;
8642
8643                PostInstallData data = new PostInstallData(args, res);
8644                mRunningInstalls.put(token, data);
8645                if (DEBUG_INSTALL) Log.v(TAG, "+ starting restore round-trip " + token);
8646
8647                if (res.returnCode == PackageManager.INSTALL_SUCCEEDED && doRestore) {
8648                    // Pass responsibility to the Backup Manager.  It will perform a
8649                    // restore if appropriate, then pass responsibility back to the
8650                    // Package Manager to run the post-install observer callbacks
8651                    // and broadcasts.
8652                    IBackupManager bm = IBackupManager.Stub.asInterface(
8653                            ServiceManager.getService(Context.BACKUP_SERVICE));
8654                    if (bm != null) {
8655                        if (DEBUG_INSTALL) Log.v(TAG, "token " + token
8656                                + " to BM for possible restore");
8657                        try {
8658                            if (bm.isBackupServiceActive(UserHandle.USER_OWNER)) {
8659                                bm.restoreAtInstall(res.pkg.applicationInfo.packageName, token);
8660                            } else {
8661                                doRestore = false;
8662                            }
8663                        } catch (RemoteException e) {
8664                            // can't happen; the backup manager is local
8665                        } catch (Exception e) {
8666                            Slog.e(TAG, "Exception trying to enqueue restore", e);
8667                            doRestore = false;
8668                        }
8669                    } else {
8670                        Slog.e(TAG, "Backup Manager not found!");
8671                        doRestore = false;
8672                    }
8673                }
8674
8675                if (!doRestore) {
8676                    // No restore possible, or the Backup Manager was mysteriously not
8677                    // available -- just fire the post-install work request directly.
8678                    if (DEBUG_INSTALL) Log.v(TAG, "No restore - queue post-install for " + token);
8679                    Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
8680                    mHandler.sendMessage(msg);
8681                }
8682            }
8683        });
8684    }
8685
8686    private abstract class HandlerParams {
8687        private static final int MAX_RETRIES = 4;
8688
8689        /**
8690         * Number of times startCopy() has been attempted and had a non-fatal
8691         * error.
8692         */
8693        private int mRetries = 0;
8694
8695        /** User handle for the user requesting the information or installation. */
8696        private final UserHandle mUser;
8697
8698        HandlerParams(UserHandle user) {
8699            mUser = user;
8700        }
8701
8702        UserHandle getUser() {
8703            return mUser;
8704        }
8705
8706        final boolean startCopy() {
8707            boolean res;
8708            try {
8709                if (DEBUG_INSTALL) Slog.i(TAG, "startCopy " + mUser + ": " + this);
8710
8711                if (++mRetries > MAX_RETRIES) {
8712                    Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up");
8713                    mHandler.sendEmptyMessage(MCS_GIVE_UP);
8714                    handleServiceError();
8715                    return false;
8716                } else {
8717                    handleStartCopy();
8718                    res = true;
8719                }
8720            } catch (RemoteException e) {
8721                if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
8722                mHandler.sendEmptyMessage(MCS_RECONNECT);
8723                res = false;
8724            }
8725            handleReturnCode();
8726            return res;
8727        }
8728
8729        final void serviceError() {
8730            if (DEBUG_INSTALL) Slog.i(TAG, "serviceError");
8731            handleServiceError();
8732            handleReturnCode();
8733        }
8734
8735        abstract void handleStartCopy() throws RemoteException;
8736        abstract void handleServiceError();
8737        abstract void handleReturnCode();
8738    }
8739
8740    class MeasureParams extends HandlerParams {
8741        private final PackageStats mStats;
8742        private boolean mSuccess;
8743
8744        private final IPackageStatsObserver mObserver;
8745
8746        public MeasureParams(PackageStats stats, IPackageStatsObserver observer) {
8747            super(new UserHandle(stats.userHandle));
8748            mObserver = observer;
8749            mStats = stats;
8750        }
8751
8752        @Override
8753        public String toString() {
8754            return "MeasureParams{"
8755                + Integer.toHexString(System.identityHashCode(this))
8756                + " " + mStats.packageName + "}";
8757        }
8758
8759        @Override
8760        void handleStartCopy() throws RemoteException {
8761            synchronized (mInstallLock) {
8762                mSuccess = getPackageSizeInfoLI(mStats.packageName, mStats.userHandle, mStats);
8763            }
8764
8765            if (mSuccess) {
8766                final boolean mounted;
8767                if (Environment.isExternalStorageEmulated()) {
8768                    mounted = true;
8769                } else {
8770                    final String status = Environment.getExternalStorageState();
8771                    mounted = (Environment.MEDIA_MOUNTED.equals(status)
8772                            || Environment.MEDIA_MOUNTED_READ_ONLY.equals(status));
8773                }
8774
8775                if (mounted) {
8776                    final UserEnvironment userEnv = new UserEnvironment(mStats.userHandle);
8777
8778                    mStats.externalCacheSize = calculateDirectorySize(mContainerService,
8779                            userEnv.buildExternalStorageAppCacheDirs(mStats.packageName));
8780
8781                    mStats.externalDataSize = calculateDirectorySize(mContainerService,
8782                            userEnv.buildExternalStorageAppDataDirs(mStats.packageName));
8783
8784                    // Always subtract cache size, since it's a subdirectory
8785                    mStats.externalDataSize -= mStats.externalCacheSize;
8786
8787                    mStats.externalMediaSize = calculateDirectorySize(mContainerService,
8788                            userEnv.buildExternalStorageAppMediaDirs(mStats.packageName));
8789
8790                    mStats.externalObbSize = calculateDirectorySize(mContainerService,
8791                            userEnv.buildExternalStorageAppObbDirs(mStats.packageName));
8792                }
8793            }
8794        }
8795
8796        @Override
8797        void handleReturnCode() {
8798            if (mObserver != null) {
8799                try {
8800                    mObserver.onGetStatsCompleted(mStats, mSuccess);
8801                } catch (RemoteException e) {
8802                    Slog.i(TAG, "Observer no longer exists.");
8803                }
8804            }
8805        }
8806
8807        @Override
8808        void handleServiceError() {
8809            Slog.e(TAG, "Could not measure application " + mStats.packageName
8810                            + " external storage");
8811        }
8812    }
8813
8814    private static long calculateDirectorySize(IMediaContainerService mcs, File[] paths)
8815            throws RemoteException {
8816        long result = 0;
8817        for (File path : paths) {
8818            result += mcs.calculateDirectorySize(path.getAbsolutePath());
8819        }
8820        return result;
8821    }
8822
8823    private static void clearDirectory(IMediaContainerService mcs, File[] paths) {
8824        for (File path : paths) {
8825            try {
8826                mcs.clearDirectory(path.getAbsolutePath());
8827            } catch (RemoteException e) {
8828            }
8829        }
8830    }
8831
8832    static class OriginInfo {
8833        /**
8834         * Location where install is coming from, before it has been
8835         * copied/renamed into place. This could be a single monolithic APK
8836         * file, or a cluster directory. This location may be untrusted.
8837         */
8838        final File file;
8839        final String cid;
8840
8841        /**
8842         * Flag indicating that {@link #file} or {@link #cid} has already been
8843         * staged, meaning downstream users don't need to defensively copy the
8844         * contents.
8845         */
8846        final boolean staged;
8847
8848        /**
8849         * Flag indicating that {@link #file} or {@link #cid} is an already
8850         * installed app that is being moved.
8851         */
8852        final boolean existing;
8853
8854        final String resolvedPath;
8855        final File resolvedFile;
8856
8857        static OriginInfo fromNothing() {
8858            return new OriginInfo(null, null, false, false);
8859        }
8860
8861        static OriginInfo fromUntrustedFile(File file) {
8862            return new OriginInfo(file, null, false, false);
8863        }
8864
8865        static OriginInfo fromExistingFile(File file) {
8866            return new OriginInfo(file, null, false, true);
8867        }
8868
8869        static OriginInfo fromStagedFile(File file) {
8870            return new OriginInfo(file, null, true, false);
8871        }
8872
8873        static OriginInfo fromStagedContainer(String cid) {
8874            return new OriginInfo(null, cid, true, false);
8875        }
8876
8877        private OriginInfo(File file, String cid, boolean staged, boolean existing) {
8878            this.file = file;
8879            this.cid = cid;
8880            this.staged = staged;
8881            this.existing = existing;
8882
8883            if (cid != null) {
8884                resolvedPath = PackageHelper.getSdDir(cid);
8885                resolvedFile = new File(resolvedPath);
8886            } else if (file != null) {
8887                resolvedPath = file.getAbsolutePath();
8888                resolvedFile = file;
8889            } else {
8890                resolvedPath = null;
8891                resolvedFile = null;
8892            }
8893        }
8894    }
8895
8896    class InstallParams extends HandlerParams {
8897        final OriginInfo origin;
8898        final IPackageInstallObserver2 observer;
8899        int installFlags;
8900        final String installerPackageName;
8901        final VerificationParams verificationParams;
8902        private InstallArgs mArgs;
8903        private int mRet;
8904        final String packageAbiOverride;
8905
8906        InstallParams(OriginInfo origin, IPackageInstallObserver2 observer, int installFlags,
8907                String installerPackageName, VerificationParams verificationParams, UserHandle user,
8908                String packageAbiOverride) {
8909            super(user);
8910            this.origin = origin;
8911            this.observer = observer;
8912            this.installFlags = installFlags;
8913            this.installerPackageName = installerPackageName;
8914            this.verificationParams = verificationParams;
8915            this.packageAbiOverride = packageAbiOverride;
8916        }
8917
8918        @Override
8919        public String toString() {
8920            return "InstallParams{" + Integer.toHexString(System.identityHashCode(this))
8921                    + " file=" + origin.file + " cid=" + origin.cid + "}";
8922        }
8923
8924        public ManifestDigest getManifestDigest() {
8925            if (verificationParams == null) {
8926                return null;
8927            }
8928            return verificationParams.getManifestDigest();
8929        }
8930
8931        private int installLocationPolicy(PackageInfoLite pkgLite) {
8932            String packageName = pkgLite.packageName;
8933            int installLocation = pkgLite.installLocation;
8934            boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
8935            // reader
8936            synchronized (mPackages) {
8937                PackageParser.Package pkg = mPackages.get(packageName);
8938                if (pkg != null) {
8939                    if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
8940                        // Check for downgrading.
8941                        if ((installFlags & PackageManager.INSTALL_ALLOW_DOWNGRADE) == 0) {
8942                            try {
8943                                checkDowngrade(pkg, pkgLite);
8944                            } catch (PackageManagerException e) {
8945                                Slog.w(TAG, "Downgrade detected: " + e.getMessage());
8946                                return PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE;
8947                            }
8948                        }
8949                        // Check for updated system application.
8950                        if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
8951                            if (onSd) {
8952                                Slog.w(TAG, "Cannot install update to system app on sdcard");
8953                                return PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION;
8954                            }
8955                            return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8956                        } else {
8957                            if (onSd) {
8958                                // Install flag overrides everything.
8959                                return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8960                            }
8961                            // If current upgrade specifies particular preference
8962                            if (installLocation == PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY) {
8963                                // Application explicitly specified internal.
8964                                return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8965                            } else if (installLocation == PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL) {
8966                                // App explictly prefers external. Let policy decide
8967                            } else {
8968                                // Prefer previous location
8969                                if (isExternal(pkg)) {
8970                                    return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8971                                }
8972                                return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8973                            }
8974                        }
8975                    } else {
8976                        // Invalid install. Return error code
8977                        return PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS;
8978                    }
8979                }
8980            }
8981            // All the special cases have been taken care of.
8982            // Return result based on recommended install location.
8983            if (onSd) {
8984                return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8985            }
8986            return pkgLite.recommendedInstallLocation;
8987        }
8988
8989        /*
8990         * Invoke remote method to get package information and install
8991         * location values. Override install location based on default
8992         * policy if needed and then create install arguments based
8993         * on the install location.
8994         */
8995        public void handleStartCopy() throws RemoteException {
8996            int ret = PackageManager.INSTALL_SUCCEEDED;
8997
8998            // If we're already staged, we've firmly committed to an install location
8999            if (origin.staged) {
9000                if (origin.file != null) {
9001                    installFlags |= PackageManager.INSTALL_INTERNAL;
9002                    installFlags &= ~PackageManager.INSTALL_EXTERNAL;
9003                } else if (origin.cid != null) {
9004                    installFlags |= PackageManager.INSTALL_EXTERNAL;
9005                    installFlags &= ~PackageManager.INSTALL_INTERNAL;
9006                } else {
9007                    throw new IllegalStateException("Invalid stage location");
9008                }
9009            }
9010
9011            final boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
9012            final boolean onInt = (installFlags & PackageManager.INSTALL_INTERNAL) != 0;
9013
9014            PackageInfoLite pkgLite = null;
9015
9016            if (onInt && onSd) {
9017                // Check if both bits are set.
9018                Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");
9019                ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
9020            } else {
9021                pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags,
9022                        packageAbiOverride);
9023
9024                /*
9025                 * If we have too little free space, try to free cache
9026                 * before giving up.
9027                 */
9028                if (!origin.staged && pkgLite.recommendedInstallLocation
9029                        == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
9030                    // TODO: focus freeing disk space on the target device
9031                    final StorageManager storage = StorageManager.from(mContext);
9032                    final long lowThreshold = storage.getStorageLowBytes(
9033                            Environment.getDataDirectory());
9034
9035                    final long sizeBytes = mContainerService.calculateInstalledSize(
9036                            origin.resolvedPath, isForwardLocked(), packageAbiOverride);
9037
9038                    if (mInstaller.freeCache(sizeBytes + lowThreshold) >= 0) {
9039                        pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath,
9040                                installFlags, packageAbiOverride);
9041                    }
9042
9043                    /*
9044                     * The cache free must have deleted the file we
9045                     * downloaded to install.
9046                     *
9047                     * TODO: fix the "freeCache" call to not delete
9048                     *       the file we care about.
9049                     */
9050                    if (pkgLite.recommendedInstallLocation
9051                            == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
9052                        pkgLite.recommendedInstallLocation
9053                            = PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE;
9054                    }
9055                }
9056            }
9057
9058            if (ret == PackageManager.INSTALL_SUCCEEDED) {
9059                int loc = pkgLite.recommendedInstallLocation;
9060                if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
9061                    ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
9062                } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
9063                    ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
9064                } else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
9065                    ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
9066                } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {
9067                    ret = PackageManager.INSTALL_FAILED_INVALID_APK;
9068                } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
9069                    ret = PackageManager.INSTALL_FAILED_INVALID_URI;
9070                } else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {
9071                    ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
9072                } else {
9073                    // Override with defaults if needed.
9074                    loc = installLocationPolicy(pkgLite);
9075                    if (loc == PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE) {
9076                        ret = PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
9077                    } else if (!onSd && !onInt) {
9078                        // Override install location with flags
9079                        if (loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {
9080                            // Set the flag to install on external media.
9081                            installFlags |= PackageManager.INSTALL_EXTERNAL;
9082                            installFlags &= ~PackageManager.INSTALL_INTERNAL;
9083                        } else {
9084                            // Make sure the flag for installing on external
9085                            // media is unset
9086                            installFlags |= PackageManager.INSTALL_INTERNAL;
9087                            installFlags &= ~PackageManager.INSTALL_EXTERNAL;
9088                        }
9089                    }
9090                }
9091            }
9092
9093            final InstallArgs args = createInstallArgs(this);
9094            mArgs = args;
9095
9096            if (ret == PackageManager.INSTALL_SUCCEEDED) {
9097                 /*
9098                 * ADB installs appear as UserHandle.USER_ALL, and can only be performed by
9099                 * UserHandle.USER_OWNER, so use the package verifier for UserHandle.USER_OWNER.
9100                 */
9101                int userIdentifier = getUser().getIdentifier();
9102                if (userIdentifier == UserHandle.USER_ALL
9103                        && ((installFlags & PackageManager.INSTALL_FROM_ADB) != 0)) {
9104                    userIdentifier = UserHandle.USER_OWNER;
9105                }
9106
9107                /*
9108                 * Determine if we have any installed package verifiers. If we
9109                 * do, then we'll defer to them to verify the packages.
9110                 */
9111                final int requiredUid = mRequiredVerifierPackage == null ? -1
9112                        : getPackageUid(mRequiredVerifierPackage, userIdentifier);
9113                if (!origin.existing && requiredUid != -1
9114                        && isVerificationEnabled(userIdentifier, installFlags)) {
9115                    final Intent verification = new Intent(
9116                            Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
9117                    verification.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
9118                    verification.setDataAndType(Uri.fromFile(new File(origin.resolvedPath)),
9119                            PACKAGE_MIME_TYPE);
9120                    verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
9121
9122                    final List<ResolveInfo> receivers = queryIntentReceivers(verification,
9123                            PACKAGE_MIME_TYPE, PackageManager.GET_DISABLED_COMPONENTS,
9124                            0 /* TODO: Which userId? */);
9125
9126                    if (DEBUG_VERIFY) {
9127                        Slog.d(TAG, "Found " + receivers.size() + " verifiers for intent "
9128                                + verification.toString() + " with " + pkgLite.verifiers.length
9129                                + " optional verifiers");
9130                    }
9131
9132                    final int verificationId = mPendingVerificationToken++;
9133
9134                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
9135
9136                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_PACKAGE,
9137                            installerPackageName);
9138
9139                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALL_FLAGS,
9140                            installFlags);
9141
9142                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_PACKAGE_NAME,
9143                            pkgLite.packageName);
9144
9145                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_VERSION_CODE,
9146                            pkgLite.versionCode);
9147
9148                    if (verificationParams != null) {
9149                        if (verificationParams.getVerificationURI() != null) {
9150                           verification.putExtra(PackageManager.EXTRA_VERIFICATION_URI,
9151                                 verificationParams.getVerificationURI());
9152                        }
9153                        if (verificationParams.getOriginatingURI() != null) {
9154                            verification.putExtra(Intent.EXTRA_ORIGINATING_URI,
9155                                  verificationParams.getOriginatingURI());
9156                        }
9157                        if (verificationParams.getReferrer() != null) {
9158                            verification.putExtra(Intent.EXTRA_REFERRER,
9159                                  verificationParams.getReferrer());
9160                        }
9161                        if (verificationParams.getOriginatingUid() >= 0) {
9162                            verification.putExtra(Intent.EXTRA_ORIGINATING_UID,
9163                                  verificationParams.getOriginatingUid());
9164                        }
9165                        if (verificationParams.getInstallerUid() >= 0) {
9166                            verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_UID,
9167                                  verificationParams.getInstallerUid());
9168                        }
9169                    }
9170
9171                    final PackageVerificationState verificationState = new PackageVerificationState(
9172                            requiredUid, args);
9173
9174                    mPendingVerification.append(verificationId, verificationState);
9175
9176                    final List<ComponentName> sufficientVerifiers = matchVerifiers(pkgLite,
9177                            receivers, verificationState);
9178
9179                    /*
9180                     * If any sufficient verifiers were listed in the package
9181                     * manifest, attempt to ask them.
9182                     */
9183                    if (sufficientVerifiers != null) {
9184                        final int N = sufficientVerifiers.size();
9185                        if (N == 0) {
9186                            Slog.i(TAG, "Additional verifiers required, but none installed.");
9187                            ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
9188                        } else {
9189                            for (int i = 0; i < N; i++) {
9190                                final ComponentName verifierComponent = sufficientVerifiers.get(i);
9191
9192                                final Intent sufficientIntent = new Intent(verification);
9193                                sufficientIntent.setComponent(verifierComponent);
9194
9195                                mContext.sendBroadcastAsUser(sufficientIntent, getUser());
9196                            }
9197                        }
9198                    }
9199
9200                    final ComponentName requiredVerifierComponent = matchComponentForVerifier(
9201                            mRequiredVerifierPackage, receivers);
9202                    if (ret == PackageManager.INSTALL_SUCCEEDED
9203                            && mRequiredVerifierPackage != null) {
9204                        /*
9205                         * Send the intent to the required verification agent,
9206                         * but only start the verification timeout after the
9207                         * target BroadcastReceivers have run.
9208                         */
9209                        verification.setComponent(requiredVerifierComponent);
9210                        mContext.sendOrderedBroadcastAsUser(verification, getUser(),
9211                                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
9212                                new BroadcastReceiver() {
9213                                    @Override
9214                                    public void onReceive(Context context, Intent intent) {
9215                                        final Message msg = mHandler
9216                                                .obtainMessage(CHECK_PENDING_VERIFICATION);
9217                                        msg.arg1 = verificationId;
9218                                        mHandler.sendMessageDelayed(msg, getVerificationTimeout());
9219                                    }
9220                                }, null, 0, null, null);
9221
9222                        /*
9223                         * We don't want the copy to proceed until verification
9224                         * succeeds, so null out this field.
9225                         */
9226                        mArgs = null;
9227                    }
9228                } else {
9229                    /*
9230                     * No package verification is enabled, so immediately start
9231                     * the remote call to initiate copy using temporary file.
9232                     */
9233                    ret = args.copyApk(mContainerService, true);
9234                }
9235            }
9236
9237            mRet = ret;
9238        }
9239
9240        @Override
9241        void handleReturnCode() {
9242            // If mArgs is null, then MCS couldn't be reached. When it
9243            // reconnects, it will try again to install. At that point, this
9244            // will succeed.
9245            if (mArgs != null) {
9246                processPendingInstall(mArgs, mRet);
9247            }
9248        }
9249
9250        @Override
9251        void handleServiceError() {
9252            mArgs = createInstallArgs(this);
9253            mRet = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
9254        }
9255
9256        public boolean isForwardLocked() {
9257            return (installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
9258        }
9259    }
9260
9261    /**
9262     * Used during creation of InstallArgs
9263     *
9264     * @param installFlags package installation flags
9265     * @return true if should be installed on external storage
9266     */
9267    private static boolean installOnSd(int installFlags) {
9268        if ((installFlags & PackageManager.INSTALL_INTERNAL) != 0) {
9269            return false;
9270        }
9271        if ((installFlags & PackageManager.INSTALL_EXTERNAL) != 0) {
9272            return true;
9273        }
9274        return false;
9275    }
9276
9277    /**
9278     * Used during creation of InstallArgs
9279     *
9280     * @param installFlags package installation flags
9281     * @return true if should be installed as forward locked
9282     */
9283    private static boolean installForwardLocked(int installFlags) {
9284        return (installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
9285    }
9286
9287    private InstallArgs createInstallArgs(InstallParams params) {
9288        if (installOnSd(params.installFlags) || params.isForwardLocked()) {
9289            return new AsecInstallArgs(params);
9290        } else {
9291            return new FileInstallArgs(params);
9292        }
9293    }
9294
9295    /**
9296     * Create args that describe an existing installed package. Typically used
9297     * when cleaning up old installs, or used as a move source.
9298     */
9299    private InstallArgs createInstallArgsForExisting(int installFlags, String codePath,
9300            String resourcePath, String nativeLibraryRoot, String[] instructionSets) {
9301        final boolean isInAsec;
9302        if (installOnSd(installFlags)) {
9303            /* Apps on SD card are always in ASEC containers. */
9304            isInAsec = true;
9305        } else if (installForwardLocked(installFlags)
9306                && !codePath.startsWith(mDrmAppPrivateInstallDir.getAbsolutePath())) {
9307            /*
9308             * Forward-locked apps are only in ASEC containers if they're the
9309             * new style
9310             */
9311            isInAsec = true;
9312        } else {
9313            isInAsec = false;
9314        }
9315
9316        if (isInAsec) {
9317            return new AsecInstallArgs(codePath, instructionSets,
9318                    installOnSd(installFlags), installForwardLocked(installFlags));
9319        } else {
9320            return new FileInstallArgs(codePath, resourcePath, nativeLibraryRoot,
9321                    instructionSets);
9322        }
9323    }
9324
9325    static abstract class InstallArgs {
9326        /** @see InstallParams#origin */
9327        final OriginInfo origin;
9328
9329        final IPackageInstallObserver2 observer;
9330        // Always refers to PackageManager flags only
9331        final int installFlags;
9332        final String installerPackageName;
9333        final ManifestDigest manifestDigest;
9334        final UserHandle user;
9335        final String abiOverride;
9336
9337        // The list of instruction sets supported by this app. This is currently
9338        // only used during the rmdex() phase to clean up resources. We can get rid of this
9339        // if we move dex files under the common app path.
9340        /* nullable */ String[] instructionSets;
9341
9342        InstallArgs(OriginInfo origin, IPackageInstallObserver2 observer, int installFlags,
9343                String installerPackageName, ManifestDigest manifestDigest, UserHandle user,
9344                String[] instructionSets, String abiOverride) {
9345            this.origin = origin;
9346            this.installFlags = installFlags;
9347            this.observer = observer;
9348            this.installerPackageName = installerPackageName;
9349            this.manifestDigest = manifestDigest;
9350            this.user = user;
9351            this.instructionSets = instructionSets;
9352            this.abiOverride = abiOverride;
9353        }
9354
9355        abstract int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException;
9356        abstract int doPreInstall(int status);
9357
9358        /**
9359         * Rename package into final resting place. All paths on the given
9360         * scanned package should be updated to reflect the rename.
9361         */
9362        abstract boolean doRename(int status, PackageParser.Package pkg, String oldCodePath);
9363        abstract int doPostInstall(int status, int uid);
9364
9365        /** @see PackageSettingBase#codePathString */
9366        abstract String getCodePath();
9367        /** @see PackageSettingBase#resourcePathString */
9368        abstract String getResourcePath();
9369        abstract String getLegacyNativeLibraryPath();
9370
9371        // Need installer lock especially for dex file removal.
9372        abstract void cleanUpResourcesLI();
9373        abstract boolean doPostDeleteLI(boolean delete);
9374        abstract boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException;
9375
9376        /**
9377         * Called before the source arguments are copied. This is used mostly
9378         * for MoveParams when it needs to read the source file to put it in the
9379         * destination.
9380         */
9381        int doPreCopy() {
9382            return PackageManager.INSTALL_SUCCEEDED;
9383        }
9384
9385        /**
9386         * Called after the source arguments are copied. This is used mostly for
9387         * MoveParams when it needs to read the source file to put it in the
9388         * destination.
9389         *
9390         * @return
9391         */
9392        int doPostCopy(int uid) {
9393            return PackageManager.INSTALL_SUCCEEDED;
9394        }
9395
9396        protected boolean isFwdLocked() {
9397            return (installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
9398        }
9399
9400        protected boolean isExternal() {
9401            return (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
9402        }
9403
9404        UserHandle getUser() {
9405            return user;
9406        }
9407    }
9408
9409    /**
9410     * Logic to handle installation of non-ASEC applications, including copying
9411     * and renaming logic.
9412     */
9413    class FileInstallArgs extends InstallArgs {
9414        private File codeFile;
9415        private File resourceFile;
9416        private File legacyNativeLibraryPath;
9417
9418        // Example topology:
9419        // /data/app/com.example/base.apk
9420        // /data/app/com.example/split_foo.apk
9421        // /data/app/com.example/lib/arm/libfoo.so
9422        // /data/app/com.example/lib/arm64/libfoo.so
9423        // /data/app/com.example/dalvik/arm/base.apk@classes.dex
9424
9425        /** New install */
9426        FileInstallArgs(InstallParams params) {
9427            super(params.origin, params.observer, params.installFlags,
9428                    params.installerPackageName, params.getManifestDigest(), params.getUser(),
9429                    null /* instruction sets */, params.packageAbiOverride);
9430            if (isFwdLocked()) {
9431                throw new IllegalArgumentException("Forward locking only supported in ASEC");
9432            }
9433        }
9434
9435        /** Existing install */
9436        FileInstallArgs(String codePath, String resourcePath, String legacyNativeLibraryPath,
9437                String[] instructionSets) {
9438            super(OriginInfo.fromNothing(), null, 0, null, null, null, instructionSets, null);
9439            this.codeFile = (codePath != null) ? new File(codePath) : null;
9440            this.resourceFile = (resourcePath != null) ? new File(resourcePath) : null;
9441            this.legacyNativeLibraryPath = (legacyNativeLibraryPath != null) ?
9442                    new File(legacyNativeLibraryPath) : null;
9443        }
9444
9445        boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException {
9446            final long sizeBytes = imcs.calculateInstalledSize(origin.file.getAbsolutePath(),
9447                    isFwdLocked(), abiOverride);
9448
9449            final StorageManager storage = StorageManager.from(mContext);
9450            return (sizeBytes <= storage.getStorageBytesUntilLow(Environment.getDataDirectory()));
9451        }
9452
9453        int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
9454            if (origin.staged) {
9455                Slog.d(TAG, origin.file + " already staged; skipping copy");
9456                codeFile = origin.file;
9457                resourceFile = origin.file;
9458                return PackageManager.INSTALL_SUCCEEDED;
9459            }
9460
9461            try {
9462                final File tempDir = mInstallerService.allocateInternalStageDirLegacy();
9463                codeFile = tempDir;
9464                resourceFile = tempDir;
9465            } catch (IOException e) {
9466                Slog.w(TAG, "Failed to create copy file: " + e);
9467                return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
9468            }
9469
9470            final IParcelFileDescriptorFactory target = new IParcelFileDescriptorFactory.Stub() {
9471                @Override
9472                public ParcelFileDescriptor open(String name, int mode) throws RemoteException {
9473                    if (!FileUtils.isValidExtFilename(name)) {
9474                        throw new IllegalArgumentException("Invalid filename: " + name);
9475                    }
9476                    try {
9477                        final File file = new File(codeFile, name);
9478                        final FileDescriptor fd = Os.open(file.getAbsolutePath(),
9479                                O_RDWR | O_CREAT, 0644);
9480                        Os.chmod(file.getAbsolutePath(), 0644);
9481                        return new ParcelFileDescriptor(fd);
9482                    } catch (ErrnoException e) {
9483                        throw new RemoteException("Failed to open: " + e.getMessage());
9484                    }
9485                }
9486            };
9487
9488            int ret = PackageManager.INSTALL_SUCCEEDED;
9489            ret = imcs.copyPackage(origin.file.getAbsolutePath(), target);
9490            if (ret != PackageManager.INSTALL_SUCCEEDED) {
9491                Slog.e(TAG, "Failed to copy package");
9492                return ret;
9493            }
9494
9495            final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
9496            NativeLibraryHelper.Handle handle = null;
9497            try {
9498                handle = NativeLibraryHelper.Handle.create(codeFile);
9499                ret = NativeLibraryHelper.copyNativeBinariesWithOverride(handle, libraryRoot,
9500                        abiOverride);
9501            } catch (IOException e) {
9502                Slog.e(TAG, "Copying native libraries failed", e);
9503                ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
9504            } finally {
9505                IoUtils.closeQuietly(handle);
9506            }
9507
9508            return ret;
9509        }
9510
9511        int doPreInstall(int status) {
9512            if (status != PackageManager.INSTALL_SUCCEEDED) {
9513                cleanUp();
9514            }
9515            return status;
9516        }
9517
9518        boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
9519            if (status != PackageManager.INSTALL_SUCCEEDED) {
9520                cleanUp();
9521                return false;
9522            } else {
9523                final File beforeCodeFile = codeFile;
9524                final File afterCodeFile = getNextCodePath(pkg.packageName);
9525
9526                Slog.d(TAG, "Renaming " + beforeCodeFile + " to " + afterCodeFile);
9527                try {
9528                    Os.rename(beforeCodeFile.getAbsolutePath(), afterCodeFile.getAbsolutePath());
9529                } catch (ErrnoException e) {
9530                    Slog.d(TAG, "Failed to rename", e);
9531                    return false;
9532                }
9533
9534                if (!SELinux.restoreconRecursive(afterCodeFile)) {
9535                    Slog.d(TAG, "Failed to restorecon");
9536                    return false;
9537                }
9538
9539                // Reflect the rename internally
9540                codeFile = afterCodeFile;
9541                resourceFile = afterCodeFile;
9542
9543                // Reflect the rename in scanned details
9544                pkg.codePath = afterCodeFile.getAbsolutePath();
9545                pkg.baseCodePath = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
9546                        pkg.baseCodePath);
9547                pkg.splitCodePaths = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
9548                        pkg.splitCodePaths);
9549
9550                // Reflect the rename in app info
9551                pkg.applicationInfo.setCodePath(pkg.codePath);
9552                pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
9553                pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
9554                pkg.applicationInfo.setResourcePath(pkg.codePath);
9555                pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
9556                pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
9557
9558                return true;
9559            }
9560        }
9561
9562        int doPostInstall(int status, int uid) {
9563            if (status != PackageManager.INSTALL_SUCCEEDED) {
9564                cleanUp();
9565            }
9566            return status;
9567        }
9568
9569        @Override
9570        String getCodePath() {
9571            return (codeFile != null) ? codeFile.getAbsolutePath() : null;
9572        }
9573
9574        @Override
9575        String getResourcePath() {
9576            return (resourceFile != null) ? resourceFile.getAbsolutePath() : null;
9577        }
9578
9579        @Override
9580        String getLegacyNativeLibraryPath() {
9581            return (legacyNativeLibraryPath != null) ? legacyNativeLibraryPath.getAbsolutePath() : null;
9582        }
9583
9584        private boolean cleanUp() {
9585            if (codeFile == null || !codeFile.exists()) {
9586                return false;
9587            }
9588
9589            if (codeFile.isDirectory()) {
9590                FileUtils.deleteContents(codeFile);
9591            }
9592            codeFile.delete();
9593
9594            if (resourceFile != null && !FileUtils.contains(codeFile, resourceFile)) {
9595                resourceFile.delete();
9596            }
9597
9598            if (legacyNativeLibraryPath != null && !FileUtils.contains(codeFile, legacyNativeLibraryPath)) {
9599                if (!FileUtils.deleteContents(legacyNativeLibraryPath)) {
9600                    Slog.w(TAG, "Couldn't delete native library directory " + legacyNativeLibraryPath);
9601                }
9602                legacyNativeLibraryPath.delete();
9603            }
9604
9605            return true;
9606        }
9607
9608        void cleanUpResourcesLI() {
9609            // Try enumerating all code paths before deleting
9610            List<String> allCodePaths = Collections.EMPTY_LIST;
9611            if (codeFile != null && codeFile.exists()) {
9612                try {
9613                    final PackageLite pkg = PackageParser.parsePackageLite(codeFile, 0);
9614                    allCodePaths = pkg.getAllCodePaths();
9615                } catch (PackageParserException e) {
9616                    // Ignored; we tried our best
9617                }
9618            }
9619
9620            cleanUp();
9621
9622            if (!allCodePaths.isEmpty()) {
9623                if (instructionSets == null) {
9624                    throw new IllegalStateException("instructionSet == null");
9625                }
9626                String[] dexCodeInstructionSets = getDexCodeInstructionSets(instructionSets);
9627                for (String codePath : allCodePaths) {
9628                    for (String dexCodeInstructionSet : dexCodeInstructionSets) {
9629                        int retCode = mInstaller.rmdex(codePath, dexCodeInstructionSet);
9630                        if (retCode < 0) {
9631                            Slog.w(TAG, "Couldn't remove dex file for package: "
9632                                    + " at location " + codePath + ", retcode=" + retCode);
9633                            // we don't consider this to be a failure of the core package deletion
9634                        }
9635                    }
9636                }
9637            }
9638        }
9639
9640        boolean doPostDeleteLI(boolean delete) {
9641            // XXX err, shouldn't we respect the delete flag?
9642            cleanUpResourcesLI();
9643            return true;
9644        }
9645    }
9646
9647    private boolean isAsecExternal(String cid) {
9648        final String asecPath = PackageHelper.getSdFilesystem(cid);
9649        return !asecPath.startsWith(mAsecInternalPath);
9650    }
9651
9652    private static void maybeThrowExceptionForMultiArchCopy(String message, int copyRet) throws
9653            PackageManagerException {
9654        if (copyRet < 0) {
9655            if (copyRet != PackageManager.NO_NATIVE_LIBRARIES &&
9656                    copyRet != PackageManager.INSTALL_FAILED_NO_MATCHING_ABIS) {
9657                throw new PackageManagerException(copyRet, message);
9658            }
9659        }
9660    }
9661
9662    /**
9663     * Extract the MountService "container ID" from the full code path of an
9664     * .apk.
9665     */
9666    static String cidFromCodePath(String fullCodePath) {
9667        int eidx = fullCodePath.lastIndexOf("/");
9668        String subStr1 = fullCodePath.substring(0, eidx);
9669        int sidx = subStr1.lastIndexOf("/");
9670        return subStr1.substring(sidx+1, eidx);
9671    }
9672
9673    /**
9674     * Logic to handle installation of ASEC applications, including copying and
9675     * renaming logic.
9676     */
9677    class AsecInstallArgs extends InstallArgs {
9678        static final String RES_FILE_NAME = "pkg.apk";
9679        static final String PUBLIC_RES_FILE_NAME = "res.zip";
9680
9681        String cid;
9682        String packagePath;
9683        String resourcePath;
9684        String legacyNativeLibraryDir;
9685
9686        /** New install */
9687        AsecInstallArgs(InstallParams params) {
9688            super(params.origin, params.observer, params.installFlags,
9689                    params.installerPackageName, params.getManifestDigest(),
9690                    params.getUser(), null /* instruction sets */,
9691                    params.packageAbiOverride);
9692        }
9693
9694        /** Existing install */
9695        AsecInstallArgs(String fullCodePath, String[] instructionSets,
9696                        boolean isExternal, boolean isForwardLocked) {
9697            super(OriginInfo.fromNothing(), null, (isExternal ? INSTALL_EXTERNAL : 0)
9698                    | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null,
9699                    instructionSets, null);
9700            // Hackily pretend we're still looking at a full code path
9701            if (!fullCodePath.endsWith(RES_FILE_NAME)) {
9702                fullCodePath = new File(fullCodePath, RES_FILE_NAME).getAbsolutePath();
9703            }
9704
9705            // Extract cid from fullCodePath
9706            int eidx = fullCodePath.lastIndexOf("/");
9707            String subStr1 = fullCodePath.substring(0, eidx);
9708            int sidx = subStr1.lastIndexOf("/");
9709            cid = subStr1.substring(sidx+1, eidx);
9710            setMountPath(subStr1);
9711        }
9712
9713        AsecInstallArgs(String cid, String[] instructionSets, boolean isForwardLocked) {
9714            super(OriginInfo.fromNothing(), null, (isAsecExternal(cid) ? INSTALL_EXTERNAL : 0)
9715                    | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null,
9716                    instructionSets, null);
9717            this.cid = cid;
9718            setMountPath(PackageHelper.getSdDir(cid));
9719        }
9720
9721        void createCopyFile() {
9722            cid = mInstallerService.allocateExternalStageCidLegacy();
9723        }
9724
9725        boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException {
9726            final long sizeBytes = imcs.calculateInstalledSize(packagePath, isFwdLocked(),
9727                    abiOverride);
9728
9729            final File target;
9730            if (isExternal()) {
9731                target = new UserEnvironment(UserHandle.USER_OWNER).getExternalStorageDirectory();
9732            } else {
9733                target = Environment.getDataDirectory();
9734            }
9735
9736            final StorageManager storage = StorageManager.from(mContext);
9737            return (sizeBytes <= storage.getStorageBytesUntilLow(target));
9738        }
9739
9740        int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
9741            if (origin.staged) {
9742                Slog.d(TAG, origin.cid + " already staged; skipping copy");
9743                cid = origin.cid;
9744                setMountPath(PackageHelper.getSdDir(cid));
9745                return PackageManager.INSTALL_SUCCEEDED;
9746            }
9747
9748            if (temp) {
9749                createCopyFile();
9750            } else {
9751                /*
9752                 * Pre-emptively destroy the container since it's destroyed if
9753                 * copying fails due to it existing anyway.
9754                 */
9755                PackageHelper.destroySdDir(cid);
9756            }
9757
9758            final String newMountPath = imcs.copyPackageToContainer(
9759                    origin.file.getAbsolutePath(), cid, getEncryptKey(), isExternal(),
9760                    isFwdLocked(), deriveAbiOverride(abiOverride, null /* settings */));
9761
9762            if (newMountPath != null) {
9763                setMountPath(newMountPath);
9764                return PackageManager.INSTALL_SUCCEEDED;
9765            } else {
9766                return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9767            }
9768        }
9769
9770        @Override
9771        String getCodePath() {
9772            return packagePath;
9773        }
9774
9775        @Override
9776        String getResourcePath() {
9777            return resourcePath;
9778        }
9779
9780        @Override
9781        String getLegacyNativeLibraryPath() {
9782            return legacyNativeLibraryDir;
9783        }
9784
9785        int doPreInstall(int status) {
9786            if (status != PackageManager.INSTALL_SUCCEEDED) {
9787                // Destroy container
9788                PackageHelper.destroySdDir(cid);
9789            } else {
9790                boolean mounted = PackageHelper.isContainerMounted(cid);
9791                if (!mounted) {
9792                    String newMountPath = PackageHelper.mountSdDir(cid, getEncryptKey(),
9793                            Process.SYSTEM_UID);
9794                    if (newMountPath != null) {
9795                        setMountPath(newMountPath);
9796                    } else {
9797                        return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9798                    }
9799                }
9800            }
9801            return status;
9802        }
9803
9804        boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
9805            String newCacheId = getNextCodePath(oldCodePath, pkg.packageName, "/" + RES_FILE_NAME);
9806            String newMountPath = null;
9807            if (PackageHelper.isContainerMounted(cid)) {
9808                // Unmount the container
9809                if (!PackageHelper.unMountSdDir(cid)) {
9810                    Slog.i(TAG, "Failed to unmount " + cid + " before renaming");
9811                    return false;
9812                }
9813            }
9814            if (!PackageHelper.renameSdDir(cid, newCacheId)) {
9815                Slog.e(TAG, "Failed to rename " + cid + " to " + newCacheId +
9816                        " which might be stale. Will try to clean up.");
9817                // Clean up the stale container and proceed to recreate.
9818                if (!PackageHelper.destroySdDir(newCacheId)) {
9819                    Slog.e(TAG, "Very strange. Cannot clean up stale container " + newCacheId);
9820                    return false;
9821                }
9822                // Successfully cleaned up stale container. Try to rename again.
9823                if (!PackageHelper.renameSdDir(cid, newCacheId)) {
9824                    Slog.e(TAG, "Failed to rename " + cid + " to " + newCacheId
9825                            + " inspite of cleaning it up.");
9826                    return false;
9827                }
9828            }
9829            if (!PackageHelper.isContainerMounted(newCacheId)) {
9830                Slog.w(TAG, "Mounting container " + newCacheId);
9831                newMountPath = PackageHelper.mountSdDir(newCacheId,
9832                        getEncryptKey(), Process.SYSTEM_UID);
9833            } else {
9834                newMountPath = PackageHelper.getSdDir(newCacheId);
9835            }
9836            if (newMountPath == null) {
9837                Slog.w(TAG, "Failed to get cache path for  " + newCacheId);
9838                return false;
9839            }
9840            Log.i(TAG, "Succesfully renamed " + cid +
9841                    " to " + newCacheId +
9842                    " at new path: " + newMountPath);
9843            cid = newCacheId;
9844
9845            final File beforeCodeFile = new File(packagePath);
9846            setMountPath(newMountPath);
9847            final File afterCodeFile = new File(packagePath);
9848
9849            // Reflect the rename in scanned details
9850            pkg.codePath = afterCodeFile.getAbsolutePath();
9851            pkg.baseCodePath = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
9852                    pkg.baseCodePath);
9853            pkg.splitCodePaths = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
9854                    pkg.splitCodePaths);
9855
9856            // Reflect the rename in app info
9857            pkg.applicationInfo.setCodePath(pkg.codePath);
9858            pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
9859            pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
9860            pkg.applicationInfo.setResourcePath(pkg.codePath);
9861            pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
9862            pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
9863
9864            return true;
9865        }
9866
9867        private void setMountPath(String mountPath) {
9868            final File mountFile = new File(mountPath);
9869
9870            final File monolithicFile = new File(mountFile, RES_FILE_NAME);
9871            if (monolithicFile.exists()) {
9872                packagePath = monolithicFile.getAbsolutePath();
9873                if (isFwdLocked()) {
9874                    resourcePath = new File(mountFile, PUBLIC_RES_FILE_NAME).getAbsolutePath();
9875                } else {
9876                    resourcePath = packagePath;
9877                }
9878            } else {
9879                packagePath = mountFile.getAbsolutePath();
9880                resourcePath = packagePath;
9881            }
9882
9883            legacyNativeLibraryDir = new File(mountFile, LIB_DIR_NAME).getAbsolutePath();
9884        }
9885
9886        int doPostInstall(int status, int uid) {
9887            if (status != PackageManager.INSTALL_SUCCEEDED) {
9888                cleanUp();
9889            } else {
9890                final int groupOwner;
9891                final String protectedFile;
9892                if (isFwdLocked()) {
9893                    groupOwner = UserHandle.getSharedAppGid(uid);
9894                    protectedFile = RES_FILE_NAME;
9895                } else {
9896                    groupOwner = -1;
9897                    protectedFile = null;
9898                }
9899
9900                if (uid < Process.FIRST_APPLICATION_UID
9901                        || !PackageHelper.fixSdPermissions(cid, groupOwner, protectedFile)) {
9902                    Slog.e(TAG, "Failed to finalize " + cid);
9903                    PackageHelper.destroySdDir(cid);
9904                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9905                }
9906
9907                boolean mounted = PackageHelper.isContainerMounted(cid);
9908                if (!mounted) {
9909                    PackageHelper.mountSdDir(cid, getEncryptKey(), Process.myUid());
9910                }
9911            }
9912            return status;
9913        }
9914
9915        private void cleanUp() {
9916            if (DEBUG_SD_INSTALL) Slog.i(TAG, "cleanUp");
9917
9918            // Destroy secure container
9919            PackageHelper.destroySdDir(cid);
9920        }
9921
9922        private List<String> getAllCodePaths() {
9923            final File codeFile = new File(getCodePath());
9924            if (codeFile != null && codeFile.exists()) {
9925                try {
9926                    final PackageLite pkg = PackageParser.parsePackageLite(codeFile, 0);
9927                    return pkg.getAllCodePaths();
9928                } catch (PackageParserException e) {
9929                    // Ignored; we tried our best
9930                }
9931            }
9932            return Collections.EMPTY_LIST;
9933        }
9934
9935        void cleanUpResourcesLI() {
9936            // Enumerate all code paths before deleting
9937            cleanUpResourcesLI(getAllCodePaths());
9938        }
9939
9940        private void cleanUpResourcesLI(List<String> allCodePaths) {
9941            cleanUp();
9942
9943            if (!allCodePaths.isEmpty()) {
9944                if (instructionSets == null) {
9945                    throw new IllegalStateException("instructionSet == null");
9946                }
9947                String[] dexCodeInstructionSets = getDexCodeInstructionSets(instructionSets);
9948                for (String codePath : allCodePaths) {
9949                    for (String dexCodeInstructionSet : dexCodeInstructionSets) {
9950                        int retCode = mInstaller.rmdex(codePath, dexCodeInstructionSet);
9951                        if (retCode < 0) {
9952                            Slog.w(TAG, "Couldn't remove dex file for package: "
9953                                    + " at location " + codePath + ", retcode=" + retCode);
9954                            // we don't consider this to be a failure of the core package deletion
9955                        }
9956                    }
9957                }
9958            }
9959        }
9960
9961        boolean matchContainer(String app) {
9962            if (cid.startsWith(app)) {
9963                return true;
9964            }
9965            return false;
9966        }
9967
9968        String getPackageName() {
9969            return getAsecPackageName(cid);
9970        }
9971
9972        boolean doPostDeleteLI(boolean delete) {
9973            if (DEBUG_SD_INSTALL) Slog.i(TAG, "doPostDeleteLI() del=" + delete);
9974            final List<String> allCodePaths = getAllCodePaths();
9975            boolean mounted = PackageHelper.isContainerMounted(cid);
9976            if (mounted) {
9977                // Unmount first
9978                if (PackageHelper.unMountSdDir(cid)) {
9979                    mounted = false;
9980                }
9981            }
9982            if (!mounted && delete) {
9983                cleanUpResourcesLI(allCodePaths);
9984            }
9985            return !mounted;
9986        }
9987
9988        @Override
9989        int doPreCopy() {
9990            if (isFwdLocked()) {
9991                if (!PackageHelper.fixSdPermissions(cid,
9992                        getPackageUid(DEFAULT_CONTAINER_PACKAGE, 0), RES_FILE_NAME)) {
9993                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9994                }
9995            }
9996
9997            return PackageManager.INSTALL_SUCCEEDED;
9998        }
9999
10000        @Override
10001        int doPostCopy(int uid) {
10002            if (isFwdLocked()) {
10003                if (uid < Process.FIRST_APPLICATION_UID
10004                        || !PackageHelper.fixSdPermissions(cid, UserHandle.getSharedAppGid(uid),
10005                                RES_FILE_NAME)) {
10006                    Slog.e(TAG, "Failed to finalize " + cid);
10007                    PackageHelper.destroySdDir(cid);
10008                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
10009                }
10010            }
10011
10012            return PackageManager.INSTALL_SUCCEEDED;
10013        }
10014    }
10015
10016    static String getAsecPackageName(String packageCid) {
10017        int idx = packageCid.lastIndexOf("-");
10018        if (idx == -1) {
10019            return packageCid;
10020        }
10021        return packageCid.substring(0, idx);
10022    }
10023
10024    // Utility method used to create code paths based on package name and available index.
10025    private static String getNextCodePath(String oldCodePath, String prefix, String suffix) {
10026        String idxStr = "";
10027        int idx = 1;
10028        // Fall back to default value of idx=1 if prefix is not
10029        // part of oldCodePath
10030        if (oldCodePath != null) {
10031            String subStr = oldCodePath;
10032            // Drop the suffix right away
10033            if (suffix != null && subStr.endsWith(suffix)) {
10034                subStr = subStr.substring(0, subStr.length() - suffix.length());
10035            }
10036            // If oldCodePath already contains prefix find out the
10037            // ending index to either increment or decrement.
10038            int sidx = subStr.lastIndexOf(prefix);
10039            if (sidx != -1) {
10040                subStr = subStr.substring(sidx + prefix.length());
10041                if (subStr != null) {
10042                    if (subStr.startsWith(INSTALL_PACKAGE_SUFFIX)) {
10043                        subStr = subStr.substring(INSTALL_PACKAGE_SUFFIX.length());
10044                    }
10045                    try {
10046                        idx = Integer.parseInt(subStr);
10047                        if (idx <= 1) {
10048                            idx++;
10049                        } else {
10050                            idx--;
10051                        }
10052                    } catch(NumberFormatException e) {
10053                    }
10054                }
10055            }
10056        }
10057        idxStr = INSTALL_PACKAGE_SUFFIX + Integer.toString(idx);
10058        return prefix + idxStr;
10059    }
10060
10061    private File getNextCodePath(String packageName) {
10062        int suffix = 1;
10063        File result;
10064        do {
10065            result = new File(mAppInstallDir, packageName + "-" + suffix);
10066            suffix++;
10067        } while (result.exists());
10068        return result;
10069    }
10070
10071    // Utility method used to ignore ADD/REMOVE events
10072    // by directory observer.
10073    private static boolean ignoreCodePath(String fullPathStr) {
10074        String apkName = deriveCodePathName(fullPathStr);
10075        int idx = apkName.lastIndexOf(INSTALL_PACKAGE_SUFFIX);
10076        if (idx != -1 && ((idx+1) < apkName.length())) {
10077            // Make sure the package ends with a numeral
10078            String version = apkName.substring(idx+1);
10079            try {
10080                Integer.parseInt(version);
10081                return true;
10082            } catch (NumberFormatException e) {}
10083        }
10084        return false;
10085    }
10086
10087    // Utility method that returns the relative package path with respect
10088    // to the installation directory. Like say for /data/data/com.test-1.apk
10089    // string com.test-1 is returned.
10090    static String deriveCodePathName(String codePath) {
10091        if (codePath == null) {
10092            return null;
10093        }
10094        final File codeFile = new File(codePath);
10095        final String name = codeFile.getName();
10096        if (codeFile.isDirectory()) {
10097            return name;
10098        } else if (name.endsWith(".apk") || name.endsWith(".tmp")) {
10099            final int lastDot = name.lastIndexOf('.');
10100            return name.substring(0, lastDot);
10101        } else {
10102            Slog.w(TAG, "Odd, " + codePath + " doesn't look like an APK");
10103            return null;
10104        }
10105    }
10106
10107    class PackageInstalledInfo {
10108        String name;
10109        int uid;
10110        // The set of users that originally had this package installed.
10111        int[] origUsers;
10112        // The set of users that now have this package installed.
10113        int[] newUsers;
10114        PackageParser.Package pkg;
10115        int returnCode;
10116        String returnMsg;
10117        PackageRemovedInfo removedInfo;
10118
10119        public void setError(int code, String msg) {
10120            returnCode = code;
10121            returnMsg = msg;
10122            Slog.w(TAG, msg);
10123        }
10124
10125        public void setError(String msg, PackageParserException e) {
10126            returnCode = e.error;
10127            returnMsg = ExceptionUtils.getCompleteMessage(msg, e);
10128            Slog.w(TAG, msg, e);
10129        }
10130
10131        public void setError(String msg, PackageManagerException e) {
10132            returnCode = e.error;
10133            returnMsg = ExceptionUtils.getCompleteMessage(msg, e);
10134            Slog.w(TAG, msg, e);
10135        }
10136
10137        // In some error cases we want to convey more info back to the observer
10138        String origPackage;
10139        String origPermission;
10140    }
10141
10142    /*
10143     * Install a non-existing package.
10144     */
10145    private void installNewPackageLI(PackageParser.Package pkg,
10146            int parseFlags, int scanFlags, UserHandle user,
10147            String installerPackageName, PackageInstalledInfo res) {
10148        // Remember this for later, in case we need to rollback this install
10149        String pkgName = pkg.packageName;
10150
10151        if (DEBUG_INSTALL) Slog.d(TAG, "installNewPackageLI: " + pkg);
10152        boolean dataDirExists = getDataPathForPackage(pkg.packageName, 0).exists();
10153        synchronized(mPackages) {
10154            if (mSettings.mRenamedPackages.containsKey(pkgName)) {
10155                // A package with the same name is already installed, though
10156                // it has been renamed to an older name.  The package we
10157                // are trying to install should be installed as an update to
10158                // the existing one, but that has not been requested, so bail.
10159                res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
10160                        + " without first uninstalling package running as "
10161                        + mSettings.mRenamedPackages.get(pkgName));
10162                return;
10163            }
10164            if (mPackages.containsKey(pkgName)) {
10165                // Don't allow installation over an existing package with the same name.
10166                res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
10167                        + " without first uninstalling.");
10168                return;
10169            }
10170        }
10171
10172        try {
10173            PackageParser.Package newPackage = scanPackageLI(pkg, parseFlags, scanFlags,
10174                    System.currentTimeMillis(), user);
10175
10176            updateSettingsLI(newPackage, installerPackageName, null, null, res);
10177            // delete the partially installed application. the data directory will have to be
10178            // restored if it was already existing
10179            if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
10180                // remove package from internal structures.  Note that we want deletePackageX to
10181                // delete the package data and cache directories that it created in
10182                // scanPackageLocked, unless those directories existed before we even tried to
10183                // install.
10184                deletePackageLI(pkgName, UserHandle.ALL, false, null, null,
10185                        dataDirExists ? PackageManager.DELETE_KEEP_DATA : 0,
10186                                res.removedInfo, true);
10187            }
10188
10189        } catch (PackageManagerException e) {
10190            res.setError("Package couldn't be installed in " + pkg.codePath, e);
10191        }
10192    }
10193
10194    private boolean checkUpgradeKeySetLP(PackageSetting oldPS, PackageParser.Package newPkg) {
10195        // Upgrade keysets are being used.  Determine if new package has a superset of the
10196        // required keys.
10197        long[] upgradeKeySets = oldPS.keySetData.getUpgradeKeySets();
10198        KeySetManagerService ksms = mSettings.mKeySetManagerService;
10199        for (int i = 0; i < upgradeKeySets.length; i++) {
10200            Set<PublicKey> upgradeSet = ksms.getPublicKeysFromKeySetLPr(upgradeKeySets[i]);
10201            if (newPkg.mSigningKeys.containsAll(upgradeSet)) {
10202                return true;
10203            }
10204        }
10205        return false;
10206    }
10207
10208    private void replacePackageLI(PackageParser.Package pkg,
10209            int parseFlags, int scanFlags, UserHandle user,
10210            String installerPackageName, PackageInstalledInfo res) {
10211        PackageParser.Package oldPackage;
10212        String pkgName = pkg.packageName;
10213        int[] allUsers;
10214        boolean[] perUserInstalled;
10215
10216        // First find the old package info and check signatures
10217        synchronized(mPackages) {
10218            oldPackage = mPackages.get(pkgName);
10219            if (DEBUG_INSTALL) Slog.d(TAG, "replacePackageLI: new=" + pkg + ", old=" + oldPackage);
10220            PackageSetting ps = mSettings.mPackages.get(pkgName);
10221            if (ps == null || !ps.keySetData.isUsingUpgradeKeySets() || ps.sharedUser != null) {
10222                // default to original signature matching
10223                if (compareSignatures(oldPackage.mSignatures, pkg.mSignatures)
10224                    != PackageManager.SIGNATURE_MATCH) {
10225                    res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
10226                            "New package has a different signature: " + pkgName);
10227                    return;
10228                }
10229            } else {
10230                if(!checkUpgradeKeySetLP(ps, pkg)) {
10231                    res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
10232                            "New package not signed by keys specified by upgrade-keysets: "
10233                            + pkgName);
10234                    return;
10235                }
10236            }
10237
10238            // In case of rollback, remember per-user/profile install state
10239            allUsers = sUserManager.getUserIds();
10240            perUserInstalled = new boolean[allUsers.length];
10241            for (int i = 0; i < allUsers.length; i++) {
10242                perUserInstalled[i] = ps != null ? ps.getInstalled(allUsers[i]) : false;
10243            }
10244        }
10245
10246        boolean sysPkg = (isSystemApp(oldPackage));
10247        if (sysPkg) {
10248            replaceSystemPackageLI(oldPackage, pkg, parseFlags, scanFlags,
10249                    user, allUsers, perUserInstalled, installerPackageName, res);
10250        } else {
10251            replaceNonSystemPackageLI(oldPackage, pkg, parseFlags, scanFlags,
10252                    user, allUsers, perUserInstalled, installerPackageName, res);
10253        }
10254    }
10255
10256    private void replaceNonSystemPackageLI(PackageParser.Package deletedPackage,
10257            PackageParser.Package pkg, int parseFlags, int scanFlags, UserHandle user,
10258            int[] allUsers, boolean[] perUserInstalled,
10259            String installerPackageName, PackageInstalledInfo res) {
10260        String pkgName = deletedPackage.packageName;
10261        boolean deletedPkg = true;
10262        boolean updatedSettings = false;
10263
10264        if (DEBUG_INSTALL) Slog.d(TAG, "replaceNonSystemPackageLI: new=" + pkg + ", old="
10265                + deletedPackage);
10266        long origUpdateTime;
10267        if (pkg.mExtras != null) {
10268            origUpdateTime = ((PackageSetting)pkg.mExtras).lastUpdateTime;
10269        } else {
10270            origUpdateTime = 0;
10271        }
10272
10273        // First delete the existing package while retaining the data directory
10274        if (!deletePackageLI(pkgName, null, true, null, null, PackageManager.DELETE_KEEP_DATA,
10275                res.removedInfo, true)) {
10276            // If the existing package wasn't successfully deleted
10277            res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE, "replaceNonSystemPackageLI");
10278            deletedPkg = false;
10279        } else {
10280            // Successfully deleted the old package; proceed with replace.
10281
10282            // If deleted package lived in a container, give users a chance to
10283            // relinquish resources before killing.
10284            if (isForwardLocked(deletedPackage) || isExternal(deletedPackage)) {
10285                if (DEBUG_INSTALL) {
10286                    Slog.i(TAG, "upgrading pkg " + deletedPackage + " is ASEC-hosted -> UNAVAILABLE");
10287                }
10288                final int[] uidArray = new int[] { deletedPackage.applicationInfo.uid };
10289                final ArrayList<String> pkgList = new ArrayList<String>(1);
10290                pkgList.add(deletedPackage.applicationInfo.packageName);
10291                sendResourcesChangedBroadcast(false, true, pkgList, uidArray, null);
10292            }
10293
10294            deleteCodeCacheDirsLI(pkgName);
10295            try {
10296                final PackageParser.Package newPackage = scanPackageLI(pkg, parseFlags,
10297                        scanFlags | SCAN_UPDATE_TIME, System.currentTimeMillis(), user);
10298                updateSettingsLI(newPackage, installerPackageName, allUsers, perUserInstalled, res);
10299                updatedSettings = true;
10300            } catch (PackageManagerException e) {
10301                res.setError("Package couldn't be installed in " + pkg.codePath, e);
10302            }
10303        }
10304
10305        if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
10306            // remove package from internal structures.  Note that we want deletePackageX to
10307            // delete the package data and cache directories that it created in
10308            // scanPackageLocked, unless those directories existed before we even tried to
10309            // install.
10310            if(updatedSettings) {
10311                if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, rolling pack: " + pkgName);
10312                deletePackageLI(
10313                        pkgName, null, true, allUsers, perUserInstalled,
10314                        PackageManager.DELETE_KEEP_DATA,
10315                                res.removedInfo, true);
10316            }
10317            // Since we failed to install the new package we need to restore the old
10318            // package that we deleted.
10319            if (deletedPkg) {
10320                if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, reinstalling: " + deletedPackage);
10321                File restoreFile = new File(deletedPackage.codePath);
10322                // Parse old package
10323                boolean oldOnSd = isExternal(deletedPackage);
10324                int oldParseFlags  = mDefParseFlags | PackageParser.PARSE_CHATTY |
10325                        (isForwardLocked(deletedPackage) ? PackageParser.PARSE_FORWARD_LOCK : 0) |
10326                        (oldOnSd ? PackageParser.PARSE_ON_SDCARD : 0);
10327                int oldScanFlags = SCAN_UPDATE_SIGNATURE | SCAN_UPDATE_TIME;
10328                try {
10329                    scanPackageLI(restoreFile, oldParseFlags, oldScanFlags, origUpdateTime, null);
10330                } catch (PackageManagerException e) {
10331                    Slog.e(TAG, "Failed to restore package : " + pkgName + " after failed upgrade: "
10332                            + e.getMessage());
10333                    return;
10334                }
10335                // Restore of old package succeeded. Update permissions.
10336                // writer
10337                synchronized (mPackages) {
10338                    updatePermissionsLPw(deletedPackage.packageName, deletedPackage,
10339                            UPDATE_PERMISSIONS_ALL);
10340                    // can downgrade to reader
10341                    mSettings.writeLPr();
10342                }
10343                Slog.i(TAG, "Successfully restored package : " + pkgName + " after failed upgrade");
10344            }
10345        }
10346    }
10347
10348    private void replaceSystemPackageLI(PackageParser.Package deletedPackage,
10349            PackageParser.Package pkg, int parseFlags, int scanFlags, UserHandle user,
10350            int[] allUsers, boolean[] perUserInstalled,
10351            String installerPackageName, PackageInstalledInfo res) {
10352        if (DEBUG_INSTALL) Slog.d(TAG, "replaceSystemPackageLI: new=" + pkg
10353                + ", old=" + deletedPackage);
10354        boolean disabledSystem = false;
10355        boolean updatedSettings = false;
10356        parseFlags |= PackageParser.PARSE_IS_SYSTEM;
10357        if ((deletedPackage.applicationInfo.privateFlags&ApplicationInfo.PRIVATE_FLAG_PRIVILEGED)
10358                != 0) {
10359            parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
10360        }
10361        String packageName = deletedPackage.packageName;
10362        if (packageName == null) {
10363            res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
10364                    "Attempt to delete null packageName.");
10365            return;
10366        }
10367        PackageParser.Package oldPkg;
10368        PackageSetting oldPkgSetting;
10369        // reader
10370        synchronized (mPackages) {
10371            oldPkg = mPackages.get(packageName);
10372            oldPkgSetting = mSettings.mPackages.get(packageName);
10373            if((oldPkg == null) || (oldPkg.applicationInfo == null) ||
10374                    (oldPkgSetting == null)) {
10375                res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
10376                        "Couldn't find package:" + packageName + " information");
10377                return;
10378            }
10379        }
10380
10381        killApplication(packageName, oldPkg.applicationInfo.uid, "replace sys pkg");
10382
10383        res.removedInfo.uid = oldPkg.applicationInfo.uid;
10384        res.removedInfo.removedPackage = packageName;
10385        // Remove existing system package
10386        removePackageLI(oldPkgSetting, true);
10387        // writer
10388        synchronized (mPackages) {
10389            disabledSystem = mSettings.disableSystemPackageLPw(packageName);
10390            if (!disabledSystem && deletedPackage != null) {
10391                // We didn't need to disable the .apk as a current system package,
10392                // which means we are replacing another update that is already
10393                // installed.  We need to make sure to delete the older one's .apk.
10394                res.removedInfo.args = createInstallArgsForExisting(0,
10395                        deletedPackage.applicationInfo.getCodePath(),
10396                        deletedPackage.applicationInfo.getResourcePath(),
10397                        deletedPackage.applicationInfo.nativeLibraryRootDir,
10398                        getAppDexInstructionSets(deletedPackage.applicationInfo));
10399            } else {
10400                res.removedInfo.args = null;
10401            }
10402        }
10403
10404        // Successfully disabled the old package. Now proceed with re-installation
10405        deleteCodeCacheDirsLI(packageName);
10406
10407        res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10408        pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
10409
10410        PackageParser.Package newPackage = null;
10411        try {
10412            newPackage = scanPackageLI(pkg, parseFlags, scanFlags, 0, user);
10413            if (newPackage.mExtras != null) {
10414                final PackageSetting newPkgSetting = (PackageSetting) newPackage.mExtras;
10415                newPkgSetting.firstInstallTime = oldPkgSetting.firstInstallTime;
10416                newPkgSetting.lastUpdateTime = System.currentTimeMillis();
10417
10418                // is the update attempting to change shared user? that isn't going to work...
10419                if (oldPkgSetting.sharedUser != newPkgSetting.sharedUser) {
10420                    res.setError(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
10421                            "Forbidding shared user change from " + oldPkgSetting.sharedUser
10422                            + " to " + newPkgSetting.sharedUser);
10423                    updatedSettings = true;
10424                }
10425            }
10426
10427            if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
10428                updateSettingsLI(newPackage, installerPackageName, allUsers, perUserInstalled, res);
10429                updatedSettings = true;
10430            }
10431
10432        } catch (PackageManagerException e) {
10433            res.setError("Package couldn't be installed in " + pkg.codePath, e);
10434        }
10435
10436        if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
10437            // Re installation failed. Restore old information
10438            // Remove new pkg information
10439            if (newPackage != null) {
10440                removeInstalledPackageLI(newPackage, true);
10441            }
10442            // Add back the old system package
10443            try {
10444                scanPackageLI(oldPkg, parseFlags, SCAN_UPDATE_SIGNATURE, 0, user);
10445            } catch (PackageManagerException e) {
10446                Slog.e(TAG, "Failed to restore original package: " + e.getMessage());
10447            }
10448            // Restore the old system information in Settings
10449            synchronized (mPackages) {
10450                if (disabledSystem) {
10451                    mSettings.enableSystemPackageLPw(packageName);
10452                }
10453                if (updatedSettings) {
10454                    mSettings.setInstallerPackageName(packageName,
10455                            oldPkgSetting.installerPackageName);
10456                }
10457                mSettings.writeLPr();
10458            }
10459        }
10460    }
10461
10462    private void updateSettingsLI(PackageParser.Package newPackage, String installerPackageName,
10463            int[] allUsers, boolean[] perUserInstalled,
10464            PackageInstalledInfo res) {
10465        String pkgName = newPackage.packageName;
10466        synchronized (mPackages) {
10467            //write settings. the installStatus will be incomplete at this stage.
10468            //note that the new package setting would have already been
10469            //added to mPackages. It hasn't been persisted yet.
10470            mSettings.setInstallStatus(pkgName, PackageSettingBase.PKG_INSTALL_INCOMPLETE);
10471            mSettings.writeLPr();
10472        }
10473
10474        if (DEBUG_INSTALL) Slog.d(TAG, "New package installed in " + newPackage.codePath);
10475
10476        synchronized (mPackages) {
10477            updatePermissionsLPw(newPackage.packageName, newPackage,
10478                    UPDATE_PERMISSIONS_REPLACE_PKG | (newPackage.permissions.size() > 0
10479                            ? UPDATE_PERMISSIONS_ALL : 0));
10480            // For system-bundled packages, we assume that installing an upgraded version
10481            // of the package implies that the user actually wants to run that new code,
10482            // so we enable the package.
10483            if (isSystemApp(newPackage)) {
10484                // NB: implicit assumption that system package upgrades apply to all users
10485                if (DEBUG_INSTALL) {
10486                    Slog.d(TAG, "Implicitly enabling system package on upgrade: " + pkgName);
10487                }
10488                PackageSetting ps = mSettings.mPackages.get(pkgName);
10489                if (ps != null) {
10490                    if (res.origUsers != null) {
10491                        for (int userHandle : res.origUsers) {
10492                            ps.setEnabled(COMPONENT_ENABLED_STATE_DEFAULT,
10493                                    userHandle, installerPackageName);
10494                        }
10495                    }
10496                    // Also convey the prior install/uninstall state
10497                    if (allUsers != null && perUserInstalled != null) {
10498                        for (int i = 0; i < allUsers.length; i++) {
10499                            if (DEBUG_INSTALL) {
10500                                Slog.d(TAG, "    user " + allUsers[i]
10501                                        + " => " + perUserInstalled[i]);
10502                            }
10503                            ps.setInstalled(perUserInstalled[i], allUsers[i]);
10504                        }
10505                        // these install state changes will be persisted in the
10506                        // upcoming call to mSettings.writeLPr().
10507                    }
10508                }
10509            }
10510            res.name = pkgName;
10511            res.uid = newPackage.applicationInfo.uid;
10512            res.pkg = newPackage;
10513            mSettings.setInstallStatus(pkgName, PackageSettingBase.PKG_INSTALL_COMPLETE);
10514            mSettings.setInstallerPackageName(pkgName, installerPackageName);
10515            res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10516            //to update install status
10517            mSettings.writeLPr();
10518        }
10519    }
10520
10521    private void installPackageLI(InstallArgs args, PackageInstalledInfo res) {
10522        final int installFlags = args.installFlags;
10523        String installerPackageName = args.installerPackageName;
10524        File tmpPackageFile = new File(args.getCodePath());
10525        boolean forwardLocked = ((installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0);
10526        boolean onSd = ((installFlags & PackageManager.INSTALL_EXTERNAL) != 0);
10527        boolean replace = false;
10528        final int scanFlags = SCAN_NEW_INSTALL | SCAN_FORCE_DEX | SCAN_UPDATE_SIGNATURE;
10529        // Result object to be returned
10530        res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10531
10532        if (DEBUG_INSTALL) Slog.d(TAG, "installPackageLI: path=" + tmpPackageFile);
10533        // Retrieve PackageSettings and parse package
10534        final int parseFlags = mDefParseFlags | PackageParser.PARSE_CHATTY
10535                | (forwardLocked ? PackageParser.PARSE_FORWARD_LOCK : 0)
10536                | (onSd ? PackageParser.PARSE_ON_SDCARD : 0);
10537        PackageParser pp = new PackageParser();
10538        pp.setSeparateProcesses(mSeparateProcesses);
10539        pp.setDisplayMetrics(mMetrics);
10540
10541        final PackageParser.Package pkg;
10542        try {
10543            pkg = pp.parsePackage(tmpPackageFile, parseFlags);
10544        } catch (PackageParserException e) {
10545            res.setError("Failed parse during installPackageLI", e);
10546            return;
10547        }
10548
10549        // Mark that we have an install time CPU ABI override.
10550        pkg.cpuAbiOverride = args.abiOverride;
10551
10552        String pkgName = res.name = pkg.packageName;
10553        if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_TEST_ONLY) != 0) {
10554            if ((installFlags & PackageManager.INSTALL_ALLOW_TEST) == 0) {
10555                res.setError(INSTALL_FAILED_TEST_ONLY, "installPackageLI");
10556                return;
10557            }
10558        }
10559
10560        try {
10561            pp.collectCertificates(pkg, parseFlags);
10562            pp.collectManifestDigest(pkg);
10563        } catch (PackageParserException e) {
10564            res.setError("Failed collect during installPackageLI", e);
10565            return;
10566        }
10567
10568        /* If the installer passed in a manifest digest, compare it now. */
10569        if (args.manifestDigest != null) {
10570            if (DEBUG_INSTALL) {
10571                final String parsedManifest = pkg.manifestDigest == null ? "null"
10572                        : pkg.manifestDigest.toString();
10573                Slog.d(TAG, "Comparing manifests: " + args.manifestDigest.toString() + " vs. "
10574                        + parsedManifest);
10575            }
10576
10577            if (!args.manifestDigest.equals(pkg.manifestDigest)) {
10578                res.setError(INSTALL_FAILED_PACKAGE_CHANGED, "Manifest digest changed");
10579                return;
10580            }
10581        } else if (DEBUG_INSTALL) {
10582            final String parsedManifest = pkg.manifestDigest == null
10583                    ? "null" : pkg.manifestDigest.toString();
10584            Slog.d(TAG, "manifestDigest was not present, but parser got: " + parsedManifest);
10585        }
10586
10587        // Get rid of all references to package scan path via parser.
10588        pp = null;
10589        String oldCodePath = null;
10590        boolean systemApp = false;
10591        synchronized (mPackages) {
10592            // Check if installing already existing package
10593            if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
10594                String oldName = mSettings.mRenamedPackages.get(pkgName);
10595                if (pkg.mOriginalPackages != null
10596                        && pkg.mOriginalPackages.contains(oldName)
10597                        && mPackages.containsKey(oldName)) {
10598                    // This package is derived from an original package,
10599                    // and this device has been updating from that original
10600                    // name.  We must continue using the original name, so
10601                    // rename the new package here.
10602                    pkg.setPackageName(oldName);
10603                    pkgName = pkg.packageName;
10604                    replace = true;
10605                    if (DEBUG_INSTALL) Slog.d(TAG, "Replacing existing renamed package: oldName="
10606                            + oldName + " pkgName=" + pkgName);
10607                } else if (mPackages.containsKey(pkgName)) {
10608                    // This package, under its official name, already exists
10609                    // on the device; we should replace it.
10610                    replace = true;
10611                    if (DEBUG_INSTALL) Slog.d(TAG, "Replace existing pacakge: " + pkgName);
10612                }
10613            }
10614
10615            PackageSetting ps = mSettings.mPackages.get(pkgName);
10616            if (ps != null) {
10617                if (DEBUG_INSTALL) Slog.d(TAG, "Existing package: " + ps);
10618
10619                // Quick sanity check that we're signed correctly if updating;
10620                // we'll check this again later when scanning, but we want to
10621                // bail early here before tripping over redefined permissions.
10622                if (!ps.keySetData.isUsingUpgradeKeySets() || ps.sharedUser != null) {
10623                    try {
10624                        verifySignaturesLP(ps, pkg);
10625                    } catch (PackageManagerException e) {
10626                        res.setError(e.error, e.getMessage());
10627                        return;
10628                    }
10629                } else {
10630                    if (!checkUpgradeKeySetLP(ps, pkg)) {
10631                        res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
10632                                + pkg.packageName + " upgrade keys do not match the "
10633                                + "previously installed version");
10634                        return;
10635                    }
10636                }
10637
10638                oldCodePath = mSettings.mPackages.get(pkgName).codePathString;
10639                if (ps.pkg != null && ps.pkg.applicationInfo != null) {
10640                    systemApp = (ps.pkg.applicationInfo.flags &
10641                            ApplicationInfo.FLAG_SYSTEM) != 0;
10642                }
10643                res.origUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
10644            }
10645
10646            // Check whether the newly-scanned package wants to define an already-defined perm
10647            int N = pkg.permissions.size();
10648            for (int i = N-1; i >= 0; i--) {
10649                PackageParser.Permission perm = pkg.permissions.get(i);
10650                BasePermission bp = mSettings.mPermissions.get(perm.info.name);
10651                if (bp != null) {
10652                    // If the defining package is signed with our cert, it's okay.  This
10653                    // also includes the "updating the same package" case, of course.
10654                    // "updating same package" could also involve key-rotation.
10655                    final boolean sigsOk;
10656                    if (!bp.sourcePackage.equals(pkg.packageName)
10657                            || !(bp.packageSetting instanceof PackageSetting)
10658                            || !bp.packageSetting.keySetData.isUsingUpgradeKeySets()
10659                            || ((PackageSetting) bp.packageSetting).sharedUser != null) {
10660                        sigsOk = compareSignatures(bp.packageSetting.signatures.mSignatures,
10661                                pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;
10662                    } else {
10663                        sigsOk = checkUpgradeKeySetLP((PackageSetting) bp.packageSetting, pkg);
10664                    }
10665                    if (!sigsOk) {
10666                        // If the owning package is the system itself, we log but allow
10667                        // install to proceed; we fail the install on all other permission
10668                        // redefinitions.
10669                        if (!bp.sourcePackage.equals("android")) {
10670                            res.setError(INSTALL_FAILED_DUPLICATE_PERMISSION, "Package "
10671                                    + pkg.packageName + " attempting to redeclare permission "
10672                                    + perm.info.name + " already owned by " + bp.sourcePackage);
10673                            res.origPermission = perm.info.name;
10674                            res.origPackage = bp.sourcePackage;
10675                            return;
10676                        } else {
10677                            Slog.w(TAG, "Package " + pkg.packageName
10678                                    + " attempting to redeclare system permission "
10679                                    + perm.info.name + "; ignoring new declaration");
10680                            pkg.permissions.remove(i);
10681                        }
10682                    }
10683                }
10684            }
10685
10686        }
10687
10688        if (systemApp && onSd) {
10689            // Disable updates to system apps on sdcard
10690            res.setError(INSTALL_FAILED_INVALID_INSTALL_LOCATION,
10691                    "Cannot install updates to system apps on sdcard");
10692            return;
10693        }
10694
10695        if (!args.doRename(res.returnCode, pkg, oldCodePath)) {
10696            res.setError(INSTALL_FAILED_INSUFFICIENT_STORAGE, "Failed rename");
10697            return;
10698        }
10699
10700        if (replace) {
10701            replacePackageLI(pkg, parseFlags, scanFlags | SCAN_REPLACING, args.user,
10702                    installerPackageName, res);
10703        } else {
10704            installNewPackageLI(pkg, parseFlags, scanFlags | SCAN_DELETE_DATA_ON_FAILURES,
10705                    args.user, installerPackageName, res);
10706        }
10707        synchronized (mPackages) {
10708            final PackageSetting ps = mSettings.mPackages.get(pkgName);
10709            if (ps != null) {
10710                res.newUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
10711            }
10712        }
10713    }
10714
10715    private static boolean isForwardLocked(PackageParser.Package pkg) {
10716        return (pkg.applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) != 0;
10717    }
10718
10719    private static boolean isForwardLocked(ApplicationInfo info) {
10720        return (info.privateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) != 0;
10721    }
10722
10723    private boolean isForwardLocked(PackageSetting ps) {
10724        return (ps.pkgPrivateFlags & ApplicationInfo.PRIVATE_FLAG_FORWARD_LOCK) != 0;
10725    }
10726
10727    private static boolean isMultiArch(PackageSetting ps) {
10728        return (ps.pkgFlags & ApplicationInfo.FLAG_MULTIARCH) != 0;
10729    }
10730
10731    private static boolean isMultiArch(ApplicationInfo info) {
10732        return (info.flags & ApplicationInfo.FLAG_MULTIARCH) != 0;
10733    }
10734
10735    private static boolean isExternal(PackageParser.Package pkg) {
10736        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10737    }
10738
10739    private static boolean isExternal(PackageSetting ps) {
10740        return (ps.pkgFlags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10741    }
10742
10743    private static boolean isExternal(ApplicationInfo info) {
10744        return (info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10745    }
10746
10747    private static boolean isSystemApp(PackageParser.Package pkg) {
10748        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
10749    }
10750
10751    private static boolean isPrivilegedApp(PackageParser.Package pkg) {
10752        return (pkg.applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0;
10753    }
10754
10755    private static boolean isSystemApp(ApplicationInfo info) {
10756        return (info.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
10757    }
10758
10759    private static boolean isSystemApp(PackageSetting ps) {
10760        return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0;
10761    }
10762
10763    private static boolean isUpdatedSystemApp(PackageSetting ps) {
10764        return (ps.pkgFlags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10765    }
10766
10767    private static boolean isUpdatedSystemApp(PackageParser.Package pkg) {
10768        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10769    }
10770
10771    private static boolean isUpdatedSystemApp(ApplicationInfo info) {
10772        return (info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10773    }
10774
10775    private int packageFlagsToInstallFlags(PackageSetting ps) {
10776        int installFlags = 0;
10777        if (isExternal(ps)) {
10778            installFlags |= PackageManager.INSTALL_EXTERNAL;
10779        }
10780        if (isForwardLocked(ps)) {
10781            installFlags |= PackageManager.INSTALL_FORWARD_LOCK;
10782        }
10783        return installFlags;
10784    }
10785
10786    private void deleteTempPackageFiles() {
10787        final FilenameFilter filter = new FilenameFilter() {
10788            public boolean accept(File dir, String name) {
10789                return name.startsWith("vmdl") && name.endsWith(".tmp");
10790            }
10791        };
10792        for (File file : mDrmAppPrivateInstallDir.listFiles(filter)) {
10793            file.delete();
10794        }
10795    }
10796
10797    @Override
10798    public void deletePackageAsUser(String packageName, IPackageDeleteObserver observer, int userId,
10799            int flags) {
10800        deletePackage(packageName, new LegacyPackageDeleteObserver(observer).getBinder(), userId,
10801                flags);
10802    }
10803
10804    @Override
10805    public void deletePackage(final String packageName,
10806            final IPackageDeleteObserver2 observer, final int userId, final int flags) {
10807        mContext.enforceCallingOrSelfPermission(
10808                android.Manifest.permission.DELETE_PACKAGES, null);
10809        final int uid = Binder.getCallingUid();
10810        if (UserHandle.getUserId(uid) != userId) {
10811            mContext.enforceCallingPermission(
10812                    android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
10813                    "deletePackage for user " + userId);
10814        }
10815        if (isUserRestricted(userId, UserManager.DISALLOW_UNINSTALL_APPS)) {
10816            try {
10817                observer.onPackageDeleted(packageName,
10818                        PackageManager.DELETE_FAILED_USER_RESTRICTED, null);
10819            } catch (RemoteException re) {
10820            }
10821            return;
10822        }
10823
10824        boolean uninstallBlocked = false;
10825        if ((flags & PackageManager.DELETE_ALL_USERS) != 0) {
10826            int[] users = sUserManager.getUserIds();
10827            for (int i = 0; i < users.length; ++i) {
10828                if (getBlockUninstallForUser(packageName, users[i])) {
10829                    uninstallBlocked = true;
10830                    break;
10831                }
10832            }
10833        } else {
10834            uninstallBlocked = getBlockUninstallForUser(packageName, userId);
10835        }
10836        if (uninstallBlocked) {
10837            try {
10838                observer.onPackageDeleted(packageName, PackageManager.DELETE_FAILED_OWNER_BLOCKED,
10839                        null);
10840            } catch (RemoteException re) {
10841            }
10842            return;
10843        }
10844
10845        if (DEBUG_REMOVE) {
10846            Slog.d(TAG, "deletePackageAsUser: pkg=" + packageName + " user=" + userId);
10847        }
10848        // Queue up an async operation since the package deletion may take a little while.
10849        mHandler.post(new Runnable() {
10850            public void run() {
10851                mHandler.removeCallbacks(this);
10852                final int returnCode = deletePackageX(packageName, userId, flags);
10853                if (observer != null) {
10854                    try {
10855                        observer.onPackageDeleted(packageName, returnCode, null);
10856                    } catch (RemoteException e) {
10857                        Log.i(TAG, "Observer no longer exists.");
10858                    } //end catch
10859                } //end if
10860            } //end run
10861        });
10862    }
10863
10864    private boolean isPackageDeviceAdmin(String packageName, int userId) {
10865        IDevicePolicyManager dpm = IDevicePolicyManager.Stub.asInterface(
10866                ServiceManager.getService(Context.DEVICE_POLICY_SERVICE));
10867        try {
10868            if (dpm != null) {
10869                if (dpm.isDeviceOwner(packageName)) {
10870                    return true;
10871                }
10872                int[] users;
10873                if (userId == UserHandle.USER_ALL) {
10874                    users = sUserManager.getUserIds();
10875                } else {
10876                    users = new int[]{userId};
10877                }
10878                for (int i = 0; i < users.length; ++i) {
10879                    if (dpm.packageHasActiveAdmins(packageName, users[i])) {
10880                        return true;
10881                    }
10882                }
10883            }
10884        } catch (RemoteException e) {
10885        }
10886        return false;
10887    }
10888
10889    /**
10890     *  This method is an internal method that could be get invoked either
10891     *  to delete an installed package or to clean up a failed installation.
10892     *  After deleting an installed package, a broadcast is sent to notify any
10893     *  listeners that the package has been installed. For cleaning up a failed
10894     *  installation, the broadcast is not necessary since the package's
10895     *  installation wouldn't have sent the initial broadcast either
10896     *  The key steps in deleting a package are
10897     *  deleting the package information in internal structures like mPackages,
10898     *  deleting the packages base directories through installd
10899     *  updating mSettings to reflect current status
10900     *  persisting settings for later use
10901     *  sending a broadcast if necessary
10902     */
10903    private int deletePackageX(String packageName, int userId, int flags) {
10904        final PackageRemovedInfo info = new PackageRemovedInfo();
10905        final boolean res;
10906
10907        final UserHandle removeForUser = (flags & PackageManager.DELETE_ALL_USERS) != 0
10908                ? UserHandle.ALL : new UserHandle(userId);
10909
10910        if (isPackageDeviceAdmin(packageName, removeForUser.getIdentifier())) {
10911            Slog.w(TAG, "Not removing package " + packageName + ": has active device admin");
10912            return PackageManager.DELETE_FAILED_DEVICE_POLICY_MANAGER;
10913        }
10914
10915        boolean removedForAllUsers = false;
10916        boolean systemUpdate = false;
10917
10918        // for the uninstall-updates case and restricted profiles, remember the per-
10919        // userhandle installed state
10920        int[] allUsers;
10921        boolean[] perUserInstalled;
10922        synchronized (mPackages) {
10923            PackageSetting ps = mSettings.mPackages.get(packageName);
10924            allUsers = sUserManager.getUserIds();
10925            perUserInstalled = new boolean[allUsers.length];
10926            for (int i = 0; i < allUsers.length; i++) {
10927                perUserInstalled[i] = ps != null ? ps.getInstalled(allUsers[i]) : false;
10928            }
10929        }
10930
10931        synchronized (mInstallLock) {
10932            if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageX: pkg=" + packageName + " user=" + userId);
10933            res = deletePackageLI(packageName, removeForUser,
10934                    true, allUsers, perUserInstalled,
10935                    flags | REMOVE_CHATTY, info, true);
10936            systemUpdate = info.isRemovedPackageSystemUpdate;
10937            if (res && !systemUpdate && mPackages.get(packageName) == null) {
10938                removedForAllUsers = true;
10939            }
10940            if (DEBUG_REMOVE) Slog.d(TAG, "delete res: systemUpdate=" + systemUpdate
10941                    + " removedForAllUsers=" + removedForAllUsers);
10942        }
10943
10944        if (res) {
10945            info.sendBroadcast(true, systemUpdate, removedForAllUsers);
10946
10947            // If the removed package was a system update, the old system package
10948            // was re-enabled; we need to broadcast this information
10949            if (systemUpdate) {
10950                Bundle extras = new Bundle(1);
10951                extras.putInt(Intent.EXTRA_UID, info.removedAppId >= 0
10952                        ? info.removedAppId : info.uid);
10953                extras.putBoolean(Intent.EXTRA_REPLACING, true);
10954
10955                sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, packageName,
10956                        extras, null, null, null);
10957                sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED, packageName,
10958                        extras, null, null, null);
10959                sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED, null,
10960                        null, packageName, null, null);
10961            }
10962        }
10963        // Force a gc here.
10964        Runtime.getRuntime().gc();
10965        // Delete the resources here after sending the broadcast to let
10966        // other processes clean up before deleting resources.
10967        if (info.args != null) {
10968            synchronized (mInstallLock) {
10969                info.args.doPostDeleteLI(true);
10970            }
10971        }
10972
10973        return res ? PackageManager.DELETE_SUCCEEDED : PackageManager.DELETE_FAILED_INTERNAL_ERROR;
10974    }
10975
10976    static class PackageRemovedInfo {
10977        String removedPackage;
10978        int uid = -1;
10979        int removedAppId = -1;
10980        int[] removedUsers = null;
10981        boolean isRemovedPackageSystemUpdate = false;
10982        // Clean up resources deleted packages.
10983        InstallArgs args = null;
10984
10985        void sendBroadcast(boolean fullRemove, boolean replacing, boolean removedForAllUsers) {
10986            Bundle extras = new Bundle(1);
10987            extras.putInt(Intent.EXTRA_UID, removedAppId >= 0 ? removedAppId : uid);
10988            extras.putBoolean(Intent.EXTRA_DATA_REMOVED, fullRemove);
10989            if (replacing) {
10990                extras.putBoolean(Intent.EXTRA_REPLACING, true);
10991            }
10992            extras.putBoolean(Intent.EXTRA_REMOVED_FOR_ALL_USERS, removedForAllUsers);
10993            if (removedPackage != null) {
10994                sendPackageBroadcast(Intent.ACTION_PACKAGE_REMOVED, removedPackage,
10995                        extras, null, null, removedUsers);
10996                if (fullRemove && !replacing) {
10997                    sendPackageBroadcast(Intent.ACTION_PACKAGE_FULLY_REMOVED, removedPackage,
10998                            extras, null, null, removedUsers);
10999                }
11000            }
11001            if (removedAppId >= 0) {
11002                sendPackageBroadcast(Intent.ACTION_UID_REMOVED, null, extras, null, null,
11003                        removedUsers);
11004            }
11005        }
11006    }
11007
11008    /*
11009     * This method deletes the package from internal data structures. If the DONT_DELETE_DATA
11010     * flag is not set, the data directory is removed as well.
11011     * make sure this flag is set for partially installed apps. If not its meaningless to
11012     * delete a partially installed application.
11013     */
11014    private void removePackageDataLI(PackageSetting ps,
11015            int[] allUserHandles, boolean[] perUserInstalled,
11016            PackageRemovedInfo outInfo, int flags, boolean writeSettings) {
11017        String packageName = ps.name;
11018        if (DEBUG_REMOVE) Slog.d(TAG, "removePackageDataLI: " + ps);
11019        removePackageLI(ps, (flags&REMOVE_CHATTY) != 0);
11020        // Retrieve object to delete permissions for shared user later on
11021        final PackageSetting deletedPs;
11022        // reader
11023        synchronized (mPackages) {
11024            deletedPs = mSettings.mPackages.get(packageName);
11025            if (outInfo != null) {
11026                outInfo.removedPackage = packageName;
11027                outInfo.removedUsers = deletedPs != null
11028                        ? deletedPs.queryInstalledUsers(sUserManager.getUserIds(), true)
11029                        : null;
11030            }
11031        }
11032        if ((flags&PackageManager.DELETE_KEEP_DATA) == 0) {
11033            removeDataDirsLI(packageName);
11034            schedulePackageCleaning(packageName, UserHandle.USER_ALL, true);
11035        }
11036        // writer
11037        synchronized (mPackages) {
11038            if (deletedPs != null) {
11039                if ((flags&PackageManager.DELETE_KEEP_DATA) == 0) {
11040                    if (outInfo != null) {
11041                        mSettings.mKeySetManagerService.removeAppKeySetDataLPw(packageName);
11042                        outInfo.removedAppId = mSettings.removePackageLPw(packageName);
11043                    }
11044                    if (deletedPs != null) {
11045                        updatePermissionsLPw(deletedPs.name, null, 0);
11046                        if (deletedPs.sharedUser != null) {
11047                            // remove permissions associated with package
11048                            mSettings.updateSharedUserPermsLPw(deletedPs, mGlobalGids);
11049                        }
11050                    }
11051                    clearPackagePreferredActivitiesLPw(deletedPs.name, UserHandle.USER_ALL);
11052                }
11053                // make sure to preserve per-user disabled state if this removal was just
11054                // a downgrade of a system app to the factory package
11055                if (allUserHandles != null && perUserInstalled != null) {
11056                    if (DEBUG_REMOVE) {
11057                        Slog.d(TAG, "Propagating install state across downgrade");
11058                    }
11059                    for (int i = 0; i < allUserHandles.length; i++) {
11060                        if (DEBUG_REMOVE) {
11061                            Slog.d(TAG, "    user " + allUserHandles[i]
11062                                    + " => " + perUserInstalled[i]);
11063                        }
11064                        ps.setInstalled(perUserInstalled[i], allUserHandles[i]);
11065                    }
11066                }
11067            }
11068            // can downgrade to reader
11069            if (writeSettings) {
11070                // Save settings now
11071                mSettings.writeLPr();
11072            }
11073        }
11074        if (outInfo != null) {
11075            // A user ID was deleted here. Go through all users and remove it
11076            // from KeyStore.
11077            removeKeystoreDataIfNeeded(UserHandle.USER_ALL, outInfo.removedAppId);
11078        }
11079    }
11080
11081    static boolean locationIsPrivileged(File path) {
11082        try {
11083            final String privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app")
11084                    .getCanonicalPath();
11085            return path.getCanonicalPath().startsWith(privilegedAppDir);
11086        } catch (IOException e) {
11087            Slog.e(TAG, "Unable to access code path " + path);
11088        }
11089        return false;
11090    }
11091
11092    /*
11093     * Tries to delete system package.
11094     */
11095    private boolean deleteSystemPackageLI(PackageSetting newPs,
11096            int[] allUserHandles, boolean[] perUserInstalled,
11097            int flags, PackageRemovedInfo outInfo, boolean writeSettings) {
11098        final boolean applyUserRestrictions
11099                = (allUserHandles != null) && (perUserInstalled != null);
11100        PackageSetting disabledPs = null;
11101        // Confirm if the system package has been updated
11102        // An updated system app can be deleted. This will also have to restore
11103        // the system pkg from system partition
11104        // reader
11105        synchronized (mPackages) {
11106            disabledPs = mSettings.getDisabledSystemPkgLPr(newPs.name);
11107        }
11108        if (DEBUG_REMOVE) Slog.d(TAG, "deleteSystemPackageLI: newPs=" + newPs
11109                + " disabledPs=" + disabledPs);
11110        if (disabledPs == null) {
11111            Slog.w(TAG, "Attempt to delete unknown system package "+ newPs.name);
11112            return false;
11113        } else if (DEBUG_REMOVE) {
11114            Slog.d(TAG, "Deleting system pkg from data partition");
11115        }
11116        if (DEBUG_REMOVE) {
11117            if (applyUserRestrictions) {
11118                Slog.d(TAG, "Remembering install states:");
11119                for (int i = 0; i < allUserHandles.length; i++) {
11120                    Slog.d(TAG, "   u=" + allUserHandles[i] + " inst=" + perUserInstalled[i]);
11121                }
11122            }
11123        }
11124        // Delete the updated package
11125        outInfo.isRemovedPackageSystemUpdate = true;
11126        if (disabledPs.versionCode < newPs.versionCode) {
11127            // Delete data for downgrades
11128            flags &= ~PackageManager.DELETE_KEEP_DATA;
11129        } else {
11130            // Preserve data by setting flag
11131            flags |= PackageManager.DELETE_KEEP_DATA;
11132        }
11133        boolean ret = deleteInstalledPackageLI(newPs, true, flags,
11134                allUserHandles, perUserInstalled, outInfo, writeSettings);
11135        if (!ret) {
11136            return false;
11137        }
11138        // writer
11139        synchronized (mPackages) {
11140            // Reinstate the old system package
11141            mSettings.enableSystemPackageLPw(newPs.name);
11142            // Remove any native libraries from the upgraded package.
11143            NativeLibraryHelper.removeNativeBinariesLI(newPs.legacyNativeLibraryPathString);
11144        }
11145        // Install the system package
11146        if (DEBUG_REMOVE) Slog.d(TAG, "Re-installing system package: " + disabledPs);
11147        int parseFlags = PackageParser.PARSE_MUST_BE_APK | PackageParser.PARSE_IS_SYSTEM;
11148        if (locationIsPrivileged(disabledPs.codePath)) {
11149            parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
11150        }
11151
11152        final PackageParser.Package newPkg;
11153        try {
11154            newPkg = scanPackageLI(disabledPs.codePath, parseFlags, SCAN_NO_PATHS, 0, null);
11155        } catch (PackageManagerException e) {
11156            Slog.w(TAG, "Failed to restore system package:" + newPs.name + ": " + e.getMessage());
11157            return false;
11158        }
11159
11160        // writer
11161        synchronized (mPackages) {
11162            PackageSetting ps = mSettings.mPackages.get(newPkg.packageName);
11163            updatePermissionsLPw(newPkg.packageName, newPkg,
11164                    UPDATE_PERMISSIONS_ALL | UPDATE_PERMISSIONS_REPLACE_PKG);
11165            if (applyUserRestrictions) {
11166                if (DEBUG_REMOVE) {
11167                    Slog.d(TAG, "Propagating install state across reinstall");
11168                }
11169                for (int i = 0; i < allUserHandles.length; i++) {
11170                    if (DEBUG_REMOVE) {
11171                        Slog.d(TAG, "    user " + allUserHandles[i]
11172                                + " => " + perUserInstalled[i]);
11173                    }
11174                    ps.setInstalled(perUserInstalled[i], allUserHandles[i]);
11175                }
11176                // Regardless of writeSettings we need to ensure that this restriction
11177                // state propagation is persisted
11178                mSettings.writeAllUsersPackageRestrictionsLPr();
11179            }
11180            // can downgrade to reader here
11181            if (writeSettings) {
11182                mSettings.writeLPr();
11183            }
11184        }
11185        return true;
11186    }
11187
11188    private boolean deleteInstalledPackageLI(PackageSetting ps,
11189            boolean deleteCodeAndResources, int flags,
11190            int[] allUserHandles, boolean[] perUserInstalled,
11191            PackageRemovedInfo outInfo, boolean writeSettings) {
11192        if (outInfo != null) {
11193            outInfo.uid = ps.appId;
11194        }
11195
11196        // Delete package data from internal structures and also remove data if flag is set
11197        removePackageDataLI(ps, allUserHandles, perUserInstalled, outInfo, flags, writeSettings);
11198
11199        // Delete application code and resources
11200        if (deleteCodeAndResources && (outInfo != null)) {
11201            outInfo.args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
11202                    ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
11203                    getAppDexInstructionSets(ps));
11204            if (DEBUG_SD_INSTALL) Slog.i(TAG, "args=" + outInfo.args);
11205        }
11206        return true;
11207    }
11208
11209    @Override
11210    public boolean setBlockUninstallForUser(String packageName, boolean blockUninstall,
11211            int userId) {
11212        mContext.enforceCallingOrSelfPermission(
11213                android.Manifest.permission.DELETE_PACKAGES, null);
11214        synchronized (mPackages) {
11215            PackageSetting ps = mSettings.mPackages.get(packageName);
11216            if (ps == null) {
11217                Log.i(TAG, "Package doesn't exist in set block uninstall " + packageName);
11218                return false;
11219            }
11220            if (!ps.getInstalled(userId)) {
11221                // Can't block uninstall for an app that is not installed or enabled.
11222                Log.i(TAG, "Package not installed in set block uninstall " + packageName);
11223                return false;
11224            }
11225            ps.setBlockUninstall(blockUninstall, userId);
11226            mSettings.writePackageRestrictionsLPr(userId);
11227        }
11228        return true;
11229    }
11230
11231    @Override
11232    public boolean getBlockUninstallForUser(String packageName, int userId) {
11233        synchronized (mPackages) {
11234            PackageSetting ps = mSettings.mPackages.get(packageName);
11235            if (ps == null) {
11236                Log.i(TAG, "Package doesn't exist in get block uninstall " + packageName);
11237                return false;
11238            }
11239            return ps.getBlockUninstall(userId);
11240        }
11241    }
11242
11243    /*
11244     * This method handles package deletion in general
11245     */
11246    private boolean deletePackageLI(String packageName, UserHandle user,
11247            boolean deleteCodeAndResources, int[] allUserHandles, boolean[] perUserInstalled,
11248            int flags, PackageRemovedInfo outInfo,
11249            boolean writeSettings) {
11250        if (packageName == null) {
11251            Slog.w(TAG, "Attempt to delete null packageName.");
11252            return false;
11253        }
11254        if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageLI: " + packageName + " user " + user);
11255        PackageSetting ps;
11256        boolean dataOnly = false;
11257        int removeUser = -1;
11258        int appId = -1;
11259        synchronized (mPackages) {
11260            ps = mSettings.mPackages.get(packageName);
11261            if (ps == null) {
11262                Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
11263                return false;
11264            }
11265            if ((!isSystemApp(ps) || (flags&PackageManager.DELETE_SYSTEM_APP) != 0) && user != null
11266                    && user.getIdentifier() != UserHandle.USER_ALL) {
11267                // The caller is asking that the package only be deleted for a single
11268                // user.  To do this, we just mark its uninstalled state and delete
11269                // its data.  If this is a system app, we only allow this to happen if
11270                // they have set the special DELETE_SYSTEM_APP which requests different
11271                // semantics than normal for uninstalling system apps.
11272                if (DEBUG_REMOVE) Slog.d(TAG, "Only deleting for single user");
11273                ps.setUserState(user.getIdentifier(),
11274                        COMPONENT_ENABLED_STATE_DEFAULT,
11275                        false, //installed
11276                        true,  //stopped
11277                        true,  //notLaunched
11278                        false, //hidden
11279                        null, null, null,
11280                        false // blockUninstall
11281                        );
11282                if (!isSystemApp(ps)) {
11283                    if (ps.isAnyInstalled(sUserManager.getUserIds())) {
11284                        // Other user still have this package installed, so all
11285                        // we need to do is clear this user's data and save that
11286                        // it is uninstalled.
11287                        if (DEBUG_REMOVE) Slog.d(TAG, "Still installed by other users");
11288                        removeUser = user.getIdentifier();
11289                        appId = ps.appId;
11290                        mSettings.writePackageRestrictionsLPr(removeUser);
11291                    } else {
11292                        // We need to set it back to 'installed' so the uninstall
11293                        // broadcasts will be sent correctly.
11294                        if (DEBUG_REMOVE) Slog.d(TAG, "Not installed by other users, full delete");
11295                        ps.setInstalled(true, user.getIdentifier());
11296                    }
11297                } else {
11298                    // This is a system app, so we assume that the
11299                    // other users still have this package installed, so all
11300                    // we need to do is clear this user's data and save that
11301                    // it is uninstalled.
11302                    if (DEBUG_REMOVE) Slog.d(TAG, "Deleting system app");
11303                    removeUser = user.getIdentifier();
11304                    appId = ps.appId;
11305                    mSettings.writePackageRestrictionsLPr(removeUser);
11306                }
11307            }
11308        }
11309
11310        if (removeUser >= 0) {
11311            // From above, we determined that we are deleting this only
11312            // for a single user.  Continue the work here.
11313            if (DEBUG_REMOVE) Slog.d(TAG, "Updating install state for user: " + removeUser);
11314            if (outInfo != null) {
11315                outInfo.removedPackage = packageName;
11316                outInfo.removedAppId = appId;
11317                outInfo.removedUsers = new int[] {removeUser};
11318            }
11319            mInstaller.clearUserData(packageName, removeUser);
11320            removeKeystoreDataIfNeeded(removeUser, appId);
11321            schedulePackageCleaning(packageName, removeUser, false);
11322            return true;
11323        }
11324
11325        if (dataOnly) {
11326            // Delete application data first
11327            if (DEBUG_REMOVE) Slog.d(TAG, "Removing package data only");
11328            removePackageDataLI(ps, null, null, outInfo, flags, writeSettings);
11329            return true;
11330        }
11331
11332        boolean ret = false;
11333        if (isSystemApp(ps)) {
11334            if (DEBUG_REMOVE) Slog.d(TAG, "Removing system package:" + ps.name);
11335            // When an updated system application is deleted we delete the existing resources as well and
11336            // fall back to existing code in system partition
11337            ret = deleteSystemPackageLI(ps, allUserHandles, perUserInstalled,
11338                    flags, outInfo, writeSettings);
11339        } else {
11340            if (DEBUG_REMOVE) Slog.d(TAG, "Removing non-system package:" + ps.name);
11341            // Kill application pre-emptively especially for apps on sd.
11342            killApplication(packageName, ps.appId, "uninstall pkg");
11343            ret = deleteInstalledPackageLI(ps, deleteCodeAndResources, flags,
11344                    allUserHandles, perUserInstalled,
11345                    outInfo, writeSettings);
11346        }
11347
11348        return ret;
11349    }
11350
11351    private final class ClearStorageConnection implements ServiceConnection {
11352        IMediaContainerService mContainerService;
11353
11354        @Override
11355        public void onServiceConnected(ComponentName name, IBinder service) {
11356            synchronized (this) {
11357                mContainerService = IMediaContainerService.Stub.asInterface(service);
11358                notifyAll();
11359            }
11360        }
11361
11362        @Override
11363        public void onServiceDisconnected(ComponentName name) {
11364        }
11365    }
11366
11367    private void clearExternalStorageDataSync(String packageName, int userId, boolean allData) {
11368        final boolean mounted;
11369        if (Environment.isExternalStorageEmulated()) {
11370            mounted = true;
11371        } else {
11372            final String status = Environment.getExternalStorageState();
11373
11374            mounted = status.equals(Environment.MEDIA_MOUNTED)
11375                    || status.equals(Environment.MEDIA_MOUNTED_READ_ONLY);
11376        }
11377
11378        if (!mounted) {
11379            return;
11380        }
11381
11382        final Intent containerIntent = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
11383        int[] users;
11384        if (userId == UserHandle.USER_ALL) {
11385            users = sUserManager.getUserIds();
11386        } else {
11387            users = new int[] { userId };
11388        }
11389        final ClearStorageConnection conn = new ClearStorageConnection();
11390        if (mContext.bindServiceAsUser(
11391                containerIntent, conn, Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
11392            try {
11393                for (int curUser : users) {
11394                    long timeout = SystemClock.uptimeMillis() + 5000;
11395                    synchronized (conn) {
11396                        long now = SystemClock.uptimeMillis();
11397                        while (conn.mContainerService == null && now < timeout) {
11398                            try {
11399                                conn.wait(timeout - now);
11400                            } catch (InterruptedException e) {
11401                            }
11402                        }
11403                    }
11404                    if (conn.mContainerService == null) {
11405                        return;
11406                    }
11407
11408                    final UserEnvironment userEnv = new UserEnvironment(curUser);
11409                    clearDirectory(conn.mContainerService,
11410                            userEnv.buildExternalStorageAppCacheDirs(packageName));
11411                    if (allData) {
11412                        clearDirectory(conn.mContainerService,
11413                                userEnv.buildExternalStorageAppDataDirs(packageName));
11414                        clearDirectory(conn.mContainerService,
11415                                userEnv.buildExternalStorageAppMediaDirs(packageName));
11416                    }
11417                }
11418            } finally {
11419                mContext.unbindService(conn);
11420            }
11421        }
11422    }
11423
11424    @Override
11425    public void clearApplicationUserData(final String packageName,
11426            final IPackageDataObserver observer, final int userId) {
11427        mContext.enforceCallingOrSelfPermission(
11428                android.Manifest.permission.CLEAR_APP_USER_DATA, null);
11429        enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false, "clear application data");
11430        // Queue up an async operation since the package deletion may take a little while.
11431        mHandler.post(new Runnable() {
11432            public void run() {
11433                mHandler.removeCallbacks(this);
11434                final boolean succeeded;
11435                synchronized (mInstallLock) {
11436                    succeeded = clearApplicationUserDataLI(packageName, userId);
11437                }
11438                clearExternalStorageDataSync(packageName, userId, true);
11439                if (succeeded) {
11440                    // invoke DeviceStorageMonitor's update method to clear any notifications
11441                    DeviceStorageMonitorInternal
11442                            dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
11443                    if (dsm != null) {
11444                        dsm.checkMemory();
11445                    }
11446                }
11447                if(observer != null) {
11448                    try {
11449                        observer.onRemoveCompleted(packageName, succeeded);
11450                    } catch (RemoteException e) {
11451                        Log.i(TAG, "Observer no longer exists.");
11452                    }
11453                } //end if observer
11454            } //end run
11455        });
11456    }
11457
11458    private boolean clearApplicationUserDataLI(String packageName, int userId) {
11459        if (packageName == null) {
11460            Slog.w(TAG, "Attempt to delete null packageName.");
11461            return false;
11462        }
11463
11464        // Try finding details about the requested package
11465        PackageParser.Package pkg;
11466        synchronized (mPackages) {
11467            pkg = mPackages.get(packageName);
11468            if (pkg == null) {
11469                final PackageSetting ps = mSettings.mPackages.get(packageName);
11470                if (ps != null) {
11471                    pkg = ps.pkg;
11472                }
11473            }
11474        }
11475
11476        if (pkg == null) {
11477            Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
11478        }
11479
11480        // Always delete data directories for package, even if we found no other
11481        // record of app. This helps users recover from UID mismatches without
11482        // resorting to a full data wipe.
11483        int retCode = mInstaller.clearUserData(packageName, userId);
11484        if (retCode < 0) {
11485            Slog.w(TAG, "Couldn't remove cache files for package: " + packageName);
11486            return false;
11487        }
11488
11489        if (pkg == null) {
11490            return false;
11491        }
11492
11493        if (pkg != null && pkg.applicationInfo != null) {
11494            final int appId = pkg.applicationInfo.uid;
11495            removeKeystoreDataIfNeeded(userId, appId);
11496        }
11497
11498        // Create a native library symlink only if we have native libraries
11499        // and if the native libraries are 32 bit libraries. We do not provide
11500        // this symlink for 64 bit libraries.
11501        if (pkg != null && pkg.applicationInfo.primaryCpuAbi != null &&
11502                !VMRuntime.is64BitAbi(pkg.applicationInfo.primaryCpuAbi)) {
11503            final String nativeLibPath = pkg.applicationInfo.nativeLibraryDir;
11504            if (mInstaller.linkNativeLibraryDirectory(pkg.packageName, nativeLibPath, userId) < 0) {
11505                Slog.w(TAG, "Failed linking native library dir");
11506                return false;
11507            }
11508        }
11509
11510        return true;
11511    }
11512
11513    /**
11514     * Remove entries from the keystore daemon. Will only remove it if the
11515     * {@code appId} is valid.
11516     */
11517    private static void removeKeystoreDataIfNeeded(int userId, int appId) {
11518        if (appId < 0) {
11519            return;
11520        }
11521
11522        final KeyStore keyStore = KeyStore.getInstance();
11523        if (keyStore != null) {
11524            if (userId == UserHandle.USER_ALL) {
11525                for (final int individual : sUserManager.getUserIds()) {
11526                    keyStore.clearUid(UserHandle.getUid(individual, appId));
11527                }
11528            } else {
11529                keyStore.clearUid(UserHandle.getUid(userId, appId));
11530            }
11531        } else {
11532            Slog.w(TAG, "Could not contact keystore to clear entries for app id " + appId);
11533        }
11534    }
11535
11536    @Override
11537    public void deleteApplicationCacheFiles(final String packageName,
11538            final IPackageDataObserver observer) {
11539        mContext.enforceCallingOrSelfPermission(
11540                android.Manifest.permission.DELETE_CACHE_FILES, null);
11541        // Queue up an async operation since the package deletion may take a little while.
11542        final int userId = UserHandle.getCallingUserId();
11543        mHandler.post(new Runnable() {
11544            public void run() {
11545                mHandler.removeCallbacks(this);
11546                final boolean succeded;
11547                synchronized (mInstallLock) {
11548                    succeded = deleteApplicationCacheFilesLI(packageName, userId);
11549                }
11550                clearExternalStorageDataSync(packageName, userId, false);
11551                if(observer != null) {
11552                    try {
11553                        observer.onRemoveCompleted(packageName, succeded);
11554                    } catch (RemoteException e) {
11555                        Log.i(TAG, "Observer no longer exists.");
11556                    }
11557                } //end if observer
11558            } //end run
11559        });
11560    }
11561
11562    private boolean deleteApplicationCacheFilesLI(String packageName, int userId) {
11563        if (packageName == null) {
11564            Slog.w(TAG, "Attempt to delete null packageName.");
11565            return false;
11566        }
11567        PackageParser.Package p;
11568        synchronized (mPackages) {
11569            p = mPackages.get(packageName);
11570        }
11571        if (p == null) {
11572            Slog.w(TAG, "Package named '" + packageName +"' doesn't exist.");
11573            return false;
11574        }
11575        final ApplicationInfo applicationInfo = p.applicationInfo;
11576        if (applicationInfo == null) {
11577            Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
11578            return false;
11579        }
11580        int retCode = mInstaller.deleteCacheFiles(packageName, userId);
11581        if (retCode < 0) {
11582            Slog.w(TAG, "Couldn't remove cache files for package: "
11583                       + packageName + " u" + userId);
11584            return false;
11585        }
11586        return true;
11587    }
11588
11589    @Override
11590    public void getPackageSizeInfo(final String packageName, int userHandle,
11591            final IPackageStatsObserver observer) {
11592        mContext.enforceCallingOrSelfPermission(
11593                android.Manifest.permission.GET_PACKAGE_SIZE, null);
11594        if (packageName == null) {
11595            throw new IllegalArgumentException("Attempt to get size of null packageName");
11596        }
11597
11598        PackageStats stats = new PackageStats(packageName, userHandle);
11599
11600        /*
11601         * Queue up an async operation since the package measurement may take a
11602         * little while.
11603         */
11604        Message msg = mHandler.obtainMessage(INIT_COPY);
11605        msg.obj = new MeasureParams(stats, observer);
11606        mHandler.sendMessage(msg);
11607    }
11608
11609    private boolean getPackageSizeInfoLI(String packageName, int userHandle,
11610            PackageStats pStats) {
11611        if (packageName == null) {
11612            Slog.w(TAG, "Attempt to get size of null packageName.");
11613            return false;
11614        }
11615        PackageParser.Package p;
11616        boolean dataOnly = false;
11617        String libDirRoot = null;
11618        String asecPath = null;
11619        PackageSetting ps = null;
11620        synchronized (mPackages) {
11621            p = mPackages.get(packageName);
11622            ps = mSettings.mPackages.get(packageName);
11623            if(p == null) {
11624                dataOnly = true;
11625                if((ps == null) || (ps.pkg == null)) {
11626                    Slog.w(TAG, "Package named '" + packageName +"' doesn't exist.");
11627                    return false;
11628                }
11629                p = ps.pkg;
11630            }
11631            if (ps != null) {
11632                libDirRoot = ps.legacyNativeLibraryPathString;
11633            }
11634            if (p != null && (isExternal(p) || isForwardLocked(p))) {
11635                String secureContainerId = cidFromCodePath(p.applicationInfo.getBaseCodePath());
11636                if (secureContainerId != null) {
11637                    asecPath = PackageHelper.getSdFilesystem(secureContainerId);
11638                }
11639            }
11640        }
11641        String publicSrcDir = null;
11642        if(!dataOnly) {
11643            final ApplicationInfo applicationInfo = p.applicationInfo;
11644            if (applicationInfo == null) {
11645                Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
11646                return false;
11647            }
11648            if (isForwardLocked(p)) {
11649                publicSrcDir = applicationInfo.getBaseResourcePath();
11650            }
11651        }
11652        // TODO: extend to measure size of split APKs
11653        // TODO(multiArch): Extend getSizeInfo to look at the full subdirectory tree,
11654        // not just the first level.
11655        // TODO(multiArch): Extend getSizeInfo to look at *all* instruction sets, not
11656        // just the primary.
11657        String[] dexCodeInstructionSets = getDexCodeInstructionSets(getAppDexInstructionSets(ps));
11658        int res = mInstaller.getSizeInfo(packageName, userHandle, p.baseCodePath, libDirRoot,
11659                publicSrcDir, asecPath, dexCodeInstructionSets, pStats);
11660        if (res < 0) {
11661            return false;
11662        }
11663
11664        // Fix-up for forward-locked applications in ASEC containers.
11665        if (!isExternal(p)) {
11666            pStats.codeSize += pStats.externalCodeSize;
11667            pStats.externalCodeSize = 0L;
11668        }
11669
11670        return true;
11671    }
11672
11673
11674    @Override
11675    public void addPackageToPreferred(String packageName) {
11676        Slog.w(TAG, "addPackageToPreferred: this is now a no-op");
11677    }
11678
11679    @Override
11680    public void removePackageFromPreferred(String packageName) {
11681        Slog.w(TAG, "removePackageFromPreferred: this is now a no-op");
11682    }
11683
11684    @Override
11685    public List<PackageInfo> getPreferredPackages(int flags) {
11686        return new ArrayList<PackageInfo>();
11687    }
11688
11689    private int getUidTargetSdkVersionLockedLPr(int uid) {
11690        Object obj = mSettings.getUserIdLPr(uid);
11691        if (obj instanceof SharedUserSetting) {
11692            final SharedUserSetting sus = (SharedUserSetting) obj;
11693            int vers = Build.VERSION_CODES.CUR_DEVELOPMENT;
11694            final Iterator<PackageSetting> it = sus.packages.iterator();
11695            while (it.hasNext()) {
11696                final PackageSetting ps = it.next();
11697                if (ps.pkg != null) {
11698                    int v = ps.pkg.applicationInfo.targetSdkVersion;
11699                    if (v < vers) vers = v;
11700                }
11701            }
11702            return vers;
11703        } else if (obj instanceof PackageSetting) {
11704            final PackageSetting ps = (PackageSetting) obj;
11705            if (ps.pkg != null) {
11706                return ps.pkg.applicationInfo.targetSdkVersion;
11707            }
11708        }
11709        return Build.VERSION_CODES.CUR_DEVELOPMENT;
11710    }
11711
11712    @Override
11713    public void addPreferredActivity(IntentFilter filter, int match,
11714            ComponentName[] set, ComponentName activity, int userId) {
11715        addPreferredActivityInternal(filter, match, set, activity, true, userId,
11716                "Adding preferred");
11717    }
11718
11719    private void addPreferredActivityInternal(IntentFilter filter, int match,
11720            ComponentName[] set, ComponentName activity, boolean always, int userId,
11721            String opname) {
11722        // writer
11723        int callingUid = Binder.getCallingUid();
11724        enforceCrossUserPermission(callingUid, userId, true, false, "add preferred activity");
11725        if (filter.countActions() == 0) {
11726            Slog.w(TAG, "Cannot set a preferred activity with no filter actions");
11727            return;
11728        }
11729        synchronized (mPackages) {
11730            if (mContext.checkCallingOrSelfPermission(
11731                    android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11732                    != PackageManager.PERMISSION_GRANTED) {
11733                if (getUidTargetSdkVersionLockedLPr(callingUid)
11734                        < Build.VERSION_CODES.FROYO) {
11735                    Slog.w(TAG, "Ignoring addPreferredActivity() from uid "
11736                            + callingUid);
11737                    return;
11738                }
11739                mContext.enforceCallingOrSelfPermission(
11740                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11741            }
11742
11743            PreferredIntentResolver pir = mSettings.editPreferredActivitiesLPw(userId);
11744            Slog.i(TAG, opname + " activity " + activity.flattenToShortString() + " for user "
11745                    + userId + ":");
11746            filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11747            pir.addFilter(new PreferredActivity(filter, match, set, activity, always));
11748            scheduleWritePackageRestrictionsLocked(userId);
11749        }
11750    }
11751
11752    @Override
11753    public void replacePreferredActivity(IntentFilter filter, int match,
11754            ComponentName[] set, ComponentName activity, int userId) {
11755        if (filter.countActions() != 1) {
11756            throw new IllegalArgumentException(
11757                    "replacePreferredActivity expects filter to have only 1 action.");
11758        }
11759        if (filter.countDataAuthorities() != 0
11760                || filter.countDataPaths() != 0
11761                || filter.countDataSchemes() > 1
11762                || filter.countDataTypes() != 0) {
11763            throw new IllegalArgumentException(
11764                    "replacePreferredActivity expects filter to have no data authorities, " +
11765                    "paths, or types; and at most one scheme.");
11766        }
11767
11768        final int callingUid = Binder.getCallingUid();
11769        enforceCrossUserPermission(callingUid, userId, true, false, "replace preferred activity");
11770        synchronized (mPackages) {
11771            if (mContext.checkCallingOrSelfPermission(
11772                    android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11773                    != PackageManager.PERMISSION_GRANTED) {
11774                if (getUidTargetSdkVersionLockedLPr(callingUid)
11775                        < Build.VERSION_CODES.FROYO) {
11776                    Slog.w(TAG, "Ignoring replacePreferredActivity() from uid "
11777                            + Binder.getCallingUid());
11778                    return;
11779                }
11780                mContext.enforceCallingOrSelfPermission(
11781                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11782            }
11783
11784            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
11785            if (pir != null) {
11786                // Get all of the existing entries that exactly match this filter.
11787                ArrayList<PreferredActivity> existing = pir.findFilters(filter);
11788                if (existing != null && existing.size() == 1) {
11789                    PreferredActivity cur = existing.get(0);
11790                    if (DEBUG_PREFERRED) {
11791                        Slog.i(TAG, "Checking replace of preferred:");
11792                        filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11793                        if (!cur.mPref.mAlways) {
11794                            Slog.i(TAG, "  -- CUR; not mAlways!");
11795                        } else {
11796                            Slog.i(TAG, "  -- CUR: mMatch=" + cur.mPref.mMatch);
11797                            Slog.i(TAG, "  -- CUR: mSet="
11798                                    + Arrays.toString(cur.mPref.mSetComponents));
11799                            Slog.i(TAG, "  -- CUR: mComponent=" + cur.mPref.mShortComponent);
11800                            Slog.i(TAG, "  -- NEW: mMatch="
11801                                    + (match&IntentFilter.MATCH_CATEGORY_MASK));
11802                            Slog.i(TAG, "  -- CUR: mSet=" + Arrays.toString(set));
11803                            Slog.i(TAG, "  -- CUR: mComponent=" + activity.flattenToShortString());
11804                        }
11805                    }
11806                    if (cur.mPref.mAlways && cur.mPref.mComponent.equals(activity)
11807                            && cur.mPref.mMatch == (match&IntentFilter.MATCH_CATEGORY_MASK)
11808                            && cur.mPref.sameSet(set)) {
11809                        // Setting the preferred activity to what it happens to be already
11810                        if (DEBUG_PREFERRED) {
11811                            Slog.i(TAG, "Replacing with same preferred activity "
11812                                    + cur.mPref.mShortComponent + " for user "
11813                                    + userId + ":");
11814                            filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11815                        }
11816                        return;
11817                    }
11818                }
11819
11820                if (existing != null) {
11821                    if (DEBUG_PREFERRED) {
11822                        Slog.i(TAG, existing.size() + " existing preferred matches for:");
11823                        filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11824                    }
11825                    for (int i = 0; i < existing.size(); i++) {
11826                        PreferredActivity pa = existing.get(i);
11827                        if (DEBUG_PREFERRED) {
11828                            Slog.i(TAG, "Removing existing preferred activity "
11829                                    + pa.mPref.mComponent + ":");
11830                            pa.dump(new LogPrinter(Log.INFO, TAG), "  ");
11831                        }
11832                        pir.removeFilter(pa);
11833                    }
11834                }
11835            }
11836            addPreferredActivityInternal(filter, match, set, activity, true, userId,
11837                    "Replacing preferred");
11838        }
11839    }
11840
11841    @Override
11842    public void clearPackagePreferredActivities(String packageName) {
11843        final int uid = Binder.getCallingUid();
11844        // writer
11845        synchronized (mPackages) {
11846            PackageParser.Package pkg = mPackages.get(packageName);
11847            if (pkg == null || pkg.applicationInfo.uid != uid) {
11848                if (mContext.checkCallingOrSelfPermission(
11849                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11850                        != PackageManager.PERMISSION_GRANTED) {
11851                    if (getUidTargetSdkVersionLockedLPr(Binder.getCallingUid())
11852                            < Build.VERSION_CODES.FROYO) {
11853                        Slog.w(TAG, "Ignoring clearPackagePreferredActivities() from uid "
11854                                + Binder.getCallingUid());
11855                        return;
11856                    }
11857                    mContext.enforceCallingOrSelfPermission(
11858                            android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11859                }
11860            }
11861
11862            int user = UserHandle.getCallingUserId();
11863            if (clearPackagePreferredActivitiesLPw(packageName, user)) {
11864                scheduleWritePackageRestrictionsLocked(user);
11865            }
11866        }
11867    }
11868
11869    /** This method takes a specific user id as well as UserHandle.USER_ALL. */
11870    boolean clearPackagePreferredActivitiesLPw(String packageName, int userId) {
11871        ArrayList<PreferredActivity> removed = null;
11872        boolean changed = false;
11873        for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
11874            final int thisUserId = mSettings.mPreferredActivities.keyAt(i);
11875            PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
11876            if (userId != UserHandle.USER_ALL && userId != thisUserId) {
11877                continue;
11878            }
11879            Iterator<PreferredActivity> it = pir.filterIterator();
11880            while (it.hasNext()) {
11881                PreferredActivity pa = it.next();
11882                // Mark entry for removal only if it matches the package name
11883                // and the entry is of type "always".
11884                if (packageName == null ||
11885                        (pa.mPref.mComponent.getPackageName().equals(packageName)
11886                                && pa.mPref.mAlways)) {
11887                    if (removed == null) {
11888                        removed = new ArrayList<PreferredActivity>();
11889                    }
11890                    removed.add(pa);
11891                }
11892            }
11893            if (removed != null) {
11894                for (int j=0; j<removed.size(); j++) {
11895                    PreferredActivity pa = removed.get(j);
11896                    pir.removeFilter(pa);
11897                }
11898                changed = true;
11899            }
11900        }
11901        return changed;
11902    }
11903
11904    @Override
11905    public void resetPreferredActivities(int userId) {
11906        /* TODO: Actually use userId. Why is it being passed in? */
11907        mContext.enforceCallingOrSelfPermission(
11908                android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11909        // writer
11910        synchronized (mPackages) {
11911            int user = UserHandle.getCallingUserId();
11912            clearPackagePreferredActivitiesLPw(null, user);
11913            mSettings.readDefaultPreferredAppsLPw(this, user);
11914            scheduleWritePackageRestrictionsLocked(user);
11915        }
11916    }
11917
11918    @Override
11919    public int getPreferredActivities(List<IntentFilter> outFilters,
11920            List<ComponentName> outActivities, String packageName) {
11921
11922        int num = 0;
11923        final int userId = UserHandle.getCallingUserId();
11924        // reader
11925        synchronized (mPackages) {
11926            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
11927            if (pir != null) {
11928                final Iterator<PreferredActivity> it = pir.filterIterator();
11929                while (it.hasNext()) {
11930                    final PreferredActivity pa = it.next();
11931                    if (packageName == null
11932                            || (pa.mPref.mComponent.getPackageName().equals(packageName)
11933                                    && pa.mPref.mAlways)) {
11934                        if (outFilters != null) {
11935                            outFilters.add(new IntentFilter(pa));
11936                        }
11937                        if (outActivities != null) {
11938                            outActivities.add(pa.mPref.mComponent);
11939                        }
11940                    }
11941                }
11942            }
11943        }
11944
11945        return num;
11946    }
11947
11948    @Override
11949    public void addPersistentPreferredActivity(IntentFilter filter, ComponentName activity,
11950            int userId) {
11951        int callingUid = Binder.getCallingUid();
11952        if (callingUid != Process.SYSTEM_UID) {
11953            throw new SecurityException(
11954                    "addPersistentPreferredActivity can only be run by the system");
11955        }
11956        if (filter.countActions() == 0) {
11957            Slog.w(TAG, "Cannot set a preferred activity with no filter actions");
11958            return;
11959        }
11960        synchronized (mPackages) {
11961            Slog.i(TAG, "Adding persistent preferred activity " + activity + " for user " + userId +
11962                    " :");
11963            filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11964            mSettings.editPersistentPreferredActivitiesLPw(userId).addFilter(
11965                    new PersistentPreferredActivity(filter, activity));
11966            scheduleWritePackageRestrictionsLocked(userId);
11967        }
11968    }
11969
11970    @Override
11971    public void clearPackagePersistentPreferredActivities(String packageName, int userId) {
11972        int callingUid = Binder.getCallingUid();
11973        if (callingUid != Process.SYSTEM_UID) {
11974            throw new SecurityException(
11975                    "clearPackagePersistentPreferredActivities can only be run by the system");
11976        }
11977        ArrayList<PersistentPreferredActivity> removed = null;
11978        boolean changed = false;
11979        synchronized (mPackages) {
11980            for (int i=0; i<mSettings.mPersistentPreferredActivities.size(); i++) {
11981                final int thisUserId = mSettings.mPersistentPreferredActivities.keyAt(i);
11982                PersistentPreferredIntentResolver ppir = mSettings.mPersistentPreferredActivities
11983                        .valueAt(i);
11984                if (userId != thisUserId) {
11985                    continue;
11986                }
11987                Iterator<PersistentPreferredActivity> it = ppir.filterIterator();
11988                while (it.hasNext()) {
11989                    PersistentPreferredActivity ppa = it.next();
11990                    // Mark entry for removal only if it matches the package name.
11991                    if (ppa.mComponent.getPackageName().equals(packageName)) {
11992                        if (removed == null) {
11993                            removed = new ArrayList<PersistentPreferredActivity>();
11994                        }
11995                        removed.add(ppa);
11996                    }
11997                }
11998                if (removed != null) {
11999                    for (int j=0; j<removed.size(); j++) {
12000                        PersistentPreferredActivity ppa = removed.get(j);
12001                        ppir.removeFilter(ppa);
12002                    }
12003                    changed = true;
12004                }
12005            }
12006
12007            if (changed) {
12008                scheduleWritePackageRestrictionsLocked(userId);
12009            }
12010        }
12011    }
12012
12013    @Override
12014    public void addCrossProfileIntentFilter(IntentFilter intentFilter, String ownerPackage,
12015            int ownerUserId, int sourceUserId, int targetUserId, int flags) {
12016        mContext.enforceCallingOrSelfPermission(
12017                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
12018        int callingUid = Binder.getCallingUid();
12019        enforceOwnerRights(ownerPackage, ownerUserId, callingUid);
12020        enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, callingUid, sourceUserId);
12021        if (intentFilter.countActions() == 0) {
12022            Slog.w(TAG, "Cannot set a crossProfile intent filter with no filter actions");
12023            return;
12024        }
12025        synchronized (mPackages) {
12026            CrossProfileIntentFilter newFilter = new CrossProfileIntentFilter(intentFilter,
12027                    ownerPackage, UserHandle.getUserId(callingUid), targetUserId, flags);
12028            CrossProfileIntentResolver resolver =
12029                    mSettings.editCrossProfileIntentResolverLPw(sourceUserId);
12030            ArrayList<CrossProfileIntentFilter> existing = resolver.findFilters(intentFilter);
12031            // We have all those whose filter is equal. Now checking if the rest is equal as well.
12032            if (existing != null) {
12033                int size = existing.size();
12034                for (int i = 0; i < size; i++) {
12035                    if (newFilter.equalsIgnoreFilter(existing.get(i))) {
12036                        return;
12037                    }
12038                }
12039            }
12040            resolver.addFilter(newFilter);
12041            scheduleWritePackageRestrictionsLocked(sourceUserId);
12042        }
12043    }
12044
12045    @Override
12046    public void clearCrossProfileIntentFilters(int sourceUserId, String ownerPackage,
12047            int ownerUserId) {
12048        mContext.enforceCallingOrSelfPermission(
12049                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
12050        int callingUid = Binder.getCallingUid();
12051        enforceOwnerRights(ownerPackage, ownerUserId, callingUid);
12052        enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, callingUid, sourceUserId);
12053        int callingUserId = UserHandle.getUserId(callingUid);
12054        synchronized (mPackages) {
12055            CrossProfileIntentResolver resolver =
12056                    mSettings.editCrossProfileIntentResolverLPw(sourceUserId);
12057            ArraySet<CrossProfileIntentFilter> set =
12058                    new ArraySet<CrossProfileIntentFilter>(resolver.filterSet());
12059            for (CrossProfileIntentFilter filter : set) {
12060                if (filter.getOwnerPackage().equals(ownerPackage)
12061                        && filter.getOwnerUserId() == callingUserId) {
12062                    resolver.removeFilter(filter);
12063                }
12064            }
12065            scheduleWritePackageRestrictionsLocked(sourceUserId);
12066        }
12067    }
12068
12069    // Enforcing that callingUid is owning pkg on userId
12070    private void enforceOwnerRights(String pkg, int userId, int callingUid) {
12071        // The system owns everything.
12072        if (UserHandle.getAppId(callingUid) == Process.SYSTEM_UID) {
12073            return;
12074        }
12075        int callingUserId = UserHandle.getUserId(callingUid);
12076        if (callingUserId != userId) {
12077            throw new SecurityException("calling uid " + callingUid
12078                    + " pretends to own " + pkg + " on user " + userId + " but belongs to user "
12079                    + callingUserId);
12080        }
12081        PackageInfo pi = getPackageInfo(pkg, 0, callingUserId);
12082        if (pi == null) {
12083            throw new IllegalArgumentException("Unknown package " + pkg + " on user "
12084                    + callingUserId);
12085        }
12086        if (!UserHandle.isSameApp(pi.applicationInfo.uid, callingUid)) {
12087            throw new SecurityException("Calling uid " + callingUid
12088                    + " does not own package " + pkg);
12089        }
12090    }
12091
12092    @Override
12093    public ComponentName getHomeActivities(List<ResolveInfo> allHomeCandidates) {
12094        Intent intent = new Intent(Intent.ACTION_MAIN);
12095        intent.addCategory(Intent.CATEGORY_HOME);
12096
12097        final int callingUserId = UserHandle.getCallingUserId();
12098        List<ResolveInfo> list = queryIntentActivities(intent, null,
12099                PackageManager.GET_META_DATA, callingUserId);
12100        ResolveInfo preferred = findPreferredActivity(intent, null, 0, list, 0,
12101                true, false, false, callingUserId);
12102
12103        allHomeCandidates.clear();
12104        if (list != null) {
12105            for (ResolveInfo ri : list) {
12106                allHomeCandidates.add(ri);
12107            }
12108        }
12109        return (preferred == null || preferred.activityInfo == null)
12110                ? null
12111                : new ComponentName(preferred.activityInfo.packageName,
12112                        preferred.activityInfo.name);
12113    }
12114
12115    @Override
12116    public void setApplicationEnabledSetting(String appPackageName,
12117            int newState, int flags, int userId, String callingPackage) {
12118        if (!sUserManager.exists(userId)) return;
12119        if (callingPackage == null) {
12120            callingPackage = Integer.toString(Binder.getCallingUid());
12121        }
12122        setEnabledSetting(appPackageName, null, newState, flags, userId, callingPackage);
12123    }
12124
12125    @Override
12126    public void setComponentEnabledSetting(ComponentName componentName,
12127            int newState, int flags, int userId) {
12128        if (!sUserManager.exists(userId)) return;
12129        setEnabledSetting(componentName.getPackageName(),
12130                componentName.getClassName(), newState, flags, userId, null);
12131    }
12132
12133    private void setEnabledSetting(final String packageName, String className, int newState,
12134            final int flags, int userId, String callingPackage) {
12135        if (!(newState == COMPONENT_ENABLED_STATE_DEFAULT
12136              || newState == COMPONENT_ENABLED_STATE_ENABLED
12137              || newState == COMPONENT_ENABLED_STATE_DISABLED
12138              || newState == COMPONENT_ENABLED_STATE_DISABLED_USER
12139              || newState == COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED)) {
12140            throw new IllegalArgumentException("Invalid new component state: "
12141                    + newState);
12142        }
12143        PackageSetting pkgSetting;
12144        final int uid = Binder.getCallingUid();
12145        final int permission = mContext.checkCallingOrSelfPermission(
12146                android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE);
12147        enforceCrossUserPermission(uid, userId, false, true, "set enabled");
12148        final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED);
12149        boolean sendNow = false;
12150        boolean isApp = (className == null);
12151        String componentName = isApp ? packageName : className;
12152        int packageUid = -1;
12153        ArrayList<String> components;
12154
12155        // writer
12156        synchronized (mPackages) {
12157            pkgSetting = mSettings.mPackages.get(packageName);
12158            if (pkgSetting == null) {
12159                if (className == null) {
12160                    throw new IllegalArgumentException(
12161                            "Unknown package: " + packageName);
12162                }
12163                throw new IllegalArgumentException(
12164                        "Unknown component: " + packageName
12165                        + "/" + className);
12166            }
12167            // Allow root and verify that userId is not being specified by a different user
12168            if (!allowedByPermission && !UserHandle.isSameApp(uid, pkgSetting.appId)) {
12169                throw new SecurityException(
12170                        "Permission Denial: attempt to change component state from pid="
12171                        + Binder.getCallingPid()
12172                        + ", uid=" + uid + ", package uid=" + pkgSetting.appId);
12173            }
12174            if (className == null) {
12175                // We're dealing with an application/package level state change
12176                if (pkgSetting.getEnabled(userId) == newState) {
12177                    // Nothing to do
12178                    return;
12179                }
12180                if (newState == PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
12181                    || newState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
12182                    // Don't care about who enables an app.
12183                    callingPackage = null;
12184                }
12185                pkgSetting.setEnabled(newState, userId, callingPackage);
12186                // pkgSetting.pkg.mSetEnabled = newState;
12187            } else {
12188                // We're dealing with a component level state change
12189                // First, verify that this is a valid class name.
12190                PackageParser.Package pkg = pkgSetting.pkg;
12191                if (pkg == null || !pkg.hasComponentClassName(className)) {
12192                    if (pkg.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.JELLY_BEAN) {
12193                        throw new IllegalArgumentException("Component class " + className
12194                                + " does not exist in " + packageName);
12195                    } else {
12196                        Slog.w(TAG, "Failed setComponentEnabledSetting: component class "
12197                                + className + " does not exist in " + packageName);
12198                    }
12199                }
12200                switch (newState) {
12201                case COMPONENT_ENABLED_STATE_ENABLED:
12202                    if (!pkgSetting.enableComponentLPw(className, userId)) {
12203                        return;
12204                    }
12205                    break;
12206                case COMPONENT_ENABLED_STATE_DISABLED:
12207                    if (!pkgSetting.disableComponentLPw(className, userId)) {
12208                        return;
12209                    }
12210                    break;
12211                case COMPONENT_ENABLED_STATE_DEFAULT:
12212                    if (!pkgSetting.restoreComponentLPw(className, userId)) {
12213                        return;
12214                    }
12215                    break;
12216                default:
12217                    Slog.e(TAG, "Invalid new component state: " + newState);
12218                    return;
12219                }
12220            }
12221            mSettings.writePackageRestrictionsLPr(userId);
12222            components = mPendingBroadcasts.get(userId, packageName);
12223            final boolean newPackage = components == null;
12224            if (newPackage) {
12225                components = new ArrayList<String>();
12226            }
12227            if (!components.contains(componentName)) {
12228                components.add(componentName);
12229            }
12230            if ((flags&PackageManager.DONT_KILL_APP) == 0) {
12231                sendNow = true;
12232                // Purge entry from pending broadcast list if another one exists already
12233                // since we are sending one right away.
12234                mPendingBroadcasts.remove(userId, packageName);
12235            } else {
12236                if (newPackage) {
12237                    mPendingBroadcasts.put(userId, packageName, components);
12238                }
12239                if (!mHandler.hasMessages(SEND_PENDING_BROADCAST)) {
12240                    // Schedule a message
12241                    mHandler.sendEmptyMessageDelayed(SEND_PENDING_BROADCAST, BROADCAST_DELAY);
12242                }
12243            }
12244        }
12245
12246        long callingId = Binder.clearCallingIdentity();
12247        try {
12248            if (sendNow) {
12249                packageUid = UserHandle.getUid(userId, pkgSetting.appId);
12250                sendPackageChangedBroadcast(packageName,
12251                        (flags&PackageManager.DONT_KILL_APP) != 0, components, packageUid);
12252            }
12253        } finally {
12254            Binder.restoreCallingIdentity(callingId);
12255        }
12256    }
12257
12258    private void sendPackageChangedBroadcast(String packageName,
12259            boolean killFlag, ArrayList<String> componentNames, int packageUid) {
12260        if (DEBUG_INSTALL)
12261            Log.v(TAG, "Sending package changed: package=" + packageName + " components="
12262                    + componentNames);
12263        Bundle extras = new Bundle(4);
12264        extras.putString(Intent.EXTRA_CHANGED_COMPONENT_NAME, componentNames.get(0));
12265        String nameList[] = new String[componentNames.size()];
12266        componentNames.toArray(nameList);
12267        extras.putStringArray(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST, nameList);
12268        extras.putBoolean(Intent.EXTRA_DONT_KILL_APP, killFlag);
12269        extras.putInt(Intent.EXTRA_UID, packageUid);
12270        sendPackageBroadcast(Intent.ACTION_PACKAGE_CHANGED,  packageName, extras, null, null,
12271                new int[] {UserHandle.getUserId(packageUid)});
12272    }
12273
12274    @Override
12275    public void setPackageStoppedState(String packageName, boolean stopped, int userId) {
12276        if (!sUserManager.exists(userId)) return;
12277        final int uid = Binder.getCallingUid();
12278        final int permission = mContext.checkCallingOrSelfPermission(
12279                android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE);
12280        final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED);
12281        enforceCrossUserPermission(uid, userId, true, true, "stop package");
12282        // writer
12283        synchronized (mPackages) {
12284            if (mSettings.setPackageStoppedStateLPw(packageName, stopped, allowedByPermission,
12285                    uid, userId)) {
12286                scheduleWritePackageRestrictionsLocked(userId);
12287            }
12288        }
12289    }
12290
12291    @Override
12292    public String getInstallerPackageName(String packageName) {
12293        // reader
12294        synchronized (mPackages) {
12295            return mSettings.getInstallerPackageNameLPr(packageName);
12296        }
12297    }
12298
12299    @Override
12300    public int getApplicationEnabledSetting(String packageName, int userId) {
12301        if (!sUserManager.exists(userId)) return COMPONENT_ENABLED_STATE_DISABLED;
12302        int uid = Binder.getCallingUid();
12303        enforceCrossUserPermission(uid, userId, false, false, "get enabled");
12304        // reader
12305        synchronized (mPackages) {
12306            return mSettings.getApplicationEnabledSettingLPr(packageName, userId);
12307        }
12308    }
12309
12310    @Override
12311    public int getComponentEnabledSetting(ComponentName componentName, int userId) {
12312        if (!sUserManager.exists(userId)) return COMPONENT_ENABLED_STATE_DISABLED;
12313        int uid = Binder.getCallingUid();
12314        enforceCrossUserPermission(uid, userId, false, false, "get component enabled");
12315        // reader
12316        synchronized (mPackages) {
12317            return mSettings.getComponentEnabledSettingLPr(componentName, userId);
12318        }
12319    }
12320
12321    @Override
12322    public void enterSafeMode() {
12323        enforceSystemOrRoot("Only the system can request entering safe mode");
12324
12325        if (!mSystemReady) {
12326            mSafeMode = true;
12327        }
12328    }
12329
12330    @Override
12331    public void systemReady() {
12332        mSystemReady = true;
12333
12334        // Read the compatibilty setting when the system is ready.
12335        boolean compatibilityModeEnabled = android.provider.Settings.Global.getInt(
12336                mContext.getContentResolver(),
12337                android.provider.Settings.Global.COMPATIBILITY_MODE, 1) == 1;
12338        PackageParser.setCompatibilityModeEnabled(compatibilityModeEnabled);
12339        if (DEBUG_SETTINGS) {
12340            Log.d(TAG, "compatibility mode:" + compatibilityModeEnabled);
12341        }
12342
12343        synchronized (mPackages) {
12344            // Verify that all of the preferred activity components actually
12345            // exist.  It is possible for applications to be updated and at
12346            // that point remove a previously declared activity component that
12347            // had been set as a preferred activity.  We try to clean this up
12348            // the next time we encounter that preferred activity, but it is
12349            // possible for the user flow to never be able to return to that
12350            // situation so here we do a sanity check to make sure we haven't
12351            // left any junk around.
12352            ArrayList<PreferredActivity> removed = new ArrayList<PreferredActivity>();
12353            for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
12354                PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
12355                removed.clear();
12356                for (PreferredActivity pa : pir.filterSet()) {
12357                    if (mActivities.mActivities.get(pa.mPref.mComponent) == null) {
12358                        removed.add(pa);
12359                    }
12360                }
12361                if (removed.size() > 0) {
12362                    for (int r=0; r<removed.size(); r++) {
12363                        PreferredActivity pa = removed.get(r);
12364                        Slog.w(TAG, "Removing dangling preferred activity: "
12365                                + pa.mPref.mComponent);
12366                        pir.removeFilter(pa);
12367                    }
12368                    mSettings.writePackageRestrictionsLPr(
12369                            mSettings.mPreferredActivities.keyAt(i));
12370                }
12371            }
12372        }
12373        sUserManager.systemReady();
12374
12375        // Kick off any messages waiting for system ready
12376        if (mPostSystemReadyMessages != null) {
12377            for (Message msg : mPostSystemReadyMessages) {
12378                msg.sendToTarget();
12379            }
12380            mPostSystemReadyMessages = null;
12381        }
12382    }
12383
12384    @Override
12385    public boolean isSafeMode() {
12386        return mSafeMode;
12387    }
12388
12389    @Override
12390    public boolean hasSystemUidErrors() {
12391        return mHasSystemUidErrors;
12392    }
12393
12394    static String arrayToString(int[] array) {
12395        StringBuffer buf = new StringBuffer(128);
12396        buf.append('[');
12397        if (array != null) {
12398            for (int i=0; i<array.length; i++) {
12399                if (i > 0) buf.append(", ");
12400                buf.append(array[i]);
12401            }
12402        }
12403        buf.append(']');
12404        return buf.toString();
12405    }
12406
12407    static class DumpState {
12408        public static final int DUMP_LIBS = 1 << 0;
12409        public static final int DUMP_FEATURES = 1 << 1;
12410        public static final int DUMP_RESOLVERS = 1 << 2;
12411        public static final int DUMP_PERMISSIONS = 1 << 3;
12412        public static final int DUMP_PACKAGES = 1 << 4;
12413        public static final int DUMP_SHARED_USERS = 1 << 5;
12414        public static final int DUMP_MESSAGES = 1 << 6;
12415        public static final int DUMP_PROVIDERS = 1 << 7;
12416        public static final int DUMP_VERIFIERS = 1 << 8;
12417        public static final int DUMP_PREFERRED = 1 << 9;
12418        public static final int DUMP_PREFERRED_XML = 1 << 10;
12419        public static final int DUMP_KEYSETS = 1 << 11;
12420        public static final int DUMP_VERSION = 1 << 12;
12421        public static final int DUMP_INSTALLS = 1 << 13;
12422
12423        public static final int OPTION_SHOW_FILTERS = 1 << 0;
12424
12425        private int mTypes;
12426
12427        private int mOptions;
12428
12429        private boolean mTitlePrinted;
12430
12431        private SharedUserSetting mSharedUser;
12432
12433        public boolean isDumping(int type) {
12434            if (mTypes == 0 && type != DUMP_PREFERRED_XML) {
12435                return true;
12436            }
12437
12438            return (mTypes & type) != 0;
12439        }
12440
12441        public void setDump(int type) {
12442            mTypes |= type;
12443        }
12444
12445        public boolean isOptionEnabled(int option) {
12446            return (mOptions & option) != 0;
12447        }
12448
12449        public void setOptionEnabled(int option) {
12450            mOptions |= option;
12451        }
12452
12453        public boolean onTitlePrinted() {
12454            final boolean printed = mTitlePrinted;
12455            mTitlePrinted = true;
12456            return printed;
12457        }
12458
12459        public boolean getTitlePrinted() {
12460            return mTitlePrinted;
12461        }
12462
12463        public void setTitlePrinted(boolean enabled) {
12464            mTitlePrinted = enabled;
12465        }
12466
12467        public SharedUserSetting getSharedUser() {
12468            return mSharedUser;
12469        }
12470
12471        public void setSharedUser(SharedUserSetting user) {
12472            mSharedUser = user;
12473        }
12474    }
12475
12476    @Override
12477    protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
12478        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
12479                != PackageManager.PERMISSION_GRANTED) {
12480            pw.println("Permission Denial: can't dump ActivityManager from from pid="
12481                    + Binder.getCallingPid()
12482                    + ", uid=" + Binder.getCallingUid()
12483                    + " without permission "
12484                    + android.Manifest.permission.DUMP);
12485            return;
12486        }
12487
12488        DumpState dumpState = new DumpState();
12489        boolean fullPreferred = false;
12490        boolean checkin = false;
12491
12492        String packageName = null;
12493
12494        int opti = 0;
12495        while (opti < args.length) {
12496            String opt = args[opti];
12497            if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
12498                break;
12499            }
12500            opti++;
12501
12502            if ("-a".equals(opt)) {
12503                // Right now we only know how to print all.
12504            } else if ("-h".equals(opt)) {
12505                pw.println("Package manager dump options:");
12506                pw.println("  [-h] [-f] [--checkin] [cmd] ...");
12507                pw.println("    --checkin: dump for a checkin");
12508                pw.println("    -f: print details of intent filters");
12509                pw.println("    -h: print this help");
12510                pw.println("  cmd may be one of:");
12511                pw.println("    l[ibraries]: list known shared libraries");
12512                pw.println("    f[ibraries]: list device features");
12513                pw.println("    k[eysets]: print known keysets");
12514                pw.println("    r[esolvers]: dump intent resolvers");
12515                pw.println("    perm[issions]: dump permissions");
12516                pw.println("    pref[erred]: print preferred package settings");
12517                pw.println("    preferred-xml [--full]: print preferred package settings as xml");
12518                pw.println("    prov[iders]: dump content providers");
12519                pw.println("    p[ackages]: dump installed packages");
12520                pw.println("    s[hared-users]: dump shared user IDs");
12521                pw.println("    m[essages]: print collected runtime messages");
12522                pw.println("    v[erifiers]: print package verifier info");
12523                pw.println("    version: print database version info");
12524                pw.println("    write: write current settings now");
12525                pw.println("    <package.name>: info about given package");
12526                pw.println("    installs: details about install sessions");
12527                return;
12528            } else if ("--checkin".equals(opt)) {
12529                checkin = true;
12530            } else if ("-f".equals(opt)) {
12531                dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
12532            } else {
12533                pw.println("Unknown argument: " + opt + "; use -h for help");
12534            }
12535        }
12536
12537        // Is the caller requesting to dump a particular piece of data?
12538        if (opti < args.length) {
12539            String cmd = args[opti];
12540            opti++;
12541            // Is this a package name?
12542            if ("android".equals(cmd) || cmd.contains(".")) {
12543                packageName = cmd;
12544                // When dumping a single package, we always dump all of its
12545                // filter information since the amount of data will be reasonable.
12546                dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
12547            } else if ("l".equals(cmd) || "libraries".equals(cmd)) {
12548                dumpState.setDump(DumpState.DUMP_LIBS);
12549            } else if ("f".equals(cmd) || "features".equals(cmd)) {
12550                dumpState.setDump(DumpState.DUMP_FEATURES);
12551            } else if ("r".equals(cmd) || "resolvers".equals(cmd)) {
12552                dumpState.setDump(DumpState.DUMP_RESOLVERS);
12553            } else if ("perm".equals(cmd) || "permissions".equals(cmd)) {
12554                dumpState.setDump(DumpState.DUMP_PERMISSIONS);
12555            } else if ("pref".equals(cmd) || "preferred".equals(cmd)) {
12556                dumpState.setDump(DumpState.DUMP_PREFERRED);
12557            } else if ("preferred-xml".equals(cmd)) {
12558                dumpState.setDump(DumpState.DUMP_PREFERRED_XML);
12559                if (opti < args.length && "--full".equals(args[opti])) {
12560                    fullPreferred = true;
12561                    opti++;
12562                }
12563            } else if ("p".equals(cmd) || "packages".equals(cmd)) {
12564                dumpState.setDump(DumpState.DUMP_PACKAGES);
12565            } else if ("s".equals(cmd) || "shared-users".equals(cmd)) {
12566                dumpState.setDump(DumpState.DUMP_SHARED_USERS);
12567            } else if ("prov".equals(cmd) || "providers".equals(cmd)) {
12568                dumpState.setDump(DumpState.DUMP_PROVIDERS);
12569            } else if ("m".equals(cmd) || "messages".equals(cmd)) {
12570                dumpState.setDump(DumpState.DUMP_MESSAGES);
12571            } else if ("v".equals(cmd) || "verifiers".equals(cmd)) {
12572                dumpState.setDump(DumpState.DUMP_VERIFIERS);
12573            } else if ("version".equals(cmd)) {
12574                dumpState.setDump(DumpState.DUMP_VERSION);
12575            } else if ("k".equals(cmd) || "keysets".equals(cmd)) {
12576                dumpState.setDump(DumpState.DUMP_KEYSETS);
12577            } else if ("installs".equals(cmd)) {
12578                dumpState.setDump(DumpState.DUMP_INSTALLS);
12579            } else if ("write".equals(cmd)) {
12580                synchronized (mPackages) {
12581                    mSettings.writeLPr();
12582                    pw.println("Settings written.");
12583                    return;
12584                }
12585            }
12586        }
12587
12588        if (checkin) {
12589            pw.println("vers,1");
12590        }
12591
12592        // reader
12593        synchronized (mPackages) {
12594            if (dumpState.isDumping(DumpState.DUMP_VERSION) && packageName == null) {
12595                if (!checkin) {
12596                    if (dumpState.onTitlePrinted())
12597                        pw.println();
12598                    pw.println("Database versions:");
12599                    pw.print("  SDK Version:");
12600                    pw.print(" internal=");
12601                    pw.print(mSettings.mInternalSdkPlatform);
12602                    pw.print(" external=");
12603                    pw.println(mSettings.mExternalSdkPlatform);
12604                    pw.print("  DB Version:");
12605                    pw.print(" internal=");
12606                    pw.print(mSettings.mInternalDatabaseVersion);
12607                    pw.print(" external=");
12608                    pw.println(mSettings.mExternalDatabaseVersion);
12609                }
12610            }
12611
12612            if (dumpState.isDumping(DumpState.DUMP_VERIFIERS) && packageName == null) {
12613                if (!checkin) {
12614                    if (dumpState.onTitlePrinted())
12615                        pw.println();
12616                    pw.println("Verifiers:");
12617                    pw.print("  Required: ");
12618                    pw.print(mRequiredVerifierPackage);
12619                    pw.print(" (uid=");
12620                    pw.print(getPackageUid(mRequiredVerifierPackage, 0));
12621                    pw.println(")");
12622                } else if (mRequiredVerifierPackage != null) {
12623                    pw.print("vrfy,"); pw.print(mRequiredVerifierPackage);
12624                    pw.print(","); pw.println(getPackageUid(mRequiredVerifierPackage, 0));
12625                }
12626            }
12627
12628            if (dumpState.isDumping(DumpState.DUMP_LIBS) && packageName == null) {
12629                boolean printedHeader = false;
12630                final Iterator<String> it = mSharedLibraries.keySet().iterator();
12631                while (it.hasNext()) {
12632                    String name = it.next();
12633                    SharedLibraryEntry ent = mSharedLibraries.get(name);
12634                    if (!checkin) {
12635                        if (!printedHeader) {
12636                            if (dumpState.onTitlePrinted())
12637                                pw.println();
12638                            pw.println("Libraries:");
12639                            printedHeader = true;
12640                        }
12641                        pw.print("  ");
12642                    } else {
12643                        pw.print("lib,");
12644                    }
12645                    pw.print(name);
12646                    if (!checkin) {
12647                        pw.print(" -> ");
12648                    }
12649                    if (ent.path != null) {
12650                        if (!checkin) {
12651                            pw.print("(jar) ");
12652                            pw.print(ent.path);
12653                        } else {
12654                            pw.print(",jar,");
12655                            pw.print(ent.path);
12656                        }
12657                    } else {
12658                        if (!checkin) {
12659                            pw.print("(apk) ");
12660                            pw.print(ent.apk);
12661                        } else {
12662                            pw.print(",apk,");
12663                            pw.print(ent.apk);
12664                        }
12665                    }
12666                    pw.println();
12667                }
12668            }
12669
12670            if (dumpState.isDumping(DumpState.DUMP_FEATURES) && packageName == null) {
12671                if (dumpState.onTitlePrinted())
12672                    pw.println();
12673                if (!checkin) {
12674                    pw.println("Features:");
12675                }
12676                Iterator<String> it = mAvailableFeatures.keySet().iterator();
12677                while (it.hasNext()) {
12678                    String name = it.next();
12679                    if (!checkin) {
12680                        pw.print("  ");
12681                    } else {
12682                        pw.print("feat,");
12683                    }
12684                    pw.println(name);
12685                }
12686            }
12687
12688            if (!checkin && dumpState.isDumping(DumpState.DUMP_RESOLVERS)) {
12689                if (mActivities.dump(pw, dumpState.getTitlePrinted() ? "\nActivity Resolver Table:"
12690                        : "Activity Resolver Table:", "  ", packageName,
12691                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
12692                    dumpState.setTitlePrinted(true);
12693                }
12694                if (mReceivers.dump(pw, dumpState.getTitlePrinted() ? "\nReceiver Resolver Table:"
12695                        : "Receiver Resolver Table:", "  ", packageName,
12696                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
12697                    dumpState.setTitlePrinted(true);
12698                }
12699                if (mServices.dump(pw, dumpState.getTitlePrinted() ? "\nService Resolver Table:"
12700                        : "Service Resolver Table:", "  ", packageName,
12701                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
12702                    dumpState.setTitlePrinted(true);
12703                }
12704                if (mProviders.dump(pw, dumpState.getTitlePrinted() ? "\nProvider Resolver Table:"
12705                        : "Provider Resolver Table:", "  ", packageName,
12706                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
12707                    dumpState.setTitlePrinted(true);
12708                }
12709            }
12710
12711            if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED)) {
12712                for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
12713                    PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
12714                    int user = mSettings.mPreferredActivities.keyAt(i);
12715                    if (pir.dump(pw,
12716                            dumpState.getTitlePrinted()
12717                                ? "\nPreferred Activities User " + user + ":"
12718                                : "Preferred Activities User " + user + ":", "  ",
12719                            packageName, true, false)) {
12720                        dumpState.setTitlePrinted(true);
12721                    }
12722                }
12723            }
12724
12725            if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED_XML)) {
12726                pw.flush();
12727                FileOutputStream fout = new FileOutputStream(fd);
12728                BufferedOutputStream str = new BufferedOutputStream(fout);
12729                XmlSerializer serializer = new FastXmlSerializer();
12730                try {
12731                    serializer.setOutput(str, "utf-8");
12732                    serializer.startDocument(null, true);
12733                    serializer.setFeature(
12734                            "http://xmlpull.org/v1/doc/features.html#indent-output", true);
12735                    mSettings.writePreferredActivitiesLPr(serializer, 0, fullPreferred);
12736                    serializer.endDocument();
12737                    serializer.flush();
12738                } catch (IllegalArgumentException e) {
12739                    pw.println("Failed writing: " + e);
12740                } catch (IllegalStateException e) {
12741                    pw.println("Failed writing: " + e);
12742                } catch (IOException e) {
12743                    pw.println("Failed writing: " + e);
12744                }
12745            }
12746
12747            if (!checkin && dumpState.isDumping(DumpState.DUMP_PERMISSIONS)) {
12748                mSettings.dumpPermissionsLPr(pw, packageName, dumpState);
12749                if (packageName == null) {
12750                    for (int iperm=0; iperm<mAppOpPermissionPackages.size(); iperm++) {
12751                        if (iperm == 0) {
12752                            if (dumpState.onTitlePrinted())
12753                                pw.println();
12754                            pw.println("AppOp Permissions:");
12755                        }
12756                        pw.print("  AppOp Permission ");
12757                        pw.print(mAppOpPermissionPackages.keyAt(iperm));
12758                        pw.println(":");
12759                        ArraySet<String> pkgs = mAppOpPermissionPackages.valueAt(iperm);
12760                        for (int ipkg=0; ipkg<pkgs.size(); ipkg++) {
12761                            pw.print("    "); pw.println(pkgs.valueAt(ipkg));
12762                        }
12763                    }
12764                }
12765            }
12766
12767            if (!checkin && dumpState.isDumping(DumpState.DUMP_PROVIDERS)) {
12768                boolean printedSomething = false;
12769                for (PackageParser.Provider p : mProviders.mProviders.values()) {
12770                    if (packageName != null && !packageName.equals(p.info.packageName)) {
12771                        continue;
12772                    }
12773                    if (!printedSomething) {
12774                        if (dumpState.onTitlePrinted())
12775                            pw.println();
12776                        pw.println("Registered ContentProviders:");
12777                        printedSomething = true;
12778                    }
12779                    pw.print("  "); p.printComponentShortName(pw); pw.println(":");
12780                    pw.print("    "); pw.println(p.toString());
12781                }
12782                printedSomething = false;
12783                for (Map.Entry<String, PackageParser.Provider> entry :
12784                        mProvidersByAuthority.entrySet()) {
12785                    PackageParser.Provider p = entry.getValue();
12786                    if (packageName != null && !packageName.equals(p.info.packageName)) {
12787                        continue;
12788                    }
12789                    if (!printedSomething) {
12790                        if (dumpState.onTitlePrinted())
12791                            pw.println();
12792                        pw.println("ContentProvider Authorities:");
12793                        printedSomething = true;
12794                    }
12795                    pw.print("  ["); pw.print(entry.getKey()); pw.println("]:");
12796                    pw.print("    "); pw.println(p.toString());
12797                    if (p.info != null && p.info.applicationInfo != null) {
12798                        final String appInfo = p.info.applicationInfo.toString();
12799                        pw.print("      applicationInfo="); pw.println(appInfo);
12800                    }
12801                }
12802            }
12803
12804            if (!checkin && dumpState.isDumping(DumpState.DUMP_KEYSETS)) {
12805                mSettings.mKeySetManagerService.dumpLPr(pw, packageName, dumpState);
12806            }
12807
12808            if (dumpState.isDumping(DumpState.DUMP_PACKAGES)) {
12809                mSettings.dumpPackagesLPr(pw, packageName, dumpState, checkin);
12810            }
12811
12812            if (dumpState.isDumping(DumpState.DUMP_SHARED_USERS)) {
12813                mSettings.dumpSharedUsersLPr(pw, packageName, dumpState, checkin);
12814            }
12815
12816            if (!checkin && dumpState.isDumping(DumpState.DUMP_INSTALLS) && packageName == null) {
12817                // XXX should handle packageName != null by dumping only install data that
12818                // the given package is involved with.
12819                if (dumpState.onTitlePrinted()) pw.println();
12820                mInstallerService.dump(new IndentingPrintWriter(pw, "  ", 120));
12821            }
12822
12823            if (!checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES) && packageName == null) {
12824                if (dumpState.onTitlePrinted()) pw.println();
12825                mSettings.dumpReadMessagesLPr(pw, dumpState);
12826
12827                pw.println();
12828                pw.println("Package warning messages:");
12829                BufferedReader in = null;
12830                String line = null;
12831                try {
12832                    in = new BufferedReader(new FileReader(getSettingsProblemFile()));
12833                    while ((line = in.readLine()) != null) {
12834                        if (line.contains("ignored: updated version")) continue;
12835                        pw.println(line);
12836                    }
12837                } catch (IOException ignored) {
12838                } finally {
12839                    IoUtils.closeQuietly(in);
12840                }
12841            }
12842
12843            if (checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES)) {
12844                BufferedReader in = null;
12845                String line = null;
12846                try {
12847                    in = new BufferedReader(new FileReader(getSettingsProblemFile()));
12848                    while ((line = in.readLine()) != null) {
12849                        if (line.contains("ignored: updated version")) continue;
12850                        pw.print("msg,");
12851                        pw.println(line);
12852                    }
12853                } catch (IOException ignored) {
12854                } finally {
12855                    IoUtils.closeQuietly(in);
12856                }
12857            }
12858        }
12859    }
12860
12861    // ------- apps on sdcard specific code -------
12862    static final boolean DEBUG_SD_INSTALL = false;
12863
12864    private static final String SD_ENCRYPTION_KEYSTORE_NAME = "AppsOnSD";
12865
12866    private static final String SD_ENCRYPTION_ALGORITHM = "AES";
12867
12868    private boolean mMediaMounted = false;
12869
12870    static String getEncryptKey() {
12871        try {
12872            String sdEncKey = SystemKeyStore.getInstance().retrieveKeyHexString(
12873                    SD_ENCRYPTION_KEYSTORE_NAME);
12874            if (sdEncKey == null) {
12875                sdEncKey = SystemKeyStore.getInstance().generateNewKeyHexString(128,
12876                        SD_ENCRYPTION_ALGORITHM, SD_ENCRYPTION_KEYSTORE_NAME);
12877                if (sdEncKey == null) {
12878                    Slog.e(TAG, "Failed to create encryption keys");
12879                    return null;
12880                }
12881            }
12882            return sdEncKey;
12883        } catch (NoSuchAlgorithmException nsae) {
12884            Slog.e(TAG, "Failed to create encryption keys with exception: " + nsae);
12885            return null;
12886        } catch (IOException ioe) {
12887            Slog.e(TAG, "Failed to retrieve encryption keys with exception: " + ioe);
12888            return null;
12889        }
12890    }
12891
12892    /*
12893     * Update media status on PackageManager.
12894     */
12895    @Override
12896    public void updateExternalMediaStatus(final boolean mediaStatus, final boolean reportStatus) {
12897        int callingUid = Binder.getCallingUid();
12898        if (callingUid != 0 && callingUid != Process.SYSTEM_UID) {
12899            throw new SecurityException("Media status can only be updated by the system");
12900        }
12901        // reader; this apparently protects mMediaMounted, but should probably
12902        // be a different lock in that case.
12903        synchronized (mPackages) {
12904            Log.i(TAG, "Updating external media status from "
12905                    + (mMediaMounted ? "mounted" : "unmounted") + " to "
12906                    + (mediaStatus ? "mounted" : "unmounted"));
12907            if (DEBUG_SD_INSTALL)
12908                Log.i(TAG, "updateExternalMediaStatus:: mediaStatus=" + mediaStatus
12909                        + ", mMediaMounted=" + mMediaMounted);
12910            if (mediaStatus == mMediaMounted) {
12911                final Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS, reportStatus ? 1
12912                        : 0, -1);
12913                mHandler.sendMessage(msg);
12914                return;
12915            }
12916            mMediaMounted = mediaStatus;
12917        }
12918        // Queue up an async operation since the package installation may take a
12919        // little while.
12920        mHandler.post(new Runnable() {
12921            public void run() {
12922                updateExternalMediaStatusInner(mediaStatus, reportStatus, true);
12923            }
12924        });
12925    }
12926
12927    /**
12928     * Called by MountService when the initial ASECs to scan are available.
12929     * Should block until all the ASEC containers are finished being scanned.
12930     */
12931    public void scanAvailableAsecs() {
12932        updateExternalMediaStatusInner(true, false, false);
12933        if (mShouldRestoreconData) {
12934            SELinuxMMAC.setRestoreconDone();
12935            mShouldRestoreconData = false;
12936        }
12937    }
12938
12939    /*
12940     * Collect information of applications on external media, map them against
12941     * existing containers and update information based on current mount status.
12942     * Please note that we always have to report status if reportStatus has been
12943     * set to true especially when unloading packages.
12944     */
12945    private void updateExternalMediaStatusInner(boolean isMounted, boolean reportStatus,
12946            boolean externalStorage) {
12947        ArrayMap<AsecInstallArgs, String> processCids = new ArrayMap<>();
12948        int[] uidArr = EmptyArray.INT;
12949
12950        final String[] list = PackageHelper.getSecureContainerList();
12951        if (ArrayUtils.isEmpty(list)) {
12952            Log.i(TAG, "No secure containers found");
12953        } else {
12954            // Process list of secure containers and categorize them
12955            // as active or stale based on their package internal state.
12956
12957            // reader
12958            synchronized (mPackages) {
12959                for (String cid : list) {
12960                    // Leave stages untouched for now; installer service owns them
12961                    if (PackageInstallerService.isStageName(cid)) continue;
12962
12963                    if (DEBUG_SD_INSTALL)
12964                        Log.i(TAG, "Processing container " + cid);
12965                    String pkgName = getAsecPackageName(cid);
12966                    if (pkgName == null) {
12967                        Slog.i(TAG, "Found stale container " + cid + " with no package name");
12968                        continue;
12969                    }
12970                    if (DEBUG_SD_INSTALL)
12971                        Log.i(TAG, "Looking for pkg : " + pkgName);
12972
12973                    final PackageSetting ps = mSettings.mPackages.get(pkgName);
12974                    if (ps == null) {
12975                        Slog.i(TAG, "Found stale container " + cid + " with no matching settings");
12976                        continue;
12977                    }
12978
12979                    /*
12980                     * Skip packages that are not external if we're unmounting
12981                     * external storage.
12982                     */
12983                    if (externalStorage && !isMounted && !isExternal(ps)) {
12984                        continue;
12985                    }
12986
12987                    final AsecInstallArgs args = new AsecInstallArgs(cid,
12988                            getAppDexInstructionSets(ps), isForwardLocked(ps));
12989                    // The package status is changed only if the code path
12990                    // matches between settings and the container id.
12991                    if (ps.codePathString != null
12992                            && ps.codePathString.startsWith(args.getCodePath())) {
12993                        if (DEBUG_SD_INSTALL) {
12994                            Log.i(TAG, "Container : " + cid + " corresponds to pkg : " + pkgName
12995                                    + " at code path: " + ps.codePathString);
12996                        }
12997
12998                        // We do have a valid package installed on sdcard
12999                        processCids.put(args, ps.codePathString);
13000                        final int uid = ps.appId;
13001                        if (uid != -1) {
13002                            uidArr = ArrayUtils.appendInt(uidArr, uid);
13003                        }
13004                    } else {
13005                        Slog.i(TAG, "Found stale container " + cid + ": expected codePath="
13006                                + ps.codePathString);
13007                    }
13008                }
13009            }
13010
13011            Arrays.sort(uidArr);
13012        }
13013
13014        // Process packages with valid entries.
13015        if (isMounted) {
13016            if (DEBUG_SD_INSTALL)
13017                Log.i(TAG, "Loading packages");
13018            loadMediaPackages(processCids, uidArr);
13019            startCleaningPackages();
13020            mInstallerService.onSecureContainersAvailable();
13021        } else {
13022            if (DEBUG_SD_INSTALL)
13023                Log.i(TAG, "Unloading packages");
13024            unloadMediaPackages(processCids, uidArr, reportStatus);
13025        }
13026    }
13027
13028    private void sendResourcesChangedBroadcast(boolean mediaStatus, boolean replacing,
13029            ArrayList<String> pkgList, int uidArr[], IIntentReceiver finishedReceiver) {
13030        int size = pkgList.size();
13031        if (size > 0) {
13032            // Send broadcasts here
13033            Bundle extras = new Bundle();
13034            extras.putStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST, pkgList
13035                    .toArray(new String[size]));
13036            if (uidArr != null) {
13037                extras.putIntArray(Intent.EXTRA_CHANGED_UID_LIST, uidArr);
13038            }
13039            if (replacing) {
13040                extras.putBoolean(Intent.EXTRA_REPLACING, replacing);
13041            }
13042            String action = mediaStatus ? Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE
13043                    : Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE;
13044            sendPackageBroadcast(action, null, extras, null, finishedReceiver, null);
13045        }
13046    }
13047
13048   /*
13049     * Look at potentially valid container ids from processCids If package
13050     * information doesn't match the one on record or package scanning fails,
13051     * the cid is added to list of removeCids. We currently don't delete stale
13052     * containers.
13053     */
13054    private void loadMediaPackages(ArrayMap<AsecInstallArgs, String> processCids, int[] uidArr) {
13055        ArrayList<String> pkgList = new ArrayList<String>();
13056        Set<AsecInstallArgs> keys = processCids.keySet();
13057
13058        for (AsecInstallArgs args : keys) {
13059            String codePath = processCids.get(args);
13060            if (DEBUG_SD_INSTALL)
13061                Log.i(TAG, "Loading container : " + args.cid);
13062            int retCode = PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
13063            try {
13064                // Make sure there are no container errors first.
13065                if (args.doPreInstall(PackageManager.INSTALL_SUCCEEDED) != PackageManager.INSTALL_SUCCEEDED) {
13066                    Slog.e(TAG, "Failed to mount cid : " + args.cid
13067                            + " when installing from sdcard");
13068                    continue;
13069                }
13070                // Check code path here.
13071                if (codePath == null || !codePath.startsWith(args.getCodePath())) {
13072                    Slog.e(TAG, "Container " + args.cid + " cachepath " + args.getCodePath()
13073                            + " does not match one in settings " + codePath);
13074                    continue;
13075                }
13076                // Parse package
13077                int parseFlags = mDefParseFlags;
13078                if (args.isExternal()) {
13079                    parseFlags |= PackageParser.PARSE_ON_SDCARD;
13080                }
13081                if (args.isFwdLocked()) {
13082                    parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
13083                }
13084
13085                synchronized (mInstallLock) {
13086                    PackageParser.Package pkg = null;
13087                    try {
13088                        pkg = scanPackageLI(new File(codePath), parseFlags, 0, 0, null);
13089                    } catch (PackageManagerException e) {
13090                        Slog.w(TAG, "Failed to scan " + codePath + ": " + e.getMessage());
13091                    }
13092                    // Scan the package
13093                    if (pkg != null) {
13094                        /*
13095                         * TODO why is the lock being held? doPostInstall is
13096                         * called in other places without the lock. This needs
13097                         * to be straightened out.
13098                         */
13099                        // writer
13100                        synchronized (mPackages) {
13101                            retCode = PackageManager.INSTALL_SUCCEEDED;
13102                            pkgList.add(pkg.packageName);
13103                            // Post process args
13104                            args.doPostInstall(PackageManager.INSTALL_SUCCEEDED,
13105                                    pkg.applicationInfo.uid);
13106                        }
13107                    } else {
13108                        Slog.i(TAG, "Failed to install pkg from  " + codePath + " from sdcard");
13109                    }
13110                }
13111
13112            } finally {
13113                if (retCode != PackageManager.INSTALL_SUCCEEDED) {
13114                    Log.w(TAG, "Container " + args.cid + " is stale, retCode=" + retCode);
13115                }
13116            }
13117        }
13118        // writer
13119        synchronized (mPackages) {
13120            // If the platform SDK has changed since the last time we booted,
13121            // we need to re-grant app permission to catch any new ones that
13122            // appear. This is really a hack, and means that apps can in some
13123            // cases get permissions that the user didn't initially explicitly
13124            // allow... it would be nice to have some better way to handle
13125            // this situation.
13126            final boolean regrantPermissions = mSettings.mExternalSdkPlatform != mSdkVersion;
13127            if (regrantPermissions)
13128                Slog.i(TAG, "Platform changed from " + mSettings.mExternalSdkPlatform + " to "
13129                        + mSdkVersion + "; regranting permissions for external storage");
13130            mSettings.mExternalSdkPlatform = mSdkVersion;
13131
13132            // Make sure group IDs have been assigned, and any permission
13133            // changes in other apps are accounted for
13134            updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL
13135                    | (regrantPermissions
13136                            ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL)
13137                            : 0));
13138
13139            mSettings.updateExternalDatabaseVersion();
13140
13141            // can downgrade to reader
13142            // Persist settings
13143            mSettings.writeLPr();
13144        }
13145        // Send a broadcast to let everyone know we are done processing
13146        if (pkgList.size() > 0) {
13147            sendResourcesChangedBroadcast(true, false, pkgList, uidArr, null);
13148        }
13149    }
13150
13151   /*
13152     * Utility method to unload a list of specified containers
13153     */
13154    private void unloadAllContainers(Set<AsecInstallArgs> cidArgs) {
13155        // Just unmount all valid containers.
13156        for (AsecInstallArgs arg : cidArgs) {
13157            synchronized (mInstallLock) {
13158                arg.doPostDeleteLI(false);
13159           }
13160       }
13161   }
13162
13163    /*
13164     * Unload packages mounted on external media. This involves deleting package
13165     * data from internal structures, sending broadcasts about diabled packages,
13166     * gc'ing to free up references, unmounting all secure containers
13167     * corresponding to packages on external media, and posting a
13168     * UPDATED_MEDIA_STATUS message if status has been requested. Please note
13169     * that we always have to post this message if status has been requested no
13170     * matter what.
13171     */
13172    private void unloadMediaPackages(ArrayMap<AsecInstallArgs, String> processCids, int uidArr[],
13173            final boolean reportStatus) {
13174        if (DEBUG_SD_INSTALL)
13175            Log.i(TAG, "unloading media packages");
13176        ArrayList<String> pkgList = new ArrayList<String>();
13177        ArrayList<AsecInstallArgs> failedList = new ArrayList<AsecInstallArgs>();
13178        final Set<AsecInstallArgs> keys = processCids.keySet();
13179        for (AsecInstallArgs args : keys) {
13180            String pkgName = args.getPackageName();
13181            if (DEBUG_SD_INSTALL)
13182                Log.i(TAG, "Trying to unload pkg : " + pkgName);
13183            // Delete package internally
13184            PackageRemovedInfo outInfo = new PackageRemovedInfo();
13185            synchronized (mInstallLock) {
13186                boolean res = deletePackageLI(pkgName, null, false, null, null,
13187                        PackageManager.DELETE_KEEP_DATA, outInfo, false);
13188                if (res) {
13189                    pkgList.add(pkgName);
13190                } else {
13191                    Slog.e(TAG, "Failed to delete pkg from sdcard : " + pkgName);
13192                    failedList.add(args);
13193                }
13194            }
13195        }
13196
13197        // reader
13198        synchronized (mPackages) {
13199            // We didn't update the settings after removing each package;
13200            // write them now for all packages.
13201            mSettings.writeLPr();
13202        }
13203
13204        // We have to absolutely send UPDATED_MEDIA_STATUS only
13205        // after confirming that all the receivers processed the ordered
13206        // broadcast when packages get disabled, force a gc to clean things up.
13207        // and unload all the containers.
13208        if (pkgList.size() > 0) {
13209            sendResourcesChangedBroadcast(false, false, pkgList, uidArr,
13210                    new IIntentReceiver.Stub() {
13211                public void performReceive(Intent intent, int resultCode, String data,
13212                        Bundle extras, boolean ordered, boolean sticky,
13213                        int sendingUser) throws RemoteException {
13214                    Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS,
13215                            reportStatus ? 1 : 0, 1, keys);
13216                    mHandler.sendMessage(msg);
13217                }
13218            });
13219        } else {
13220            Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS, reportStatus ? 1 : 0, -1,
13221                    keys);
13222            mHandler.sendMessage(msg);
13223        }
13224    }
13225
13226    /** Binder call */
13227    @Override
13228    public void movePackage(final String packageName, final IPackageMoveObserver observer,
13229            final int flags) {
13230        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MOVE_PACKAGE, null);
13231        UserHandle user = new UserHandle(UserHandle.getCallingUserId());
13232        int returnCode = PackageManager.MOVE_SUCCEEDED;
13233        int currInstallFlags = 0;
13234        int newInstallFlags = 0;
13235
13236        File codeFile = null;
13237        String installerPackageName = null;
13238        String packageAbiOverride = null;
13239
13240        // reader
13241        synchronized (mPackages) {
13242            final PackageParser.Package pkg = mPackages.get(packageName);
13243            final PackageSetting ps = mSettings.mPackages.get(packageName);
13244            if (pkg == null || ps == null) {
13245                returnCode = PackageManager.MOVE_FAILED_DOESNT_EXIST;
13246            } else {
13247                // Disable moving fwd locked apps and system packages
13248                if (pkg.applicationInfo != null && isSystemApp(pkg)) {
13249                    Slog.w(TAG, "Cannot move system application");
13250                    returnCode = PackageManager.MOVE_FAILED_SYSTEM_PACKAGE;
13251                } else if (pkg.mOperationPending) {
13252                    Slog.w(TAG, "Attempt to move package which has pending operations");
13253                    returnCode = PackageManager.MOVE_FAILED_OPERATION_PENDING;
13254                } else {
13255                    // Find install location first
13256                    if ((flags & PackageManager.MOVE_EXTERNAL_MEDIA) != 0
13257                            && (flags & PackageManager.MOVE_INTERNAL) != 0) {
13258                        Slog.w(TAG, "Ambigous flags specified for move location.");
13259                        returnCode = PackageManager.MOVE_FAILED_INVALID_LOCATION;
13260                    } else {
13261                        newInstallFlags = (flags & PackageManager.MOVE_EXTERNAL_MEDIA) != 0
13262                                ? PackageManager.INSTALL_EXTERNAL : PackageManager.INSTALL_INTERNAL;
13263                        currInstallFlags = isExternal(pkg)
13264                                ? PackageManager.INSTALL_EXTERNAL : PackageManager.INSTALL_INTERNAL;
13265
13266                        if (newInstallFlags == currInstallFlags) {
13267                            Slog.w(TAG, "No move required. Trying to move to same location");
13268                            returnCode = PackageManager.MOVE_FAILED_INVALID_LOCATION;
13269                        } else {
13270                            if (isForwardLocked(pkg)) {
13271                                currInstallFlags |= PackageManager.INSTALL_FORWARD_LOCK;
13272                                newInstallFlags |= PackageManager.INSTALL_FORWARD_LOCK;
13273                            }
13274                        }
13275                    }
13276                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
13277                        pkg.mOperationPending = true;
13278                    }
13279                }
13280
13281                codeFile = new File(pkg.codePath);
13282                installerPackageName = ps.installerPackageName;
13283                packageAbiOverride = ps.cpuAbiOverrideString;
13284            }
13285        }
13286
13287        if (returnCode != PackageManager.MOVE_SUCCEEDED) {
13288            try {
13289                observer.packageMoved(packageName, returnCode);
13290            } catch (RemoteException ignored) {
13291            }
13292            return;
13293        }
13294
13295        final IPackageInstallObserver2 installObserver = new IPackageInstallObserver2.Stub() {
13296            @Override
13297            public void onUserActionRequired(Intent intent) throws RemoteException {
13298                throw new IllegalStateException();
13299            }
13300
13301            @Override
13302            public void onPackageInstalled(String basePackageName, int returnCode, String msg,
13303                    Bundle extras) throws RemoteException {
13304                Slog.d(TAG, "Install result for move: "
13305                        + PackageManager.installStatusToString(returnCode, msg));
13306
13307                // We usually have a new package now after the install, but if
13308                // we failed we need to clear the pending flag on the original
13309                // package object.
13310                synchronized (mPackages) {
13311                    final PackageParser.Package pkg = mPackages.get(packageName);
13312                    if (pkg != null) {
13313                        pkg.mOperationPending = false;
13314                    }
13315                }
13316
13317                final int status = PackageManager.installStatusToPublicStatus(returnCode);
13318                switch (status) {
13319                    case PackageInstaller.STATUS_SUCCESS:
13320                        observer.packageMoved(packageName, PackageManager.MOVE_SUCCEEDED);
13321                        break;
13322                    case PackageInstaller.STATUS_FAILURE_STORAGE:
13323                        observer.packageMoved(packageName, PackageManager.MOVE_FAILED_INSUFFICIENT_STORAGE);
13324                        break;
13325                    default:
13326                        observer.packageMoved(packageName, PackageManager.MOVE_FAILED_INTERNAL_ERROR);
13327                        break;
13328                }
13329            }
13330        };
13331
13332        // Treat a move like reinstalling an existing app, which ensures that we
13333        // process everythign uniformly, like unpacking native libraries.
13334        newInstallFlags |= PackageManager.INSTALL_REPLACE_EXISTING;
13335
13336        final Message msg = mHandler.obtainMessage(INIT_COPY);
13337        final OriginInfo origin = OriginInfo.fromExistingFile(codeFile);
13338        msg.obj = new InstallParams(origin, installObserver, newInstallFlags,
13339                installerPackageName, null, user, packageAbiOverride);
13340        mHandler.sendMessage(msg);
13341    }
13342
13343    @Override
13344    public boolean setInstallLocation(int loc) {
13345        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WRITE_SECURE_SETTINGS,
13346                null);
13347        if (getInstallLocation() == loc) {
13348            return true;
13349        }
13350        if (loc == PackageHelper.APP_INSTALL_AUTO || loc == PackageHelper.APP_INSTALL_INTERNAL
13351                || loc == PackageHelper.APP_INSTALL_EXTERNAL) {
13352            android.provider.Settings.Global.putInt(mContext.getContentResolver(),
13353                    android.provider.Settings.Global.DEFAULT_INSTALL_LOCATION, loc);
13354            return true;
13355        }
13356        return false;
13357   }
13358
13359    @Override
13360    public int getInstallLocation() {
13361        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
13362                android.provider.Settings.Global.DEFAULT_INSTALL_LOCATION,
13363                PackageHelper.APP_INSTALL_AUTO);
13364    }
13365
13366    /** Called by UserManagerService */
13367    void cleanUpUserLILPw(UserManagerService userManager, int userHandle) {
13368        mDirtyUsers.remove(userHandle);
13369        mSettings.removeUserLPw(userHandle);
13370        mPendingBroadcasts.remove(userHandle);
13371        if (mInstaller != null) {
13372            // Technically, we shouldn't be doing this with the package lock
13373            // held.  However, this is very rare, and there is already so much
13374            // other disk I/O going on, that we'll let it slide for now.
13375            mInstaller.removeUserDataDirs(userHandle);
13376        }
13377        mUserNeedsBadging.delete(userHandle);
13378        removeUnusedPackagesLILPw(userManager, userHandle);
13379    }
13380
13381    /**
13382     * We're removing userHandle and would like to remove any downloaded packages
13383     * that are no longer in use by any other user.
13384     * @param userHandle the user being removed
13385     */
13386    private void removeUnusedPackagesLILPw(UserManagerService userManager, final int userHandle) {
13387        final boolean DEBUG_CLEAN_APKS = false;
13388        int [] users = userManager.getUserIdsLPr();
13389        Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
13390        while (psit.hasNext()) {
13391            PackageSetting ps = psit.next();
13392            if (ps.pkg == null) {
13393                continue;
13394            }
13395            final String packageName = ps.pkg.packageName;
13396            // Skip over if system app
13397            if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0) {
13398                continue;
13399            }
13400            if (DEBUG_CLEAN_APKS) {
13401                Slog.i(TAG, "Checking package " + packageName);
13402            }
13403            boolean keep = false;
13404            for (int i = 0; i < users.length; i++) {
13405                if (users[i] != userHandle && ps.getInstalled(users[i])) {
13406                    keep = true;
13407                    if (DEBUG_CLEAN_APKS) {
13408                        Slog.i(TAG, "  Keeping package " + packageName + " for user "
13409                                + users[i]);
13410                    }
13411                    break;
13412                }
13413            }
13414            if (!keep) {
13415                if (DEBUG_CLEAN_APKS) {
13416                    Slog.i(TAG, "  Removing package " + packageName);
13417                }
13418                mHandler.post(new Runnable() {
13419                    public void run() {
13420                        deletePackageX(packageName, userHandle, 0);
13421                    } //end run
13422                });
13423            }
13424        }
13425    }
13426
13427    /** Called by UserManagerService */
13428    void createNewUserLILPw(int userHandle, File path) {
13429        if (mInstaller != null) {
13430            mInstaller.createUserConfig(userHandle);
13431            mSettings.createNewUserLILPw(this, mInstaller, userHandle, path);
13432        }
13433    }
13434
13435    @Override
13436    public VerifierDeviceIdentity getVerifierDeviceIdentity() throws RemoteException {
13437        mContext.enforceCallingOrSelfPermission(
13438                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
13439                "Only package verification agents can read the verifier device identity");
13440
13441        synchronized (mPackages) {
13442            return mSettings.getVerifierDeviceIdentityLPw();
13443        }
13444    }
13445
13446    @Override
13447    public void setPermissionEnforced(String permission, boolean enforced) {
13448        mContext.enforceCallingOrSelfPermission(GRANT_REVOKE_PERMISSIONS, null);
13449        if (READ_EXTERNAL_STORAGE.equals(permission)) {
13450            synchronized (mPackages) {
13451                if (mSettings.mReadExternalStorageEnforced == null
13452                        || mSettings.mReadExternalStorageEnforced != enforced) {
13453                    mSettings.mReadExternalStorageEnforced = enforced;
13454                    mSettings.writeLPr();
13455                }
13456            }
13457            // kill any non-foreground processes so we restart them and
13458            // grant/revoke the GID.
13459            final IActivityManager am = ActivityManagerNative.getDefault();
13460            if (am != null) {
13461                final long token = Binder.clearCallingIdentity();
13462                try {
13463                    am.killProcessesBelowForeground("setPermissionEnforcement");
13464                } catch (RemoteException e) {
13465                } finally {
13466                    Binder.restoreCallingIdentity(token);
13467                }
13468            }
13469        } else {
13470            throw new IllegalArgumentException("No selective enforcement for " + permission);
13471        }
13472    }
13473
13474    @Override
13475    @Deprecated
13476    public boolean isPermissionEnforced(String permission) {
13477        return true;
13478    }
13479
13480    @Override
13481    public boolean isStorageLow() {
13482        final long token = Binder.clearCallingIdentity();
13483        try {
13484            final DeviceStorageMonitorInternal
13485                    dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
13486            if (dsm != null) {
13487                return dsm.isMemoryLow();
13488            } else {
13489                return false;
13490            }
13491        } finally {
13492            Binder.restoreCallingIdentity(token);
13493        }
13494    }
13495
13496    @Override
13497    public IPackageInstaller getPackageInstaller() {
13498        return mInstallerService;
13499    }
13500
13501    private boolean userNeedsBadging(int userId) {
13502        int index = mUserNeedsBadging.indexOfKey(userId);
13503        if (index < 0) {
13504            final UserInfo userInfo;
13505            final long token = Binder.clearCallingIdentity();
13506            try {
13507                userInfo = sUserManager.getUserInfo(userId);
13508            } finally {
13509                Binder.restoreCallingIdentity(token);
13510            }
13511            final boolean b;
13512            if (userInfo != null && userInfo.isManagedProfile()) {
13513                b = true;
13514            } else {
13515                b = false;
13516            }
13517            mUserNeedsBadging.put(userId, b);
13518            return b;
13519        }
13520        return mUserNeedsBadging.valueAt(index);
13521    }
13522
13523    @Override
13524    public KeySet getKeySetByAlias(String packageName, String alias) {
13525        if (packageName == null || alias == null) {
13526            return null;
13527        }
13528        synchronized(mPackages) {
13529            final PackageParser.Package pkg = mPackages.get(packageName);
13530            if (pkg == null) {
13531                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13532                throw new IllegalArgumentException("Unknown package: " + packageName);
13533            }
13534            KeySetManagerService ksms = mSettings.mKeySetManagerService;
13535            return new KeySet(ksms.getKeySetByAliasAndPackageNameLPr(packageName, alias));
13536        }
13537    }
13538
13539    @Override
13540    public KeySet getSigningKeySet(String packageName) {
13541        if (packageName == null) {
13542            return null;
13543        }
13544        synchronized(mPackages) {
13545            final PackageParser.Package pkg = mPackages.get(packageName);
13546            if (pkg == null) {
13547                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13548                throw new IllegalArgumentException("Unknown package: " + packageName);
13549            }
13550            if (pkg.applicationInfo.uid != Binder.getCallingUid()
13551                    && Process.SYSTEM_UID != Binder.getCallingUid()) {
13552                throw new SecurityException("May not access signing KeySet of other apps.");
13553            }
13554            KeySetManagerService ksms = mSettings.mKeySetManagerService;
13555            return new KeySet(ksms.getSigningKeySetByPackageNameLPr(packageName));
13556        }
13557    }
13558
13559    @Override
13560    public boolean isPackageSignedByKeySet(String packageName, KeySet ks) {
13561        if (packageName == null || ks == null) {
13562            return false;
13563        }
13564        synchronized(mPackages) {
13565            final PackageParser.Package pkg = mPackages.get(packageName);
13566            if (pkg == null) {
13567                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13568                throw new IllegalArgumentException("Unknown package: " + packageName);
13569            }
13570            IBinder ksh = ks.getToken();
13571            if (ksh instanceof KeySetHandle) {
13572                KeySetManagerService ksms = mSettings.mKeySetManagerService;
13573                return ksms.packageIsSignedByLPr(packageName, (KeySetHandle) ksh);
13574            }
13575            return false;
13576        }
13577    }
13578
13579    @Override
13580    public boolean isPackageSignedByKeySetExactly(String packageName, KeySet ks) {
13581        if (packageName == null || ks == null) {
13582            return false;
13583        }
13584        synchronized(mPackages) {
13585            final PackageParser.Package pkg = mPackages.get(packageName);
13586            if (pkg == null) {
13587                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13588                throw new IllegalArgumentException("Unknown package: " + packageName);
13589            }
13590            IBinder ksh = ks.getToken();
13591            if (ksh instanceof KeySetHandle) {
13592                KeySetManagerService ksms = mSettings.mKeySetManagerService;
13593                return ksms.packageIsSignedByExactlyLPr(packageName, (KeySetHandle) ksh);
13594            }
13595            return false;
13596        }
13597    }
13598
13599    public void getUsageStatsIfNoPackageUsageInfo() {
13600        if (!mPackageUsage.isHistoricalPackageUsageAvailable()) {
13601            UsageStatsManager usm = (UsageStatsManager) mContext.getSystemService(Context.USAGE_STATS_SERVICE);
13602            if (usm == null) {
13603                throw new IllegalStateException("UsageStatsManager must be initialized");
13604            }
13605            long now = System.currentTimeMillis();
13606            Map<String, UsageStats> stats = usm.queryAndAggregateUsageStats(now - mDexOptLRUThresholdInMills, now);
13607            for (Map.Entry<String, UsageStats> entry : stats.entrySet()) {
13608                String packageName = entry.getKey();
13609                PackageParser.Package pkg = mPackages.get(packageName);
13610                if (pkg == null) {
13611                    continue;
13612                }
13613                UsageStats usage = entry.getValue();
13614                pkg.mLastPackageUsageTimeInMills = usage.getLastTimeUsed();
13615                mPackageUsage.mIsHistoricalPackageUsageAvailable = true;
13616            }
13617        }
13618    }
13619
13620    /**
13621     * Check and throw if the given before/after packages would be considered a
13622     * downgrade.
13623     */
13624    private static void checkDowngrade(PackageParser.Package before, PackageInfoLite after)
13625            throws PackageManagerException {
13626        if (after.versionCode < before.mVersionCode) {
13627            throw new PackageManagerException(INSTALL_FAILED_VERSION_DOWNGRADE,
13628                    "Update version code " + after.versionCode + " is older than current "
13629                    + before.mVersionCode);
13630        } else if (after.versionCode == before.mVersionCode) {
13631            if (after.baseRevisionCode < before.baseRevisionCode) {
13632                throw new PackageManagerException(INSTALL_FAILED_VERSION_DOWNGRADE,
13633                        "Update base revision code " + after.baseRevisionCode
13634                        + " is older than current " + before.baseRevisionCode);
13635            }
13636
13637            if (!ArrayUtils.isEmpty(after.splitNames)) {
13638                for (int i = 0; i < after.splitNames.length; i++) {
13639                    final String splitName = after.splitNames[i];
13640                    final int j = ArrayUtils.indexOf(before.splitNames, splitName);
13641                    if (j != -1) {
13642                        if (after.splitRevisionCodes[i] < before.splitRevisionCodes[j]) {
13643                            throw new PackageManagerException(INSTALL_FAILED_VERSION_DOWNGRADE,
13644                                    "Update split " + splitName + " revision code "
13645                                    + after.splitRevisionCodes[i] + " is older than current "
13646                                    + before.splitRevisionCodes[j]);
13647                        }
13648                    }
13649                }
13650            }
13651        }
13652    }
13653}
13654