actionparameter.java

一个完整的XACML工程,学习XACML技术的好例子!

/*
* Copyright (c) 2006, University of Kent
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without 
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this 
* list of conditions and the following disclaimer.
* 
* Redistributions 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. 
*
* 1. Neither the name of the University of Kent nor the names of its 
* contributors may be used to endorse or promote products derived from this 
* software without specific prior written permission. 
*
* 2. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS  
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
* PURPOSE ARE DISCLAIMED. 
*
* 3. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
* POSSIBILITY OF SUCH DAMAGE.
*
* 4. YOU AGREE THAT THE EXCLUSIONS IN PARAGRAPHS 2 AND 3 ABOVE ARE REASONABLE
* IN THE CIRCUMSTANCES.  IN PARTICULAR, YOU ACKNOWLEDGE (1) THAT THIS
* SOFTWARE HAS BEEN MADE AVAILABLE TO YOU FREE OF CHARGE, (2) THAT THIS
* SOFTWARE IS NOT "PRODUCT" QUALITY, BUT HAS BEEN PRODUCED BY A RESEARCH
* GROUP WHO DESIRE TO MAKE THIS SOFTWARE FREELY AVAILABLE TO PEOPLE WHO WISH
* TO USE IT, AND (3) THAT BECAUSE THIS SOFTWARE IS NOT OF "PRODUCT" QUALITY
* IT IS INEVITABLE THAT THERE WILL BE BUGS AND ERRORS, AND POSSIBLY MORE
* SERIOUS FAULTS, IN THIS SOFTWARE.
*
* 5. This license is governed, except to the extent that local laws
* necessarily apply, by the laws of England and Wales.
*/
package uk.ac.kent.dpa.custom.authz.util;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import javax.xml.namespace.QName;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.HashMap;

import org.globus.wsrf.security.SecurityException;

/**
 * This class is used to store a specific parameter element path for a
 * given operation for a said service. The parameter path is a list of
 * QNames, where each QName is QName of a child element of previous
 * QName element. The root of this list is the top level element in
 * the SOAPBody. For example, an array of QName with element 0 as
 * {http://foo.bar.edu}, element 1 as outer;{http://foo.bar.edu}inner,
 * and element 2 as {http://foo.bar.edu}innermost would be a parameter
 * path to the element innermost where inner is child of outer and
 * innermost is a child of inner.
 */
public class ActionParameter {

    private static Log logger =
        LogFactory.getLog(ActionParameter.class.getName());

    private String servicePath = null;
    private String methodName = null;
    private QName[] parameterPath = null;

    public static final String DELIMITER = "?";
    public static final String PARAMETER_DELIMITER = ";";

    public ActionParameter(String servicePath_, String methodName_,
                         QName[] parameterPath_) {

        if (servicePath_ == null) {
            throw new IllegalArgumentException("servicePathNull");
        }

        if (methodName_ == null) {
            throw new IllegalArgumentException("methodNameNull");
        }

        if (parameterPath_ == null) {
            throw new IllegalArgumentException("paramPathNull");
        }

        this.servicePath = servicePath_;
        this.methodName = methodName_;
        this.parameterPath = parameterPath_;
    }

    public String getServicePath() {

        return this.servicePath;
    }

    public String getMethodName() {

        return this.methodName;
    }

    public QName[] getParmeterPath() {

        return this.parameterPath;
    }

    /**
     * The format used for string representation is as follows:
     * servicePath?methodName?paramQName1;paramQName2;paramQNamen
     */
    public String toString() {

        String retStr = this.servicePath + DELIMITER + this.methodName
                + DELIMITER;
        if (this.parameterPath.length > 0) {
            retStr = retStr + "(" + this.parameterPath[0].getNamespaceURI()
                    + ")" + this.parameterPath[0].getLocalPart();
        }
        for (int i=1;i<this.parameterPath.length; i++) {
            retStr = retStr + PARAMETER_DELIMITER +
                     "(" + this.parameterPath[i].getNamespaceURI()
                    + ")" + this.parameterPath[i].getLocalPart();
        }
        logger.debug("Value is " + retStr);
        return retStr;
    }

   /**
    * <p> Reads a configuration file with information about the parameters to
    * extract from SOAP Message. The format of the file is individual line
    * entry with this format: "servicePath methodname parameterPath". The
    * parameterPath is a string with string representation of each QName, in
    * the order it needs to be looked into with semicolon (;) as
    * delimiter. Service path is the full service endpoint (i.e
    * protocol://localhost:portNumber/serviceName)</p>
    * <p> The properties that are read in are stored as a HashMap. The
    * HashMap is keyed on the servicePath and stores a HashMap as the
    * value. The HashMap stored as value is keyed on the method name
    * and the parameter path is stored as the value.
    */
    public static HashMap getParametersFromFile(File file)
           throws SecurityException {

       if (file == null) {
           return null;
       }

       logger.debug("File name is " + file.getPath());

       BufferedReader reader = null;

       // Construct to store the values read in. A HashMap with serviceName as
       // key. The value is another HashMap with methodName as key and vector
       // of SOAPParameter (one for each parameter as value)
       HashMap soapParameters = new HashMap();

       String line;
       try {
           reader = new BufferedReader(new FileReader(file));
           while ((line = reader.readLine()) != null) {

               StringTokenizer tokenizer = new StringTokenizer(line);
               if (tokenizer.countTokens() != 3) {
                   String error = "Malformed line, should be of format " +
                                  " serviceName methodName parameterPath";
                   logger.error(error);
                   throw new SecurityException(error);
               }

               String serviceName = tokenizer.nextToken().trim();
               String methodName = tokenizer.nextToken().trim();
               String parameterPath = tokenizer.nextToken().trim();

               logger.debug("Read parameter. Service name " + serviceName
                            + " method name " + methodName + " prameterPath "
                            + parameterPath);

               StringTokenizer paramTok = new StringTokenizer(parameterPath,
                                                              ";");
               QName parameters[] = new QName[paramTok.countTokens()];
               int i=0;
               while (paramTok.hasMoreTokens()) {
                   String qname = paramTok.nextToken();
                   parameters[i] = QName.valueOf(qname);
                   i++;
               }

               ActionParameter soapParameter =
                       new ActionParameter(serviceName, methodName, parameters);
               if (!soapParameters.containsKey(serviceName)) {
                   logger.debug("Adding service " + serviceName);
                   soapParameters.put(serviceName, new HashMap());
               }
               HashMap value = (HashMap)soapParameters.get(serviceName);
               // value cannot be null, although it is allowed in HashMap
               if (!value.containsKey(methodName)) {
                   logger.debug("Adding method to hashmap " + methodName);
                   value.put(methodName, new Vector());
               }
               Vector paramVector = (Vector)value.get(methodName);
               //parameters cannot be null, although it is allowed in HashMap
               paramVector.add(soapParameter);
           }
       } catch (FileNotFoundException exp) {
           throw new SecurityException(exp);
       } catch (IOException exp) {
           String err = "Error reading file " + file.getPath();
           throw new SecurityException(err, exp);
       } finally {
           if (reader != null) {
               try {
                   reader.close();
               } catch (Exception exp) {
                   logger.error(exp);
               }
           }
       }

       return soapParameters;
   }
}