/*
|
* Copyright (C) 2013 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
package com.android.server.firewall;
|
|
import android.content.ComponentName;
|
import android.content.Intent;
|
import android.net.Uri;
|
import android.os.PatternMatcher;
|
import org.xmlpull.v1.XmlPullParser;
|
import org.xmlpull.v1.XmlPullParserException;
|
|
import java.io.IOException;
|
import java.util.regex.Pattern;
|
|
abstract class StringFilter implements Filter {
|
private static final String ATTR_EQUALS = "equals";
|
private static final String ATTR_STARTS_WITH = "startsWith";
|
private static final String ATTR_CONTAINS = "contains";
|
private static final String ATTR_PATTERN = "pattern";
|
private static final String ATTR_REGEX = "regex";
|
private static final String ATTR_IS_NULL = "isNull";
|
|
private final ValueProvider mValueProvider;
|
|
private StringFilter(ValueProvider valueProvider) {
|
this.mValueProvider = valueProvider;
|
}
|
|
/**
|
* Constructs a new StringFilter based on the string filter attribute on the current
|
* element, and the given StringValueMatcher.
|
*
|
* The current node should contain exactly 1 string filter attribute. E.g. equals,
|
* contains, etc. Otherwise, an XmlPullParserException will be thrown.
|
*
|
* @param parser An XmlPullParser object positioned at an element that should
|
* contain a string filter attribute
|
* @return This StringFilter object
|
*/
|
public static StringFilter readFromXml(ValueProvider valueProvider, XmlPullParser parser)
|
throws IOException, XmlPullParserException {
|
StringFilter filter = null;
|
|
for (int i=0; i<parser.getAttributeCount(); i++) {
|
StringFilter newFilter = getFilter(valueProvider, parser, i);
|
if (newFilter != null) {
|
if (filter != null) {
|
throw new XmlPullParserException("Multiple string filter attributes found");
|
}
|
filter = newFilter;
|
}
|
}
|
|
if (filter == null) {
|
// if there are no string filter attributes, we default to isNull="false" so that an
|
// empty filter is equivalent to an existence check
|
filter = new IsNullFilter(valueProvider, false);
|
}
|
|
return filter;
|
}
|
|
private static StringFilter getFilter(ValueProvider valueProvider, XmlPullParser parser,
|
int attributeIndex) {
|
String attributeName = parser.getAttributeName(attributeIndex);
|
|
switch (attributeName.charAt(0)) {
|
case 'e':
|
if (!attributeName.equals(ATTR_EQUALS)) {
|
return null;
|
}
|
return new EqualsFilter(valueProvider, parser.getAttributeValue(attributeIndex));
|
case 'i':
|
if (!attributeName.equals(ATTR_IS_NULL)) {
|
return null;
|
}
|
return new IsNullFilter(valueProvider, parser.getAttributeValue(attributeIndex));
|
case 's':
|
if (!attributeName.equals(ATTR_STARTS_WITH)) {
|
return null;
|
}
|
return new StartsWithFilter(valueProvider,
|
parser.getAttributeValue(attributeIndex));
|
case 'c':
|
if (!attributeName.equals(ATTR_CONTAINS)) {
|
return null;
|
}
|
return new ContainsFilter(valueProvider, parser.getAttributeValue(attributeIndex));
|
case 'p':
|
if (!attributeName.equals(ATTR_PATTERN)) {
|
return null;
|
}
|
return new PatternStringFilter(valueProvider,
|
parser.getAttributeValue(attributeIndex));
|
case 'r':
|
if (!attributeName.equals(ATTR_REGEX)) {
|
return null;
|
}
|
return new RegexFilter(valueProvider, parser.getAttributeValue(attributeIndex));
|
}
|
return null;
|
}
|
|
protected abstract boolean matchesValue(String value);
|
|
@Override
|
public boolean matches(IntentFirewall ifw, ComponentName resolvedComponent, Intent intent,
|
int callerUid, int callerPid, String resolvedType, int receivingUid) {
|
String value = mValueProvider.getValue(resolvedComponent, intent, resolvedType);
|
return matchesValue(value);
|
}
|
|
private static abstract class ValueProvider extends FilterFactory {
|
protected ValueProvider(String tag) {
|
super(tag);
|
}
|
|
public Filter newFilter(XmlPullParser parser)
|
throws IOException, XmlPullParserException {
|
return StringFilter.readFromXml(this, parser);
|
}
|
|
public abstract String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType);
|
}
|
|
private static class EqualsFilter extends StringFilter {
|
private final String mFilterValue;
|
|
public EqualsFilter(ValueProvider valueProvider, String attrValue) {
|
super(valueProvider);
|
mFilterValue = attrValue;
|
}
|
|
@Override
|
public boolean matchesValue(String value) {
|
return value != null && value.equals(mFilterValue);
|
}
|
}
|
|
private static class ContainsFilter extends StringFilter {
|
private final String mFilterValue;
|
|
public ContainsFilter(ValueProvider valueProvider, String attrValue) {
|
super(valueProvider);
|
mFilterValue = attrValue;
|
}
|
|
@Override
|
public boolean matchesValue(String value) {
|
return value != null && value.contains(mFilterValue);
|
}
|
}
|
|
private static class StartsWithFilter extends StringFilter {
|
private final String mFilterValue;
|
|
public StartsWithFilter(ValueProvider valueProvider, String attrValue) {
|
super(valueProvider);
|
mFilterValue = attrValue;
|
}
|
|
@Override
|
public boolean matchesValue(String value) {
|
return value != null && value.startsWith(mFilterValue);
|
}
|
}
|
|
private static class PatternStringFilter extends StringFilter {
|
private final PatternMatcher mPattern;
|
|
public PatternStringFilter(ValueProvider valueProvider, String attrValue) {
|
super(valueProvider);
|
mPattern = new PatternMatcher(attrValue, PatternMatcher.PATTERN_SIMPLE_GLOB);
|
}
|
|
@Override
|
public boolean matchesValue(String value) {
|
return value != null && mPattern.match(value);
|
}
|
}
|
|
private static class RegexFilter extends StringFilter {
|
private final Pattern mPattern;
|
|
public RegexFilter(ValueProvider valueProvider, String attrValue) {
|
super(valueProvider);
|
this.mPattern = Pattern.compile(attrValue);
|
}
|
|
@Override
|
public boolean matchesValue(String value) {
|
return value != null && mPattern.matcher(value).matches();
|
}
|
}
|
|
private static class IsNullFilter extends StringFilter {
|
private final boolean mIsNull;
|
|
public IsNullFilter(ValueProvider valueProvider, String attrValue) {
|
super(valueProvider);
|
mIsNull = Boolean.parseBoolean(attrValue);
|
}
|
|
public IsNullFilter(ValueProvider valueProvider, boolean isNull) {
|
super(valueProvider);
|
mIsNull = isNull;
|
}
|
|
@Override
|
public boolean matchesValue(String value) {
|
return (value == null) == mIsNull;
|
}
|
}
|
|
public static final ValueProvider COMPONENT = new ValueProvider("component") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
if (resolvedComponent != null) {
|
return resolvedComponent.flattenToString();
|
}
|
return null;
|
}
|
};
|
|
public static final ValueProvider COMPONENT_NAME = new ValueProvider("component-name") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
if (resolvedComponent != null) {
|
return resolvedComponent.getClassName();
|
}
|
return null;
|
}
|
};
|
|
public static final ValueProvider COMPONENT_PACKAGE = new ValueProvider("component-package") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
if (resolvedComponent != null) {
|
return resolvedComponent.getPackageName();
|
}
|
return null;
|
}
|
};
|
|
public static final FilterFactory ACTION = new ValueProvider("action") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
return intent.getAction();
|
}
|
};
|
|
public static final ValueProvider DATA = new ValueProvider("data") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
Uri data = intent.getData();
|
if (data != null) {
|
return data.toString();
|
}
|
return null;
|
}
|
};
|
|
public static final ValueProvider MIME_TYPE = new ValueProvider("mime-type") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
return resolvedType;
|
}
|
};
|
|
public static final ValueProvider SCHEME = new ValueProvider("scheme") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
Uri data = intent.getData();
|
if (data != null) {
|
return data.getScheme();
|
}
|
return null;
|
}
|
};
|
|
public static final ValueProvider SSP = new ValueProvider("scheme-specific-part") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
Uri data = intent.getData();
|
if (data != null) {
|
return data.getSchemeSpecificPart();
|
}
|
return null;
|
}
|
};
|
|
public static final ValueProvider HOST = new ValueProvider("host") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
Uri data = intent.getData();
|
if (data != null) {
|
return data.getHost();
|
}
|
return null;
|
}
|
};
|
|
public static final ValueProvider PATH = new ValueProvider("path") {
|
@Override
|
public String getValue(ComponentName resolvedComponent, Intent intent,
|
String resolvedType) {
|
Uri data = intent.getData();
|
if (data != null) {
|
return data.getPath();
|
}
|
return null;
|
}
|
};
|
}
|
