/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 1999-2004 The Apache Software Foundation.
*
* Licensed 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 com.sun.org.apache.xml.internal.security.keys.keyresolver;
import java.security.PublicKey;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import javax.crypto.SecretKey;
import com.sun.org.apache.xml.internal.security.keys.storage.StorageResolver;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
/**
* KeyResolver is factory class for subclass of KeyResolverSpi that
* represent child element of KeyInfo.
*
* @author $Author: raul $
*/
public class KeyResolver {
/** {@link java.util.logging} logging facility */
static java.util.logging.Logger log =
java.util.logging.Logger.getLogger(KeyResolver.class.getName());
/** Field _alreadyInitialized */
static boolean _alreadyInitialized = false;
/** Field _resolverVector */
static List _resolverVector = null;
/** Field _resolverSpi */
protected KeyResolverSpi _resolverSpi = null;
/** Field _storage */
protected StorageResolver _storage = null;
/**
* Constructor ResourceResolver
*
* @param className
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
*/
private KeyResolver(String className)
throws ClassNotFoundException, IllegalAccessException,
InstantiationException {
this._resolverSpi =
(KeyResolverSpi) Class.forName(className).newInstance();
}
/**
* Method length
*
* @return the length of resolvers registed
*/
public static int length() {
return KeyResolver._resolverVector.size();
}
/**
* Method item
*
* @param i
* @return the number i resolver registerd
* @throws KeyResolverException
*/
public static KeyResolver item(int i) throws KeyResolverException {
KeyResolver resolver = (KeyResolver) KeyResolver._resolverVector.get(i);
if (resolver==null) {
throw new KeyResolverException("utils.resolver.noClass");
}
return resolver;
}
/**
* Method getInstance
*
* @param element
* @param BaseURI
* @param storage
* @return the instance that happends to implement the thing.
*
* @throws KeyResolverException
*/
public static final KeyResolver getInstance(
Element element, String BaseURI, StorageResolver storage)
throws KeyResolverException {
for (int i = 0; i < KeyResolver._resolverVector.size(); i++) {
KeyResolver resolver=
(KeyResolver) KeyResolver._resolverVector.get(i);
if (resolver==null) {
Object exArgs[] = {
(((element != null)
&& (element.getNodeType() == Node.ELEMENT_NODE))
? element.getTagName()
: "null") };
throw new KeyResolverException("utils.resolver.noClass", exArgs);
}
if (true)
if (log.isLoggable(java.util.logging.Level.FINE)) log.log(java.util.logging.Level.FINE, "check resolvability by class " + resolver.getClass());
if (resolver.canResolve(element, BaseURI, storage)) {
return resolver;
}
}
Object exArgs[] = {
(((element != null) && (element.getNodeType() == Node.ELEMENT_NODE))
? element.getTagName()
: "null") };
throw new KeyResolverException("utils.resolver.noClass", exArgs);
}
/**
* The init() function is called by com.sun.org.apache.xml.internal.security.Init.init()
*/
public static void init() {
if (!KeyResolver._alreadyInitialized) {
KeyResolver._resolverVector = new ArrayList(10);
_alreadyInitialized = true;
}
}
/**
* This method is used for registering {@link KeyResolverSpi}s which are
* available to <I>all</I> {@link com.sun.org.apache.xml.internal.security.keys.KeyInfo} objects. This means that
* personalized {@link KeyResolverSpi}s should only be registered directly
* to the {@link com.sun.org.apache.xml.internal.security.keys.KeyInfo} using
* {@link com.sun.org.apache.xml.internal.security.keys.KeyInfo#registerInternalKeyResolver}.
*
* @param className
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
*/
public static void register(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
KeyResolver._resolverVector.add(new KeyResolver(className));
}
/**
* This method is used for registering {@link KeyResolverSpi}s which are
* available to <I>all</I> {@link com.sun.org.apache.xml.internal.security.keys.KeyInfo} objects. This means that
* personalized {@link KeyResolverSpi}s should only be registered directly
* to the {@link com.sun.org.apache.xml.internal.security.keys.KeyInfo} using {@link com.sun.org.apache.xml.internal.security.keys.KeyInfo#registerInternalKeyResolver}.
*
* @param className
*/
public static void registerAtStart(String className) {
KeyResolver._resolverVector.add(0, className);
}
/*
* Method resolve
*
* @param element
*
* @throws KeyResolverException
*/
/**
* Method resolveStatic
*
* @param element
* @param BaseURI
* @param storage
* @return resolve from the static register an element
*
* @throws KeyResolverException
*/
public static PublicKey resolveStatic(
Element element, String BaseURI, StorageResolver storage)
throws KeyResolverException {
KeyResolver myResolver = KeyResolver.getInstance(element, BaseURI,
storage);
return myResolver.resolvePublicKey(element, BaseURI, storage);
}
/**
* Method resolve
*
* @param element
* @param BaseURI
* @param storage
* @return resolved public key from the registered from the elements
*
* @throws KeyResolverException
*/
public PublicKey resolvePublicKey(
Element element, String BaseURI, StorageResolver storage)
throws KeyResolverException {
return this._resolverSpi.engineResolvePublicKey(element, BaseURI, storage);
}
/**
* Method resolveX509Certificate
*
* @param element
* @param BaseURI
* @param storage
* @return resolved X509certificate key from the registered from the elements
*
* @throws KeyResolverException
*/
public X509Certificate resolveX509Certificate(
Element element, String BaseURI, StorageResolver storage)
throws KeyResolverException {
return this._resolverSpi.engineResolveX509Certificate(element, BaseURI,
storage);
}
/**
* @param element
* @param BaseURI
* @param storage
* @return resolved SecretKey key from the registered from the elements
* @throws KeyResolverException
*/
public SecretKey resolveSecretKey(
Element element, String BaseURI, StorageResolver storage)
throws KeyResolverException {
return this._resolverSpi.engineResolveSecretKey(element, BaseURI,
storage);
}
/**
* Method setProperty
*
* @param key
* @param value
*/
public void setProperty(String key, String value) {
this._resolverSpi.engineSetProperty(key, value);
}
/**
* Method getProperty
*
* @param key
* @return the property setted for this resolver
*/
public String getProperty(String key) {
return this._resolverSpi.engineGetProperty(key);
}
/**
* Method getPropertyKeys
*
* @return the properties key registerd in this resolver
*/
public String[] getPropertyKeys() {
return this._resolverSpi.engineGetPropertyKeys();
}
/**
* Method understandsProperty
*
* @param propertyToTest
* @return true if the resolver understands property propertyToTest
*/
public boolean understandsProperty(String propertyToTest) {
return this._resolverSpi.understandsProperty(propertyToTest);
}
/**
* Method canResolve
*
* @param element
* @param BaseURI
* @param storage
* @return true if can resolve the key in the element
*/
public boolean canResolve(Element element, String BaseURI,
StorageResolver storage) {
return this._resolverSpi.engineCanResolve(element, BaseURI, storage);
}
/**
* Method resolverClassName
*
* @return the name of the resolver.
*/
public String resolverClassName() {
return this._resolverSpi.getClass().getName();
}
}