1 /*
2 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
3 */
4 /*
5 * Licensed to the Apache Software Foundation (ASF) under one or more
6 * contributor license agreements. See the NOTICE file distributed with
7 * this work for additional information regarding copyright ownership.
8 * The ASF licenses this file to You under the Apache License, Version 2.0
9 * (the "License"); you may not use this file except in compliance with
10 * the License. You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 package com.sun.org.apache.xerces.internal.jaxp.validation;
22
23 import com.sun.org.apache.xerces.internal.impl.Constants;
24 import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
25 import com.sun.org.apache.xerces.internal.impl.validation.EntityState;
26 import com.sun.org.apache.xerces.internal.impl.validation.ValidationManager;
27 import com.sun.org.apache.xerces.internal.impl.xs.XMLSchemaValidator;
28 import com.sun.org.apache.xerces.internal.impl.xs.util.SimpleLocator;
29 import com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl;
30 import com.sun.org.apache.xerces.internal.util.NamespaceSupport;
31 import com.sun.org.apache.xerces.internal.util.SymbolTable;
32 import com.sun.org.apache.xerces.internal.util.XMLAttributesImpl;
33 import com.sun.org.apache.xerces.internal.util.XMLSymbols;
34 import com.sun.org.apache.xerces.internal.xni.NamespaceContext;
35 import com.sun.org.apache.xerces.internal.xni.QName;
36 import com.sun.org.apache.xerces.internal.xni.XMLString;
37 import com.sun.org.apache.xerces.internal.xni.XNIException;
38 import com.sun.org.apache.xerces.internal.xni.parser.XMLParseException;
39 import java.io.IOException;
40 import java.util.Enumeration;
41 import javax.xml.parsers.DocumentBuilder;
42 import javax.xml.parsers.DocumentBuilderFactory;
43 import javax.xml.parsers.ParserConfigurationException;
44 import javax.xml.transform.Result;
45 import javax.xml.transform.Source;
46 import javax.xml.transform.dom.DOMResult;
47 import javax.xml.transform.dom.DOMSource;
48 import org.w3c.dom.Attr;
49 import org.w3c.dom.CDATASection;
50 import org.w3c.dom.Comment;
51 import org.w3c.dom.Document;
52 import org.w3c.dom.DocumentType;
53 import org.w3c.dom.Entity;
54 import org.w3c.dom.NamedNodeMap;
55 import org.w3c.dom.Node;
56 import org.w3c.dom.ProcessingInstruction;
57 import org.w3c.dom.Text;
58 import org.xml.sax.SAXException;
59
60 /**
61 * <p>A validator helper for <code>DOMSource</code>s.</p>
62 *
63 * @author Michael Glavassevich, IBM
64 * @LastModified: Oct 2017
65 */
66 final class DOMValidatorHelper implements ValidatorHelper, EntityState {
67
68 //
69 // Constants
70 //
71
72 /** Chunk size (1024). */
73 private static final int CHUNK_SIZE = (1 << 10);
74
75 /** Chunk mask (CHUNK_SIZE - 1). */
76 private static final int CHUNK_MASK = CHUNK_SIZE - 1;
77
78 // property identifiers
79
80 /** Property identifier: error reporter. */
81 private static final String ERROR_REPORTER =
82 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;
83
84 /** Property identifier: namespace context. */
85 private static final String NAMESPACE_CONTEXT =
86 Constants.XERCES_PROPERTY_PREFIX + Constants.NAMESPACE_CONTEXT_PROPERTY;
87
88 /** Property identifier: XML Schema validator. */
89 private static final String SCHEMA_VALIDATOR =
90 Constants.XERCES_PROPERTY_PREFIX + Constants.SCHEMA_VALIDATOR_PROPERTY;
91
92 /** Property identifier: symbol table. */
93 private static final String SYMBOL_TABLE =
94 Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;
95
96 /** Property identifier: validation manager. */
97 private static final String VALIDATION_MANAGER =
98 Constants.XERCES_PROPERTY_PREFIX + Constants.VALIDATION_MANAGER_PROPERTY;
99
100 //
101 // Data
102 //
103
104 /** Error reporter. */
105 private XMLErrorReporter fErrorReporter;
106
107 /** The namespace context of this document: stores namespaces in scope. **/
108 private NamespaceSupport fNamespaceContext;
109
110 /** The namespace context of the DOMSource, includes context from ancestor nodes. **/
111 private DOMNamespaceContext fDOMNamespaceContext = new DOMNamespaceContext();
112
113 /** Schema validator. **/
114 private XMLSchemaValidator fSchemaValidator;
115
116 /** Symbol table **/
117 private SymbolTable fSymbolTable;
118
119 /** Validation manager. **/
120 private ValidationManager fValidationManager;
121
122 /** Component manager. **/
123 private XMLSchemaValidatorComponentManager fComponentManager;
124
125 /** Simple Locator. **/
126 private final SimpleLocator fXMLLocator = new SimpleLocator(null, null, -1, -1, -1);
127
128 /** DOM document handler. **/
129 private DOMDocumentHandler fDOMValidatorHandler;
130
131 /** DOM result augmentor. **/
132 private final DOMResultAugmentor fDOMResultAugmentor = new DOMResultAugmentor(this);
133
134 /** DOM result builder. **/
135 private final DOMResultBuilder fDOMResultBuilder = new DOMResultBuilder();
136
137 /** Map for tracking unparsed entities. **/
138 private NamedNodeMap fEntities = null;
139
140 /** Array for holding character data. **/
141 private char [] fCharBuffer = new char[CHUNK_SIZE];
142
143 /** Root node. **/
144 private Node fRoot;
145
146 /** Current element. **/
147 private Node fCurrentElement;
148
149 /** Fields for start element, end element and characters. **/
150 final QName fElementQName = new QName();
151 final QName fAttributeQName = new QName();
152 final XMLAttributesImpl fAttributes = new XMLAttributesImpl();
153 final XMLString fTempString = new XMLString();
154
155 public DOMValidatorHelper(XMLSchemaValidatorComponentManager componentManager) {
156 fComponentManager = componentManager;
157 fErrorReporter = (XMLErrorReporter) fComponentManager.getProperty(ERROR_REPORTER);
158 fNamespaceContext = (NamespaceSupport) fComponentManager.getProperty(NAMESPACE_CONTEXT);
159 fSchemaValidator = (XMLSchemaValidator) fComponentManager.getProperty(SCHEMA_VALIDATOR);
160 fSymbolTable = (SymbolTable) fComponentManager.getProperty(SYMBOL_TABLE);
161 fValidationManager = (ValidationManager) fComponentManager.getProperty(VALIDATION_MANAGER);
162 }
163
164 /*
165 * ValidatorHelper methods
166 */
167
168 public void validate(Source source, Result result)
169 throws SAXException, IOException {
170 if (result instanceof DOMResult || result == null) {
171 final DOMSource domSource = (DOMSource) source;
172 final DOMResult domResult = (DOMResult) result;
173 Node node = domSource.getNode();
174 fRoot = node;
175 if (node != null) {
176 fComponentManager.reset();
177 fValidationManager.setEntityState(this);
178 fDOMNamespaceContext.reset();
179 String systemId = domSource.getSystemId();
180 fXMLLocator.setLiteralSystemId(systemId);
181 fXMLLocator.setExpandedSystemId(systemId);
182 fErrorReporter.setDocumentLocator(fXMLLocator);
183 try {
184 // regardless of what type of node this is, fire start and end document events
185 setupEntityMap((node.getNodeType() == Node.DOCUMENT_NODE) ? (Document) node : node.getOwnerDocument());
186 setupDOMResultHandler(domSource, domResult);
187 fSchemaValidator.startDocument(fXMLLocator, null, fDOMNamespaceContext, null);
188 validate(node);
189 fSchemaValidator.endDocument(null);
190 }
191 catch (XMLParseException e) {
192 throw Util.toSAXParseException(e);
193 }
194 catch (XNIException e) {
195 throw Util.toSAXException(e);
196 }
197 finally {
198 // Release references to application objects
199 fRoot = null;
200 //fCurrentElement = null; -- keep the reference to support current-element-node property
201 fEntities = null;
202 if (fDOMValidatorHandler != null) {
203 fDOMValidatorHandler.setDOMResult(null);
204 }
205 }
206 }
207 return;
208 }
209 throw new IllegalArgumentException(JAXPValidationMessageFormatter.formatMessage(fComponentManager.getLocale(),
210 "SourceResultMismatch",
211 new Object [] {source.getClass().getName(), result.getClass().getName()}));
212 }
213
214 /*
215 * EntityState methods
216 */
217
218 public boolean isEntityDeclared(String name) {
219 return false;
220 }
221
222 public boolean isEntityUnparsed(String name) {
223 if (fEntities != null) {
224 Entity entity = (Entity) fEntities.getNamedItem(name);
225 if (entity != null) {
226 return (entity.getNotationName() != null);
227 }
228 }
229 return false;
230 }
231
232 /*
233 * Other methods
234 */
235
236 /** Traverse the DOM and fire events to the schema validator. */
237 private void validate(Node node) {
238 final Node top = node;
239 // Performs a non-recursive traversal of the DOM. This
240 // will avoid a stack overflow for DOMs with high depth.
241 while (node != null) {
242 beginNode(node);
243 Node next = node.getFirstChild();
244 while (next == null) {
245 finishNode(node);
246 if (top == node) {
247 break;
248 }
249 next = node.getNextSibling();
250 if (next == null) {
251 node = node.getParentNode();
252 if (node == null || top == node) {
253 if (node != null) {
254 finishNode(node);
255 }
256 next = null;
257 break;
258 }
259 }
260 }
261 node = next;
262 }
263 }
264
265 /** Do processing for the start of a node. */
266 private void beginNode(Node node) {
267 switch (node.getNodeType()) {
268 case Node.ELEMENT_NODE:
269 fCurrentElement = node;
270 // push namespace context
271 fNamespaceContext.pushContext();
272 // start element
273 fillQName(fElementQName, node);
274 processAttributes(node.getAttributes());
275 fSchemaValidator.startElement(fElementQName, fAttributes, null);
276 break;
277 case Node.TEXT_NODE:
278 if (fDOMValidatorHandler != null) {
279 fDOMValidatorHandler.setIgnoringCharacters(true);
280 sendCharactersToValidator(node.getNodeValue());
281 fDOMValidatorHandler.setIgnoringCharacters(false);
282 fDOMValidatorHandler.characters((Text) node);
283 }
284 else {
285 sendCharactersToValidator(node.getNodeValue());
286 }
287 break;
288 case Node.CDATA_SECTION_NODE:
289 if (fDOMValidatorHandler != null) {
290 fDOMValidatorHandler.setIgnoringCharacters(true);
291 fSchemaValidator.startCDATA(null);
292 sendCharactersToValidator(node.getNodeValue());
293 fSchemaValidator.endCDATA(null);
294 fDOMValidatorHandler.setIgnoringCharacters(false);
295 fDOMValidatorHandler.cdata((CDATASection) node);
296 }
297 else {
298 fSchemaValidator.startCDATA(null);
299 sendCharactersToValidator(node.getNodeValue());
300 fSchemaValidator.endCDATA(null);
301 }
302 break;
303 case Node.PROCESSING_INSTRUCTION_NODE:
304 /**
305 * The validator does nothing with processing instructions so bypass it.
306 * Send the ProcessingInstruction node directly to the result builder.
307 */
308 if (fDOMValidatorHandler != null) {
309 fDOMValidatorHandler.processingInstruction((ProcessingInstruction) node);
310 }
311 break;
312 case Node.COMMENT_NODE:
313 /**
314 * The validator does nothing with comments so bypass it.
315 * Send the Comment node directly to the result builder.
316 */
317 if (fDOMValidatorHandler != null) {
318 fDOMValidatorHandler.comment((Comment) node);
319 }
320 break;
321 case Node.DOCUMENT_TYPE_NODE:
322 /**
323 * Send the DocumentType node directly to the result builder.
324 */
325 if (fDOMValidatorHandler != null) {
326 fDOMValidatorHandler.doctypeDecl((DocumentType) node);
327 }
328 break;
329 default: // Ignore other node types.
330 break;
331 }
332 }
333
334 /** Do processing for the end of a node. */
335 private void finishNode(Node node) {
336 if (node.getNodeType() == Node.ELEMENT_NODE) {
337 fCurrentElement = node;
338 // end element
339 fillQName(fElementQName, node);
340 fSchemaValidator.endElement(fElementQName, null);
341 // pop namespace context
342 fNamespaceContext.popContext();
343 }
344 }
345
346 /**
347 * Extracts NamedNodeMap of entities. We need this to validate
348 * elements and attributes of type xs:ENTITY, xs:ENTITIES or
349 * types dervied from them.
350 */
351 private void setupEntityMap(Document doc) {
352 if (doc != null) {
353 DocumentType docType = doc.getDoctype();
354 if (docType != null) {
355 fEntities = docType.getEntities();
356 return;
357 }
358 }
359 fEntities = null;
360 }
361
362 /**
363 * Sets up handler for <code>DOMResult</code>.
364 */
365 private void setupDOMResultHandler(DOMSource source, DOMResult result) throws SAXException {
366 // If there's no DOMResult, unset the validator handler
367 if (result == null) {
368 fDOMValidatorHandler = null;
369 fSchemaValidator.setDocumentHandler(null);
370 return;
371 }
372 final Node nodeResult = result.getNode();
373 // If the source node and result node are the same use the DOMResultAugmentor.
374 // Otherwise use the DOMResultBuilder.
375 if (source.getNode() == nodeResult) {
376 fDOMValidatorHandler = fDOMResultAugmentor;
377 fDOMResultAugmentor.setDOMResult(result);
378 fSchemaValidator.setDocumentHandler(fDOMResultAugmentor);
379 return;
380 }
381 if (result.getNode() == null) {
382 try {
383 DocumentBuilderFactory factory = fComponentManager.getFeature(Constants.ORACLE_FEATURE_SERVICE_MECHANISM) ?
384 DocumentBuilderFactory.newInstance() : new DocumentBuilderFactoryImpl();
385 factory.setNamespaceAware(true);
386 DocumentBuilder builder = factory.newDocumentBuilder();
387 result.setNode(builder.newDocument());
388 }
389 catch (ParserConfigurationException e) {
390 throw new SAXException(e);
391 }
392 }
393 fDOMValidatorHandler = fDOMResultBuilder;
394 fDOMResultBuilder.setDOMResult(result);
395 fSchemaValidator.setDocumentHandler(fDOMResultBuilder);
396 }
397
398 private void fillQName(QName toFill, Node node) {
399 final String prefix = node.getPrefix();
400 final String localName = node.getLocalName();
401 final String rawName = node.getNodeName();
402 final String namespace = node.getNamespaceURI();
403
404 toFill.uri = (namespace != null && namespace.length() > 0) ? fSymbolTable.addSymbol(namespace) : null;
405 toFill.rawname = (rawName != null) ? fSymbolTable.addSymbol(rawName) : XMLSymbols.EMPTY_STRING;
406
407 // Is this a DOM level1 document?
408 if (localName == null) {
409 int k = rawName.indexOf(':');
410 if (k > 0) {
411 toFill.prefix = fSymbolTable.addSymbol(rawName.substring(0, k));
412 toFill.localpart = fSymbolTable.addSymbol(rawName.substring(k + 1));
413 }
414 else {
415 toFill.prefix = XMLSymbols.EMPTY_STRING;
416 toFill.localpart = toFill.rawname;
417 }
418 }
419 else {
420 toFill.prefix = (prefix != null) ? fSymbolTable.addSymbol(prefix) : XMLSymbols.EMPTY_STRING;
421 toFill.localpart = (localName != null) ? fSymbolTable.addSymbol(localName) : XMLSymbols.EMPTY_STRING;
422 }
423 }
424
425 private void processAttributes(NamedNodeMap attrMap) {
426 final int attrCount = attrMap.getLength();
427 fAttributes.removeAllAttributes();
428 for (int i = 0; i < attrCount; ++i) {
429 Attr attr = (Attr) attrMap.item(i);
430 String value = attr.getValue();
431 if (value == null) {
432 value = XMLSymbols.EMPTY_STRING;
433 }
434 fillQName(fAttributeQName, attr);
435 // REVISIT: Assuming all attributes are of type CDATA. The actual type may not matter. -- mrglavas
436 fAttributes.addAttributeNS(fAttributeQName, XMLSymbols.fCDATASymbol, value);
437 fAttributes.setSpecified(i, attr.getSpecified());
438 // REVISIT: Should we be looking at non-namespace attributes
439 // for additional mappings? Should we detect illegal namespace
440 // declarations and exclude them from the context? -- mrglavas
441 if (fAttributeQName.uri == NamespaceContext.XMLNS_URI) {
442 // process namespace attribute
443 if (fAttributeQName.prefix == XMLSymbols.PREFIX_XMLNS) {
444 fNamespaceContext.declarePrefix(fAttributeQName.localpart, value.length() != 0 ? fSymbolTable.addSymbol(value) : null);
445 }
446 else {
447 fNamespaceContext.declarePrefix(XMLSymbols.EMPTY_STRING, value.length() != 0 ? fSymbolTable.addSymbol(value) : null);
448 }
449 }
450 }
451 }
452
453 private void sendCharactersToValidator(String str) {
454 if (str != null) {
455 final int length = str.length();
456 final int remainder = length & CHUNK_MASK;
457 if (remainder > 0) {
458 str.getChars(0, remainder, fCharBuffer, 0);
459 fTempString.setValues(fCharBuffer, 0, remainder);
460 fSchemaValidator.characters(fTempString, null);
461 }
462 int i = remainder;
463 while (i < length) {
464 str.getChars(i, i += CHUNK_SIZE, fCharBuffer, 0);
465 fTempString.setValues(fCharBuffer, 0, CHUNK_SIZE);
466 fSchemaValidator.characters(fTempString, null);
467 }
468 }
469 }
470
471 Node getCurrentElement() {
472 return fCurrentElement;
473 }
474
475 /**
476 * NamespaceContext for the DOMSource, includes context for ancestor nodes.
477 */
478 final class DOMNamespaceContext implements NamespaceContext {
479
480 //
481 // Data
482 //
483
484 /**
485 * Namespace binding information. This array is composed of a
486 * series of tuples containing the namespace binding information:
487 * <prefix, uri>.
488 */
489 protected String[] fNamespace = new String[16 * 2];
490
491 /** The size of the namespace information array. */
492 protected int fNamespaceSize = 0;
493
494 /**
495 * Flag indicating whether the namespace context
496 * has been from the root node's ancestors.
497 */
498 protected boolean fDOMContextBuilt = false;
499
500 //
501 // Methods
502 //
503
504 public void pushContext() {
505 fNamespaceContext.pushContext();
506 }
507
508 public void popContext() {
509 fNamespaceContext.popContext();
510 }
511
512 public boolean declarePrefix(String prefix, String uri) {
513 return fNamespaceContext.declarePrefix(prefix, uri);
514 }
515
516 public String getURI(String prefix) {
517 String uri = fNamespaceContext.getURI(prefix);
518 if (uri == null) {
519 if (!fDOMContextBuilt) {
520 fillNamespaceContext();
521 fDOMContextBuilt = true;
522 }
523 if (fNamespaceSize > 0 &&
524 !fNamespaceContext.containsPrefix(prefix)) {
525 uri = getURI0(prefix);
526 }
527 }
528 return uri;
529 }
530
531 public String getPrefix(String uri) {
532 return fNamespaceContext.getPrefix(uri);
533 }
534
535 public int getDeclaredPrefixCount() {
536 return fNamespaceContext.getDeclaredPrefixCount();
537 }
538
539 public String getDeclaredPrefixAt(int index) {
540 return fNamespaceContext.getDeclaredPrefixAt(index);
541 }
542
543 public Enumeration<String> getAllPrefixes() {
544 return fNamespaceContext.getAllPrefixes();
545 }
546
547 public void reset() {
548 fDOMContextBuilt = false;
549 fNamespaceSize = 0;
550 }
551
552 private void fillNamespaceContext() {
553 if (fRoot != null) {
554 Node currentNode = fRoot.getParentNode();
555 while (currentNode != null) {
556 if (Node.ELEMENT_NODE == currentNode.getNodeType()) {
557 NamedNodeMap attributes = currentNode.getAttributes();
558 final int attrCount = attributes.getLength();
559 for (int i = 0; i < attrCount; ++i) {
560 Attr attr = (Attr) attributes.item(i);
561 String value = attr.getValue();
562 if (value == null) {
563 value = XMLSymbols.EMPTY_STRING;
564 }
565 fillQName(fAttributeQName, attr);
566 // REVISIT: Should we be looking at non-namespace attributes
567 // for additional mappings? Should we detect illegal namespace
568 // declarations and exclude them from the context? -- mrglavas
569 if (fAttributeQName.uri == NamespaceContext.XMLNS_URI) {
570 // process namespace attribute
571 if (fAttributeQName.prefix == XMLSymbols.PREFIX_XMLNS) {
572 declarePrefix0(fAttributeQName.localpart, value.length() != 0 ? fSymbolTable.addSymbol(value) : null);
573 }
574 else {
575 declarePrefix0(XMLSymbols.EMPTY_STRING, value.length() != 0 ? fSymbolTable.addSymbol(value) : null);
576 }
577 }
578 }
579
580 }
581 currentNode = currentNode.getParentNode();
582 }
583 }
584 }
585
586 private void declarePrefix0(String prefix, String uri) {
587 // resize array, if needed
588 if (fNamespaceSize == fNamespace.length) {
589 String[] namespacearray = new String[fNamespaceSize * 2];
590 System.arraycopy(fNamespace, 0, namespacearray, 0, fNamespaceSize);
591 fNamespace = namespacearray;
592 }
593
594 // bind prefix to uri in current context
595 fNamespace[fNamespaceSize++] = prefix;
596 fNamespace[fNamespaceSize++] = uri;
597 }
598
599 private String getURI0(String prefix) {
600 // find prefix in the DOM context
601 for (int i = 0; i < fNamespaceSize; i += 2) {
602 if (fNamespace[i] == prefix) {
603 return fNamespace[i + 1];
604 }
605 }
606 // prefix not found
607 return null;
608 }
609 }
610
611 } // DOMValidatorHelper