PackageManagerService.java revision 7dba6eb3ac4fd6c8195cb0d0425866de50a9e114 
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_CPU_ABI_INCOMPATIBLE;
30import static android.content.pm.PackageManager.INSTALL_FAILED_DEXOPT;
31import static android.content.pm.PackageManager.INSTALL_FAILED_DUPLICATE_PACKAGE;
32import static android.content.pm.PackageManager.INSTALL_FAILED_DUPLICATE_PERMISSION;
33import static android.content.pm.PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
34import static android.content.pm.PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
35import static android.content.pm.PackageManager.INSTALL_FAILED_INVALID_APK;
36import static android.content.pm.PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
37import static android.content.pm.PackageManager.INSTALL_FAILED_MISSING_SHARED_LIBRARY;
38import static android.content.pm.PackageManager.INSTALL_FAILED_PACKAGE_CHANGED;
39import static android.content.pm.PackageManager.INSTALL_FAILED_REPLACE_COULDNT_DELETE;
40import static android.content.pm.PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
41import static android.content.pm.PackageManager.INSTALL_FAILED_TEST_ONLY;
42import static android.content.pm.PackageManager.INSTALL_FAILED_UID_CHANGED;
43import static android.content.pm.PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
44import static android.content.pm.PackageManager.INSTALL_FAILED_USER_RESTRICTED;
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 android.system.OsConstants.S_IRGRP;
53import static android.system.OsConstants.S_IROTH;
54import static android.system.OsConstants.S_IRWXU;
55import static android.system.OsConstants.S_IXGRP;
56import static android.system.OsConstants.S_IXOTH;
57import static com.android.internal.app.IntentForwarderActivity.FORWARD_INTENT_TO_MANAGED_PROFILE;
58import static com.android.internal.app.IntentForwarderActivity.FORWARD_INTENT_TO_USER_OWNER;
59import static com.android.internal.util.ArrayUtils.appendInt;
60import static com.android.internal.util.ArrayUtils.removeInt;
61
62import android.util.ArrayMap;
63
64import com.android.internal.R;
65import com.android.internal.app.IMediaContainerService;
66import com.android.internal.app.ResolverActivity;
67import com.android.internal.content.NativeLibraryHelper;
68import com.android.internal.content.PackageHelper;
69import com.android.internal.os.IParcelFileDescriptorFactory;
70import com.android.internal.util.ArrayUtils;
71import com.android.internal.util.FastPrintWriter;
72import com.android.internal.util.FastXmlSerializer;
73import com.android.internal.util.IndentingPrintWriter;
74import com.android.internal.util.Preconditions;
75import com.android.server.EventLogTags;
76import com.android.server.IntentResolver;
77import com.android.server.LocalServices;
78import com.android.server.ServiceThread;
79import com.android.server.SystemConfig;
80import com.android.server.Watchdog;
81import com.android.server.pm.Settings.DatabaseVersion;
82import com.android.server.storage.DeviceStorageMonitorInternal;
83
84import org.xmlpull.v1.XmlSerializer;
85
86import android.app.ActivityManager;
87import android.app.ActivityManagerNative;
88import android.app.IActivityManager;
89import android.app.admin.IDevicePolicyManager;
90import android.app.backup.IBackupManager;
91import android.content.BroadcastReceiver;
92import android.content.ComponentName;
93import android.content.Context;
94import android.content.IIntentReceiver;
95import android.content.Intent;
96import android.content.IntentFilter;
97import android.content.IntentSender;
98import android.content.IntentSender.SendIntentException;
99import android.content.ServiceConnection;
100import android.content.pm.ActivityInfo;
101import android.content.pm.ApplicationInfo;
102import android.content.pm.FeatureInfo;
103import android.content.pm.IPackageDataObserver;
104import android.content.pm.IPackageDeleteObserver;
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.InstallSessionParams;
111import android.content.pm.InstrumentationInfo;
112import android.content.pm.ManifestDigest;
113import android.content.pm.PackageCleanItem;
114import android.content.pm.PackageInfo;
115import android.content.pm.PackageInfoLite;
116import android.content.pm.PackageManager;
117import android.content.pm.PackageParser.ActivityIntentInfo;
118import android.content.pm.PackageParser.PackageLite;
119import android.content.pm.PackageParser.PackageParserException;
120import android.content.pm.PackageParser;
121import android.content.pm.PackageStats;
122import android.content.pm.PackageUserState;
123import android.content.pm.ParceledListSlice;
124import android.content.pm.PermissionGroupInfo;
125import android.content.pm.PermissionInfo;
126import android.content.pm.ProviderInfo;
127import android.content.pm.ResolveInfo;
128import android.content.pm.ServiceInfo;
129import android.content.pm.Signature;
130import android.content.pm.UserInfo;
131import android.content.pm.VerificationParams;
132import android.content.pm.VerifierDeviceIdentity;
133import android.content.pm.VerifierInfo;
134import android.content.res.Resources;
135import android.hardware.display.DisplayManager;
136import android.net.Uri;
137import android.os.Binder;
138import android.os.Build;
139import android.os.Bundle;
140import android.os.Environment;
141import android.os.Environment.UserEnvironment;
142import android.os.FileObserver;
143import android.os.FileUtils;
144import android.os.Handler;
145import android.os.IBinder;
146import android.os.Looper;
147import android.os.Message;
148import android.os.Parcel;
149import android.os.ParcelFileDescriptor;
150import android.os.Process;
151import android.os.RemoteException;
152import android.os.SELinux;
153import android.os.ServiceManager;
154import android.os.SystemClock;
155import android.os.SystemProperties;
156import android.os.UserHandle;
157import android.os.UserManager;
158import android.security.KeyStore;
159import android.security.SystemKeyStore;
160import android.system.ErrnoException;
161import android.system.Os;
162import android.system.StructStat;
163import android.text.TextUtils;
164import android.util.ArraySet;
165import android.util.AtomicFile;
166import android.util.DisplayMetrics;
167import android.util.EventLog;
168import android.util.ExceptionUtils;
169import android.util.Log;
170import android.util.LogPrinter;
171import android.util.PrintStreamPrinter;
172import android.util.Slog;
173import android.util.SparseArray;
174import android.util.SparseBooleanArray;
175import android.view.Display;
176
177import java.io.BufferedInputStream;
178import java.io.BufferedOutputStream;
179import java.io.File;
180import java.io.FileDescriptor;
181import java.io.FileInputStream;
182import java.io.FileNotFoundException;
183import java.io.FileOutputStream;
184import java.io.FilenameFilter;
185import java.io.IOException;
186import java.io.InputStream;
187import java.io.PrintWriter;
188import java.nio.charset.StandardCharsets;
189import java.security.NoSuchAlgorithmException;
190import java.security.PublicKey;
191import java.security.cert.CertificateEncodingException;
192import java.security.cert.CertificateException;
193import java.text.SimpleDateFormat;
194import java.util.ArrayList;
195import java.util.Arrays;
196import java.util.Collection;
197import java.util.Collections;
198import java.util.Comparator;
199import java.util.Date;
200import java.util.HashMap;
201import java.util.HashSet;
202import java.util.Iterator;
203import java.util.List;
204import java.util.Map;
205import java.util.Set;
206import java.util.concurrent.atomic.AtomicBoolean;
207import java.util.concurrent.atomic.AtomicLong;
208
209import dalvik.system.DexFile;
210import dalvik.system.StaleDexCacheError;
211import dalvik.system.VMRuntime;
212
213import libcore.io.IoUtils;
214
215/**
216 * Keep track of all those .apks everywhere.
217 *
218 * This is very central to the platform's security; please run the unit
219 * tests whenever making modifications here:
220 *
221mmm frameworks/base/tests/AndroidTests
222adb install -r -f out/target/product/passion/data/app/AndroidTests.apk
223adb shell am instrument -w -e class com.android.unit_tests.PackageManagerTests com.android.unit_tests/android.test.InstrumentationTestRunner
224 *
225 * {@hide}
226 */
227public class PackageManagerService extends IPackageManager.Stub {
228    static final String TAG = "PackageManager";
229    static final boolean DEBUG_SETTINGS = false;
230    static final boolean DEBUG_PREFERRED = false;
231    static final boolean DEBUG_UPGRADE = false;
232    private static final boolean DEBUG_INSTALL = false;
233    private static final boolean DEBUG_REMOVE = false;
234    private static final boolean DEBUG_BROADCASTS = false;
235    private static final boolean DEBUG_SHOW_INFO = false;
236    private static final boolean DEBUG_PACKAGE_INFO = false;
237    private static final boolean DEBUG_INTENT_MATCHING = false;
238    private static final boolean DEBUG_PACKAGE_SCANNING = false;
239    private static final boolean DEBUG_APP_DIR_OBSERVER = false;
240    private static final boolean DEBUG_VERIFY = false;
241    private static final boolean DEBUG_DEXOPT = false;
242    private static final boolean DEBUG_ABI_SELECTION = false;
243
244    private static final int RADIO_UID = Process.PHONE_UID;
245    private static final int LOG_UID = Process.LOG_UID;
246    private static final int NFC_UID = Process.NFC_UID;
247    private static final int BLUETOOTH_UID = Process.BLUETOOTH_UID;
248    private static final int SHELL_UID = Process.SHELL_UID;
249
250    // Cap the size of permission trees that 3rd party apps can define
251    private static final int MAX_PERMISSION_TREE_FOOTPRINT = 32768;     // characters of text
252
253    private static final int REMOVE_EVENTS =
254        FileObserver.CLOSE_WRITE | FileObserver.DELETE | FileObserver.MOVED_FROM;
255    private static final int ADD_EVENTS =
256        FileObserver.CLOSE_WRITE /*| FileObserver.CREATE*/ | FileObserver.MOVED_TO;
257
258    private static final int OBSERVER_EVENTS = REMOVE_EVENTS | ADD_EVENTS;
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_MONITOR = 1<<0;
264    static final int SCAN_NO_DEX = 1<<1;
265    static final int SCAN_FORCE_DEX = 1<<2;
266    static final int SCAN_UPDATE_SIGNATURE = 1<<3;
267    static final int SCAN_NEW_INSTALL = 1<<4;
268    static final int SCAN_NO_PATHS = 1<<5;
269    static final int SCAN_UPDATE_TIME = 1<<6;
270    static final int SCAN_DEFER_DEX = 1<<7;
271    static final int SCAN_BOOTING = 1<<8;
272    static final int SCAN_TRUSTED_OVERLAY = 1<<9;
273    static final int SCAN_DELETE_DATA_ON_FAILURES = 1<<10;
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     * Whether verification is enabled by default.
287     */
288    private static final boolean DEFAULT_VERIFY_ENABLE = true;
289
290    /**
291     * The default maximum time to wait for the verification agent to return in
292     * milliseconds.
293     */
294    private static final long DEFAULT_VERIFICATION_TIMEOUT = 10 * 1000;
295
296    /**
297     * The default response for package verification timeout.
298     *
299     * This can be either PackageManager.VERIFICATION_ALLOW or
300     * PackageManager.VERIFICATION_REJECT.
301     */
302    private static final int DEFAULT_VERIFICATION_RESPONSE = PackageManager.VERIFICATION_ALLOW;
303
304    static final String DEFAULT_CONTAINER_PACKAGE = "com.android.defcontainer";
305
306    static final ComponentName DEFAULT_CONTAINER_COMPONENT = new ComponentName(
307            DEFAULT_CONTAINER_PACKAGE,
308            "com.android.defcontainer.DefaultContainerService");
309
310    private static final String PACKAGE_MIME_TYPE = "application/vnd.android.package-archive";
311
312    private static final String LIB_DIR_NAME = "lib";
313    private static final String LIB64_DIR_NAME = "lib64";
314
315    private static final String VENDOR_OVERLAY_DIR = "/vendor/overlay";
316
317    static final String mTempContainerPrefix = "smdl2tmp";
318
319    private static String sPreferredInstructionSet;
320
321    final ServiceThread mHandlerThread;
322
323    private static final String IDMAP_PREFIX = "/data/resource-cache/";
324    private static final String IDMAP_SUFFIX = "@idmap";
325
326    final PackageHandler mHandler;
327
328    final int mSdkVersion = Build.VERSION.SDK_INT;
329
330    final Context mContext;
331    final boolean mFactoryTest;
332    final boolean mOnlyCore;
333    final DisplayMetrics mMetrics;
334    final int mDefParseFlags;
335    final String[] mSeparateProcesses;
336
337    // This is where all application persistent data goes.
338    final File mAppDataDir;
339
340    // This is where all application persistent data goes for secondary users.
341    final File mUserAppDataDir;
342
343    /** The location for ASEC container files on internal storage. */
344    final String mAsecInternalPath;
345
346    // This is the object monitoring the framework dir.
347    final FileObserver mFrameworkInstallObserver;
348
349    // This is the object monitoring the system app dir.
350    final FileObserver mSystemInstallObserver;
351
352    // This is the object monitoring the privileged system app dir.
353    final FileObserver mPrivilegedInstallObserver;
354
355    // This is the object monitoring the vendor app dir.
356    final FileObserver mVendorInstallObserver;
357
358    // This is the object monitoring the vendor overlay package dir.
359    final FileObserver mVendorOverlayInstallObserver;
360
361    // This is the object monitoring the OEM app dir.
362    final FileObserver mOemInstallObserver;
363
364    // This is the object monitoring mAppInstallDir.
365    final FileObserver mAppInstallObserver;
366
367    // This is the object monitoring mDrmAppPrivateInstallDir.
368    final FileObserver mDrmAppInstallObserver;
369
370    // Used for privilege escalation. MUST NOT BE CALLED WITH mPackages
371    // LOCK HELD.  Can be called with mInstallLock held.
372    final Installer mInstaller;
373
374    /** Directory where installed third-party apps stored */
375    final File mAppInstallDir;
376
377    /**
378     * Directory to which applications installed internally have their
379     * 32 bit native libraries copied.
380     */
381    private File mAppLib32InstallDir;
382
383    // Directory containing the private parts (e.g. code and non-resource assets) of forward-locked
384    // apps.
385    final File mDrmAppPrivateInstallDir;
386
387    // ----------------------------------------------------------------
388
389    // Lock for state used when installing and doing other long running
390    // operations.  Methods that must be called with this lock held have
391    // the suffix "LI".
392    final Object mInstallLock = new Object();
393
394    // These are the directories in the 3rd party applications installed dir
395    // that we have currently loaded packages from.  Keys are the application's
396    // installed zip file (absolute codePath), and values are Package.
397    final HashMap<String, PackageParser.Package> mAppDirs =
398            new HashMap<String, PackageParser.Package>();
399
400    // ----------------------------------------------------------------
401
402    // Keys are String (package name), values are Package.  This also serves
403    // as the lock for the global state.  Methods that must be called with
404    // this lock held have the prefix "LP".
405    final HashMap<String, PackageParser.Package> mPackages =
406            new HashMap<String, PackageParser.Package>();
407
408    // Tracks available target package names -> overlay package paths.
409    final HashMap<String, HashMap<String, PackageParser.Package>> mOverlays =
410        new HashMap<String, HashMap<String, PackageParser.Package>>();
411
412    final Settings mSettings;
413    boolean mRestoredSettings;
414
415    // System configuration read by SystemConfig.
416    final int[] mGlobalGids;
417    final SparseArray<HashSet<String>> mSystemPermissions;
418    final HashMap<String, FeatureInfo> mAvailableFeatures;
419
420    // If mac_permissions.xml was found for seinfo labeling.
421    boolean mFoundPolicyFile;
422
423    // If a recursive restorecon of /data/data/<pkg> is needed.
424    private boolean mShouldRestoreconData = SELinuxMMAC.shouldRestorecon();
425
426    public static final class SharedLibraryEntry {
427        public final String path;
428        public final String apk;
429
430        SharedLibraryEntry(String _path, String _apk) {
431            path = _path;
432            apk = _apk;
433        }
434    }
435
436    // Currently known shared libraries.
437    final HashMap<String, SharedLibraryEntry> mSharedLibraries =
438            new HashMap<String, SharedLibraryEntry>();
439
440    // All available activities, for your resolving pleasure.
441    final ActivityIntentResolver mActivities =
442            new ActivityIntentResolver();
443
444    // All available receivers, for your resolving pleasure.
445    final ActivityIntentResolver mReceivers =
446            new ActivityIntentResolver();
447
448    // All available services, for your resolving pleasure.
449    final ServiceIntentResolver mServices = new ServiceIntentResolver();
450
451    // All available providers, for your resolving pleasure.
452    final ProviderIntentResolver mProviders = new ProviderIntentResolver();
453
454    // Mapping from provider base names (first directory in content URI codePath)
455    // to the provider information.
456    final HashMap<String, PackageParser.Provider> mProvidersByAuthority =
457            new HashMap<String, PackageParser.Provider>();
458
459    // Mapping from instrumentation class names to info about them.
460    final HashMap<ComponentName, PackageParser.Instrumentation> mInstrumentation =
461            new HashMap<ComponentName, PackageParser.Instrumentation>();
462
463    // Mapping from permission names to info about them.
464    final HashMap<String, PackageParser.PermissionGroup> mPermissionGroups =
465            new HashMap<String, PackageParser.PermissionGroup>();
466
467    // Packages whose data we have transfered into another package, thus
468    // should no longer exist.
469    final HashSet<String> mTransferedPackages = new HashSet<String>();
470
471    // Broadcast actions that are only available to the system.
472    final HashSet<String> mProtectedBroadcasts = new HashSet<String>();
473
474    /** List of packages waiting for verification. */
475    final SparseArray<PackageVerificationState> mPendingVerification
476            = new SparseArray<PackageVerificationState>();
477
478    final PackageInstallerService mInstallerService;
479
480    HashSet<PackageParser.Package> mDeferredDexOpt = null;
481
482    // Cache of users who need badging.
483    SparseBooleanArray mUserNeedsBadging = new SparseBooleanArray();
484
485    /** Token for keys in mPendingVerification. */
486    private int mPendingVerificationToken = 0;
487
488    boolean mSystemReady;
489    boolean mSafeMode;
490    boolean mHasSystemUidErrors;
491
492    ApplicationInfo mAndroidApplication;
493    final ActivityInfo mResolveActivity = new ActivityInfo();
494    final ResolveInfo mResolveInfo = new ResolveInfo();
495    ComponentName mResolveComponentName;
496    PackageParser.Package mPlatformPackage;
497    ComponentName mCustomResolverComponentName;
498
499    boolean mResolverReplaced = false;
500
501    // Set of pending broadcasts for aggregating enable/disable of components.
502    static class PendingPackageBroadcasts {
503        // for each user id, a map of <package name -> components within that package>
504        final SparseArray<HashMap<String, ArrayList<String>>> mUidMap;
505
506        public PendingPackageBroadcasts() {
507            mUidMap = new SparseArray<HashMap<String, ArrayList<String>>>(2);
508        }
509
510        public ArrayList<String> get(int userId, String packageName) {
511            HashMap<String, ArrayList<String>> packages = getOrAllocate(userId);
512            return packages.get(packageName);
513        }
514
515        public void put(int userId, String packageName, ArrayList<String> components) {
516            HashMap<String, ArrayList<String>> packages = getOrAllocate(userId);
517            packages.put(packageName, components);
518        }
519
520        public void remove(int userId, String packageName) {
521            HashMap<String, ArrayList<String>> packages = mUidMap.get(userId);
522            if (packages != null) {
523                packages.remove(packageName);
524            }
525        }
526
527        public void remove(int userId) {
528            mUidMap.remove(userId);
529        }
530
531        public int userIdCount() {
532            return mUidMap.size();
533        }
534
535        public int userIdAt(int n) {
536            return mUidMap.keyAt(n);
537        }
538
539        public HashMap<String, ArrayList<String>> packagesForUserId(int userId) {
540            return mUidMap.get(userId);
541        }
542
543        public int size() {
544            // total number of pending broadcast entries across all userIds
545            int num = 0;
546            for (int i = 0; i< mUidMap.size(); i++) {
547                num += mUidMap.valueAt(i).size();
548            }
549            return num;
550        }
551
552        public void clear() {
553            mUidMap.clear();
554        }
555
556        private HashMap<String, ArrayList<String>> getOrAllocate(int userId) {
557            HashMap<String, ArrayList<String>> map = mUidMap.get(userId);
558            if (map == null) {
559                map = new HashMap<String, ArrayList<String>>();
560                mUidMap.put(userId, map);
561            }
562            return map;
563        }
564    }
565    final PendingPackageBroadcasts mPendingBroadcasts = new PendingPackageBroadcasts();
566
567    // Service Connection to remote media container service to copy
568    // package uri's from external media onto secure containers
569    // or internal storage.
570    private IMediaContainerService mContainerService = null;
571
572    static final int SEND_PENDING_BROADCAST = 1;
573    static final int MCS_BOUND = 3;
574    static final int END_COPY = 4;
575    static final int INIT_COPY = 5;
576    static final int MCS_UNBIND = 6;
577    static final int START_CLEANING_PACKAGE = 7;
578    static final int FIND_INSTALL_LOC = 8;
579    static final int POST_INSTALL = 9;
580    static final int MCS_RECONNECT = 10;
581    static final int MCS_GIVE_UP = 11;
582    static final int UPDATED_MEDIA_STATUS = 12;
583    static final int WRITE_SETTINGS = 13;
584    static final int WRITE_PACKAGE_RESTRICTIONS = 14;
585    static final int PACKAGE_VERIFIED = 15;
586    static final int CHECK_PENDING_VERIFICATION = 16;
587
588    static final int WRITE_SETTINGS_DELAY = 10*1000;  // 10 seconds
589
590    // Delay time in millisecs
591    static final int BROADCAST_DELAY = 10 * 1000;
592
593    static UserManagerService sUserManager;
594
595    // Stores a list of users whose package restrictions file needs to be updated
596    private HashSet<Integer> mDirtyUsers = new HashSet<Integer>();
597
598    final private DefaultContainerConnection mDefContainerConn =
599            new DefaultContainerConnection();
600    class DefaultContainerConnection implements ServiceConnection {
601        public void onServiceConnected(ComponentName name, IBinder service) {
602            if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceConnected");
603            IMediaContainerService imcs =
604                IMediaContainerService.Stub.asInterface(service);
605            mHandler.sendMessage(mHandler.obtainMessage(MCS_BOUND, imcs));
606        }
607
608        public void onServiceDisconnected(ComponentName name) {
609            if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceDisconnected");
610        }
611    };
612
613    // Recordkeeping of restore-after-install operations that are currently in flight
614    // between the Package Manager and the Backup Manager
615    class PostInstallData {
616        public InstallArgs args;
617        public PackageInstalledInfo res;
618
619        PostInstallData(InstallArgs _a, PackageInstalledInfo _r) {
620            args = _a;
621            res = _r;
622        }
623    };
624    final SparseArray<PostInstallData> mRunningInstalls = new SparseArray<PostInstallData>();
625    int mNextInstallToken = 1;  // nonzero; will be wrapped back to 1 when ++ overflows
626
627    private final String mRequiredVerifierPackage;
628
629    private final PackageUsage mPackageUsage = new PackageUsage();
630
631    private class PackageUsage {
632        private static final int WRITE_INTERVAL
633            = (DEBUG_DEXOPT) ? 0 : 30*60*1000; // 30m in ms
634
635        private final Object mFileLock = new Object();
636        private final AtomicLong mLastWritten = new AtomicLong(0);
637        private final AtomicBoolean mBackgroundWriteRunning = new AtomicBoolean(false);
638
639        private boolean mIsHistoricalPackageUsageAvailable = true;
640
641        boolean isHistoricalPackageUsageAvailable() {
642            return mIsHistoricalPackageUsageAvailable;
643        }
644
645        void write(boolean force) {
646            if (force) {
647                writeInternal();
648                return;
649            }
650            if (SystemClock.elapsedRealtime() - mLastWritten.get() < WRITE_INTERVAL
651                && !DEBUG_DEXOPT) {
652                return;
653            }
654            if (mBackgroundWriteRunning.compareAndSet(false, true)) {
655                new Thread("PackageUsage_DiskWriter") {
656                    @Override
657                    public void run() {
658                        try {
659                            writeInternal();
660                        } finally {
661                            mBackgroundWriteRunning.set(false);
662                        }
663                    }
664                }.start();
665            }
666        }
667
668        private void writeInternal() {
669            synchronized (mPackages) {
670                synchronized (mFileLock) {
671                    AtomicFile file = getFile();
672                    FileOutputStream f = null;
673                    try {
674                        f = file.startWrite();
675                        BufferedOutputStream out = new BufferedOutputStream(f);
676                        FileUtils.setPermissions(file.getBaseFile().getPath(), 0660, SYSTEM_UID, PACKAGE_INFO_GID);
677                        StringBuilder sb = new StringBuilder();
678                        for (PackageParser.Package pkg : mPackages.values()) {
679                            if (pkg.mLastPackageUsageTimeInMills == 0) {
680                                continue;
681                            }
682                            sb.setLength(0);
683                            sb.append(pkg.packageName);
684                            sb.append(' ');
685                            sb.append((long)pkg.mLastPackageUsageTimeInMills);
686                            sb.append('\n');
687                            out.write(sb.toString().getBytes(StandardCharsets.US_ASCII));
688                        }
689                        out.flush();
690                        file.finishWrite(f);
691                    } catch (IOException e) {
692                        if (f != null) {
693                            file.failWrite(f);
694                        }
695                        Log.e(TAG, "Failed to write package usage times", e);
696                    }
697                }
698            }
699            mLastWritten.set(SystemClock.elapsedRealtime());
700        }
701
702        void readLP() {
703            synchronized (mFileLock) {
704                AtomicFile file = getFile();
705                BufferedInputStream in = null;
706                try {
707                    in = new BufferedInputStream(file.openRead());
708                    StringBuffer sb = new StringBuffer();
709                    while (true) {
710                        String packageName = readToken(in, sb, ' ');
711                        if (packageName == null) {
712                            break;
713                        }
714                        String timeInMillisString = readToken(in, sb, '\n');
715                        if (timeInMillisString == null) {
716                            throw new IOException("Failed to find last usage time for package "
717                                                  + packageName);
718                        }
719                        PackageParser.Package pkg = mPackages.get(packageName);
720                        if (pkg == null) {
721                            continue;
722                        }
723                        long timeInMillis;
724                        try {
725                            timeInMillis = Long.parseLong(timeInMillisString.toString());
726                        } catch (NumberFormatException e) {
727                            throw new IOException("Failed to parse " + timeInMillisString
728                                                  + " as a long.", e);
729                        }
730                        pkg.mLastPackageUsageTimeInMills = timeInMillis;
731                    }
732                } catch (FileNotFoundException expected) {
733                    mIsHistoricalPackageUsageAvailable = false;
734                } catch (IOException e) {
735                    Log.w(TAG, "Failed to read package usage times", e);
736                } finally {
737                    IoUtils.closeQuietly(in);
738                }
739            }
740            mLastWritten.set(SystemClock.elapsedRealtime());
741        }
742
743        private String readToken(InputStream in, StringBuffer sb, char endOfToken)
744                throws IOException {
745            sb.setLength(0);
746            while (true) {
747                int ch = in.read();
748                if (ch == -1) {
749                    if (sb.length() == 0) {
750                        return null;
751                    }
752                    throw new IOException("Unexpected EOF");
753                }
754                if (ch == endOfToken) {
755                    return sb.toString();
756                }
757                sb.append((char)ch);
758            }
759        }
760
761        private AtomicFile getFile() {
762            File dataDir = Environment.getDataDirectory();
763            File systemDir = new File(dataDir, "system");
764            File fname = new File(systemDir, "package-usage.list");
765            return new AtomicFile(fname);
766        }
767    }
768
769    class PackageHandler extends Handler {
770        private boolean mBound = false;
771        final ArrayList<HandlerParams> mPendingInstalls =
772            new ArrayList<HandlerParams>();
773
774        private boolean connectToService() {
775            if (DEBUG_SD_INSTALL) Log.i(TAG, "Trying to bind to" +
776                    " DefaultContainerService");
777            Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
778            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
779            if (mContext.bindServiceAsUser(service, mDefContainerConn,
780                    Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
781                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
782                mBound = true;
783                return true;
784            }
785            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
786            return false;
787        }
788
789        private void disconnectService() {
790            mContainerService = null;
791            mBound = false;
792            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
793            mContext.unbindService(mDefContainerConn);
794            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
795        }
796
797        PackageHandler(Looper looper) {
798            super(looper);
799        }
800
801        public void handleMessage(Message msg) {
802            try {
803                doHandleMessage(msg);
804            } finally {
805                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
806            }
807        }
808
809        void doHandleMessage(Message msg) {
810            switch (msg.what) {
811                case INIT_COPY: {
812                    HandlerParams params = (HandlerParams) msg.obj;
813                    int idx = mPendingInstalls.size();
814                    if (DEBUG_INSTALL) Slog.i(TAG, "init_copy idx=" + idx + ": " + params);
815                    // If a bind was already initiated we dont really
816                    // need to do anything. The pending install
817                    // will be processed later on.
818                    if (!mBound) {
819                        // If this is the only one pending we might
820                        // have to bind to the service again.
821                        if (!connectToService()) {
822                            Slog.e(TAG, "Failed to bind to media container service");
823                            params.serviceError();
824                            return;
825                        } else {
826                            // Once we bind to the service, the first
827                            // pending request will be processed.
828                            mPendingInstalls.add(idx, params);
829                        }
830                    } else {
831                        mPendingInstalls.add(idx, params);
832                        // Already bound to the service. Just make
833                        // sure we trigger off processing the first request.
834                        if (idx == 0) {
835                            mHandler.sendEmptyMessage(MCS_BOUND);
836                        }
837                    }
838                    break;
839                }
840                case MCS_BOUND: {
841                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_bound");
842                    if (msg.obj != null) {
843                        mContainerService = (IMediaContainerService) msg.obj;
844                    }
845                    if (mContainerService == null) {
846                        // Something seriously wrong. Bail out
847                        Slog.e(TAG, "Cannot bind to media container service");
848                        for (HandlerParams params : mPendingInstalls) {
849                            // Indicate service bind error
850                            params.serviceError();
851                        }
852                        mPendingInstalls.clear();
853                    } else if (mPendingInstalls.size() > 0) {
854                        HandlerParams params = mPendingInstalls.get(0);
855                        if (params != null) {
856                            if (params.startCopy()) {
857                                // We are done...  look for more work or to
858                                // go idle.
859                                if (DEBUG_SD_INSTALL) Log.i(TAG,
860                                        "Checking for more work or unbind...");
861                                // Delete pending install
862                                if (mPendingInstalls.size() > 0) {
863                                    mPendingInstalls.remove(0);
864                                }
865                                if (mPendingInstalls.size() == 0) {
866                                    if (mBound) {
867                                        if (DEBUG_SD_INSTALL) Log.i(TAG,
868                                                "Posting delayed MCS_UNBIND");
869                                        removeMessages(MCS_UNBIND);
870                                        Message ubmsg = obtainMessage(MCS_UNBIND);
871                                        // Unbind after a little delay, to avoid
872                                        // continual thrashing.
873                                        sendMessageDelayed(ubmsg, 10000);
874                                    }
875                                } else {
876                                    // There are more pending requests in queue.
877                                    // Just post MCS_BOUND message to trigger processing
878                                    // of next pending install.
879                                    if (DEBUG_SD_INSTALL) Log.i(TAG,
880                                            "Posting MCS_BOUND for next work");
881                                    mHandler.sendEmptyMessage(MCS_BOUND);
882                                }
883                            }
884                        }
885                    } else {
886                        // Should never happen ideally.
887                        Slog.w(TAG, "Empty queue");
888                    }
889                    break;
890                }
891                case MCS_RECONNECT: {
892                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_reconnect");
893                    if (mPendingInstalls.size() > 0) {
894                        if (mBound) {
895                            disconnectService();
896                        }
897                        if (!connectToService()) {
898                            Slog.e(TAG, "Failed to bind to media container service");
899                            for (HandlerParams params : mPendingInstalls) {
900                                // Indicate service bind error
901                                params.serviceError();
902                            }
903                            mPendingInstalls.clear();
904                        }
905                    }
906                    break;
907                }
908                case MCS_UNBIND: {
909                    // If there is no actual work left, then time to unbind.
910                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_unbind");
911
912                    if (mPendingInstalls.size() == 0 && mPendingVerification.size() == 0) {
913                        if (mBound) {
914                            if (DEBUG_INSTALL) Slog.i(TAG, "calling disconnectService()");
915
916                            disconnectService();
917                        }
918                    } else if (mPendingInstalls.size() > 0) {
919                        // There are more pending requests in queue.
920                        // Just post MCS_BOUND message to trigger processing
921                        // of next pending install.
922                        mHandler.sendEmptyMessage(MCS_BOUND);
923                    }
924
925                    break;
926                }
927                case MCS_GIVE_UP: {
928                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_giveup too many retries");
929                    mPendingInstalls.remove(0);
930                    break;
931                }
932                case SEND_PENDING_BROADCAST: {
933                    String packages[];
934                    ArrayList<String> components[];
935                    int size = 0;
936                    int uids[];
937                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
938                    synchronized (mPackages) {
939                        if (mPendingBroadcasts == null) {
940                            return;
941                        }
942                        size = mPendingBroadcasts.size();
943                        if (size <= 0) {
944                            // Nothing to be done. Just return
945                            return;
946                        }
947                        packages = new String[size];
948                        components = new ArrayList[size];
949                        uids = new int[size];
950                        int i = 0;  // filling out the above arrays
951
952                        for (int n = 0; n < mPendingBroadcasts.userIdCount(); n++) {
953                            int packageUserId = mPendingBroadcasts.userIdAt(n);
954                            Iterator<Map.Entry<String, ArrayList<String>>> it
955                                    = mPendingBroadcasts.packagesForUserId(packageUserId)
956                                            .entrySet().iterator();
957                            while (it.hasNext() && i < size) {
958                                Map.Entry<String, ArrayList<String>> ent = it.next();
959                                packages[i] = ent.getKey();
960                                components[i] = ent.getValue();
961                                PackageSetting ps = mSettings.mPackages.get(ent.getKey());
962                                uids[i] = (ps != null)
963                                        ? UserHandle.getUid(packageUserId, ps.appId)
964                                        : -1;
965                                i++;
966                            }
967                        }
968                        size = i;
969                        mPendingBroadcasts.clear();
970                    }
971                    // Send broadcasts
972                    for (int i = 0; i < size; i++) {
973                        sendPackageChangedBroadcast(packages[i], true, components[i], uids[i]);
974                    }
975                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
976                    break;
977                }
978                case START_CLEANING_PACKAGE: {
979                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
980                    final String packageName = (String)msg.obj;
981                    final int userId = msg.arg1;
982                    final boolean andCode = msg.arg2 != 0;
983                    synchronized (mPackages) {
984                        if (userId == UserHandle.USER_ALL) {
985                            int[] users = sUserManager.getUserIds();
986                            for (int user : users) {
987                                mSettings.addPackageToCleanLPw(
988                                        new PackageCleanItem(user, packageName, andCode));
989                            }
990                        } else {
991                            mSettings.addPackageToCleanLPw(
992                                    new PackageCleanItem(userId, packageName, andCode));
993                        }
994                    }
995                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
996                    startCleaningPackages();
997                } break;
998                case POST_INSTALL: {
999                    if (DEBUG_INSTALL) Log.v(TAG, "Handling post-install for " + msg.arg1);
1000                    PostInstallData data = mRunningInstalls.get(msg.arg1);
1001                    mRunningInstalls.delete(msg.arg1);
1002                    boolean deleteOld = false;
1003
1004                    if (data != null) {
1005                        InstallArgs args = data.args;
1006                        PackageInstalledInfo res = data.res;
1007
1008                        if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
1009                            res.removedInfo.sendBroadcast(false, true, false);
1010                            Bundle extras = new Bundle(1);
1011                            extras.putInt(Intent.EXTRA_UID, res.uid);
1012                            // Determine the set of users who are adding this
1013                            // package for the first time vs. those who are seeing
1014                            // an update.
1015                            int[] firstUsers;
1016                            int[] updateUsers = new int[0];
1017                            if (res.origUsers == null || res.origUsers.length == 0) {
1018                                firstUsers = res.newUsers;
1019                            } else {
1020                                firstUsers = new int[0];
1021                                for (int i=0; i<res.newUsers.length; i++) {
1022                                    int user = res.newUsers[i];
1023                                    boolean isNew = true;
1024                                    for (int j=0; j<res.origUsers.length; j++) {
1025                                        if (res.origUsers[j] == user) {
1026                                            isNew = false;
1027                                            break;
1028                                        }
1029                                    }
1030                                    if (isNew) {
1031                                        int[] newFirst = new int[firstUsers.length+1];
1032                                        System.arraycopy(firstUsers, 0, newFirst, 0,
1033                                                firstUsers.length);
1034                                        newFirst[firstUsers.length] = user;
1035                                        firstUsers = newFirst;
1036                                    } else {
1037                                        int[] newUpdate = new int[updateUsers.length+1];
1038                                        System.arraycopy(updateUsers, 0, newUpdate, 0,
1039                                                updateUsers.length);
1040                                        newUpdate[updateUsers.length] = user;
1041                                        updateUsers = newUpdate;
1042                                    }
1043                                }
1044                            }
1045                            sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
1046                                    res.pkg.applicationInfo.packageName,
1047                                    extras, null, null, firstUsers);
1048                            final boolean update = res.removedInfo.removedPackage != null;
1049                            if (update) {
1050                                extras.putBoolean(Intent.EXTRA_REPLACING, true);
1051                            }
1052                            sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
1053                                    res.pkg.applicationInfo.packageName,
1054                                    extras, null, null, updateUsers);
1055                            if (update) {
1056                                sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED,
1057                                        res.pkg.applicationInfo.packageName,
1058                                        extras, null, null, updateUsers);
1059                                sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED,
1060                                        null, null,
1061                                        res.pkg.applicationInfo.packageName, null, updateUsers);
1062
1063                                // treat asec-hosted packages like removable media on upgrade
1064                                if (isForwardLocked(res.pkg) || isExternal(res.pkg)) {
1065                                    if (DEBUG_INSTALL) {
1066                                        Slog.i(TAG, "upgrading pkg " + res.pkg
1067                                                + " is ASEC-hosted -> AVAILABLE");
1068                                    }
1069                                    int[] uidArray = new int[] { res.pkg.applicationInfo.uid };
1070                                    ArrayList<String> pkgList = new ArrayList<String>(1);
1071                                    pkgList.add(res.pkg.applicationInfo.packageName);
1072                                    sendResourcesChangedBroadcast(true, true,
1073                                            pkgList,uidArray, null);
1074                                }
1075                            }
1076                            if (res.removedInfo.args != null) {
1077                                // Remove the replaced package's older resources safely now
1078                                deleteOld = true;
1079                            }
1080
1081                            // Log current value of "unknown sources" setting
1082                            EventLog.writeEvent(EventLogTags.UNKNOWN_SOURCES_ENABLED,
1083                                getUnknownSourcesSettings());
1084                        }
1085                        // Force a gc to clear up things
1086                        Runtime.getRuntime().gc();
1087                        // We delete after a gc for applications  on sdcard.
1088                        if (deleteOld) {
1089                            synchronized (mInstallLock) {
1090                                res.removedInfo.args.doPostDeleteLI(true);
1091                            }
1092                        }
1093                        if (args.observer != null) {
1094                            try {
1095                                Bundle extras = extrasForInstallResult(res);
1096                                args.observer.packageInstalled(res.name, extras, res.returnCode,
1097                                        res.returnMsg);
1098                            } catch (RemoteException e) {
1099                                Slog.i(TAG, "Observer no longer exists.");
1100                            }
1101                        }
1102                    } else {
1103                        Slog.e(TAG, "Bogus post-install token " + msg.arg1);
1104                    }
1105                } break;
1106                case UPDATED_MEDIA_STATUS: {
1107                    if (DEBUG_SD_INSTALL) Log.i(TAG, "Got message UPDATED_MEDIA_STATUS");
1108                    boolean reportStatus = msg.arg1 == 1;
1109                    boolean doGc = msg.arg2 == 1;
1110                    if (DEBUG_SD_INSTALL) Log.i(TAG, "reportStatus=" + reportStatus + ", doGc = " + doGc);
1111                    if (doGc) {
1112                        // Force a gc to clear up stale containers.
1113                        Runtime.getRuntime().gc();
1114                    }
1115                    if (msg.obj != null) {
1116                        @SuppressWarnings("unchecked")
1117                        Set<AsecInstallArgs> args = (Set<AsecInstallArgs>) msg.obj;
1118                        if (DEBUG_SD_INSTALL) Log.i(TAG, "Unloading all containers");
1119                        // Unload containers
1120                        unloadAllContainers(args);
1121                    }
1122                    if (reportStatus) {
1123                        try {
1124                            if (DEBUG_SD_INSTALL) Log.i(TAG, "Invoking MountService call back");
1125                            PackageHelper.getMountService().finishMediaUpdate();
1126                        } catch (RemoteException e) {
1127                            Log.e(TAG, "MountService not running?");
1128                        }
1129                    }
1130                } break;
1131                case WRITE_SETTINGS: {
1132                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1133                    synchronized (mPackages) {
1134                        removeMessages(WRITE_SETTINGS);
1135                        removeMessages(WRITE_PACKAGE_RESTRICTIONS);
1136                        mSettings.writeLPr();
1137                        mDirtyUsers.clear();
1138                    }
1139                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1140                } break;
1141                case WRITE_PACKAGE_RESTRICTIONS: {
1142                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1143                    synchronized (mPackages) {
1144                        removeMessages(WRITE_PACKAGE_RESTRICTIONS);
1145                        for (int userId : mDirtyUsers) {
1146                            mSettings.writePackageRestrictionsLPr(userId);
1147                        }
1148                        mDirtyUsers.clear();
1149                    }
1150                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1151                } break;
1152                case CHECK_PENDING_VERIFICATION: {
1153                    final int verificationId = msg.arg1;
1154                    final PackageVerificationState state = mPendingVerification.get(verificationId);
1155
1156                    if ((state != null) && !state.timeoutExtended()) {
1157                        final InstallArgs args = state.getInstallArgs();
1158                        final Uri originUri = Uri.fromFile(args.originFile);
1159
1160                        Slog.i(TAG, "Verification timed out for " + originUri);
1161                        mPendingVerification.remove(verificationId);
1162
1163                        int ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
1164
1165                        if (getDefaultVerificationResponse() == PackageManager.VERIFICATION_ALLOW) {
1166                            Slog.i(TAG, "Continuing with installation of " + originUri);
1167                            state.setVerifierResponse(Binder.getCallingUid(),
1168                                    PackageManager.VERIFICATION_ALLOW_WITHOUT_SUFFICIENT);
1169                            broadcastPackageVerified(verificationId, originUri,
1170                                    PackageManager.VERIFICATION_ALLOW,
1171                                    state.getInstallArgs().getUser());
1172                            try {
1173                                ret = args.copyApk(mContainerService, true);
1174                            } catch (RemoteException e) {
1175                                Slog.e(TAG, "Could not contact the ContainerService");
1176                            }
1177                        } else {
1178                            broadcastPackageVerified(verificationId, originUri,
1179                                    PackageManager.VERIFICATION_REJECT,
1180                                    state.getInstallArgs().getUser());
1181                        }
1182
1183                        processPendingInstall(args, ret);
1184                        mHandler.sendEmptyMessage(MCS_UNBIND);
1185                    }
1186                    break;
1187                }
1188                case PACKAGE_VERIFIED: {
1189                    final int verificationId = msg.arg1;
1190
1191                    final PackageVerificationState state = mPendingVerification.get(verificationId);
1192                    if (state == null) {
1193                        Slog.w(TAG, "Invalid verification token " + verificationId + " received");
1194                        break;
1195                    }
1196
1197                    final PackageVerificationResponse response = (PackageVerificationResponse) msg.obj;
1198
1199                    state.setVerifierResponse(response.callerUid, response.code);
1200
1201                    if (state.isVerificationComplete()) {
1202                        mPendingVerification.remove(verificationId);
1203
1204                        final InstallArgs args = state.getInstallArgs();
1205                        final Uri originUri = Uri.fromFile(args.originFile);
1206
1207                        int ret;
1208                        if (state.isInstallAllowed()) {
1209                            ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
1210                            broadcastPackageVerified(verificationId, originUri,
1211                                    response.code, state.getInstallArgs().getUser());
1212                            try {
1213                                ret = args.copyApk(mContainerService, true);
1214                            } catch (RemoteException e) {
1215                                Slog.e(TAG, "Could not contact the ContainerService");
1216                            }
1217                        } else {
1218                            ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
1219                        }
1220
1221                        processPendingInstall(args, ret);
1222
1223                        mHandler.sendEmptyMessage(MCS_UNBIND);
1224                    }
1225
1226                    break;
1227                }
1228            }
1229        }
1230    }
1231
1232    Bundle extrasForInstallResult(PackageInstalledInfo res) {
1233        Bundle extras = null;
1234        switch (res.returnCode) {
1235            case PackageManager.INSTALL_FAILED_DUPLICATE_PERMISSION: {
1236                extras = new Bundle();
1237                extras.putString(PackageManager.EXTRA_FAILURE_EXISTING_PERMISSION,
1238                        res.origPermission);
1239                extras.putString(PackageManager.EXTRA_FAILURE_EXISTING_PACKAGE,
1240                        res.origPackage);
1241                break;
1242            }
1243        }
1244        return extras;
1245    }
1246
1247    void scheduleWriteSettingsLocked() {
1248        if (!mHandler.hasMessages(WRITE_SETTINGS)) {
1249            mHandler.sendEmptyMessageDelayed(WRITE_SETTINGS, WRITE_SETTINGS_DELAY);
1250        }
1251    }
1252
1253    void scheduleWritePackageRestrictionsLocked(int userId) {
1254        if (!sUserManager.exists(userId)) return;
1255        mDirtyUsers.add(userId);
1256        if (!mHandler.hasMessages(WRITE_PACKAGE_RESTRICTIONS)) {
1257            mHandler.sendEmptyMessageDelayed(WRITE_PACKAGE_RESTRICTIONS, WRITE_SETTINGS_DELAY);
1258        }
1259    }
1260
1261    public static final PackageManagerService main(Context context, Installer installer,
1262            boolean factoryTest, boolean onlyCore) {
1263        PackageManagerService m = new PackageManagerService(context, installer,
1264                factoryTest, onlyCore);
1265        ServiceManager.addService("package", m);
1266        return m;
1267    }
1268
1269    static String[] splitString(String str, char sep) {
1270        int count = 1;
1271        int i = 0;
1272        while ((i=str.indexOf(sep, i)) >= 0) {
1273            count++;
1274            i++;
1275        }
1276
1277        String[] res = new String[count];
1278        i=0;
1279        count = 0;
1280        int lastI=0;
1281        while ((i=str.indexOf(sep, i)) >= 0) {
1282            res[count] = str.substring(lastI, i);
1283            count++;
1284            i++;
1285            lastI = i;
1286        }
1287        res[count] = str.substring(lastI, str.length());
1288        return res;
1289    }
1290
1291    private static void getDefaultDisplayMetrics(Context context, DisplayMetrics metrics) {
1292        DisplayManager displayManager = (DisplayManager) context.getSystemService(
1293                Context.DISPLAY_SERVICE);
1294        displayManager.getDisplay(Display.DEFAULT_DISPLAY).getMetrics(metrics);
1295    }
1296
1297    public PackageManagerService(Context context, Installer installer,
1298            boolean factoryTest, boolean onlyCore) {
1299        EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START,
1300                SystemClock.uptimeMillis());
1301
1302        if (mSdkVersion <= 0) {
1303            Slog.w(TAG, "**** ro.build.version.sdk not set!");
1304        }
1305
1306        mContext = context;
1307        mFactoryTest = factoryTest;
1308        mOnlyCore = onlyCore;
1309        mMetrics = new DisplayMetrics();
1310        mSettings = new Settings(context);
1311        mSettings.addSharedUserLPw("android.uid.system", Process.SYSTEM_UID,
1312                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1313        mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID,
1314                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1315        mSettings.addSharedUserLPw("android.uid.log", LOG_UID,
1316                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1317        mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID,
1318                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1319        mSettings.addSharedUserLPw("android.uid.bluetooth", BLUETOOTH_UID,
1320                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1321        mSettings.addSharedUserLPw("android.uid.shell", SHELL_UID,
1322                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1323
1324        String separateProcesses = SystemProperties.get("debug.separate_processes");
1325        if (separateProcesses != null && separateProcesses.length() > 0) {
1326            if ("*".equals(separateProcesses)) {
1327                mDefParseFlags = PackageParser.PARSE_IGNORE_PROCESSES;
1328                mSeparateProcesses = null;
1329                Slog.w(TAG, "Running with debug.separate_processes: * (ALL)");
1330            } else {
1331                mDefParseFlags = 0;
1332                mSeparateProcesses = separateProcesses.split(",");
1333                Slog.w(TAG, "Running with debug.separate_processes: "
1334                        + separateProcesses);
1335            }
1336        } else {
1337            mDefParseFlags = 0;
1338            mSeparateProcesses = null;
1339        }
1340
1341        mInstaller = installer;
1342
1343        getDefaultDisplayMetrics(context, mMetrics);
1344
1345        SystemConfig systemConfig = SystemConfig.getInstance();
1346        mGlobalGids = systemConfig.getGlobalGids();
1347        mSystemPermissions = systemConfig.getSystemPermissions();
1348        mAvailableFeatures = systemConfig.getAvailableFeatures();
1349
1350        synchronized (mInstallLock) {
1351        // writer
1352        synchronized (mPackages) {
1353            mHandlerThread = new ServiceThread(TAG,
1354                    Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
1355            mHandlerThread.start();
1356            mHandler = new PackageHandler(mHandlerThread.getLooper());
1357            Watchdog.getInstance().addThread(mHandler, WATCHDOG_TIMEOUT);
1358
1359            File dataDir = Environment.getDataDirectory();
1360            mAppDataDir = new File(dataDir, "data");
1361            mAppInstallDir = new File(dataDir, "app");
1362            mAppLib32InstallDir = new File(dataDir, "app-lib");
1363            mAsecInternalPath = new File(dataDir, "app-asec").getPath();
1364            mUserAppDataDir = new File(dataDir, "user");
1365            mDrmAppPrivateInstallDir = new File(dataDir, "app-private");
1366
1367            sUserManager = new UserManagerService(context, this,
1368                    mInstallLock, mPackages);
1369
1370            // Propagate permission configuration in to package manager.
1371            ArrayMap<String, SystemConfig.PermissionEntry> permConfig
1372                    = systemConfig.getPermissions();
1373            for (int i=0; i<permConfig.size(); i++) {
1374                SystemConfig.PermissionEntry perm = permConfig.valueAt(i);
1375                BasePermission bp = mSettings.mPermissions.get(perm.name);
1376                if (bp == null) {
1377                    bp = new BasePermission(perm.name, null, BasePermission.TYPE_BUILTIN);
1378                    mSettings.mPermissions.put(perm.name, bp);
1379                }
1380                if (perm.gids != null) {
1381                    bp.gids = appendInts(bp.gids, perm.gids);
1382                }
1383            }
1384
1385            ArrayMap<String, String> libConfig = systemConfig.getSharedLibraries();
1386            for (int i=0; i<libConfig.size(); i++) {
1387                mSharedLibraries.put(libConfig.keyAt(i),
1388                        new SharedLibraryEntry(libConfig.valueAt(i), null));
1389            }
1390
1391            mFoundPolicyFile = SELinuxMMAC.readInstallPolicy();
1392
1393            mRestoredSettings = mSettings.readLPw(this, sUserManager.getUsers(false),
1394                    mSdkVersion, mOnlyCore);
1395
1396            String customResolverActivity = Resources.getSystem().getString(
1397                    R.string.config_customResolverActivity);
1398            if (TextUtils.isEmpty(customResolverActivity)) {
1399                customResolverActivity = null;
1400            } else {
1401                mCustomResolverComponentName = ComponentName.unflattenFromString(
1402                        customResolverActivity);
1403            }
1404
1405            long startTime = SystemClock.uptimeMillis();
1406
1407            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SYSTEM_SCAN_START,
1408                    startTime);
1409
1410            // Set flag to monitor and not change apk file paths when
1411            // scanning install directories.
1412            int scanMode = SCAN_MONITOR | SCAN_NO_PATHS | SCAN_DEFER_DEX | SCAN_BOOTING;
1413
1414            final HashSet<String> alreadyDexOpted = new HashSet<String>();
1415
1416            /**
1417             * Add everything in the in the boot class path to the
1418             * list of process files because dexopt will have been run
1419             * if necessary during zygote startup.
1420             */
1421            String bootClassPath = System.getProperty("java.boot.class.path");
1422            if (bootClassPath != null) {
1423                String[] paths = splitString(bootClassPath, ':');
1424                for (int i=0; i<paths.length; i++) {
1425                    alreadyDexOpted.add(paths[i]);
1426                }
1427            } else {
1428                Slog.w(TAG, "No BOOTCLASSPATH found!");
1429            }
1430
1431            boolean didDexOptLibraryOrTool = false;
1432
1433            final List<String> instructionSets = getAllInstructionSets();
1434
1435            /**
1436             * Ensure all external libraries have had dexopt run on them.
1437             */
1438            if (mSharedLibraries.size() > 0) {
1439                // NOTE: For now, we're compiling these system "shared libraries"
1440                // (and framework jars) into all available architectures. It's possible
1441                // to compile them only when we come across an app that uses them (there's
1442                // already logic for that in scanPackageLI) but that adds some complexity.
1443                for (String instructionSet : instructionSets) {
1444                    for (SharedLibraryEntry libEntry : mSharedLibraries.values()) {
1445                        final String lib = libEntry.path;
1446                        if (lib == null) {
1447                            continue;
1448                        }
1449
1450                        try {
1451                            if (DexFile.isDexOptNeededInternal(lib, null, instructionSet, false)) {
1452                                alreadyDexOpted.add(lib);
1453
1454                                // The list of "shared libraries" we have at this point is
1455                                mInstaller.dexopt(lib, Process.SYSTEM_UID, true, instructionSet);
1456                                didDexOptLibraryOrTool = true;
1457                            }
1458                        } catch (FileNotFoundException e) {
1459                            Slog.w(TAG, "Library not found: " + lib);
1460                        } catch (IOException e) {
1461                            Slog.w(TAG, "Cannot dexopt " + lib + "; is it an APK or JAR? "
1462                                    + e.getMessage());
1463                        }
1464                    }
1465                }
1466            }
1467
1468            File frameworkDir = new File(Environment.getRootDirectory(), "framework");
1469
1470            // Gross hack for now: we know this file doesn't contain any
1471            // code, so don't dexopt it to avoid the resulting log spew.
1472            alreadyDexOpted.add(frameworkDir.getPath() + "/framework-res.apk");
1473
1474            // Gross hack for now: we know this file is only part of
1475            // the boot class path for art, so don't dexopt it to
1476            // avoid the resulting log spew.
1477            alreadyDexOpted.add(frameworkDir.getPath() + "/core-libart.jar");
1478
1479            /**
1480             * And there are a number of commands implemented in Java, which
1481             * we currently need to do the dexopt on so that they can be
1482             * run from a non-root shell.
1483             */
1484            String[] frameworkFiles = frameworkDir.list();
1485            if (frameworkFiles != null) {
1486                // TODO: We could compile these only for the most preferred ABI. We should
1487                // first double check that the dex files for these commands are not referenced
1488                // by other system apps.
1489                for (String instructionSet : instructionSets) {
1490                    for (int i=0; i<frameworkFiles.length; i++) {
1491                        File libPath = new File(frameworkDir, frameworkFiles[i]);
1492                        String path = libPath.getPath();
1493                        // Skip the file if we already did it.
1494                        if (alreadyDexOpted.contains(path)) {
1495                            continue;
1496                        }
1497                        // Skip the file if it is not a type we want to dexopt.
1498                        if (!path.endsWith(".apk") && !path.endsWith(".jar")) {
1499                            continue;
1500                        }
1501                        try {
1502                            if (DexFile.isDexOptNeededInternal(path, null, instructionSet, false)) {
1503                                mInstaller.dexopt(path, Process.SYSTEM_UID, true, instructionSet);
1504                                didDexOptLibraryOrTool = true;
1505                            }
1506                        } catch (FileNotFoundException e) {
1507                            Slog.w(TAG, "Jar not found: " + path);
1508                        } catch (IOException e) {
1509                            Slog.w(TAG, "Exception reading jar: " + path, e);
1510                        }
1511                    }
1512                }
1513            }
1514
1515            if (didDexOptLibraryOrTool) {
1516                // If we dexopted a library or tool, then something on the system has
1517                // changed. Consider this significant, and wipe away all other
1518                // existing dexopt files to ensure we don't leave any dangling around.
1519                //
1520                // TODO: This should be revisited because it isn't as good an indicator
1521                // as it used to be. It used to include the boot classpath but at some point
1522                // DexFile.isDexOptNeeded started returning false for the boot
1523                // class path files in all cases. It is very possible in a
1524                // small maintenance release update that the library and tool
1525                // jars may be unchanged but APK could be removed resulting in
1526                // unused dalvik-cache files.
1527                for (String instructionSet : instructionSets) {
1528                    mInstaller.pruneDexCache(instructionSet);
1529                }
1530
1531                // Additionally, delete all dex files from the root directory
1532                // since there shouldn't be any there anyway, unless we're upgrading
1533                // from an older OS version or a build that contained the "old" style
1534                // flat scheme.
1535                mInstaller.pruneDexCache(".");
1536            }
1537
1538            // Collect vendor overlay packages.
1539            // (Do this before scanning any apps.)
1540            // For security and version matching reason, only consider
1541            // overlay packages if they reside in VENDOR_OVERLAY_DIR.
1542            File vendorOverlayDir = new File(VENDOR_OVERLAY_DIR);
1543            mVendorOverlayInstallObserver = new AppDirObserver(
1544                    vendorOverlayDir.getPath(), OBSERVER_EVENTS, true, false);
1545            mVendorOverlayInstallObserver.startWatching();
1546            scanDirLI(vendorOverlayDir, PackageParser.PARSE_IS_SYSTEM
1547                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode | SCAN_TRUSTED_OVERLAY, 0);
1548
1549            // Find base frameworks (resource packages without code).
1550            mFrameworkInstallObserver = new AppDirObserver(
1551                    frameworkDir.getPath(), OBSERVER_EVENTS, true, false);
1552            mFrameworkInstallObserver.startWatching();
1553            scanDirLI(frameworkDir, PackageParser.PARSE_IS_SYSTEM
1554                    | PackageParser.PARSE_IS_SYSTEM_DIR
1555                    | PackageParser.PARSE_IS_PRIVILEGED,
1556                    scanMode | SCAN_NO_DEX, 0);
1557
1558            // Collected privileged system packages.
1559            File privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app");
1560            mPrivilegedInstallObserver = new AppDirObserver(
1561                    privilegedAppDir.getPath(), OBSERVER_EVENTS, true, true);
1562            mPrivilegedInstallObserver.startWatching();
1563            scanDirLI(privilegedAppDir, PackageParser.PARSE_IS_SYSTEM
1564                    | PackageParser.PARSE_IS_SYSTEM_DIR
1565                    | PackageParser.PARSE_IS_PRIVILEGED, scanMode, 0);
1566
1567            // Collect ordinary system packages.
1568            File systemAppDir = new File(Environment.getRootDirectory(), "app");
1569            mSystemInstallObserver = new AppDirObserver(
1570                    systemAppDir.getPath(), OBSERVER_EVENTS, true, false);
1571            mSystemInstallObserver.startWatching();
1572            scanDirLI(systemAppDir, PackageParser.PARSE_IS_SYSTEM
1573                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
1574
1575            // Collect all vendor packages.
1576            File vendorAppDir = new File("/vendor/app");
1577            try {
1578                vendorAppDir = vendorAppDir.getCanonicalFile();
1579            } catch (IOException e) {
1580                // failed to look up canonical path, continue with original one
1581            }
1582            mVendorInstallObserver = new AppDirObserver(
1583                    vendorAppDir.getPath(), OBSERVER_EVENTS, true, false);
1584            mVendorInstallObserver.startWatching();
1585            scanDirLI(vendorAppDir, PackageParser.PARSE_IS_SYSTEM
1586                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
1587
1588            // Collect all OEM packages.
1589            File oemAppDir = new File(Environment.getOemDirectory(), "app");
1590            mOemInstallObserver = new AppDirObserver(
1591                    oemAppDir.getPath(), OBSERVER_EVENTS, true, false);
1592            mOemInstallObserver.startWatching();
1593            scanDirLI(oemAppDir, PackageParser.PARSE_IS_SYSTEM
1594                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
1595
1596            if (DEBUG_UPGRADE) Log.v(TAG, "Running installd update commands");
1597            mInstaller.moveFiles();
1598
1599            // Prune any system packages that no longer exist.
1600            final List<String> possiblyDeletedUpdatedSystemApps = new ArrayList<String>();
1601            if (!mOnlyCore) {
1602                Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
1603                while (psit.hasNext()) {
1604                    PackageSetting ps = psit.next();
1605
1606                    /*
1607                     * If this is not a system app, it can't be a
1608                     * disable system app.
1609                     */
1610                    if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0) {
1611                        continue;
1612                    }
1613
1614                    /*
1615                     * If the package is scanned, it's not erased.
1616                     */
1617                    final PackageParser.Package scannedPkg = mPackages.get(ps.name);
1618                    if (scannedPkg != null) {
1619                        /*
1620                         * If the system app is both scanned and in the
1621                         * disabled packages list, then it must have been
1622                         * added via OTA. Remove it from the currently
1623                         * scanned package so the previously user-installed
1624                         * application can be scanned.
1625                         */
1626                        if (mSettings.isDisabledSystemPackageLPr(ps.name)) {
1627                            Slog.i(TAG, "Expecting better updatd system app for " + ps.name
1628                                    + "; removing system app");
1629                            removePackageLI(ps, true);
1630                        }
1631
1632                        continue;
1633                    }
1634
1635                    if (!mSettings.isDisabledSystemPackageLPr(ps.name)) {
1636                        psit.remove();
1637                        String msg = "System package " + ps.name
1638                                + " no longer exists; wiping its data";
1639                        reportSettingsProblem(Log.WARN, msg);
1640                        removeDataDirsLI(ps.name);
1641                    } else {
1642                        final PackageSetting disabledPs = mSettings.getDisabledSystemPkgLPr(ps.name);
1643                        if (disabledPs.codePath == null || !disabledPs.codePath.exists()) {
1644                            possiblyDeletedUpdatedSystemApps.add(ps.name);
1645                        }
1646                    }
1647                }
1648            }
1649
1650            //look for any incomplete package installations
1651            ArrayList<PackageSetting> deletePkgsList = mSettings.getListOfIncompleteInstallPackagesLPr();
1652            //clean up list
1653            for(int i = 0; i < deletePkgsList.size(); i++) {
1654                //clean up here
1655                cleanupInstallFailedPackage(deletePkgsList.get(i));
1656            }
1657            //delete tmp files
1658            deleteTempPackageFiles();
1659
1660            // Remove any shared userIDs that have no associated packages
1661            mSettings.pruneSharedUsersLPw();
1662
1663            if (!mOnlyCore) {
1664                EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_DATA_SCAN_START,
1665                        SystemClock.uptimeMillis());
1666                mAppInstallObserver = new AppDirObserver(
1667                    mAppInstallDir.getPath(), OBSERVER_EVENTS, false, false);
1668                mAppInstallObserver.startWatching();
1669                scanDirLI(mAppInstallDir, 0, scanMode, 0);
1670
1671                mDrmAppInstallObserver = new AppDirObserver(
1672                    mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false, false);
1673                mDrmAppInstallObserver.startWatching();
1674                scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,
1675                        scanMode, 0);
1676
1677                /**
1678                 * Remove disable package settings for any updated system
1679                 * apps that were removed via an OTA. If they're not a
1680                 * previously-updated app, remove them completely.
1681                 * Otherwise, just revoke their system-level permissions.
1682                 */
1683                for (String deletedAppName : possiblyDeletedUpdatedSystemApps) {
1684                    PackageParser.Package deletedPkg = mPackages.get(deletedAppName);
1685                    mSettings.removeDisabledSystemPackageLPw(deletedAppName);
1686
1687                    String msg;
1688                    if (deletedPkg == null) {
1689                        msg = "Updated system package " + deletedAppName
1690                                + " no longer exists; wiping its data";
1691                        removeDataDirsLI(deletedAppName);
1692                    } else {
1693                        msg = "Updated system app + " + deletedAppName
1694                                + " no longer present; removing system privileges for "
1695                                + deletedAppName;
1696
1697                        deletedPkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_SYSTEM;
1698
1699                        PackageSetting deletedPs = mSettings.mPackages.get(deletedAppName);
1700                        deletedPs.pkgFlags &= ~ApplicationInfo.FLAG_SYSTEM;
1701                    }
1702                    reportSettingsProblem(Log.WARN, msg);
1703                }
1704            } else {
1705                mAppInstallObserver = null;
1706                mDrmAppInstallObserver = null;
1707            }
1708
1709            // Now that we know all of the shared libraries, update all clients to have
1710            // the correct library paths.
1711            updateAllSharedLibrariesLPw();
1712
1713            for (SharedUserSetting setting : mSettings.getAllSharedUsersLPw()) {
1714                // NOTE: We ignore potential failures here during a system scan (like
1715                // the rest of the commands above) because there's precious little we
1716                // can do about it. A settings error is reported, though.
1717                adjustCpuAbisForSharedUserLPw(setting.packages, null /* scanned package */,
1718                        false /* force dexopt */, false /* defer dexopt */);
1719            }
1720
1721            // Now that we know all the packages we are keeping,
1722            // read and update their last usage times.
1723            mPackageUsage.readLP();
1724
1725            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,
1726                    SystemClock.uptimeMillis());
1727            Slog.i(TAG, "Time to scan packages: "
1728                    + ((SystemClock.uptimeMillis()-startTime)/1000f)
1729                    + " seconds");
1730
1731            // If the platform SDK has changed since the last time we booted,
1732            // we need to re-grant app permission to catch any new ones that
1733            // appear.  This is really a hack, and means that apps can in some
1734            // cases get permissions that the user didn't initially explicitly
1735            // allow...  it would be nice to have some better way to handle
1736            // this situation.
1737            final boolean regrantPermissions = mSettings.mInternalSdkPlatform
1738                    != mSdkVersion;
1739            if (regrantPermissions) Slog.i(TAG, "Platform changed from "
1740                    + mSettings.mInternalSdkPlatform + " to " + mSdkVersion
1741                    + "; regranting permissions for internal storage");
1742            mSettings.mInternalSdkPlatform = mSdkVersion;
1743
1744            updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL
1745                    | (regrantPermissions
1746                            ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL)
1747                            : 0));
1748
1749            // If this is the first boot, and it is a normal boot, then
1750            // we need to initialize the default preferred apps.
1751            if (!mRestoredSettings && !onlyCore) {
1752                mSettings.readDefaultPreferredAppsLPw(this, 0);
1753            }
1754
1755            // All the changes are done during package scanning.
1756            mSettings.updateInternalDatabaseVersion();
1757
1758            // can downgrade to reader
1759            mSettings.writeLPr();
1760
1761            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_READY,
1762                    SystemClock.uptimeMillis());
1763
1764
1765            mRequiredVerifierPackage = getRequiredVerifierLPr();
1766        } // synchronized (mPackages)
1767        } // synchronized (mInstallLock)
1768
1769        mInstallerService = new PackageInstallerService(context, this, mAppInstallDir);
1770
1771        // Now after opening every single application zip, make sure they
1772        // are all flushed.  Not really needed, but keeps things nice and
1773        // tidy.
1774        Runtime.getRuntime().gc();
1775    }
1776
1777    @Override
1778    public boolean isFirstBoot() {
1779        return !mRestoredSettings;
1780    }
1781
1782    @Override
1783    public boolean isOnlyCoreApps() {
1784        return mOnlyCore;
1785    }
1786
1787    private String getRequiredVerifierLPr() {
1788        final Intent verification = new Intent(Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
1789        final List<ResolveInfo> receivers = queryIntentReceivers(verification, PACKAGE_MIME_TYPE,
1790                PackageManager.GET_DISABLED_COMPONENTS, 0 /* TODO: Which userId? */);
1791
1792        String requiredVerifier = null;
1793
1794        final int N = receivers.size();
1795        for (int i = 0; i < N; i++) {
1796            final ResolveInfo info = receivers.get(i);
1797
1798            if (info.activityInfo == null) {
1799                continue;
1800            }
1801
1802            final String packageName = info.activityInfo.packageName;
1803
1804            final PackageSetting ps = mSettings.mPackages.get(packageName);
1805            if (ps == null) {
1806                continue;
1807            }
1808
1809            final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
1810            if (!gp.grantedPermissions
1811                    .contains(android.Manifest.permission.PACKAGE_VERIFICATION_AGENT)) {
1812                continue;
1813            }
1814
1815            if (requiredVerifier != null) {
1816                throw new RuntimeException("There can be only one required verifier");
1817            }
1818
1819            requiredVerifier = packageName;
1820        }
1821
1822        return requiredVerifier;
1823    }
1824
1825    @Override
1826    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
1827            throws RemoteException {
1828        try {
1829            return super.onTransact(code, data, reply, flags);
1830        } catch (RuntimeException e) {
1831            if (!(e instanceof SecurityException) && !(e instanceof IllegalArgumentException)) {
1832                Slog.wtf(TAG, "Package Manager Crash", e);
1833            }
1834            throw e;
1835        }
1836    }
1837
1838    void cleanupInstallFailedPackage(PackageSetting ps) {
1839        Slog.i(TAG, "Cleaning up incompletely installed app: " + ps.name);
1840        removeDataDirsLI(ps.name);
1841
1842        // TODO: try cleaning up codePath directory contents first, since it
1843        // might be a cluster
1844
1845        if (ps.codePath != null) {
1846            if (!ps.codePath.delete()) {
1847                Slog.w(TAG, "Unable to remove old code file: " + ps.codePath);
1848            }
1849        }
1850        if (ps.resourcePath != null) {
1851            if (!ps.resourcePath.delete() && !ps.resourcePath.equals(ps.codePath)) {
1852                Slog.w(TAG, "Unable to remove old code file: " + ps.resourcePath);
1853            }
1854        }
1855        mSettings.removePackageLPw(ps.name);
1856    }
1857
1858    static int[] appendInts(int[] cur, int[] add) {
1859        if (add == null) return cur;
1860        if (cur == null) return add;
1861        final int N = add.length;
1862        for (int i=0; i<N; i++) {
1863            cur = appendInt(cur, add[i]);
1864        }
1865        return cur;
1866    }
1867
1868    static int[] removeInts(int[] cur, int[] rem) {
1869        if (rem == null) return cur;
1870        if (cur == null) return cur;
1871        final int N = rem.length;
1872        for (int i=0; i<N; i++) {
1873            cur = removeInt(cur, rem[i]);
1874        }
1875        return cur;
1876    }
1877
1878    PackageInfo generatePackageInfo(PackageParser.Package p, int flags, int userId) {
1879        if (!sUserManager.exists(userId)) return null;
1880        final PackageSetting ps = (PackageSetting) p.mExtras;
1881        if (ps == null) {
1882            return null;
1883        }
1884        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
1885        final PackageUserState state = ps.readUserState(userId);
1886        return PackageParser.generatePackageInfo(p, gp.gids, flags,
1887                ps.firstInstallTime, ps.lastUpdateTime, gp.grantedPermissions,
1888                state, userId);
1889    }
1890
1891    @Override
1892    public boolean isPackageAvailable(String packageName, int userId) {
1893        if (!sUserManager.exists(userId)) return false;
1894        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "is package available");
1895        synchronized (mPackages) {
1896            PackageParser.Package p = mPackages.get(packageName);
1897            if (p != null) {
1898                final PackageSetting ps = (PackageSetting) p.mExtras;
1899                if (ps != null) {
1900                    final PackageUserState state = ps.readUserState(userId);
1901                    if (state != null) {
1902                        return PackageParser.isAvailable(state);
1903                    }
1904                }
1905            }
1906        }
1907        return false;
1908    }
1909
1910    @Override
1911    public PackageInfo getPackageInfo(String packageName, int flags, int userId) {
1912        if (!sUserManager.exists(userId)) return null;
1913        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get package info");
1914        // reader
1915        synchronized (mPackages) {
1916            PackageParser.Package p = mPackages.get(packageName);
1917            if (DEBUG_PACKAGE_INFO)
1918                Log.v(TAG, "getPackageInfo " + packageName + ": " + p);
1919            if (p != null) {
1920                return generatePackageInfo(p, flags, userId);
1921            }
1922            if((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) {
1923                return generatePackageInfoFromSettingsLPw(packageName, flags, userId);
1924            }
1925        }
1926        return null;
1927    }
1928
1929    @Override
1930    public String[] currentToCanonicalPackageNames(String[] names) {
1931        String[] out = new String[names.length];
1932        // reader
1933        synchronized (mPackages) {
1934            for (int i=names.length-1; i>=0; i--) {
1935                PackageSetting ps = mSettings.mPackages.get(names[i]);
1936                out[i] = ps != null && ps.realName != null ? ps.realName : names[i];
1937            }
1938        }
1939        return out;
1940    }
1941
1942    @Override
1943    public String[] canonicalToCurrentPackageNames(String[] names) {
1944        String[] out = new String[names.length];
1945        // reader
1946        synchronized (mPackages) {
1947            for (int i=names.length-1; i>=0; i--) {
1948                String cur = mSettings.mRenamedPackages.get(names[i]);
1949                out[i] = cur != null ? cur : names[i];
1950            }
1951        }
1952        return out;
1953    }
1954
1955    @Override
1956    public int getPackageUid(String packageName, int userId) {
1957        if (!sUserManager.exists(userId)) return -1;
1958        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get package uid");
1959        // reader
1960        synchronized (mPackages) {
1961            PackageParser.Package p = mPackages.get(packageName);
1962            if(p != null) {
1963                return UserHandle.getUid(userId, p.applicationInfo.uid);
1964            }
1965            PackageSetting ps = mSettings.mPackages.get(packageName);
1966            if((ps == null) || (ps.pkg == null) || (ps.pkg.applicationInfo == null)) {
1967                return -1;
1968            }
1969            p = ps.pkg;
1970            return p != null ? UserHandle.getUid(userId, p.applicationInfo.uid) : -1;
1971        }
1972    }
1973
1974    @Override
1975    public int[] getPackageGids(String packageName) {
1976        // reader
1977        synchronized (mPackages) {
1978            PackageParser.Package p = mPackages.get(packageName);
1979            if (DEBUG_PACKAGE_INFO)
1980                Log.v(TAG, "getPackageGids" + packageName + ": " + p);
1981            if (p != null) {
1982                final PackageSetting ps = (PackageSetting)p.mExtras;
1983                return ps.getGids();
1984            }
1985        }
1986        // stupid thing to indicate an error.
1987        return new int[0];
1988    }
1989
1990    static final PermissionInfo generatePermissionInfo(
1991            BasePermission bp, int flags) {
1992        if (bp.perm != null) {
1993            return PackageParser.generatePermissionInfo(bp.perm, flags);
1994        }
1995        PermissionInfo pi = new PermissionInfo();
1996        pi.name = bp.name;
1997        pi.packageName = bp.sourcePackage;
1998        pi.nonLocalizedLabel = bp.name;
1999        pi.protectionLevel = bp.protectionLevel;
2000        return pi;
2001    }
2002
2003    @Override
2004    public PermissionInfo getPermissionInfo(String name, int flags) {
2005        // reader
2006        synchronized (mPackages) {
2007            final BasePermission p = mSettings.mPermissions.get(name);
2008            if (p != null) {
2009                return generatePermissionInfo(p, flags);
2010            }
2011            return null;
2012        }
2013    }
2014
2015    @Override
2016    public List<PermissionInfo> queryPermissionsByGroup(String group, int flags) {
2017        // reader
2018        synchronized (mPackages) {
2019            ArrayList<PermissionInfo> out = new ArrayList<PermissionInfo>(10);
2020            for (BasePermission p : mSettings.mPermissions.values()) {
2021                if (group == null) {
2022                    if (p.perm == null || p.perm.info.group == null) {
2023                        out.add(generatePermissionInfo(p, flags));
2024                    }
2025                } else {
2026                    if (p.perm != null && group.equals(p.perm.info.group)) {
2027                        out.add(PackageParser.generatePermissionInfo(p.perm, flags));
2028                    }
2029                }
2030            }
2031
2032            if (out.size() > 0) {
2033                return out;
2034            }
2035            return mPermissionGroups.containsKey(group) ? out : null;
2036        }
2037    }
2038
2039    @Override
2040    public PermissionGroupInfo getPermissionGroupInfo(String name, int flags) {
2041        // reader
2042        synchronized (mPackages) {
2043            return PackageParser.generatePermissionGroupInfo(
2044                    mPermissionGroups.get(name), flags);
2045        }
2046    }
2047
2048    @Override
2049    public List<PermissionGroupInfo> getAllPermissionGroups(int flags) {
2050        // reader
2051        synchronized (mPackages) {
2052            final int N = mPermissionGroups.size();
2053            ArrayList<PermissionGroupInfo> out
2054                    = new ArrayList<PermissionGroupInfo>(N);
2055            for (PackageParser.PermissionGroup pg : mPermissionGroups.values()) {
2056                out.add(PackageParser.generatePermissionGroupInfo(pg, flags));
2057            }
2058            return out;
2059        }
2060    }
2061
2062    private ApplicationInfo generateApplicationInfoFromSettingsLPw(String packageName, int flags,
2063            int userId) {
2064        if (!sUserManager.exists(userId)) return null;
2065        PackageSetting ps = mSettings.mPackages.get(packageName);
2066        if (ps != null) {
2067            if (ps.pkg == null) {
2068                PackageInfo pInfo = generatePackageInfoFromSettingsLPw(packageName,
2069                        flags, userId);
2070                if (pInfo != null) {
2071                    return pInfo.applicationInfo;
2072                }
2073                return null;
2074            }
2075            return PackageParser.generateApplicationInfo(ps.pkg, flags,
2076                    ps.readUserState(userId), userId);
2077        }
2078        return null;
2079    }
2080
2081    private PackageInfo generatePackageInfoFromSettingsLPw(String packageName, int flags,
2082            int userId) {
2083        if (!sUserManager.exists(userId)) return null;
2084        PackageSetting ps = mSettings.mPackages.get(packageName);
2085        if (ps != null) {
2086            PackageParser.Package pkg = ps.pkg;
2087            if (pkg == null) {
2088                if ((flags & PackageManager.GET_UNINSTALLED_PACKAGES) == 0) {
2089                    return null;
2090                }
2091                // Only data remains, so we aren't worried about code paths
2092                pkg = new PackageParser.Package(packageName);
2093                pkg.applicationInfo.packageName = packageName;
2094                pkg.applicationInfo.flags = ps.pkgFlags | ApplicationInfo.FLAG_IS_DATA_ONLY;
2095                pkg.applicationInfo.dataDir =
2096                        getDataPathForPackage(packageName, 0).getPath();
2097                pkg.applicationInfo.primaryCpuAbi = ps.primaryCpuAbiString;
2098                pkg.applicationInfo.secondaryCpuAbi = ps.secondaryCpuAbiString;
2099            }
2100            return generatePackageInfo(pkg, flags, userId);
2101        }
2102        return null;
2103    }
2104
2105    @Override
2106    public ApplicationInfo getApplicationInfo(String packageName, int flags, int userId) {
2107        if (!sUserManager.exists(userId)) return null;
2108        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get application info");
2109        // writer
2110        synchronized (mPackages) {
2111            PackageParser.Package p = mPackages.get(packageName);
2112            if (DEBUG_PACKAGE_INFO) Log.v(
2113                    TAG, "getApplicationInfo " + packageName
2114                    + ": " + p);
2115            if (p != null) {
2116                PackageSetting ps = mSettings.mPackages.get(packageName);
2117                if (ps == null) return null;
2118                // Note: isEnabledLP() does not apply here - always return info
2119                return PackageParser.generateApplicationInfo(
2120                        p, flags, ps.readUserState(userId), userId);
2121            }
2122            if ("android".equals(packageName)||"system".equals(packageName)) {
2123                return mAndroidApplication;
2124            }
2125            if ((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) {
2126                return generateApplicationInfoFromSettingsLPw(packageName, flags, userId);
2127            }
2128        }
2129        return null;
2130    }
2131
2132
2133    @Override
2134    public void freeStorageAndNotify(final long freeStorageSize, final IPackageDataObserver observer) {
2135        mContext.enforceCallingOrSelfPermission(
2136                android.Manifest.permission.CLEAR_APP_CACHE, null);
2137        // Queue up an async operation since clearing cache may take a little while.
2138        mHandler.post(new Runnable() {
2139            public void run() {
2140                mHandler.removeCallbacks(this);
2141                int retCode = -1;
2142                synchronized (mInstallLock) {
2143                    retCode = mInstaller.freeCache(freeStorageSize);
2144                    if (retCode < 0) {
2145                        Slog.w(TAG, "Couldn't clear application caches");
2146                    }
2147                }
2148                if (observer != null) {
2149                    try {
2150                        observer.onRemoveCompleted(null, (retCode >= 0));
2151                    } catch (RemoteException e) {
2152                        Slog.w(TAG, "RemoveException when invoking call back");
2153                    }
2154                }
2155            }
2156        });
2157    }
2158
2159    @Override
2160    public void freeStorage(final long freeStorageSize, final IntentSender pi) {
2161        mContext.enforceCallingOrSelfPermission(
2162                android.Manifest.permission.CLEAR_APP_CACHE, null);
2163        // Queue up an async operation since clearing cache may take a little while.
2164        mHandler.post(new Runnable() {
2165            public void run() {
2166                mHandler.removeCallbacks(this);
2167                int retCode = -1;
2168                synchronized (mInstallLock) {
2169                    retCode = mInstaller.freeCache(freeStorageSize);
2170                    if (retCode < 0) {
2171                        Slog.w(TAG, "Couldn't clear application caches");
2172                    }
2173                }
2174                if(pi != null) {
2175                    try {
2176                        // Callback via pending intent
2177                        int code = (retCode >= 0) ? 1 : 0;
2178                        pi.sendIntent(null, code, null,
2179                                null, null);
2180                    } catch (SendIntentException e1) {
2181                        Slog.i(TAG, "Failed to send pending intent");
2182                    }
2183                }
2184            }
2185        });
2186    }
2187
2188    void freeStorage(long freeStorageSize) throws IOException {
2189        synchronized (mInstallLock) {
2190            if (mInstaller.freeCache(freeStorageSize) < 0) {
2191                throw new IOException("Failed to free enough space");
2192            }
2193        }
2194    }
2195
2196    @Override
2197    public ActivityInfo getActivityInfo(ComponentName component, int flags, int userId) {
2198        if (!sUserManager.exists(userId)) return null;
2199        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get activity info");
2200        synchronized (mPackages) {
2201            PackageParser.Activity a = mActivities.mActivities.get(component);
2202
2203            if (DEBUG_PACKAGE_INFO) Log.v(TAG, "getActivityInfo " + component + ": " + a);
2204            if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {
2205                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2206                if (ps == null) return null;
2207                return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),
2208                        userId);
2209            }
2210            if (mResolveComponentName.equals(component)) {
2211                return mResolveActivity;
2212            }
2213        }
2214        return null;
2215    }
2216
2217    @Override
2218    public boolean activitySupportsIntent(ComponentName component, Intent intent,
2219            String resolvedType) {
2220        synchronized (mPackages) {
2221            PackageParser.Activity a = mActivities.mActivities.get(component);
2222            if (a == null) {
2223                return false;
2224            }
2225            for (int i=0; i<a.intents.size(); i++) {
2226                if (a.intents.get(i).match(intent.getAction(), resolvedType, intent.getScheme(),
2227                        intent.getData(), intent.getCategories(), TAG) >= 0) {
2228                    return true;
2229                }
2230            }
2231            return false;
2232        }
2233    }
2234
2235    @Override
2236    public ActivityInfo getReceiverInfo(ComponentName component, int flags, int userId) {
2237        if (!sUserManager.exists(userId)) return null;
2238        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get receiver info");
2239        synchronized (mPackages) {
2240            PackageParser.Activity a = mReceivers.mActivities.get(component);
2241            if (DEBUG_PACKAGE_INFO) Log.v(
2242                TAG, "getReceiverInfo " + component + ": " + a);
2243            if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {
2244                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2245                if (ps == null) return null;
2246                return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),
2247                        userId);
2248            }
2249        }
2250        return null;
2251    }
2252
2253    @Override
2254    public ServiceInfo getServiceInfo(ComponentName component, int flags, int userId) {
2255        if (!sUserManager.exists(userId)) return null;
2256        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get service info");
2257        synchronized (mPackages) {
2258            PackageParser.Service s = mServices.mServices.get(component);
2259            if (DEBUG_PACKAGE_INFO) Log.v(
2260                TAG, "getServiceInfo " + component + ": " + s);
2261            if (s != null && mSettings.isEnabledLPr(s.info, flags, userId)) {
2262                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2263                if (ps == null) return null;
2264                return PackageParser.generateServiceInfo(s, flags, ps.readUserState(userId),
2265                        userId);
2266            }
2267        }
2268        return null;
2269    }
2270
2271    @Override
2272    public ProviderInfo getProviderInfo(ComponentName component, int flags, int userId) {
2273        if (!sUserManager.exists(userId)) return null;
2274        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get provider info");
2275        synchronized (mPackages) {
2276            PackageParser.Provider p = mProviders.mProviders.get(component);
2277            if (DEBUG_PACKAGE_INFO) Log.v(
2278                TAG, "getProviderInfo " + component + ": " + p);
2279            if (p != null && mSettings.isEnabledLPr(p.info, flags, userId)) {
2280                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2281                if (ps == null) return null;
2282                return PackageParser.generateProviderInfo(p, flags, ps.readUserState(userId),
2283                        userId);
2284            }
2285        }
2286        return null;
2287    }
2288
2289    @Override
2290    public String[] getSystemSharedLibraryNames() {
2291        Set<String> libSet;
2292        synchronized (mPackages) {
2293            libSet = mSharedLibraries.keySet();
2294            int size = libSet.size();
2295            if (size > 0) {
2296                String[] libs = new String[size];
2297                libSet.toArray(libs);
2298                return libs;
2299            }
2300        }
2301        return null;
2302    }
2303
2304    @Override
2305    public FeatureInfo[] getSystemAvailableFeatures() {
2306        Collection<FeatureInfo> featSet;
2307        synchronized (mPackages) {
2308            featSet = mAvailableFeatures.values();
2309            int size = featSet.size();
2310            if (size > 0) {
2311                FeatureInfo[] features = new FeatureInfo[size+1];
2312                featSet.toArray(features);
2313                FeatureInfo fi = new FeatureInfo();
2314                fi.reqGlEsVersion = SystemProperties.getInt("ro.opengles.version",
2315                        FeatureInfo.GL_ES_VERSION_UNDEFINED);
2316                features[size] = fi;
2317                return features;
2318            }
2319        }
2320        return null;
2321    }
2322
2323    @Override
2324    public boolean hasSystemFeature(String name) {
2325        synchronized (mPackages) {
2326            return mAvailableFeatures.containsKey(name);
2327        }
2328    }
2329
2330    private void checkValidCaller(int uid, int userId) {
2331        if (UserHandle.getUserId(uid) == userId || uid == Process.SYSTEM_UID || uid == 0)
2332            return;
2333
2334        throw new SecurityException("Caller uid=" + uid
2335                + " is not privileged to communicate with user=" + userId);
2336    }
2337
2338    @Override
2339    public int checkPermission(String permName, String pkgName) {
2340        synchronized (mPackages) {
2341            PackageParser.Package p = mPackages.get(pkgName);
2342            if (p != null && p.mExtras != null) {
2343                PackageSetting ps = (PackageSetting)p.mExtras;
2344                if (ps.sharedUser != null) {
2345                    if (ps.sharedUser.grantedPermissions.contains(permName)) {
2346                        return PackageManager.PERMISSION_GRANTED;
2347                    }
2348                } else if (ps.grantedPermissions.contains(permName)) {
2349                    return PackageManager.PERMISSION_GRANTED;
2350                }
2351            }
2352        }
2353        return PackageManager.PERMISSION_DENIED;
2354    }
2355
2356    @Override
2357    public int checkUidPermission(String permName, int uid) {
2358        synchronized (mPackages) {
2359            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2360            if (obj != null) {
2361                GrantedPermissions gp = (GrantedPermissions)obj;
2362                if (gp.grantedPermissions.contains(permName)) {
2363                    return PackageManager.PERMISSION_GRANTED;
2364                }
2365            } else {
2366                HashSet<String> perms = mSystemPermissions.get(uid);
2367                if (perms != null && perms.contains(permName)) {
2368                    return PackageManager.PERMISSION_GRANTED;
2369                }
2370            }
2371        }
2372        return PackageManager.PERMISSION_DENIED;
2373    }
2374
2375    /**
2376     * Checks if the request is from the system or an app that has INTERACT_ACROSS_USERS
2377     * or INTERACT_ACROSS_USERS_FULL permissions, if the userid is not for the caller.
2378     * @param message the message to log on security exception
2379     */
2380    void enforceCrossUserPermission(int callingUid, int userId, boolean requireFullPermission,
2381            String message) {
2382        if (userId < 0) {
2383            throw new IllegalArgumentException("Invalid userId " + userId);
2384        }
2385        if (userId == UserHandle.getUserId(callingUid)) return;
2386        if (callingUid != Process.SYSTEM_UID && callingUid != 0) {
2387            if (requireFullPermission) {
2388                mContext.enforceCallingOrSelfPermission(
2389                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
2390            } else {
2391                try {
2392                    mContext.enforceCallingOrSelfPermission(
2393                            android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
2394                } catch (SecurityException se) {
2395                    mContext.enforceCallingOrSelfPermission(
2396                            android.Manifest.permission.INTERACT_ACROSS_USERS, message);
2397                }
2398            }
2399        }
2400    }
2401
2402    private BasePermission findPermissionTreeLP(String permName) {
2403        for(BasePermission bp : mSettings.mPermissionTrees.values()) {
2404            if (permName.startsWith(bp.name) &&
2405                    permName.length() > bp.name.length() &&
2406                    permName.charAt(bp.name.length()) == '.') {
2407                return bp;
2408            }
2409        }
2410        return null;
2411    }
2412
2413    private BasePermission checkPermissionTreeLP(String permName) {
2414        if (permName != null) {
2415            BasePermission bp = findPermissionTreeLP(permName);
2416            if (bp != null) {
2417                if (bp.uid == UserHandle.getAppId(Binder.getCallingUid())) {
2418                    return bp;
2419                }
2420                throw new SecurityException("Calling uid "
2421                        + Binder.getCallingUid()
2422                        + " is not allowed to add to permission tree "
2423                        + bp.name + " owned by uid " + bp.uid);
2424            }
2425        }
2426        throw new SecurityException("No permission tree found for " + permName);
2427    }
2428
2429    static boolean compareStrings(CharSequence s1, CharSequence s2) {
2430        if (s1 == null) {
2431            return s2 == null;
2432        }
2433        if (s2 == null) {
2434            return false;
2435        }
2436        if (s1.getClass() != s2.getClass()) {
2437            return false;
2438        }
2439        return s1.equals(s2);
2440    }
2441
2442    static boolean comparePermissionInfos(PermissionInfo pi1, PermissionInfo pi2) {
2443        if (pi1.icon != pi2.icon) return false;
2444        if (pi1.logo != pi2.logo) return false;
2445        if (pi1.protectionLevel != pi2.protectionLevel) return false;
2446        if (!compareStrings(pi1.name, pi2.name)) return false;
2447        if (!compareStrings(pi1.nonLocalizedLabel, pi2.nonLocalizedLabel)) return false;
2448        // We'll take care of setting this one.
2449        if (!compareStrings(pi1.packageName, pi2.packageName)) return false;
2450        // These are not currently stored in settings.
2451        //if (!compareStrings(pi1.group, pi2.group)) return false;
2452        //if (!compareStrings(pi1.nonLocalizedDescription, pi2.nonLocalizedDescription)) return false;
2453        //if (pi1.labelRes != pi2.labelRes) return false;
2454        //if (pi1.descriptionRes != pi2.descriptionRes) return false;
2455        return true;
2456    }
2457
2458    int permissionInfoFootprint(PermissionInfo info) {
2459        int size = info.name.length();
2460        if (info.nonLocalizedLabel != null) size += info.nonLocalizedLabel.length();
2461        if (info.nonLocalizedDescription != null) size += info.nonLocalizedDescription.length();
2462        return size;
2463    }
2464
2465    int calculateCurrentPermissionFootprintLocked(BasePermission tree) {
2466        int size = 0;
2467        for (BasePermission perm : mSettings.mPermissions.values()) {
2468            if (perm.uid == tree.uid) {
2469                size += perm.name.length() + permissionInfoFootprint(perm.perm.info);
2470            }
2471        }
2472        return size;
2473    }
2474
2475    void enforcePermissionCapLocked(PermissionInfo info, BasePermission tree) {
2476        // We calculate the max size of permissions defined by this uid and throw
2477        // if that plus the size of 'info' would exceed our stated maximum.
2478        if (tree.uid != Process.SYSTEM_UID) {
2479            final int curTreeSize = calculateCurrentPermissionFootprintLocked(tree);
2480            if (curTreeSize + permissionInfoFootprint(info) > MAX_PERMISSION_TREE_FOOTPRINT) {
2481                throw new SecurityException("Permission tree size cap exceeded");
2482            }
2483        }
2484    }
2485
2486    boolean addPermissionLocked(PermissionInfo info, boolean async) {
2487        if (info.labelRes == 0 && info.nonLocalizedLabel == null) {
2488            throw new SecurityException("Label must be specified in permission");
2489        }
2490        BasePermission tree = checkPermissionTreeLP(info.name);
2491        BasePermission bp = mSettings.mPermissions.get(info.name);
2492        boolean added = bp == null;
2493        boolean changed = true;
2494        int fixedLevel = PermissionInfo.fixProtectionLevel(info.protectionLevel);
2495        if (added) {
2496            enforcePermissionCapLocked(info, tree);
2497            bp = new BasePermission(info.name, tree.sourcePackage,
2498                    BasePermission.TYPE_DYNAMIC);
2499        } else if (bp.type != BasePermission.TYPE_DYNAMIC) {
2500            throw new SecurityException(
2501                    "Not allowed to modify non-dynamic permission "
2502                    + info.name);
2503        } else {
2504            if (bp.protectionLevel == fixedLevel
2505                    && bp.perm.owner.equals(tree.perm.owner)
2506                    && bp.uid == tree.uid
2507                    && comparePermissionInfos(bp.perm.info, info)) {
2508                changed = false;
2509            }
2510        }
2511        bp.protectionLevel = fixedLevel;
2512        info = new PermissionInfo(info);
2513        info.protectionLevel = fixedLevel;
2514        bp.perm = new PackageParser.Permission(tree.perm.owner, info);
2515        bp.perm.info.packageName = tree.perm.info.packageName;
2516        bp.uid = tree.uid;
2517        if (added) {
2518            mSettings.mPermissions.put(info.name, bp);
2519        }
2520        if (changed) {
2521            if (!async) {
2522                mSettings.writeLPr();
2523            } else {
2524                scheduleWriteSettingsLocked();
2525            }
2526        }
2527        return added;
2528    }
2529
2530    @Override
2531    public boolean addPermission(PermissionInfo info) {
2532        synchronized (mPackages) {
2533            return addPermissionLocked(info, false);
2534        }
2535    }
2536
2537    @Override
2538    public boolean addPermissionAsync(PermissionInfo info) {
2539        synchronized (mPackages) {
2540            return addPermissionLocked(info, true);
2541        }
2542    }
2543
2544    @Override
2545    public void removePermission(String name) {
2546        synchronized (mPackages) {
2547            checkPermissionTreeLP(name);
2548            BasePermission bp = mSettings.mPermissions.get(name);
2549            if (bp != null) {
2550                if (bp.type != BasePermission.TYPE_DYNAMIC) {
2551                    throw new SecurityException(
2552                            "Not allowed to modify non-dynamic permission "
2553                            + name);
2554                }
2555                mSettings.mPermissions.remove(name);
2556                mSettings.writeLPr();
2557            }
2558        }
2559    }
2560
2561    private static void checkGrantRevokePermissions(PackageParser.Package pkg, BasePermission bp) {
2562        int index = pkg.requestedPermissions.indexOf(bp.name);
2563        if (index == -1) {
2564            throw new SecurityException("Package " + pkg.packageName
2565                    + " has not requested permission " + bp.name);
2566        }
2567        boolean isNormal =
2568                ((bp.protectionLevel&PermissionInfo.PROTECTION_MASK_BASE)
2569                        == PermissionInfo.PROTECTION_NORMAL);
2570        boolean isDangerous =
2571                ((bp.protectionLevel&PermissionInfo.PROTECTION_MASK_BASE)
2572                        == PermissionInfo.PROTECTION_DANGEROUS);
2573        boolean isDevelopment =
2574                ((bp.protectionLevel&PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0);
2575
2576        if (!isNormal && !isDangerous && !isDevelopment) {
2577            throw new SecurityException("Permission " + bp.name
2578                    + " is not a changeable permission type");
2579        }
2580
2581        if (isNormal || isDangerous) {
2582            if (pkg.requestedPermissionsRequired.get(index)) {
2583                throw new SecurityException("Can't change " + bp.name
2584                        + ". It is required by the application");
2585            }
2586        }
2587    }
2588
2589    @Override
2590    public void grantPermission(String packageName, String permissionName) {
2591        mContext.enforceCallingOrSelfPermission(
2592                android.Manifest.permission.GRANT_REVOKE_PERMISSIONS, null);
2593        synchronized (mPackages) {
2594            final PackageParser.Package pkg = mPackages.get(packageName);
2595            if (pkg == null) {
2596                throw new IllegalArgumentException("Unknown package: " + packageName);
2597            }
2598            final BasePermission bp = mSettings.mPermissions.get(permissionName);
2599            if (bp == null) {
2600                throw new IllegalArgumentException("Unknown permission: " + permissionName);
2601            }
2602
2603            checkGrantRevokePermissions(pkg, bp);
2604
2605            final PackageSetting ps = (PackageSetting) pkg.mExtras;
2606            if (ps == null) {
2607                return;
2608            }
2609            final GrantedPermissions gp = (ps.sharedUser != null) ? ps.sharedUser : ps;
2610            if (gp.grantedPermissions.add(permissionName)) {
2611                if (ps.haveGids) {
2612                    gp.gids = appendInts(gp.gids, bp.gids);
2613                }
2614                mSettings.writeLPr();
2615            }
2616        }
2617    }
2618
2619    @Override
2620    public void revokePermission(String packageName, String permissionName) {
2621        int changedAppId = -1;
2622
2623        synchronized (mPackages) {
2624            final PackageParser.Package pkg = mPackages.get(packageName);
2625            if (pkg == null) {
2626                throw new IllegalArgumentException("Unknown package: " + packageName);
2627            }
2628            if (pkg.applicationInfo.uid != Binder.getCallingUid()) {
2629                mContext.enforceCallingOrSelfPermission(
2630                        android.Manifest.permission.GRANT_REVOKE_PERMISSIONS, null);
2631            }
2632            final BasePermission bp = mSettings.mPermissions.get(permissionName);
2633            if (bp == null) {
2634                throw new IllegalArgumentException("Unknown permission: " + permissionName);
2635            }
2636
2637            checkGrantRevokePermissions(pkg, bp);
2638
2639            final PackageSetting ps = (PackageSetting) pkg.mExtras;
2640            if (ps == null) {
2641                return;
2642            }
2643            final GrantedPermissions gp = (ps.sharedUser != null) ? ps.sharedUser : ps;
2644            if (gp.grantedPermissions.remove(permissionName)) {
2645                gp.grantedPermissions.remove(permissionName);
2646                if (ps.haveGids) {
2647                    gp.gids = removeInts(gp.gids, bp.gids);
2648                }
2649                mSettings.writeLPr();
2650                changedAppId = ps.appId;
2651            }
2652        }
2653
2654        if (changedAppId >= 0) {
2655            // We changed the perm on someone, kill its processes.
2656            IActivityManager am = ActivityManagerNative.getDefault();
2657            if (am != null) {
2658                final int callingUserId = UserHandle.getCallingUserId();
2659                final long ident = Binder.clearCallingIdentity();
2660                try {
2661                    //XXX we should only revoke for the calling user's app permissions,
2662                    // but for now we impact all users.
2663                    //am.killUid(UserHandle.getUid(callingUserId, changedAppId),
2664                    //        "revoke " + permissionName);
2665                    int[] users = sUserManager.getUserIds();
2666                    for (int user : users) {
2667                        am.killUid(UserHandle.getUid(user, changedAppId),
2668                                "revoke " + permissionName);
2669                    }
2670                } catch (RemoteException e) {
2671                } finally {
2672                    Binder.restoreCallingIdentity(ident);
2673                }
2674            }
2675        }
2676    }
2677
2678    @Override
2679    public boolean isProtectedBroadcast(String actionName) {
2680        synchronized (mPackages) {
2681            return mProtectedBroadcasts.contains(actionName);
2682        }
2683    }
2684
2685    @Override
2686    public int checkSignatures(String pkg1, String pkg2) {
2687        synchronized (mPackages) {
2688            final PackageParser.Package p1 = mPackages.get(pkg1);
2689            final PackageParser.Package p2 = mPackages.get(pkg2);
2690            if (p1 == null || p1.mExtras == null
2691                    || p2 == null || p2.mExtras == null) {
2692                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2693            }
2694            return compareSignatures(p1.mSignatures, p2.mSignatures);
2695        }
2696    }
2697
2698    @Override
2699    public int checkUidSignatures(int uid1, int uid2) {
2700        // Map to base uids.
2701        uid1 = UserHandle.getAppId(uid1);
2702        uid2 = UserHandle.getAppId(uid2);
2703        // reader
2704        synchronized (mPackages) {
2705            Signature[] s1;
2706            Signature[] s2;
2707            Object obj = mSettings.getUserIdLPr(uid1);
2708            if (obj != null) {
2709                if (obj instanceof SharedUserSetting) {
2710                    s1 = ((SharedUserSetting)obj).signatures.mSignatures;
2711                } else if (obj instanceof PackageSetting) {
2712                    s1 = ((PackageSetting)obj).signatures.mSignatures;
2713                } else {
2714                    return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2715                }
2716            } else {
2717                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2718            }
2719            obj = mSettings.getUserIdLPr(uid2);
2720            if (obj != null) {
2721                if (obj instanceof SharedUserSetting) {
2722                    s2 = ((SharedUserSetting)obj).signatures.mSignatures;
2723                } else if (obj instanceof PackageSetting) {
2724                    s2 = ((PackageSetting)obj).signatures.mSignatures;
2725                } else {
2726                    return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2727                }
2728            } else {
2729                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2730            }
2731            return compareSignatures(s1, s2);
2732        }
2733    }
2734
2735    /**
2736     * Compares two sets of signatures. Returns:
2737     * <br />
2738     * {@link PackageManager#SIGNATURE_NEITHER_SIGNED}: if both signature sets are null,
2739     * <br />
2740     * {@link PackageManager#SIGNATURE_FIRST_NOT_SIGNED}: if the first signature set is null,
2741     * <br />
2742     * {@link PackageManager#SIGNATURE_SECOND_NOT_SIGNED}: if the second signature set is null,
2743     * <br />
2744     * {@link PackageManager#SIGNATURE_MATCH}: if the two signature sets are identical,
2745     * <br />
2746     * {@link PackageManager#SIGNATURE_NO_MATCH}: if the two signature sets differ.
2747     */
2748    static int compareSignatures(Signature[] s1, Signature[] s2) {
2749        if (s1 == null) {
2750            return s2 == null
2751                    ? PackageManager.SIGNATURE_NEITHER_SIGNED
2752                    : PackageManager.SIGNATURE_FIRST_NOT_SIGNED;
2753        }
2754
2755        if (s2 == null) {
2756            return PackageManager.SIGNATURE_SECOND_NOT_SIGNED;
2757        }
2758
2759        if (s1.length != s2.length) {
2760            return PackageManager.SIGNATURE_NO_MATCH;
2761        }
2762
2763        // Since both signature sets are of size 1, we can compare without HashSets.
2764        if (s1.length == 1) {
2765            return s1[0].equals(s2[0]) ?
2766                    PackageManager.SIGNATURE_MATCH :
2767                    PackageManager.SIGNATURE_NO_MATCH;
2768        }
2769
2770        HashSet<Signature> set1 = new HashSet<Signature>();
2771        for (Signature sig : s1) {
2772            set1.add(sig);
2773        }
2774        HashSet<Signature> set2 = new HashSet<Signature>();
2775        for (Signature sig : s2) {
2776            set2.add(sig);
2777        }
2778        // Make sure s2 contains all signatures in s1.
2779        if (set1.equals(set2)) {
2780            return PackageManager.SIGNATURE_MATCH;
2781        }
2782        return PackageManager.SIGNATURE_NO_MATCH;
2783    }
2784
2785    /**
2786     * If the database version for this type of package (internal storage or
2787     * external storage) is less than the version where package signatures
2788     * were updated, return true.
2789     */
2790    private boolean isCompatSignatureUpdateNeeded(PackageParser.Package scannedPkg) {
2791        return (isExternal(scannedPkg) && mSettings.isExternalDatabaseVersionOlderThan(
2792                DatabaseVersion.SIGNATURE_END_ENTITY))
2793                || (!isExternal(scannedPkg) && mSettings.isInternalDatabaseVersionOlderThan(
2794                        DatabaseVersion.SIGNATURE_END_ENTITY));
2795    }
2796
2797    /**
2798     * Used for backward compatibility to make sure any packages with
2799     * certificate chains get upgraded to the new style. {@code existingSigs}
2800     * will be in the old format (since they were stored on disk from before the
2801     * system upgrade) and {@code scannedSigs} will be in the newer format.
2802     */
2803    private int compareSignaturesCompat(PackageSignatures existingSigs,
2804            PackageParser.Package scannedPkg) {
2805        if (!isCompatSignatureUpdateNeeded(scannedPkg)) {
2806            return PackageManager.SIGNATURE_NO_MATCH;
2807        }
2808
2809        HashSet<Signature> existingSet = new HashSet<Signature>();
2810        for (Signature sig : existingSigs.mSignatures) {
2811            existingSet.add(sig);
2812        }
2813        HashSet<Signature> scannedCompatSet = new HashSet<Signature>();
2814        for (Signature sig : scannedPkg.mSignatures) {
2815            try {
2816                Signature[] chainSignatures = sig.getChainSignatures();
2817                for (Signature chainSig : chainSignatures) {
2818                    scannedCompatSet.add(chainSig);
2819                }
2820            } catch (CertificateEncodingException e) {
2821                scannedCompatSet.add(sig);
2822            }
2823        }
2824        /*
2825         * Make sure the expanded scanned set contains all signatures in the
2826         * existing one.
2827         */
2828        if (scannedCompatSet.equals(existingSet)) {
2829            // Migrate the old signatures to the new scheme.
2830            existingSigs.assignSignatures(scannedPkg.mSignatures);
2831            // The new KeySets will be re-added later in the scanning process.
2832            synchronized (mPackages) {
2833                mSettings.mKeySetManagerService.removeAppKeySetDataLPw(scannedPkg.packageName);
2834            }
2835            return PackageManager.SIGNATURE_MATCH;
2836        }
2837        return PackageManager.SIGNATURE_NO_MATCH;
2838    }
2839
2840    @Override
2841    public String[] getPackagesForUid(int uid) {
2842        uid = UserHandle.getAppId(uid);
2843        // reader
2844        synchronized (mPackages) {
2845            Object obj = mSettings.getUserIdLPr(uid);
2846            if (obj instanceof SharedUserSetting) {
2847                final SharedUserSetting sus = (SharedUserSetting) obj;
2848                final int N = sus.packages.size();
2849                final String[] res = new String[N];
2850                final Iterator<PackageSetting> it = sus.packages.iterator();
2851                int i = 0;
2852                while (it.hasNext()) {
2853                    res[i++] = it.next().name;
2854                }
2855                return res;
2856            } else if (obj instanceof PackageSetting) {
2857                final PackageSetting ps = (PackageSetting) obj;
2858                return new String[] { ps.name };
2859            }
2860        }
2861        return null;
2862    }
2863
2864    @Override
2865    public String getNameForUid(int uid) {
2866        // reader
2867        synchronized (mPackages) {
2868            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2869            if (obj instanceof SharedUserSetting) {
2870                final SharedUserSetting sus = (SharedUserSetting) obj;
2871                return sus.name + ":" + sus.userId;
2872            } else if (obj instanceof PackageSetting) {
2873                final PackageSetting ps = (PackageSetting) obj;
2874                return ps.name;
2875            }
2876        }
2877        return null;
2878    }
2879
2880    @Override
2881    public int getUidForSharedUser(String sharedUserName) {
2882        if(sharedUserName == null) {
2883            return -1;
2884        }
2885        // reader
2886        synchronized (mPackages) {
2887            final SharedUserSetting suid = mSettings.getSharedUserLPw(sharedUserName, 0, false);
2888            if (suid == null) {
2889                return -1;
2890            }
2891            return suid.userId;
2892        }
2893    }
2894
2895    @Override
2896    public int getFlagsForUid(int uid) {
2897        synchronized (mPackages) {
2898            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2899            if (obj instanceof SharedUserSetting) {
2900                final SharedUserSetting sus = (SharedUserSetting) obj;
2901                return sus.pkgFlags;
2902            } else if (obj instanceof PackageSetting) {
2903                final PackageSetting ps = (PackageSetting) obj;
2904                return ps.pkgFlags;
2905            }
2906        }
2907        return 0;
2908    }
2909
2910    @Override
2911    public ResolveInfo resolveIntent(Intent intent, String resolvedType,
2912            int flags, int userId) {
2913        if (!sUserManager.exists(userId)) return null;
2914        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "resolve intent");
2915        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
2916        return chooseBestActivity(intent, resolvedType, flags, query, userId);
2917    }
2918
2919    @Override
2920    public void setLastChosenActivity(Intent intent, String resolvedType, int flags,
2921            IntentFilter filter, int match, ComponentName activity) {
2922        final int userId = UserHandle.getCallingUserId();
2923        if (DEBUG_PREFERRED) {
2924            Log.v(TAG, "setLastChosenActivity intent=" + intent
2925                + " resolvedType=" + resolvedType
2926                + " flags=" + flags
2927                + " filter=" + filter
2928                + " match=" + match
2929                + " activity=" + activity);
2930            filter.dump(new PrintStreamPrinter(System.out), "    ");
2931        }
2932        intent.setComponent(null);
2933        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
2934        // Find any earlier preferred or last chosen entries and nuke them
2935        findPreferredActivity(intent, resolvedType,
2936                flags, query, 0, false, true, false, userId);
2937        // Add the new activity as the last chosen for this filter
2938        addPreferredActivityInternal(filter, match, null, activity, false, userId);
2939    }
2940
2941    @Override
2942    public ResolveInfo getLastChosenActivity(Intent intent, String resolvedType, int flags) {
2943        final int userId = UserHandle.getCallingUserId();
2944        if (DEBUG_PREFERRED) Log.v(TAG, "Querying last chosen activity for " + intent);
2945        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
2946        return findPreferredActivity(intent, resolvedType, flags, query, 0,
2947                false, false, false, userId);
2948    }
2949
2950    private ResolveInfo chooseBestActivity(Intent intent, String resolvedType,
2951            int flags, List<ResolveInfo> query, int userId) {
2952        if (query != null) {
2953            final int N = query.size();
2954            if (N == 1) {
2955                return query.get(0);
2956            } else if (N > 1) {
2957                final boolean debug = ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
2958                // If there is more than one activity with the same priority,
2959                // then let the user decide between them.
2960                ResolveInfo r0 = query.get(0);
2961                ResolveInfo r1 = query.get(1);
2962                if (DEBUG_INTENT_MATCHING || debug) {
2963                    Slog.v(TAG, r0.activityInfo.name + "=" + r0.priority + " vs "
2964                            + r1.activityInfo.name + "=" + r1.priority);
2965                }
2966                // If the first activity has a higher priority, or a different
2967                // default, then it is always desireable to pick it.
2968                if (r0.priority != r1.priority
2969                        || r0.preferredOrder != r1.preferredOrder
2970                        || r0.isDefault != r1.isDefault) {
2971                    return query.get(0);
2972                }
2973                // If we have saved a preference for a preferred activity for
2974                // this Intent, use that.
2975                ResolveInfo ri = findPreferredActivity(intent, resolvedType,
2976                        flags, query, r0.priority, true, false, debug, userId);
2977                if (ri != null) {
2978                    return ri;
2979                }
2980                if (userId != 0) {
2981                    ri = new ResolveInfo(mResolveInfo);
2982                    ri.activityInfo = new ActivityInfo(ri.activityInfo);
2983                    ri.activityInfo.applicationInfo = new ApplicationInfo(
2984                            ri.activityInfo.applicationInfo);
2985                    ri.activityInfo.applicationInfo.uid = UserHandle.getUid(userId,
2986                            UserHandle.getAppId(ri.activityInfo.applicationInfo.uid));
2987                    return ri;
2988                }
2989                return mResolveInfo;
2990            }
2991        }
2992        return null;
2993    }
2994
2995    private ResolveInfo findPersistentPreferredActivityLP(Intent intent, String resolvedType,
2996            int flags, List<ResolveInfo> query, boolean debug, int userId) {
2997        final int N = query.size();
2998        PersistentPreferredIntentResolver ppir = mSettings.mPersistentPreferredActivities
2999                .get(userId);
3000        // Get the list of persistent preferred activities that handle the intent
3001        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Looking for presistent preferred activities...");
3002        List<PersistentPreferredActivity> pprefs = ppir != null
3003                ? ppir.queryIntent(intent, resolvedType,
3004                        (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId)
3005                : null;
3006        if (pprefs != null && pprefs.size() > 0) {
3007            final int M = pprefs.size();
3008            for (int i=0; i<M; i++) {
3009                final PersistentPreferredActivity ppa = pprefs.get(i);
3010                if (DEBUG_PREFERRED || debug) {
3011                    Slog.v(TAG, "Checking PersistentPreferredActivity ds="
3012                            + (ppa.countDataSchemes() > 0 ? ppa.getDataScheme(0) : "<none>")
3013                            + "\n  component=" + ppa.mComponent);
3014                    ppa.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3015                }
3016                final ActivityInfo ai = getActivityInfo(ppa.mComponent,
3017                        flags | PackageManager.GET_DISABLED_COMPONENTS, userId);
3018                if (DEBUG_PREFERRED || debug) {
3019                    Slog.v(TAG, "Found persistent preferred activity:");
3020                    if (ai != null) {
3021                        ai.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3022                    } else {
3023                        Slog.v(TAG, "  null");
3024                    }
3025                }
3026                if (ai == null) {
3027                    // This previously registered persistent preferred activity
3028                    // component is no longer known. Ignore it and do NOT remove it.
3029                    continue;
3030                }
3031                for (int j=0; j<N; j++) {
3032                    final ResolveInfo ri = query.get(j);
3033                    if (!ri.activityInfo.applicationInfo.packageName
3034                            .equals(ai.applicationInfo.packageName)) {
3035                        continue;
3036                    }
3037                    if (!ri.activityInfo.name.equals(ai.name)) {
3038                        continue;
3039                    }
3040                    //  Found a persistent preference that can handle the intent.
3041                    if (DEBUG_PREFERRED || debug) {
3042                        Slog.v(TAG, "Returning persistent preferred activity: " +
3043                                ri.activityInfo.packageName + "/" + ri.activityInfo.name);
3044                    }
3045                    return ri;
3046                }
3047            }
3048        }
3049        return null;
3050    }
3051
3052    ResolveInfo findPreferredActivity(Intent intent, String resolvedType, int flags,
3053            List<ResolveInfo> query, int priority, boolean always,
3054            boolean removeMatches, boolean debug, int userId) {
3055        if (!sUserManager.exists(userId)) return null;
3056        // writer
3057        synchronized (mPackages) {
3058            if (intent.getSelector() != null) {
3059                intent = intent.getSelector();
3060            }
3061            if (DEBUG_PREFERRED) intent.addFlags(Intent.FLAG_DEBUG_LOG_RESOLUTION);
3062
3063            // Try to find a matching persistent preferred activity.
3064            ResolveInfo pri = findPersistentPreferredActivityLP(intent, resolvedType, flags, query,
3065                    debug, userId);
3066
3067            // If a persistent preferred activity matched, use it.
3068            if (pri != null) {
3069                return pri;
3070            }
3071
3072            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
3073            // Get the list of preferred activities that handle the intent
3074            if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Looking for preferred activities...");
3075            List<PreferredActivity> prefs = pir != null
3076                    ? pir.queryIntent(intent, resolvedType,
3077                            (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId)
3078                    : null;
3079            if (prefs != null && prefs.size() > 0) {
3080                // First figure out how good the original match set is.
3081                // We will only allow preferred activities that came
3082                // from the same match quality.
3083                int match = 0;
3084
3085                if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Figuring out best match...");
3086
3087                final int N = query.size();
3088                for (int j=0; j<N; j++) {
3089                    final ResolveInfo ri = query.get(j);
3090                    if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Match for " + ri.activityInfo
3091                            + ": 0x" + Integer.toHexString(match));
3092                    if (ri.match > match) {
3093                        match = ri.match;
3094                    }
3095                }
3096
3097                if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Best match: 0x"
3098                        + Integer.toHexString(match));
3099
3100                match &= IntentFilter.MATCH_CATEGORY_MASK;
3101                final int M = prefs.size();
3102                for (int i=0; i<M; i++) {
3103                    final PreferredActivity pa = prefs.get(i);
3104                    if (DEBUG_PREFERRED || debug) {
3105                        Slog.v(TAG, "Checking PreferredActivity ds="
3106                                + (pa.countDataSchemes() > 0 ? pa.getDataScheme(0) : "<none>")
3107                                + "\n  component=" + pa.mPref.mComponent);
3108                        pa.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3109                    }
3110                    if (pa.mPref.mMatch != match) {
3111                        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Skipping bad match "
3112                                + Integer.toHexString(pa.mPref.mMatch));
3113                        continue;
3114                    }
3115                    // If it's not an "always" type preferred activity and that's what we're
3116                    // looking for, skip it.
3117                    if (always && !pa.mPref.mAlways) {
3118                        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Skipping mAlways=false entry");
3119                        continue;
3120                    }
3121                    final ActivityInfo ai = getActivityInfo(pa.mPref.mComponent,
3122                            flags | PackageManager.GET_DISABLED_COMPONENTS, userId);
3123                    if (DEBUG_PREFERRED || debug) {
3124                        Slog.v(TAG, "Found preferred activity:");
3125                        if (ai != null) {
3126                            ai.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3127                        } else {
3128                            Slog.v(TAG, "  null");
3129                        }
3130                    }
3131                    if (ai == null) {
3132                        // This previously registered preferred activity
3133                        // component is no longer known.  Most likely an update
3134                        // to the app was installed and in the new version this
3135                        // component no longer exists.  Clean it up by removing
3136                        // it from the preferred activities list, and skip it.
3137                        Slog.w(TAG, "Removing dangling preferred activity: "
3138                                + pa.mPref.mComponent);
3139                        pir.removeFilter(pa);
3140                        continue;
3141                    }
3142                    for (int j=0; j<N; j++) {
3143                        final ResolveInfo ri = query.get(j);
3144                        if (!ri.activityInfo.applicationInfo.packageName
3145                                .equals(ai.applicationInfo.packageName)) {
3146                            continue;
3147                        }
3148                        if (!ri.activityInfo.name.equals(ai.name)) {
3149                            continue;
3150                        }
3151
3152                        if (removeMatches) {
3153                            pir.removeFilter(pa);
3154                            if (DEBUG_PREFERRED) {
3155                                Slog.v(TAG, "Removing match " + pa.mPref.mComponent);
3156                            }
3157                            break;
3158                        }
3159
3160                        // Okay we found a previously set preferred or last chosen app.
3161                        // If the result set is different from when this
3162                        // was created, we need to clear it and re-ask the
3163                        // user their preference, if we're looking for an "always" type entry.
3164                        if (always && !pa.mPref.sameSet(query, priority)) {
3165                            Slog.i(TAG, "Result set changed, dropping preferred activity for "
3166                                    + intent + " type " + resolvedType);
3167                            if (DEBUG_PREFERRED) {
3168                                Slog.v(TAG, "Removing preferred activity since set changed "
3169                                        + pa.mPref.mComponent);
3170                            }
3171                            pir.removeFilter(pa);
3172                            // Re-add the filter as a "last chosen" entry (!always)
3173                            PreferredActivity lastChosen = new PreferredActivity(
3174                                    pa, pa.mPref.mMatch, null, pa.mPref.mComponent, false);
3175                            pir.addFilter(lastChosen);
3176                            mSettings.writePackageRestrictionsLPr(userId);
3177                            return null;
3178                        }
3179
3180                        // Yay! Either the set matched or we're looking for the last chosen
3181                        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Returning preferred activity: "
3182                                + ri.activityInfo.packageName + "/" + ri.activityInfo.name);
3183                        mSettings.writePackageRestrictionsLPr(userId);
3184                        return ri;
3185                    }
3186                }
3187            }
3188            mSettings.writePackageRestrictionsLPr(userId);
3189        }
3190        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "No preferred activity to return");
3191        return null;
3192    }
3193
3194    /*
3195     * Returns if intent can be forwarded from the sourceUserId to the targetUserId
3196     */
3197    @Override
3198    public boolean canForwardTo(Intent intent, String resolvedType, int sourceUserId,
3199            int targetUserId) {
3200        mContext.enforceCallingOrSelfPermission(
3201                android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
3202        List<CrossProfileIntentFilter> matches =
3203                getMatchingCrossProfileIntentFilters(intent, resolvedType, sourceUserId);
3204        if (matches != null) {
3205            int size = matches.size();
3206            for (int i = 0; i < size; i++) {
3207                if (matches.get(i).getTargetUserId() == targetUserId) return true;
3208            }
3209        }
3210
3211        ArrayList<String> packageNames = null;
3212        SparseArray<ArrayList<String>> fromSource =
3213                mSettings.mCrossProfilePackageInfo.get(sourceUserId);
3214        if (fromSource != null) {
3215            packageNames = fromSource.get(targetUserId);
3216        }
3217        if (packageNames.contains(intent.getPackage())) {
3218            return true;
3219        }
3220        // We need the package name, so we try to resolve with the loosest flags possible
3221        List<ResolveInfo> resolveInfos = mActivities.queryIntent(
3222                intent, resolvedType, PackageManager.GET_UNINSTALLED_PACKAGES, targetUserId);
3223        int count = resolveInfos.size();
3224        for (int i = 0; i < count; i++) {
3225            ResolveInfo resolveInfo = resolveInfos.get(i);
3226            if (packageNames.contains(resolveInfo.activityInfo.packageName)) {
3227                return true;
3228            }
3229        }
3230        return false;
3231    }
3232
3233    private List<CrossProfileIntentFilter> getMatchingCrossProfileIntentFilters(Intent intent,
3234            String resolvedType, int userId) {
3235        CrossProfileIntentResolver resolver = mSettings.mCrossProfileIntentResolvers.get(userId);
3236        if (resolver != null) {
3237            return resolver.queryIntent(intent, resolvedType, false, userId);
3238        }
3239        return null;
3240    }
3241
3242    @Override
3243    public List<ResolveInfo> queryIntentActivities(Intent intent,
3244            String resolvedType, int flags, int userId) {
3245        if (!sUserManager.exists(userId)) return Collections.emptyList();
3246        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "query intent activities");
3247        ComponentName comp = intent.getComponent();
3248        if (comp == null) {
3249            if (intent.getSelector() != null) {
3250                intent = intent.getSelector();
3251                comp = intent.getComponent();
3252            }
3253        }
3254
3255        if (comp != null) {
3256            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3257            final ActivityInfo ai = getActivityInfo(comp, flags, userId);
3258            if (ai != null) {
3259                final ResolveInfo ri = new ResolveInfo();
3260                ri.activityInfo = ai;
3261                list.add(ri);
3262            }
3263            return list;
3264        }
3265
3266        // reader
3267        synchronized (mPackages) {
3268            final String pkgName = intent.getPackage();
3269            boolean queryCrossProfile = (flags & PackageManager.NO_CROSS_PROFILE) == 0;
3270            if (pkgName == null) {
3271                ResolveInfo resolveInfo = null;
3272                if (queryCrossProfile) {
3273                    // Check if the intent needs to be forwarded to another user for this package
3274                    ArrayList<ResolveInfo> crossProfileResult =
3275                            queryIntentActivitiesCrossProfilePackage(
3276                                    intent, resolvedType, flags, userId);
3277                    if (!crossProfileResult.isEmpty()) {
3278                        // Skip the current profile
3279                        return crossProfileResult;
3280                    }
3281                    List<CrossProfileIntentFilter> matchingFilters =
3282                            getMatchingCrossProfileIntentFilters(intent, resolvedType, userId);
3283                    // Check for results that need to skip the current profile.
3284                    resolveInfo = querySkipCurrentProfileIntents(matchingFilters, intent,
3285                            resolvedType, flags, userId);
3286                    if (resolveInfo != null) {
3287                        List<ResolveInfo> result = new ArrayList<ResolveInfo>(1);
3288                        result.add(resolveInfo);
3289                        return result;
3290                    }
3291                    // Check for cross profile results.
3292                    resolveInfo = queryCrossProfileIntents(
3293                            matchingFilters, intent, resolvedType, flags, userId);
3294                }
3295                // Check for results in the current profile.
3296                List<ResolveInfo> result = mActivities.queryIntent(
3297                        intent, resolvedType, flags, userId);
3298                if (resolveInfo != null) {
3299                    result.add(resolveInfo);
3300                }
3301                return result;
3302            }
3303            final PackageParser.Package pkg = mPackages.get(pkgName);
3304            if (pkg != null) {
3305                if (queryCrossProfile) {
3306                    ArrayList<ResolveInfo> crossProfileResult =
3307                            queryIntentActivitiesCrossProfilePackage(
3308                                    intent, resolvedType, flags, userId, pkg, pkgName);
3309                    if (!crossProfileResult.isEmpty()) {
3310                        // Skip the current profile
3311                        return crossProfileResult;
3312                    }
3313                }
3314                return mActivities.queryIntentForPackage(intent, resolvedType, flags,
3315                        pkg.activities, userId);
3316            }
3317            return new ArrayList<ResolveInfo>();
3318        }
3319    }
3320
3321    private ResolveInfo querySkipCurrentProfileIntents(
3322            List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
3323            int flags, int sourceUserId) {
3324        if (matchingFilters != null) {
3325            int size = matchingFilters.size();
3326            for (int i = 0; i < size; i ++) {
3327                CrossProfileIntentFilter filter = matchingFilters.get(i);
3328                if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) != 0) {
3329                    // Checking if there are activities in the target user that can handle the
3330                    // intent.
3331                    ResolveInfo resolveInfo = checkTargetCanHandle(filter, intent, resolvedType,
3332                            flags, sourceUserId);
3333                    if (resolveInfo != null) {
3334                        return resolveInfo;
3335                    }
3336                }
3337            }
3338        }
3339        return null;
3340    }
3341
3342    private ArrayList<ResolveInfo> queryIntentActivitiesCrossProfilePackage(
3343            Intent intent, String resolvedType, int flags, int userId) {
3344        ArrayList<ResolveInfo> matchingResolveInfos = new ArrayList<ResolveInfo>();
3345        SparseArray<ArrayList<String>> sourceForwardingInfo =
3346                mSettings.mCrossProfilePackageInfo.get(userId);
3347        if (sourceForwardingInfo != null) {
3348            int NI = sourceForwardingInfo.size();
3349            for (int i = 0; i < NI; i++) {
3350                int targetUserId = sourceForwardingInfo.keyAt(i);
3351                ArrayList<String> packageNames = sourceForwardingInfo.valueAt(i);
3352                List<ResolveInfo> resolveInfos = mActivities.queryIntent(
3353                        intent, resolvedType, flags, targetUserId);
3354                int NJ = resolveInfos.size();
3355                for (int j = 0; j < NJ; j++) {
3356                    ResolveInfo resolveInfo = resolveInfos.get(j);
3357                    if (packageNames.contains(resolveInfo.activityInfo.packageName)) {
3358                        matchingResolveInfos.add(createForwardingResolveInfo(
3359                                resolveInfo.filter, userId, targetUserId));
3360                    }
3361                }
3362            }
3363        }
3364        return matchingResolveInfos;
3365    }
3366
3367    private ArrayList<ResolveInfo> queryIntentActivitiesCrossProfilePackage(
3368            Intent intent, String resolvedType, int flags, int userId, PackageParser.Package pkg,
3369            String packageName) {
3370        ArrayList<ResolveInfo> matchingResolveInfos = new ArrayList<ResolveInfo>();
3371        SparseArray<ArrayList<String>> sourceForwardingInfo =
3372                mSettings.mCrossProfilePackageInfo.get(userId);
3373        if (sourceForwardingInfo != null) {
3374            int NI = sourceForwardingInfo.size();
3375            for (int i = 0; i < NI; i++) {
3376                int targetUserId = sourceForwardingInfo.keyAt(i);
3377                if (sourceForwardingInfo.valueAt(i).contains(packageName)) {
3378                    List<ResolveInfo> resolveInfos = mActivities.queryIntentForPackage(
3379                            intent, resolvedType, flags, pkg.activities, targetUserId);
3380                    int NJ = resolveInfos.size();
3381                    for (int j = 0; j < NJ; j++) {
3382                        ResolveInfo resolveInfo = resolveInfos.get(j);
3383                        matchingResolveInfos.add(createForwardingResolveInfo(
3384                                resolveInfo.filter, userId, targetUserId));
3385                    }
3386                }
3387            }
3388        }
3389        return matchingResolveInfos;
3390    }
3391
3392    // Return matching ResolveInfo if any for skip current profile intent filters.
3393    private ResolveInfo queryCrossProfileIntents(
3394            List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
3395            int flags, int sourceUserId) {
3396        if (matchingFilters != null) {
3397            // Two {@link CrossProfileIntentFilter}s can have the same targetUserId and
3398            // match the same intent. For performance reasons, it is better not to
3399            // run queryIntent twice for the same userId
3400            SparseBooleanArray alreadyTriedUserIds = new SparseBooleanArray();
3401            int size = matchingFilters.size();
3402            for (int i = 0; i < size; i++) {
3403                CrossProfileIntentFilter filter = matchingFilters.get(i);
3404                int targetUserId = filter.getTargetUserId();
3405                if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) == 0
3406                        && !alreadyTriedUserIds.get(targetUserId)) {
3407                    // Checking if there are activities in the target user that can handle the
3408                    // intent.
3409                    ResolveInfo resolveInfo = checkTargetCanHandle(filter, intent, resolvedType,
3410                            flags, sourceUserId);
3411                    if (resolveInfo != null) return resolveInfo;
3412                    alreadyTriedUserIds.put(targetUserId, true);
3413                }
3414            }
3415        }
3416        return null;
3417    }
3418
3419    private ResolveInfo checkTargetCanHandle(CrossProfileIntentFilter filter, Intent intent,
3420            String resolvedType, int flags, int sourceUserId) {
3421        List<ResolveInfo> resultTargetUser = mActivities.queryIntent(intent,
3422                resolvedType, flags, filter.getTargetUserId());
3423        if (resultTargetUser != null && !resultTargetUser.isEmpty()) {
3424            return createForwardingResolveInfo(filter, sourceUserId, filter.getTargetUserId());
3425        }
3426        return null;
3427    }
3428
3429    private ResolveInfo createForwardingResolveInfo(IntentFilter filter,
3430            int sourceUserId, int targetUserId) {
3431        ResolveInfo forwardingResolveInfo = new ResolveInfo();
3432        String className;
3433        if (targetUserId == UserHandle.USER_OWNER) {
3434            className = FORWARD_INTENT_TO_USER_OWNER;
3435        } else {
3436            className = FORWARD_INTENT_TO_MANAGED_PROFILE;
3437        }
3438        ComponentName forwardingActivityComponentName = new ComponentName(
3439                mAndroidApplication.packageName, className);
3440        ActivityInfo forwardingActivityInfo = getActivityInfo(forwardingActivityComponentName, 0,
3441                sourceUserId);
3442        if (targetUserId == UserHandle.USER_OWNER) {
3443            forwardingActivityInfo.showUserIcon = UserHandle.USER_OWNER;
3444            forwardingResolveInfo.noResourceId = true;
3445        }
3446        forwardingResolveInfo.activityInfo = forwardingActivityInfo;
3447        forwardingResolveInfo.priority = 0;
3448        forwardingResolveInfo.preferredOrder = 0;
3449        forwardingResolveInfo.match = 0;
3450        forwardingResolveInfo.isDefault = true;
3451        forwardingResolveInfo.filter = filter;
3452        forwardingResolveInfo.targetUserId = targetUserId;
3453        return forwardingResolveInfo;
3454    }
3455
3456    @Override
3457    public List<ResolveInfo> queryIntentActivityOptions(ComponentName caller,
3458            Intent[] specifics, String[] specificTypes, Intent intent,
3459            String resolvedType, int flags, int userId) {
3460        if (!sUserManager.exists(userId)) return Collections.emptyList();
3461        enforceCrossUserPermission(Binder.getCallingUid(), userId, false,
3462                "query intent activity options");
3463        final String resultsAction = intent.getAction();
3464
3465        List<ResolveInfo> results = queryIntentActivities(intent, resolvedType, flags
3466                | PackageManager.GET_RESOLVED_FILTER, userId);
3467
3468        if (DEBUG_INTENT_MATCHING) {
3469            Log.v(TAG, "Query " + intent + ": " + results);
3470        }
3471
3472        int specificsPos = 0;
3473        int N;
3474
3475        // todo: note that the algorithm used here is O(N^2).  This
3476        // isn't a problem in our current environment, but if we start running
3477        // into situations where we have more than 5 or 10 matches then this
3478        // should probably be changed to something smarter...
3479
3480        // First we go through and resolve each of the specific items
3481        // that were supplied, taking care of removing any corresponding
3482        // duplicate items in the generic resolve list.
3483        if (specifics != null) {
3484            for (int i=0; i<specifics.length; i++) {
3485                final Intent sintent = specifics[i];
3486                if (sintent == null) {
3487                    continue;
3488                }
3489
3490                if (DEBUG_INTENT_MATCHING) {
3491                    Log.v(TAG, "Specific #" + i + ": " + sintent);
3492                }
3493
3494                String action = sintent.getAction();
3495                if (resultsAction != null && resultsAction.equals(action)) {
3496                    // If this action was explicitly requested, then don't
3497                    // remove things that have it.
3498                    action = null;
3499                }
3500
3501                ResolveInfo ri = null;
3502                ActivityInfo ai = null;
3503
3504                ComponentName comp = sintent.getComponent();
3505                if (comp == null) {
3506                    ri = resolveIntent(
3507                        sintent,
3508                        specificTypes != null ? specificTypes[i] : null,
3509                            flags, userId);
3510                    if (ri == null) {
3511                        continue;
3512                    }
3513                    if (ri == mResolveInfo) {
3514                        // ACK!  Must do something better with this.
3515                    }
3516                    ai = ri.activityInfo;
3517                    comp = new ComponentName(ai.applicationInfo.packageName,
3518                            ai.name);
3519                } else {
3520                    ai = getActivityInfo(comp, flags, userId);
3521                    if (ai == null) {
3522                        continue;
3523                    }
3524                }
3525
3526                // Look for any generic query activities that are duplicates
3527                // of this specific one, and remove them from the results.
3528                if (DEBUG_INTENT_MATCHING) Log.v(TAG, "Specific #" + i + ": " + ai);
3529                N = results.size();
3530                int j;
3531                for (j=specificsPos; j<N; j++) {
3532                    ResolveInfo sri = results.get(j);
3533                    if ((sri.activityInfo.name.equals(comp.getClassName())
3534                            && sri.activityInfo.applicationInfo.packageName.equals(
3535                                    comp.getPackageName()))
3536                        || (action != null && sri.filter.matchAction(action))) {
3537                        results.remove(j);
3538                        if (DEBUG_INTENT_MATCHING) Log.v(
3539                            TAG, "Removing duplicate item from " + j
3540                            + " due to specific " + specificsPos);
3541                        if (ri == null) {
3542                            ri = sri;
3543                        }
3544                        j--;
3545                        N--;
3546                    }
3547                }
3548
3549                // Add this specific item to its proper place.
3550                if (ri == null) {
3551                    ri = new ResolveInfo();
3552                    ri.activityInfo = ai;
3553                }
3554                results.add(specificsPos, ri);
3555                ri.specificIndex = i;
3556                specificsPos++;
3557            }
3558        }
3559
3560        // Now we go through the remaining generic results and remove any
3561        // duplicate actions that are found here.
3562        N = results.size();
3563        for (int i=specificsPos; i<N-1; i++) {
3564            final ResolveInfo rii = results.get(i);
3565            if (rii.filter == null) {
3566                continue;
3567            }
3568
3569            // Iterate over all of the actions of this result's intent
3570            // filter...  typically this should be just one.
3571            final Iterator<String> it = rii.filter.actionsIterator();
3572            if (it == null) {
3573                continue;
3574            }
3575            while (it.hasNext()) {
3576                final String action = it.next();
3577                if (resultsAction != null && resultsAction.equals(action)) {
3578                    // If this action was explicitly requested, then don't
3579                    // remove things that have it.
3580                    continue;
3581                }
3582                for (int j=i+1; j<N; j++) {
3583                    final ResolveInfo rij = results.get(j);
3584                    if (rij.filter != null && rij.filter.hasAction(action)) {
3585                        results.remove(j);
3586                        if (DEBUG_INTENT_MATCHING) Log.v(
3587                            TAG, "Removing duplicate item from " + j
3588                            + " due to action " + action + " at " + i);
3589                        j--;
3590                        N--;
3591                    }
3592                }
3593            }
3594
3595            // If the caller didn't request filter information, drop it now
3596            // so we don't have to marshall/unmarshall it.
3597            if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) {
3598                rii.filter = null;
3599            }
3600        }
3601
3602        // Filter out the caller activity if so requested.
3603        if (caller != null) {
3604            N = results.size();
3605            for (int i=0; i<N; i++) {
3606                ActivityInfo ainfo = results.get(i).activityInfo;
3607                if (caller.getPackageName().equals(ainfo.applicationInfo.packageName)
3608                        && caller.getClassName().equals(ainfo.name)) {
3609                    results.remove(i);
3610                    break;
3611                }
3612            }
3613        }
3614
3615        // If the caller didn't request filter information,
3616        // drop them now so we don't have to
3617        // marshall/unmarshall it.
3618        if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) {
3619            N = results.size();
3620            for (int i=0; i<N; i++) {
3621                results.get(i).filter = null;
3622            }
3623        }
3624
3625        if (DEBUG_INTENT_MATCHING) Log.v(TAG, "Result: " + results);
3626        return results;
3627    }
3628
3629    @Override
3630    public List<ResolveInfo> queryIntentReceivers(Intent intent, String resolvedType, int flags,
3631            int userId) {
3632        if (!sUserManager.exists(userId)) return Collections.emptyList();
3633        ComponentName comp = intent.getComponent();
3634        if (comp == null) {
3635            if (intent.getSelector() != null) {
3636                intent = intent.getSelector();
3637                comp = intent.getComponent();
3638            }
3639        }
3640        if (comp != null) {
3641            List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3642            ActivityInfo ai = getReceiverInfo(comp, flags, userId);
3643            if (ai != null) {
3644                ResolveInfo ri = new ResolveInfo();
3645                ri.activityInfo = ai;
3646                list.add(ri);
3647            }
3648            return list;
3649        }
3650
3651        // reader
3652        synchronized (mPackages) {
3653            String pkgName = intent.getPackage();
3654            if (pkgName == null) {
3655                return mReceivers.queryIntent(intent, resolvedType, flags, userId);
3656            }
3657            final PackageParser.Package pkg = mPackages.get(pkgName);
3658            if (pkg != null) {
3659                return mReceivers.queryIntentForPackage(intent, resolvedType, flags, pkg.receivers,
3660                        userId);
3661            }
3662            return null;
3663        }
3664    }
3665
3666    @Override
3667    public ResolveInfo resolveService(Intent intent, String resolvedType, int flags, int userId) {
3668        List<ResolveInfo> query = queryIntentServices(intent, resolvedType, flags, userId);
3669        if (!sUserManager.exists(userId)) return null;
3670        if (query != null) {
3671            if (query.size() >= 1) {
3672                // If there is more than one service with the same priority,
3673                // just arbitrarily pick the first one.
3674                return query.get(0);
3675            }
3676        }
3677        return null;
3678    }
3679
3680    @Override
3681    public List<ResolveInfo> queryIntentServices(Intent intent, String resolvedType, int flags,
3682            int userId) {
3683        if (!sUserManager.exists(userId)) return Collections.emptyList();
3684        ComponentName comp = intent.getComponent();
3685        if (comp == null) {
3686            if (intent.getSelector() != null) {
3687                intent = intent.getSelector();
3688                comp = intent.getComponent();
3689            }
3690        }
3691        if (comp != null) {
3692            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3693            final ServiceInfo si = getServiceInfo(comp, flags, userId);
3694            if (si != null) {
3695                final ResolveInfo ri = new ResolveInfo();
3696                ri.serviceInfo = si;
3697                list.add(ri);
3698            }
3699            return list;
3700        }
3701
3702        // reader
3703        synchronized (mPackages) {
3704            String pkgName = intent.getPackage();
3705            if (pkgName == null) {
3706                return mServices.queryIntent(intent, resolvedType, flags, userId);
3707            }
3708            final PackageParser.Package pkg = mPackages.get(pkgName);
3709            if (pkg != null) {
3710                return mServices.queryIntentForPackage(intent, resolvedType, flags, pkg.services,
3711                        userId);
3712            }
3713            return null;
3714        }
3715    }
3716
3717    @Override
3718    public List<ResolveInfo> queryIntentContentProviders(
3719            Intent intent, String resolvedType, int flags, int userId) {
3720        if (!sUserManager.exists(userId)) return Collections.emptyList();
3721        ComponentName comp = intent.getComponent();
3722        if (comp == null) {
3723            if (intent.getSelector() != null) {
3724                intent = intent.getSelector();
3725                comp = intent.getComponent();
3726            }
3727        }
3728        if (comp != null) {
3729            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3730            final ProviderInfo pi = getProviderInfo(comp, flags, userId);
3731            if (pi != null) {
3732                final ResolveInfo ri = new ResolveInfo();
3733                ri.providerInfo = pi;
3734                list.add(ri);
3735            }
3736            return list;
3737        }
3738
3739        // reader
3740        synchronized (mPackages) {
3741            String pkgName = intent.getPackage();
3742            if (pkgName == null) {
3743                return mProviders.queryIntent(intent, resolvedType, flags, userId);
3744            }
3745            final PackageParser.Package pkg = mPackages.get(pkgName);
3746            if (pkg != null) {
3747                return mProviders.queryIntentForPackage(
3748                        intent, resolvedType, flags, pkg.providers, userId);
3749            }
3750            return null;
3751        }
3752    }
3753
3754    @Override
3755    public ParceledListSlice<PackageInfo> getInstalledPackages(int flags, int userId) {
3756        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3757
3758        enforceCrossUserPermission(Binder.getCallingUid(), userId, true, "get installed packages");
3759
3760        // writer
3761        synchronized (mPackages) {
3762            ArrayList<PackageInfo> list;
3763            if (listUninstalled) {
3764                list = new ArrayList<PackageInfo>(mSettings.mPackages.size());
3765                for (PackageSetting ps : mSettings.mPackages.values()) {
3766                    PackageInfo pi;
3767                    if (ps.pkg != null) {
3768                        pi = generatePackageInfo(ps.pkg, flags, userId);
3769                    } else {
3770                        pi = generatePackageInfoFromSettingsLPw(ps.name, flags, userId);
3771                    }
3772                    if (pi != null) {
3773                        list.add(pi);
3774                    }
3775                }
3776            } else {
3777                list = new ArrayList<PackageInfo>(mPackages.size());
3778                for (PackageParser.Package p : mPackages.values()) {
3779                    PackageInfo pi = generatePackageInfo(p, flags, userId);
3780                    if (pi != null) {
3781                        list.add(pi);
3782                    }
3783                }
3784            }
3785
3786            return new ParceledListSlice<PackageInfo>(list);
3787        }
3788    }
3789
3790    private void addPackageHoldingPermissions(ArrayList<PackageInfo> list, PackageSetting ps,
3791            String[] permissions, boolean[] tmp, int flags, int userId) {
3792        int numMatch = 0;
3793        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
3794        for (int i=0; i<permissions.length; i++) {
3795            if (gp.grantedPermissions.contains(permissions[i])) {
3796                tmp[i] = true;
3797                numMatch++;
3798            } else {
3799                tmp[i] = false;
3800            }
3801        }
3802        if (numMatch == 0) {
3803            return;
3804        }
3805        PackageInfo pi;
3806        if (ps.pkg != null) {
3807            pi = generatePackageInfo(ps.pkg, flags, userId);
3808        } else {
3809            pi = generatePackageInfoFromSettingsLPw(ps.name, flags, userId);
3810        }
3811        if ((flags&PackageManager.GET_PERMISSIONS) == 0) {
3812            if (numMatch == permissions.length) {
3813                pi.requestedPermissions = permissions;
3814            } else {
3815                pi.requestedPermissions = new String[numMatch];
3816                numMatch = 0;
3817                for (int i=0; i<permissions.length; i++) {
3818                    if (tmp[i]) {
3819                        pi.requestedPermissions[numMatch] = permissions[i];
3820                        numMatch++;
3821                    }
3822                }
3823            }
3824        }
3825        list.add(pi);
3826    }
3827
3828    @Override
3829    public ParceledListSlice<PackageInfo> getPackagesHoldingPermissions(
3830            String[] permissions, int flags, int userId) {
3831        if (!sUserManager.exists(userId)) return null;
3832        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3833
3834        // writer
3835        synchronized (mPackages) {
3836            ArrayList<PackageInfo> list = new ArrayList<PackageInfo>();
3837            boolean[] tmpBools = new boolean[permissions.length];
3838            if (listUninstalled) {
3839                for (PackageSetting ps : mSettings.mPackages.values()) {
3840                    addPackageHoldingPermissions(list, ps, permissions, tmpBools, flags, userId);
3841                }
3842            } else {
3843                for (PackageParser.Package pkg : mPackages.values()) {
3844                    PackageSetting ps = (PackageSetting)pkg.mExtras;
3845                    if (ps != null) {
3846                        addPackageHoldingPermissions(list, ps, permissions, tmpBools, flags,
3847                                userId);
3848                    }
3849                }
3850            }
3851
3852            return new ParceledListSlice<PackageInfo>(list);
3853        }
3854    }
3855
3856    @Override
3857    public ParceledListSlice<ApplicationInfo> getInstalledApplications(int flags, int userId) {
3858        if (!sUserManager.exists(userId)) return null;
3859        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3860
3861        // writer
3862        synchronized (mPackages) {
3863            ArrayList<ApplicationInfo> list;
3864            if (listUninstalled) {
3865                list = new ArrayList<ApplicationInfo>(mSettings.mPackages.size());
3866                for (PackageSetting ps : mSettings.mPackages.values()) {
3867                    ApplicationInfo ai;
3868                    if (ps.pkg != null) {
3869                        ai = PackageParser.generateApplicationInfo(ps.pkg, flags,
3870                                ps.readUserState(userId), userId);
3871                    } else {
3872                        ai = generateApplicationInfoFromSettingsLPw(ps.name, flags, userId);
3873                    }
3874                    if (ai != null) {
3875                        list.add(ai);
3876                    }
3877                }
3878            } else {
3879                list = new ArrayList<ApplicationInfo>(mPackages.size());
3880                for (PackageParser.Package p : mPackages.values()) {
3881                    if (p.mExtras != null) {
3882                        ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags,
3883                                ((PackageSetting)p.mExtras).readUserState(userId), userId);
3884                        if (ai != null) {
3885                            list.add(ai);
3886                        }
3887                    }
3888                }
3889            }
3890
3891            return new ParceledListSlice<ApplicationInfo>(list);
3892        }
3893    }
3894
3895    public List<ApplicationInfo> getPersistentApplications(int flags) {
3896        final ArrayList<ApplicationInfo> finalList = new ArrayList<ApplicationInfo>();
3897
3898        // reader
3899        synchronized (mPackages) {
3900            final Iterator<PackageParser.Package> i = mPackages.values().iterator();
3901            final int userId = UserHandle.getCallingUserId();
3902            while (i.hasNext()) {
3903                final PackageParser.Package p = i.next();
3904                if (p.applicationInfo != null
3905                        && (p.applicationInfo.flags&ApplicationInfo.FLAG_PERSISTENT) != 0
3906                        && (!mSafeMode || isSystemApp(p))) {
3907                    PackageSetting ps = mSettings.mPackages.get(p.packageName);
3908                    if (ps != null) {
3909                        ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags,
3910                                ps.readUserState(userId), userId);
3911                        if (ai != null) {
3912                            finalList.add(ai);
3913                        }
3914                    }
3915                }
3916            }
3917        }
3918
3919        return finalList;
3920    }
3921
3922    @Override
3923    public ProviderInfo resolveContentProvider(String name, int flags, int userId) {
3924        if (!sUserManager.exists(userId)) return null;
3925        // reader
3926        synchronized (mPackages) {
3927            final PackageParser.Provider provider = mProvidersByAuthority.get(name);
3928            PackageSetting ps = provider != null
3929                    ? mSettings.mPackages.get(provider.owner.packageName)
3930                    : null;
3931            return ps != null
3932                    && mSettings.isEnabledLPr(provider.info, flags, userId)
3933                    && (!mSafeMode || (provider.info.applicationInfo.flags
3934                            &ApplicationInfo.FLAG_SYSTEM) != 0)
3935                    ? PackageParser.generateProviderInfo(provider, flags,
3936                            ps.readUserState(userId), userId)
3937                    : null;
3938        }
3939    }
3940
3941    /**
3942     * @deprecated
3943     */
3944    @Deprecated
3945    public void querySyncProviders(List<String> outNames, List<ProviderInfo> outInfo) {
3946        // reader
3947        synchronized (mPackages) {
3948            final Iterator<Map.Entry<String, PackageParser.Provider>> i = mProvidersByAuthority
3949                    .entrySet().iterator();
3950            final int userId = UserHandle.getCallingUserId();
3951            while (i.hasNext()) {
3952                Map.Entry<String, PackageParser.Provider> entry = i.next();
3953                PackageParser.Provider p = entry.getValue();
3954                PackageSetting ps = mSettings.mPackages.get(p.owner.packageName);
3955
3956                if (ps != null && p.syncable
3957                        && (!mSafeMode || (p.info.applicationInfo.flags
3958                                &ApplicationInfo.FLAG_SYSTEM) != 0)) {
3959                    ProviderInfo info = PackageParser.generateProviderInfo(p, 0,
3960                            ps.readUserState(userId), userId);
3961                    if (info != null) {
3962                        outNames.add(entry.getKey());
3963                        outInfo.add(info);
3964                    }
3965                }
3966            }
3967        }
3968    }
3969
3970    @Override
3971    public List<ProviderInfo> queryContentProviders(String processName,
3972            int uid, int flags) {
3973        ArrayList<ProviderInfo> finalList = null;
3974        // reader
3975        synchronized (mPackages) {
3976            final Iterator<PackageParser.Provider> i = mProviders.mProviders.values().iterator();
3977            final int userId = processName != null ?
3978                    UserHandle.getUserId(uid) : UserHandle.getCallingUserId();
3979            while (i.hasNext()) {
3980                final PackageParser.Provider p = i.next();
3981                PackageSetting ps = mSettings.mPackages.get(p.owner.packageName);
3982                if (ps != null && p.info.authority != null
3983                        && (processName == null
3984                                || (p.info.processName.equals(processName)
3985                                        && UserHandle.isSameApp(p.info.applicationInfo.uid, uid)))
3986                        && mSettings.isEnabledLPr(p.info, flags, userId)
3987                        && (!mSafeMode
3988                                || (p.info.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0)) {
3989                    if (finalList == null) {
3990                        finalList = new ArrayList<ProviderInfo>(3);
3991                    }
3992                    ProviderInfo info = PackageParser.generateProviderInfo(p, flags,
3993                            ps.readUserState(userId), userId);
3994                    if (info != null) {
3995                        finalList.add(info);
3996                    }
3997                }
3998            }
3999        }
4000
4001        if (finalList != null) {
4002            Collections.sort(finalList, mProviderInitOrderSorter);
4003        }
4004
4005        return finalList;
4006    }
4007
4008    @Override
4009    public InstrumentationInfo getInstrumentationInfo(ComponentName name,
4010            int flags) {
4011        // reader
4012        synchronized (mPackages) {
4013            final PackageParser.Instrumentation i = mInstrumentation.get(name);
4014            return PackageParser.generateInstrumentationInfo(i, flags);
4015        }
4016    }
4017
4018    @Override
4019    public List<InstrumentationInfo> queryInstrumentation(String targetPackage,
4020            int flags) {
4021        ArrayList<InstrumentationInfo> finalList =
4022            new ArrayList<InstrumentationInfo>();
4023
4024        // reader
4025        synchronized (mPackages) {
4026            final Iterator<PackageParser.Instrumentation> i = mInstrumentation.values().iterator();
4027            while (i.hasNext()) {
4028                final PackageParser.Instrumentation p = i.next();
4029                if (targetPackage == null
4030                        || targetPackage.equals(p.info.targetPackage)) {
4031                    InstrumentationInfo ii = PackageParser.generateInstrumentationInfo(p,
4032                            flags);
4033                    if (ii != null) {
4034                        finalList.add(ii);
4035                    }
4036                }
4037            }
4038        }
4039
4040        return finalList;
4041    }
4042
4043    private void createIdmapsForPackageLI(PackageParser.Package pkg) {
4044        HashMap<String, PackageParser.Package> overlays = mOverlays.get(pkg.packageName);
4045        if (overlays == null) {
4046            Slog.w(TAG, "Unable to create idmap for " + pkg.packageName + ": no overlay packages");
4047            return;
4048        }
4049        for (PackageParser.Package opkg : overlays.values()) {
4050            // Not much to do if idmap fails: we already logged the error
4051            // and we certainly don't want to abort installation of pkg simply
4052            // because an overlay didn't fit properly. For these reasons,
4053            // ignore the return value of createIdmapForPackagePairLI.
4054            createIdmapForPackagePairLI(pkg, opkg);
4055        }
4056    }
4057
4058    private boolean createIdmapForPackagePairLI(PackageParser.Package pkg,
4059            PackageParser.Package opkg) {
4060        if (!opkg.mTrustedOverlay) {
4061            Slog.w(TAG, "Skipping target and overlay pair " + pkg.baseCodePath + " and " +
4062                    opkg.baseCodePath + ": overlay not trusted");
4063            return false;
4064        }
4065        HashMap<String, PackageParser.Package> overlaySet = mOverlays.get(pkg.packageName);
4066        if (overlaySet == null) {
4067            Slog.e(TAG, "was about to create idmap for " + pkg.baseCodePath + " and " +
4068                    opkg.baseCodePath + " but target package has no known overlays");
4069            return false;
4070        }
4071        final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
4072        // TODO: generate idmap for split APKs
4073        if (mInstaller.idmap(pkg.baseCodePath, opkg.baseCodePath, sharedGid) != 0) {
4074            Slog.e(TAG, "Failed to generate idmap for " + pkg.baseCodePath + " and "
4075                    + opkg.baseCodePath);
4076            return false;
4077        }
4078        PackageParser.Package[] overlayArray =
4079            overlaySet.values().toArray(new PackageParser.Package[0]);
4080        Comparator<PackageParser.Package> cmp = new Comparator<PackageParser.Package>() {
4081            public int compare(PackageParser.Package p1, PackageParser.Package p2) {
4082                return p1.mOverlayPriority - p2.mOverlayPriority;
4083            }
4084        };
4085        Arrays.sort(overlayArray, cmp);
4086
4087        pkg.applicationInfo.resourceDirs = new String[overlayArray.length];
4088        int i = 0;
4089        for (PackageParser.Package p : overlayArray) {
4090            pkg.applicationInfo.resourceDirs[i++] = p.baseCodePath;
4091        }
4092        return true;
4093    }
4094
4095    private void scanDirLI(File dir, int flags, int scanMode, long currentTime) {
4096        final File[] files = dir.listFiles();
4097        if (ArrayUtils.isEmpty(files)) {
4098            Log.d(TAG, "No files in app dir " + dir);
4099            return;
4100        }
4101
4102        if (DEBUG_PACKAGE_SCANNING) {
4103            Log.d(TAG, "Scanning app dir " + dir + " scanMode=" + scanMode
4104                    + " flags=0x" + Integer.toHexString(flags));
4105        }
4106
4107        for (File file : files) {
4108            final boolean isPackage = isApkFile(file) || file.isDirectory();
4109            if (!isPackage) {
4110                // Ignore entries which are not apk's
4111                continue;
4112            }
4113            try {
4114                scanPackageLI(file, flags | PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime,
4115                        null, null);
4116            } catch (PackageManagerException e) {
4117                Slog.w(TAG, "Failed to parse " + file + ": " + e.getMessage());
4118
4119                // Don't mess around with apps in system partition.
4120                if ((flags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
4121                        e.error == PackageManager.INSTALL_FAILED_INVALID_APK) {
4122                    // Delete the apk
4123                    Slog.w(TAG, "Cleaning up failed install of " + file);
4124                    file.delete();
4125                }
4126            }
4127        }
4128    }
4129
4130    private static File getSettingsProblemFile() {
4131        File dataDir = Environment.getDataDirectory();
4132        File systemDir = new File(dataDir, "system");
4133        File fname = new File(systemDir, "uiderrors.txt");
4134        return fname;
4135    }
4136
4137    static void reportSettingsProblem(int priority, String msg) {
4138        try {
4139            File fname = getSettingsProblemFile();
4140            FileOutputStream out = new FileOutputStream(fname, true);
4141            PrintWriter pw = new FastPrintWriter(out);
4142            SimpleDateFormat formatter = new SimpleDateFormat();
4143            String dateString = formatter.format(new Date(System.currentTimeMillis()));
4144            pw.println(dateString + ": " + msg);
4145            pw.close();
4146            FileUtils.setPermissions(
4147                    fname.toString(),
4148                    FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IROTH,
4149                    -1, -1);
4150        } catch (java.io.IOException e) {
4151        }
4152        Slog.println(priority, TAG, msg);
4153    }
4154
4155    private void collectCertificatesLI(PackageParser pp, PackageSetting ps,
4156            PackageParser.Package pkg, File srcFile, int parseFlags)
4157            throws PackageManagerException {
4158        if (ps != null
4159                && ps.codePath.equals(srcFile)
4160                && ps.timeStamp == srcFile.lastModified()
4161                && !isCompatSignatureUpdateNeeded(pkg)) {
4162            long mSigningKeySetId = ps.keySetData.getProperSigningKeySet();
4163            if (ps.signatures.mSignatures != null
4164                    && ps.signatures.mSignatures.length != 0
4165                    && mSigningKeySetId != PackageKeySetData.KEYSET_UNASSIGNED) {
4166                // Optimization: reuse the existing cached certificates
4167                // if the package appears to be unchanged.
4168                pkg.mSignatures = ps.signatures.mSignatures;
4169                KeySetManagerService ksms = mSettings.mKeySetManagerService;
4170                synchronized (mPackages) {
4171                    pkg.mSigningKeys = ksms.getPublicKeysFromKeySetLPr(mSigningKeySetId);
4172                }
4173                return;
4174            }
4175
4176            Slog.w(TAG, "PackageSetting for " + ps.name
4177                    + " is missing signatures.  Collecting certs again to recover them.");
4178        } else {
4179            Log.i(TAG, srcFile.toString() + " changed; collecting certs");
4180        }
4181
4182        try {
4183            pp.collectCertificates(pkg, parseFlags);
4184            pp.collectManifestDigest(pkg);
4185        } catch (PackageParserException e) {
4186            throw new PackageManagerException(e.error, "Failed to collect certificates for "
4187                    + pkg.packageName + ": " + e.getMessage());
4188        }
4189    }
4190
4191    /*
4192     *  Scan a package and return the newly parsed package.
4193     *  Returns null in case of errors and the error code is stored in mLastScanError
4194     */
4195    private PackageParser.Package scanPackageLI(File scanFile, int parseFlags, int scanMode,
4196            long currentTime, UserHandle user, String abiOverride) throws PackageManagerException {
4197        if (DEBUG_INSTALL) Slog.d(TAG, "Parsing: " + scanFile);
4198        parseFlags |= mDefParseFlags;
4199        PackageParser pp = new PackageParser();
4200        pp.setSeparateProcesses(mSeparateProcesses);
4201        pp.setOnlyCoreApps(mOnlyCore);
4202        pp.setDisplayMetrics(mMetrics);
4203
4204        if ((scanMode & SCAN_TRUSTED_OVERLAY) != 0) {
4205            parseFlags |= PackageParser.PARSE_TRUSTED_OVERLAY;
4206        }
4207
4208        final PackageParser.Package pkg;
4209        try {
4210            pkg = pp.parsePackage(scanFile, parseFlags);
4211        } catch (PackageParserException e) {
4212            throw new PackageManagerException(e.error,
4213                    "Failed to scan " + scanFile + ": " + e.getMessage());
4214        }
4215
4216        PackageSetting ps = null;
4217        PackageSetting updatedPkg;
4218        // reader
4219        synchronized (mPackages) {
4220            // Look to see if we already know about this package.
4221            String oldName = mSettings.mRenamedPackages.get(pkg.packageName);
4222            if (pkg.mOriginalPackages != null && pkg.mOriginalPackages.contains(oldName)) {
4223                // This package has been renamed to its original name.  Let's
4224                // use that.
4225                ps = mSettings.peekPackageLPr(oldName);
4226            }
4227            // If there was no original package, see one for the real package name.
4228            if (ps == null) {
4229                ps = mSettings.peekPackageLPr(pkg.packageName);
4230            }
4231            // Check to see if this package could be hiding/updating a system
4232            // package.  Must look for it either under the original or real
4233            // package name depending on our state.
4234            updatedPkg = mSettings.getDisabledSystemPkgLPr(ps != null ? ps.name : pkg.packageName);
4235            if (DEBUG_INSTALL && updatedPkg != null) Slog.d(TAG, "updatedPkg = " + updatedPkg);
4236        }
4237        boolean updatedPkgBetter = false;
4238        // First check if this is a system package that may involve an update
4239        if (updatedPkg != null && (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
4240            if (ps != null && !ps.codePath.equals(scanFile)) {
4241                // The path has changed from what was last scanned...  check the
4242                // version of the new path against what we have stored to determine
4243                // what to do.
4244                if (DEBUG_INSTALL) Slog.d(TAG, "Path changing from " + ps.codePath);
4245                if (pkg.mVersionCode < ps.versionCode) {
4246                    // The system package has been updated and the code path does not match
4247                    // Ignore entry. Skip it.
4248                    Log.i(TAG, "Package " + ps.name + " at " + scanFile
4249                            + " ignored: updated version " + ps.versionCode
4250                            + " better than this " + pkg.mVersionCode);
4251                    if (!updatedPkg.codePath.equals(scanFile)) {
4252                        Slog.w(PackageManagerService.TAG, "Code path for hidden system pkg : "
4253                                + ps.name + " changing from " + updatedPkg.codePathString
4254                                + " to " + scanFile);
4255                        updatedPkg.codePath = scanFile;
4256                        updatedPkg.codePathString = scanFile.toString();
4257                        // This is the point at which we know that the system-disk APK
4258                        // for this package has moved during a reboot (e.g. due to an OTA),
4259                        // so we need to reevaluate it for privilege policy.
4260                        if (locationIsPrivileged(scanFile)) {
4261                            updatedPkg.pkgFlags |= ApplicationInfo.FLAG_PRIVILEGED;
4262                        }
4263                    }
4264                    updatedPkg.pkg = pkg;
4265                    throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE, null);
4266                } else {
4267                    // The current app on the system partition is better than
4268                    // what we have updated to on the data partition; switch
4269                    // back to the system partition version.
4270                    // At this point, its safely assumed that package installation for
4271                    // apps in system partition will go through. If not there won't be a working
4272                    // version of the app
4273                    // writer
4274                    synchronized (mPackages) {
4275                        // Just remove the loaded entries from package lists.
4276                        mPackages.remove(ps.name);
4277                    }
4278                    Slog.w(TAG, "Package " + ps.name + " at " + scanFile
4279                            + "reverting from " + ps.codePathString
4280                            + ": new version " + pkg.mVersionCode
4281                            + " better than installed " + ps.versionCode);
4282
4283                    InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
4284                            ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
4285                            getAppDexInstructionSets(ps), isMultiArch(ps));
4286                    synchronized (mInstallLock) {
4287                        args.cleanUpResourcesLI();
4288                    }
4289                    synchronized (mPackages) {
4290                        mSettings.enableSystemPackageLPw(ps.name);
4291                    }
4292                    updatedPkgBetter = true;
4293                }
4294            }
4295        }
4296
4297        if (updatedPkg != null) {
4298            // An updated system app will not have the PARSE_IS_SYSTEM flag set
4299            // initially
4300            parseFlags |= PackageParser.PARSE_IS_SYSTEM;
4301
4302            // An updated privileged app will not have the PARSE_IS_PRIVILEGED
4303            // flag set initially
4304            if ((updatedPkg.pkgFlags & ApplicationInfo.FLAG_PRIVILEGED) != 0) {
4305                parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
4306            }
4307        }
4308
4309        // Verify certificates against what was last scanned
4310        collectCertificatesLI(pp, ps, pkg, scanFile, parseFlags);
4311
4312        /*
4313         * A new system app appeared, but we already had a non-system one of the
4314         * same name installed earlier.
4315         */
4316        boolean shouldHideSystemApp = false;
4317        if (updatedPkg == null && ps != null
4318                && (parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) != 0 && !isSystemApp(ps)) {
4319            /*
4320             * Check to make sure the signatures match first. If they don't,
4321             * wipe the installed application and its data.
4322             */
4323            if (compareSignatures(ps.signatures.mSignatures, pkg.mSignatures)
4324                    != PackageManager.SIGNATURE_MATCH) {
4325                if (DEBUG_INSTALL) Slog.d(TAG, "Signature mismatch!");
4326                deletePackageLI(pkg.packageName, null, true, null, null, 0, null, false);
4327                ps = null;
4328            } else {
4329                /*
4330                 * If the newly-added system app is an older version than the
4331                 * already installed version, hide it. It will be scanned later
4332                 * and re-added like an update.
4333                 */
4334                if (pkg.mVersionCode < ps.versionCode) {
4335                    shouldHideSystemApp = true;
4336                } else {
4337                    /*
4338                     * The newly found system app is a newer version that the
4339                     * one previously installed. Simply remove the
4340                     * already-installed application and replace it with our own
4341                     * while keeping the application data.
4342                     */
4343                    Slog.w(TAG, "Package " + ps.name + " at " + scanFile + "reverting from "
4344                            + ps.codePathString + ": new version " + pkg.mVersionCode
4345                            + " better than installed " + ps.versionCode);
4346                    InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
4347                            ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
4348                            getAppDexInstructionSets(ps), isMultiArch(ps));
4349                    synchronized (mInstallLock) {
4350                        args.cleanUpResourcesLI();
4351                    }
4352                }
4353            }
4354        }
4355
4356        // The apk is forward locked (not public) if its code and resources
4357        // are kept in different files. (except for app in either system or
4358        // vendor path).
4359        // TODO grab this value from PackageSettings
4360        if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
4361            if (ps != null && !ps.codePath.equals(ps.resourcePath)) {
4362                parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
4363            }
4364        }
4365
4366        // TODO: extend to support forward-locked splits
4367        String resourcePath = null;
4368        String baseResourcePath = null;
4369        if ((parseFlags & PackageParser.PARSE_FORWARD_LOCK) != 0 && !updatedPkgBetter) {
4370            if (ps != null && ps.resourcePathString != null) {
4371                resourcePath = ps.resourcePathString;
4372                baseResourcePath = ps.resourcePathString;
4373            } else {
4374                // Should not happen at all. Just log an error.
4375                Slog.e(TAG, "Resource path not set for pkg : " + pkg.packageName);
4376            }
4377        } else {
4378            resourcePath = pkg.codePath;
4379            baseResourcePath = pkg.baseCodePath;
4380        }
4381
4382        // Set application objects path explicitly.
4383        pkg.applicationInfo.setCodePath(pkg.codePath);
4384        pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
4385        pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
4386        pkg.applicationInfo.setResourcePath(resourcePath);
4387        pkg.applicationInfo.setBaseResourcePath(baseResourcePath);
4388        pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
4389
4390        // Note that we invoke the following method only if we are about to unpack an application
4391        PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanMode
4392                | SCAN_UPDATE_SIGNATURE, currentTime, user, abiOverride);
4393
4394        /*
4395         * If the system app should be overridden by a previously installed
4396         * data, hide the system app now and let the /data/app scan pick it up
4397         * again.
4398         */
4399        if (shouldHideSystemApp) {
4400            synchronized (mPackages) {
4401                /*
4402                 * We have to grant systems permissions before we hide, because
4403                 * grantPermissions will assume the package update is trying to
4404                 * expand its permissions.
4405                 */
4406                grantPermissionsLPw(pkg, true);
4407                mSettings.disableSystemPackageLPw(pkg.packageName);
4408            }
4409        }
4410
4411        return scannedPkg;
4412    }
4413
4414    private static String fixProcessName(String defProcessName,
4415            String processName, int uid) {
4416        if (processName == null) {
4417            return defProcessName;
4418        }
4419        return processName;
4420    }
4421
4422    private void verifySignaturesLP(PackageSetting pkgSetting, PackageParser.Package pkg)
4423            throws PackageManagerException {
4424        if (pkgSetting.signatures.mSignatures != null) {
4425            // Already existing package. Make sure signatures match
4426            boolean match = compareSignatures(pkgSetting.signatures.mSignatures, pkg.mSignatures)
4427                    == PackageManager.SIGNATURE_MATCH;
4428            if (!match) {
4429                match = compareSignaturesCompat(pkgSetting.signatures, pkg)
4430                        == PackageManager.SIGNATURE_MATCH;
4431            }
4432            if (!match) {
4433                throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
4434                        + pkg.packageName + " signatures do not match the "
4435                        + "previously installed version; ignoring!");
4436            }
4437        }
4438
4439        // Check for shared user signatures
4440        if (pkgSetting.sharedUser != null && pkgSetting.sharedUser.signatures.mSignatures != null) {
4441            // Already existing package. Make sure signatures match
4442            boolean match = compareSignatures(pkgSetting.sharedUser.signatures.mSignatures,
4443                    pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;
4444            if (!match) {
4445                match = compareSignaturesCompat(pkgSetting.sharedUser.signatures, pkg)
4446                        == PackageManager.SIGNATURE_MATCH;
4447            }
4448            if (!match) {
4449                throw new PackageManagerException(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
4450                        "Package " + pkg.packageName
4451                        + " has no signatures that match those in shared user "
4452                        + pkgSetting.sharedUser.name + "; ignoring!");
4453            }
4454        }
4455    }
4456
4457    /**
4458     * Enforces that only the system UID or root's UID can call a method exposed
4459     * via Binder.
4460     *
4461     * @param message used as message if SecurityException is thrown
4462     * @throws SecurityException if the caller is not system or root
4463     */
4464    private static final void enforceSystemOrRoot(String message) {
4465        final int uid = Binder.getCallingUid();
4466        if (uid != Process.SYSTEM_UID && uid != 0) {
4467            throw new SecurityException(message);
4468        }
4469    }
4470
4471    @Override
4472    public void performBootDexOpt() {
4473        enforceSystemOrRoot("Only the system can request dexopt be performed");
4474
4475        final HashSet<PackageParser.Package> pkgs;
4476        synchronized (mPackages) {
4477            pkgs = mDeferredDexOpt;
4478            mDeferredDexOpt = null;
4479        }
4480
4481        if (pkgs != null) {
4482            // Filter out packages that aren't recently used.
4483            //
4484            // The exception is first boot of a non-eng device, which
4485            // should do a full dexopt.
4486            boolean eng = "eng".equals(SystemProperties.get("ro.build.type"));
4487            if (eng || (!isFirstBoot() && mPackageUsage.isHistoricalPackageUsageAvailable())) {
4488                // TODO: add a property to control this?
4489                long dexOptLRUThresholdInMinutes;
4490                if (eng) {
4491                    dexOptLRUThresholdInMinutes = 30; // only last 30 minutes of apps for eng builds.
4492                } else {
4493                    dexOptLRUThresholdInMinutes = 7 * 24 * 60; // apps used in the 7 days for users.
4494                }
4495                long dexOptLRUThresholdInMills = dexOptLRUThresholdInMinutes * 60 * 1000;
4496
4497                int total = pkgs.size();
4498                int skipped = 0;
4499                long now = System.currentTimeMillis();
4500                for (Iterator<PackageParser.Package> i = pkgs.iterator(); i.hasNext();) {
4501                    PackageParser.Package pkg = i.next();
4502                    long then = pkg.mLastPackageUsageTimeInMills;
4503                    if (then + dexOptLRUThresholdInMills < now) {
4504                        if (DEBUG_DEXOPT) {
4505                            Log.i(TAG, "Skipping dexopt of " + pkg.packageName + " last resumed: " +
4506                                  ((then == 0) ? "never" : new Date(then)));
4507                        }
4508                        i.remove();
4509                        skipped++;
4510                    }
4511                }
4512                if (DEBUG_DEXOPT) {
4513                    Log.i(TAG, "Skipped optimizing " + skipped + " of " + total);
4514                }
4515            }
4516
4517            int i = 0;
4518            for (PackageParser.Package pkg : pkgs) {
4519                i++;
4520                if (DEBUG_DEXOPT) {
4521                    Log.i(TAG, "Optimizing app " + i + " of " + pkgs.size()
4522                          + ": " + pkg.packageName);
4523                }
4524                if (!isFirstBoot()) {
4525                    try {
4526                        ActivityManagerNative.getDefault().showBootMessage(
4527                                mContext.getResources().getString(
4528                                        R.string.android_upgrading_apk,
4529                                        i, pkgs.size()), true);
4530                    } catch (RemoteException e) {
4531                    }
4532                }
4533                PackageParser.Package p = pkg;
4534                synchronized (mInstallLock) {
4535                    if (p.mDexOptNeeded) {
4536                        performDexOptLI(p, false /* force dex */, false /* defer */,
4537                                true /* include dependencies */);
4538                    }
4539                }
4540            }
4541        }
4542    }
4543
4544    @Override
4545    public boolean performDexOpt(String packageName) {
4546        enforceSystemOrRoot("Only the system can request dexopt be performed");
4547        return performDexOpt(packageName, true);
4548    }
4549
4550    public boolean performDexOpt(String packageName, boolean updateUsage) {
4551
4552        PackageParser.Package p;
4553        synchronized (mPackages) {
4554            p = mPackages.get(packageName);
4555            if (p == null) {
4556                return false;
4557            }
4558            if (updateUsage) {
4559                p.mLastPackageUsageTimeInMills = System.currentTimeMillis();
4560            }
4561            mPackageUsage.write(false);
4562            if (!p.mDexOptNeeded) {
4563                return false;
4564            }
4565        }
4566
4567        synchronized (mInstallLock) {
4568            return performDexOptLI(p, false /* force dex */, false /* defer */,
4569                    true /* include dependencies */) == DEX_OPT_PERFORMED;
4570        }
4571    }
4572
4573    public HashSet<String> getPackagesThatNeedDexOpt() {
4574        HashSet<String> pkgs = null;
4575        synchronized (mPackages) {
4576            for (PackageParser.Package p : mPackages.values()) {
4577                if (DEBUG_DEXOPT) {
4578                    Log.i(TAG, p.packageName + " mDexOptNeeded=" + p.mDexOptNeeded);
4579                }
4580                if (!p.mDexOptNeeded) {
4581                    continue;
4582                }
4583                if (pkgs == null) {
4584                    pkgs = new HashSet<String>();
4585                }
4586                pkgs.add(p.packageName);
4587            }
4588        }
4589        return pkgs;
4590    }
4591
4592    public void shutdown() {
4593        mPackageUsage.write(true);
4594    }
4595
4596    private void performDexOptLibsLI(ArrayList<String> libs, String[] instructionSets,
4597             boolean forceDex, boolean defer, HashSet<String> done) {
4598        for (int i=0; i<libs.size(); i++) {
4599            PackageParser.Package libPkg;
4600            String libName;
4601            synchronized (mPackages) {
4602                libName = libs.get(i);
4603                SharedLibraryEntry lib = mSharedLibraries.get(libName);
4604                if (lib != null && lib.apk != null) {
4605                    libPkg = mPackages.get(lib.apk);
4606                } else {
4607                    libPkg = null;
4608                }
4609            }
4610            if (libPkg != null && !done.contains(libName)) {
4611                performDexOptLI(libPkg, instructionSets, forceDex, defer, done);
4612            }
4613        }
4614    }
4615
4616    static final int DEX_OPT_SKIPPED = 0;
4617    static final int DEX_OPT_PERFORMED = 1;
4618    static final int DEX_OPT_DEFERRED = 2;
4619    static final int DEX_OPT_FAILED = -1;
4620
4621    private int performDexOptLI(PackageParser.Package pkg, String[] targetInstructionSets,
4622            boolean forceDex, boolean defer, HashSet<String> done) {
4623        final String[] instructionSets = targetInstructionSets != null ?
4624                targetInstructionSets : getAppDexInstructionSets(pkg.applicationInfo);
4625
4626        if (done != null) {
4627            done.add(pkg.packageName);
4628            if (pkg.usesLibraries != null) {
4629                performDexOptLibsLI(pkg.usesLibraries, instructionSets, forceDex, defer, done);
4630            }
4631            if (pkg.usesOptionalLibraries != null) {
4632                performDexOptLibsLI(pkg.usesOptionalLibraries, instructionSets, forceDex, defer, done);
4633            }
4634        }
4635
4636        if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_HAS_CODE) == 0) {
4637            return DEX_OPT_SKIPPED;
4638        }
4639
4640        final List<String> paths = pkg.getAllCodePathsExcludingResourceOnly();
4641        boolean performedDexOpt = false;
4642        // There are three basic cases here:
4643        // 1.) we need to dexopt, either because we are forced or it is needed
4644        // 2.) we are defering a needed dexopt
4645        // 3.) we are skipping an unneeded dexopt
4646        for (String path : paths) {
4647            for (String instructionSet : instructionSets) {
4648                try {
4649                    final boolean isDexOptNeeded = DexFile.isDexOptNeededInternal(path,
4650                            pkg.packageName, instructionSet, defer);
4651                    if (forceDex || (!defer && isDexOptNeeded)) {
4652                        Log.i(TAG, "Running dexopt on: " + path + " pkg="
4653                                + pkg.applicationInfo.packageName + " isa=" + instructionSet);
4654                        final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
4655                        final int ret = mInstaller.dexopt(path, sharedGid, !isForwardLocked(pkg),
4656                                pkg.packageName, instructionSet);
4657
4658                        if (ret < 0) {
4659                            // Don't bother running dexopt again if we failed, it will probably
4660                            // just result in an error again. Also, don't bother dexopting for other
4661                            // paths & ISAs.
4662                            pkg.mDexOptNeeded = false;
4663                            return DEX_OPT_FAILED;
4664                        } else {
4665                            performedDexOpt = true;
4666                        }
4667                    }
4668
4669                    // We're deciding to defer a needed dexopt. Don't bother dexopting for other
4670                    // paths and instruction sets. We'll deal with them all together when we process
4671                    // our list of deferred dexopts.
4672                    if (defer && isDexOptNeeded) {
4673                        if (mDeferredDexOpt == null) {
4674                            mDeferredDexOpt = new HashSet<PackageParser.Package>();
4675                        }
4676                        mDeferredDexOpt.add(pkg);
4677                        return DEX_OPT_DEFERRED;
4678                    }
4679                } catch (FileNotFoundException e) {
4680                    Slog.w(TAG, "Apk not found for dexopt: " + path);
4681                    return DEX_OPT_FAILED;
4682                } catch (IOException e) {
4683                    Slog.w(TAG, "IOException reading apk: " + path, e);
4684                    return DEX_OPT_FAILED;
4685                } catch (StaleDexCacheError e) {
4686                    Slog.w(TAG, "StaleDexCacheError when reading apk: " + path, e);
4687                    return DEX_OPT_FAILED;
4688                } catch (Exception e) {
4689                    Slog.w(TAG, "Exception when doing dexopt : ", e);
4690                    return DEX_OPT_FAILED;
4691                }
4692            }
4693        }
4694
4695        // If we've gotten here, we're sure that no error occurred and that we haven't
4696        // deferred dex-opt. We've either dex-opted one more paths or instruction sets or
4697        // we've skipped all of them because they are up to date. In both cases this
4698        // package doesn't need dexopt any longer.
4699        pkg.mDexOptNeeded = false;
4700        return performedDexOpt ? DEX_OPT_PERFORMED : DEX_OPT_SKIPPED;
4701    }
4702
4703    private static String[] getAppDexInstructionSets(ApplicationInfo info) {
4704        if (info.primaryCpuAbi != null) {
4705            if (info.secondaryCpuAbi != null) {
4706                return new String[] {
4707                        VMRuntime.getInstructionSet(info.primaryCpuAbi),
4708                        VMRuntime.getInstructionSet(info.secondaryCpuAbi) };
4709            } else {
4710                return new String[] {
4711                        VMRuntime.getInstructionSet(info.primaryCpuAbi) };
4712            }
4713        }
4714
4715        return new String[] { getPreferredInstructionSet() };
4716    }
4717
4718    private static String[] getAppDexInstructionSets(PackageSetting ps) {
4719        if (ps.primaryCpuAbiString != null) {
4720            if (ps.secondaryCpuAbiString != null) {
4721                return new String[] {
4722                        VMRuntime.getInstructionSet(ps.primaryCpuAbiString),
4723                        VMRuntime.getInstructionSet(ps.secondaryCpuAbiString) };
4724            } else {
4725                return new String[] {
4726                        VMRuntime.getInstructionSet(ps.primaryCpuAbiString) };
4727            }
4728        }
4729
4730        return new String[] { getPreferredInstructionSet() };
4731    }
4732
4733    private static String getPreferredInstructionSet() {
4734        if (sPreferredInstructionSet == null) {
4735            sPreferredInstructionSet = VMRuntime.getInstructionSet(Build.SUPPORTED_ABIS[0]);
4736        }
4737
4738        return sPreferredInstructionSet;
4739    }
4740
4741    private static List<String> getAllInstructionSets() {
4742        final String[] allAbis = Build.SUPPORTED_ABIS;
4743        final List<String> allInstructionSets = new ArrayList<String>(allAbis.length);
4744
4745        for (String abi : allAbis) {
4746            final String instructionSet = VMRuntime.getInstructionSet(abi);
4747            if (!allInstructionSets.contains(instructionSet)) {
4748                allInstructionSets.add(instructionSet);
4749            }
4750        }
4751
4752        return allInstructionSets;
4753    }
4754
4755    private int performDexOptLI(PackageParser.Package pkg, boolean forceDex, boolean defer,
4756            boolean inclDependencies) {
4757        HashSet<String> done;
4758        if (inclDependencies && (pkg.usesLibraries != null || pkg.usesOptionalLibraries != null)) {
4759            done = new HashSet<String>();
4760            done.add(pkg.packageName);
4761        } else {
4762            done = null;
4763        }
4764        return performDexOptLI(pkg, null /* target instruction sets */,  forceDex, defer, done);
4765    }
4766
4767    private boolean verifyPackageUpdateLPr(PackageSetting oldPkg, PackageParser.Package newPkg) {
4768        if ((oldPkg.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0) {
4769            Slog.w(TAG, "Unable to update from " + oldPkg.name
4770                    + " to " + newPkg.packageName
4771                    + ": old package not in system partition");
4772            return false;
4773        } else if (mPackages.get(oldPkg.name) != null) {
4774            Slog.w(TAG, "Unable to update from " + oldPkg.name
4775                    + " to " + newPkg.packageName
4776                    + ": old package still exists");
4777            return false;
4778        }
4779        return true;
4780    }
4781
4782    File getDataPathForUser(int userId) {
4783        return new File(mUserAppDataDir.getAbsolutePath() + File.separator + userId);
4784    }
4785
4786    private File getDataPathForPackage(String packageName, int userId) {
4787        /*
4788         * Until we fully support multiple users, return the directory we
4789         * previously would have. The PackageManagerTests will need to be
4790         * revised when this is changed back..
4791         */
4792        if (userId == 0) {
4793            return new File(mAppDataDir, packageName);
4794        } else {
4795            return new File(mUserAppDataDir.getAbsolutePath() + File.separator + userId
4796                + File.separator + packageName);
4797        }
4798    }
4799
4800    private int createDataDirsLI(String packageName, int uid, String seinfo) {
4801        int[] users = sUserManager.getUserIds();
4802        int res = mInstaller.install(packageName, uid, uid, seinfo);
4803        if (res < 0) {
4804            return res;
4805        }
4806        for (int user : users) {
4807            if (user != 0) {
4808                res = mInstaller.createUserData(packageName,
4809                        UserHandle.getUid(user, uid), user, seinfo);
4810                if (res < 0) {
4811                    return res;
4812                }
4813            }
4814        }
4815        return res;
4816    }
4817
4818    private int removeDataDirsLI(String packageName) {
4819        int[] users = sUserManager.getUserIds();
4820        int res = 0;
4821        for (int user : users) {
4822            int resInner = mInstaller.remove(packageName, user);
4823            if (resInner < 0) {
4824                res = resInner;
4825            }
4826        }
4827
4828        return res;
4829    }
4830
4831    private void addSharedLibraryLPw(ArraySet<String> usesLibraryFiles, SharedLibraryEntry file,
4832            PackageParser.Package changingLib) {
4833        if (file.path != null) {
4834            usesLibraryFiles.add(file.path);
4835            return;
4836        }
4837        PackageParser.Package p = mPackages.get(file.apk);
4838        if (changingLib != null && changingLib.packageName.equals(file.apk)) {
4839            // If we are doing this while in the middle of updating a library apk,
4840            // then we need to make sure to use that new apk for determining the
4841            // dependencies here.  (We haven't yet finished committing the new apk
4842            // to the package manager state.)
4843            if (p == null || p.packageName.equals(changingLib.packageName)) {
4844                p = changingLib;
4845            }
4846        }
4847        if (p != null) {
4848            usesLibraryFiles.addAll(p.getAllCodePaths());
4849        }
4850    }
4851
4852    private void updateSharedLibrariesLPw(PackageParser.Package pkg,
4853            PackageParser.Package changingLib) throws PackageManagerException {
4854        // We might be upgrading from a version of the platform that did not
4855        // provide per-package native library directories for system apps.
4856        // Fix that up here.
4857        if (isSystemApp(pkg)) {
4858            PackageSetting ps = mSettings.mPackages.get(pkg.applicationInfo.packageName);
4859            if (!isUpdatedSystemApp(pkg)) {
4860                setBundledAppAbisAndRoots(pkg, ps);
4861            }
4862        }
4863
4864        if (pkg.usesLibraries != null || pkg.usesOptionalLibraries != null) {
4865            final ArraySet<String> usesLibraryFiles = new ArraySet<>();
4866            int N = pkg.usesLibraries != null ? pkg.usesLibraries.size() : 0;
4867            for (int i=0; i<N; i++) {
4868                final SharedLibraryEntry file = mSharedLibraries.get(pkg.usesLibraries.get(i));
4869                if (file == null) {
4870                    throw new PackageManagerException(INSTALL_FAILED_MISSING_SHARED_LIBRARY,
4871                            "Package " + pkg.packageName + " requires unavailable shared library "
4872                            + pkg.usesLibraries.get(i) + "; failing!");
4873                }
4874                addSharedLibraryLPw(usesLibraryFiles, file, changingLib);
4875            }
4876            N = pkg.usesOptionalLibraries != null ? pkg.usesOptionalLibraries.size() : 0;
4877            for (int i=0; i<N; i++) {
4878                final SharedLibraryEntry file = mSharedLibraries.get(pkg.usesOptionalLibraries.get(i));
4879                if (file == null) {
4880                    Slog.w(TAG, "Package " + pkg.packageName
4881                            + " desires unavailable shared library "
4882                            + pkg.usesOptionalLibraries.get(i) + "; ignoring!");
4883                } else {
4884                    addSharedLibraryLPw(usesLibraryFiles, file, changingLib);
4885                }
4886            }
4887            N = usesLibraryFiles.size();
4888            if (N > 0) {
4889                pkg.usesLibraryFiles = usesLibraryFiles.toArray(new String[N]);
4890            } else {
4891                pkg.usesLibraryFiles = null;
4892            }
4893        }
4894    }
4895
4896    private static boolean hasString(List<String> list, List<String> which) {
4897        if (list == null) {
4898            return false;
4899        }
4900        for (int i=list.size()-1; i>=0; i--) {
4901            for (int j=which.size()-1; j>=0; j--) {
4902                if (which.get(j).equals(list.get(i))) {
4903                    return true;
4904                }
4905            }
4906        }
4907        return false;
4908    }
4909
4910    private void updateAllSharedLibrariesLPw() {
4911        for (PackageParser.Package pkg : mPackages.values()) {
4912            try {
4913                updateSharedLibrariesLPw(pkg, null);
4914            } catch (PackageManagerException e) {
4915                Slog.e(TAG, "updateAllSharedLibrariesLPw failed: " + e.getMessage());
4916            }
4917        }
4918    }
4919
4920    private ArrayList<PackageParser.Package> updateAllSharedLibrariesLPw(
4921            PackageParser.Package changingPkg) {
4922        ArrayList<PackageParser.Package> res = null;
4923        for (PackageParser.Package pkg : mPackages.values()) {
4924            if (hasString(pkg.usesLibraries, changingPkg.libraryNames)
4925                    || hasString(pkg.usesOptionalLibraries, changingPkg.libraryNames)) {
4926                if (res == null) {
4927                    res = new ArrayList<PackageParser.Package>();
4928                }
4929                res.add(pkg);
4930                try {
4931                    updateSharedLibrariesLPw(pkg, changingPkg);
4932                } catch (PackageManagerException e) {
4933                    Slog.e(TAG, "updateAllSharedLibrariesLPw failed: " + e.getMessage());
4934                }
4935            }
4936        }
4937        return res;
4938    }
4939
4940    private PackageParser.Package scanPackageLI(PackageParser.Package pkg, int parseFlags,
4941            int scanMode, long currentTime, UserHandle user, String abiOverride)
4942            throws PackageManagerException {
4943        final File scanFile = new File(pkg.codePath);
4944        if (pkg.applicationInfo.getCodePath() == null ||
4945                pkg.applicationInfo.getResourcePath() == null) {
4946            // Bail out. The resource and code paths haven't been set.
4947            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
4948                    "Code and resource paths haven't been set correctly");
4949        }
4950
4951        if ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
4952            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
4953        }
4954
4955        if ((parseFlags&PackageParser.PARSE_IS_PRIVILEGED) != 0) {
4956            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_PRIVILEGED;
4957        }
4958
4959        if (mCustomResolverComponentName != null &&
4960                mCustomResolverComponentName.getPackageName().equals(pkg.packageName)) {
4961            setUpCustomResolverActivity(pkg);
4962        }
4963
4964        if (pkg.packageName.equals("android")) {
4965            synchronized (mPackages) {
4966                if (mAndroidApplication != null) {
4967                    Slog.w(TAG, "*************************************************");
4968                    Slog.w(TAG, "Core android package being redefined.  Skipping.");
4969                    Slog.w(TAG, " file=" + scanFile);
4970                    Slog.w(TAG, "*************************************************");
4971                    throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
4972                            "Core android package being redefined.  Skipping.");
4973                }
4974
4975                // Set up information for our fall-back user intent resolution activity.
4976                mPlatformPackage = pkg;
4977                pkg.mVersionCode = mSdkVersion;
4978                mAndroidApplication = pkg.applicationInfo;
4979
4980                if (!mResolverReplaced) {
4981                    mResolveActivity.applicationInfo = mAndroidApplication;
4982                    mResolveActivity.name = ResolverActivity.class.getName();
4983                    mResolveActivity.packageName = mAndroidApplication.packageName;
4984                    mResolveActivity.processName = "system:ui";
4985                    mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
4986                    mResolveActivity.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NEVER;
4987                    mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
4988                    mResolveActivity.theme = R.style.Theme_Holo_Dialog_Alert;
4989                    mResolveActivity.exported = true;
4990                    mResolveActivity.enabled = true;
4991                    mResolveInfo.activityInfo = mResolveActivity;
4992                    mResolveInfo.priority = 0;
4993                    mResolveInfo.preferredOrder = 0;
4994                    mResolveInfo.match = 0;
4995                    mResolveComponentName = new ComponentName(
4996                            mAndroidApplication.packageName, mResolveActivity.name);
4997                }
4998            }
4999        }
5000
5001        if (DEBUG_PACKAGE_SCANNING) {
5002            if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5003                Log.d(TAG, "Scanning package " + pkg.packageName);
5004        }
5005
5006        if (mPackages.containsKey(pkg.packageName)
5007                || mSharedLibraries.containsKey(pkg.packageName)) {
5008            throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
5009                    "Application package " + pkg.packageName
5010                    + " already installed.  Skipping duplicate.");
5011        }
5012
5013        // Initialize package source and resource directories
5014        File destCodeFile = new File(pkg.applicationInfo.getCodePath());
5015        File destResourceFile = new File(pkg.applicationInfo.getResourcePath());
5016
5017        SharedUserSetting suid = null;
5018        PackageSetting pkgSetting = null;
5019
5020        if (!isSystemApp(pkg)) {
5021            // Only system apps can use these features.
5022            pkg.mOriginalPackages = null;
5023            pkg.mRealPackage = null;
5024            pkg.mAdoptPermissions = null;
5025        }
5026
5027        // writer
5028        synchronized (mPackages) {
5029            if (pkg.mSharedUserId != null) {
5030                suid = mSettings.getSharedUserLPw(pkg.mSharedUserId, 0, true);
5031                if (suid == null) {
5032                    throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5033                            "Creating application package " + pkg.packageName
5034                            + " for shared user failed");
5035                }
5036                if (DEBUG_PACKAGE_SCANNING) {
5037                    if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5038                        Log.d(TAG, "Shared UserID " + pkg.mSharedUserId + " (uid=" + suid.userId
5039                                + "): packages=" + suid.packages);
5040                }
5041            }
5042
5043            // Check if we are renaming from an original package name.
5044            PackageSetting origPackage = null;
5045            String realName = null;
5046            if (pkg.mOriginalPackages != null) {
5047                // This package may need to be renamed to a previously
5048                // installed name.  Let's check on that...
5049                final String renamed = mSettings.mRenamedPackages.get(pkg.mRealPackage);
5050                if (pkg.mOriginalPackages.contains(renamed)) {
5051                    // This package had originally been installed as the
5052                    // original name, and we have already taken care of
5053                    // transitioning to the new one.  Just update the new
5054                    // one to continue using the old name.
5055                    realName = pkg.mRealPackage;
5056                    if (!pkg.packageName.equals(renamed)) {
5057                        // Callers into this function may have already taken
5058                        // care of renaming the package; only do it here if
5059                        // it is not already done.
5060                        pkg.setPackageName(renamed);
5061                    }
5062
5063                } else {
5064                    for (int i=pkg.mOriginalPackages.size()-1; i>=0; i--) {
5065                        if ((origPackage = mSettings.peekPackageLPr(
5066                                pkg.mOriginalPackages.get(i))) != null) {
5067                            // We do have the package already installed under its
5068                            // original name...  should we use it?
5069                            if (!verifyPackageUpdateLPr(origPackage, pkg)) {
5070                                // New package is not compatible with original.
5071                                origPackage = null;
5072                                continue;
5073                            } else if (origPackage.sharedUser != null) {
5074                                // Make sure uid is compatible between packages.
5075                                if (!origPackage.sharedUser.name.equals(pkg.mSharedUserId)) {
5076                                    Slog.w(TAG, "Unable to migrate data from " + origPackage.name
5077                                            + " to " + pkg.packageName + ": old uid "
5078                                            + origPackage.sharedUser.name
5079                                            + " differs from " + pkg.mSharedUserId);
5080                                    origPackage = null;
5081                                    continue;
5082                                }
5083                            } else {
5084                                if (DEBUG_UPGRADE) Log.v(TAG, "Renaming new package "
5085                                        + pkg.packageName + " to old name " + origPackage.name);
5086                            }
5087                            break;
5088                        }
5089                    }
5090                }
5091            }
5092
5093            if (mTransferedPackages.contains(pkg.packageName)) {
5094                Slog.w(TAG, "Package " + pkg.packageName
5095                        + " was transferred to another, but its .apk remains");
5096            }
5097
5098            // Just create the setting, don't add it yet. For already existing packages
5099            // the PkgSetting exists already and doesn't have to be created.
5100            pkgSetting = mSettings.getPackageLPw(pkg, origPackage, realName, suid, destCodeFile,
5101                    destResourceFile, pkg.applicationInfo.nativeLibraryRootDir,
5102                    pkg.applicationInfo.primaryCpuAbi,
5103                    pkg.applicationInfo.secondaryCpuAbi,
5104                    pkg.applicationInfo.flags, user, false);
5105            if (pkgSetting == null) {
5106                throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5107                        "Creating application package " + pkg.packageName + " failed");
5108            }
5109
5110            if (pkgSetting.origPackage != null) {
5111                // If we are first transitioning from an original package,
5112                // fix up the new package's name now.  We need to do this after
5113                // looking up the package under its new name, so getPackageLP
5114                // can take care of fiddling things correctly.
5115                pkg.setPackageName(origPackage.name);
5116
5117                // File a report about this.
5118                String msg = "New package " + pkgSetting.realName
5119                        + " renamed to replace old package " + pkgSetting.name;
5120                reportSettingsProblem(Log.WARN, msg);
5121
5122                // Make a note of it.
5123                mTransferedPackages.add(origPackage.name);
5124
5125                // No longer need to retain this.
5126                pkgSetting.origPackage = null;
5127            }
5128
5129            if (realName != null) {
5130                // Make a note of it.
5131                mTransferedPackages.add(pkg.packageName);
5132            }
5133
5134            if (mSettings.isDisabledSystemPackageLPr(pkg.packageName)) {
5135                pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
5136            }
5137
5138            if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
5139                // Check all shared libraries and map to their actual file path.
5140                // We only do this here for apps not on a system dir, because those
5141                // are the only ones that can fail an install due to this.  We
5142                // will take care of the system apps by updating all of their
5143                // library paths after the scan is done.
5144                updateSharedLibrariesLPw(pkg, null);
5145            }
5146
5147            if (mFoundPolicyFile) {
5148                SELinuxMMAC.assignSeinfoValue(pkg);
5149            }
5150
5151            pkg.applicationInfo.uid = pkgSetting.appId;
5152            pkg.mExtras = pkgSetting;
5153            if (!pkgSetting.keySetData.isUsingUpgradeKeySets() || pkgSetting.sharedUser != null) {
5154                try {
5155                    verifySignaturesLP(pkgSetting, pkg);
5156                } catch (PackageManagerException e) {
5157                    if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
5158                        throw e;
5159                    }
5160                    // The signature has changed, but this package is in the system
5161                    // image...  let's recover!
5162                    pkgSetting.signatures.mSignatures = pkg.mSignatures;
5163                    // However...  if this package is part of a shared user, but it
5164                    // doesn't match the signature of the shared user, let's fail.
5165                    // What this means is that you can't change the signatures
5166                    // associated with an overall shared user, which doesn't seem all
5167                    // that unreasonable.
5168                    if (pkgSetting.sharedUser != null) {
5169                        if (compareSignatures(pkgSetting.sharedUser.signatures.mSignatures,
5170                                              pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {
5171                            throw new PackageManagerException(
5172                                    INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
5173                                            "Signature mismatch for shared user : "
5174                                            + pkgSetting.sharedUser);
5175                        }
5176                    }
5177                    // File a report about this.
5178                    String msg = "System package " + pkg.packageName
5179                        + " signature changed; retaining data.";
5180                    reportSettingsProblem(Log.WARN, msg);
5181                }
5182            } else {
5183                if (!checkUpgradeKeySetLP(pkgSetting, pkg)) {
5184                    throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
5185                            + pkg.packageName + " upgrade keys do not match the "
5186                            + "previously installed version");
5187                } else {
5188                    // signatures may have changed as result of upgrade
5189                    pkgSetting.signatures.mSignatures = pkg.mSignatures;
5190                }
5191            }
5192            // Verify that this new package doesn't have any content providers
5193            // that conflict with existing packages.  Only do this if the
5194            // package isn't already installed, since we don't want to break
5195            // things that are installed.
5196            if ((scanMode&SCAN_NEW_INSTALL) != 0) {
5197                final int N = pkg.providers.size();
5198                int i;
5199                for (i=0; i<N; i++) {
5200                    PackageParser.Provider p = pkg.providers.get(i);
5201                    if (p.info.authority != null) {
5202                        String names[] = p.info.authority.split(";");
5203                        for (int j = 0; j < names.length; j++) {
5204                            if (mProvidersByAuthority.containsKey(names[j])) {
5205                                PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
5206                                final String otherPackageName =
5207                                        ((other != null && other.getComponentName() != null) ?
5208                                                other.getComponentName().getPackageName() : "?");
5209                                throw new PackageManagerException(
5210                                        INSTALL_FAILED_CONFLICTING_PROVIDER,
5211                                                "Can't install because provider name " + names[j]
5212                                                + " (in package " + pkg.applicationInfo.packageName
5213                                                + ") is already used by " + otherPackageName);
5214                            }
5215                        }
5216                    }
5217                }
5218            }
5219
5220            if (pkg.mAdoptPermissions != null) {
5221                // This package wants to adopt ownership of permissions from
5222                // another package.
5223                for (int i = pkg.mAdoptPermissions.size() - 1; i >= 0; i--) {
5224                    final String origName = pkg.mAdoptPermissions.get(i);
5225                    final PackageSetting orig = mSettings.peekPackageLPr(origName);
5226                    if (orig != null) {
5227                        if (verifyPackageUpdateLPr(orig, pkg)) {
5228                            Slog.i(TAG, "Adopting permissions from " + origName + " to "
5229                                    + pkg.packageName);
5230                            mSettings.transferPermissionsLPw(origName, pkg.packageName);
5231                        }
5232                    }
5233                }
5234            }
5235        }
5236
5237        final String pkgName = pkg.packageName;
5238
5239        final long scanFileTime = scanFile.lastModified();
5240        final boolean forceDex = (scanMode&SCAN_FORCE_DEX) != 0;
5241        pkg.applicationInfo.processName = fixProcessName(
5242                pkg.applicationInfo.packageName,
5243                pkg.applicationInfo.processName,
5244                pkg.applicationInfo.uid);
5245
5246        File dataPath;
5247        if (mPlatformPackage == pkg) {
5248            // The system package is special.
5249            dataPath = new File (Environment.getDataDirectory(), "system");
5250            pkg.applicationInfo.dataDir = dataPath.getPath();
5251        } else {
5252            // This is a normal package, need to make its data directory.
5253            dataPath = getDataPathForPackage(pkg.packageName, 0);
5254
5255            boolean uidError = false;
5256
5257            if (dataPath.exists()) {
5258                int currentUid = 0;
5259                try {
5260                    StructStat stat = Os.stat(dataPath.getPath());
5261                    currentUid = stat.st_uid;
5262                } catch (ErrnoException e) {
5263                    Slog.e(TAG, "Couldn't stat path " + dataPath.getPath(), e);
5264                }
5265
5266                // If we have mismatched owners for the data path, we have a problem.
5267                if (currentUid != pkg.applicationInfo.uid) {
5268                    boolean recovered = false;
5269                    if (currentUid == 0) {
5270                        // The directory somehow became owned by root.  Wow.
5271                        // This is probably because the system was stopped while
5272                        // installd was in the middle of messing with its libs
5273                        // directory.  Ask installd to fix that.
5274                        int ret = mInstaller.fixUid(pkgName, pkg.applicationInfo.uid,
5275                                pkg.applicationInfo.uid);
5276                        if (ret >= 0) {
5277                            recovered = true;
5278                            String msg = "Package " + pkg.packageName
5279                                    + " unexpectedly changed to uid 0; recovered to " +
5280                                    + pkg.applicationInfo.uid;
5281                            reportSettingsProblem(Log.WARN, msg);
5282                        }
5283                    }
5284                    if (!recovered && ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
5285                            || (scanMode&SCAN_BOOTING) != 0)) {
5286                        // If this is a system app, we can at least delete its
5287                        // current data so the application will still work.
5288                        int ret = removeDataDirsLI(pkgName);
5289                        if (ret >= 0) {
5290                            // TODO: Kill the processes first
5291                            // Old data gone!
5292                            String prefix = (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
5293                                    ? "System package " : "Third party package ";
5294                            String msg = prefix + pkg.packageName
5295                                    + " has changed from uid: "
5296                                    + currentUid + " to "
5297                                    + pkg.applicationInfo.uid + "; old data erased";
5298                            reportSettingsProblem(Log.WARN, msg);
5299                            recovered = true;
5300
5301                            // And now re-install the app.
5302                            ret = createDataDirsLI(pkgName, pkg.applicationInfo.uid,
5303                                                   pkg.applicationInfo.seinfo);
5304                            if (ret == -1) {
5305                                // Ack should not happen!
5306                                msg = prefix + pkg.packageName
5307                                        + " could not have data directory re-created after delete.";
5308                                reportSettingsProblem(Log.WARN, msg);
5309                                throw new PackageManagerException(
5310                                        INSTALL_FAILED_INSUFFICIENT_STORAGE, msg);
5311                            }
5312                        }
5313                        if (!recovered) {
5314                            mHasSystemUidErrors = true;
5315                        }
5316                    } else if (!recovered) {
5317                        // If we allow this install to proceed, we will be broken.
5318                        // Abort, abort!
5319                        throw new PackageManagerException(INSTALL_FAILED_UID_CHANGED,
5320                                "scanPackageLI");
5321                    }
5322                    if (!recovered) {
5323                        pkg.applicationInfo.dataDir = "/mismatched_uid/settings_"
5324                            + pkg.applicationInfo.uid + "/fs_"
5325                            + currentUid;
5326                        pkg.applicationInfo.nativeLibraryDir = pkg.applicationInfo.dataDir;
5327                        pkg.applicationInfo.nativeLibraryRootDir = pkg.applicationInfo.dataDir;
5328                        String msg = "Package " + pkg.packageName
5329                                + " has mismatched uid: "
5330                                + currentUid + " on disk, "
5331                                + pkg.applicationInfo.uid + " in settings";
5332                        // writer
5333                        synchronized (mPackages) {
5334                            mSettings.mReadMessages.append(msg);
5335                            mSettings.mReadMessages.append('\n');
5336                            uidError = true;
5337                            if (!pkgSetting.uidError) {
5338                                reportSettingsProblem(Log.ERROR, msg);
5339                            }
5340                        }
5341                    }
5342                }
5343                pkg.applicationInfo.dataDir = dataPath.getPath();
5344                if (mShouldRestoreconData) {
5345                    Slog.i(TAG, "SELinux relabeling of " + pkg.packageName + " issued.");
5346                    mInstaller.restoreconData(pkg.packageName, pkg.applicationInfo.seinfo,
5347                                pkg.applicationInfo.uid);
5348                }
5349            } else {
5350                if (DEBUG_PACKAGE_SCANNING) {
5351                    if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5352                        Log.v(TAG, "Want this data dir: " + dataPath);
5353                }
5354                //invoke installer to do the actual installation
5355                int ret = createDataDirsLI(pkgName, pkg.applicationInfo.uid,
5356                                           pkg.applicationInfo.seinfo);
5357                if (ret < 0) {
5358                    // Error from installer
5359                    throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5360                            "Unable to create data dirs [errorCode=" + ret + "]");
5361                }
5362
5363                if (dataPath.exists()) {
5364                    pkg.applicationInfo.dataDir = dataPath.getPath();
5365                } else {
5366                    Slog.w(TAG, "Unable to create data directory: " + dataPath);
5367                    pkg.applicationInfo.dataDir = null;
5368                }
5369            }
5370
5371            pkgSetting.uidError = uidError;
5372        }
5373
5374        final String path = scanFile.getPath();
5375        final String codePath = pkg.applicationInfo.getCodePath();
5376        if (isSystemApp(pkg) && !isUpdatedSystemApp(pkg)) {
5377            // For the case where we had previously uninstalled an update, get rid
5378            // of any native binaries we might have unpackaged. Note that this assumes
5379            // that system app updates were not installed via ASEC.
5380            //
5381            // TODO(multiArch): Is this cleanup really necessary ?
5382            NativeLibraryHelper.removeNativeBinariesFromDirLI(
5383                    new File(codePath, LIB_DIR_NAME), false /* delete dirs */);
5384            setBundledAppAbisAndRoots(pkg, pkgSetting);
5385            setNativeLibraryPaths(pkg);
5386        } else {
5387            // TODO: We can probably be smarter about this stuff. For installed apps,
5388            // we can calculate this information at install time once and for all. For
5389            // system apps, we can probably assume that this information doesn't change
5390            // after the first boot scan. As things stand, we do lots of unnecessary work.
5391
5392            // Give ourselves some initial paths; we'll come back for another
5393            // pass once we've determined ABI below.
5394            setNativeLibraryPaths(pkg);
5395
5396            final boolean isAsec = isForwardLocked(pkg) || isExternal(pkg);
5397            final String nativeLibraryRootStr = pkg.applicationInfo.nativeLibraryRootDir;
5398            final boolean useIsaSpecificSubdirs = pkg.applicationInfo.nativeLibraryRootRequiresIsa;
5399
5400            NativeLibraryHelper.Handle handle = null;
5401            try {
5402                handle = NativeLibraryHelper.Handle.create(scanFile);
5403                // TODO(multiArch): This can be null for apps that didn't go through the
5404                // usual installation process. We can calculate it again, like we
5405                // do during install time.
5406                //
5407                // TODO(multiArch): Why do we need to rescan ASEC apps again ? It seems totally
5408                // unnecessary.
5409                final File nativeLibraryRoot = new File(nativeLibraryRootStr);
5410
5411                // Null out the abis so that they can be recalculated.
5412                pkg.applicationInfo.primaryCpuAbi = null;
5413                pkg.applicationInfo.secondaryCpuAbi = null;
5414                if (isMultiArch(pkg.applicationInfo)) {
5415                    // Warn if we've set an abiOverride for multi-lib packages..
5416                    // By definition, we need to copy both 32 and 64 bit libraries for
5417                    // such packages.
5418                    if (abiOverride != null) {
5419                        Slog.w(TAG, "Ignoring abiOverride for multi arch application.");
5420                    }
5421
5422                    int abi32 = PackageManager.NO_NATIVE_LIBRARIES;
5423                    int abi64 = PackageManager.NO_NATIVE_LIBRARIES;
5424                    if (Build.SUPPORTED_32_BIT_ABIS.length > 0) {
5425                        if (isAsec) {
5426                            abi32 = NativeLibraryHelper.findSupportedAbi(handle, Build.SUPPORTED_32_BIT_ABIS);
5427                        } else {
5428                            abi32 = copyNativeLibrariesForInternalApp(handle,
5429                                    nativeLibraryRoot, Build.SUPPORTED_32_BIT_ABIS, useIsaSpecificSubdirs);
5430                        }
5431                    }
5432
5433                    maybeThrowExceptionForMultiArchCopy(
5434                            "Error unpackaging 32 bit native libs for multiarch app.", abi32);
5435
5436                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0) {
5437                        if (isAsec) {
5438                            abi64 = NativeLibraryHelper.findSupportedAbi(handle, Build.SUPPORTED_64_BIT_ABIS);
5439                        } else {
5440                            abi64 = copyNativeLibrariesForInternalApp(handle,
5441                                    nativeLibraryRoot, Build.SUPPORTED_64_BIT_ABIS, useIsaSpecificSubdirs);
5442                        }
5443                    }
5444
5445                    maybeThrowExceptionForMultiArchCopy(
5446                            "Error unpackaging 64 bit native libs for multiarch app.", abi64);
5447
5448                    if (abi64 >= 0) {
5449                        pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[abi64];
5450                    }
5451
5452                    if (abi32 >= 0) {
5453                        final String abi = Build.SUPPORTED_32_BIT_ABIS[abi32];
5454                        if (abi64 >= 0) {
5455                            pkg.applicationInfo.secondaryCpuAbi = abi;
5456                        } else {
5457                            pkg.applicationInfo.primaryCpuAbi = abi;
5458                        }
5459                    }
5460                } else {
5461                    String[] abiList = (abiOverride != null) ?
5462                            new String[] { abiOverride } : Build.SUPPORTED_ABIS;
5463
5464                    // Enable gross and lame hacks for apps that are built with old
5465                    // SDK tools. We must scan their APKs for renderscript bitcode and
5466                    // not launch them if it's present. Don't bother checking on devices
5467                    // that don't have 64 bit support.
5468                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0 && abiOverride == null &&
5469                            NativeLibraryHelper.hasRenderscriptBitcode(handle)) {
5470                        abiList = Build.SUPPORTED_32_BIT_ABIS;
5471                    }
5472
5473                    final int copyRet;
5474                    if (isAsec) {
5475                        copyRet = NativeLibraryHelper.findSupportedAbi(handle, abiList);
5476                    } else {
5477                        copyRet = copyNativeLibrariesForInternalApp(handle, nativeLibraryRoot, abiList,
5478                                useIsaSpecificSubdirs);
5479                    }
5480
5481                    if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES) {
5482                        throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
5483                                "Error unpackaging native libs for app, errorCode=" + copyRet);
5484                    }
5485
5486                    if (copyRet >= 0) {
5487                        pkg.applicationInfo.primaryCpuAbi = abiList[copyRet];
5488                    }
5489                }
5490            } catch (IOException ioe) {
5491                Slog.e(TAG, "Unable to get canonical file " + ioe.toString());
5492            } finally {
5493                IoUtils.closeQuietly(handle);
5494            }
5495
5496            // Now that we've calculated the ABIs and determined if it's an internal app,
5497            // we will go ahead and populate the nativeLibraryPath.
5498            setNativeLibraryPaths(pkg);
5499
5500            if (DEBUG_INSTALL) Slog.i(TAG, "Linking native library dir for " + path);
5501            final int[] userIds = sUserManager.getUserIds();
5502            synchronized (mInstallLock) {
5503                // Create a native library symlink only if we have native libraries
5504                // and if the native libraries are 32 bit libraries. We do not provide
5505                // this symlink for 64 bit libraries.
5506                if (pkg.applicationInfo.primaryCpuAbi != null &&
5507                        !VMRuntime.is64BitAbi(pkg.applicationInfo.primaryCpuAbi)) {
5508                    final String nativeLibPath = pkg.applicationInfo.nativeLibraryDir;
5509                    for (int userId : userIds) {
5510                        if (mInstaller.linkNativeLibraryDirectory(pkg.packageName, nativeLibPath, userId) < 0) {
5511                            throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
5512                                    "Failed linking native library dir (user=" + userId + ")");
5513                        }
5514                    }
5515                }
5516            }
5517
5518            pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
5519            pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
5520        }
5521
5522        Slog.d(TAG, "Resolved nativeLibraryRoot for " + pkg.applicationInfo.packageName
5523                + " to root=" + pkg.applicationInfo.nativeLibraryRootDir + ", isa="
5524                + pkg.applicationInfo.nativeLibraryRootRequiresIsa);
5525
5526        // Push the derived path down into PackageSettings so we know what to
5527        // clean up at uninstall time.
5528        pkgSetting.legacyNativeLibraryPathString = pkg.applicationInfo.nativeLibraryRootDir;
5529
5530        if (DEBUG_ABI_SELECTION) {
5531            Log.d(TAG, "Abis for package[" + pkg.packageName + "] are" +
5532                    " primary=" + pkg.applicationInfo.primaryCpuAbi +
5533                    " secondary=" + pkg.applicationInfo.secondaryCpuAbi);
5534        }
5535
5536        if ((scanMode&SCAN_BOOTING) == 0 && pkgSetting.sharedUser != null) {
5537            // We don't do this here during boot because we can do it all
5538            // at once after scanning all existing packages.
5539            //
5540            // We also do this *before* we perform dexopt on this package, so that
5541            // we can avoid redundant dexopts, and also to make sure we've got the
5542            // code and package path correct.
5543            adjustCpuAbisForSharedUserLPw(pkgSetting.sharedUser.packages,
5544                    pkg, forceDex, (scanMode & SCAN_DEFER_DEX) != 0);
5545        }
5546
5547        if ((scanMode&SCAN_NO_DEX) == 0) {
5548            if (performDexOptLI(pkg, forceDex, (scanMode&SCAN_DEFER_DEX) != 0, false)
5549                    == DEX_OPT_FAILED) {
5550                if ((scanMode & SCAN_DELETE_DATA_ON_FAILURES) != 0) {
5551                    removeDataDirsLI(pkg.packageName);
5552                }
5553
5554                throw new PackageManagerException(INSTALL_FAILED_DEXOPT, "scanPackageLI");
5555            }
5556        }
5557
5558        if (mFactoryTest && pkg.requestedPermissions.contains(
5559                android.Manifest.permission.FACTORY_TEST)) {
5560            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_FACTORY_TEST;
5561        }
5562
5563        ArrayList<PackageParser.Package> clientLibPkgs = null;
5564
5565        // writer
5566        synchronized (mPackages) {
5567            if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
5568                // Only system apps can add new shared libraries.
5569                if (pkg.libraryNames != null) {
5570                    for (int i=0; i<pkg.libraryNames.size(); i++) {
5571                        String name = pkg.libraryNames.get(i);
5572                        boolean allowed = false;
5573                        if (isUpdatedSystemApp(pkg)) {
5574                            // New library entries can only be added through the
5575                            // system image.  This is important to get rid of a lot
5576                            // of nasty edge cases: for example if we allowed a non-
5577                            // system update of the app to add a library, then uninstalling
5578                            // the update would make the library go away, and assumptions
5579                            // we made such as through app install filtering would now
5580                            // have allowed apps on the device which aren't compatible
5581                            // with it.  Better to just have the restriction here, be
5582                            // conservative, and create many fewer cases that can negatively
5583                            // impact the user experience.
5584                            final PackageSetting sysPs = mSettings
5585                                    .getDisabledSystemPkgLPr(pkg.packageName);
5586                            if (sysPs.pkg != null && sysPs.pkg.libraryNames != null) {
5587                                for (int j=0; j<sysPs.pkg.libraryNames.size(); j++) {
5588                                    if (name.equals(sysPs.pkg.libraryNames.get(j))) {
5589                                        allowed = true;
5590                                        allowed = true;
5591                                        break;
5592                                    }
5593                                }
5594                            }
5595                        } else {
5596                            allowed = true;
5597                        }
5598                        if (allowed) {
5599                            if (!mSharedLibraries.containsKey(name)) {
5600                                mSharedLibraries.put(name, new SharedLibraryEntry(null, pkg.packageName));
5601                            } else if (!name.equals(pkg.packageName)) {
5602                                Slog.w(TAG, "Package " + pkg.packageName + " library "
5603                                        + name + " already exists; skipping");
5604                            }
5605                        } else {
5606                            Slog.w(TAG, "Package " + pkg.packageName + " declares lib "
5607                                    + name + " that is not declared on system image; skipping");
5608                        }
5609                    }
5610                    if ((scanMode&SCAN_BOOTING) == 0) {
5611                        // If we are not booting, we need to update any applications
5612                        // that are clients of our shared library.  If we are booting,
5613                        // this will all be done once the scan is complete.
5614                        clientLibPkgs = updateAllSharedLibrariesLPw(pkg);
5615                    }
5616                }
5617            }
5618        }
5619
5620        // We also need to dexopt any apps that are dependent on this library.  Note that
5621        // if these fail, we should abort the install since installing the library will
5622        // result in some apps being broken.
5623        if (clientLibPkgs != null) {
5624            if ((scanMode&SCAN_NO_DEX) == 0) {
5625                for (int i=0; i<clientLibPkgs.size(); i++) {
5626                    PackageParser.Package clientPkg = clientLibPkgs.get(i);
5627                    if (performDexOptLI(clientPkg, forceDex, (scanMode&SCAN_DEFER_DEX) != 0, false)
5628                            == DEX_OPT_FAILED) {
5629                        if ((scanMode & SCAN_DELETE_DATA_ON_FAILURES) != 0) {
5630                            removeDataDirsLI(pkg.packageName);
5631                        }
5632
5633                        throw new PackageManagerException(INSTALL_FAILED_DEXOPT,
5634                                "scanPackageLI failed to dexopt clientLibPkgs");
5635                    }
5636                }
5637            }
5638        }
5639
5640        // Request the ActivityManager to kill the process(only for existing packages)
5641        // so that we do not end up in a confused state while the user is still using the older
5642        // version of the application while the new one gets installed.
5643        if ((parseFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
5644            // If the package lives in an asec, tell everyone that the container is going
5645            // away so they can clean up any references to its resources (which would prevent
5646            // vold from being able to unmount the asec)
5647            if (isForwardLocked(pkg) || isExternal(pkg)) {
5648                if (DEBUG_INSTALL) {
5649                    Slog.i(TAG, "upgrading pkg " + pkg + " is ASEC-hosted -> UNAVAILABLE");
5650                }
5651                final int[] uidArray = new int[] { pkg.applicationInfo.uid };
5652                final ArrayList<String> pkgList = new ArrayList<String>(1);
5653                pkgList.add(pkg.applicationInfo.packageName);
5654                sendResourcesChangedBroadcast(false, true, pkgList, uidArray, null);
5655            }
5656
5657            // Post the request that it be killed now that the going-away broadcast is en route
5658            killApplication(pkg.applicationInfo.packageName,
5659                        pkg.applicationInfo.uid, "update pkg");
5660        }
5661
5662        // Also need to kill any apps that are dependent on the library.
5663        if (clientLibPkgs != null) {
5664            for (int i=0; i<clientLibPkgs.size(); i++) {
5665                PackageParser.Package clientPkg = clientLibPkgs.get(i);
5666                killApplication(clientPkg.applicationInfo.packageName,
5667                        clientPkg.applicationInfo.uid, "update lib");
5668            }
5669        }
5670
5671        // writer
5672        synchronized (mPackages) {
5673            // We don't expect installation to fail beyond this point,
5674            if ((scanMode&SCAN_MONITOR) != 0) {
5675                mAppDirs.put(pkg.codePath, pkg);
5676            }
5677            // Add the new setting to mSettings
5678            mSettings.insertPackageSettingLPw(pkgSetting, pkg);
5679            // Add the new setting to mPackages
5680            mPackages.put(pkg.applicationInfo.packageName, pkg);
5681            // Make sure we don't accidentally delete its data.
5682            final Iterator<PackageCleanItem> iter = mSettings.mPackagesToBeCleaned.iterator();
5683            while (iter.hasNext()) {
5684                PackageCleanItem item = iter.next();
5685                if (pkgName.equals(item.packageName)) {
5686                    iter.remove();
5687                }
5688            }
5689
5690            // Take care of first install / last update times.
5691            if (currentTime != 0) {
5692                if (pkgSetting.firstInstallTime == 0) {
5693                    pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = currentTime;
5694                } else if ((scanMode&SCAN_UPDATE_TIME) != 0) {
5695                    pkgSetting.lastUpdateTime = currentTime;
5696                }
5697            } else if (pkgSetting.firstInstallTime == 0) {
5698                // We need *something*.  Take time time stamp of the file.
5699                pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = scanFileTime;
5700            } else if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) != 0) {
5701                if (scanFileTime != pkgSetting.timeStamp) {
5702                    // A package on the system image has changed; consider this
5703                    // to be an update.
5704                    pkgSetting.lastUpdateTime = scanFileTime;
5705                }
5706            }
5707
5708            // Add the package's KeySets to the global KeySetManagerService
5709            KeySetManagerService ksms = mSettings.mKeySetManagerService;
5710            try {
5711                // Old KeySetData no longer valid.
5712                ksms.removeAppKeySetDataLPw(pkg.packageName);
5713                ksms.addSigningKeySetToPackageLPw(pkg.packageName, pkg.mSigningKeys);
5714                if (pkg.mKeySetMapping != null) {
5715                    for (Map.Entry<String, ArraySet<PublicKey>> entry :
5716                            pkg.mKeySetMapping.entrySet()) {
5717                        if (entry.getValue() != null) {
5718                            ksms.addDefinedKeySetToPackageLPw(pkg.packageName,
5719                                                          entry.getValue(), entry.getKey());
5720                        }
5721                    }
5722                    if (pkg.mUpgradeKeySets != null) {
5723                        for (String upgradeAlias : pkg.mUpgradeKeySets) {
5724                            ksms.addUpgradeKeySetToPackageLPw(pkg.packageName, upgradeAlias);
5725                        }
5726                    }
5727                }
5728            } catch (NullPointerException e) {
5729                Slog.e(TAG, "Could not add KeySet to " + pkg.packageName, e);
5730            } catch (IllegalArgumentException e) {
5731                Slog.e(TAG, "Could not add KeySet to malformed package" + pkg.packageName, e);
5732            }
5733
5734            int N = pkg.providers.size();
5735            StringBuilder r = null;
5736            int i;
5737            for (i=0; i<N; i++) {
5738                PackageParser.Provider p = pkg.providers.get(i);
5739                p.info.processName = fixProcessName(pkg.applicationInfo.processName,
5740                        p.info.processName, pkg.applicationInfo.uid);
5741                mProviders.addProvider(p);
5742                p.syncable = p.info.isSyncable;
5743                if (p.info.authority != null) {
5744                    String names[] = p.info.authority.split(";");
5745                    p.info.authority = null;
5746                    for (int j = 0; j < names.length; j++) {
5747                        if (j == 1 && p.syncable) {
5748                            // We only want the first authority for a provider to possibly be
5749                            // syncable, so if we already added this provider using a different
5750                            // authority clear the syncable flag. We copy the provider before
5751                            // changing it because the mProviders object contains a reference
5752                            // to a provider that we don't want to change.
5753                            // Only do this for the second authority since the resulting provider
5754                            // object can be the same for all future authorities for this provider.
5755                            p = new PackageParser.Provider(p);
5756                            p.syncable = false;
5757                        }
5758                        if (!mProvidersByAuthority.containsKey(names[j])) {
5759                            mProvidersByAuthority.put(names[j], p);
5760                            if (p.info.authority == null) {
5761                                p.info.authority = names[j];
5762                            } else {
5763                                p.info.authority = p.info.authority + ";" + names[j];
5764                            }
5765                            if (DEBUG_PACKAGE_SCANNING) {
5766                                if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5767                                    Log.d(TAG, "Registered content provider: " + names[j]
5768                                            + ", className = " + p.info.name + ", isSyncable = "
5769                                            + p.info.isSyncable);
5770                            }
5771                        } else {
5772                            PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
5773                            Slog.w(TAG, "Skipping provider name " + names[j] +
5774                                    " (in package " + pkg.applicationInfo.packageName +
5775                                    "): name already used by "
5776                                    + ((other != null && other.getComponentName() != null)
5777                                            ? other.getComponentName().getPackageName() : "?"));
5778                        }
5779                    }
5780                }
5781                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5782                    if (r == null) {
5783                        r = new StringBuilder(256);
5784                    } else {
5785                        r.append(' ');
5786                    }
5787                    r.append(p.info.name);
5788                }
5789            }
5790            if (r != null) {
5791                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Providers: " + r);
5792            }
5793
5794            N = pkg.services.size();
5795            r = null;
5796            for (i=0; i<N; i++) {
5797                PackageParser.Service s = pkg.services.get(i);
5798                s.info.processName = fixProcessName(pkg.applicationInfo.processName,
5799                        s.info.processName, pkg.applicationInfo.uid);
5800                mServices.addService(s);
5801                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5802                    if (r == null) {
5803                        r = new StringBuilder(256);
5804                    } else {
5805                        r.append(' ');
5806                    }
5807                    r.append(s.info.name);
5808                }
5809            }
5810            if (r != null) {
5811                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Services: " + r);
5812            }
5813
5814            N = pkg.receivers.size();
5815            r = null;
5816            for (i=0; i<N; i++) {
5817                PackageParser.Activity a = pkg.receivers.get(i);
5818                a.info.processName = fixProcessName(pkg.applicationInfo.processName,
5819                        a.info.processName, pkg.applicationInfo.uid);
5820                mReceivers.addActivity(a, "receiver");
5821                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5822                    if (r == null) {
5823                        r = new StringBuilder(256);
5824                    } else {
5825                        r.append(' ');
5826                    }
5827                    r.append(a.info.name);
5828                }
5829            }
5830            if (r != null) {
5831                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Receivers: " + r);
5832            }
5833
5834            N = pkg.activities.size();
5835            r = null;
5836            for (i=0; i<N; i++) {
5837                PackageParser.Activity a = pkg.activities.get(i);
5838                a.info.processName = fixProcessName(pkg.applicationInfo.processName,
5839                        a.info.processName, pkg.applicationInfo.uid);
5840                mActivities.addActivity(a, "activity");
5841                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5842                    if (r == null) {
5843                        r = new StringBuilder(256);
5844                    } else {
5845                        r.append(' ');
5846                    }
5847                    r.append(a.info.name);
5848                }
5849            }
5850            if (r != null) {
5851                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Activities: " + r);
5852            }
5853
5854            N = pkg.permissionGroups.size();
5855            r = null;
5856            for (i=0; i<N; i++) {
5857                PackageParser.PermissionGroup pg = pkg.permissionGroups.get(i);
5858                PackageParser.PermissionGroup cur = mPermissionGroups.get(pg.info.name);
5859                if (cur == null) {
5860                    mPermissionGroups.put(pg.info.name, pg);
5861                    if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5862                        if (r == null) {
5863                            r = new StringBuilder(256);
5864                        } else {
5865                            r.append(' ');
5866                        }
5867                        r.append(pg.info.name);
5868                    }
5869                } else {
5870                    Slog.w(TAG, "Permission group " + pg.info.name + " from package "
5871                            + pg.info.packageName + " ignored: original from "
5872                            + cur.info.packageName);
5873                    if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5874                        if (r == null) {
5875                            r = new StringBuilder(256);
5876                        } else {
5877                            r.append(' ');
5878                        }
5879                        r.append("DUP:");
5880                        r.append(pg.info.name);
5881                    }
5882                }
5883            }
5884            if (r != null) {
5885                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Permission Groups: " + r);
5886            }
5887
5888            N = pkg.permissions.size();
5889            r = null;
5890            for (i=0; i<N; i++) {
5891                PackageParser.Permission p = pkg.permissions.get(i);
5892                HashMap<String, BasePermission> permissionMap =
5893                        p.tree ? mSettings.mPermissionTrees
5894                        : mSettings.mPermissions;
5895                p.group = mPermissionGroups.get(p.info.group);
5896                if (p.info.group == null || p.group != null) {
5897                    BasePermission bp = permissionMap.get(p.info.name);
5898                    if (bp == null) {
5899                        bp = new BasePermission(p.info.name, p.info.packageName,
5900                                BasePermission.TYPE_NORMAL);
5901                        permissionMap.put(p.info.name, bp);
5902                    }
5903                    if (bp.perm == null) {
5904                        if (bp.sourcePackage != null
5905                                && !bp.sourcePackage.equals(p.info.packageName)) {
5906                            // If this is a permission that was formerly defined by a non-system
5907                            // app, but is now defined by a system app (following an upgrade),
5908                            // discard the previous declaration and consider the system's to be
5909                            // canonical.
5910                            if (isSystemApp(p.owner)) {
5911                                String msg = "New decl " + p.owner + " of permission  "
5912                                        + p.info.name + " is system";
5913                                reportSettingsProblem(Log.WARN, msg);
5914                                bp.sourcePackage = null;
5915                            }
5916                        }
5917                        if (bp.sourcePackage == null
5918                                || bp.sourcePackage.equals(p.info.packageName)) {
5919                            BasePermission tree = findPermissionTreeLP(p.info.name);
5920                            if (tree == null
5921                                    || tree.sourcePackage.equals(p.info.packageName)) {
5922                                bp.packageSetting = pkgSetting;
5923                                bp.perm = p;
5924                                bp.uid = pkg.applicationInfo.uid;
5925                                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5926                                    if (r == null) {
5927                                        r = new StringBuilder(256);
5928                                    } else {
5929                                        r.append(' ');
5930                                    }
5931                                    r.append(p.info.name);
5932                                }
5933                            } else {
5934                                Slog.w(TAG, "Permission " + p.info.name + " from package "
5935                                        + p.info.packageName + " ignored: base tree "
5936                                        + tree.name + " is from package "
5937                                        + tree.sourcePackage);
5938                            }
5939                        } else {
5940                            Slog.w(TAG, "Permission " + p.info.name + " from package "
5941                                    + p.info.packageName + " ignored: original from "
5942                                    + bp.sourcePackage);
5943                        }
5944                    } else if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5945                        if (r == null) {
5946                            r = new StringBuilder(256);
5947                        } else {
5948                            r.append(' ');
5949                        }
5950                        r.append("DUP:");
5951                        r.append(p.info.name);
5952                    }
5953                    if (bp.perm == p) {
5954                        bp.protectionLevel = p.info.protectionLevel;
5955                    }
5956                } else {
5957                    Slog.w(TAG, "Permission " + p.info.name + " from package "
5958                            + p.info.packageName + " ignored: no group "
5959                            + p.group);
5960                }
5961            }
5962            if (r != null) {
5963                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Permissions: " + r);
5964            }
5965
5966            N = pkg.instrumentation.size();
5967            r = null;
5968            for (i=0; i<N; i++) {
5969                PackageParser.Instrumentation a = pkg.instrumentation.get(i);
5970                a.info.packageName = pkg.applicationInfo.packageName;
5971                a.info.sourceDir = pkg.applicationInfo.sourceDir;
5972                a.info.publicSourceDir = pkg.applicationInfo.publicSourceDir;
5973                a.info.splitSourceDirs = pkg.applicationInfo.splitSourceDirs;
5974                a.info.splitPublicSourceDirs = pkg.applicationInfo.splitPublicSourceDirs;
5975                a.info.dataDir = pkg.applicationInfo.dataDir;
5976
5977                // TODO: Update instrumentation.nativeLibraryDir as well ? Does it
5978                // need other information about the application, like the ABI and what not ?
5979                a.info.nativeLibraryDir = pkg.applicationInfo.nativeLibraryDir;
5980                mInstrumentation.put(a.getComponentName(), a);
5981                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5982                    if (r == null) {
5983                        r = new StringBuilder(256);
5984                    } else {
5985                        r.append(' ');
5986                    }
5987                    r.append(a.info.name);
5988                }
5989            }
5990            if (r != null) {
5991                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Instrumentation: " + r);
5992            }
5993
5994            if (pkg.protectedBroadcasts != null) {
5995                N = pkg.protectedBroadcasts.size();
5996                for (i=0; i<N; i++) {
5997                    mProtectedBroadcasts.add(pkg.protectedBroadcasts.get(i));
5998                }
5999            }
6000
6001            pkgSetting.setTimeStamp(scanFileTime);
6002
6003            // Create idmap files for pairs of (packages, overlay packages).
6004            // Note: "android", ie framework-res.apk, is handled by native layers.
6005            if (pkg.mOverlayTarget != null) {
6006                // This is an overlay package.
6007                if (pkg.mOverlayTarget != null && !pkg.mOverlayTarget.equals("android")) {
6008                    if (!mOverlays.containsKey(pkg.mOverlayTarget)) {
6009                        mOverlays.put(pkg.mOverlayTarget,
6010                                new HashMap<String, PackageParser.Package>());
6011                    }
6012                    HashMap<String, PackageParser.Package> map = mOverlays.get(pkg.mOverlayTarget);
6013                    map.put(pkg.packageName, pkg);
6014                    PackageParser.Package orig = mPackages.get(pkg.mOverlayTarget);
6015                    if (orig != null && !createIdmapForPackagePairLI(orig, pkg)) {
6016                        throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
6017                                "scanPackageLI failed to createIdmap");
6018                    }
6019                }
6020            } else if (mOverlays.containsKey(pkg.packageName) &&
6021                    !pkg.packageName.equals("android")) {
6022                // This is a regular package, with one or more known overlay packages.
6023                createIdmapsForPackageLI(pkg);
6024            }
6025        }
6026
6027        return pkg;
6028    }
6029
6030    /**
6031     * Adjusts ABIs for a set of packages belonging to a shared user so that they all match.
6032     * i.e, so that all packages can be run inside a single process if required.
6033     *
6034     * Optionally, callers can pass in a parsed package via {@code newPackage} in which case
6035     * this function will either try and make the ABI for all packages in {@code packagesForUser}
6036     * match {@code scannedPackage} or will update the ABI of {@code scannedPackage} to match
6037     * the ABI selected for {@code packagesForUser}. This variant is used when installing or
6038     * updating a package that belongs to a shared user.
6039     *
6040     * NOTE: We currently only match for the primary CPU abi string. Matching the secondary
6041     * adds unnecessary complexity.
6042     */
6043    private void adjustCpuAbisForSharedUserLPw(Set<PackageSetting> packagesForUser,
6044            PackageParser.Package scannedPackage, boolean forceDexOpt, boolean deferDexOpt) {
6045        String requiredInstructionSet = null;
6046        if (scannedPackage != null && scannedPackage.applicationInfo.primaryCpuAbi != null) {
6047            requiredInstructionSet = VMRuntime.getInstructionSet(
6048                     scannedPackage.applicationInfo.primaryCpuAbi);
6049        }
6050
6051        PackageSetting requirer = null;
6052        for (PackageSetting ps : packagesForUser) {
6053            // If packagesForUser contains scannedPackage, we skip it. This will happen
6054            // when scannedPackage is an update of an existing package. Without this check,
6055            // we will never be able to change the ABI of any package belonging to a shared
6056            // user, even if it's compatible with other packages.
6057            if (scannedPackage == null || !scannedPackage.packageName.equals(ps.name)) {
6058                if (ps.primaryCpuAbiString == null) {
6059                    continue;
6060                }
6061
6062                final String instructionSet = VMRuntime.getInstructionSet(ps.primaryCpuAbiString);
6063                if (requiredInstructionSet != null && !instructionSet.equals(requiredInstructionSet)) {
6064                    // We have a mismatch between instruction sets (say arm vs arm64) warn about
6065                    // this but there's not much we can do.
6066                    String errorMessage = "Instruction set mismatch, "
6067                            + ((requirer == null) ? "[caller]" : requirer)
6068                            + " requires " + requiredInstructionSet + " whereas " + ps
6069                            + " requires " + instructionSet;
6070                    Slog.w(TAG, errorMessage);
6071                }
6072
6073                if (requiredInstructionSet == null) {
6074                    requiredInstructionSet = instructionSet;
6075                    requirer = ps;
6076                }
6077            }
6078        }
6079
6080        if (requiredInstructionSet != null) {
6081            String adjustedAbi;
6082            if (requirer != null) {
6083                // requirer != null implies that either scannedPackage was null or that scannedPackage
6084                // did not require an ABI, in which case we have to adjust scannedPackage to match
6085                // the ABI of the set (which is the same as requirer's ABI)
6086                adjustedAbi = requirer.primaryCpuAbiString;
6087                if (scannedPackage != null) {
6088                    scannedPackage.applicationInfo.primaryCpuAbi = adjustedAbi;
6089                }
6090            } else {
6091                // requirer == null implies that we're updating all ABIs in the set to
6092                // match scannedPackage.
6093                adjustedAbi =  scannedPackage.applicationInfo.primaryCpuAbi;
6094            }
6095
6096            for (PackageSetting ps : packagesForUser) {
6097                if (scannedPackage == null || !scannedPackage.packageName.equals(ps.name)) {
6098                    if (ps.primaryCpuAbiString != null) {
6099                        continue;
6100                    }
6101
6102                    ps.primaryCpuAbiString = adjustedAbi;
6103                    if (ps.pkg != null && ps.pkg.applicationInfo != null) {
6104                        ps.pkg.applicationInfo.primaryCpuAbi = adjustedAbi;
6105                        Slog.i(TAG, "Adjusting ABI for : " + ps.name + " to " + adjustedAbi);
6106
6107                        if (performDexOptLI(ps.pkg, forceDexOpt, deferDexOpt, true) == DEX_OPT_FAILED) {
6108                            ps.primaryCpuAbiString = null;
6109                            ps.pkg.applicationInfo.primaryCpuAbi = null;
6110                            return;
6111                        } else {
6112                            mInstaller.rmdex(ps.codePathString, getPreferredInstructionSet());
6113                        }
6114                    }
6115                }
6116            }
6117        }
6118    }
6119
6120    private void setUpCustomResolverActivity(PackageParser.Package pkg) {
6121        synchronized (mPackages) {
6122            mResolverReplaced = true;
6123            // Set up information for custom user intent resolution activity.
6124            mResolveActivity.applicationInfo = pkg.applicationInfo;
6125            mResolveActivity.name = mCustomResolverComponentName.getClassName();
6126            mResolveActivity.packageName = pkg.applicationInfo.packageName;
6127            mResolveActivity.processName = null;
6128            mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
6129            mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS |
6130                    ActivityInfo.FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS;
6131            mResolveActivity.theme = 0;
6132            mResolveActivity.exported = true;
6133            mResolveActivity.enabled = true;
6134            mResolveInfo.activityInfo = mResolveActivity;
6135            mResolveInfo.priority = 0;
6136            mResolveInfo.preferredOrder = 0;
6137            mResolveInfo.match = 0;
6138            mResolveComponentName = mCustomResolverComponentName;
6139            Slog.i(TAG, "Replacing default ResolverActivity with custom activity: " +
6140                    mResolveComponentName);
6141        }
6142    }
6143
6144    private static String calculateApkRoot(final String codePathString) {
6145        final File codePath = new File(codePathString);
6146        final File codeRoot;
6147        if (FileUtils.contains(Environment.getRootDirectory(), codePath)) {
6148            codeRoot = Environment.getRootDirectory();
6149        } else if (FileUtils.contains(Environment.getOemDirectory(), codePath)) {
6150            codeRoot = Environment.getOemDirectory();
6151        } else if (FileUtils.contains(Environment.getVendorDirectory(), codePath)) {
6152            codeRoot = Environment.getVendorDirectory();
6153        } else {
6154            // Unrecognized code path; take its top real segment as the apk root:
6155            // e.g. /something/app/blah.apk => /something
6156            try {
6157                File f = codePath.getCanonicalFile();
6158                File parent = f.getParentFile();    // non-null because codePath is a file
6159                File tmp;
6160                while ((tmp = parent.getParentFile()) != null) {
6161                    f = parent;
6162                    parent = tmp;
6163                }
6164                codeRoot = f;
6165                Slog.w(TAG, "Unrecognized code path "
6166                        + codePath + " - using " + codeRoot);
6167            } catch (IOException e) {
6168                // Can't canonicalize the code path -- shenanigans?
6169                Slog.w(TAG, "Can't canonicalize code path " + codePath);
6170                return Environment.getRootDirectory().getPath();
6171            }
6172        }
6173        return codeRoot.getPath();
6174    }
6175
6176    /**
6177     * Derive and set the location of native libraries for the given package,
6178     * which varies depending on where and how the package was installed.
6179     */
6180    private void setNativeLibraryPaths(PackageParser.Package pkg) {
6181        final ApplicationInfo info = pkg.applicationInfo;
6182        final String codePath = pkg.codePath;
6183        final File codeFile = new File(codePath);
6184        // If "/system/lib64/apkname" exists, assume that is the per-package
6185        // native library directory to use; otherwise use "/system/lib/apkname".
6186        final String apkRoot = calculateApkRoot(info.sourceDir);
6187
6188        final boolean bundledApp = isSystemApp(info) && !isUpdatedSystemApp(info);
6189        final boolean asecApp = isForwardLocked(info) || isExternal(info);
6190
6191
6192        info.nativeLibraryRootDir = null;
6193        info.nativeLibraryRootRequiresIsa = false;
6194        info.nativeLibraryDir = null;
6195        info.secondaryNativeLibraryDir = null;
6196
6197        if (bundledApp) {
6198            // Monolithic bundled install
6199            // TODO: support cluster bundled installs?
6200
6201            final boolean is64Bit = (info.primaryCpuAbi != null)
6202                    && VMRuntime.is64BitAbi(info.primaryCpuAbi);
6203
6204            // This is a bundled system app so choose the path based on the ABI.
6205            // if it's a 64 bit abi, use lib64 otherwise use lib32. Note that this
6206            // is just the default path.
6207            final String apkName = deriveCodePathName(codePath);
6208            final String libDir = is64Bit ? LIB64_DIR_NAME : LIB_DIR_NAME;
6209            info.nativeLibraryRootDir = Environment.buildPath(new File(apkRoot), libDir,
6210                    apkName).getAbsolutePath();
6211            info.nativeLibraryRootRequiresIsa = false;
6212
6213            info.nativeLibraryDir = info.nativeLibraryRootDir;
6214            if (info.secondaryCpuAbi != null) {
6215                final String secondaryLibDir = is64Bit ? LIB_DIR_NAME : LIB64_DIR_NAME;
6216                info.secondaryNativeLibraryDir = Environment.buildPath(new File(apkRoot),
6217                        secondaryLibDir, apkName).getAbsolutePath();
6218            }
6219        } else if (isApkFile(codeFile)) {
6220            // Monolithic install
6221            if (asecApp) {
6222                info.nativeLibraryRootDir = new File(codeFile.getParentFile(), LIB_DIR_NAME)
6223                        .getAbsolutePath();
6224            } else {
6225                final String apkName = deriveCodePathName(codePath);
6226                info.nativeLibraryRootDir = new File(mAppLib32InstallDir, apkName)
6227                        .getAbsolutePath();
6228            }
6229
6230            info.nativeLibraryRootRequiresIsa = false;
6231            info.nativeLibraryDir = info.nativeLibraryRootDir;
6232        } else {
6233            // Cluster install
6234            info.nativeLibraryRootDir = new File(codeFile, LIB_DIR_NAME).getAbsolutePath();
6235            info.nativeLibraryRootRequiresIsa = true;
6236
6237            if (info.primaryCpuAbi != null) {
6238                info.nativeLibraryDir = new File(info.nativeLibraryRootDir,
6239                        VMRuntime.getInstructionSet(info.primaryCpuAbi)).getAbsolutePath();
6240            }
6241
6242            if (info.secondaryCpuAbi != null) {
6243                info.secondaryNativeLibraryDir = new File(info.nativeLibraryRootDir,
6244                        VMRuntime.getInstructionSet(info.secondaryCpuAbi)).getAbsolutePath();
6245            }
6246        }
6247    }
6248
6249    /**
6250     * Calculate the abis and roots for a bundled app. These can uniquely
6251     * be determined from the contents of the system partition, i.e whether
6252     * it contains 64 or 32 bit shared libraries etc. We do not validate any
6253     * of this information, and instead assume that the system was built
6254     * sensibly.
6255     */
6256    private void setBundledAppAbisAndRoots(PackageParser.Package pkg,
6257                                           PackageSetting pkgSetting) {
6258        final String apkName = deriveCodePathName(pkg.applicationInfo.getCodePath());
6259
6260        // If "/system/lib64/apkname" exists, assume that is the per-package
6261        // native library directory to use; otherwise use "/system/lib/apkname".
6262        final String apkRoot = calculateApkRoot(pkg.applicationInfo.sourceDir);
6263        setBundledAppAbi(pkg, apkRoot, apkName);
6264        // pkgSetting might be null during rescan following uninstall of updates
6265        // to a bundled app, so accommodate that possibility.  The settings in
6266        // that case will be established later from the parsed package.
6267        //
6268        // If the settings aren't null, sync them up with what we've just derived.
6269        // note that apkRoot isn't stored in the package settings.
6270        if (pkgSetting != null) {
6271            pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
6272            pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
6273        }
6274    }
6275
6276    /**
6277     * Deduces the ABI of a bundled app and sets the relevant fields on the
6278     * parsed pkg object.
6279     *
6280     * @param apkRoot the root of the installed apk, something like {@code /system} or {@code /oem}
6281     *        under which system libraries are installed.
6282     * @param apkName the name of the installed package.
6283     */
6284    private static void setBundledAppAbi(PackageParser.Package pkg, String apkRoot, String apkName) {
6285        // This is of the form "/system/lib64/<packagename>", "/vendor/lib64/<packagename>"
6286        // or similar.
6287        final boolean has64BitLibs = (new File(apkRoot, new File(LIB64_DIR_NAME, apkName).getPath())).exists();
6288        final boolean has32BitLibs = (new File(apkRoot, new File(LIB_DIR_NAME, apkName).getPath())).exists();
6289
6290        if (has64BitLibs && !has32BitLibs) {
6291            // The package has 64 bit libs, but not 32 bit libs. Its primary
6292            // ABI should be 64 bit. We can safely assume here that the bundled
6293            // native libraries correspond to the most preferred ABI in the list.
6294
6295            pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6296            pkg.applicationInfo.secondaryCpuAbi = null;
6297        } else if (has32BitLibs && !has64BitLibs) {
6298            // The package has 32 bit libs but not 64 bit libs. Its primary
6299            // ABI should be 32 bit.
6300
6301            pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6302            pkg.applicationInfo.secondaryCpuAbi = null;
6303        } else if (has32BitLibs && has64BitLibs) {
6304            // The application has both 64 and 32 bit bundled libraries. We check
6305            // here that the app declares multiArch support, and warn if it doesn't.
6306            //
6307            // We will be lenient here and record both ABIs. The primary will be the
6308            // ABI that's higher on the list, i.e, a device that's configured to prefer
6309            // 64 bit apps will see a 64 bit primary ABI,
6310
6311            if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_MULTIARCH) == 0) {
6312                Slog.e(TAG, "Package: " + pkg + " has multiple bundled libs, but is not multiarch.");
6313            }
6314
6315            if (VMRuntime.is64BitInstructionSet(getPreferredInstructionSet())) {
6316                pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6317                pkg.applicationInfo.secondaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6318            } else {
6319                pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6320                pkg.applicationInfo.secondaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6321            }
6322        } else {
6323            pkg.applicationInfo.primaryCpuAbi = null;
6324            pkg.applicationInfo.secondaryCpuAbi = null;
6325        }
6326    }
6327
6328    private static void createNativeLibrarySubdir(File path) throws IOException {
6329        if (!path.isDirectory()) {
6330            path.delete();
6331
6332            if (!path.mkdir()) {
6333                throw new IOException("Cannot create " + path.getPath());
6334            }
6335
6336            try {
6337                Os.chmod(path.getPath(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
6338            } catch (ErrnoException e) {
6339                throw new IOException("Cannot chmod native library directory "
6340                        + path.getPath(), e);
6341            }
6342        } else if (!SELinux.restorecon(path)) {
6343            throw new IOException("Cannot set SELinux context for " + path.getPath());
6344        }
6345    }
6346
6347    private static int copyNativeLibrariesForInternalApp(NativeLibraryHelper.Handle handle,
6348            final File nativeLibraryRoot, String[] abiList, boolean useIsaSubdir) throws IOException {
6349        createNativeLibrarySubdir(nativeLibraryRoot);
6350
6351        /*
6352         * If this is an internal application or our nativeLibraryPath points to
6353         * the app-lib directory, unpack the libraries if necessary.
6354         */
6355        int abi = NativeLibraryHelper.findSupportedAbi(handle, abiList);
6356        if (abi >= 0) {
6357            /*
6358             * If we have a matching instruction set, construct a subdir under the native
6359             * library root that corresponds to this instruction set.
6360             */
6361            final String instructionSet = VMRuntime.getInstructionSet(abiList[abi]);
6362            final File subDir;
6363            if (useIsaSubdir) {
6364                final File isaSubdir = new File(nativeLibraryRoot, instructionSet);
6365                createNativeLibrarySubdir(isaSubdir);
6366                subDir = isaSubdir;
6367            } else {
6368                subDir = nativeLibraryRoot;
6369            }
6370
6371            int copyRet = NativeLibraryHelper.copyNativeBinariesIfNeededLI(handle, subDir, abiList[abi]);
6372            if (copyRet != PackageManager.INSTALL_SUCCEEDED) {
6373                return copyRet;
6374            }
6375        }
6376
6377        return abi;
6378    }
6379
6380    private void killApplication(String pkgName, int appId, String reason) {
6381        // Request the ActivityManager to kill the process(only for existing packages)
6382        // so that we do not end up in a confused state while the user is still using the older
6383        // version of the application while the new one gets installed.
6384        IActivityManager am = ActivityManagerNative.getDefault();
6385        if (am != null) {
6386            try {
6387                am.killApplicationWithAppId(pkgName, appId, reason);
6388            } catch (RemoteException e) {
6389            }
6390        }
6391    }
6392
6393    void removePackageLI(PackageSetting ps, boolean chatty) {
6394        if (DEBUG_INSTALL) {
6395            if (chatty)
6396                Log.d(TAG, "Removing package " + ps.name);
6397        }
6398
6399        // writer
6400        synchronized (mPackages) {
6401            mPackages.remove(ps.name);
6402            if (ps.codePathString != null) {
6403                mAppDirs.remove(ps.codePathString);
6404            }
6405
6406            final PackageParser.Package pkg = ps.pkg;
6407            if (pkg != null) {
6408                cleanPackageDataStructuresLILPw(pkg, chatty);
6409            }
6410        }
6411    }
6412
6413    void removeInstalledPackageLI(PackageParser.Package pkg, boolean chatty) {
6414        if (DEBUG_INSTALL) {
6415            if (chatty)
6416                Log.d(TAG, "Removing package " + pkg.applicationInfo.packageName);
6417        }
6418
6419        // writer
6420        synchronized (mPackages) {
6421            mPackages.remove(pkg.applicationInfo.packageName);
6422            if (pkg.codePath != null) {
6423                mAppDirs.remove(pkg.codePath);
6424            }
6425            cleanPackageDataStructuresLILPw(pkg, chatty);
6426        }
6427    }
6428
6429    void cleanPackageDataStructuresLILPw(PackageParser.Package pkg, boolean chatty) {
6430        int N = pkg.providers.size();
6431        StringBuilder r = null;
6432        int i;
6433        for (i=0; i<N; i++) {
6434            PackageParser.Provider p = pkg.providers.get(i);
6435            mProviders.removeProvider(p);
6436            if (p.info.authority == null) {
6437
6438                /* There was another ContentProvider with this authority when
6439                 * this app was installed so this authority is null,
6440                 * Ignore it as we don't have to unregister the provider.
6441                 */
6442                continue;
6443            }
6444            String names[] = p.info.authority.split(";");
6445            for (int j = 0; j < names.length; j++) {
6446                if (mProvidersByAuthority.get(names[j]) == p) {
6447                    mProvidersByAuthority.remove(names[j]);
6448                    if (DEBUG_REMOVE) {
6449                        if (chatty)
6450                            Log.d(TAG, "Unregistered content provider: " + names[j]
6451                                    + ", className = " + p.info.name + ", isSyncable = "
6452                                    + p.info.isSyncable);
6453                    }
6454                }
6455            }
6456            if (DEBUG_REMOVE && chatty) {
6457                if (r == null) {
6458                    r = new StringBuilder(256);
6459                } else {
6460                    r.append(' ');
6461                }
6462                r.append(p.info.name);
6463            }
6464        }
6465        if (r != null) {
6466            if (DEBUG_REMOVE) Log.d(TAG, "  Providers: " + r);
6467        }
6468
6469        N = pkg.services.size();
6470        r = null;
6471        for (i=0; i<N; i++) {
6472            PackageParser.Service s = pkg.services.get(i);
6473            mServices.removeService(s);
6474            if (chatty) {
6475                if (r == null) {
6476                    r = new StringBuilder(256);
6477                } else {
6478                    r.append(' ');
6479                }
6480                r.append(s.info.name);
6481            }
6482        }
6483        if (r != null) {
6484            if (DEBUG_REMOVE) Log.d(TAG, "  Services: " + r);
6485        }
6486
6487        N = pkg.receivers.size();
6488        r = null;
6489        for (i=0; i<N; i++) {
6490            PackageParser.Activity a = pkg.receivers.get(i);
6491            mReceivers.removeActivity(a, "receiver");
6492            if (DEBUG_REMOVE && chatty) {
6493                if (r == null) {
6494                    r = new StringBuilder(256);
6495                } else {
6496                    r.append(' ');
6497                }
6498                r.append(a.info.name);
6499            }
6500        }
6501        if (r != null) {
6502            if (DEBUG_REMOVE) Log.d(TAG, "  Receivers: " + r);
6503        }
6504
6505        N = pkg.activities.size();
6506        r = null;
6507        for (i=0; i<N; i++) {
6508            PackageParser.Activity a = pkg.activities.get(i);
6509            mActivities.removeActivity(a, "activity");
6510            if (DEBUG_REMOVE && chatty) {
6511                if (r == null) {
6512                    r = new StringBuilder(256);
6513                } else {
6514                    r.append(' ');
6515                }
6516                r.append(a.info.name);
6517            }
6518        }
6519        if (r != null) {
6520            if (DEBUG_REMOVE) Log.d(TAG, "  Activities: " + r);
6521        }
6522
6523        N = pkg.permissions.size();
6524        r = null;
6525        for (i=0; i<N; i++) {
6526            PackageParser.Permission p = pkg.permissions.get(i);
6527            BasePermission bp = mSettings.mPermissions.get(p.info.name);
6528            if (bp == null) {
6529                bp = mSettings.mPermissionTrees.get(p.info.name);
6530            }
6531            if (bp != null && bp.perm == p) {
6532                bp.perm = null;
6533                if (DEBUG_REMOVE && chatty) {
6534                    if (r == null) {
6535                        r = new StringBuilder(256);
6536                    } else {
6537                        r.append(' ');
6538                    }
6539                    r.append(p.info.name);
6540                }
6541            }
6542        }
6543        if (r != null) {
6544            if (DEBUG_REMOVE) Log.d(TAG, "  Permissions: " + r);
6545        }
6546
6547        N = pkg.instrumentation.size();
6548        r = null;
6549        for (i=0; i<N; i++) {
6550            PackageParser.Instrumentation a = pkg.instrumentation.get(i);
6551            mInstrumentation.remove(a.getComponentName());
6552            if (DEBUG_REMOVE && chatty) {
6553                if (r == null) {
6554                    r = new StringBuilder(256);
6555                } else {
6556                    r.append(' ');
6557                }
6558                r.append(a.info.name);
6559            }
6560        }
6561        if (r != null) {
6562            if (DEBUG_REMOVE) Log.d(TAG, "  Instrumentation: " + r);
6563        }
6564
6565        r = null;
6566        if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
6567            // Only system apps can hold shared libraries.
6568            if (pkg.libraryNames != null) {
6569                for (i=0; i<pkg.libraryNames.size(); i++) {
6570                    String name = pkg.libraryNames.get(i);
6571                    SharedLibraryEntry cur = mSharedLibraries.get(name);
6572                    if (cur != null && cur.apk != null && cur.apk.equals(pkg.packageName)) {
6573                        mSharedLibraries.remove(name);
6574                        if (DEBUG_REMOVE && chatty) {
6575                            if (r == null) {
6576                                r = new StringBuilder(256);
6577                            } else {
6578                                r.append(' ');
6579                            }
6580                            r.append(name);
6581                        }
6582                    }
6583                }
6584            }
6585        }
6586        if (r != null) {
6587            if (DEBUG_REMOVE) Log.d(TAG, "  Libraries: " + r);
6588        }
6589    }
6590
6591    private static boolean hasPermission(PackageParser.Package pkgInfo, String perm) {
6592        for (int i=pkgInfo.permissions.size()-1; i>=0; i--) {
6593            if (pkgInfo.permissions.get(i).info.name.equals(perm)) {
6594                return true;
6595            }
6596        }
6597        return false;
6598    }
6599
6600    static final int UPDATE_PERMISSIONS_ALL = 1<<0;
6601    static final int UPDATE_PERMISSIONS_REPLACE_PKG = 1<<1;
6602    static final int UPDATE_PERMISSIONS_REPLACE_ALL = 1<<2;
6603
6604    private void updatePermissionsLPw(String changingPkg,
6605            PackageParser.Package pkgInfo, int flags) {
6606        // Make sure there are no dangling permission trees.
6607        Iterator<BasePermission> it = mSettings.mPermissionTrees.values().iterator();
6608        while (it.hasNext()) {
6609            final BasePermission bp = it.next();
6610            if (bp.packageSetting == null) {
6611                // We may not yet have parsed the package, so just see if
6612                // we still know about its settings.
6613                bp.packageSetting = mSettings.mPackages.get(bp.sourcePackage);
6614            }
6615            if (bp.packageSetting == null) {
6616                Slog.w(TAG, "Removing dangling permission tree: " + bp.name
6617                        + " from package " + bp.sourcePackage);
6618                it.remove();
6619            } else if (changingPkg != null && changingPkg.equals(bp.sourcePackage)) {
6620                if (pkgInfo == null || !hasPermission(pkgInfo, bp.name)) {
6621                    Slog.i(TAG, "Removing old permission tree: " + bp.name
6622                            + " from package " + bp.sourcePackage);
6623                    flags |= UPDATE_PERMISSIONS_ALL;
6624                    it.remove();
6625                }
6626            }
6627        }
6628
6629        // Make sure all dynamic permissions have been assigned to a package,
6630        // and make sure there are no dangling permissions.
6631        it = mSettings.mPermissions.values().iterator();
6632        while (it.hasNext()) {
6633            final BasePermission bp = it.next();
6634            if (bp.type == BasePermission.TYPE_DYNAMIC) {
6635                if (DEBUG_SETTINGS) Log.v(TAG, "Dynamic permission: name="
6636                        + bp.name + " pkg=" + bp.sourcePackage
6637                        + " info=" + bp.pendingInfo);
6638                if (bp.packageSetting == null && bp.pendingInfo != null) {
6639                    final BasePermission tree = findPermissionTreeLP(bp.name);
6640                    if (tree != null && tree.perm != null) {
6641                        bp.packageSetting = tree.packageSetting;
6642                        bp.perm = new PackageParser.Permission(tree.perm.owner,
6643                                new PermissionInfo(bp.pendingInfo));
6644                        bp.perm.info.packageName = tree.perm.info.packageName;
6645                        bp.perm.info.name = bp.name;
6646                        bp.uid = tree.uid;
6647                    }
6648                }
6649            }
6650            if (bp.packageSetting == null) {
6651                // We may not yet have parsed the package, so just see if
6652                // we still know about its settings.
6653                bp.packageSetting = mSettings.mPackages.get(bp.sourcePackage);
6654            }
6655            if (bp.packageSetting == null) {
6656                Slog.w(TAG, "Removing dangling permission: " + bp.name
6657                        + " from package " + bp.sourcePackage);
6658                it.remove();
6659            } else if (changingPkg != null && changingPkg.equals(bp.sourcePackage)) {
6660                if (pkgInfo == null || !hasPermission(pkgInfo, bp.name)) {
6661                    Slog.i(TAG, "Removing old permission: " + bp.name
6662                            + " from package " + bp.sourcePackage);
6663                    flags |= UPDATE_PERMISSIONS_ALL;
6664                    it.remove();
6665                }
6666            }
6667        }
6668
6669        // Now update the permissions for all packages, in particular
6670        // replace the granted permissions of the system packages.
6671        if ((flags&UPDATE_PERMISSIONS_ALL) != 0) {
6672            for (PackageParser.Package pkg : mPackages.values()) {
6673                if (pkg != pkgInfo) {
6674                    grantPermissionsLPw(pkg, (flags&UPDATE_PERMISSIONS_REPLACE_ALL) != 0);
6675                }
6676            }
6677        }
6678
6679        if (pkgInfo != null) {
6680            grantPermissionsLPw(pkgInfo, (flags&UPDATE_PERMISSIONS_REPLACE_PKG) != 0);
6681        }
6682    }
6683
6684    private void grantPermissionsLPw(PackageParser.Package pkg, boolean replace) {
6685        final PackageSetting ps = (PackageSetting) pkg.mExtras;
6686        if (ps == null) {
6687            return;
6688        }
6689        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
6690        HashSet<String> origPermissions = gp.grantedPermissions;
6691        boolean changedPermission = false;
6692
6693        if (replace) {
6694            ps.permissionsFixed = false;
6695            if (gp == ps) {
6696                origPermissions = new HashSet<String>(gp.grantedPermissions);
6697                gp.grantedPermissions.clear();
6698                gp.gids = mGlobalGids;
6699            }
6700        }
6701
6702        if (gp.gids == null) {
6703            gp.gids = mGlobalGids;
6704        }
6705
6706        final int N = pkg.requestedPermissions.size();
6707        for (int i=0; i<N; i++) {
6708            final String name = pkg.requestedPermissions.get(i);
6709            final boolean required = pkg.requestedPermissionsRequired.get(i);
6710            final BasePermission bp = mSettings.mPermissions.get(name);
6711            if (DEBUG_INSTALL) {
6712                if (gp != ps) {
6713                    Log.i(TAG, "Package " + pkg.packageName + " checking " + name + ": " + bp);
6714                }
6715            }
6716
6717            if (bp == null || bp.packageSetting == null) {
6718                Slog.w(TAG, "Unknown permission " + name
6719                        + " in package " + pkg.packageName);
6720                continue;
6721            }
6722
6723            final String perm = bp.name;
6724            boolean allowed;
6725            boolean allowedSig = false;
6726            final int level = bp.protectionLevel & PermissionInfo.PROTECTION_MASK_BASE;
6727            if (level == PermissionInfo.PROTECTION_NORMAL
6728                    || level == PermissionInfo.PROTECTION_DANGEROUS) {
6729                // We grant a normal or dangerous permission if any of the following
6730                // are true:
6731                // 1) The permission is required
6732                // 2) The permission is optional, but was granted in the past
6733                // 3) The permission is optional, but was requested by an
6734                //    app in /system (not /data)
6735                //
6736                // Otherwise, reject the permission.
6737                allowed = (required || origPermissions.contains(perm)
6738                        || (isSystemApp(ps) && !isUpdatedSystemApp(ps)));
6739            } else if (bp.packageSetting == null) {
6740                // This permission is invalid; skip it.
6741                allowed = false;
6742            } else if (level == PermissionInfo.PROTECTION_SIGNATURE) {
6743                allowed = grantSignaturePermission(perm, pkg, bp, origPermissions);
6744                if (allowed) {
6745                    allowedSig = true;
6746                }
6747            } else {
6748                allowed = false;
6749            }
6750            if (DEBUG_INSTALL) {
6751                if (gp != ps) {
6752                    Log.i(TAG, "Package " + pkg.packageName + " granting " + perm);
6753                }
6754            }
6755            if (allowed) {
6756                if (!isSystemApp(ps) && ps.permissionsFixed) {
6757                    // If this is an existing, non-system package, then
6758                    // we can't add any new permissions to it.
6759                    if (!allowedSig && !gp.grantedPermissions.contains(perm)) {
6760                        // Except...  if this is a permission that was added
6761                        // to the platform (note: need to only do this when
6762                        // updating the platform).
6763                        allowed = isNewPlatformPermissionForPackage(perm, pkg);
6764                    }
6765                }
6766                if (allowed) {
6767                    if (!gp.grantedPermissions.contains(perm)) {
6768                        changedPermission = true;
6769                        gp.grantedPermissions.add(perm);
6770                        gp.gids = appendInts(gp.gids, bp.gids);
6771                    } else if (!ps.haveGids) {
6772                        gp.gids = appendInts(gp.gids, bp.gids);
6773                    }
6774                } else {
6775                    Slog.w(TAG, "Not granting permission " + perm
6776                            + " to package " + pkg.packageName
6777                            + " because it was previously installed without");
6778                }
6779            } else {
6780                if (gp.grantedPermissions.remove(perm)) {
6781                    changedPermission = true;
6782                    gp.gids = removeInts(gp.gids, bp.gids);
6783                    Slog.i(TAG, "Un-granting permission " + perm
6784                            + " from package " + pkg.packageName
6785                            + " (protectionLevel=" + bp.protectionLevel
6786                            + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags)
6787                            + ")");
6788                } else {
6789                    Slog.w(TAG, "Not granting permission " + perm
6790                            + " to package " + pkg.packageName
6791                            + " (protectionLevel=" + bp.protectionLevel
6792                            + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags)
6793                            + ")");
6794                }
6795            }
6796        }
6797
6798        if ((changedPermission || replace) && !ps.permissionsFixed &&
6799                !isSystemApp(ps) || isUpdatedSystemApp(ps)){
6800            // This is the first that we have heard about this package, so the
6801            // permissions we have now selected are fixed until explicitly
6802            // changed.
6803            ps.permissionsFixed = true;
6804        }
6805        ps.haveGids = true;
6806    }
6807
6808    private boolean isNewPlatformPermissionForPackage(String perm, PackageParser.Package pkg) {
6809        boolean allowed = false;
6810        final int NP = PackageParser.NEW_PERMISSIONS.length;
6811        for (int ip=0; ip<NP; ip++) {
6812            final PackageParser.NewPermissionInfo npi
6813                    = PackageParser.NEW_PERMISSIONS[ip];
6814            if (npi.name.equals(perm)
6815                    && pkg.applicationInfo.targetSdkVersion < npi.sdkVersion) {
6816                allowed = true;
6817                Log.i(TAG, "Auto-granting " + perm + " to old pkg "
6818                        + pkg.packageName);
6819                break;
6820            }
6821        }
6822        return allowed;
6823    }
6824
6825    private boolean grantSignaturePermission(String perm, PackageParser.Package pkg,
6826                                          BasePermission bp, HashSet<String> origPermissions) {
6827        boolean allowed;
6828        allowed = (compareSignatures(
6829                bp.packageSetting.signatures.mSignatures, pkg.mSignatures)
6830                        == PackageManager.SIGNATURE_MATCH)
6831                || (compareSignatures(mPlatformPackage.mSignatures, pkg.mSignatures)
6832                        == PackageManager.SIGNATURE_MATCH);
6833        if (!allowed && (bp.protectionLevel
6834                & PermissionInfo.PROTECTION_FLAG_SYSTEM) != 0) {
6835            if (isSystemApp(pkg)) {
6836                // For updated system applications, a system permission
6837                // is granted only if it had been defined by the original application.
6838                if (isUpdatedSystemApp(pkg)) {
6839                    final PackageSetting sysPs = mSettings
6840                            .getDisabledSystemPkgLPr(pkg.packageName);
6841                    final GrantedPermissions origGp = sysPs.sharedUser != null
6842                            ? sysPs.sharedUser : sysPs;
6843
6844                    if (origGp.grantedPermissions.contains(perm)) {
6845                        // If the original was granted this permission, we take
6846                        // that grant decision as read and propagate it to the
6847                        // update.
6848                        allowed = true;
6849                    } else {
6850                        // The system apk may have been updated with an older
6851                        // version of the one on the data partition, but which
6852                        // granted a new system permission that it didn't have
6853                        // before.  In this case we do want to allow the app to
6854                        // now get the new permission if the ancestral apk is
6855                        // privileged to get it.
6856                        if (sysPs.pkg != null && sysPs.isPrivileged()) {
6857                            for (int j=0;
6858                                    j<sysPs.pkg.requestedPermissions.size(); j++) {
6859                                if (perm.equals(
6860                                        sysPs.pkg.requestedPermissions.get(j))) {
6861                                    allowed = true;
6862                                    break;
6863                                }
6864                            }
6865                        }
6866                    }
6867                } else {
6868                    allowed = isPrivilegedApp(pkg);
6869                }
6870            }
6871        }
6872        if (!allowed && (bp.protectionLevel
6873                & PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0) {
6874            // For development permissions, a development permission
6875            // is granted only if it was already granted.
6876            allowed = origPermissions.contains(perm);
6877        }
6878        return allowed;
6879    }
6880
6881    final class ActivityIntentResolver
6882            extends IntentResolver<PackageParser.ActivityIntentInfo, ResolveInfo> {
6883        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
6884                boolean defaultOnly, int userId) {
6885            if (!sUserManager.exists(userId)) return null;
6886            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
6887            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
6888        }
6889
6890        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
6891                int userId) {
6892            if (!sUserManager.exists(userId)) return null;
6893            mFlags = flags;
6894            return super.queryIntent(intent, resolvedType,
6895                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
6896        }
6897
6898        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
6899                int flags, ArrayList<PackageParser.Activity> packageActivities, int userId) {
6900            if (!sUserManager.exists(userId)) return null;
6901            if (packageActivities == null) {
6902                return null;
6903            }
6904            mFlags = flags;
6905            final boolean defaultOnly = (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0;
6906            final int N = packageActivities.size();
6907            ArrayList<PackageParser.ActivityIntentInfo[]> listCut =
6908                new ArrayList<PackageParser.ActivityIntentInfo[]>(N);
6909
6910            ArrayList<PackageParser.ActivityIntentInfo> intentFilters;
6911            for (int i = 0; i < N; ++i) {
6912                intentFilters = packageActivities.get(i).intents;
6913                if (intentFilters != null && intentFilters.size() > 0) {
6914                    PackageParser.ActivityIntentInfo[] array =
6915                            new PackageParser.ActivityIntentInfo[intentFilters.size()];
6916                    intentFilters.toArray(array);
6917                    listCut.add(array);
6918                }
6919            }
6920            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
6921        }
6922
6923        public final void addActivity(PackageParser.Activity a, String type) {
6924            final boolean systemApp = isSystemApp(a.info.applicationInfo);
6925            mActivities.put(a.getComponentName(), a);
6926            if (DEBUG_SHOW_INFO)
6927                Log.v(
6928                TAG, "  " + type + " " +
6929                (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel : a.info.name) + ":");
6930            if (DEBUG_SHOW_INFO)
6931                Log.v(TAG, "    Class=" + a.info.name);
6932            final int NI = a.intents.size();
6933            for (int j=0; j<NI; j++) {
6934                PackageParser.ActivityIntentInfo intent = a.intents.get(j);
6935                if (!systemApp && intent.getPriority() > 0 && "activity".equals(type)) {
6936                    intent.setPriority(0);
6937                    Log.w(TAG, "Package " + a.info.applicationInfo.packageName + " has activity "
6938                            + a.className + " with priority > 0, forcing to 0");
6939                }
6940                if (DEBUG_SHOW_INFO) {
6941                    Log.v(TAG, "    IntentFilter:");
6942                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
6943                }
6944                if (!intent.debugCheck()) {
6945                    Log.w(TAG, "==> For Activity " + a.info.name);
6946                }
6947                addFilter(intent);
6948            }
6949        }
6950
6951        public final void removeActivity(PackageParser.Activity a, String type) {
6952            mActivities.remove(a.getComponentName());
6953            if (DEBUG_SHOW_INFO) {
6954                Log.v(TAG, "  " + type + " "
6955                        + (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel
6956                                : a.info.name) + ":");
6957                Log.v(TAG, "    Class=" + a.info.name);
6958            }
6959            final int NI = a.intents.size();
6960            for (int j=0; j<NI; j++) {
6961                PackageParser.ActivityIntentInfo intent = a.intents.get(j);
6962                if (DEBUG_SHOW_INFO) {
6963                    Log.v(TAG, "    IntentFilter:");
6964                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
6965                }
6966                removeFilter(intent);
6967            }
6968        }
6969
6970        @Override
6971        protected boolean allowFilterResult(
6972                PackageParser.ActivityIntentInfo filter, List<ResolveInfo> dest) {
6973            ActivityInfo filterAi = filter.activity.info;
6974            for (int i=dest.size()-1; i>=0; i--) {
6975                ActivityInfo destAi = dest.get(i).activityInfo;
6976                if (destAi.name == filterAi.name
6977                        && destAi.packageName == filterAi.packageName) {
6978                    return false;
6979                }
6980            }
6981            return true;
6982        }
6983
6984        @Override
6985        protected ActivityIntentInfo[] newArray(int size) {
6986            return new ActivityIntentInfo[size];
6987        }
6988
6989        @Override
6990        protected boolean isFilterStopped(PackageParser.ActivityIntentInfo filter, int userId) {
6991            if (!sUserManager.exists(userId)) return true;
6992            PackageParser.Package p = filter.activity.owner;
6993            if (p != null) {
6994                PackageSetting ps = (PackageSetting)p.mExtras;
6995                if (ps != null) {
6996                    // System apps are never considered stopped for purposes of
6997                    // filtering, because there may be no way for the user to
6998                    // actually re-launch them.
6999                    return (ps.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0
7000                            && ps.getStopped(userId);
7001                }
7002            }
7003            return false;
7004        }
7005
7006        @Override
7007        protected boolean isPackageForFilter(String packageName,
7008                PackageParser.ActivityIntentInfo info) {
7009            return packageName.equals(info.activity.owner.packageName);
7010        }
7011
7012        @Override
7013        protected ResolveInfo newResult(PackageParser.ActivityIntentInfo info,
7014                int match, int userId) {
7015            if (!sUserManager.exists(userId)) return null;
7016            if (!mSettings.isEnabledLPr(info.activity.info, mFlags, userId)) {
7017                return null;
7018            }
7019            final PackageParser.Activity activity = info.activity;
7020            if (mSafeMode && (activity.info.applicationInfo.flags
7021                    &ApplicationInfo.FLAG_SYSTEM) == 0) {
7022                return null;
7023            }
7024            PackageSetting ps = (PackageSetting) activity.owner.mExtras;
7025            if (ps == null) {
7026                return null;
7027            }
7028            ActivityInfo ai = PackageParser.generateActivityInfo(activity, mFlags,
7029                    ps.readUserState(userId), userId);
7030            if (ai == null) {
7031                return null;
7032            }
7033            final ResolveInfo res = new ResolveInfo();
7034            res.activityInfo = ai;
7035            if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) {
7036                res.filter = info;
7037            }
7038            res.priority = info.getPriority();
7039            res.preferredOrder = activity.owner.mPreferredOrder;
7040            //System.out.println("Result: " + res.activityInfo.className +
7041            //                   " = " + res.priority);
7042            res.match = match;
7043            res.isDefault = info.hasDefault;
7044            res.labelRes = info.labelRes;
7045            res.nonLocalizedLabel = info.nonLocalizedLabel;
7046            if (userNeedsBadging(userId)) {
7047                res.noResourceId = true;
7048            } else {
7049                res.icon = info.icon;
7050            }
7051            res.system = isSystemApp(res.activityInfo.applicationInfo);
7052            return res;
7053        }
7054
7055        @Override
7056        protected void sortResults(List<ResolveInfo> results) {
7057            Collections.sort(results, mResolvePrioritySorter);
7058        }
7059
7060        @Override
7061        protected void dumpFilter(PrintWriter out, String prefix,
7062                PackageParser.ActivityIntentInfo filter) {
7063            out.print(prefix); out.print(
7064                    Integer.toHexString(System.identityHashCode(filter.activity)));
7065                    out.print(' ');
7066                    filter.activity.printComponentShortName(out);
7067                    out.print(" filter ");
7068                    out.println(Integer.toHexString(System.identityHashCode(filter)));
7069        }
7070
7071//        List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) {
7072//            final Iterator<ResolveInfo> i = resolveInfoList.iterator();
7073//            final List<ResolveInfo> retList = Lists.newArrayList();
7074//            while (i.hasNext()) {
7075//                final ResolveInfo resolveInfo = i.next();
7076//                if (isEnabledLP(resolveInfo.activityInfo)) {
7077//                    retList.add(resolveInfo);
7078//                }
7079//            }
7080//            return retList;
7081//        }
7082
7083        // Keys are String (activity class name), values are Activity.
7084        private final HashMap<ComponentName, PackageParser.Activity> mActivities
7085                = new HashMap<ComponentName, PackageParser.Activity>();
7086        private int mFlags;
7087    }
7088
7089    private final class ServiceIntentResolver
7090            extends IntentResolver<PackageParser.ServiceIntentInfo, ResolveInfo> {
7091        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
7092                boolean defaultOnly, int userId) {
7093            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
7094            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
7095        }
7096
7097        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
7098                int userId) {
7099            if (!sUserManager.exists(userId)) return null;
7100            mFlags = flags;
7101            return super.queryIntent(intent, resolvedType,
7102                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
7103        }
7104
7105        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
7106                int flags, ArrayList<PackageParser.Service> packageServices, int userId) {
7107            if (!sUserManager.exists(userId)) return null;
7108            if (packageServices == null) {
7109                return null;
7110            }
7111            mFlags = flags;
7112            final boolean defaultOnly = (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0;
7113            final int N = packageServices.size();
7114            ArrayList<PackageParser.ServiceIntentInfo[]> listCut =
7115                new ArrayList<PackageParser.ServiceIntentInfo[]>(N);
7116
7117            ArrayList<PackageParser.ServiceIntentInfo> intentFilters;
7118            for (int i = 0; i < N; ++i) {
7119                intentFilters = packageServices.get(i).intents;
7120                if (intentFilters != null && intentFilters.size() > 0) {
7121                    PackageParser.ServiceIntentInfo[] array =
7122                            new PackageParser.ServiceIntentInfo[intentFilters.size()];
7123                    intentFilters.toArray(array);
7124                    listCut.add(array);
7125                }
7126            }
7127            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
7128        }
7129
7130        public final void addService(PackageParser.Service s) {
7131            mServices.put(s.getComponentName(), s);
7132            if (DEBUG_SHOW_INFO) {
7133                Log.v(TAG, "  "
7134                        + (s.info.nonLocalizedLabel != null
7135                        ? s.info.nonLocalizedLabel : s.info.name) + ":");
7136                Log.v(TAG, "    Class=" + s.info.name);
7137            }
7138            final int NI = s.intents.size();
7139            int j;
7140            for (j=0; j<NI; j++) {
7141                PackageParser.ServiceIntentInfo intent = s.intents.get(j);
7142                if (DEBUG_SHOW_INFO) {
7143                    Log.v(TAG, "    IntentFilter:");
7144                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7145                }
7146                if (!intent.debugCheck()) {
7147                    Log.w(TAG, "==> For Service " + s.info.name);
7148                }
7149                addFilter(intent);
7150            }
7151        }
7152
7153        public final void removeService(PackageParser.Service s) {
7154            mServices.remove(s.getComponentName());
7155            if (DEBUG_SHOW_INFO) {
7156                Log.v(TAG, "  " + (s.info.nonLocalizedLabel != null
7157                        ? s.info.nonLocalizedLabel : s.info.name) + ":");
7158                Log.v(TAG, "    Class=" + s.info.name);
7159            }
7160            final int NI = s.intents.size();
7161            int j;
7162            for (j=0; j<NI; j++) {
7163                PackageParser.ServiceIntentInfo intent = s.intents.get(j);
7164                if (DEBUG_SHOW_INFO) {
7165                    Log.v(TAG, "    IntentFilter:");
7166                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7167                }
7168                removeFilter(intent);
7169            }
7170        }
7171
7172        @Override
7173        protected boolean allowFilterResult(
7174                PackageParser.ServiceIntentInfo filter, List<ResolveInfo> dest) {
7175            ServiceInfo filterSi = filter.service.info;
7176            for (int i=dest.size()-1; i>=0; i--) {
7177                ServiceInfo destAi = dest.get(i).serviceInfo;
7178                if (destAi.name == filterSi.name
7179                        && destAi.packageName == filterSi.packageName) {
7180                    return false;
7181                }
7182            }
7183            return true;
7184        }
7185
7186        @Override
7187        protected PackageParser.ServiceIntentInfo[] newArray(int size) {
7188            return new PackageParser.ServiceIntentInfo[size];
7189        }
7190
7191        @Override
7192        protected boolean isFilterStopped(PackageParser.ServiceIntentInfo filter, int userId) {
7193            if (!sUserManager.exists(userId)) return true;
7194            PackageParser.Package p = filter.service.owner;
7195            if (p != null) {
7196                PackageSetting ps = (PackageSetting)p.mExtras;
7197                if (ps != null) {
7198                    // System apps are never considered stopped for purposes of
7199                    // filtering, because there may be no way for the user to
7200                    // actually re-launch them.
7201                    return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0
7202                            && ps.getStopped(userId);
7203                }
7204            }
7205            return false;
7206        }
7207
7208        @Override
7209        protected boolean isPackageForFilter(String packageName,
7210                PackageParser.ServiceIntentInfo info) {
7211            return packageName.equals(info.service.owner.packageName);
7212        }
7213
7214        @Override
7215        protected ResolveInfo newResult(PackageParser.ServiceIntentInfo filter,
7216                int match, int userId) {
7217            if (!sUserManager.exists(userId)) return null;
7218            final PackageParser.ServiceIntentInfo info = (PackageParser.ServiceIntentInfo)filter;
7219            if (!mSettings.isEnabledLPr(info.service.info, mFlags, userId)) {
7220                return null;
7221            }
7222            final PackageParser.Service service = info.service;
7223            if (mSafeMode && (service.info.applicationInfo.flags
7224                    &ApplicationInfo.FLAG_SYSTEM) == 0) {
7225                return null;
7226            }
7227            PackageSetting ps = (PackageSetting) service.owner.mExtras;
7228            if (ps == null) {
7229                return null;
7230            }
7231            ServiceInfo si = PackageParser.generateServiceInfo(service, mFlags,
7232                    ps.readUserState(userId), userId);
7233            if (si == null) {
7234                return null;
7235            }
7236            final ResolveInfo res = new ResolveInfo();
7237            res.serviceInfo = si;
7238            if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) {
7239                res.filter = filter;
7240            }
7241            res.priority = info.getPriority();
7242            res.preferredOrder = service.owner.mPreferredOrder;
7243            //System.out.println("Result: " + res.activityInfo.className +
7244            //                   " = " + res.priority);
7245            res.match = match;
7246            res.isDefault = info.hasDefault;
7247            res.labelRes = info.labelRes;
7248            res.nonLocalizedLabel = info.nonLocalizedLabel;
7249            res.icon = info.icon;
7250            res.system = isSystemApp(res.serviceInfo.applicationInfo);
7251            return res;
7252        }
7253
7254        @Override
7255        protected void sortResults(List<ResolveInfo> results) {
7256            Collections.sort(results, mResolvePrioritySorter);
7257        }
7258
7259        @Override
7260        protected void dumpFilter(PrintWriter out, String prefix,
7261                PackageParser.ServiceIntentInfo filter) {
7262            out.print(prefix); out.print(
7263                    Integer.toHexString(System.identityHashCode(filter.service)));
7264                    out.print(' ');
7265                    filter.service.printComponentShortName(out);
7266                    out.print(" filter ");
7267                    out.println(Integer.toHexString(System.identityHashCode(filter)));
7268        }
7269
7270//        List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) {
7271//            final Iterator<ResolveInfo> i = resolveInfoList.iterator();
7272//            final List<ResolveInfo> retList = Lists.newArrayList();
7273//            while (i.hasNext()) {
7274//                final ResolveInfo resolveInfo = (ResolveInfo) i;
7275//                if (isEnabledLP(resolveInfo.serviceInfo)) {
7276//                    retList.add(resolveInfo);
7277//                }
7278//            }
7279//            return retList;
7280//        }
7281
7282        // Keys are String (activity class name), values are Activity.
7283        private final HashMap<ComponentName, PackageParser.Service> mServices
7284                = new HashMap<ComponentName, PackageParser.Service>();
7285        private int mFlags;
7286    };
7287
7288    private final class ProviderIntentResolver
7289            extends IntentResolver<PackageParser.ProviderIntentInfo, ResolveInfo> {
7290        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
7291                boolean defaultOnly, int userId) {
7292            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
7293            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
7294        }
7295
7296        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
7297                int userId) {
7298            if (!sUserManager.exists(userId))
7299                return null;
7300            mFlags = flags;
7301            return super.queryIntent(intent, resolvedType,
7302                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
7303        }
7304
7305        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
7306                int flags, ArrayList<PackageParser.Provider> packageProviders, int userId) {
7307            if (!sUserManager.exists(userId))
7308                return null;
7309            if (packageProviders == null) {
7310                return null;
7311            }
7312            mFlags = flags;
7313            final boolean defaultOnly = (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0;
7314            final int N = packageProviders.size();
7315            ArrayList<PackageParser.ProviderIntentInfo[]> listCut =
7316                    new ArrayList<PackageParser.ProviderIntentInfo[]>(N);
7317
7318            ArrayList<PackageParser.ProviderIntentInfo> intentFilters;
7319            for (int i = 0; i < N; ++i) {
7320                intentFilters = packageProviders.get(i).intents;
7321                if (intentFilters != null && intentFilters.size() > 0) {
7322                    PackageParser.ProviderIntentInfo[] array =
7323                            new PackageParser.ProviderIntentInfo[intentFilters.size()];
7324                    intentFilters.toArray(array);
7325                    listCut.add(array);
7326                }
7327            }
7328            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
7329        }
7330
7331        public final void addProvider(PackageParser.Provider p) {
7332            if (mProviders.containsKey(p.getComponentName())) {
7333                Slog.w(TAG, "Provider " + p.getComponentName() + " already defined; ignoring");
7334                return;
7335            }
7336
7337            mProviders.put(p.getComponentName(), p);
7338            if (DEBUG_SHOW_INFO) {
7339                Log.v(TAG, "  "
7340                        + (p.info.nonLocalizedLabel != null
7341                                ? p.info.nonLocalizedLabel : p.info.name) + ":");
7342                Log.v(TAG, "    Class=" + p.info.name);
7343            }
7344            final int NI = p.intents.size();
7345            int j;
7346            for (j = 0; j < NI; j++) {
7347                PackageParser.ProviderIntentInfo intent = p.intents.get(j);
7348                if (DEBUG_SHOW_INFO) {
7349                    Log.v(TAG, "    IntentFilter:");
7350                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7351                }
7352                if (!intent.debugCheck()) {
7353                    Log.w(TAG, "==> For Provider " + p.info.name);
7354                }
7355                addFilter(intent);
7356            }
7357        }
7358
7359        public final void removeProvider(PackageParser.Provider p) {
7360            mProviders.remove(p.getComponentName());
7361            if (DEBUG_SHOW_INFO) {
7362                Log.v(TAG, "  " + (p.info.nonLocalizedLabel != null
7363                        ? p.info.nonLocalizedLabel : p.info.name) + ":");
7364                Log.v(TAG, "    Class=" + p.info.name);
7365            }
7366            final int NI = p.intents.size();
7367            int j;
7368            for (j = 0; j < NI; j++) {
7369                PackageParser.ProviderIntentInfo intent = p.intents.get(j);
7370                if (DEBUG_SHOW_INFO) {
7371                    Log.v(TAG, "    IntentFilter:");
7372                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7373                }
7374                removeFilter(intent);
7375            }
7376        }
7377
7378        @Override
7379        protected boolean allowFilterResult(
7380                PackageParser.ProviderIntentInfo filter, List<ResolveInfo> dest) {
7381            ProviderInfo filterPi = filter.provider.info;
7382            for (int i = dest.size() - 1; i >= 0; i--) {
7383                ProviderInfo destPi = dest.get(i).providerInfo;
7384                if (destPi.name == filterPi.name
7385                        && destPi.packageName == filterPi.packageName) {
7386                    return false;
7387                }
7388            }
7389            return true;
7390        }
7391
7392        @Override
7393        protected PackageParser.ProviderIntentInfo[] newArray(int size) {
7394            return new PackageParser.ProviderIntentInfo[size];
7395        }
7396
7397        @Override
7398        protected boolean isFilterStopped(PackageParser.ProviderIntentInfo filter, int userId) {
7399            if (!sUserManager.exists(userId))
7400                return true;
7401            PackageParser.Package p = filter.provider.owner;
7402            if (p != null) {
7403                PackageSetting ps = (PackageSetting) p.mExtras;
7404                if (ps != null) {
7405                    // System apps are never considered stopped for purposes of
7406                    // filtering, because there may be no way for the user to
7407                    // actually re-launch them.
7408                    return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0
7409                            && ps.getStopped(userId);
7410                }
7411            }
7412            return false;
7413        }
7414
7415        @Override
7416        protected boolean isPackageForFilter(String packageName,
7417                PackageParser.ProviderIntentInfo info) {
7418            return packageName.equals(info.provider.owner.packageName);
7419        }
7420
7421        @Override
7422        protected ResolveInfo newResult(PackageParser.ProviderIntentInfo filter,
7423                int match, int userId) {
7424            if (!sUserManager.exists(userId))
7425                return null;
7426            final PackageParser.ProviderIntentInfo info = filter;
7427            if (!mSettings.isEnabledLPr(info.provider.info, mFlags, userId)) {
7428                return null;
7429            }
7430            final PackageParser.Provider provider = info.provider;
7431            if (mSafeMode && (provider.info.applicationInfo.flags
7432                    & ApplicationInfo.FLAG_SYSTEM) == 0) {
7433                return null;
7434            }
7435            PackageSetting ps = (PackageSetting) provider.owner.mExtras;
7436            if (ps == null) {
7437                return null;
7438            }
7439            ProviderInfo pi = PackageParser.generateProviderInfo(provider, mFlags,
7440                    ps.readUserState(userId), userId);
7441            if (pi == null) {
7442                return null;
7443            }
7444            final ResolveInfo res = new ResolveInfo();
7445            res.providerInfo = pi;
7446            if ((mFlags & PackageManager.GET_RESOLVED_FILTER) != 0) {
7447                res.filter = filter;
7448            }
7449            res.priority = info.getPriority();
7450            res.preferredOrder = provider.owner.mPreferredOrder;
7451            res.match = match;
7452            res.isDefault = info.hasDefault;
7453            res.labelRes = info.labelRes;
7454            res.nonLocalizedLabel = info.nonLocalizedLabel;
7455            res.icon = info.icon;
7456            res.system = isSystemApp(res.providerInfo.applicationInfo);
7457            return res;
7458        }
7459
7460        @Override
7461        protected void sortResults(List<ResolveInfo> results) {
7462            Collections.sort(results, mResolvePrioritySorter);
7463        }
7464
7465        @Override
7466        protected void dumpFilter(PrintWriter out, String prefix,
7467                PackageParser.ProviderIntentInfo filter) {
7468            out.print(prefix);
7469            out.print(
7470                    Integer.toHexString(System.identityHashCode(filter.provider)));
7471            out.print(' ');
7472            filter.provider.printComponentShortName(out);
7473            out.print(" filter ");
7474            out.println(Integer.toHexString(System.identityHashCode(filter)));
7475        }
7476
7477        private final HashMap<ComponentName, PackageParser.Provider> mProviders
7478                = new HashMap<ComponentName, PackageParser.Provider>();
7479        private int mFlags;
7480    };
7481
7482    private static final Comparator<ResolveInfo> mResolvePrioritySorter =
7483            new Comparator<ResolveInfo>() {
7484        public int compare(ResolveInfo r1, ResolveInfo r2) {
7485            int v1 = r1.priority;
7486            int v2 = r2.priority;
7487            //System.out.println("Comparing: q1=" + q1 + " q2=" + q2);
7488            if (v1 != v2) {
7489                return (v1 > v2) ? -1 : 1;
7490            }
7491            v1 = r1.preferredOrder;
7492            v2 = r2.preferredOrder;
7493            if (v1 != v2) {
7494                return (v1 > v2) ? -1 : 1;
7495            }
7496            if (r1.isDefault != r2.isDefault) {
7497                return r1.isDefault ? -1 : 1;
7498            }
7499            v1 = r1.match;
7500            v2 = r2.match;
7501            //System.out.println("Comparing: m1=" + m1 + " m2=" + m2);
7502            if (v1 != v2) {
7503                return (v1 > v2) ? -1 : 1;
7504            }
7505            if (r1.system != r2.system) {
7506                return r1.system ? -1 : 1;
7507            }
7508            return 0;
7509        }
7510    };
7511
7512    private static final Comparator<ProviderInfo> mProviderInitOrderSorter =
7513            new Comparator<ProviderInfo>() {
7514        public int compare(ProviderInfo p1, ProviderInfo p2) {
7515            final int v1 = p1.initOrder;
7516            final int v2 = p2.initOrder;
7517            return (v1 > v2) ? -1 : ((v1 < v2) ? 1 : 0);
7518        }
7519    };
7520
7521    static final void sendPackageBroadcast(String action, String pkg,
7522            Bundle extras, String targetPkg, IIntentReceiver finishedReceiver,
7523            int[] userIds) {
7524        IActivityManager am = ActivityManagerNative.getDefault();
7525        if (am != null) {
7526            try {
7527                if (userIds == null) {
7528                    userIds = am.getRunningUserIds();
7529                }
7530                for (int id : userIds) {
7531                    final Intent intent = new Intent(action,
7532                            pkg != null ? Uri.fromParts("package", pkg, null) : null);
7533                    if (extras != null) {
7534                        intent.putExtras(extras);
7535                    }
7536                    if (targetPkg != null) {
7537                        intent.setPackage(targetPkg);
7538                    }
7539                    // Modify the UID when posting to other users
7540                    int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
7541                    if (uid > 0 && UserHandle.getUserId(uid) != id) {
7542                        uid = UserHandle.getUid(id, UserHandle.getAppId(uid));
7543                        intent.putExtra(Intent.EXTRA_UID, uid);
7544                    }
7545                    intent.putExtra(Intent.EXTRA_USER_HANDLE, id);
7546                    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
7547                    if (DEBUG_BROADCASTS) {
7548                        RuntimeException here = new RuntimeException("here");
7549                        here.fillInStackTrace();
7550                        Slog.d(TAG, "Sending to user " + id + ": "
7551                                + intent.toShortString(false, true, false, false)
7552                                + " " + intent.getExtras(), here);
7553                    }
7554                    am.broadcastIntent(null, intent, null, finishedReceiver,
7555                            0, null, null, null, android.app.AppOpsManager.OP_NONE,
7556                            finishedReceiver != null, false, id);
7557                }
7558            } catch (RemoteException ex) {
7559            }
7560        }
7561    }
7562
7563    /**
7564     * Check if the external storage media is available. This is true if there
7565     * is a mounted external storage medium or if the external storage is
7566     * emulated.
7567     */
7568    private boolean isExternalMediaAvailable() {
7569        return mMediaMounted || Environment.isExternalStorageEmulated();
7570    }
7571
7572    @Override
7573    public PackageCleanItem nextPackageToClean(PackageCleanItem lastPackage) {
7574        // writer
7575        synchronized (mPackages) {
7576            if (!isExternalMediaAvailable()) {
7577                // If the external storage is no longer mounted at this point,
7578                // the caller may not have been able to delete all of this
7579                // packages files and can not delete any more.  Bail.
7580                return null;
7581            }
7582            final ArrayList<PackageCleanItem> pkgs = mSettings.mPackagesToBeCleaned;
7583            if (lastPackage != null) {
7584                pkgs.remove(lastPackage);
7585            }
7586            if (pkgs.size() > 0) {
7587                return pkgs.get(0);
7588            }
7589        }
7590        return null;
7591    }
7592
7593    void schedulePackageCleaning(String packageName, int userId, boolean andCode) {
7594        if (false) {
7595            RuntimeException here = new RuntimeException("here");
7596            here.fillInStackTrace();
7597            Slog.d(TAG, "Schedule cleaning " + packageName + " user=" + userId
7598                    + " andCode=" + andCode, here);
7599        }
7600        mHandler.sendMessage(mHandler.obtainMessage(START_CLEANING_PACKAGE,
7601                userId, andCode ? 1 : 0, packageName));
7602    }
7603
7604    void startCleaningPackages() {
7605        // reader
7606        synchronized (mPackages) {
7607            if (!isExternalMediaAvailable()) {
7608                return;
7609            }
7610            if (mSettings.mPackagesToBeCleaned.isEmpty()) {
7611                return;
7612            }
7613        }
7614        Intent intent = new Intent(PackageManager.ACTION_CLEAN_EXTERNAL_STORAGE);
7615        intent.setComponent(DEFAULT_CONTAINER_COMPONENT);
7616        IActivityManager am = ActivityManagerNative.getDefault();
7617        if (am != null) {
7618            try {
7619                am.startService(null, intent, null, UserHandle.USER_OWNER);
7620            } catch (RemoteException e) {
7621            }
7622        }
7623    }
7624
7625    private final class AppDirObserver extends FileObserver {
7626        public AppDirObserver(String path, int mask, boolean isrom, boolean isPrivileged) {
7627            super(path, mask);
7628            mRootDir = path;
7629            mIsRom = isrom;
7630            mIsPrivileged = isPrivileged;
7631        }
7632
7633        public void onEvent(int event, String path) {
7634            String removedPackage = null;
7635            int removedAppId = -1;
7636            int[] removedUsers = null;
7637            String addedPackage = null;
7638            int addedAppId = -1;
7639            int[] addedUsers = null;
7640
7641            // TODO post a message to the handler to obtain serial ordering
7642            synchronized (mInstallLock) {
7643                String fullPathStr = null;
7644                File fullPath = null;
7645                if (path != null) {
7646                    fullPath = new File(mRootDir, path);
7647                    fullPathStr = fullPath.getPath();
7648                }
7649
7650                if (DEBUG_APP_DIR_OBSERVER)
7651                    Log.v(TAG, "File " + fullPathStr + " changed: " + Integer.toHexString(event));
7652
7653                if (!isApkFile(fullPath)) {
7654                    if (DEBUG_APP_DIR_OBSERVER)
7655                        Log.v(TAG, "Ignoring change of non-package file: " + fullPathStr);
7656                    return;
7657                }
7658
7659                // Ignore packages that are being installed or
7660                // have just been installed.
7661                if (ignoreCodePath(fullPathStr)) {
7662                    return;
7663                }
7664                PackageParser.Package p = null;
7665                PackageSetting ps = null;
7666                // reader
7667                synchronized (mPackages) {
7668                    p = mAppDirs.get(fullPathStr);
7669                    if (p != null) {
7670                        ps = mSettings.mPackages.get(p.applicationInfo.packageName);
7671                        if (ps != null) {
7672                            removedUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
7673                        } else {
7674                            removedUsers = sUserManager.getUserIds();
7675                        }
7676                    }
7677                    addedUsers = sUserManager.getUserIds();
7678                }
7679                if ((event&REMOVE_EVENTS) != 0) {
7680                    if (ps != null) {
7681                        if (DEBUG_REMOVE) Slog.d(TAG, "Package disappeared: " + ps);
7682                        removePackageLI(ps, true);
7683                        removedPackage = ps.name;
7684                        removedAppId = ps.appId;
7685                    }
7686                }
7687
7688                if ((event&ADD_EVENTS) != 0) {
7689                    if (p == null) {
7690                        if (DEBUG_INSTALL) Slog.d(TAG, "New file appeared: " + fullPath);
7691                        int flags = PackageParser.PARSE_CHATTY | PackageParser.PARSE_MUST_BE_APK;
7692                        if (mIsRom) {
7693                            flags |= PackageParser.PARSE_IS_SYSTEM
7694                                    | PackageParser.PARSE_IS_SYSTEM_DIR;
7695                            if (mIsPrivileged) {
7696                                flags |= PackageParser.PARSE_IS_PRIVILEGED;
7697                            }
7698                        }
7699                        try {
7700                            p = scanPackageLI(fullPath, flags,
7701                                    SCAN_MONITOR | SCAN_NO_PATHS | SCAN_UPDATE_TIME,
7702                                    System.currentTimeMillis(), UserHandle.ALL, null);
7703                        } catch (PackageManagerException e) {
7704                            Slog.w(TAG, "Failed to scan " + fullPath + ": " + e.getMessage());
7705                            p = null;
7706                        }
7707                        if (p != null) {
7708                            /*
7709                             * TODO this seems dangerous as the package may have
7710                             * changed since we last acquired the mPackages
7711                             * lock.
7712                             */
7713                            // writer
7714                            synchronized (mPackages) {
7715                                updatePermissionsLPw(p.packageName, p,
7716                                        p.permissions.size() > 0 ? UPDATE_PERMISSIONS_ALL : 0);
7717                            }
7718                            addedPackage = p.applicationInfo.packageName;
7719                            addedAppId = UserHandle.getAppId(p.applicationInfo.uid);
7720                        }
7721                    }
7722                }
7723
7724                // reader
7725                synchronized (mPackages) {
7726                    mSettings.writeLPr();
7727                }
7728            }
7729
7730            if (removedPackage != null) {
7731                Bundle extras = new Bundle(1);
7732                extras.putInt(Intent.EXTRA_UID, removedAppId);
7733                extras.putBoolean(Intent.EXTRA_DATA_REMOVED, false);
7734                sendPackageBroadcast(Intent.ACTION_PACKAGE_REMOVED, removedPackage,
7735                        extras, null, null, removedUsers);
7736            }
7737            if (addedPackage != null) {
7738                Bundle extras = new Bundle(1);
7739                extras.putInt(Intent.EXTRA_UID, addedAppId);
7740                sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, addedPackage,
7741                        extras, null, null, addedUsers);
7742            }
7743        }
7744
7745        private final String mRootDir;
7746        private final boolean mIsRom;
7747        private final boolean mIsPrivileged;
7748    }
7749
7750    @Override
7751    public void installPackage(String originPath, IPackageInstallObserver2 observer, int flags,
7752            String installerPackageName, VerificationParams verificationParams,
7753            String packageAbiOverride) {
7754        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES,
7755                null);
7756
7757        final File originFile = new File(originPath);
7758        final int uid = Binder.getCallingUid();
7759        if (isUserRestricted(UserHandle.getUserId(uid), UserManager.DISALLOW_INSTALL_APPS)) {
7760            try {
7761                if (observer != null) {
7762                    observer.packageInstalled("", null, INSTALL_FAILED_USER_RESTRICTED, null);
7763                }
7764            } catch (RemoteException re) {
7765            }
7766            return;
7767        }
7768
7769        UserHandle user;
7770        if ((flags&PackageManager.INSTALL_ALL_USERS) != 0) {
7771            user = UserHandle.ALL;
7772        } else {
7773            user = new UserHandle(UserHandle.getUserId(uid));
7774        }
7775
7776        final int filteredFlags;
7777        if (uid == Process.SHELL_UID || uid == 0) {
7778            if (DEBUG_INSTALL) {
7779                Slog.v(TAG, "Install from ADB");
7780            }
7781            filteredFlags = flags | PackageManager.INSTALL_FROM_ADB;
7782        } else {
7783            filteredFlags = flags & ~PackageManager.INSTALL_FROM_ADB;
7784        }
7785
7786        verificationParams.setInstallerUid(uid);
7787
7788        final Message msg = mHandler.obtainMessage(INIT_COPY);
7789        msg.obj = new InstallParams(originFile, false, observer, filteredFlags,
7790                installerPackageName, verificationParams, user, packageAbiOverride);
7791        mHandler.sendMessage(msg);
7792    }
7793
7794    void installStage(String packageName, File stageDir, IPackageInstallObserver2 observer,
7795            InstallSessionParams params, String installerPackageName, int installerUid,
7796            UserHandle user) {
7797        final VerificationParams verifParams = new VerificationParams(null, params.originatingUri,
7798                params.referrerUri, installerUid, null);
7799
7800        final Message msg = mHandler.obtainMessage(INIT_COPY);
7801        msg.obj = new InstallParams(stageDir, true, observer, params.installFlags,
7802                installerPackageName, verifParams, user, params.abiOverride);
7803        mHandler.sendMessage(msg);
7804    }
7805
7806    private void sendPackageAddedForUser(String packageName, PackageSetting pkgSetting, int userId) {
7807        Bundle extras = new Bundle(1);
7808        extras.putInt(Intent.EXTRA_UID, UserHandle.getUid(userId, pkgSetting.appId));
7809
7810        sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
7811                packageName, extras, null, null, new int[] {userId});
7812        try {
7813            IActivityManager am = ActivityManagerNative.getDefault();
7814            final boolean isSystem =
7815                    isSystemApp(pkgSetting) || isUpdatedSystemApp(pkgSetting);
7816            if (isSystem && am.isUserRunning(userId, false)) {
7817                // The just-installed/enabled app is bundled on the system, so presumed
7818                // to be able to run automatically without needing an explicit launch.
7819                // Send it a BOOT_COMPLETED if it would ordinarily have gotten one.
7820                Intent bcIntent = new Intent(Intent.ACTION_BOOT_COMPLETED)
7821                        .addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES)
7822                        .setPackage(packageName);
7823                am.broadcastIntent(null, bcIntent, null, null, 0, null, null, null,
7824                        android.app.AppOpsManager.OP_NONE, false, false, userId);
7825            }
7826        } catch (RemoteException e) {
7827            // shouldn't happen
7828            Slog.w(TAG, "Unable to bootstrap installed package", e);
7829        }
7830    }
7831
7832    @Override
7833    public boolean setApplicationBlockedSettingAsUser(String packageName, boolean blocked,
7834            int userId) {
7835        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USERS, null);
7836        PackageSetting pkgSetting;
7837        final int uid = Binder.getCallingUid();
7838        if (UserHandle.getUserId(uid) != userId) {
7839            mContext.enforceCallingOrSelfPermission(
7840                    android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
7841                    "setApplicationBlockedSetting for user " + userId);
7842        }
7843
7844        if (blocked && isPackageDeviceAdmin(packageName, userId)) {
7845            Slog.w(TAG, "Not blocking package " + packageName + ": has active device admin");
7846            return false;
7847        }
7848
7849        long callingId = Binder.clearCallingIdentity();
7850        try {
7851            boolean sendAdded = false;
7852            boolean sendRemoved = false;
7853            // writer
7854            synchronized (mPackages) {
7855                pkgSetting = mSettings.mPackages.get(packageName);
7856                if (pkgSetting == null) {
7857                    return false;
7858                }
7859                if (pkgSetting.getBlocked(userId) != blocked) {
7860                    pkgSetting.setBlocked(blocked, userId);
7861                    mSettings.writePackageRestrictionsLPr(userId);
7862                    if (blocked) {
7863                        sendRemoved = true;
7864                    } else {
7865                        sendAdded = true;
7866                    }
7867                }
7868            }
7869            if (sendAdded) {
7870                sendPackageAddedForUser(packageName, pkgSetting, userId);
7871                return true;
7872            }
7873            if (sendRemoved) {
7874                killApplication(packageName, UserHandle.getUid(userId, pkgSetting.appId),
7875                        "blocking pkg");
7876                sendPackageBlockedForUser(packageName, pkgSetting, userId);
7877            }
7878        } finally {
7879            Binder.restoreCallingIdentity(callingId);
7880        }
7881        return false;
7882    }
7883
7884    private void sendPackageBlockedForUser(String packageName, PackageSetting pkgSetting,
7885            int userId) {
7886        final PackageRemovedInfo info = new PackageRemovedInfo();
7887        info.removedPackage = packageName;
7888        info.removedUsers = new int[] {userId};
7889        info.uid = UserHandle.getUid(userId, pkgSetting.appId);
7890        info.sendBroadcast(false, false, false);
7891    }
7892
7893    /**
7894     * Returns true if application is not found or there was an error. Otherwise it returns
7895     * the blocked state of the package for the given user.
7896     */
7897    @Override
7898    public boolean getApplicationBlockedSettingAsUser(String packageName, int userId) {
7899        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USERS, null);
7900        enforceCrossUserPermission(Binder.getCallingUid(), userId, true,
7901                "getApplicationBlocked for user " + userId);
7902        PackageSetting pkgSetting;
7903        long callingId = Binder.clearCallingIdentity();
7904        try {
7905            // writer
7906            synchronized (mPackages) {
7907                pkgSetting = mSettings.mPackages.get(packageName);
7908                if (pkgSetting == null) {
7909                    return true;
7910                }
7911                return pkgSetting.getBlocked(userId);
7912            }
7913        } finally {
7914            Binder.restoreCallingIdentity(callingId);
7915        }
7916    }
7917
7918    /**
7919     * @hide
7920     */
7921    @Override
7922    public int installExistingPackageAsUser(String packageName, int userId) {
7923        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES,
7924                null);
7925        PackageSetting pkgSetting;
7926        final int uid = Binder.getCallingUid();
7927        enforceCrossUserPermission(uid, userId, true, "installExistingPackage for user " + userId);
7928        if (isUserRestricted(userId, UserManager.DISALLOW_INSTALL_APPS)) {
7929            return PackageManager.INSTALL_FAILED_USER_RESTRICTED;
7930        }
7931
7932        long callingId = Binder.clearCallingIdentity();
7933        try {
7934            boolean sendAdded = false;
7935            Bundle extras = new Bundle(1);
7936
7937            // writer
7938            synchronized (mPackages) {
7939                pkgSetting = mSettings.mPackages.get(packageName);
7940                if (pkgSetting == null) {
7941                    return PackageManager.INSTALL_FAILED_INVALID_URI;
7942                }
7943                if (!pkgSetting.getInstalled(userId)) {
7944                    pkgSetting.setInstalled(true, userId);
7945                    pkgSetting.setBlocked(false, userId);
7946                    mSettings.writePackageRestrictionsLPr(userId);
7947                    sendAdded = true;
7948                }
7949            }
7950
7951            if (sendAdded) {
7952                sendPackageAddedForUser(packageName, pkgSetting, userId);
7953            }
7954        } finally {
7955            Binder.restoreCallingIdentity(callingId);
7956        }
7957
7958        return PackageManager.INSTALL_SUCCEEDED;
7959    }
7960
7961    boolean isUserRestricted(int userId, String restrictionKey) {
7962        Bundle restrictions = sUserManager.getUserRestrictions(userId);
7963        if (restrictions.getBoolean(restrictionKey, false)) {
7964            Log.w(TAG, "User is restricted: " + restrictionKey);
7965            return true;
7966        }
7967        return false;
7968    }
7969
7970    @Override
7971    public void verifyPendingInstall(int id, int verificationCode) throws RemoteException {
7972        mContext.enforceCallingOrSelfPermission(
7973                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
7974                "Only package verification agents can verify applications");
7975
7976        final Message msg = mHandler.obtainMessage(PACKAGE_VERIFIED);
7977        final PackageVerificationResponse response = new PackageVerificationResponse(
7978                verificationCode, Binder.getCallingUid());
7979        msg.arg1 = id;
7980        msg.obj = response;
7981        mHandler.sendMessage(msg);
7982    }
7983
7984    @Override
7985    public void extendVerificationTimeout(int id, int verificationCodeAtTimeout,
7986            long millisecondsToDelay) {
7987        mContext.enforceCallingOrSelfPermission(
7988                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
7989                "Only package verification agents can extend verification timeouts");
7990
7991        final PackageVerificationState state = mPendingVerification.get(id);
7992        final PackageVerificationResponse response = new PackageVerificationResponse(
7993                verificationCodeAtTimeout, Binder.getCallingUid());
7994
7995        if (millisecondsToDelay > PackageManager.MAXIMUM_VERIFICATION_TIMEOUT) {
7996            millisecondsToDelay = PackageManager.MAXIMUM_VERIFICATION_TIMEOUT;
7997        }
7998        if (millisecondsToDelay < 0) {
7999            millisecondsToDelay = 0;
8000        }
8001        if ((verificationCodeAtTimeout != PackageManager.VERIFICATION_ALLOW)
8002                && (verificationCodeAtTimeout != PackageManager.VERIFICATION_REJECT)) {
8003            verificationCodeAtTimeout = PackageManager.VERIFICATION_REJECT;
8004        }
8005
8006        if ((state != null) && !state.timeoutExtended()) {
8007            state.extendTimeout();
8008
8009            final Message msg = mHandler.obtainMessage(PACKAGE_VERIFIED);
8010            msg.arg1 = id;
8011            msg.obj = response;
8012            mHandler.sendMessageDelayed(msg, millisecondsToDelay);
8013        }
8014    }
8015
8016    private void broadcastPackageVerified(int verificationId, Uri packageUri,
8017            int verificationCode, UserHandle user) {
8018        final Intent intent = new Intent(Intent.ACTION_PACKAGE_VERIFIED);
8019        intent.setDataAndType(packageUri, PACKAGE_MIME_TYPE);
8020        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
8021        intent.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
8022        intent.putExtra(PackageManager.EXTRA_VERIFICATION_RESULT, verificationCode);
8023
8024        mContext.sendBroadcastAsUser(intent, user,
8025                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT);
8026    }
8027
8028    private ComponentName matchComponentForVerifier(String packageName,
8029            List<ResolveInfo> receivers) {
8030        ActivityInfo targetReceiver = null;
8031
8032        final int NR = receivers.size();
8033        for (int i = 0; i < NR; i++) {
8034            final ResolveInfo info = receivers.get(i);
8035            if (info.activityInfo == null) {
8036                continue;
8037            }
8038
8039            if (packageName.equals(info.activityInfo.packageName)) {
8040                targetReceiver = info.activityInfo;
8041                break;
8042            }
8043        }
8044
8045        if (targetReceiver == null) {
8046            return null;
8047        }
8048
8049        return new ComponentName(targetReceiver.packageName, targetReceiver.name);
8050    }
8051
8052    private List<ComponentName> matchVerifiers(PackageInfoLite pkgInfo,
8053            List<ResolveInfo> receivers, final PackageVerificationState verificationState) {
8054        if (pkgInfo.verifiers.length == 0) {
8055            return null;
8056        }
8057
8058        final int N = pkgInfo.verifiers.length;
8059        final List<ComponentName> sufficientVerifiers = new ArrayList<ComponentName>(N + 1);
8060        for (int i = 0; i < N; i++) {
8061            final VerifierInfo verifierInfo = pkgInfo.verifiers[i];
8062
8063            final ComponentName comp = matchComponentForVerifier(verifierInfo.packageName,
8064                    receivers);
8065            if (comp == null) {
8066                continue;
8067            }
8068
8069            final int verifierUid = getUidForVerifier(verifierInfo);
8070            if (verifierUid == -1) {
8071                continue;
8072            }
8073
8074            if (DEBUG_VERIFY) {
8075                Slog.d(TAG, "Added sufficient verifier " + verifierInfo.packageName
8076                        + " with the correct signature");
8077            }
8078            sufficientVerifiers.add(comp);
8079            verificationState.addSufficientVerifier(verifierUid);
8080        }
8081
8082        return sufficientVerifiers;
8083    }
8084
8085    private int getUidForVerifier(VerifierInfo verifierInfo) {
8086        synchronized (mPackages) {
8087            final PackageParser.Package pkg = mPackages.get(verifierInfo.packageName);
8088            if (pkg == null) {
8089                return -1;
8090            } else if (pkg.mSignatures.length != 1) {
8091                Slog.i(TAG, "Verifier package " + verifierInfo.packageName
8092                        + " has more than one signature; ignoring");
8093                return -1;
8094            }
8095
8096            /*
8097             * If the public key of the package's signature does not match
8098             * our expected public key, then this is a different package and
8099             * we should skip.
8100             */
8101
8102            final byte[] expectedPublicKey;
8103            try {
8104                final Signature verifierSig = pkg.mSignatures[0];
8105                final PublicKey publicKey = verifierSig.getPublicKey();
8106                expectedPublicKey = publicKey.getEncoded();
8107            } catch (CertificateException e) {
8108                return -1;
8109            }
8110
8111            final byte[] actualPublicKey = verifierInfo.publicKey.getEncoded();
8112
8113            if (!Arrays.equals(actualPublicKey, expectedPublicKey)) {
8114                Slog.i(TAG, "Verifier package " + verifierInfo.packageName
8115                        + " does not have the expected public key; ignoring");
8116                return -1;
8117            }
8118
8119            return pkg.applicationInfo.uid;
8120        }
8121    }
8122
8123    @Override
8124    public void finishPackageInstall(int token) {
8125        enforceSystemOrRoot("Only the system is allowed to finish installs");
8126
8127        if (DEBUG_INSTALL) {
8128            Slog.v(TAG, "BM finishing package install for " + token);
8129        }
8130
8131        final Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
8132        mHandler.sendMessage(msg);
8133    }
8134
8135    /**
8136     * Get the verification agent timeout.
8137     *
8138     * @return verification timeout in milliseconds
8139     */
8140    private long getVerificationTimeout() {
8141        return android.provider.Settings.Global.getLong(mContext.getContentResolver(),
8142                android.provider.Settings.Global.PACKAGE_VERIFIER_TIMEOUT,
8143                DEFAULT_VERIFICATION_TIMEOUT);
8144    }
8145
8146    /**
8147     * Get the default verification agent response code.
8148     *
8149     * @return default verification response code
8150     */
8151    private int getDefaultVerificationResponse() {
8152        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8153                android.provider.Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE,
8154                DEFAULT_VERIFICATION_RESPONSE);
8155    }
8156
8157    /**
8158     * Check whether or not package verification has been enabled.
8159     *
8160     * @return true if verification should be performed
8161     */
8162    private boolean isVerificationEnabled(int userId, int flags) {
8163        if (!DEFAULT_VERIFY_ENABLE) {
8164            return false;
8165        }
8166
8167        boolean ensureVerifyAppsEnabled = isUserRestricted(userId, UserManager.ENSURE_VERIFY_APPS);
8168
8169        // Check if installing from ADB
8170        if ((flags & PackageManager.INSTALL_FROM_ADB) != 0) {
8171            // Do not run verification in a test harness environment
8172            if (ActivityManager.isRunningInTestHarness()) {
8173                return false;
8174            }
8175            if (ensureVerifyAppsEnabled) {
8176                return true;
8177            }
8178            // Check if the developer does not want package verification for ADB installs
8179            if (android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8180                    android.provider.Settings.Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1) == 0) {
8181                return false;
8182            }
8183        }
8184
8185        if (ensureVerifyAppsEnabled) {
8186            return true;
8187        }
8188
8189        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8190                android.provider.Settings.Global.PACKAGE_VERIFIER_ENABLE, 1) == 1;
8191    }
8192
8193    /**
8194     * Get the "allow unknown sources" setting.
8195     *
8196     * @return the current "allow unknown sources" setting
8197     */
8198    private int getUnknownSourcesSettings() {
8199        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8200                android.provider.Settings.Global.INSTALL_NON_MARKET_APPS,
8201                -1);
8202    }
8203
8204    @Override
8205    public void setInstallerPackageName(String targetPackage, String installerPackageName) {
8206        final int uid = Binder.getCallingUid();
8207        // writer
8208        synchronized (mPackages) {
8209            PackageSetting targetPackageSetting = mSettings.mPackages.get(targetPackage);
8210            if (targetPackageSetting == null) {
8211                throw new IllegalArgumentException("Unknown target package: " + targetPackage);
8212            }
8213
8214            PackageSetting installerPackageSetting;
8215            if (installerPackageName != null) {
8216                installerPackageSetting = mSettings.mPackages.get(installerPackageName);
8217                if (installerPackageSetting == null) {
8218                    throw new IllegalArgumentException("Unknown installer package: "
8219                            + installerPackageName);
8220                }
8221            } else {
8222                installerPackageSetting = null;
8223            }
8224
8225            Signature[] callerSignature;
8226            Object obj = mSettings.getUserIdLPr(uid);
8227            if (obj != null) {
8228                if (obj instanceof SharedUserSetting) {
8229                    callerSignature = ((SharedUserSetting)obj).signatures.mSignatures;
8230                } else if (obj instanceof PackageSetting) {
8231                    callerSignature = ((PackageSetting)obj).signatures.mSignatures;
8232                } else {
8233                    throw new SecurityException("Bad object " + obj + " for uid " + uid);
8234                }
8235            } else {
8236                throw new SecurityException("Unknown calling uid " + uid);
8237            }
8238
8239            // Verify: can't set installerPackageName to a package that is
8240            // not signed with the same cert as the caller.
8241            if (installerPackageSetting != null) {
8242                if (compareSignatures(callerSignature,
8243                        installerPackageSetting.signatures.mSignatures)
8244                        != PackageManager.SIGNATURE_MATCH) {
8245                    throw new SecurityException(
8246                            "Caller does not have same cert as new installer package "
8247                            + installerPackageName);
8248                }
8249            }
8250
8251            // Verify: if target already has an installer package, it must
8252            // be signed with the same cert as the caller.
8253            if (targetPackageSetting.installerPackageName != null) {
8254                PackageSetting setting = mSettings.mPackages.get(
8255                        targetPackageSetting.installerPackageName);
8256                // If the currently set package isn't valid, then it's always
8257                // okay to change it.
8258                if (setting != null) {
8259                    if (compareSignatures(callerSignature,
8260                            setting.signatures.mSignatures)
8261                            != PackageManager.SIGNATURE_MATCH) {
8262                        throw new SecurityException(
8263                                "Caller does not have same cert as old installer package "
8264                                + targetPackageSetting.installerPackageName);
8265                    }
8266                }
8267            }
8268
8269            // Okay!
8270            targetPackageSetting.installerPackageName = installerPackageName;
8271            scheduleWriteSettingsLocked();
8272        }
8273    }
8274
8275    private void processPendingInstall(final InstallArgs args, final int currentStatus) {
8276        // Queue up an async operation since the package installation may take a little while.
8277        mHandler.post(new Runnable() {
8278            public void run() {
8279                mHandler.removeCallbacks(this);
8280                 // Result object to be returned
8281                PackageInstalledInfo res = new PackageInstalledInfo();
8282                res.returnCode = currentStatus;
8283                res.uid = -1;
8284                res.pkg = null;
8285                res.removedInfo = new PackageRemovedInfo();
8286                if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
8287                    args.doPreInstall(res.returnCode);
8288                    synchronized (mInstallLock) {
8289                        installPackageLI(args, true, res);
8290                    }
8291                    args.doPostInstall(res.returnCode, res.uid);
8292                }
8293
8294                // A restore should be performed at this point if (a) the install
8295                // succeeded, (b) the operation is not an update, and (c) the new
8296                // package has a backupAgent defined.
8297                final boolean update = res.removedInfo.removedPackage != null;
8298                boolean doRestore = (!update
8299                        && res.pkg != null
8300                        && res.pkg.applicationInfo.backupAgentName != null);
8301
8302                // Set up the post-install work request bookkeeping.  This will be used
8303                // and cleaned up by the post-install event handling regardless of whether
8304                // there's a restore pass performed.  Token values are >= 1.
8305                int token;
8306                if (mNextInstallToken < 0) mNextInstallToken = 1;
8307                token = mNextInstallToken++;
8308
8309                PostInstallData data = new PostInstallData(args, res);
8310                mRunningInstalls.put(token, data);
8311                if (DEBUG_INSTALL) Log.v(TAG, "+ starting restore round-trip " + token);
8312
8313                if (res.returnCode == PackageManager.INSTALL_SUCCEEDED && doRestore) {
8314                    // Pass responsibility to the Backup Manager.  It will perform a
8315                    // restore if appropriate, then pass responsibility back to the
8316                    // Package Manager to run the post-install observer callbacks
8317                    // and broadcasts.
8318                    IBackupManager bm = IBackupManager.Stub.asInterface(
8319                            ServiceManager.getService(Context.BACKUP_SERVICE));
8320                    if (bm != null) {
8321                        if (DEBUG_INSTALL) Log.v(TAG, "token " + token
8322                                + " to BM for possible restore");
8323                        try {
8324                            bm.restoreAtInstall(res.pkg.applicationInfo.packageName, token);
8325                        } catch (RemoteException e) {
8326                            // can't happen; the backup manager is local
8327                        } catch (Exception e) {
8328                            Slog.e(TAG, "Exception trying to enqueue restore", e);
8329                            doRestore = false;
8330                        }
8331                    } else {
8332                        Slog.e(TAG, "Backup Manager not found!");
8333                        doRestore = false;
8334                    }
8335                }
8336
8337                if (!doRestore) {
8338                    // No restore possible, or the Backup Manager was mysteriously not
8339                    // available -- just fire the post-install work request directly.
8340                    if (DEBUG_INSTALL) Log.v(TAG, "No restore - queue post-install for " + token);
8341                    Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
8342                    mHandler.sendMessage(msg);
8343                }
8344            }
8345        });
8346    }
8347
8348    private abstract class HandlerParams {
8349        private static final int MAX_RETRIES = 4;
8350
8351        /**
8352         * Number of times startCopy() has been attempted and had a non-fatal
8353         * error.
8354         */
8355        private int mRetries = 0;
8356
8357        /** User handle for the user requesting the information or installation. */
8358        private final UserHandle mUser;
8359
8360        HandlerParams(UserHandle user) {
8361            mUser = user;
8362        }
8363
8364        UserHandle getUser() {
8365            return mUser;
8366        }
8367
8368        final boolean startCopy() {
8369            boolean res;
8370            try {
8371                if (DEBUG_INSTALL) Slog.i(TAG, "startCopy " + mUser + ": " + this);
8372
8373                if (++mRetries > MAX_RETRIES) {
8374                    Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up");
8375                    mHandler.sendEmptyMessage(MCS_GIVE_UP);
8376                    handleServiceError();
8377                    return false;
8378                } else {
8379                    handleStartCopy();
8380                    res = true;
8381                }
8382            } catch (RemoteException e) {
8383                if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
8384                mHandler.sendEmptyMessage(MCS_RECONNECT);
8385                res = false;
8386            }
8387            handleReturnCode();
8388            return res;
8389        }
8390
8391        final void serviceError() {
8392            if (DEBUG_INSTALL) Slog.i(TAG, "serviceError");
8393            handleServiceError();
8394            handleReturnCode();
8395        }
8396
8397        abstract void handleStartCopy() throws RemoteException;
8398        abstract void handleServiceError();
8399        abstract void handleReturnCode();
8400    }
8401
8402    class MeasureParams extends HandlerParams {
8403        private final PackageStats mStats;
8404        private boolean mSuccess;
8405
8406        private final IPackageStatsObserver mObserver;
8407
8408        public MeasureParams(PackageStats stats, IPackageStatsObserver observer) {
8409            super(new UserHandle(stats.userHandle));
8410            mObserver = observer;
8411            mStats = stats;
8412        }
8413
8414        @Override
8415        public String toString() {
8416            return "MeasureParams{"
8417                + Integer.toHexString(System.identityHashCode(this))
8418                + " " + mStats.packageName + "}";
8419        }
8420
8421        @Override
8422        void handleStartCopy() throws RemoteException {
8423            synchronized (mInstallLock) {
8424                mSuccess = getPackageSizeInfoLI(mStats.packageName, mStats.userHandle, mStats);
8425            }
8426
8427            if (mSuccess) {
8428                final boolean mounted;
8429                if (Environment.isExternalStorageEmulated()) {
8430                    mounted = true;
8431                } else {
8432                    final String status = Environment.getExternalStorageState();
8433                    mounted = (Environment.MEDIA_MOUNTED.equals(status)
8434                            || Environment.MEDIA_MOUNTED_READ_ONLY.equals(status));
8435                }
8436
8437                if (mounted) {
8438                    final UserEnvironment userEnv = new UserEnvironment(mStats.userHandle);
8439
8440                    mStats.externalCacheSize = calculateDirectorySize(mContainerService,
8441                            userEnv.buildExternalStorageAppCacheDirs(mStats.packageName));
8442
8443                    mStats.externalDataSize = calculateDirectorySize(mContainerService,
8444                            userEnv.buildExternalStorageAppDataDirs(mStats.packageName));
8445
8446                    // Always subtract cache size, since it's a subdirectory
8447                    mStats.externalDataSize -= mStats.externalCacheSize;
8448
8449                    mStats.externalMediaSize = calculateDirectorySize(mContainerService,
8450                            userEnv.buildExternalStorageAppMediaDirs(mStats.packageName));
8451
8452                    mStats.externalObbSize = calculateDirectorySize(mContainerService,
8453                            userEnv.buildExternalStorageAppObbDirs(mStats.packageName));
8454                }
8455            }
8456        }
8457
8458        @Override
8459        void handleReturnCode() {
8460            if (mObserver != null) {
8461                try {
8462                    mObserver.onGetStatsCompleted(mStats, mSuccess);
8463                } catch (RemoteException e) {
8464                    Slog.i(TAG, "Observer no longer exists.");
8465                }
8466            }
8467        }
8468
8469        @Override
8470        void handleServiceError() {
8471            Slog.e(TAG, "Could not measure application " + mStats.packageName
8472                            + " external storage");
8473        }
8474    }
8475
8476    private static long calculateDirectorySize(IMediaContainerService mcs, File[] paths)
8477            throws RemoteException {
8478        long result = 0;
8479        for (File path : paths) {
8480            result += mcs.calculateDirectorySize(path.getAbsolutePath());
8481        }
8482        return result;
8483    }
8484
8485    private static void clearDirectory(IMediaContainerService mcs, File[] paths) {
8486        for (File path : paths) {
8487            try {
8488                mcs.clearDirectory(path.getAbsolutePath());
8489            } catch (RemoteException e) {
8490            }
8491        }
8492    }
8493
8494    class InstallParams extends HandlerParams {
8495        /**
8496         * Location where install is coming from, before it has been
8497         * copied/renamed into place. This could be a single monolithic APK
8498         * file, or a cluster directory. This location may be untrusted.
8499         */
8500        final File originFile;
8501
8502        /**
8503         * Flag indicating that {@link #originFile} has already been staged,
8504         * meaning downstream users don't need to defensively copy the contents.
8505         */
8506        boolean originStaged;
8507
8508        final IPackageInstallObserver2 observer;
8509        int flags;
8510        final String installerPackageName;
8511        final VerificationParams verificationParams;
8512        private InstallArgs mArgs;
8513        private int mRet;
8514        final String packageAbiOverride;
8515        boolean multiArch;
8516
8517        InstallParams(File originFile, boolean originStaged, IPackageInstallObserver2 observer,
8518                int flags, String installerPackageName, VerificationParams verificationParams,
8519                UserHandle user, String packageAbiOverride) {
8520            super(user);
8521            this.originFile = Preconditions.checkNotNull(originFile);
8522            this.originStaged = originStaged;
8523            this.observer = observer;
8524            this.flags = flags;
8525            this.installerPackageName = installerPackageName;
8526            this.verificationParams = verificationParams;
8527            this.packageAbiOverride = packageAbiOverride;
8528        }
8529
8530        @Override
8531        public String toString() {
8532            return "InstallParams{"
8533                + Integer.toHexString(System.identityHashCode(this))
8534                + " " + originFile + "}";
8535        }
8536
8537        public ManifestDigest getManifestDigest() {
8538            if (verificationParams == null) {
8539                return null;
8540            }
8541            return verificationParams.getManifestDigest();
8542        }
8543
8544        private int installLocationPolicy(PackageInfoLite pkgLite, int flags) {
8545            String packageName = pkgLite.packageName;
8546            int installLocation = pkgLite.installLocation;
8547            boolean onSd = (flags & PackageManager.INSTALL_EXTERNAL) != 0;
8548            // reader
8549            synchronized (mPackages) {
8550                PackageParser.Package pkg = mPackages.get(packageName);
8551                if (pkg != null) {
8552                    if ((flags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
8553                        // Check for downgrading.
8554                        if ((flags & PackageManager.INSTALL_ALLOW_DOWNGRADE) == 0) {
8555                            if (pkgLite.versionCode < pkg.mVersionCode) {
8556                                Slog.w(TAG, "Can't install update of " + packageName
8557                                        + " update version " + pkgLite.versionCode
8558                                        + " is older than installed version "
8559                                        + pkg.mVersionCode);
8560                                return PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE;
8561                            }
8562                        }
8563                        // Check for updated system application.
8564                        if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
8565                            if (onSd) {
8566                                Slog.w(TAG, "Cannot install update to system app on sdcard");
8567                                return PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION;
8568                            }
8569                            return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8570                        } else {
8571                            if (onSd) {
8572                                // Install flag overrides everything.
8573                                return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8574                            }
8575                            // If current upgrade specifies particular preference
8576                            if (installLocation == PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY) {
8577                                // Application explicitly specified internal.
8578                                return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8579                            } else if (installLocation == PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL) {
8580                                // App explictly prefers external. Let policy decide
8581                            } else {
8582                                // Prefer previous location
8583                                if (isExternal(pkg)) {
8584                                    return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8585                                }
8586                                return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8587                            }
8588                        }
8589                    } else {
8590                        // Invalid install. Return error code
8591                        return PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS;
8592                    }
8593                }
8594            }
8595            // All the special cases have been taken care of.
8596            // Return result based on recommended install location.
8597            if (onSd) {
8598                return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8599            }
8600            return pkgLite.recommendedInstallLocation;
8601        }
8602
8603        private long getMemoryLowThreshold() {
8604            final DeviceStorageMonitorInternal
8605                    dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
8606            if (dsm == null) {
8607                return 0L;
8608            }
8609            return dsm.getMemoryLowThreshold();
8610        }
8611
8612        /*
8613         * Invoke remote method to get package information and install
8614         * location values. Override install location based on default
8615         * policy if needed and then create install arguments based
8616         * on the install location.
8617         */
8618        public void handleStartCopy() throws RemoteException {
8619            int ret = PackageManager.INSTALL_SUCCEEDED;
8620            final boolean onSd = (flags & PackageManager.INSTALL_EXTERNAL) != 0;
8621            final boolean onInt = (flags & PackageManager.INSTALL_INTERNAL) != 0;
8622            PackageInfoLite pkgLite = null;
8623
8624            if (onInt && onSd) {
8625                // Check if both bits are set.
8626                Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");
8627                ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
8628            } else {
8629                final long lowThreshold = getMemoryLowThreshold();
8630                if (lowThreshold == 0L) {
8631                    Log.w(TAG, "Couldn't get low memory threshold; no free limit imposed");
8632                }
8633
8634                // Remote call to find out default install location
8635                final String originPath = originFile.getAbsolutePath();
8636                pkgLite = mContainerService.getMinimalPackageInfo(originPath, flags, lowThreshold,
8637                        packageAbiOverride);
8638                // Keep track of whether this package is a multiArch package until
8639                // we perform a full scan of it. We need to do this because we might
8640                // end up extracting the package shared libraries before we perform
8641                // a full scan.
8642                multiArch = pkgLite.multiArch;
8643
8644                /*
8645                 * If we have too little free space, try to free cache
8646                 * before giving up.
8647                 */
8648                if (pkgLite.recommendedInstallLocation
8649                        == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
8650                    final long size = mContainerService.calculateInstalledSize(
8651                            originPath, isForwardLocked(), packageAbiOverride);
8652                    if (mInstaller.freeCache(size + lowThreshold) >= 0) {
8653                        pkgLite = mContainerService.getMinimalPackageInfo(originPath, flags,
8654                                lowThreshold, packageAbiOverride);
8655                    }
8656                    /*
8657                     * The cache free must have deleted the file we
8658                     * downloaded to install.
8659                     *
8660                     * TODO: fix the "freeCache" call to not delete
8661                     *       the file we care about.
8662                     */
8663                    if (pkgLite.recommendedInstallLocation
8664                            == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
8665                        pkgLite.recommendedInstallLocation
8666                            = PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE;
8667                    }
8668                }
8669            }
8670
8671            if (ret == PackageManager.INSTALL_SUCCEEDED) {
8672                int loc = pkgLite.recommendedInstallLocation;
8673                if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
8674                    ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
8675                } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
8676                    ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
8677                } else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
8678                    ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
8679                } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {
8680                    ret = PackageManager.INSTALL_FAILED_INVALID_APK;
8681                } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
8682                    ret = PackageManager.INSTALL_FAILED_INVALID_URI;
8683                } else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {
8684                    ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
8685                } else {
8686                    // Override with defaults if needed.
8687                    loc = installLocationPolicy(pkgLite, flags);
8688                    if (loc == PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE) {
8689                        ret = PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
8690                    } else if (!onSd && !onInt) {
8691                        // Override install location with flags
8692                        if (loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {
8693                            // Set the flag to install on external media.
8694                            flags |= PackageManager.INSTALL_EXTERNAL;
8695                            flags &= ~PackageManager.INSTALL_INTERNAL;
8696                        } else {
8697                            // Make sure the flag for installing on external
8698                            // media is unset
8699                            flags |= PackageManager.INSTALL_INTERNAL;
8700                            flags &= ~PackageManager.INSTALL_EXTERNAL;
8701                        }
8702                    }
8703                }
8704            }
8705
8706            final InstallArgs args = createInstallArgs(this);
8707            mArgs = args;
8708
8709            if (ret == PackageManager.INSTALL_SUCCEEDED) {
8710                 /*
8711                 * ADB installs appear as UserHandle.USER_ALL, and can only be performed by
8712                 * UserHandle.USER_OWNER, so use the package verifier for UserHandle.USER_OWNER.
8713                 */
8714                int userIdentifier = getUser().getIdentifier();
8715                if (userIdentifier == UserHandle.USER_ALL
8716                        && ((flags & PackageManager.INSTALL_FROM_ADB) != 0)) {
8717                    userIdentifier = UserHandle.USER_OWNER;
8718                }
8719
8720                /*
8721                 * Determine if we have any installed package verifiers. If we
8722                 * do, then we'll defer to them to verify the packages.
8723                 */
8724                final int requiredUid = mRequiredVerifierPackage == null ? -1
8725                        : getPackageUid(mRequiredVerifierPackage, userIdentifier);
8726                if (requiredUid != -1 && isVerificationEnabled(userIdentifier, flags)) {
8727                    // TODO: send verifier the install session instead of uri
8728                    final Intent verification = new Intent(
8729                            Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
8730                    verification.setDataAndType(Uri.fromFile(originFile), PACKAGE_MIME_TYPE);
8731                    verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
8732
8733                    final List<ResolveInfo> receivers = queryIntentReceivers(verification,
8734                            PACKAGE_MIME_TYPE, PackageManager.GET_DISABLED_COMPONENTS,
8735                            0 /* TODO: Which userId? */);
8736
8737                    if (DEBUG_VERIFY) {
8738                        Slog.d(TAG, "Found " + receivers.size() + " verifiers for intent "
8739                                + verification.toString() + " with " + pkgLite.verifiers.length
8740                                + " optional verifiers");
8741                    }
8742
8743                    final int verificationId = mPendingVerificationToken++;
8744
8745                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
8746
8747                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_PACKAGE,
8748                            installerPackageName);
8749
8750                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALL_FLAGS, flags);
8751
8752                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_PACKAGE_NAME,
8753                            pkgLite.packageName);
8754
8755                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_VERSION_CODE,
8756                            pkgLite.versionCode);
8757
8758                    if (verificationParams != null) {
8759                        if (verificationParams.getVerificationURI() != null) {
8760                           verification.putExtra(PackageManager.EXTRA_VERIFICATION_URI,
8761                                 verificationParams.getVerificationURI());
8762                        }
8763                        if (verificationParams.getOriginatingURI() != null) {
8764                            verification.putExtra(Intent.EXTRA_ORIGINATING_URI,
8765                                  verificationParams.getOriginatingURI());
8766                        }
8767                        if (verificationParams.getReferrer() != null) {
8768                            verification.putExtra(Intent.EXTRA_REFERRER,
8769                                  verificationParams.getReferrer());
8770                        }
8771                        if (verificationParams.getOriginatingUid() >= 0) {
8772                            verification.putExtra(Intent.EXTRA_ORIGINATING_UID,
8773                                  verificationParams.getOriginatingUid());
8774                        }
8775                        if (verificationParams.getInstallerUid() >= 0) {
8776                            verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_UID,
8777                                  verificationParams.getInstallerUid());
8778                        }
8779                    }
8780
8781                    final PackageVerificationState verificationState = new PackageVerificationState(
8782                            requiredUid, args);
8783
8784                    mPendingVerification.append(verificationId, verificationState);
8785
8786                    final List<ComponentName> sufficientVerifiers = matchVerifiers(pkgLite,
8787                            receivers, verificationState);
8788
8789                    /*
8790                     * If any sufficient verifiers were listed in the package
8791                     * manifest, attempt to ask them.
8792                     */
8793                    if (sufficientVerifiers != null) {
8794                        final int N = sufficientVerifiers.size();
8795                        if (N == 0) {
8796                            Slog.i(TAG, "Additional verifiers required, but none installed.");
8797                            ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
8798                        } else {
8799                            for (int i = 0; i < N; i++) {
8800                                final ComponentName verifierComponent = sufficientVerifiers.get(i);
8801
8802                                final Intent sufficientIntent = new Intent(verification);
8803                                sufficientIntent.setComponent(verifierComponent);
8804
8805                                mContext.sendBroadcastAsUser(sufficientIntent, getUser());
8806                            }
8807                        }
8808                    }
8809
8810                    final ComponentName requiredVerifierComponent = matchComponentForVerifier(
8811                            mRequiredVerifierPackage, receivers);
8812                    if (ret == PackageManager.INSTALL_SUCCEEDED
8813                            && mRequiredVerifierPackage != null) {
8814                        /*
8815                         * Send the intent to the required verification agent,
8816                         * but only start the verification timeout after the
8817                         * target BroadcastReceivers have run.
8818                         */
8819                        verification.setComponent(requiredVerifierComponent);
8820                        mContext.sendOrderedBroadcastAsUser(verification, getUser(),
8821                                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
8822                                new BroadcastReceiver() {
8823                                    @Override
8824                                    public void onReceive(Context context, Intent intent) {
8825                                        final Message msg = mHandler
8826                                                .obtainMessage(CHECK_PENDING_VERIFICATION);
8827                                        msg.arg1 = verificationId;
8828                                        mHandler.sendMessageDelayed(msg, getVerificationTimeout());
8829                                    }
8830                                }, null, 0, null, null);
8831
8832                        /*
8833                         * We don't want the copy to proceed until verification
8834                         * succeeds, so null out this field.
8835                         */
8836                        mArgs = null;
8837                    }
8838                } else {
8839                    /*
8840                     * No package verification is enabled, so immediately start
8841                     * the remote call to initiate copy using temporary file.
8842                     */
8843                    ret = args.copyApk(mContainerService, true);
8844                }
8845            }
8846
8847            mRet = ret;
8848        }
8849
8850        @Override
8851        void handleReturnCode() {
8852            // If mArgs is null, then MCS couldn't be reached. When it
8853            // reconnects, it will try again to install. At that point, this
8854            // will succeed.
8855            if (mArgs != null) {
8856                processPendingInstall(mArgs, mRet);
8857            }
8858        }
8859
8860        @Override
8861        void handleServiceError() {
8862            mArgs = createInstallArgs(this);
8863            mRet = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
8864        }
8865
8866        public boolean isForwardLocked() {
8867            return (flags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
8868        }
8869    }
8870
8871    /*
8872     * Utility class used in movePackage api.
8873     * srcArgs and targetArgs are not set for invalid flags and make
8874     * sure to do null checks when invoking methods on them.
8875     * We probably want to return ErrorPrams for both failed installs
8876     * and moves.
8877     */
8878    class MoveParams extends HandlerParams {
8879        final IPackageMoveObserver observer;
8880        final int flags;
8881        final String packageName;
8882        final InstallArgs srcArgs;
8883        final InstallArgs targetArgs;
8884        int uid;
8885        int mRet;
8886
8887        MoveParams(InstallArgs srcArgs, IPackageMoveObserver observer, int flags,
8888                String packageName, String[] instructionSets, int uid, UserHandle user,
8889                boolean isMultiArch) {
8890            super(user);
8891            this.srcArgs = srcArgs;
8892            this.observer = observer;
8893            this.flags = flags;
8894            this.packageName = packageName;
8895            this.uid = uid;
8896            if (srcArgs != null) {
8897                final String codePath = srcArgs.getCodePath();
8898                targetArgs = createInstallArgsForMoveTarget(codePath, flags, packageName,
8899                        instructionSets, isMultiArch);
8900            } else {
8901                targetArgs = null;
8902            }
8903        }
8904
8905        @Override
8906        public String toString() {
8907            return "MoveParams{"
8908                + Integer.toHexString(System.identityHashCode(this))
8909                + " " + packageName + "}";
8910        }
8911
8912        public void handleStartCopy() throws RemoteException {
8913            mRet = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
8914            // Check for storage space on target medium
8915            if (!targetArgs.checkFreeStorage(mContainerService)) {
8916                Log.w(TAG, "Insufficient storage to install");
8917                return;
8918            }
8919
8920            mRet = srcArgs.doPreCopy();
8921            if (mRet != PackageManager.INSTALL_SUCCEEDED) {
8922                return;
8923            }
8924
8925            mRet = targetArgs.copyApk(mContainerService, false);
8926            if (mRet != PackageManager.INSTALL_SUCCEEDED) {
8927                srcArgs.doPostCopy(uid);
8928                return;
8929            }
8930
8931            mRet = srcArgs.doPostCopy(uid);
8932            if (mRet != PackageManager.INSTALL_SUCCEEDED) {
8933                return;
8934            }
8935
8936            mRet = targetArgs.doPreInstall(mRet);
8937            if (mRet != PackageManager.INSTALL_SUCCEEDED) {
8938                return;
8939            }
8940
8941            if (DEBUG_SD_INSTALL) {
8942                StringBuilder builder = new StringBuilder();
8943                if (srcArgs != null) {
8944                    builder.append("src: ");
8945                    builder.append(srcArgs.getCodePath());
8946                }
8947                if (targetArgs != null) {
8948                    builder.append(" target : ");
8949                    builder.append(targetArgs.getCodePath());
8950                }
8951                Log.i(TAG, builder.toString());
8952            }
8953        }
8954
8955        @Override
8956        void handleReturnCode() {
8957            targetArgs.doPostInstall(mRet, uid);
8958            int currentStatus = PackageManager.MOVE_FAILED_INTERNAL_ERROR;
8959            if (mRet == PackageManager.INSTALL_SUCCEEDED) {
8960                currentStatus = PackageManager.MOVE_SUCCEEDED;
8961            } else if (mRet == PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE){
8962                currentStatus = PackageManager.MOVE_FAILED_INSUFFICIENT_STORAGE;
8963            }
8964            processPendingMove(this, currentStatus);
8965        }
8966
8967        @Override
8968        void handleServiceError() {
8969            mRet = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
8970        }
8971    }
8972
8973    /**
8974     * Used during creation of InstallArgs
8975     *
8976     * @param flags package installation flags
8977     * @return true if should be installed on external storage
8978     */
8979    private static boolean installOnSd(int flags) {
8980        if ((flags & PackageManager.INSTALL_INTERNAL) != 0) {
8981            return false;
8982        }
8983        if ((flags & PackageManager.INSTALL_EXTERNAL) != 0) {
8984            return true;
8985        }
8986        return false;
8987    }
8988
8989    /**
8990     * Used during creation of InstallArgs
8991     *
8992     * @param flags package installation flags
8993     * @return true if should be installed as forward locked
8994     */
8995    private static boolean installForwardLocked(int flags) {
8996        return (flags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
8997    }
8998
8999    private InstallArgs createInstallArgs(InstallParams params) {
9000        // TODO: extend to support incoming zero-copy locations
9001
9002        if (installOnSd(params.flags) || params.isForwardLocked()) {
9003            return new AsecInstallArgs(params);
9004        } else {
9005            return new FileInstallArgs(params);
9006        }
9007    }
9008
9009    /**
9010     * Create args that describe an existing installed package. Typically used
9011     * when cleaning up old installs, or used as a move source.
9012     */
9013    private InstallArgs createInstallArgsForExisting(int flags, String codePath,
9014            String resourcePath, String nativeLibraryRoot, String[] instructionSets,
9015            boolean isMultiArch) {
9016        final boolean isInAsec;
9017        if (installOnSd(flags)) {
9018            /* Apps on SD card are always in ASEC containers. */
9019            isInAsec = true;
9020        } else if (installForwardLocked(flags)
9021                && !codePath.startsWith(mDrmAppPrivateInstallDir.getAbsolutePath())) {
9022            /*
9023             * Forward-locked apps are only in ASEC containers if they're the
9024             * new style
9025             */
9026            isInAsec = true;
9027        } else {
9028            isInAsec = false;
9029        }
9030
9031        if (isInAsec) {
9032            return new AsecInstallArgs(codePath, instructionSets,
9033                    installOnSd(flags), installForwardLocked(flags), isMultiArch);
9034        } else {
9035            return new FileInstallArgs(codePath, resourcePath, nativeLibraryRoot,
9036                    instructionSets, isMultiArch);
9037        }
9038    }
9039
9040    private InstallArgs createInstallArgsForMoveTarget(String codePath, int flags, String pkgName,
9041            String[] instructionSets, boolean isMultiArch) {
9042        final File codeFile = new File(codePath);
9043        if (installOnSd(flags) || installForwardLocked(flags)) {
9044            String cid = getNextCodePath(codePath, pkgName, "/"
9045                    + AsecInstallArgs.RES_FILE_NAME);
9046            return new AsecInstallArgs(codeFile, cid, instructionSets, installOnSd(flags),
9047                    installForwardLocked(flags), isMultiArch);
9048        } else {
9049            return new FileInstallArgs(codeFile, instructionSets, isMultiArch);
9050        }
9051    }
9052
9053    static abstract class InstallArgs {
9054        /** @see InstallParams#originFile */
9055        final File originFile;
9056        /** @see InstallParams#originStaged */
9057        final boolean originStaged;
9058
9059        // TODO: define inherit location
9060
9061        final IPackageInstallObserver2 observer;
9062        // Always refers to PackageManager flags only
9063        final int flags;
9064        final String installerPackageName;
9065        final ManifestDigest manifestDigest;
9066        final UserHandle user;
9067        final String abiOverride;
9068        final boolean multiArch;
9069
9070        // The list of instruction sets supported by this app. This is currently
9071        // only used during the rmdex() phase to clean up resources. We can get rid of this
9072        // if we move dex files under the common app path.
9073        /* nullable */ String[] instructionSets;
9074
9075        InstallArgs(File originFile, boolean originStaged, IPackageInstallObserver2 observer,
9076                    int flags, String installerPackageName, ManifestDigest manifestDigest,
9077                    UserHandle user, String[] instructionSets,
9078                    String abiOverride, boolean multiArch) {
9079            this.originFile = originFile;
9080            this.originStaged = originStaged;
9081            this.flags = flags;
9082            this.observer = observer;
9083            this.installerPackageName = installerPackageName;
9084            this.manifestDigest = manifestDigest;
9085            this.user = user;
9086            this.instructionSets = instructionSets;
9087            this.abiOverride = abiOverride;
9088            this.multiArch = multiArch;
9089        }
9090
9091        abstract int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException;
9092        abstract int doPreInstall(int status);
9093
9094        /**
9095         * Rename package into final resting place. All paths on the given
9096         * scanned package should be updated to reflect the rename.
9097         */
9098        abstract boolean doRename(int status, PackageParser.Package pkg, String oldCodePath);
9099        abstract int doPostInstall(int status, int uid);
9100
9101        /** @see PackageSettingBase#codePathString */
9102        abstract String getCodePath();
9103        /** @see PackageSettingBase#resourcePathString */
9104        abstract String getResourcePath();
9105        abstract String getLegacyNativeLibraryPath();
9106
9107        // Need installer lock especially for dex file removal.
9108        abstract void cleanUpResourcesLI();
9109        abstract boolean doPostDeleteLI(boolean delete);
9110        abstract boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException;
9111
9112        /**
9113         * Called before the source arguments are copied. This is used mostly
9114         * for MoveParams when it needs to read the source file to put it in the
9115         * destination.
9116         */
9117        int doPreCopy() {
9118            return PackageManager.INSTALL_SUCCEEDED;
9119        }
9120
9121        /**
9122         * Called after the source arguments are copied. This is used mostly for
9123         * MoveParams when it needs to read the source file to put it in the
9124         * destination.
9125         *
9126         * @return
9127         */
9128        int doPostCopy(int uid) {
9129            return PackageManager.INSTALL_SUCCEEDED;
9130        }
9131
9132        protected boolean isFwdLocked() {
9133            return (flags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
9134        }
9135
9136        UserHandle getUser() {
9137            return user;
9138        }
9139    }
9140
9141    /**
9142     * Logic to handle installation of non-ASEC applications, including copying
9143     * and renaming logic.
9144     */
9145    class FileInstallArgs extends InstallArgs {
9146        private File codeFile;
9147        private File resourceFile;
9148        private File legacyNativeLibraryPath;
9149
9150        // Example topology:
9151        // /data/app/com.example/base.apk
9152        // /data/app/com.example/split_foo.apk
9153        // /data/app/com.example/lib/arm/libfoo.so
9154        // /data/app/com.example/lib/arm64/libfoo.so
9155        // /data/app/com.example/dalvik/arm/base.apk@classes.dex
9156
9157        /** New install */
9158        FileInstallArgs(InstallParams params) {
9159            super(params.originFile, params.originStaged, params.observer, params.flags,
9160                    params.installerPackageName, params.getManifestDigest(), params.getUser(),
9161                    null /* instruction sets */, params.packageAbiOverride,
9162                    params.multiArch);
9163            if (isFwdLocked()) {
9164                throw new IllegalArgumentException("Forward locking only supported in ASEC");
9165            }
9166        }
9167
9168        /** Existing install */
9169        FileInstallArgs(String codePath, String resourcePath, String legacyNativeLibraryPath,
9170                String[] instructionSets, boolean isMultiArch) {
9171            super(null, false, null, 0, null, null, null, instructionSets, null, isMultiArch);
9172            this.codeFile = (codePath != null) ? new File(codePath) : null;
9173            this.resourceFile = (resourcePath != null) ? new File(resourcePath) : null;
9174            this.legacyNativeLibraryPath = (legacyNativeLibraryPath != null) ?
9175                    new File(legacyNativeLibraryPath) : null;
9176        }
9177
9178        /** New install from existing */
9179        FileInstallArgs(File originFile, String[] instructionSets, boolean isMultiArch) {
9180            super(originFile, false, null, 0, null, null, null, instructionSets, null,
9181                    isMultiArch);
9182        }
9183
9184        boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException {
9185            final long lowThreshold;
9186
9187            final DeviceStorageMonitorInternal
9188                    dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
9189            if (dsm == null) {
9190                Log.w(TAG, "Couldn't get low memory threshold; no free limit imposed");
9191                lowThreshold = 0L;
9192            } else {
9193                if (dsm.isMemoryLow()) {
9194                    Log.w(TAG, "Memory is reported as being too low; aborting package install");
9195                    return false;
9196                }
9197
9198                lowThreshold = dsm.getMemoryLowThreshold();
9199            }
9200
9201            return imcs.checkInternalFreeStorage(originFile.getAbsolutePath(), isFwdLocked(),
9202                    lowThreshold);
9203        }
9204
9205        int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
9206            int ret = PackageManager.INSTALL_SUCCEEDED;
9207
9208            if (originStaged) {
9209                Slog.d(TAG, originFile + " already staged; skipping copy");
9210                codeFile = originFile;
9211                resourceFile = originFile;
9212            } else {
9213                try {
9214                    final File tempDir = mInstallerService.allocateSessionDir();
9215                    codeFile = tempDir;
9216                    resourceFile = tempDir;
9217                } catch (IOException e) {
9218                    Slog.w(TAG, "Failed to create copy file: " + e);
9219                    return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
9220                }
9221
9222                final IParcelFileDescriptorFactory target = new IParcelFileDescriptorFactory.Stub() {
9223                    @Override
9224                    public ParcelFileDescriptor open(String name, int mode) throws RemoteException {
9225                        if (!FileUtils.isValidExtFilename(name)) {
9226                            throw new IllegalArgumentException("Invalid filename: " + name);
9227                        }
9228                        try {
9229                            final File file = new File(codeFile, name);
9230                            final FileDescriptor fd = Os.open(file.getAbsolutePath(),
9231                                    O_RDWR | O_CREAT, 0644);
9232                            Os.chmod(file.getAbsolutePath(), 0644);
9233                            return new ParcelFileDescriptor(fd);
9234                        } catch (ErrnoException e) {
9235                            throw new RemoteException("Failed to open: " + e.getMessage());
9236                        }
9237                    }
9238                };
9239
9240                ret = imcs.copyPackage(originFile.getAbsolutePath(), target);
9241                if (ret != PackageManager.INSTALL_SUCCEEDED) {
9242                    Slog.e(TAG, "Failed to copy package");
9243                    return ret;
9244                }
9245            }
9246
9247            final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
9248            NativeLibraryHelper.Handle handle = null;
9249            try {
9250                handle = NativeLibraryHelper.Handle.create(codeFile);
9251                if (multiArch) {
9252                    // Warn if we've set an abiOverride for multi-lib packages..
9253                    // By definition, we need to copy both 32 and 64 bit libraries for
9254                    // such packages.
9255                    if (abiOverride != null) {
9256                        Slog.w(TAG, "Ignoring abiOverride for multi arch application.");
9257                    }
9258
9259                    int copyRet = PackageManager.NO_NATIVE_LIBRARIES;
9260                    if (Build.SUPPORTED_32_BIT_ABIS.length > 0) {
9261                        copyRet = copyNativeLibrariesForInternalApp(handle, libraryRoot,
9262                                Build.SUPPORTED_32_BIT_ABIS, true /* use isa specific subdirs */);
9263                        maybeThrowExceptionForMultiArchCopy("Failure copying 32 bit native libraries", copyRet);
9264                    }
9265
9266                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0) {
9267                        copyRet = copyNativeLibrariesForInternalApp(handle, libraryRoot,
9268                                Build.SUPPORTED_64_BIT_ABIS, true /* use isa specific subdirs */);
9269                        maybeThrowExceptionForMultiArchCopy("Failure copying 64 bit native libraries", copyRet);
9270                    }
9271                } else {
9272                    String[] abiList = (abiOverride != null) ?
9273                            new String[] { abiOverride } : Build.SUPPORTED_ABIS;
9274
9275                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0 && abiOverride == null &&
9276                            NativeLibraryHelper.hasRenderscriptBitcode(handle)) {
9277                        abiList = Build.SUPPORTED_32_BIT_ABIS;
9278                    }
9279
9280                    int copyRet = copyNativeLibrariesForInternalApp(handle, libraryRoot, abiList,
9281                            true /* use isa specific subdirs */);
9282                    if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES) {
9283                        Slog.w(TAG, "Failure copying native libraries [errorCode=" + copyRet + "]");
9284                        return copyRet;
9285                    }
9286                }
9287            } catch (IOException e) {
9288                Slog.e(TAG, "Copying native libraries failed", e);
9289                ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
9290            } catch (PackageManagerException pme) {
9291                Slog.e(TAG, "Copying native libraries failed", pme);
9292                ret = pme.error;
9293            } finally {
9294                IoUtils.closeQuietly(handle);
9295            }
9296
9297            return ret;
9298        }
9299
9300        int doPreInstall(int status) {
9301            if (status != PackageManager.INSTALL_SUCCEEDED) {
9302                cleanUp();
9303            }
9304            return status;
9305        }
9306
9307        boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
9308            if (status != PackageManager.INSTALL_SUCCEEDED) {
9309                cleanUp();
9310                return false;
9311            } else {
9312                final File beforeCodeFile = codeFile;
9313                final File afterCodeFile = getNextCodePath(pkg.packageName);
9314
9315                Slog.d(TAG, "Renaming " + beforeCodeFile + " to " + afterCodeFile);
9316                try {
9317                    Os.rename(beforeCodeFile.getAbsolutePath(), afterCodeFile.getAbsolutePath());
9318                } catch (ErrnoException e) {
9319                    Slog.d(TAG, "Failed to rename", e);
9320                    return false;
9321                }
9322
9323                if (!SELinux.restoreconRecursive(afterCodeFile)) {
9324                    Slog.d(TAG, "Failed to restorecon");
9325                    return false;
9326                }
9327
9328                // Reflect the rename internally
9329                codeFile = afterCodeFile;
9330                resourceFile = afterCodeFile;
9331
9332                // Reflect the rename in scanned details
9333                pkg.codePath = afterCodeFile.getAbsolutePath();
9334                pkg.baseCodePath = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
9335                        pkg.baseCodePath);
9336                pkg.splitCodePaths = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
9337                        pkg.splitCodePaths);
9338
9339                // Reflect the rename in app info
9340                pkg.applicationInfo.setCodePath(pkg.codePath);
9341                pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
9342                pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
9343                pkg.applicationInfo.setResourcePath(pkg.codePath);
9344                pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
9345                pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
9346
9347                return true;
9348            }
9349        }
9350
9351        int doPostInstall(int status, int uid) {
9352            if (status != PackageManager.INSTALL_SUCCEEDED) {
9353                cleanUp();
9354            }
9355            return status;
9356        }
9357
9358        @Override
9359        String getCodePath() {
9360            return (codeFile != null) ? codeFile.getAbsolutePath() : null;
9361        }
9362
9363        @Override
9364        String getResourcePath() {
9365            return (resourceFile != null) ? resourceFile.getAbsolutePath() : null;
9366        }
9367
9368        @Override
9369        String getLegacyNativeLibraryPath() {
9370            return (legacyNativeLibraryPath != null) ? legacyNativeLibraryPath.getAbsolutePath() : null;
9371        }
9372
9373        private boolean cleanUp() {
9374            if (codeFile == null || !codeFile.exists()) {
9375                return false;
9376            }
9377
9378            if (codeFile.isDirectory()) {
9379                FileUtils.deleteContents(codeFile);
9380            }
9381            codeFile.delete();
9382
9383            if (resourceFile != null && !FileUtils.contains(codeFile, resourceFile)) {
9384                resourceFile.delete();
9385            }
9386
9387            if (legacyNativeLibraryPath != null && !FileUtils.contains(codeFile, legacyNativeLibraryPath)) {
9388                if (!FileUtils.deleteContents(legacyNativeLibraryPath)) {
9389                    Slog.w(TAG, "Couldn't delete native library directory " + legacyNativeLibraryPath);
9390                }
9391                legacyNativeLibraryPath.delete();
9392            }
9393
9394            return true;
9395        }
9396
9397        void cleanUpResourcesLI() {
9398            // Try enumerating all code paths before deleting
9399            List<String> allCodePaths = Collections.EMPTY_LIST;
9400            if (codeFile != null && codeFile.exists()) {
9401                try {
9402                    final PackageLite pkg = PackageParser.parsePackageLite(codeFile, 0);
9403                    allCodePaths = pkg.getAllCodePaths();
9404                } catch (PackageParserException e) {
9405                    // Ignored; we tried our best
9406                }
9407            }
9408
9409            cleanUp();
9410
9411            if (!allCodePaths.isEmpty()) {
9412                if (instructionSets == null) {
9413                    throw new IllegalStateException("instructionSet == null");
9414                }
9415
9416                for (String codePath : allCodePaths) {
9417                    for (String instructionSet : instructionSets) {
9418                        int retCode = mInstaller.rmdex(codePath, instructionSet);
9419                        if (retCode < 0) {
9420                            Slog.w(TAG, "Couldn't remove dex file for package: "
9421                                    + " at location " + codePath + ", retcode=" + retCode);
9422                            // we don't consider this to be a failure of the core package deletion
9423                        }
9424                    }
9425                }
9426            }
9427        }
9428
9429        boolean doPostDeleteLI(boolean delete) {
9430            // XXX err, shouldn't we respect the delete flag?
9431            cleanUpResourcesLI();
9432            return true;
9433        }
9434    }
9435
9436    private boolean isAsecExternal(String cid) {
9437        final String asecPath = PackageHelper.getSdFilesystem(cid);
9438        return !asecPath.startsWith(mAsecInternalPath);
9439    }
9440
9441    private static void maybeThrowExceptionForMultiArchCopy(String message, int copyRet) throws
9442            PackageManagerException {
9443        if (copyRet < 0) {
9444            if (copyRet != PackageManager.NO_NATIVE_LIBRARIES &&
9445                    copyRet != PackageManager.INSTALL_FAILED_NO_MATCHING_ABIS) {
9446                throw new PackageManagerException(copyRet, message);
9447            }
9448        }
9449    }
9450
9451    /**
9452     * Extract the MountService "container ID" from the full code path of an
9453     * .apk.
9454     */
9455    static String cidFromCodePath(String fullCodePath) {
9456        int eidx = fullCodePath.lastIndexOf("/");
9457        String subStr1 = fullCodePath.substring(0, eidx);
9458        int sidx = subStr1.lastIndexOf("/");
9459        return subStr1.substring(sidx+1, eidx);
9460    }
9461
9462    /**
9463     * Logic to handle installation of ASEC applications, including copying and
9464     * renaming logic.
9465     */
9466    class AsecInstallArgs extends InstallArgs {
9467        // TODO: teach about handling cluster directories
9468
9469        static final String RES_FILE_NAME = "pkg.apk";
9470        static final String PUBLIC_RES_FILE_NAME = "res.zip";
9471
9472        String cid;
9473        String packagePath;
9474        String resourcePath;
9475        String legacyNativeLibraryDir;
9476
9477        /** New install */
9478        AsecInstallArgs(InstallParams params) {
9479            super(params.originFile, params.originStaged, params.observer, params.flags,
9480                    params.installerPackageName, params.getManifestDigest(),
9481                    params.getUser(), null /* instruction sets */,
9482                    params.packageAbiOverride, params.multiArch);
9483        }
9484
9485        /** Existing install */
9486        AsecInstallArgs(String fullCodePath, String[] instructionSets,
9487                        boolean isExternal, boolean isForwardLocked, boolean isMultiArch) {
9488            super(null, false, null, (isExternal ? INSTALL_EXTERNAL : 0)
9489                    | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null,
9490                    instructionSets, null, isMultiArch);
9491            // Extract cid from fullCodePath
9492            int eidx = fullCodePath.lastIndexOf("/");
9493            String subStr1 = fullCodePath.substring(0, eidx);
9494            int sidx = subStr1.lastIndexOf("/");
9495            cid = subStr1.substring(sidx+1, eidx);
9496            setCachePath(subStr1);
9497        }
9498
9499        AsecInstallArgs(String cid, String[] instructionSets, boolean isForwardLocked,
9500                        boolean isMultiArch) {
9501            super(null, false, null, (isAsecExternal(cid) ? INSTALL_EXTERNAL : 0)
9502                    | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null,
9503                    instructionSets, null, isMultiArch);
9504            this.cid = cid;
9505            setCachePath(PackageHelper.getSdDir(cid));
9506        }
9507
9508        /** New install from existing */
9509        AsecInstallArgs(File originPackageFile, String cid, String[] instructionSets,
9510                boolean isExternal, boolean isForwardLocked, boolean isMultiArch) {
9511            super(originPackageFile, false, null, (isExternal ? INSTALL_EXTERNAL : 0)
9512                    | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null,
9513                    instructionSets, null, isMultiArch);
9514            this.cid = cid;
9515        }
9516
9517        void createCopyFile() {
9518            cid = getTempContainerId();
9519        }
9520
9521        boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException {
9522            return imcs.checkExternalFreeStorage(originFile.getAbsolutePath(), isFwdLocked(),
9523                    abiOverride);
9524        }
9525
9526        private final boolean isExternal() {
9527            return (flags & PackageManager.INSTALL_EXTERNAL) != 0;
9528        }
9529
9530        int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
9531            if (temp) {
9532                createCopyFile();
9533            } else {
9534                /*
9535                 * Pre-emptively destroy the container since it's destroyed if
9536                 * copying fails due to it existing anyway.
9537                 */
9538                PackageHelper.destroySdDir(cid);
9539            }
9540
9541            final String newCachePath = imcs.copyPackageToContainer(
9542                    originFile.getAbsolutePath(), cid, getEncryptKey(), isExternal(),
9543                    isFwdLocked(), abiOverride);
9544
9545            if (newCachePath != null) {
9546                setCachePath(newCachePath);
9547                return PackageManager.INSTALL_SUCCEEDED;
9548            } else {
9549                return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9550            }
9551        }
9552
9553        @Override
9554        String getCodePath() {
9555            return packagePath;
9556        }
9557
9558        @Override
9559        String getResourcePath() {
9560            return resourcePath;
9561        }
9562
9563        @Override
9564        String getLegacyNativeLibraryPath() {
9565            return legacyNativeLibraryDir;
9566        }
9567
9568        int doPreInstall(int status) {
9569            if (status != PackageManager.INSTALL_SUCCEEDED) {
9570                // Destroy container
9571                PackageHelper.destroySdDir(cid);
9572            } else {
9573                boolean mounted = PackageHelper.isContainerMounted(cid);
9574                if (!mounted) {
9575                    String newCachePath = PackageHelper.mountSdDir(cid, getEncryptKey(),
9576                            Process.SYSTEM_UID);
9577                    if (newCachePath != null) {
9578                        setCachePath(newCachePath);
9579                    } else {
9580                        return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9581                    }
9582                }
9583            }
9584            return status;
9585        }
9586
9587        boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
9588            String newCacheId = getNextCodePath(oldCodePath, pkg.packageName, "/" + RES_FILE_NAME);
9589            String newCachePath = null;
9590            if (PackageHelper.isContainerMounted(cid)) {
9591                // Unmount the container
9592                if (!PackageHelper.unMountSdDir(cid)) {
9593                    Slog.i(TAG, "Failed to unmount " + cid + " before renaming");
9594                    return false;
9595                }
9596            }
9597            if (!PackageHelper.renameSdDir(cid, newCacheId)) {
9598                Slog.e(TAG, "Failed to rename " + cid + " to " + newCacheId +
9599                        " which might be stale. Will try to clean up.");
9600                // Clean up the stale container and proceed to recreate.
9601                if (!PackageHelper.destroySdDir(newCacheId)) {
9602                    Slog.e(TAG, "Very strange. Cannot clean up stale container " + newCacheId);
9603                    return false;
9604                }
9605                // Successfully cleaned up stale container. Try to rename again.
9606                if (!PackageHelper.renameSdDir(cid, newCacheId)) {
9607                    Slog.e(TAG, "Failed to rename " + cid + " to " + newCacheId
9608                            + " inspite of cleaning it up.");
9609                    return false;
9610                }
9611            }
9612            if (!PackageHelper.isContainerMounted(newCacheId)) {
9613                Slog.w(TAG, "Mounting container " + newCacheId);
9614                newCachePath = PackageHelper.mountSdDir(newCacheId,
9615                        getEncryptKey(), Process.SYSTEM_UID);
9616            } else {
9617                newCachePath = PackageHelper.getSdDir(newCacheId);
9618            }
9619            if (newCachePath == null) {
9620                Slog.w(TAG, "Failed to get cache path for  " + newCacheId);
9621                return false;
9622            }
9623            Log.i(TAG, "Succesfully renamed " + cid +
9624                    " to " + newCacheId +
9625                    " at new path: " + newCachePath);
9626            cid = newCacheId;
9627            setCachePath(newCachePath);
9628
9629            // TODO: extend to support split APKs
9630            pkg.codePath = getCodePath();
9631            pkg.baseCodePath = getCodePath();
9632            pkg.splitCodePaths = null;
9633
9634            pkg.applicationInfo.setCodePath(getCodePath());
9635            pkg.applicationInfo.setBaseCodePath(getCodePath());
9636            pkg.applicationInfo.setSplitCodePaths(null);
9637            pkg.applicationInfo.setResourcePath(getResourcePath());
9638            pkg.applicationInfo.setBaseResourcePath(getResourcePath());
9639            pkg.applicationInfo.setSplitResourcePaths(null);
9640
9641            return true;
9642        }
9643
9644        private void setCachePath(String newCachePath) {
9645            File cachePath = new File(newCachePath);
9646            legacyNativeLibraryDir = new File(cachePath, LIB_DIR_NAME).getPath();
9647            packagePath = new File(cachePath, RES_FILE_NAME).getPath();
9648
9649            if (isFwdLocked()) {
9650                resourcePath = new File(cachePath, PUBLIC_RES_FILE_NAME).getPath();
9651            } else {
9652                resourcePath = packagePath;
9653            }
9654        }
9655
9656        int doPostInstall(int status, int uid) {
9657            if (status != PackageManager.INSTALL_SUCCEEDED) {
9658                cleanUp();
9659            } else {
9660                final int groupOwner;
9661                final String protectedFile;
9662                if (isFwdLocked()) {
9663                    groupOwner = UserHandle.getSharedAppGid(uid);
9664                    protectedFile = RES_FILE_NAME;
9665                } else {
9666                    groupOwner = -1;
9667                    protectedFile = null;
9668                }
9669
9670                if (uid < Process.FIRST_APPLICATION_UID
9671                        || !PackageHelper.fixSdPermissions(cid, groupOwner, protectedFile)) {
9672                    Slog.e(TAG, "Failed to finalize " + cid);
9673                    PackageHelper.destroySdDir(cid);
9674                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9675                }
9676
9677                boolean mounted = PackageHelper.isContainerMounted(cid);
9678                if (!mounted) {
9679                    PackageHelper.mountSdDir(cid, getEncryptKey(), Process.myUid());
9680                }
9681            }
9682            return status;
9683        }
9684
9685        private void cleanUp() {
9686            if (DEBUG_SD_INSTALL) Slog.i(TAG, "cleanUp");
9687
9688            // Destroy secure container
9689            PackageHelper.destroySdDir(cid);
9690        }
9691
9692        void cleanUpResourcesLI() {
9693            String sourceFile = getCodePath();
9694            // Remove dex file
9695            if (instructionSets == null) {
9696                throw new IllegalStateException("instructionSet == null");
9697            }
9698            for (String instructionSet : instructionSets) {
9699                int retCode = mInstaller.rmdex(sourceFile, instructionSet);
9700                if (retCode < 0) {
9701                    Slog.w(TAG, "Couldn't remove dex file for package: "
9702                            + " at location "
9703                            + sourceFile.toString() + ", retcode=" + retCode);
9704                    // we don't consider this to be a failure of the core package deletion
9705                }
9706            }
9707            cleanUp();
9708        }
9709
9710        boolean matchContainer(String app) {
9711            if (cid.startsWith(app)) {
9712                return true;
9713            }
9714            return false;
9715        }
9716
9717        String getPackageName() {
9718            return getAsecPackageName(cid);
9719        }
9720
9721        boolean doPostDeleteLI(boolean delete) {
9722            boolean ret = false;
9723            boolean mounted = PackageHelper.isContainerMounted(cid);
9724            if (mounted) {
9725                // Unmount first
9726                ret = PackageHelper.unMountSdDir(cid);
9727            }
9728            if (ret && delete) {
9729                cleanUpResourcesLI();
9730            }
9731            return ret;
9732        }
9733
9734        @Override
9735        int doPreCopy() {
9736            if (isFwdLocked()) {
9737                if (!PackageHelper.fixSdPermissions(cid,
9738                        getPackageUid(DEFAULT_CONTAINER_PACKAGE, 0), RES_FILE_NAME)) {
9739                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9740                }
9741            }
9742
9743            return PackageManager.INSTALL_SUCCEEDED;
9744        }
9745
9746        @Override
9747        int doPostCopy(int uid) {
9748            if (isFwdLocked()) {
9749                if (uid < Process.FIRST_APPLICATION_UID
9750                        || !PackageHelper.fixSdPermissions(cid, UserHandle.getSharedAppGid(uid),
9751                                RES_FILE_NAME)) {
9752                    Slog.e(TAG, "Failed to finalize " + cid);
9753                    PackageHelper.destroySdDir(cid);
9754                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9755                }
9756            }
9757
9758            return PackageManager.INSTALL_SUCCEEDED;
9759        }
9760    }
9761
9762    static String getAsecPackageName(String packageCid) {
9763        int idx = packageCid.lastIndexOf("-");
9764        if (idx == -1) {
9765            return packageCid;
9766        }
9767        return packageCid.substring(0, idx);
9768    }
9769
9770    // Utility method used to create code paths based on package name and available index.
9771    private static String getNextCodePath(String oldCodePath, String prefix, String suffix) {
9772        String idxStr = "";
9773        int idx = 1;
9774        // Fall back to default value of idx=1 if prefix is not
9775        // part of oldCodePath
9776        if (oldCodePath != null) {
9777            String subStr = oldCodePath;
9778            // Drop the suffix right away
9779            if (suffix != null && subStr.endsWith(suffix)) {
9780                subStr = subStr.substring(0, subStr.length() - suffix.length());
9781            }
9782            // If oldCodePath already contains prefix find out the
9783            // ending index to either increment or decrement.
9784            int sidx = subStr.lastIndexOf(prefix);
9785            if (sidx != -1) {
9786                subStr = subStr.substring(sidx + prefix.length());
9787                if (subStr != null) {
9788                    if (subStr.startsWith(INSTALL_PACKAGE_SUFFIX)) {
9789                        subStr = subStr.substring(INSTALL_PACKAGE_SUFFIX.length());
9790                    }
9791                    try {
9792                        idx = Integer.parseInt(subStr);
9793                        if (idx <= 1) {
9794                            idx++;
9795                        } else {
9796                            idx--;
9797                        }
9798                    } catch(NumberFormatException e) {
9799                    }
9800                }
9801            }
9802        }
9803        idxStr = INSTALL_PACKAGE_SUFFIX + Integer.toString(idx);
9804        return prefix + idxStr;
9805    }
9806
9807    private File getNextCodePath(String packageName) {
9808        int suffix = 1;
9809        File result;
9810        do {
9811            result = new File(mAppInstallDir, packageName + "-" + suffix);
9812            suffix++;
9813        } while (result.exists());
9814        return result;
9815    }
9816
9817    // Utility method used to ignore ADD/REMOVE events
9818    // by directory observer.
9819    private static boolean ignoreCodePath(String fullPathStr) {
9820        String apkName = deriveCodePathName(fullPathStr);
9821        int idx = apkName.lastIndexOf(INSTALL_PACKAGE_SUFFIX);
9822        if (idx != -1 && ((idx+1) < apkName.length())) {
9823            // Make sure the package ends with a numeral
9824            String version = apkName.substring(idx+1);
9825            try {
9826                Integer.parseInt(version);
9827                return true;
9828            } catch (NumberFormatException e) {}
9829        }
9830        return false;
9831    }
9832
9833    // Utility method that returns the relative package path with respect
9834    // to the installation directory. Like say for /data/data/com.test-1.apk
9835    // string com.test-1 is returned.
9836    static String deriveCodePathName(String codePath) {
9837        if (codePath == null) {
9838            return null;
9839        }
9840        final File codeFile = new File(codePath);
9841        final String name = codeFile.getName();
9842        if (codeFile.isDirectory()) {
9843            return name;
9844        } else if (name.endsWith(".apk") || name.endsWith(".tmp")) {
9845            final int lastDot = name.lastIndexOf('.');
9846            return name.substring(0, lastDot);
9847        } else {
9848            Slog.w(TAG, "Odd, " + codePath + " doesn't look like an APK");
9849            return null;
9850        }
9851    }
9852
9853    class PackageInstalledInfo {
9854        String name;
9855        int uid;
9856        // The set of users that originally had this package installed.
9857        int[] origUsers;
9858        // The set of users that now have this package installed.
9859        int[] newUsers;
9860        PackageParser.Package pkg;
9861        int returnCode;
9862        String returnMsg;
9863        PackageRemovedInfo removedInfo;
9864
9865        public void setError(int code, String msg) {
9866            returnCode = code;
9867            returnMsg = msg;
9868            Slog.w(TAG, msg);
9869        }
9870
9871        public void setError(String msg, PackageParserException e) {
9872            returnCode = e.error;
9873            returnMsg = ExceptionUtils.getCompleteMessage(msg, e);
9874            Slog.w(TAG, msg, e);
9875        }
9876
9877        public void setError(String msg, PackageManagerException e) {
9878            returnCode = e.error;
9879            returnMsg = ExceptionUtils.getCompleteMessage(msg, e);
9880            Slog.w(TAG, msg, e);
9881        }
9882
9883        // In some error cases we want to convey more info back to the observer
9884        String origPackage;
9885        String origPermission;
9886    }
9887
9888    /*
9889     * Install a non-existing package.
9890     */
9891    private void installNewPackageLI(PackageParser.Package pkg,
9892            int parseFlags, int scanMode, UserHandle user,
9893            String installerPackageName, PackageInstalledInfo res, String abiOverride) {
9894        // Remember this for later, in case we need to rollback this install
9895        String pkgName = pkg.packageName;
9896
9897        if (DEBUG_INSTALL) Slog.d(TAG, "installNewPackageLI: " + pkg);
9898        boolean dataDirExists = getDataPathForPackage(pkg.packageName, 0).exists();
9899        synchronized(mPackages) {
9900            if (mSettings.mRenamedPackages.containsKey(pkgName)) {
9901                // A package with the same name is already installed, though
9902                // it has been renamed to an older name.  The package we
9903                // are trying to install should be installed as an update to
9904                // the existing one, but that has not been requested, so bail.
9905                res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
9906                        + " without first uninstalling package running as "
9907                        + mSettings.mRenamedPackages.get(pkgName));
9908                return;
9909            }
9910            if (mPackages.containsKey(pkgName) || mAppDirs.containsKey(pkg.codePath)) {
9911                // Don't allow installation over an existing package with the same name.
9912                res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
9913                        + " without first uninstalling.");
9914                return;
9915            }
9916        }
9917
9918        try {
9919            PackageParser.Package newPackage = scanPackageLI(pkg, parseFlags, scanMode,
9920                    System.currentTimeMillis(), user, abiOverride);
9921
9922            updateSettingsLI(newPackage, installerPackageName, null, null, res);
9923            // delete the partially installed application. the data directory will have to be
9924            // restored if it was already existing
9925            if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
9926                // remove package from internal structures.  Note that we want deletePackageX to
9927                // delete the package data and cache directories that it created in
9928                // scanPackageLocked, unless those directories existed before we even tried to
9929                // install.
9930                deletePackageLI(pkgName, UserHandle.ALL, false, null, null,
9931                        dataDirExists ? PackageManager.DELETE_KEEP_DATA : 0,
9932                                res.removedInfo, true);
9933            }
9934
9935        } catch (PackageManagerException e) {
9936            res.setError("Package couldn't be installed in " + pkg.codePath, e);
9937        }
9938    }
9939
9940    private boolean checkUpgradeKeySetLP(PackageSetting oldPS, PackageParser.Package newPkg) {
9941        // Upgrade keysets are being used.  Determine if new package has a superset of the
9942        // required keys.
9943        long[] upgradeKeySets = oldPS.keySetData.getUpgradeKeySets();
9944        KeySetManagerService ksms = mSettings.mKeySetManagerService;
9945        for (int i = 0; i < upgradeKeySets.length; i++) {
9946            Set<PublicKey> upgradeSet = ksms.getPublicKeysFromKeySetLPr(upgradeKeySets[i]);
9947            if (newPkg.mSigningKeys.containsAll(upgradeSet)) {
9948                return true;
9949            }
9950        }
9951        return false;
9952    }
9953
9954    private void replacePackageLI(PackageParser.Package pkg,
9955            int parseFlags, int scanMode, UserHandle user,
9956            String installerPackageName, PackageInstalledInfo res, String abiOverride) {
9957        PackageParser.Package oldPackage;
9958        String pkgName = pkg.packageName;
9959        int[] allUsers;
9960        boolean[] perUserInstalled;
9961
9962        // First find the old package info and check signatures
9963        synchronized(mPackages) {
9964            oldPackage = mPackages.get(pkgName);
9965            if (DEBUG_INSTALL) Slog.d(TAG, "replacePackageLI: new=" + pkg + ", old=" + oldPackage);
9966            PackageSetting ps = mSettings.mPackages.get(pkgName);
9967            if (ps == null || !ps.keySetData.isUsingUpgradeKeySets() || ps.sharedUser != null) {
9968                // default to original signature matching
9969                if (compareSignatures(oldPackage.mSignatures, pkg.mSignatures)
9970                    != PackageManager.SIGNATURE_MATCH) {
9971                    res.setError(INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
9972                            "New package has a different signature: " + pkgName);
9973                    return;
9974                }
9975            } else {
9976                if(!checkUpgradeKeySetLP(ps, pkg)) {
9977                    res.setError(INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
9978                            "New package not signed by keys specified by upgrade-keysets: "
9979                            + pkgName);
9980                    return;
9981                }
9982            }
9983
9984            // In case of rollback, remember per-user/profile install state
9985            allUsers = sUserManager.getUserIds();
9986            perUserInstalled = new boolean[allUsers.length];
9987            for (int i = 0; i < allUsers.length; i++) {
9988                perUserInstalled[i] = ps != null ? ps.getInstalled(allUsers[i]) : false;
9989            }
9990        }
9991        boolean sysPkg = (isSystemApp(oldPackage));
9992        if (sysPkg) {
9993            replaceSystemPackageLI(oldPackage, pkg, parseFlags, scanMode,
9994                    user, allUsers, perUserInstalled, installerPackageName, res,
9995                    abiOverride);
9996        } else {
9997            replaceNonSystemPackageLI(oldPackage, pkg, parseFlags, scanMode,
9998                    user, allUsers, perUserInstalled, installerPackageName, res,
9999                    abiOverride);
10000        }
10001    }
10002
10003    private void replaceNonSystemPackageLI(PackageParser.Package deletedPackage,
10004            PackageParser.Package pkg, int parseFlags, int scanMode, UserHandle user,
10005            int[] allUsers, boolean[] perUserInstalled,
10006            String installerPackageName, PackageInstalledInfo res, String abiOverride) {
10007        String pkgName = deletedPackage.packageName;
10008        boolean deletedPkg = true;
10009        boolean updatedSettings = false;
10010
10011        if (DEBUG_INSTALL) Slog.d(TAG, "replaceNonSystemPackageLI: new=" + pkg + ", old="
10012                + deletedPackage);
10013        long origUpdateTime;
10014        if (pkg.mExtras != null) {
10015            origUpdateTime = ((PackageSetting)pkg.mExtras).lastUpdateTime;
10016        } else {
10017            origUpdateTime = 0;
10018        }
10019
10020        // First delete the existing package while retaining the data directory
10021        if (!deletePackageLI(pkgName, null, true, null, null, PackageManager.DELETE_KEEP_DATA,
10022                res.removedInfo, true)) {
10023            // If the existing package wasn't successfully deleted
10024            res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE, "replaceNonSystemPackageLI");
10025            deletedPkg = false;
10026        } else {
10027            // Successfully deleted the old package. Now proceed with re-installation
10028            try {
10029                final PackageParser.Package newPackage = scanPackageLI(pkg, parseFlags,
10030                        scanMode | SCAN_UPDATE_TIME, System.currentTimeMillis(), user, abiOverride);
10031                updateSettingsLI(newPackage, installerPackageName, allUsers, perUserInstalled, res);
10032                updatedSettings = true;
10033            } catch (PackageManagerException e) {
10034                res.setError("Package couldn't be installed in " + pkg.codePath, e);
10035            }
10036        }
10037
10038        if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
10039            // remove package from internal structures.  Note that we want deletePackageX to
10040            // delete the package data and cache directories that it created in
10041            // scanPackageLocked, unless those directories existed before we even tried to
10042            // install.
10043            if(updatedSettings) {
10044                if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, rolling pack: " + pkgName);
10045                deletePackageLI(
10046                        pkgName, null, true, allUsers, perUserInstalled,
10047                        PackageManager.DELETE_KEEP_DATA,
10048                                res.removedInfo, true);
10049            }
10050            // Since we failed to install the new package we need to restore the old
10051            // package that we deleted.
10052            if (deletedPkg) {
10053                if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, reinstalling: " + deletedPackage);
10054                File restoreFile = new File(deletedPackage.codePath);
10055                // Parse old package
10056                boolean oldOnSd = isExternal(deletedPackage);
10057                int oldParseFlags  = mDefParseFlags | PackageParser.PARSE_CHATTY |
10058                        (isForwardLocked(deletedPackage) ? PackageParser.PARSE_FORWARD_LOCK : 0) |
10059                        (oldOnSd ? PackageParser.PARSE_ON_SDCARD : 0);
10060                int oldScanMode = (oldOnSd ? 0 : SCAN_MONITOR) | SCAN_UPDATE_SIGNATURE
10061                        | SCAN_UPDATE_TIME;
10062                try {
10063                    scanPackageLI(restoreFile, oldParseFlags, oldScanMode, origUpdateTime, null,
10064                            null);
10065                } catch (PackageManagerException e) {
10066                    Slog.e(TAG, "Failed to restore package : " + pkgName + " after failed upgrade: "
10067                            + e.getMessage());
10068                    return;
10069                }
10070                // Restore of old package succeeded. Update permissions.
10071                // writer
10072                synchronized (mPackages) {
10073                    updatePermissionsLPw(deletedPackage.packageName, deletedPackage,
10074                            UPDATE_PERMISSIONS_ALL);
10075                    // can downgrade to reader
10076                    mSettings.writeLPr();
10077                }
10078                Slog.i(TAG, "Successfully restored package : " + pkgName + " after failed upgrade");
10079            }
10080        }
10081    }
10082
10083    private void replaceSystemPackageLI(PackageParser.Package deletedPackage,
10084            PackageParser.Package pkg, int parseFlags, int scanMode, UserHandle user,
10085            int[] allUsers, boolean[] perUserInstalled,
10086            String installerPackageName, PackageInstalledInfo res, String abiOverride) {
10087        if (DEBUG_INSTALL) Slog.d(TAG, "replaceSystemPackageLI: new=" + pkg
10088                + ", old=" + deletedPackage);
10089        boolean updatedSettings = false;
10090        parseFlags |= PackageManager.INSTALL_REPLACE_EXISTING |
10091                PackageParser.PARSE_IS_SYSTEM;
10092        if ((deletedPackage.applicationInfo.flags&ApplicationInfo.FLAG_PRIVILEGED) != 0) {
10093            parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
10094        }
10095        String packageName = deletedPackage.packageName;
10096        if (packageName == null) {
10097            res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
10098                    "Attempt to delete null packageName.");
10099            return;
10100        }
10101        PackageParser.Package oldPkg;
10102        PackageSetting oldPkgSetting;
10103        // reader
10104        synchronized (mPackages) {
10105            oldPkg = mPackages.get(packageName);
10106            oldPkgSetting = mSettings.mPackages.get(packageName);
10107            if((oldPkg == null) || (oldPkg.applicationInfo == null) ||
10108                    (oldPkgSetting == null)) {
10109                res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
10110                        "Couldn't find package:" + packageName + " information");
10111                return;
10112            }
10113        }
10114
10115        killApplication(packageName, oldPkg.applicationInfo.uid, "replace sys pkg");
10116
10117        res.removedInfo.uid = oldPkg.applicationInfo.uid;
10118        res.removedInfo.removedPackage = packageName;
10119        // Remove existing system package
10120        removePackageLI(oldPkgSetting, true);
10121        // writer
10122        synchronized (mPackages) {
10123            if (!mSettings.disableSystemPackageLPw(packageName) && deletedPackage != null) {
10124                // We didn't need to disable the .apk as a current system package,
10125                // which means we are replacing another update that is already
10126                // installed.  We need to make sure to delete the older one's .apk.
10127                res.removedInfo.args = createInstallArgsForExisting(0,
10128                        deletedPackage.applicationInfo.getCodePath(),
10129                        deletedPackage.applicationInfo.getResourcePath(),
10130                        deletedPackage.applicationInfo.nativeLibraryRootDir,
10131                        getAppDexInstructionSets(deletedPackage.applicationInfo),
10132                        isMultiArch(deletedPackage.applicationInfo));
10133            } else {
10134                res.removedInfo.args = null;
10135            }
10136        }
10137
10138        // Successfully disabled the old package. Now proceed with re-installation
10139        res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10140        pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
10141
10142        PackageParser.Package newPackage = null;
10143        try {
10144            newPackage = scanPackageLI(pkg, parseFlags, scanMode, 0, user, abiOverride);
10145            if (newPackage.mExtras != null) {
10146                final PackageSetting newPkgSetting = (PackageSetting) newPackage.mExtras;
10147                newPkgSetting.firstInstallTime = oldPkgSetting.firstInstallTime;
10148                newPkgSetting.lastUpdateTime = System.currentTimeMillis();
10149
10150                // is the update attempting to change shared user? that isn't going to work...
10151                if (oldPkgSetting.sharedUser != newPkgSetting.sharedUser) {
10152                    res.setError(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
10153                            "Forbidding shared user change from " + oldPkgSetting.sharedUser
10154                            + " to " + newPkgSetting.sharedUser);
10155                    updatedSettings = true;
10156                }
10157            }
10158
10159            if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
10160                updateSettingsLI(newPackage, installerPackageName, allUsers, perUserInstalled, res);
10161                updatedSettings = true;
10162            }
10163
10164        } catch (PackageManagerException e) {
10165            res.setError("Package couldn't be installed in " + pkg.codePath, e);
10166        }
10167
10168        if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
10169            // Re installation failed. Restore old information
10170            // Remove new pkg information
10171            if (newPackage != null) {
10172                removeInstalledPackageLI(newPackage, true);
10173            }
10174            // Add back the old system package
10175            try {
10176                scanPackageLI(oldPkg, parseFlags, SCAN_MONITOR | SCAN_UPDATE_SIGNATURE, 0, user,
10177                        null);
10178            } catch (PackageManagerException e) {
10179                Slog.e(TAG, "Failed to restore original package: " + e.getMessage());
10180            }
10181            // Restore the old system information in Settings
10182            synchronized(mPackages) {
10183                if (updatedSettings) {
10184                    mSettings.enableSystemPackageLPw(packageName);
10185                    mSettings.setInstallerPackageName(packageName,
10186                            oldPkgSetting.installerPackageName);
10187                }
10188                mSettings.writeLPr();
10189            }
10190        }
10191    }
10192
10193    // Utility method used to move dex files during install.
10194    private int moveDexFilesLI(String oldCodePath, PackageParser.Package newPackage) {
10195        // TODO: extend to move split APK dex files
10196        if ((newPackage.applicationInfo.flags&ApplicationInfo.FLAG_HAS_CODE) != 0) {
10197            final String[] instructionSets = getAppDexInstructionSets(newPackage.applicationInfo);
10198            for (String instructionSet : instructionSets) {
10199                int retCode = mInstaller.movedex(oldCodePath, newPackage.baseCodePath,
10200                        instructionSet);
10201                if (retCode != 0) {
10202                /*
10203                 * Programs may be lazily run through dexopt, so the
10204                 * source may not exist. However, something seems to
10205                 * have gone wrong, so note that dexopt needs to be
10206                 * run again and remove the source file. In addition,
10207                 * remove the target to make sure there isn't a stale
10208                 * file from a previous version of the package.
10209                 */
10210                    newPackage.mDexOptNeeded = true;
10211                    mInstaller.rmdex(oldCodePath, instructionSet);
10212                    mInstaller.rmdex(newPackage.baseCodePath, instructionSet);
10213                }
10214            }
10215        }
10216        return PackageManager.INSTALL_SUCCEEDED;
10217    }
10218
10219    private void updateSettingsLI(PackageParser.Package newPackage, String installerPackageName,
10220            int[] allUsers, boolean[] perUserInstalled,
10221            PackageInstalledInfo res) {
10222        String pkgName = newPackage.packageName;
10223        synchronized (mPackages) {
10224            //write settings. the installStatus will be incomplete at this stage.
10225            //note that the new package setting would have already been
10226            //added to mPackages. It hasn't been persisted yet.
10227            mSettings.setInstallStatus(pkgName, PackageSettingBase.PKG_INSTALL_INCOMPLETE);
10228            mSettings.writeLPr();
10229        }
10230
10231        if (DEBUG_INSTALL) Slog.d(TAG, "New package installed in " + newPackage.codePath);
10232
10233        synchronized (mPackages) {
10234            updatePermissionsLPw(newPackage.packageName, newPackage,
10235                    UPDATE_PERMISSIONS_REPLACE_PKG | (newPackage.permissions.size() > 0
10236                            ? UPDATE_PERMISSIONS_ALL : 0));
10237            // For system-bundled packages, we assume that installing an upgraded version
10238            // of the package implies that the user actually wants to run that new code,
10239            // so we enable the package.
10240            if (isSystemApp(newPackage)) {
10241                // NB: implicit assumption that system package upgrades apply to all users
10242                if (DEBUG_INSTALL) {
10243                    Slog.d(TAG, "Implicitly enabling system package on upgrade: " + pkgName);
10244                }
10245                PackageSetting ps = mSettings.mPackages.get(pkgName);
10246                if (ps != null) {
10247                    if (res.origUsers != null) {
10248                        for (int userHandle : res.origUsers) {
10249                            ps.setEnabled(COMPONENT_ENABLED_STATE_DEFAULT,
10250                                    userHandle, installerPackageName);
10251                        }
10252                    }
10253                    // Also convey the prior install/uninstall state
10254                    if (allUsers != null && perUserInstalled != null) {
10255                        for (int i = 0; i < allUsers.length; i++) {
10256                            if (DEBUG_INSTALL) {
10257                                Slog.d(TAG, "    user " + allUsers[i]
10258                                        + " => " + perUserInstalled[i]);
10259                            }
10260                            ps.setInstalled(perUserInstalled[i], allUsers[i]);
10261                        }
10262                        // these install state changes will be persisted in the
10263                        // upcoming call to mSettings.writeLPr().
10264                    }
10265                }
10266            }
10267            res.name = pkgName;
10268            res.uid = newPackage.applicationInfo.uid;
10269            res.pkg = newPackage;
10270            mSettings.setInstallStatus(pkgName, PackageSettingBase.PKG_INSTALL_COMPLETE);
10271            mSettings.setInstallerPackageName(pkgName, installerPackageName);
10272            res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10273            //to update install status
10274            mSettings.writeLPr();
10275        }
10276    }
10277
10278    private void installPackageLI(InstallArgs args, boolean newInstall, PackageInstalledInfo res) {
10279        int pFlags = args.flags;
10280        String installerPackageName = args.installerPackageName;
10281        File tmpPackageFile = new File(args.getCodePath());
10282        boolean forwardLocked = ((pFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0);
10283        boolean onSd = ((pFlags & PackageManager.INSTALL_EXTERNAL) != 0);
10284        boolean replace = false;
10285        int scanMode = (onSd ? 0 : SCAN_MONITOR) | SCAN_FORCE_DEX | SCAN_UPDATE_SIGNATURE
10286                | (newInstall ? SCAN_NEW_INSTALL : 0);
10287        // Result object to be returned
10288        res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10289
10290        if (DEBUG_INSTALL) Slog.d(TAG, "installPackageLI: path=" + tmpPackageFile);
10291        // Retrieve PackageSettings and parse package
10292        int parseFlags = mDefParseFlags | PackageParser.PARSE_CHATTY
10293                | (forwardLocked ? PackageParser.PARSE_FORWARD_LOCK : 0)
10294                | (onSd ? PackageParser.PARSE_ON_SDCARD : 0);
10295        PackageParser pp = new PackageParser();
10296        pp.setSeparateProcesses(mSeparateProcesses);
10297        pp.setDisplayMetrics(mMetrics);
10298
10299        final PackageParser.Package pkg;
10300        try {
10301            pkg = pp.parsePackage(tmpPackageFile, parseFlags);
10302        } catch (PackageParserException e) {
10303            res.setError("Failed parse during installPackageLI", e);
10304            return;
10305        }
10306
10307        String pkgName = res.name = pkg.packageName;
10308        if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_TEST_ONLY) != 0) {
10309            if ((pFlags&PackageManager.INSTALL_ALLOW_TEST) == 0) {
10310                res.setError(INSTALL_FAILED_TEST_ONLY, "installPackageLI");
10311                return;
10312            }
10313        }
10314
10315        try {
10316            pp.collectCertificates(pkg, parseFlags);
10317            pp.collectManifestDigest(pkg);
10318        } catch (PackageParserException e) {
10319            res.setError("Failed collect during installPackageLI", e);
10320            return;
10321        }
10322
10323        /* If the installer passed in a manifest digest, compare it now. */
10324        if (args.manifestDigest != null) {
10325            if (DEBUG_INSTALL) {
10326                final String parsedManifest = pkg.manifestDigest == null ? "null"
10327                        : pkg.manifestDigest.toString();
10328                Slog.d(TAG, "Comparing manifests: " + args.manifestDigest.toString() + " vs. "
10329                        + parsedManifest);
10330            }
10331
10332            if (!args.manifestDigest.equals(pkg.manifestDigest)) {
10333                res.setError(INSTALL_FAILED_PACKAGE_CHANGED, "Manifest digest changed");
10334                return;
10335            }
10336        } else if (DEBUG_INSTALL) {
10337            final String parsedManifest = pkg.manifestDigest == null
10338                    ? "null" : pkg.manifestDigest.toString();
10339            Slog.d(TAG, "manifestDigest was not present, but parser got: " + parsedManifest);
10340        }
10341
10342        // Get rid of all references to package scan path via parser.
10343        pp = null;
10344        String oldCodePath = null;
10345        boolean systemApp = false;
10346        synchronized (mPackages) {
10347            // Check whether the newly-scanned package wants to define an already-defined perm
10348            int N = pkg.permissions.size();
10349            for (int i = N-1; i >= 0; i--) {
10350                PackageParser.Permission perm = pkg.permissions.get(i);
10351                BasePermission bp = mSettings.mPermissions.get(perm.info.name);
10352                if (bp != null) {
10353                    // If the defining package is signed with our cert, it's okay.  This
10354                    // also includes the "updating the same package" case, of course.
10355                    if (compareSignatures(bp.packageSetting.signatures.mSignatures,
10356                            pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {
10357                        // If the owning package is the system itself, we log but allow
10358                        // install to proceed; we fail the install on all other permission
10359                        // redefinitions.
10360                        if (!bp.sourcePackage.equals("android")) {
10361                            res.setError(INSTALL_FAILED_DUPLICATE_PERMISSION, "Package "
10362                                    + pkg.packageName + " attempting to redeclare permission "
10363                                    + perm.info.name + " already owned by " + bp.sourcePackage);
10364                            res.origPermission = perm.info.name;
10365                            res.origPackage = bp.sourcePackage;
10366                            return;
10367                        } else {
10368                            Slog.w(TAG, "Package " + pkg.packageName
10369                                    + " attempting to redeclare system permission "
10370                                    + perm.info.name + "; ignoring new declaration");
10371                            pkg.permissions.remove(i);
10372                        }
10373                    }
10374                }
10375            }
10376
10377            // Check if installing already existing package
10378            if ((pFlags&PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
10379                String oldName = mSettings.mRenamedPackages.get(pkgName);
10380                if (pkg.mOriginalPackages != null
10381                        && pkg.mOriginalPackages.contains(oldName)
10382                        && mPackages.containsKey(oldName)) {
10383                    // This package is derived from an original package,
10384                    // and this device has been updating from that original
10385                    // name.  We must continue using the original name, so
10386                    // rename the new package here.
10387                    pkg.setPackageName(oldName);
10388                    pkgName = pkg.packageName;
10389                    replace = true;
10390                    if (DEBUG_INSTALL) Slog.d(TAG, "Replacing existing renamed package: oldName="
10391                            + oldName + " pkgName=" + pkgName);
10392                } else if (mPackages.containsKey(pkgName)) {
10393                    // This package, under its official name, already exists
10394                    // on the device; we should replace it.
10395                    replace = true;
10396                    if (DEBUG_INSTALL) Slog.d(TAG, "Replace existing pacakge: " + pkgName);
10397                }
10398            }
10399            PackageSetting ps = mSettings.mPackages.get(pkgName);
10400            if (ps != null) {
10401                if (DEBUG_INSTALL) Slog.d(TAG, "Existing package: " + ps);
10402                oldCodePath = mSettings.mPackages.get(pkgName).codePathString;
10403                if (ps.pkg != null && ps.pkg.applicationInfo != null) {
10404                    systemApp = (ps.pkg.applicationInfo.flags &
10405                            ApplicationInfo.FLAG_SYSTEM) != 0;
10406                }
10407                res.origUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
10408            }
10409        }
10410
10411        if (systemApp && onSd) {
10412            // Disable updates to system apps on sdcard
10413            res.setError(INSTALL_FAILED_INVALID_INSTALL_LOCATION,
10414                    "Cannot install updates to system apps on sdcard");
10415            return;
10416        }
10417
10418        if (!args.doRename(res.returnCode, pkg, oldCodePath)) {
10419            res.setError(INSTALL_FAILED_INSUFFICIENT_STORAGE, "Failed rename");
10420            return;
10421        }
10422
10423        if (replace) {
10424            replacePackageLI(pkg, parseFlags, scanMode, args.user,
10425                    installerPackageName, res, args.abiOverride);
10426        } else {
10427            installNewPackageLI(pkg, parseFlags, scanMode | SCAN_DELETE_DATA_ON_FAILURES, args.user,
10428                    installerPackageName, res, args.abiOverride);
10429        }
10430        synchronized (mPackages) {
10431            final PackageSetting ps = mSettings.mPackages.get(pkgName);
10432            if (ps != null) {
10433                res.newUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
10434            }
10435        }
10436    }
10437
10438    private static boolean isForwardLocked(PackageParser.Package pkg) {
10439        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0;
10440    }
10441
10442    private static boolean isForwardLocked(ApplicationInfo info) {
10443        return (info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0;
10444    }
10445
10446    private boolean isForwardLocked(PackageSetting ps) {
10447        return (ps.pkgFlags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0;
10448    }
10449
10450    private static boolean isMultiArch(PackageSetting ps) {
10451        return (ps.pkgFlags & ApplicationInfo.FLAG_MULTIARCH) != 0;
10452    }
10453
10454    private static boolean isMultiArch(ApplicationInfo info) {
10455        return (info.flags & ApplicationInfo.FLAG_MULTIARCH) != 0;
10456    }
10457
10458    private static boolean isExternal(PackageParser.Package pkg) {
10459        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10460    }
10461
10462    private static boolean isExternal(PackageSetting ps) {
10463        return (ps.pkgFlags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10464    }
10465
10466    private static boolean isExternal(ApplicationInfo info) {
10467        return (info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10468    }
10469
10470    private static boolean isSystemApp(PackageParser.Package pkg) {
10471        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
10472    }
10473
10474    private static boolean isPrivilegedApp(PackageParser.Package pkg) {
10475        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_PRIVILEGED) != 0;
10476    }
10477
10478    private static boolean isSystemApp(ApplicationInfo info) {
10479        return (info.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
10480    }
10481
10482    private static boolean isSystemApp(PackageSetting ps) {
10483        return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0;
10484    }
10485
10486    private static boolean isUpdatedSystemApp(PackageSetting ps) {
10487        return (ps.pkgFlags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10488    }
10489
10490    private static boolean isUpdatedSystemApp(PackageParser.Package pkg) {
10491        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10492    }
10493
10494    private static boolean isUpdatedSystemApp(ApplicationInfo info) {
10495        return (info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10496    }
10497
10498    private int packageFlagsToInstallFlags(PackageSetting ps) {
10499        int installFlags = 0;
10500        if (isExternal(ps)) {
10501            installFlags |= PackageManager.INSTALL_EXTERNAL;
10502        }
10503        if (isForwardLocked(ps)) {
10504            installFlags |= PackageManager.INSTALL_FORWARD_LOCK;
10505        }
10506        return installFlags;
10507    }
10508
10509    private void deleteTempPackageFiles() {
10510        final FilenameFilter filter = new FilenameFilter() {
10511            public boolean accept(File dir, String name) {
10512                return name.startsWith("vmdl") && name.endsWith(".tmp");
10513            }
10514        };
10515        for (File file : mDrmAppPrivateInstallDir.listFiles(filter)) {
10516            file.delete();
10517        }
10518    }
10519
10520    @Override
10521    public void deletePackageAsUser(final String packageName,
10522                                    final IPackageDeleteObserver observer,
10523                                    final int userId, final int flags) {
10524        mContext.enforceCallingOrSelfPermission(
10525                android.Manifest.permission.DELETE_PACKAGES, null);
10526        final int uid = Binder.getCallingUid();
10527        if (UserHandle.getUserId(uid) != userId) {
10528            mContext.enforceCallingPermission(
10529                    android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
10530                    "deletePackage for user " + userId);
10531        }
10532        if (isUserRestricted(userId, UserManager.DISALLOW_UNINSTALL_APPS)) {
10533            try {
10534                observer.packageDeleted(packageName, PackageManager.DELETE_FAILED_USER_RESTRICTED);
10535            } catch (RemoteException re) {
10536            }
10537            return;
10538        }
10539
10540        boolean blocked = false;
10541        if ((flags & PackageManager.DELETE_ALL_USERS) != 0) {
10542            int[] users = sUserManager.getUserIds();
10543            for (int i = 0; i < users.length; ++i) {
10544                if (getBlockUninstallForUser(packageName, users[i])) {
10545                    blocked = true;
10546                    break;
10547                }
10548            }
10549        } else {
10550            blocked = getBlockUninstallForUser(packageName, userId);
10551        }
10552        if (blocked) {
10553            try {
10554                observer.packageDeleted(packageName, PackageManager.DELETE_FAILED_OWNER_BLOCKED);
10555            } catch (RemoteException re) {
10556            }
10557            return;
10558        }
10559
10560        if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageAsUser: pkg=" + packageName + " user=" + userId);
10561        // Queue up an async operation since the package deletion may take a little while.
10562        mHandler.post(new Runnable() {
10563            public void run() {
10564                mHandler.removeCallbacks(this);
10565                final int returnCode = deletePackageX(packageName, userId, flags);
10566                if (observer != null) {
10567                    try {
10568                        observer.packageDeleted(packageName, returnCode);
10569                    } catch (RemoteException e) {
10570                        Log.i(TAG, "Observer no longer exists.");
10571                    } //end catch
10572                } //end if
10573            } //end run
10574        });
10575    }
10576
10577    private boolean isPackageDeviceAdmin(String packageName, int userId) {
10578        IDevicePolicyManager dpm = IDevicePolicyManager.Stub.asInterface(
10579                ServiceManager.getService(Context.DEVICE_POLICY_SERVICE));
10580        try {
10581            if (dpm != null && (dpm.packageHasActiveAdmins(packageName, userId)
10582                    || dpm.isDeviceOwner(packageName))) {
10583                return true;
10584            }
10585        } catch (RemoteException e) {
10586        }
10587        return false;
10588    }
10589
10590    /**
10591     *  This method is an internal method that could be get invoked either
10592     *  to delete an installed package or to clean up a failed installation.
10593     *  After deleting an installed package, a broadcast is sent to notify any
10594     *  listeners that the package has been installed. For cleaning up a failed
10595     *  installation, the broadcast is not necessary since the package's
10596     *  installation wouldn't have sent the initial broadcast either
10597     *  The key steps in deleting a package are
10598     *  deleting the package information in internal structures like mPackages,
10599     *  deleting the packages base directories through installd
10600     *  updating mSettings to reflect current status
10601     *  persisting settings for later use
10602     *  sending a broadcast if necessary
10603     */
10604    private int deletePackageX(String packageName, int userId, int flags) {
10605        final PackageRemovedInfo info = new PackageRemovedInfo();
10606        final boolean res;
10607
10608        if (isPackageDeviceAdmin(packageName, userId)) {
10609            Slog.w(TAG, "Not removing package " + packageName + ": has active device admin");
10610            return PackageManager.DELETE_FAILED_DEVICE_POLICY_MANAGER;
10611        }
10612
10613        boolean removedForAllUsers = false;
10614        boolean systemUpdate = false;
10615
10616        // for the uninstall-updates case and restricted profiles, remember the per-
10617        // userhandle installed state
10618        int[] allUsers;
10619        boolean[] perUserInstalled;
10620        synchronized (mPackages) {
10621            PackageSetting ps = mSettings.mPackages.get(packageName);
10622            allUsers = sUserManager.getUserIds();
10623            perUserInstalled = new boolean[allUsers.length];
10624            for (int i = 0; i < allUsers.length; i++) {
10625                perUserInstalled[i] = ps != null ? ps.getInstalled(allUsers[i]) : false;
10626            }
10627        }
10628
10629        synchronized (mInstallLock) {
10630            if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageX: pkg=" + packageName + " user=" + userId);
10631            res = deletePackageLI(packageName,
10632                    (flags & PackageManager.DELETE_ALL_USERS) != 0
10633                            ? UserHandle.ALL : new UserHandle(userId),
10634                    true, allUsers, perUserInstalled,
10635                    flags | REMOVE_CHATTY, info, true);
10636            systemUpdate = info.isRemovedPackageSystemUpdate;
10637            if (res && !systemUpdate && mPackages.get(packageName) == null) {
10638                removedForAllUsers = true;
10639            }
10640            if (DEBUG_REMOVE) Slog.d(TAG, "delete res: systemUpdate=" + systemUpdate
10641                    + " removedForAllUsers=" + removedForAllUsers);
10642        }
10643
10644        if (res) {
10645            info.sendBroadcast(true, systemUpdate, removedForAllUsers);
10646
10647            // If the removed package was a system update, the old system package
10648            // was re-enabled; we need to broadcast this information
10649            if (systemUpdate) {
10650                Bundle extras = new Bundle(1);
10651                extras.putInt(Intent.EXTRA_UID, info.removedAppId >= 0
10652                        ? info.removedAppId : info.uid);
10653                extras.putBoolean(Intent.EXTRA_REPLACING, true);
10654
10655                sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, packageName,
10656                        extras, null, null, null);
10657                sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED, packageName,
10658                        extras, null, null, null);
10659                sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED, null,
10660                        null, packageName, null, null);
10661            }
10662        }
10663        // Force a gc here.
10664        Runtime.getRuntime().gc();
10665        // Delete the resources here after sending the broadcast to let
10666        // other processes clean up before deleting resources.
10667        if (info.args != null) {
10668            synchronized (mInstallLock) {
10669                info.args.doPostDeleteLI(true);
10670            }
10671        }
10672
10673        return res ? PackageManager.DELETE_SUCCEEDED : PackageManager.DELETE_FAILED_INTERNAL_ERROR;
10674    }
10675
10676    static class PackageRemovedInfo {
10677        String removedPackage;
10678        int uid = -1;
10679        int removedAppId = -1;
10680        int[] removedUsers = null;
10681        boolean isRemovedPackageSystemUpdate = false;
10682        // Clean up resources deleted packages.
10683        InstallArgs args = null;
10684
10685        void sendBroadcast(boolean fullRemove, boolean replacing, boolean removedForAllUsers) {
10686            Bundle extras = new Bundle(1);
10687            extras.putInt(Intent.EXTRA_UID, removedAppId >= 0 ? removedAppId : uid);
10688            extras.putBoolean(Intent.EXTRA_DATA_REMOVED, fullRemove);
10689            if (replacing) {
10690                extras.putBoolean(Intent.EXTRA_REPLACING, true);
10691            }
10692            extras.putBoolean(Intent.EXTRA_REMOVED_FOR_ALL_USERS, removedForAllUsers);
10693            if (removedPackage != null) {
10694                sendPackageBroadcast(Intent.ACTION_PACKAGE_REMOVED, removedPackage,
10695                        extras, null, null, removedUsers);
10696                if (fullRemove && !replacing) {
10697                    sendPackageBroadcast(Intent.ACTION_PACKAGE_FULLY_REMOVED, removedPackage,
10698                            extras, null, null, removedUsers);
10699                }
10700            }
10701            if (removedAppId >= 0) {
10702                sendPackageBroadcast(Intent.ACTION_UID_REMOVED, null, extras, null, null,
10703                        removedUsers);
10704            }
10705        }
10706    }
10707
10708    /*
10709     * This method deletes the package from internal data structures. If the DONT_DELETE_DATA
10710     * flag is not set, the data directory is removed as well.
10711     * make sure this flag is set for partially installed apps. If not its meaningless to
10712     * delete a partially installed application.
10713     */
10714    private void removePackageDataLI(PackageSetting ps,
10715            int[] allUserHandles, boolean[] perUserInstalled,
10716            PackageRemovedInfo outInfo, int flags, boolean writeSettings) {
10717        String packageName = ps.name;
10718        if (DEBUG_REMOVE) Slog.d(TAG, "removePackageDataLI: " + ps);
10719        removePackageLI(ps, (flags&REMOVE_CHATTY) != 0);
10720        // Retrieve object to delete permissions for shared user later on
10721        final PackageSetting deletedPs;
10722        // reader
10723        synchronized (mPackages) {
10724            deletedPs = mSettings.mPackages.get(packageName);
10725            if (outInfo != null) {
10726                outInfo.removedPackage = packageName;
10727                outInfo.removedUsers = deletedPs != null
10728                        ? deletedPs.queryInstalledUsers(sUserManager.getUserIds(), true)
10729                        : null;
10730            }
10731        }
10732        if ((flags&PackageManager.DELETE_KEEP_DATA) == 0) {
10733            removeDataDirsLI(packageName);
10734            schedulePackageCleaning(packageName, UserHandle.USER_ALL, true);
10735        }
10736        // writer
10737        synchronized (mPackages) {
10738            if (deletedPs != null) {
10739                if ((flags&PackageManager.DELETE_KEEP_DATA) == 0) {
10740                    if (outInfo != null) {
10741                        mSettings.mKeySetManagerService.removeAppKeySetDataLPw(packageName);
10742                        outInfo.removedAppId = mSettings.removePackageLPw(packageName);
10743                    }
10744                    if (deletedPs != null) {
10745                        updatePermissionsLPw(deletedPs.name, null, 0);
10746                        if (deletedPs.sharedUser != null) {
10747                            // remove permissions associated with package
10748                            mSettings.updateSharedUserPermsLPw(deletedPs, mGlobalGids);
10749                        }
10750                    }
10751                    clearPackagePreferredActivitiesLPw(deletedPs.name, UserHandle.USER_ALL);
10752                }
10753                // make sure to preserve per-user disabled state if this removal was just
10754                // a downgrade of a system app to the factory package
10755                if (allUserHandles != null && perUserInstalled != null) {
10756                    if (DEBUG_REMOVE) {
10757                        Slog.d(TAG, "Propagating install state across downgrade");
10758                    }
10759                    for (int i = 0; i < allUserHandles.length; i++) {
10760                        if (DEBUG_REMOVE) {
10761                            Slog.d(TAG, "    user " + allUserHandles[i]
10762                                    + " => " + perUserInstalled[i]);
10763                        }
10764                        ps.setInstalled(perUserInstalled[i], allUserHandles[i]);
10765                    }
10766                }
10767            }
10768            // can downgrade to reader
10769            if (writeSettings) {
10770                // Save settings now
10771                mSettings.writeLPr();
10772            }
10773        }
10774        if (outInfo != null) {
10775            // A user ID was deleted here. Go through all users and remove it
10776            // from KeyStore.
10777            removeKeystoreDataIfNeeded(UserHandle.USER_ALL, outInfo.removedAppId);
10778        }
10779    }
10780
10781    static boolean locationIsPrivileged(File path) {
10782        try {
10783            final String privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app")
10784                    .getCanonicalPath();
10785            return path.getCanonicalPath().startsWith(privilegedAppDir);
10786        } catch (IOException e) {
10787            Slog.e(TAG, "Unable to access code path " + path);
10788        }
10789        return false;
10790    }
10791
10792    /*
10793     * Tries to delete system package.
10794     */
10795    private boolean deleteSystemPackageLI(PackageSetting newPs,
10796            int[] allUserHandles, boolean[] perUserInstalled,
10797            int flags, PackageRemovedInfo outInfo, boolean writeSettings) {
10798        final boolean applyUserRestrictions
10799                = (allUserHandles != null) && (perUserInstalled != null);
10800        PackageSetting disabledPs = null;
10801        // Confirm if the system package has been updated
10802        // An updated system app can be deleted. This will also have to restore
10803        // the system pkg from system partition
10804        // reader
10805        synchronized (mPackages) {
10806            disabledPs = mSettings.getDisabledSystemPkgLPr(newPs.name);
10807        }
10808        if (DEBUG_REMOVE) Slog.d(TAG, "deleteSystemPackageLI: newPs=" + newPs
10809                + " disabledPs=" + disabledPs);
10810        if (disabledPs == null) {
10811            Slog.w(TAG, "Attempt to delete unknown system package "+ newPs.name);
10812            return false;
10813        } else if (DEBUG_REMOVE) {
10814            Slog.d(TAG, "Deleting system pkg from data partition");
10815        }
10816        if (DEBUG_REMOVE) {
10817            if (applyUserRestrictions) {
10818                Slog.d(TAG, "Remembering install states:");
10819                for (int i = 0; i < allUserHandles.length; i++) {
10820                    Slog.d(TAG, "   u=" + allUserHandles[i] + " inst=" + perUserInstalled[i]);
10821                }
10822            }
10823        }
10824        // Delete the updated package
10825        outInfo.isRemovedPackageSystemUpdate = true;
10826        if (disabledPs.versionCode < newPs.versionCode) {
10827            // Delete data for downgrades
10828            flags &= ~PackageManager.DELETE_KEEP_DATA;
10829        } else {
10830            // Preserve data by setting flag
10831            flags |= PackageManager.DELETE_KEEP_DATA;
10832        }
10833        boolean ret = deleteInstalledPackageLI(newPs, true, flags,
10834                allUserHandles, perUserInstalled, outInfo, writeSettings);
10835        if (!ret) {
10836            return false;
10837        }
10838        // writer
10839        synchronized (mPackages) {
10840            // Reinstate the old system package
10841            mSettings.enableSystemPackageLPw(newPs.name);
10842            // Remove any native libraries from the upgraded package.
10843            NativeLibraryHelper.removeNativeBinariesLI(newPs.legacyNativeLibraryPathString);
10844        }
10845        // Install the system package
10846        if (DEBUG_REMOVE) Slog.d(TAG, "Re-installing system package: " + disabledPs);
10847        int parseFlags = PackageParser.PARSE_MUST_BE_APK | PackageParser.PARSE_IS_SYSTEM;
10848        if (locationIsPrivileged(disabledPs.codePath)) {
10849            parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
10850        }
10851
10852        final PackageParser.Package newPkg;
10853        try {
10854            newPkg = scanPackageLI(disabledPs.codePath, parseFlags, SCAN_MONITOR | SCAN_NO_PATHS, 0,
10855                    null, null);
10856        } catch (PackageManagerException e) {
10857            Slog.w(TAG, "Failed to restore system package:" + newPs.name + ": " + e.getMessage());
10858            return false;
10859        }
10860
10861        // writer
10862        synchronized (mPackages) {
10863            PackageSetting ps = mSettings.mPackages.get(newPkg.packageName);
10864            setBundledAppAbisAndRoots(newPkg, ps);
10865            updatePermissionsLPw(newPkg.packageName, newPkg,
10866                    UPDATE_PERMISSIONS_ALL | UPDATE_PERMISSIONS_REPLACE_PKG);
10867            if (applyUserRestrictions) {
10868                if (DEBUG_REMOVE) {
10869                    Slog.d(TAG, "Propagating install state across reinstall");
10870                }
10871                for (int i = 0; i < allUserHandles.length; i++) {
10872                    if (DEBUG_REMOVE) {
10873                        Slog.d(TAG, "    user " + allUserHandles[i]
10874                                + " => " + perUserInstalled[i]);
10875                    }
10876                    ps.setInstalled(perUserInstalled[i], allUserHandles[i]);
10877                }
10878                // Regardless of writeSettings we need to ensure that this restriction
10879                // state propagation is persisted
10880                mSettings.writeAllUsersPackageRestrictionsLPr();
10881            }
10882            // can downgrade to reader here
10883            if (writeSettings) {
10884                mSettings.writeLPr();
10885            }
10886        }
10887        return true;
10888    }
10889
10890    private boolean deleteInstalledPackageLI(PackageSetting ps,
10891            boolean deleteCodeAndResources, int flags,
10892            int[] allUserHandles, boolean[] perUserInstalled,
10893            PackageRemovedInfo outInfo, boolean writeSettings) {
10894        if (outInfo != null) {
10895            outInfo.uid = ps.appId;
10896        }
10897
10898        // Delete package data from internal structures and also remove data if flag is set
10899        removePackageDataLI(ps, allUserHandles, perUserInstalled, outInfo, flags, writeSettings);
10900
10901        // Delete application code and resources
10902        if (deleteCodeAndResources && (outInfo != null)) {
10903            outInfo.args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
10904                    ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
10905                    getAppDexInstructionSets(ps), isMultiArch(ps));
10906        }
10907        return true;
10908    }
10909
10910    @Override
10911    public boolean setBlockUninstallForUser(String packageName, boolean blockUninstall,
10912            int userId) {
10913        mContext.enforceCallingOrSelfPermission(
10914                android.Manifest.permission.DELETE_PACKAGES, null);
10915        synchronized (mPackages) {
10916            PackageSetting ps = mSettings.mPackages.get(packageName);
10917            if (ps == null) {
10918                Log.i(TAG, "Package doesn't exist in set block uninstall " + packageName);
10919                return false;
10920            }
10921            if (!ps.getInstalled(userId)) {
10922                // Can't block uninstall for an app that is not installed or enabled.
10923                Log.i(TAG, "Package not installed in set block uninstall " + packageName);
10924                return false;
10925            }
10926            ps.setBlockUninstall(blockUninstall, userId);
10927            mSettings.writePackageRestrictionsLPr(userId);
10928        }
10929        return true;
10930    }
10931
10932    @Override
10933    public boolean getBlockUninstallForUser(String packageName, int userId) {
10934        synchronized (mPackages) {
10935            PackageSetting ps = mSettings.mPackages.get(packageName);
10936            if (ps == null) {
10937                Log.i(TAG, "Package doesn't exist in get block uninstall " + packageName);
10938                return false;
10939            }
10940            return ps.getBlockUninstall(userId);
10941        }
10942    }
10943
10944    /*
10945     * This method handles package deletion in general
10946     */
10947    private boolean deletePackageLI(String packageName, UserHandle user,
10948            boolean deleteCodeAndResources, int[] allUserHandles, boolean[] perUserInstalled,
10949            int flags, PackageRemovedInfo outInfo,
10950            boolean writeSettings) {
10951        if (packageName == null) {
10952            Slog.w(TAG, "Attempt to delete null packageName.");
10953            return false;
10954        }
10955        if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageLI: " + packageName + " user " + user);
10956        PackageSetting ps;
10957        boolean dataOnly = false;
10958        int removeUser = -1;
10959        int appId = -1;
10960        synchronized (mPackages) {
10961            ps = mSettings.mPackages.get(packageName);
10962            if (ps == null) {
10963                Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
10964                return false;
10965            }
10966            if ((!isSystemApp(ps) || (flags&PackageManager.DELETE_SYSTEM_APP) != 0) && user != null
10967                    && user.getIdentifier() != UserHandle.USER_ALL) {
10968                // The caller is asking that the package only be deleted for a single
10969                // user.  To do this, we just mark its uninstalled state and delete
10970                // its data.  If this is a system app, we only allow this to happen if
10971                // they have set the special DELETE_SYSTEM_APP which requests different
10972                // semantics than normal for uninstalling system apps.
10973                if (DEBUG_REMOVE) Slog.d(TAG, "Only deleting for single user");
10974                ps.setUserState(user.getIdentifier(),
10975                        COMPONENT_ENABLED_STATE_DEFAULT,
10976                        false, //installed
10977                        true,  //stopped
10978                        true,  //notLaunched
10979                        false, //blocked
10980                        null, null, null,
10981                        false // blockUninstall
10982                        );
10983                if (!isSystemApp(ps)) {
10984                    if (ps.isAnyInstalled(sUserManager.getUserIds())) {
10985                        // Other user still have this package installed, so all
10986                        // we need to do is clear this user's data and save that
10987                        // it is uninstalled.
10988                        if (DEBUG_REMOVE) Slog.d(TAG, "Still installed by other users");
10989                        removeUser = user.getIdentifier();
10990                        appId = ps.appId;
10991                        mSettings.writePackageRestrictionsLPr(removeUser);
10992                    } else {
10993                        // We need to set it back to 'installed' so the uninstall
10994                        // broadcasts will be sent correctly.
10995                        if (DEBUG_REMOVE) Slog.d(TAG, "Not installed by other users, full delete");
10996                        ps.setInstalled(true, user.getIdentifier());
10997                    }
10998                } else {
10999                    // This is a system app, so we assume that the
11000                    // other users still have this package installed, so all
11001                    // we need to do is clear this user's data and save that
11002                    // it is uninstalled.
11003                    if (DEBUG_REMOVE) Slog.d(TAG, "Deleting system app");
11004                    removeUser = user.getIdentifier();
11005                    appId = ps.appId;
11006                    mSettings.writePackageRestrictionsLPr(removeUser);
11007                }
11008            }
11009        }
11010
11011        if (removeUser >= 0) {
11012            // From above, we determined that we are deleting this only
11013            // for a single user.  Continue the work here.
11014            if (DEBUG_REMOVE) Slog.d(TAG, "Updating install state for user: " + removeUser);
11015            if (outInfo != null) {
11016                outInfo.removedPackage = packageName;
11017                outInfo.removedAppId = appId;
11018                outInfo.removedUsers = new int[] {removeUser};
11019            }
11020            mInstaller.clearUserData(packageName, removeUser);
11021            removeKeystoreDataIfNeeded(removeUser, appId);
11022            schedulePackageCleaning(packageName, removeUser, false);
11023            return true;
11024        }
11025
11026        if (dataOnly) {
11027            // Delete application data first
11028            if (DEBUG_REMOVE) Slog.d(TAG, "Removing package data only");
11029            removePackageDataLI(ps, null, null, outInfo, flags, writeSettings);
11030            return true;
11031        }
11032
11033        boolean ret = false;
11034        if (isSystemApp(ps)) {
11035            if (DEBUG_REMOVE) Slog.d(TAG, "Removing system package:" + ps.name);
11036            // When an updated system application is deleted we delete the existing resources as well and
11037            // fall back to existing code in system partition
11038            ret = deleteSystemPackageLI(ps, allUserHandles, perUserInstalled,
11039                    flags, outInfo, writeSettings);
11040        } else {
11041            if (DEBUG_REMOVE) Slog.d(TAG, "Removing non-system package:" + ps.name);
11042            // Kill application pre-emptively especially for apps on sd.
11043            killApplication(packageName, ps.appId, "uninstall pkg");
11044            ret = deleteInstalledPackageLI(ps, deleteCodeAndResources, flags,
11045                    allUserHandles, perUserInstalled,
11046                    outInfo, writeSettings);
11047        }
11048
11049        return ret;
11050    }
11051
11052    private final class ClearStorageConnection implements ServiceConnection {
11053        IMediaContainerService mContainerService;
11054
11055        @Override
11056        public void onServiceConnected(ComponentName name, IBinder service) {
11057            synchronized (this) {
11058                mContainerService = IMediaContainerService.Stub.asInterface(service);
11059                notifyAll();
11060            }
11061        }
11062
11063        @Override
11064        public void onServiceDisconnected(ComponentName name) {
11065        }
11066    }
11067
11068    private void clearExternalStorageDataSync(String packageName, int userId, boolean allData) {
11069        final boolean mounted;
11070        if (Environment.isExternalStorageEmulated()) {
11071            mounted = true;
11072        } else {
11073            final String status = Environment.getExternalStorageState();
11074
11075            mounted = status.equals(Environment.MEDIA_MOUNTED)
11076                    || status.equals(Environment.MEDIA_MOUNTED_READ_ONLY);
11077        }
11078
11079        if (!mounted) {
11080            return;
11081        }
11082
11083        final Intent containerIntent = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
11084        int[] users;
11085        if (userId == UserHandle.USER_ALL) {
11086            users = sUserManager.getUserIds();
11087        } else {
11088            users = new int[] { userId };
11089        }
11090        final ClearStorageConnection conn = new ClearStorageConnection();
11091        if (mContext.bindServiceAsUser(
11092                containerIntent, conn, Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
11093            try {
11094                for (int curUser : users) {
11095                    long timeout = SystemClock.uptimeMillis() + 5000;
11096                    synchronized (conn) {
11097                        long now = SystemClock.uptimeMillis();
11098                        while (conn.mContainerService == null && now < timeout) {
11099                            try {
11100                                conn.wait(timeout - now);
11101                            } catch (InterruptedException e) {
11102                            }
11103                        }
11104                    }
11105                    if (conn.mContainerService == null) {
11106                        return;
11107                    }
11108
11109                    final UserEnvironment userEnv = new UserEnvironment(curUser);
11110                    clearDirectory(conn.mContainerService,
11111                            userEnv.buildExternalStorageAppCacheDirs(packageName));
11112                    if (allData) {
11113                        clearDirectory(conn.mContainerService,
11114                                userEnv.buildExternalStorageAppDataDirs(packageName));
11115                        clearDirectory(conn.mContainerService,
11116                                userEnv.buildExternalStorageAppMediaDirs(packageName));
11117                    }
11118                }
11119            } finally {
11120                mContext.unbindService(conn);
11121            }
11122        }
11123    }
11124
11125    @Override
11126    public void clearApplicationUserData(final String packageName,
11127            final IPackageDataObserver observer, final int userId) {
11128        mContext.enforceCallingOrSelfPermission(
11129                android.Manifest.permission.CLEAR_APP_USER_DATA, null);
11130        enforceCrossUserPermission(Binder.getCallingUid(), userId, true, "clear application data");
11131        // Queue up an async operation since the package deletion may take a little while.
11132        mHandler.post(new Runnable() {
11133            public void run() {
11134                mHandler.removeCallbacks(this);
11135                final boolean succeeded;
11136                synchronized (mInstallLock) {
11137                    succeeded = clearApplicationUserDataLI(packageName, userId);
11138                }
11139                clearExternalStorageDataSync(packageName, userId, true);
11140                if (succeeded) {
11141                    // invoke DeviceStorageMonitor's update method to clear any notifications
11142                    DeviceStorageMonitorInternal
11143                            dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
11144                    if (dsm != null) {
11145                        dsm.checkMemory();
11146                    }
11147                }
11148                if(observer != null) {
11149                    try {
11150                        observer.onRemoveCompleted(packageName, succeeded);
11151                    } catch (RemoteException e) {
11152                        Log.i(TAG, "Observer no longer exists.");
11153                    }
11154                } //end if observer
11155            } //end run
11156        });
11157    }
11158
11159    private boolean clearApplicationUserDataLI(String packageName, int userId) {
11160        if (packageName == null) {
11161            Slog.w(TAG, "Attempt to delete null packageName.");
11162            return false;
11163        }
11164        PackageParser.Package p;
11165        boolean dataOnly = false;
11166        final int appId;
11167        synchronized (mPackages) {
11168            p = mPackages.get(packageName);
11169            if (p == null) {
11170                dataOnly = true;
11171                PackageSetting ps = mSettings.mPackages.get(packageName);
11172                if ((ps == null) || (ps.pkg == null)) {
11173                    Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
11174                    return false;
11175                }
11176                p = ps.pkg;
11177            }
11178            if (!dataOnly) {
11179                // need to check this only for fully installed applications
11180                if (p == null) {
11181                    Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
11182                    return false;
11183                }
11184                final ApplicationInfo applicationInfo = p.applicationInfo;
11185                if (applicationInfo == null) {
11186                    Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
11187                    return false;
11188                }
11189            }
11190            if (p != null && p.applicationInfo != null) {
11191                appId = p.applicationInfo.uid;
11192            } else {
11193                appId = -1;
11194            }
11195        }
11196        int retCode = mInstaller.clearUserData(packageName, userId);
11197        if (retCode < 0) {
11198            Slog.w(TAG, "Couldn't remove cache files for package: "
11199                    + packageName);
11200            return false;
11201        }
11202        removeKeystoreDataIfNeeded(userId, appId);
11203        return true;
11204    }
11205
11206    /**
11207     * Remove entries from the keystore daemon. Will only remove it if the
11208     * {@code appId} is valid.
11209     */
11210    private static void removeKeystoreDataIfNeeded(int userId, int appId) {
11211        if (appId < 0) {
11212            return;
11213        }
11214
11215        final KeyStore keyStore = KeyStore.getInstance();
11216        if (keyStore != null) {
11217            if (userId == UserHandle.USER_ALL) {
11218                for (final int individual : sUserManager.getUserIds()) {
11219                    keyStore.clearUid(UserHandle.getUid(individual, appId));
11220                }
11221            } else {
11222                keyStore.clearUid(UserHandle.getUid(userId, appId));
11223            }
11224        } else {
11225            Slog.w(TAG, "Could not contact keystore to clear entries for app id " + appId);
11226        }
11227    }
11228
11229    @Override
11230    public void deleteApplicationCacheFiles(final String packageName,
11231            final IPackageDataObserver observer) {
11232        mContext.enforceCallingOrSelfPermission(
11233                android.Manifest.permission.DELETE_CACHE_FILES, null);
11234        // Queue up an async operation since the package deletion may take a little while.
11235        final int userId = UserHandle.getCallingUserId();
11236        mHandler.post(new Runnable() {
11237            public void run() {
11238                mHandler.removeCallbacks(this);
11239                final boolean succeded;
11240                synchronized (mInstallLock) {
11241                    succeded = deleteApplicationCacheFilesLI(packageName, userId);
11242                }
11243                clearExternalStorageDataSync(packageName, userId, false);
11244                if(observer != null) {
11245                    try {
11246                        observer.onRemoveCompleted(packageName, succeded);
11247                    } catch (RemoteException e) {
11248                        Log.i(TAG, "Observer no longer exists.");
11249                    }
11250                } //end if observer
11251            } //end run
11252        });
11253    }
11254
11255    private boolean deleteApplicationCacheFilesLI(String packageName, int userId) {
11256        if (packageName == null) {
11257            Slog.w(TAG, "Attempt to delete null packageName.");
11258            return false;
11259        }
11260        PackageParser.Package p;
11261        synchronized (mPackages) {
11262            p = mPackages.get(packageName);
11263        }
11264        if (p == null) {
11265            Slog.w(TAG, "Package named '" + packageName +"' doesn't exist.");
11266            return false;
11267        }
11268        final ApplicationInfo applicationInfo = p.applicationInfo;
11269        if (applicationInfo == null) {
11270            Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
11271            return false;
11272        }
11273        int retCode = mInstaller.deleteCacheFiles(packageName, userId);
11274        if (retCode < 0) {
11275            Slog.w(TAG, "Couldn't remove cache files for package: "
11276                       + packageName + " u" + userId);
11277            return false;
11278        }
11279        return true;
11280    }
11281
11282    @Override
11283    public void getPackageSizeInfo(final String packageName, int userHandle,
11284            final IPackageStatsObserver observer) {
11285        mContext.enforceCallingOrSelfPermission(
11286                android.Manifest.permission.GET_PACKAGE_SIZE, null);
11287        if (packageName == null) {
11288            throw new IllegalArgumentException("Attempt to get size of null packageName");
11289        }
11290
11291        PackageStats stats = new PackageStats(packageName, userHandle);
11292
11293        /*
11294         * Queue up an async operation since the package measurement may take a
11295         * little while.
11296         */
11297        Message msg = mHandler.obtainMessage(INIT_COPY);
11298        msg.obj = new MeasureParams(stats, observer);
11299        mHandler.sendMessage(msg);
11300    }
11301
11302    private boolean getPackageSizeInfoLI(String packageName, int userHandle,
11303            PackageStats pStats) {
11304        if (packageName == null) {
11305            Slog.w(TAG, "Attempt to get size of null packageName.");
11306            return false;
11307        }
11308        PackageParser.Package p;
11309        boolean dataOnly = false;
11310        String libDirRoot = null;
11311        String asecPath = null;
11312        PackageSetting ps = null;
11313        synchronized (mPackages) {
11314            p = mPackages.get(packageName);
11315            ps = mSettings.mPackages.get(packageName);
11316            if(p == null) {
11317                dataOnly = true;
11318                if((ps == null) || (ps.pkg == null)) {
11319                    Slog.w(TAG, "Package named '" + packageName +"' doesn't exist.");
11320                    return false;
11321                }
11322                p = ps.pkg;
11323            }
11324            if (ps != null) {
11325                libDirRoot = ps.legacyNativeLibraryPathString;
11326            }
11327            if (p != null && (isExternal(p) || isForwardLocked(p))) {
11328                String secureContainerId = cidFromCodePath(p.applicationInfo.getBaseCodePath());
11329                if (secureContainerId != null) {
11330                    asecPath = PackageHelper.getSdFilesystem(secureContainerId);
11331                }
11332            }
11333        }
11334        String publicSrcDir = null;
11335        if(!dataOnly) {
11336            final ApplicationInfo applicationInfo = p.applicationInfo;
11337            if (applicationInfo == null) {
11338                Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
11339                return false;
11340            }
11341            if (isForwardLocked(p)) {
11342                publicSrcDir = applicationInfo.getBaseResourcePath();
11343            }
11344        }
11345        // TODO: extend to measure size of split APKs
11346        // TODO(multiArch): Extend getSizeInfo to look at the full subdirectory tree,
11347        // not just the first level.
11348        // TODO(multiArch): Extend getSizeInfo to look at *all* instruction sets, not
11349        // just the primary.
11350        int res = mInstaller.getSizeInfo(packageName, userHandle, p.baseCodePath, libDirRoot,
11351                publicSrcDir, asecPath, getAppDexInstructionSets(ps),
11352                pStats);
11353        if (res < 0) {
11354            return false;
11355        }
11356
11357        // Fix-up for forward-locked applications in ASEC containers.
11358        if (!isExternal(p)) {
11359            pStats.codeSize += pStats.externalCodeSize;
11360            pStats.externalCodeSize = 0L;
11361        }
11362
11363        return true;
11364    }
11365
11366
11367    @Override
11368    public void addPackageToPreferred(String packageName) {
11369        Slog.w(TAG, "addPackageToPreferred: this is now a no-op");
11370    }
11371
11372    @Override
11373    public void removePackageFromPreferred(String packageName) {
11374        Slog.w(TAG, "removePackageFromPreferred: this is now a no-op");
11375    }
11376
11377    @Override
11378    public List<PackageInfo> getPreferredPackages(int flags) {
11379        return new ArrayList<PackageInfo>();
11380    }
11381
11382    private int getUidTargetSdkVersionLockedLPr(int uid) {
11383        Object obj = mSettings.getUserIdLPr(uid);
11384        if (obj instanceof SharedUserSetting) {
11385            final SharedUserSetting sus = (SharedUserSetting) obj;
11386            int vers = Build.VERSION_CODES.CUR_DEVELOPMENT;
11387            final Iterator<PackageSetting> it = sus.packages.iterator();
11388            while (it.hasNext()) {
11389                final PackageSetting ps = it.next();
11390                if (ps.pkg != null) {
11391                    int v = ps.pkg.applicationInfo.targetSdkVersion;
11392                    if (v < vers) vers = v;
11393                }
11394            }
11395            return vers;
11396        } else if (obj instanceof PackageSetting) {
11397            final PackageSetting ps = (PackageSetting) obj;
11398            if (ps.pkg != null) {
11399                return ps.pkg.applicationInfo.targetSdkVersion;
11400            }
11401        }
11402        return Build.VERSION_CODES.CUR_DEVELOPMENT;
11403    }
11404
11405    @Override
11406    public void addPreferredActivity(IntentFilter filter, int match,
11407            ComponentName[] set, ComponentName activity, int userId) {
11408        addPreferredActivityInternal(filter, match, set, activity, true, userId);
11409    }
11410
11411    private void addPreferredActivityInternal(IntentFilter filter, int match,
11412            ComponentName[] set, ComponentName activity, boolean always, int userId) {
11413        // writer
11414        int callingUid = Binder.getCallingUid();
11415        enforceCrossUserPermission(callingUid, userId, true, "add preferred activity");
11416        if (filter.countActions() == 0) {
11417            Slog.w(TAG, "Cannot set a preferred activity with no filter actions");
11418            return;
11419        }
11420        synchronized (mPackages) {
11421            if (mContext.checkCallingOrSelfPermission(
11422                    android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11423                    != PackageManager.PERMISSION_GRANTED) {
11424                if (getUidTargetSdkVersionLockedLPr(callingUid)
11425                        < Build.VERSION_CODES.FROYO) {
11426                    Slog.w(TAG, "Ignoring addPreferredActivity() from uid "
11427                            + callingUid);
11428                    return;
11429                }
11430                mContext.enforceCallingOrSelfPermission(
11431                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11432            }
11433
11434            Slog.i(TAG, "Adding preferred activity " + activity + " for user " + userId + " :");
11435            filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11436            mSettings.editPreferredActivitiesLPw(userId).addFilter(
11437                    new PreferredActivity(filter, match, set, activity, always));
11438            mSettings.writePackageRestrictionsLPr(userId);
11439        }
11440    }
11441
11442    @Override
11443    public void replacePreferredActivity(IntentFilter filter, int match,
11444            ComponentName[] set, ComponentName activity) {
11445        if (filter.countActions() != 1) {
11446            throw new IllegalArgumentException(
11447                    "replacePreferredActivity expects filter to have only 1 action.");
11448        }
11449        if (filter.countDataAuthorities() != 0
11450                || filter.countDataPaths() != 0
11451                || filter.countDataSchemes() > 1
11452                || filter.countDataTypes() != 0) {
11453            throw new IllegalArgumentException(
11454                    "replacePreferredActivity expects filter to have no data authorities, " +
11455                    "paths, or types; and at most one scheme.");
11456        }
11457        synchronized (mPackages) {
11458            if (mContext.checkCallingOrSelfPermission(
11459                    android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11460                    != PackageManager.PERMISSION_GRANTED) {
11461                if (getUidTargetSdkVersionLockedLPr(Binder.getCallingUid())
11462                        < Build.VERSION_CODES.FROYO) {
11463                    Slog.w(TAG, "Ignoring replacePreferredActivity() from uid "
11464                            + Binder.getCallingUid());
11465                    return;
11466                }
11467                mContext.enforceCallingOrSelfPermission(
11468                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11469            }
11470
11471            final int callingUserId = UserHandle.getCallingUserId();
11472            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(callingUserId);
11473            if (pir != null) {
11474                Intent intent = new Intent(filter.getAction(0)).addCategory(filter.getCategory(0));
11475                if (filter.countDataSchemes() == 1) {
11476                    Uri.Builder builder = new Uri.Builder();
11477                    builder.scheme(filter.getDataScheme(0));
11478                    intent.setData(builder.build());
11479                }
11480                List<PreferredActivity> matches = pir.queryIntent(
11481                        intent, null, true, callingUserId);
11482                if (DEBUG_PREFERRED) {
11483                    Slog.i(TAG, matches.size() + " preferred matches for " + intent);
11484                }
11485                for (int i = 0; i < matches.size(); i++) {
11486                    PreferredActivity pa = matches.get(i);
11487                    if (DEBUG_PREFERRED) {
11488                        Slog.i(TAG, "Removing preferred activity "
11489                                + pa.mPref.mComponent + ":");
11490                        filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11491                    }
11492                    pir.removeFilter(pa);
11493                }
11494            }
11495            addPreferredActivityInternal(filter, match, set, activity, true, callingUserId);
11496        }
11497    }
11498
11499    @Override
11500    public void clearPackagePreferredActivities(String packageName) {
11501        final int uid = Binder.getCallingUid();
11502        // writer
11503        synchronized (mPackages) {
11504            PackageParser.Package pkg = mPackages.get(packageName);
11505            if (pkg == null || pkg.applicationInfo.uid != uid) {
11506                if (mContext.checkCallingOrSelfPermission(
11507                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11508                        != PackageManager.PERMISSION_GRANTED) {
11509                    if (getUidTargetSdkVersionLockedLPr(Binder.getCallingUid())
11510                            < Build.VERSION_CODES.FROYO) {
11511                        Slog.w(TAG, "Ignoring clearPackagePreferredActivities() from uid "
11512                                + Binder.getCallingUid());
11513                        return;
11514                    }
11515                    mContext.enforceCallingOrSelfPermission(
11516                            android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11517                }
11518            }
11519
11520            int user = UserHandle.getCallingUserId();
11521            if (clearPackagePreferredActivitiesLPw(packageName, user)) {
11522                mSettings.writePackageRestrictionsLPr(user);
11523                scheduleWriteSettingsLocked();
11524            }
11525        }
11526    }
11527
11528    /** This method takes a specific user id as well as UserHandle.USER_ALL. */
11529    boolean clearPackagePreferredActivitiesLPw(String packageName, int userId) {
11530        ArrayList<PreferredActivity> removed = null;
11531        boolean changed = false;
11532        for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
11533            final int thisUserId = mSettings.mPreferredActivities.keyAt(i);
11534            PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
11535            if (userId != UserHandle.USER_ALL && userId != thisUserId) {
11536                continue;
11537            }
11538            Iterator<PreferredActivity> it = pir.filterIterator();
11539            while (it.hasNext()) {
11540                PreferredActivity pa = it.next();
11541                // Mark entry for removal only if it matches the package name
11542                // and the entry is of type "always".
11543                if (packageName == null ||
11544                        (pa.mPref.mComponent.getPackageName().equals(packageName)
11545                                && pa.mPref.mAlways)) {
11546                    if (removed == null) {
11547                        removed = new ArrayList<PreferredActivity>();
11548                    }
11549                    removed.add(pa);
11550                }
11551            }
11552            if (removed != null) {
11553                for (int j=0; j<removed.size(); j++) {
11554                    PreferredActivity pa = removed.get(j);
11555                    pir.removeFilter(pa);
11556                }
11557                changed = true;
11558            }
11559        }
11560        return changed;
11561    }
11562
11563    @Override
11564    public void resetPreferredActivities(int userId) {
11565        mContext.enforceCallingOrSelfPermission(
11566                android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11567        // writer
11568        synchronized (mPackages) {
11569            int user = UserHandle.getCallingUserId();
11570            clearPackagePreferredActivitiesLPw(null, user);
11571            mSettings.readDefaultPreferredAppsLPw(this, user);
11572            mSettings.writePackageRestrictionsLPr(user);
11573            scheduleWriteSettingsLocked();
11574        }
11575    }
11576
11577    @Override
11578    public int getPreferredActivities(List<IntentFilter> outFilters,
11579            List<ComponentName> outActivities, String packageName) {
11580
11581        int num = 0;
11582        final int userId = UserHandle.getCallingUserId();
11583        // reader
11584        synchronized (mPackages) {
11585            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
11586            if (pir != null) {
11587                final Iterator<PreferredActivity> it = pir.filterIterator();
11588                while (it.hasNext()) {
11589                    final PreferredActivity pa = it.next();
11590                    if (packageName == null
11591                            || (pa.mPref.mComponent.getPackageName().equals(packageName)
11592                                    && pa.mPref.mAlways)) {
11593                        if (outFilters != null) {
11594                            outFilters.add(new IntentFilter(pa));
11595                        }
11596                        if (outActivities != null) {
11597                            outActivities.add(pa.mPref.mComponent);
11598                        }
11599                    }
11600                }
11601            }
11602        }
11603
11604        return num;
11605    }
11606
11607    @Override
11608    public void addPersistentPreferredActivity(IntentFilter filter, ComponentName activity,
11609            int userId) {
11610        int callingUid = Binder.getCallingUid();
11611        if (callingUid != Process.SYSTEM_UID) {
11612            throw new SecurityException(
11613                    "addPersistentPreferredActivity can only be run by the system");
11614        }
11615        if (filter.countActions() == 0) {
11616            Slog.w(TAG, "Cannot set a preferred activity with no filter actions");
11617            return;
11618        }
11619        synchronized (mPackages) {
11620            Slog.i(TAG, "Adding persistent preferred activity " + activity + " for user " + userId +
11621                    " :");
11622            filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11623            mSettings.editPersistentPreferredActivitiesLPw(userId).addFilter(
11624                    new PersistentPreferredActivity(filter, activity));
11625            mSettings.writePackageRestrictionsLPr(userId);
11626        }
11627    }
11628
11629    @Override
11630    public void clearPackagePersistentPreferredActivities(String packageName, int userId) {
11631        int callingUid = Binder.getCallingUid();
11632        if (callingUid != Process.SYSTEM_UID) {
11633            throw new SecurityException(
11634                    "clearPackagePersistentPreferredActivities can only be run by the system");
11635        }
11636        ArrayList<PersistentPreferredActivity> removed = null;
11637        boolean changed = false;
11638        synchronized (mPackages) {
11639            for (int i=0; i<mSettings.mPersistentPreferredActivities.size(); i++) {
11640                final int thisUserId = mSettings.mPersistentPreferredActivities.keyAt(i);
11641                PersistentPreferredIntentResolver ppir = mSettings.mPersistentPreferredActivities
11642                        .valueAt(i);
11643                if (userId != thisUserId) {
11644                    continue;
11645                }
11646                Iterator<PersistentPreferredActivity> it = ppir.filterIterator();
11647                while (it.hasNext()) {
11648                    PersistentPreferredActivity ppa = it.next();
11649                    // Mark entry for removal only if it matches the package name.
11650                    if (ppa.mComponent.getPackageName().equals(packageName)) {
11651                        if (removed == null) {
11652                            removed = new ArrayList<PersistentPreferredActivity>();
11653                        }
11654                        removed.add(ppa);
11655                    }
11656                }
11657                if (removed != null) {
11658                    for (int j=0; j<removed.size(); j++) {
11659                        PersistentPreferredActivity ppa = removed.get(j);
11660                        ppir.removeFilter(ppa);
11661                    }
11662                    changed = true;
11663                }
11664            }
11665
11666            if (changed) {
11667                mSettings.writePackageRestrictionsLPr(userId);
11668            }
11669        }
11670    }
11671
11672    @Override
11673    public void addCrossProfileIntentFilter(IntentFilter intentFilter, int sourceUserId,
11674            int targetUserId, int flags) {
11675        mContext.enforceCallingOrSelfPermission(
11676                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
11677        if (intentFilter.countActions() == 0) {
11678            Slog.w(TAG, "Cannot set a crossProfile intent filter with no filter actions");
11679            return;
11680        }
11681        synchronized (mPackages) {
11682            CrossProfileIntentFilter filter = new CrossProfileIntentFilter(intentFilter,
11683                    targetUserId, flags);
11684            mSettings.editCrossProfileIntentResolverLPw(sourceUserId).addFilter(filter);
11685            mSettings.writePackageRestrictionsLPr(sourceUserId);
11686        }
11687    }
11688
11689    public void addCrossProfileIntentsForPackage(String packageName,
11690            int sourceUserId, int targetUserId) {
11691        mContext.enforceCallingOrSelfPermission(
11692                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
11693        mSettings.addCrossProfilePackage(packageName, sourceUserId, targetUserId);
11694        mSettings.writePackageRestrictionsLPr(sourceUserId);
11695    }
11696
11697    public void removeCrossProfileIntentsForPackage(String packageName,
11698            int sourceUserId, int targetUserId) {
11699        mContext.enforceCallingOrSelfPermission(
11700                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
11701        mSettings.removeCrossProfilePackage(packageName, sourceUserId, targetUserId);
11702        mSettings.writePackageRestrictionsLPr(sourceUserId);
11703    }
11704
11705    @Override
11706    public void clearCrossProfileIntentFilters(int sourceUserId) {
11707        mContext.enforceCallingOrSelfPermission(
11708                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
11709        synchronized (mPackages) {
11710            CrossProfileIntentResolver resolver =
11711                    mSettings.editCrossProfileIntentResolverLPw(sourceUserId);
11712            HashSet<CrossProfileIntentFilter> set =
11713                    new HashSet<CrossProfileIntentFilter>(resolver.filterSet());
11714            for (CrossProfileIntentFilter filter : set) {
11715                if ((filter.getFlags() & PackageManager.SET_BY_PROFILE_OWNER) != 0) {
11716                    resolver.removeFilter(filter);
11717                }
11718            }
11719            mSettings.writePackageRestrictionsLPr(sourceUserId);
11720        }
11721    }
11722
11723    @Override
11724    public ComponentName getHomeActivities(List<ResolveInfo> allHomeCandidates) {
11725        Intent intent = new Intent(Intent.ACTION_MAIN);
11726        intent.addCategory(Intent.CATEGORY_HOME);
11727
11728        final int callingUserId = UserHandle.getCallingUserId();
11729        List<ResolveInfo> list = queryIntentActivities(intent, null,
11730                PackageManager.GET_META_DATA, callingUserId);
11731        ResolveInfo preferred = findPreferredActivity(intent, null, 0, list, 0,
11732                true, false, false, callingUserId);
11733
11734        allHomeCandidates.clear();
11735        if (list != null) {
11736            for (ResolveInfo ri : list) {
11737                allHomeCandidates.add(ri);
11738            }
11739        }
11740        return (preferred == null || preferred.activityInfo == null)
11741                ? null
11742                : new ComponentName(preferred.activityInfo.packageName,
11743                        preferred.activityInfo.name);
11744    }
11745
11746    @Override
11747    public void setApplicationEnabledSetting(String appPackageName,
11748            int newState, int flags, int userId, String callingPackage) {
11749        if (!sUserManager.exists(userId)) return;
11750        if (callingPackage == null) {
11751            callingPackage = Integer.toString(Binder.getCallingUid());
11752        }
11753        setEnabledSetting(appPackageName, null, newState, flags, userId, callingPackage);
11754    }
11755
11756    @Override
11757    public void setComponentEnabledSetting(ComponentName componentName,
11758            int newState, int flags, int userId) {
11759        if (!sUserManager.exists(userId)) return;
11760        setEnabledSetting(componentName.getPackageName(),
11761                componentName.getClassName(), newState, flags, userId, null);
11762    }
11763
11764    private void setEnabledSetting(final String packageName, String className, int newState,
11765            final int flags, int userId, String callingPackage) {
11766        if (!(newState == COMPONENT_ENABLED_STATE_DEFAULT
11767              || newState == COMPONENT_ENABLED_STATE_ENABLED
11768              || newState == COMPONENT_ENABLED_STATE_DISABLED
11769              || newState == COMPONENT_ENABLED_STATE_DISABLED_USER
11770              || newState == COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED)) {
11771            throw new IllegalArgumentException("Invalid new component state: "
11772                    + newState);
11773        }
11774        PackageSetting pkgSetting;
11775        final int uid = Binder.getCallingUid();
11776        final int permission = mContext.checkCallingOrSelfPermission(
11777                android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE);
11778        enforceCrossUserPermission(uid, userId, false, "set enabled");
11779        final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED);
11780        boolean sendNow = false;
11781        boolean isApp = (className == null);
11782        String componentName = isApp ? packageName : className;
11783        int packageUid = -1;
11784        ArrayList<String> components;
11785
11786        // writer
11787        synchronized (mPackages) {
11788            pkgSetting = mSettings.mPackages.get(packageName);
11789            if (pkgSetting == null) {
11790                if (className == null) {
11791                    throw new IllegalArgumentException(
11792                            "Unknown package: " + packageName);
11793                }
11794                throw new IllegalArgumentException(
11795                        "Unknown component: " + packageName
11796                        + "/" + className);
11797            }
11798            // Allow root and verify that userId is not being specified by a different user
11799            if (!allowedByPermission && !UserHandle.isSameApp(uid, pkgSetting.appId)) {
11800                throw new SecurityException(
11801                        "Permission Denial: attempt to change component state from pid="
11802                        + Binder.getCallingPid()
11803                        + ", uid=" + uid + ", package uid=" + pkgSetting.appId);
11804            }
11805            if (className == null) {
11806                // We're dealing with an application/package level state change
11807                if (pkgSetting.getEnabled(userId) == newState) {
11808                    // Nothing to do
11809                    return;
11810                }
11811                if (newState == PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
11812                    || newState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
11813                    // Don't care about who enables an app.
11814                    callingPackage = null;
11815                }
11816                pkgSetting.setEnabled(newState, userId, callingPackage);
11817                // pkgSetting.pkg.mSetEnabled = newState;
11818            } else {
11819                // We're dealing with a component level state change
11820                // First, verify that this is a valid class name.
11821                PackageParser.Package pkg = pkgSetting.pkg;
11822                if (pkg == null || !pkg.hasComponentClassName(className)) {
11823                    if (pkg.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.JELLY_BEAN) {
11824                        throw new IllegalArgumentException("Component class " + className
11825                                + " does not exist in " + packageName);
11826                    } else {
11827                        Slog.w(TAG, "Failed setComponentEnabledSetting: component class "
11828                                + className + " does not exist in " + packageName);
11829                    }
11830                }
11831                switch (newState) {
11832                case COMPONENT_ENABLED_STATE_ENABLED:
11833                    if (!pkgSetting.enableComponentLPw(className, userId)) {
11834                        return;
11835                    }
11836                    break;
11837                case COMPONENT_ENABLED_STATE_DISABLED:
11838                    if (!pkgSetting.disableComponentLPw(className, userId)) {
11839                        return;
11840                    }
11841                    break;
11842                case COMPONENT_ENABLED_STATE_DEFAULT:
11843                    if (!pkgSetting.restoreComponentLPw(className, userId)) {
11844                        return;
11845                    }
11846                    break;
11847                default:
11848                    Slog.e(TAG, "Invalid new component state: " + newState);
11849                    return;
11850                }
11851            }
11852            mSettings.writePackageRestrictionsLPr(userId);
11853            components = mPendingBroadcasts.get(userId, packageName);
11854            final boolean newPackage = components == null;
11855            if (newPackage) {
11856                components = new ArrayList<String>();
11857            }
11858            if (!components.contains(componentName)) {
11859                components.add(componentName);
11860            }
11861            if ((flags&PackageManager.DONT_KILL_APP) == 0) {
11862                sendNow = true;
11863                // Purge entry from pending broadcast list if another one exists already
11864                // since we are sending one right away.
11865                mPendingBroadcasts.remove(userId, packageName);
11866            } else {
11867                if (newPackage) {
11868                    mPendingBroadcasts.put(userId, packageName, components);
11869                }
11870                if (!mHandler.hasMessages(SEND_PENDING_BROADCAST)) {
11871                    // Schedule a message
11872                    mHandler.sendEmptyMessageDelayed(SEND_PENDING_BROADCAST, BROADCAST_DELAY);
11873                }
11874            }
11875        }
11876
11877        long callingId = Binder.clearCallingIdentity();
11878        try {
11879            if (sendNow) {
11880                packageUid = UserHandle.getUid(userId, pkgSetting.appId);
11881                sendPackageChangedBroadcast(packageName,
11882                        (flags&PackageManager.DONT_KILL_APP) != 0, components, packageUid);
11883            }
11884        } finally {
11885            Binder.restoreCallingIdentity(callingId);
11886        }
11887    }
11888
11889    private void sendPackageChangedBroadcast(String packageName,
11890            boolean killFlag, ArrayList<String> componentNames, int packageUid) {
11891        if (DEBUG_INSTALL)
11892            Log.v(TAG, "Sending package changed: package=" + packageName + " components="
11893                    + componentNames);
11894        Bundle extras = new Bundle(4);
11895        extras.putString(Intent.EXTRA_CHANGED_COMPONENT_NAME, componentNames.get(0));
11896        String nameList[] = new String[componentNames.size()];
11897        componentNames.toArray(nameList);
11898        extras.putStringArray(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST, nameList);
11899        extras.putBoolean(Intent.EXTRA_DONT_KILL_APP, killFlag);
11900        extras.putInt(Intent.EXTRA_UID, packageUid);
11901        sendPackageBroadcast(Intent.ACTION_PACKAGE_CHANGED,  packageName, extras, null, null,
11902                new int[] {UserHandle.getUserId(packageUid)});
11903    }
11904
11905    @Override
11906    public void setPackageStoppedState(String packageName, boolean stopped, int userId) {
11907        if (!sUserManager.exists(userId)) return;
11908        final int uid = Binder.getCallingUid();
11909        final int permission = mContext.checkCallingOrSelfPermission(
11910                android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE);
11911        final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED);
11912        enforceCrossUserPermission(uid, userId, true, "stop package");
11913        // writer
11914        synchronized (mPackages) {
11915            if (mSettings.setPackageStoppedStateLPw(packageName, stopped, allowedByPermission,
11916                    uid, userId)) {
11917                scheduleWritePackageRestrictionsLocked(userId);
11918            }
11919        }
11920    }
11921
11922    @Override
11923    public String getInstallerPackageName(String packageName) {
11924        // reader
11925        synchronized (mPackages) {
11926            return mSettings.getInstallerPackageNameLPr(packageName);
11927        }
11928    }
11929
11930    @Override
11931    public int getApplicationEnabledSetting(String packageName, int userId) {
11932        if (!sUserManager.exists(userId)) return COMPONENT_ENABLED_STATE_DISABLED;
11933        int uid = Binder.getCallingUid();
11934        enforceCrossUserPermission(uid, userId, false, "get enabled");
11935        // reader
11936        synchronized (mPackages) {
11937            return mSettings.getApplicationEnabledSettingLPr(packageName, userId);
11938        }
11939    }
11940
11941    @Override
11942    public int getComponentEnabledSetting(ComponentName componentName, int userId) {
11943        if (!sUserManager.exists(userId)) return COMPONENT_ENABLED_STATE_DISABLED;
11944        int uid = Binder.getCallingUid();
11945        enforceCrossUserPermission(uid, userId, false, "get component enabled");
11946        // reader
11947        synchronized (mPackages) {
11948            return mSettings.getComponentEnabledSettingLPr(componentName, userId);
11949        }
11950    }
11951
11952    @Override
11953    public void enterSafeMode() {
11954        enforceSystemOrRoot("Only the system can request entering safe mode");
11955
11956        if (!mSystemReady) {
11957            mSafeMode = true;
11958        }
11959    }
11960
11961    @Override
11962    public void systemReady() {
11963        mSystemReady = true;
11964
11965        // Read the compatibilty setting when the system is ready.
11966        boolean compatibilityModeEnabled = android.provider.Settings.Global.getInt(
11967                mContext.getContentResolver(),
11968                android.provider.Settings.Global.COMPATIBILITY_MODE, 1) == 1;
11969        PackageParser.setCompatibilityModeEnabled(compatibilityModeEnabled);
11970        if (DEBUG_SETTINGS) {
11971            Log.d(TAG, "compatibility mode:" + compatibilityModeEnabled);
11972        }
11973
11974        synchronized (mPackages) {
11975            // Verify that all of the preferred activity components actually
11976            // exist.  It is possible for applications to be updated and at
11977            // that point remove a previously declared activity component that
11978            // had been set as a preferred activity.  We try to clean this up
11979            // the next time we encounter that preferred activity, but it is
11980            // possible for the user flow to never be able to return to that
11981            // situation so here we do a sanity check to make sure we haven't
11982            // left any junk around.
11983            ArrayList<PreferredActivity> removed = new ArrayList<PreferredActivity>();
11984            for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
11985                PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
11986                removed.clear();
11987                for (PreferredActivity pa : pir.filterSet()) {
11988                    if (mActivities.mActivities.get(pa.mPref.mComponent) == null) {
11989                        removed.add(pa);
11990                    }
11991                }
11992                if (removed.size() > 0) {
11993                    for (int r=0; r<removed.size(); r++) {
11994                        PreferredActivity pa = removed.get(r);
11995                        Slog.w(TAG, "Removing dangling preferred activity: "
11996                                + pa.mPref.mComponent);
11997                        pir.removeFilter(pa);
11998                    }
11999                    mSettings.writePackageRestrictionsLPr(
12000                            mSettings.mPreferredActivities.keyAt(i));
12001                }
12002            }
12003        }
12004        sUserManager.systemReady();
12005    }
12006
12007    @Override
12008    public boolean isSafeMode() {
12009        return mSafeMode;
12010    }
12011
12012    @Override
12013    public boolean hasSystemUidErrors() {
12014        return mHasSystemUidErrors;
12015    }
12016
12017    static String arrayToString(int[] array) {
12018        StringBuffer buf = new StringBuffer(128);
12019        buf.append('[');
12020        if (array != null) {
12021            for (int i=0; i<array.length; i++) {
12022                if (i > 0) buf.append(", ");
12023                buf.append(array[i]);
12024            }
12025        }
12026        buf.append(']');
12027        return buf.toString();
12028    }
12029
12030    static class DumpState {
12031        public static final int DUMP_LIBS = 1 << 0;
12032        public static final int DUMP_FEATURES = 1 << 1;
12033        public static final int DUMP_RESOLVERS = 1 << 2;
12034        public static final int DUMP_PERMISSIONS = 1 << 3;
12035        public static final int DUMP_PACKAGES = 1 << 4;
12036        public static final int DUMP_SHARED_USERS = 1 << 5;
12037        public static final int DUMP_MESSAGES = 1 << 6;
12038        public static final int DUMP_PROVIDERS = 1 << 7;
12039        public static final int DUMP_VERIFIERS = 1 << 8;
12040        public static final int DUMP_PREFERRED = 1 << 9;
12041        public static final int DUMP_PREFERRED_XML = 1 << 10;
12042        public static final int DUMP_KEYSETS = 1 << 11;
12043        public static final int DUMP_VERSION = 1 << 12;
12044        public static final int DUMP_INSTALLS = 1 << 13;
12045
12046        public static final int OPTION_SHOW_FILTERS = 1 << 0;
12047
12048        private int mTypes;
12049
12050        private int mOptions;
12051
12052        private boolean mTitlePrinted;
12053
12054        private SharedUserSetting mSharedUser;
12055
12056        public boolean isDumping(int type) {
12057            if (mTypes == 0 && type != DUMP_PREFERRED_XML) {
12058                return true;
12059            }
12060
12061            return (mTypes & type) != 0;
12062        }
12063
12064        public void setDump(int type) {
12065            mTypes |= type;
12066        }
12067
12068        public boolean isOptionEnabled(int option) {
12069            return (mOptions & option) != 0;
12070        }
12071
12072        public void setOptionEnabled(int option) {
12073            mOptions |= option;
12074        }
12075
12076        public boolean onTitlePrinted() {
12077            final boolean printed = mTitlePrinted;
12078            mTitlePrinted = true;
12079            return printed;
12080        }
12081
12082        public boolean getTitlePrinted() {
12083            return mTitlePrinted;
12084        }
12085
12086        public void setTitlePrinted(boolean enabled) {
12087            mTitlePrinted = enabled;
12088        }
12089
12090        public SharedUserSetting getSharedUser() {
12091            return mSharedUser;
12092        }
12093
12094        public void setSharedUser(SharedUserSetting user) {
12095            mSharedUser = user;
12096        }
12097    }
12098
12099    @Override
12100    protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
12101        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
12102                != PackageManager.PERMISSION_GRANTED) {
12103            pw.println("Permission Denial: can't dump ActivityManager from from pid="
12104                    + Binder.getCallingPid()
12105                    + ", uid=" + Binder.getCallingUid()
12106                    + " without permission "
12107                    + android.Manifest.permission.DUMP);
12108            return;
12109        }
12110
12111        DumpState dumpState = new DumpState();
12112        boolean fullPreferred = false;
12113        boolean checkin = false;
12114
12115        String packageName = null;
12116
12117        int opti = 0;
12118        while (opti < args.length) {
12119            String opt = args[opti];
12120            if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
12121                break;
12122            }
12123            opti++;
12124            if ("-a".equals(opt)) {
12125                // Right now we only know how to print all.
12126            } else if ("-h".equals(opt)) {
12127                pw.println("Package manager dump options:");
12128                pw.println("  [-h] [-f] [--checkin] [cmd] ...");
12129                pw.println("    --checkin: dump for a checkin");
12130                pw.println("    -f: print details of intent filters");
12131                pw.println("    -h: print this help");
12132                pw.println("  cmd may be one of:");
12133                pw.println("    l[ibraries]: list known shared libraries");
12134                pw.println("    f[ibraries]: list device features");
12135                pw.println("    k[eysets]: print known keysets");
12136                pw.println("    r[esolvers]: dump intent resolvers");
12137                pw.println("    perm[issions]: dump permissions");
12138                pw.println("    pref[erred]: print preferred package settings");
12139                pw.println("    preferred-xml [--full]: print preferred package settings as xml");
12140                pw.println("    prov[iders]: dump content providers");
12141                pw.println("    p[ackages]: dump installed packages");
12142                pw.println("    s[hared-users]: dump shared user IDs");
12143                pw.println("    m[essages]: print collected runtime messages");
12144                pw.println("    v[erifiers]: print package verifier info");
12145                pw.println("    version: print database version info");
12146                pw.println("    write: write current settings now");
12147                pw.println("    <package.name>: info about given package");
12148                pw.println("    installs: details about install sessions");
12149                return;
12150            } else if ("--checkin".equals(opt)) {
12151                checkin = true;
12152            } else if ("-f".equals(opt)) {
12153                dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
12154            } else {
12155                pw.println("Unknown argument: " + opt + "; use -h for help");
12156            }
12157        }
12158
12159        // Is the caller requesting to dump a particular piece of data?
12160        if (opti < args.length) {
12161            String cmd = args[opti];
12162            opti++;
12163            // Is this a package name?
12164            if ("android".equals(cmd) || cmd.contains(".")) {
12165                packageName = cmd;
12166                // When dumping a single package, we always dump all of its
12167                // filter information since the amount of data will be reasonable.
12168                dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
12169            } else if ("l".equals(cmd) || "libraries".equals(cmd)) {
12170                dumpState.setDump(DumpState.DUMP_LIBS);
12171            } else if ("f".equals(cmd) || "features".equals(cmd)) {
12172                dumpState.setDump(DumpState.DUMP_FEATURES);
12173            } else if ("r".equals(cmd) || "resolvers".equals(cmd)) {
12174                dumpState.setDump(DumpState.DUMP_RESOLVERS);
12175            } else if ("perm".equals(cmd) || "permissions".equals(cmd)) {
12176                dumpState.setDump(DumpState.DUMP_PERMISSIONS);
12177            } else if ("pref".equals(cmd) || "preferred".equals(cmd)) {
12178                dumpState.setDump(DumpState.DUMP_PREFERRED);
12179            } else if ("preferred-xml".equals(cmd)) {
12180                dumpState.setDump(DumpState.DUMP_PREFERRED_XML);
12181                if (opti < args.length && "--full".equals(args[opti])) {
12182                    fullPreferred = true;
12183                    opti++;
12184                }
12185            } else if ("p".equals(cmd) || "packages".equals(cmd)) {
12186                dumpState.setDump(DumpState.DUMP_PACKAGES);
12187            } else if ("s".equals(cmd) || "shared-users".equals(cmd)) {
12188                dumpState.setDump(DumpState.DUMP_SHARED_USERS);
12189            } else if ("prov".equals(cmd) || "providers".equals(cmd)) {
12190                dumpState.setDump(DumpState.DUMP_PROVIDERS);
12191            } else if ("m".equals(cmd) || "messages".equals(cmd)) {
12192                dumpState.setDump(DumpState.DUMP_MESSAGES);
12193            } else if ("v".equals(cmd) || "verifiers".equals(cmd)) {
12194                dumpState.setDump(DumpState.DUMP_VERIFIERS);
12195            } else if ("version".equals(cmd)) {
12196                dumpState.setDump(DumpState.DUMP_VERSION);
12197            } else if ("k".equals(cmd) || "keysets".equals(cmd)) {
12198                dumpState.setDump(DumpState.DUMP_KEYSETS);
12199            } else if ("write".equals(cmd)) {
12200                synchronized (mPackages) {
12201                    mSettings.writeLPr();
12202                    pw.println("Settings written.");
12203                    return;
12204                }
12205            } else if ("installs".equals(cmd)) {
12206                dumpState.setDump(DumpState.DUMP_INSTALLS);
12207            }
12208        }
12209
12210        if (checkin) {
12211            pw.println("vers,1");
12212        }
12213
12214        // reader
12215        synchronized (mPackages) {
12216            if (dumpState.isDumping(DumpState.DUMP_VERSION) && packageName == null) {
12217                if (!checkin) {
12218                    if (dumpState.onTitlePrinted())
12219                        pw.println();
12220                    pw.println("Database versions:");
12221                    pw.print("  SDK Version:");
12222                    pw.print(" internal=");
12223                    pw.print(mSettings.mInternalSdkPlatform);
12224                    pw.print(" external=");
12225                    pw.println(mSettings.mExternalSdkPlatform);
12226                    pw.print("  DB Version:");
12227                    pw.print(" internal=");
12228                    pw.print(mSettings.mInternalDatabaseVersion);
12229                    pw.print(" external=");
12230                    pw.println(mSettings.mExternalDatabaseVersion);
12231                }
12232            }
12233
12234            if (dumpState.isDumping(DumpState.DUMP_VERIFIERS) && packageName == null) {
12235                if (!checkin) {
12236                    if (dumpState.onTitlePrinted())
12237                        pw.println();
12238                    pw.println("Verifiers:");
12239                    pw.print("  Required: ");
12240                    pw.print(mRequiredVerifierPackage);
12241                    pw.print(" (uid=");
12242                    pw.print(getPackageUid(mRequiredVerifierPackage, 0));
12243                    pw.println(")");
12244                } else if (mRequiredVerifierPackage != null) {
12245                    pw.print("vrfy,"); pw.print(mRequiredVerifierPackage);
12246                    pw.print(","); pw.println(getPackageUid(mRequiredVerifierPackage, 0));
12247                }
12248            }
12249
12250            if (dumpState.isDumping(DumpState.DUMP_LIBS) && packageName == null) {
12251                boolean printedHeader = false;
12252                final Iterator<String> it = mSharedLibraries.keySet().iterator();
12253                while (it.hasNext()) {
12254                    String name = it.next();
12255                    SharedLibraryEntry ent = mSharedLibraries.get(name);
12256                    if (!checkin) {
12257                        if (!printedHeader) {
12258                            if (dumpState.onTitlePrinted())
12259                                pw.println();
12260                            pw.println("Libraries:");
12261                            printedHeader = true;
12262                        }
12263                        pw.print("  ");
12264                    } else {
12265                        pw.print("lib,");
12266                    }
12267                    pw.print(name);
12268                    if (!checkin) {
12269                        pw.print(" -> ");
12270                    }
12271                    if (ent.path != null) {
12272                        if (!checkin) {
12273                            pw.print("(jar) ");
12274                            pw.print(ent.path);
12275                        } else {
12276                            pw.print(",jar,");
12277                            pw.print(ent.path);
12278                        }
12279                    } else {
12280                        if (!checkin) {
12281                            pw.print("(apk) ");
12282                            pw.print(ent.apk);
12283                        } else {
12284                            pw.print(",apk,");
12285                            pw.print(ent.apk);
12286                        }
12287                    }
12288                    pw.println();
12289                }
12290            }
12291
12292            if (dumpState.isDumping(DumpState.DUMP_FEATURES) && packageName == null) {
12293                if (dumpState.onTitlePrinted())
12294                    pw.println();
12295                if (!checkin) {
12296                    pw.println("Features:");
12297                }
12298                Iterator<String> it = mAvailableFeatures.keySet().iterator();
12299                while (it.hasNext()) {
12300                    String name = it.next();
12301                    if (!checkin) {
12302                        pw.print("  ");
12303                    } else {
12304                        pw.print("feat,");
12305                    }
12306                    pw.println(name);
12307                }
12308            }
12309
12310            if (!checkin && dumpState.isDumping(DumpState.DUMP_RESOLVERS)) {
12311                if (mActivities.dump(pw, dumpState.getTitlePrinted() ? "\nActivity Resolver Table:"
12312                        : "Activity Resolver Table:", "  ", packageName,
12313                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
12314                    dumpState.setTitlePrinted(true);
12315                }
12316                if (mReceivers.dump(pw, dumpState.getTitlePrinted() ? "\nReceiver Resolver Table:"
12317                        : "Receiver Resolver Table:", "  ", packageName,
12318                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
12319                    dumpState.setTitlePrinted(true);
12320                }
12321                if (mServices.dump(pw, dumpState.getTitlePrinted() ? "\nService Resolver Table:"
12322                        : "Service Resolver Table:", "  ", packageName,
12323                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
12324                    dumpState.setTitlePrinted(true);
12325                }
12326                if (mProviders.dump(pw, dumpState.getTitlePrinted() ? "\nProvider Resolver Table:"
12327                        : "Provider Resolver Table:", "  ", packageName,
12328                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
12329                    dumpState.setTitlePrinted(true);
12330                }
12331            }
12332
12333            if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED)) {
12334                for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
12335                    PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
12336                    int user = mSettings.mPreferredActivities.keyAt(i);
12337                    if (pir.dump(pw,
12338                            dumpState.getTitlePrinted()
12339                                ? "\nPreferred Activities User " + user + ":"
12340                                : "Preferred Activities User " + user + ":", "  ",
12341                            packageName, true)) {
12342                        dumpState.setTitlePrinted(true);
12343                    }
12344                }
12345            }
12346
12347            if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED_XML)) {
12348                pw.flush();
12349                FileOutputStream fout = new FileOutputStream(fd);
12350                BufferedOutputStream str = new BufferedOutputStream(fout);
12351                XmlSerializer serializer = new FastXmlSerializer();
12352                try {
12353                    serializer.setOutput(str, "utf-8");
12354                    serializer.startDocument(null, true);
12355                    serializer.setFeature(
12356                            "http://xmlpull.org/v1/doc/features.html#indent-output", true);
12357                    mSettings.writePreferredActivitiesLPr(serializer, 0, fullPreferred);
12358                    serializer.endDocument();
12359                    serializer.flush();
12360                } catch (IllegalArgumentException e) {
12361                    pw.println("Failed writing: " + e);
12362                } catch (IllegalStateException e) {
12363                    pw.println("Failed writing: " + e);
12364                } catch (IOException e) {
12365                    pw.println("Failed writing: " + e);
12366                }
12367            }
12368
12369            if (!checkin && dumpState.isDumping(DumpState.DUMP_PERMISSIONS)) {
12370                mSettings.dumpPermissionsLPr(pw, packageName, dumpState);
12371            }
12372
12373            if (!checkin && dumpState.isDumping(DumpState.DUMP_PROVIDERS)) {
12374                boolean printedSomething = false;
12375                for (PackageParser.Provider p : mProviders.mProviders.values()) {
12376                    if (packageName != null && !packageName.equals(p.info.packageName)) {
12377                        continue;
12378                    }
12379                    if (!printedSomething) {
12380                        if (dumpState.onTitlePrinted())
12381                            pw.println();
12382                        pw.println("Registered ContentProviders:");
12383                        printedSomething = true;
12384                    }
12385                    pw.print("  "); p.printComponentShortName(pw); pw.println(":");
12386                    pw.print("    "); pw.println(p.toString());
12387                }
12388                printedSomething = false;
12389                for (Map.Entry<String, PackageParser.Provider> entry :
12390                        mProvidersByAuthority.entrySet()) {
12391                    PackageParser.Provider p = entry.getValue();
12392                    if (packageName != null && !packageName.equals(p.info.packageName)) {
12393                        continue;
12394                    }
12395                    if (!printedSomething) {
12396                        if (dumpState.onTitlePrinted())
12397                            pw.println();
12398                        pw.println("ContentProvider Authorities:");
12399                        printedSomething = true;
12400                    }
12401                    pw.print("  ["); pw.print(entry.getKey()); pw.println("]:");
12402                    pw.print("    "); pw.println(p.toString());
12403                    if (p.info != null && p.info.applicationInfo != null) {
12404                        final String appInfo = p.info.applicationInfo.toString();
12405                        pw.print("      applicationInfo="); pw.println(appInfo);
12406                    }
12407                }
12408            }
12409
12410            if (!checkin && dumpState.isDumping(DumpState.DUMP_KEYSETS)) {
12411                mSettings.mKeySetManagerService.dumpLPr(pw, packageName, dumpState);
12412            }
12413
12414            if (dumpState.isDumping(DumpState.DUMP_PACKAGES)) {
12415                mSettings.dumpPackagesLPr(pw, packageName, dumpState, checkin);
12416            }
12417
12418            if (!checkin && dumpState.isDumping(DumpState.DUMP_SHARED_USERS)) {
12419                mSettings.dumpSharedUsersLPr(pw, packageName, dumpState);
12420            }
12421
12422            if (!checkin && dumpState.isDumping(DumpState.DUMP_INSTALLS)) {
12423                if (dumpState.onTitlePrinted()) pw.println();
12424                mInstallerService.dump(new IndentingPrintWriter(pw, "  ", 120));
12425            }
12426
12427            if (!checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES) && packageName == null) {
12428                if (dumpState.onTitlePrinted()) pw.println();
12429                mSettings.dumpReadMessagesLPr(pw, dumpState);
12430
12431                pw.println();
12432                pw.println("Package warning messages:");
12433                final File fname = getSettingsProblemFile();
12434                FileInputStream in = null;
12435                try {
12436                    in = new FileInputStream(fname);
12437                    final int avail = in.available();
12438                    final byte[] data = new byte[avail];
12439                    in.read(data);
12440                    pw.print(new String(data));
12441                } catch (FileNotFoundException e) {
12442                } catch (IOException e) {
12443                } finally {
12444                    if (in != null) {
12445                        try {
12446                            in.close();
12447                        } catch (IOException e) {
12448                        }
12449                    }
12450                }
12451            }
12452        }
12453    }
12454
12455    // ------- apps on sdcard specific code -------
12456    static final boolean DEBUG_SD_INSTALL = false;
12457
12458    private static final String SD_ENCRYPTION_KEYSTORE_NAME = "AppsOnSD";
12459
12460    private static final String SD_ENCRYPTION_ALGORITHM = "AES";
12461
12462    private boolean mMediaMounted = false;
12463
12464    private String getEncryptKey() {
12465        try {
12466            String sdEncKey = SystemKeyStore.getInstance().retrieveKeyHexString(
12467                    SD_ENCRYPTION_KEYSTORE_NAME);
12468            if (sdEncKey == null) {
12469                sdEncKey = SystemKeyStore.getInstance().generateNewKeyHexString(128,
12470                        SD_ENCRYPTION_ALGORITHM, SD_ENCRYPTION_KEYSTORE_NAME);
12471                if (sdEncKey == null) {
12472                    Slog.e(TAG, "Failed to create encryption keys");
12473                    return null;
12474                }
12475            }
12476            return sdEncKey;
12477        } catch (NoSuchAlgorithmException nsae) {
12478            Slog.e(TAG, "Failed to create encryption keys with exception: " + nsae);
12479            return null;
12480        } catch (IOException ioe) {
12481            Slog.e(TAG, "Failed to retrieve encryption keys with exception: " + ioe);
12482            return null;
12483        }
12484
12485    }
12486
12487    /* package */static String getTempContainerId() {
12488        int tmpIdx = 1;
12489        String list[] = PackageHelper.getSecureContainerList();
12490        if (list != null) {
12491            for (final String name : list) {
12492                // Ignore null and non-temporary container entries
12493                if (name == null || !name.startsWith(mTempContainerPrefix)) {
12494                    continue;
12495                }
12496
12497                String subStr = name.substring(mTempContainerPrefix.length());
12498                try {
12499                    int cid = Integer.parseInt(subStr);
12500                    if (cid >= tmpIdx) {
12501                        tmpIdx = cid + 1;
12502                    }
12503                } catch (NumberFormatException e) {
12504                }
12505            }
12506        }
12507        return mTempContainerPrefix + tmpIdx;
12508    }
12509
12510    /*
12511     * Update media status on PackageManager.
12512     */
12513    @Override
12514    public void updateExternalMediaStatus(final boolean mediaStatus, final boolean reportStatus) {
12515        int callingUid = Binder.getCallingUid();
12516        if (callingUid != 0 && callingUid != Process.SYSTEM_UID) {
12517            throw new SecurityException("Media status can only be updated by the system");
12518        }
12519        // reader; this apparently protects mMediaMounted, but should probably
12520        // be a different lock in that case.
12521        synchronized (mPackages) {
12522            Log.i(TAG, "Updating external media status from "
12523                    + (mMediaMounted ? "mounted" : "unmounted") + " to "
12524                    + (mediaStatus ? "mounted" : "unmounted"));
12525            if (DEBUG_SD_INSTALL)
12526                Log.i(TAG, "updateExternalMediaStatus:: mediaStatus=" + mediaStatus
12527                        + ", mMediaMounted=" + mMediaMounted);
12528            if (mediaStatus == mMediaMounted) {
12529                final Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS, reportStatus ? 1
12530                        : 0, -1);
12531                mHandler.sendMessage(msg);
12532                return;
12533            }
12534            mMediaMounted = mediaStatus;
12535        }
12536        // Queue up an async operation since the package installation may take a
12537        // little while.
12538        mHandler.post(new Runnable() {
12539            public void run() {
12540                updateExternalMediaStatusInner(mediaStatus, reportStatus, true);
12541            }
12542        });
12543    }
12544
12545    /**
12546     * Called by MountService when the initial ASECs to scan are available.
12547     * Should block until all the ASEC containers are finished being scanned.
12548     */
12549    public void scanAvailableAsecs() {
12550        updateExternalMediaStatusInner(true, false, false);
12551        if (mShouldRestoreconData) {
12552            SELinuxMMAC.setRestoreconDone();
12553            mShouldRestoreconData = false;
12554        }
12555    }
12556
12557    /*
12558     * Collect information of applications on external media, map them against
12559     * existing containers and update information based on current mount status.
12560     * Please note that we always have to report status if reportStatus has been
12561     * set to true especially when unloading packages.
12562     */
12563    private void updateExternalMediaStatusInner(boolean isMounted, boolean reportStatus,
12564            boolean externalStorage) {
12565        // Collection of uids
12566        int uidArr[] = null;
12567        // Collection of stale containers
12568        HashSet<String> removeCids = new HashSet<String>();
12569        // Collection of packages on external media with valid containers.
12570        HashMap<AsecInstallArgs, String> processCids = new HashMap<AsecInstallArgs, String>();
12571        // Get list of secure containers.
12572        final String list[] = PackageHelper.getSecureContainerList();
12573        if (list == null || list.length == 0) {
12574            Log.i(TAG, "No secure containers on sdcard");
12575        } else {
12576            // Process list of secure containers and categorize them
12577            // as active or stale based on their package internal state.
12578            int uidList[] = new int[list.length];
12579            int num = 0;
12580            // reader
12581            synchronized (mPackages) {
12582                for (String cid : list) {
12583                    if (DEBUG_SD_INSTALL)
12584                        Log.i(TAG, "Processing container " + cid);
12585                    String pkgName = getAsecPackageName(cid);
12586                    if (pkgName == null) {
12587                        if (DEBUG_SD_INSTALL)
12588                            Log.i(TAG, "Container : " + cid + " stale");
12589                        removeCids.add(cid);
12590                        continue;
12591                    }
12592                    if (DEBUG_SD_INSTALL)
12593                        Log.i(TAG, "Looking for pkg : " + pkgName);
12594
12595                    final PackageSetting ps = mSettings.mPackages.get(pkgName);
12596                    if (ps == null) {
12597                        Log.i(TAG, "Deleting container with no matching settings " + cid);
12598                        removeCids.add(cid);
12599                        continue;
12600                    }
12601
12602                    /*
12603                     * Skip packages that are not external if we're unmounting
12604                     * external storage.
12605                     */
12606                    if (externalStorage && !isMounted && !isExternal(ps)) {
12607                        continue;
12608                    }
12609
12610                    final AsecInstallArgs args = new AsecInstallArgs(cid,
12611                            getAppDexInstructionSets(ps), isForwardLocked(ps), isMultiArch(ps));
12612                    // The package status is changed only if the code path
12613                    // matches between settings and the container id.
12614                    if (ps.codePathString != null && ps.codePathString.equals(args.getCodePath())) {
12615                        if (DEBUG_SD_INSTALL) {
12616                            Log.i(TAG, "Container : " + cid + " corresponds to pkg : " + pkgName
12617                                    + " at code path: " + ps.codePathString);
12618                        }
12619
12620                        // We do have a valid package installed on sdcard
12621                        processCids.put(args, ps.codePathString);
12622                        final int uid = ps.appId;
12623                        if (uid != -1) {
12624                            uidList[num++] = uid;
12625                        }
12626                    } else {
12627                        Log.i(TAG, "Deleting stale container for " + cid);
12628                        removeCids.add(cid);
12629                    }
12630                }
12631            }
12632
12633            if (num > 0) {
12634                // Sort uid list
12635                Arrays.sort(uidList, 0, num);
12636                // Throw away duplicates
12637                uidArr = new int[num];
12638                uidArr[0] = uidList[0];
12639                int di = 0;
12640                for (int i = 1; i < num; i++) {
12641                    if (uidList[i - 1] != uidList[i]) {
12642                        uidArr[di++] = uidList[i];
12643                    }
12644                }
12645            }
12646        }
12647        // Process packages with valid entries.
12648        if (isMounted) {
12649            if (DEBUG_SD_INSTALL)
12650                Log.i(TAG, "Loading packages");
12651            loadMediaPackages(processCids, uidArr, removeCids);
12652            startCleaningPackages();
12653        } else {
12654            if (DEBUG_SD_INSTALL)
12655                Log.i(TAG, "Unloading packages");
12656            unloadMediaPackages(processCids, uidArr, reportStatus);
12657        }
12658    }
12659
12660   private void sendResourcesChangedBroadcast(boolean mediaStatus, boolean replacing,
12661           ArrayList<String> pkgList, int uidArr[], IIntentReceiver finishedReceiver) {
12662        int size = pkgList.size();
12663        if (size > 0) {
12664            // Send broadcasts here
12665            Bundle extras = new Bundle();
12666            extras.putStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST, pkgList
12667                    .toArray(new String[size]));
12668            if (uidArr != null) {
12669                extras.putIntArray(Intent.EXTRA_CHANGED_UID_LIST, uidArr);
12670            }
12671            if (replacing) {
12672                extras.putBoolean(Intent.EXTRA_REPLACING, replacing);
12673            }
12674            String action = mediaStatus ? Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE
12675                    : Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE;
12676            sendPackageBroadcast(action, null, extras, null, finishedReceiver, null);
12677        }
12678    }
12679
12680   /*
12681     * Look at potentially valid container ids from processCids If package
12682     * information doesn't match the one on record or package scanning fails,
12683     * the cid is added to list of removeCids. We currently don't delete stale
12684     * containers.
12685     */
12686   private void loadMediaPackages(HashMap<AsecInstallArgs, String> processCids, int uidArr[],
12687            HashSet<String> removeCids) {
12688        ArrayList<String> pkgList = new ArrayList<String>();
12689        Set<AsecInstallArgs> keys = processCids.keySet();
12690        boolean doGc = false;
12691        for (AsecInstallArgs args : keys) {
12692            String codePath = processCids.get(args);
12693            if (DEBUG_SD_INSTALL)
12694                Log.i(TAG, "Loading container : " + args.cid);
12695            int retCode = PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
12696            try {
12697                // Make sure there are no container errors first.
12698                if (args.doPreInstall(PackageManager.INSTALL_SUCCEEDED) != PackageManager.INSTALL_SUCCEEDED) {
12699                    Slog.e(TAG, "Failed to mount cid : " + args.cid
12700                            + " when installing from sdcard");
12701                    continue;
12702                }
12703                // Check code path here.
12704                if (codePath == null || !codePath.equals(args.getCodePath())) {
12705                    Slog.e(TAG, "Container " + args.cid + " cachepath " + args.getCodePath()
12706                            + " does not match one in settings " + codePath);
12707                    continue;
12708                }
12709                // Parse package
12710                int parseFlags = mDefParseFlags;
12711                if (args.isExternal()) {
12712                    parseFlags |= PackageParser.PARSE_ON_SDCARD;
12713                }
12714                if (args.isFwdLocked()) {
12715                    parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
12716                }
12717
12718                doGc = true;
12719                synchronized (mInstallLock) {
12720                    PackageParser.Package pkg = null;
12721                    try {
12722                        pkg = scanPackageLI(new File(codePath), parseFlags, 0, 0, null, null);
12723                    } catch (PackageManagerException e) {
12724                        Slog.w(TAG, "Failed to scan " + codePath + ": " + e.getMessage());
12725                    }
12726                    // Scan the package
12727                    if (pkg != null) {
12728                        /*
12729                         * TODO why is the lock being held? doPostInstall is
12730                         * called in other places without the lock. This needs
12731                         * to be straightened out.
12732                         */
12733                        // writer
12734                        synchronized (mPackages) {
12735                            retCode = PackageManager.INSTALL_SUCCEEDED;
12736                            pkgList.add(pkg.packageName);
12737                            // Post process args
12738                            args.doPostInstall(PackageManager.INSTALL_SUCCEEDED,
12739                                    pkg.applicationInfo.uid);
12740                        }
12741                    } else {
12742                        Slog.i(TAG, "Failed to install pkg from  " + codePath + " from sdcard");
12743                    }
12744                }
12745
12746            } finally {
12747                if (retCode != PackageManager.INSTALL_SUCCEEDED) {
12748                    // Don't destroy container here. Wait till gc clears things
12749                    // up.
12750                    removeCids.add(args.cid);
12751                }
12752            }
12753        }
12754        // writer
12755        synchronized (mPackages) {
12756            // If the platform SDK has changed since the last time we booted,
12757            // we need to re-grant app permission to catch any new ones that
12758            // appear. This is really a hack, and means that apps can in some
12759            // cases get permissions that the user didn't initially explicitly
12760            // allow... it would be nice to have some better way to handle
12761            // this situation.
12762            final boolean regrantPermissions = mSettings.mExternalSdkPlatform != mSdkVersion;
12763            if (regrantPermissions)
12764                Slog.i(TAG, "Platform changed from " + mSettings.mExternalSdkPlatform + " to "
12765                        + mSdkVersion + "; regranting permissions for external storage");
12766            mSettings.mExternalSdkPlatform = mSdkVersion;
12767
12768            // Make sure group IDs have been assigned, and any permission
12769            // changes in other apps are accounted for
12770            updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL
12771                    | (regrantPermissions
12772                            ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL)
12773                            : 0));
12774
12775            mSettings.updateExternalDatabaseVersion();
12776
12777            // can downgrade to reader
12778            // Persist settings
12779            mSettings.writeLPr();
12780        }
12781        // Send a broadcast to let everyone know we are done processing
12782        if (pkgList.size() > 0) {
12783            sendResourcesChangedBroadcast(true, false, pkgList, uidArr, null);
12784        }
12785        // Force gc to avoid any stale parser references that we might have.
12786        if (doGc) {
12787            Runtime.getRuntime().gc();
12788        }
12789        // List stale containers and destroy stale temporary containers.
12790        if (removeCids != null) {
12791            for (String cid : removeCids) {
12792                if (cid.startsWith(mTempContainerPrefix)) {
12793                    Log.i(TAG, "Destroying stale temporary container " + cid);
12794                    PackageHelper.destroySdDir(cid);
12795                } else {
12796                    Log.w(TAG, "Container " + cid + " is stale");
12797               }
12798           }
12799        }
12800    }
12801
12802   /*
12803     * Utility method to unload a list of specified containers
12804     */
12805    private void unloadAllContainers(Set<AsecInstallArgs> cidArgs) {
12806        // Just unmount all valid containers.
12807        for (AsecInstallArgs arg : cidArgs) {
12808            synchronized (mInstallLock) {
12809                arg.doPostDeleteLI(false);
12810           }
12811       }
12812   }
12813
12814    /*
12815     * Unload packages mounted on external media. This involves deleting package
12816     * data from internal structures, sending broadcasts about diabled packages,
12817     * gc'ing to free up references, unmounting all secure containers
12818     * corresponding to packages on external media, and posting a
12819     * UPDATED_MEDIA_STATUS message if status has been requested. Please note
12820     * that we always have to post this message if status has been requested no
12821     * matter what.
12822     */
12823    private void unloadMediaPackages(HashMap<AsecInstallArgs, String> processCids, int uidArr[],
12824            final boolean reportStatus) {
12825        if (DEBUG_SD_INSTALL)
12826            Log.i(TAG, "unloading media packages");
12827        ArrayList<String> pkgList = new ArrayList<String>();
12828        ArrayList<AsecInstallArgs> failedList = new ArrayList<AsecInstallArgs>();
12829        final Set<AsecInstallArgs> keys = processCids.keySet();
12830        for (AsecInstallArgs args : keys) {
12831            String pkgName = args.getPackageName();
12832            if (DEBUG_SD_INSTALL)
12833                Log.i(TAG, "Trying to unload pkg : " + pkgName);
12834            // Delete package internally
12835            PackageRemovedInfo outInfo = new PackageRemovedInfo();
12836            synchronized (mInstallLock) {
12837                boolean res = deletePackageLI(pkgName, null, false, null, null,
12838                        PackageManager.DELETE_KEEP_DATA, outInfo, false);
12839                if (res) {
12840                    pkgList.add(pkgName);
12841                } else {
12842                    Slog.e(TAG, "Failed to delete pkg from sdcard : " + pkgName);
12843                    failedList.add(args);
12844                }
12845            }
12846        }
12847
12848        // reader
12849        synchronized (mPackages) {
12850            // We didn't update the settings after removing each package;
12851            // write them now for all packages.
12852            mSettings.writeLPr();
12853        }
12854
12855        // We have to absolutely send UPDATED_MEDIA_STATUS only
12856        // after confirming that all the receivers processed the ordered
12857        // broadcast when packages get disabled, force a gc to clean things up.
12858        // and unload all the containers.
12859        if (pkgList.size() > 0) {
12860            sendResourcesChangedBroadcast(false, false, pkgList, uidArr,
12861                    new IIntentReceiver.Stub() {
12862                public void performReceive(Intent intent, int resultCode, String data,
12863                        Bundle extras, boolean ordered, boolean sticky,
12864                        int sendingUser) throws RemoteException {
12865                    Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS,
12866                            reportStatus ? 1 : 0, 1, keys);
12867                    mHandler.sendMessage(msg);
12868                }
12869            });
12870        } else {
12871            Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS, reportStatus ? 1 : 0, -1,
12872                    keys);
12873            mHandler.sendMessage(msg);
12874        }
12875    }
12876
12877    /** Binder call */
12878    @Override
12879    public void movePackage(final String packageName, final IPackageMoveObserver observer,
12880            final int flags) {
12881        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MOVE_PACKAGE, null);
12882        UserHandle user = new UserHandle(UserHandle.getCallingUserId());
12883        int returnCode = PackageManager.MOVE_SUCCEEDED;
12884        int currFlags = 0;
12885        int newFlags = 0;
12886        // reader
12887        synchronized (mPackages) {
12888            PackageParser.Package pkg = mPackages.get(packageName);
12889            if (pkg == null) {
12890                returnCode = PackageManager.MOVE_FAILED_DOESNT_EXIST;
12891            } else {
12892                // Disable moving fwd locked apps and system packages
12893                if (pkg.applicationInfo != null && isSystemApp(pkg)) {
12894                    Slog.w(TAG, "Cannot move system application");
12895                    returnCode = PackageManager.MOVE_FAILED_SYSTEM_PACKAGE;
12896                } else if (pkg.mOperationPending) {
12897                    Slog.w(TAG, "Attempt to move package which has pending operations");
12898                    returnCode = PackageManager.MOVE_FAILED_OPERATION_PENDING;
12899                } else {
12900                    // Find install location first
12901                    if ((flags & PackageManager.MOVE_EXTERNAL_MEDIA) != 0
12902                            && (flags & PackageManager.MOVE_INTERNAL) != 0) {
12903                        Slog.w(TAG, "Ambigous flags specified for move location.");
12904                        returnCode = PackageManager.MOVE_FAILED_INVALID_LOCATION;
12905                    } else {
12906                        newFlags = (flags & PackageManager.MOVE_EXTERNAL_MEDIA) != 0 ? PackageManager.INSTALL_EXTERNAL
12907                                : PackageManager.INSTALL_INTERNAL;
12908                        currFlags = isExternal(pkg) ? PackageManager.INSTALL_EXTERNAL
12909                                : PackageManager.INSTALL_INTERNAL;
12910
12911                        if (newFlags == currFlags) {
12912                            Slog.w(TAG, "No move required. Trying to move to same location");
12913                            returnCode = PackageManager.MOVE_FAILED_INVALID_LOCATION;
12914                        } else {
12915                            if (isForwardLocked(pkg)) {
12916                                currFlags |= PackageManager.INSTALL_FORWARD_LOCK;
12917                                newFlags |= PackageManager.INSTALL_FORWARD_LOCK;
12918                            }
12919                        }
12920                    }
12921                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
12922                        pkg.mOperationPending = true;
12923                    }
12924                }
12925            }
12926
12927            /*
12928             * TODO this next block probably shouldn't be inside the lock. We
12929             * can't guarantee these won't change after this is fired off
12930             * anyway.
12931             */
12932            if (returnCode != PackageManager.MOVE_SUCCEEDED) {
12933                processPendingMove(new MoveParams(null, observer, 0, packageName, null, -1, user, false),
12934                        returnCode);
12935            } else {
12936                Message msg = mHandler.obtainMessage(INIT_COPY);
12937                final String[] instructionSets = getAppDexInstructionSets(pkg.applicationInfo);
12938                final boolean multiArch = isMultiArch(pkg.applicationInfo);
12939                InstallArgs srcArgs = createInstallArgsForExisting(currFlags,
12940                        pkg.applicationInfo.getCodePath(), pkg.applicationInfo.getResourcePath(),
12941                        pkg.applicationInfo.nativeLibraryRootDir, instructionSets, multiArch);
12942                MoveParams mp = new MoveParams(srcArgs, observer, newFlags, packageName,
12943                        instructionSets, pkg.applicationInfo.uid, user, multiArch);
12944                msg.obj = mp;
12945                mHandler.sendMessage(msg);
12946            }
12947        }
12948    }
12949
12950    private void processPendingMove(final MoveParams mp, final int currentStatus) {
12951        // Queue up an async operation since the package deletion may take a
12952        // little while.
12953        mHandler.post(new Runnable() {
12954            public void run() {
12955                // TODO fix this; this does nothing.
12956                mHandler.removeCallbacks(this);
12957                int returnCode = currentStatus;
12958                if (currentStatus == PackageManager.MOVE_SUCCEEDED) {
12959                    int uidArr[] = null;
12960                    ArrayList<String> pkgList = null;
12961                    synchronized (mPackages) {
12962                        PackageParser.Package pkg = mPackages.get(mp.packageName);
12963                        if (pkg == null) {
12964                            Slog.w(TAG, " Package " + mp.packageName
12965                                    + " doesn't exist. Aborting move");
12966                            returnCode = PackageManager.MOVE_FAILED_DOESNT_EXIST;
12967                        } else if (!mp.srcArgs.getCodePath().equals(
12968                                pkg.applicationInfo.getCodePath())) {
12969                            Slog.w(TAG, "Package " + mp.packageName + " code path changed from "
12970                                    + mp.srcArgs.getCodePath() + " to "
12971                                    + pkg.applicationInfo.getCodePath()
12972                                    + " Aborting move and returning error");
12973                            returnCode = PackageManager.MOVE_FAILED_INTERNAL_ERROR;
12974                        } else {
12975                            uidArr = new int[] {
12976                                pkg.applicationInfo.uid
12977                            };
12978                            pkgList = new ArrayList<String>();
12979                            pkgList.add(mp.packageName);
12980                        }
12981                    }
12982                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
12983                        // Send resources unavailable broadcast
12984                        sendResourcesChangedBroadcast(false, true, pkgList, uidArr, null);
12985                        // Update package code and resource paths
12986                        synchronized (mInstallLock) {
12987                            synchronized (mPackages) {
12988                                PackageParser.Package pkg = mPackages.get(mp.packageName);
12989                                // Recheck for package again.
12990                                if (pkg == null) {
12991                                    Slog.w(TAG, " Package " + mp.packageName
12992                                            + " doesn't exist. Aborting move");
12993                                    returnCode = PackageManager.MOVE_FAILED_DOESNT_EXIST;
12994                                } else if (!mp.srcArgs.getCodePath().equals(
12995                                        pkg.applicationInfo.getCodePath())) {
12996                                    Slog.w(TAG, "Package " + mp.packageName
12997                                            + " code path changed from " + mp.srcArgs.getCodePath()
12998                                            + " to " + pkg.applicationInfo.getCodePath()
12999                                            + " Aborting move and returning error");
13000                                    returnCode = PackageManager.MOVE_FAILED_INTERNAL_ERROR;
13001                                } else {
13002                                    final String oldCodePath = pkg.codePath;
13003                                    final String newCodePath = mp.targetArgs.getCodePath();
13004                                    final String newResPath = mp.targetArgs.getResourcePath();
13005                                    // TODO: This assumes the new style of installation.
13006                                    // should we look at legacyNativeLibraryPath ?
13007                                    final String newNativeRoot = new File(pkg.codePath, LIB_DIR_NAME).getAbsolutePath();
13008                                    final File newNativeDir = new File(newNativeRoot);
13009
13010                                    if (!isForwardLocked(pkg) && !isExternal(pkg)) {
13011                                        // TODO(multiArch): Fix this so that it looks at the existing
13012                                        // recorded CPU abis from the package. There's no need for a separate
13013                                        // round of ABI scanning here.
13014                                        NativeLibraryHelper.Handle handle = null;
13015                                        try {
13016                                            handle = NativeLibraryHelper.Handle.create(
13017                                                    new File(newCodePath));
13018                                            final int abi = NativeLibraryHelper.findSupportedAbi(
13019                                                    handle, Build.SUPPORTED_ABIS);
13020                                            if (abi >= 0) {
13021                                                NativeLibraryHelper.copyNativeBinariesIfNeededLI(
13022                                                        handle, newNativeDir, Build.SUPPORTED_ABIS[abi]);
13023                                            }
13024                                        } catch (IOException ioe) {
13025                                            Slog.w(TAG, "Unable to extract native libs for package :"
13026                                                    + mp.packageName, ioe);
13027                                            returnCode = PackageManager.MOVE_FAILED_INTERNAL_ERROR;
13028                                        } finally {
13029                                            IoUtils.closeQuietly(handle);
13030                                        }
13031                                    }
13032
13033                                    final int[] users = sUserManager.getUserIds();
13034                                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
13035                                        for (int user : users) {
13036                                            // TODO(multiArch): Fix this so that it links to the
13037                                            // correct directory. We're currently pointing to root. but we
13038                                            // must point to the arch specific subdirectory (if applicable).
13039                                            //
13040                                            // TODO(multiArch): Bogus reference to nativeLibraryDir.
13041                                            if (mInstaller.linkNativeLibraryDirectory(pkg.packageName,
13042                                                    newNativeRoot, user) < 0) {
13043                                                returnCode = PackageManager.MOVE_FAILED_INSUFFICIENT_STORAGE;
13044                                            }
13045                                        }
13046                                    }
13047
13048                                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
13049                                        pkg.codePath = newCodePath;
13050                                        pkg.baseCodePath = newCodePath;
13051                                        // Move dex files around
13052                                        if (moveDexFilesLI(oldCodePath, pkg) != PackageManager.INSTALL_SUCCEEDED) {
13053                                            // Moving of dex files failed. Set
13054                                            // error code and abort move.
13055                                            pkg.codePath = oldCodePath;
13056                                            pkg.baseCodePath = oldCodePath;
13057                                            returnCode = PackageManager.MOVE_FAILED_INSUFFICIENT_STORAGE;
13058                                        }
13059                                    }
13060
13061                                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
13062                                        pkg.applicationInfo.setCodePath(newCodePath);
13063                                        pkg.applicationInfo.setBaseCodePath(newCodePath);
13064                                        pkg.applicationInfo.setSplitCodePaths(null);
13065                                        pkg.applicationInfo.setResourcePath(newResPath);
13066                                        pkg.applicationInfo.setBaseResourcePath(newResPath);
13067                                        pkg.applicationInfo.setSplitResourcePaths(null);
13068
13069                                        PackageSetting ps = (PackageSetting) pkg.mExtras;
13070                                        ps.codePath = new File(pkg.applicationInfo.getCodePath());
13071                                        ps.codePathString = ps.codePath.getPath();
13072                                        ps.resourcePath = new File(pkg.applicationInfo.getResourcePath());
13073                                        ps.resourcePathString = ps.resourcePath.getPath();
13074
13075                                        // Note that we don't have to recalculate the primary and secondary
13076                                        // CPU ABIs because they must already have been calculated during the
13077                                        // initial install of the app.
13078                                        ps.legacyNativeLibraryPathString = null;
13079
13080                                        // Set the application info flag
13081                                        // correctly.
13082                                        if ((mp.flags & PackageManager.INSTALL_EXTERNAL) != 0) {
13083                                            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_EXTERNAL_STORAGE;
13084                                        } else {
13085                                            pkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_EXTERNAL_STORAGE;
13086                                        }
13087                                        ps.setFlags(pkg.applicationInfo.flags);
13088                                        mAppDirs.remove(oldCodePath);
13089                                        mAppDirs.put(newCodePath, pkg);
13090                                        // Persist settings
13091                                        mSettings.writeLPr();
13092                                    }
13093                                }
13094                            }
13095                        }
13096                        // Send resources available broadcast
13097                        sendResourcesChangedBroadcast(true, false, pkgList, uidArr, null);
13098                    }
13099                }
13100                if (returnCode != PackageManager.MOVE_SUCCEEDED) {
13101                    // Clean up failed installation
13102                    if (mp.targetArgs != null) {
13103                        mp.targetArgs.doPostInstall(PackageManager.INSTALL_FAILED_INTERNAL_ERROR,
13104                                -1);
13105                    }
13106                } else {
13107                    // Force a gc to clear things up.
13108                    Runtime.getRuntime().gc();
13109                    // Delete older code
13110                    synchronized (mInstallLock) {
13111                        mp.srcArgs.doPostDeleteLI(true);
13112                    }
13113                }
13114
13115                // Allow more operations on this file if we didn't fail because
13116                // an operation was already pending for this package.
13117                if (returnCode != PackageManager.MOVE_FAILED_OPERATION_PENDING) {
13118                    synchronized (mPackages) {
13119                        PackageParser.Package pkg = mPackages.get(mp.packageName);
13120                        if (pkg != null) {
13121                            pkg.mOperationPending = false;
13122                       }
13123                   }
13124                }
13125
13126                IPackageMoveObserver observer = mp.observer;
13127                if (observer != null) {
13128                    try {
13129                        observer.packageMoved(mp.packageName, returnCode);
13130                    } catch (RemoteException e) {
13131                        Log.i(TAG, "Observer no longer exists.");
13132                    }
13133                }
13134            }
13135        });
13136    }
13137
13138    @Override
13139    public boolean setInstallLocation(int loc) {
13140        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WRITE_SECURE_SETTINGS,
13141                null);
13142        if (getInstallLocation() == loc) {
13143            return true;
13144        }
13145        if (loc == PackageHelper.APP_INSTALL_AUTO || loc == PackageHelper.APP_INSTALL_INTERNAL
13146                || loc == PackageHelper.APP_INSTALL_EXTERNAL) {
13147            android.provider.Settings.Global.putInt(mContext.getContentResolver(),
13148                    android.provider.Settings.Global.DEFAULT_INSTALL_LOCATION, loc);
13149            return true;
13150        }
13151        return false;
13152   }
13153
13154    @Override
13155    public int getInstallLocation() {
13156        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
13157                android.provider.Settings.Global.DEFAULT_INSTALL_LOCATION,
13158                PackageHelper.APP_INSTALL_AUTO);
13159    }
13160
13161    /** Called by UserManagerService */
13162    void cleanUpUserLILPw(int userHandle) {
13163        mDirtyUsers.remove(userHandle);
13164        mSettings.removeUserLPw(userHandle);
13165        mPendingBroadcasts.remove(userHandle);
13166        if (mInstaller != null) {
13167            // Technically, we shouldn't be doing this with the package lock
13168            // held.  However, this is very rare, and there is already so much
13169            // other disk I/O going on, that we'll let it slide for now.
13170            mInstaller.removeUserDataDirs(userHandle);
13171        }
13172        mUserNeedsBadging.delete(userHandle);
13173    }
13174
13175    /** Called by UserManagerService */
13176    void createNewUserLILPw(int userHandle, File path) {
13177        if (mInstaller != null) {
13178            mInstaller.createUserConfig(userHandle);
13179            mSettings.createNewUserLILPw(this, mInstaller, userHandle, path);
13180        }
13181    }
13182
13183    @Override
13184    public VerifierDeviceIdentity getVerifierDeviceIdentity() throws RemoteException {
13185        mContext.enforceCallingOrSelfPermission(
13186                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
13187                "Only package verification agents can read the verifier device identity");
13188
13189        synchronized (mPackages) {
13190            return mSettings.getVerifierDeviceIdentityLPw();
13191        }
13192    }
13193
13194    @Override
13195    public void setPermissionEnforced(String permission, boolean enforced) {
13196        mContext.enforceCallingOrSelfPermission(GRANT_REVOKE_PERMISSIONS, null);
13197        if (READ_EXTERNAL_STORAGE.equals(permission)) {
13198            synchronized (mPackages) {
13199                if (mSettings.mReadExternalStorageEnforced == null
13200                        || mSettings.mReadExternalStorageEnforced != enforced) {
13201                    mSettings.mReadExternalStorageEnforced = enforced;
13202                    mSettings.writeLPr();
13203                }
13204            }
13205            // kill any non-foreground processes so we restart them and
13206            // grant/revoke the GID.
13207            final IActivityManager am = ActivityManagerNative.getDefault();
13208            if (am != null) {
13209                final long token = Binder.clearCallingIdentity();
13210                try {
13211                    am.killProcessesBelowForeground("setPermissionEnforcement");
13212                } catch (RemoteException e) {
13213                } finally {
13214                    Binder.restoreCallingIdentity(token);
13215                }
13216            }
13217        } else {
13218            throw new IllegalArgumentException("No selective enforcement for " + permission);
13219        }
13220    }
13221
13222    @Override
13223    @Deprecated
13224    public boolean isPermissionEnforced(String permission) {
13225        return true;
13226    }
13227
13228    @Override
13229    public boolean isStorageLow() {
13230        final long token = Binder.clearCallingIdentity();
13231        try {
13232            final DeviceStorageMonitorInternal
13233                    dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
13234            if (dsm != null) {
13235                return dsm.isMemoryLow();
13236            } else {
13237                return false;
13238            }
13239        } finally {
13240            Binder.restoreCallingIdentity(token);
13241        }
13242    }
13243
13244    @Override
13245    public IPackageInstaller getPackageInstaller() {
13246        return mInstallerService;
13247    }
13248
13249    private boolean userNeedsBadging(int userId) {
13250        int index = mUserNeedsBadging.indexOfKey(userId);
13251        if (index < 0) {
13252            final UserInfo userInfo;
13253            final long token = Binder.clearCallingIdentity();
13254            try {
13255                userInfo = sUserManager.getUserInfo(userId);
13256            } finally {
13257                Binder.restoreCallingIdentity(token);
13258            }
13259            final boolean b;
13260            if (userInfo != null && userInfo.isManagedProfile()) {
13261                b = true;
13262            } else {
13263                b = false;
13264            }
13265            mUserNeedsBadging.put(userId, b);
13266            return b;
13267        }
13268        return mUserNeedsBadging.valueAt(index);
13269    }
13270
13271    @Override
13272    public KeySetHandle getKeySetByAlias(String packageName, String alias) {
13273        if (packageName == null || alias == null) {
13274            return null;
13275        }
13276        synchronized(mPackages) {
13277            final PackageParser.Package pkg = mPackages.get(packageName);
13278            if (pkg == null) {
13279                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13280                throw new IllegalArgumentException("Unknown package: " + packageName);
13281            }
13282            if (pkg.applicationInfo.uid != Binder.getCallingUid()
13283                    && Process.SYSTEM_UID != Binder.getCallingUid()) {
13284                throw new SecurityException("May not access KeySets defined by"
13285                        + " aliases in other applications.");
13286            }
13287            KeySetManagerService ksms = mSettings.mKeySetManagerService;
13288            return ksms.getKeySetByAliasAndPackageNameLPr(packageName, alias);
13289        }
13290    }
13291
13292    @Override
13293    public KeySetHandle getSigningKeySet(String packageName) {
13294        if (packageName == null) {
13295            return null;
13296        }
13297        synchronized(mPackages) {
13298            final PackageParser.Package pkg = mPackages.get(packageName);
13299            if (pkg == null) {
13300                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13301                throw new IllegalArgumentException("Unknown package: " + packageName);
13302            }
13303            if (pkg.applicationInfo.uid != Binder.getCallingUid()
13304                    && Process.SYSTEM_UID != Binder.getCallingUid()) {
13305                throw new SecurityException("May not access signing KeySet of other apps.");
13306            }
13307            KeySetManagerService ksms = mSettings.mKeySetManagerService;
13308            return ksms.getSigningKeySetByPackageNameLPr(packageName);
13309        }
13310    }
13311
13312    @Override
13313    public boolean isPackageSignedByKeySet(String packageName, IBinder ks) {
13314        if (packageName == null || ks == null) {
13315            return false;
13316        }
13317        synchronized(mPackages) {
13318            final PackageParser.Package pkg = mPackages.get(packageName);
13319            if (pkg == null) {
13320                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13321                throw new IllegalArgumentException("Unknown package: " + packageName);
13322            }
13323            if (ks instanceof KeySetHandle) {
13324                KeySetManagerService ksms = mSettings.mKeySetManagerService;
13325                return ksms.packageIsSignedByLPr(packageName, (KeySetHandle) ks);
13326            }
13327            return false;
13328        }
13329    }
13330
13331    @Override
13332    public boolean isPackageSignedByKeySetExactly(String packageName, IBinder ks) {
13333        if (packageName == null || ks == null) {
13334            return false;
13335        }
13336        synchronized(mPackages) {
13337            final PackageParser.Package pkg = mPackages.get(packageName);
13338            if (pkg == null) {
13339                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13340                throw new IllegalArgumentException("Unknown package: " + packageName);
13341            }
13342            if (ks instanceof KeySetHandle) {
13343                KeySetManagerService ksms = mSettings.mKeySetManagerService;
13344                return ksms.packageIsSignedByExactlyLPr(packageName, (KeySetHandle) ks);
13345            }
13346            return false;
13347        }
13348    }
13349}
13350