History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/xml/crypto/dsig/TransformService.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/xml/crypto/dsig/TransformService.java+393−0
@@ -0,0 +1,393 @@
1+/*
2+ * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+/*
26+ * $Id: TransformService.java,v 1.6.4.1 2005/09/15 12:42:11 mullan Exp $
27+ */
28+package javax.xml.crypto.dsig;
29+
30+import java.security.InvalidAlgorithmParameterException;
31+import java.security.NoSuchAlgorithmException;
32+import java.security.NoSuchProviderException;
33+import java.security.Provider;
34+import java.security.Provider.Service;
35+import java.security.Security;
36+import java.util.*;
37+import javax.xml.crypto.MarshalException;
38+import javax.xml.crypto.XMLStructure;
39+import javax.xml.crypto.XMLCryptoContext;
40+import javax.xml.crypto.dsig.spec.TransformParameterSpec;
41+
42+import sun.security.jca.*;
43+import sun.security.jca.GetInstance.Instance;
44+
45+/**
46+ * A Service Provider Interface for transform and canonicalization algorithms.
47+ *
48+ * <p>Each instance of <code>TransformService</code> supports a specific
49+ * transform or canonicalization algorithm and XML mechanism type. To create a
50+ * <code>TransformService</code>, call one of the static
51+ * {@link #getInstance getInstance} methods, passing in the algorithm URI and
52+ * XML mechanism type desired, for example:
53+ *
54+ * <blockquote><code>
55+ * TransformService ts = TransformService.getInstance(Transform.XPATH2, "DOM");
56+ * </code></blockquote>
57+ *
58+ * <p><code>TransformService</code> implementations are registered and loaded
59+ * using the {@link java.security.Provider} mechanism. Each
60+ * <code>TransformService</code> service provider implementation should include
61+ * a <code>MechanismType</code> service attribute that identifies the XML
62+ * mechanism type that it supports. If the attribute is not specified,
63+ * "DOM" is assumed. For example, a service provider that supports the
64+ * XPath Filter 2 Transform and DOM mechanism would be specified in the
65+ * <code>Provider</code> subclass as:
66+ * <pre>
67+ * put("TransformService." + Transform.XPATH2,
68+ * "org.example.XPath2TransformService");
69+ * put("TransformService." + Transform.XPATH2 + " MechanismType", "DOM");
70+ * </pre>
71+ * <code>TransformService</code> implementations that support the DOM
72+ * mechanism type must abide by the DOM interoperability requirements defined
73+ * in the
74+ * <a href="../../../../../technotes/guides/security/xmldsig/overview.html#DOM Mechanism Requirements">
75+ * DOM Mechanism Requirements</a> section of the API overview. See the
76+ * <a href="../../../../../technotes/guides/security/xmldsig/overview.html#Service Provider">
77+ * Service Providers</a> section of the API overview for a list of standard
78+ * mechanism types.
79+ * <p>
80+ * Once a <code>TransformService</code> has been created, it can be used
81+ * to process <code>Transform</code> or <code>CanonicalizationMethod</code>
82+ * objects. If the <code>Transform</code> or <code>CanonicalizationMethod</code>
83+ * exists in XML form (for example, when validating an existing
84+ * <code>XMLSignature</code>), the {@link #init(XMLStructure, XMLCryptoContext)}
85+ * method must be first called to initialize the transform and provide document
86+ * context (even if there are no parameters). Alternatively, if the
87+ * <code>Transform</code> or <code>CanonicalizationMethod</code> is being
88+ * created from scratch, the {@link #init(TransformParameterSpec)} method
89+ * is called to initialize the transform with parameters and the
90+ * {@link #marshalParams marshalParams} method is called to marshal the
91+ * parameters to XML and provide the transform with document context. Finally,
92+ * the {@link #transform transform} method is called to perform the
93+ * transformation.
94+ * <p>
95+ * <b>Concurrent Access</b>
96+ * <p>The static methods of this class are guaranteed to be thread-safe.
97+ * Multiple threads may concurrently invoke the static methods defined in this
98+ * class with no ill effects.
99+ *
100+ * <p>However, this is not true for the non-static methods defined by this
101+ * class. Unless otherwise documented by a specific provider, threads that
102+ * need to access a single <code>TransformService</code> instance
103+ * concurrently should synchronize amongst themselves and provide the
104+ * necessary locking. Multiple threads each manipulating a different
105+ * <code>TransformService</code> instance need not synchronize.
106+ *
107+ * @author Sean Mullan
108+ * @author JSR 105 Expert Group
109+ * @since 1.6
110+ */
111+public abstract class TransformService implements Transform {
112+
113+ private String algorithm;
114+ private String mechanism;
115+ private Provider provider;
116+
117+ /**
118+ * Default constructor, for invocation by subclasses.
119+ */
120+ protected TransformService() {}
121+
122+ /**
123+ * Returns a <code>TransformService</code> that supports the specified
124+ * algorithm URI (ex: {@link Transform#XPATH2}) and mechanism type
125+ * (ex: DOM).
126+ *
127+ * <p>This method uses the standard JCA provider lookup mechanism to
128+ * locate and instantiate a <code>TransformService</code> implementation
129+ * of the desired algorithm and <code>MechanismType</code> service
130+ * attribute. It traverses the list of registered security
131+ * <code>Provider</code>s, starting with the most preferred
132+ * <code>Provider</code>. A new <code>TransformService</code> object
133+ * from the first <code>Provider</code> that supports the specified
134+ * algorithm and mechanism type is returned.
135+ *
136+ * <p> Note that the list of registered providers may be retrieved via
137+ * the {@link Security#getProviders() Security.getProviders()} method.
138+ *
139+ * @param algorithm the URI of the algorithm
140+ * @param mechanismType the type of the XML processing mechanism and
141+ * representation
142+ * @return a new <code>TransformService</code>
143+ * @throws NullPointerException if <code>algorithm</code> or
144+ * <code>mechanismType</code> is <code>null</code>
145+ * @throws NoSuchAlgorithmException if no <code>Provider</code> supports a
146+ * <code>TransformService</code> implementation for the specified
147+ * algorithm and mechanism type
148+ * @see Provider
149+ */
150+ public static TransformService getInstance
151+ (String algorithm, String mechanismType)
152+ throws NoSuchAlgorithmException {
153+ if (mechanismType == null || algorithm == null) {
154+ throw new NullPointerException();
155+ }
156+ boolean dom = false;
157+ if (mechanismType.equals("DOM")) {
158+ dom = true;
159+ }
160+ List services = GetInstance.getServices("TransformService", algorithm);
161+ for (Iterator t = services.iterator(); t.hasNext(); ) {
162+ Service s = (Service)t.next();
163+ String value = s.getAttribute("MechanismType");
164+ if ((value == null && dom) ||
165+ (value != null && value.equals(mechanismType))) {
166+ Instance instance = GetInstance.getInstance(s, null);
167+ TransformService ts = (TransformService) instance.impl;
168+ ts.algorithm = algorithm;
169+ ts.mechanism = mechanismType;
170+ ts.provider = instance.provider;
171+ return ts;
172+ }
173+ }
174+ throw new NoSuchAlgorithmException
175+ (algorithm + " algorithm and " + mechanismType
176+ + " mechanism not available");
177+ }
178+
179+ /**
180+ * Returns a <code>TransformService</code> that supports the specified
181+ * algorithm URI (ex: {@link Transform#XPATH2}) and mechanism type
182+ * (ex: DOM) as supplied by the specified provider. Note that the specified
183+ * <code>Provider</code> object does not have to be registered in the
184+ * provider list.
185+ *
186+ * @param algorithm the URI of the algorithm
187+ * @param mechanismType the type of the XML processing mechanism and
188+ * representation
189+ * @param provider the <code>Provider</code> object
190+ * @return a new <code>TransformService</code>
191+ * @throws NullPointerException if <code>provider</code>,
192+ * <code>algorithm</code>, or <code>mechanismType</code> is
193+ * <code>null</code>
194+ * @throws NoSuchAlgorithmException if a <code>TransformService</code>
195+ * implementation for the specified algorithm and mechanism type is not
196+ * available from the specified <code>Provider</code> object
197+ * @see Provider
198+ */
199+ public static TransformService getInstance
200+ (String algorithm, String mechanismType, Provider provider)
201+ throws NoSuchAlgorithmException {
202+ if (mechanismType == null || algorithm == null || provider == null) {
203+ throw new NullPointerException();
204+ }
205+
206+ boolean dom = false;
207+ if (mechanismType.equals("DOM")) {
208+ dom = true;
209+ }
210+ Service s = GetInstance.getService
211+ ("TransformService", algorithm, provider);
212+ String value = s.getAttribute("MechanismType");
213+ if ((value == null && dom) ||
214+ (value != null && value.equals(mechanismType))) {
215+ Instance instance = GetInstance.getInstance(s, null);
216+ TransformService ts = (TransformService) instance.impl;
217+ ts.algorithm = algorithm;
218+ ts.mechanism = mechanismType;
219+ ts.provider = instance.provider;
220+ return ts;
221+ }
222+ throw new NoSuchAlgorithmException
223+ (algorithm + " algorithm and " + mechanismType
224+ + " mechanism not available");
225+ }
226+
227+ /**
228+ * Returns a <code>TransformService</code> that supports the specified
229+ * algorithm URI (ex: {@link Transform#XPATH2}) and mechanism type
230+ * (ex: DOM) as supplied by the specified provider. The specified provider
231+ * must be registered in the security provider list.
232+ *
233+ * <p>Note that the list of registered providers may be retrieved via
234+ * the {@link Security#getProviders() Security.getProviders()} method.
235+ *
236+ * @param algorithm the URI of the algorithm
237+ * @param mechanismType the type of the XML processing mechanism and
238+ * representation
239+ * @param provider the string name of the provider
240+ * @return a new <code>TransformService</code>
241+ * @throws NoSuchProviderException if the specified provider is not
242+ * registered in the security provider list
243+ * @throws NullPointerException if <code>provider</code>,
244+ * <code>mechanismType</code>, or <code>algorithm</code> is
245+ * <code>null</code>
246+ * @throws NoSuchAlgorithmException if a <code>TransformService</code>
247+ * implementation for the specified algorithm and mechanism type is not
248+ * available from the specified provider
249+ * @see Provider
250+ */
251+ public static TransformService getInstance
252+ (String algorithm, String mechanismType, String provider)
253+ throws NoSuchAlgorithmException, NoSuchProviderException {
254+ if (mechanismType == null || algorithm == null || provider == null) {
255+ throw new NullPointerException();
256+ } else if (provider.length() == 0) {
257+ throw new NoSuchProviderException();
258+ }
259+ boolean dom = false;
260+ if (mechanismType.equals("DOM")) {
261+ dom = true;
262+ }
263+ Service s = GetInstance.getService
264+ ("TransformService", algorithm, provider);
265+ String value = s.getAttribute("MechanismType");
266+ if ((value == null && dom) ||
267+ (value != null && value.equals(mechanismType))) {
268+ Instance instance = GetInstance.getInstance(s, null);
269+ TransformService ts = (TransformService) instance.impl;
270+ ts.algorithm = algorithm;
271+ ts.mechanism = mechanismType;
272+ ts.provider = instance.provider;
273+ return ts;
274+ }
275+ throw new NoSuchAlgorithmException
276+ (algorithm + " algorithm and " + mechanismType
277+ + " mechanism not available");
278+ }
279+
280+ private static class MechanismMapEntry implements Map.Entry {
281+ private final String mechanism;
282+ private final String algorithm;
283+ private final String key;
284+ MechanismMapEntry(String algorithm, String mechanism) {
285+ this.algorithm = algorithm;
286+ this.mechanism = mechanism;
287+ this.key = "TransformService." + algorithm + " MechanismType";
288+ }
289+ public boolean equals(Object o) {
290+ if (!(o instanceof Map.Entry)) {
291+ return false;
292+ }
293+ Map.Entry e = (Map.Entry) o;
294+ return (getKey()==null ?
295+ e.getKey()==null : getKey().equals(e.getKey())) &&
296+ (getValue()==null ?
297+ e.getValue()==null : getValue().equals(e.getValue()));
298+ }
299+ public Object getKey() {
300+ return key;
301+ }
302+ public Object getValue() {
303+ return mechanism;
304+ }
305+ public Object setValue(Object value) {
306+ throw new UnsupportedOperationException();
307+ }
308+ public int hashCode() {
309+ return (getKey()==null ? 0 : getKey().hashCode()) ^
310+ (getValue()==null ? 0 : getValue().hashCode());
311+ }
312+ }
313+
314+ /**
315+ * Returns the mechanism type supported by this <code>TransformService</code>.
316+ *
317+ * @return the mechanism type
318+ */
319+ public final String getMechanismType() {
320+ return mechanism;
321+ }
322+
323+ /**
324+ * Returns the URI of the algorithm supported by this
325+ * <code>TransformService</code>.
326+ *
327+ * @return the algorithm URI
328+ */
329+ public final String getAlgorithm() {
330+ return algorithm;
331+ }
332+
333+ /**
334+ * Returns the provider of this <code>TransformService</code>.
335+ *
336+ * @return the provider
337+ */
338+ public final Provider getProvider() {
339+ return provider;
340+ }
341+
342+ /**
343+ * Initializes this <code>TransformService</code> with the specified
344+ * parameters.
345+ *
346+ * <p>If the parameters exist in XML form, the
347+ * {@link #init(XMLStructure, XMLCryptoContext)} method should be used to
348+ * initialize the <code>TransformService</code>.
349+ *
350+ * @param params the algorithm parameters (may be <code>null</code> if
351+ * not required or optional)
352+ * @throws InvalidAlgorithmParameterException if the specified parameters
353+ * are invalid for this algorithm
354+ */
355+ public abstract void init(TransformParameterSpec params)
356+ throws InvalidAlgorithmParameterException;
357+
358+ /**
359+ * Marshals the algorithm-specific parameters. If there are no parameters
360+ * to be marshalled, this method returns without throwing an exception.
361+ *
362+ * @param parent a mechanism-specific structure containing the parent
363+ * node that the marshalled parameters should be appended to
364+ * @param context the <code>XMLCryptoContext</code> containing
365+ * additional context (may be <code>null</code> if not applicable)
366+ * @throws ClassCastException if the type of <code>parent</code> or
367+ * <code>context</code> is not compatible with this
368+ * <code>TransformService</code>
369+ * @throws NullPointerException if <code>parent</code> is <code>null</code>
370+ * @throws MarshalException if the parameters cannot be marshalled
371+ */
372+ public abstract void marshalParams
373+ (XMLStructure parent, XMLCryptoContext context)
374+ throws MarshalException;
375+
376+ /**
377+ * Initializes this <code>TransformService</code> with the specified
378+ * parameters and document context.
379+ *
380+ * @param parent a mechanism-specific structure containing the parent
381+ * structure
382+ * @param context the <code>XMLCryptoContext</code> containing
383+ * additional context (may be <code>null</code> if not applicable)
384+ * @throws ClassCastException if the type of <code>parent</code> or
385+ * <code>context</code> is not compatible with this
386+ * <code>TransformService</code>
387+ * @throws NullPointerException if <code>parent</code> is <code>null</code>
388+ * @throws InvalidAlgorithmParameterException if the specified parameters
389+ * are invalid for this algorithm
390+ */
391+ public abstract void init(XMLStructure parent, XMLCryptoContext context)
392+ throws InvalidAlgorithmParameterException;
393+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t