Examples with IntentFilterVerificationInfo android.content.pm.IntentFilterVerificationInfo used on opensource projects

Example 16 with IntentFilterVerificationInfo

use of android.content.pm.IntentFilterVerificationInfo in project android_frameworks_base by DirtyUnicorns.

the class PackageManagerService method needsNetworkVerificationLPr.

private boolean needsNetworkVerificationLPr(ActivityIntentInfo filter) {
    final ComponentName cn = filter.activity.getComponentName();
    final String packageName = cn.getPackageName();
    IntentFilterVerificationInfo ivi = mSettings.getIntentFilterVerificationLPr(packageName);
    if (ivi == null) {
        return true;
    }
    int status = ivi.getStatus();
    switch(status) {
        case INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED:
        case INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK:
            return true;
        default:
            // Nothing to do
            return false;
    }
}

Example 17 with IntentFilterVerificationInfo

use of android.content.pm.IntentFilterVerificationInfo in project android_frameworks_base by DirtyUnicorns.

the class PackageManagerService method dump.

@Override
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
    if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) != PackageManager.PERMISSION_GRANTED) {
        pw.println("Permission Denial: can't dump ActivityManager from from pid=" + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid() + " without permission " + android.Manifest.permission.DUMP);
        return;
    }
    DumpState dumpState = new DumpState();
    boolean fullPreferred = false;
    boolean checkin = false;
    String packageName = null;
    ArraySet<String> permissionNames = null;
    int opti = 0;
    while (opti < args.length) {
        String opt = args[opti];
        if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
            break;
        }
        opti++;
        if ("-a".equals(opt)) {
        // Right now we only know how to print all.
        } else if ("-h".equals(opt)) {
            pw.println("Package manager dump options:");
            pw.println("  [-h] [-f] [--checkin] [cmd] ...");
            pw.println("    --checkin: dump for a checkin");
            pw.println("    -f: print details of intent filters");
            pw.println("    -h: print this help");
            pw.println("  cmd may be one of:");
            pw.println("    l[ibraries]: list known shared libraries");
            pw.println("    f[eatures]: list device features");
            pw.println("    k[eysets]: print known keysets");
            pw.println("    r[esolvers] [activity|service|receiver|content]: dump intent resolvers");
            pw.println("    perm[issions]: dump permissions");
            pw.println("    permission [name ...]: dump declaration and use of given permission");
            pw.println("    pref[erred]: print preferred package settings");
            pw.println("    preferred-xml [--full]: print preferred package settings as xml");
            pw.println("    prov[iders]: dump content providers");
            pw.println("    p[ackages]: dump installed packages");
            pw.println("    s[hared-users]: dump shared user IDs");
            pw.println("    m[essages]: print collected runtime messages");
            pw.println("    v[erifiers]: print package verifier info");
            pw.println("    d[omain-preferred-apps]: print domains preferred apps");
            pw.println("    i[ntent-filter-verifiers]|ifv: print intent filter verifier info");
            pw.println("    version: print database version info");
            pw.println("    write: write current settings now");
            pw.println("    installs: details about install sessions");
            pw.println("    check-permission <permission> <package> [<user>]: does pkg hold perm?");
            pw.println("    dexopt: dump dexopt state");
            pw.println("    compiler-stats: dump compiler statistics");
            pw.println("    <package.name>: info about given package");
            return;
        } else if ("--checkin".equals(opt)) {
            checkin = true;
        } else if ("-f".equals(opt)) {
            dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
        } else {
            pw.println("Unknown argument: " + opt + "; use -h for help");
        }
    }
    // Is the caller requesting to dump a particular piece of data?
    if (opti < args.length) {
        String cmd = args[opti];
        opti++;
        // Is this a package name?
        if ("android".equals(cmd) || cmd.contains(".")) {
            packageName = cmd;
            // When dumping a single package, we always dump all of its
            // filter information since the amount of data will be reasonable.
            dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
        } else if ("check-permission".equals(cmd)) {
            if (opti >= args.length) {
                pw.println("Error: check-permission missing permission argument");
                return;
            }
            String perm = args[opti];
            opti++;
            if (opti >= args.length) {
                pw.println("Error: check-permission missing package argument");
                return;
            }
            String pkg = args[opti];
            opti++;
            int user = UserHandle.getUserId(Binder.getCallingUid());
            if (opti < args.length) {
                try {
                    user = Integer.parseInt(args[opti]);
                } catch (NumberFormatException e) {
                    pw.println("Error: check-permission user argument is not a number: " + args[opti]);
                    return;
                }
            }
            pw.println(checkPermission(perm, pkg, user));
            return;
        } else if ("l".equals(cmd) || "libraries".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_LIBS);
        } else if ("f".equals(cmd) || "features".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_FEATURES);
        } else if ("r".equals(cmd) || "resolvers".equals(cmd)) {
            if (opti >= args.length) {
                dumpState.setDump(DumpState.DUMP_ACTIVITY_RESOLVERS | DumpState.DUMP_SERVICE_RESOLVERS | DumpState.DUMP_RECEIVER_RESOLVERS | DumpState.DUMP_CONTENT_RESOLVERS);
            } else {
                while (opti < args.length) {
                    String name = args[opti];
                    if ("a".equals(name) || "activity".equals(name)) {
                        dumpState.setDump(DumpState.DUMP_ACTIVITY_RESOLVERS);
                    } else if ("s".equals(name) || "service".equals(name)) {
                        dumpState.setDump(DumpState.DUMP_SERVICE_RESOLVERS);
                    } else if ("r".equals(name) || "receiver".equals(name)) {
                        dumpState.setDump(DumpState.DUMP_RECEIVER_RESOLVERS);
                    } else if ("c".equals(name) || "content".equals(name)) {
                        dumpState.setDump(DumpState.DUMP_CONTENT_RESOLVERS);
                    } else {
                        pw.println("Error: unknown resolver table type: " + name);
                        return;
                    }
                    opti++;
                }
            }
        } else if ("perm".equals(cmd) || "permissions".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PERMISSIONS);
        } else if ("permission".equals(cmd)) {
            if (opti >= args.length) {
                pw.println("Error: permission requires permission name");
                return;
            }
            permissionNames = new ArraySet<>();
            while (opti < args.length) {
                permissionNames.add(args[opti]);
                opti++;
            }
            dumpState.setDump(DumpState.DUMP_PERMISSIONS | DumpState.DUMP_PACKAGES | DumpState.DUMP_SHARED_USERS);
        } else if ("pref".equals(cmd) || "preferred".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PREFERRED);
        } else if ("preferred-xml".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PREFERRED_XML);
            if (opti < args.length && "--full".equals(args[opti])) {
                fullPreferred = true;
                opti++;
            }
        } else if ("d".equals(cmd) || "domain-preferred-apps".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_DOMAIN_PREFERRED);
        } else if ("p".equals(cmd) || "packages".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PACKAGES);
        } else if ("s".equals(cmd) || "shared-users".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_SHARED_USERS);
        } else if ("prov".equals(cmd) || "providers".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PROVIDERS);
        } else if ("m".equals(cmd) || "messages".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_MESSAGES);
        } else if ("v".equals(cmd) || "verifiers".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_VERIFIERS);
        } else if ("i".equals(cmd) || "ifv".equals(cmd) || "intent-filter-verifiers".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_INTENT_FILTER_VERIFIERS);
        } else if ("version".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_VERSION);
        } else if ("k".equals(cmd) || "keysets".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_KEYSETS);
        } else if ("installs".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_INSTALLS);
        } else if ("frozen".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_FROZEN);
        } else if ("dexopt".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_DEXOPT);
        } else if ("compiler-stats".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_COMPILER_STATS);
        } else if ("write".equals(cmd)) {
            synchronized (mPackages) {
                mSettings.writeLPr();
                pw.println("Settings written.");
                return;
            }
        }
    }
    if (checkin) {
        pw.println("vers,1");
    }
    // reader
    synchronized (mPackages) {
        if (dumpState.isDumping(DumpState.DUMP_VERSION) && packageName == null) {
            if (!checkin) {
                if (dumpState.onTitlePrinted())
                    pw.println();
                pw.println("Database versions:");
                mSettings.dumpVersionLPr(new IndentingPrintWriter(pw, "  "));
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_VERIFIERS) && packageName == null) {
            if (!checkin) {
                if (dumpState.onTitlePrinted())
                    pw.println();
                pw.println("Verifiers:");
                pw.print("  Required: ");
                pw.print(mRequiredVerifierPackage);
                pw.print(" (uid=");
                pw.print(getPackageUid(mRequiredVerifierPackage, MATCH_DEBUG_TRIAGED_MISSING, UserHandle.USER_SYSTEM));
                pw.println(")");
            } else if (mRequiredVerifierPackage != null) {
                pw.print("vrfy,");
                pw.print(mRequiredVerifierPackage);
                pw.print(",");
                pw.println(getPackageUid(mRequiredVerifierPackage, MATCH_DEBUG_TRIAGED_MISSING, UserHandle.USER_SYSTEM));
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_INTENT_FILTER_VERIFIERS) && packageName == null) {
            if (mIntentFilterVerifierComponent != null) {
                String verifierPackageName = mIntentFilterVerifierComponent.getPackageName();
                if (!checkin) {
                    if (dumpState.onTitlePrinted())
                        pw.println();
                    pw.println("Intent Filter Verifier:");
                    pw.print("  Using: ");
                    pw.print(verifierPackageName);
                    pw.print(" (uid=");
                    pw.print(getPackageUid(verifierPackageName, MATCH_DEBUG_TRIAGED_MISSING, UserHandle.USER_SYSTEM));
                    pw.println(")");
                } else if (verifierPackageName != null) {
                    pw.print("ifv,");
                    pw.print(verifierPackageName);
                    pw.print(",");
                    pw.println(getPackageUid(verifierPackageName, MATCH_DEBUG_TRIAGED_MISSING, UserHandle.USER_SYSTEM));
                }
            } else {
                pw.println();
                pw.println("No Intent Filter Verifier available!");
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_LIBS) && packageName == null) {
            boolean printedHeader = false;
            final Iterator<String> it = mSharedLibraries.keySet().iterator();
            while (it.hasNext()) {
                String name = it.next();
                SharedLibraryEntry ent = mSharedLibraries.get(name);
                if (!checkin) {
                    if (!printedHeader) {
                        if (dumpState.onTitlePrinted())
                            pw.println();
                        pw.println("Libraries:");
                        printedHeader = true;
                    }
                    pw.print("  ");
                } else {
                    pw.print("lib,");
                }
                pw.print(name);
                if (!checkin) {
                    pw.print(" -> ");
                }
                if (ent.path != null) {
                    if (!checkin) {
                        pw.print("(jar) ");
                        pw.print(ent.path);
                    } else {
                        pw.print(",jar,");
                        pw.print(ent.path);
                    }
                } else {
                    if (!checkin) {
                        pw.print("(apk) ");
                        pw.print(ent.apk);
                    } else {
                        pw.print(",apk,");
                        pw.print(ent.apk);
                    }
                }
                pw.println();
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_FEATURES) && packageName == null) {
            if (dumpState.onTitlePrinted())
                pw.println();
            if (!checkin) {
                pw.println("Features:");
            }
            for (FeatureInfo feat : mAvailableFeatures.values()) {
                if (checkin) {
                    pw.print("feat,");
                    pw.print(feat.name);
                    pw.print(",");
                    pw.println(feat.version);
                } else {
                    pw.print("  ");
                    pw.print(feat.name);
                    if (feat.version > 0) {
                        pw.print(" version=");
                        pw.print(feat.version);
                    }
                    pw.println();
                }
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_ACTIVITY_RESOLVERS)) {
            if (mActivities.dump(pw, dumpState.getTitlePrinted() ? "\nActivity Resolver Table:" : "Activity Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_RECEIVER_RESOLVERS)) {
            if (mReceivers.dump(pw, dumpState.getTitlePrinted() ? "\nReceiver Resolver Table:" : "Receiver Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_SERVICE_RESOLVERS)) {
            if (mServices.dump(pw, dumpState.getTitlePrinted() ? "\nService Resolver Table:" : "Service Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_CONTENT_RESOLVERS)) {
            if (mProviders.dump(pw, dumpState.getTitlePrinted() ? "\nProvider Resolver Table:" : "Provider Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED)) {
            for (int i = 0; i < mSettings.mPreferredActivities.size(); i++) {
                PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
                int user = mSettings.mPreferredActivities.keyAt(i);
                if (pir.dump(pw, dumpState.getTitlePrinted() ? "\nPreferred Activities User " + user + ":" : "Preferred Activities User " + user + ":", "  ", packageName, true, false)) {
                    dumpState.setTitlePrinted(true);
                }
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED_XML)) {
            pw.flush();
            FileOutputStream fout = new FileOutputStream(fd);
            BufferedOutputStream str = new BufferedOutputStream(fout);
            XmlSerializer serializer = new FastXmlSerializer();
            try {
                serializer.setOutput(str, StandardCharsets.UTF_8.name());
                serializer.startDocument(null, true);
                serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
                mSettings.writePreferredActivitiesLPr(serializer, 0, fullPreferred);
                serializer.endDocument();
                serializer.flush();
            } catch (IllegalArgumentException e) {
                pw.println("Failed writing: " + e);
            } catch (IllegalStateException e) {
                pw.println("Failed writing: " + e);
            } catch (IOException e) {
                pw.println("Failed writing: " + e);
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_DOMAIN_PREFERRED) && packageName == null) {
            pw.println();
            int count = mSettings.mPackages.size();
            if (count == 0) {
                pw.println("No applications!");
                pw.println();
            } else {
                final String prefix = "  ";
                Collection<PackageSetting> allPackageSettings = mSettings.mPackages.values();
                if (allPackageSettings.size() == 0) {
                    pw.println("No domain preferred apps!");
                    pw.println();
                } else {
                    pw.println("App verification status:");
                    pw.println();
                    count = 0;
                    for (PackageSetting ps : allPackageSettings) {
                        IntentFilterVerificationInfo ivi = ps.getIntentFilterVerificationInfo();
                        if (ivi == null || ivi.getPackageName() == null)
                            continue;
                        pw.println(prefix + "Package: " + ivi.getPackageName());
                        pw.println(prefix + "Domains: " + ivi.getDomainsString());
                        pw.println(prefix + "Status:  " + ivi.getStatusString());
                        pw.println();
                        count++;
                    }
                    if (count == 0) {
                        pw.println(prefix + "No app verification established.");
                        pw.println();
                    }
                    for (int userId : sUserManager.getUserIds()) {
                        pw.println("App linkages for user " + userId + ":");
                        pw.println();
                        count = 0;
                        for (PackageSetting ps : allPackageSettings) {
                            final long status = ps.getDomainVerificationStatusForUser(userId);
                            if (status >> 32 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED) {
                                continue;
                            }
                            pw.println(prefix + "Package: " + ps.name);
                            pw.println(prefix + "Domains: " + dumpDomainString(ps.name));
                            String statusStr = IntentFilterVerificationInfo.getStatusStringFromValue(status);
                            pw.println(prefix + "Status:  " + statusStr);
                            pw.println();
                            count++;
                        }
                        if (count == 0) {
                            pw.println(prefix + "No configured app linkages.");
                            pw.println();
                        }
                    }
                }
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_PERMISSIONS)) {
            mSettings.dumpPermissionsLPr(pw, packageName, permissionNames, dumpState);
            if (packageName == null && permissionNames == null) {
                for (int iperm = 0; iperm < mAppOpPermissionPackages.size(); iperm++) {
                    if (iperm == 0) {
                        if (dumpState.onTitlePrinted())
                            pw.println();
                        pw.println("AppOp Permissions:");
                    }
                    pw.print("  AppOp Permission ");
                    pw.print(mAppOpPermissionPackages.keyAt(iperm));
                    pw.println(":");
                    ArraySet<String> pkgs = mAppOpPermissionPackages.valueAt(iperm);
                    for (int ipkg = 0; ipkg < pkgs.size(); ipkg++) {
                        pw.print("    ");
                        pw.println(pkgs.valueAt(ipkg));
                    }
                }
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_PROVIDERS)) {
            boolean printedSomething = false;
            for (PackageParser.Provider p : mProviders.mProviders.values()) {
                if (packageName != null && !packageName.equals(p.info.packageName)) {
                    continue;
                }
                if (!printedSomething) {
                    if (dumpState.onTitlePrinted())
                        pw.println();
                    pw.println("Registered ContentProviders:");
                    printedSomething = true;
                }
                pw.print("  ");
                p.printComponentShortName(pw);
                pw.println(":");
                pw.print("    ");
                pw.println(p.toString());
            }
            printedSomething = false;
            for (Map.Entry<String, PackageParser.Provider> entry : mProvidersByAuthority.entrySet()) {
                PackageParser.Provider p = entry.getValue();
                if (packageName != null && !packageName.equals(p.info.packageName)) {
                    continue;
                }
                if (!printedSomething) {
                    if (dumpState.onTitlePrinted())
                        pw.println();
                    pw.println("ContentProvider Authorities:");
                    printedSomething = true;
                }
                pw.print("  [");
                pw.print(entry.getKey());
                pw.println("]:");
                pw.print("    ");
                pw.println(p.toString());
                if (p.info != null && p.info.applicationInfo != null) {
                    final String appInfo = p.info.applicationInfo.toString();
                    pw.print("      applicationInfo=");
                    pw.println(appInfo);
                }
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_KEYSETS)) {
            mSettings.mKeySetManagerService.dumpLPr(pw, packageName, dumpState);
        }
        if (dumpState.isDumping(DumpState.DUMP_PACKAGES)) {
            mSettings.dumpPackagesLPr(pw, packageName, permissionNames, dumpState, checkin);
        }
        if (dumpState.isDumping(DumpState.DUMP_SHARED_USERS)) {
            mSettings.dumpSharedUsersLPr(pw, packageName, permissionNames, dumpState, checkin);
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_PERMISSIONS) && packageName == null) {
            mSettings.dumpRestoredPermissionGrantsLPr(pw, dumpState);
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_INSTALLS) && packageName == null) {
            // the given package is involved with.
            if (dumpState.onTitlePrinted())
                pw.println();
            mInstallerService.dump(new IndentingPrintWriter(pw, "  ", 120));
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_FROZEN) && packageName == null) {
            // the given package is involved with.
            if (dumpState.onTitlePrinted())
                pw.println();
            final IndentingPrintWriter ipw = new IndentingPrintWriter(pw, "  ", 120);
            ipw.println();
            ipw.println("Frozen packages:");
            ipw.increaseIndent();
            if (mFrozenPackages.size() == 0) {
                ipw.println("(none)");
            } else {
                for (int i = 0; i < mFrozenPackages.size(); i++) {
                    ipw.println(mFrozenPackages.valueAt(i));
                }
            }
            ipw.decreaseIndent();
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_DEXOPT)) {
            if (dumpState.onTitlePrinted())
                pw.println();
            dumpDexoptStateLPr(pw, packageName);
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_COMPILER_STATS)) {
            if (dumpState.onTitlePrinted())
                pw.println();
            dumpCompilerStatsLPr(pw, packageName);
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES) && packageName == null) {
            if (dumpState.onTitlePrinted())
                pw.println();
            mSettings.dumpReadMessagesLPr(pw, dumpState);
            pw.println();
            pw.println("Package warning messages:");
            BufferedReader in = null;
            String line = null;
            try {
                in = new BufferedReader(new FileReader(getSettingsProblemFile()));
                while ((line = in.readLine()) != null) {
                    if (line.contains("ignored: updated version"))
                        continue;
                    pw.println(line);
                }
            } catch (IOException ignored) {
            } finally {
                IoUtils.closeQuietly(in);
            }
        }
        if (checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES)) {
            BufferedReader in = null;
            String line = null;
            try {
                in = new BufferedReader(new FileReader(getSettingsProblemFile()));
                while ((line = in.readLine()) != null) {
                    if (line.contains("ignored: updated version"))
                        continue;
                    pw.print("msg,");
                    pw.println(line);
                }
            } catch (IOException ignored) {
            } finally {
                IoUtils.closeQuietly(in);
            }
        }
    }
}

