geronimo-jacc_1.1_spec/src/main/java/javax/security/jacc/HTTPMethodSpec.java

/*
 * 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.
 */

//
// This source code implements specifications defined by the Java
// Community Process. In order to remain compliant with the specification
// DO NOT add / change / or delete method signatures!
//

package javax.security.jacc;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.regex.Pattern;


/**
 * @version $Rev$ $Date$
 */
final class HTTPMethodSpec {

    private final static String[] HTTP_METHODS = {"GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "TRACE"};
    private final static int[] HTTP_MASKS = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40};

    final static int NA = 0x00;
    final static int INTEGRAL = 0x01;
    final static int CONFIDENTIAL = 0x02;
    final static int NONE = INTEGRAL | CONFIDENTIAL;

    private final int mask;
    private final String[] extensionMethods;
    private final boolean isExcluded;
    private final int transport;
    private String actions;
    private static final String[] NO_METHODS = new String[0];
    private static final Pattern TOKEN_PATTERN = Pattern.compile("[!-~&&[^\\(\\)\\<\\>@,;:\\\\\"/\\[\\]\\?=\\{\\}]]*");

    public HTTPMethodSpec(String[] HTTPMethods) {
        this(HTTPMethods, null);
    }

    public HTTPMethodSpec(String name, boolean parseTransportType) {
        if (parseTransportType) {
            if (name == null || name.length() == 0) {
                this.transport = NONE;
            } else {
                String[] tokens = name.split(":", 2);

                if (tokens.length == 2) {
                    if (tokens[1].equals("NONE")) {
                        this.transport = NONE;
                    } else if (tokens[1].equals("INTEGRAL")) {
                        this.transport = INTEGRAL;
                    } else if (tokens[1].equals("CONFIDENTIAL")) {
                        this.transport = CONFIDENTIAL;
                    } else {
                        throw new IllegalArgumentException("Invalid transportType: " + tokens[1]);
                    }
                } else {
                    this.transport = NONE;
                }
                name = tokens[0];
            }
        } else {
            this.transport = NA;
        }

        if (name == null || name.length() == 0) {
            this.mask = 0x00;
            this.extensionMethods = NO_METHODS;
            this.isExcluded = true;
        } else {
            ArrayList<String> extensions = null;
            if (isExcluded = name.charAt(0) == '!') {
                name = name.substring(1);
            }
            int tmpMask = 0;

            if (name.length() > 0) {
                String[] methods = name.split(",", -1);
                for (int i = 0; i < methods.length; i++) {
                    boolean found = false;

                    for (int j = 0; j < HTTP_METHODS.length; j++) {
                        if (methods[i].equals(HTTP_METHODS[j])) {
                            tmpMask |= HTTP_MASKS[j];
                            found = true;

                            break;
                        }
                    }
                    if (!found) {
                        checkToken(methods[i]);
                        if (extensions == null) {
                            extensions = new ArrayList<String>(methods.length);
                        }
                        add(extensions, methods[i]);
                    }
                }
            }
            this.mask = tmpMask;
            if (extensions == null) {
                extensionMethods = NO_METHODS;
            } else {
                extensionMethods = extensions.toArray(new String[extensions.size()]);
            }
        }
    }

    public HTTPMethodSpec(String[] HTTPMethods, String transport) {
        boolean parseTransportType = transport != null;

        if (HTTPMethods == null || HTTPMethods.length == 0) {
            this.mask = 0x00;
            this.extensionMethods = NO_METHODS;
            this.isExcluded = true;
        } else {
            int tmpMask = 0;
            this.isExcluded = false;
            ArrayList<String> extensions = null;

            for (int i = 0; i < HTTPMethods.length; i++) {
                boolean found = false;

                for (int j = 0; j < HTTP_METHODS.length; j++) {
                    if (HTTPMethods[i].equals(HTTP_METHODS[j])) {
                        tmpMask |= HTTP_MASKS[j];
                        found = true;

                        break;
                    }
                }
                if (!found) {
                    checkToken(HTTPMethods[i]);
                    if (extensions == null) {
                        extensions = new ArrayList<String>(HTTPMethods.length);
                    }
                    add(extensions, HTTPMethods[i]);
                }
            }
            this.mask = tmpMask;
            if (extensions == null) {
                extensionMethods = NO_METHODS;
            } else {
                extensionMethods = extensions.toArray(new String[extensions.size()]);
            }
        }

        if (parseTransportType) {
            if (transport.length() == 0 || transport.equals("NONE")) {
                this.transport = NONE;
            } else if (transport.equals("INTEGRAL")) {
                this.transport = INTEGRAL;
            } else if (transport.equals("CONFIDENTIAL")) {
                this.transport = CONFIDENTIAL;
            } else {
                throw new IllegalArgumentException("Invalid transport");
            }
        } else {
            this.transport = NA;
        }
    }

