policyreference.java

来自「sunxacml源码」· Java 代码 · 共 553 行 · 第 1/2 页

/*
 * @(#)PolicyReference.java
 *
 * Copyright 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistribution of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 * 
 *   2. Redistribution in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed or intended for use in
 * the design, construction, operation or maintenance of any nuclear facility.
 */

package com.sun.xacml;

import com.sun.xacml.combine.CombiningAlgorithm;

import com.sun.xacml.ctx.Result;
import com.sun.xacml.ctx.Status;

import com.sun.xacml.finder.PolicyFinder;
import com.sun.xacml.finder.PolicyFinderResult;

import java.io.OutputStream;
import java.io.PrintStream;

import java.net.URI;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


/**
 * This class is used as a placeholder for the PolicyIdReference and
 * PolicySetIdReference fields in a PolicySetType. When a reference is used
 * in a policy set, it is telling the PDP to use an external policy in
 * the current policy. Each time the PDP needs to evaluate that policy
 * reference, it asks the policy finder for the policy. Typically the policy
 * finder will have cached the referenced policy, so this isn't too slow.
 * <p>
 * NOTE: all of the accessor methods, the match method, and the evaluate method
 * require this class to ask its <code>PolicyFinder</code> for the referenced
 * policy, which can be a slow operation. Care should be taken, therefore in
 * calling these methods too often. Also note that it's not safe to cache the
 * results of these calls, since the referenced policy may change.
 *
 * @since 1.0
 * @author Seth Proctor
 */
public class PolicyReference extends AbstractPolicy
{
    
    /**
     * Identifies this as a reference to a <code>Policy</code>
     */
    public static final int POLICY_REFERENCE = 0;

    /**
     * Identifies this as a reference to a <code>PolicySet</code>
     */
    public static final int POLICYSET_REFERENCE = 1;

    // the reference
    private URI reference;

    // the reference type
    private int policyType;

    // and version constraints on this reference
    private VersionConstraints constraints;

    // the finder to use in finding the referenced policy
    private PolicyFinder finder;

    // the meta-data for the parent policy
    private PolicyMetaData parentMetaData;

    // the logger we'll use for all messages
    private static final Logger logger =
        Logger.getLogger(PolicyReference.class.getName());

    /**
     * Creates a new <code>PolicyReference</code> instance. This has no
     * constraints on version matching. Note that an XACML 1.x reference may
     * not have any constraints.
     *
     * @param reference the reference to the policy
     * @param policyType one of the two fields in this class
     * @param finder the <code>PolicyFinder</code> used to handle the reference
     * @param parentMetaData the meta-data associated with the containing
     *                       (parent) policy
     *
     * @throws IllegalArgumentException if the input policyType isn't valid
     */
    public PolicyReference(URI reference, int policyType, PolicyFinder finder,
                           PolicyMetaData parentMetaData)
        throws IllegalArgumentException
    {
        this(reference, policyType, new VersionConstraints(null, null, null),
             finder, parentMetaData);
    }

    /**
     * Creates a new <code>PolicyReference</code> instance with version
     * constraints. Note that an XACML 1.x reference may not have any
     * constraints.
     *
     * @param reference the reference to the policy
     * @param policyType one of the two fields in this class
     * @param constraints any optional constraints on the version of the
     *                    referenced policy (this is never null, but
     *                    it may impose no constraints, and in fact will
     *                    never impose constraints when used from a pre-2.0
     *                    XACML policy)
     * @param finder the <code>PolicyFinder</code> used to handle the reference
     * @param parentMetaData the meta-data associated with the containing
     *                       (parent) policy
     *
     * @throws IllegalArgumentException if the input policyType isn't valid
     */
    public PolicyReference(URI reference, int policyType,
                           VersionConstraints constraints, PolicyFinder finder,
                           PolicyMetaData parentMetaData)
        throws IllegalArgumentException {

        // check if input policyType is a valid value
        if ((policyType != POLICY_REFERENCE) && 
            (policyType != POLICYSET_REFERENCE))
            throw new IllegalArgumentException("Input policyType is not a" +
                                               "valid value");

        this.reference = reference;
        this.policyType = policyType;
        this.constraints = constraints;
        this.finder = finder;
        this.parentMetaData = parentMetaData;
    }

    /**
     * Creates an instance of a <code>PolicyReference</code> object based on
     * a DOM node.
     *
     * @deprecated As of 2.0 you should avoid using this method and should
     *             instead use the version that takes a
     *             <code>PolicyMetaData</code> instance. This method will
     *             only work for XACML 1.x policies.
     *
     * @param root the DOM root of a PolicyIdReference or a 
     *             PolicySetIdReference XML type
     * @param finder the <code>PolicyFinder</code> used to handle the reference
     *
     * @exception ParsingException if the node is invalid
     */
    public static PolicyReference getInstance(Node root, PolicyFinder finder)
        throws ParsingException
    {
        return getInstance(root, finder, new PolicyMetaData());
    }

    /**
     * Creates an instance of a <code>PolicyReference</code> object based on
     * a DOM node.
     *
     * @param root the DOM root of a PolicyIdReference or a 
     *             PolicySetIdReference XML type
     * @param finder the <code>PolicyFinder</code> used to handle the reference
     * @param metaData the meta-data associated with the containing policy
     *
     * @exception ParsingException if the node is invalid
     */
    public static PolicyReference getInstance(Node root, PolicyFinder finder,
                                              PolicyMetaData metaData)
        throws ParsingException
    {
        URI reference = null;
        int policyType;
        
        // see what type of reference we are
        String name = root.getNodeName();
        if (name.equals("PolicyIdReference")) {
            policyType = POLICY_REFERENCE;
        } else if (name.equals("PolicySetIdReference")) {
            policyType = POLICYSET_REFERENCE;
        } else {
            throw new ParsingException("Unknown reference type: " + name);
        }

        // next get the reference
        try {
            reference = new URI(root.getFirstChild().getNodeValue());
        } catch (Exception e) {
            throw new ParsingException("Invalid URI in Reference", e);
        }

        // now get any constraints
        NamedNodeMap map = root.getAttributes();

        String versionConstraint = null;
        Node versionNode = map.getNamedItem("Version");
        if (versionNode != null)
            versionConstraint = versionNode.getNodeValue();

        String earlyConstraint = null;
        Node earlyNode = map.getNamedItem("EarliestVersion");
        if (earlyNode != null)
            earlyConstraint = earlyNode.getNodeValue();

        String lateConstraint = null;
        Node lateNode = map.getNamedItem("LatestVersion");
        if (lateNode != null)
            lateConstraint = lateNode.getNodeValue();

        VersionConstraints constraints =
            new VersionConstraints(versionConstraint, earlyConstraint,
                                   lateConstraint);

        // finally, create the reference
        return new PolicyReference(reference, policyType, constraints, finder,
                                   metaData);
    }

    /**
     * Returns the refernce identitfier used to resolve the policy.
     *
     * @return the reference <code>URI</code>
     */
    public URI getReference() {
        return reference;
    }

    /**
     * Returns the version constraints associated with this reference. This
     * will never be null, though the constraints may be empty.
     *
     * @return the version constraints
     */
    public VersionConstraints getConstraints() {
        return constraints;
    }

    /**
     * Returns whether this is a reference to a policy or to a policy set.
     *
     * @return the reference type, either <code>POLICY_REFERENCE</code>
     *         or <code>POLICYSET_REFERENCE</code>
     */