Wed, 27 Apr 2016 01:27:09 +0800
Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/jaxws/
changeset: 657:d47a47f961ee
tag: jdk8u25-b17
1 /*
2 * Copyright (c) 1997, 2013, 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 */
26 package com.sun.xml.internal.ws.util.pipe;
28 import com.sun.istack.internal.NotNull;
29 import com.sun.istack.internal.Nullable;
30 import com.sun.xml.internal.stream.buffer.XMLStreamBufferResult;
31 import com.sun.xml.internal.ws.api.WSBinding;
32 import com.sun.xml.internal.ws.api.message.Message;
33 import com.sun.xml.internal.ws.api.message.Packet;
34 import com.sun.xml.internal.ws.api.pipe.Tube;
35 import com.sun.xml.internal.ws.api.pipe.TubeCloner;
36 import com.sun.xml.internal.ws.api.pipe.helper.AbstractFilterTubeImpl;
37 import com.sun.xml.internal.ws.api.server.DocumentAddressResolver;
38 import com.sun.xml.internal.ws.api.server.SDDocument;
39 import com.sun.xml.internal.ws.api.server.SDDocumentSource;
40 import com.sun.xml.internal.ws.developer.SchemaValidationFeature;
41 import com.sun.xml.internal.ws.developer.ValidationErrorHandler;
42 import com.sun.xml.internal.ws.server.SDDocumentImpl;
43 import com.sun.xml.internal.ws.util.ByteArrayBuffer;
44 import com.sun.xml.internal.ws.util.xml.XmlUtil;
45 import com.sun.xml.internal.ws.wsdl.SDDocumentResolver;
46 import com.sun.xml.internal.ws.wsdl.parser.WSDLConstants;
47 import org.w3c.dom.*;
48 import org.w3c.dom.ls.LSInput;
49 import org.w3c.dom.ls.LSResourceResolver;
50 import org.xml.sax.SAXException;
51 import org.xml.sax.helpers.NamespaceSupport;
53 import javax.xml.XMLConstants;
54 import javax.xml.namespace.QName;
55 import javax.xml.transform.Source;
56 import javax.xml.transform.Transformer;
57 import javax.xml.transform.TransformerException;
58 import javax.xml.transform.dom.DOMResult;
59 import javax.xml.transform.dom.DOMSource;
60 import javax.xml.transform.stream.StreamSource;
61 import javax.xml.validation.SchemaFactory;
62 import javax.xml.validation.Validator;
63 import javax.xml.ws.WebServiceException;
64 import java.io.IOException;
65 import java.io.InputStream;
66 import java.io.Reader;
67 import java.io.StringReader;
68 import java.net.MalformedURLException;
69 import java.net.URI;
70 import java.net.URL;
71 import java.util.*;
72 import java.util.logging.Level;
73 import java.util.logging.Logger;
75 import static com.sun.xml.internal.ws.util.xml.XmlUtil.allowExternalAccess;
77 /**
78 * {@link Tube} that does the schema validation.
79 *
80 * @author Jitendra Kotamraju
81 */
82 public abstract class AbstractSchemaValidationTube extends AbstractFilterTubeImpl {
84 private static final Logger LOGGER = Logger.getLogger(AbstractSchemaValidationTube.class.getName());
86 protected final WSBinding binding;
87 protected final SchemaValidationFeature feature;
88 protected final DocumentAddressResolver resolver = new ValidationDocumentAddressResolver();
89 protected final SchemaFactory sf;
91 public AbstractSchemaValidationTube(WSBinding binding, Tube next) {
92 super(next);
93 this.binding = binding;
94 feature = binding.getFeature(SchemaValidationFeature.class);
95 sf = allowExternalAccess(SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI), "file", false);
96 }
98 protected AbstractSchemaValidationTube(AbstractSchemaValidationTube that, TubeCloner cloner) {
99 super(that, cloner);
100 this.binding = that.binding;
101 this.feature = that.feature;
102 this.sf = that.sf;
103 }
105 protected abstract Validator getValidator();
107 protected abstract boolean isNoValidation();
109 private static class ValidationDocumentAddressResolver implements DocumentAddressResolver {
111 @Nullable
112 @Override
113 public String getRelativeAddressFor(@NotNull SDDocument current, @NotNull SDDocument referenced) {
114 LOGGER.log(Level.FINE, "Current = {0} resolved relative={1}", new Object[]{current.getURL(), referenced.getURL()});
115 return referenced.getURL().toExternalForm();
116 }
117 }
119 private Document createDOM(SDDocument doc) {
120 // Get infoset
121 ByteArrayBuffer bab = new ByteArrayBuffer();
122 try {
123 doc.writeTo(null, resolver, bab);
124 } catch (IOException ioe) {
125 throw new WebServiceException(ioe);
126 }
128 // Convert infoset to DOM
129 Transformer trans = XmlUtil.newTransformer();
130 Source source = new StreamSource(bab.newInputStream(), null); //doc.getURL().toExternalForm());
131 DOMResult result = new DOMResult();
132 try {
133 trans.transform(source, result);
134 } catch(TransformerException te) {
135 throw new WebServiceException(te);
136 }
137 return (Document)result.getNode();
138 }
140 protected class MetadataResolverImpl implements SDDocumentResolver, LSResourceResolver {
142 // systemID --> SDDocument
143 final Map<String, SDDocument> docs = new HashMap<String, SDDocument>();
145 // targetnamespace --> SDDocument
146 final Map<String, SDDocument> nsMapping = new HashMap<String, SDDocument>();
148 public MetadataResolverImpl() {
149 }
151 public MetadataResolverImpl(Iterable<SDDocument> it) {
152 for(SDDocument doc : it) {
153 if (doc.isSchema()) {
154 docs.put(doc.getURL().toExternalForm(), doc);
155 nsMapping.put(((SDDocument.Schema)doc).getTargetNamespace(), doc);
156 }
157 }
158 }
160 void addSchema(Source schema) {
161 assert schema.getSystemId() != null;
163 String systemId = schema.getSystemId();
164 try {
165 XMLStreamBufferResult xsbr = XmlUtil.identityTransform(schema, new XMLStreamBufferResult());
166 SDDocumentSource sds = SDDocumentSource.create(new URL(systemId), xsbr.getXMLStreamBuffer());
167 SDDocument sdoc = SDDocumentImpl.create(sds, new QName(""), new QName(""));
168 docs.put(systemId, sdoc);
169 nsMapping.put(((SDDocument.Schema)sdoc).getTargetNamespace(), sdoc);
170 } catch(Exception ex) {
171 LOGGER.log(Level.WARNING, "Exception in adding schemas to resolver", ex);
172 }
173 }
175 void addSchemas(Collection<? extends Source> schemas) {
176 for(Source src : schemas) {
177 addSchema(src);
178 }
179 }
181 @Override
182 public SDDocument resolve(String systemId) {
183 SDDocument sdi = docs.get(systemId);
184 if (sdi == null) {
185 SDDocumentSource sds;
186 try {
187 sds = SDDocumentSource.create(new URL(systemId));
188 } catch(MalformedURLException e) {
189 throw new WebServiceException(e);
190 }
191 sdi = SDDocumentImpl.create(sds, new QName(""), new QName(""));
192 docs.put(systemId, sdi);
193 }
194 return sdi;
195 }
197 @Override
198 public LSInput resolveResource(String type, String namespaceURI, String publicId, final String systemId, final String baseURI) {
199 if (LOGGER.isLoggable(Level.FINE)) {
200 LOGGER.log(Level.FINE, "type={0} namespaceURI={1} publicId={2} systemId={3} baseURI={4}", new Object[]{type, namespaceURI, publicId, systemId, baseURI});
201 }
202 try {
203 final SDDocument doc;
204 if (systemId == null) {
205 doc = nsMapping.get(namespaceURI);
206 } else {
207 URI rel = (baseURI != null)
208 ? new URI(baseURI).resolve(systemId)
209 : new URI(systemId);
210 doc = docs.get(rel.toString());
211 }
212 if (doc != null) {
213 return new LSInput() {
215 @Override
216 public Reader getCharacterStream() {
217 return null;
218 }
220 @Override
221 public void setCharacterStream(Reader characterStream) {
222 throw new UnsupportedOperationException();
223 }
225 @Override
226 public InputStream getByteStream() {
227 ByteArrayBuffer bab = new ByteArrayBuffer();
228 try {
229 doc.writeTo(null, resolver, bab);
230 } catch (IOException ioe) {
231 throw new WebServiceException(ioe);
232 }
233 return bab.newInputStream();
234 }
236 @Override
237 public void setByteStream(InputStream byteStream) {
238 throw new UnsupportedOperationException();
239 }
241 @Override
242 public String getStringData() {
243 return null;
244 }
246 @Override
247 public void setStringData(String stringData) {
248 throw new UnsupportedOperationException();
249 }
251 @Override
252 public String getSystemId() {
253 return doc.getURL().toExternalForm();
254 }
256 @Override
257 public void setSystemId(String systemId) {
258 throw new UnsupportedOperationException();
259 }
261 @Override
262 public String getPublicId() {
263 return null;
264 }
266 @Override
267 public void setPublicId(String publicId) {
268 throw new UnsupportedOperationException();
269 }
271 @Override
272 public String getBaseURI() {
273 return doc.getURL().toExternalForm();
274 }
276 @Override
277 public void setBaseURI(String baseURI) {
278 throw new UnsupportedOperationException();
279 }
281 @Override
282 public String getEncoding() {
283 return null;
284 }
286 @Override
287 public void setEncoding(String encoding) {
288 throw new UnsupportedOperationException();
289 }
291 @Override
292 public boolean getCertifiedText() {
293 return false;
294 }
296 @Override
297 public void setCertifiedText(boolean certifiedText) {
298 throw new UnsupportedOperationException();
299 }
300 };
301 }
302 } catch(Exception e) {
303 LOGGER.log(Level.WARNING, "Exception in LSResourceResolver impl", e);
304 }
305 if (LOGGER.isLoggable(Level.FINE)) {
306 LOGGER.log(Level.FINE, "Don''t know about systemId={0} baseURI={1}", new Object[]{systemId, baseURI});
307 }
308 return null;
309 }
311 }
313 private void updateMultiSchemaForTns(String tns, String systemId, Map<String, List<String>> schemas) {
314 List<String> docIdList = schemas.get(tns);
315 if (docIdList == null) {
316 docIdList = new ArrayList<String>();
317 schemas.put(tns, docIdList);
318 }
319 docIdList.add(systemId);
320 }
322 /*
323 * Using the following algorithm described in the xerces discussion thread:
324 *
325 * "If you're synthesizing schema documents to glue together the ones in
326 * the WSDL then you may not even need to use "honour-all-schemaLocations".
327 * Create a schema document for each namespace with <xs:include>s
328 * (for each schema document in the WSDL with that target namespace)
329 * and then combine those together with <xs:import>s for each of those
330 * namespaces in a "master" schema document.
331 *
332 * That should work with any schema processor, not just those which
333 * honour multiple imports for the same namespace."
334 */
335 protected Source[] getSchemaSources(Iterable<SDDocument> docs, MetadataResolverImpl mdresolver) {
336 // All schema fragments in WSDLs are put inlinedSchemas
337 // systemID --> DOMSource
338 Map<String, DOMSource> inlinedSchemas = new HashMap<String, DOMSource>();
340 // Consolidates all the schemas(inlined and external) for a tns
341 // tns --> list of systemId
342 Map<String, List<String>> multiSchemaForTns = new HashMap<String, List<String>>();
344 for(SDDocument sdoc: docs) {
345 if (sdoc.isWSDL()) {
346 Document dom = createDOM(sdoc);
347 // Get xsd:schema node from WSDL's DOM
348 addSchemaFragmentSource(dom, sdoc.getURL().toExternalForm(), inlinedSchemas);
349 } else if (sdoc.isSchema()) {
350 updateMultiSchemaForTns(((SDDocument.Schema)sdoc).getTargetNamespace(), sdoc.getURL().toExternalForm(), multiSchemaForTns);
351 }
352 }
353 if (LOGGER.isLoggable(Level.FINE)) {
354 LOGGER.log(Level.FINE, "WSDL inlined schema fragment documents(these are used to create a pseudo schema) = {0}", inlinedSchemas.keySet());
355 }
356 for(DOMSource src: inlinedSchemas.values()) {
357 String tns = getTargetNamespace(src);
358 updateMultiSchemaForTns(tns, src.getSystemId(), multiSchemaForTns);
359 }
361 if (multiSchemaForTns.isEmpty()) {
362 return new Source[0]; // WSDL doesn't have any schema fragments
363 } else if (multiSchemaForTns.size() == 1 && multiSchemaForTns.values().iterator().next().size() == 1) {
364 // It must be a inlined schema, otherwise there would be at least two schemas
365 String systemId = multiSchemaForTns.values().iterator().next().get(0);
366 return new Source[] {inlinedSchemas.get(systemId)};
367 }
369 // need to resolve these inlined schema fragments
370 mdresolver.addSchemas(inlinedSchemas.values());
372 // If there are multiple schema fragments for the same tns, create a
373 // pseudo schema for that tns by using <xsd:include> of those.
374 // tns --> systemId of a pseudo schema document (consolidated for that tns)
375 Map<String, String> oneSchemaForTns = new HashMap<String, String>();
376 int i = 0;
377 for(Map.Entry<String, List<String>> e: multiSchemaForTns.entrySet()) {
378 String systemId;
379 List<String> sameTnsSchemas = e.getValue();
380 if (sameTnsSchemas.size() > 1) {
381 // SDDocumentSource should be changed to take String systemId
382 // String pseudoSystemId = "urn:x-jax-ws-include-"+i++;
383 systemId = "file:x-jax-ws-include-"+i++;
384 Source src = createSameTnsPseudoSchema(e.getKey(), sameTnsSchemas, systemId);
385 mdresolver.addSchema(src);
386 } else {
387 systemId = sameTnsSchemas.get(0);
388 }
389 oneSchemaForTns.put(e.getKey(), systemId);
390 }
392 // create a master pseudo schema with all the different tns
393 Source pseudoSchema = createMasterPseudoSchema(oneSchemaForTns);
394 return new Source[] { pseudoSchema };
395 }
397 private @Nullable void addSchemaFragmentSource(Document doc, String systemId, Map<String, DOMSource> map) {
398 Element e = doc.getDocumentElement();
399 assert e.getNamespaceURI().equals(WSDLConstants.NS_WSDL);
400 assert e.getLocalName().equals("definitions");
402 NodeList typesList = e.getElementsByTagNameNS(WSDLConstants.NS_WSDL, "types");
403 for(int i=0; i < typesList.getLength(); i++) {
404 NodeList schemaList = ((Element)typesList.item(i)).getElementsByTagNameNS(WSDLConstants.NS_XMLNS, "schema");
405 for(int j=0; j < schemaList.getLength(); j++) {
406 Element elem = (Element)schemaList.item(j);
407 NamespaceSupport nss = new NamespaceSupport();
408 // Doing this because transformer is not picking up inscope namespaces
409 // why doesn't transformer pickup the inscope namespaces ??
410 buildNamespaceSupport(nss, elem);
411 patchDOMFragment(nss, elem);
412 String docId = systemId+"#schema"+j;
413 map.put(docId, new DOMSource(elem, docId));
414 }
415 }
416 }
419 /*
420 * Recursively visit ancestors and build up {@link org.xml.sax.helpers.NamespaceSupport} object.
421 */
422 private void buildNamespaceSupport(NamespaceSupport nss, Node node) {
423 if (node==null || node.getNodeType()!=Node.ELEMENT_NODE) {
424 return;
425 }
427 buildNamespaceSupport( nss, node.getParentNode() );
429 nss.pushContext();
430 NamedNodeMap atts = node.getAttributes();
431 for( int i=0; i<atts.getLength(); i++ ) {
432 Attr a = (Attr)atts.item(i);
433 if( "xmlns".equals(a.getPrefix()) ) {
434 nss.declarePrefix( a.getLocalName(), a.getValue() );
435 continue;
436 }
437 if( "xmlns".equals(a.getName()) ) {
438 nss.declarePrefix( "", a.getValue() );
439 //continue;
440 }
441 }
442 }
444 /**
445 * Adds inscope namespaces as attributes to <xsd:schema> fragment nodes.
446 *
447 * @param nss namespace context info
448 * @param elem that is patched with inscope namespaces
449 */
450 private @Nullable void patchDOMFragment(NamespaceSupport nss, Element elem) {
451 NamedNodeMap atts = elem.getAttributes();
452 for( Enumeration en = nss.getPrefixes(); en.hasMoreElements(); ) {
453 String prefix = (String)en.nextElement();
455 for( int i=0; i<atts.getLength(); i++ ) {
456 Attr a = (Attr)atts.item(i);
457 if (!"xmlns".equals(a.getPrefix()) || !a.getLocalName().equals(prefix)) {
458 if (LOGGER.isLoggable(Level.FINE)) {
459 LOGGER.log(Level.FINE, "Patching with xmlns:{0}={1}", new Object[]{prefix, nss.getURI(prefix)});
460 }
461 elem.setAttributeNS(XMLConstants.XMLNS_ATTRIBUTE_NS_URI, "xmlns:"+prefix, nss.getURI(prefix));
462 }
463 }
464 }
465 }
467 /*
468 * Creates a pseudo schema for the WSDL schema fragments that have the same
469 * targetNamespace.
470 *
471 * <xsd:schema targetNamespace="X">
472 * <xsd:include schemaLocation="Y1"/>
473 * <xsd:include schemaLocation="Y2"/>
474 * </xsd:schema>
475 *
476 * @param tns targetNamespace of the the schema documents
477 * @param docs collection of systemId for the schema documents that have the
478 * same tns, the collection must have more than one document
479 * @param psuedoSystemId for the created pseudo schema
480 * @return Source of pseudo schema that can be used multiple times
481 */
482 private @Nullable Source createSameTnsPseudoSchema(String tns, Collection<String> docs, String pseudoSystemId) {
483 assert docs.size() > 1;
485 final StringBuilder sb = new StringBuilder("<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'");
486 if (!tns.equals("")) {
487 sb.append(" targetNamespace='").append(tns).append("'");
488 }
489 sb.append(">\n");
490 for(String systemId : docs) {
491 sb.append("<xsd:include schemaLocation='").append(systemId).append("'/>\n");
492 }
493 sb.append("</xsd:schema>\n");
494 if (LOGGER.isLoggable(Level.FINE)) {
495 LOGGER.log(Level.FINE, "Pseudo Schema for the same tns={0}is {1}", new Object[]{tns, sb});
496 }
498 // override getReader() so that the same source can be used multiple times
499 return new StreamSource(pseudoSystemId) {
500 @Override
501 public Reader getReader() {
502 return new StringReader(sb.toString());
503 }
504 };
505 }
507 /*
508 * Creates a master pseudo schema importing all WSDL schema fragments with
509 * different tns+pseudo schema for same tns.
510 * <xsd:schema targetNamespace="urn:x-jax-ws-master">
511 * <xsd:import schemaLocation="Y1" namespace="X1"/>
512 * <xsd:import schemaLocation="Y2" namespace="X2"/>
513 * </xsd:schema>
514 *
515 * @param pseudo a map(tns-->systemId) of schema documents
516 * @return Source of pseudo schema that can be used multiple times
517 */
518 private Source createMasterPseudoSchema(Map<String, String> docs) {
519 final StringBuilder sb = new StringBuilder("<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema' targetNamespace='urn:x-jax-ws-master'>\n");
520 for(Map.Entry<String, String> e : docs.entrySet()) {
521 String systemId = e.getValue();
522 String ns = e.getKey();
523 sb.append("<xsd:import schemaLocation='").append(systemId).append("'");
524 if (!ns.equals("")) {
525 sb.append(" namespace='").append(ns).append("'");
526 }
527 sb.append("/>\n");
528 }
529 sb.append("</xsd:schema>");
530 if (LOGGER.isLoggable(Level.FINE)) {
531 LOGGER.log(Level.FINE, "Master Pseudo Schema = {0}", sb);
532 }
534 // override getReader() so that the same source can be used multiple times
535 return new StreamSource("file:x-jax-ws-master-doc") {
536 @Override
537 public Reader getReader() {
538 return new StringReader(sb.toString());
539 }
540 };
541 }
543 protected void doProcess(Packet packet) throws SAXException {
544 getValidator().reset();
545 Class<? extends ValidationErrorHandler> handlerClass = feature.getErrorHandler();
546 ValidationErrorHandler handler;
547 try {
548 handler = handlerClass.newInstance();
549 } catch(Exception e) {
550 throw new WebServiceException(e);
551 }
552 handler.setPacket(packet);
553 getValidator().setErrorHandler(handler);
554 Message msg = packet.getMessage().copy();
555 Source source = msg.readPayloadAsSource();
556 try {
557 // Validator javadoc allows ONLY SAX, and DOM Sources
558 // But the impl seems to handle all kinds.
559 getValidator().validate(source);
560 } catch(IOException e) {
561 throw new WebServiceException(e);
562 }
563 }
565 private String getTargetNamespace(DOMSource src) {
566 Element elem = (Element)src.getNode();
567 return elem.getAttribute("targetNamespace");
568 }
570 // protected static void printSource(Source src) {
571 // try {
572 // ByteArrayBuffer bos = new ByteArrayBuffer();
573 // StreamResult sr = new StreamResult(bos );
574 // Transformer trans = TransformerFactory.newInstance().newTransformer();
575 // trans.transform(src, sr);
576 // LOGGER.info("**** src ******"+bos.toString());
577 // bos.close();
578 // } catch(Exception e) {
579 // e.printStackTrace();
580 // }
581 // }
583 }