    public HTTPMethodSpec(String singleMethod, int transport) {
        int tmpMask = 0;

        for (int j = 0; j < HTTP_METHODS.length; j++) {
            if (HTTP_METHODS[j].equals(singleMethod)) {
                tmpMask = HTTP_MASKS[j];

                break;
            }
        }
        if (tmpMask == 0) {
            checkToken(singleMethod);
            this.extensionMethods = new String[]{singleMethod};
        } else {
            this.extensionMethods = NO_METHODS;
        }

        this.mask = tmpMask;
        this.isExcluded = false;
        this.transport = transport;
    }


    private void checkToken(String method) {
        if (!TOKEN_PATTERN.matcher(method).matches()) {
            throw new IllegalArgumentException("Invalid HTTPMethodSpec");
        }
    }

    private void add(ArrayList<String> extensions, String httpMethod) {
        for (int i = 0; i < extensions.size(); i++) {
            String existingMethod = extensions.get(i);
            int compare = existingMethod.compareTo(httpMethod);
            if (compare == 0) {
                return;
            }
            if (compare > 0) {
                extensions.add(i, httpMethod);
                return;
            }
        }
        extensions.add(httpMethod);
    }


    public boolean equals(HTTPMethodSpec o) {
        return mask == o.mask && transport == o.transport && isExcluded == o.isExcluded && Arrays.equals(extensionMethods, o.extensionMethods);
    }

    public String getActions() {
        if (actions == null) {
            StringBuilder buffer;
            if (isAllHttpActions()) {
                if (hasTransportGuarantee()) {
                    buffer = new StringBuilder();
                } else {
                    return "";
                }
            } else {
                buffer = new StringBuilder();
                if (isExcluded) {
                    buffer.append("!");
                }

                boolean first = true;
                for (int i = 0; i < HTTP_MASKS.length; i++) {
                    if ((mask & HTTP_MASKS[i]) > 0) {
                        if (first) {
                            first = false;
                        } else {
                            buffer.append(",");
                        }
                        buffer.append(HTTP_METHODS[i]);
                    }
                }
                for (String method : extensionMethods) {
                    if (first) {
                        first = false;
                    } else {
                        buffer.append(",");
                    }
                    buffer.append(method);
                }
            }

            if (hasTransportGuarantee()) {
                if (transport == INTEGRAL) {
                    buffer.append(":INTEGRAL");
                } else if (transport == CONFIDENTIAL) {
                    buffer.append(":CONFIDENTIAL");
                }
            }

            actions = buffer.toString();
        }
        return actions;
    }

    private boolean isAllHttpActions() {
        return isExcluded && mask == 0x00 && extensionMethods.length == 0;
    }

    private boolean hasTransportGuarantee() {
        return  !(transport == NA || transport == NONE);
    }

    public int hashCode() {
        return mask ^ (transport <<8) ^ (isExcluded? 0:0x200);
    }

    public String toString() {
        return getActions();
    }

    public boolean implies(HTTPMethodSpec p) {
        if ((transport & p.transport) != p.transport) {
            return false;
        }
        if (isExcluded) {
            if (p.isExcluded) {
                return ((mask & p.mask) == mask) && contains(p.extensionMethods, extensionMethods);
            } else {
                return ((mask & p.mask) == 0x00) && isDisjoint(extensionMethods, p.extensionMethods);
            }
        } else {
            if (p.isExcluded) {
                return false;
            } else {
                return ((mask & p.mask) == p.mask) && contains(extensionMethods, p.extensionMethods);
            }
        }
    }

    private boolean isDisjoint(String[] a, String[] b) {
        int start = 0;
        for (int i = 0; i < a.length; i++) {
            String s = a[i];
            for (int j = start; j < b.length; j++) {
                String s1 = b[j];
                int compare = s.compareTo(s1);
                if (compare == 0) {
                    return false;
                }
                if (compare < 0) {
                    start = j;
                    break;
                }
            }
        }
        return true;
    }

    private boolean contains(String[] set, String[] subset) {
        int start = 0;
        for (int i = 0; i < subset.length; i++) {
            boolean found = false;
            String s = subset[i];
            for (int j = start; j < set.length; j++) {
                String s1 = set[j];
                int compare = s.compareTo(s1);
                if (compare == 0) {
                    found = true;
                    start = j + 1;
                    break;
                }
                if (compare < 0) {
                    return false;
                }
            }
            if (!found) {
                return false;
            }
        }
        return true;
    }
}