Example 18 with IntentFilterVerificationInfo

use of android.content.pm.IntentFilterVerificationInfo in project android_frameworks_base by DirtyUnicorns.

the class PackageManagerService method verifyIntentFiltersIfNeeded.

private void verifyIntentFiltersIfNeeded(int userId, int verifierUid, boolean replacing, PackageParser.Package pkg) {
    int size = pkg.activities.size();
    if (size == 0) {
        if (DEBUG_DOMAIN_VERIFICATION)
            Slog.d(TAG, "No activity, so no need to verify any IntentFilter!");
        return;
    }
    final boolean hasDomainURLs = hasDomainURLs(pkg);
    if (!hasDomainURLs) {
        if (DEBUG_DOMAIN_VERIFICATION)
            Slog.d(TAG, "No domain URLs, so no need to verify any IntentFilter!");
        return;
    }
    if (DEBUG_DOMAIN_VERIFICATION)
        Slog.d(TAG, "Checking for userId:" + userId + " if any IntentFilter from the " + size + " Activities needs verification ...");
    int count = 0;
    final String packageName = pkg.packageName;
    synchronized (mPackages) {
        // package, we have nothing to do: it means the state was restored from backup.
        if (!replacing) {
            IntentFilterVerificationInfo ivi = mSettings.getIntentFilterVerificationLPr(packageName);
            if (ivi != null) {
                if (DEBUG_DOMAIN_VERIFICATION) {
                    Slog.i(TAG, "Package " + packageName + " already verified: status=" + ivi.getStatusString());
                }
                return;
            }
        }
        // If any filters need to be verified, then all need to be.
        boolean needToVerify = false;
        for (PackageParser.Activity a : pkg.activities) {
            for (ActivityIntentInfo filter : a.intents) {
                if (filter.needsVerification() && needsNetworkVerificationLPr(filter)) {
                    if (DEBUG_DOMAIN_VERIFICATION) {
                        Slog.d(TAG, "Intent filter needs verification, so processing all filters");
                    }
                    needToVerify = true;
                    break;
                }
            }
        }
        if (needToVerify) {
            final int verificationId = mIntentFilterVerificationToken++;
            for (PackageParser.Activity a : pkg.activities) {
                for (ActivityIntentInfo filter : a.intents) {
                    if (filter.handlesWebUris(true) && needsNetworkVerificationLPr(filter)) {
                        if (DEBUG_DOMAIN_VERIFICATION)
                            Slog.d(TAG, "Verification needed for IntentFilter:" + filter.toString());
                        mIntentFilterVerifier.addOneIntentFilterVerification(verifierUid, userId, verificationId, filter, packageName);
                        count++;
                    }
                }
            }
        }
    }
    if (count > 0) {
        if (DEBUG_DOMAIN_VERIFICATION)
            Slog.d(TAG, "Starting " + count + " IntentFilter verification" + (count > 1 ? "s" : "") + " for userId:" + userId);
        mIntentFilterVerifier.startVerifications(userId);
    } else {
        if (DEBUG_DOMAIN_VERIFICATION) {
            Slog.d(TAG, "No filters or not all autoVerify for " + packageName);
        }
    }
}

