org.apache.commons.jexl3.internal.introspection.SandboxUberspect Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-jexl3 Show documentation
The Apache Commons JEXL library is an implementation of the JSTL Expression Language with extensions.
The newest version!
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.apache.commons.jexl3.internal.introspection;

import java.util.Iterator;
import java.util.List;
import java.util.Objects;

import org.apache.commons.jexl3.JexlArithmetic;
import org.apache.commons.jexl3.JexlOperator;
import org.apache.commons.jexl3.introspection.JexlMethod;
import org.apache.commons.jexl3.introspection.JexlPropertyGet;
import org.apache.commons.jexl3.introspection.JexlPropertySet;
import org.apache.commons.jexl3.introspection.JexlSandbox;
import org.apache.commons.jexl3.introspection.JexlUberspect;

/**
 * An uberspect that controls usage of properties, methods and constructors through a sandbox.
 * @since 3.0
 */
public final class SandboxUberspect implements JexlUberspect {
    /**
     * Identity equality.
     * Spotbugs just hates string identity...
     * @param lhs left hand side
     * @param rhs right hand side
     * @return true if left is identical to right
     */
    private static boolean eq(final Object lhs, final Object rhs) {
        return lhs == rhs;
    }
    /** The base uberspect. */
    private final JexlUberspect uberspect;

    /**  The sandbox. */
    private final JexlSandbox sandbox;

    /**
     * A constructor for JexlSandbox uberspect.
     * @param theUberspect the JexlUberspect to sandbox
     * @param theSandbox the sandbox which is copied to avoid changes at runtime
     */
    public SandboxUberspect(final JexlUberspect theUberspect, final JexlSandbox theSandbox) {
        Objects.requireNonNull(theSandbox, "theSandbox");
        Objects.requireNonNull(theUberspect, "theUberspect");
        this.uberspect = theUberspect;
        this.sandbox = theSandbox.copy();
    }

    @Override
    public JexlArithmetic.Uberspect getArithmetic(final JexlArithmetic arithmetic) {
        return uberspect.getArithmetic(arithmetic);
    }

    @Override
    public Class getClassByName(final String className) {
        return uberspect.getClassByName(className);
    }

    @Override
    public ClassLoader getClassLoader() {
        return uberspect.getClassLoader();
    }

    @Override
    public JexlMethod getConstructor(final Object ctorHandle, final Object... args) {
        final String className;
        if (ctorHandle instanceof Class) {
            className = sandbox.execute((Class) ctorHandle, "");
        } else if (ctorHandle != null) {
            className = sandbox.execute(ctorHandle.toString(), "");
        } else {
            className = null;
        }
        return className != null && className != JexlSandbox.NULL ? uberspect.getConstructor(className, args) : null;
    }

    @Override
    public Iterator getIterator(final Object obj) {
        return uberspect.getIterator(obj);
    }

    @Override
    public JexlMethod getMethod(final Object obj, final String method, final Object... args) {
        if (obj != null && method != null) {
            final Class clazz = obj instanceof Class ? (Class) obj : obj.getClass();
            final String actual = sandbox.execute(clazz, method);
            if (actual != null && actual != JexlSandbox.NULL) {
                return uberspect.getMethod(obj, actual, args);
            }
        }
        return null;
    }

    @Override
    public JexlPropertyGet getPropertyGet(final List resolvers,
                                          final Object obj,
                                          final Object identifier) {
        if (obj != null) {
            final Class clazz = obj instanceof Class? (Class) obj : obj.getClass();
            if (identifier != null) {
                final String property = identifier.toString();
                final String actual = sandbox.read(clazz, property);
                if (actual != null) {
                    // no transformation, strict equality: use identifier before string conversion
                    final Object pty = eq(actual, property) ? identifier : actual;
                    return uberspect.getPropertyGet(resolvers, obj, pty);
                }
            } else {
                final String actual = sandbox.read(clazz, null);
                if (actual != JexlSandbox.NULL) {
                     return uberspect.getPropertyGet(resolvers, obj, null);
                }
            }
        }
        return null;
    }

    @Override
    public JexlPropertyGet getPropertyGet(final Object obj, final Object identifier) {
        return getPropertyGet(null, obj, identifier);
    }

    @Override
    public JexlPropertySet getPropertySet(final List resolvers,
                                          final Object obj,
                                          final Object identifier,
                                          final Object arg) {
        if (obj != null) {
            final Class clazz = obj instanceof Class? (Class) obj : obj.getClass();
            if (identifier != null) {
                final String property = identifier.toString();
                final String actual = sandbox.write(clazz, property);
                if (actual != null) {
                    // no transformation, strict equality: use identifier before string conversion
                    final Object pty = eq(actual, property) ? identifier : actual;
                    return uberspect.getPropertySet(resolvers, obj, pty, arg);
                }
            } else {
                final String actual = sandbox.write(clazz, null);
                if (actual != JexlSandbox.NULL) {
                    return uberspect.getPropertySet(resolvers, obj, null, arg);
                }
            }
        }
        return null;
    }

    @Override
    public JexlPropertySet getPropertySet(final Object obj,final Object identifier,final Object arg) {
        return getPropertySet(null, obj, identifier, arg);
    }

    @Override
    public List getResolvers(final JexlOperator op, final Object obj) {
        return uberspect.getResolvers(op, obj);
    }

    @Override
    public int getVersion() {
        return uberspect.getVersion();
    }

    @Override
    public void setClassLoader(final ClassLoader loader) {
        uberspect.setClassLoader(loader);
    }
}