source: java/net/deterlab/abac/CredentialFactory.java @ 65dbf06

package net.deterlab.abac;

import java.io.*;
import java.util.*;
import java.lang.reflect.*;


/**
 * The system demultiplex point for parsing Credentials.  Static class that
 * keeps an ordered list of CredentialParsers to try and a couple helper
 * functions to open files, etc in calling the CredentialParsers.  All
 * credential parsing should use a credential factory.
 * @author <a href="http://abac.deterlab.net">ISI ABAC team</a>
 * @version 1.3
 */
public class CredentialFactory {
    static List<CredentialParser> defParsers =new ArrayList<CredentialParser>();
    static List<CredentialParser> parsers = new ArrayList<CredentialParser>();
    static String defName = "net.deterlab.abac.GENICredential";
    public static final int maxSize = 50 * 1024;

    /**
     * Initialize the Default parser list.
     * @throws ABACException in extreme cases.  Should never happen.
     */
    static void initDefaultParser() throws ABACException {
        try {
            Class c = Class.forName(defName);
            Method m = c.getMethod("getCredentialParser");
            CredentialParser cp = (CredentialParser) m.invoke(null);

            defParsers.add(cp);
        }
        catch (Exception e) {
            throw new ABACException("Could not initialize default " +
                    "credential parser.  Something is very wrong", e);
        }
    }

    /**
     * Parse an input stream using each possible credential format and the
     * available identities for validation.  Return the credentials found or
     * throw an ABACException with the problem.  It wraps the input stream in a
     * BufferedInputStream in order to retry is a parser fails.  Credentials
     * larger than maxSize will nor be able to be reparsed.
     * @param is an InputStream to parse
     * @param ids a Collection of Identities for validation
     * @return an Array of Credentials parsed
     * @throws CertInvalidException if the stream is unparsable
     * @throws MissingIssuerException if none of the Identities can validate the
     * @throws BadSignatureException if the signature check fails
     */
    static public Credential[] parseCredential(InputStream is, 
            Collection<Identity> ids) throws ABACException {
        Credential[] rv = null;
        ABACException err = null;
        List<CredentialParser> useParsers = 
            (parsers.size()> 0 ) ? parsers : defParsers;

        if ( defParsers.size() < 1 )  initDefaultParser();

        if (!is.markSupported() && useParsers.size() > 1) 
            is = new BufferedInputStream(is, maxSize);
        is.mark(maxSize);

        for (CredentialParser c : useParsers ) {
            try {
                rv = c.parseCredential(is, ids);
                break;
            }
            catch (ABACException e ) {
                err = e;
                rv = null;
            }
            try {
                if (useParsers.size() > 1) is.reset(); 
            }
            catch (IOException ie) { 
                break;
            }
        }

        if ( rv != null ) 
            return rv;
        else 
            throw (err != null) ? err :
                new ABACException("null exception and failed construction??");
    }


    /**
     * Parse a File using each possible credential format and the
     * available identities for validation.  Return the credentials found or
     * throw an ABACException with the problem.  Calls the InputStream version
     * internally.
     * @param f a File to parse
     * @param ids a Collection of Identities for validation
     * @return an Array of Credentials parsed
     * @throws CertInvalidException if the stream is unparsable
     * @throws MissingIssuerException if none of the Identities can validate the
     * @throws BadSignatureException if the signature check fails
     */
    static public Credential[] parseCredential(File f, 
            Collection<Identity> ids) throws ABACException {
        try {
            return parseCredential(new FileInputStream(f), ids);
        }
        catch (FileNotFoundException e) {
            throw new CertInvalidException(e.getMessage(), e);
        }
    }
    /**
     * Parse a file named fn using each possible credential format and the
     * available identities for validation.  Return the credentials found or
     * throw an ABACException with the problem.  Calls the InputStream version
     * internally.
     * @param fn a String holding the filename to parse
     * @param ids a Collection of Identities for validation
     * @return an Array of Credentials parsed
     * @throws CertInvalidException if the stream is unparsable
     * @throws MissingIssuerException if none of the Identities can validate the
     * @throws BadSignatureException if the signature check fails
     */
    static public Credential[] parseCredential(String fn, 
            Collection<Identity> ids) throws ABACException {
        return parseCredential(new File(fn), ids);
    }

    /**
     * Add the named class to the list of usable parsers.  The class passed in
     * must have a static getCredentialParser() method that returns a
     * CredentialParser to use.
     * @param name a String containing the binary name of the class to register
     * @throws ABACException if there is a problem.  The cause field of this
     * exception is set to the classloading exception, if any.
     */
    static public void registerClass(String name)
        throws ABACException {
        CredentialParser cp = null;

        try {
            Class c = Class.forName(name);
            Method m = c.getMethod("getCredentialParser");

            cp = (CredentialParser) m.invoke(null);
        }
        catch (Exception e) {
            throw new ABACException("Could not register credential type" + 
                    e.getMessage(), e);
        }

        parsers.add(cp);
    }
}