Example 19 with IntentFilterVerificationInfo

use of android.content.pm.IntentFilterVerificationInfo in project android_frameworks_base by crdroidandroid.

the class Settings method writeAllDomainVerificationsLPr.

// Specifically for backup/restore
void writeAllDomainVerificationsLPr(XmlSerializer serializer, int userId) throws IllegalArgumentException, IllegalStateException, IOException {
    serializer.startTag(null, TAG_ALL_INTENT_FILTER_VERIFICATION);
    final int N = mPackages.size();
    for (int i = 0; i < N; i++) {
        PackageSetting ps = mPackages.valueAt(i);
        IntentFilterVerificationInfo ivi = ps.getIntentFilterVerificationInfo();
        if (ivi != null) {
            writeDomainVerificationsLPr(serializer, ivi);
        }
    }
    serializer.endTag(null, TAG_ALL_INTENT_FILTER_VERIFICATION);
}

Example 20 with IntentFilterVerificationInfo

use of android.content.pm.IntentFilterVerificationInfo in project android_frameworks_base by crdroidandroid.

the class Settings method readRestoredIntentFilterVerifications.

private void readRestoredIntentFilterVerifications(XmlPullParser parser) throws XmlPullParserException, IOException {
    int outerDepth = parser.getDepth();
    int type;
    while ((type = parser.next()) != XmlPullParser.END_DOCUMENT && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
        if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
            continue;
        }
        final String tagName = parser.getName();
        if (tagName.equals(TAG_DOMAIN_VERIFICATION)) {
            IntentFilterVerificationInfo ivi = new IntentFilterVerificationInfo(parser);
            if (DEBUG_DOMAIN_VERIFICATION) {
                Slog.i(TAG, "Restored IVI for " + ivi.getPackageName() + " status=" + ivi.getStatusString());
            }
            mRestoredIntentFilterVerifications.put(ivi.getPackageName(), ivi);
        } else {
            Slog.w(TAG, "Unknown element: " + tagName);
            XmlUtils.skipCurrentTag(parser);
        }
    }
}