PackageManagerService.java revision f5f1828d968e427b95fe219af022434f1cdfaeb4 
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.Log;
169import android.util.LogPrinter;
170import android.util.PrintStreamPrinter;
171import android.util.Slog;
172import android.util.SparseArray;
173import android.util.SparseBooleanArray;
174import android.view.Display;
175
176import java.io.BufferedInputStream;
177import java.io.BufferedOutputStream;
178import java.io.File;
179import java.io.FileDescriptor;
180import java.io.FileInputStream;
181import java.io.FileNotFoundException;
182import java.io.FileOutputStream;
183import java.io.FilenameFilter;
184import java.io.IOException;
185import java.io.InputStream;
186import java.io.PrintWriter;
187import java.nio.charset.StandardCharsets;
188import java.security.NoSuchAlgorithmException;
189import java.security.PublicKey;
190import java.security.cert.CertificateEncodingException;
191import java.security.cert.CertificateException;
192import java.text.SimpleDateFormat;
193import java.util.ArrayList;
194import java.util.Arrays;
195import java.util.Collection;
196import java.util.Collections;
197import java.util.Comparator;
198import java.util.Date;
199import java.util.HashMap;
200import java.util.HashSet;
201import java.util.Iterator;
202import java.util.List;
203import java.util.Map;
204import java.util.Set;
205import java.util.concurrent.atomic.AtomicBoolean;
206import java.util.concurrent.atomic.AtomicLong;
207
208import dalvik.system.DexFile;
209import dalvik.system.StaleDexCacheError;
210import dalvik.system.VMRuntime;
211
212import libcore.io.IoUtils;
213
214/**
215 * Keep track of all those .apks everywhere.
216 *
217 * This is very central to the platform's security; please run the unit
218 * tests whenever making modifications here:
219 *
220mmm frameworks/base/tests/AndroidTests
221adb install -r -f out/target/product/passion/data/app/AndroidTests.apk
222adb shell am instrument -w -e class com.android.unit_tests.PackageManagerTests com.android.unit_tests/android.test.InstrumentationTestRunner
223 *
224 * {@hide}
225 */
226public class PackageManagerService extends IPackageManager.Stub {
227    static final String TAG = "PackageManager";
228    static final boolean DEBUG_SETTINGS = false;
229    static final boolean DEBUG_PREFERRED = false;
230    static final boolean DEBUG_UPGRADE = false;
231    private static final boolean DEBUG_INSTALL = false;
232    private static final boolean DEBUG_REMOVE = false;
233    private static final boolean DEBUG_BROADCASTS = false;
234    private static final boolean DEBUG_SHOW_INFO = false;
235    private static final boolean DEBUG_PACKAGE_INFO = false;
236    private static final boolean DEBUG_INTENT_MATCHING = false;
237    private static final boolean DEBUG_PACKAGE_SCANNING = false;
238    private static final boolean DEBUG_APP_DIR_OBSERVER = false;
239    private static final boolean DEBUG_VERIFY = false;
240    private static final boolean DEBUG_DEXOPT = false;
241    private static final boolean DEBUG_ABI_SELECTION = false;
242
243    private static final int RADIO_UID = Process.PHONE_UID;
244    private static final int LOG_UID = Process.LOG_UID;
245    private static final int NFC_UID = Process.NFC_UID;
246    private static final int BLUETOOTH_UID = Process.BLUETOOTH_UID;
247    private static final int SHELL_UID = Process.SHELL_UID;
248
249    // Cap the size of permission trees that 3rd party apps can define
250    private static final int MAX_PERMISSION_TREE_FOOTPRINT = 32768;     // characters of text
251
252    private static final int REMOVE_EVENTS =
253        FileObserver.CLOSE_WRITE | FileObserver.DELETE | FileObserver.MOVED_FROM;
254    private static final int ADD_EVENTS =
255        FileObserver.CLOSE_WRITE /*| FileObserver.CREATE*/ | FileObserver.MOVED_TO;
256
257    private static final int OBSERVER_EVENTS = REMOVE_EVENTS | ADD_EVENTS;
258    // Suffix used during package installation when copying/moving
259    // package apks to install directory.
260    private static final String INSTALL_PACKAGE_SUFFIX = "-";
261
262    static final int SCAN_MONITOR = 1<<0;
263    static final int SCAN_NO_DEX = 1<<1;
264    static final int SCAN_FORCE_DEX = 1<<2;
265    static final int SCAN_UPDATE_SIGNATURE = 1<<3;
266    static final int SCAN_NEW_INSTALL = 1<<4;
267    static final int SCAN_NO_PATHS = 1<<5;
268    static final int SCAN_UPDATE_TIME = 1<<6;
269    static final int SCAN_DEFER_DEX = 1<<7;
270    static final int SCAN_BOOTING = 1<<8;
271    static final int SCAN_TRUSTED_OVERLAY = 1<<9;
272    static final int SCAN_DELETE_DATA_ON_FAILURES = 1<<10;
273
274    static final int REMOVE_CHATTY = 1<<16;
275
276    /**
277     * Timeout (in milliseconds) after which the watchdog should declare that
278     * our handler thread is wedged.  The usual default for such things is one
279     * minute but we sometimes do very lengthy I/O operations on this thread,
280     * such as installing multi-gigabyte applications, so ours needs to be longer.
281     */
282    private static final long WATCHDOG_TIMEOUT = 1000*60*10;     // ten minutes
283
284    /**
285     * Whether verification is enabled by default.
286     */
287    private static final boolean DEFAULT_VERIFY_ENABLE = true;
288
289    /**
290     * The default maximum time to wait for the verification agent to return in
291     * milliseconds.
292     */
293    private static final long DEFAULT_VERIFICATION_TIMEOUT = 10 * 1000;
294
295    /**
296     * The default response for package verification timeout.
297     *
298     * This can be either PackageManager.VERIFICATION_ALLOW or
299     * PackageManager.VERIFICATION_REJECT.
300     */
301    private static final int DEFAULT_VERIFICATION_RESPONSE = PackageManager.VERIFICATION_ALLOW;
302
303    static final String DEFAULT_CONTAINER_PACKAGE = "com.android.defcontainer";
304
305    static final ComponentName DEFAULT_CONTAINER_COMPONENT = new ComponentName(
306            DEFAULT_CONTAINER_PACKAGE,
307            "com.android.defcontainer.DefaultContainerService");
308
309    private static final String PACKAGE_MIME_TYPE = "application/vnd.android.package-archive";
310
311    private static final String LIB_DIR_NAME = "lib";
312    private static final String LIB64_DIR_NAME = "lib64";
313
314    private static final String VENDOR_OVERLAY_DIR = "/vendor/overlay";
315
316    static final String mTempContainerPrefix = "smdl2tmp";
317
318    private static String sPreferredInstructionSet;
319
320    final ServiceThread mHandlerThread;
321
322    private static final String IDMAP_PREFIX = "/data/resource-cache/";
323    private static final String IDMAP_SUFFIX = "@idmap";
324
325    final PackageHandler mHandler;
326
327    final int mSdkVersion = Build.VERSION.SDK_INT;
328
329    final Context mContext;
330    final boolean mFactoryTest;
331    final boolean mOnlyCore;
332    final DisplayMetrics mMetrics;
333    final int mDefParseFlags;
334    final String[] mSeparateProcesses;
335
336    // This is where all application persistent data goes.
337    final File mAppDataDir;
338
339    // This is where all application persistent data goes for secondary users.
340    final File mUserAppDataDir;
341
342    /** The location for ASEC container files on internal storage. */
343    final String mAsecInternalPath;
344
345    // This is the object monitoring the framework dir.
346    final FileObserver mFrameworkInstallObserver;
347
348    // This is the object monitoring the system app dir.
349    final FileObserver mSystemInstallObserver;
350
351    // This is the object monitoring the privileged system app dir.
352    final FileObserver mPrivilegedInstallObserver;
353
354    // This is the object monitoring the vendor app dir.
355    final FileObserver mVendorInstallObserver;
356
357    // This is the object monitoring the vendor overlay package dir.
358    final FileObserver mVendorOverlayInstallObserver;
359
360    // This is the object monitoring the OEM app dir.
361    final FileObserver mOemInstallObserver;
362
363    // This is the object monitoring mAppInstallDir.
364    final FileObserver mAppInstallObserver;
365
366    // This is the object monitoring mDrmAppPrivateInstallDir.
367    final FileObserver mDrmAppInstallObserver;
368
369    // Used for privilege escalation. MUST NOT BE CALLED WITH mPackages
370    // LOCK HELD.  Can be called with mInstallLock held.
371    final Installer mInstaller;
372
373    /** Directory where installed third-party apps stored */
374    final File mAppInstallDir;
375
376    /**
377     * Directory to which applications installed internally have their
378     * 32 bit native libraries copied.
379     */
380    private File mAppLib32InstallDir;
381
382    // Directory containing the private parts (e.g. code and non-resource assets) of forward-locked
383    // apps.
384    final File mDrmAppPrivateInstallDir;
385
386    // ----------------------------------------------------------------
387
388    // Lock for state used when installing and doing other long running
389    // operations.  Methods that must be called with this lock held have
390    // the suffix "LI".
391    final Object mInstallLock = new Object();
392
393    // These are the directories in the 3rd party applications installed dir
394    // that we have currently loaded packages from.  Keys are the application's
395    // installed zip file (absolute codePath), and values are Package.
396    final HashMap<String, PackageParser.Package> mAppDirs =
397            new HashMap<String, PackageParser.Package>();
398
399    // ----------------------------------------------------------------
400
401    // Keys are String (package name), values are Package.  This also serves
402    // as the lock for the global state.  Methods that must be called with
403    // this lock held have the prefix "LP".
404    final HashMap<String, PackageParser.Package> mPackages =
405            new HashMap<String, PackageParser.Package>();
406
407    // Tracks available target package names -> overlay package paths.
408    final HashMap<String, HashMap<String, PackageParser.Package>> mOverlays =
409        new HashMap<String, HashMap<String, PackageParser.Package>>();
410
411    final Settings mSettings;
412    boolean mRestoredSettings;
413
414    // System configuration read by SystemConfig.
415    final int[] mGlobalGids;
416    final SparseArray<HashSet<String>> mSystemPermissions;
417    final HashMap<String, FeatureInfo> mAvailableFeatures;
418
419    // If mac_permissions.xml was found for seinfo labeling.
420    boolean mFoundPolicyFile;
421
422    // If a recursive restorecon of /data/data/<pkg> is needed.
423    private boolean mShouldRestoreconData = SELinuxMMAC.shouldRestorecon();
424
425    public static final class SharedLibraryEntry {
426        public final String path;
427        public final String apk;
428
429        SharedLibraryEntry(String _path, String _apk) {
430            path = _path;
431            apk = _apk;
432        }
433    }
434
435    // Currently known shared libraries.
436    final HashMap<String, SharedLibraryEntry> mSharedLibraries =
437            new HashMap<String, SharedLibraryEntry>();
438
439    // All available activities, for your resolving pleasure.
440    final ActivityIntentResolver mActivities =
441            new ActivityIntentResolver();
442
443    // All available receivers, for your resolving pleasure.
444    final ActivityIntentResolver mReceivers =
445            new ActivityIntentResolver();
446
447    // All available services, for your resolving pleasure.
448    final ServiceIntentResolver mServices = new ServiceIntentResolver();
449
450    // All available providers, for your resolving pleasure.
451    final ProviderIntentResolver mProviders = new ProviderIntentResolver();
452
453    // Mapping from provider base names (first directory in content URI codePath)
454    // to the provider information.
455    final HashMap<String, PackageParser.Provider> mProvidersByAuthority =
456            new HashMap<String, PackageParser.Provider>();
457
458    // Mapping from instrumentation class names to info about them.
459    final HashMap<ComponentName, PackageParser.Instrumentation> mInstrumentation =
460            new HashMap<ComponentName, PackageParser.Instrumentation>();
461
462    // Mapping from permission names to info about them.
463    final HashMap<String, PackageParser.PermissionGroup> mPermissionGroups =
464            new HashMap<String, PackageParser.PermissionGroup>();
465
466    // Packages whose data we have transfered into another package, thus
467    // should no longer exist.
468    final HashSet<String> mTransferedPackages = new HashSet<String>();
469
470    // Broadcast actions that are only available to the system.
471    final HashSet<String> mProtectedBroadcasts = new HashSet<String>();
472
473    /** List of packages waiting for verification. */
474    final SparseArray<PackageVerificationState> mPendingVerification
475            = new SparseArray<PackageVerificationState>();
476
477    final PackageInstallerService mInstallerService;
478
479    HashSet<PackageParser.Package> mDeferredDexOpt = null;
480
481    // Cache of users who need badging.
482    SparseBooleanArray mUserNeedsBadging = new SparseBooleanArray();
483
484    /** Token for keys in mPendingVerification. */
485    private int mPendingVerificationToken = 0;
486
487    boolean mSystemReady;
488    boolean mSafeMode;
489    boolean mHasSystemUidErrors;
490
491    ApplicationInfo mAndroidApplication;
492    final ActivityInfo mResolveActivity = new ActivityInfo();
493    final ResolveInfo mResolveInfo = new ResolveInfo();
494    ComponentName mResolveComponentName;
495    PackageParser.Package mPlatformPackage;
496    ComponentName mCustomResolverComponentName;
497
498    boolean mResolverReplaced = false;
499
500    // Set of pending broadcasts for aggregating enable/disable of components.
501    static class PendingPackageBroadcasts {
502        // for each user id, a map of <package name -> components within that package>
503        final SparseArray<HashMap<String, ArrayList<String>>> mUidMap;
504
505        public PendingPackageBroadcasts() {
506            mUidMap = new SparseArray<HashMap<String, ArrayList<String>>>(2);
507        }
508
509        public ArrayList<String> get(int userId, String packageName) {
510            HashMap<String, ArrayList<String>> packages = getOrAllocate(userId);
511            return packages.get(packageName);
512        }
513
514        public void put(int userId, String packageName, ArrayList<String> components) {
515            HashMap<String, ArrayList<String>> packages = getOrAllocate(userId);
516            packages.put(packageName, components);
517        }
518
519        public void remove(int userId, String packageName) {
520            HashMap<String, ArrayList<String>> packages = mUidMap.get(userId);
521            if (packages != null) {
522                packages.remove(packageName);
523            }
524        }
525
526        public void remove(int userId) {
527            mUidMap.remove(userId);
528        }
529
530        public int userIdCount() {
531            return mUidMap.size();
532        }
533
534        public int userIdAt(int n) {
535            return mUidMap.keyAt(n);
536        }
537
538        public HashMap<String, ArrayList<String>> packagesForUserId(int userId) {
539            return mUidMap.get(userId);
540        }
541
542        public int size() {
543            // total number of pending broadcast entries across all userIds
544            int num = 0;
545            for (int i = 0; i< mUidMap.size(); i++) {
546                num += mUidMap.valueAt(i).size();
547            }
548            return num;
549        }
550
551        public void clear() {
552            mUidMap.clear();
553        }
554
555        private HashMap<String, ArrayList<String>> getOrAllocate(int userId) {
556            HashMap<String, ArrayList<String>> map = mUidMap.get(userId);
557            if (map == null) {
558                map = new HashMap<String, ArrayList<String>>();
559                mUidMap.put(userId, map);
560            }
561            return map;
562        }
563    }
564    final PendingPackageBroadcasts mPendingBroadcasts = new PendingPackageBroadcasts();
565
566    // Service Connection to remote media container service to copy
567    // package uri's from external media onto secure containers
568    // or internal storage.
569    private IMediaContainerService mContainerService = null;
570
571    static final int SEND_PENDING_BROADCAST = 1;
572    static final int MCS_BOUND = 3;
573    static final int END_COPY = 4;
574    static final int INIT_COPY = 5;
575    static final int MCS_UNBIND = 6;
576    static final int START_CLEANING_PACKAGE = 7;
577    static final int FIND_INSTALL_LOC = 8;
578    static final int POST_INSTALL = 9;
579    static final int MCS_RECONNECT = 10;
580    static final int MCS_GIVE_UP = 11;
581    static final int UPDATED_MEDIA_STATUS = 12;
582    static final int WRITE_SETTINGS = 13;
583    static final int WRITE_PACKAGE_RESTRICTIONS = 14;
584    static final int PACKAGE_VERIFIED = 15;
585    static final int CHECK_PENDING_VERIFICATION = 16;
586
587    static final int WRITE_SETTINGS_DELAY = 10*1000;  // 10 seconds
588
589    // Delay time in millisecs
590    static final int BROADCAST_DELAY = 10 * 1000;
591
592    static UserManagerService sUserManager;
593
594    // Stores a list of users whose package restrictions file needs to be updated
595    private HashSet<Integer> mDirtyUsers = new HashSet<Integer>();
596
597    final private DefaultContainerConnection mDefContainerConn =
598            new DefaultContainerConnection();
599    class DefaultContainerConnection implements ServiceConnection {
600        public void onServiceConnected(ComponentName name, IBinder service) {
601            if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceConnected");
602            IMediaContainerService imcs =
603                IMediaContainerService.Stub.asInterface(service);
604            mHandler.sendMessage(mHandler.obtainMessage(MCS_BOUND, imcs));
605        }
606
607        public void onServiceDisconnected(ComponentName name) {
608            if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceDisconnected");
609        }
610    };
611
612    // Recordkeeping of restore-after-install operations that are currently in flight
613    // between the Package Manager and the Backup Manager
614    class PostInstallData {
615        public InstallArgs args;
616        public PackageInstalledInfo res;
617
618        PostInstallData(InstallArgs _a, PackageInstalledInfo _r) {
619            args = _a;
620            res = _r;
621        }
622    };
623    final SparseArray<PostInstallData> mRunningInstalls = new SparseArray<PostInstallData>();
624    int mNextInstallToken = 1;  // nonzero; will be wrapped back to 1 when ++ overflows
625
626    private final String mRequiredVerifierPackage;
627
628    private final PackageUsage mPackageUsage = new PackageUsage();
629
630    private class PackageUsage {
631        private static final int WRITE_INTERVAL
632            = (DEBUG_DEXOPT) ? 0 : 30*60*1000; // 30m in ms
633
634        private final Object mFileLock = new Object();
635        private final AtomicLong mLastWritten = new AtomicLong(0);
636        private final AtomicBoolean mBackgroundWriteRunning = new AtomicBoolean(false);
637
638        private boolean mIsHistoricalPackageUsageAvailable = true;
639
640        boolean isHistoricalPackageUsageAvailable() {
641            return mIsHistoricalPackageUsageAvailable;
642        }
643
644        void write(boolean force) {
645            if (force) {
646                writeInternal();
647                return;
648            }
649            if (SystemClock.elapsedRealtime() - mLastWritten.get() < WRITE_INTERVAL
650                && !DEBUG_DEXOPT) {
651                return;
652            }
653            if (mBackgroundWriteRunning.compareAndSet(false, true)) {
654                new Thread("PackageUsage_DiskWriter") {
655                    @Override
656                    public void run() {
657                        try {
658                            writeInternal();
659                        } finally {
660                            mBackgroundWriteRunning.set(false);
661                        }
662                    }
663                }.start();
664            }
665        }
666
667        private void writeInternal() {
668            synchronized (mPackages) {
669                synchronized (mFileLock) {
670                    AtomicFile file = getFile();
671                    FileOutputStream f = null;
672                    try {
673                        f = file.startWrite();
674                        BufferedOutputStream out = new BufferedOutputStream(f);
675                        FileUtils.setPermissions(file.getBaseFile().getPath(), 0660, SYSTEM_UID, PACKAGE_INFO_GID);
676                        StringBuilder sb = new StringBuilder();
677                        for (PackageParser.Package pkg : mPackages.values()) {
678                            if (pkg.mLastPackageUsageTimeInMills == 0) {
679                                continue;
680                            }
681                            sb.setLength(0);
682                            sb.append(pkg.packageName);
683                            sb.append(' ');
684                            sb.append((long)pkg.mLastPackageUsageTimeInMills);
685                            sb.append('\n');
686                            out.write(sb.toString().getBytes(StandardCharsets.US_ASCII));
687                        }
688                        out.flush();
689                        file.finishWrite(f);
690                    } catch (IOException e) {
691                        if (f != null) {
692                            file.failWrite(f);
693                        }
694                        Log.e(TAG, "Failed to write package usage times", e);
695                    }
696                }
697            }
698            mLastWritten.set(SystemClock.elapsedRealtime());
699        }
700
701        void readLP() {
702            synchronized (mFileLock) {
703                AtomicFile file = getFile();
704                BufferedInputStream in = null;
705                try {
706                    in = new BufferedInputStream(file.openRead());
707                    StringBuffer sb = new StringBuffer();
708                    while (true) {
709                        String packageName = readToken(in, sb, ' ');
710                        if (packageName == null) {
711                            break;
712                        }
713                        String timeInMillisString = readToken(in, sb, '\n');
714                        if (timeInMillisString == null) {
715                            throw new IOException("Failed to find last usage time for package "
716                                                  + packageName);
717                        }
718                        PackageParser.Package pkg = mPackages.get(packageName);
719                        if (pkg == null) {
720                            continue;
721                        }
722                        long timeInMillis;
723                        try {
724                            timeInMillis = Long.parseLong(timeInMillisString.toString());
725                        } catch (NumberFormatException e) {
726                            throw new IOException("Failed to parse " + timeInMillisString
727                                                  + " as a long.", e);
728                        }
729                        pkg.mLastPackageUsageTimeInMills = timeInMillis;
730                    }
731                } catch (FileNotFoundException expected) {
732                    mIsHistoricalPackageUsageAvailable = false;
733                } catch (IOException e) {
734                    Log.w(TAG, "Failed to read package usage times", e);
735                } finally {
736                    IoUtils.closeQuietly(in);
737                }
738            }
739            mLastWritten.set(SystemClock.elapsedRealtime());
740        }
741
742        private String readToken(InputStream in, StringBuffer sb, char endOfToken)
743                throws IOException {
744            sb.setLength(0);
745            while (true) {
746                int ch = in.read();
747                if (ch == -1) {
748                    if (sb.length() == 0) {
749                        return null;
750                    }
751                    throw new IOException("Unexpected EOF");
752                }
753                if (ch == endOfToken) {
754                    return sb.toString();
755                }
756                sb.append((char)ch);
757            }
758        }
759
760        private AtomicFile getFile() {
761            File dataDir = Environment.getDataDirectory();
762            File systemDir = new File(dataDir, "system");
763            File fname = new File(systemDir, "package-usage.list");
764            return new AtomicFile(fname);
765        }
766    }
767
768    class PackageHandler extends Handler {
769        private boolean mBound = false;
770        final ArrayList<HandlerParams> mPendingInstalls =
771            new ArrayList<HandlerParams>();
772
773        private boolean connectToService() {
774            if (DEBUG_SD_INSTALL) Log.i(TAG, "Trying to bind to" +
775                    " DefaultContainerService");
776            Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
777            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
778            if (mContext.bindServiceAsUser(service, mDefContainerConn,
779                    Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
780                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
781                mBound = true;
782                return true;
783            }
784            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
785            return false;
786        }
787
788        private void disconnectService() {
789            mContainerService = null;
790            mBound = false;
791            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
792            mContext.unbindService(mDefContainerConn);
793            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
794        }
795
796        PackageHandler(Looper looper) {
797            super(looper);
798        }
799
800        public void handleMessage(Message msg) {
801            try {
802                doHandleMessage(msg);
803            } finally {
804                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
805            }
806        }
807
808        void doHandleMessage(Message msg) {
809            switch (msg.what) {
810                case INIT_COPY: {
811                    HandlerParams params = (HandlerParams) msg.obj;
812                    int idx = mPendingInstalls.size();
813                    if (DEBUG_INSTALL) Slog.i(TAG, "init_copy idx=" + idx + ": " + params);
814                    // If a bind was already initiated we dont really
815                    // need to do anything. The pending install
816                    // will be processed later on.
817                    if (!mBound) {
818                        // If this is the only one pending we might
819                        // have to bind to the service again.
820                        if (!connectToService()) {
821                            Slog.e(TAG, "Failed to bind to media container service");
822                            params.serviceError();
823                            return;
824                        } else {
825                            // Once we bind to the service, the first
826                            // pending request will be processed.
827                            mPendingInstalls.add(idx, params);
828                        }
829                    } else {
830                        mPendingInstalls.add(idx, params);
831                        // Already bound to the service. Just make
832                        // sure we trigger off processing the first request.
833                        if (idx == 0) {
834                            mHandler.sendEmptyMessage(MCS_BOUND);
835                        }
836                    }
837                    break;
838                }
839                case MCS_BOUND: {
840                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_bound");
841                    if (msg.obj != null) {
842                        mContainerService = (IMediaContainerService) msg.obj;
843                    }
844                    if (mContainerService == null) {
845                        // Something seriously wrong. Bail out
846                        Slog.e(TAG, "Cannot bind to media container service");
847                        for (HandlerParams params : mPendingInstalls) {
848                            // Indicate service bind error
849                            params.serviceError();
850                        }
851                        mPendingInstalls.clear();
852                    } else if (mPendingInstalls.size() > 0) {
853                        HandlerParams params = mPendingInstalls.get(0);
854                        if (params != null) {
855                            if (params.startCopy()) {
856                                // We are done...  look for more work or to
857                                // go idle.
858                                if (DEBUG_SD_INSTALL) Log.i(TAG,
859                                        "Checking for more work or unbind...");
860                                // Delete pending install
861                                if (mPendingInstalls.size() > 0) {
862                                    mPendingInstalls.remove(0);
863                                }
864                                if (mPendingInstalls.size() == 0) {
865                                    if (mBound) {
866                                        if (DEBUG_SD_INSTALL) Log.i(TAG,
867                                                "Posting delayed MCS_UNBIND");
868                                        removeMessages(MCS_UNBIND);
869                                        Message ubmsg = obtainMessage(MCS_UNBIND);
870                                        // Unbind after a little delay, to avoid
871                                        // continual thrashing.
872                                        sendMessageDelayed(ubmsg, 10000);
873                                    }
874                                } else {
875                                    // There are more pending requests in queue.
876                                    // Just post MCS_BOUND message to trigger processing
877                                    // of next pending install.
878                                    if (DEBUG_SD_INSTALL) Log.i(TAG,
879                                            "Posting MCS_BOUND for next work");
880                                    mHandler.sendEmptyMessage(MCS_BOUND);
881                                }
882                            }
883                        }
884                    } else {
885                        // Should never happen ideally.
886                        Slog.w(TAG, "Empty queue");
887                    }
888                    break;
889                }
890                case MCS_RECONNECT: {
891                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_reconnect");
892                    if (mPendingInstalls.size() > 0) {
893                        if (mBound) {
894                            disconnectService();
895                        }
896                        if (!connectToService()) {
897                            Slog.e(TAG, "Failed to bind to media container service");
898                            for (HandlerParams params : mPendingInstalls) {
899                                // Indicate service bind error
900                                params.serviceError();
901                            }
902                            mPendingInstalls.clear();
903                        }
904                    }
905                    break;
906                }
907                case MCS_UNBIND: {
908                    // If there is no actual work left, then time to unbind.
909                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_unbind");
910
911                    if (mPendingInstalls.size() == 0 && mPendingVerification.size() == 0) {
912                        if (mBound) {
913                            if (DEBUG_INSTALL) Slog.i(TAG, "calling disconnectService()");
914
915                            disconnectService();
916                        }
917                    } else if (mPendingInstalls.size() > 0) {
918                        // There are more pending requests in queue.
919                        // Just post MCS_BOUND message to trigger processing
920                        // of next pending install.
921                        mHandler.sendEmptyMessage(MCS_BOUND);
922                    }
923
924                    break;
925                }
926                case MCS_GIVE_UP: {
927                    if (DEBUG_INSTALL) Slog.i(TAG, "mcs_giveup too many retries");
928                    mPendingInstalls.remove(0);
929                    break;
930                }
931                case SEND_PENDING_BROADCAST: {
932                    String packages[];
933                    ArrayList<String> components[];
934                    int size = 0;
935                    int uids[];
936                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
937                    synchronized (mPackages) {
938                        if (mPendingBroadcasts == null) {
939                            return;
940                        }
941                        size = mPendingBroadcasts.size();
942                        if (size <= 0) {
943                            // Nothing to be done. Just return
944                            return;
945                        }
946                        packages = new String[size];
947                        components = new ArrayList[size];
948                        uids = new int[size];
949                        int i = 0;  // filling out the above arrays
950
951                        for (int n = 0; n < mPendingBroadcasts.userIdCount(); n++) {
952                            int packageUserId = mPendingBroadcasts.userIdAt(n);
953                            Iterator<Map.Entry<String, ArrayList<String>>> it
954                                    = mPendingBroadcasts.packagesForUserId(packageUserId)
955                                            .entrySet().iterator();
956                            while (it.hasNext() && i < size) {
957                                Map.Entry<String, ArrayList<String>> ent = it.next();
958                                packages[i] = ent.getKey();
959                                components[i] = ent.getValue();
960                                PackageSetting ps = mSettings.mPackages.get(ent.getKey());
961                                uids[i] = (ps != null)
962                                        ? UserHandle.getUid(packageUserId, ps.appId)
963                                        : -1;
964                                i++;
965                            }
966                        }
967                        size = i;
968                        mPendingBroadcasts.clear();
969                    }
970                    // Send broadcasts
971                    for (int i = 0; i < size; i++) {
972                        sendPackageChangedBroadcast(packages[i], true, components[i], uids[i]);
973                    }
974                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
975                    break;
976                }
977                case START_CLEANING_PACKAGE: {
978                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
979                    final String packageName = (String)msg.obj;
980                    final int userId = msg.arg1;
981                    final boolean andCode = msg.arg2 != 0;
982                    synchronized (mPackages) {
983                        if (userId == UserHandle.USER_ALL) {
984                            int[] users = sUserManager.getUserIds();
985                            for (int user : users) {
986                                mSettings.addPackageToCleanLPw(
987                                        new PackageCleanItem(user, packageName, andCode));
988                            }
989                        } else {
990                            mSettings.addPackageToCleanLPw(
991                                    new PackageCleanItem(userId, packageName, andCode));
992                        }
993                    }
994                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
995                    startCleaningPackages();
996                } break;
997                case POST_INSTALL: {
998                    if (DEBUG_INSTALL) Log.v(TAG, "Handling post-install for " + msg.arg1);
999                    PostInstallData data = mRunningInstalls.get(msg.arg1);
1000                    mRunningInstalls.delete(msg.arg1);
1001                    boolean deleteOld = false;
1002
1003                    if (data != null) {
1004                        InstallArgs args = data.args;
1005                        PackageInstalledInfo res = data.res;
1006
1007                        if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
1008                            res.removedInfo.sendBroadcast(false, true, false);
1009                            Bundle extras = new Bundle(1);
1010                            extras.putInt(Intent.EXTRA_UID, res.uid);
1011                            // Determine the set of users who are adding this
1012                            // package for the first time vs. those who are seeing
1013                            // an update.
1014                            int[] firstUsers;
1015                            int[] updateUsers = new int[0];
1016                            if (res.origUsers == null || res.origUsers.length == 0) {
1017                                firstUsers = res.newUsers;
1018                            } else {
1019                                firstUsers = new int[0];
1020                                for (int i=0; i<res.newUsers.length; i++) {
1021                                    int user = res.newUsers[i];
1022                                    boolean isNew = true;
1023                                    for (int j=0; j<res.origUsers.length; j++) {
1024                                        if (res.origUsers[j] == user) {
1025                                            isNew = false;
1026                                            break;
1027                                        }
1028                                    }
1029                                    if (isNew) {
1030                                        int[] newFirst = new int[firstUsers.length+1];
1031                                        System.arraycopy(firstUsers, 0, newFirst, 0,
1032                                                firstUsers.length);
1033                                        newFirst[firstUsers.length] = user;
1034                                        firstUsers = newFirst;
1035                                    } else {
1036                                        int[] newUpdate = new int[updateUsers.length+1];
1037                                        System.arraycopy(updateUsers, 0, newUpdate, 0,
1038                                                updateUsers.length);
1039                                        newUpdate[updateUsers.length] = user;
1040                                        updateUsers = newUpdate;
1041                                    }
1042                                }
1043                            }
1044                            sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
1045                                    res.pkg.applicationInfo.packageName,
1046                                    extras, null, null, firstUsers);
1047                            final boolean update = res.removedInfo.removedPackage != null;
1048                            if (update) {
1049                                extras.putBoolean(Intent.EXTRA_REPLACING, true);
1050                            }
1051                            sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
1052                                    res.pkg.applicationInfo.packageName,
1053                                    extras, null, null, updateUsers);
1054                            if (update) {
1055                                sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED,
1056                                        res.pkg.applicationInfo.packageName,
1057                                        extras, null, null, updateUsers);
1058                                sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED,
1059                                        null, null,
1060                                        res.pkg.applicationInfo.packageName, null, updateUsers);
1061
1062                                // treat asec-hosted packages like removable media on upgrade
1063                                if (isForwardLocked(res.pkg) || isExternal(res.pkg)) {
1064                                    if (DEBUG_INSTALL) {
1065                                        Slog.i(TAG, "upgrading pkg " + res.pkg
1066                                                + " is ASEC-hosted -> AVAILABLE");
1067                                    }
1068                                    int[] uidArray = new int[] { res.pkg.applicationInfo.uid };
1069                                    ArrayList<String> pkgList = new ArrayList<String>(1);
1070                                    pkgList.add(res.pkg.applicationInfo.packageName);
1071                                    sendResourcesChangedBroadcast(true, true,
1072                                            pkgList,uidArray, null);
1073                                }
1074                            }
1075                            if (res.removedInfo.args != null) {
1076                                // Remove the replaced package's older resources safely now
1077                                deleteOld = true;
1078                            }
1079
1080                            // Log current value of "unknown sources" setting
1081                            EventLog.writeEvent(EventLogTags.UNKNOWN_SOURCES_ENABLED,
1082                                getUnknownSourcesSettings());
1083                        }
1084                        // Force a gc to clear up things
1085                        Runtime.getRuntime().gc();
1086                        // We delete after a gc for applications  on sdcard.
1087                        if (deleteOld) {
1088                            synchronized (mInstallLock) {
1089                                res.removedInfo.args.doPostDeleteLI(true);
1090                            }
1091                        }
1092                        if (args.observer != null) {
1093                            try {
1094                                Bundle extras = extrasForInstallResult(res);
1095                                args.observer.packageInstalled(res.name, extras, res.returnCode,
1096                                        res.returnMsg);
1097                            } catch (RemoteException e) {
1098                                Slog.i(TAG, "Observer no longer exists.");
1099                            }
1100                        }
1101                    } else {
1102                        Slog.e(TAG, "Bogus post-install token " + msg.arg1);
1103                    }
1104                } break;
1105                case UPDATED_MEDIA_STATUS: {
1106                    if (DEBUG_SD_INSTALL) Log.i(TAG, "Got message UPDATED_MEDIA_STATUS");
1107                    boolean reportStatus = msg.arg1 == 1;
1108                    boolean doGc = msg.arg2 == 1;
1109                    if (DEBUG_SD_INSTALL) Log.i(TAG, "reportStatus=" + reportStatus + ", doGc = " + doGc);
1110                    if (doGc) {
1111                        // Force a gc to clear up stale containers.
1112                        Runtime.getRuntime().gc();
1113                    }
1114                    if (msg.obj != null) {
1115                        @SuppressWarnings("unchecked")
1116                        Set<AsecInstallArgs> args = (Set<AsecInstallArgs>) msg.obj;
1117                        if (DEBUG_SD_INSTALL) Log.i(TAG, "Unloading all containers");
1118                        // Unload containers
1119                        unloadAllContainers(args);
1120                    }
1121                    if (reportStatus) {
1122                        try {
1123                            if (DEBUG_SD_INSTALL) Log.i(TAG, "Invoking MountService call back");
1124                            PackageHelper.getMountService().finishMediaUpdate();
1125                        } catch (RemoteException e) {
1126                            Log.e(TAG, "MountService not running?");
1127                        }
1128                    }
1129                } break;
1130                case WRITE_SETTINGS: {
1131                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1132                    synchronized (mPackages) {
1133                        removeMessages(WRITE_SETTINGS);
1134                        removeMessages(WRITE_PACKAGE_RESTRICTIONS);
1135                        mSettings.writeLPr();
1136                        mDirtyUsers.clear();
1137                    }
1138                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1139                } break;
1140                case WRITE_PACKAGE_RESTRICTIONS: {
1141                    Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1142                    synchronized (mPackages) {
1143                        removeMessages(WRITE_PACKAGE_RESTRICTIONS);
1144                        for (int userId : mDirtyUsers) {
1145                            mSettings.writePackageRestrictionsLPr(userId);
1146                        }
1147                        mDirtyUsers.clear();
1148                    }
1149                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1150                } break;
1151                case CHECK_PENDING_VERIFICATION: {
1152                    final int verificationId = msg.arg1;
1153                    final PackageVerificationState state = mPendingVerification.get(verificationId);
1154
1155                    if ((state != null) && !state.timeoutExtended()) {
1156                        final InstallArgs args = state.getInstallArgs();
1157                        final Uri originUri = Uri.fromFile(args.originFile);
1158
1159                        Slog.i(TAG, "Verification timed out for " + originUri);
1160                        mPendingVerification.remove(verificationId);
1161
1162                        int ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
1163
1164                        if (getDefaultVerificationResponse() == PackageManager.VERIFICATION_ALLOW) {
1165                            Slog.i(TAG, "Continuing with installation of " + originUri);
1166                            state.setVerifierResponse(Binder.getCallingUid(),
1167                                    PackageManager.VERIFICATION_ALLOW_WITHOUT_SUFFICIENT);
1168                            broadcastPackageVerified(verificationId, originUri,
1169                                    PackageManager.VERIFICATION_ALLOW,
1170                                    state.getInstallArgs().getUser());
1171                            try {
1172                                ret = args.copyApk(mContainerService, true);
1173                            } catch (RemoteException e) {
1174                                Slog.e(TAG, "Could not contact the ContainerService");
1175                            }
1176                        } else {
1177                            broadcastPackageVerified(verificationId, originUri,
1178                                    PackageManager.VERIFICATION_REJECT,
1179                                    state.getInstallArgs().getUser());
1180                        }
1181
1182                        processPendingInstall(args, ret);
1183                        mHandler.sendEmptyMessage(MCS_UNBIND);
1184                    }
1185                    break;
1186                }
1187                case PACKAGE_VERIFIED: {
1188                    final int verificationId = msg.arg1;
1189
1190                    final PackageVerificationState state = mPendingVerification.get(verificationId);
1191                    if (state == null) {
1192                        Slog.w(TAG, "Invalid verification token " + verificationId + " received");
1193                        break;
1194                    }
1195
1196                    final PackageVerificationResponse response = (PackageVerificationResponse) msg.obj;
1197
1198                    state.setVerifierResponse(response.callerUid, response.code);
1199
1200                    if (state.isVerificationComplete()) {
1201                        mPendingVerification.remove(verificationId);
1202
1203                        final InstallArgs args = state.getInstallArgs();
1204                        final Uri originUri = Uri.fromFile(args.originFile);
1205
1206                        int ret;
1207                        if (state.isInstallAllowed()) {
1208                            ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
1209                            broadcastPackageVerified(verificationId, originUri,
1210                                    response.code, state.getInstallArgs().getUser());
1211                            try {
1212                                ret = args.copyApk(mContainerService, true);
1213                            } catch (RemoteException e) {
1214                                Slog.e(TAG, "Could not contact the ContainerService");
1215                            }
1216                        } else {
1217                            ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
1218                        }
1219
1220                        processPendingInstall(args, ret);
1221
1222                        mHandler.sendEmptyMessage(MCS_UNBIND);
1223                    }
1224
1225                    break;
1226                }
1227            }
1228        }
1229    }
1230
1231    Bundle extrasForInstallResult(PackageInstalledInfo res) {
1232        Bundle extras = null;
1233        switch (res.returnCode) {
1234            case PackageManager.INSTALL_FAILED_DUPLICATE_PERMISSION: {
1235                extras = new Bundle();
1236                extras.putString(PackageManager.EXTRA_FAILURE_EXISTING_PERMISSION,
1237                        res.origPermission);
1238                extras.putString(PackageManager.EXTRA_FAILURE_EXISTING_PACKAGE,
1239                        res.origPackage);
1240                break;
1241            }
1242        }
1243        return extras;
1244    }
1245
1246    void scheduleWriteSettingsLocked() {
1247        if (!mHandler.hasMessages(WRITE_SETTINGS)) {
1248            mHandler.sendEmptyMessageDelayed(WRITE_SETTINGS, WRITE_SETTINGS_DELAY);
1249        }
1250    }
1251
1252    void scheduleWritePackageRestrictionsLocked(int userId) {
1253        if (!sUserManager.exists(userId)) return;
1254        mDirtyUsers.add(userId);
1255        if (!mHandler.hasMessages(WRITE_PACKAGE_RESTRICTIONS)) {
1256            mHandler.sendEmptyMessageDelayed(WRITE_PACKAGE_RESTRICTIONS, WRITE_SETTINGS_DELAY);
1257        }
1258    }
1259
1260    public static final PackageManagerService main(Context context, Installer installer,
1261            boolean factoryTest, boolean onlyCore) {
1262        PackageManagerService m = new PackageManagerService(context, installer,
1263                factoryTest, onlyCore);
1264        ServiceManager.addService("package", m);
1265        return m;
1266    }
1267
1268    static String[] splitString(String str, char sep) {
1269        int count = 1;
1270        int i = 0;
1271        while ((i=str.indexOf(sep, i)) >= 0) {
1272            count++;
1273            i++;
1274        }
1275
1276        String[] res = new String[count];
1277        i=0;
1278        count = 0;
1279        int lastI=0;
1280        while ((i=str.indexOf(sep, i)) >= 0) {
1281            res[count] = str.substring(lastI, i);
1282            count++;
1283            i++;
1284            lastI = i;
1285        }
1286        res[count] = str.substring(lastI, str.length());
1287        return res;
1288    }
1289
1290    private static void getDefaultDisplayMetrics(Context context, DisplayMetrics metrics) {
1291        DisplayManager displayManager = (DisplayManager) context.getSystemService(
1292                Context.DISPLAY_SERVICE);
1293        displayManager.getDisplay(Display.DEFAULT_DISPLAY).getMetrics(metrics);
1294    }
1295
1296    public PackageManagerService(Context context, Installer installer,
1297            boolean factoryTest, boolean onlyCore) {
1298        EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START,
1299                SystemClock.uptimeMillis());
1300
1301        if (mSdkVersion <= 0) {
1302            Slog.w(TAG, "**** ro.build.version.sdk not set!");
1303        }
1304
1305        mContext = context;
1306        mFactoryTest = factoryTest;
1307        mOnlyCore = onlyCore;
1308        mMetrics = new DisplayMetrics();
1309        mSettings = new Settings(context);
1310        mSettings.addSharedUserLPw("android.uid.system", Process.SYSTEM_UID,
1311                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1312        mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID,
1313                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1314        mSettings.addSharedUserLPw("android.uid.log", LOG_UID,
1315                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1316        mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID,
1317                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1318        mSettings.addSharedUserLPw("android.uid.bluetooth", BLUETOOTH_UID,
1319                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1320        mSettings.addSharedUserLPw("android.uid.shell", SHELL_UID,
1321                ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PRIVILEGED);
1322
1323        String separateProcesses = SystemProperties.get("debug.separate_processes");
1324        if (separateProcesses != null && separateProcesses.length() > 0) {
1325            if ("*".equals(separateProcesses)) {
1326                mDefParseFlags = PackageParser.PARSE_IGNORE_PROCESSES;
1327                mSeparateProcesses = null;
1328                Slog.w(TAG, "Running with debug.separate_processes: * (ALL)");
1329            } else {
1330                mDefParseFlags = 0;
1331                mSeparateProcesses = separateProcesses.split(",");
1332                Slog.w(TAG, "Running with debug.separate_processes: "
1333                        + separateProcesses);
1334            }
1335        } else {
1336            mDefParseFlags = 0;
1337            mSeparateProcesses = null;
1338        }
1339
1340        mInstaller = installer;
1341
1342        getDefaultDisplayMetrics(context, mMetrics);
1343
1344        SystemConfig systemConfig = SystemConfig.getInstance();
1345        mGlobalGids = systemConfig.getGlobalGids();
1346        mSystemPermissions = systemConfig.getSystemPermissions();
1347        mAvailableFeatures = systemConfig.getAvailableFeatures();
1348
1349        synchronized (mInstallLock) {
1350        // writer
1351        synchronized (mPackages) {
1352            mHandlerThread = new ServiceThread(TAG,
1353                    Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
1354            mHandlerThread.start();
1355            mHandler = new PackageHandler(mHandlerThread.getLooper());
1356            Watchdog.getInstance().addThread(mHandler, WATCHDOG_TIMEOUT);
1357
1358            File dataDir = Environment.getDataDirectory();
1359            mAppDataDir = new File(dataDir, "data");
1360            mAppInstallDir = new File(dataDir, "app");
1361            mAppLib32InstallDir = new File(dataDir, "app-lib");
1362            mAsecInternalPath = new File(dataDir, "app-asec").getPath();
1363            mUserAppDataDir = new File(dataDir, "user");
1364            mDrmAppPrivateInstallDir = new File(dataDir, "app-private");
1365
1366            sUserManager = new UserManagerService(context, this,
1367                    mInstallLock, mPackages);
1368
1369            // Propagate permission configuration in to package manager.
1370            ArrayMap<String, SystemConfig.PermissionEntry> permConfig
1371                    = systemConfig.getPermissions();
1372            for (int i=0; i<permConfig.size(); i++) {
1373                SystemConfig.PermissionEntry perm = permConfig.valueAt(i);
1374                BasePermission bp = mSettings.mPermissions.get(perm.name);
1375                if (bp == null) {
1376                    bp = new BasePermission(perm.name, null, BasePermission.TYPE_BUILTIN);
1377                    mSettings.mPermissions.put(perm.name, bp);
1378                }
1379                if (perm.gids != null) {
1380                    bp.gids = appendInts(bp.gids, perm.gids);
1381                }
1382            }
1383
1384            ArrayMap<String, String> libConfig = systemConfig.getSharedLibraries();
1385            for (int i=0; i<libConfig.size(); i++) {
1386                mSharedLibraries.put(libConfig.keyAt(i),
1387                        new SharedLibraryEntry(libConfig.valueAt(i), null));
1388            }
1389
1390            mFoundPolicyFile = SELinuxMMAC.readInstallPolicy();
1391
1392            mRestoredSettings = mSettings.readLPw(this, sUserManager.getUsers(false),
1393                    mSdkVersion, mOnlyCore);
1394
1395            String customResolverActivity = Resources.getSystem().getString(
1396                    R.string.config_customResolverActivity);
1397            if (TextUtils.isEmpty(customResolverActivity)) {
1398                customResolverActivity = null;
1399            } else {
1400                mCustomResolverComponentName = ComponentName.unflattenFromString(
1401                        customResolverActivity);
1402            }
1403
1404            long startTime = SystemClock.uptimeMillis();
1405
1406            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SYSTEM_SCAN_START,
1407                    startTime);
1408
1409            // Set flag to monitor and not change apk file paths when
1410            // scanning install directories.
1411            int scanMode = SCAN_MONITOR | SCAN_NO_PATHS | SCAN_DEFER_DEX | SCAN_BOOTING;
1412
1413            final HashSet<String> alreadyDexOpted = new HashSet<String>();
1414
1415            /**
1416             * Add everything in the in the boot class path to the
1417             * list of process files because dexopt will have been run
1418             * if necessary during zygote startup.
1419             */
1420            String bootClassPath = System.getProperty("java.boot.class.path");
1421            if (bootClassPath != null) {
1422                String[] paths = splitString(bootClassPath, ':');
1423                for (int i=0; i<paths.length; i++) {
1424                    alreadyDexOpted.add(paths[i]);
1425                }
1426            } else {
1427                Slog.w(TAG, "No BOOTCLASSPATH found!");
1428            }
1429
1430            boolean didDexOptLibraryOrTool = false;
1431
1432            final List<String> instructionSets = getAllInstructionSets();
1433
1434            /**
1435             * Ensure all external libraries have had dexopt run on them.
1436             */
1437            if (mSharedLibraries.size() > 0) {
1438                // NOTE: For now, we're compiling these system "shared libraries"
1439                // (and framework jars) into all available architectures. It's possible
1440                // to compile them only when we come across an app that uses them (there's
1441                // already logic for that in scanPackageLI) but that adds some complexity.
1442                for (String instructionSet : instructionSets) {
1443                    for (SharedLibraryEntry libEntry : mSharedLibraries.values()) {
1444                        final String lib = libEntry.path;
1445                        if (lib == null) {
1446                            continue;
1447                        }
1448
1449                        try {
1450                            if (DexFile.isDexOptNeededInternal(lib, null, instructionSet, false)) {
1451                                alreadyDexOpted.add(lib);
1452
1453                                // The list of "shared libraries" we have at this point is
1454                                mInstaller.dexopt(lib, Process.SYSTEM_UID, true, instructionSet);
1455                                didDexOptLibraryOrTool = true;
1456                            }
1457                        } catch (FileNotFoundException e) {
1458                            Slog.w(TAG, "Library not found: " + lib);
1459                        } catch (IOException e) {
1460                            Slog.w(TAG, "Cannot dexopt " + lib + "; is it an APK or JAR? "
1461                                    + e.getMessage());
1462                        }
1463                    }
1464                }
1465            }
1466
1467            File frameworkDir = new File(Environment.getRootDirectory(), "framework");
1468
1469            // Gross hack for now: we know this file doesn't contain any
1470            // code, so don't dexopt it to avoid the resulting log spew.
1471            alreadyDexOpted.add(frameworkDir.getPath() + "/framework-res.apk");
1472
1473            // Gross hack for now: we know this file is only part of
1474            // the boot class path for art, so don't dexopt it to
1475            // avoid the resulting log spew.
1476            alreadyDexOpted.add(frameworkDir.getPath() + "/core-libart.jar");
1477
1478            /**
1479             * And there are a number of commands implemented in Java, which
1480             * we currently need to do the dexopt on so that they can be
1481             * run from a non-root shell.
1482             */
1483            String[] frameworkFiles = frameworkDir.list();
1484            if (frameworkFiles != null) {
1485                // TODO: We could compile these only for the most preferred ABI. We should
1486                // first double check that the dex files for these commands are not referenced
1487                // by other system apps.
1488                for (String instructionSet : instructionSets) {
1489                    for (int i=0; i<frameworkFiles.length; i++) {
1490                        File libPath = new File(frameworkDir, frameworkFiles[i]);
1491                        String path = libPath.getPath();
1492                        // Skip the file if we already did it.
1493                        if (alreadyDexOpted.contains(path)) {
1494                            continue;
1495                        }
1496                        // Skip the file if it is not a type we want to dexopt.
1497                        if (!path.endsWith(".apk") && !path.endsWith(".jar")) {
1498                            continue;
1499                        }
1500                        try {
1501                            if (DexFile.isDexOptNeededInternal(path, null, instructionSet, false)) {
1502                                mInstaller.dexopt(path, Process.SYSTEM_UID, true, instructionSet);
1503                                didDexOptLibraryOrTool = true;
1504                            }
1505                        } catch (FileNotFoundException e) {
1506                            Slog.w(TAG, "Jar not found: " + path);
1507                        } catch (IOException e) {
1508                            Slog.w(TAG, "Exception reading jar: " + path, e);
1509                        }
1510                    }
1511                }
1512            }
1513
1514            if (didDexOptLibraryOrTool) {
1515                // If we dexopted a library or tool, then something on the system has
1516                // changed. Consider this significant, and wipe away all other
1517                // existing dexopt files to ensure we don't leave any dangling around.
1518                //
1519                // TODO: This should be revisited because it isn't as good an indicator
1520                // as it used to be. It used to include the boot classpath but at some point
1521                // DexFile.isDexOptNeeded started returning false for the boot
1522                // class path files in all cases. It is very possible in a
1523                // small maintenance release update that the library and tool
1524                // jars may be unchanged but APK could be removed resulting in
1525                // unused dalvik-cache files.
1526                for (String instructionSet : instructionSets) {
1527                    mInstaller.pruneDexCache(instructionSet);
1528                }
1529
1530                // Additionally, delete all dex files from the root directory
1531                // since there shouldn't be any there anyway, unless we're upgrading
1532                // from an older OS version or a build that contained the "old" style
1533                // flat scheme.
1534                mInstaller.pruneDexCache(".");
1535            }
1536
1537            // Collect vendor overlay packages.
1538            // (Do this before scanning any apps.)
1539            // For security and version matching reason, only consider
1540            // overlay packages if they reside in VENDOR_OVERLAY_DIR.
1541            File vendorOverlayDir = new File(VENDOR_OVERLAY_DIR);
1542            mVendorOverlayInstallObserver = new AppDirObserver(
1543                    vendorOverlayDir.getPath(), OBSERVER_EVENTS, true, false);
1544            mVendorOverlayInstallObserver.startWatching();
1545            scanDirLI(vendorOverlayDir, PackageParser.PARSE_IS_SYSTEM
1546                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode | SCAN_TRUSTED_OVERLAY, 0);
1547
1548            // Find base frameworks (resource packages without code).
1549            mFrameworkInstallObserver = new AppDirObserver(
1550                    frameworkDir.getPath(), OBSERVER_EVENTS, true, false);
1551            mFrameworkInstallObserver.startWatching();
1552            scanDirLI(frameworkDir, PackageParser.PARSE_IS_SYSTEM
1553                    | PackageParser.PARSE_IS_SYSTEM_DIR
1554                    | PackageParser.PARSE_IS_PRIVILEGED,
1555                    scanMode | SCAN_NO_DEX, 0);
1556
1557            // Collected privileged system packages.
1558            File privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app");
1559            mPrivilegedInstallObserver = new AppDirObserver(
1560                    privilegedAppDir.getPath(), OBSERVER_EVENTS, true, true);
1561            mPrivilegedInstallObserver.startWatching();
1562            scanDirLI(privilegedAppDir, PackageParser.PARSE_IS_SYSTEM
1563                    | PackageParser.PARSE_IS_SYSTEM_DIR
1564                    | PackageParser.PARSE_IS_PRIVILEGED, scanMode, 0);
1565
1566            // Collect ordinary system packages.
1567            File systemAppDir = new File(Environment.getRootDirectory(), "app");
1568            mSystemInstallObserver = new AppDirObserver(
1569                    systemAppDir.getPath(), OBSERVER_EVENTS, true, false);
1570            mSystemInstallObserver.startWatching();
1571            scanDirLI(systemAppDir, PackageParser.PARSE_IS_SYSTEM
1572                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
1573
1574            // Collect all vendor packages.
1575            File vendorAppDir = new File("/vendor/app");
1576            try {
1577                vendorAppDir = vendorAppDir.getCanonicalFile();
1578            } catch (IOException e) {
1579                // failed to look up canonical path, continue with original one
1580            }
1581            mVendorInstallObserver = new AppDirObserver(
1582                    vendorAppDir.getPath(), OBSERVER_EVENTS, true, false);
1583            mVendorInstallObserver.startWatching();
1584            scanDirLI(vendorAppDir, PackageParser.PARSE_IS_SYSTEM
1585                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
1586
1587            // Collect all OEM packages.
1588            File oemAppDir = new File(Environment.getOemDirectory(), "app");
1589            mOemInstallObserver = new AppDirObserver(
1590                    oemAppDir.getPath(), OBSERVER_EVENTS, true, false);
1591            mOemInstallObserver.startWatching();
1592            scanDirLI(oemAppDir, PackageParser.PARSE_IS_SYSTEM
1593                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
1594
1595            if (DEBUG_UPGRADE) Log.v(TAG, "Running installd update commands");
1596            mInstaller.moveFiles();
1597
1598            // Prune any system packages that no longer exist.
1599            final List<String> possiblyDeletedUpdatedSystemApps = new ArrayList<String>();
1600            if (!mOnlyCore) {
1601                Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
1602                while (psit.hasNext()) {
1603                    PackageSetting ps = psit.next();
1604
1605                    /*
1606                     * If this is not a system app, it can't be a
1607                     * disable system app.
1608                     */
1609                    if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0) {
1610                        continue;
1611                    }
1612
1613                    /*
1614                     * If the package is scanned, it's not erased.
1615                     */
1616                    final PackageParser.Package scannedPkg = mPackages.get(ps.name);
1617                    if (scannedPkg != null) {
1618                        /*
1619                         * If the system app is both scanned and in the
1620                         * disabled packages list, then it must have been
1621                         * added via OTA. Remove it from the currently
1622                         * scanned package so the previously user-installed
1623                         * application can be scanned.
1624                         */
1625                        if (mSettings.isDisabledSystemPackageLPr(ps.name)) {
1626                            Slog.i(TAG, "Expecting better updatd system app for " + ps.name
1627                                    + "; removing system app");
1628                            removePackageLI(ps, true);
1629                        }
1630
1631                        continue;
1632                    }
1633
1634                    if (!mSettings.isDisabledSystemPackageLPr(ps.name)) {
1635                        psit.remove();
1636                        String msg = "System package " + ps.name
1637                                + " no longer exists; wiping its data";
1638                        reportSettingsProblem(Log.WARN, msg);
1639                        removeDataDirsLI(ps.name);
1640                    } else {
1641                        final PackageSetting disabledPs = mSettings.getDisabledSystemPkgLPr(ps.name);
1642                        if (disabledPs.codePath == null || !disabledPs.codePath.exists()) {
1643                            possiblyDeletedUpdatedSystemApps.add(ps.name);
1644                        }
1645                    }
1646                }
1647            }
1648
1649            //look for any incomplete package installations
1650            ArrayList<PackageSetting> deletePkgsList = mSettings.getListOfIncompleteInstallPackagesLPr();
1651            //clean up list
1652            for(int i = 0; i < deletePkgsList.size(); i++) {
1653                //clean up here
1654                cleanupInstallFailedPackage(deletePkgsList.get(i));
1655            }
1656            //delete tmp files
1657            deleteTempPackageFiles();
1658
1659            // Remove any shared userIDs that have no associated packages
1660            mSettings.pruneSharedUsersLPw();
1661
1662            if (!mOnlyCore) {
1663                EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_DATA_SCAN_START,
1664                        SystemClock.uptimeMillis());
1665                mAppInstallObserver = new AppDirObserver(
1666                    mAppInstallDir.getPath(), OBSERVER_EVENTS, false, false);
1667                mAppInstallObserver.startWatching();
1668                scanDirLI(mAppInstallDir, 0, scanMode, 0);
1669
1670                mDrmAppInstallObserver = new AppDirObserver(
1671                    mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false, false);
1672                mDrmAppInstallObserver.startWatching();
1673                scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,
1674                        scanMode, 0);
1675
1676                /**
1677                 * Remove disable package settings for any updated system
1678                 * apps that were removed via an OTA. If they're not a
1679                 * previously-updated app, remove them completely.
1680                 * Otherwise, just revoke their system-level permissions.
1681                 */
1682                for (String deletedAppName : possiblyDeletedUpdatedSystemApps) {
1683                    PackageParser.Package deletedPkg = mPackages.get(deletedAppName);
1684                    mSettings.removeDisabledSystemPackageLPw(deletedAppName);
1685
1686                    String msg;
1687                    if (deletedPkg == null) {
1688                        msg = "Updated system package " + deletedAppName
1689                                + " no longer exists; wiping its data";
1690                        removeDataDirsLI(deletedAppName);
1691                    } else {
1692                        msg = "Updated system app + " + deletedAppName
1693                                + " no longer present; removing system privileges for "
1694                                + deletedAppName;
1695
1696                        deletedPkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_SYSTEM;
1697
1698                        PackageSetting deletedPs = mSettings.mPackages.get(deletedAppName);
1699                        deletedPs.pkgFlags &= ~ApplicationInfo.FLAG_SYSTEM;
1700                    }
1701                    reportSettingsProblem(Log.WARN, msg);
1702                }
1703            } else {
1704                mAppInstallObserver = null;
1705                mDrmAppInstallObserver = null;
1706            }
1707
1708            // Now that we know all of the shared libraries, update all clients to have
1709            // the correct library paths.
1710            updateAllSharedLibrariesLPw();
1711
1712            for (SharedUserSetting setting : mSettings.getAllSharedUsersLPw()) {
1713                // NOTE: We ignore potential failures here during a system scan (like
1714                // the rest of the commands above) because there's precious little we
1715                // can do about it. A settings error is reported, though.
1716                adjustCpuAbisForSharedUserLPw(setting.packages, null,
1717                        false /* force dexopt */, false /* defer dexopt */);
1718            }
1719
1720            // Now that we know all the packages we are keeping,
1721            // read and update their last usage times.
1722            mPackageUsage.readLP();
1723
1724            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,
1725                    SystemClock.uptimeMillis());
1726            Slog.i(TAG, "Time to scan packages: "
1727                    + ((SystemClock.uptimeMillis()-startTime)/1000f)
1728                    + " seconds");
1729
1730            // If the platform SDK has changed since the last time we booted,
1731            // we need to re-grant app permission to catch any new ones that
1732            // appear.  This is really a hack, and means that apps can in some
1733            // cases get permissions that the user didn't initially explicitly
1734            // allow...  it would be nice to have some better way to handle
1735            // this situation.
1736            final boolean regrantPermissions = mSettings.mInternalSdkPlatform
1737                    != mSdkVersion;
1738            if (regrantPermissions) Slog.i(TAG, "Platform changed from "
1739                    + mSettings.mInternalSdkPlatform + " to " + mSdkVersion
1740                    + "; regranting permissions for internal storage");
1741            mSettings.mInternalSdkPlatform = mSdkVersion;
1742
1743            updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL
1744                    | (regrantPermissions
1745                            ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL)
1746                            : 0));
1747
1748            // If this is the first boot, and it is a normal boot, then
1749            // we need to initialize the default preferred apps.
1750            if (!mRestoredSettings && !onlyCore) {
1751                mSettings.readDefaultPreferredAppsLPw(this, 0);
1752            }
1753
1754            // All the changes are done during package scanning.
1755            mSettings.updateInternalDatabaseVersion();
1756
1757            // can downgrade to reader
1758            mSettings.writeLPr();
1759
1760            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_READY,
1761                    SystemClock.uptimeMillis());
1762
1763
1764            mRequiredVerifierPackage = getRequiredVerifierLPr();
1765        } // synchronized (mPackages)
1766        } // synchronized (mInstallLock)
1767
1768        mInstallerService = new PackageInstallerService(context, this, mAppInstallDir);
1769
1770        // Now after opening every single application zip, make sure they
1771        // are all flushed.  Not really needed, but keeps things nice and
1772        // tidy.
1773        Runtime.getRuntime().gc();
1774    }
1775
1776    @Override
1777    public boolean isFirstBoot() {
1778        return !mRestoredSettings;
1779    }
1780
1781    @Override
1782    public boolean isOnlyCoreApps() {
1783        return mOnlyCore;
1784    }
1785
1786    private String getRequiredVerifierLPr() {
1787        final Intent verification = new Intent(Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
1788        final List<ResolveInfo> receivers = queryIntentReceivers(verification, PACKAGE_MIME_TYPE,
1789                PackageManager.GET_DISABLED_COMPONENTS, 0 /* TODO: Which userId? */);
1790
1791        String requiredVerifier = null;
1792
1793        final int N = receivers.size();
1794        for (int i = 0; i < N; i++) {
1795            final ResolveInfo info = receivers.get(i);
1796
1797            if (info.activityInfo == null) {
1798                continue;
1799            }
1800
1801            final String packageName = info.activityInfo.packageName;
1802
1803            final PackageSetting ps = mSettings.mPackages.get(packageName);
1804            if (ps == null) {
1805                continue;
1806            }
1807
1808            final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
1809            if (!gp.grantedPermissions
1810                    .contains(android.Manifest.permission.PACKAGE_VERIFICATION_AGENT)) {
1811                continue;
1812            }
1813
1814            if (requiredVerifier != null) {
1815                throw new RuntimeException("There can be only one required verifier");
1816            }
1817
1818            requiredVerifier = packageName;
1819        }
1820
1821        return requiredVerifier;
1822    }
1823
1824    @Override
1825    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
1826            throws RemoteException {
1827        try {
1828            return super.onTransact(code, data, reply, flags);
1829        } catch (RuntimeException e) {
1830            if (!(e instanceof SecurityException) && !(e instanceof IllegalArgumentException)) {
1831                Slog.wtf(TAG, "Package Manager Crash", e);
1832            }
1833            throw e;
1834        }
1835    }
1836
1837    void cleanupInstallFailedPackage(PackageSetting ps) {
1838        Slog.i(TAG, "Cleaning up incompletely installed app: " + ps.name);
1839        removeDataDirsLI(ps.name);
1840
1841        // TODO: try cleaning up codePath directory contents first, since it
1842        // might be a cluster
1843
1844        if (ps.codePath != null) {
1845            if (!ps.codePath.delete()) {
1846                Slog.w(TAG, "Unable to remove old code file: " + ps.codePath);
1847            }
1848        }
1849        if (ps.resourcePath != null) {
1850            if (!ps.resourcePath.delete() && !ps.resourcePath.equals(ps.codePath)) {
1851                Slog.w(TAG, "Unable to remove old code file: " + ps.resourcePath);
1852            }
1853        }
1854        mSettings.removePackageLPw(ps.name);
1855    }
1856
1857    static int[] appendInts(int[] cur, int[] add) {
1858        if (add == null) return cur;
1859        if (cur == null) return add;
1860        final int N = add.length;
1861        for (int i=0; i<N; i++) {
1862            cur = appendInt(cur, add[i]);
1863        }
1864        return cur;
1865    }
1866
1867    static int[] removeInts(int[] cur, int[] rem) {
1868        if (rem == null) return cur;
1869        if (cur == null) return cur;
1870        final int N = rem.length;
1871        for (int i=0; i<N; i++) {
1872            cur = removeInt(cur, rem[i]);
1873        }
1874        return cur;
1875    }
1876
1877    PackageInfo generatePackageInfo(PackageParser.Package p, int flags, int userId) {
1878        if (!sUserManager.exists(userId)) return null;
1879        final PackageSetting ps = (PackageSetting) p.mExtras;
1880        if (ps == null) {
1881            return null;
1882        }
1883        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
1884        final PackageUserState state = ps.readUserState(userId);
1885        return PackageParser.generatePackageInfo(p, gp.gids, flags,
1886                ps.firstInstallTime, ps.lastUpdateTime, gp.grantedPermissions,
1887                state, userId);
1888    }
1889
1890    @Override
1891    public boolean isPackageAvailable(String packageName, int userId) {
1892        if (!sUserManager.exists(userId)) return false;
1893        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "is package available");
1894        synchronized (mPackages) {
1895            PackageParser.Package p = mPackages.get(packageName);
1896            if (p != null) {
1897                final PackageSetting ps = (PackageSetting) p.mExtras;
1898                if (ps != null) {
1899                    final PackageUserState state = ps.readUserState(userId);
1900                    if (state != null) {
1901                        return PackageParser.isAvailable(state);
1902                    }
1903                }
1904            }
1905        }
1906        return false;
1907    }
1908
1909    @Override
1910    public PackageInfo getPackageInfo(String packageName, int flags, int userId) {
1911        if (!sUserManager.exists(userId)) return null;
1912        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get package info");
1913        // reader
1914        synchronized (mPackages) {
1915            PackageParser.Package p = mPackages.get(packageName);
1916            if (DEBUG_PACKAGE_INFO)
1917                Log.v(TAG, "getPackageInfo " + packageName + ": " + p);
1918            if (p != null) {
1919                return generatePackageInfo(p, flags, userId);
1920            }
1921            if((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) {
1922                return generatePackageInfoFromSettingsLPw(packageName, flags, userId);
1923            }
1924        }
1925        return null;
1926    }
1927
1928    @Override
1929    public String[] currentToCanonicalPackageNames(String[] names) {
1930        String[] out = new String[names.length];
1931        // reader
1932        synchronized (mPackages) {
1933            for (int i=names.length-1; i>=0; i--) {
1934                PackageSetting ps = mSettings.mPackages.get(names[i]);
1935                out[i] = ps != null && ps.realName != null ? ps.realName : names[i];
1936            }
1937        }
1938        return out;
1939    }
1940
1941    @Override
1942    public String[] canonicalToCurrentPackageNames(String[] names) {
1943        String[] out = new String[names.length];
1944        // reader
1945        synchronized (mPackages) {
1946            for (int i=names.length-1; i>=0; i--) {
1947                String cur = mSettings.mRenamedPackages.get(names[i]);
1948                out[i] = cur != null ? cur : names[i];
1949            }
1950        }
1951        return out;
1952    }
1953
1954    @Override
1955    public int getPackageUid(String packageName, int userId) {
1956        if (!sUserManager.exists(userId)) return -1;
1957        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get package uid");
1958        // reader
1959        synchronized (mPackages) {
1960            PackageParser.Package p = mPackages.get(packageName);
1961            if(p != null) {
1962                return UserHandle.getUid(userId, p.applicationInfo.uid);
1963            }
1964            PackageSetting ps = mSettings.mPackages.get(packageName);
1965            if((ps == null) || (ps.pkg == null) || (ps.pkg.applicationInfo == null)) {
1966                return -1;
1967            }
1968            p = ps.pkg;
1969            return p != null ? UserHandle.getUid(userId, p.applicationInfo.uid) : -1;
1970        }
1971    }
1972
1973    @Override
1974    public int[] getPackageGids(String packageName) {
1975        // reader
1976        synchronized (mPackages) {
1977            PackageParser.Package p = mPackages.get(packageName);
1978            if (DEBUG_PACKAGE_INFO)
1979                Log.v(TAG, "getPackageGids" + packageName + ": " + p);
1980            if (p != null) {
1981                final PackageSetting ps = (PackageSetting)p.mExtras;
1982                return ps.getGids();
1983            }
1984        }
1985        // stupid thing to indicate an error.
1986        return new int[0];
1987    }
1988
1989    static final PermissionInfo generatePermissionInfo(
1990            BasePermission bp, int flags) {
1991        if (bp.perm != null) {
1992            return PackageParser.generatePermissionInfo(bp.perm, flags);
1993        }
1994        PermissionInfo pi = new PermissionInfo();
1995        pi.name = bp.name;
1996        pi.packageName = bp.sourcePackage;
1997        pi.nonLocalizedLabel = bp.name;
1998        pi.protectionLevel = bp.protectionLevel;
1999        return pi;
2000    }
2001
2002    @Override
2003    public PermissionInfo getPermissionInfo(String name, int flags) {
2004        // reader
2005        synchronized (mPackages) {
2006            final BasePermission p = mSettings.mPermissions.get(name);
2007            if (p != null) {
2008                return generatePermissionInfo(p, flags);
2009            }
2010            return null;
2011        }
2012    }
2013
2014    @Override
2015    public List<PermissionInfo> queryPermissionsByGroup(String group, int flags) {
2016        // reader
2017        synchronized (mPackages) {
2018            ArrayList<PermissionInfo> out = new ArrayList<PermissionInfo>(10);
2019            for (BasePermission p : mSettings.mPermissions.values()) {
2020                if (group == null) {
2021                    if (p.perm == null || p.perm.info.group == null) {
2022                        out.add(generatePermissionInfo(p, flags));
2023                    }
2024                } else {
2025                    if (p.perm != null && group.equals(p.perm.info.group)) {
2026                        out.add(PackageParser.generatePermissionInfo(p.perm, flags));
2027                    }
2028                }
2029            }
2030
2031            if (out.size() > 0) {
2032                return out;
2033            }
2034            return mPermissionGroups.containsKey(group) ? out : null;
2035        }
2036    }
2037
2038    @Override
2039    public PermissionGroupInfo getPermissionGroupInfo(String name, int flags) {
2040        // reader
2041        synchronized (mPackages) {
2042            return PackageParser.generatePermissionGroupInfo(
2043                    mPermissionGroups.get(name), flags);
2044        }
2045    }
2046
2047    @Override
2048    public List<PermissionGroupInfo> getAllPermissionGroups(int flags) {
2049        // reader
2050        synchronized (mPackages) {
2051            final int N = mPermissionGroups.size();
2052            ArrayList<PermissionGroupInfo> out
2053                    = new ArrayList<PermissionGroupInfo>(N);
2054            for (PackageParser.PermissionGroup pg : mPermissionGroups.values()) {
2055                out.add(PackageParser.generatePermissionGroupInfo(pg, flags));
2056            }
2057            return out;
2058        }
2059    }
2060
2061    private ApplicationInfo generateApplicationInfoFromSettingsLPw(String packageName, int flags,
2062            int userId) {
2063        if (!sUserManager.exists(userId)) return null;
2064        PackageSetting ps = mSettings.mPackages.get(packageName);
2065        if (ps != null) {
2066            if (ps.pkg == null) {
2067                PackageInfo pInfo = generatePackageInfoFromSettingsLPw(packageName,
2068                        flags, userId);
2069                if (pInfo != null) {
2070                    return pInfo.applicationInfo;
2071                }
2072                return null;
2073            }
2074            return PackageParser.generateApplicationInfo(ps.pkg, flags,
2075                    ps.readUserState(userId), userId);
2076        }
2077        return null;
2078    }
2079
2080    private PackageInfo generatePackageInfoFromSettingsLPw(String packageName, int flags,
2081            int userId) {
2082        if (!sUserManager.exists(userId)) return null;
2083        PackageSetting ps = mSettings.mPackages.get(packageName);
2084        if (ps != null) {
2085            PackageParser.Package pkg = ps.pkg;
2086            if (pkg == null) {
2087                if ((flags & PackageManager.GET_UNINSTALLED_PACKAGES) == 0) {
2088                    return null;
2089                }
2090                // Only data remains, so we aren't worried about code paths
2091                pkg = new PackageParser.Package(packageName);
2092                pkg.applicationInfo.packageName = packageName;
2093                pkg.applicationInfo.flags = ps.pkgFlags | ApplicationInfo.FLAG_IS_DATA_ONLY;
2094                pkg.applicationInfo.dataDir =
2095                        getDataPathForPackage(packageName, 0).getPath();
2096                pkg.applicationInfo.primaryCpuAbi = ps.primaryCpuAbiString;
2097                pkg.applicationInfo.secondaryCpuAbi = ps.secondaryCpuAbiString;
2098            }
2099            return generatePackageInfo(pkg, flags, userId);
2100        }
2101        return null;
2102    }
2103
2104    @Override
2105    public ApplicationInfo getApplicationInfo(String packageName, int flags, int userId) {
2106        if (!sUserManager.exists(userId)) return null;
2107        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get application info");
2108        // writer
2109        synchronized (mPackages) {
2110            PackageParser.Package p = mPackages.get(packageName);
2111            if (DEBUG_PACKAGE_INFO) Log.v(
2112                    TAG, "getApplicationInfo " + packageName
2113                    + ": " + p);
2114            if (p != null) {
2115                PackageSetting ps = mSettings.mPackages.get(packageName);
2116                if (ps == null) return null;
2117                // Note: isEnabledLP() does not apply here - always return info
2118                return PackageParser.generateApplicationInfo(
2119                        p, flags, ps.readUserState(userId), userId);
2120            }
2121            if ("android".equals(packageName)||"system".equals(packageName)) {
2122                return mAndroidApplication;
2123            }
2124            if ((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) {
2125                return generateApplicationInfoFromSettingsLPw(packageName, flags, userId);
2126            }
2127        }
2128        return null;
2129    }
2130
2131
2132    @Override
2133    public void freeStorageAndNotify(final long freeStorageSize, final IPackageDataObserver observer) {
2134        mContext.enforceCallingOrSelfPermission(
2135                android.Manifest.permission.CLEAR_APP_CACHE, null);
2136        // Queue up an async operation since clearing cache may take a little while.
2137        mHandler.post(new Runnable() {
2138            public void run() {
2139                mHandler.removeCallbacks(this);
2140                int retCode = -1;
2141                synchronized (mInstallLock) {
2142                    retCode = mInstaller.freeCache(freeStorageSize);
2143                    if (retCode < 0) {
2144                        Slog.w(TAG, "Couldn't clear application caches");
2145                    }
2146                }
2147                if (observer != null) {
2148                    try {
2149                        observer.onRemoveCompleted(null, (retCode >= 0));
2150                    } catch (RemoteException e) {
2151                        Slog.w(TAG, "RemoveException when invoking call back");
2152                    }
2153                }
2154            }
2155        });
2156    }
2157
2158    @Override
2159    public void freeStorage(final long freeStorageSize, final IntentSender pi) {
2160        mContext.enforceCallingOrSelfPermission(
2161                android.Manifest.permission.CLEAR_APP_CACHE, null);
2162        // Queue up an async operation since clearing cache may take a little while.
2163        mHandler.post(new Runnable() {
2164            public void run() {
2165                mHandler.removeCallbacks(this);
2166                int retCode = -1;
2167                synchronized (mInstallLock) {
2168                    retCode = mInstaller.freeCache(freeStorageSize);
2169                    if (retCode < 0) {
2170                        Slog.w(TAG, "Couldn't clear application caches");
2171                    }
2172                }
2173                if(pi != null) {
2174                    try {
2175                        // Callback via pending intent
2176                        int code = (retCode >= 0) ? 1 : 0;
2177                        pi.sendIntent(null, code, null,
2178                                null, null);
2179                    } catch (SendIntentException e1) {
2180                        Slog.i(TAG, "Failed to send pending intent");
2181                    }
2182                }
2183            }
2184        });
2185    }
2186
2187    void freeStorage(long freeStorageSize) throws IOException {
2188        synchronized (mInstallLock) {
2189            if (mInstaller.freeCache(freeStorageSize) < 0) {
2190                throw new IOException("Failed to free enough space");
2191            }
2192        }
2193    }
2194
2195    @Override
2196    public ActivityInfo getActivityInfo(ComponentName component, int flags, int userId) {
2197        if (!sUserManager.exists(userId)) return null;
2198        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get activity info");
2199        synchronized (mPackages) {
2200            PackageParser.Activity a = mActivities.mActivities.get(component);
2201
2202            if (DEBUG_PACKAGE_INFO) Log.v(TAG, "getActivityInfo " + component + ": " + a);
2203            if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {
2204                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2205                if (ps == null) return null;
2206                return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),
2207                        userId);
2208            }
2209            if (mResolveComponentName.equals(component)) {
2210                return mResolveActivity;
2211            }
2212        }
2213        return null;
2214    }
2215
2216    @Override
2217    public boolean activitySupportsIntent(ComponentName component, Intent intent,
2218            String resolvedType) {
2219        synchronized (mPackages) {
2220            PackageParser.Activity a = mActivities.mActivities.get(component);
2221            if (a == null) {
2222                return false;
2223            }
2224            for (int i=0; i<a.intents.size(); i++) {
2225                if (a.intents.get(i).match(intent.getAction(), resolvedType, intent.getScheme(),
2226                        intent.getData(), intent.getCategories(), TAG) >= 0) {
2227                    return true;
2228                }
2229            }
2230            return false;
2231        }
2232    }
2233
2234    @Override
2235    public ActivityInfo getReceiverInfo(ComponentName component, int flags, int userId) {
2236        if (!sUserManager.exists(userId)) return null;
2237        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get receiver info");
2238        synchronized (mPackages) {
2239            PackageParser.Activity a = mReceivers.mActivities.get(component);
2240            if (DEBUG_PACKAGE_INFO) Log.v(
2241                TAG, "getReceiverInfo " + component + ": " + a);
2242            if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {
2243                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2244                if (ps == null) return null;
2245                return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),
2246                        userId);
2247            }
2248        }
2249        return null;
2250    }
2251
2252    @Override
2253    public ServiceInfo getServiceInfo(ComponentName component, int flags, int userId) {
2254        if (!sUserManager.exists(userId)) return null;
2255        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get service info");
2256        synchronized (mPackages) {
2257            PackageParser.Service s = mServices.mServices.get(component);
2258            if (DEBUG_PACKAGE_INFO) Log.v(
2259                TAG, "getServiceInfo " + component + ": " + s);
2260            if (s != null && mSettings.isEnabledLPr(s.info, flags, userId)) {
2261                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2262                if (ps == null) return null;
2263                return PackageParser.generateServiceInfo(s, flags, ps.readUserState(userId),
2264                        userId);
2265            }
2266        }
2267        return null;
2268    }
2269
2270    @Override
2271    public ProviderInfo getProviderInfo(ComponentName component, int flags, int userId) {
2272        if (!sUserManager.exists(userId)) return null;
2273        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "get provider info");
2274        synchronized (mPackages) {
2275            PackageParser.Provider p = mProviders.mProviders.get(component);
2276            if (DEBUG_PACKAGE_INFO) Log.v(
2277                TAG, "getProviderInfo " + component + ": " + p);
2278            if (p != null && mSettings.isEnabledLPr(p.info, flags, userId)) {
2279                PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2280                if (ps == null) return null;
2281                return PackageParser.generateProviderInfo(p, flags, ps.readUserState(userId),
2282                        userId);
2283            }
2284        }
2285        return null;
2286    }
2287
2288    @Override
2289    public String[] getSystemSharedLibraryNames() {
2290        Set<String> libSet;
2291        synchronized (mPackages) {
2292            libSet = mSharedLibraries.keySet();
2293            int size = libSet.size();
2294            if (size > 0) {
2295                String[] libs = new String[size];
2296                libSet.toArray(libs);
2297                return libs;
2298            }
2299        }
2300        return null;
2301    }
2302
2303    @Override
2304    public FeatureInfo[] getSystemAvailableFeatures() {
2305        Collection<FeatureInfo> featSet;
2306        synchronized (mPackages) {
2307            featSet = mAvailableFeatures.values();
2308            int size = featSet.size();
2309            if (size > 0) {
2310                FeatureInfo[] features = new FeatureInfo[size+1];
2311                featSet.toArray(features);
2312                FeatureInfo fi = new FeatureInfo();
2313                fi.reqGlEsVersion = SystemProperties.getInt("ro.opengles.version",
2314                        FeatureInfo.GL_ES_VERSION_UNDEFINED);
2315                features[size] = fi;
2316                return features;
2317            }
2318        }
2319        return null;
2320    }
2321
2322    @Override
2323    public boolean hasSystemFeature(String name) {
2324        synchronized (mPackages) {
2325            return mAvailableFeatures.containsKey(name);
2326        }
2327    }
2328
2329    private void checkValidCaller(int uid, int userId) {
2330        if (UserHandle.getUserId(uid) == userId || uid == Process.SYSTEM_UID || uid == 0)
2331            return;
2332
2333        throw new SecurityException("Caller uid=" + uid
2334                + " is not privileged to communicate with user=" + userId);
2335    }
2336
2337    @Override
2338    public int checkPermission(String permName, String pkgName) {
2339        synchronized (mPackages) {
2340            PackageParser.Package p = mPackages.get(pkgName);
2341            if (p != null && p.mExtras != null) {
2342                PackageSetting ps = (PackageSetting)p.mExtras;
2343                if (ps.sharedUser != null) {
2344                    if (ps.sharedUser.grantedPermissions.contains(permName)) {
2345                        return PackageManager.PERMISSION_GRANTED;
2346                    }
2347                } else if (ps.grantedPermissions.contains(permName)) {
2348                    return PackageManager.PERMISSION_GRANTED;
2349                }
2350            }
2351        }
2352        return PackageManager.PERMISSION_DENIED;
2353    }
2354
2355    @Override
2356    public int checkUidPermission(String permName, int uid) {
2357        synchronized (mPackages) {
2358            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2359            if (obj != null) {
2360                GrantedPermissions gp = (GrantedPermissions)obj;
2361                if (gp.grantedPermissions.contains(permName)) {
2362                    return PackageManager.PERMISSION_GRANTED;
2363                }
2364            } else {
2365                HashSet<String> perms = mSystemPermissions.get(uid);
2366                if (perms != null && perms.contains(permName)) {
2367                    return PackageManager.PERMISSION_GRANTED;
2368                }
2369            }
2370        }
2371        return PackageManager.PERMISSION_DENIED;
2372    }
2373
2374    /**
2375     * Checks if the request is from the system or an app that has INTERACT_ACROSS_USERS
2376     * or INTERACT_ACROSS_USERS_FULL permissions, if the userid is not for the caller.
2377     * @param message the message to log on security exception
2378     */
2379    void enforceCrossUserPermission(int callingUid, int userId, boolean requireFullPermission,
2380            String message) {
2381        if (userId < 0) {
2382            throw new IllegalArgumentException("Invalid userId " + userId);
2383        }
2384        if (userId == UserHandle.getUserId(callingUid)) return;
2385        if (callingUid != Process.SYSTEM_UID && callingUid != 0) {
2386            if (requireFullPermission) {
2387                mContext.enforceCallingOrSelfPermission(
2388                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
2389            } else {
2390                try {
2391                    mContext.enforceCallingOrSelfPermission(
2392                            android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
2393                } catch (SecurityException se) {
2394                    mContext.enforceCallingOrSelfPermission(
2395                            android.Manifest.permission.INTERACT_ACROSS_USERS, message);
2396                }
2397            }
2398        }
2399    }
2400
2401    private BasePermission findPermissionTreeLP(String permName) {
2402        for(BasePermission bp : mSettings.mPermissionTrees.values()) {
2403            if (permName.startsWith(bp.name) &&
2404                    permName.length() > bp.name.length() &&
2405                    permName.charAt(bp.name.length()) == '.') {
2406                return bp;
2407            }
2408        }
2409        return null;
2410    }
2411
2412    private BasePermission checkPermissionTreeLP(String permName) {
2413        if (permName != null) {
2414            BasePermission bp = findPermissionTreeLP(permName);
2415            if (bp != null) {
2416                if (bp.uid == UserHandle.getAppId(Binder.getCallingUid())) {
2417                    return bp;
2418                }
2419                throw new SecurityException("Calling uid "
2420                        + Binder.getCallingUid()
2421                        + " is not allowed to add to permission tree "
2422                        + bp.name + " owned by uid " + bp.uid);
2423            }
2424        }
2425        throw new SecurityException("No permission tree found for " + permName);
2426    }
2427
2428    static boolean compareStrings(CharSequence s1, CharSequence s2) {
2429        if (s1 == null) {
2430            return s2 == null;
2431        }
2432        if (s2 == null) {
2433            return false;
2434        }
2435        if (s1.getClass() != s2.getClass()) {
2436            return false;
2437        }
2438        return s1.equals(s2);
2439    }
2440
2441    static boolean comparePermissionInfos(PermissionInfo pi1, PermissionInfo pi2) {
2442        if (pi1.icon != pi2.icon) return false;
2443        if (pi1.logo != pi2.logo) return false;
2444        if (pi1.protectionLevel != pi2.protectionLevel) return false;
2445        if (!compareStrings(pi1.name, pi2.name)) return false;
2446        if (!compareStrings(pi1.nonLocalizedLabel, pi2.nonLocalizedLabel)) return false;
2447        // We'll take care of setting this one.
2448        if (!compareStrings(pi1.packageName, pi2.packageName)) return false;
2449        // These are not currently stored in settings.
2450        //if (!compareStrings(pi1.group, pi2.group)) return false;
2451        //if (!compareStrings(pi1.nonLocalizedDescription, pi2.nonLocalizedDescription)) return false;
2452        //if (pi1.labelRes != pi2.labelRes) return false;
2453        //if (pi1.descriptionRes != pi2.descriptionRes) return false;
2454        return true;
2455    }
2456
2457    int permissionInfoFootprint(PermissionInfo info) {
2458        int size = info.name.length();
2459        if (info.nonLocalizedLabel != null) size += info.nonLocalizedLabel.length();
2460        if (info.nonLocalizedDescription != null) size += info.nonLocalizedDescription.length();
2461        return size;
2462    }
2463
2464    int calculateCurrentPermissionFootprintLocked(BasePermission tree) {
2465        int size = 0;
2466        for (BasePermission perm : mSettings.mPermissions.values()) {
2467            if (perm.uid == tree.uid) {
2468                size += perm.name.length() + permissionInfoFootprint(perm.perm.info);
2469            }
2470        }
2471        return size;
2472    }
2473
2474    void enforcePermissionCapLocked(PermissionInfo info, BasePermission tree) {
2475        // We calculate the max size of permissions defined by this uid and throw
2476        // if that plus the size of 'info' would exceed our stated maximum.
2477        if (tree.uid != Process.SYSTEM_UID) {
2478            final int curTreeSize = calculateCurrentPermissionFootprintLocked(tree);
2479            if (curTreeSize + permissionInfoFootprint(info) > MAX_PERMISSION_TREE_FOOTPRINT) {
2480                throw new SecurityException("Permission tree size cap exceeded");
2481            }
2482        }
2483    }
2484
2485    boolean addPermissionLocked(PermissionInfo info, boolean async) {
2486        if (info.labelRes == 0 && info.nonLocalizedLabel == null) {
2487            throw new SecurityException("Label must be specified in permission");
2488        }
2489        BasePermission tree = checkPermissionTreeLP(info.name);
2490        BasePermission bp = mSettings.mPermissions.get(info.name);
2491        boolean added = bp == null;
2492        boolean changed = true;
2493        int fixedLevel = PermissionInfo.fixProtectionLevel(info.protectionLevel);
2494        if (added) {
2495            enforcePermissionCapLocked(info, tree);
2496            bp = new BasePermission(info.name, tree.sourcePackage,
2497                    BasePermission.TYPE_DYNAMIC);
2498        } else if (bp.type != BasePermission.TYPE_DYNAMIC) {
2499            throw new SecurityException(
2500                    "Not allowed to modify non-dynamic permission "
2501                    + info.name);
2502        } else {
2503            if (bp.protectionLevel == fixedLevel
2504                    && bp.perm.owner.equals(tree.perm.owner)
2505                    && bp.uid == tree.uid
2506                    && comparePermissionInfos(bp.perm.info, info)) {
2507                changed = false;
2508            }
2509        }
2510        bp.protectionLevel = fixedLevel;
2511        info = new PermissionInfo(info);
2512        info.protectionLevel = fixedLevel;
2513        bp.perm = new PackageParser.Permission(tree.perm.owner, info);
2514        bp.perm.info.packageName = tree.perm.info.packageName;
2515        bp.uid = tree.uid;
2516        if (added) {
2517            mSettings.mPermissions.put(info.name, bp);
2518        }
2519        if (changed) {
2520            if (!async) {
2521                mSettings.writeLPr();
2522            } else {
2523                scheduleWriteSettingsLocked();
2524            }
2525        }
2526        return added;
2527    }
2528
2529    @Override
2530    public boolean addPermission(PermissionInfo info) {
2531        synchronized (mPackages) {
2532            return addPermissionLocked(info, false);
2533        }
2534    }
2535
2536    @Override
2537    public boolean addPermissionAsync(PermissionInfo info) {
2538        synchronized (mPackages) {
2539            return addPermissionLocked(info, true);
2540        }
2541    }
2542
2543    @Override
2544    public void removePermission(String name) {
2545        synchronized (mPackages) {
2546            checkPermissionTreeLP(name);
2547            BasePermission bp = mSettings.mPermissions.get(name);
2548            if (bp != null) {
2549                if (bp.type != BasePermission.TYPE_DYNAMIC) {
2550                    throw new SecurityException(
2551                            "Not allowed to modify non-dynamic permission "
2552                            + name);
2553                }
2554                mSettings.mPermissions.remove(name);
2555                mSettings.writeLPr();
2556            }
2557        }
2558    }
2559
2560    private static void checkGrantRevokePermissions(PackageParser.Package pkg, BasePermission bp) {
2561        int index = pkg.requestedPermissions.indexOf(bp.name);
2562        if (index == -1) {
2563            throw new SecurityException("Package " + pkg.packageName
2564                    + " has not requested permission " + bp.name);
2565        }
2566        boolean isNormal =
2567                ((bp.protectionLevel&PermissionInfo.PROTECTION_MASK_BASE)
2568                        == PermissionInfo.PROTECTION_NORMAL);
2569        boolean isDangerous =
2570                ((bp.protectionLevel&PermissionInfo.PROTECTION_MASK_BASE)
2571                        == PermissionInfo.PROTECTION_DANGEROUS);
2572        boolean isDevelopment =
2573                ((bp.protectionLevel&PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0);
2574
2575        if (!isNormal && !isDangerous && !isDevelopment) {
2576            throw new SecurityException("Permission " + bp.name
2577                    + " is not a changeable permission type");
2578        }
2579
2580        if (isNormal || isDangerous) {
2581            if (pkg.requestedPermissionsRequired.get(index)) {
2582                throw new SecurityException("Can't change " + bp.name
2583                        + ". It is required by the application");
2584            }
2585        }
2586    }
2587
2588    @Override
2589    public void grantPermission(String packageName, String permissionName) {
2590        mContext.enforceCallingOrSelfPermission(
2591                android.Manifest.permission.GRANT_REVOKE_PERMISSIONS, null);
2592        synchronized (mPackages) {
2593            final PackageParser.Package pkg = mPackages.get(packageName);
2594            if (pkg == null) {
2595                throw new IllegalArgumentException("Unknown package: " + packageName);
2596            }
2597            final BasePermission bp = mSettings.mPermissions.get(permissionName);
2598            if (bp == null) {
2599                throw new IllegalArgumentException("Unknown permission: " + permissionName);
2600            }
2601
2602            checkGrantRevokePermissions(pkg, bp);
2603
2604            final PackageSetting ps = (PackageSetting) pkg.mExtras;
2605            if (ps == null) {
2606                return;
2607            }
2608            final GrantedPermissions gp = (ps.sharedUser != null) ? ps.sharedUser : ps;
2609            if (gp.grantedPermissions.add(permissionName)) {
2610                if (ps.haveGids) {
2611                    gp.gids = appendInts(gp.gids, bp.gids);
2612                }
2613                mSettings.writeLPr();
2614            }
2615        }
2616    }
2617
2618    @Override
2619    public void revokePermission(String packageName, String permissionName) {
2620        int changedAppId = -1;
2621
2622        synchronized (mPackages) {
2623            final PackageParser.Package pkg = mPackages.get(packageName);
2624            if (pkg == null) {
2625                throw new IllegalArgumentException("Unknown package: " + packageName);
2626            }
2627            if (pkg.applicationInfo.uid != Binder.getCallingUid()) {
2628                mContext.enforceCallingOrSelfPermission(
2629                        android.Manifest.permission.GRANT_REVOKE_PERMISSIONS, null);
2630            }
2631            final BasePermission bp = mSettings.mPermissions.get(permissionName);
2632            if (bp == null) {
2633                throw new IllegalArgumentException("Unknown permission: " + permissionName);
2634            }
2635
2636            checkGrantRevokePermissions(pkg, bp);
2637
2638            final PackageSetting ps = (PackageSetting) pkg.mExtras;
2639            if (ps == null) {
2640                return;
2641            }
2642            final GrantedPermissions gp = (ps.sharedUser != null) ? ps.sharedUser : ps;
2643            if (gp.grantedPermissions.remove(permissionName)) {
2644                gp.grantedPermissions.remove(permissionName);
2645                if (ps.haveGids) {
2646                    gp.gids = removeInts(gp.gids, bp.gids);
2647                }
2648                mSettings.writeLPr();
2649                changedAppId = ps.appId;
2650            }
2651        }
2652
2653        if (changedAppId >= 0) {
2654            // We changed the perm on someone, kill its processes.
2655            IActivityManager am = ActivityManagerNative.getDefault();
2656            if (am != null) {
2657                final int callingUserId = UserHandle.getCallingUserId();
2658                final long ident = Binder.clearCallingIdentity();
2659                try {
2660                    //XXX we should only revoke for the calling user's app permissions,
2661                    // but for now we impact all users.
2662                    //am.killUid(UserHandle.getUid(callingUserId, changedAppId),
2663                    //        "revoke " + permissionName);
2664                    int[] users = sUserManager.getUserIds();
2665                    for (int user : users) {
2666                        am.killUid(UserHandle.getUid(user, changedAppId),
2667                                "revoke " + permissionName);
2668                    }
2669                } catch (RemoteException e) {
2670                } finally {
2671                    Binder.restoreCallingIdentity(ident);
2672                }
2673            }
2674        }
2675    }
2676
2677    @Override
2678    public boolean isProtectedBroadcast(String actionName) {
2679        synchronized (mPackages) {
2680            return mProtectedBroadcasts.contains(actionName);
2681        }
2682    }
2683
2684    @Override
2685    public int checkSignatures(String pkg1, String pkg2) {
2686        synchronized (mPackages) {
2687            final PackageParser.Package p1 = mPackages.get(pkg1);
2688            final PackageParser.Package p2 = mPackages.get(pkg2);
2689            if (p1 == null || p1.mExtras == null
2690                    || p2 == null || p2.mExtras == null) {
2691                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2692            }
2693            return compareSignatures(p1.mSignatures, p2.mSignatures);
2694        }
2695    }
2696
2697    @Override
2698    public int checkUidSignatures(int uid1, int uid2) {
2699        // Map to base uids.
2700        uid1 = UserHandle.getAppId(uid1);
2701        uid2 = UserHandle.getAppId(uid2);
2702        // reader
2703        synchronized (mPackages) {
2704            Signature[] s1;
2705            Signature[] s2;
2706            Object obj = mSettings.getUserIdLPr(uid1);
2707            if (obj != null) {
2708                if (obj instanceof SharedUserSetting) {
2709                    s1 = ((SharedUserSetting)obj).signatures.mSignatures;
2710                } else if (obj instanceof PackageSetting) {
2711                    s1 = ((PackageSetting)obj).signatures.mSignatures;
2712                } else {
2713                    return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2714                }
2715            } else {
2716                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2717            }
2718            obj = mSettings.getUserIdLPr(uid2);
2719            if (obj != null) {
2720                if (obj instanceof SharedUserSetting) {
2721                    s2 = ((SharedUserSetting)obj).signatures.mSignatures;
2722                } else if (obj instanceof PackageSetting) {
2723                    s2 = ((PackageSetting)obj).signatures.mSignatures;
2724                } else {
2725                    return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2726                }
2727            } else {
2728                return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
2729            }
2730            return compareSignatures(s1, s2);
2731        }
2732    }
2733
2734    /**
2735     * Compares two sets of signatures. Returns:
2736     * <br />
2737     * {@link PackageManager#SIGNATURE_NEITHER_SIGNED}: if both signature sets are null,
2738     * <br />
2739     * {@link PackageManager#SIGNATURE_FIRST_NOT_SIGNED}: if the first signature set is null,
2740     * <br />
2741     * {@link PackageManager#SIGNATURE_SECOND_NOT_SIGNED}: if the second signature set is null,
2742     * <br />
2743     * {@link PackageManager#SIGNATURE_MATCH}: if the two signature sets are identical,
2744     * <br />
2745     * {@link PackageManager#SIGNATURE_NO_MATCH}: if the two signature sets differ.
2746     */
2747    static int compareSignatures(Signature[] s1, Signature[] s2) {
2748        if (s1 == null) {
2749            return s2 == null
2750                    ? PackageManager.SIGNATURE_NEITHER_SIGNED
2751                    : PackageManager.SIGNATURE_FIRST_NOT_SIGNED;
2752        }
2753
2754        if (s2 == null) {
2755            return PackageManager.SIGNATURE_SECOND_NOT_SIGNED;
2756        }
2757
2758        if (s1.length != s2.length) {
2759            return PackageManager.SIGNATURE_NO_MATCH;
2760        }
2761
2762        // Since both signature sets are of size 1, we can compare without HashSets.
2763        if (s1.length == 1) {
2764            return s1[0].equals(s2[0]) ?
2765                    PackageManager.SIGNATURE_MATCH :
2766                    PackageManager.SIGNATURE_NO_MATCH;
2767        }
2768
2769        HashSet<Signature> set1 = new HashSet<Signature>();
2770        for (Signature sig : s1) {
2771            set1.add(sig);
2772        }
2773        HashSet<Signature> set2 = new HashSet<Signature>();
2774        for (Signature sig : s2) {
2775            set2.add(sig);
2776        }
2777        // Make sure s2 contains all signatures in s1.
2778        if (set1.equals(set2)) {
2779            return PackageManager.SIGNATURE_MATCH;
2780        }
2781        return PackageManager.SIGNATURE_NO_MATCH;
2782    }
2783
2784    /**
2785     * If the database version for this type of package (internal storage or
2786     * external storage) is less than the version where package signatures
2787     * were updated, return true.
2788     */
2789    private boolean isCompatSignatureUpdateNeeded(PackageParser.Package scannedPkg) {
2790        return (isExternal(scannedPkg) && mSettings.isExternalDatabaseVersionOlderThan(
2791                DatabaseVersion.SIGNATURE_END_ENTITY))
2792                || (!isExternal(scannedPkg) && mSettings.isInternalDatabaseVersionOlderThan(
2793                        DatabaseVersion.SIGNATURE_END_ENTITY));
2794    }
2795
2796    /**
2797     * Used for backward compatibility to make sure any packages with
2798     * certificate chains get upgraded to the new style. {@code existingSigs}
2799     * will be in the old format (since they were stored on disk from before the
2800     * system upgrade) and {@code scannedSigs} will be in the newer format.
2801     */
2802    private int compareSignaturesCompat(PackageSignatures existingSigs,
2803            PackageParser.Package scannedPkg) {
2804        if (!isCompatSignatureUpdateNeeded(scannedPkg)) {
2805            return PackageManager.SIGNATURE_NO_MATCH;
2806        }
2807
2808        HashSet<Signature> existingSet = new HashSet<Signature>();
2809        for (Signature sig : existingSigs.mSignatures) {
2810            existingSet.add(sig);
2811        }
2812        HashSet<Signature> scannedCompatSet = new HashSet<Signature>();
2813        for (Signature sig : scannedPkg.mSignatures) {
2814            try {
2815                Signature[] chainSignatures = sig.getChainSignatures();
2816                for (Signature chainSig : chainSignatures) {
2817                    scannedCompatSet.add(chainSig);
2818                }
2819            } catch (CertificateEncodingException e) {
2820                scannedCompatSet.add(sig);
2821            }
2822        }
2823        /*
2824         * Make sure the expanded scanned set contains all signatures in the
2825         * existing one.
2826         */
2827        if (scannedCompatSet.equals(existingSet)) {
2828            // Migrate the old signatures to the new scheme.
2829            existingSigs.assignSignatures(scannedPkg.mSignatures);
2830            // The new KeySets will be re-added later in the scanning process.
2831            synchronized (mPackages) {
2832                mSettings.mKeySetManagerService.removeAppKeySetDataLPw(scannedPkg.packageName);
2833            }
2834            return PackageManager.SIGNATURE_MATCH;
2835        }
2836        return PackageManager.SIGNATURE_NO_MATCH;
2837    }
2838
2839    @Override
2840    public String[] getPackagesForUid(int uid) {
2841        uid = UserHandle.getAppId(uid);
2842        // reader
2843        synchronized (mPackages) {
2844            Object obj = mSettings.getUserIdLPr(uid);
2845            if (obj instanceof SharedUserSetting) {
2846                final SharedUserSetting sus = (SharedUserSetting) obj;
2847                final int N = sus.packages.size();
2848                final String[] res = new String[N];
2849                final Iterator<PackageSetting> it = sus.packages.iterator();
2850                int i = 0;
2851                while (it.hasNext()) {
2852                    res[i++] = it.next().name;
2853                }
2854                return res;
2855            } else if (obj instanceof PackageSetting) {
2856                final PackageSetting ps = (PackageSetting) obj;
2857                return new String[] { ps.name };
2858            }
2859        }
2860        return null;
2861    }
2862
2863    @Override
2864    public String getNameForUid(int uid) {
2865        // reader
2866        synchronized (mPackages) {
2867            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2868            if (obj instanceof SharedUserSetting) {
2869                final SharedUserSetting sus = (SharedUserSetting) obj;
2870                return sus.name + ":" + sus.userId;
2871            } else if (obj instanceof PackageSetting) {
2872                final PackageSetting ps = (PackageSetting) obj;
2873                return ps.name;
2874            }
2875        }
2876        return null;
2877    }
2878
2879    @Override
2880    public int getUidForSharedUser(String sharedUserName) {
2881        if(sharedUserName == null) {
2882            return -1;
2883        }
2884        // reader
2885        synchronized (mPackages) {
2886            final SharedUserSetting suid = mSettings.getSharedUserLPw(sharedUserName, 0, false);
2887            if (suid == null) {
2888                return -1;
2889            }
2890            return suid.userId;
2891        }
2892    }
2893
2894    @Override
2895    public int getFlagsForUid(int uid) {
2896        synchronized (mPackages) {
2897            Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
2898            if (obj instanceof SharedUserSetting) {
2899                final SharedUserSetting sus = (SharedUserSetting) obj;
2900                return sus.pkgFlags;
2901            } else if (obj instanceof PackageSetting) {
2902                final PackageSetting ps = (PackageSetting) obj;
2903                return ps.pkgFlags;
2904            }
2905        }
2906        return 0;
2907    }
2908
2909    @Override
2910    public ResolveInfo resolveIntent(Intent intent, String resolvedType,
2911            int flags, int userId) {
2912        if (!sUserManager.exists(userId)) return null;
2913        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "resolve intent");
2914        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
2915        return chooseBestActivity(intent, resolvedType, flags, query, userId);
2916    }
2917
2918    @Override
2919    public void setLastChosenActivity(Intent intent, String resolvedType, int flags,
2920            IntentFilter filter, int match, ComponentName activity) {
2921        final int userId = UserHandle.getCallingUserId();
2922        if (DEBUG_PREFERRED) {
2923            Log.v(TAG, "setLastChosenActivity intent=" + intent
2924                + " resolvedType=" + resolvedType
2925                + " flags=" + flags
2926                + " filter=" + filter
2927                + " match=" + match
2928                + " activity=" + activity);
2929            filter.dump(new PrintStreamPrinter(System.out), "    ");
2930        }
2931        intent.setComponent(null);
2932        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
2933        // Find any earlier preferred or last chosen entries and nuke them
2934        findPreferredActivity(intent, resolvedType,
2935                flags, query, 0, false, true, false, userId);
2936        // Add the new activity as the last chosen for this filter
2937        addPreferredActivityInternal(filter, match, null, activity, false, userId);
2938    }
2939
2940    @Override
2941    public ResolveInfo getLastChosenActivity(Intent intent, String resolvedType, int flags) {
2942        final int userId = UserHandle.getCallingUserId();
2943        if (DEBUG_PREFERRED) Log.v(TAG, "Querying last chosen activity for " + intent);
2944        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
2945        return findPreferredActivity(intent, resolvedType, flags, query, 0,
2946                false, false, false, userId);
2947    }
2948
2949    private ResolveInfo chooseBestActivity(Intent intent, String resolvedType,
2950            int flags, List<ResolveInfo> query, int userId) {
2951        if (query != null) {
2952            final int N = query.size();
2953            if (N == 1) {
2954                return query.get(0);
2955            } else if (N > 1) {
2956                final boolean debug = ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
2957                // If there is more than one activity with the same priority,
2958                // then let the user decide between them.
2959                ResolveInfo r0 = query.get(0);
2960                ResolveInfo r1 = query.get(1);
2961                if (DEBUG_INTENT_MATCHING || debug) {
2962                    Slog.v(TAG, r0.activityInfo.name + "=" + r0.priority + " vs "
2963                            + r1.activityInfo.name + "=" + r1.priority);
2964                }
2965                // If the first activity has a higher priority, or a different
2966                // default, then it is always desireable to pick it.
2967                if (r0.priority != r1.priority
2968                        || r0.preferredOrder != r1.preferredOrder
2969                        || r0.isDefault != r1.isDefault) {
2970                    return query.get(0);
2971                }
2972                // If we have saved a preference for a preferred activity for
2973                // this Intent, use that.
2974                ResolveInfo ri = findPreferredActivity(intent, resolvedType,
2975                        flags, query, r0.priority, true, false, debug, userId);
2976                if (ri != null) {
2977                    return ri;
2978                }
2979                if (userId != 0) {
2980                    ri = new ResolveInfo(mResolveInfo);
2981                    ri.activityInfo = new ActivityInfo(ri.activityInfo);
2982                    ri.activityInfo.applicationInfo = new ApplicationInfo(
2983                            ri.activityInfo.applicationInfo);
2984                    ri.activityInfo.applicationInfo.uid = UserHandle.getUid(userId,
2985                            UserHandle.getAppId(ri.activityInfo.applicationInfo.uid));
2986                    return ri;
2987                }
2988                return mResolveInfo;
2989            }
2990        }
2991        return null;
2992    }
2993
2994    private ResolveInfo findPersistentPreferredActivityLP(Intent intent, String resolvedType,
2995            int flags, List<ResolveInfo> query, boolean debug, int userId) {
2996        final int N = query.size();
2997        PersistentPreferredIntentResolver ppir = mSettings.mPersistentPreferredActivities
2998                .get(userId);
2999        // Get the list of persistent preferred activities that handle the intent
3000        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Looking for presistent preferred activities...");
3001        List<PersistentPreferredActivity> pprefs = ppir != null
3002                ? ppir.queryIntent(intent, resolvedType,
3003                        (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId)
3004                : null;
3005        if (pprefs != null && pprefs.size() > 0) {
3006            final int M = pprefs.size();
3007            for (int i=0; i<M; i++) {
3008                final PersistentPreferredActivity ppa = pprefs.get(i);
3009                if (DEBUG_PREFERRED || debug) {
3010                    Slog.v(TAG, "Checking PersistentPreferredActivity ds="
3011                            + (ppa.countDataSchemes() > 0 ? ppa.getDataScheme(0) : "<none>")
3012                            + "\n  component=" + ppa.mComponent);
3013                    ppa.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3014                }
3015                final ActivityInfo ai = getActivityInfo(ppa.mComponent,
3016                        flags | PackageManager.GET_DISABLED_COMPONENTS, userId);
3017                if (DEBUG_PREFERRED || debug) {
3018                    Slog.v(TAG, "Found persistent preferred activity:");
3019                    if (ai != null) {
3020                        ai.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3021                    } else {
3022                        Slog.v(TAG, "  null");
3023                    }
3024                }
3025                if (ai == null) {
3026                    // This previously registered persistent preferred activity
3027                    // component is no longer known. Ignore it and do NOT remove it.
3028                    continue;
3029                }
3030                for (int j=0; j<N; j++) {
3031                    final ResolveInfo ri = query.get(j);
3032                    if (!ri.activityInfo.applicationInfo.packageName
3033                            .equals(ai.applicationInfo.packageName)) {
3034                        continue;
3035                    }
3036                    if (!ri.activityInfo.name.equals(ai.name)) {
3037                        continue;
3038                    }
3039                    //  Found a persistent preference that can handle the intent.
3040                    if (DEBUG_PREFERRED || debug) {
3041                        Slog.v(TAG, "Returning persistent preferred activity: " +
3042                                ri.activityInfo.packageName + "/" + ri.activityInfo.name);
3043                    }
3044                    return ri;
3045                }
3046            }
3047        }
3048        return null;
3049    }
3050
3051    ResolveInfo findPreferredActivity(Intent intent, String resolvedType, int flags,
3052            List<ResolveInfo> query, int priority, boolean always,
3053            boolean removeMatches, boolean debug, int userId) {
3054        if (!sUserManager.exists(userId)) return null;
3055        // writer
3056        synchronized (mPackages) {
3057            if (intent.getSelector() != null) {
3058                intent = intent.getSelector();
3059            }
3060            if (DEBUG_PREFERRED) intent.addFlags(Intent.FLAG_DEBUG_LOG_RESOLUTION);
3061
3062            // Try to find a matching persistent preferred activity.
3063            ResolveInfo pri = findPersistentPreferredActivityLP(intent, resolvedType, flags, query,
3064                    debug, userId);
3065
3066            // If a persistent preferred activity matched, use it.
3067            if (pri != null) {
3068                return pri;
3069            }
3070
3071            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
3072            // Get the list of preferred activities that handle the intent
3073            if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Looking for preferred activities...");
3074            List<PreferredActivity> prefs = pir != null
3075                    ? pir.queryIntent(intent, resolvedType,
3076                            (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId)
3077                    : null;
3078            if (prefs != null && prefs.size() > 0) {
3079                // First figure out how good the original match set is.
3080                // We will only allow preferred activities that came
3081                // from the same match quality.
3082                int match = 0;
3083
3084                if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Figuring out best match...");
3085
3086                final int N = query.size();
3087                for (int j=0; j<N; j++) {
3088                    final ResolveInfo ri = query.get(j);
3089                    if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Match for " + ri.activityInfo
3090                            + ": 0x" + Integer.toHexString(match));
3091                    if (ri.match > match) {
3092                        match = ri.match;
3093                    }
3094                }
3095
3096                if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Best match: 0x"
3097                        + Integer.toHexString(match));
3098
3099                match &= IntentFilter.MATCH_CATEGORY_MASK;
3100                final int M = prefs.size();
3101                for (int i=0; i<M; i++) {
3102                    final PreferredActivity pa = prefs.get(i);
3103                    if (DEBUG_PREFERRED || debug) {
3104                        Slog.v(TAG, "Checking PreferredActivity ds="
3105                                + (pa.countDataSchemes() > 0 ? pa.getDataScheme(0) : "<none>")
3106                                + "\n  component=" + pa.mPref.mComponent);
3107                        pa.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3108                    }
3109                    if (pa.mPref.mMatch != match) {
3110                        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Skipping bad match "
3111                                + Integer.toHexString(pa.mPref.mMatch));
3112                        continue;
3113                    }
3114                    // If it's not an "always" type preferred activity and that's what we're
3115                    // looking for, skip it.
3116                    if (always && !pa.mPref.mAlways) {
3117                        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Skipping mAlways=false entry");
3118                        continue;
3119                    }
3120                    final ActivityInfo ai = getActivityInfo(pa.mPref.mComponent,
3121                            flags | PackageManager.GET_DISABLED_COMPONENTS, userId);
3122                    if (DEBUG_PREFERRED || debug) {
3123                        Slog.v(TAG, "Found preferred activity:");
3124                        if (ai != null) {
3125                            ai.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), "  ");
3126                        } else {
3127                            Slog.v(TAG, "  null");
3128                        }
3129                    }
3130                    if (ai == null) {
3131                        // This previously registered preferred activity
3132                        // component is no longer known.  Most likely an update
3133                        // to the app was installed and in the new version this
3134                        // component no longer exists.  Clean it up by removing
3135                        // it from the preferred activities list, and skip it.
3136                        Slog.w(TAG, "Removing dangling preferred activity: "
3137                                + pa.mPref.mComponent);
3138                        pir.removeFilter(pa);
3139                        continue;
3140                    }
3141                    for (int j=0; j<N; j++) {
3142                        final ResolveInfo ri = query.get(j);
3143                        if (!ri.activityInfo.applicationInfo.packageName
3144                                .equals(ai.applicationInfo.packageName)) {
3145                            continue;
3146                        }
3147                        if (!ri.activityInfo.name.equals(ai.name)) {
3148                            continue;
3149                        }
3150
3151                        if (removeMatches) {
3152                            pir.removeFilter(pa);
3153                            if (DEBUG_PREFERRED) {
3154                                Slog.v(TAG, "Removing match " + pa.mPref.mComponent);
3155                            }
3156                            break;
3157                        }
3158
3159                        // Okay we found a previously set preferred or last chosen app.
3160                        // If the result set is different from when this
3161                        // was created, we need to clear it and re-ask the
3162                        // user their preference, if we're looking for an "always" type entry.
3163                        if (always && !pa.mPref.sameSet(query, priority)) {
3164                            Slog.i(TAG, "Result set changed, dropping preferred activity for "
3165                                    + intent + " type " + resolvedType);
3166                            if (DEBUG_PREFERRED) {
3167                                Slog.v(TAG, "Removing preferred activity since set changed "
3168                                        + pa.mPref.mComponent);
3169                            }
3170                            pir.removeFilter(pa);
3171                            // Re-add the filter as a "last chosen" entry (!always)
3172                            PreferredActivity lastChosen = new PreferredActivity(
3173                                    pa, pa.mPref.mMatch, null, pa.mPref.mComponent, false);
3174                            pir.addFilter(lastChosen);
3175                            mSettings.writePackageRestrictionsLPr(userId);
3176                            return null;
3177                        }
3178
3179                        // Yay! Either the set matched or we're looking for the last chosen
3180                        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Returning preferred activity: "
3181                                + ri.activityInfo.packageName + "/" + ri.activityInfo.name);
3182                        mSettings.writePackageRestrictionsLPr(userId);
3183                        return ri;
3184                    }
3185                }
3186            }
3187            mSettings.writePackageRestrictionsLPr(userId);
3188        }
3189        if (DEBUG_PREFERRED || debug) Slog.v(TAG, "No preferred activity to return");
3190        return null;
3191    }
3192
3193    /*
3194     * Returns if intent can be forwarded from the sourceUserId to the targetUserId
3195     */
3196    @Override
3197    public boolean canForwardTo(Intent intent, String resolvedType, int sourceUserId,
3198            int targetUserId) {
3199        mContext.enforceCallingOrSelfPermission(
3200                android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
3201        List<CrossProfileIntentFilter> matches =
3202                getMatchingCrossProfileIntentFilters(intent, resolvedType, sourceUserId);
3203        if (matches != null) {
3204            int size = matches.size();
3205            for (int i = 0; i < size; i++) {
3206                if (matches.get(i).getTargetUserId() == targetUserId) return true;
3207            }
3208        }
3209
3210        ArrayList<String> packageNames = null;
3211        SparseArray<ArrayList<String>> fromSource =
3212                mSettings.mCrossProfilePackageInfo.get(sourceUserId);
3213        if (fromSource != null) {
3214            packageNames = fromSource.get(targetUserId);
3215        }
3216        if (packageNames.contains(intent.getPackage())) {
3217            return true;
3218        }
3219        // We need the package name, so we try to resolve with the loosest flags possible
3220        List<ResolveInfo> resolveInfos = mActivities.queryIntent(
3221                intent, resolvedType, PackageManager.GET_UNINSTALLED_PACKAGES, targetUserId);
3222        int count = resolveInfos.size();
3223        for (int i = 0; i < count; i++) {
3224            ResolveInfo resolveInfo = resolveInfos.get(i);
3225            if (packageNames.contains(resolveInfo.activityInfo.packageName)) {
3226                return true;
3227            }
3228        }
3229        return false;
3230    }
3231
3232    private List<CrossProfileIntentFilter> getMatchingCrossProfileIntentFilters(Intent intent,
3233            String resolvedType, int userId) {
3234        CrossProfileIntentResolver resolver = mSettings.mCrossProfileIntentResolvers.get(userId);
3235        if (resolver != null) {
3236            return resolver.queryIntent(intent, resolvedType, false, userId);
3237        }
3238        return null;
3239    }
3240
3241    @Override
3242    public List<ResolveInfo> queryIntentActivities(Intent intent,
3243            String resolvedType, int flags, int userId) {
3244        if (!sUserManager.exists(userId)) return Collections.emptyList();
3245        enforceCrossUserPermission(Binder.getCallingUid(), userId, false, "query intent activities");
3246        ComponentName comp = intent.getComponent();
3247        if (comp == null) {
3248            if (intent.getSelector() != null) {
3249                intent = intent.getSelector();
3250                comp = intent.getComponent();
3251            }
3252        }
3253
3254        if (comp != null) {
3255            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3256            final ActivityInfo ai = getActivityInfo(comp, flags, userId);
3257            if (ai != null) {
3258                final ResolveInfo ri = new ResolveInfo();
3259                ri.activityInfo = ai;
3260                list.add(ri);
3261            }
3262            return list;
3263        }
3264
3265        // reader
3266        synchronized (mPackages) {
3267            final String pkgName = intent.getPackage();
3268            boolean queryCrossProfile = (flags & PackageManager.NO_CROSS_PROFILE) == 0;
3269            if (pkgName == null) {
3270                ResolveInfo resolveInfo = null;
3271                if (queryCrossProfile) {
3272                    // Check if the intent needs to be forwarded to another user for this package
3273                    ArrayList<ResolveInfo> crossProfileResult =
3274                            queryIntentActivitiesCrossProfilePackage(
3275                                    intent, resolvedType, flags, userId);
3276                    if (!crossProfileResult.isEmpty()) {
3277                        // Skip the current profile
3278                        return crossProfileResult;
3279                    }
3280                    List<CrossProfileIntentFilter> matchingFilters =
3281                            getMatchingCrossProfileIntentFilters(intent, resolvedType, userId);
3282                    // Check for results that need to skip the current profile.
3283                    resolveInfo = querySkipCurrentProfileIntents(matchingFilters, intent,
3284                            resolvedType, flags, userId);
3285                    if (resolveInfo != null) {
3286                        List<ResolveInfo> result = new ArrayList<ResolveInfo>(1);
3287                        result.add(resolveInfo);
3288                        return result;
3289                    }
3290                    // Check for cross profile results.
3291                    resolveInfo = queryCrossProfileIntents(
3292                            matchingFilters, intent, resolvedType, flags, userId);
3293                }
3294                // Check for results in the current profile.
3295                List<ResolveInfo> result = mActivities.queryIntent(
3296                        intent, resolvedType, flags, userId);
3297                if (resolveInfo != null) {
3298                    result.add(resolveInfo);
3299                }
3300                return result;
3301            }
3302            final PackageParser.Package pkg = mPackages.get(pkgName);
3303            if (pkg != null) {
3304                if (queryCrossProfile) {
3305                    ArrayList<ResolveInfo> crossProfileResult =
3306                            queryIntentActivitiesCrossProfilePackage(
3307                                    intent, resolvedType, flags, userId, pkg, pkgName);
3308                    if (!crossProfileResult.isEmpty()) {
3309                        // Skip the current profile
3310                        return crossProfileResult;
3311                    }
3312                }
3313                return mActivities.queryIntentForPackage(intent, resolvedType, flags,
3314                        pkg.activities, userId);
3315            }
3316            return new ArrayList<ResolveInfo>();
3317        }
3318    }
3319
3320    private ResolveInfo querySkipCurrentProfileIntents(
3321            List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
3322            int flags, int sourceUserId) {
3323        if (matchingFilters != null) {
3324            int size = matchingFilters.size();
3325            for (int i = 0; i < size; i ++) {
3326                CrossProfileIntentFilter filter = matchingFilters.get(i);
3327                if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) != 0) {
3328                    // Checking if there are activities in the target user that can handle the
3329                    // intent.
3330                    ResolveInfo resolveInfo = checkTargetCanHandle(filter, intent, resolvedType,
3331                            flags, sourceUserId);
3332                    if (resolveInfo != null) {
3333                        return resolveInfo;
3334                    }
3335                }
3336            }
3337        }
3338        return null;
3339    }
3340
3341    private ArrayList<ResolveInfo> queryIntentActivitiesCrossProfilePackage(
3342            Intent intent, String resolvedType, int flags, int userId) {
3343        ArrayList<ResolveInfo> matchingResolveInfos = new ArrayList<ResolveInfo>();
3344        SparseArray<ArrayList<String>> sourceForwardingInfo =
3345                mSettings.mCrossProfilePackageInfo.get(userId);
3346        if (sourceForwardingInfo != null) {
3347            int NI = sourceForwardingInfo.size();
3348            for (int i = 0; i < NI; i++) {
3349                int targetUserId = sourceForwardingInfo.keyAt(i);
3350                ArrayList<String> packageNames = sourceForwardingInfo.valueAt(i);
3351                List<ResolveInfo> resolveInfos = mActivities.queryIntent(
3352                        intent, resolvedType, flags, targetUserId);
3353                int NJ = resolveInfos.size();
3354                for (int j = 0; j < NJ; j++) {
3355                    ResolveInfo resolveInfo = resolveInfos.get(j);
3356                    if (packageNames.contains(resolveInfo.activityInfo.packageName)) {
3357                        matchingResolveInfos.add(createForwardingResolveInfo(
3358                                resolveInfo.filter, userId, targetUserId));
3359                    }
3360                }
3361            }
3362        }
3363        return matchingResolveInfos;
3364    }
3365
3366    private ArrayList<ResolveInfo> queryIntentActivitiesCrossProfilePackage(
3367            Intent intent, String resolvedType, int flags, int userId, PackageParser.Package pkg,
3368            String packageName) {
3369        ArrayList<ResolveInfo> matchingResolveInfos = new ArrayList<ResolveInfo>();
3370        SparseArray<ArrayList<String>> sourceForwardingInfo =
3371                mSettings.mCrossProfilePackageInfo.get(userId);
3372        if (sourceForwardingInfo != null) {
3373            int NI = sourceForwardingInfo.size();
3374            for (int i = 0; i < NI; i++) {
3375                int targetUserId = sourceForwardingInfo.keyAt(i);
3376                if (sourceForwardingInfo.valueAt(i).contains(packageName)) {
3377                    List<ResolveInfo> resolveInfos = mActivities.queryIntentForPackage(
3378                            intent, resolvedType, flags, pkg.activities, targetUserId);
3379                    int NJ = resolveInfos.size();
3380                    for (int j = 0; j < NJ; j++) {
3381                        ResolveInfo resolveInfo = resolveInfos.get(j);
3382                        matchingResolveInfos.add(createForwardingResolveInfo(
3383                                resolveInfo.filter, userId, targetUserId));
3384                    }
3385                }
3386            }
3387        }
3388        return matchingResolveInfos;
3389    }
3390
3391    // Return matching ResolveInfo if any for skip current profile intent filters.
3392    private ResolveInfo queryCrossProfileIntents(
3393            List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
3394            int flags, int sourceUserId) {
3395        if (matchingFilters != null) {
3396            // Two {@link CrossProfileIntentFilter}s can have the same targetUserId and
3397            // match the same intent. For performance reasons, it is better not to
3398            // run queryIntent twice for the same userId
3399            SparseBooleanArray alreadyTriedUserIds = new SparseBooleanArray();
3400            int size = matchingFilters.size();
3401            for (int i = 0; i < size; i++) {
3402                CrossProfileIntentFilter filter = matchingFilters.get(i);
3403                int targetUserId = filter.getTargetUserId();
3404                if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) == 0
3405                        && !alreadyTriedUserIds.get(targetUserId)) {
3406                    // Checking if there are activities in the target user that can handle the
3407                    // intent.
3408                    ResolveInfo resolveInfo = checkTargetCanHandle(filter, intent, resolvedType,
3409                            flags, sourceUserId);
3410                    if (resolveInfo != null) return resolveInfo;
3411                    alreadyTriedUserIds.put(targetUserId, true);
3412                }
3413            }
3414        }
3415        return null;
3416    }
3417
3418    private ResolveInfo checkTargetCanHandle(CrossProfileIntentFilter filter, Intent intent,
3419            String resolvedType, int flags, int sourceUserId) {
3420        List<ResolveInfo> resultTargetUser = mActivities.queryIntent(intent,
3421                resolvedType, flags, filter.getTargetUserId());
3422        if (resultTargetUser != null && !resultTargetUser.isEmpty()) {
3423            return createForwardingResolveInfo(filter, sourceUserId, filter.getTargetUserId());
3424        }
3425        return null;
3426    }
3427
3428    private ResolveInfo createForwardingResolveInfo(IntentFilter filter,
3429            int sourceUserId, int targetUserId) {
3430        ResolveInfo forwardingResolveInfo = new ResolveInfo();
3431        String className;
3432        if (targetUserId == UserHandle.USER_OWNER) {
3433            className = FORWARD_INTENT_TO_USER_OWNER;
3434        } else {
3435            className = FORWARD_INTENT_TO_MANAGED_PROFILE;
3436        }
3437        ComponentName forwardingActivityComponentName = new ComponentName(
3438                mAndroidApplication.packageName, className);
3439        ActivityInfo forwardingActivityInfo = getActivityInfo(forwardingActivityComponentName, 0,
3440                sourceUserId);
3441        if (targetUserId == UserHandle.USER_OWNER) {
3442            forwardingActivityInfo.showUserIcon = UserHandle.USER_OWNER;
3443            forwardingResolveInfo.noResourceId = true;
3444        }
3445        forwardingResolveInfo.activityInfo = forwardingActivityInfo;
3446        forwardingResolveInfo.priority = 0;
3447        forwardingResolveInfo.preferredOrder = 0;
3448        forwardingResolveInfo.match = 0;
3449        forwardingResolveInfo.isDefault = true;
3450        forwardingResolveInfo.filter = filter;
3451        forwardingResolveInfo.targetUserId = targetUserId;
3452        return forwardingResolveInfo;
3453    }
3454
3455    @Override
3456    public List<ResolveInfo> queryIntentActivityOptions(ComponentName caller,
3457            Intent[] specifics, String[] specificTypes, Intent intent,
3458            String resolvedType, int flags, int userId) {
3459        if (!sUserManager.exists(userId)) return Collections.emptyList();
3460        enforceCrossUserPermission(Binder.getCallingUid(), userId, false,
3461                "query intent activity options");
3462        final String resultsAction = intent.getAction();
3463
3464        List<ResolveInfo> results = queryIntentActivities(intent, resolvedType, flags
3465                | PackageManager.GET_RESOLVED_FILTER, userId);
3466
3467        if (DEBUG_INTENT_MATCHING) {
3468            Log.v(TAG, "Query " + intent + ": " + results);
3469        }
3470
3471        int specificsPos = 0;
3472        int N;
3473
3474        // todo: note that the algorithm used here is O(N^2).  This
3475        // isn't a problem in our current environment, but if we start running
3476        // into situations where we have more than 5 or 10 matches then this
3477        // should probably be changed to something smarter...
3478
3479        // First we go through and resolve each of the specific items
3480        // that were supplied, taking care of removing any corresponding
3481        // duplicate items in the generic resolve list.
3482        if (specifics != null) {
3483            for (int i=0; i<specifics.length; i++) {
3484                final Intent sintent = specifics[i];
3485                if (sintent == null) {
3486                    continue;
3487                }
3488
3489                if (DEBUG_INTENT_MATCHING) {
3490                    Log.v(TAG, "Specific #" + i + ": " + sintent);
3491                }
3492
3493                String action = sintent.getAction();
3494                if (resultsAction != null && resultsAction.equals(action)) {
3495                    // If this action was explicitly requested, then don't
3496                    // remove things that have it.
3497                    action = null;
3498                }
3499
3500                ResolveInfo ri = null;
3501                ActivityInfo ai = null;
3502
3503                ComponentName comp = sintent.getComponent();
3504                if (comp == null) {
3505                    ri = resolveIntent(
3506                        sintent,
3507                        specificTypes != null ? specificTypes[i] : null,
3508                            flags, userId);
3509                    if (ri == null) {
3510                        continue;
3511                    }
3512                    if (ri == mResolveInfo) {
3513                        // ACK!  Must do something better with this.
3514                    }
3515                    ai = ri.activityInfo;
3516                    comp = new ComponentName(ai.applicationInfo.packageName,
3517                            ai.name);
3518                } else {
3519                    ai = getActivityInfo(comp, flags, userId);
3520                    if (ai == null) {
3521                        continue;
3522                    }
3523                }
3524
3525                // Look for any generic query activities that are duplicates
3526                // of this specific one, and remove them from the results.
3527                if (DEBUG_INTENT_MATCHING) Log.v(TAG, "Specific #" + i + ": " + ai);
3528                N = results.size();
3529                int j;
3530                for (j=specificsPos; j<N; j++) {
3531                    ResolveInfo sri = results.get(j);
3532                    if ((sri.activityInfo.name.equals(comp.getClassName())
3533                            && sri.activityInfo.applicationInfo.packageName.equals(
3534                                    comp.getPackageName()))
3535                        || (action != null && sri.filter.matchAction(action))) {
3536                        results.remove(j);
3537                        if (DEBUG_INTENT_MATCHING) Log.v(
3538                            TAG, "Removing duplicate item from " + j
3539                            + " due to specific " + specificsPos);
3540                        if (ri == null) {
3541                            ri = sri;
3542                        }
3543                        j--;
3544                        N--;
3545                    }
3546                }
3547
3548                // Add this specific item to its proper place.
3549                if (ri == null) {
3550                    ri = new ResolveInfo();
3551                    ri.activityInfo = ai;
3552                }
3553                results.add(specificsPos, ri);
3554                ri.specificIndex = i;
3555                specificsPos++;
3556            }
3557        }
3558
3559        // Now we go through the remaining generic results and remove any
3560        // duplicate actions that are found here.
3561        N = results.size();
3562        for (int i=specificsPos; i<N-1; i++) {
3563            final ResolveInfo rii = results.get(i);
3564            if (rii.filter == null) {
3565                continue;
3566            }
3567
3568            // Iterate over all of the actions of this result's intent
3569            // filter...  typically this should be just one.
3570            final Iterator<String> it = rii.filter.actionsIterator();
3571            if (it == null) {
3572                continue;
3573            }
3574            while (it.hasNext()) {
3575                final String action = it.next();
3576                if (resultsAction != null && resultsAction.equals(action)) {
3577                    // If this action was explicitly requested, then don't
3578                    // remove things that have it.
3579                    continue;
3580                }
3581                for (int j=i+1; j<N; j++) {
3582                    final ResolveInfo rij = results.get(j);
3583                    if (rij.filter != null && rij.filter.hasAction(action)) {
3584                        results.remove(j);
3585                        if (DEBUG_INTENT_MATCHING) Log.v(
3586                            TAG, "Removing duplicate item from " + j
3587                            + " due to action " + action + " at " + i);
3588                        j--;
3589                        N--;
3590                    }
3591                }
3592            }
3593
3594            // If the caller didn't request filter information, drop it now
3595            // so we don't have to marshall/unmarshall it.
3596            if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) {
3597                rii.filter = null;
3598            }
3599        }
3600
3601        // Filter out the caller activity if so requested.
3602        if (caller != null) {
3603            N = results.size();
3604            for (int i=0; i<N; i++) {
3605                ActivityInfo ainfo = results.get(i).activityInfo;
3606                if (caller.getPackageName().equals(ainfo.applicationInfo.packageName)
3607                        && caller.getClassName().equals(ainfo.name)) {
3608                    results.remove(i);
3609                    break;
3610                }
3611            }
3612        }
3613
3614        // If the caller didn't request filter information,
3615        // drop them now so we don't have to
3616        // marshall/unmarshall it.
3617        if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) {
3618            N = results.size();
3619            for (int i=0; i<N; i++) {
3620                results.get(i).filter = null;
3621            }
3622        }
3623
3624        if (DEBUG_INTENT_MATCHING) Log.v(TAG, "Result: " + results);
3625        return results;
3626    }
3627
3628    @Override
3629    public List<ResolveInfo> queryIntentReceivers(Intent intent, String resolvedType, int flags,
3630            int userId) {
3631        if (!sUserManager.exists(userId)) return Collections.emptyList();
3632        ComponentName comp = intent.getComponent();
3633        if (comp == null) {
3634            if (intent.getSelector() != null) {
3635                intent = intent.getSelector();
3636                comp = intent.getComponent();
3637            }
3638        }
3639        if (comp != null) {
3640            List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3641            ActivityInfo ai = getReceiverInfo(comp, flags, userId);
3642            if (ai != null) {
3643                ResolveInfo ri = new ResolveInfo();
3644                ri.activityInfo = ai;
3645                list.add(ri);
3646            }
3647            return list;
3648        }
3649
3650        // reader
3651        synchronized (mPackages) {
3652            String pkgName = intent.getPackage();
3653            if (pkgName == null) {
3654                return mReceivers.queryIntent(intent, resolvedType, flags, userId);
3655            }
3656            final PackageParser.Package pkg = mPackages.get(pkgName);
3657            if (pkg != null) {
3658                return mReceivers.queryIntentForPackage(intent, resolvedType, flags, pkg.receivers,
3659                        userId);
3660            }
3661            return null;
3662        }
3663    }
3664
3665    @Override
3666    public ResolveInfo resolveService(Intent intent, String resolvedType, int flags, int userId) {
3667        List<ResolveInfo> query = queryIntentServices(intent, resolvedType, flags, userId);
3668        if (!sUserManager.exists(userId)) return null;
3669        if (query != null) {
3670            if (query.size() >= 1) {
3671                // If there is more than one service with the same priority,
3672                // just arbitrarily pick the first one.
3673                return query.get(0);
3674            }
3675        }
3676        return null;
3677    }
3678
3679    @Override
3680    public List<ResolveInfo> queryIntentServices(Intent intent, String resolvedType, int flags,
3681            int userId) {
3682        if (!sUserManager.exists(userId)) return Collections.emptyList();
3683        ComponentName comp = intent.getComponent();
3684        if (comp == null) {
3685            if (intent.getSelector() != null) {
3686                intent = intent.getSelector();
3687                comp = intent.getComponent();
3688            }
3689        }
3690        if (comp != null) {
3691            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3692            final ServiceInfo si = getServiceInfo(comp, flags, userId);
3693            if (si != null) {
3694                final ResolveInfo ri = new ResolveInfo();
3695                ri.serviceInfo = si;
3696                list.add(ri);
3697            }
3698            return list;
3699        }
3700
3701        // reader
3702        synchronized (mPackages) {
3703            String pkgName = intent.getPackage();
3704            if (pkgName == null) {
3705                return mServices.queryIntent(intent, resolvedType, flags, userId);
3706            }
3707            final PackageParser.Package pkg = mPackages.get(pkgName);
3708            if (pkg != null) {
3709                return mServices.queryIntentForPackage(intent, resolvedType, flags, pkg.services,
3710                        userId);
3711            }
3712            return null;
3713        }
3714    }
3715
3716    @Override
3717    public List<ResolveInfo> queryIntentContentProviders(
3718            Intent intent, String resolvedType, int flags, int userId) {
3719        if (!sUserManager.exists(userId)) return Collections.emptyList();
3720        ComponentName comp = intent.getComponent();
3721        if (comp == null) {
3722            if (intent.getSelector() != null) {
3723                intent = intent.getSelector();
3724                comp = intent.getComponent();
3725            }
3726        }
3727        if (comp != null) {
3728            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
3729            final ProviderInfo pi = getProviderInfo(comp, flags, userId);
3730            if (pi != null) {
3731                final ResolveInfo ri = new ResolveInfo();
3732                ri.providerInfo = pi;
3733                list.add(ri);
3734            }
3735            return list;
3736        }
3737
3738        // reader
3739        synchronized (mPackages) {
3740            String pkgName = intent.getPackage();
3741            if (pkgName == null) {
3742                return mProviders.queryIntent(intent, resolvedType, flags, userId);
3743            }
3744            final PackageParser.Package pkg = mPackages.get(pkgName);
3745            if (pkg != null) {
3746                return mProviders.queryIntentForPackage(
3747                        intent, resolvedType, flags, pkg.providers, userId);
3748            }
3749            return null;
3750        }
3751    }
3752
3753    @Override
3754    public ParceledListSlice<PackageInfo> getInstalledPackages(int flags, int userId) {
3755        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3756
3757        enforceCrossUserPermission(Binder.getCallingUid(), userId, true, "get installed packages");
3758
3759        // writer
3760        synchronized (mPackages) {
3761            ArrayList<PackageInfo> list;
3762            if (listUninstalled) {
3763                list = new ArrayList<PackageInfo>(mSettings.mPackages.size());
3764                for (PackageSetting ps : mSettings.mPackages.values()) {
3765                    PackageInfo pi;
3766                    if (ps.pkg != null) {
3767                        pi = generatePackageInfo(ps.pkg, flags, userId);
3768                    } else {
3769                        pi = generatePackageInfoFromSettingsLPw(ps.name, flags, userId);
3770                    }
3771                    if (pi != null) {
3772                        list.add(pi);
3773                    }
3774                }
3775            } else {
3776                list = new ArrayList<PackageInfo>(mPackages.size());
3777                for (PackageParser.Package p : mPackages.values()) {
3778                    PackageInfo pi = generatePackageInfo(p, flags, userId);
3779                    if (pi != null) {
3780                        list.add(pi);
3781                    }
3782                }
3783            }
3784
3785            return new ParceledListSlice<PackageInfo>(list);
3786        }
3787    }
3788
3789    private void addPackageHoldingPermissions(ArrayList<PackageInfo> list, PackageSetting ps,
3790            String[] permissions, boolean[] tmp, int flags, int userId) {
3791        int numMatch = 0;
3792        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
3793        for (int i=0; i<permissions.length; i++) {
3794            if (gp.grantedPermissions.contains(permissions[i])) {
3795                tmp[i] = true;
3796                numMatch++;
3797            } else {
3798                tmp[i] = false;
3799            }
3800        }
3801        if (numMatch == 0) {
3802            return;
3803        }
3804        PackageInfo pi;
3805        if (ps.pkg != null) {
3806            pi = generatePackageInfo(ps.pkg, flags, userId);
3807        } else {
3808            pi = generatePackageInfoFromSettingsLPw(ps.name, flags, userId);
3809        }
3810        if ((flags&PackageManager.GET_PERMISSIONS) == 0) {
3811            if (numMatch == permissions.length) {
3812                pi.requestedPermissions = permissions;
3813            } else {
3814                pi.requestedPermissions = new String[numMatch];
3815                numMatch = 0;
3816                for (int i=0; i<permissions.length; i++) {
3817                    if (tmp[i]) {
3818                        pi.requestedPermissions[numMatch] = permissions[i];
3819                        numMatch++;
3820                    }
3821                }
3822            }
3823        }
3824        list.add(pi);
3825    }
3826
3827    @Override
3828    public ParceledListSlice<PackageInfo> getPackagesHoldingPermissions(
3829            String[] permissions, int flags, int userId) {
3830        if (!sUserManager.exists(userId)) return null;
3831        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3832
3833        // writer
3834        synchronized (mPackages) {
3835            ArrayList<PackageInfo> list = new ArrayList<PackageInfo>();
3836            boolean[] tmpBools = new boolean[permissions.length];
3837            if (listUninstalled) {
3838                for (PackageSetting ps : mSettings.mPackages.values()) {
3839                    addPackageHoldingPermissions(list, ps, permissions, tmpBools, flags, userId);
3840                }
3841            } else {
3842                for (PackageParser.Package pkg : mPackages.values()) {
3843                    PackageSetting ps = (PackageSetting)pkg.mExtras;
3844                    if (ps != null) {
3845                        addPackageHoldingPermissions(list, ps, permissions, tmpBools, flags,
3846                                userId);
3847                    }
3848                }
3849            }
3850
3851            return new ParceledListSlice<PackageInfo>(list);
3852        }
3853    }
3854
3855    @Override
3856    public ParceledListSlice<ApplicationInfo> getInstalledApplications(int flags, int userId) {
3857        if (!sUserManager.exists(userId)) return null;
3858        final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
3859
3860        // writer
3861        synchronized (mPackages) {
3862            ArrayList<ApplicationInfo> list;
3863            if (listUninstalled) {
3864                list = new ArrayList<ApplicationInfo>(mSettings.mPackages.size());
3865                for (PackageSetting ps : mSettings.mPackages.values()) {
3866                    ApplicationInfo ai;
3867                    if (ps.pkg != null) {
3868                        ai = PackageParser.generateApplicationInfo(ps.pkg, flags,
3869                                ps.readUserState(userId), userId);
3870                    } else {
3871                        ai = generateApplicationInfoFromSettingsLPw(ps.name, flags, userId);
3872                    }
3873                    if (ai != null) {
3874                        list.add(ai);
3875                    }
3876                }
3877            } else {
3878                list = new ArrayList<ApplicationInfo>(mPackages.size());
3879                for (PackageParser.Package p : mPackages.values()) {
3880                    if (p.mExtras != null) {
3881                        ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags,
3882                                ((PackageSetting)p.mExtras).readUserState(userId), userId);
3883                        if (ai != null) {
3884                            list.add(ai);
3885                        }
3886                    }
3887                }
3888            }
3889
3890            return new ParceledListSlice<ApplicationInfo>(list);
3891        }
3892    }
3893
3894    public List<ApplicationInfo> getPersistentApplications(int flags) {
3895        final ArrayList<ApplicationInfo> finalList = new ArrayList<ApplicationInfo>();
3896
3897        // reader
3898        synchronized (mPackages) {
3899            final Iterator<PackageParser.Package> i = mPackages.values().iterator();
3900            final int userId = UserHandle.getCallingUserId();
3901            while (i.hasNext()) {
3902                final PackageParser.Package p = i.next();
3903                if (p.applicationInfo != null
3904                        && (p.applicationInfo.flags&ApplicationInfo.FLAG_PERSISTENT) != 0
3905                        && (!mSafeMode || isSystemApp(p))) {
3906                    PackageSetting ps = mSettings.mPackages.get(p.packageName);
3907                    if (ps != null) {
3908                        ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags,
3909                                ps.readUserState(userId), userId);
3910                        if (ai != null) {
3911                            finalList.add(ai);
3912                        }
3913                    }
3914                }
3915            }
3916        }
3917
3918        return finalList;
3919    }
3920
3921    @Override
3922    public ProviderInfo resolveContentProvider(String name, int flags, int userId) {
3923        if (!sUserManager.exists(userId)) return null;
3924        // reader
3925        synchronized (mPackages) {
3926            final PackageParser.Provider provider = mProvidersByAuthority.get(name);
3927            PackageSetting ps = provider != null
3928                    ? mSettings.mPackages.get(provider.owner.packageName)
3929                    : null;
3930            return ps != null
3931                    && mSettings.isEnabledLPr(provider.info, flags, userId)
3932                    && (!mSafeMode || (provider.info.applicationInfo.flags
3933                            &ApplicationInfo.FLAG_SYSTEM) != 0)
3934                    ? PackageParser.generateProviderInfo(provider, flags,
3935                            ps.readUserState(userId), userId)
3936                    : null;
3937        }
3938    }
3939
3940    /**
3941     * @deprecated
3942     */
3943    @Deprecated
3944    public void querySyncProviders(List<String> outNames, List<ProviderInfo> outInfo) {
3945        // reader
3946        synchronized (mPackages) {
3947            final Iterator<Map.Entry<String, PackageParser.Provider>> i = mProvidersByAuthority
3948                    .entrySet().iterator();
3949            final int userId = UserHandle.getCallingUserId();
3950            while (i.hasNext()) {
3951                Map.Entry<String, PackageParser.Provider> entry = i.next();
3952                PackageParser.Provider p = entry.getValue();
3953                PackageSetting ps = mSettings.mPackages.get(p.owner.packageName);
3954
3955                if (ps != null && p.syncable
3956                        && (!mSafeMode || (p.info.applicationInfo.flags
3957                                &ApplicationInfo.FLAG_SYSTEM) != 0)) {
3958                    ProviderInfo info = PackageParser.generateProviderInfo(p, 0,
3959                            ps.readUserState(userId), userId);
3960                    if (info != null) {
3961                        outNames.add(entry.getKey());
3962                        outInfo.add(info);
3963                    }
3964                }
3965            }
3966        }
3967    }
3968
3969    @Override
3970    public List<ProviderInfo> queryContentProviders(String processName,
3971            int uid, int flags) {
3972        ArrayList<ProviderInfo> finalList = null;
3973        // reader
3974        synchronized (mPackages) {
3975            final Iterator<PackageParser.Provider> i = mProviders.mProviders.values().iterator();
3976            final int userId = processName != null ?
3977                    UserHandle.getUserId(uid) : UserHandle.getCallingUserId();
3978            while (i.hasNext()) {
3979                final PackageParser.Provider p = i.next();
3980                PackageSetting ps = mSettings.mPackages.get(p.owner.packageName);
3981                if (ps != null && p.info.authority != null
3982                        && (processName == null
3983                                || (p.info.processName.equals(processName)
3984                                        && UserHandle.isSameApp(p.info.applicationInfo.uid, uid)))
3985                        && mSettings.isEnabledLPr(p.info, flags, userId)
3986                        && (!mSafeMode
3987                                || (p.info.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0)) {
3988                    if (finalList == null) {
3989                        finalList = new ArrayList<ProviderInfo>(3);
3990                    }
3991                    ProviderInfo info = PackageParser.generateProviderInfo(p, flags,
3992                            ps.readUserState(userId), userId);
3993                    if (info != null) {
3994                        finalList.add(info);
3995                    }
3996                }
3997            }
3998        }
3999
4000        if (finalList != null) {
4001            Collections.sort(finalList, mProviderInitOrderSorter);
4002        }
4003
4004        return finalList;
4005    }
4006
4007    @Override
4008    public InstrumentationInfo getInstrumentationInfo(ComponentName name,
4009            int flags) {
4010        // reader
4011        synchronized (mPackages) {
4012            final PackageParser.Instrumentation i = mInstrumentation.get(name);
4013            return PackageParser.generateInstrumentationInfo(i, flags);
4014        }
4015    }
4016
4017    @Override
4018    public List<InstrumentationInfo> queryInstrumentation(String targetPackage,
4019            int flags) {
4020        ArrayList<InstrumentationInfo> finalList =
4021            new ArrayList<InstrumentationInfo>();
4022
4023        // reader
4024        synchronized (mPackages) {
4025            final Iterator<PackageParser.Instrumentation> i = mInstrumentation.values().iterator();
4026            while (i.hasNext()) {
4027                final PackageParser.Instrumentation p = i.next();
4028                if (targetPackage == null
4029                        || targetPackage.equals(p.info.targetPackage)) {
4030                    InstrumentationInfo ii = PackageParser.generateInstrumentationInfo(p,
4031                            flags);
4032                    if (ii != null) {
4033                        finalList.add(ii);
4034                    }
4035                }
4036            }
4037        }
4038
4039        return finalList;
4040    }
4041
4042    private void createIdmapsForPackageLI(PackageParser.Package pkg) {
4043        HashMap<String, PackageParser.Package> overlays = mOverlays.get(pkg.packageName);
4044        if (overlays == null) {
4045            Slog.w(TAG, "Unable to create idmap for " + pkg.packageName + ": no overlay packages");
4046            return;
4047        }
4048        for (PackageParser.Package opkg : overlays.values()) {
4049            // Not much to do if idmap fails: we already logged the error
4050            // and we certainly don't want to abort installation of pkg simply
4051            // because an overlay didn't fit properly. For these reasons,
4052            // ignore the return value of createIdmapForPackagePairLI.
4053            createIdmapForPackagePairLI(pkg, opkg);
4054        }
4055    }
4056
4057    private boolean createIdmapForPackagePairLI(PackageParser.Package pkg,
4058            PackageParser.Package opkg) {
4059        if (!opkg.mTrustedOverlay) {
4060            Slog.w(TAG, "Skipping target and overlay pair " + pkg.baseCodePath + " and " +
4061                    opkg.baseCodePath + ": overlay not trusted");
4062            return false;
4063        }
4064        HashMap<String, PackageParser.Package> overlaySet = mOverlays.get(pkg.packageName);
4065        if (overlaySet == null) {
4066            Slog.e(TAG, "was about to create idmap for " + pkg.baseCodePath + " and " +
4067                    opkg.baseCodePath + " but target package has no known overlays");
4068            return false;
4069        }
4070        final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
4071        // TODO: generate idmap for split APKs
4072        if (mInstaller.idmap(pkg.baseCodePath, opkg.baseCodePath, sharedGid) != 0) {
4073            Slog.e(TAG, "Failed to generate idmap for " + pkg.baseCodePath + " and "
4074                    + opkg.baseCodePath);
4075            return false;
4076        }
4077        PackageParser.Package[] overlayArray =
4078            overlaySet.values().toArray(new PackageParser.Package[0]);
4079        Comparator<PackageParser.Package> cmp = new Comparator<PackageParser.Package>() {
4080            public int compare(PackageParser.Package p1, PackageParser.Package p2) {
4081                return p1.mOverlayPriority - p2.mOverlayPriority;
4082            }
4083        };
4084        Arrays.sort(overlayArray, cmp);
4085
4086        pkg.applicationInfo.resourceDirs = new String[overlayArray.length];
4087        int i = 0;
4088        for (PackageParser.Package p : overlayArray) {
4089            pkg.applicationInfo.resourceDirs[i++] = p.baseCodePath;
4090        }
4091        return true;
4092    }
4093
4094    private void scanDirLI(File dir, int flags, int scanMode, long currentTime) {
4095        final File[] files = dir.listFiles();
4096        if (ArrayUtils.isEmpty(files)) {
4097            Log.d(TAG, "No files in app dir " + dir);
4098            return;
4099        }
4100
4101        if (DEBUG_PACKAGE_SCANNING) {
4102            Log.d(TAG, "Scanning app dir " + dir + " scanMode=" + scanMode
4103                    + " flags=0x" + Integer.toHexString(flags));
4104        }
4105
4106        for (File file : files) {
4107            final boolean isPackage = isApkFile(file) || file.isDirectory();
4108            if (!isPackage) {
4109                // Ignore entries which are not apk's
4110                continue;
4111            }
4112            try {
4113                scanPackageLI(file, flags | PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime,
4114                        null, null);
4115            } catch (PackageManagerException e) {
4116                Slog.w(TAG, "Failed to parse " + file + ": " + e.getMessage());
4117
4118                // Don't mess around with apps in system partition.
4119                if ((flags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
4120                        e.error == PackageManager.INSTALL_FAILED_INVALID_APK) {
4121                    // Delete the apk
4122                    Slog.w(TAG, "Cleaning up failed install of " + file);
4123                    file.delete();
4124                }
4125            }
4126        }
4127    }
4128
4129    private static File getSettingsProblemFile() {
4130        File dataDir = Environment.getDataDirectory();
4131        File systemDir = new File(dataDir, "system");
4132        File fname = new File(systemDir, "uiderrors.txt");
4133        return fname;
4134    }
4135
4136    static void reportSettingsProblem(int priority, String msg) {
4137        try {
4138            File fname = getSettingsProblemFile();
4139            FileOutputStream out = new FileOutputStream(fname, true);
4140            PrintWriter pw = new FastPrintWriter(out);
4141            SimpleDateFormat formatter = new SimpleDateFormat();
4142            String dateString = formatter.format(new Date(System.currentTimeMillis()));
4143            pw.println(dateString + ": " + msg);
4144            pw.close();
4145            FileUtils.setPermissions(
4146                    fname.toString(),
4147                    FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IROTH,
4148                    -1, -1);
4149        } catch (java.io.IOException e) {
4150        }
4151        Slog.println(priority, TAG, msg);
4152    }
4153
4154    private void collectCertificatesLI(PackageParser pp, PackageSetting ps,
4155            PackageParser.Package pkg, File srcFile, int parseFlags)
4156            throws PackageManagerException {
4157        if (ps != null
4158                && ps.codePath.equals(srcFile)
4159                && ps.timeStamp == srcFile.lastModified()
4160                && !isCompatSignatureUpdateNeeded(pkg)) {
4161            long mSigningKeySetId = ps.keySetData.getProperSigningKeySet();
4162            if (ps.signatures.mSignatures != null
4163                    && ps.signatures.mSignatures.length != 0
4164                    && mSigningKeySetId != PackageKeySetData.KEYSET_UNASSIGNED) {
4165                // Optimization: reuse the existing cached certificates
4166                // if the package appears to be unchanged.
4167                pkg.mSignatures = ps.signatures.mSignatures;
4168                KeySetManagerService ksms = mSettings.mKeySetManagerService;
4169                synchronized (mPackages) {
4170                    pkg.mSigningKeys = ksms.getPublicKeysFromKeySetLPr(mSigningKeySetId);
4171                }
4172                return;
4173            }
4174
4175            Slog.w(TAG, "PackageSetting for " + ps.name
4176                    + " is missing signatures.  Collecting certs again to recover them.");
4177        } else {
4178            Log.i(TAG, srcFile.toString() + " changed; collecting certs");
4179        }
4180
4181        try {
4182            pp.collectCertificates(pkg, parseFlags);
4183            pp.collectManifestDigest(pkg);
4184        } catch (PackageParserException e) {
4185            throw new PackageManagerException(e.error, "Failed to collect certificates for "
4186                    + pkg.packageName + ": " + e.getMessage());
4187        }
4188    }
4189
4190    /*
4191     *  Scan a package and return the newly parsed package.
4192     *  Returns null in case of errors and the error code is stored in mLastScanError
4193     */
4194    private PackageParser.Package scanPackageLI(File scanFile, int parseFlags, int scanMode,
4195            long currentTime, UserHandle user, String abiOverride) throws PackageManagerException {
4196        if (DEBUG_INSTALL) Slog.d(TAG, "Parsing: " + scanFile);
4197        parseFlags |= mDefParseFlags;
4198        PackageParser pp = new PackageParser();
4199        pp.setSeparateProcesses(mSeparateProcesses);
4200        pp.setOnlyCoreApps(mOnlyCore);
4201        pp.setDisplayMetrics(mMetrics);
4202
4203        if ((scanMode & SCAN_TRUSTED_OVERLAY) != 0) {
4204            parseFlags |= PackageParser.PARSE_TRUSTED_OVERLAY;
4205        }
4206
4207        final PackageParser.Package pkg;
4208        try {
4209            pkg = pp.parsePackage(scanFile, parseFlags);
4210        } catch (PackageParserException e) {
4211            throw new PackageManagerException(e.error,
4212                    "Failed to scan " + scanFile + ": " + e.getMessage());
4213        }
4214
4215        PackageSetting ps = null;
4216        PackageSetting updatedPkg;
4217        // reader
4218        synchronized (mPackages) {
4219            // Look to see if we already know about this package.
4220            String oldName = mSettings.mRenamedPackages.get(pkg.packageName);
4221            if (pkg.mOriginalPackages != null && pkg.mOriginalPackages.contains(oldName)) {
4222                // This package has been renamed to its original name.  Let's
4223                // use that.
4224                ps = mSettings.peekPackageLPr(oldName);
4225            }
4226            // If there was no original package, see one for the real package name.
4227            if (ps == null) {
4228                ps = mSettings.peekPackageLPr(pkg.packageName);
4229            }
4230            // Check to see if this package could be hiding/updating a system
4231            // package.  Must look for it either under the original or real
4232            // package name depending on our state.
4233            updatedPkg = mSettings.getDisabledSystemPkgLPr(ps != null ? ps.name : pkg.packageName);
4234            if (DEBUG_INSTALL && updatedPkg != null) Slog.d(TAG, "updatedPkg = " + updatedPkg);
4235        }
4236        boolean updatedPkgBetter = false;
4237        // First check if this is a system package that may involve an update
4238        if (updatedPkg != null && (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
4239            if (ps != null && !ps.codePath.equals(scanFile)) {
4240                // The path has changed from what was last scanned...  check the
4241                // version of the new path against what we have stored to determine
4242                // what to do.
4243                if (DEBUG_INSTALL) Slog.d(TAG, "Path changing from " + ps.codePath);
4244                if (pkg.mVersionCode < ps.versionCode) {
4245                    // The system package has been updated and the code path does not match
4246                    // Ignore entry. Skip it.
4247                    Log.i(TAG, "Package " + ps.name + " at " + scanFile
4248                            + " ignored: updated version " + ps.versionCode
4249                            + " better than this " + pkg.mVersionCode);
4250                    if (!updatedPkg.codePath.equals(scanFile)) {
4251                        Slog.w(PackageManagerService.TAG, "Code path for hidden system pkg : "
4252                                + ps.name + " changing from " + updatedPkg.codePathString
4253                                + " to " + scanFile);
4254                        updatedPkg.codePath = scanFile;
4255                        updatedPkg.codePathString = scanFile.toString();
4256                        // This is the point at which we know that the system-disk APK
4257                        // for this package has moved during a reboot (e.g. due to an OTA),
4258                        // so we need to reevaluate it for privilege policy.
4259                        if (locationIsPrivileged(scanFile)) {
4260                            updatedPkg.pkgFlags |= ApplicationInfo.FLAG_PRIVILEGED;
4261                        }
4262                    }
4263                    updatedPkg.pkg = pkg;
4264                    throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE, null);
4265                } else {
4266                    // The current app on the system partition is better than
4267                    // what we have updated to on the data partition; switch
4268                    // back to the system partition version.
4269                    // At this point, its safely assumed that package installation for
4270                    // apps in system partition will go through. If not there won't be a working
4271                    // version of the app
4272                    // writer
4273                    synchronized (mPackages) {
4274                        // Just remove the loaded entries from package lists.
4275                        mPackages.remove(ps.name);
4276                    }
4277                    Slog.w(TAG, "Package " + ps.name + " at " + scanFile
4278                            + "reverting from " + ps.codePathString
4279                            + ": new version " + pkg.mVersionCode
4280                            + " better than installed " + ps.versionCode);
4281
4282                    InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
4283                            ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
4284                            getAppDexInstructionSets(ps), isMultiArch(ps));
4285                    synchronized (mInstallLock) {
4286                        args.cleanUpResourcesLI();
4287                    }
4288                    synchronized (mPackages) {
4289                        mSettings.enableSystemPackageLPw(ps.name);
4290                    }
4291                    updatedPkgBetter = true;
4292                }
4293            }
4294        }
4295
4296        if (updatedPkg != null) {
4297            // An updated system app will not have the PARSE_IS_SYSTEM flag set
4298            // initially
4299            parseFlags |= PackageParser.PARSE_IS_SYSTEM;
4300
4301            // An updated privileged app will not have the PARSE_IS_PRIVILEGED
4302            // flag set initially
4303            if ((updatedPkg.pkgFlags & ApplicationInfo.FLAG_PRIVILEGED) != 0) {
4304                parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
4305            }
4306        }
4307
4308        // Verify certificates against what was last scanned
4309        collectCertificatesLI(pp, ps, pkg, scanFile, parseFlags);
4310
4311        /*
4312         * A new system app appeared, but we already had a non-system one of the
4313         * same name installed earlier.
4314         */
4315        boolean shouldHideSystemApp = false;
4316        if (updatedPkg == null && ps != null
4317                && (parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) != 0 && !isSystemApp(ps)) {
4318            /*
4319             * Check to make sure the signatures match first. If they don't,
4320             * wipe the installed application and its data.
4321             */
4322            if (compareSignatures(ps.signatures.mSignatures, pkg.mSignatures)
4323                    != PackageManager.SIGNATURE_MATCH) {
4324                if (DEBUG_INSTALL) Slog.d(TAG, "Signature mismatch!");
4325                deletePackageLI(pkg.packageName, null, true, null, null, 0, null, false);
4326                ps = null;
4327            } else {
4328                /*
4329                 * If the newly-added system app is an older version than the
4330                 * already installed version, hide it. It will be scanned later
4331                 * and re-added like an update.
4332                 */
4333                if (pkg.mVersionCode < ps.versionCode) {
4334                    shouldHideSystemApp = true;
4335                } else {
4336                    /*
4337                     * The newly found system app is a newer version that the
4338                     * one previously installed. Simply remove the
4339                     * already-installed application and replace it with our own
4340                     * while keeping the application data.
4341                     */
4342                    Slog.w(TAG, "Package " + ps.name + " at " + scanFile + "reverting from "
4343                            + ps.codePathString + ": new version " + pkg.mVersionCode
4344                            + " better than installed " + ps.versionCode);
4345                    InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
4346                            ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
4347                            getAppDexInstructionSets(ps), isMultiArch(ps));
4348                    synchronized (mInstallLock) {
4349                        args.cleanUpResourcesLI();
4350                    }
4351                }
4352            }
4353        }
4354
4355        // The apk is forward locked (not public) if its code and resources
4356        // are kept in different files. (except for app in either system or
4357        // vendor path).
4358        // TODO grab this value from PackageSettings
4359        if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
4360            if (ps != null && !ps.codePath.equals(ps.resourcePath)) {
4361                parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
4362            }
4363        }
4364
4365        // TODO: extend to support forward-locked splits
4366        String resourcePath = null;
4367        String baseResourcePath = null;
4368        if ((parseFlags & PackageParser.PARSE_FORWARD_LOCK) != 0 && !updatedPkgBetter) {
4369            if (ps != null && ps.resourcePathString != null) {
4370                resourcePath = ps.resourcePathString;
4371                baseResourcePath = ps.resourcePathString;
4372            } else {
4373                // Should not happen at all. Just log an error.
4374                Slog.e(TAG, "Resource path not set for pkg : " + pkg.packageName);
4375            }
4376        } else {
4377            resourcePath = pkg.codePath;
4378            baseResourcePath = pkg.baseCodePath;
4379        }
4380
4381        // Set application objects path explicitly.
4382        pkg.applicationInfo.setCodePath(pkg.codePath);
4383        pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
4384        pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
4385        pkg.applicationInfo.setResourcePath(resourcePath);
4386        pkg.applicationInfo.setBaseResourcePath(baseResourcePath);
4387        pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
4388
4389        // Note that we invoke the following method only if we are about to unpack an application
4390        PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanMode
4391                | SCAN_UPDATE_SIGNATURE, currentTime, user, abiOverride);
4392
4393        /*
4394         * If the system app should be overridden by a previously installed
4395         * data, hide the system app now and let the /data/app scan pick it up
4396         * again.
4397         */
4398        if (shouldHideSystemApp) {
4399            synchronized (mPackages) {
4400                /*
4401                 * We have to grant systems permissions before we hide, because
4402                 * grantPermissions will assume the package update is trying to
4403                 * expand its permissions.
4404                 */
4405                grantPermissionsLPw(pkg, true);
4406                mSettings.disableSystemPackageLPw(pkg.packageName);
4407            }
4408        }
4409
4410        return scannedPkg;
4411    }
4412
4413    private static String fixProcessName(String defProcessName,
4414            String processName, int uid) {
4415        if (processName == null) {
4416            return defProcessName;
4417        }
4418        return processName;
4419    }
4420
4421    private void verifySignaturesLP(PackageSetting pkgSetting, PackageParser.Package pkg)
4422            throws PackageManagerException {
4423        if (pkgSetting.signatures.mSignatures != null) {
4424            // Already existing package. Make sure signatures match
4425            boolean match = compareSignatures(pkgSetting.signatures.mSignatures, pkg.mSignatures)
4426                    == PackageManager.SIGNATURE_MATCH;
4427            if (!match) {
4428                match = compareSignaturesCompat(pkgSetting.signatures, pkg)
4429                        == PackageManager.SIGNATURE_MATCH;
4430            }
4431            if (!match) {
4432                throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
4433                        + pkg.packageName + " signatures do not match the "
4434                        + "previously installed version; ignoring!");
4435            }
4436        }
4437
4438        // Check for shared user signatures
4439        if (pkgSetting.sharedUser != null && pkgSetting.sharedUser.signatures.mSignatures != null) {
4440            // Already existing package. Make sure signatures match
4441            boolean match = compareSignatures(pkgSetting.sharedUser.signatures.mSignatures,
4442                    pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;
4443            if (!match) {
4444                match = compareSignaturesCompat(pkgSetting.sharedUser.signatures, pkg)
4445                        == PackageManager.SIGNATURE_MATCH;
4446            }
4447            if (!match) {
4448                throw new PackageManagerException(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
4449                        "Package " + pkg.packageName
4450                        + " has no signatures that match those in shared user "
4451                        + pkgSetting.sharedUser.name + "; ignoring!");
4452            }
4453        }
4454    }
4455
4456    /**
4457     * Enforces that only the system UID or root's UID can call a method exposed
4458     * via Binder.
4459     *
4460     * @param message used as message if SecurityException is thrown
4461     * @throws SecurityException if the caller is not system or root
4462     */
4463    private static final void enforceSystemOrRoot(String message) {
4464        final int uid = Binder.getCallingUid();
4465        if (uid != Process.SYSTEM_UID && uid != 0) {
4466            throw new SecurityException(message);
4467        }
4468    }
4469
4470    @Override
4471    public void performBootDexOpt() {
4472        enforceSystemOrRoot("Only the system can request dexopt be performed");
4473
4474        final HashSet<PackageParser.Package> pkgs;
4475        synchronized (mPackages) {
4476            pkgs = mDeferredDexOpt;
4477            mDeferredDexOpt = null;
4478        }
4479
4480        if (pkgs != null) {
4481            // Filter out packages that aren't recently used.
4482            //
4483            // The exception is first boot of a non-eng device, which
4484            // should do a full dexopt.
4485            boolean eng = "eng".equals(SystemProperties.get("ro.build.type"));
4486            if (eng || (!isFirstBoot() && mPackageUsage.isHistoricalPackageUsageAvailable())) {
4487                // TODO: add a property to control this?
4488                long dexOptLRUThresholdInMinutes;
4489                if (eng) {
4490                    dexOptLRUThresholdInMinutes = 30; // only last 30 minutes of apps for eng builds.
4491                } else {
4492                    dexOptLRUThresholdInMinutes = 7 * 24 * 60; // apps used in the 7 days for users.
4493                }
4494                long dexOptLRUThresholdInMills = dexOptLRUThresholdInMinutes * 60 * 1000;
4495
4496                int total = pkgs.size();
4497                int skipped = 0;
4498                long now = System.currentTimeMillis();
4499                for (Iterator<PackageParser.Package> i = pkgs.iterator(); i.hasNext();) {
4500                    PackageParser.Package pkg = i.next();
4501                    long then = pkg.mLastPackageUsageTimeInMills;
4502                    if (then + dexOptLRUThresholdInMills < now) {
4503                        if (DEBUG_DEXOPT) {
4504                            Log.i(TAG, "Skipping dexopt of " + pkg.packageName + " last resumed: " +
4505                                  ((then == 0) ? "never" : new Date(then)));
4506                        }
4507                        i.remove();
4508                        skipped++;
4509                    }
4510                }
4511                if (DEBUG_DEXOPT) {
4512                    Log.i(TAG, "Skipped optimizing " + skipped + " of " + total);
4513                }
4514            }
4515
4516            int i = 0;
4517            for (PackageParser.Package pkg : pkgs) {
4518                i++;
4519                if (DEBUG_DEXOPT) {
4520                    Log.i(TAG, "Optimizing app " + i + " of " + pkgs.size()
4521                          + ": " + pkg.packageName);
4522                }
4523                if (!isFirstBoot()) {
4524                    try {
4525                        ActivityManagerNative.getDefault().showBootMessage(
4526                                mContext.getResources().getString(
4527                                        R.string.android_upgrading_apk,
4528                                        i, pkgs.size()), true);
4529                    } catch (RemoteException e) {
4530                    }
4531                }
4532                PackageParser.Package p = pkg;
4533                synchronized (mInstallLock) {
4534                    if (p.mDexOptNeeded) {
4535                        performDexOptLI(p, false /* force dex */, false /* defer */,
4536                                true /* include dependencies */);
4537                    }
4538                }
4539            }
4540        }
4541    }
4542
4543    @Override
4544    public boolean performDexOpt(String packageName) {
4545        enforceSystemOrRoot("Only the system can request dexopt be performed");
4546        return performDexOpt(packageName, true);
4547    }
4548
4549    public boolean performDexOpt(String packageName, boolean updateUsage) {
4550
4551        PackageParser.Package p;
4552        synchronized (mPackages) {
4553            p = mPackages.get(packageName);
4554            if (p == null) {
4555                return false;
4556            }
4557            if (updateUsage) {
4558                p.mLastPackageUsageTimeInMills = System.currentTimeMillis();
4559            }
4560            mPackageUsage.write(false);
4561            if (!p.mDexOptNeeded) {
4562                return false;
4563            }
4564        }
4565
4566        synchronized (mInstallLock) {
4567            return performDexOptLI(p, false /* force dex */, false /* defer */,
4568                    true /* include dependencies */) == DEX_OPT_PERFORMED;
4569        }
4570    }
4571
4572    public HashSet<String> getPackagesThatNeedDexOpt() {
4573        HashSet<String> pkgs = null;
4574        synchronized (mPackages) {
4575            for (PackageParser.Package p : mPackages.values()) {
4576                if (DEBUG_DEXOPT) {
4577                    Log.i(TAG, p.packageName + " mDexOptNeeded=" + p.mDexOptNeeded);
4578                }
4579                if (!p.mDexOptNeeded) {
4580                    continue;
4581                }
4582                if (pkgs == null) {
4583                    pkgs = new HashSet<String>();
4584                }
4585                pkgs.add(p.packageName);
4586            }
4587        }
4588        return pkgs;
4589    }
4590
4591    public void shutdown() {
4592        mPackageUsage.write(true);
4593    }
4594
4595    private void performDexOptLibsLI(ArrayList<String> libs, String[] instructionSets,
4596             boolean forceDex, boolean defer, HashSet<String> done) {
4597        for (int i=0; i<libs.size(); i++) {
4598            PackageParser.Package libPkg;
4599            String libName;
4600            synchronized (mPackages) {
4601                libName = libs.get(i);
4602                SharedLibraryEntry lib = mSharedLibraries.get(libName);
4603                if (lib != null && lib.apk != null) {
4604                    libPkg = mPackages.get(lib.apk);
4605                } else {
4606                    libPkg = null;
4607                }
4608            }
4609            if (libPkg != null && !done.contains(libName)) {
4610                performDexOptLI(libPkg, instructionSets, forceDex, defer, done);
4611            }
4612        }
4613    }
4614
4615    static final int DEX_OPT_SKIPPED = 0;
4616    static final int DEX_OPT_PERFORMED = 1;
4617    static final int DEX_OPT_DEFERRED = 2;
4618    static final int DEX_OPT_FAILED = -1;
4619
4620    private int performDexOptLI(PackageParser.Package pkg, String[] targetInstructionSets,
4621            boolean forceDex, boolean defer, HashSet<String> done) {
4622        final String[] instructionSets = targetInstructionSets != null ?
4623                targetInstructionSets : getAppDexInstructionSets(pkg.applicationInfo);
4624
4625        if (done != null) {
4626            done.add(pkg.packageName);
4627            if (pkg.usesLibraries != null) {
4628                performDexOptLibsLI(pkg.usesLibraries, instructionSets, forceDex, defer, done);
4629            }
4630            if (pkg.usesOptionalLibraries != null) {
4631                performDexOptLibsLI(pkg.usesOptionalLibraries, instructionSets, forceDex, defer, done);
4632            }
4633        }
4634
4635        if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_HAS_CODE) == 0) {
4636            return DEX_OPT_SKIPPED;
4637        }
4638
4639        final Collection<String> paths = pkg.getAllCodePaths();
4640        boolean performedDexOpt = false;
4641        // There are three basic cases here:
4642        // 1.) we need to dexopt, either because we are forced or it is needed
4643        // 2.) we are defering a needed dexopt
4644        // 3.) we are skipping an unneeded dexopt
4645        for (String path : paths) {
4646            for (String instructionSet : instructionSets) {
4647                try {
4648                    final boolean isDexOptNeeded = DexFile.isDexOptNeededInternal(path,
4649                            pkg.packageName, instructionSet, defer);
4650                    if (forceDex || (!defer && isDexOptNeeded)) {
4651                        Log.i(TAG, "Running dexopt on: " + pkg.applicationInfo.packageName + " isa=" + instructionSet);
4652                        final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
4653                        final int ret = mInstaller.dexopt(path, sharedGid, !isForwardLocked(pkg),
4654                                pkg.packageName, instructionSet);
4655
4656                        if (ret < 0) {
4657                            // Don't bother running dexopt again if we failed, it will probably
4658                            // just result in an error again. Also, don't bother dexopting for other
4659                            // paths & ISAs.
4660                            pkg.mDexOptNeeded = false;
4661                            return DEX_OPT_FAILED;
4662                        } else {
4663                            performedDexOpt = true;
4664                        }
4665                    }
4666
4667                    // We're deciding to defer a needed dexopt. Don't bother dexopting for other
4668                    // paths and instruction sets. We'll deal with them all together when we process
4669                    // our list of deferred dexopts.
4670                    if (defer && isDexOptNeeded) {
4671                        if (mDeferredDexOpt == null) {
4672                            mDeferredDexOpt = new HashSet<PackageParser.Package>();
4673                        }
4674                        mDeferredDexOpt.add(pkg);
4675                        return DEX_OPT_DEFERRED;
4676                    }
4677                } catch (FileNotFoundException e) {
4678                    Slog.w(TAG, "Apk not found for dexopt: " + path);
4679                    return DEX_OPT_FAILED;
4680                } catch (IOException e) {
4681                    Slog.w(TAG, "IOException reading apk: " + path, e);
4682                    return DEX_OPT_FAILED;
4683                } catch (StaleDexCacheError e) {
4684                    Slog.w(TAG, "StaleDexCacheError when reading apk: " + path, e);
4685                    return DEX_OPT_FAILED;
4686                } catch (Exception e) {
4687                    Slog.w(TAG, "Exception when doing dexopt : ", e);
4688                    return DEX_OPT_FAILED;
4689                }
4690            }
4691        }
4692
4693        // If we've gotten here, we're sure that no error occurred and that we haven't
4694        // deferred dex-opt. We've either dex-opted one more paths or instruction sets or
4695        // we've skipped all of them because they are up to date. In both cases this
4696        // package doesn't need dexopt any longer.
4697        pkg.mDexOptNeeded = false;
4698        return performedDexOpt ? DEX_OPT_PERFORMED : DEX_OPT_SKIPPED;
4699    }
4700
4701    private static String[] getAppDexInstructionSets(ApplicationInfo info) {
4702        if (info.primaryCpuAbi != null) {
4703            if (info.secondaryCpuAbi != null) {
4704                return new String[] {
4705                        VMRuntime.getInstructionSet(info.primaryCpuAbi),
4706                        VMRuntime.getInstructionSet(info.secondaryCpuAbi) };
4707            } else {
4708                return new String[] {
4709                        VMRuntime.getInstructionSet(info.primaryCpuAbi) };
4710            }
4711        }
4712
4713        return new String[] { getPreferredInstructionSet() };
4714    }
4715
4716    private static String[] getAppDexInstructionSets(PackageSetting ps) {
4717        if (ps.primaryCpuAbiString != null) {
4718            if (ps.secondaryCpuAbiString != null) {
4719                return new String[] {
4720                        VMRuntime.getInstructionSet(ps.primaryCpuAbiString),
4721                        VMRuntime.getInstructionSet(ps.secondaryCpuAbiString) };
4722            } else {
4723                return new String[] {
4724                        VMRuntime.getInstructionSet(ps.primaryCpuAbiString) };
4725            }
4726        }
4727
4728        return new String[] { getPreferredInstructionSet() };
4729    }
4730
4731    private static String getPreferredInstructionSet() {
4732        if (sPreferredInstructionSet == null) {
4733            sPreferredInstructionSet = VMRuntime.getInstructionSet(Build.SUPPORTED_ABIS[0]);
4734        }
4735
4736        return sPreferredInstructionSet;
4737    }
4738
4739    private static List<String> getAllInstructionSets() {
4740        final String[] allAbis = Build.SUPPORTED_ABIS;
4741        final List<String> allInstructionSets = new ArrayList<String>(allAbis.length);
4742
4743        for (String abi : allAbis) {
4744            final String instructionSet = VMRuntime.getInstructionSet(abi);
4745            if (!allInstructionSets.contains(instructionSet)) {
4746                allInstructionSets.add(instructionSet);
4747            }
4748        }
4749
4750        return allInstructionSets;
4751    }
4752
4753    private int performDexOptLI(PackageParser.Package pkg, boolean forceDex, boolean defer,
4754            boolean inclDependencies) {
4755        HashSet<String> done;
4756        if (inclDependencies && (pkg.usesLibraries != null || pkg.usesOptionalLibraries != null)) {
4757            done = new HashSet<String>();
4758            done.add(pkg.packageName);
4759        } else {
4760            done = null;
4761        }
4762        return performDexOptLI(pkg, null /* target instruction sets */,  forceDex, defer, done);
4763    }
4764
4765    private boolean verifyPackageUpdateLPr(PackageSetting oldPkg, PackageParser.Package newPkg) {
4766        if ((oldPkg.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0) {
4767            Slog.w(TAG, "Unable to update from " + oldPkg.name
4768                    + " to " + newPkg.packageName
4769                    + ": old package not in system partition");
4770            return false;
4771        } else if (mPackages.get(oldPkg.name) != null) {
4772            Slog.w(TAG, "Unable to update from " + oldPkg.name
4773                    + " to " + newPkg.packageName
4774                    + ": old package still exists");
4775            return false;
4776        }
4777        return true;
4778    }
4779
4780    File getDataPathForUser(int userId) {
4781        return new File(mUserAppDataDir.getAbsolutePath() + File.separator + userId);
4782    }
4783
4784    private File getDataPathForPackage(String packageName, int userId) {
4785        /*
4786         * Until we fully support multiple users, return the directory we
4787         * previously would have. The PackageManagerTests will need to be
4788         * revised when this is changed back..
4789         */
4790        if (userId == 0) {
4791            return new File(mAppDataDir, packageName);
4792        } else {
4793            return new File(mUserAppDataDir.getAbsolutePath() + File.separator + userId
4794                + File.separator + packageName);
4795        }
4796    }
4797
4798    private int createDataDirsLI(String packageName, int uid, String seinfo) {
4799        int[] users = sUserManager.getUserIds();
4800        int res = mInstaller.install(packageName, uid, uid, seinfo);
4801        if (res < 0) {
4802            return res;
4803        }
4804        for (int user : users) {
4805            if (user != 0) {
4806                res = mInstaller.createUserData(packageName,
4807                        UserHandle.getUid(user, uid), user, seinfo);
4808                if (res < 0) {
4809                    return res;
4810                }
4811            }
4812        }
4813        return res;
4814    }
4815
4816    private int removeDataDirsLI(String packageName) {
4817        int[] users = sUserManager.getUserIds();
4818        int res = 0;
4819        for (int user : users) {
4820            int resInner = mInstaller.remove(packageName, user);
4821            if (resInner < 0) {
4822                res = resInner;
4823            }
4824        }
4825
4826        return res;
4827    }
4828
4829    private void addSharedLibraryLPw(ArraySet<String> usesLibraryFiles, SharedLibraryEntry file,
4830            PackageParser.Package changingLib) {
4831        if (file.path != null) {
4832            usesLibraryFiles.add(file.path);
4833            return;
4834        }
4835        PackageParser.Package p = mPackages.get(file.apk);
4836        if (changingLib != null && changingLib.packageName.equals(file.apk)) {
4837            // If we are doing this while in the middle of updating a library apk,
4838            // then we need to make sure to use that new apk for determining the
4839            // dependencies here.  (We haven't yet finished committing the new apk
4840            // to the package manager state.)
4841            if (p == null || p.packageName.equals(changingLib.packageName)) {
4842                p = changingLib;
4843            }
4844        }
4845        if (p != null) {
4846            usesLibraryFiles.addAll(p.getAllCodePaths());
4847        }
4848    }
4849
4850    private void updateSharedLibrariesLPw(PackageParser.Package pkg,
4851            PackageParser.Package changingLib) throws PackageManagerException {
4852        // We might be upgrading from a version of the platform that did not
4853        // provide per-package native library directories for system apps.
4854        // Fix that up here.
4855        if (isSystemApp(pkg)) {
4856            PackageSetting ps = mSettings.mPackages.get(pkg.applicationInfo.packageName);
4857            if (!isUpdatedSystemApp(pkg)) {
4858                setBundledAppAbisAndRoots(pkg, ps);
4859            }
4860        }
4861
4862        if (pkg.usesLibraries != null || pkg.usesOptionalLibraries != null) {
4863            final ArraySet<String> usesLibraryFiles = new ArraySet<>();
4864            int N = pkg.usesLibraries != null ? pkg.usesLibraries.size() : 0;
4865            for (int i=0; i<N; i++) {
4866                final SharedLibraryEntry file = mSharedLibraries.get(pkg.usesLibraries.get(i));
4867                if (file == null) {
4868                    throw new PackageManagerException(INSTALL_FAILED_MISSING_SHARED_LIBRARY,
4869                            "Package " + pkg.packageName + " requires unavailable shared library "
4870                            + pkg.usesLibraries.get(i) + "; failing!");
4871                }
4872                addSharedLibraryLPw(usesLibraryFiles, file, changingLib);
4873            }
4874            N = pkg.usesOptionalLibraries != null ? pkg.usesOptionalLibraries.size() : 0;
4875            for (int i=0; i<N; i++) {
4876                final SharedLibraryEntry file = mSharedLibraries.get(pkg.usesOptionalLibraries.get(i));
4877                if (file == null) {
4878                    Slog.w(TAG, "Package " + pkg.packageName
4879                            + " desires unavailable shared library "
4880                            + pkg.usesOptionalLibraries.get(i) + "; ignoring!");
4881                } else {
4882                    addSharedLibraryLPw(usesLibraryFiles, file, changingLib);
4883                }
4884            }
4885            N = usesLibraryFiles.size();
4886            if (N > 0) {
4887                pkg.usesLibraryFiles = usesLibraryFiles.toArray(new String[N]);
4888            } else {
4889                pkg.usesLibraryFiles = null;
4890            }
4891        }
4892    }
4893
4894    private static boolean hasString(List<String> list, List<String> which) {
4895        if (list == null) {
4896            return false;
4897        }
4898        for (int i=list.size()-1; i>=0; i--) {
4899            for (int j=which.size()-1; j>=0; j--) {
4900                if (which.get(j).equals(list.get(i))) {
4901                    return true;
4902                }
4903            }
4904        }
4905        return false;
4906    }
4907
4908    private void updateAllSharedLibrariesLPw() {
4909        for (PackageParser.Package pkg : mPackages.values()) {
4910            try {
4911                updateSharedLibrariesLPw(pkg, null);
4912            } catch (PackageManagerException e) {
4913                Slog.e(TAG, "updateAllSharedLibrariesLPw failed: " + e.getMessage());
4914            }
4915        }
4916    }
4917
4918    private ArrayList<PackageParser.Package> updateAllSharedLibrariesLPw(
4919            PackageParser.Package changingPkg) {
4920        ArrayList<PackageParser.Package> res = null;
4921        for (PackageParser.Package pkg : mPackages.values()) {
4922            if (hasString(pkg.usesLibraries, changingPkg.libraryNames)
4923                    || hasString(pkg.usesOptionalLibraries, changingPkg.libraryNames)) {
4924                if (res == null) {
4925                    res = new ArrayList<PackageParser.Package>();
4926                }
4927                res.add(pkg);
4928                try {
4929                    updateSharedLibrariesLPw(pkg, changingPkg);
4930                } catch (PackageManagerException e) {
4931                    Slog.e(TAG, "updateAllSharedLibrariesLPw failed: " + e.getMessage());
4932                }
4933            }
4934        }
4935        return res;
4936    }
4937
4938    private PackageParser.Package scanPackageLI(PackageParser.Package pkg, int parseFlags,
4939            int scanMode, long currentTime, UserHandle user, String abiOverride)
4940            throws PackageManagerException {
4941        final File scanFile = new File(pkg.codePath);
4942        if (pkg.applicationInfo.getCodePath() == null ||
4943                pkg.applicationInfo.getResourcePath() == null) {
4944            // Bail out. The resource and code paths haven't been set.
4945            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
4946                    "Code and resource paths haven't been set correctly");
4947        }
4948
4949        if ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
4950            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
4951        }
4952
4953        if ((parseFlags&PackageParser.PARSE_IS_PRIVILEGED) != 0) {
4954            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_PRIVILEGED;
4955        }
4956
4957        if (mCustomResolverComponentName != null &&
4958                mCustomResolverComponentName.getPackageName().equals(pkg.packageName)) {
4959            setUpCustomResolverActivity(pkg);
4960        }
4961
4962        if (pkg.packageName.equals("android")) {
4963            synchronized (mPackages) {
4964                if (mAndroidApplication != null) {
4965                    Slog.w(TAG, "*************************************************");
4966                    Slog.w(TAG, "Core android package being redefined.  Skipping.");
4967                    Slog.w(TAG, " file=" + scanFile);
4968                    Slog.w(TAG, "*************************************************");
4969                    throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
4970                            "Core android package being redefined.  Skipping.");
4971                }
4972
4973                // Set up information for our fall-back user intent resolution activity.
4974                mPlatformPackage = pkg;
4975                pkg.mVersionCode = mSdkVersion;
4976                mAndroidApplication = pkg.applicationInfo;
4977
4978                if (!mResolverReplaced) {
4979                    mResolveActivity.applicationInfo = mAndroidApplication;
4980                    mResolveActivity.name = ResolverActivity.class.getName();
4981                    mResolveActivity.packageName = mAndroidApplication.packageName;
4982                    mResolveActivity.processName = "system:ui";
4983                    mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
4984                    mResolveActivity.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NEVER;
4985                    mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
4986                    mResolveActivity.theme = R.style.Theme_Holo_Dialog_Alert;
4987                    mResolveActivity.exported = true;
4988                    mResolveActivity.enabled = true;
4989                    mResolveInfo.activityInfo = mResolveActivity;
4990                    mResolveInfo.priority = 0;
4991                    mResolveInfo.preferredOrder = 0;
4992                    mResolveInfo.match = 0;
4993                    mResolveComponentName = new ComponentName(
4994                            mAndroidApplication.packageName, mResolveActivity.name);
4995                }
4996            }
4997        }
4998
4999        if (DEBUG_PACKAGE_SCANNING) {
5000            if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5001                Log.d(TAG, "Scanning package " + pkg.packageName);
5002        }
5003
5004        if (mPackages.containsKey(pkg.packageName)
5005                || mSharedLibraries.containsKey(pkg.packageName)) {
5006            throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
5007                    "Application package " + pkg.packageName
5008                    + " already installed.  Skipping duplicate.");
5009        }
5010
5011        // Initialize package source and resource directories
5012        File destCodeFile = new File(pkg.applicationInfo.getCodePath());
5013        File destResourceFile = new File(pkg.applicationInfo.getResourcePath());
5014
5015        SharedUserSetting suid = null;
5016        PackageSetting pkgSetting = null;
5017
5018        if (!isSystemApp(pkg)) {
5019            // Only system apps can use these features.
5020            pkg.mOriginalPackages = null;
5021            pkg.mRealPackage = null;
5022            pkg.mAdoptPermissions = null;
5023        }
5024
5025        // writer
5026        synchronized (mPackages) {
5027            if (pkg.mSharedUserId != null) {
5028                suid = mSettings.getSharedUserLPw(pkg.mSharedUserId, 0, true);
5029                if (suid == null) {
5030                    throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5031                            "Creating application package " + pkg.packageName
5032                            + " for shared user failed");
5033                }
5034                if (DEBUG_PACKAGE_SCANNING) {
5035                    if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5036                        Log.d(TAG, "Shared UserID " + pkg.mSharedUserId + " (uid=" + suid.userId
5037                                + "): packages=" + suid.packages);
5038                }
5039            }
5040
5041            // Check if we are renaming from an original package name.
5042            PackageSetting origPackage = null;
5043            String realName = null;
5044            if (pkg.mOriginalPackages != null) {
5045                // This package may need to be renamed to a previously
5046                // installed name.  Let's check on that...
5047                final String renamed = mSettings.mRenamedPackages.get(pkg.mRealPackage);
5048                if (pkg.mOriginalPackages.contains(renamed)) {
5049                    // This package had originally been installed as the
5050                    // original name, and we have already taken care of
5051                    // transitioning to the new one.  Just update the new
5052                    // one to continue using the old name.
5053                    realName = pkg.mRealPackage;
5054                    if (!pkg.packageName.equals(renamed)) {
5055                        // Callers into this function may have already taken
5056                        // care of renaming the package; only do it here if
5057                        // it is not already done.
5058                        pkg.setPackageName(renamed);
5059                    }
5060
5061                } else {
5062                    for (int i=pkg.mOriginalPackages.size()-1; i>=0; i--) {
5063                        if ((origPackage = mSettings.peekPackageLPr(
5064                                pkg.mOriginalPackages.get(i))) != null) {
5065                            // We do have the package already installed under its
5066                            // original name...  should we use it?
5067                            if (!verifyPackageUpdateLPr(origPackage, pkg)) {
5068                                // New package is not compatible with original.
5069                                origPackage = null;
5070                                continue;
5071                            } else if (origPackage.sharedUser != null) {
5072                                // Make sure uid is compatible between packages.
5073                                if (!origPackage.sharedUser.name.equals(pkg.mSharedUserId)) {
5074                                    Slog.w(TAG, "Unable to migrate data from " + origPackage.name
5075                                            + " to " + pkg.packageName + ": old uid "
5076                                            + origPackage.sharedUser.name
5077                                            + " differs from " + pkg.mSharedUserId);
5078                                    origPackage = null;
5079                                    continue;
5080                                }
5081                            } else {
5082                                if (DEBUG_UPGRADE) Log.v(TAG, "Renaming new package "
5083                                        + pkg.packageName + " to old name " + origPackage.name);
5084                            }
5085                            break;
5086                        }
5087                    }
5088                }
5089            }
5090
5091            if (mTransferedPackages.contains(pkg.packageName)) {
5092                Slog.w(TAG, "Package " + pkg.packageName
5093                        + " was transferred to another, but its .apk remains");
5094            }
5095
5096            // Just create the setting, don't add it yet. For already existing packages
5097            // the PkgSetting exists already and doesn't have to be created.
5098            pkgSetting = mSettings.getPackageLPw(pkg, origPackage, realName, suid, destCodeFile,
5099                    destResourceFile, pkg.applicationInfo.nativeLibraryRootDir,
5100                    pkg.applicationInfo.primaryCpuAbi,
5101                    pkg.applicationInfo.secondaryCpuAbi,
5102                    pkg.applicationInfo.flags, user, false);
5103            if (pkgSetting == null) {
5104                throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5105                        "Creating application package " + pkg.packageName + " failed");
5106            }
5107
5108            if (pkgSetting.origPackage != null) {
5109                // If we are first transitioning from an original package,
5110                // fix up the new package's name now.  We need to do this after
5111                // looking up the package under its new name, so getPackageLP
5112                // can take care of fiddling things correctly.
5113                pkg.setPackageName(origPackage.name);
5114
5115                // File a report about this.
5116                String msg = "New package " + pkgSetting.realName
5117                        + " renamed to replace old package " + pkgSetting.name;
5118                reportSettingsProblem(Log.WARN, msg);
5119
5120                // Make a note of it.
5121                mTransferedPackages.add(origPackage.name);
5122
5123                // No longer need to retain this.
5124                pkgSetting.origPackage = null;
5125            }
5126
5127            if (realName != null) {
5128                // Make a note of it.
5129                mTransferedPackages.add(pkg.packageName);
5130            }
5131
5132            if (mSettings.isDisabledSystemPackageLPr(pkg.packageName)) {
5133                pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
5134            }
5135
5136            if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
5137                // Check all shared libraries and map to their actual file path.
5138                // We only do this here for apps not on a system dir, because those
5139                // are the only ones that can fail an install due to this.  We
5140                // will take care of the system apps by updating all of their
5141                // library paths after the scan is done.
5142                updateSharedLibrariesLPw(pkg, null);
5143            }
5144
5145            if (mFoundPolicyFile) {
5146                SELinuxMMAC.assignSeinfoValue(pkg);
5147            }
5148
5149            pkg.applicationInfo.uid = pkgSetting.appId;
5150            pkg.mExtras = pkgSetting;
5151            if (!pkgSetting.keySetData.isUsingUpgradeKeySets() || pkgSetting.sharedUser != null) {
5152                try {
5153                    verifySignaturesLP(pkgSetting, pkg);
5154                } catch (PackageManagerException e) {
5155                    if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
5156                        throw e;
5157                    }
5158                    // The signature has changed, but this package is in the system
5159                    // image...  let's recover!
5160                    pkgSetting.signatures.mSignatures = pkg.mSignatures;
5161                    // However...  if this package is part of a shared user, but it
5162                    // doesn't match the signature of the shared user, let's fail.
5163                    // What this means is that you can't change the signatures
5164                    // associated with an overall shared user, which doesn't seem all
5165                    // that unreasonable.
5166                    if (pkgSetting.sharedUser != null) {
5167                        if (compareSignatures(pkgSetting.sharedUser.signatures.mSignatures,
5168                                              pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {
5169                            throw new PackageManagerException(
5170                                    INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
5171                                            "Signature mismatch for shared user : "
5172                                            + pkgSetting.sharedUser);
5173                        }
5174                    }
5175                    // File a report about this.
5176                    String msg = "System package " + pkg.packageName
5177                        + " signature changed; retaining data.";
5178                    reportSettingsProblem(Log.WARN, msg);
5179                }
5180            } else {
5181                if (!checkUpgradeKeySetLP(pkgSetting, pkg)) {
5182                    throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
5183                            + pkg.packageName + " upgrade keys do not match the "
5184                            + "previously installed version");
5185                } else {
5186                    // signatures may have changed as result of upgrade
5187                    pkgSetting.signatures.mSignatures = pkg.mSignatures;
5188                }
5189            }
5190            // Verify that this new package doesn't have any content providers
5191            // that conflict with existing packages.  Only do this if the
5192            // package isn't already installed, since we don't want to break
5193            // things that are installed.
5194            if ((scanMode&SCAN_NEW_INSTALL) != 0) {
5195                final int N = pkg.providers.size();
5196                int i;
5197                for (i=0; i<N; i++) {
5198                    PackageParser.Provider p = pkg.providers.get(i);
5199                    if (p.info.authority != null) {
5200                        String names[] = p.info.authority.split(";");
5201                        for (int j = 0; j < names.length; j++) {
5202                            if (mProvidersByAuthority.containsKey(names[j])) {
5203                                PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
5204                                final String otherPackageName =
5205                                        ((other != null && other.getComponentName() != null) ?
5206                                                other.getComponentName().getPackageName() : "?");
5207                                throw new PackageManagerException(
5208                                        INSTALL_FAILED_CONFLICTING_PROVIDER,
5209                                                "Can't install because provider name " + names[j]
5210                                                + " (in package " + pkg.applicationInfo.packageName
5211                                                + ") is already used by " + otherPackageName);
5212                            }
5213                        }
5214                    }
5215                }
5216            }
5217
5218            if (pkg.mAdoptPermissions != null) {
5219                // This package wants to adopt ownership of permissions from
5220                // another package.
5221                for (int i = pkg.mAdoptPermissions.size() - 1; i >= 0; i--) {
5222                    final String origName = pkg.mAdoptPermissions.get(i);
5223                    final PackageSetting orig = mSettings.peekPackageLPr(origName);
5224                    if (orig != null) {
5225                        if (verifyPackageUpdateLPr(orig, pkg)) {
5226                            Slog.i(TAG, "Adopting permissions from " + origName + " to "
5227                                    + pkg.packageName);
5228                            mSettings.transferPermissionsLPw(origName, pkg.packageName);
5229                        }
5230                    }
5231                }
5232            }
5233        }
5234
5235        final String pkgName = pkg.packageName;
5236
5237        final long scanFileTime = scanFile.lastModified();
5238        final boolean forceDex = (scanMode&SCAN_FORCE_DEX) != 0;
5239        pkg.applicationInfo.processName = fixProcessName(
5240                pkg.applicationInfo.packageName,
5241                pkg.applicationInfo.processName,
5242                pkg.applicationInfo.uid);
5243
5244        File dataPath;
5245        if (mPlatformPackage == pkg) {
5246            // The system package is special.
5247            dataPath = new File (Environment.getDataDirectory(), "system");
5248            pkg.applicationInfo.dataDir = dataPath.getPath();
5249        } else {
5250            // This is a normal package, need to make its data directory.
5251            dataPath = getDataPathForPackage(pkg.packageName, 0);
5252
5253            boolean uidError = false;
5254
5255            if (dataPath.exists()) {
5256                int currentUid = 0;
5257                try {
5258                    StructStat stat = Os.stat(dataPath.getPath());
5259                    currentUid = stat.st_uid;
5260                } catch (ErrnoException e) {
5261                    Slog.e(TAG, "Couldn't stat path " + dataPath.getPath(), e);
5262                }
5263
5264                // If we have mismatched owners for the data path, we have a problem.
5265                if (currentUid != pkg.applicationInfo.uid) {
5266                    boolean recovered = false;
5267                    if (currentUid == 0) {
5268                        // The directory somehow became owned by root.  Wow.
5269                        // This is probably because the system was stopped while
5270                        // installd was in the middle of messing with its libs
5271                        // directory.  Ask installd to fix that.
5272                        int ret = mInstaller.fixUid(pkgName, pkg.applicationInfo.uid,
5273                                pkg.applicationInfo.uid);
5274                        if (ret >= 0) {
5275                            recovered = true;
5276                            String msg = "Package " + pkg.packageName
5277                                    + " unexpectedly changed to uid 0; recovered to " +
5278                                    + pkg.applicationInfo.uid;
5279                            reportSettingsProblem(Log.WARN, msg);
5280                        }
5281                    }
5282                    if (!recovered && ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
5283                            || (scanMode&SCAN_BOOTING) != 0)) {
5284                        // If this is a system app, we can at least delete its
5285                        // current data so the application will still work.
5286                        int ret = removeDataDirsLI(pkgName);
5287                        if (ret >= 0) {
5288                            // TODO: Kill the processes first
5289                            // Old data gone!
5290                            String prefix = (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
5291                                    ? "System package " : "Third party package ";
5292                            String msg = prefix + pkg.packageName
5293                                    + " has changed from uid: "
5294                                    + currentUid + " to "
5295                                    + pkg.applicationInfo.uid + "; old data erased";
5296                            reportSettingsProblem(Log.WARN, msg);
5297                            recovered = true;
5298
5299                            // And now re-install the app.
5300                            ret = createDataDirsLI(pkgName, pkg.applicationInfo.uid,
5301                                                   pkg.applicationInfo.seinfo);
5302                            if (ret == -1) {
5303                                // Ack should not happen!
5304                                msg = prefix + pkg.packageName
5305                                        + " could not have data directory re-created after delete.";
5306                                reportSettingsProblem(Log.WARN, msg);
5307                                throw new PackageManagerException(
5308                                        INSTALL_FAILED_INSUFFICIENT_STORAGE, msg);
5309                            }
5310                        }
5311                        if (!recovered) {
5312                            mHasSystemUidErrors = true;
5313                        }
5314                    } else if (!recovered) {
5315                        // If we allow this install to proceed, we will be broken.
5316                        // Abort, abort!
5317                        throw new PackageManagerException(INSTALL_FAILED_UID_CHANGED,
5318                                "scanPackageLI");
5319                    }
5320                    if (!recovered) {
5321                        pkg.applicationInfo.dataDir = "/mismatched_uid/settings_"
5322                            + pkg.applicationInfo.uid + "/fs_"
5323                            + currentUid;
5324                        pkg.applicationInfo.nativeLibraryDir = pkg.applicationInfo.dataDir;
5325                        pkg.applicationInfo.nativeLibraryRootDir = pkg.applicationInfo.dataDir;
5326                        String msg = "Package " + pkg.packageName
5327                                + " has mismatched uid: "
5328                                + currentUid + " on disk, "
5329                                + pkg.applicationInfo.uid + " in settings";
5330                        // writer
5331                        synchronized (mPackages) {
5332                            mSettings.mReadMessages.append(msg);
5333                            mSettings.mReadMessages.append('\n');
5334                            uidError = true;
5335                            if (!pkgSetting.uidError) {
5336                                reportSettingsProblem(Log.ERROR, msg);
5337                            }
5338                        }
5339                    }
5340                }
5341                pkg.applicationInfo.dataDir = dataPath.getPath();
5342                if (mShouldRestoreconData) {
5343                    Slog.i(TAG, "SELinux relabeling of " + pkg.packageName + " issued.");
5344                    mInstaller.restoreconData(pkg.packageName, pkg.applicationInfo.seinfo,
5345                                pkg.applicationInfo.uid);
5346                }
5347            } else {
5348                if (DEBUG_PACKAGE_SCANNING) {
5349                    if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5350                        Log.v(TAG, "Want this data dir: " + dataPath);
5351                }
5352                //invoke installer to do the actual installation
5353                int ret = createDataDirsLI(pkgName, pkg.applicationInfo.uid,
5354                                           pkg.applicationInfo.seinfo);
5355                if (ret < 0) {
5356                    // Error from installer
5357                    throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
5358                            "Unable to create data dirs [errorCode=" + ret + "]");
5359                }
5360
5361                if (dataPath.exists()) {
5362                    pkg.applicationInfo.dataDir = dataPath.getPath();
5363                } else {
5364                    Slog.w(TAG, "Unable to create data directory: " + dataPath);
5365                    pkg.applicationInfo.dataDir = null;
5366                }
5367            }
5368
5369            pkgSetting.uidError = uidError;
5370        }
5371
5372        final String path = scanFile.getPath();
5373        final String codePath = pkg.applicationInfo.getCodePath();
5374        if (isSystemApp(pkg) && !isUpdatedSystemApp(pkg)) {
5375            // For the case where we had previously uninstalled an update, get rid
5376            // of any native binaries we might have unpackaged. Note that this assumes
5377            // that system app updates were not installed via ASEC.
5378            //
5379            // TODO(multiArch): Is this cleanup really necessary ?
5380            NativeLibraryHelper.removeNativeBinariesFromDirLI(
5381                    new File(codePath, LIB_DIR_NAME), false /* delete dirs */);
5382            setBundledAppAbisAndRoots(pkg, pkgSetting);
5383            setNativeLibraryPaths(pkg);
5384        } else {
5385            // TODO: We can probably be smarter about this stuff. For installed apps,
5386            // we can calculate this information at install time once and for all. For
5387            // system apps, we can probably assume that this information doesn't change
5388            // after the first boot scan. As things stand, we do lots of unnecessary work.
5389
5390            // Give ourselves some initial paths; we'll come back for another
5391            // pass once we've determined ABI below.
5392            setNativeLibraryPaths(pkg);
5393
5394            final boolean isAsec = isForwardLocked(pkg) || isExternal(pkg);
5395            final String nativeLibraryRootStr = pkg.applicationInfo.nativeLibraryRootDir;
5396            final boolean useIsaSpecificSubdirs = pkg.applicationInfo.nativeLibraryRootRequiresIsa;
5397
5398            NativeLibraryHelper.Handle handle = null;
5399            try {
5400                handle = NativeLibraryHelper.Handle.create(scanFile);
5401                // TODO(multiArch): This can be null for apps that didn't go through the
5402                // usual installation process. We can calculate it again, like we
5403                // do during install time.
5404                //
5405                // TODO(multiArch): Why do we need to rescan ASEC apps again ? It seems totally
5406                // unnecessary.
5407                final File nativeLibraryRoot = new File(nativeLibraryRootStr);
5408
5409                // Null out the abis so that they can be recalculated.
5410                pkg.applicationInfo.primaryCpuAbi = null;
5411                pkg.applicationInfo.secondaryCpuAbi = null;
5412                if (isMultiArch(pkg.applicationInfo)) {
5413                    // Warn if we've set an abiOverride for multi-lib packages..
5414                    // By definition, we need to copy both 32 and 64 bit libraries for
5415                    // such packages.
5416                    if (abiOverride != null) {
5417                        Slog.w(TAG, "Ignoring abiOverride for multi arch application.");
5418                    }
5419
5420                    int abi32 = PackageManager.NO_NATIVE_LIBRARIES;
5421                    int abi64 = PackageManager.NO_NATIVE_LIBRARIES;
5422                    if (Build.SUPPORTED_32_BIT_ABIS.length > 0) {
5423                        if (isAsec) {
5424                            abi32 = NativeLibraryHelper.findSupportedAbi(handle, Build.SUPPORTED_32_BIT_ABIS);
5425                        } else {
5426                            abi32 = copyNativeLibrariesForInternalApp(handle,
5427                                    nativeLibraryRoot, Build.SUPPORTED_32_BIT_ABIS, useIsaSpecificSubdirs);
5428                        }
5429                    }
5430
5431                    maybeThrowExceptionForMultiArchCopy(
5432                            "Error unpackaging 32 bit native libs for multiarch app.", abi32);
5433
5434                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0) {
5435                        if (isAsec) {
5436                            abi64 = NativeLibraryHelper.findSupportedAbi(handle, Build.SUPPORTED_64_BIT_ABIS);
5437                        } else {
5438                            abi64 = copyNativeLibrariesForInternalApp(handle,
5439                                    nativeLibraryRoot, Build.SUPPORTED_64_BIT_ABIS, useIsaSpecificSubdirs);
5440                        }
5441                    }
5442
5443                    maybeThrowExceptionForMultiArchCopy(
5444                            "Error unpackaging 64 bit native libs for multiarch app.", abi64);
5445
5446                    if (abi64 >= 0) {
5447                        pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[abi64];
5448                    }
5449
5450                    if (abi32 >= 0) {
5451                        final String abi = Build.SUPPORTED_32_BIT_ABIS[abi32];
5452                        if (abi64 >= 0) {
5453                            pkg.applicationInfo.secondaryCpuAbi = abi;
5454                        } else {
5455                            pkg.applicationInfo.primaryCpuAbi = abi;
5456                        }
5457                    }
5458                } else {
5459                    String[] abiList = (abiOverride != null) ?
5460                            new String[] { abiOverride } : Build.SUPPORTED_ABIS;
5461
5462                    // Enable gross and lame hacks for apps that are built with old
5463                    // SDK tools. We must scan their APKs for renderscript bitcode and
5464                    // not launch them if it's present. Don't bother checking on devices
5465                    // that don't have 64 bit support.
5466                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0 && abiOverride == null &&
5467                            NativeLibraryHelper.hasRenderscriptBitcode(handle)) {
5468                        abiList = Build.SUPPORTED_32_BIT_ABIS;
5469                    }
5470
5471                    final int copyRet;
5472                    if (isAsec) {
5473                        copyRet = NativeLibraryHelper.findSupportedAbi(handle, abiList);
5474                    } else {
5475                        copyRet = copyNativeLibrariesForInternalApp(handle, nativeLibraryRoot, abiList,
5476                                useIsaSpecificSubdirs);
5477                    }
5478
5479                    if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES) {
5480                        throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
5481                                "Error unpackaging native libs for app, errorCode=" + copyRet);
5482                    }
5483
5484                    if (copyRet >= 0) {
5485                        pkg.applicationInfo.primaryCpuAbi = abiList[copyRet];
5486                    }
5487                }
5488            } catch (IOException ioe) {
5489                Slog.e(TAG, "Unable to get canonical file " + ioe.toString());
5490            } finally {
5491                IoUtils.closeQuietly(handle);
5492            }
5493
5494            // Now that we've calculated the ABIs and determined if it's an internal app,
5495            // we will go ahead and populate the nativeLibraryPath.
5496            setNativeLibraryPaths(pkg);
5497
5498            if (DEBUG_INSTALL) Slog.i(TAG, "Linking native library dir for " + path);
5499            final int[] userIds = sUserManager.getUserIds();
5500            synchronized (mInstallLock) {
5501                // Create a native library symlink only if we have native libraries
5502                // and if the native libraries are 32 bit libraries. We do not provide
5503                // this symlink for 64 bit libraries.
5504                if (pkg.applicationInfo.primaryCpuAbi != null &&
5505                        !VMRuntime.is64BitAbi(pkg.applicationInfo.primaryCpuAbi)) {
5506                    final String nativeLibPath = pkg.applicationInfo.nativeLibraryDir;
5507                    for (int userId : userIds) {
5508                        if (mInstaller.linkNativeLibraryDirectory(pkg.packageName, nativeLibPath, userId) < 0) {
5509                            throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
5510                                    "Failed linking native library dir (user=" + userId + ")");
5511                        }
5512                    }
5513                }
5514            }
5515
5516            pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
5517            pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
5518        }
5519
5520        Slog.d(TAG, "Resolved nativeLibraryRoot for " + pkg.applicationInfo.packageName
5521                + " to root=" + pkg.applicationInfo.nativeLibraryRootDir + ", isa="
5522                + pkg.applicationInfo.nativeLibraryRootRequiresIsa);
5523
5524        // Push the derived path down into PackageSettings so we know what to
5525        // clean up at uninstall time.
5526        pkgSetting.legacyNativeLibraryPathString = pkg.applicationInfo.nativeLibraryRootDir;
5527
5528        if (DEBUG_ABI_SELECTION) {
5529            Log.d(TAG, "Abis for package[" + pkg.packageName + "] are" +
5530                    " primary=" + pkg.applicationInfo.primaryCpuAbi +
5531                    " secondary=" + pkg.applicationInfo.secondaryCpuAbi);
5532        }
5533
5534        if ((scanMode&SCAN_BOOTING) == 0 && pkgSetting.sharedUser != null) {
5535            // We don't do this here during boot because we can do it all
5536            // at once after scanning all existing packages.
5537            //
5538            // We also do this *before* we perform dexopt on this package, so that
5539            // we can avoid redundant dexopts, and also to make sure we've got the
5540            // code and package path correct.
5541            if (!adjustCpuAbisForSharedUserLPw(pkgSetting.sharedUser.packages,
5542                    pkg, forceDex, (scanMode & SCAN_DEFER_DEX) != 0)) {
5543                throw new PackageManagerException(INSTALL_FAILED_CPU_ABI_INCOMPATIBLE,
5544                        "scanPackageLI");
5545            }
5546        }
5547
5548        if ((scanMode&SCAN_NO_DEX) == 0) {
5549            if (performDexOptLI(pkg, forceDex, (scanMode&SCAN_DEFER_DEX) != 0, false)
5550                    == DEX_OPT_FAILED) {
5551                if ((scanMode & SCAN_DELETE_DATA_ON_FAILURES) != 0) {
5552                    removeDataDirsLI(pkg.packageName);
5553                }
5554
5555                throw new PackageManagerException(INSTALL_FAILED_DEXOPT, "scanPackageLI");
5556            }
5557        }
5558
5559        if (mFactoryTest && pkg.requestedPermissions.contains(
5560                android.Manifest.permission.FACTORY_TEST)) {
5561            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_FACTORY_TEST;
5562        }
5563
5564        ArrayList<PackageParser.Package> clientLibPkgs = null;
5565
5566        // writer
5567        synchronized (mPackages) {
5568            if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
5569                // Only system apps can add new shared libraries.
5570                if (pkg.libraryNames != null) {
5571                    for (int i=0; i<pkg.libraryNames.size(); i++) {
5572                        String name = pkg.libraryNames.get(i);
5573                        boolean allowed = false;
5574                        if (isUpdatedSystemApp(pkg)) {
5575                            // New library entries can only be added through the
5576                            // system image.  This is important to get rid of a lot
5577                            // of nasty edge cases: for example if we allowed a non-
5578                            // system update of the app to add a library, then uninstalling
5579                            // the update would make the library go away, and assumptions
5580                            // we made such as through app install filtering would now
5581                            // have allowed apps on the device which aren't compatible
5582                            // with it.  Better to just have the restriction here, be
5583                            // conservative, and create many fewer cases that can negatively
5584                            // impact the user experience.
5585                            final PackageSetting sysPs = mSettings
5586                                    .getDisabledSystemPkgLPr(pkg.packageName);
5587                            if (sysPs.pkg != null && sysPs.pkg.libraryNames != null) {
5588                                for (int j=0; j<sysPs.pkg.libraryNames.size(); j++) {
5589                                    if (name.equals(sysPs.pkg.libraryNames.get(j))) {
5590                                        allowed = true;
5591                                        allowed = true;
5592                                        break;
5593                                    }
5594                                }
5595                            }
5596                        } else {
5597                            allowed = true;
5598                        }
5599                        if (allowed) {
5600                            if (!mSharedLibraries.containsKey(name)) {
5601                                mSharedLibraries.put(name, new SharedLibraryEntry(null, pkg.packageName));
5602                            } else if (!name.equals(pkg.packageName)) {
5603                                Slog.w(TAG, "Package " + pkg.packageName + " library "
5604                                        + name + " already exists; skipping");
5605                            }
5606                        } else {
5607                            Slog.w(TAG, "Package " + pkg.packageName + " declares lib "
5608                                    + name + " that is not declared on system image; skipping");
5609                        }
5610                    }
5611                    if ((scanMode&SCAN_BOOTING) == 0) {
5612                        // If we are not booting, we need to update any applications
5613                        // that are clients of our shared library.  If we are booting,
5614                        // this will all be done once the scan is complete.
5615                        clientLibPkgs = updateAllSharedLibrariesLPw(pkg);
5616                    }
5617                }
5618            }
5619        }
5620
5621        // We also need to dexopt any apps that are dependent on this library.  Note that
5622        // if these fail, we should abort the install since installing the library will
5623        // result in some apps being broken.
5624        if (clientLibPkgs != null) {
5625            if ((scanMode&SCAN_NO_DEX) == 0) {
5626                for (int i=0; i<clientLibPkgs.size(); i++) {
5627                    PackageParser.Package clientPkg = clientLibPkgs.get(i);
5628                    if (performDexOptLI(clientPkg, forceDex, (scanMode&SCAN_DEFER_DEX) != 0, false)
5629                            == DEX_OPT_FAILED) {
5630                        if ((scanMode & SCAN_DELETE_DATA_ON_FAILURES) != 0) {
5631                            removeDataDirsLI(pkg.packageName);
5632                        }
5633
5634                        throw new PackageManagerException(INSTALL_FAILED_DEXOPT,
5635                                "scanPackageLI failed to dexopt clientLibPkgs");
5636                    }
5637                }
5638            }
5639        }
5640
5641        // Request the ActivityManager to kill the process(only for existing packages)
5642        // so that we do not end up in a confused state while the user is still using the older
5643        // version of the application while the new one gets installed.
5644        if ((parseFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
5645            // If the package lives in an asec, tell everyone that the container is going
5646            // away so they can clean up any references to its resources (which would prevent
5647            // vold from being able to unmount the asec)
5648            if (isForwardLocked(pkg) || isExternal(pkg)) {
5649                if (DEBUG_INSTALL) {
5650                    Slog.i(TAG, "upgrading pkg " + pkg + " is ASEC-hosted -> UNAVAILABLE");
5651                }
5652                final int[] uidArray = new int[] { pkg.applicationInfo.uid };
5653                final ArrayList<String> pkgList = new ArrayList<String>(1);
5654                pkgList.add(pkg.applicationInfo.packageName);
5655                sendResourcesChangedBroadcast(false, true, pkgList, uidArray, null);
5656            }
5657
5658            // Post the request that it be killed now that the going-away broadcast is en route
5659            killApplication(pkg.applicationInfo.packageName,
5660                        pkg.applicationInfo.uid, "update pkg");
5661        }
5662
5663        // Also need to kill any apps that are dependent on the library.
5664        if (clientLibPkgs != null) {
5665            for (int i=0; i<clientLibPkgs.size(); i++) {
5666                PackageParser.Package clientPkg = clientLibPkgs.get(i);
5667                killApplication(clientPkg.applicationInfo.packageName,
5668                        clientPkg.applicationInfo.uid, "update lib");
5669            }
5670        }
5671
5672        // writer
5673        synchronized (mPackages) {
5674            // We don't expect installation to fail beyond this point,
5675            if ((scanMode&SCAN_MONITOR) != 0) {
5676                mAppDirs.put(pkg.codePath, pkg);
5677            }
5678            // Add the new setting to mSettings
5679            mSettings.insertPackageSettingLPw(pkgSetting, pkg);
5680            // Add the new setting to mPackages
5681            mPackages.put(pkg.applicationInfo.packageName, pkg);
5682            // Make sure we don't accidentally delete its data.
5683            final Iterator<PackageCleanItem> iter = mSettings.mPackagesToBeCleaned.iterator();
5684            while (iter.hasNext()) {
5685                PackageCleanItem item = iter.next();
5686                if (pkgName.equals(item.packageName)) {
5687                    iter.remove();
5688                }
5689            }
5690
5691            // Take care of first install / last update times.
5692            if (currentTime != 0) {
5693                if (pkgSetting.firstInstallTime == 0) {
5694                    pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = currentTime;
5695                } else if ((scanMode&SCAN_UPDATE_TIME) != 0) {
5696                    pkgSetting.lastUpdateTime = currentTime;
5697                }
5698            } else if (pkgSetting.firstInstallTime == 0) {
5699                // We need *something*.  Take time time stamp of the file.
5700                pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = scanFileTime;
5701            } else if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) != 0) {
5702                if (scanFileTime != pkgSetting.timeStamp) {
5703                    // A package on the system image has changed; consider this
5704                    // to be an update.
5705                    pkgSetting.lastUpdateTime = scanFileTime;
5706                }
5707            }
5708
5709            // Add the package's KeySets to the global KeySetManagerService
5710            KeySetManagerService ksms = mSettings.mKeySetManagerService;
5711            try {
5712                // Old KeySetData no longer valid.
5713                ksms.removeAppKeySetDataLPw(pkg.packageName);
5714                ksms.addSigningKeySetToPackageLPw(pkg.packageName, pkg.mSigningKeys);
5715                if (pkg.mKeySetMapping != null) {
5716                    for (Map.Entry<String, ArraySet<PublicKey>> entry :
5717                            pkg.mKeySetMapping.entrySet()) {
5718                        if (entry.getValue() != null) {
5719                            ksms.addDefinedKeySetToPackageLPw(pkg.packageName,
5720                                                          entry.getValue(), entry.getKey());
5721                        }
5722                    }
5723                    if (pkg.mUpgradeKeySets != null) {
5724                        for (String upgradeAlias : pkg.mUpgradeKeySets) {
5725                            ksms.addUpgradeKeySetToPackageLPw(pkg.packageName, upgradeAlias);
5726                        }
5727                    }
5728                }
5729            } catch (NullPointerException e) {
5730                Slog.e(TAG, "Could not add KeySet to " + pkg.packageName, e);
5731            } catch (IllegalArgumentException e) {
5732                Slog.e(TAG, "Could not add KeySet to malformed package" + pkg.packageName, e);
5733            }
5734
5735            int N = pkg.providers.size();
5736            StringBuilder r = null;
5737            int i;
5738            for (i=0; i<N; i++) {
5739                PackageParser.Provider p = pkg.providers.get(i);
5740                p.info.processName = fixProcessName(pkg.applicationInfo.processName,
5741                        p.info.processName, pkg.applicationInfo.uid);
5742                mProviders.addProvider(p);
5743                p.syncable = p.info.isSyncable;
5744                if (p.info.authority != null) {
5745                    String names[] = p.info.authority.split(";");
5746                    p.info.authority = null;
5747                    for (int j = 0; j < names.length; j++) {
5748                        if (j == 1 && p.syncable) {
5749                            // We only want the first authority for a provider to possibly be
5750                            // syncable, so if we already added this provider using a different
5751                            // authority clear the syncable flag. We copy the provider before
5752                            // changing it because the mProviders object contains a reference
5753                            // to a provider that we don't want to change.
5754                            // Only do this for the second authority since the resulting provider
5755                            // object can be the same for all future authorities for this provider.
5756                            p = new PackageParser.Provider(p);
5757                            p.syncable = false;
5758                        }
5759                        if (!mProvidersByAuthority.containsKey(names[j])) {
5760                            mProvidersByAuthority.put(names[j], p);
5761                            if (p.info.authority == null) {
5762                                p.info.authority = names[j];
5763                            } else {
5764                                p.info.authority = p.info.authority + ";" + names[j];
5765                            }
5766                            if (DEBUG_PACKAGE_SCANNING) {
5767                                if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
5768                                    Log.d(TAG, "Registered content provider: " + names[j]
5769                                            + ", className = " + p.info.name + ", isSyncable = "
5770                                            + p.info.isSyncable);
5771                            }
5772                        } else {
5773                            PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
5774                            Slog.w(TAG, "Skipping provider name " + names[j] +
5775                                    " (in package " + pkg.applicationInfo.packageName +
5776                                    "): name already used by "
5777                                    + ((other != null && other.getComponentName() != null)
5778                                            ? other.getComponentName().getPackageName() : "?"));
5779                        }
5780                    }
5781                }
5782                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5783                    if (r == null) {
5784                        r = new StringBuilder(256);
5785                    } else {
5786                        r.append(' ');
5787                    }
5788                    r.append(p.info.name);
5789                }
5790            }
5791            if (r != null) {
5792                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Providers: " + r);
5793            }
5794
5795            N = pkg.services.size();
5796            r = null;
5797            for (i=0; i<N; i++) {
5798                PackageParser.Service s = pkg.services.get(i);
5799                s.info.processName = fixProcessName(pkg.applicationInfo.processName,
5800                        s.info.processName, pkg.applicationInfo.uid);
5801                mServices.addService(s);
5802                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5803                    if (r == null) {
5804                        r = new StringBuilder(256);
5805                    } else {
5806                        r.append(' ');
5807                    }
5808                    r.append(s.info.name);
5809                }
5810            }
5811            if (r != null) {
5812                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Services: " + r);
5813            }
5814
5815            N = pkg.receivers.size();
5816            r = null;
5817            for (i=0; i<N; i++) {
5818                PackageParser.Activity a = pkg.receivers.get(i);
5819                a.info.processName = fixProcessName(pkg.applicationInfo.processName,
5820                        a.info.processName, pkg.applicationInfo.uid);
5821                mReceivers.addActivity(a, "receiver");
5822                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5823                    if (r == null) {
5824                        r = new StringBuilder(256);
5825                    } else {
5826                        r.append(' ');
5827                    }
5828                    r.append(a.info.name);
5829                }
5830            }
5831            if (r != null) {
5832                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Receivers: " + r);
5833            }
5834
5835            N = pkg.activities.size();
5836            r = null;
5837            for (i=0; i<N; i++) {
5838                PackageParser.Activity a = pkg.activities.get(i);
5839                a.info.processName = fixProcessName(pkg.applicationInfo.processName,
5840                        a.info.processName, pkg.applicationInfo.uid);
5841                mActivities.addActivity(a, "activity");
5842                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5843                    if (r == null) {
5844                        r = new StringBuilder(256);
5845                    } else {
5846                        r.append(' ');
5847                    }
5848                    r.append(a.info.name);
5849                }
5850            }
5851            if (r != null) {
5852                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Activities: " + r);
5853            }
5854
5855            N = pkg.permissionGroups.size();
5856            r = null;
5857            for (i=0; i<N; i++) {
5858                PackageParser.PermissionGroup pg = pkg.permissionGroups.get(i);
5859                PackageParser.PermissionGroup cur = mPermissionGroups.get(pg.info.name);
5860                if (cur == null) {
5861                    mPermissionGroups.put(pg.info.name, pg);
5862                    if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5863                        if (r == null) {
5864                            r = new StringBuilder(256);
5865                        } else {
5866                            r.append(' ');
5867                        }
5868                        r.append(pg.info.name);
5869                    }
5870                } else {
5871                    Slog.w(TAG, "Permission group " + pg.info.name + " from package "
5872                            + pg.info.packageName + " ignored: original from "
5873                            + cur.info.packageName);
5874                    if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5875                        if (r == null) {
5876                            r = new StringBuilder(256);
5877                        } else {
5878                            r.append(' ');
5879                        }
5880                        r.append("DUP:");
5881                        r.append(pg.info.name);
5882                    }
5883                }
5884            }
5885            if (r != null) {
5886                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Permission Groups: " + r);
5887            }
5888
5889            N = pkg.permissions.size();
5890            r = null;
5891            for (i=0; i<N; i++) {
5892                PackageParser.Permission p = pkg.permissions.get(i);
5893                HashMap<String, BasePermission> permissionMap =
5894                        p.tree ? mSettings.mPermissionTrees
5895                        : mSettings.mPermissions;
5896                p.group = mPermissionGroups.get(p.info.group);
5897                if (p.info.group == null || p.group != null) {
5898                    BasePermission bp = permissionMap.get(p.info.name);
5899                    if (bp == null) {
5900                        bp = new BasePermission(p.info.name, p.info.packageName,
5901                                BasePermission.TYPE_NORMAL);
5902                        permissionMap.put(p.info.name, bp);
5903                    }
5904                    if (bp.perm == null) {
5905                        if (bp.sourcePackage != null
5906                                && !bp.sourcePackage.equals(p.info.packageName)) {
5907                            // If this is a permission that was formerly defined by a non-system
5908                            // app, but is now defined by a system app (following an upgrade),
5909                            // discard the previous declaration and consider the system's to be
5910                            // canonical.
5911                            if (isSystemApp(p.owner)) {
5912                                String msg = "New decl " + p.owner + " of permission  "
5913                                        + p.info.name + " is system";
5914                                reportSettingsProblem(Log.WARN, msg);
5915                                bp.sourcePackage = null;
5916                            }
5917                        }
5918                        if (bp.sourcePackage == null
5919                                || bp.sourcePackage.equals(p.info.packageName)) {
5920                            BasePermission tree = findPermissionTreeLP(p.info.name);
5921                            if (tree == null
5922                                    || tree.sourcePackage.equals(p.info.packageName)) {
5923                                bp.packageSetting = pkgSetting;
5924                                bp.perm = p;
5925                                bp.uid = pkg.applicationInfo.uid;
5926                                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5927                                    if (r == null) {
5928                                        r = new StringBuilder(256);
5929                                    } else {
5930                                        r.append(' ');
5931                                    }
5932                                    r.append(p.info.name);
5933                                }
5934                            } else {
5935                                Slog.w(TAG, "Permission " + p.info.name + " from package "
5936                                        + p.info.packageName + " ignored: base tree "
5937                                        + tree.name + " is from package "
5938                                        + tree.sourcePackage);
5939                            }
5940                        } else {
5941                            Slog.w(TAG, "Permission " + p.info.name + " from package "
5942                                    + p.info.packageName + " ignored: original from "
5943                                    + bp.sourcePackage);
5944                        }
5945                    } else if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5946                        if (r == null) {
5947                            r = new StringBuilder(256);
5948                        } else {
5949                            r.append(' ');
5950                        }
5951                        r.append("DUP:");
5952                        r.append(p.info.name);
5953                    }
5954                    if (bp.perm == p) {
5955                        bp.protectionLevel = p.info.protectionLevel;
5956                    }
5957                } else {
5958                    Slog.w(TAG, "Permission " + p.info.name + " from package "
5959                            + p.info.packageName + " ignored: no group "
5960                            + p.group);
5961                }
5962            }
5963            if (r != null) {
5964                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Permissions: " + r);
5965            }
5966
5967            N = pkg.instrumentation.size();
5968            r = null;
5969            for (i=0; i<N; i++) {
5970                PackageParser.Instrumentation a = pkg.instrumentation.get(i);
5971                a.info.packageName = pkg.applicationInfo.packageName;
5972                a.info.sourceDir = pkg.applicationInfo.sourceDir;
5973                a.info.publicSourceDir = pkg.applicationInfo.publicSourceDir;
5974                a.info.splitSourceDirs = pkg.applicationInfo.splitSourceDirs;
5975                a.info.splitPublicSourceDirs = pkg.applicationInfo.splitPublicSourceDirs;
5976                a.info.dataDir = pkg.applicationInfo.dataDir;
5977
5978                // TODO: Update instrumentation.nativeLibraryDir as well ? Does it
5979                // need other information about the application, like the ABI and what not ?
5980                a.info.nativeLibraryDir = pkg.applicationInfo.nativeLibraryDir;
5981                mInstrumentation.put(a.getComponentName(), a);
5982                if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
5983                    if (r == null) {
5984                        r = new StringBuilder(256);
5985                    } else {
5986                        r.append(' ');
5987                    }
5988                    r.append(a.info.name);
5989                }
5990            }
5991            if (r != null) {
5992                if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, "  Instrumentation: " + r);
5993            }
5994
5995            if (pkg.protectedBroadcasts != null) {
5996                N = pkg.protectedBroadcasts.size();
5997                for (i=0; i<N; i++) {
5998                    mProtectedBroadcasts.add(pkg.protectedBroadcasts.get(i));
5999                }
6000            }
6001
6002            pkgSetting.setTimeStamp(scanFileTime);
6003
6004            // Create idmap files for pairs of (packages, overlay packages).
6005            // Note: "android", ie framework-res.apk, is handled by native layers.
6006            if (pkg.mOverlayTarget != null) {
6007                // This is an overlay package.
6008                if (pkg.mOverlayTarget != null && !pkg.mOverlayTarget.equals("android")) {
6009                    if (!mOverlays.containsKey(pkg.mOverlayTarget)) {
6010                        mOverlays.put(pkg.mOverlayTarget,
6011                                new HashMap<String, PackageParser.Package>());
6012                    }
6013                    HashMap<String, PackageParser.Package> map = mOverlays.get(pkg.mOverlayTarget);
6014                    map.put(pkg.packageName, pkg);
6015                    PackageParser.Package orig = mPackages.get(pkg.mOverlayTarget);
6016                    if (orig != null && !createIdmapForPackagePairLI(orig, pkg)) {
6017                        throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
6018                                "scanPackageLI failed to createIdmap");
6019                    }
6020                }
6021            } else if (mOverlays.containsKey(pkg.packageName) &&
6022                    !pkg.packageName.equals("android")) {
6023                // This is a regular package, with one or more known overlay packages.
6024                createIdmapsForPackageLI(pkg);
6025            }
6026        }
6027
6028        return pkg;
6029    }
6030
6031    /**
6032     * Adjusts ABIs for a set of packages belonging to a shared user so that they all match.
6033     * i.e, so that all packages can be run inside a single process if required.
6034     *
6035     * Optionally, callers can pass in a parsed package via {@code newPackage} in which case
6036     * this function will either try and make the ABI for all packages in {@code packagesForUser}
6037     * match {@code scannedPackage} or will update the ABI of {@code scannedPackage} to match
6038     * the ABI selected for {@code packagesForUser}. This variant is used when installing or
6039     * updating a package that belongs to a shared user.
6040     *
6041     * NOTE: We currently only match for the primary CPU abi string. Matching the secondary
6042     * adds unnecessary complexity.
6043     */
6044    private boolean adjustCpuAbisForSharedUserLPw(Set<PackageSetting> packagesForUser,
6045            PackageParser.Package scannedPackage, boolean forceDexOpt, boolean deferDexOpt) {
6046        String requiredInstructionSet = null;
6047        if (scannedPackage != null && scannedPackage.applicationInfo.primaryCpuAbi != null) {
6048            requiredInstructionSet = VMRuntime.getInstructionSet(
6049                     scannedPackage.applicationInfo.primaryCpuAbi);
6050        }
6051
6052        PackageSetting requirer = null;
6053        for (PackageSetting ps : packagesForUser) {
6054            // If packagesForUser contains scannedPackage, we skip it. This will happen
6055            // when scannedPackage is an update of an existing package. Without this check,
6056            // we will never be able to change the ABI of any package belonging to a shared
6057            // user, even if it's compatible with other packages.
6058            if (scannedPackage == null || ! scannedPackage.packageName.equals(ps.name)) {
6059                if (ps.primaryCpuAbiString == null) {
6060                    continue;
6061                }
6062
6063                final String instructionSet = VMRuntime.getInstructionSet(ps.primaryCpuAbiString);
6064                if (requiredInstructionSet != null) {
6065                    if (!instructionSet.equals(requiredInstructionSet)) {
6066                        // We have a mismatch between instruction sets (say arm vs arm64).
6067                        // bail out.
6068                        String errorMessage = "Instruction set mismatch, "
6069                                + ((requirer == null) ? "[caller]" : requirer)
6070                                + " requires " + requiredInstructionSet + " whereas " + ps
6071                                + " requires " + instructionSet;
6072                        Slog.e(TAG, errorMessage);
6073
6074                        reportSettingsProblem(Log.WARN, errorMessage);
6075                        // Give up, don't bother making any other changes to the package settings.
6076                        return false;
6077                    }
6078                } else {
6079                    requiredInstructionSet = instructionSet;
6080                    requirer = ps;
6081                }
6082            }
6083        }
6084
6085        if (requiredInstructionSet != null) {
6086            String adjustedAbi;
6087            if (requirer != null) {
6088                // requirer != null implies that either scannedPackage was null or that scannedPackage
6089                // did not require an ABI, in which case we have to adjust scannedPackage to match
6090                // the ABI of the set (which is the same as requirer's ABI)
6091                adjustedAbi = requirer.primaryCpuAbiString;
6092                if (scannedPackage != null) {
6093                    scannedPackage.applicationInfo.primaryCpuAbi = adjustedAbi;
6094                }
6095            } else {
6096                // requirer == null implies that we're updating all ABIs in the set to
6097                // match scannedPackage.
6098                adjustedAbi =  scannedPackage.applicationInfo.primaryCpuAbi;
6099            }
6100
6101            for (PackageSetting ps : packagesForUser) {
6102                if (scannedPackage == null || !scannedPackage.packageName.equals(ps.name)) {
6103                    if (ps.primaryCpuAbiString != null) {
6104                        continue;
6105                    }
6106
6107                    ps.primaryCpuAbiString = adjustedAbi;
6108                    if (ps.pkg != null && ps.pkg.applicationInfo != null) {
6109                        ps.pkg.applicationInfo.primaryCpuAbi = adjustedAbi;
6110                        Slog.i(TAG, "Adjusting ABI for : " + ps.name + " to " + adjustedAbi);
6111
6112                        if (performDexOptLI(ps.pkg, forceDexOpt, deferDexOpt, true) == DEX_OPT_FAILED) {
6113                            ps.primaryCpuAbiString = null;
6114                            ps.pkg.applicationInfo.primaryCpuAbi = null;
6115                            return false;
6116                        } else {
6117                            mInstaller.rmdex(ps.codePathString, getPreferredInstructionSet());
6118                        }
6119                    }
6120                }
6121            }
6122        }
6123
6124        return true;
6125    }
6126
6127    private void setUpCustomResolverActivity(PackageParser.Package pkg) {
6128        synchronized (mPackages) {
6129            mResolverReplaced = true;
6130            // Set up information for custom user intent resolution activity.
6131            mResolveActivity.applicationInfo = pkg.applicationInfo;
6132            mResolveActivity.name = mCustomResolverComponentName.getClassName();
6133            mResolveActivity.packageName = pkg.applicationInfo.packageName;
6134            mResolveActivity.processName = null;
6135            mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
6136            mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS |
6137                    ActivityInfo.FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS;
6138            mResolveActivity.theme = 0;
6139            mResolveActivity.exported = true;
6140            mResolveActivity.enabled = true;
6141            mResolveInfo.activityInfo = mResolveActivity;
6142            mResolveInfo.priority = 0;
6143            mResolveInfo.preferredOrder = 0;
6144            mResolveInfo.match = 0;
6145            mResolveComponentName = mCustomResolverComponentName;
6146            Slog.i(TAG, "Replacing default ResolverActivity with custom activity: " +
6147                    mResolveComponentName);
6148        }
6149    }
6150
6151    private static String calculateApkRoot(final String codePathString) {
6152        final File codePath = new File(codePathString);
6153        final File codeRoot;
6154        if (FileUtils.contains(Environment.getRootDirectory(), codePath)) {
6155            codeRoot = Environment.getRootDirectory();
6156        } else if (FileUtils.contains(Environment.getOemDirectory(), codePath)) {
6157            codeRoot = Environment.getOemDirectory();
6158        } else if (FileUtils.contains(Environment.getVendorDirectory(), codePath)) {
6159            codeRoot = Environment.getVendorDirectory();
6160        } else {
6161            // Unrecognized code path; take its top real segment as the apk root:
6162            // e.g. /something/app/blah.apk => /something
6163            try {
6164                File f = codePath.getCanonicalFile();
6165                File parent = f.getParentFile();    // non-null because codePath is a file
6166                File tmp;
6167                while ((tmp = parent.getParentFile()) != null) {
6168                    f = parent;
6169                    parent = tmp;
6170                }
6171                codeRoot = f;
6172                Slog.w(TAG, "Unrecognized code path "
6173                        + codePath + " - using " + codeRoot);
6174            } catch (IOException e) {
6175                // Can't canonicalize the code path -- shenanigans?
6176                Slog.w(TAG, "Can't canonicalize code path " + codePath);
6177                return Environment.getRootDirectory().getPath();
6178            }
6179        }
6180        return codeRoot.getPath();
6181    }
6182
6183    /**
6184     * Derive and set the location of native libraries for the given package,
6185     * which varies depending on where and how the package was installed.
6186     */
6187    private void setNativeLibraryPaths(PackageParser.Package pkg) {
6188        final ApplicationInfo info = pkg.applicationInfo;
6189        final String codePath = pkg.codePath;
6190        final File codeFile = new File(codePath);
6191
6192        final boolean bundledApp = isSystemApp(info) && !isUpdatedSystemApp(info);
6193        final boolean asecApp = isForwardLocked(info) || isExternal(info);
6194
6195        info.nativeLibraryRootDir = null;
6196        info.nativeLibraryRootRequiresIsa = false;
6197        info.nativeLibraryDir = null;
6198
6199        if (bundledApp) {
6200            // Monolithic bundled install
6201            // TODO: support cluster bundled installs?
6202
6203            final boolean is64Bit = (info.primaryCpuAbi != null)
6204                    && VMRuntime.is64BitAbi(info.primaryCpuAbi);
6205
6206            // This is a bundled system app so choose the path based on the ABI.
6207            // if it's a 64 bit abi, use lib64 otherwise use lib32. Note that this
6208            // is just the default path.
6209            final String apkName = deriveCodePathName(codePath);
6210            final String libDir = is64Bit ? LIB64_DIR_NAME : LIB_DIR_NAME;
6211            info.nativeLibraryRootDir = Environment.buildPath(new File(info.apkRoot), libDir,
6212                    apkName).getAbsolutePath();
6213            info.nativeLibraryRootRequiresIsa = false;
6214
6215        } else if (isApkFile(codeFile)) {
6216            // Monolithic install
6217            if (asecApp) {
6218                info.nativeLibraryRootDir = new File(codeFile.getParentFile(), LIB_DIR_NAME)
6219                        .getAbsolutePath();
6220                info.nativeLibraryRootRequiresIsa = false;
6221            } else {
6222                final String apkName = deriveCodePathName(codePath);
6223                info.nativeLibraryRootDir = new File(mAppLib32InstallDir, apkName)
6224                        .getAbsolutePath();
6225                info.nativeLibraryRootRequiresIsa = false;
6226            }
6227        } else {
6228            // Cluster install
6229            info.nativeLibraryRootDir = new File(codeFile, LIB_DIR_NAME).getAbsolutePath();
6230            info.nativeLibraryRootRequiresIsa = true;
6231        }
6232
6233        if (info.nativeLibraryRootRequiresIsa) {
6234            if (info.primaryCpuAbi != null) {
6235                info.nativeLibraryDir = new File(info.nativeLibraryRootDir,
6236                        VMRuntime.getInstructionSet(info.primaryCpuAbi)).getAbsolutePath();
6237            }
6238        } else {
6239            info.nativeLibraryDir = info.nativeLibraryRootDir;
6240        }
6241    }
6242
6243    /**
6244     * Calculate the abis and roots for a bundled app. These can uniquely
6245     * be determined from the contents of the system partition, i.e whether
6246     * it contains 64 or 32 bit shared libraries etc. We do not validate any
6247     * of this information, and instead assume that the system was built
6248     * sensibly.
6249     */
6250    private void setBundledAppAbisAndRoots(PackageParser.Package pkg,
6251                                           PackageSetting pkgSetting) {
6252        final String apkName = deriveCodePathName(pkg.applicationInfo.getCodePath());
6253
6254        // If "/system/lib64/apkname" exists, assume that is the per-package
6255        // native library directory to use; otherwise use "/system/lib/apkname".
6256        final String apkRoot = calculateApkRoot(pkg.applicationInfo.sourceDir);
6257        pkg.applicationInfo.apkRoot = apkRoot;
6258        setBundledAppAbi(pkg, apkRoot, apkName);
6259        // pkgSetting might be null during rescan following uninstall of updates
6260        // to a bundled app, so accommodate that possibility.  The settings in
6261        // that case will be established later from the parsed package.
6262        //
6263        // If the settings aren't null, sync them up with what we've just derived.
6264        // note that apkRoot isn't stored in the package settings.
6265        if (pkgSetting != null) {
6266            pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
6267            pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
6268        }
6269    }
6270
6271    /**
6272     * Deduces the ABI of a bundled app and sets the relevant fields on the
6273     * parsed pkg object.
6274     *
6275     * @param apkRoot the root of the installed apk, something like {@code /system} or {@code /oem}
6276     *        under which system libraries are installed.
6277     * @param apkName the name of the installed package.
6278     */
6279    private static void setBundledAppAbi(PackageParser.Package pkg, String apkRoot, String apkName) {
6280        // This is of the form "/system/lib64/<packagename>", "/vendor/lib64/<packagename>"
6281        // or similar.
6282        final boolean has64BitLibs = (new File(apkRoot, new File(LIB64_DIR_NAME, apkName).getPath())).exists();
6283        final boolean has32BitLibs = (new File(apkRoot, new File(LIB_DIR_NAME, apkName).getPath())).exists();
6284
6285        if (has64BitLibs && !has32BitLibs) {
6286            // The package has 64 bit libs, but not 32 bit libs. Its primary
6287            // ABI should be 64 bit. We can safely assume here that the bundled
6288            // native libraries correspond to the most preferred ABI in the list.
6289
6290            pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6291            pkg.applicationInfo.secondaryCpuAbi = null;
6292        } else if (has32BitLibs && !has64BitLibs) {
6293            // The package has 32 bit libs but not 64 bit libs. Its primary
6294            // ABI should be 32 bit.
6295
6296            pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6297            pkg.applicationInfo.secondaryCpuAbi = null;
6298        } else if (has32BitLibs && has64BitLibs) {
6299            // The application has both 64 and 32 bit bundled libraries. We check
6300            // here that the app declares multiArch support, and warn if it doesn't.
6301            //
6302            // We will be lenient here and record both ABIs. The primary will be the
6303            // ABI that's higher on the list, i.e, a device that's configured to prefer
6304            // 64 bit apps will see a 64 bit primary ABI,
6305
6306            if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_MULTIARCH) == 0) {
6307                Slog.e(TAG, "Package: " + pkg + " has multiple bundled libs, but is not multiarch.");
6308            }
6309
6310            if (VMRuntime.is64BitInstructionSet(getPreferredInstructionSet())) {
6311                pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6312                pkg.applicationInfo.secondaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6313            } else {
6314                pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
6315                pkg.applicationInfo.secondaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
6316            }
6317        } else {
6318            pkg.applicationInfo.primaryCpuAbi = null;
6319            pkg.applicationInfo.secondaryCpuAbi = null;
6320        }
6321    }
6322
6323    private static void createNativeLibrarySubdir(File path) throws IOException {
6324        if (!path.isDirectory()) {
6325            path.delete();
6326
6327            if (!path.mkdir()) {
6328                throw new IOException("Cannot create " + path.getPath());
6329            }
6330
6331            try {
6332                Os.chmod(path.getPath(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
6333            } catch (ErrnoException e) {
6334                throw new IOException("Cannot chmod native library directory "
6335                        + path.getPath(), e);
6336            }
6337        } else if (!SELinux.restorecon(path)) {
6338            throw new IOException("Cannot set SELinux context for " + path.getPath());
6339        }
6340    }
6341
6342    private static int copyNativeLibrariesForInternalApp(NativeLibraryHelper.Handle handle,
6343            final File nativeLibraryRoot, String[] abiList, boolean useIsaSubdir) throws IOException {
6344        createNativeLibrarySubdir(nativeLibraryRoot);
6345
6346        /*
6347         * If this is an internal application or our nativeLibraryPath points to
6348         * the app-lib directory, unpack the libraries if necessary.
6349         */
6350        int abi = NativeLibraryHelper.findSupportedAbi(handle, abiList);
6351        if (abi >= 0) {
6352            /*
6353             * If we have a matching instruction set, construct a subdir under the native
6354             * library root that corresponds to this instruction set.
6355             */
6356            final String instructionSet = VMRuntime.getInstructionSet(abiList[abi]);
6357            final File subDir;
6358            if (useIsaSubdir) {
6359                final File isaSubdir = new File(nativeLibraryRoot, instructionSet);
6360                createNativeLibrarySubdir(isaSubdir);
6361                subDir = isaSubdir;
6362            } else {
6363                subDir = nativeLibraryRoot;
6364            }
6365
6366            int copyRet = NativeLibraryHelper.copyNativeBinariesIfNeededLI(handle, subDir, abiList[abi]);
6367            if (copyRet != PackageManager.INSTALL_SUCCEEDED) {
6368                return copyRet;
6369            }
6370        }
6371
6372        return abi;
6373    }
6374
6375    private void killApplication(String pkgName, int appId, String reason) {
6376        // Request the ActivityManager to kill the process(only for existing packages)
6377        // so that we do not end up in a confused state while the user is still using the older
6378        // version of the application while the new one gets installed.
6379        IActivityManager am = ActivityManagerNative.getDefault();
6380        if (am != null) {
6381            try {
6382                am.killApplicationWithAppId(pkgName, appId, reason);
6383            } catch (RemoteException e) {
6384            }
6385        }
6386    }
6387
6388    void removePackageLI(PackageSetting ps, boolean chatty) {
6389        if (DEBUG_INSTALL) {
6390            if (chatty)
6391                Log.d(TAG, "Removing package " + ps.name);
6392        }
6393
6394        // writer
6395        synchronized (mPackages) {
6396            mPackages.remove(ps.name);
6397            if (ps.codePathString != null) {
6398                mAppDirs.remove(ps.codePathString);
6399            }
6400
6401            final PackageParser.Package pkg = ps.pkg;
6402            if (pkg != null) {
6403                cleanPackageDataStructuresLILPw(pkg, chatty);
6404            }
6405        }
6406    }
6407
6408    void removeInstalledPackageLI(PackageParser.Package pkg, boolean chatty) {
6409        if (DEBUG_INSTALL) {
6410            if (chatty)
6411                Log.d(TAG, "Removing package " + pkg.applicationInfo.packageName);
6412        }
6413
6414        // writer
6415        synchronized (mPackages) {
6416            mPackages.remove(pkg.applicationInfo.packageName);
6417            if (pkg.codePath != null) {
6418                mAppDirs.remove(pkg.codePath);
6419            }
6420            cleanPackageDataStructuresLILPw(pkg, chatty);
6421        }
6422    }
6423
6424    void cleanPackageDataStructuresLILPw(PackageParser.Package pkg, boolean chatty) {
6425        int N = pkg.providers.size();
6426        StringBuilder r = null;
6427        int i;
6428        for (i=0; i<N; i++) {
6429            PackageParser.Provider p = pkg.providers.get(i);
6430            mProviders.removeProvider(p);
6431            if (p.info.authority == null) {
6432
6433                /* There was another ContentProvider with this authority when
6434                 * this app was installed so this authority is null,
6435                 * Ignore it as we don't have to unregister the provider.
6436                 */
6437                continue;
6438            }
6439            String names[] = p.info.authority.split(";");
6440            for (int j = 0; j < names.length; j++) {
6441                if (mProvidersByAuthority.get(names[j]) == p) {
6442                    mProvidersByAuthority.remove(names[j]);
6443                    if (DEBUG_REMOVE) {
6444                        if (chatty)
6445                            Log.d(TAG, "Unregistered content provider: " + names[j]
6446                                    + ", className = " + p.info.name + ", isSyncable = "
6447                                    + p.info.isSyncable);
6448                    }
6449                }
6450            }
6451            if (DEBUG_REMOVE && chatty) {
6452                if (r == null) {
6453                    r = new StringBuilder(256);
6454                } else {
6455                    r.append(' ');
6456                }
6457                r.append(p.info.name);
6458            }
6459        }
6460        if (r != null) {
6461            if (DEBUG_REMOVE) Log.d(TAG, "  Providers: " + r);
6462        }
6463
6464        N = pkg.services.size();
6465        r = null;
6466        for (i=0; i<N; i++) {
6467            PackageParser.Service s = pkg.services.get(i);
6468            mServices.removeService(s);
6469            if (chatty) {
6470                if (r == null) {
6471                    r = new StringBuilder(256);
6472                } else {
6473                    r.append(' ');
6474                }
6475                r.append(s.info.name);
6476            }
6477        }
6478        if (r != null) {
6479            if (DEBUG_REMOVE) Log.d(TAG, "  Services: " + r);
6480        }
6481
6482        N = pkg.receivers.size();
6483        r = null;
6484        for (i=0; i<N; i++) {
6485            PackageParser.Activity a = pkg.receivers.get(i);
6486            mReceivers.removeActivity(a, "receiver");
6487            if (DEBUG_REMOVE && chatty) {
6488                if (r == null) {
6489                    r = new StringBuilder(256);
6490                } else {
6491                    r.append(' ');
6492                }
6493                r.append(a.info.name);
6494            }
6495        }
6496        if (r != null) {
6497            if (DEBUG_REMOVE) Log.d(TAG, "  Receivers: " + r);
6498        }
6499
6500        N = pkg.activities.size();
6501        r = null;
6502        for (i=0; i<N; i++) {
6503            PackageParser.Activity a = pkg.activities.get(i);
6504            mActivities.removeActivity(a, "activity");
6505            if (DEBUG_REMOVE && chatty) {
6506                if (r == null) {
6507                    r = new StringBuilder(256);
6508                } else {
6509                    r.append(' ');
6510                }
6511                r.append(a.info.name);
6512            }
6513        }
6514        if (r != null) {
6515            if (DEBUG_REMOVE) Log.d(TAG, "  Activities: " + r);
6516        }
6517
6518        N = pkg.permissions.size();
6519        r = null;
6520        for (i=0; i<N; i++) {
6521            PackageParser.Permission p = pkg.permissions.get(i);
6522            BasePermission bp = mSettings.mPermissions.get(p.info.name);
6523            if (bp == null) {
6524                bp = mSettings.mPermissionTrees.get(p.info.name);
6525            }
6526            if (bp != null && bp.perm == p) {
6527                bp.perm = null;
6528                if (DEBUG_REMOVE && chatty) {
6529                    if (r == null) {
6530                        r = new StringBuilder(256);
6531                    } else {
6532                        r.append(' ');
6533                    }
6534                    r.append(p.info.name);
6535                }
6536            }
6537        }
6538        if (r != null) {
6539            if (DEBUG_REMOVE) Log.d(TAG, "  Permissions: " + r);
6540        }
6541
6542        N = pkg.instrumentation.size();
6543        r = null;
6544        for (i=0; i<N; i++) {
6545            PackageParser.Instrumentation a = pkg.instrumentation.get(i);
6546            mInstrumentation.remove(a.getComponentName());
6547            if (DEBUG_REMOVE && chatty) {
6548                if (r == null) {
6549                    r = new StringBuilder(256);
6550                } else {
6551                    r.append(' ');
6552                }
6553                r.append(a.info.name);
6554            }
6555        }
6556        if (r != null) {
6557            if (DEBUG_REMOVE) Log.d(TAG, "  Instrumentation: " + r);
6558        }
6559
6560        r = null;
6561        if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
6562            // Only system apps can hold shared libraries.
6563            if (pkg.libraryNames != null) {
6564                for (i=0; i<pkg.libraryNames.size(); i++) {
6565                    String name = pkg.libraryNames.get(i);
6566                    SharedLibraryEntry cur = mSharedLibraries.get(name);
6567                    if (cur != null && cur.apk != null && cur.apk.equals(pkg.packageName)) {
6568                        mSharedLibraries.remove(name);
6569                        if (DEBUG_REMOVE && chatty) {
6570                            if (r == null) {
6571                                r = new StringBuilder(256);
6572                            } else {
6573                                r.append(' ');
6574                            }
6575                            r.append(name);
6576                        }
6577                    }
6578                }
6579            }
6580        }
6581        if (r != null) {
6582            if (DEBUG_REMOVE) Log.d(TAG, "  Libraries: " + r);
6583        }
6584    }
6585
6586    private static boolean hasPermission(PackageParser.Package pkgInfo, String perm) {
6587        for (int i=pkgInfo.permissions.size()-1; i>=0; i--) {
6588            if (pkgInfo.permissions.get(i).info.name.equals(perm)) {
6589                return true;
6590            }
6591        }
6592        return false;
6593    }
6594
6595    static final int UPDATE_PERMISSIONS_ALL = 1<<0;
6596    static final int UPDATE_PERMISSIONS_REPLACE_PKG = 1<<1;
6597    static final int UPDATE_PERMISSIONS_REPLACE_ALL = 1<<2;
6598
6599    private void updatePermissionsLPw(String changingPkg,
6600            PackageParser.Package pkgInfo, int flags) {
6601        // Make sure there are no dangling permission trees.
6602        Iterator<BasePermission> it = mSettings.mPermissionTrees.values().iterator();
6603        while (it.hasNext()) {
6604            final BasePermission bp = it.next();
6605            if (bp.packageSetting == null) {
6606                // We may not yet have parsed the package, so just see if
6607                // we still know about its settings.
6608                bp.packageSetting = mSettings.mPackages.get(bp.sourcePackage);
6609            }
6610            if (bp.packageSetting == null) {
6611                Slog.w(TAG, "Removing dangling permission tree: " + bp.name
6612                        + " from package " + bp.sourcePackage);
6613                it.remove();
6614            } else if (changingPkg != null && changingPkg.equals(bp.sourcePackage)) {
6615                if (pkgInfo == null || !hasPermission(pkgInfo, bp.name)) {
6616                    Slog.i(TAG, "Removing old permission tree: " + bp.name
6617                            + " from package " + bp.sourcePackage);
6618                    flags |= UPDATE_PERMISSIONS_ALL;
6619                    it.remove();
6620                }
6621            }
6622        }
6623
6624        // Make sure all dynamic permissions have been assigned to a package,
6625        // and make sure there are no dangling permissions.
6626        it = mSettings.mPermissions.values().iterator();
6627        while (it.hasNext()) {
6628            final BasePermission bp = it.next();
6629            if (bp.type == BasePermission.TYPE_DYNAMIC) {
6630                if (DEBUG_SETTINGS) Log.v(TAG, "Dynamic permission: name="
6631                        + bp.name + " pkg=" + bp.sourcePackage
6632                        + " info=" + bp.pendingInfo);
6633                if (bp.packageSetting == null && bp.pendingInfo != null) {
6634                    final BasePermission tree = findPermissionTreeLP(bp.name);
6635                    if (tree != null && tree.perm != null) {
6636                        bp.packageSetting = tree.packageSetting;
6637                        bp.perm = new PackageParser.Permission(tree.perm.owner,
6638                                new PermissionInfo(bp.pendingInfo));
6639                        bp.perm.info.packageName = tree.perm.info.packageName;
6640                        bp.perm.info.name = bp.name;
6641                        bp.uid = tree.uid;
6642                    }
6643                }
6644            }
6645            if (bp.packageSetting == null) {
6646                // We may not yet have parsed the package, so just see if
6647                // we still know about its settings.
6648                bp.packageSetting = mSettings.mPackages.get(bp.sourcePackage);
6649            }
6650            if (bp.packageSetting == null) {
6651                Slog.w(TAG, "Removing dangling permission: " + bp.name
6652                        + " from package " + bp.sourcePackage);
6653                it.remove();
6654            } else if (changingPkg != null && changingPkg.equals(bp.sourcePackage)) {
6655                if (pkgInfo == null || !hasPermission(pkgInfo, bp.name)) {
6656                    Slog.i(TAG, "Removing old permission: " + bp.name
6657                            + " from package " + bp.sourcePackage);
6658                    flags |= UPDATE_PERMISSIONS_ALL;
6659                    it.remove();
6660                }
6661            }
6662        }
6663
6664        // Now update the permissions for all packages, in particular
6665        // replace the granted permissions of the system packages.
6666        if ((flags&UPDATE_PERMISSIONS_ALL) != 0) {
6667            for (PackageParser.Package pkg : mPackages.values()) {
6668                if (pkg != pkgInfo) {
6669                    grantPermissionsLPw(pkg, (flags&UPDATE_PERMISSIONS_REPLACE_ALL) != 0);
6670                }
6671            }
6672        }
6673
6674        if (pkgInfo != null) {
6675            grantPermissionsLPw(pkgInfo, (flags&UPDATE_PERMISSIONS_REPLACE_PKG) != 0);
6676        }
6677    }
6678
6679    private void grantPermissionsLPw(PackageParser.Package pkg, boolean replace) {
6680        final PackageSetting ps = (PackageSetting) pkg.mExtras;
6681        if (ps == null) {
6682            return;
6683        }
6684        final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
6685        HashSet<String> origPermissions = gp.grantedPermissions;
6686        boolean changedPermission = false;
6687
6688        if (replace) {
6689            ps.permissionsFixed = false;
6690            if (gp == ps) {
6691                origPermissions = new HashSet<String>(gp.grantedPermissions);
6692                gp.grantedPermissions.clear();
6693                gp.gids = mGlobalGids;
6694            }
6695        }
6696
6697        if (gp.gids == null) {
6698            gp.gids = mGlobalGids;
6699        }
6700
6701        final int N = pkg.requestedPermissions.size();
6702        for (int i=0; i<N; i++) {
6703            final String name = pkg.requestedPermissions.get(i);
6704            final boolean required = pkg.requestedPermissionsRequired.get(i);
6705            final BasePermission bp = mSettings.mPermissions.get(name);
6706            if (DEBUG_INSTALL) {
6707                if (gp != ps) {
6708                    Log.i(TAG, "Package " + pkg.packageName + " checking " + name + ": " + bp);
6709                }
6710            }
6711
6712            if (bp == null || bp.packageSetting == null) {
6713                Slog.w(TAG, "Unknown permission " + name
6714                        + " in package " + pkg.packageName);
6715                continue;
6716            }
6717
6718            final String perm = bp.name;
6719            boolean allowed;
6720            boolean allowedSig = false;
6721            final int level = bp.protectionLevel & PermissionInfo.PROTECTION_MASK_BASE;
6722            if (level == PermissionInfo.PROTECTION_NORMAL
6723                    || level == PermissionInfo.PROTECTION_DANGEROUS) {
6724                // We grant a normal or dangerous permission if any of the following
6725                // are true:
6726                // 1) The permission is required
6727                // 2) The permission is optional, but was granted in the past
6728                // 3) The permission is optional, but was requested by an
6729                //    app in /system (not /data)
6730                //
6731                // Otherwise, reject the permission.
6732                allowed = (required || origPermissions.contains(perm)
6733                        || (isSystemApp(ps) && !isUpdatedSystemApp(ps)));
6734            } else if (bp.packageSetting == null) {
6735                // This permission is invalid; skip it.
6736                allowed = false;
6737            } else if (level == PermissionInfo.PROTECTION_SIGNATURE) {
6738                allowed = grantSignaturePermission(perm, pkg, bp, origPermissions);
6739                if (allowed) {
6740                    allowedSig = true;
6741                }
6742            } else {
6743                allowed = false;
6744            }
6745            if (DEBUG_INSTALL) {
6746                if (gp != ps) {
6747                    Log.i(TAG, "Package " + pkg.packageName + " granting " + perm);
6748                }
6749            }
6750            if (allowed) {
6751                if (!isSystemApp(ps) && ps.permissionsFixed) {
6752                    // If this is an existing, non-system package, then
6753                    // we can't add any new permissions to it.
6754                    if (!allowedSig && !gp.grantedPermissions.contains(perm)) {
6755                        // Except...  if this is a permission that was added
6756                        // to the platform (note: need to only do this when
6757                        // updating the platform).
6758                        allowed = isNewPlatformPermissionForPackage(perm, pkg);
6759                    }
6760                }
6761                if (allowed) {
6762                    if (!gp.grantedPermissions.contains(perm)) {
6763                        changedPermission = true;
6764                        gp.grantedPermissions.add(perm);
6765                        gp.gids = appendInts(gp.gids, bp.gids);
6766                    } else if (!ps.haveGids) {
6767                        gp.gids = appendInts(gp.gids, bp.gids);
6768                    }
6769                } else {
6770                    Slog.w(TAG, "Not granting permission " + perm
6771                            + " to package " + pkg.packageName
6772                            + " because it was previously installed without");
6773                }
6774            } else {
6775                if (gp.grantedPermissions.remove(perm)) {
6776                    changedPermission = true;
6777                    gp.gids = removeInts(gp.gids, bp.gids);
6778                    Slog.i(TAG, "Un-granting permission " + perm
6779                            + " from package " + pkg.packageName
6780                            + " (protectionLevel=" + bp.protectionLevel
6781                            + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags)
6782                            + ")");
6783                } else {
6784                    Slog.w(TAG, "Not granting permission " + perm
6785                            + " to package " + pkg.packageName
6786                            + " (protectionLevel=" + bp.protectionLevel
6787                            + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags)
6788                            + ")");
6789                }
6790            }
6791        }
6792
6793        if ((changedPermission || replace) && !ps.permissionsFixed &&
6794                !isSystemApp(ps) || isUpdatedSystemApp(ps)){
6795            // This is the first that we have heard about this package, so the
6796            // permissions we have now selected are fixed until explicitly
6797            // changed.
6798            ps.permissionsFixed = true;
6799        }
6800        ps.haveGids = true;
6801    }
6802
6803    private boolean isNewPlatformPermissionForPackage(String perm, PackageParser.Package pkg) {
6804        boolean allowed = false;
6805        final int NP = PackageParser.NEW_PERMISSIONS.length;
6806        for (int ip=0; ip<NP; ip++) {
6807            final PackageParser.NewPermissionInfo npi
6808                    = PackageParser.NEW_PERMISSIONS[ip];
6809            if (npi.name.equals(perm)
6810                    && pkg.applicationInfo.targetSdkVersion < npi.sdkVersion) {
6811                allowed = true;
6812                Log.i(TAG, "Auto-granting " + perm + " to old pkg "
6813                        + pkg.packageName);
6814                break;
6815            }
6816        }
6817        return allowed;
6818    }
6819
6820    private boolean grantSignaturePermission(String perm, PackageParser.Package pkg,
6821                                          BasePermission bp, HashSet<String> origPermissions) {
6822        boolean allowed;
6823        allowed = (compareSignatures(
6824                bp.packageSetting.signatures.mSignatures, pkg.mSignatures)
6825                        == PackageManager.SIGNATURE_MATCH)
6826                || (compareSignatures(mPlatformPackage.mSignatures, pkg.mSignatures)
6827                        == PackageManager.SIGNATURE_MATCH);
6828        if (!allowed && (bp.protectionLevel
6829                & PermissionInfo.PROTECTION_FLAG_SYSTEM) != 0) {
6830            if (isSystemApp(pkg)) {
6831                // For updated system applications, a system permission
6832                // is granted only if it had been defined by the original application.
6833                if (isUpdatedSystemApp(pkg)) {
6834                    final PackageSetting sysPs = mSettings
6835                            .getDisabledSystemPkgLPr(pkg.packageName);
6836                    final GrantedPermissions origGp = sysPs.sharedUser != null
6837                            ? sysPs.sharedUser : sysPs;
6838
6839                    if (origGp.grantedPermissions.contains(perm)) {
6840                        // If the original was granted this permission, we take
6841                        // that grant decision as read and propagate it to the
6842                        // update.
6843                        allowed = true;
6844                    } else {
6845                        // The system apk may have been updated with an older
6846                        // version of the one on the data partition, but which
6847                        // granted a new system permission that it didn't have
6848                        // before.  In this case we do want to allow the app to
6849                        // now get the new permission if the ancestral apk is
6850                        // privileged to get it.
6851                        if (sysPs.pkg != null && sysPs.isPrivileged()) {
6852                            for (int j=0;
6853                                    j<sysPs.pkg.requestedPermissions.size(); j++) {
6854                                if (perm.equals(
6855                                        sysPs.pkg.requestedPermissions.get(j))) {
6856                                    allowed = true;
6857                                    break;
6858                                }
6859                            }
6860                        }
6861                    }
6862                } else {
6863                    allowed = isPrivilegedApp(pkg);
6864                }
6865            }
6866        }
6867        if (!allowed && (bp.protectionLevel
6868                & PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0) {
6869            // For development permissions, a development permission
6870            // is granted only if it was already granted.
6871            allowed = origPermissions.contains(perm);
6872        }
6873        return allowed;
6874    }
6875
6876    final class ActivityIntentResolver
6877            extends IntentResolver<PackageParser.ActivityIntentInfo, ResolveInfo> {
6878        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
6879                boolean defaultOnly, int userId) {
6880            if (!sUserManager.exists(userId)) return null;
6881            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
6882            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
6883        }
6884
6885        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
6886                int userId) {
6887            if (!sUserManager.exists(userId)) return null;
6888            mFlags = flags;
6889            return super.queryIntent(intent, resolvedType,
6890                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
6891        }
6892
6893        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
6894                int flags, ArrayList<PackageParser.Activity> packageActivities, int userId) {
6895            if (!sUserManager.exists(userId)) return null;
6896            if (packageActivities == null) {
6897                return null;
6898            }
6899            mFlags = flags;
6900            final boolean defaultOnly = (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0;
6901            final int N = packageActivities.size();
6902            ArrayList<PackageParser.ActivityIntentInfo[]> listCut =
6903                new ArrayList<PackageParser.ActivityIntentInfo[]>(N);
6904
6905            ArrayList<PackageParser.ActivityIntentInfo> intentFilters;
6906            for (int i = 0; i < N; ++i) {
6907                intentFilters = packageActivities.get(i).intents;
6908                if (intentFilters != null && intentFilters.size() > 0) {
6909                    PackageParser.ActivityIntentInfo[] array =
6910                            new PackageParser.ActivityIntentInfo[intentFilters.size()];
6911                    intentFilters.toArray(array);
6912                    listCut.add(array);
6913                }
6914            }
6915            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
6916        }
6917
6918        public final void addActivity(PackageParser.Activity a, String type) {
6919            final boolean systemApp = isSystemApp(a.info.applicationInfo);
6920            mActivities.put(a.getComponentName(), a);
6921            if (DEBUG_SHOW_INFO)
6922                Log.v(
6923                TAG, "  " + type + " " +
6924                (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel : a.info.name) + ":");
6925            if (DEBUG_SHOW_INFO)
6926                Log.v(TAG, "    Class=" + a.info.name);
6927            final int NI = a.intents.size();
6928            for (int j=0; j<NI; j++) {
6929                PackageParser.ActivityIntentInfo intent = a.intents.get(j);
6930                if (!systemApp && intent.getPriority() > 0 && "activity".equals(type)) {
6931                    intent.setPriority(0);
6932                    Log.w(TAG, "Package " + a.info.applicationInfo.packageName + " has activity "
6933                            + a.className + " with priority > 0, forcing to 0");
6934                }
6935                if (DEBUG_SHOW_INFO) {
6936                    Log.v(TAG, "    IntentFilter:");
6937                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
6938                }
6939                if (!intent.debugCheck()) {
6940                    Log.w(TAG, "==> For Activity " + a.info.name);
6941                }
6942                addFilter(intent);
6943            }
6944        }
6945
6946        public final void removeActivity(PackageParser.Activity a, String type) {
6947            mActivities.remove(a.getComponentName());
6948            if (DEBUG_SHOW_INFO) {
6949                Log.v(TAG, "  " + type + " "
6950                        + (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel
6951                                : a.info.name) + ":");
6952                Log.v(TAG, "    Class=" + a.info.name);
6953            }
6954            final int NI = a.intents.size();
6955            for (int j=0; j<NI; j++) {
6956                PackageParser.ActivityIntentInfo intent = a.intents.get(j);
6957                if (DEBUG_SHOW_INFO) {
6958                    Log.v(TAG, "    IntentFilter:");
6959                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
6960                }
6961                removeFilter(intent);
6962            }
6963        }
6964
6965        @Override
6966        protected boolean allowFilterResult(
6967                PackageParser.ActivityIntentInfo filter, List<ResolveInfo> dest) {
6968            ActivityInfo filterAi = filter.activity.info;
6969            for (int i=dest.size()-1; i>=0; i--) {
6970                ActivityInfo destAi = dest.get(i).activityInfo;
6971                if (destAi.name == filterAi.name
6972                        && destAi.packageName == filterAi.packageName) {
6973                    return false;
6974                }
6975            }
6976            return true;
6977        }
6978
6979        @Override
6980        protected ActivityIntentInfo[] newArray(int size) {
6981            return new ActivityIntentInfo[size];
6982        }
6983
6984        @Override
6985        protected boolean isFilterStopped(PackageParser.ActivityIntentInfo filter, int userId) {
6986            if (!sUserManager.exists(userId)) return true;
6987            PackageParser.Package p = filter.activity.owner;
6988            if (p != null) {
6989                PackageSetting ps = (PackageSetting)p.mExtras;
6990                if (ps != null) {
6991                    // System apps are never considered stopped for purposes of
6992                    // filtering, because there may be no way for the user to
6993                    // actually re-launch them.
6994                    return (ps.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0
6995                            && ps.getStopped(userId);
6996                }
6997            }
6998            return false;
6999        }
7000
7001        @Override
7002        protected boolean isPackageForFilter(String packageName,
7003                PackageParser.ActivityIntentInfo info) {
7004            return packageName.equals(info.activity.owner.packageName);
7005        }
7006
7007        @Override
7008        protected ResolveInfo newResult(PackageParser.ActivityIntentInfo info,
7009                int match, int userId) {
7010            if (!sUserManager.exists(userId)) return null;
7011            if (!mSettings.isEnabledLPr(info.activity.info, mFlags, userId)) {
7012                return null;
7013            }
7014            final PackageParser.Activity activity = info.activity;
7015            if (mSafeMode && (activity.info.applicationInfo.flags
7016                    &ApplicationInfo.FLAG_SYSTEM) == 0) {
7017                return null;
7018            }
7019            PackageSetting ps = (PackageSetting) activity.owner.mExtras;
7020            if (ps == null) {
7021                return null;
7022            }
7023            ActivityInfo ai = PackageParser.generateActivityInfo(activity, mFlags,
7024                    ps.readUserState(userId), userId);
7025            if (ai == null) {
7026                return null;
7027            }
7028            final ResolveInfo res = new ResolveInfo();
7029            res.activityInfo = ai;
7030            if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) {
7031                res.filter = info;
7032            }
7033            res.priority = info.getPriority();
7034            res.preferredOrder = activity.owner.mPreferredOrder;
7035            //System.out.println("Result: " + res.activityInfo.className +
7036            //                   " = " + res.priority);
7037            res.match = match;
7038            res.isDefault = info.hasDefault;
7039            res.labelRes = info.labelRes;
7040            res.nonLocalizedLabel = info.nonLocalizedLabel;
7041            if (userNeedsBadging(userId)) {
7042                res.noResourceId = true;
7043            } else {
7044                res.icon = info.icon;
7045            }
7046            res.system = isSystemApp(res.activityInfo.applicationInfo);
7047            return res;
7048        }
7049
7050        @Override
7051        protected void sortResults(List<ResolveInfo> results) {
7052            Collections.sort(results, mResolvePrioritySorter);
7053        }
7054
7055        @Override
7056        protected void dumpFilter(PrintWriter out, String prefix,
7057                PackageParser.ActivityIntentInfo filter) {
7058            out.print(prefix); out.print(
7059                    Integer.toHexString(System.identityHashCode(filter.activity)));
7060                    out.print(' ');
7061                    filter.activity.printComponentShortName(out);
7062                    out.print(" filter ");
7063                    out.println(Integer.toHexString(System.identityHashCode(filter)));
7064        }
7065
7066//        List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) {
7067//            final Iterator<ResolveInfo> i = resolveInfoList.iterator();
7068//            final List<ResolveInfo> retList = Lists.newArrayList();
7069//            while (i.hasNext()) {
7070//                final ResolveInfo resolveInfo = i.next();
7071//                if (isEnabledLP(resolveInfo.activityInfo)) {
7072//                    retList.add(resolveInfo);
7073//                }
7074//            }
7075//            return retList;
7076//        }
7077
7078        // Keys are String (activity class name), values are Activity.
7079        private final HashMap<ComponentName, PackageParser.Activity> mActivities
7080                = new HashMap<ComponentName, PackageParser.Activity>();
7081        private int mFlags;
7082    }
7083
7084    private final class ServiceIntentResolver
7085            extends IntentResolver<PackageParser.ServiceIntentInfo, ResolveInfo> {
7086        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
7087                boolean defaultOnly, int userId) {
7088            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
7089            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
7090        }
7091
7092        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
7093                int userId) {
7094            if (!sUserManager.exists(userId)) return null;
7095            mFlags = flags;
7096            return super.queryIntent(intent, resolvedType,
7097                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
7098        }
7099
7100        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
7101                int flags, ArrayList<PackageParser.Service> packageServices, int userId) {
7102            if (!sUserManager.exists(userId)) return null;
7103            if (packageServices == null) {
7104                return null;
7105            }
7106            mFlags = flags;
7107            final boolean defaultOnly = (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0;
7108            final int N = packageServices.size();
7109            ArrayList<PackageParser.ServiceIntentInfo[]> listCut =
7110                new ArrayList<PackageParser.ServiceIntentInfo[]>(N);
7111
7112            ArrayList<PackageParser.ServiceIntentInfo> intentFilters;
7113            for (int i = 0; i < N; ++i) {
7114                intentFilters = packageServices.get(i).intents;
7115                if (intentFilters != null && intentFilters.size() > 0) {
7116                    PackageParser.ServiceIntentInfo[] array =
7117                            new PackageParser.ServiceIntentInfo[intentFilters.size()];
7118                    intentFilters.toArray(array);
7119                    listCut.add(array);
7120                }
7121            }
7122            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
7123        }
7124
7125        public final void addService(PackageParser.Service s) {
7126            mServices.put(s.getComponentName(), s);
7127            if (DEBUG_SHOW_INFO) {
7128                Log.v(TAG, "  "
7129                        + (s.info.nonLocalizedLabel != null
7130                        ? s.info.nonLocalizedLabel : s.info.name) + ":");
7131                Log.v(TAG, "    Class=" + s.info.name);
7132            }
7133            final int NI = s.intents.size();
7134            int j;
7135            for (j=0; j<NI; j++) {
7136                PackageParser.ServiceIntentInfo intent = s.intents.get(j);
7137                if (DEBUG_SHOW_INFO) {
7138                    Log.v(TAG, "    IntentFilter:");
7139                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7140                }
7141                if (!intent.debugCheck()) {
7142                    Log.w(TAG, "==> For Service " + s.info.name);
7143                }
7144                addFilter(intent);
7145            }
7146        }
7147
7148        public final void removeService(PackageParser.Service s) {
7149            mServices.remove(s.getComponentName());
7150            if (DEBUG_SHOW_INFO) {
7151                Log.v(TAG, "  " + (s.info.nonLocalizedLabel != null
7152                        ? s.info.nonLocalizedLabel : s.info.name) + ":");
7153                Log.v(TAG, "    Class=" + s.info.name);
7154            }
7155            final int NI = s.intents.size();
7156            int j;
7157            for (j=0; j<NI; j++) {
7158                PackageParser.ServiceIntentInfo intent = s.intents.get(j);
7159                if (DEBUG_SHOW_INFO) {
7160                    Log.v(TAG, "    IntentFilter:");
7161                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7162                }
7163                removeFilter(intent);
7164            }
7165        }
7166
7167        @Override
7168        protected boolean allowFilterResult(
7169                PackageParser.ServiceIntentInfo filter, List<ResolveInfo> dest) {
7170            ServiceInfo filterSi = filter.service.info;
7171            for (int i=dest.size()-1; i>=0; i--) {
7172                ServiceInfo destAi = dest.get(i).serviceInfo;
7173                if (destAi.name == filterSi.name
7174                        && destAi.packageName == filterSi.packageName) {
7175                    return false;
7176                }
7177            }
7178            return true;
7179        }
7180
7181        @Override
7182        protected PackageParser.ServiceIntentInfo[] newArray(int size) {
7183            return new PackageParser.ServiceIntentInfo[size];
7184        }
7185
7186        @Override
7187        protected boolean isFilterStopped(PackageParser.ServiceIntentInfo filter, int userId) {
7188            if (!sUserManager.exists(userId)) return true;
7189            PackageParser.Package p = filter.service.owner;
7190            if (p != null) {
7191                PackageSetting ps = (PackageSetting)p.mExtras;
7192                if (ps != null) {
7193                    // System apps are never considered stopped for purposes of
7194                    // filtering, because there may be no way for the user to
7195                    // actually re-launch them.
7196                    return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0
7197                            && ps.getStopped(userId);
7198                }
7199            }
7200            return false;
7201        }
7202
7203        @Override
7204        protected boolean isPackageForFilter(String packageName,
7205                PackageParser.ServiceIntentInfo info) {
7206            return packageName.equals(info.service.owner.packageName);
7207        }
7208
7209        @Override
7210        protected ResolveInfo newResult(PackageParser.ServiceIntentInfo filter,
7211                int match, int userId) {
7212            if (!sUserManager.exists(userId)) return null;
7213            final PackageParser.ServiceIntentInfo info = (PackageParser.ServiceIntentInfo)filter;
7214            if (!mSettings.isEnabledLPr(info.service.info, mFlags, userId)) {
7215                return null;
7216            }
7217            final PackageParser.Service service = info.service;
7218            if (mSafeMode && (service.info.applicationInfo.flags
7219                    &ApplicationInfo.FLAG_SYSTEM) == 0) {
7220                return null;
7221            }
7222            PackageSetting ps = (PackageSetting) service.owner.mExtras;
7223            if (ps == null) {
7224                return null;
7225            }
7226            ServiceInfo si = PackageParser.generateServiceInfo(service, mFlags,
7227                    ps.readUserState(userId), userId);
7228            if (si == null) {
7229                return null;
7230            }
7231            final ResolveInfo res = new ResolveInfo();
7232            res.serviceInfo = si;
7233            if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) {
7234                res.filter = filter;
7235            }
7236            res.priority = info.getPriority();
7237            res.preferredOrder = service.owner.mPreferredOrder;
7238            //System.out.println("Result: " + res.activityInfo.className +
7239            //                   " = " + res.priority);
7240            res.match = match;
7241            res.isDefault = info.hasDefault;
7242            res.labelRes = info.labelRes;
7243            res.nonLocalizedLabel = info.nonLocalizedLabel;
7244            res.icon = info.icon;
7245            res.system = isSystemApp(res.serviceInfo.applicationInfo);
7246            return res;
7247        }
7248
7249        @Override
7250        protected void sortResults(List<ResolveInfo> results) {
7251            Collections.sort(results, mResolvePrioritySorter);
7252        }
7253
7254        @Override
7255        protected void dumpFilter(PrintWriter out, String prefix,
7256                PackageParser.ServiceIntentInfo filter) {
7257            out.print(prefix); out.print(
7258                    Integer.toHexString(System.identityHashCode(filter.service)));
7259                    out.print(' ');
7260                    filter.service.printComponentShortName(out);
7261                    out.print(" filter ");
7262                    out.println(Integer.toHexString(System.identityHashCode(filter)));
7263        }
7264
7265//        List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) {
7266//            final Iterator<ResolveInfo> i = resolveInfoList.iterator();
7267//            final List<ResolveInfo> retList = Lists.newArrayList();
7268//            while (i.hasNext()) {
7269//                final ResolveInfo resolveInfo = (ResolveInfo) i;
7270//                if (isEnabledLP(resolveInfo.serviceInfo)) {
7271//                    retList.add(resolveInfo);
7272//                }
7273//            }
7274//            return retList;
7275//        }
7276
7277        // Keys are String (activity class name), values are Activity.
7278        private final HashMap<ComponentName, PackageParser.Service> mServices
7279                = new HashMap<ComponentName, PackageParser.Service>();
7280        private int mFlags;
7281    };
7282
7283    private final class ProviderIntentResolver
7284            extends IntentResolver<PackageParser.ProviderIntentInfo, ResolveInfo> {
7285        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
7286                boolean defaultOnly, int userId) {
7287            mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
7288            return super.queryIntent(intent, resolvedType, defaultOnly, userId);
7289        }
7290
7291        public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
7292                int userId) {
7293            if (!sUserManager.exists(userId))
7294                return null;
7295            mFlags = flags;
7296            return super.queryIntent(intent, resolvedType,
7297                    (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
7298        }
7299
7300        public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
7301                int flags, ArrayList<PackageParser.Provider> packageProviders, int userId) {
7302            if (!sUserManager.exists(userId))
7303                return null;
7304            if (packageProviders == null) {
7305                return null;
7306            }
7307            mFlags = flags;
7308            final boolean defaultOnly = (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0;
7309            final int N = packageProviders.size();
7310            ArrayList<PackageParser.ProviderIntentInfo[]> listCut =
7311                    new ArrayList<PackageParser.ProviderIntentInfo[]>(N);
7312
7313            ArrayList<PackageParser.ProviderIntentInfo> intentFilters;
7314            for (int i = 0; i < N; ++i) {
7315                intentFilters = packageProviders.get(i).intents;
7316                if (intentFilters != null && intentFilters.size() > 0) {
7317                    PackageParser.ProviderIntentInfo[] array =
7318                            new PackageParser.ProviderIntentInfo[intentFilters.size()];
7319                    intentFilters.toArray(array);
7320                    listCut.add(array);
7321                }
7322            }
7323            return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
7324        }
7325
7326        public final void addProvider(PackageParser.Provider p) {
7327            if (mProviders.containsKey(p.getComponentName())) {
7328                Slog.w(TAG, "Provider " + p.getComponentName() + " already defined; ignoring");
7329                return;
7330            }
7331
7332            mProviders.put(p.getComponentName(), p);
7333            if (DEBUG_SHOW_INFO) {
7334                Log.v(TAG, "  "
7335                        + (p.info.nonLocalizedLabel != null
7336                                ? p.info.nonLocalizedLabel : p.info.name) + ":");
7337                Log.v(TAG, "    Class=" + p.info.name);
7338            }
7339            final int NI = p.intents.size();
7340            int j;
7341            for (j = 0; j < NI; j++) {
7342                PackageParser.ProviderIntentInfo intent = p.intents.get(j);
7343                if (DEBUG_SHOW_INFO) {
7344                    Log.v(TAG, "    IntentFilter:");
7345                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7346                }
7347                if (!intent.debugCheck()) {
7348                    Log.w(TAG, "==> For Provider " + p.info.name);
7349                }
7350                addFilter(intent);
7351            }
7352        }
7353
7354        public final void removeProvider(PackageParser.Provider p) {
7355            mProviders.remove(p.getComponentName());
7356            if (DEBUG_SHOW_INFO) {
7357                Log.v(TAG, "  " + (p.info.nonLocalizedLabel != null
7358                        ? p.info.nonLocalizedLabel : p.info.name) + ":");
7359                Log.v(TAG, "    Class=" + p.info.name);
7360            }
7361            final int NI = p.intents.size();
7362            int j;
7363            for (j = 0; j < NI; j++) {
7364                PackageParser.ProviderIntentInfo intent = p.intents.get(j);
7365                if (DEBUG_SHOW_INFO) {
7366                    Log.v(TAG, "    IntentFilter:");
7367                    intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");
7368                }
7369                removeFilter(intent);
7370            }
7371        }
7372
7373        @Override
7374        protected boolean allowFilterResult(
7375                PackageParser.ProviderIntentInfo filter, List<ResolveInfo> dest) {
7376            ProviderInfo filterPi = filter.provider.info;
7377            for (int i = dest.size() - 1; i >= 0; i--) {
7378                ProviderInfo destPi = dest.get(i).providerInfo;
7379                if (destPi.name == filterPi.name
7380                        && destPi.packageName == filterPi.packageName) {
7381                    return false;
7382                }
7383            }
7384            return true;
7385        }
7386
7387        @Override
7388        protected PackageParser.ProviderIntentInfo[] newArray(int size) {
7389            return new PackageParser.ProviderIntentInfo[size];
7390        }
7391
7392        @Override
7393        protected boolean isFilterStopped(PackageParser.ProviderIntentInfo filter, int userId) {
7394            if (!sUserManager.exists(userId))
7395                return true;
7396            PackageParser.Package p = filter.provider.owner;
7397            if (p != null) {
7398                PackageSetting ps = (PackageSetting) p.mExtras;
7399                if (ps != null) {
7400                    // System apps are never considered stopped for purposes of
7401                    // filtering, because there may be no way for the user to
7402                    // actually re-launch them.
7403                    return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0
7404                            && ps.getStopped(userId);
7405                }
7406            }
7407            return false;
7408        }
7409
7410        @Override
7411        protected boolean isPackageForFilter(String packageName,
7412                PackageParser.ProviderIntentInfo info) {
7413            return packageName.equals(info.provider.owner.packageName);
7414        }
7415
7416        @Override
7417        protected ResolveInfo newResult(PackageParser.ProviderIntentInfo filter,
7418                int match, int userId) {
7419            if (!sUserManager.exists(userId))
7420                return null;
7421            final PackageParser.ProviderIntentInfo info = filter;
7422            if (!mSettings.isEnabledLPr(info.provider.info, mFlags, userId)) {
7423                return null;
7424            }
7425            final PackageParser.Provider provider = info.provider;
7426            if (mSafeMode && (provider.info.applicationInfo.flags
7427                    & ApplicationInfo.FLAG_SYSTEM) == 0) {
7428                return null;
7429            }
7430            PackageSetting ps = (PackageSetting) provider.owner.mExtras;
7431            if (ps == null) {
7432                return null;
7433            }
7434            ProviderInfo pi = PackageParser.generateProviderInfo(provider, mFlags,
7435                    ps.readUserState(userId), userId);
7436            if (pi == null) {
7437                return null;
7438            }
7439            final ResolveInfo res = new ResolveInfo();
7440            res.providerInfo = pi;
7441            if ((mFlags & PackageManager.GET_RESOLVED_FILTER) != 0) {
7442                res.filter = filter;
7443            }
7444            res.priority = info.getPriority();
7445            res.preferredOrder = provider.owner.mPreferredOrder;
7446            res.match = match;
7447            res.isDefault = info.hasDefault;
7448            res.labelRes = info.labelRes;
7449            res.nonLocalizedLabel = info.nonLocalizedLabel;
7450            res.icon = info.icon;
7451            res.system = isSystemApp(res.providerInfo.applicationInfo);
7452            return res;
7453        }
7454
7455        @Override
7456        protected void sortResults(List<ResolveInfo> results) {
7457            Collections.sort(results, mResolvePrioritySorter);
7458        }
7459
7460        @Override
7461        protected void dumpFilter(PrintWriter out, String prefix,
7462                PackageParser.ProviderIntentInfo filter) {
7463            out.print(prefix);
7464            out.print(
7465                    Integer.toHexString(System.identityHashCode(filter.provider)));
7466            out.print(' ');
7467            filter.provider.printComponentShortName(out);
7468            out.print(" filter ");
7469            out.println(Integer.toHexString(System.identityHashCode(filter)));
7470        }
7471
7472        private final HashMap<ComponentName, PackageParser.Provider> mProviders
7473                = new HashMap<ComponentName, PackageParser.Provider>();
7474        private int mFlags;
7475    };
7476
7477    private static final Comparator<ResolveInfo> mResolvePrioritySorter =
7478            new Comparator<ResolveInfo>() {
7479        public int compare(ResolveInfo r1, ResolveInfo r2) {
7480            int v1 = r1.priority;
7481            int v2 = r2.priority;
7482            //System.out.println("Comparing: q1=" + q1 + " q2=" + q2);
7483            if (v1 != v2) {
7484                return (v1 > v2) ? -1 : 1;
7485            }
7486            v1 = r1.preferredOrder;
7487            v2 = r2.preferredOrder;
7488            if (v1 != v2) {
7489                return (v1 > v2) ? -1 : 1;
7490            }
7491            if (r1.isDefault != r2.isDefault) {
7492                return r1.isDefault ? -1 : 1;
7493            }
7494            v1 = r1.match;
7495            v2 = r2.match;
7496            //System.out.println("Comparing: m1=" + m1 + " m2=" + m2);
7497            if (v1 != v2) {
7498                return (v1 > v2) ? -1 : 1;
7499            }
7500            if (r1.system != r2.system) {
7501                return r1.system ? -1 : 1;
7502            }
7503            return 0;
7504        }
7505    };
7506
7507    private static final Comparator<ProviderInfo> mProviderInitOrderSorter =
7508            new Comparator<ProviderInfo>() {
7509        public int compare(ProviderInfo p1, ProviderInfo p2) {
7510            final int v1 = p1.initOrder;
7511            final int v2 = p2.initOrder;
7512            return (v1 > v2) ? -1 : ((v1 < v2) ? 1 : 0);
7513        }
7514    };
7515
7516    static final void sendPackageBroadcast(String action, String pkg,
7517            Bundle extras, String targetPkg, IIntentReceiver finishedReceiver,
7518            int[] userIds) {
7519        IActivityManager am = ActivityManagerNative.getDefault();
7520        if (am != null) {
7521            try {
7522                if (userIds == null) {
7523                    userIds = am.getRunningUserIds();
7524                }
7525                for (int id : userIds) {
7526                    final Intent intent = new Intent(action,
7527                            pkg != null ? Uri.fromParts("package", pkg, null) : null);
7528                    if (extras != null) {
7529                        intent.putExtras(extras);
7530                    }
7531                    if (targetPkg != null) {
7532                        intent.setPackage(targetPkg);
7533                    }
7534                    // Modify the UID when posting to other users
7535                    int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
7536                    if (uid > 0 && UserHandle.getUserId(uid) != id) {
7537                        uid = UserHandle.getUid(id, UserHandle.getAppId(uid));
7538                        intent.putExtra(Intent.EXTRA_UID, uid);
7539                    }
7540                    intent.putExtra(Intent.EXTRA_USER_HANDLE, id);
7541                    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
7542                    if (DEBUG_BROADCASTS) {
7543                        RuntimeException here = new RuntimeException("here");
7544                        here.fillInStackTrace();
7545                        Slog.d(TAG, "Sending to user " + id + ": "
7546                                + intent.toShortString(false, true, false, false)
7547                                + " " + intent.getExtras(), here);
7548                    }
7549                    am.broadcastIntent(null, intent, null, finishedReceiver,
7550                            0, null, null, null, android.app.AppOpsManager.OP_NONE,
7551                            finishedReceiver != null, false, id);
7552                }
7553            } catch (RemoteException ex) {
7554            }
7555        }
7556    }
7557
7558    /**
7559     * Check if the external storage media is available. This is true if there
7560     * is a mounted external storage medium or if the external storage is
7561     * emulated.
7562     */
7563    private boolean isExternalMediaAvailable() {
7564        return mMediaMounted || Environment.isExternalStorageEmulated();
7565    }
7566
7567    @Override
7568    public PackageCleanItem nextPackageToClean(PackageCleanItem lastPackage) {
7569        // writer
7570        synchronized (mPackages) {
7571            if (!isExternalMediaAvailable()) {
7572                // If the external storage is no longer mounted at this point,
7573                // the caller may not have been able to delete all of this
7574                // packages files and can not delete any more.  Bail.
7575                return null;
7576            }
7577            final ArrayList<PackageCleanItem> pkgs = mSettings.mPackagesToBeCleaned;
7578            if (lastPackage != null) {
7579                pkgs.remove(lastPackage);
7580            }
7581            if (pkgs.size() > 0) {
7582                return pkgs.get(0);
7583            }
7584        }
7585        return null;
7586    }
7587
7588    void schedulePackageCleaning(String packageName, int userId, boolean andCode) {
7589        if (false) {
7590            RuntimeException here = new RuntimeException("here");
7591            here.fillInStackTrace();
7592            Slog.d(TAG, "Schedule cleaning " + packageName + " user=" + userId
7593                    + " andCode=" + andCode, here);
7594        }
7595        mHandler.sendMessage(mHandler.obtainMessage(START_CLEANING_PACKAGE,
7596                userId, andCode ? 1 : 0, packageName));
7597    }
7598
7599    void startCleaningPackages() {
7600        // reader
7601        synchronized (mPackages) {
7602            if (!isExternalMediaAvailable()) {
7603                return;
7604            }
7605            if (mSettings.mPackagesToBeCleaned.isEmpty()) {
7606                return;
7607            }
7608        }
7609        Intent intent = new Intent(PackageManager.ACTION_CLEAN_EXTERNAL_STORAGE);
7610        intent.setComponent(DEFAULT_CONTAINER_COMPONENT);
7611        IActivityManager am = ActivityManagerNative.getDefault();
7612        if (am != null) {
7613            try {
7614                am.startService(null, intent, null, UserHandle.USER_OWNER);
7615            } catch (RemoteException e) {
7616            }
7617        }
7618    }
7619
7620    private final class AppDirObserver extends FileObserver {
7621        public AppDirObserver(String path, int mask, boolean isrom, boolean isPrivileged) {
7622            super(path, mask);
7623            mRootDir = path;
7624            mIsRom = isrom;
7625            mIsPrivileged = isPrivileged;
7626        }
7627
7628        public void onEvent(int event, String path) {
7629            String removedPackage = null;
7630            int removedAppId = -1;
7631            int[] removedUsers = null;
7632            String addedPackage = null;
7633            int addedAppId = -1;
7634            int[] addedUsers = null;
7635
7636            // TODO post a message to the handler to obtain serial ordering
7637            synchronized (mInstallLock) {
7638                String fullPathStr = null;
7639                File fullPath = null;
7640                if (path != null) {
7641                    fullPath = new File(mRootDir, path);
7642                    fullPathStr = fullPath.getPath();
7643                }
7644
7645                if (DEBUG_APP_DIR_OBSERVER)
7646                    Log.v(TAG, "File " + fullPathStr + " changed: " + Integer.toHexString(event));
7647
7648                if (!isApkFile(fullPath)) {
7649                    if (DEBUG_APP_DIR_OBSERVER)
7650                        Log.v(TAG, "Ignoring change of non-package file: " + fullPathStr);
7651                    return;
7652                }
7653
7654                // Ignore packages that are being installed or
7655                // have just been installed.
7656                if (ignoreCodePath(fullPathStr)) {
7657                    return;
7658                }
7659                PackageParser.Package p = null;
7660                PackageSetting ps = null;
7661                // reader
7662                synchronized (mPackages) {
7663                    p = mAppDirs.get(fullPathStr);
7664                    if (p != null) {
7665                        ps = mSettings.mPackages.get(p.applicationInfo.packageName);
7666                        if (ps != null) {
7667                            removedUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
7668                        } else {
7669                            removedUsers = sUserManager.getUserIds();
7670                        }
7671                    }
7672                    addedUsers = sUserManager.getUserIds();
7673                }
7674                if ((event&REMOVE_EVENTS) != 0) {
7675                    if (ps != null) {
7676                        if (DEBUG_REMOVE) Slog.d(TAG, "Package disappeared: " + ps);
7677                        removePackageLI(ps, true);
7678                        removedPackage = ps.name;
7679                        removedAppId = ps.appId;
7680                    }
7681                }
7682
7683                if ((event&ADD_EVENTS) != 0) {
7684                    if (p == null) {
7685                        if (DEBUG_INSTALL) Slog.d(TAG, "New file appeared: " + fullPath);
7686                        int flags = PackageParser.PARSE_CHATTY | PackageParser.PARSE_MUST_BE_APK;
7687                        if (mIsRom) {
7688                            flags |= PackageParser.PARSE_IS_SYSTEM
7689                                    | PackageParser.PARSE_IS_SYSTEM_DIR;
7690                            if (mIsPrivileged) {
7691                                flags |= PackageParser.PARSE_IS_PRIVILEGED;
7692                            }
7693                        }
7694                        try {
7695                            p = scanPackageLI(fullPath, flags,
7696                                    SCAN_MONITOR | SCAN_NO_PATHS | SCAN_UPDATE_TIME,
7697                                    System.currentTimeMillis(), UserHandle.ALL, null);
7698                        } catch (PackageManagerException e) {
7699                            Slog.w(TAG, "Failed to scan " + fullPath + ": " + e.getMessage());
7700                            p = null;
7701                        }
7702                        if (p != null) {
7703                            /*
7704                             * TODO this seems dangerous as the package may have
7705                             * changed since we last acquired the mPackages
7706                             * lock.
7707                             */
7708                            // writer
7709                            synchronized (mPackages) {
7710                                updatePermissionsLPw(p.packageName, p,
7711                                        p.permissions.size() > 0 ? UPDATE_PERMISSIONS_ALL : 0);
7712                            }
7713                            addedPackage = p.applicationInfo.packageName;
7714                            addedAppId = UserHandle.getAppId(p.applicationInfo.uid);
7715                        }
7716                    }
7717                }
7718
7719                // reader
7720                synchronized (mPackages) {
7721                    mSettings.writeLPr();
7722                }
7723            }
7724
7725            if (removedPackage != null) {
7726                Bundle extras = new Bundle(1);
7727                extras.putInt(Intent.EXTRA_UID, removedAppId);
7728                extras.putBoolean(Intent.EXTRA_DATA_REMOVED, false);
7729                sendPackageBroadcast(Intent.ACTION_PACKAGE_REMOVED, removedPackage,
7730                        extras, null, null, removedUsers);
7731            }
7732            if (addedPackage != null) {
7733                Bundle extras = new Bundle(1);
7734                extras.putInt(Intent.EXTRA_UID, addedAppId);
7735                sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, addedPackage,
7736                        extras, null, null, addedUsers);
7737            }
7738        }
7739
7740        private final String mRootDir;
7741        private final boolean mIsRom;
7742        private final boolean mIsPrivileged;
7743    }
7744
7745    @Override
7746    public void installPackage(String originPath, IPackageInstallObserver2 observer, int flags,
7747            String installerPackageName, VerificationParams verificationParams,
7748            String packageAbiOverride) {
7749        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES,
7750                null);
7751
7752        final File originFile = new File(originPath);
7753        final int uid = Binder.getCallingUid();
7754        if (isUserRestricted(UserHandle.getUserId(uid), UserManager.DISALLOW_INSTALL_APPS)) {
7755            try {
7756                if (observer != null) {
7757                    observer.packageInstalled("", null, INSTALL_FAILED_USER_RESTRICTED, null);
7758                }
7759            } catch (RemoteException re) {
7760            }
7761            return;
7762        }
7763
7764        UserHandle user;
7765        if ((flags&PackageManager.INSTALL_ALL_USERS) != 0) {
7766            user = UserHandle.ALL;
7767        } else {
7768            user = new UserHandle(UserHandle.getUserId(uid));
7769        }
7770
7771        final int filteredFlags;
7772        if (uid == Process.SHELL_UID || uid == 0) {
7773            if (DEBUG_INSTALL) {
7774                Slog.v(TAG, "Install from ADB");
7775            }
7776            filteredFlags = flags | PackageManager.INSTALL_FROM_ADB;
7777        } else {
7778            filteredFlags = flags & ~PackageManager.INSTALL_FROM_ADB;
7779        }
7780
7781        verificationParams.setInstallerUid(uid);
7782
7783        final Message msg = mHandler.obtainMessage(INIT_COPY);
7784        msg.obj = new InstallParams(originFile, false, observer, filteredFlags,
7785                installerPackageName, verificationParams, user, packageAbiOverride);
7786        mHandler.sendMessage(msg);
7787    }
7788
7789    void installStage(String packageName, File stageDir, IPackageInstallObserver2 observer,
7790            InstallSessionParams params, String installerPackageName, int installerUid,
7791            UserHandle user) {
7792        final VerificationParams verifParams = new VerificationParams(null, params.originatingUri,
7793                params.referrerUri, installerUid, null);
7794
7795        final Message msg = mHandler.obtainMessage(INIT_COPY);
7796        msg.obj = new InstallParams(stageDir, true, observer, params.installFlags,
7797                installerPackageName, verifParams, user, params.abiOverride);
7798        mHandler.sendMessage(msg);
7799    }
7800
7801    private void sendPackageAddedForUser(String packageName, PackageSetting pkgSetting, int userId) {
7802        Bundle extras = new Bundle(1);
7803        extras.putInt(Intent.EXTRA_UID, UserHandle.getUid(userId, pkgSetting.appId));
7804
7805        sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
7806                packageName, extras, null, null, new int[] {userId});
7807        try {
7808            IActivityManager am = ActivityManagerNative.getDefault();
7809            final boolean isSystem =
7810                    isSystemApp(pkgSetting) || isUpdatedSystemApp(pkgSetting);
7811            if (isSystem && am.isUserRunning(userId, false)) {
7812                // The just-installed/enabled app is bundled on the system, so presumed
7813                // to be able to run automatically without needing an explicit launch.
7814                // Send it a BOOT_COMPLETED if it would ordinarily have gotten one.
7815                Intent bcIntent = new Intent(Intent.ACTION_BOOT_COMPLETED)
7816                        .addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES)
7817                        .setPackage(packageName);
7818                am.broadcastIntent(null, bcIntent, null, null, 0, null, null, null,
7819                        android.app.AppOpsManager.OP_NONE, false, false, userId);
7820            }
7821        } catch (RemoteException e) {
7822            // shouldn't happen
7823            Slog.w(TAG, "Unable to bootstrap installed package", e);
7824        }
7825    }
7826
7827    @Override
7828    public boolean setApplicationBlockedSettingAsUser(String packageName, boolean blocked,
7829            int userId) {
7830        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USERS, null);
7831        PackageSetting pkgSetting;
7832        final int uid = Binder.getCallingUid();
7833        if (UserHandle.getUserId(uid) != userId) {
7834            mContext.enforceCallingOrSelfPermission(
7835                    android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
7836                    "setApplicationBlockedSetting for user " + userId);
7837        }
7838
7839        if (blocked && isPackageDeviceAdmin(packageName, userId)) {
7840            Slog.w(TAG, "Not blocking package " + packageName + ": has active device admin");
7841            return false;
7842        }
7843
7844        long callingId = Binder.clearCallingIdentity();
7845        try {
7846            boolean sendAdded = false;
7847            boolean sendRemoved = false;
7848            // writer
7849            synchronized (mPackages) {
7850                pkgSetting = mSettings.mPackages.get(packageName);
7851                if (pkgSetting == null) {
7852                    return false;
7853                }
7854                if (pkgSetting.getBlocked(userId) != blocked) {
7855                    pkgSetting.setBlocked(blocked, userId);
7856                    mSettings.writePackageRestrictionsLPr(userId);
7857                    if (blocked) {
7858                        sendRemoved = true;
7859                    } else {
7860                        sendAdded = true;
7861                    }
7862                }
7863            }
7864            if (sendAdded) {
7865                sendPackageAddedForUser(packageName, pkgSetting, userId);
7866                return true;
7867            }
7868            if (sendRemoved) {
7869                killApplication(packageName, UserHandle.getUid(userId, pkgSetting.appId),
7870                        "blocking pkg");
7871                sendPackageBlockedForUser(packageName, pkgSetting, userId);
7872            }
7873        } finally {
7874            Binder.restoreCallingIdentity(callingId);
7875        }
7876        return false;
7877    }
7878
7879    private void sendPackageBlockedForUser(String packageName, PackageSetting pkgSetting,
7880            int userId) {
7881        final PackageRemovedInfo info = new PackageRemovedInfo();
7882        info.removedPackage = packageName;
7883        info.removedUsers = new int[] {userId};
7884        info.uid = UserHandle.getUid(userId, pkgSetting.appId);
7885        info.sendBroadcast(false, false, false);
7886    }
7887
7888    /**
7889     * Returns true if application is not found or there was an error. Otherwise it returns
7890     * the blocked state of the package for the given user.
7891     */
7892    @Override
7893    public boolean getApplicationBlockedSettingAsUser(String packageName, int userId) {
7894        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USERS, null);
7895        enforceCrossUserPermission(Binder.getCallingUid(), userId, true,
7896                "getApplicationBlocked for user " + userId);
7897        PackageSetting pkgSetting;
7898        long callingId = Binder.clearCallingIdentity();
7899        try {
7900            // writer
7901            synchronized (mPackages) {
7902                pkgSetting = mSettings.mPackages.get(packageName);
7903                if (pkgSetting == null) {
7904                    return true;
7905                }
7906                return pkgSetting.getBlocked(userId);
7907            }
7908        } finally {
7909            Binder.restoreCallingIdentity(callingId);
7910        }
7911    }
7912
7913    /**
7914     * @hide
7915     */
7916    @Override
7917    public int installExistingPackageAsUser(String packageName, int userId) {
7918        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES,
7919                null);
7920        PackageSetting pkgSetting;
7921        final int uid = Binder.getCallingUid();
7922        enforceCrossUserPermission(uid, userId, true, "installExistingPackage for user " + userId);
7923        if (isUserRestricted(userId, UserManager.DISALLOW_INSTALL_APPS)) {
7924            return PackageManager.INSTALL_FAILED_USER_RESTRICTED;
7925        }
7926
7927        long callingId = Binder.clearCallingIdentity();
7928        try {
7929            boolean sendAdded = false;
7930            Bundle extras = new Bundle(1);
7931
7932            // writer
7933            synchronized (mPackages) {
7934                pkgSetting = mSettings.mPackages.get(packageName);
7935                if (pkgSetting == null) {
7936                    return PackageManager.INSTALL_FAILED_INVALID_URI;
7937                }
7938                if (!pkgSetting.getInstalled(userId)) {
7939                    pkgSetting.setInstalled(true, userId);
7940                    pkgSetting.setBlocked(false, userId);
7941                    mSettings.writePackageRestrictionsLPr(userId);
7942                    sendAdded = true;
7943                }
7944            }
7945
7946            if (sendAdded) {
7947                sendPackageAddedForUser(packageName, pkgSetting, userId);
7948            }
7949        } finally {
7950            Binder.restoreCallingIdentity(callingId);
7951        }
7952
7953        return PackageManager.INSTALL_SUCCEEDED;
7954    }
7955
7956    boolean isUserRestricted(int userId, String restrictionKey) {
7957        Bundle restrictions = sUserManager.getUserRestrictions(userId);
7958        if (restrictions.getBoolean(restrictionKey, false)) {
7959            Log.w(TAG, "User is restricted: " + restrictionKey);
7960            return true;
7961        }
7962        return false;
7963    }
7964
7965    @Override
7966    public void verifyPendingInstall(int id, int verificationCode) throws RemoteException {
7967        mContext.enforceCallingOrSelfPermission(
7968                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
7969                "Only package verification agents can verify applications");
7970
7971        final Message msg = mHandler.obtainMessage(PACKAGE_VERIFIED);
7972        final PackageVerificationResponse response = new PackageVerificationResponse(
7973                verificationCode, Binder.getCallingUid());
7974        msg.arg1 = id;
7975        msg.obj = response;
7976        mHandler.sendMessage(msg);
7977    }
7978
7979    @Override
7980    public void extendVerificationTimeout(int id, int verificationCodeAtTimeout,
7981            long millisecondsToDelay) {
7982        mContext.enforceCallingOrSelfPermission(
7983                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
7984                "Only package verification agents can extend verification timeouts");
7985
7986        final PackageVerificationState state = mPendingVerification.get(id);
7987        final PackageVerificationResponse response = new PackageVerificationResponse(
7988                verificationCodeAtTimeout, Binder.getCallingUid());
7989
7990        if (millisecondsToDelay > PackageManager.MAXIMUM_VERIFICATION_TIMEOUT) {
7991            millisecondsToDelay = PackageManager.MAXIMUM_VERIFICATION_TIMEOUT;
7992        }
7993        if (millisecondsToDelay < 0) {
7994            millisecondsToDelay = 0;
7995        }
7996        if ((verificationCodeAtTimeout != PackageManager.VERIFICATION_ALLOW)
7997                && (verificationCodeAtTimeout != PackageManager.VERIFICATION_REJECT)) {
7998            verificationCodeAtTimeout = PackageManager.VERIFICATION_REJECT;
7999        }
8000
8001        if ((state != null) && !state.timeoutExtended()) {
8002            state.extendTimeout();
8003
8004            final Message msg = mHandler.obtainMessage(PACKAGE_VERIFIED);
8005            msg.arg1 = id;
8006            msg.obj = response;
8007            mHandler.sendMessageDelayed(msg, millisecondsToDelay);
8008        }
8009    }
8010
8011    private void broadcastPackageVerified(int verificationId, Uri packageUri,
8012            int verificationCode, UserHandle user) {
8013        final Intent intent = new Intent(Intent.ACTION_PACKAGE_VERIFIED);
8014        intent.setDataAndType(packageUri, PACKAGE_MIME_TYPE);
8015        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
8016        intent.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
8017        intent.putExtra(PackageManager.EXTRA_VERIFICATION_RESULT, verificationCode);
8018
8019        mContext.sendBroadcastAsUser(intent, user,
8020                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT);
8021    }
8022
8023    private ComponentName matchComponentForVerifier(String packageName,
8024            List<ResolveInfo> receivers) {
8025        ActivityInfo targetReceiver = null;
8026
8027        final int NR = receivers.size();
8028        for (int i = 0; i < NR; i++) {
8029            final ResolveInfo info = receivers.get(i);
8030            if (info.activityInfo == null) {
8031                continue;
8032            }
8033
8034            if (packageName.equals(info.activityInfo.packageName)) {
8035                targetReceiver = info.activityInfo;
8036                break;
8037            }
8038        }
8039
8040        if (targetReceiver == null) {
8041            return null;
8042        }
8043
8044        return new ComponentName(targetReceiver.packageName, targetReceiver.name);
8045    }
8046
8047    private List<ComponentName> matchVerifiers(PackageInfoLite pkgInfo,
8048            List<ResolveInfo> receivers, final PackageVerificationState verificationState) {
8049        if (pkgInfo.verifiers.length == 0) {
8050            return null;
8051        }
8052
8053        final int N = pkgInfo.verifiers.length;
8054        final List<ComponentName> sufficientVerifiers = new ArrayList<ComponentName>(N + 1);
8055        for (int i = 0; i < N; i++) {
8056            final VerifierInfo verifierInfo = pkgInfo.verifiers[i];
8057
8058            final ComponentName comp = matchComponentForVerifier(verifierInfo.packageName,
8059                    receivers);
8060            if (comp == null) {
8061                continue;
8062            }
8063
8064            final int verifierUid = getUidForVerifier(verifierInfo);
8065            if (verifierUid == -1) {
8066                continue;
8067            }
8068
8069            if (DEBUG_VERIFY) {
8070                Slog.d(TAG, "Added sufficient verifier " + verifierInfo.packageName
8071                        + " with the correct signature");
8072            }
8073            sufficientVerifiers.add(comp);
8074            verificationState.addSufficientVerifier(verifierUid);
8075        }
8076
8077        return sufficientVerifiers;
8078    }
8079
8080    private int getUidForVerifier(VerifierInfo verifierInfo) {
8081        synchronized (mPackages) {
8082            final PackageParser.Package pkg = mPackages.get(verifierInfo.packageName);
8083            if (pkg == null) {
8084                return -1;
8085            } else if (pkg.mSignatures.length != 1) {
8086                Slog.i(TAG, "Verifier package " + verifierInfo.packageName
8087                        + " has more than one signature; ignoring");
8088                return -1;
8089            }
8090
8091            /*
8092             * If the public key of the package's signature does not match
8093             * our expected public key, then this is a different package and
8094             * we should skip.
8095             */
8096
8097            final byte[] expectedPublicKey;
8098            try {
8099                final Signature verifierSig = pkg.mSignatures[0];
8100                final PublicKey publicKey = verifierSig.getPublicKey();
8101                expectedPublicKey = publicKey.getEncoded();
8102            } catch (CertificateException e) {
8103                return -1;
8104            }
8105
8106            final byte[] actualPublicKey = verifierInfo.publicKey.getEncoded();
8107
8108            if (!Arrays.equals(actualPublicKey, expectedPublicKey)) {
8109                Slog.i(TAG, "Verifier package " + verifierInfo.packageName
8110                        + " does not have the expected public key; ignoring");
8111                return -1;
8112            }
8113
8114            return pkg.applicationInfo.uid;
8115        }
8116    }
8117
8118    @Override
8119    public void finishPackageInstall(int token) {
8120        enforceSystemOrRoot("Only the system is allowed to finish installs");
8121
8122        if (DEBUG_INSTALL) {
8123            Slog.v(TAG, "BM finishing package install for " + token);
8124        }
8125
8126        final Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
8127        mHandler.sendMessage(msg);
8128    }
8129
8130    /**
8131     * Get the verification agent timeout.
8132     *
8133     * @return verification timeout in milliseconds
8134     */
8135    private long getVerificationTimeout() {
8136        return android.provider.Settings.Global.getLong(mContext.getContentResolver(),
8137                android.provider.Settings.Global.PACKAGE_VERIFIER_TIMEOUT,
8138                DEFAULT_VERIFICATION_TIMEOUT);
8139    }
8140
8141    /**
8142     * Get the default verification agent response code.
8143     *
8144     * @return default verification response code
8145     */
8146    private int getDefaultVerificationResponse() {
8147        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8148                android.provider.Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE,
8149                DEFAULT_VERIFICATION_RESPONSE);
8150    }
8151
8152    /**
8153     * Check whether or not package verification has been enabled.
8154     *
8155     * @return true if verification should be performed
8156     */
8157    private boolean isVerificationEnabled(int userId, int flags) {
8158        if (!DEFAULT_VERIFY_ENABLE) {
8159            return false;
8160        }
8161
8162        boolean ensureVerifyAppsEnabled = isUserRestricted(userId, UserManager.ENSURE_VERIFY_APPS);
8163
8164        // Check if installing from ADB
8165        if ((flags & PackageManager.INSTALL_FROM_ADB) != 0) {
8166            // Do not run verification in a test harness environment
8167            if (ActivityManager.isRunningInTestHarness()) {
8168                return false;
8169            }
8170            if (ensureVerifyAppsEnabled) {
8171                return true;
8172            }
8173            // Check if the developer does not want package verification for ADB installs
8174            if (android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8175                    android.provider.Settings.Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1) == 0) {
8176                return false;
8177            }
8178        }
8179
8180        if (ensureVerifyAppsEnabled) {
8181            return true;
8182        }
8183
8184        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8185                android.provider.Settings.Global.PACKAGE_VERIFIER_ENABLE, 1) == 1;
8186    }
8187
8188    /**
8189     * Get the "allow unknown sources" setting.
8190     *
8191     * @return the current "allow unknown sources" setting
8192     */
8193    private int getUnknownSourcesSettings() {
8194        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
8195                android.provider.Settings.Global.INSTALL_NON_MARKET_APPS,
8196                -1);
8197    }
8198
8199    @Override
8200    public void setInstallerPackageName(String targetPackage, String installerPackageName) {
8201        final int uid = Binder.getCallingUid();
8202        // writer
8203        synchronized (mPackages) {
8204            PackageSetting targetPackageSetting = mSettings.mPackages.get(targetPackage);
8205            if (targetPackageSetting == null) {
8206                throw new IllegalArgumentException("Unknown target package: " + targetPackage);
8207            }
8208
8209            PackageSetting installerPackageSetting;
8210            if (installerPackageName != null) {
8211                installerPackageSetting = mSettings.mPackages.get(installerPackageName);
8212                if (installerPackageSetting == null) {
8213                    throw new IllegalArgumentException("Unknown installer package: "
8214                            + installerPackageName);
8215                }
8216            } else {
8217                installerPackageSetting = null;
8218            }
8219
8220            Signature[] callerSignature;
8221            Object obj = mSettings.getUserIdLPr(uid);
8222            if (obj != null) {
8223                if (obj instanceof SharedUserSetting) {
8224                    callerSignature = ((SharedUserSetting)obj).signatures.mSignatures;
8225                } else if (obj instanceof PackageSetting) {
8226                    callerSignature = ((PackageSetting)obj).signatures.mSignatures;
8227                } else {
8228                    throw new SecurityException("Bad object " + obj + " for uid " + uid);
8229                }
8230            } else {
8231                throw new SecurityException("Unknown calling uid " + uid);
8232            }
8233
8234            // Verify: can't set installerPackageName to a package that is
8235            // not signed with the same cert as the caller.
8236            if (installerPackageSetting != null) {
8237                if (compareSignatures(callerSignature,
8238                        installerPackageSetting.signatures.mSignatures)
8239                        != PackageManager.SIGNATURE_MATCH) {
8240                    throw new SecurityException(
8241                            "Caller does not have same cert as new installer package "
8242                            + installerPackageName);
8243                }
8244            }
8245
8246            // Verify: if target already has an installer package, it must
8247            // be signed with the same cert as the caller.
8248            if (targetPackageSetting.installerPackageName != null) {
8249                PackageSetting setting = mSettings.mPackages.get(
8250                        targetPackageSetting.installerPackageName);
8251                // If the currently set package isn't valid, then it's always
8252                // okay to change it.
8253                if (setting != null) {
8254                    if (compareSignatures(callerSignature,
8255                            setting.signatures.mSignatures)
8256                            != PackageManager.SIGNATURE_MATCH) {
8257                        throw new SecurityException(
8258                                "Caller does not have same cert as old installer package "
8259                                + targetPackageSetting.installerPackageName);
8260                    }
8261                }
8262            }
8263
8264            // Okay!
8265            targetPackageSetting.installerPackageName = installerPackageName;
8266            scheduleWriteSettingsLocked();
8267        }
8268    }
8269
8270    private void processPendingInstall(final InstallArgs args, final int currentStatus) {
8271        // Queue up an async operation since the package installation may take a little while.
8272        mHandler.post(new Runnable() {
8273            public void run() {
8274                mHandler.removeCallbacks(this);
8275                 // Result object to be returned
8276                PackageInstalledInfo res = new PackageInstalledInfo();
8277                res.returnCode = currentStatus;
8278                res.uid = -1;
8279                res.pkg = null;
8280                res.removedInfo = new PackageRemovedInfo();
8281                if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
8282                    args.doPreInstall(res.returnCode);
8283                    synchronized (mInstallLock) {
8284                        installPackageLI(args, true, res);
8285                    }
8286                    args.doPostInstall(res.returnCode, res.uid);
8287                }
8288
8289                // A restore should be performed at this point if (a) the install
8290                // succeeded, (b) the operation is not an update, and (c) the new
8291                // package has a backupAgent defined.
8292                final boolean update = res.removedInfo.removedPackage != null;
8293                boolean doRestore = (!update
8294                        && res.pkg != null
8295                        && res.pkg.applicationInfo.backupAgentName != null);
8296
8297                // Set up the post-install work request bookkeeping.  This will be used
8298                // and cleaned up by the post-install event handling regardless of whether
8299                // there's a restore pass performed.  Token values are >= 1.
8300                int token;
8301                if (mNextInstallToken < 0) mNextInstallToken = 1;
8302                token = mNextInstallToken++;
8303
8304                PostInstallData data = new PostInstallData(args, res);
8305                mRunningInstalls.put(token, data);
8306                if (DEBUG_INSTALL) Log.v(TAG, "+ starting restore round-trip " + token);
8307
8308                if (res.returnCode == PackageManager.INSTALL_SUCCEEDED && doRestore) {
8309                    // Pass responsibility to the Backup Manager.  It will perform a
8310                    // restore if appropriate, then pass responsibility back to the
8311                    // Package Manager to run the post-install observer callbacks
8312                    // and broadcasts.
8313                    IBackupManager bm = IBackupManager.Stub.asInterface(
8314                            ServiceManager.getService(Context.BACKUP_SERVICE));
8315                    if (bm != null) {
8316                        if (DEBUG_INSTALL) Log.v(TAG, "token " + token
8317                                + " to BM for possible restore");
8318                        try {
8319                            bm.restoreAtInstall(res.pkg.applicationInfo.packageName, token);
8320                        } catch (RemoteException e) {
8321                            // can't happen; the backup manager is local
8322                        } catch (Exception e) {
8323                            Slog.e(TAG, "Exception trying to enqueue restore", e);
8324                            doRestore = false;
8325                        }
8326                    } else {
8327                        Slog.e(TAG, "Backup Manager not found!");
8328                        doRestore = false;
8329                    }
8330                }
8331
8332                if (!doRestore) {
8333                    // No restore possible, or the Backup Manager was mysteriously not
8334                    // available -- just fire the post-install work request directly.
8335                    if (DEBUG_INSTALL) Log.v(TAG, "No restore - queue post-install for " + token);
8336                    Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
8337                    mHandler.sendMessage(msg);
8338                }
8339            }
8340        });
8341    }
8342
8343    private abstract class HandlerParams {
8344        private static final int MAX_RETRIES = 4;
8345
8346        /**
8347         * Number of times startCopy() has been attempted and had a non-fatal
8348         * error.
8349         */
8350        private int mRetries = 0;
8351
8352        /** User handle for the user requesting the information or installation. */
8353        private final UserHandle mUser;
8354
8355        HandlerParams(UserHandle user) {
8356            mUser = user;
8357        }
8358
8359        UserHandle getUser() {
8360            return mUser;
8361        }
8362
8363        final boolean startCopy() {
8364            boolean res;
8365            try {
8366                if (DEBUG_INSTALL) Slog.i(TAG, "startCopy " + mUser + ": " + this);
8367
8368                if (++mRetries > MAX_RETRIES) {
8369                    Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up");
8370                    mHandler.sendEmptyMessage(MCS_GIVE_UP);
8371                    handleServiceError();
8372                    return false;
8373                } else {
8374                    handleStartCopy();
8375                    res = true;
8376                }
8377            } catch (RemoteException e) {
8378                if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
8379                mHandler.sendEmptyMessage(MCS_RECONNECT);
8380                res = false;
8381            }
8382            handleReturnCode();
8383            return res;
8384        }
8385
8386        final void serviceError() {
8387            if (DEBUG_INSTALL) Slog.i(TAG, "serviceError");
8388            handleServiceError();
8389            handleReturnCode();
8390        }
8391
8392        abstract void handleStartCopy() throws RemoteException;
8393        abstract void handleServiceError();
8394        abstract void handleReturnCode();
8395    }
8396
8397    class MeasureParams extends HandlerParams {
8398        private final PackageStats mStats;
8399        private boolean mSuccess;
8400
8401        private final IPackageStatsObserver mObserver;
8402
8403        public MeasureParams(PackageStats stats, IPackageStatsObserver observer) {
8404            super(new UserHandle(stats.userHandle));
8405            mObserver = observer;
8406            mStats = stats;
8407        }
8408
8409        @Override
8410        public String toString() {
8411            return "MeasureParams{"
8412                + Integer.toHexString(System.identityHashCode(this))
8413                + " " + mStats.packageName + "}";
8414        }
8415
8416        @Override
8417        void handleStartCopy() throws RemoteException {
8418            synchronized (mInstallLock) {
8419                mSuccess = getPackageSizeInfoLI(mStats.packageName, mStats.userHandle, mStats);
8420            }
8421
8422            if (mSuccess) {
8423                final boolean mounted;
8424                if (Environment.isExternalStorageEmulated()) {
8425                    mounted = true;
8426                } else {
8427                    final String status = Environment.getExternalStorageState();
8428                    mounted = (Environment.MEDIA_MOUNTED.equals(status)
8429                            || Environment.MEDIA_MOUNTED_READ_ONLY.equals(status));
8430                }
8431
8432                if (mounted) {
8433                    final UserEnvironment userEnv = new UserEnvironment(mStats.userHandle);
8434
8435                    mStats.externalCacheSize = calculateDirectorySize(mContainerService,
8436                            userEnv.buildExternalStorageAppCacheDirs(mStats.packageName));
8437
8438                    mStats.externalDataSize = calculateDirectorySize(mContainerService,
8439                            userEnv.buildExternalStorageAppDataDirs(mStats.packageName));
8440
8441                    // Always subtract cache size, since it's a subdirectory
8442                    mStats.externalDataSize -= mStats.externalCacheSize;
8443
8444                    mStats.externalMediaSize = calculateDirectorySize(mContainerService,
8445                            userEnv.buildExternalStorageAppMediaDirs(mStats.packageName));
8446
8447                    mStats.externalObbSize = calculateDirectorySize(mContainerService,
8448                            userEnv.buildExternalStorageAppObbDirs(mStats.packageName));
8449                }
8450            }
8451        }
8452
8453        @Override
8454        void handleReturnCode() {
8455            if (mObserver != null) {
8456                try {
8457                    mObserver.onGetStatsCompleted(mStats, mSuccess);
8458                } catch (RemoteException e) {
8459                    Slog.i(TAG, "Observer no longer exists.");
8460                }
8461            }
8462        }
8463
8464        @Override
8465        void handleServiceError() {
8466            Slog.e(TAG, "Could not measure application " + mStats.packageName
8467                            + " external storage");
8468        }
8469    }
8470
8471    private static long calculateDirectorySize(IMediaContainerService mcs, File[] paths)
8472            throws RemoteException {
8473        long result = 0;
8474        for (File path : paths) {
8475            result += mcs.calculateDirectorySize(path.getAbsolutePath());
8476        }
8477        return result;
8478    }
8479
8480    private static void clearDirectory(IMediaContainerService mcs, File[] paths) {
8481        for (File path : paths) {
8482            try {
8483                mcs.clearDirectory(path.getAbsolutePath());
8484            } catch (RemoteException e) {
8485            }
8486        }
8487    }
8488
8489    class InstallParams extends HandlerParams {
8490        /**
8491         * Location where install is coming from, before it has been
8492         * copied/renamed into place. This could be a single monolithic APK
8493         * file, or a cluster directory. This location may be untrusted.
8494         */
8495        final File originFile;
8496
8497        /**
8498         * Flag indicating that {@link #originFile} has already been staged,
8499         * meaning downstream users don't need to defensively copy the contents.
8500         */
8501        boolean originStaged;
8502
8503        final IPackageInstallObserver2 observer;
8504        int flags;
8505        final String installerPackageName;
8506        final VerificationParams verificationParams;
8507        private InstallArgs mArgs;
8508        private int mRet;
8509        final String packageAbiOverride;
8510        boolean multiArch;
8511
8512        InstallParams(File originFile, boolean originStaged, IPackageInstallObserver2 observer,
8513                int flags, String installerPackageName, VerificationParams verificationParams,
8514                UserHandle user, String packageAbiOverride) {
8515            super(user);
8516            this.originFile = Preconditions.checkNotNull(originFile);
8517            this.originStaged = originStaged;
8518            this.observer = observer;
8519            this.flags = flags;
8520            this.installerPackageName = installerPackageName;
8521            this.verificationParams = verificationParams;
8522            this.packageAbiOverride = packageAbiOverride;
8523        }
8524
8525        @Override
8526        public String toString() {
8527            return "InstallParams{"
8528                + Integer.toHexString(System.identityHashCode(this))
8529                + " " + originFile + "}";
8530        }
8531
8532        public ManifestDigest getManifestDigest() {
8533            if (verificationParams == null) {
8534                return null;
8535            }
8536            return verificationParams.getManifestDigest();
8537        }
8538
8539        private int installLocationPolicy(PackageInfoLite pkgLite, int flags) {
8540            String packageName = pkgLite.packageName;
8541            int installLocation = pkgLite.installLocation;
8542            boolean onSd = (flags & PackageManager.INSTALL_EXTERNAL) != 0;
8543            // reader
8544            synchronized (mPackages) {
8545                PackageParser.Package pkg = mPackages.get(packageName);
8546                if (pkg != null) {
8547                    if ((flags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
8548                        // Check for downgrading.
8549                        if ((flags & PackageManager.INSTALL_ALLOW_DOWNGRADE) == 0) {
8550                            if (pkgLite.versionCode < pkg.mVersionCode) {
8551                                Slog.w(TAG, "Can't install update of " + packageName
8552                                        + " update version " + pkgLite.versionCode
8553                                        + " is older than installed version "
8554                                        + pkg.mVersionCode);
8555                                return PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE;
8556                            }
8557                        }
8558                        // Check for updated system application.
8559                        if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
8560                            if (onSd) {
8561                                Slog.w(TAG, "Cannot install update to system app on sdcard");
8562                                return PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION;
8563                            }
8564                            return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8565                        } else {
8566                            if (onSd) {
8567                                // Install flag overrides everything.
8568                                return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8569                            }
8570                            // If current upgrade specifies particular preference
8571                            if (installLocation == PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY) {
8572                                // Application explicitly specified internal.
8573                                return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8574                            } else if (installLocation == PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL) {
8575                                // App explictly prefers external. Let policy decide
8576                            } else {
8577                                // Prefer previous location
8578                                if (isExternal(pkg)) {
8579                                    return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8580                                }
8581                                return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
8582                            }
8583                        }
8584                    } else {
8585                        // Invalid install. Return error code
8586                        return PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS;
8587                    }
8588                }
8589            }
8590            // All the special cases have been taken care of.
8591            // Return result based on recommended install location.
8592            if (onSd) {
8593                return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
8594            }
8595            return pkgLite.recommendedInstallLocation;
8596        }
8597
8598        private long getMemoryLowThreshold() {
8599            final DeviceStorageMonitorInternal
8600                    dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
8601            if (dsm == null) {
8602                return 0L;
8603            }
8604            return dsm.getMemoryLowThreshold();
8605        }
8606
8607        /*
8608         * Invoke remote method to get package information and install
8609         * location values. Override install location based on default
8610         * policy if needed and then create install arguments based
8611         * on the install location.
8612         */
8613        public void handleStartCopy() throws RemoteException {
8614            int ret = PackageManager.INSTALL_SUCCEEDED;
8615            final boolean onSd = (flags & PackageManager.INSTALL_EXTERNAL) != 0;
8616            final boolean onInt = (flags & PackageManager.INSTALL_INTERNAL) != 0;
8617            PackageInfoLite pkgLite = null;
8618
8619            if (onInt && onSd) {
8620                // Check if both bits are set.
8621                Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");
8622                ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
8623            } else {
8624                final long lowThreshold = getMemoryLowThreshold();
8625                if (lowThreshold == 0L) {
8626                    Log.w(TAG, "Couldn't get low memory threshold; no free limit imposed");
8627                }
8628
8629                // Remote call to find out default install location
8630                final String originPath = originFile.getAbsolutePath();
8631                pkgLite = mContainerService.getMinimalPackageInfo(originPath, flags, lowThreshold,
8632                        packageAbiOverride);
8633                // Keep track of whether this package is a multiArch package until
8634                // we perform a full scan of it. We need to do this because we might
8635                // end up extracting the package shared libraries before we perform
8636                // a full scan.
8637                multiArch = pkgLite.multiArch;
8638
8639                /*
8640                 * If we have too little free space, try to free cache
8641                 * before giving up.
8642                 */
8643                if (pkgLite.recommendedInstallLocation
8644                        == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
8645                    final long size = mContainerService.calculateInstalledSize(
8646                            originPath, isForwardLocked(), packageAbiOverride);
8647                    if (mInstaller.freeCache(size + lowThreshold) >= 0) {
8648                        pkgLite = mContainerService.getMinimalPackageInfo(originPath, flags,
8649                                lowThreshold, packageAbiOverride);
8650                    }
8651                    /*
8652                     * The cache free must have deleted the file we
8653                     * downloaded to install.
8654                     *
8655                     * TODO: fix the "freeCache" call to not delete
8656                     *       the file we care about.
8657                     */
8658                    if (pkgLite.recommendedInstallLocation
8659                            == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
8660                        pkgLite.recommendedInstallLocation
8661                            = PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE;
8662                    }
8663                }
8664            }
8665
8666            if (ret == PackageManager.INSTALL_SUCCEEDED) {
8667                int loc = pkgLite.recommendedInstallLocation;
8668                if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
8669                    ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
8670                } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
8671                    ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
8672                } else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
8673                    ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
8674                } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {
8675                    ret = PackageManager.INSTALL_FAILED_INVALID_APK;
8676                } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
8677                    ret = PackageManager.INSTALL_FAILED_INVALID_URI;
8678                } else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {
8679                    ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
8680                } else {
8681                    // Override with defaults if needed.
8682                    loc = installLocationPolicy(pkgLite, flags);
8683                    if (loc == PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE) {
8684                        ret = PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
8685                    } else if (!onSd && !onInt) {
8686                        // Override install location with flags
8687                        if (loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {
8688                            // Set the flag to install on external media.
8689                            flags |= PackageManager.INSTALL_EXTERNAL;
8690                            flags &= ~PackageManager.INSTALL_INTERNAL;
8691                        } else {
8692                            // Make sure the flag for installing on external
8693                            // media is unset
8694                            flags |= PackageManager.INSTALL_INTERNAL;
8695                            flags &= ~PackageManager.INSTALL_EXTERNAL;
8696                        }
8697                    }
8698                }
8699            }
8700
8701            final InstallArgs args = createInstallArgs(this);
8702            mArgs = args;
8703
8704            if (ret == PackageManager.INSTALL_SUCCEEDED) {
8705                 /*
8706                 * ADB installs appear as UserHandle.USER_ALL, and can only be performed by
8707                 * UserHandle.USER_OWNER, so use the package verifier for UserHandle.USER_OWNER.
8708                 */
8709                int userIdentifier = getUser().getIdentifier();
8710                if (userIdentifier == UserHandle.USER_ALL
8711                        && ((flags & PackageManager.INSTALL_FROM_ADB) != 0)) {
8712                    userIdentifier = UserHandle.USER_OWNER;
8713                }
8714
8715                /*
8716                 * Determine if we have any installed package verifiers. If we
8717                 * do, then we'll defer to them to verify the packages.
8718                 */
8719                final int requiredUid = mRequiredVerifierPackage == null ? -1
8720                        : getPackageUid(mRequiredVerifierPackage, userIdentifier);
8721                if (requiredUid != -1 && isVerificationEnabled(userIdentifier, flags)) {
8722                    // TODO: send verifier the install session instead of uri
8723                    final Intent verification = new Intent(
8724                            Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
8725                    verification.setDataAndType(Uri.fromFile(originFile), PACKAGE_MIME_TYPE);
8726                    verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
8727
8728                    final List<ResolveInfo> receivers = queryIntentReceivers(verification,
8729                            PACKAGE_MIME_TYPE, PackageManager.GET_DISABLED_COMPONENTS,
8730                            0 /* TODO: Which userId? */);
8731
8732                    if (DEBUG_VERIFY) {
8733                        Slog.d(TAG, "Found " + receivers.size() + " verifiers for intent "
8734                                + verification.toString() + " with " + pkgLite.verifiers.length
8735                                + " optional verifiers");
8736                    }
8737
8738                    final int verificationId = mPendingVerificationToken++;
8739
8740                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
8741
8742                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_PACKAGE,
8743                            installerPackageName);
8744
8745                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALL_FLAGS, flags);
8746
8747                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_PACKAGE_NAME,
8748                            pkgLite.packageName);
8749
8750                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_VERSION_CODE,
8751                            pkgLite.versionCode);
8752
8753                    if (verificationParams != null) {
8754                        if (verificationParams.getVerificationURI() != null) {
8755                           verification.putExtra(PackageManager.EXTRA_VERIFICATION_URI,
8756                                 verificationParams.getVerificationURI());
8757                        }
8758                        if (verificationParams.getOriginatingURI() != null) {
8759                            verification.putExtra(Intent.EXTRA_ORIGINATING_URI,
8760                                  verificationParams.getOriginatingURI());
8761                        }
8762                        if (verificationParams.getReferrer() != null) {
8763                            verification.putExtra(Intent.EXTRA_REFERRER,
8764                                  verificationParams.getReferrer());
8765                        }
8766                        if (verificationParams.getOriginatingUid() >= 0) {
8767                            verification.putExtra(Intent.EXTRA_ORIGINATING_UID,
8768                                  verificationParams.getOriginatingUid());
8769                        }
8770                        if (verificationParams.getInstallerUid() >= 0) {
8771                            verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_UID,
8772                                  verificationParams.getInstallerUid());
8773                        }
8774                    }
8775
8776                    final PackageVerificationState verificationState = new PackageVerificationState(
8777                            requiredUid, args);
8778
8779                    mPendingVerification.append(verificationId, verificationState);
8780
8781                    final List<ComponentName> sufficientVerifiers = matchVerifiers(pkgLite,
8782                            receivers, verificationState);
8783
8784                    /*
8785                     * If any sufficient verifiers were listed in the package
8786                     * manifest, attempt to ask them.
8787                     */
8788                    if (sufficientVerifiers != null) {
8789                        final int N = sufficientVerifiers.size();
8790                        if (N == 0) {
8791                            Slog.i(TAG, "Additional verifiers required, but none installed.");
8792                            ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
8793                        } else {
8794                            for (int i = 0; i < N; i++) {
8795                                final ComponentName verifierComponent = sufficientVerifiers.get(i);
8796
8797                                final Intent sufficientIntent = new Intent(verification);
8798                                sufficientIntent.setComponent(verifierComponent);
8799
8800                                mContext.sendBroadcastAsUser(sufficientIntent, getUser());
8801                            }
8802                        }
8803                    }
8804
8805                    final ComponentName requiredVerifierComponent = matchComponentForVerifier(
8806                            mRequiredVerifierPackage, receivers);
8807                    if (ret == PackageManager.INSTALL_SUCCEEDED
8808                            && mRequiredVerifierPackage != null) {
8809                        /*
8810                         * Send the intent to the required verification agent,
8811                         * but only start the verification timeout after the
8812                         * target BroadcastReceivers have run.
8813                         */
8814                        verification.setComponent(requiredVerifierComponent);
8815                        mContext.sendOrderedBroadcastAsUser(verification, getUser(),
8816                                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
8817                                new BroadcastReceiver() {
8818                                    @Override
8819                                    public void onReceive(Context context, Intent intent) {
8820                                        final Message msg = mHandler
8821                                                .obtainMessage(CHECK_PENDING_VERIFICATION);
8822                                        msg.arg1 = verificationId;
8823                                        mHandler.sendMessageDelayed(msg, getVerificationTimeout());
8824                                    }
8825                                }, null, 0, null, null);
8826
8827                        /*
8828                         * We don't want the copy to proceed until verification
8829                         * succeeds, so null out this field.
8830                         */
8831                        mArgs = null;
8832                    }
8833                } else {
8834                    /*
8835                     * No package verification is enabled, so immediately start
8836                     * the remote call to initiate copy using temporary file.
8837                     */
8838                    ret = args.copyApk(mContainerService, true);
8839                }
8840            }
8841
8842            mRet = ret;
8843        }
8844
8845        @Override
8846        void handleReturnCode() {
8847            // If mArgs is null, then MCS couldn't be reached. When it
8848            // reconnects, it will try again to install. At that point, this
8849            // will succeed.
8850            if (mArgs != null) {
8851                processPendingInstall(mArgs, mRet);
8852            }
8853        }
8854
8855        @Override
8856        void handleServiceError() {
8857            mArgs = createInstallArgs(this);
8858            mRet = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
8859        }
8860
8861        public boolean isForwardLocked() {
8862            return (flags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
8863        }
8864    }
8865
8866    /*
8867     * Utility class used in movePackage api.
8868     * srcArgs and targetArgs are not set for invalid flags and make
8869     * sure to do null checks when invoking methods on them.
8870     * We probably want to return ErrorPrams for both failed installs
8871     * and moves.
8872     */
8873    class MoveParams extends HandlerParams {
8874        final IPackageMoveObserver observer;
8875        final int flags;
8876        final String packageName;
8877        final InstallArgs srcArgs;
8878        final InstallArgs targetArgs;
8879        int uid;
8880        int mRet;
8881
8882        MoveParams(InstallArgs srcArgs, IPackageMoveObserver observer, int flags,
8883                String packageName, String[] instructionSets, int uid, UserHandle user,
8884                boolean isMultiArch) {
8885            super(user);
8886            this.srcArgs = srcArgs;
8887            this.observer = observer;
8888            this.flags = flags;
8889            this.packageName = packageName;
8890            this.uid = uid;
8891            if (srcArgs != null) {
8892                final String codePath = srcArgs.getCodePath();
8893                targetArgs = createInstallArgsForMoveTarget(codePath, flags, packageName,
8894                        instructionSets, isMultiArch);
8895            } else {
8896                targetArgs = null;
8897            }
8898        }
8899
8900        @Override
8901        public String toString() {
8902            return "MoveParams{"
8903                + Integer.toHexString(System.identityHashCode(this))
8904                + " " + packageName + "}";
8905        }
8906
8907        public void handleStartCopy() throws RemoteException {
8908            mRet = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
8909            // Check for storage space on target medium
8910            if (!targetArgs.checkFreeStorage(mContainerService)) {
8911                Log.w(TAG, "Insufficient storage to install");
8912                return;
8913            }
8914
8915            mRet = srcArgs.doPreCopy();
8916            if (mRet != PackageManager.INSTALL_SUCCEEDED) {
8917                return;
8918            }
8919
8920            mRet = targetArgs.copyApk(mContainerService, false);
8921            if (mRet != PackageManager.INSTALL_SUCCEEDED) {
8922                srcArgs.doPostCopy(uid);
8923                return;
8924            }
8925
8926            mRet = srcArgs.doPostCopy(uid);
8927            if (mRet != PackageManager.INSTALL_SUCCEEDED) {
8928                return;
8929            }
8930
8931            mRet = targetArgs.doPreInstall(mRet);
8932            if (mRet != PackageManager.INSTALL_SUCCEEDED) {
8933                return;
8934            }
8935
8936            if (DEBUG_SD_INSTALL) {
8937                StringBuilder builder = new StringBuilder();
8938                if (srcArgs != null) {
8939                    builder.append("src: ");
8940                    builder.append(srcArgs.getCodePath());
8941                }
8942                if (targetArgs != null) {
8943                    builder.append(" target : ");
8944                    builder.append(targetArgs.getCodePath());
8945                }
8946                Log.i(TAG, builder.toString());
8947            }
8948        }
8949
8950        @Override
8951        void handleReturnCode() {
8952            targetArgs.doPostInstall(mRet, uid);
8953            int currentStatus = PackageManager.MOVE_FAILED_INTERNAL_ERROR;
8954            if (mRet == PackageManager.INSTALL_SUCCEEDED) {
8955                currentStatus = PackageManager.MOVE_SUCCEEDED;
8956            } else if (mRet == PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE){
8957                currentStatus = PackageManager.MOVE_FAILED_INSUFFICIENT_STORAGE;
8958            }
8959            processPendingMove(this, currentStatus);
8960        }
8961
8962        @Override
8963        void handleServiceError() {
8964            mRet = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
8965        }
8966    }
8967
8968    /**
8969     * Used during creation of InstallArgs
8970     *
8971     * @param flags package installation flags
8972     * @return true if should be installed on external storage
8973     */
8974    private static boolean installOnSd(int flags) {
8975        if ((flags & PackageManager.INSTALL_INTERNAL) != 0) {
8976            return false;
8977        }
8978        if ((flags & PackageManager.INSTALL_EXTERNAL) != 0) {
8979            return true;
8980        }
8981        return false;
8982    }
8983
8984    /**
8985     * Used during creation of InstallArgs
8986     *
8987     * @param flags package installation flags
8988     * @return true if should be installed as forward locked
8989     */
8990    private static boolean installForwardLocked(int flags) {
8991        return (flags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
8992    }
8993
8994    private InstallArgs createInstallArgs(InstallParams params) {
8995        // TODO: extend to support incoming zero-copy locations
8996
8997        if (installOnSd(params.flags) || params.isForwardLocked()) {
8998            return new AsecInstallArgs(params);
8999        } else {
9000            return new FileInstallArgs(params);
9001        }
9002    }
9003
9004    /**
9005     * Create args that describe an existing installed package. Typically used
9006     * when cleaning up old installs, or used as a move source.
9007     */
9008    private InstallArgs createInstallArgsForExisting(int flags, String codePath,
9009            String resourcePath, String nativeLibraryRoot, String[] instructionSets,
9010            boolean isMultiArch) {
9011        final boolean isInAsec;
9012        if (installOnSd(flags)) {
9013            /* Apps on SD card are always in ASEC containers. */
9014            isInAsec = true;
9015        } else if (installForwardLocked(flags)
9016                && !codePath.startsWith(mDrmAppPrivateInstallDir.getAbsolutePath())) {
9017            /*
9018             * Forward-locked apps are only in ASEC containers if they're the
9019             * new style
9020             */
9021            isInAsec = true;
9022        } else {
9023            isInAsec = false;
9024        }
9025
9026        if (isInAsec) {
9027            return new AsecInstallArgs(codePath, instructionSets,
9028                    installOnSd(flags), installForwardLocked(flags), isMultiArch);
9029        } else {
9030            return new FileInstallArgs(codePath, resourcePath, nativeLibraryRoot,
9031                    instructionSets, isMultiArch);
9032        }
9033    }
9034
9035    private InstallArgs createInstallArgsForMoveTarget(String codePath, int flags, String pkgName,
9036            String[] instructionSets, boolean isMultiArch) {
9037        final File codeFile = new File(codePath);
9038        if (installOnSd(flags) || installForwardLocked(flags)) {
9039            String cid = getNextCodePath(codePath, pkgName, "/"
9040                    + AsecInstallArgs.RES_FILE_NAME);
9041            return new AsecInstallArgs(codeFile, cid, instructionSets, installOnSd(flags),
9042                    installForwardLocked(flags), isMultiArch);
9043        } else {
9044            return new FileInstallArgs(codeFile, instructionSets, isMultiArch);
9045        }
9046    }
9047
9048    static abstract class InstallArgs {
9049        /** @see InstallParams#originFile */
9050        final File originFile;
9051        /** @see InstallParams#originStaged */
9052        final boolean originStaged;
9053
9054        // TODO: define inherit location
9055
9056        final IPackageInstallObserver2 observer;
9057        // Always refers to PackageManager flags only
9058        final int flags;
9059        final String installerPackageName;
9060        final ManifestDigest manifestDigest;
9061        final UserHandle user;
9062        final String abiOverride;
9063        final boolean multiArch;
9064
9065        // The list of instruction sets supported by this app. This is currently
9066        // only used during the rmdex() phase to clean up resources. We can get rid of this
9067        // if we move dex files under the common app path.
9068        /* nullable */ String[] instructionSets;
9069
9070        InstallArgs(File originFile, boolean originStaged, IPackageInstallObserver2 observer,
9071                    int flags, String installerPackageName, ManifestDigest manifestDigest,
9072                    UserHandle user, String[] instructionSets,
9073                    String abiOverride, boolean multiArch) {
9074            this.originFile = originFile;
9075            this.originStaged = originStaged;
9076            this.flags = flags;
9077            this.observer = observer;
9078            this.installerPackageName = installerPackageName;
9079            this.manifestDigest = manifestDigest;
9080            this.user = user;
9081            this.instructionSets = instructionSets;
9082            this.abiOverride = abiOverride;
9083            this.multiArch = multiArch;
9084        }
9085
9086        abstract int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException;
9087        abstract int doPreInstall(int status);
9088
9089        /**
9090         * Rename package into final resting place. All paths on the given
9091         * scanned package should be updated to reflect the rename.
9092         */
9093        abstract boolean doRename(int status, PackageParser.Package pkg, String oldCodePath);
9094        abstract int doPostInstall(int status, int uid);
9095
9096        /** @see PackageSettingBase#codePathString */
9097        abstract String getCodePath();
9098        /** @see PackageSettingBase#resourcePathString */
9099        abstract String getResourcePath();
9100        abstract String getLegacyNativeLibraryPath();
9101
9102        // Need installer lock especially for dex file removal.
9103        abstract void cleanUpResourcesLI();
9104        abstract boolean doPostDeleteLI(boolean delete);
9105        abstract boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException;
9106
9107        /**
9108         * Called before the source arguments are copied. This is used mostly
9109         * for MoveParams when it needs to read the source file to put it in the
9110         * destination.
9111         */
9112        int doPreCopy() {
9113            return PackageManager.INSTALL_SUCCEEDED;
9114        }
9115
9116        /**
9117         * Called after the source arguments are copied. This is used mostly for
9118         * MoveParams when it needs to read the source file to put it in the
9119         * destination.
9120         *
9121         * @return
9122         */
9123        int doPostCopy(int uid) {
9124            return PackageManager.INSTALL_SUCCEEDED;
9125        }
9126
9127        protected boolean isFwdLocked() {
9128            return (flags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
9129        }
9130
9131        UserHandle getUser() {
9132            return user;
9133        }
9134    }
9135
9136    /**
9137     * Logic to handle installation of non-ASEC applications, including copying
9138     * and renaming logic.
9139     */
9140    class FileInstallArgs extends InstallArgs {
9141        private File codeFile;
9142        private File resourceFile;
9143        private File legacyNativeLibraryPath;
9144
9145        // Example topology:
9146        // /data/app/com.example/base.apk
9147        // /data/app/com.example/split_foo.apk
9148        // /data/app/com.example/lib/arm/libfoo.so
9149        // /data/app/com.example/lib/arm64/libfoo.so
9150        // /data/app/com.example/dalvik/arm/base.apk@classes.dex
9151
9152        /** New install */
9153        FileInstallArgs(InstallParams params) {
9154            super(params.originFile, params.originStaged, params.observer, params.flags,
9155                    params.installerPackageName, params.getManifestDigest(), params.getUser(),
9156                    null /* instruction sets */, params.packageAbiOverride,
9157                    params.multiArch);
9158            if (isFwdLocked()) {
9159                throw new IllegalArgumentException("Forward locking only supported in ASEC");
9160            }
9161        }
9162
9163        /** Existing install */
9164        FileInstallArgs(String codePath, String resourcePath, String legacyNativeLibraryPath,
9165                String[] instructionSets, boolean isMultiArch) {
9166            super(null, false, null, 0, null, null, null, instructionSets, null, isMultiArch);
9167            this.codeFile = (codePath != null) ? new File(codePath) : null;
9168            this.resourceFile = (resourcePath != null) ? new File(resourcePath) : null;
9169            this.legacyNativeLibraryPath = (legacyNativeLibraryPath != null) ?
9170                    new File(legacyNativeLibraryPath) : null;
9171        }
9172
9173        /** New install from existing */
9174        FileInstallArgs(File originFile, String[] instructionSets, boolean isMultiArch) {
9175            super(originFile, false, null, 0, null, null, null, instructionSets, null,
9176                    isMultiArch);
9177        }
9178
9179        boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException {
9180            final long lowThreshold;
9181
9182            final DeviceStorageMonitorInternal
9183                    dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
9184            if (dsm == null) {
9185                Log.w(TAG, "Couldn't get low memory threshold; no free limit imposed");
9186                lowThreshold = 0L;
9187            } else {
9188                if (dsm.isMemoryLow()) {
9189                    Log.w(TAG, "Memory is reported as being too low; aborting package install");
9190                    return false;
9191                }
9192
9193                lowThreshold = dsm.getMemoryLowThreshold();
9194            }
9195
9196            return imcs.checkInternalFreeStorage(originFile.getAbsolutePath(), isFwdLocked(),
9197                    lowThreshold);
9198        }
9199
9200        int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
9201            int ret = PackageManager.INSTALL_SUCCEEDED;
9202
9203            if (originStaged) {
9204                Slog.d(TAG, originFile + " already staged; skipping copy");
9205                codeFile = originFile;
9206                resourceFile = originFile;
9207            } else {
9208                try {
9209                    final File tempDir = mInstallerService.allocateSessionDir();
9210                    codeFile = tempDir;
9211                    resourceFile = tempDir;
9212                } catch (IOException e) {
9213                    Slog.w(TAG, "Failed to create copy file: " + e);
9214                    return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
9215                }
9216
9217                final IParcelFileDescriptorFactory target = new IParcelFileDescriptorFactory.Stub() {
9218                    @Override
9219                    public ParcelFileDescriptor open(String name, int mode) throws RemoteException {
9220                        if (!FileUtils.isValidExtFilename(name)) {
9221                            throw new IllegalArgumentException("Invalid filename: " + name);
9222                        }
9223                        try {
9224                            final File file = new File(codeFile, name);
9225                            final FileDescriptor fd = Os.open(file.getAbsolutePath(),
9226                                    O_RDWR | O_CREAT, 0644);
9227                            Os.chmod(file.getAbsolutePath(), 0644);
9228                            return new ParcelFileDescriptor(fd);
9229                        } catch (ErrnoException e) {
9230                            throw new RemoteException("Failed to open: " + e.getMessage());
9231                        }
9232                    }
9233                };
9234
9235                ret = imcs.copyPackage(originFile.getAbsolutePath(), target);
9236                if (ret != PackageManager.INSTALL_SUCCEEDED) {
9237                    Slog.e(TAG, "Failed to copy package");
9238                    return ret;
9239                }
9240            }
9241
9242            final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
9243            NativeLibraryHelper.Handle handle = null;
9244            try {
9245                handle = NativeLibraryHelper.Handle.create(codeFile);
9246                if (multiArch) {
9247                    // Warn if we've set an abiOverride for multi-lib packages..
9248                    // By definition, we need to copy both 32 and 64 bit libraries for
9249                    // such packages.
9250                    if (abiOverride != null) {
9251                        Slog.w(TAG, "Ignoring abiOverride for multi arch application.");
9252                    }
9253
9254                    int copyRet = PackageManager.NO_NATIVE_LIBRARIES;
9255                    if (Build.SUPPORTED_32_BIT_ABIS.length > 0) {
9256                        copyRet = copyNativeLibrariesForInternalApp(handle, libraryRoot,
9257                                Build.SUPPORTED_32_BIT_ABIS, true /* use isa specific subdirs */);
9258                        maybeThrowExceptionForMultiArchCopy("Failure copying 32 bit native libraries", copyRet);
9259                    }
9260
9261                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0) {
9262                        copyRet = copyNativeLibrariesForInternalApp(handle, libraryRoot,
9263                                Build.SUPPORTED_64_BIT_ABIS, true /* use isa specific subdirs */);
9264                        maybeThrowExceptionForMultiArchCopy("Failure copying 64 bit native libraries", copyRet);
9265                    }
9266                } else {
9267                    String[] abiList = (abiOverride != null) ?
9268                            new String[] { abiOverride } : Build.SUPPORTED_ABIS;
9269
9270                    if (Build.SUPPORTED_64_BIT_ABIS.length > 0 && abiOverride == null &&
9271                            NativeLibraryHelper.hasRenderscriptBitcode(handle)) {
9272                        abiList = Build.SUPPORTED_32_BIT_ABIS;
9273                    }
9274
9275                    int copyRet = copyNativeLibrariesForInternalApp(handle, libraryRoot, abiList,
9276                            true /* use isa specific subdirs */);
9277                    if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES) {
9278                        Slog.w(TAG, "Failure copying native libraries [errorCode=" + copyRet + "]");
9279                        return copyRet;
9280                    }
9281                }
9282            } catch (IOException e) {
9283                Slog.e(TAG, "Copying native libraries failed", e);
9284                ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
9285            } catch (PackageManagerException pme) {
9286                Slog.e(TAG, "Copying native libraries failed", pme);
9287                ret = pme.error;
9288            } finally {
9289                IoUtils.closeQuietly(handle);
9290            }
9291
9292            return ret;
9293        }
9294
9295        int doPreInstall(int status) {
9296            if (status != PackageManager.INSTALL_SUCCEEDED) {
9297                cleanUp();
9298            }
9299            return status;
9300        }
9301
9302        boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
9303            if (status != PackageManager.INSTALL_SUCCEEDED) {
9304                cleanUp();
9305                return false;
9306            } else {
9307                final File beforeCodeFile = codeFile;
9308                final File afterCodeFile = getNextCodePath(pkg.packageName);
9309
9310                Slog.d(TAG, "Renaming " + beforeCodeFile + " to " + afterCodeFile);
9311                try {
9312                    Os.rename(beforeCodeFile.getAbsolutePath(), afterCodeFile.getAbsolutePath());
9313                } catch (ErrnoException e) {
9314                    Slog.d(TAG, "Failed to rename", e);
9315                    return false;
9316                }
9317
9318                if (!SELinux.restoreconRecursive(afterCodeFile)) {
9319                    Slog.d(TAG, "Failed to restorecon");
9320                    return false;
9321                }
9322
9323                // Reflect the rename internally
9324                codeFile = afterCodeFile;
9325                resourceFile = afterCodeFile;
9326
9327                // Reflect the rename in scanned details
9328                pkg.codePath = afterCodeFile.getAbsolutePath();
9329                pkg.baseCodePath = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
9330                        pkg.baseCodePath);
9331                pkg.splitCodePaths = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
9332                        pkg.splitCodePaths);
9333
9334                // Reflect the rename in app info
9335                pkg.applicationInfo.setCodePath(pkg.codePath);
9336                pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
9337                pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
9338                pkg.applicationInfo.setResourcePath(pkg.codePath);
9339                pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
9340                pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
9341
9342                return true;
9343            }
9344        }
9345
9346        int doPostInstall(int status, int uid) {
9347            if (status != PackageManager.INSTALL_SUCCEEDED) {
9348                cleanUp();
9349            }
9350            return status;
9351        }
9352
9353        @Override
9354        String getCodePath() {
9355            return (codeFile != null) ? codeFile.getAbsolutePath() : null;
9356        }
9357
9358        @Override
9359        String getResourcePath() {
9360            return (resourceFile != null) ? resourceFile.getAbsolutePath() : null;
9361        }
9362
9363        @Override
9364        String getLegacyNativeLibraryPath() {
9365            return (legacyNativeLibraryPath != null) ? legacyNativeLibraryPath.getAbsolutePath() : null;
9366        }
9367
9368        private boolean cleanUp() {
9369            if (codeFile == null || !codeFile.exists()) {
9370                return false;
9371            }
9372
9373            if (codeFile.isDirectory()) {
9374                FileUtils.deleteContents(codeFile);
9375            }
9376            codeFile.delete();
9377
9378            if (resourceFile != null && !FileUtils.contains(codeFile, resourceFile)) {
9379                resourceFile.delete();
9380            }
9381
9382            if (legacyNativeLibraryPath != null && !FileUtils.contains(codeFile, legacyNativeLibraryPath)) {
9383                if (!FileUtils.deleteContents(legacyNativeLibraryPath)) {
9384                    Slog.w(TAG, "Couldn't delete native library directory " + legacyNativeLibraryPath);
9385                }
9386                legacyNativeLibraryPath.delete();
9387            }
9388
9389            return true;
9390        }
9391
9392        void cleanUpResourcesLI() {
9393            // Try enumerating all code paths before deleting
9394            List<String> allCodePaths = Collections.EMPTY_LIST;
9395            if (codeFile != null && codeFile.exists()) {
9396                try {
9397                    final PackageLite pkg = PackageParser.parsePackageLite(codeFile, 0);
9398                    allCodePaths = pkg.getAllCodePaths();
9399                } catch (PackageParserException e) {
9400                    // Ignored; we tried our best
9401                }
9402            }
9403
9404            cleanUp();
9405
9406            if (!allCodePaths.isEmpty()) {
9407                if (instructionSets == null) {
9408                    throw new IllegalStateException("instructionSet == null");
9409                }
9410
9411                for (String codePath : allCodePaths) {
9412                    for (String instructionSet : instructionSets) {
9413                        int retCode = mInstaller.rmdex(codePath, instructionSet);
9414                        if (retCode < 0) {
9415                            Slog.w(TAG, "Couldn't remove dex file for package: "
9416                                    + " at location " + codePath + ", retcode=" + retCode);
9417                            // we don't consider this to be a failure of the core package deletion
9418                        }
9419                    }
9420                }
9421            }
9422        }
9423
9424        boolean doPostDeleteLI(boolean delete) {
9425            // XXX err, shouldn't we respect the delete flag?
9426            cleanUpResourcesLI();
9427            return true;
9428        }
9429    }
9430
9431    private boolean isAsecExternal(String cid) {
9432        final String asecPath = PackageHelper.getSdFilesystem(cid);
9433        return !asecPath.startsWith(mAsecInternalPath);
9434    }
9435
9436    private static void maybeThrowExceptionForMultiArchCopy(String message, int copyRet) throws
9437            PackageManagerException {
9438        if (copyRet < 0) {
9439            if (copyRet != PackageManager.NO_NATIVE_LIBRARIES &&
9440                    copyRet != PackageManager.INSTALL_FAILED_NO_MATCHING_ABIS) {
9441                throw new PackageManagerException(copyRet, message);
9442            }
9443        }
9444    }
9445
9446    /**
9447     * Extract the MountService "container ID" from the full code path of an
9448     * .apk.
9449     */
9450    static String cidFromCodePath(String fullCodePath) {
9451        int eidx = fullCodePath.lastIndexOf("/");
9452        String subStr1 = fullCodePath.substring(0, eidx);
9453        int sidx = subStr1.lastIndexOf("/");
9454        return subStr1.substring(sidx+1, eidx);
9455    }
9456
9457    /**
9458     * Logic to handle installation of ASEC applications, including copying and
9459     * renaming logic.
9460     */
9461    class AsecInstallArgs extends InstallArgs {
9462        // TODO: teach about handling cluster directories
9463
9464        static final String RES_FILE_NAME = "pkg.apk";
9465        static final String PUBLIC_RES_FILE_NAME = "res.zip";
9466
9467        String cid;
9468        String packagePath;
9469        String resourcePath;
9470        String legacyNativeLibraryDir;
9471
9472        /** New install */
9473        AsecInstallArgs(InstallParams params) {
9474            super(params.originFile, params.originStaged, params.observer, params.flags,
9475                    params.installerPackageName, params.getManifestDigest(),
9476                    params.getUser(), null /* instruction sets */,
9477                    params.packageAbiOverride, params.multiArch);
9478        }
9479
9480        /** Existing install */
9481        AsecInstallArgs(String fullCodePath, String[] instructionSets,
9482                        boolean isExternal, boolean isForwardLocked, boolean isMultiArch) {
9483            super(null, false, null, (isExternal ? INSTALL_EXTERNAL : 0)
9484                    | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null,
9485                    instructionSets, null, isMultiArch);
9486            // Extract cid from fullCodePath
9487            int eidx = fullCodePath.lastIndexOf("/");
9488            String subStr1 = fullCodePath.substring(0, eidx);
9489            int sidx = subStr1.lastIndexOf("/");
9490            cid = subStr1.substring(sidx+1, eidx);
9491            setCachePath(subStr1);
9492        }
9493
9494        AsecInstallArgs(String cid, String[] instructionSets, boolean isForwardLocked,
9495                        boolean isMultiArch) {
9496            super(null, false, null, (isAsecExternal(cid) ? INSTALL_EXTERNAL : 0)
9497                    | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null,
9498                    instructionSets, null, isMultiArch);
9499            this.cid = cid;
9500            setCachePath(PackageHelper.getSdDir(cid));
9501        }
9502
9503        /** New install from existing */
9504        AsecInstallArgs(File originPackageFile, String cid, String[] instructionSets,
9505                boolean isExternal, boolean isForwardLocked, boolean isMultiArch) {
9506            super(originPackageFile, false, null, (isExternal ? INSTALL_EXTERNAL : 0)
9507                    | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null,
9508                    instructionSets, null, isMultiArch);
9509            this.cid = cid;
9510        }
9511
9512        void createCopyFile() {
9513            cid = getTempContainerId();
9514        }
9515
9516        boolean checkFreeStorage(IMediaContainerService imcs) throws RemoteException {
9517            return imcs.checkExternalFreeStorage(originFile.getAbsolutePath(), isFwdLocked(),
9518                    abiOverride);
9519        }
9520
9521        private final boolean isExternal() {
9522            return (flags & PackageManager.INSTALL_EXTERNAL) != 0;
9523        }
9524
9525        int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
9526            if (temp) {
9527                createCopyFile();
9528            } else {
9529                /*
9530                 * Pre-emptively destroy the container since it's destroyed if
9531                 * copying fails due to it existing anyway.
9532                 */
9533                PackageHelper.destroySdDir(cid);
9534            }
9535
9536            final String newCachePath = imcs.copyPackageToContainer(
9537                    originFile.getAbsolutePath(), cid, getEncryptKey(), isExternal(),
9538                    isFwdLocked(), abiOverride);
9539
9540            if (newCachePath != null) {
9541                setCachePath(newCachePath);
9542                return PackageManager.INSTALL_SUCCEEDED;
9543            } else {
9544                return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9545            }
9546        }
9547
9548        @Override
9549        String getCodePath() {
9550            return packagePath;
9551        }
9552
9553        @Override
9554        String getResourcePath() {
9555            return resourcePath;
9556        }
9557
9558        @Override
9559        String getLegacyNativeLibraryPath() {
9560            return legacyNativeLibraryDir;
9561        }
9562
9563        int doPreInstall(int status) {
9564            if (status != PackageManager.INSTALL_SUCCEEDED) {
9565                // Destroy container
9566                PackageHelper.destroySdDir(cid);
9567            } else {
9568                boolean mounted = PackageHelper.isContainerMounted(cid);
9569                if (!mounted) {
9570                    String newCachePath = PackageHelper.mountSdDir(cid, getEncryptKey(),
9571                            Process.SYSTEM_UID);
9572                    if (newCachePath != null) {
9573                        setCachePath(newCachePath);
9574                    } else {
9575                        return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9576                    }
9577                }
9578            }
9579            return status;
9580        }
9581
9582        boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
9583            String newCacheId = getNextCodePath(oldCodePath, pkg.packageName, "/" + RES_FILE_NAME);
9584            String newCachePath = null;
9585            if (PackageHelper.isContainerMounted(cid)) {
9586                // Unmount the container
9587                if (!PackageHelper.unMountSdDir(cid)) {
9588                    Slog.i(TAG, "Failed to unmount " + cid + " before renaming");
9589                    return false;
9590                }
9591            }
9592            if (!PackageHelper.renameSdDir(cid, newCacheId)) {
9593                Slog.e(TAG, "Failed to rename " + cid + " to " + newCacheId +
9594                        " which might be stale. Will try to clean up.");
9595                // Clean up the stale container and proceed to recreate.
9596                if (!PackageHelper.destroySdDir(newCacheId)) {
9597                    Slog.e(TAG, "Very strange. Cannot clean up stale container " + newCacheId);
9598                    return false;
9599                }
9600                // Successfully cleaned up stale container. Try to rename again.
9601                if (!PackageHelper.renameSdDir(cid, newCacheId)) {
9602                    Slog.e(TAG, "Failed to rename " + cid + " to " + newCacheId
9603                            + " inspite of cleaning it up.");
9604                    return false;
9605                }
9606            }
9607            if (!PackageHelper.isContainerMounted(newCacheId)) {
9608                Slog.w(TAG, "Mounting container " + newCacheId);
9609                newCachePath = PackageHelper.mountSdDir(newCacheId,
9610                        getEncryptKey(), Process.SYSTEM_UID);
9611            } else {
9612                newCachePath = PackageHelper.getSdDir(newCacheId);
9613            }
9614            if (newCachePath == null) {
9615                Slog.w(TAG, "Failed to get cache path for  " + newCacheId);
9616                return false;
9617            }
9618            Log.i(TAG, "Succesfully renamed " + cid +
9619                    " to " + newCacheId +
9620                    " at new path: " + newCachePath);
9621            cid = newCacheId;
9622            setCachePath(newCachePath);
9623
9624            // TODO: extend to support split APKs
9625            pkg.codePath = getCodePath();
9626            pkg.baseCodePath = getCodePath();
9627            pkg.splitCodePaths = null;
9628
9629            pkg.applicationInfo.setCodePath(getCodePath());
9630            pkg.applicationInfo.setBaseCodePath(getCodePath());
9631            pkg.applicationInfo.setSplitCodePaths(null);
9632            pkg.applicationInfo.setResourcePath(getResourcePath());
9633            pkg.applicationInfo.setBaseResourcePath(getResourcePath());
9634            pkg.applicationInfo.setSplitResourcePaths(null);
9635
9636            return true;
9637        }
9638
9639        private void setCachePath(String newCachePath) {
9640            File cachePath = new File(newCachePath);
9641            legacyNativeLibraryDir = new File(cachePath, LIB_DIR_NAME).getPath();
9642            packagePath = new File(cachePath, RES_FILE_NAME).getPath();
9643
9644            if (isFwdLocked()) {
9645                resourcePath = new File(cachePath, PUBLIC_RES_FILE_NAME).getPath();
9646            } else {
9647                resourcePath = packagePath;
9648            }
9649        }
9650
9651        int doPostInstall(int status, int uid) {
9652            if (status != PackageManager.INSTALL_SUCCEEDED) {
9653                cleanUp();
9654            } else {
9655                final int groupOwner;
9656                final String protectedFile;
9657                if (isFwdLocked()) {
9658                    groupOwner = UserHandle.getSharedAppGid(uid);
9659                    protectedFile = RES_FILE_NAME;
9660                } else {
9661                    groupOwner = -1;
9662                    protectedFile = null;
9663                }
9664
9665                if (uid < Process.FIRST_APPLICATION_UID
9666                        || !PackageHelper.fixSdPermissions(cid, groupOwner, protectedFile)) {
9667                    Slog.e(TAG, "Failed to finalize " + cid);
9668                    PackageHelper.destroySdDir(cid);
9669                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9670                }
9671
9672                boolean mounted = PackageHelper.isContainerMounted(cid);
9673                if (!mounted) {
9674                    PackageHelper.mountSdDir(cid, getEncryptKey(), Process.myUid());
9675                }
9676            }
9677            return status;
9678        }
9679
9680        private void cleanUp() {
9681            if (DEBUG_SD_INSTALL) Slog.i(TAG, "cleanUp");
9682
9683            // Destroy secure container
9684            PackageHelper.destroySdDir(cid);
9685        }
9686
9687        void cleanUpResourcesLI() {
9688            String sourceFile = getCodePath();
9689            // Remove dex file
9690            if (instructionSets == null) {
9691                throw new IllegalStateException("instructionSet == null");
9692            }
9693            for (String instructionSet : instructionSets) {
9694                int retCode = mInstaller.rmdex(sourceFile, instructionSet);
9695                if (retCode < 0) {
9696                    Slog.w(TAG, "Couldn't remove dex file for package: "
9697                            + " at location "
9698                            + sourceFile.toString() + ", retcode=" + retCode);
9699                    // we don't consider this to be a failure of the core package deletion
9700                }
9701            }
9702            cleanUp();
9703        }
9704
9705        boolean matchContainer(String app) {
9706            if (cid.startsWith(app)) {
9707                return true;
9708            }
9709            return false;
9710        }
9711
9712        String getPackageName() {
9713            return getAsecPackageName(cid);
9714        }
9715
9716        boolean doPostDeleteLI(boolean delete) {
9717            boolean ret = false;
9718            boolean mounted = PackageHelper.isContainerMounted(cid);
9719            if (mounted) {
9720                // Unmount first
9721                ret = PackageHelper.unMountSdDir(cid);
9722            }
9723            if (ret && delete) {
9724                cleanUpResourcesLI();
9725            }
9726            return ret;
9727        }
9728
9729        @Override
9730        int doPreCopy() {
9731            if (isFwdLocked()) {
9732                if (!PackageHelper.fixSdPermissions(cid,
9733                        getPackageUid(DEFAULT_CONTAINER_PACKAGE, 0), RES_FILE_NAME)) {
9734                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9735                }
9736            }
9737
9738            return PackageManager.INSTALL_SUCCEEDED;
9739        }
9740
9741        @Override
9742        int doPostCopy(int uid) {
9743            if (isFwdLocked()) {
9744                if (uid < Process.FIRST_APPLICATION_UID
9745                        || !PackageHelper.fixSdPermissions(cid, UserHandle.getSharedAppGid(uid),
9746                                RES_FILE_NAME)) {
9747                    Slog.e(TAG, "Failed to finalize " + cid);
9748                    PackageHelper.destroySdDir(cid);
9749                    return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
9750                }
9751            }
9752
9753            return PackageManager.INSTALL_SUCCEEDED;
9754        }
9755    }
9756
9757    static String getAsecPackageName(String packageCid) {
9758        int idx = packageCid.lastIndexOf("-");
9759        if (idx == -1) {
9760            return packageCid;
9761        }
9762        return packageCid.substring(0, idx);
9763    }
9764
9765    // Utility method used to create code paths based on package name and available index.
9766    private static String getNextCodePath(String oldCodePath, String prefix, String suffix) {
9767        String idxStr = "";
9768        int idx = 1;
9769        // Fall back to default value of idx=1 if prefix is not
9770        // part of oldCodePath
9771        if (oldCodePath != null) {
9772            String subStr = oldCodePath;
9773            // Drop the suffix right away
9774            if (suffix != null && subStr.endsWith(suffix)) {
9775                subStr = subStr.substring(0, subStr.length() - suffix.length());
9776            }
9777            // If oldCodePath already contains prefix find out the
9778            // ending index to either increment or decrement.
9779            int sidx = subStr.lastIndexOf(prefix);
9780            if (sidx != -1) {
9781                subStr = subStr.substring(sidx + prefix.length());
9782                if (subStr != null) {
9783                    if (subStr.startsWith(INSTALL_PACKAGE_SUFFIX)) {
9784                        subStr = subStr.substring(INSTALL_PACKAGE_SUFFIX.length());
9785                    }
9786                    try {
9787                        idx = Integer.parseInt(subStr);
9788                        if (idx <= 1) {
9789                            idx++;
9790                        } else {
9791                            idx--;
9792                        }
9793                    } catch(NumberFormatException e) {
9794                    }
9795                }
9796            }
9797        }
9798        idxStr = INSTALL_PACKAGE_SUFFIX + Integer.toString(idx);
9799        return prefix + idxStr;
9800    }
9801
9802    private File getNextCodePath(String packageName) {
9803        int suffix = 1;
9804        File result;
9805        do {
9806            result = new File(mAppInstallDir, packageName + "-" + suffix);
9807            suffix++;
9808        } while (result.exists());
9809        return result;
9810    }
9811
9812    // Utility method used to ignore ADD/REMOVE events
9813    // by directory observer.
9814    private static boolean ignoreCodePath(String fullPathStr) {
9815        String apkName = deriveCodePathName(fullPathStr);
9816        int idx = apkName.lastIndexOf(INSTALL_PACKAGE_SUFFIX);
9817        if (idx != -1 && ((idx+1) < apkName.length())) {
9818            // Make sure the package ends with a numeral
9819            String version = apkName.substring(idx+1);
9820            try {
9821                Integer.parseInt(version);
9822                return true;
9823            } catch (NumberFormatException e) {}
9824        }
9825        return false;
9826    }
9827
9828    // Utility method that returns the relative package path with respect
9829    // to the installation directory. Like say for /data/data/com.test-1.apk
9830    // string com.test-1 is returned.
9831    static String deriveCodePathName(String codePath) {
9832        if (codePath == null) {
9833            return null;
9834        }
9835        final File codeFile = new File(codePath);
9836        final String name = codeFile.getName();
9837        if (codeFile.isDirectory()) {
9838            return name;
9839        } else if (name.endsWith(".apk") || name.endsWith(".tmp")) {
9840            final int lastDot = name.lastIndexOf('.');
9841            return name.substring(0, lastDot);
9842        } else {
9843            Slog.w(TAG, "Odd, " + codePath + " doesn't look like an APK");
9844            return null;
9845        }
9846    }
9847
9848    class PackageInstalledInfo {
9849        String name;
9850        int uid;
9851        // The set of users that originally had this package installed.
9852        int[] origUsers;
9853        // The set of users that now have this package installed.
9854        int[] newUsers;
9855        PackageParser.Package pkg;
9856        int returnCode;
9857        String returnMsg;
9858        PackageRemovedInfo removedInfo;
9859
9860        public void setError(int code, String msg) {
9861            returnCode = code;
9862            returnMsg = msg;
9863            Slog.w(TAG, msg);
9864        }
9865
9866        // In some error cases we want to convey more info back to the observer
9867        String origPackage;
9868        String origPermission;
9869    }
9870
9871    /*
9872     * Install a non-existing package.
9873     */
9874    private void installNewPackageLI(PackageParser.Package pkg,
9875            int parseFlags, int scanMode, UserHandle user,
9876            String installerPackageName, PackageInstalledInfo res, String abiOverride) {
9877        // Remember this for later, in case we need to rollback this install
9878        String pkgName = pkg.packageName;
9879
9880        if (DEBUG_INSTALL) Slog.d(TAG, "installNewPackageLI: " + pkg);
9881        boolean dataDirExists = getDataPathForPackage(pkg.packageName, 0).exists();
9882        synchronized(mPackages) {
9883            if (mSettings.mRenamedPackages.containsKey(pkgName)) {
9884                // A package with the same name is already installed, though
9885                // it has been renamed to an older name.  The package we
9886                // are trying to install should be installed as an update to
9887                // the existing one, but that has not been requested, so bail.
9888                res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
9889                        + " without first uninstalling package running as "
9890                        + mSettings.mRenamedPackages.get(pkgName));
9891                return;
9892            }
9893            if (mPackages.containsKey(pkgName) || mAppDirs.containsKey(pkg.codePath)) {
9894                // Don't allow installation over an existing package with the same name.
9895                res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
9896                        + " without first uninstalling.");
9897                return;
9898            }
9899        }
9900
9901        try {
9902            PackageParser.Package newPackage = scanPackageLI(pkg, parseFlags, scanMode,
9903                    System.currentTimeMillis(), user, abiOverride);
9904
9905            updateSettingsLI(newPackage, installerPackageName, null, null, res);
9906            // delete the partially installed application. the data directory will have to be
9907            // restored if it was already existing
9908            if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
9909                // remove package from internal structures.  Note that we want deletePackageX to
9910                // delete the package data and cache directories that it created in
9911                // scanPackageLocked, unless those directories existed before we even tried to
9912                // install.
9913                deletePackageLI(pkgName, UserHandle.ALL, false, null, null,
9914                        dataDirExists ? PackageManager.DELETE_KEEP_DATA : 0,
9915                                res.removedInfo, true);
9916            }
9917
9918        } catch (PackageManagerException e) {
9919            res.setError(e.error,
9920                    "Package couldn't be installed in " + pkg.codePath + ": " + e.getMessage());
9921        }
9922    }
9923
9924    private boolean checkUpgradeKeySetLP(PackageSetting oldPS, PackageParser.Package newPkg) {
9925        // Upgrade keysets are being used.  Determine if new package has a superset of the
9926        // required keys.
9927        long[] upgradeKeySets = oldPS.keySetData.getUpgradeKeySets();
9928        KeySetManagerService ksms = mSettings.mKeySetManagerService;
9929        for (int i = 0; i < upgradeKeySets.length; i++) {
9930            Set<PublicKey> upgradeSet = ksms.getPublicKeysFromKeySetLPr(upgradeKeySets[i]);
9931            if (newPkg.mSigningKeys.containsAll(upgradeSet)) {
9932                return true;
9933            }
9934        }
9935        return false;
9936    }
9937
9938    private void replacePackageLI(PackageParser.Package pkg,
9939            int parseFlags, int scanMode, UserHandle user,
9940            String installerPackageName, PackageInstalledInfo res, String abiOverride) {
9941        PackageParser.Package oldPackage;
9942        String pkgName = pkg.packageName;
9943        int[] allUsers;
9944        boolean[] perUserInstalled;
9945
9946        // First find the old package info and check signatures
9947        synchronized(mPackages) {
9948            oldPackage = mPackages.get(pkgName);
9949            if (DEBUG_INSTALL) Slog.d(TAG, "replacePackageLI: new=" + pkg + ", old=" + oldPackage);
9950            PackageSetting ps = mSettings.mPackages.get(pkgName);
9951            if (ps == null || !ps.keySetData.isUsingUpgradeKeySets() || ps.sharedUser != null) {
9952                // default to original signature matching
9953                if (compareSignatures(oldPackage.mSignatures, pkg.mSignatures)
9954                    != PackageManager.SIGNATURE_MATCH) {
9955                    res.setError(INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
9956                            "New package has a different signature: " + pkgName);
9957                    return;
9958                }
9959            } else {
9960                if(!checkUpgradeKeySetLP(ps, pkg)) {
9961                    res.setError(INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
9962                            "New package not signed by keys specified by upgrade-keysets: "
9963                            + pkgName);
9964                    return;
9965                }
9966            }
9967
9968            // In case of rollback, remember per-user/profile install state
9969            allUsers = sUserManager.getUserIds();
9970            perUserInstalled = new boolean[allUsers.length];
9971            for (int i = 0; i < allUsers.length; i++) {
9972                perUserInstalled[i] = ps != null ? ps.getInstalled(allUsers[i]) : false;
9973            }
9974        }
9975        boolean sysPkg = (isSystemApp(oldPackage));
9976        if (sysPkg) {
9977            replaceSystemPackageLI(oldPackage, pkg, parseFlags, scanMode,
9978                    user, allUsers, perUserInstalled, installerPackageName, res,
9979                    abiOverride);
9980        } else {
9981            replaceNonSystemPackageLI(oldPackage, pkg, parseFlags, scanMode,
9982                    user, allUsers, perUserInstalled, installerPackageName, res,
9983                    abiOverride);
9984        }
9985    }
9986
9987    private void replaceNonSystemPackageLI(PackageParser.Package deletedPackage,
9988            PackageParser.Package pkg, int parseFlags, int scanMode, UserHandle user,
9989            int[] allUsers, boolean[] perUserInstalled,
9990            String installerPackageName, PackageInstalledInfo res, String abiOverride) {
9991        String pkgName = deletedPackage.packageName;
9992        boolean deletedPkg = true;
9993        boolean updatedSettings = false;
9994
9995        if (DEBUG_INSTALL) Slog.d(TAG, "replaceNonSystemPackageLI: new=" + pkg + ", old="
9996                + deletedPackage);
9997        long origUpdateTime;
9998        if (pkg.mExtras != null) {
9999            origUpdateTime = ((PackageSetting)pkg.mExtras).lastUpdateTime;
10000        } else {
10001            origUpdateTime = 0;
10002        }
10003
10004        // First delete the existing package while retaining the data directory
10005        if (!deletePackageLI(pkgName, null, true, null, null, PackageManager.DELETE_KEEP_DATA,
10006                res.removedInfo, true)) {
10007            // If the existing package wasn't successfully deleted
10008            res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE, "replaceNonSystemPackageLI");
10009            deletedPkg = false;
10010        } else {
10011            // Successfully deleted the old package. Now proceed with re-installation
10012            try {
10013                final PackageParser.Package newPackage = scanPackageLI(pkg, parseFlags,
10014                        scanMode | SCAN_UPDATE_TIME, System.currentTimeMillis(), user, abiOverride);
10015                updateSettingsLI(newPackage, installerPackageName, allUsers, perUserInstalled, res);
10016                updatedSettings = true;
10017            } catch (PackageManagerException e) {
10018                res.setError(e.error,
10019                        "Package couldn't be installed in " + pkg.codePath + ": " + e.getMessage());
10020            }
10021        }
10022
10023        if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
10024            // remove package from internal structures.  Note that we want deletePackageX to
10025            // delete the package data and cache directories that it created in
10026            // scanPackageLocked, unless those directories existed before we even tried to
10027            // install.
10028            if(updatedSettings) {
10029                if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, rolling pack: " + pkgName);
10030                deletePackageLI(
10031                        pkgName, null, true, allUsers, perUserInstalled,
10032                        PackageManager.DELETE_KEEP_DATA,
10033                                res.removedInfo, true);
10034            }
10035            // Since we failed to install the new package we need to restore the old
10036            // package that we deleted.
10037            if (deletedPkg) {
10038                if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, reinstalling: " + deletedPackage);
10039                File restoreFile = new File(deletedPackage.codePath);
10040                // Parse old package
10041                boolean oldOnSd = isExternal(deletedPackage);
10042                int oldParseFlags  = mDefParseFlags | PackageParser.PARSE_CHATTY |
10043                        (isForwardLocked(deletedPackage) ? PackageParser.PARSE_FORWARD_LOCK : 0) |
10044                        (oldOnSd ? PackageParser.PARSE_ON_SDCARD : 0);
10045                int oldScanMode = (oldOnSd ? 0 : SCAN_MONITOR) | SCAN_UPDATE_SIGNATURE
10046                        | SCAN_UPDATE_TIME;
10047                try {
10048                    scanPackageLI(restoreFile, oldParseFlags, oldScanMode, origUpdateTime, null,
10049                            null);
10050                } catch (PackageManagerException e) {
10051                    Slog.e(TAG, "Failed to restore package : " + pkgName + " after failed upgrade: "
10052                            + e.getMessage());
10053                    return;
10054                }
10055                // Restore of old package succeeded. Update permissions.
10056                // writer
10057                synchronized (mPackages) {
10058                    updatePermissionsLPw(deletedPackage.packageName, deletedPackage,
10059                            UPDATE_PERMISSIONS_ALL);
10060                    // can downgrade to reader
10061                    mSettings.writeLPr();
10062                }
10063                Slog.i(TAG, "Successfully restored package : " + pkgName + " after failed upgrade");
10064            }
10065        }
10066    }
10067
10068    private void replaceSystemPackageLI(PackageParser.Package deletedPackage,
10069            PackageParser.Package pkg, int parseFlags, int scanMode, UserHandle user,
10070            int[] allUsers, boolean[] perUserInstalled,
10071            String installerPackageName, PackageInstalledInfo res, String abiOverride) {
10072        if (DEBUG_INSTALL) Slog.d(TAG, "replaceSystemPackageLI: new=" + pkg
10073                + ", old=" + deletedPackage);
10074        boolean updatedSettings = false;
10075        parseFlags |= PackageManager.INSTALL_REPLACE_EXISTING |
10076                PackageParser.PARSE_IS_SYSTEM;
10077        if ((deletedPackage.applicationInfo.flags&ApplicationInfo.FLAG_PRIVILEGED) != 0) {
10078            parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
10079        }
10080        String packageName = deletedPackage.packageName;
10081        if (packageName == null) {
10082            res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
10083                    "Attempt to delete null packageName.");
10084            return;
10085        }
10086        PackageParser.Package oldPkg;
10087        PackageSetting oldPkgSetting;
10088        // reader
10089        synchronized (mPackages) {
10090            oldPkg = mPackages.get(packageName);
10091            oldPkgSetting = mSettings.mPackages.get(packageName);
10092            if((oldPkg == null) || (oldPkg.applicationInfo == null) ||
10093                    (oldPkgSetting == null)) {
10094                res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
10095                        "Couldn't find package:" + packageName + " information");
10096                return;
10097            }
10098        }
10099
10100        killApplication(packageName, oldPkg.applicationInfo.uid, "replace sys pkg");
10101
10102        res.removedInfo.uid = oldPkg.applicationInfo.uid;
10103        res.removedInfo.removedPackage = packageName;
10104        // Remove existing system package
10105        removePackageLI(oldPkgSetting, true);
10106        // writer
10107        synchronized (mPackages) {
10108            if (!mSettings.disableSystemPackageLPw(packageName) && deletedPackage != null) {
10109                // We didn't need to disable the .apk as a current system package,
10110                // which means we are replacing another update that is already
10111                // installed.  We need to make sure to delete the older one's .apk.
10112                res.removedInfo.args = createInstallArgsForExisting(0,
10113                        deletedPackage.applicationInfo.getCodePath(),
10114                        deletedPackage.applicationInfo.getResourcePath(),
10115                        deletedPackage.applicationInfo.nativeLibraryRootDir,
10116                        getAppDexInstructionSets(deletedPackage.applicationInfo),
10117                        isMultiArch(deletedPackage.applicationInfo));
10118            } else {
10119                res.removedInfo.args = null;
10120            }
10121        }
10122
10123        // Successfully disabled the old package. Now proceed with re-installation
10124        res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10125        pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
10126
10127        PackageParser.Package newPackage = null;
10128        try {
10129            newPackage = scanPackageLI(pkg, parseFlags, scanMode, 0, user, abiOverride);
10130            if (newPackage.mExtras != null) {
10131                final PackageSetting newPkgSetting = (PackageSetting) newPackage.mExtras;
10132                newPkgSetting.firstInstallTime = oldPkgSetting.firstInstallTime;
10133                newPkgSetting.lastUpdateTime = System.currentTimeMillis();
10134
10135                // is the update attempting to change shared user? that isn't going to work...
10136                if (oldPkgSetting.sharedUser != newPkgSetting.sharedUser) {
10137                    res.setError(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
10138                            "Forbidding shared user change from " + oldPkgSetting.sharedUser
10139                            + " to " + newPkgSetting.sharedUser);
10140                    updatedSettings = true;
10141                }
10142            }
10143
10144            if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
10145                updateSettingsLI(newPackage, installerPackageName, allUsers, perUserInstalled, res);
10146                updatedSettings = true;
10147            }
10148
10149        } catch (PackageManagerException e) {
10150            res.setError(e.error,
10151                    "Package couldn't be installed in " + pkg.codePath + ": " + e.getMessage());
10152        }
10153
10154        if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
10155            // Re installation failed. Restore old information
10156            // Remove new pkg information
10157            if (newPackage != null) {
10158                removeInstalledPackageLI(newPackage, true);
10159            }
10160            // Add back the old system package
10161            try {
10162                scanPackageLI(oldPkg, parseFlags, SCAN_MONITOR | SCAN_UPDATE_SIGNATURE, 0, user,
10163                        null);
10164            } catch (PackageManagerException e) {
10165                Slog.e(TAG, "Failed to restore original package: " + e.getMessage());
10166            }
10167            // Restore the old system information in Settings
10168            synchronized(mPackages) {
10169                if (updatedSettings) {
10170                    mSettings.enableSystemPackageLPw(packageName);
10171                    mSettings.setInstallerPackageName(packageName,
10172                            oldPkgSetting.installerPackageName);
10173                }
10174                mSettings.writeLPr();
10175            }
10176        }
10177    }
10178
10179    // Utility method used to move dex files during install.
10180    private int moveDexFilesLI(String oldCodePath, PackageParser.Package newPackage) {
10181        // TODO: extend to move split APK dex files
10182        if ((newPackage.applicationInfo.flags&ApplicationInfo.FLAG_HAS_CODE) != 0) {
10183            final String[] instructionSets = getAppDexInstructionSets(newPackage.applicationInfo);
10184            for (String instructionSet : instructionSets) {
10185                int retCode = mInstaller.movedex(oldCodePath, newPackage.baseCodePath,
10186                        instructionSet);
10187                if (retCode != 0) {
10188                /*
10189                 * Programs may be lazily run through dexopt, so the
10190                 * source may not exist. However, something seems to
10191                 * have gone wrong, so note that dexopt needs to be
10192                 * run again and remove the source file. In addition,
10193                 * remove the target to make sure there isn't a stale
10194                 * file from a previous version of the package.
10195                 */
10196                    newPackage.mDexOptNeeded = true;
10197                    mInstaller.rmdex(oldCodePath, instructionSet);
10198                    mInstaller.rmdex(newPackage.baseCodePath, instructionSet);
10199                }
10200            }
10201        }
10202        return PackageManager.INSTALL_SUCCEEDED;
10203    }
10204
10205    private void updateSettingsLI(PackageParser.Package newPackage, String installerPackageName,
10206            int[] allUsers, boolean[] perUserInstalled,
10207            PackageInstalledInfo res) {
10208        String pkgName = newPackage.packageName;
10209        synchronized (mPackages) {
10210            //write settings. the installStatus will be incomplete at this stage.
10211            //note that the new package setting would have already been
10212            //added to mPackages. It hasn't been persisted yet.
10213            mSettings.setInstallStatus(pkgName, PackageSettingBase.PKG_INSTALL_INCOMPLETE);
10214            mSettings.writeLPr();
10215        }
10216
10217        if (DEBUG_INSTALL) Slog.d(TAG, "New package installed in " + newPackage.codePath);
10218
10219        synchronized (mPackages) {
10220            updatePermissionsLPw(newPackage.packageName, newPackage,
10221                    UPDATE_PERMISSIONS_REPLACE_PKG | (newPackage.permissions.size() > 0
10222                            ? UPDATE_PERMISSIONS_ALL : 0));
10223            // For system-bundled packages, we assume that installing an upgraded version
10224            // of the package implies that the user actually wants to run that new code,
10225            // so we enable the package.
10226            if (isSystemApp(newPackage)) {
10227                // NB: implicit assumption that system package upgrades apply to all users
10228                if (DEBUG_INSTALL) {
10229                    Slog.d(TAG, "Implicitly enabling system package on upgrade: " + pkgName);
10230                }
10231                PackageSetting ps = mSettings.mPackages.get(pkgName);
10232                if (ps != null) {
10233                    if (res.origUsers != null) {
10234                        for (int userHandle : res.origUsers) {
10235                            ps.setEnabled(COMPONENT_ENABLED_STATE_DEFAULT,
10236                                    userHandle, installerPackageName);
10237                        }
10238                    }
10239                    // Also convey the prior install/uninstall state
10240                    if (allUsers != null && perUserInstalled != null) {
10241                        for (int i = 0; i < allUsers.length; i++) {
10242                            if (DEBUG_INSTALL) {
10243                                Slog.d(TAG, "    user " + allUsers[i]
10244                                        + " => " + perUserInstalled[i]);
10245                            }
10246                            ps.setInstalled(perUserInstalled[i], allUsers[i]);
10247                        }
10248                        // these install state changes will be persisted in the
10249                        // upcoming call to mSettings.writeLPr().
10250                    }
10251                }
10252            }
10253            res.name = pkgName;
10254            res.uid = newPackage.applicationInfo.uid;
10255            res.pkg = newPackage;
10256            mSettings.setInstallStatus(pkgName, PackageSettingBase.PKG_INSTALL_COMPLETE);
10257            mSettings.setInstallerPackageName(pkgName, installerPackageName);
10258            res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10259            //to update install status
10260            mSettings.writeLPr();
10261        }
10262    }
10263
10264    private void installPackageLI(InstallArgs args, boolean newInstall, PackageInstalledInfo res) {
10265        int pFlags = args.flags;
10266        String installerPackageName = args.installerPackageName;
10267        File tmpPackageFile = new File(args.getCodePath());
10268        boolean forwardLocked = ((pFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0);
10269        boolean onSd = ((pFlags & PackageManager.INSTALL_EXTERNAL) != 0);
10270        boolean replace = false;
10271        int scanMode = (onSd ? 0 : SCAN_MONITOR) | SCAN_FORCE_DEX | SCAN_UPDATE_SIGNATURE
10272                | (newInstall ? SCAN_NEW_INSTALL : 0);
10273        // Result object to be returned
10274        res.returnCode = PackageManager.INSTALL_SUCCEEDED;
10275
10276        if (DEBUG_INSTALL) Slog.d(TAG, "installPackageLI: path=" + tmpPackageFile);
10277        // Retrieve PackageSettings and parse package
10278        int parseFlags = mDefParseFlags | PackageParser.PARSE_CHATTY
10279                | (forwardLocked ? PackageParser.PARSE_FORWARD_LOCK : 0)
10280                | (onSd ? PackageParser.PARSE_ON_SDCARD : 0);
10281        PackageParser pp = new PackageParser();
10282        pp.setSeparateProcesses(mSeparateProcesses);
10283        pp.setDisplayMetrics(mMetrics);
10284
10285        final PackageParser.Package pkg;
10286        try {
10287            pkg = pp.parsePackage(tmpPackageFile, parseFlags);
10288        } catch (PackageParserException e) {
10289            res.setError(e.error, "Failed parse during installPackageLI: " + e.getMessage());
10290            return;
10291        }
10292
10293        String pkgName = res.name = pkg.packageName;
10294        if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_TEST_ONLY) != 0) {
10295            if ((pFlags&PackageManager.INSTALL_ALLOW_TEST) == 0) {
10296                res.setError(INSTALL_FAILED_TEST_ONLY, "installPackageLI");
10297                return;
10298            }
10299        }
10300
10301        try {
10302            pp.collectCertificates(pkg, parseFlags);
10303            pp.collectManifestDigest(pkg);
10304        } catch (PackageParserException e) {
10305            res.setError(e.error, "Failed collect during installPackageLI: " + e.getMessage());
10306            return;
10307        }
10308
10309        /* If the installer passed in a manifest digest, compare it now. */
10310        if (args.manifestDigest != null) {
10311            if (DEBUG_INSTALL) {
10312                final String parsedManifest = pkg.manifestDigest == null ? "null"
10313                        : pkg.manifestDigest.toString();
10314                Slog.d(TAG, "Comparing manifests: " + args.manifestDigest.toString() + " vs. "
10315                        + parsedManifest);
10316            }
10317
10318            if (!args.manifestDigest.equals(pkg.manifestDigest)) {
10319                res.setError(INSTALL_FAILED_PACKAGE_CHANGED, "Manifest digest changed");
10320                return;
10321            }
10322        } else if (DEBUG_INSTALL) {
10323            final String parsedManifest = pkg.manifestDigest == null
10324                    ? "null" : pkg.manifestDigest.toString();
10325            Slog.d(TAG, "manifestDigest was not present, but parser got: " + parsedManifest);
10326        }
10327
10328        // Get rid of all references to package scan path via parser.
10329        pp = null;
10330        String oldCodePath = null;
10331        boolean systemApp = false;
10332        synchronized (mPackages) {
10333            // Check whether the newly-scanned package wants to define an already-defined perm
10334            int N = pkg.permissions.size();
10335            for (int i = N-1; i >= 0; i--) {
10336                PackageParser.Permission perm = pkg.permissions.get(i);
10337                BasePermission bp = mSettings.mPermissions.get(perm.info.name);
10338                if (bp != null) {
10339                    // If the defining package is signed with our cert, it's okay.  This
10340                    // also includes the "updating the same package" case, of course.
10341                    if (compareSignatures(bp.packageSetting.signatures.mSignatures,
10342                            pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {
10343                        // If the owning package is the system itself, we log but allow
10344                        // install to proceed; we fail the install on all other permission
10345                        // redefinitions.
10346                        if (!bp.sourcePackage.equals("android")) {
10347                            res.setError(INSTALL_FAILED_DUPLICATE_PERMISSION, "Package "
10348                                    + pkg.packageName + " attempting to redeclare permission "
10349                                    + perm.info.name + " already owned by " + bp.sourcePackage);
10350                            res.origPermission = perm.info.name;
10351                            res.origPackage = bp.sourcePackage;
10352                            return;
10353                        } else {
10354                            Slog.w(TAG, "Package " + pkg.packageName
10355                                    + " attempting to redeclare system permission "
10356                                    + perm.info.name + "; ignoring new declaration");
10357                            pkg.permissions.remove(i);
10358                        }
10359                    }
10360                }
10361            }
10362
10363            // Check if installing already existing package
10364            if ((pFlags&PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
10365                String oldName = mSettings.mRenamedPackages.get(pkgName);
10366                if (pkg.mOriginalPackages != null
10367                        && pkg.mOriginalPackages.contains(oldName)
10368                        && mPackages.containsKey(oldName)) {
10369                    // This package is derived from an original package,
10370                    // and this device has been updating from that original
10371                    // name.  We must continue using the original name, so
10372                    // rename the new package here.
10373                    pkg.setPackageName(oldName);
10374                    pkgName = pkg.packageName;
10375                    replace = true;
10376                    if (DEBUG_INSTALL) Slog.d(TAG, "Replacing existing renamed package: oldName="
10377                            + oldName + " pkgName=" + pkgName);
10378                } else if (mPackages.containsKey(pkgName)) {
10379                    // This package, under its official name, already exists
10380                    // on the device; we should replace it.
10381                    replace = true;
10382                    if (DEBUG_INSTALL) Slog.d(TAG, "Replace existing pacakge: " + pkgName);
10383                }
10384            }
10385            PackageSetting ps = mSettings.mPackages.get(pkgName);
10386            if (ps != null) {
10387                if (DEBUG_INSTALL) Slog.d(TAG, "Existing package: " + ps);
10388                oldCodePath = mSettings.mPackages.get(pkgName).codePathString;
10389                if (ps.pkg != null && ps.pkg.applicationInfo != null) {
10390                    systemApp = (ps.pkg.applicationInfo.flags &
10391                            ApplicationInfo.FLAG_SYSTEM) != 0;
10392                }
10393                res.origUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
10394            }
10395        }
10396
10397        if (systemApp && onSd) {
10398            // Disable updates to system apps on sdcard
10399            res.setError(INSTALL_FAILED_INVALID_INSTALL_LOCATION,
10400                    "Cannot install updates to system apps on sdcard");
10401            return;
10402        }
10403
10404        if (!args.doRename(res.returnCode, pkg, oldCodePath)) {
10405            res.setError(INSTALL_FAILED_INSUFFICIENT_STORAGE, "Failed rename");
10406            return;
10407        }
10408
10409        if (replace) {
10410            replacePackageLI(pkg, parseFlags, scanMode, args.user,
10411                    installerPackageName, res, args.abiOverride);
10412        } else {
10413            installNewPackageLI(pkg, parseFlags, scanMode | SCAN_DELETE_DATA_ON_FAILURES, args.user,
10414                    installerPackageName, res, args.abiOverride);
10415        }
10416        synchronized (mPackages) {
10417            final PackageSetting ps = mSettings.mPackages.get(pkgName);
10418            if (ps != null) {
10419                res.newUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
10420            }
10421        }
10422    }
10423
10424    private static boolean isForwardLocked(PackageParser.Package pkg) {
10425        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0;
10426    }
10427
10428    private static boolean isForwardLocked(ApplicationInfo info) {
10429        return (info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0;
10430    }
10431
10432    private boolean isForwardLocked(PackageSetting ps) {
10433        return (ps.pkgFlags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0;
10434    }
10435
10436    private static boolean isMultiArch(PackageSetting ps) {
10437        return (ps.pkgFlags & ApplicationInfo.FLAG_MULTIARCH) != 0;
10438    }
10439
10440    private static boolean isMultiArch(ApplicationInfo info) {
10441        return (info.flags & ApplicationInfo.FLAG_MULTIARCH) != 0;
10442    }
10443
10444    private static boolean isExternal(PackageParser.Package pkg) {
10445        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10446    }
10447
10448    private static boolean isExternal(PackageSetting ps) {
10449        return (ps.pkgFlags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10450    }
10451
10452    private static boolean isExternal(ApplicationInfo info) {
10453        return (info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
10454    }
10455
10456    private static boolean isSystemApp(PackageParser.Package pkg) {
10457        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
10458    }
10459
10460    private static boolean isPrivilegedApp(PackageParser.Package pkg) {
10461        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_PRIVILEGED) != 0;
10462    }
10463
10464    private static boolean isSystemApp(ApplicationInfo info) {
10465        return (info.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
10466    }
10467
10468    private static boolean isSystemApp(PackageSetting ps) {
10469        return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0;
10470    }
10471
10472    private static boolean isUpdatedSystemApp(PackageSetting ps) {
10473        return (ps.pkgFlags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10474    }
10475
10476    private static boolean isUpdatedSystemApp(PackageParser.Package pkg) {
10477        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10478    }
10479
10480    private static boolean isUpdatedSystemApp(ApplicationInfo info) {
10481        return (info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
10482    }
10483
10484    private int packageFlagsToInstallFlags(PackageSetting ps) {
10485        int installFlags = 0;
10486        if (isExternal(ps)) {
10487            installFlags |= PackageManager.INSTALL_EXTERNAL;
10488        }
10489        if (isForwardLocked(ps)) {
10490            installFlags |= PackageManager.INSTALL_FORWARD_LOCK;
10491        }
10492        return installFlags;
10493    }
10494
10495    private void deleteTempPackageFiles() {
10496        final FilenameFilter filter = new FilenameFilter() {
10497            public boolean accept(File dir, String name) {
10498                return name.startsWith("vmdl") && name.endsWith(".tmp");
10499            }
10500        };
10501        for (File file : mDrmAppPrivateInstallDir.listFiles(filter)) {
10502            file.delete();
10503        }
10504    }
10505
10506    @Override
10507    public void deletePackageAsUser(final String packageName,
10508                                    final IPackageDeleteObserver observer,
10509                                    final int userId, final int flags) {
10510        mContext.enforceCallingOrSelfPermission(
10511                android.Manifest.permission.DELETE_PACKAGES, null);
10512        final int uid = Binder.getCallingUid();
10513        if (UserHandle.getUserId(uid) != userId) {
10514            mContext.enforceCallingPermission(
10515                    android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
10516                    "deletePackage for user " + userId);
10517        }
10518        if (isUserRestricted(userId, UserManager.DISALLOW_UNINSTALL_APPS)) {
10519            try {
10520                observer.packageDeleted(packageName, PackageManager.DELETE_FAILED_USER_RESTRICTED);
10521            } catch (RemoteException re) {
10522            }
10523            return;
10524        }
10525
10526        boolean blocked = false;
10527        if ((flags & PackageManager.DELETE_ALL_USERS) != 0) {
10528            int[] users = sUserManager.getUserIds();
10529            for (int i = 0; i < users.length; ++i) {
10530                if (getBlockUninstallForUser(packageName, users[i])) {
10531                    blocked = true;
10532                    break;
10533                }
10534            }
10535        } else {
10536            blocked = getBlockUninstallForUser(packageName, userId);
10537        }
10538        if (blocked) {
10539            try {
10540                observer.packageDeleted(packageName, PackageManager.DELETE_FAILED_OWNER_BLOCKED);
10541            } catch (RemoteException re) {
10542            }
10543            return;
10544        }
10545
10546        if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageAsUser: pkg=" + packageName + " user=" + userId);
10547        // Queue up an async operation since the package deletion may take a little while.
10548        mHandler.post(new Runnable() {
10549            public void run() {
10550                mHandler.removeCallbacks(this);
10551                final int returnCode = deletePackageX(packageName, userId, flags);
10552                if (observer != null) {
10553                    try {
10554                        observer.packageDeleted(packageName, returnCode);
10555                    } catch (RemoteException e) {
10556                        Log.i(TAG, "Observer no longer exists.");
10557                    } //end catch
10558                } //end if
10559            } //end run
10560        });
10561    }
10562
10563    private boolean isPackageDeviceAdmin(String packageName, int userId) {
10564        IDevicePolicyManager dpm = IDevicePolicyManager.Stub.asInterface(
10565                ServiceManager.getService(Context.DEVICE_POLICY_SERVICE));
10566        try {
10567            if (dpm != null && (dpm.packageHasActiveAdmins(packageName, userId)
10568                    || dpm.isDeviceOwner(packageName))) {
10569                return true;
10570            }
10571        } catch (RemoteException e) {
10572        }
10573        return false;
10574    }
10575
10576    /**
10577     *  This method is an internal method that could be get invoked either
10578     *  to delete an installed package or to clean up a failed installation.
10579     *  After deleting an installed package, a broadcast is sent to notify any
10580     *  listeners that the package has been installed. For cleaning up a failed
10581     *  installation, the broadcast is not necessary since the package's
10582     *  installation wouldn't have sent the initial broadcast either
10583     *  The key steps in deleting a package are
10584     *  deleting the package information in internal structures like mPackages,
10585     *  deleting the packages base directories through installd
10586     *  updating mSettings to reflect current status
10587     *  persisting settings for later use
10588     *  sending a broadcast if necessary
10589     */
10590    private int deletePackageX(String packageName, int userId, int flags) {
10591        final PackageRemovedInfo info = new PackageRemovedInfo();
10592        final boolean res;
10593
10594        if (isPackageDeviceAdmin(packageName, userId)) {
10595            Slog.w(TAG, "Not removing package " + packageName + ": has active device admin");
10596            return PackageManager.DELETE_FAILED_DEVICE_POLICY_MANAGER;
10597        }
10598
10599        boolean removedForAllUsers = false;
10600        boolean systemUpdate = false;
10601
10602        // for the uninstall-updates case and restricted profiles, remember the per-
10603        // userhandle installed state
10604        int[] allUsers;
10605        boolean[] perUserInstalled;
10606        synchronized (mPackages) {
10607            PackageSetting ps = mSettings.mPackages.get(packageName);
10608            allUsers = sUserManager.getUserIds();
10609            perUserInstalled = new boolean[allUsers.length];
10610            for (int i = 0; i < allUsers.length; i++) {
10611                perUserInstalled[i] = ps != null ? ps.getInstalled(allUsers[i]) : false;
10612            }
10613        }
10614
10615        synchronized (mInstallLock) {
10616            if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageX: pkg=" + packageName + " user=" + userId);
10617            res = deletePackageLI(packageName,
10618                    (flags & PackageManager.DELETE_ALL_USERS) != 0
10619                            ? UserHandle.ALL : new UserHandle(userId),
10620                    true, allUsers, perUserInstalled,
10621                    flags | REMOVE_CHATTY, info, true);
10622            systemUpdate = info.isRemovedPackageSystemUpdate;
10623            if (res && !systemUpdate && mPackages.get(packageName) == null) {
10624                removedForAllUsers = true;
10625            }
10626            if (DEBUG_REMOVE) Slog.d(TAG, "delete res: systemUpdate=" + systemUpdate
10627                    + " removedForAllUsers=" + removedForAllUsers);
10628        }
10629
10630        if (res) {
10631            info.sendBroadcast(true, systemUpdate, removedForAllUsers);
10632
10633            // If the removed package was a system update, the old system package
10634            // was re-enabled; we need to broadcast this information
10635            if (systemUpdate) {
10636                Bundle extras = new Bundle(1);
10637                extras.putInt(Intent.EXTRA_UID, info.removedAppId >= 0
10638                        ? info.removedAppId : info.uid);
10639                extras.putBoolean(Intent.EXTRA_REPLACING, true);
10640
10641                sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, packageName,
10642                        extras, null, null, null);
10643                sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED, packageName,
10644                        extras, null, null, null);
10645                sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED, null,
10646                        null, packageName, null, null);
10647            }
10648        }
10649        // Force a gc here.
10650        Runtime.getRuntime().gc();
10651        // Delete the resources here after sending the broadcast to let
10652        // other processes clean up before deleting resources.
10653        if (info.args != null) {
10654            synchronized (mInstallLock) {
10655                info.args.doPostDeleteLI(true);
10656            }
10657        }
10658
10659        return res ? PackageManager.DELETE_SUCCEEDED : PackageManager.DELETE_FAILED_INTERNAL_ERROR;
10660    }
10661
10662    static class PackageRemovedInfo {
10663        String removedPackage;
10664        int uid = -1;
10665        int removedAppId = -1;
10666        int[] removedUsers = null;
10667        boolean isRemovedPackageSystemUpdate = false;
10668        // Clean up resources deleted packages.
10669        InstallArgs args = null;
10670
10671        void sendBroadcast(boolean fullRemove, boolean replacing, boolean removedForAllUsers) {
10672            Bundle extras = new Bundle(1);
10673            extras.putInt(Intent.EXTRA_UID, removedAppId >= 0 ? removedAppId : uid);
10674            extras.putBoolean(Intent.EXTRA_DATA_REMOVED, fullRemove);
10675            if (replacing) {
10676                extras.putBoolean(Intent.EXTRA_REPLACING, true);
10677            }
10678            extras.putBoolean(Intent.EXTRA_REMOVED_FOR_ALL_USERS, removedForAllUsers);
10679            if (removedPackage != null) {
10680                sendPackageBroadcast(Intent.ACTION_PACKAGE_REMOVED, removedPackage,
10681                        extras, null, null, removedUsers);
10682                if (fullRemove && !replacing) {
10683                    sendPackageBroadcast(Intent.ACTION_PACKAGE_FULLY_REMOVED, removedPackage,
10684                            extras, null, null, removedUsers);
10685                }
10686            }
10687            if (removedAppId >= 0) {
10688                sendPackageBroadcast(Intent.ACTION_UID_REMOVED, null, extras, null, null,
10689                        removedUsers);
10690            }
10691        }
10692    }
10693
10694    /*
10695     * This method deletes the package from internal data structures. If the DONT_DELETE_DATA
10696     * flag is not set, the data directory is removed as well.
10697     * make sure this flag is set for partially installed apps. If not its meaningless to
10698     * delete a partially installed application.
10699     */
10700    private void removePackageDataLI(PackageSetting ps,
10701            int[] allUserHandles, boolean[] perUserInstalled,
10702            PackageRemovedInfo outInfo, int flags, boolean writeSettings) {
10703        String packageName = ps.name;
10704        if (DEBUG_REMOVE) Slog.d(TAG, "removePackageDataLI: " + ps);
10705        removePackageLI(ps, (flags&REMOVE_CHATTY) != 0);
10706        // Retrieve object to delete permissions for shared user later on
10707        final PackageSetting deletedPs;
10708        // reader
10709        synchronized (mPackages) {
10710            deletedPs = mSettings.mPackages.get(packageName);
10711            if (outInfo != null) {
10712                outInfo.removedPackage = packageName;
10713                outInfo.removedUsers = deletedPs != null
10714                        ? deletedPs.queryInstalledUsers(sUserManager.getUserIds(), true)
10715                        : null;
10716            }
10717        }
10718        if ((flags&PackageManager.DELETE_KEEP_DATA) == 0) {
10719            removeDataDirsLI(packageName);
10720            schedulePackageCleaning(packageName, UserHandle.USER_ALL, true);
10721        }
10722        // writer
10723        synchronized (mPackages) {
10724            if (deletedPs != null) {
10725                if ((flags&PackageManager.DELETE_KEEP_DATA) == 0) {
10726                    if (outInfo != null) {
10727                        mSettings.mKeySetManagerService.removeAppKeySetDataLPw(packageName);
10728                        outInfo.removedAppId = mSettings.removePackageLPw(packageName);
10729                    }
10730                    if (deletedPs != null) {
10731                        updatePermissionsLPw(deletedPs.name, null, 0);
10732                        if (deletedPs.sharedUser != null) {
10733                            // remove permissions associated with package
10734                            mSettings.updateSharedUserPermsLPw(deletedPs, mGlobalGids);
10735                        }
10736                    }
10737                    clearPackagePreferredActivitiesLPw(deletedPs.name, UserHandle.USER_ALL);
10738                }
10739                // make sure to preserve per-user disabled state if this removal was just
10740                // a downgrade of a system app to the factory package
10741                if (allUserHandles != null && perUserInstalled != null) {
10742                    if (DEBUG_REMOVE) {
10743                        Slog.d(TAG, "Propagating install state across downgrade");
10744                    }
10745                    for (int i = 0; i < allUserHandles.length; i++) {
10746                        if (DEBUG_REMOVE) {
10747                            Slog.d(TAG, "    user " + allUserHandles[i]
10748                                    + " => " + perUserInstalled[i]);
10749                        }
10750                        ps.setInstalled(perUserInstalled[i], allUserHandles[i]);
10751                    }
10752                }
10753            }
10754            // can downgrade to reader
10755            if (writeSettings) {
10756                // Save settings now
10757                mSettings.writeLPr();
10758            }
10759        }
10760        if (outInfo != null) {
10761            // A user ID was deleted here. Go through all users and remove it
10762            // from KeyStore.
10763            removeKeystoreDataIfNeeded(UserHandle.USER_ALL, outInfo.removedAppId);
10764        }
10765    }
10766
10767    static boolean locationIsPrivileged(File path) {
10768        try {
10769            final String privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app")
10770                    .getCanonicalPath();
10771            return path.getCanonicalPath().startsWith(privilegedAppDir);
10772        } catch (IOException e) {
10773            Slog.e(TAG, "Unable to access code path " + path);
10774        }
10775        return false;
10776    }
10777
10778    /*
10779     * Tries to delete system package.
10780     */
10781    private boolean deleteSystemPackageLI(PackageSetting newPs,
10782            int[] allUserHandles, boolean[] perUserInstalled,
10783            int flags, PackageRemovedInfo outInfo, boolean writeSettings) {
10784        final boolean applyUserRestrictions
10785                = (allUserHandles != null) && (perUserInstalled != null);
10786        PackageSetting disabledPs = null;
10787        // Confirm if the system package has been updated
10788        // An updated system app can be deleted. This will also have to restore
10789        // the system pkg from system partition
10790        // reader
10791        synchronized (mPackages) {
10792            disabledPs = mSettings.getDisabledSystemPkgLPr(newPs.name);
10793        }
10794        if (DEBUG_REMOVE) Slog.d(TAG, "deleteSystemPackageLI: newPs=" + newPs
10795                + " disabledPs=" + disabledPs);
10796        if (disabledPs == null) {
10797            Slog.w(TAG, "Attempt to delete unknown system package "+ newPs.name);
10798            return false;
10799        } else if (DEBUG_REMOVE) {
10800            Slog.d(TAG, "Deleting system pkg from data partition");
10801        }
10802        if (DEBUG_REMOVE) {
10803            if (applyUserRestrictions) {
10804                Slog.d(TAG, "Remembering install states:");
10805                for (int i = 0; i < allUserHandles.length; i++) {
10806                    Slog.d(TAG, "   u=" + allUserHandles[i] + " inst=" + perUserInstalled[i]);
10807                }
10808            }
10809        }
10810        // Delete the updated package
10811        outInfo.isRemovedPackageSystemUpdate = true;
10812        if (disabledPs.versionCode < newPs.versionCode) {
10813            // Delete data for downgrades
10814            flags &= ~PackageManager.DELETE_KEEP_DATA;
10815        } else {
10816            // Preserve data by setting flag
10817            flags |= PackageManager.DELETE_KEEP_DATA;
10818        }
10819        boolean ret = deleteInstalledPackageLI(newPs, true, flags,
10820                allUserHandles, perUserInstalled, outInfo, writeSettings);
10821        if (!ret) {
10822            return false;
10823        }
10824        // writer
10825        synchronized (mPackages) {
10826            // Reinstate the old system package
10827            mSettings.enableSystemPackageLPw(newPs.name);
10828            // Remove any native libraries from the upgraded package.
10829            NativeLibraryHelper.removeNativeBinariesLI(newPs.legacyNativeLibraryPathString);
10830        }
10831        // Install the system package
10832        if (DEBUG_REMOVE) Slog.d(TAG, "Re-installing system package: " + disabledPs);
10833        int parseFlags = PackageParser.PARSE_MUST_BE_APK | PackageParser.PARSE_IS_SYSTEM;
10834        if (locationIsPrivileged(disabledPs.codePath)) {
10835            parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
10836        }
10837
10838        final PackageParser.Package newPkg;
10839        try {
10840            newPkg = scanPackageLI(disabledPs.codePath, parseFlags, SCAN_MONITOR | SCAN_NO_PATHS, 0,
10841                    null, null);
10842        } catch (PackageManagerException e) {
10843            Slog.w(TAG, "Failed to restore system package:" + newPs.name + ": " + e.getMessage());
10844            return false;
10845        }
10846
10847        // writer
10848        synchronized (mPackages) {
10849            PackageSetting ps = mSettings.mPackages.get(newPkg.packageName);
10850            setBundledAppAbisAndRoots(newPkg, ps);
10851            updatePermissionsLPw(newPkg.packageName, newPkg,
10852                    UPDATE_PERMISSIONS_ALL | UPDATE_PERMISSIONS_REPLACE_PKG);
10853            if (applyUserRestrictions) {
10854                if (DEBUG_REMOVE) {
10855                    Slog.d(TAG, "Propagating install state across reinstall");
10856                }
10857                for (int i = 0; i < allUserHandles.length; i++) {
10858                    if (DEBUG_REMOVE) {
10859                        Slog.d(TAG, "    user " + allUserHandles[i]
10860                                + " => " + perUserInstalled[i]);
10861                    }
10862                    ps.setInstalled(perUserInstalled[i], allUserHandles[i]);
10863                }
10864                // Regardless of writeSettings we need to ensure that this restriction
10865                // state propagation is persisted
10866                mSettings.writeAllUsersPackageRestrictionsLPr();
10867            }
10868            // can downgrade to reader here
10869            if (writeSettings) {
10870                mSettings.writeLPr();
10871            }
10872        }
10873        return true;
10874    }
10875
10876    private boolean deleteInstalledPackageLI(PackageSetting ps,
10877            boolean deleteCodeAndResources, int flags,
10878            int[] allUserHandles, boolean[] perUserInstalled,
10879            PackageRemovedInfo outInfo, boolean writeSettings) {
10880        if (outInfo != null) {
10881            outInfo.uid = ps.appId;
10882        }
10883
10884        // Delete package data from internal structures and also remove data if flag is set
10885        removePackageDataLI(ps, allUserHandles, perUserInstalled, outInfo, flags, writeSettings);
10886
10887        // Delete application code and resources
10888        if (deleteCodeAndResources && (outInfo != null)) {
10889            outInfo.args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
10890                    ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,
10891                    getAppDexInstructionSets(ps), isMultiArch(ps));
10892        }
10893        return true;
10894    }
10895
10896    @Override
10897    public boolean setBlockUninstallForUser(String packageName, boolean blockUninstall,
10898            int userId) {
10899        mContext.enforceCallingOrSelfPermission(
10900                android.Manifest.permission.DELETE_PACKAGES, null);
10901        synchronized (mPackages) {
10902            PackageSetting ps = mSettings.mPackages.get(packageName);
10903            if (ps == null) {
10904                Log.i(TAG, "Package doesn't exist in set block uninstall " + packageName);
10905                return false;
10906            }
10907            if (!ps.getInstalled(userId)) {
10908                // Can't block uninstall for an app that is not installed or enabled.
10909                Log.i(TAG, "Package not installed in set block uninstall " + packageName);
10910                return false;
10911            }
10912            ps.setBlockUninstall(blockUninstall, userId);
10913            mSettings.writePackageRestrictionsLPr(userId);
10914        }
10915        return true;
10916    }
10917
10918    @Override
10919    public boolean getBlockUninstallForUser(String packageName, int userId) {
10920        synchronized (mPackages) {
10921            PackageSetting ps = mSettings.mPackages.get(packageName);
10922            if (ps == null) {
10923                Log.i(TAG, "Package doesn't exist in get block uninstall " + packageName);
10924                return false;
10925            }
10926            return ps.getBlockUninstall(userId);
10927        }
10928    }
10929
10930    /*
10931     * This method handles package deletion in general
10932     */
10933    private boolean deletePackageLI(String packageName, UserHandle user,
10934            boolean deleteCodeAndResources, int[] allUserHandles, boolean[] perUserInstalled,
10935            int flags, PackageRemovedInfo outInfo,
10936            boolean writeSettings) {
10937        if (packageName == null) {
10938            Slog.w(TAG, "Attempt to delete null packageName.");
10939            return false;
10940        }
10941        if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageLI: " + packageName + " user " + user);
10942        PackageSetting ps;
10943        boolean dataOnly = false;
10944        int removeUser = -1;
10945        int appId = -1;
10946        synchronized (mPackages) {
10947            ps = mSettings.mPackages.get(packageName);
10948            if (ps == null) {
10949                Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
10950                return false;
10951            }
10952            if ((!isSystemApp(ps) || (flags&PackageManager.DELETE_SYSTEM_APP) != 0) && user != null
10953                    && user.getIdentifier() != UserHandle.USER_ALL) {
10954                // The caller is asking that the package only be deleted for a single
10955                // user.  To do this, we just mark its uninstalled state and delete
10956                // its data.  If this is a system app, we only allow this to happen if
10957                // they have set the special DELETE_SYSTEM_APP which requests different
10958                // semantics than normal for uninstalling system apps.
10959                if (DEBUG_REMOVE) Slog.d(TAG, "Only deleting for single user");
10960                ps.setUserState(user.getIdentifier(),
10961                        COMPONENT_ENABLED_STATE_DEFAULT,
10962                        false, //installed
10963                        true,  //stopped
10964                        true,  //notLaunched
10965                        false, //blocked
10966                        null, null, null,
10967                        false // blockUninstall
10968                        );
10969                if (!isSystemApp(ps)) {
10970                    if (ps.isAnyInstalled(sUserManager.getUserIds())) {
10971                        // Other user still have this package installed, so all
10972                        // we need to do is clear this user's data and save that
10973                        // it is uninstalled.
10974                        if (DEBUG_REMOVE) Slog.d(TAG, "Still installed by other users");
10975                        removeUser = user.getIdentifier();
10976                        appId = ps.appId;
10977                        mSettings.writePackageRestrictionsLPr(removeUser);
10978                    } else {
10979                        // We need to set it back to 'installed' so the uninstall
10980                        // broadcasts will be sent correctly.
10981                        if (DEBUG_REMOVE) Slog.d(TAG, "Not installed by other users, full delete");
10982                        ps.setInstalled(true, user.getIdentifier());
10983                    }
10984                } else {
10985                    // This is a system app, so we assume that the
10986                    // other users still have this package installed, so all
10987                    // we need to do is clear this user's data and save that
10988                    // it is uninstalled.
10989                    if (DEBUG_REMOVE) Slog.d(TAG, "Deleting system app");
10990                    removeUser = user.getIdentifier();
10991                    appId = ps.appId;
10992                    mSettings.writePackageRestrictionsLPr(removeUser);
10993                }
10994            }
10995        }
10996
10997        if (removeUser >= 0) {
10998            // From above, we determined that we are deleting this only
10999            // for a single user.  Continue the work here.
11000            if (DEBUG_REMOVE) Slog.d(TAG, "Updating install state for user: " + removeUser);
11001            if (outInfo != null) {
11002                outInfo.removedPackage = packageName;
11003                outInfo.removedAppId = appId;
11004                outInfo.removedUsers = new int[] {removeUser};
11005            }
11006            mInstaller.clearUserData(packageName, removeUser);
11007            removeKeystoreDataIfNeeded(removeUser, appId);
11008            schedulePackageCleaning(packageName, removeUser, false);
11009            return true;
11010        }
11011
11012        if (dataOnly) {
11013            // Delete application data first
11014            if (DEBUG_REMOVE) Slog.d(TAG, "Removing package data only");
11015            removePackageDataLI(ps, null, null, outInfo, flags, writeSettings);
11016            return true;
11017        }
11018
11019        boolean ret = false;
11020        if (isSystemApp(ps)) {
11021            if (DEBUG_REMOVE) Slog.d(TAG, "Removing system package:" + ps.name);
11022            // When an updated system application is deleted we delete the existing resources as well and
11023            // fall back to existing code in system partition
11024            ret = deleteSystemPackageLI(ps, allUserHandles, perUserInstalled,
11025                    flags, outInfo, writeSettings);
11026        } else {
11027            if (DEBUG_REMOVE) Slog.d(TAG, "Removing non-system package:" + ps.name);
11028            // Kill application pre-emptively especially for apps on sd.
11029            killApplication(packageName, ps.appId, "uninstall pkg");
11030            ret = deleteInstalledPackageLI(ps, deleteCodeAndResources, flags,
11031                    allUserHandles, perUserInstalled,
11032                    outInfo, writeSettings);
11033        }
11034
11035        return ret;
11036    }
11037
11038    private final class ClearStorageConnection implements ServiceConnection {
11039        IMediaContainerService mContainerService;
11040
11041        @Override
11042        public void onServiceConnected(ComponentName name, IBinder service) {
11043            synchronized (this) {
11044                mContainerService = IMediaContainerService.Stub.asInterface(service);
11045                notifyAll();
11046            }
11047        }
11048
11049        @Override
11050        public void onServiceDisconnected(ComponentName name) {
11051        }
11052    }
11053
11054    private void clearExternalStorageDataSync(String packageName, int userId, boolean allData) {
11055        final boolean mounted;
11056        if (Environment.isExternalStorageEmulated()) {
11057            mounted = true;
11058        } else {
11059            final String status = Environment.getExternalStorageState();
11060
11061            mounted = status.equals(Environment.MEDIA_MOUNTED)
11062                    || status.equals(Environment.MEDIA_MOUNTED_READ_ONLY);
11063        }
11064
11065        if (!mounted) {
11066            return;
11067        }
11068
11069        final Intent containerIntent = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
11070        int[] users;
11071        if (userId == UserHandle.USER_ALL) {
11072            users = sUserManager.getUserIds();
11073        } else {
11074            users = new int[] { userId };
11075        }
11076        final ClearStorageConnection conn = new ClearStorageConnection();
11077        if (mContext.bindServiceAsUser(
11078                containerIntent, conn, Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
11079            try {
11080                for (int curUser : users) {
11081                    long timeout = SystemClock.uptimeMillis() + 5000;
11082                    synchronized (conn) {
11083                        long now = SystemClock.uptimeMillis();
11084                        while (conn.mContainerService == null && now < timeout) {
11085                            try {
11086                                conn.wait(timeout - now);
11087                            } catch (InterruptedException e) {
11088                            }
11089                        }
11090                    }
11091                    if (conn.mContainerService == null) {
11092                        return;
11093                    }
11094
11095                    final UserEnvironment userEnv = new UserEnvironment(curUser);
11096                    clearDirectory(conn.mContainerService,
11097                            userEnv.buildExternalStorageAppCacheDirs(packageName));
11098                    if (allData) {
11099                        clearDirectory(conn.mContainerService,
11100                                userEnv.buildExternalStorageAppDataDirs(packageName));
11101                        clearDirectory(conn.mContainerService,
11102                                userEnv.buildExternalStorageAppMediaDirs(packageName));
11103                    }
11104                }
11105            } finally {
11106                mContext.unbindService(conn);
11107            }
11108        }
11109    }
11110
11111    @Override
11112    public void clearApplicationUserData(final String packageName,
11113            final IPackageDataObserver observer, final int userId) {
11114        mContext.enforceCallingOrSelfPermission(
11115                android.Manifest.permission.CLEAR_APP_USER_DATA, null);
11116        enforceCrossUserPermission(Binder.getCallingUid(), userId, true, "clear application data");
11117        // Queue up an async operation since the package deletion may take a little while.
11118        mHandler.post(new Runnable() {
11119            public void run() {
11120                mHandler.removeCallbacks(this);
11121                final boolean succeeded;
11122                synchronized (mInstallLock) {
11123                    succeeded = clearApplicationUserDataLI(packageName, userId);
11124                }
11125                clearExternalStorageDataSync(packageName, userId, true);
11126                if (succeeded) {
11127                    // invoke DeviceStorageMonitor's update method to clear any notifications
11128                    DeviceStorageMonitorInternal
11129                            dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
11130                    if (dsm != null) {
11131                        dsm.checkMemory();
11132                    }
11133                }
11134                if(observer != null) {
11135                    try {
11136                        observer.onRemoveCompleted(packageName, succeeded);
11137                    } catch (RemoteException e) {
11138                        Log.i(TAG, "Observer no longer exists.");
11139                    }
11140                } //end if observer
11141            } //end run
11142        });
11143    }
11144
11145    private boolean clearApplicationUserDataLI(String packageName, int userId) {
11146        if (packageName == null) {
11147            Slog.w(TAG, "Attempt to delete null packageName.");
11148            return false;
11149        }
11150        PackageParser.Package p;
11151        boolean dataOnly = false;
11152        final int appId;
11153        synchronized (mPackages) {
11154            p = mPackages.get(packageName);
11155            if (p == null) {
11156                dataOnly = true;
11157                PackageSetting ps = mSettings.mPackages.get(packageName);
11158                if ((ps == null) || (ps.pkg == null)) {
11159                    Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
11160                    return false;
11161                }
11162                p = ps.pkg;
11163            }
11164            if (!dataOnly) {
11165                // need to check this only for fully installed applications
11166                if (p == null) {
11167                    Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
11168                    return false;
11169                }
11170                final ApplicationInfo applicationInfo = p.applicationInfo;
11171                if (applicationInfo == null) {
11172                    Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
11173                    return false;
11174                }
11175            }
11176            if (p != null && p.applicationInfo != null) {
11177                appId = p.applicationInfo.uid;
11178            } else {
11179                appId = -1;
11180            }
11181        }
11182        int retCode = mInstaller.clearUserData(packageName, userId);
11183        if (retCode < 0) {
11184            Slog.w(TAG, "Couldn't remove cache files for package: "
11185                    + packageName);
11186            return false;
11187        }
11188        removeKeystoreDataIfNeeded(userId, appId);
11189        return true;
11190    }
11191
11192    /**
11193     * Remove entries from the keystore daemon. Will only remove it if the
11194     * {@code appId} is valid.
11195     */
11196    private static void removeKeystoreDataIfNeeded(int userId, int appId) {
11197        if (appId < 0) {
11198            return;
11199        }
11200
11201        final KeyStore keyStore = KeyStore.getInstance();
11202        if (keyStore != null) {
11203            if (userId == UserHandle.USER_ALL) {
11204                for (final int individual : sUserManager.getUserIds()) {
11205                    keyStore.clearUid(UserHandle.getUid(individual, appId));
11206                }
11207            } else {
11208                keyStore.clearUid(UserHandle.getUid(userId, appId));
11209            }
11210        } else {
11211            Slog.w(TAG, "Could not contact keystore to clear entries for app id " + appId);
11212        }
11213    }
11214
11215    @Override
11216    public void deleteApplicationCacheFiles(final String packageName,
11217            final IPackageDataObserver observer) {
11218        mContext.enforceCallingOrSelfPermission(
11219                android.Manifest.permission.DELETE_CACHE_FILES, null);
11220        // Queue up an async operation since the package deletion may take a little while.
11221        final int userId = UserHandle.getCallingUserId();
11222        mHandler.post(new Runnable() {
11223            public void run() {
11224                mHandler.removeCallbacks(this);
11225                final boolean succeded;
11226                synchronized (mInstallLock) {
11227                    succeded = deleteApplicationCacheFilesLI(packageName, userId);
11228                }
11229                clearExternalStorageDataSync(packageName, userId, false);
11230                if(observer != null) {
11231                    try {
11232                        observer.onRemoveCompleted(packageName, succeded);
11233                    } catch (RemoteException e) {
11234                        Log.i(TAG, "Observer no longer exists.");
11235                    }
11236                } //end if observer
11237            } //end run
11238        });
11239    }
11240
11241    private boolean deleteApplicationCacheFilesLI(String packageName, int userId) {
11242        if (packageName == null) {
11243            Slog.w(TAG, "Attempt to delete null packageName.");
11244            return false;
11245        }
11246        PackageParser.Package p;
11247        synchronized (mPackages) {
11248            p = mPackages.get(packageName);
11249        }
11250        if (p == null) {
11251            Slog.w(TAG, "Package named '" + packageName +"' doesn't exist.");
11252            return false;
11253        }
11254        final ApplicationInfo applicationInfo = p.applicationInfo;
11255        if (applicationInfo == null) {
11256            Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
11257            return false;
11258        }
11259        int retCode = mInstaller.deleteCacheFiles(packageName, userId);
11260        if (retCode < 0) {
11261            Slog.w(TAG, "Couldn't remove cache files for package: "
11262                       + packageName + " u" + userId);
11263            return false;
11264        }
11265        return true;
11266    }
11267
11268    @Override
11269    public void getPackageSizeInfo(final String packageName, int userHandle,
11270            final IPackageStatsObserver observer) {
11271        mContext.enforceCallingOrSelfPermission(
11272                android.Manifest.permission.GET_PACKAGE_SIZE, null);
11273        if (packageName == null) {
11274            throw new IllegalArgumentException("Attempt to get size of null packageName");
11275        }
11276
11277        PackageStats stats = new PackageStats(packageName, userHandle);
11278
11279        /*
11280         * Queue up an async operation since the package measurement may take a
11281         * little while.
11282         */
11283        Message msg = mHandler.obtainMessage(INIT_COPY);
11284        msg.obj = new MeasureParams(stats, observer);
11285        mHandler.sendMessage(msg);
11286    }
11287
11288    private boolean getPackageSizeInfoLI(String packageName, int userHandle,
11289            PackageStats pStats) {
11290        if (packageName == null) {
11291            Slog.w(TAG, "Attempt to get size of null packageName.");
11292            return false;
11293        }
11294        PackageParser.Package p;
11295        boolean dataOnly = false;
11296        String libDirRoot = null;
11297        String asecPath = null;
11298        PackageSetting ps = null;
11299        synchronized (mPackages) {
11300            p = mPackages.get(packageName);
11301            ps = mSettings.mPackages.get(packageName);
11302            if(p == null) {
11303                dataOnly = true;
11304                if((ps == null) || (ps.pkg == null)) {
11305                    Slog.w(TAG, "Package named '" + packageName +"' doesn't exist.");
11306                    return false;
11307                }
11308                p = ps.pkg;
11309            }
11310            if (ps != null) {
11311                libDirRoot = ps.legacyNativeLibraryPathString;
11312            }
11313            if (p != null && (isExternal(p) || isForwardLocked(p))) {
11314                String secureContainerId = cidFromCodePath(p.applicationInfo.getBaseCodePath());
11315                if (secureContainerId != null) {
11316                    asecPath = PackageHelper.getSdFilesystem(secureContainerId);
11317                }
11318            }
11319        }
11320        String publicSrcDir = null;
11321        if(!dataOnly) {
11322            final ApplicationInfo applicationInfo = p.applicationInfo;
11323            if (applicationInfo == null) {
11324                Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
11325                return false;
11326            }
11327            if (isForwardLocked(p)) {
11328                publicSrcDir = applicationInfo.getBaseResourcePath();
11329            }
11330        }
11331        // TODO: extend to measure size of split APKs
11332        // TODO(multiArch): Extend getSizeInfo to look at the full subdirectory tree,
11333        // not just the first level.
11334        // TODO(multiArch): Extend getSizeInfo to look at *all* instruction sets, not
11335        // just the primary.
11336        int res = mInstaller.getSizeInfo(packageName, userHandle, p.baseCodePath, libDirRoot,
11337                publicSrcDir, asecPath, getAppDexInstructionSets(ps),
11338                pStats);
11339        if (res < 0) {
11340            return false;
11341        }
11342
11343        // Fix-up for forward-locked applications in ASEC containers.
11344        if (!isExternal(p)) {
11345            pStats.codeSize += pStats.externalCodeSize;
11346            pStats.externalCodeSize = 0L;
11347        }
11348
11349        return true;
11350    }
11351
11352
11353    @Override
11354    public void addPackageToPreferred(String packageName) {
11355        Slog.w(TAG, "addPackageToPreferred: this is now a no-op");
11356    }
11357
11358    @Override
11359    public void removePackageFromPreferred(String packageName) {
11360        Slog.w(TAG, "removePackageFromPreferred: this is now a no-op");
11361    }
11362
11363    @Override
11364    public List<PackageInfo> getPreferredPackages(int flags) {
11365        return new ArrayList<PackageInfo>();
11366    }
11367
11368    private int getUidTargetSdkVersionLockedLPr(int uid) {
11369        Object obj = mSettings.getUserIdLPr(uid);
11370        if (obj instanceof SharedUserSetting) {
11371            final SharedUserSetting sus = (SharedUserSetting) obj;
11372            int vers = Build.VERSION_CODES.CUR_DEVELOPMENT;
11373            final Iterator<PackageSetting> it = sus.packages.iterator();
11374            while (it.hasNext()) {
11375                final PackageSetting ps = it.next();
11376                if (ps.pkg != null) {
11377                    int v = ps.pkg.applicationInfo.targetSdkVersion;
11378                    if (v < vers) vers = v;
11379                }
11380            }
11381            return vers;
11382        } else if (obj instanceof PackageSetting) {
11383            final PackageSetting ps = (PackageSetting) obj;
11384            if (ps.pkg != null) {
11385                return ps.pkg.applicationInfo.targetSdkVersion;
11386            }
11387        }
11388        return Build.VERSION_CODES.CUR_DEVELOPMENT;
11389    }
11390
11391    @Override
11392    public void addPreferredActivity(IntentFilter filter, int match,
11393            ComponentName[] set, ComponentName activity, int userId) {
11394        addPreferredActivityInternal(filter, match, set, activity, true, userId);
11395    }
11396
11397    private void addPreferredActivityInternal(IntentFilter filter, int match,
11398            ComponentName[] set, ComponentName activity, boolean always, int userId) {
11399        // writer
11400        int callingUid = Binder.getCallingUid();
11401        enforceCrossUserPermission(callingUid, userId, true, "add preferred activity");
11402        if (filter.countActions() == 0) {
11403            Slog.w(TAG, "Cannot set a preferred activity with no filter actions");
11404            return;
11405        }
11406        synchronized (mPackages) {
11407            if (mContext.checkCallingOrSelfPermission(
11408                    android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11409                    != PackageManager.PERMISSION_GRANTED) {
11410                if (getUidTargetSdkVersionLockedLPr(callingUid)
11411                        < Build.VERSION_CODES.FROYO) {
11412                    Slog.w(TAG, "Ignoring addPreferredActivity() from uid "
11413                            + callingUid);
11414                    return;
11415                }
11416                mContext.enforceCallingOrSelfPermission(
11417                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11418            }
11419
11420            Slog.i(TAG, "Adding preferred activity " + activity + " for user " + userId + " :");
11421            filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11422            mSettings.editPreferredActivitiesLPw(userId).addFilter(
11423                    new PreferredActivity(filter, match, set, activity, always));
11424            mSettings.writePackageRestrictionsLPr(userId);
11425        }
11426    }
11427
11428    @Override
11429    public void replacePreferredActivity(IntentFilter filter, int match,
11430            ComponentName[] set, ComponentName activity) {
11431        if (filter.countActions() != 1) {
11432            throw new IllegalArgumentException(
11433                    "replacePreferredActivity expects filter to have only 1 action.");
11434        }
11435        if (filter.countDataAuthorities() != 0
11436                || filter.countDataPaths() != 0
11437                || filter.countDataSchemes() > 1
11438                || filter.countDataTypes() != 0) {
11439            throw new IllegalArgumentException(
11440                    "replacePreferredActivity expects filter to have no data authorities, " +
11441                    "paths, or types; and at most one scheme.");
11442        }
11443        synchronized (mPackages) {
11444            if (mContext.checkCallingOrSelfPermission(
11445                    android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11446                    != PackageManager.PERMISSION_GRANTED) {
11447                if (getUidTargetSdkVersionLockedLPr(Binder.getCallingUid())
11448                        < Build.VERSION_CODES.FROYO) {
11449                    Slog.w(TAG, "Ignoring replacePreferredActivity() from uid "
11450                            + Binder.getCallingUid());
11451                    return;
11452                }
11453                mContext.enforceCallingOrSelfPermission(
11454                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11455            }
11456
11457            final int callingUserId = UserHandle.getCallingUserId();
11458            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(callingUserId);
11459            if (pir != null) {
11460                Intent intent = new Intent(filter.getAction(0)).addCategory(filter.getCategory(0));
11461                if (filter.countDataSchemes() == 1) {
11462                    Uri.Builder builder = new Uri.Builder();
11463                    builder.scheme(filter.getDataScheme(0));
11464                    intent.setData(builder.build());
11465                }
11466                List<PreferredActivity> matches = pir.queryIntent(
11467                        intent, null, true, callingUserId);
11468                if (DEBUG_PREFERRED) {
11469                    Slog.i(TAG, matches.size() + " preferred matches for " + intent);
11470                }
11471                for (int i = 0; i < matches.size(); i++) {
11472                    PreferredActivity pa = matches.get(i);
11473                    if (DEBUG_PREFERRED) {
11474                        Slog.i(TAG, "Removing preferred activity "
11475                                + pa.mPref.mComponent + ":");
11476                        filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11477                    }
11478                    pir.removeFilter(pa);
11479                }
11480            }
11481            addPreferredActivityInternal(filter, match, set, activity, true, callingUserId);
11482        }
11483    }
11484
11485    @Override
11486    public void clearPackagePreferredActivities(String packageName) {
11487        final int uid = Binder.getCallingUid();
11488        // writer
11489        synchronized (mPackages) {
11490            PackageParser.Package pkg = mPackages.get(packageName);
11491            if (pkg == null || pkg.applicationInfo.uid != uid) {
11492                if (mContext.checkCallingOrSelfPermission(
11493                        android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
11494                        != PackageManager.PERMISSION_GRANTED) {
11495                    if (getUidTargetSdkVersionLockedLPr(Binder.getCallingUid())
11496                            < Build.VERSION_CODES.FROYO) {
11497                        Slog.w(TAG, "Ignoring clearPackagePreferredActivities() from uid "
11498                                + Binder.getCallingUid());
11499                        return;
11500                    }
11501                    mContext.enforceCallingOrSelfPermission(
11502                            android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11503                }
11504            }
11505
11506            int user = UserHandle.getCallingUserId();
11507            if (clearPackagePreferredActivitiesLPw(packageName, user)) {
11508                mSettings.writePackageRestrictionsLPr(user);
11509                scheduleWriteSettingsLocked();
11510            }
11511        }
11512    }
11513
11514    /** This method takes a specific user id as well as UserHandle.USER_ALL. */
11515    boolean clearPackagePreferredActivitiesLPw(String packageName, int userId) {
11516        ArrayList<PreferredActivity> removed = null;
11517        boolean changed = false;
11518        for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
11519            final int thisUserId = mSettings.mPreferredActivities.keyAt(i);
11520            PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
11521            if (userId != UserHandle.USER_ALL && userId != thisUserId) {
11522                continue;
11523            }
11524            Iterator<PreferredActivity> it = pir.filterIterator();
11525            while (it.hasNext()) {
11526                PreferredActivity pa = it.next();
11527                // Mark entry for removal only if it matches the package name
11528                // and the entry is of type "always".
11529                if (packageName == null ||
11530                        (pa.mPref.mComponent.getPackageName().equals(packageName)
11531                                && pa.mPref.mAlways)) {
11532                    if (removed == null) {
11533                        removed = new ArrayList<PreferredActivity>();
11534                    }
11535                    removed.add(pa);
11536                }
11537            }
11538            if (removed != null) {
11539                for (int j=0; j<removed.size(); j++) {
11540                    PreferredActivity pa = removed.get(j);
11541                    pir.removeFilter(pa);
11542                }
11543                changed = true;
11544            }
11545        }
11546        return changed;
11547    }
11548
11549    @Override
11550    public void resetPreferredActivities(int userId) {
11551        mContext.enforceCallingOrSelfPermission(
11552                android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
11553        // writer
11554        synchronized (mPackages) {
11555            int user = UserHandle.getCallingUserId();
11556            clearPackagePreferredActivitiesLPw(null, user);
11557            mSettings.readDefaultPreferredAppsLPw(this, user);
11558            mSettings.writePackageRestrictionsLPr(user);
11559            scheduleWriteSettingsLocked();
11560        }
11561    }
11562
11563    @Override
11564    public int getPreferredActivities(List<IntentFilter> outFilters,
11565            List<ComponentName> outActivities, String packageName) {
11566
11567        int num = 0;
11568        final int userId = UserHandle.getCallingUserId();
11569        // reader
11570        synchronized (mPackages) {
11571            PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
11572            if (pir != null) {
11573                final Iterator<PreferredActivity> it = pir.filterIterator();
11574                while (it.hasNext()) {
11575                    final PreferredActivity pa = it.next();
11576                    if (packageName == null
11577                            || (pa.mPref.mComponent.getPackageName().equals(packageName)
11578                                    && pa.mPref.mAlways)) {
11579                        if (outFilters != null) {
11580                            outFilters.add(new IntentFilter(pa));
11581                        }
11582                        if (outActivities != null) {
11583                            outActivities.add(pa.mPref.mComponent);
11584                        }
11585                    }
11586                }
11587            }
11588        }
11589
11590        return num;
11591    }
11592
11593    @Override
11594    public void addPersistentPreferredActivity(IntentFilter filter, ComponentName activity,
11595            int userId) {
11596        int callingUid = Binder.getCallingUid();
11597        if (callingUid != Process.SYSTEM_UID) {
11598            throw new SecurityException(
11599                    "addPersistentPreferredActivity can only be run by the system");
11600        }
11601        if (filter.countActions() == 0) {
11602            Slog.w(TAG, "Cannot set a preferred activity with no filter actions");
11603            return;
11604        }
11605        synchronized (mPackages) {
11606            Slog.i(TAG, "Adding persistent preferred activity " + activity + " for user " + userId +
11607                    " :");
11608            filter.dump(new LogPrinter(Log.INFO, TAG), "  ");
11609            mSettings.editPersistentPreferredActivitiesLPw(userId).addFilter(
11610                    new PersistentPreferredActivity(filter, activity));
11611            mSettings.writePackageRestrictionsLPr(userId);
11612        }
11613    }
11614
11615    @Override
11616    public void clearPackagePersistentPreferredActivities(String packageName, int userId) {
11617        int callingUid = Binder.getCallingUid();
11618        if (callingUid != Process.SYSTEM_UID) {
11619            throw new SecurityException(
11620                    "clearPackagePersistentPreferredActivities can only be run by the system");
11621        }
11622        ArrayList<PersistentPreferredActivity> removed = null;
11623        boolean changed = false;
11624        synchronized (mPackages) {
11625            for (int i=0; i<mSettings.mPersistentPreferredActivities.size(); i++) {
11626                final int thisUserId = mSettings.mPersistentPreferredActivities.keyAt(i);
11627                PersistentPreferredIntentResolver ppir = mSettings.mPersistentPreferredActivities
11628                        .valueAt(i);
11629                if (userId != thisUserId) {
11630                    continue;
11631                }
11632                Iterator<PersistentPreferredActivity> it = ppir.filterIterator();
11633                while (it.hasNext()) {
11634                    PersistentPreferredActivity ppa = it.next();
11635                    // Mark entry for removal only if it matches the package name.
11636                    if (ppa.mComponent.getPackageName().equals(packageName)) {
11637                        if (removed == null) {
11638                            removed = new ArrayList<PersistentPreferredActivity>();
11639                        }
11640                        removed.add(ppa);
11641                    }
11642                }
11643                if (removed != null) {
11644                    for (int j=0; j<removed.size(); j++) {
11645                        PersistentPreferredActivity ppa = removed.get(j);
11646                        ppir.removeFilter(ppa);
11647                    }
11648                    changed = true;
11649                }
11650            }
11651
11652            if (changed) {
11653                mSettings.writePackageRestrictionsLPr(userId);
11654            }
11655        }
11656    }
11657
11658    @Override
11659    public void addCrossProfileIntentFilter(IntentFilter intentFilter, int sourceUserId,
11660            int targetUserId, int flags) {
11661        mContext.enforceCallingOrSelfPermission(
11662                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
11663        if (intentFilter.countActions() == 0) {
11664            Slog.w(TAG, "Cannot set a crossProfile intent filter with no filter actions");
11665            return;
11666        }
11667        synchronized (mPackages) {
11668            CrossProfileIntentFilter filter = new CrossProfileIntentFilter(intentFilter,
11669                    targetUserId, flags);
11670            mSettings.editCrossProfileIntentResolverLPw(sourceUserId).addFilter(filter);
11671            mSettings.writePackageRestrictionsLPr(sourceUserId);
11672        }
11673    }
11674
11675    public void addCrossProfileIntentsForPackage(String packageName,
11676            int sourceUserId, int targetUserId) {
11677        mContext.enforceCallingOrSelfPermission(
11678                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
11679        mSettings.addCrossProfilePackage(packageName, sourceUserId, targetUserId);
11680        mSettings.writePackageRestrictionsLPr(sourceUserId);
11681    }
11682
11683    public void removeCrossProfileIntentsForPackage(String packageName,
11684            int sourceUserId, int targetUserId) {
11685        mContext.enforceCallingOrSelfPermission(
11686                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
11687        mSettings.removeCrossProfilePackage(packageName, sourceUserId, targetUserId);
11688        mSettings.writePackageRestrictionsLPr(sourceUserId);
11689    }
11690
11691    @Override
11692    public void clearCrossProfileIntentFilters(int sourceUserId) {
11693        mContext.enforceCallingOrSelfPermission(
11694                        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
11695        synchronized (mPackages) {
11696            CrossProfileIntentResolver resolver =
11697                    mSettings.editCrossProfileIntentResolverLPw(sourceUserId);
11698            HashSet<CrossProfileIntentFilter> set =
11699                    new HashSet<CrossProfileIntentFilter>(resolver.filterSet());
11700            for (CrossProfileIntentFilter filter : set) {
11701                if ((filter.getFlags() & PackageManager.SET_BY_PROFILE_OWNER) != 0) {
11702                    resolver.removeFilter(filter);
11703                }
11704            }
11705            mSettings.writePackageRestrictionsLPr(sourceUserId);
11706        }
11707    }
11708
11709    @Override
11710    public ComponentName getHomeActivities(List<ResolveInfo> allHomeCandidates) {
11711        Intent intent = new Intent(Intent.ACTION_MAIN);
11712        intent.addCategory(Intent.CATEGORY_HOME);
11713
11714        final int callingUserId = UserHandle.getCallingUserId();
11715        List<ResolveInfo> list = queryIntentActivities(intent, null,
11716                PackageManager.GET_META_DATA, callingUserId);
11717        ResolveInfo preferred = findPreferredActivity(intent, null, 0, list, 0,
11718                true, false, false, callingUserId);
11719
11720        allHomeCandidates.clear();
11721        if (list != null) {
11722            for (ResolveInfo ri : list) {
11723                allHomeCandidates.add(ri);
11724            }
11725        }
11726        return (preferred == null || preferred.activityInfo == null)
11727                ? null
11728                : new ComponentName(preferred.activityInfo.packageName,
11729                        preferred.activityInfo.name);
11730    }
11731
11732    @Override
11733    public void setApplicationEnabledSetting(String appPackageName,
11734            int newState, int flags, int userId, String callingPackage) {
11735        if (!sUserManager.exists(userId)) return;
11736        if (callingPackage == null) {
11737            callingPackage = Integer.toString(Binder.getCallingUid());
11738        }
11739        setEnabledSetting(appPackageName, null, newState, flags, userId, callingPackage);
11740    }
11741
11742    @Override
11743    public void setComponentEnabledSetting(ComponentName componentName,
11744            int newState, int flags, int userId) {
11745        if (!sUserManager.exists(userId)) return;
11746        setEnabledSetting(componentName.getPackageName(),
11747                componentName.getClassName(), newState, flags, userId, null);
11748    }
11749
11750    private void setEnabledSetting(final String packageName, String className, int newState,
11751            final int flags, int userId, String callingPackage) {
11752        if (!(newState == COMPONENT_ENABLED_STATE_DEFAULT
11753              || newState == COMPONENT_ENABLED_STATE_ENABLED
11754              || newState == COMPONENT_ENABLED_STATE_DISABLED
11755              || newState == COMPONENT_ENABLED_STATE_DISABLED_USER
11756              || newState == COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED)) {
11757            throw new IllegalArgumentException("Invalid new component state: "
11758                    + newState);
11759        }
11760        PackageSetting pkgSetting;
11761        final int uid = Binder.getCallingUid();
11762        final int permission = mContext.checkCallingOrSelfPermission(
11763                android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE);
11764        enforceCrossUserPermission(uid, userId, false, "set enabled");
11765        final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED);
11766        boolean sendNow = false;
11767        boolean isApp = (className == null);
11768        String componentName = isApp ? packageName : className;
11769        int packageUid = -1;
11770        ArrayList<String> components;
11771
11772        // writer
11773        synchronized (mPackages) {
11774            pkgSetting = mSettings.mPackages.get(packageName);
11775            if (pkgSetting == null) {
11776                if (className == null) {
11777                    throw new IllegalArgumentException(
11778                            "Unknown package: " + packageName);
11779                }
11780                throw new IllegalArgumentException(
11781                        "Unknown component: " + packageName
11782                        + "/" + className);
11783            }
11784            // Allow root and verify that userId is not being specified by a different user
11785            if (!allowedByPermission && !UserHandle.isSameApp(uid, pkgSetting.appId)) {
11786                throw new SecurityException(
11787                        "Permission Denial: attempt to change component state from pid="
11788                        + Binder.getCallingPid()
11789                        + ", uid=" + uid + ", package uid=" + pkgSetting.appId);
11790            }
11791            if (className == null) {
11792                // We're dealing with an application/package level state change
11793                if (pkgSetting.getEnabled(userId) == newState) {
11794                    // Nothing to do
11795                    return;
11796                }
11797                if (newState == PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
11798                    || newState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
11799                    // Don't care about who enables an app.
11800                    callingPackage = null;
11801                }
11802                pkgSetting.setEnabled(newState, userId, callingPackage);
11803                // pkgSetting.pkg.mSetEnabled = newState;
11804            } else {
11805                // We're dealing with a component level state change
11806                // First, verify that this is a valid class name.
11807                PackageParser.Package pkg = pkgSetting.pkg;
11808                if (pkg == null || !pkg.hasComponentClassName(className)) {
11809                    if (pkg.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.JELLY_BEAN) {
11810                        throw new IllegalArgumentException("Component class " + className
11811                                + " does not exist in " + packageName);
11812                    } else {
11813                        Slog.w(TAG, "Failed setComponentEnabledSetting: component class "
11814                                + className + " does not exist in " + packageName);
11815                    }
11816                }
11817                switch (newState) {
11818                case COMPONENT_ENABLED_STATE_ENABLED:
11819                    if (!pkgSetting.enableComponentLPw(className, userId)) {
11820                        return;
11821                    }
11822                    break;
11823                case COMPONENT_ENABLED_STATE_DISABLED:
11824                    if (!pkgSetting.disableComponentLPw(className, userId)) {
11825                        return;
11826                    }
11827                    break;
11828                case COMPONENT_ENABLED_STATE_DEFAULT:
11829                    if (!pkgSetting.restoreComponentLPw(className, userId)) {
11830                        return;
11831                    }
11832                    break;
11833                default:
11834                    Slog.e(TAG, "Invalid new component state: " + newState);
11835                    return;
11836                }
11837            }
11838            mSettings.writePackageRestrictionsLPr(userId);
11839            components = mPendingBroadcasts.get(userId, packageName);
11840            final boolean newPackage = components == null;
11841            if (newPackage) {
11842                components = new ArrayList<String>();
11843            }
11844            if (!components.contains(componentName)) {
11845                components.add(componentName);
11846            }
11847            if ((flags&PackageManager.DONT_KILL_APP) == 0) {
11848                sendNow = true;
11849                // Purge entry from pending broadcast list if another one exists already
11850                // since we are sending one right away.
11851                mPendingBroadcasts.remove(userId, packageName);
11852            } else {
11853                if (newPackage) {
11854                    mPendingBroadcasts.put(userId, packageName, components);
11855                }
11856                if (!mHandler.hasMessages(SEND_PENDING_BROADCAST)) {
11857                    // Schedule a message
11858                    mHandler.sendEmptyMessageDelayed(SEND_PENDING_BROADCAST, BROADCAST_DELAY);
11859                }
11860            }
11861        }
11862
11863        long callingId = Binder.clearCallingIdentity();
11864        try {
11865            if (sendNow) {
11866                packageUid = UserHandle.getUid(userId, pkgSetting.appId);
11867                sendPackageChangedBroadcast(packageName,
11868                        (flags&PackageManager.DONT_KILL_APP) != 0, components, packageUid);
11869            }
11870        } finally {
11871            Binder.restoreCallingIdentity(callingId);
11872        }
11873    }
11874
11875    private void sendPackageChangedBroadcast(String packageName,
11876            boolean killFlag, ArrayList<String> componentNames, int packageUid) {
11877        if (DEBUG_INSTALL)
11878            Log.v(TAG, "Sending package changed: package=" + packageName + " components="
11879                    + componentNames);
11880        Bundle extras = new Bundle(4);
11881        extras.putString(Intent.EXTRA_CHANGED_COMPONENT_NAME, componentNames.get(0));
11882        String nameList[] = new String[componentNames.size()];
11883        componentNames.toArray(nameList);
11884        extras.putStringArray(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST, nameList);
11885        extras.putBoolean(Intent.EXTRA_DONT_KILL_APP, killFlag);
11886        extras.putInt(Intent.EXTRA_UID, packageUid);
11887        sendPackageBroadcast(Intent.ACTION_PACKAGE_CHANGED,  packageName, extras, null, null,
11888                new int[] {UserHandle.getUserId(packageUid)});
11889    }
11890
11891    @Override
11892    public void setPackageStoppedState(String packageName, boolean stopped, int userId) {
11893        if (!sUserManager.exists(userId)) return;
11894        final int uid = Binder.getCallingUid();
11895        final int permission = mContext.checkCallingOrSelfPermission(
11896                android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE);
11897        final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED);
11898        enforceCrossUserPermission(uid, userId, true, "stop package");
11899        // writer
11900        synchronized (mPackages) {
11901            if (mSettings.setPackageStoppedStateLPw(packageName, stopped, allowedByPermission,
11902                    uid, userId)) {
11903                scheduleWritePackageRestrictionsLocked(userId);
11904            }
11905        }
11906    }
11907
11908    @Override
11909    public String getInstallerPackageName(String packageName) {
11910        // reader
11911        synchronized (mPackages) {
11912            return mSettings.getInstallerPackageNameLPr(packageName);
11913        }
11914    }
11915
11916    @Override
11917    public int getApplicationEnabledSetting(String packageName, int userId) {
11918        if (!sUserManager.exists(userId)) return COMPONENT_ENABLED_STATE_DISABLED;
11919        int uid = Binder.getCallingUid();
11920        enforceCrossUserPermission(uid, userId, false, "get enabled");
11921        // reader
11922        synchronized (mPackages) {
11923            return mSettings.getApplicationEnabledSettingLPr(packageName, userId);
11924        }
11925    }
11926
11927    @Override
11928    public int getComponentEnabledSetting(ComponentName componentName, int userId) {
11929        if (!sUserManager.exists(userId)) return COMPONENT_ENABLED_STATE_DISABLED;
11930        int uid = Binder.getCallingUid();
11931        enforceCrossUserPermission(uid, userId, false, "get component enabled");
11932        // reader
11933        synchronized (mPackages) {
11934            return mSettings.getComponentEnabledSettingLPr(componentName, userId);
11935        }
11936    }
11937
11938    @Override
11939    public void enterSafeMode() {
11940        enforceSystemOrRoot("Only the system can request entering safe mode");
11941
11942        if (!mSystemReady) {
11943            mSafeMode = true;
11944        }
11945    }
11946
11947    @Override
11948    public void systemReady() {
11949        mSystemReady = true;
11950
11951        // Read the compatibilty setting when the system is ready.
11952        boolean compatibilityModeEnabled = android.provider.Settings.Global.getInt(
11953                mContext.getContentResolver(),
11954                android.provider.Settings.Global.COMPATIBILITY_MODE, 1) == 1;
11955        PackageParser.setCompatibilityModeEnabled(compatibilityModeEnabled);
11956        if (DEBUG_SETTINGS) {
11957            Log.d(TAG, "compatibility mode:" + compatibilityModeEnabled);
11958        }
11959
11960        synchronized (mPackages) {
11961            // Verify that all of the preferred activity components actually
11962            // exist.  It is possible for applications to be updated and at
11963            // that point remove a previously declared activity component that
11964            // had been set as a preferred activity.  We try to clean this up
11965            // the next time we encounter that preferred activity, but it is
11966            // possible for the user flow to never be able to return to that
11967            // situation so here we do a sanity check to make sure we haven't
11968            // left any junk around.
11969            ArrayList<PreferredActivity> removed = new ArrayList<PreferredActivity>();
11970            for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
11971                PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
11972                removed.clear();
11973                for (PreferredActivity pa : pir.filterSet()) {
11974                    if (mActivities.mActivities.get(pa.mPref.mComponent) == null) {
11975                        removed.add(pa);
11976                    }
11977                }
11978                if (removed.size() > 0) {
11979                    for (int r=0; r<removed.size(); r++) {
11980                        PreferredActivity pa = removed.get(r);
11981                        Slog.w(TAG, "Removing dangling preferred activity: "
11982                                + pa.mPref.mComponent);
11983                        pir.removeFilter(pa);
11984                    }
11985                    mSettings.writePackageRestrictionsLPr(
11986                            mSettings.mPreferredActivities.keyAt(i));
11987                }
11988            }
11989        }
11990        sUserManager.systemReady();
11991    }
11992
11993    @Override
11994    public boolean isSafeMode() {
11995        return mSafeMode;
11996    }
11997
11998    @Override
11999    public boolean hasSystemUidErrors() {
12000        return mHasSystemUidErrors;
12001    }
12002
12003    static String arrayToString(int[] array) {
12004        StringBuffer buf = new StringBuffer(128);
12005        buf.append('[');
12006        if (array != null) {
12007            for (int i=0; i<array.length; i++) {
12008                if (i > 0) buf.append(", ");
12009                buf.append(array[i]);
12010            }
12011        }
12012        buf.append(']');
12013        return buf.toString();
12014    }
12015
12016    static class DumpState {
12017        public static final int DUMP_LIBS = 1 << 0;
12018        public static final int DUMP_FEATURES = 1 << 1;
12019        public static final int DUMP_RESOLVERS = 1 << 2;
12020        public static final int DUMP_PERMISSIONS = 1 << 3;
12021        public static final int DUMP_PACKAGES = 1 << 4;
12022        public static final int DUMP_SHARED_USERS = 1 << 5;
12023        public static final int DUMP_MESSAGES = 1 << 6;
12024        public static final int DUMP_PROVIDERS = 1 << 7;
12025        public static final int DUMP_VERIFIERS = 1 << 8;
12026        public static final int DUMP_PREFERRED = 1 << 9;
12027        public static final int DUMP_PREFERRED_XML = 1 << 10;
12028        public static final int DUMP_KEYSETS = 1 << 11;
12029        public static final int DUMP_VERSION = 1 << 12;
12030        public static final int DUMP_INSTALLS = 1 << 13;
12031
12032        public static final int OPTION_SHOW_FILTERS = 1 << 0;
12033
12034        private int mTypes;
12035
12036        private int mOptions;
12037
12038        private boolean mTitlePrinted;
12039
12040        private SharedUserSetting mSharedUser;
12041
12042        public boolean isDumping(int type) {
12043            if (mTypes == 0 && type != DUMP_PREFERRED_XML) {
12044                return true;
12045            }
12046
12047            return (mTypes & type) != 0;
12048        }
12049
12050        public void setDump(int type) {
12051            mTypes |= type;
12052        }
12053
12054        public boolean isOptionEnabled(int option) {
12055            return (mOptions & option) != 0;
12056        }
12057
12058        public void setOptionEnabled(int option) {
12059            mOptions |= option;
12060        }
12061
12062        public boolean onTitlePrinted() {
12063            final boolean printed = mTitlePrinted;
12064            mTitlePrinted = true;
12065            return printed;
12066        }
12067
12068        public boolean getTitlePrinted() {
12069            return mTitlePrinted;
12070        }
12071
12072        public void setTitlePrinted(boolean enabled) {
12073            mTitlePrinted = enabled;
12074        }
12075
12076        public SharedUserSetting getSharedUser() {
12077            return mSharedUser;
12078        }
12079
12080        public void setSharedUser(SharedUserSetting user) {
12081            mSharedUser = user;
12082        }
12083    }
12084
12085    @Override
12086    protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
12087        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
12088                != PackageManager.PERMISSION_GRANTED) {
12089            pw.println("Permission Denial: can't dump ActivityManager from from pid="
12090                    + Binder.getCallingPid()
12091                    + ", uid=" + Binder.getCallingUid()
12092                    + " without permission "
12093                    + android.Manifest.permission.DUMP);
12094            return;
12095        }
12096
12097        DumpState dumpState = new DumpState();
12098        boolean fullPreferred = false;
12099        boolean checkin = false;
12100
12101        String packageName = null;
12102
12103        int opti = 0;
12104        while (opti < args.length) {
12105            String opt = args[opti];
12106            if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
12107                break;
12108            }
12109            opti++;
12110            if ("-a".equals(opt)) {
12111                // Right now we only know how to print all.
12112            } else if ("-h".equals(opt)) {
12113                pw.println("Package manager dump options:");
12114                pw.println("  [-h] [-f] [--checkin] [cmd] ...");
12115                pw.println("    --checkin: dump for a checkin");
12116                pw.println("    -f: print details of intent filters");
12117                pw.println("    -h: print this help");
12118                pw.println("  cmd may be one of:");
12119                pw.println("    l[ibraries]: list known shared libraries");
12120                pw.println("    f[ibraries]: list device features");
12121                pw.println("    k[eysets]: print known keysets");
12122                pw.println("    r[esolvers]: dump intent resolvers");
12123                pw.println("    perm[issions]: dump permissions");
12124                pw.println("    pref[erred]: print preferred package settings");
12125                pw.println("    preferred-xml [--full]: print preferred package settings as xml");
12126                pw.println("    prov[iders]: dump content providers");
12127                pw.println("    p[ackages]: dump installed packages");
12128                pw.println("    s[hared-users]: dump shared user IDs");
12129                pw.println("    m[essages]: print collected runtime messages");
12130                pw.println("    v[erifiers]: print package verifier info");
12131                pw.println("    version: print database version info");
12132                pw.println("    write: write current settings now");
12133                pw.println("    <package.name>: info about given package");
12134                pw.println("    installs: details about install sessions");
12135                return;
12136            } else if ("--checkin".equals(opt)) {
12137                checkin = true;
12138            } else if ("-f".equals(opt)) {
12139                dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
12140            } else {
12141                pw.println("Unknown argument: " + opt + "; use -h for help");
12142            }
12143        }
12144
12145        // Is the caller requesting to dump a particular piece of data?
12146        if (opti < args.length) {
12147            String cmd = args[opti];
12148            opti++;
12149            // Is this a package name?
12150            if ("android".equals(cmd) || cmd.contains(".")) {
12151                packageName = cmd;
12152                // When dumping a single package, we always dump all of its
12153                // filter information since the amount of data will be reasonable.
12154                dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
12155            } else if ("l".equals(cmd) || "libraries".equals(cmd)) {
12156                dumpState.setDump(DumpState.DUMP_LIBS);
12157            } else if ("f".equals(cmd) || "features".equals(cmd)) {
12158                dumpState.setDump(DumpState.DUMP_FEATURES);
12159            } else if ("r".equals(cmd) || "resolvers".equals(cmd)) {
12160                dumpState.setDump(DumpState.DUMP_RESOLVERS);
12161            } else if ("perm".equals(cmd) || "permissions".equals(cmd)) {
12162                dumpState.setDump(DumpState.DUMP_PERMISSIONS);
12163            } else if ("pref".equals(cmd) || "preferred".equals(cmd)) {
12164                dumpState.setDump(DumpState.DUMP_PREFERRED);
12165            } else if ("preferred-xml".equals(cmd)) {
12166                dumpState.setDump(DumpState.DUMP_PREFERRED_XML);
12167                if (opti < args.length && "--full".equals(args[opti])) {
12168                    fullPreferred = true;
12169                    opti++;
12170                }
12171            } else if ("p".equals(cmd) || "packages".equals(cmd)) {
12172                dumpState.setDump(DumpState.DUMP_PACKAGES);
12173            } else if ("s".equals(cmd) || "shared-users".equals(cmd)) {
12174                dumpState.setDump(DumpState.DUMP_SHARED_USERS);
12175            } else if ("prov".equals(cmd) || "providers".equals(cmd)) {
12176                dumpState.setDump(DumpState.DUMP_PROVIDERS);
12177            } else if ("m".equals(cmd) || "messages".equals(cmd)) {
12178                dumpState.setDump(DumpState.DUMP_MESSAGES);
12179            } else if ("v".equals(cmd) || "verifiers".equals(cmd)) {
12180                dumpState.setDump(DumpState.DUMP_VERIFIERS);
12181            } else if ("version".equals(cmd)) {
12182                dumpState.setDump(DumpState.DUMP_VERSION);
12183            } else if ("k".equals(cmd) || "keysets".equals(cmd)) {
12184                dumpState.setDump(DumpState.DUMP_KEYSETS);
12185            } else if ("write".equals(cmd)) {
12186                synchronized (mPackages) {
12187                    mSettings.writeLPr();
12188                    pw.println("Settings written.");
12189                    return;
12190                }
12191            } else if ("installs".equals(cmd)) {
12192                dumpState.setDump(DumpState.DUMP_INSTALLS);
12193            }
12194        }
12195
12196        if (checkin) {
12197            pw.println("vers,1");
12198        }
12199
12200        // reader
12201        synchronized (mPackages) {
12202            if (dumpState.isDumping(DumpState.DUMP_VERSION) && packageName == null) {
12203                if (!checkin) {
12204                    if (dumpState.onTitlePrinted())
12205                        pw.println();
12206                    pw.println("Database versions:");
12207                    pw.print("  SDK Version:");
12208                    pw.print(" internal=");
12209                    pw.print(mSettings.mInternalSdkPlatform);
12210                    pw.print(" external=");
12211                    pw.println(mSettings.mExternalSdkPlatform);
12212                    pw.print("  DB Version:");
12213                    pw.print(" internal=");
12214                    pw.print(mSettings.mInternalDatabaseVersion);
12215                    pw.print(" external=");
12216                    pw.println(mSettings.mExternalDatabaseVersion);
12217                }
12218            }
12219
12220            if (dumpState.isDumping(DumpState.DUMP_VERIFIERS) && packageName == null) {
12221                if (!checkin) {
12222                    if (dumpState.onTitlePrinted())
12223                        pw.println();
12224                    pw.println("Verifiers:");
12225                    pw.print("  Required: ");
12226                    pw.print(mRequiredVerifierPackage);
12227                    pw.print(" (uid=");
12228                    pw.print(getPackageUid(mRequiredVerifierPackage, 0));
12229                    pw.println(")");
12230                } else if (mRequiredVerifierPackage != null) {
12231                    pw.print("vrfy,"); pw.print(mRequiredVerifierPackage);
12232                    pw.print(","); pw.println(getPackageUid(mRequiredVerifierPackage, 0));
12233                }
12234            }
12235
12236            if (dumpState.isDumping(DumpState.DUMP_LIBS) && packageName == null) {
12237                boolean printedHeader = false;
12238                final Iterator<String> it = mSharedLibraries.keySet().iterator();
12239                while (it.hasNext()) {
12240                    String name = it.next();
12241                    SharedLibraryEntry ent = mSharedLibraries.get(name);
12242                    if (!checkin) {
12243                        if (!printedHeader) {
12244                            if (dumpState.onTitlePrinted())
12245                                pw.println();
12246                            pw.println("Libraries:");
12247                            printedHeader = true;
12248                        }
12249                        pw.print("  ");
12250                    } else {
12251                        pw.print("lib,");
12252                    }
12253                    pw.print(name);
12254                    if (!checkin) {
12255                        pw.print(" -> ");
12256                    }
12257                    if (ent.path != null) {
12258                        if (!checkin) {
12259                            pw.print("(jar) ");
12260                            pw.print(ent.path);
12261                        } else {
12262                            pw.print(",jar,");
12263                            pw.print(ent.path);
12264                        }
12265                    } else {
12266                        if (!checkin) {
12267                            pw.print("(apk) ");
12268                            pw.print(ent.apk);
12269                        } else {
12270                            pw.print(",apk,");
12271                            pw.print(ent.apk);
12272                        }
12273                    }
12274                    pw.println();
12275                }
12276            }
12277
12278            if (dumpState.isDumping(DumpState.DUMP_FEATURES) && packageName == null) {
12279                if (dumpState.onTitlePrinted())
12280                    pw.println();
12281                if (!checkin) {
12282                    pw.println("Features:");
12283                }
12284                Iterator<String> it = mAvailableFeatures.keySet().iterator();
12285                while (it.hasNext()) {
12286                    String name = it.next();
12287                    if (!checkin) {
12288                        pw.print("  ");
12289                    } else {
12290                        pw.print("feat,");
12291                    }
12292                    pw.println(name);
12293                }
12294            }
12295
12296            if (!checkin && dumpState.isDumping(DumpState.DUMP_RESOLVERS)) {
12297                if (mActivities.dump(pw, dumpState.getTitlePrinted() ? "\nActivity Resolver Table:"
12298                        : "Activity Resolver Table:", "  ", packageName,
12299                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
12300                    dumpState.setTitlePrinted(true);
12301                }
12302                if (mReceivers.dump(pw, dumpState.getTitlePrinted() ? "\nReceiver Resolver Table:"
12303                        : "Receiver Resolver Table:", "  ", packageName,
12304                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
12305                    dumpState.setTitlePrinted(true);
12306                }
12307                if (mServices.dump(pw, dumpState.getTitlePrinted() ? "\nService Resolver Table:"
12308                        : "Service Resolver Table:", "  ", packageName,
12309                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
12310                    dumpState.setTitlePrinted(true);
12311                }
12312                if (mProviders.dump(pw, dumpState.getTitlePrinted() ? "\nProvider Resolver Table:"
12313                        : "Provider Resolver Table:", "  ", packageName,
12314                        dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
12315                    dumpState.setTitlePrinted(true);
12316                }
12317            }
12318
12319            if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED)) {
12320                for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
12321                    PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
12322                    int user = mSettings.mPreferredActivities.keyAt(i);
12323                    if (pir.dump(pw,
12324                            dumpState.getTitlePrinted()
12325                                ? "\nPreferred Activities User " + user + ":"
12326                                : "Preferred Activities User " + user + ":", "  ",
12327                            packageName, true)) {
12328                        dumpState.setTitlePrinted(true);
12329                    }
12330                }
12331            }
12332
12333            if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED_XML)) {
12334                pw.flush();
12335                FileOutputStream fout = new FileOutputStream(fd);
12336                BufferedOutputStream str = new BufferedOutputStream(fout);
12337                XmlSerializer serializer = new FastXmlSerializer();
12338                try {
12339                    serializer.setOutput(str, "utf-8");
12340                    serializer.startDocument(null, true);
12341                    serializer.setFeature(
12342                            "http://xmlpull.org/v1/doc/features.html#indent-output", true);
12343                    mSettings.writePreferredActivitiesLPr(serializer, 0, fullPreferred);
12344                    serializer.endDocument();
12345                    serializer.flush();
12346                } catch (IllegalArgumentException e) {
12347                    pw.println("Failed writing: " + e);
12348                } catch (IllegalStateException e) {
12349                    pw.println("Failed writing: " + e);
12350                } catch (IOException e) {
12351                    pw.println("Failed writing: " + e);
12352                }
12353            }
12354
12355            if (!checkin && dumpState.isDumping(DumpState.DUMP_PERMISSIONS)) {
12356                mSettings.dumpPermissionsLPr(pw, packageName, dumpState);
12357            }
12358
12359            if (!checkin && dumpState.isDumping(DumpState.DUMP_PROVIDERS)) {
12360                boolean printedSomething = false;
12361                for (PackageParser.Provider p : mProviders.mProviders.values()) {
12362                    if (packageName != null && !packageName.equals(p.info.packageName)) {
12363                        continue;
12364                    }
12365                    if (!printedSomething) {
12366                        if (dumpState.onTitlePrinted())
12367                            pw.println();
12368                        pw.println("Registered ContentProviders:");
12369                        printedSomething = true;
12370                    }
12371                    pw.print("  "); p.printComponentShortName(pw); pw.println(":");
12372                    pw.print("    "); pw.println(p.toString());
12373                }
12374                printedSomething = false;
12375                for (Map.Entry<String, PackageParser.Provider> entry :
12376                        mProvidersByAuthority.entrySet()) {
12377                    PackageParser.Provider p = entry.getValue();
12378                    if (packageName != null && !packageName.equals(p.info.packageName)) {
12379                        continue;
12380                    }
12381                    if (!printedSomething) {
12382                        if (dumpState.onTitlePrinted())
12383                            pw.println();
12384                        pw.println("ContentProvider Authorities:");
12385                        printedSomething = true;
12386                    }
12387                    pw.print("  ["); pw.print(entry.getKey()); pw.println("]:");
12388                    pw.print("    "); pw.println(p.toString());
12389                    if (p.info != null && p.info.applicationInfo != null) {
12390                        final String appInfo = p.info.applicationInfo.toString();
12391                        pw.print("      applicationInfo="); pw.println(appInfo);
12392                    }
12393                }
12394            }
12395
12396            if (!checkin && dumpState.isDumping(DumpState.DUMP_KEYSETS)) {
12397                mSettings.mKeySetManagerService.dumpLPr(pw, packageName, dumpState);
12398            }
12399
12400            if (dumpState.isDumping(DumpState.DUMP_PACKAGES)) {
12401                mSettings.dumpPackagesLPr(pw, packageName, dumpState, checkin);
12402            }
12403
12404            if (!checkin && dumpState.isDumping(DumpState.DUMP_SHARED_USERS)) {
12405                mSettings.dumpSharedUsersLPr(pw, packageName, dumpState);
12406            }
12407
12408            if (!checkin && dumpState.isDumping(DumpState.DUMP_INSTALLS)) {
12409                if (dumpState.onTitlePrinted()) pw.println();
12410                mInstallerService.dump(new IndentingPrintWriter(pw, "  ", 120));
12411            }
12412
12413            if (!checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES) && packageName == null) {
12414                if (dumpState.onTitlePrinted()) pw.println();
12415                mSettings.dumpReadMessagesLPr(pw, dumpState);
12416
12417                pw.println();
12418                pw.println("Package warning messages:");
12419                final File fname = getSettingsProblemFile();
12420                FileInputStream in = null;
12421                try {
12422                    in = new FileInputStream(fname);
12423                    final int avail = in.available();
12424                    final byte[] data = new byte[avail];
12425                    in.read(data);
12426                    pw.print(new String(data));
12427                } catch (FileNotFoundException e) {
12428                } catch (IOException e) {
12429                } finally {
12430                    if (in != null) {
12431                        try {
12432                            in.close();
12433                        } catch (IOException e) {
12434                        }
12435                    }
12436                }
12437            }
12438        }
12439    }
12440
12441    // ------- apps on sdcard specific code -------
12442    static final boolean DEBUG_SD_INSTALL = false;
12443
12444    private static final String SD_ENCRYPTION_KEYSTORE_NAME = "AppsOnSD";
12445
12446    private static final String SD_ENCRYPTION_ALGORITHM = "AES";
12447
12448    private boolean mMediaMounted = false;
12449
12450    private String getEncryptKey() {
12451        try {
12452            String sdEncKey = SystemKeyStore.getInstance().retrieveKeyHexString(
12453                    SD_ENCRYPTION_KEYSTORE_NAME);
12454            if (sdEncKey == null) {
12455                sdEncKey = SystemKeyStore.getInstance().generateNewKeyHexString(128,
12456                        SD_ENCRYPTION_ALGORITHM, SD_ENCRYPTION_KEYSTORE_NAME);
12457                if (sdEncKey == null) {
12458                    Slog.e(TAG, "Failed to create encryption keys");
12459                    return null;
12460                }
12461            }
12462            return sdEncKey;
12463        } catch (NoSuchAlgorithmException nsae) {
12464            Slog.e(TAG, "Failed to create encryption keys with exception: " + nsae);
12465            return null;
12466        } catch (IOException ioe) {
12467            Slog.e(TAG, "Failed to retrieve encryption keys with exception: " + ioe);
12468            return null;
12469        }
12470
12471    }
12472
12473    /* package */static String getTempContainerId() {
12474        int tmpIdx = 1;
12475        String list[] = PackageHelper.getSecureContainerList();
12476        if (list != null) {
12477            for (final String name : list) {
12478                // Ignore null and non-temporary container entries
12479                if (name == null || !name.startsWith(mTempContainerPrefix)) {
12480                    continue;
12481                }
12482
12483                String subStr = name.substring(mTempContainerPrefix.length());
12484                try {
12485                    int cid = Integer.parseInt(subStr);
12486                    if (cid >= tmpIdx) {
12487                        tmpIdx = cid + 1;
12488                    }
12489                } catch (NumberFormatException e) {
12490                }
12491            }
12492        }
12493        return mTempContainerPrefix + tmpIdx;
12494    }
12495
12496    /*
12497     * Update media status on PackageManager.
12498     */
12499    @Override
12500    public void updateExternalMediaStatus(final boolean mediaStatus, final boolean reportStatus) {
12501        int callingUid = Binder.getCallingUid();
12502        if (callingUid != 0 && callingUid != Process.SYSTEM_UID) {
12503            throw new SecurityException("Media status can only be updated by the system");
12504        }
12505        // reader; this apparently protects mMediaMounted, but should probably
12506        // be a different lock in that case.
12507        synchronized (mPackages) {
12508            Log.i(TAG, "Updating external media status from "
12509                    + (mMediaMounted ? "mounted" : "unmounted") + " to "
12510                    + (mediaStatus ? "mounted" : "unmounted"));
12511            if (DEBUG_SD_INSTALL)
12512                Log.i(TAG, "updateExternalMediaStatus:: mediaStatus=" + mediaStatus
12513                        + ", mMediaMounted=" + mMediaMounted);
12514            if (mediaStatus == mMediaMounted) {
12515                final Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS, reportStatus ? 1
12516                        : 0, -1);
12517                mHandler.sendMessage(msg);
12518                return;
12519            }
12520            mMediaMounted = mediaStatus;
12521        }
12522        // Queue up an async operation since the package installation may take a
12523        // little while.
12524        mHandler.post(new Runnable() {
12525            public void run() {
12526                updateExternalMediaStatusInner(mediaStatus, reportStatus, true);
12527            }
12528        });
12529    }
12530
12531    /**
12532     * Called by MountService when the initial ASECs to scan are available.
12533     * Should block until all the ASEC containers are finished being scanned.
12534     */
12535    public void scanAvailableAsecs() {
12536        updateExternalMediaStatusInner(true, false, false);
12537        if (mShouldRestoreconData) {
12538            SELinuxMMAC.setRestoreconDone();
12539            mShouldRestoreconData = false;
12540        }
12541    }
12542
12543    /*
12544     * Collect information of applications on external media, map them against
12545     * existing containers and update information based on current mount status.
12546     * Please note that we always have to report status if reportStatus has been
12547     * set to true especially when unloading packages.
12548     */
12549    private void updateExternalMediaStatusInner(boolean isMounted, boolean reportStatus,
12550            boolean externalStorage) {
12551        // Collection of uids
12552        int uidArr[] = null;
12553        // Collection of stale containers
12554        HashSet<String> removeCids = new HashSet<String>();
12555        // Collection of packages on external media with valid containers.
12556        HashMap<AsecInstallArgs, String> processCids = new HashMap<AsecInstallArgs, String>();
12557        // Get list of secure containers.
12558        final String list[] = PackageHelper.getSecureContainerList();
12559        if (list == null || list.length == 0) {
12560            Log.i(TAG, "No secure containers on sdcard");
12561        } else {
12562            // Process list of secure containers and categorize them
12563            // as active or stale based on their package internal state.
12564            int uidList[] = new int[list.length];
12565            int num = 0;
12566            // reader
12567            synchronized (mPackages) {
12568                for (String cid : list) {
12569                    if (DEBUG_SD_INSTALL)
12570                        Log.i(TAG, "Processing container " + cid);
12571                    String pkgName = getAsecPackageName(cid);
12572                    if (pkgName == null) {
12573                        if (DEBUG_SD_INSTALL)
12574                            Log.i(TAG, "Container : " + cid + " stale");
12575                        removeCids.add(cid);
12576                        continue;
12577                    }
12578                    if (DEBUG_SD_INSTALL)
12579                        Log.i(TAG, "Looking for pkg : " + pkgName);
12580
12581                    final PackageSetting ps = mSettings.mPackages.get(pkgName);
12582                    if (ps == null) {
12583                        Log.i(TAG, "Deleting container with no matching settings " + cid);
12584                        removeCids.add(cid);
12585                        continue;
12586                    }
12587
12588                    /*
12589                     * Skip packages that are not external if we're unmounting
12590                     * external storage.
12591                     */
12592                    if (externalStorage && !isMounted && !isExternal(ps)) {
12593                        continue;
12594                    }
12595
12596                    final AsecInstallArgs args = new AsecInstallArgs(cid,
12597                            getAppDexInstructionSets(ps), isForwardLocked(ps), isMultiArch(ps));
12598                    // The package status is changed only if the code path
12599                    // matches between settings and the container id.
12600                    if (ps.codePathString != null && ps.codePathString.equals(args.getCodePath())) {
12601                        if (DEBUG_SD_INSTALL) {
12602                            Log.i(TAG, "Container : " + cid + " corresponds to pkg : " + pkgName
12603                                    + " at code path: " + ps.codePathString);
12604                        }
12605
12606                        // We do have a valid package installed on sdcard
12607                        processCids.put(args, ps.codePathString);
12608                        final int uid = ps.appId;
12609                        if (uid != -1) {
12610                            uidList[num++] = uid;
12611                        }
12612                    } else {
12613                        Log.i(TAG, "Deleting stale container for " + cid);
12614                        removeCids.add(cid);
12615                    }
12616                }
12617            }
12618
12619            if (num > 0) {
12620                // Sort uid list
12621                Arrays.sort(uidList, 0, num);
12622                // Throw away duplicates
12623                uidArr = new int[num];
12624                uidArr[0] = uidList[0];
12625                int di = 0;
12626                for (int i = 1; i < num; i++) {
12627                    if (uidList[i - 1] != uidList[i]) {
12628                        uidArr[di++] = uidList[i];
12629                    }
12630                }
12631            }
12632        }
12633        // Process packages with valid entries.
12634        if (isMounted) {
12635            if (DEBUG_SD_INSTALL)
12636                Log.i(TAG, "Loading packages");
12637            loadMediaPackages(processCids, uidArr, removeCids);
12638            startCleaningPackages();
12639        } else {
12640            if (DEBUG_SD_INSTALL)
12641                Log.i(TAG, "Unloading packages");
12642            unloadMediaPackages(processCids, uidArr, reportStatus);
12643        }
12644    }
12645
12646   private void sendResourcesChangedBroadcast(boolean mediaStatus, boolean replacing,
12647           ArrayList<String> pkgList, int uidArr[], IIntentReceiver finishedReceiver) {
12648        int size = pkgList.size();
12649        if (size > 0) {
12650            // Send broadcasts here
12651            Bundle extras = new Bundle();
12652            extras.putStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST, pkgList
12653                    .toArray(new String[size]));
12654            if (uidArr != null) {
12655                extras.putIntArray(Intent.EXTRA_CHANGED_UID_LIST, uidArr);
12656            }
12657            if (replacing) {
12658                extras.putBoolean(Intent.EXTRA_REPLACING, replacing);
12659            }
12660            String action = mediaStatus ? Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE
12661                    : Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE;
12662            sendPackageBroadcast(action, null, extras, null, finishedReceiver, null);
12663        }
12664    }
12665
12666   /*
12667     * Look at potentially valid container ids from processCids If package
12668     * information doesn't match the one on record or package scanning fails,
12669     * the cid is added to list of removeCids. We currently don't delete stale
12670     * containers.
12671     */
12672   private void loadMediaPackages(HashMap<AsecInstallArgs, String> processCids, int uidArr[],
12673            HashSet<String> removeCids) {
12674        ArrayList<String> pkgList = new ArrayList<String>();
12675        Set<AsecInstallArgs> keys = processCids.keySet();
12676        boolean doGc = false;
12677        for (AsecInstallArgs args : keys) {
12678            String codePath = processCids.get(args);
12679            if (DEBUG_SD_INSTALL)
12680                Log.i(TAG, "Loading container : " + args.cid);
12681            int retCode = PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
12682            try {
12683                // Make sure there are no container errors first.
12684                if (args.doPreInstall(PackageManager.INSTALL_SUCCEEDED) != PackageManager.INSTALL_SUCCEEDED) {
12685                    Slog.e(TAG, "Failed to mount cid : " + args.cid
12686                            + " when installing from sdcard");
12687                    continue;
12688                }
12689                // Check code path here.
12690                if (codePath == null || !codePath.equals(args.getCodePath())) {
12691                    Slog.e(TAG, "Container " + args.cid + " cachepath " + args.getCodePath()
12692                            + " does not match one in settings " + codePath);
12693                    continue;
12694                }
12695                // Parse package
12696                int parseFlags = mDefParseFlags;
12697                if (args.isExternal()) {
12698                    parseFlags |= PackageParser.PARSE_ON_SDCARD;
12699                }
12700                if (args.isFwdLocked()) {
12701                    parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
12702                }
12703
12704                doGc = true;
12705                synchronized (mInstallLock) {
12706                    PackageParser.Package pkg = null;
12707                    try {
12708                        pkg = scanPackageLI(new File(codePath), parseFlags, 0, 0, null, null);
12709                    } catch (PackageManagerException e) {
12710                        Slog.w(TAG, "Failed to scan " + codePath + ": " + e.getMessage());
12711                    }
12712                    // Scan the package
12713                    if (pkg != null) {
12714                        /*
12715                         * TODO why is the lock being held? doPostInstall is
12716                         * called in other places without the lock. This needs
12717                         * to be straightened out.
12718                         */
12719                        // writer
12720                        synchronized (mPackages) {
12721                            retCode = PackageManager.INSTALL_SUCCEEDED;
12722                            pkgList.add(pkg.packageName);
12723                            // Post process args
12724                            args.doPostInstall(PackageManager.INSTALL_SUCCEEDED,
12725                                    pkg.applicationInfo.uid);
12726                        }
12727                    } else {
12728                        Slog.i(TAG, "Failed to install pkg from  " + codePath + " from sdcard");
12729                    }
12730                }
12731
12732            } finally {
12733                if (retCode != PackageManager.INSTALL_SUCCEEDED) {
12734                    // Don't destroy container here. Wait till gc clears things
12735                    // up.
12736                    removeCids.add(args.cid);
12737                }
12738            }
12739        }
12740        // writer
12741        synchronized (mPackages) {
12742            // If the platform SDK has changed since the last time we booted,
12743            // we need to re-grant app permission to catch any new ones that
12744            // appear. This is really a hack, and means that apps can in some
12745            // cases get permissions that the user didn't initially explicitly
12746            // allow... it would be nice to have some better way to handle
12747            // this situation.
12748            final boolean regrantPermissions = mSettings.mExternalSdkPlatform != mSdkVersion;
12749            if (regrantPermissions)
12750                Slog.i(TAG, "Platform changed from " + mSettings.mExternalSdkPlatform + " to "
12751                        + mSdkVersion + "; regranting permissions for external storage");
12752            mSettings.mExternalSdkPlatform = mSdkVersion;
12753
12754            // Make sure group IDs have been assigned, and any permission
12755            // changes in other apps are accounted for
12756            updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL
12757                    | (regrantPermissions
12758                            ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL)
12759                            : 0));
12760
12761            mSettings.updateExternalDatabaseVersion();
12762
12763            // can downgrade to reader
12764            // Persist settings
12765            mSettings.writeLPr();
12766        }
12767        // Send a broadcast to let everyone know we are done processing
12768        if (pkgList.size() > 0) {
12769            sendResourcesChangedBroadcast(true, false, pkgList, uidArr, null);
12770        }
12771        // Force gc to avoid any stale parser references that we might have.
12772        if (doGc) {
12773            Runtime.getRuntime().gc();
12774        }
12775        // List stale containers and destroy stale temporary containers.
12776        if (removeCids != null) {
12777            for (String cid : removeCids) {
12778                if (cid.startsWith(mTempContainerPrefix)) {
12779                    Log.i(TAG, "Destroying stale temporary container " + cid);
12780                    PackageHelper.destroySdDir(cid);
12781                } else {
12782                    Log.w(TAG, "Container " + cid + " is stale");
12783               }
12784           }
12785        }
12786    }
12787
12788   /*
12789     * Utility method to unload a list of specified containers
12790     */
12791    private void unloadAllContainers(Set<AsecInstallArgs> cidArgs) {
12792        // Just unmount all valid containers.
12793        for (AsecInstallArgs arg : cidArgs) {
12794            synchronized (mInstallLock) {
12795                arg.doPostDeleteLI(false);
12796           }
12797       }
12798   }
12799
12800    /*
12801     * Unload packages mounted on external media. This involves deleting package
12802     * data from internal structures, sending broadcasts about diabled packages,
12803     * gc'ing to free up references, unmounting all secure containers
12804     * corresponding to packages on external media, and posting a
12805     * UPDATED_MEDIA_STATUS message if status has been requested. Please note
12806     * that we always have to post this message if status has been requested no
12807     * matter what.
12808     */
12809    private void unloadMediaPackages(HashMap<AsecInstallArgs, String> processCids, int uidArr[],
12810            final boolean reportStatus) {
12811        if (DEBUG_SD_INSTALL)
12812            Log.i(TAG, "unloading media packages");
12813        ArrayList<String> pkgList = new ArrayList<String>();
12814        ArrayList<AsecInstallArgs> failedList = new ArrayList<AsecInstallArgs>();
12815        final Set<AsecInstallArgs> keys = processCids.keySet();
12816        for (AsecInstallArgs args : keys) {
12817            String pkgName = args.getPackageName();
12818            if (DEBUG_SD_INSTALL)
12819                Log.i(TAG, "Trying to unload pkg : " + pkgName);
12820            // Delete package internally
12821            PackageRemovedInfo outInfo = new PackageRemovedInfo();
12822            synchronized (mInstallLock) {
12823                boolean res = deletePackageLI(pkgName, null, false, null, null,
12824                        PackageManager.DELETE_KEEP_DATA, outInfo, false);
12825                if (res) {
12826                    pkgList.add(pkgName);
12827                } else {
12828                    Slog.e(TAG, "Failed to delete pkg from sdcard : " + pkgName);
12829                    failedList.add(args);
12830                }
12831            }
12832        }
12833
12834        // reader
12835        synchronized (mPackages) {
12836            // We didn't update the settings after removing each package;
12837            // write them now for all packages.
12838            mSettings.writeLPr();
12839        }
12840
12841        // We have to absolutely send UPDATED_MEDIA_STATUS only
12842        // after confirming that all the receivers processed the ordered
12843        // broadcast when packages get disabled, force a gc to clean things up.
12844        // and unload all the containers.
12845        if (pkgList.size() > 0) {
12846            sendResourcesChangedBroadcast(false, false, pkgList, uidArr,
12847                    new IIntentReceiver.Stub() {
12848                public void performReceive(Intent intent, int resultCode, String data,
12849                        Bundle extras, boolean ordered, boolean sticky,
12850                        int sendingUser) throws RemoteException {
12851                    Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS,
12852                            reportStatus ? 1 : 0, 1, keys);
12853                    mHandler.sendMessage(msg);
12854                }
12855            });
12856        } else {
12857            Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS, reportStatus ? 1 : 0, -1,
12858                    keys);
12859            mHandler.sendMessage(msg);
12860        }
12861    }
12862
12863    /** Binder call */
12864    @Override
12865    public void movePackage(final String packageName, final IPackageMoveObserver observer,
12866            final int flags) {
12867        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MOVE_PACKAGE, null);
12868        UserHandle user = new UserHandle(UserHandle.getCallingUserId());
12869        int returnCode = PackageManager.MOVE_SUCCEEDED;
12870        int currFlags = 0;
12871        int newFlags = 0;
12872        // reader
12873        synchronized (mPackages) {
12874            PackageParser.Package pkg = mPackages.get(packageName);
12875            if (pkg == null) {
12876                returnCode = PackageManager.MOVE_FAILED_DOESNT_EXIST;
12877            } else {
12878                // Disable moving fwd locked apps and system packages
12879                if (pkg.applicationInfo != null && isSystemApp(pkg)) {
12880                    Slog.w(TAG, "Cannot move system application");
12881                    returnCode = PackageManager.MOVE_FAILED_SYSTEM_PACKAGE;
12882                } else if (pkg.mOperationPending) {
12883                    Slog.w(TAG, "Attempt to move package which has pending operations");
12884                    returnCode = PackageManager.MOVE_FAILED_OPERATION_PENDING;
12885                } else {
12886                    // Find install location first
12887                    if ((flags & PackageManager.MOVE_EXTERNAL_MEDIA) != 0
12888                            && (flags & PackageManager.MOVE_INTERNAL) != 0) {
12889                        Slog.w(TAG, "Ambigous flags specified for move location.");
12890                        returnCode = PackageManager.MOVE_FAILED_INVALID_LOCATION;
12891                    } else {
12892                        newFlags = (flags & PackageManager.MOVE_EXTERNAL_MEDIA) != 0 ? PackageManager.INSTALL_EXTERNAL
12893                                : PackageManager.INSTALL_INTERNAL;
12894                        currFlags = isExternal(pkg) ? PackageManager.INSTALL_EXTERNAL
12895                                : PackageManager.INSTALL_INTERNAL;
12896
12897                        if (newFlags == currFlags) {
12898                            Slog.w(TAG, "No move required. Trying to move to same location");
12899                            returnCode = PackageManager.MOVE_FAILED_INVALID_LOCATION;
12900                        } else {
12901                            if (isForwardLocked(pkg)) {
12902                                currFlags |= PackageManager.INSTALL_FORWARD_LOCK;
12903                                newFlags |= PackageManager.INSTALL_FORWARD_LOCK;
12904                            }
12905                        }
12906                    }
12907                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
12908                        pkg.mOperationPending = true;
12909                    }
12910                }
12911            }
12912
12913            /*
12914             * TODO this next block probably shouldn't be inside the lock. We
12915             * can't guarantee these won't change after this is fired off
12916             * anyway.
12917             */
12918            if (returnCode != PackageManager.MOVE_SUCCEEDED) {
12919                processPendingMove(new MoveParams(null, observer, 0, packageName, null, -1, user, false),
12920                        returnCode);
12921            } else {
12922                Message msg = mHandler.obtainMessage(INIT_COPY);
12923                final String[] instructionSets = getAppDexInstructionSets(pkg.applicationInfo);
12924                final boolean multiArch = isMultiArch(pkg.applicationInfo);
12925                InstallArgs srcArgs = createInstallArgsForExisting(currFlags,
12926                        pkg.applicationInfo.getCodePath(), pkg.applicationInfo.getResourcePath(),
12927                        pkg.applicationInfo.nativeLibraryRootDir, instructionSets, multiArch);
12928                MoveParams mp = new MoveParams(srcArgs, observer, newFlags, packageName,
12929                        instructionSets, pkg.applicationInfo.uid, user, multiArch);
12930                msg.obj = mp;
12931                mHandler.sendMessage(msg);
12932            }
12933        }
12934    }
12935
12936    private void processPendingMove(final MoveParams mp, final int currentStatus) {
12937        // Queue up an async operation since the package deletion may take a
12938        // little while.
12939        mHandler.post(new Runnable() {
12940            public void run() {
12941                // TODO fix this; this does nothing.
12942                mHandler.removeCallbacks(this);
12943                int returnCode = currentStatus;
12944                if (currentStatus == PackageManager.MOVE_SUCCEEDED) {
12945                    int uidArr[] = null;
12946                    ArrayList<String> pkgList = null;
12947                    synchronized (mPackages) {
12948                        PackageParser.Package pkg = mPackages.get(mp.packageName);
12949                        if (pkg == null) {
12950                            Slog.w(TAG, " Package " + mp.packageName
12951                                    + " doesn't exist. Aborting move");
12952                            returnCode = PackageManager.MOVE_FAILED_DOESNT_EXIST;
12953                        } else if (!mp.srcArgs.getCodePath().equals(
12954                                pkg.applicationInfo.getCodePath())) {
12955                            Slog.w(TAG, "Package " + mp.packageName + " code path changed from "
12956                                    + mp.srcArgs.getCodePath() + " to "
12957                                    + pkg.applicationInfo.getCodePath()
12958                                    + " Aborting move and returning error");
12959                            returnCode = PackageManager.MOVE_FAILED_INTERNAL_ERROR;
12960                        } else {
12961                            uidArr = new int[] {
12962                                pkg.applicationInfo.uid
12963                            };
12964                            pkgList = new ArrayList<String>();
12965                            pkgList.add(mp.packageName);
12966                        }
12967                    }
12968                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
12969                        // Send resources unavailable broadcast
12970                        sendResourcesChangedBroadcast(false, true, pkgList, uidArr, null);
12971                        // Update package code and resource paths
12972                        synchronized (mInstallLock) {
12973                            synchronized (mPackages) {
12974                                PackageParser.Package pkg = mPackages.get(mp.packageName);
12975                                // Recheck for package again.
12976                                if (pkg == null) {
12977                                    Slog.w(TAG, " Package " + mp.packageName
12978                                            + " doesn't exist. Aborting move");
12979                                    returnCode = PackageManager.MOVE_FAILED_DOESNT_EXIST;
12980                                } else if (!mp.srcArgs.getCodePath().equals(
12981                                        pkg.applicationInfo.getCodePath())) {
12982                                    Slog.w(TAG, "Package " + mp.packageName
12983                                            + " code path changed from " + mp.srcArgs.getCodePath()
12984                                            + " to " + pkg.applicationInfo.getCodePath()
12985                                            + " Aborting move and returning error");
12986                                    returnCode = PackageManager.MOVE_FAILED_INTERNAL_ERROR;
12987                                } else {
12988                                    final String oldCodePath = pkg.codePath;
12989                                    final String newCodePath = mp.targetArgs.getCodePath();
12990                                    final String newResPath = mp.targetArgs.getResourcePath();
12991                                    // TODO: This assumes the new style of installation.
12992                                    // should we look at legacyNativeLibraryPath ?
12993                                    final String newNativeRoot = new File(pkg.codePath, LIB_DIR_NAME).getAbsolutePath();
12994                                    final File newNativeDir = new File(newNativeRoot);
12995
12996                                    if (!isForwardLocked(pkg) && !isExternal(pkg)) {
12997                                        // TODO(multiArch): Fix this so that it looks at the existing
12998                                        // recorded CPU abis from the package. There's no need for a separate
12999                                        // round of ABI scanning here.
13000                                        NativeLibraryHelper.Handle handle = null;
13001                                        try {
13002                                            handle = NativeLibraryHelper.Handle.create(
13003                                                    new File(newCodePath));
13004                                            final int abi = NativeLibraryHelper.findSupportedAbi(
13005                                                    handle, Build.SUPPORTED_ABIS);
13006                                            if (abi >= 0) {
13007                                                NativeLibraryHelper.copyNativeBinariesIfNeededLI(
13008                                                        handle, newNativeDir, Build.SUPPORTED_ABIS[abi]);
13009                                            }
13010                                        } catch (IOException ioe) {
13011                                            Slog.w(TAG, "Unable to extract native libs for package :"
13012                                                    + mp.packageName, ioe);
13013                                            returnCode = PackageManager.MOVE_FAILED_INTERNAL_ERROR;
13014                                        } finally {
13015                                            IoUtils.closeQuietly(handle);
13016                                        }
13017                                    }
13018
13019                                    final int[] users = sUserManager.getUserIds();
13020                                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
13021                                        for (int user : users) {
13022                                            // TODO(multiArch): Fix this so that it links to the
13023                                            // correct directory. We're currently pointing to root. but we
13024                                            // must point to the arch specific subdirectory (if applicable).
13025                                            //
13026                                            // TODO(multiArch): Bogus reference to nativeLibraryDir.
13027                                            if (mInstaller.linkNativeLibraryDirectory(pkg.packageName,
13028                                                    newNativeRoot, user) < 0) {
13029                                                returnCode = PackageManager.MOVE_FAILED_INSUFFICIENT_STORAGE;
13030                                            }
13031                                        }
13032                                    }
13033
13034                                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
13035                                        pkg.codePath = newCodePath;
13036                                        pkg.baseCodePath = newCodePath;
13037                                        // Move dex files around
13038                                        if (moveDexFilesLI(oldCodePath, pkg) != PackageManager.INSTALL_SUCCEEDED) {
13039                                            // Moving of dex files failed. Set
13040                                            // error code and abort move.
13041                                            pkg.codePath = oldCodePath;
13042                                            pkg.baseCodePath = oldCodePath;
13043                                            returnCode = PackageManager.MOVE_FAILED_INSUFFICIENT_STORAGE;
13044                                        }
13045                                    }
13046
13047                                    if (returnCode == PackageManager.MOVE_SUCCEEDED) {
13048                                        pkg.applicationInfo.setCodePath(newCodePath);
13049                                        pkg.applicationInfo.setBaseCodePath(newCodePath);
13050                                        pkg.applicationInfo.setSplitCodePaths(null);
13051                                        pkg.applicationInfo.setResourcePath(newResPath);
13052                                        pkg.applicationInfo.setBaseResourcePath(newResPath);
13053                                        pkg.applicationInfo.setSplitResourcePaths(null);
13054
13055                                        PackageSetting ps = (PackageSetting) pkg.mExtras;
13056                                        ps.codePath = new File(pkg.applicationInfo.getCodePath());
13057                                        ps.codePathString = ps.codePath.getPath();
13058                                        ps.resourcePath = new File(pkg.applicationInfo.getResourcePath());
13059                                        ps.resourcePathString = ps.resourcePath.getPath();
13060
13061                                        // Note that we don't have to recalculate the primary and secondary
13062                                        // CPU ABIs because they must already have been calculated during the
13063                                        // initial install of the app.
13064                                        ps.legacyNativeLibraryPathString = null;
13065
13066                                        // Set the application info flag
13067                                        // correctly.
13068                                        if ((mp.flags & PackageManager.INSTALL_EXTERNAL) != 0) {
13069                                            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_EXTERNAL_STORAGE;
13070                                        } else {
13071                                            pkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_EXTERNAL_STORAGE;
13072                                        }
13073                                        ps.setFlags(pkg.applicationInfo.flags);
13074                                        mAppDirs.remove(oldCodePath);
13075                                        mAppDirs.put(newCodePath, pkg);
13076                                        // Persist settings
13077                                        mSettings.writeLPr();
13078                                    }
13079                                }
13080                            }
13081                        }
13082                        // Send resources available broadcast
13083                        sendResourcesChangedBroadcast(true, false, pkgList, uidArr, null);
13084                    }
13085                }
13086                if (returnCode != PackageManager.MOVE_SUCCEEDED) {
13087                    // Clean up failed installation
13088                    if (mp.targetArgs != null) {
13089                        mp.targetArgs.doPostInstall(PackageManager.INSTALL_FAILED_INTERNAL_ERROR,
13090                                -1);
13091                    }
13092                } else {
13093                    // Force a gc to clear things up.
13094                    Runtime.getRuntime().gc();
13095                    // Delete older code
13096                    synchronized (mInstallLock) {
13097                        mp.srcArgs.doPostDeleteLI(true);
13098                    }
13099                }
13100
13101                // Allow more operations on this file if we didn't fail because
13102                // an operation was already pending for this package.
13103                if (returnCode != PackageManager.MOVE_FAILED_OPERATION_PENDING) {
13104                    synchronized (mPackages) {
13105                        PackageParser.Package pkg = mPackages.get(mp.packageName);
13106                        if (pkg != null) {
13107                            pkg.mOperationPending = false;
13108                       }
13109                   }
13110                }
13111
13112                IPackageMoveObserver observer = mp.observer;
13113                if (observer != null) {
13114                    try {
13115                        observer.packageMoved(mp.packageName, returnCode);
13116                    } catch (RemoteException e) {
13117                        Log.i(TAG, "Observer no longer exists.");
13118                    }
13119                }
13120            }
13121        });
13122    }
13123
13124    @Override
13125    public boolean setInstallLocation(int loc) {
13126        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WRITE_SECURE_SETTINGS,
13127                null);
13128        if (getInstallLocation() == loc) {
13129            return true;
13130        }
13131        if (loc == PackageHelper.APP_INSTALL_AUTO || loc == PackageHelper.APP_INSTALL_INTERNAL
13132                || loc == PackageHelper.APP_INSTALL_EXTERNAL) {
13133            android.provider.Settings.Global.putInt(mContext.getContentResolver(),
13134                    android.provider.Settings.Global.DEFAULT_INSTALL_LOCATION, loc);
13135            return true;
13136        }
13137        return false;
13138   }
13139
13140    @Override
13141    public int getInstallLocation() {
13142        return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
13143                android.provider.Settings.Global.DEFAULT_INSTALL_LOCATION,
13144                PackageHelper.APP_INSTALL_AUTO);
13145    }
13146
13147    /** Called by UserManagerService */
13148    void cleanUpUserLILPw(int userHandle) {
13149        mDirtyUsers.remove(userHandle);
13150        mSettings.removeUserLPw(userHandle);
13151        mPendingBroadcasts.remove(userHandle);
13152        if (mInstaller != null) {
13153            // Technically, we shouldn't be doing this with the package lock
13154            // held.  However, this is very rare, and there is already so much
13155            // other disk I/O going on, that we'll let it slide for now.
13156            mInstaller.removeUserDataDirs(userHandle);
13157        }
13158        mUserNeedsBadging.delete(userHandle);
13159    }
13160
13161    /** Called by UserManagerService */
13162    void createNewUserLILPw(int userHandle, File path) {
13163        if (mInstaller != null) {
13164            mInstaller.createUserConfig(userHandle);
13165            mSettings.createNewUserLILPw(this, mInstaller, userHandle, path);
13166        }
13167    }
13168
13169    @Override
13170    public VerifierDeviceIdentity getVerifierDeviceIdentity() throws RemoteException {
13171        mContext.enforceCallingOrSelfPermission(
13172                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
13173                "Only package verification agents can read the verifier device identity");
13174
13175        synchronized (mPackages) {
13176            return mSettings.getVerifierDeviceIdentityLPw();
13177        }
13178    }
13179
13180    @Override
13181    public void setPermissionEnforced(String permission, boolean enforced) {
13182        mContext.enforceCallingOrSelfPermission(GRANT_REVOKE_PERMISSIONS, null);
13183        if (READ_EXTERNAL_STORAGE.equals(permission)) {
13184            synchronized (mPackages) {
13185                if (mSettings.mReadExternalStorageEnforced == null
13186                        || mSettings.mReadExternalStorageEnforced != enforced) {
13187                    mSettings.mReadExternalStorageEnforced = enforced;
13188                    mSettings.writeLPr();
13189                }
13190            }
13191            // kill any non-foreground processes so we restart them and
13192            // grant/revoke the GID.
13193            final IActivityManager am = ActivityManagerNative.getDefault();
13194            if (am != null) {
13195                final long token = Binder.clearCallingIdentity();
13196                try {
13197                    am.killProcessesBelowForeground("setPermissionEnforcement");
13198                } catch (RemoteException e) {
13199                } finally {
13200                    Binder.restoreCallingIdentity(token);
13201                }
13202            }
13203        } else {
13204            throw new IllegalArgumentException("No selective enforcement for " + permission);
13205        }
13206    }
13207
13208    @Override
13209    @Deprecated
13210    public boolean isPermissionEnforced(String permission) {
13211        return true;
13212    }
13213
13214    @Override
13215    public boolean isStorageLow() {
13216        final long token = Binder.clearCallingIdentity();
13217        try {
13218            final DeviceStorageMonitorInternal
13219                    dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
13220            if (dsm != null) {
13221                return dsm.isMemoryLow();
13222            } else {
13223                return false;
13224            }
13225        } finally {
13226            Binder.restoreCallingIdentity(token);
13227        }
13228    }
13229
13230    @Override
13231    public IPackageInstaller getPackageInstaller() {
13232        return mInstallerService;
13233    }
13234
13235    private boolean userNeedsBadging(int userId) {
13236        int index = mUserNeedsBadging.indexOfKey(userId);
13237        if (index < 0) {
13238            final UserInfo userInfo;
13239            final long token = Binder.clearCallingIdentity();
13240            try {
13241                userInfo = sUserManager.getUserInfo(userId);
13242            } finally {
13243                Binder.restoreCallingIdentity(token);
13244            }
13245            final boolean b;
13246            if (userInfo != null && userInfo.isManagedProfile()) {
13247                b = true;
13248            } else {
13249                b = false;
13250            }
13251            mUserNeedsBadging.put(userId, b);
13252            return b;
13253        }
13254        return mUserNeedsBadging.valueAt(index);
13255    }
13256
13257    @Override
13258    public KeySetHandle getKeySetByAlias(String packageName, String alias) {
13259        if (packageName == null || alias == null) {
13260            return null;
13261        }
13262        synchronized(mPackages) {
13263            final PackageParser.Package pkg = mPackages.get(packageName);
13264            if (pkg == null) {
13265                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13266                throw new IllegalArgumentException("Unknown package: " + packageName);
13267            }
13268            if (pkg.applicationInfo.uid != Binder.getCallingUid()
13269                    && Process.SYSTEM_UID != Binder.getCallingUid()) {
13270                throw new SecurityException("May not access KeySets defined by"
13271                        + " aliases in other applications.");
13272            }
13273            KeySetManagerService ksms = mSettings.mKeySetManagerService;
13274            return ksms.getKeySetByAliasAndPackageNameLPr(packageName, alias);
13275        }
13276    }
13277
13278    @Override
13279    public KeySetHandle getSigningKeySet(String packageName) {
13280        if (packageName == null) {
13281            return null;
13282        }
13283        synchronized(mPackages) {
13284            final PackageParser.Package pkg = mPackages.get(packageName);
13285            if (pkg == null) {
13286                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13287                throw new IllegalArgumentException("Unknown package: " + packageName);
13288            }
13289            if (pkg.applicationInfo.uid != Binder.getCallingUid()
13290                    && Process.SYSTEM_UID != Binder.getCallingUid()) {
13291                throw new SecurityException("May not access signing KeySet of other apps.");
13292            }
13293            KeySetManagerService ksms = mSettings.mKeySetManagerService;
13294            return ksms.getSigningKeySetByPackageNameLPr(packageName);
13295        }
13296    }
13297
13298    @Override
13299    public boolean isPackageSignedByKeySet(String packageName, IBinder ks) {
13300        if (packageName == null || ks == null) {
13301            return false;
13302        }
13303        synchronized(mPackages) {
13304            final PackageParser.Package pkg = mPackages.get(packageName);
13305            if (pkg == null) {
13306                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13307                throw new IllegalArgumentException("Unknown package: " + packageName);
13308            }
13309            if (ks instanceof KeySetHandle) {
13310                KeySetManagerService ksms = mSettings.mKeySetManagerService;
13311                return ksms.packageIsSignedByLPr(packageName, (KeySetHandle) ks);
13312            }
13313            return false;
13314        }
13315    }
13316
13317    @Override
13318    public boolean isPackageSignedByKeySetExactly(String packageName, IBinder ks) {
13319        if (packageName == null || ks == null) {
13320            return false;
13321        }
13322        synchronized(mPackages) {
13323            final PackageParser.Package pkg = mPackages.get(packageName);
13324            if (pkg == null) {
13325                Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
13326                throw new IllegalArgumentException("Unknown package: " + packageName);
13327            }
13328            if (ks instanceof KeySetHandle) {
13329                KeySetManagerService ksms = mSettings.mKeySetManagerService;
13330                return ksms.packageIsSignedByExactlyLPr(packageName, (KeySetHandle) ks);
13331            }
13332            return false;
13333        }
13334    }
13335}
13336