path: root/services/core/java/com/android/server/firewall/StringFilter.java

/*
 * 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;
        }
    };
}