Lines Matching refs:policy
168 * Service that maintains low-level network policy rules, using
171 * Derives active rules by combining a given policy with other system status,
199 private static final String TAG_POLICY_LIST = "policy-list";
200 private static final String TAG_NETWORK_POLICY = "network-policy";
201 private static final String TAG_UID_POLICY = "uid-policy";
202 private static final String TAG_APP_POLICY = "app-policy";
220 private static final String ATTR_POLICY = "policy";
341 Slog.w(TAG, "bandwidth controls disabled, unable to enforce policy");
376 // read policy from disk
406 // listen for package changes to update policy
412 // listen for UID changes to update policy
416 // listen for user changes to update policy
505 // global background data policy
522 // remove any policy and update rules to clean up
627 * state. Ignores hints when policy is user-defined.
644 NetworkPolicy policy = mNetworkPolicy.get(template);
645 if (policy == null && meteredHint) {
646 // policy doesn't exist, and AP is hinting that it's
647 // metered: create an inferred policy.
648 policy = new NetworkPolicy(template, CYCLE_NONE, Time.TIMEZONE_UTC,
651 addNetworkPolicyLocked(policy);
653 } else if (policy != null && policy.inferred) {
654 // policy exists, and was inferred: update its current
656 policy.metered = meteredHint;
695 // examine stats for each active policy
698 final NetworkPolicy policy = mNetworkPolicy.valueAt(i);
700 if (!isTemplateRelevant(policy.template)) continue;
701 if (!policy.hasCycle()) continue;
703 final long start = computeLastCycleBoundary(currentTime, policy);
705 final long totalBytes = getTotalBytes(policy.template, start, end);
707 if (policy.isOverLimit(totalBytes)) {
708 if (policy.lastLimitSnooze >= start) {
709 enqueueNotification(policy, TYPE_LIMIT_SNOOZED, totalBytes);
711 enqueueNotification(policy, TYPE_LIMIT, totalBytes);
712 notifyOverLimitLocked(policy.template);
716 notifyUnderLimitLocked(policy.template);
718 if (policy.isOverWarning(totalBytes) && policy.lastWarningSnooze < start) {
719 enqueueNotification(policy, TYPE_WARNING, totalBytes);
784 private String buildNotificationTag(NetworkPolicy policy, int type) {
785 return TAG + ":" + policy.template.hashCode() + ":" + type;
792 private void enqueueNotification(NetworkPolicy policy, int type, long totalBytes) {
793 final String tag = buildNotificationTag(policy, type);
811 final Intent snoozeIntent = buildSnoozeWarningIntent(policy.template);
815 final Intent viewIntent = buildViewDataUsageIntent(policy.template);
826 switch (policy.template.getMatchRule()) {
851 final Intent intent = buildNetworkOverLimitIntent(policy.template);
857 final long overBytes = totalBytes - policy.limitBytes;
862 switch (policy.template.getMatchRule()) {
886 final Intent intent = buildViewDataUsageIntent(policy.template);
984 // TODO: reset any policy-disabled networks when any policy is removed
989 final NetworkPolicy policy = mNetworkPolicy.valueAt(i);
990 // shortcut when policy has no limit
991 if (policy.limitBytes == LIMIT_DISABLED || !policy.hasCycle()) {
992 setNetworkTemplateEnabled(policy.template, true);
996 final long start = computeLastCycleBoundary(currentTime, policy);
998 final long totalBytes = getTotalBytes(policy.template, start, end);
1001 final boolean overLimitWithoutSnooze = policy.isOverLimit(totalBytes)
1002 && policy.lastLimitSnooze < start;
1005 setNetworkTemplateEnabled(policy.template, networkEnabled);
1076 final NetworkPolicy policy = mNetworkPolicy.valueAt(i);
1081 if (policy.template.matches(ident.second)) {
1088 mNetworkRules.put(policy, ifaces);
1095 // apply each policy that we found ifaces for; compute remaining data
1099 final NetworkPolicy policy = mNetworkRules.keyAt(i);
1104 if (policy.hasCycle()) {
1105 start = computeLastCycleBoundary(currentTime, policy);
1106 totalBytes = getTotalBytes(policy.template, start, currentTime);
1113 Slog.d(TAG, "applying policy " + policy.toString() + " to ifaces "
1117 final boolean hasWarning = policy.warningBytes != LIMIT_DISABLED;
1118 final boolean hasLimit = policy.limitBytes != LIMIT_DISABLED;
1119 if (hasLimit || policy.metered) {
1122 // metered network, but no policy limit; we still need to
1125 } else if (policy.lastLimitSnooze >= start) {
1133 quotaBytes = Math.max(1, policy.limitBytes - totalBytes);
1152 if (hasWarning && policy.warningBytes < lowestRule) {
1153 lowestRule = policy.warningBytes;
1155 if (hasLimit && policy.limitBytes < lowestRule) {
1156 lowestRule = policy.limitBytes;
1184 * have at least a default mobile policy defined.
1201 // Poke around to see if we already have a policy
1215 Slog.i(TAG, "No policy for subscriber " + NetworkIdentity.scrubSubscriberId(subscriberId)
1216 + "; generating default policy");
1218 // Build default mobile policy, and assume usage cycle starts today
1229 final NetworkPolicy policy = new NetworkPolicy(template, cycleDay, cycleTimezone,
1231 addNetworkPolicyLocked(policy);
1237 // clear any existing policy and read from disk
1322 final int policy = readIntAttribute(in, ATTR_POLICY);
1325 setUidPolicyUncheckedLocked(uid, policy, false);
1327 Slog.w(TAG, "unable to apply policy to UID " + uid + "; ignoring");
1331 final int policy = readIntAttribute(in, ATTR_POLICY);
1336 setUidPolicyUncheckedLocked(uid, policy, false);
1338 Slog.w(TAG, "unable to apply policy to UID " + uid + "; ignoring");
1345 // missing policy is okay, probably first boot
1348 Log.wtf(TAG, "problem reading network policy", e);
1350 Log.wtf(TAG, "problem reading network policy", e);
1389 final NetworkPolicy policy = mNetworkPolicy.valueAt(i);
1390 final NetworkTemplate template = policy.template;
1402 writeIntAttribute(out, ATTR_CYCLE_DAY, policy.cycleDay);
1403 out.attribute(null, ATTR_CYCLE_TIMEZONE, policy.cycleTimezone);
1404 writeLongAttribute(out, ATTR_WARNING_BYTES, policy.warningBytes);
1405 writeLongAttribute(out, ATTR_LIMIT_BYTES, policy.limitBytes);
1406 writeLongAttribute(out, ATTR_LAST_WARNING_SNOOZE, policy.lastWarningSnooze);
1407 writeLongAttribute(out, ATTR_LAST_LIMIT_SNOOZE, policy.lastLimitSnooze);
1408 writeBooleanAttribute(out, ATTR_METERED, policy.metered);
1409 writeBooleanAttribute(out, ATTR_INFERRED, policy.inferred);
1416 final int policy = mUidPolicy.valueAt(i);
1419 if (policy == POLICY_NONE) continue;
1423 writeIntAttribute(out, ATTR_POLICY, policy);
1439 public void setUidPolicy(int uid, int policy) {
1443 throw new IllegalArgumentException("cannot apply policy to UID " + uid);
1448 if (oldPolicy != policy) {
1449 setUidPolicyUncheckedLocked(uid, policy, true);
1455 public void addUidPolicy(int uid, int policy) {
1459 throw new IllegalArgumentException("cannot apply policy to UID " + uid);
1464 policy |= oldPolicy;
1465 if (oldPolicy != policy) {
1466 setUidPolicyUncheckedLocked(uid, policy, true);
1472 public void removeUidPolicy(int uid, int policy) {
1476 throw new IllegalArgumentException("cannot apply policy to UID " + uid);
1481 policy = oldPolicy & ~policy;
1482 if (oldPolicy != policy) {
1483 setUidPolicyUncheckedLocked(uid, policy, true);
1488 private void setUidPolicyUncheckedLocked(int uid, int policy, boolean persist) {
1489 mUidPolicy.put(uid, policy);
1491 // uid policy changed, recompute rules and persist policy.
1508 public int[] getUidsWithPolicy(int policy) {
1516 if (uidPolicy == policy) {
1564 // TODO: create permission for observing network policy
1574 // TODO: create permission for observing network policy
1594 void addNetworkPolicyLocked(NetworkPolicy policy) {
1596 policies = ArrayUtils.appendElement(NetworkPolicy.class, policies, policy);
1624 for (NetworkPolicy policy : policies) {
1626 // restrictive policy
1627 policy.template = NetworkTemplate.normalize(policy.template, merged);
1628 final NetworkPolicy existing = mNetworkPolicy.get(policy.template);
1629 if (existing == null || existing.compareTo(policy) > 0) {
1631 Slog.d(TAG, "Normalization replaced " + existing + " with " + policy);
1633 mNetworkPolicy.put(policy.template, policy);
1654 // find and snooze local policy that matches
1655 final NetworkPolicy policy = mNetworkPolicy.get(template);
1656 if (policy == null) {
1657 throw new IllegalArgumentException("unable to find policy for " + template);
1662 policy.lastWarningSnooze = currentTime;
1665 policy.lastLimitSnooze = currentTime;
1706 NetworkPolicy policy = mNetworkPolicy.valueAt(i);
1707 if (policy.template.matches(ident)) {
1708 return policy;
1731 final NetworkPolicy policy;
1733 policy = findPolicyForNetworkLocked(ident);
1736 if (policy == null || !policy.hasCycle()) {
1737 // missing policy means we can't derive useful quota info
1743 // find total bytes used under policy
1744 final long start = computeLastCycleBoundary(currentTime, policy);
1746 final long totalBytes = getTotalBytes(policy.template, start, end);
1748 // report soft and hard limits under policy
1749 final long softLimitBytes = policy.warningBytes != WARNING_DISABLED ? policy.warningBytes
1751 final long hardLimitBytes = policy.limitBytes != LIMIT_DISABLED ? policy.limitBytes
1766 final NetworkPolicy policy;
1768 policy = findPolicyForNetworkLocked(ident);
1771 if (policy != null) {
1772 return policy.metered;
1826 final int policy = mUidPolicy.valueAt(i);
1829 fout.print(" policy=");
1830 dumpPolicy(fout, policy);
2013 // derive active rules based on policy and active state
2016 // uid in background, and policy says to block metered data