001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: /**
019: * @author Vera Y. Petrashkova
020: * @version $Revision$
021: */package java.security.cert;
022:
023: import java.security.AccessController;
024: import java.security.InvalidAlgorithmParameterException;
025: import java.security.NoSuchAlgorithmException;
026: import java.security.NoSuchProviderException;
027: import java.security.Provider;
028: import java.security.Security;
029:
030: import org.apache.harmony.security.fortress.Engine;
031: import org.apache.harmony.security.internal.nls.Messages;
032:
033: /**
034: * @com.intel.drl.spec_ref
035: *
036: */
037:
038: public class CertPathValidator {
039: // Store CertPathValidator implementation service name
040: private static final String SERVICE = "CertPathValidator"; //$NON-NLS-1$
041:
042: // Used to access common engine functionality
043: private static Engine engine = new Engine(SERVICE);
044:
045: // Store default property name
046: private static final String PROPERTYNAME = "certpathvalidator.type"; //$NON-NLS-1$
047:
048: // Default value of CertPathBuilder type. It returns if certpathbuild.type
049: // property is not defined in java.security file
050: private static final String DEFAULTPROPERTY = "PKIX"; //$NON-NLS-1$
051:
052: // Store used provider
053: private final Provider provider;
054:
055: // Store used spi implementation
056: private final CertPathValidatorSpi spiImpl;
057:
058: // Store used algorithm value
059: private final String algorithm;
060:
061: /**
062: * @com.intel.drl.spec_ref
063: *
064: */
065: protected CertPathValidator(CertPathValidatorSpi validatorSpi,
066: Provider provider, String algorithm) {
067: this .provider = provider;
068: this .algorithm = algorithm;
069: this .spiImpl = validatorSpi;
070: }
071:
072: /**
073: * @com.intel.drl.spec_ref
074: *
075: */
076: public final String getAlgorithm() {
077: return algorithm;
078: }
079:
080: /**
081: * @com.intel.drl.spec_ref
082: *
083: */
084: public final Provider getProvider() {
085: return provider;
086: }
087:
088: /**
089: * @com.intel.drl.spec_ref
090: *
091: * throws NullPointerException if algorithm is null
092: */
093: public static CertPathValidator getInstance(String algorithm)
094: throws NoSuchAlgorithmException {
095: if (algorithm == null) {
096: throw new NullPointerException(Messages
097: .getString("security.01")); //$NON-NLS-1$
098: }
099: synchronized (engine) {
100: engine.getInstance(algorithm, null);
101: return new CertPathValidator(
102: (CertPathValidatorSpi) engine.spi, engine.provider,
103: algorithm);
104: }
105: }
106:
107: /**
108: * @com.intel.drl.spec_ref
109: *
110: * throws NullPointerException if algorithm is null
111: */
112: public static CertPathValidator getInstance(String algorithm,
113: String provider) throws NoSuchAlgorithmException,
114: NoSuchProviderException {
115: if ((provider == null) || (provider.length() == 0)) {
116: throw new IllegalArgumentException(Messages
117: .getString("security.02")); //$NON-NLS-1$
118: }
119: Provider impProvider = Security.getProvider(provider);
120: if (impProvider == null) {
121: throw new NoSuchProviderException(provider);
122: }
123: return getInstance(algorithm, impProvider);
124: }
125:
126: /**
127: * @com.intel.drl.spec_ref*
128: *
129: * throws NullPointerException if algorithm is null
130: */
131: public static CertPathValidator getInstance(String algorithm,
132: Provider provider) throws NoSuchAlgorithmException {
133: if (provider == null) {
134: throw new IllegalArgumentException(Messages
135: .getString("security.04")); //$NON-NLS-1$
136: }
137: if (algorithm == null) {
138: throw new NullPointerException(Messages
139: .getString("security.01")); //$NON-NLS-1$
140: }
141: synchronized (engine) {
142: engine.getInstance(algorithm, provider, null);
143: return new CertPathValidator(
144: (CertPathValidatorSpi) engine.spi, provider,
145: algorithm);
146: }
147: }
148:
149: /**
150: * @com.intel.drl.spec_ref
151: *
152: */
153: public final CertPathValidatorResult validate(CertPath certPath,
154: CertPathParameters params)
155: throws CertPathValidatorException,
156: InvalidAlgorithmParameterException {
157: return spiImpl.engineValidate(certPath, params);
158: }
159:
160: /**
161: * @com.intel.drl.spec_ref
162: *
163: */
164: public static final String getDefaultType() {
165: String defaultType = AccessController
166: .doPrivileged(new java.security.PrivilegedAction<String>() {
167: public String run() {
168: return Security.getProperty(PROPERTYNAME);
169: }
170: });
171: return (defaultType != null ? defaultType : DEFAULTPROPERTY);
172: }
173: }
|