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 javax.net.ssl;
022:
023: import java.security.AccessController;
024: import java.security.InvalidAlgorithmParameterException;
025: import java.security.KeyStore;
026: import java.security.KeyStoreException;
027: import java.security.NoSuchAlgorithmException;
028: import java.security.NoSuchProviderException;
029: import java.security.Provider;
030: import java.security.Security;
031:
032: import org.apache.harmony.security.fortress.Engine;
033:
034: /**
035: * @com.intel.drl.spec_ref
036: *
037: */
038:
039: public class TrustManagerFactory {
040: // Store TrustManager service name
041: private static final String SERVICE = "TrustManagerFactory";
042:
043: // Used to access common engine functionality
044: private static Engine engine = new Engine(SERVICE);
045:
046: // Store default property name
047: private static final String PROPERTYNAME = "ssl.TrustManagerFactory.algorithm";
048:
049: // Store used provider
050: private final Provider provider;
051:
052: // Storeused TrustManagerFactorySpi implementation
053: private final TrustManagerFactorySpi spiImpl;
054:
055: // Store used algorithm
056: private final String algorithm;
057:
058: /**
059: * @com.intel.drl.spec_ref
060: *
061: */
062: protected TrustManagerFactory(TrustManagerFactorySpi factorySpi,
063: Provider provider, String algorithm) {
064: this .provider = provider;
065: this .algorithm = algorithm;
066: this .spiImpl = factorySpi;
067: }
068:
069: /**
070: * @com.intel.drl.spec_ref
071: *
072: */
073: public final String getAlgorithm() {
074: return algorithm;
075: }
076:
077: /**
078: * @com.intel.drl.spec_ref
079: *
080: * throws NullPointerException if algorithm is null (instead of
081: * NoSuchAlgorithmException as in 1.4 release)
082: */
083: public static final TrustManagerFactory getInstance(String algorithm)
084: throws NoSuchAlgorithmException {
085: if (algorithm == null) {
086: throw new NullPointerException("algorithm is null");
087: }
088: synchronized (engine) {
089: engine.getInstance(algorithm, null);
090: return new TrustManagerFactory(
091: (TrustManagerFactorySpi) engine.spi,
092: engine.provider, algorithm);
093: }
094: }
095:
096: /**
097: * @com.intel.drl.spec_ref
098: *
099: * throws NullPointerException if algorithm is null (instead of
100: * NoSuchAlgorithmException as in 1.4 release)
101: */
102: public static final TrustManagerFactory getInstance(
103: String algorithm, String provider)
104: throws NoSuchAlgorithmException, NoSuchProviderException {
105: if ((provider == null) || (provider.length() == 0)) {
106: throw new IllegalArgumentException(
107: "Provider is null oe empty");
108: }
109: Provider impProvider = Security.getProvider(provider);
110: if (impProvider == null) {
111: throw new NoSuchProviderException(provider);
112: }
113: return getInstance(algorithm, impProvider);
114: }
115:
116: /**
117: * @com.intel.drl.spec_ref
118: *
119: * throws NullPointerException if algorithm is null (instead of
120: * NoSuchAlgorithmException as in 1.4 release)
121: */
122: public static final TrustManagerFactory getInstance(
123: String algorithm, Provider provider)
124: throws NoSuchAlgorithmException {
125: if (provider == null) {
126: throw new IllegalArgumentException("Provider is null");
127: }
128: if (algorithm == null) {
129: throw new NullPointerException("algorithm is null");
130: }
131: synchronized (engine) {
132: engine.getInstance(algorithm, provider, null);
133: return new TrustManagerFactory(
134: (TrustManagerFactorySpi) engine.spi, provider,
135: algorithm);
136: }
137: }
138:
139: /**
140: * @com.intel.drl.spec_ref
141: *
142: */
143: public final Provider getProvider() {
144: return provider;
145: }
146:
147: /**
148: * @com.intel.drl.spec_ref
149: *
150: */
151: public final void init(KeyStore ks) throws KeyStoreException {
152: spiImpl.engineInit(ks);
153: }
154:
155: /**
156: * @com.intel.drl.spec_ref
157: *
158: */
159: public final void init(ManagerFactoryParameters spec)
160: throws InvalidAlgorithmParameterException {
161: spiImpl.engineInit(spec);
162: }
163:
164: /**
165: * @com.intel.drl.spec_ref
166: *
167: */
168: public final TrustManager[] getTrustManagers() {
169: return spiImpl.engineGetTrustManagers();
170: }
171:
172: /**
173: * @com.intel.drl.spec_ref
174: *
175: */
176: public static final String getDefaultAlgorithm() {
177: return AccessController
178: .doPrivileged(new java.security.PrivilegedAction<String>() {
179: public String run() {
180: return Security.getProperty(PROPERTYNAME);
181: }
182: });
183: }
184: }
|