You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
739 lines
30 KiB
739 lines
30 KiB
/*
|
|
* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
|
|
*/
|
|
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.sun.org.apache.xerces.internal.jaxp;
|
|
|
|
import com.sun.org.apache.xerces.internal.impl.Constants;
|
|
import com.sun.org.apache.xerces.internal.impl.validation.ValidationManager;
|
|
import com.sun.org.apache.xerces.internal.impl.xs.XMLSchemaValidator;
|
|
import com.sun.org.apache.xerces.internal.jaxp.validation.XSGrammarPoolContainer;
|
|
import com.sun.org.apache.xerces.internal.util.SAXMessageFormatter;
|
|
import com.sun.org.apache.xerces.internal.util.Status;
|
|
import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager;
|
|
import com.sun.org.apache.xerces.internal.utils.XMLSecurityPropertyManager;
|
|
import com.sun.org.apache.xerces.internal.xni.XMLDocumentHandler;
|
|
import com.sun.org.apache.xerces.internal.xni.parser.XMLComponent;
|
|
import com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;
|
|
import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
|
|
import com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentSource;
|
|
import com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfiguration;
|
|
import com.sun.org.apache.xerces.internal.xs.AttributePSVI;
|
|
import com.sun.org.apache.xerces.internal.xs.ElementPSVI;
|
|
import com.sun.org.apache.xerces.internal.xs.PSVIProvider;
|
|
import java.io.IOException;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import javax.xml.XMLConstants;
|
|
import javax.xml.validation.Schema;
|
|
import org.xml.sax.EntityResolver;
|
|
import org.xml.sax.ErrorHandler;
|
|
import org.xml.sax.HandlerBase;
|
|
import org.xml.sax.InputSource;
|
|
import org.xml.sax.Parser;
|
|
import org.xml.sax.SAXException;
|
|
import org.xml.sax.SAXNotRecognizedException;
|
|
import org.xml.sax.SAXNotSupportedException;
|
|
import org.xml.sax.XMLReader;
|
|
import org.xml.sax.helpers.DefaultHandler;
|
|
|
|
/**
|
|
* This is the implementation specific class for the
|
|
* <code>javax.xml.parsers.SAXParser</code>.
|
|
*
|
|
* @author Rajiv Mordani
|
|
* @author Edwin Goei
|
|
*
|
|
* @version $Id: SAXParserImpl.java,v 1.7 2010-11-01 04:40:06 joehw Exp $
|
|
*/
|
|
public class SAXParserImpl extends javax.xml.parsers.SAXParser
|
|
implements JAXPConstants, PSVIProvider {
|
|
|
|
/** Feature identifier: namespaces. */
|
|
private static final String NAMESPACES_FEATURE =
|
|
Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE;
|
|
|
|
/** Feature identifier: namespace prefixes. */
|
|
private static final String NAMESPACE_PREFIXES_FEATURE =
|
|
Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACE_PREFIXES_FEATURE;
|
|
|
|
/** Feature identifier: validation. */
|
|
private static final String VALIDATION_FEATURE =
|
|
Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;
|
|
|
|
/** Feature identifier: XML Schema validation */
|
|
private static final String XMLSCHEMA_VALIDATION_FEATURE =
|
|
Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_VALIDATION_FEATURE;
|
|
|
|
/** Feature identifier: XInclude processing */
|
|
private static final String XINCLUDE_FEATURE =
|
|
Constants.XERCES_FEATURE_PREFIX + Constants.XINCLUDE_FEATURE;
|
|
|
|
/** Property identifier: security manager. */
|
|
private static final String SECURITY_MANAGER =
|
|
Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;
|
|
|
|
/** Property identifier: Security property manager. */
|
|
private static final String XML_SECURITY_PROPERTY_MANAGER =
|
|
Constants.XML_SECURITY_PROPERTY_MANAGER;
|
|
|
|
private final JAXPSAXParser xmlReader;
|
|
private String schemaLanguage = null; // null means DTD
|
|
private final Schema grammar;
|
|
|
|
private final XMLComponent fSchemaValidator;
|
|
private final XMLComponentManager fSchemaValidatorComponentManager;
|
|
private final ValidationManager fSchemaValidationManager;
|
|
private final UnparsedEntityHandler fUnparsedEntityHandler;
|
|
|
|
/** Initial ErrorHandler */
|
|
private final ErrorHandler fInitErrorHandler;
|
|
|
|
/** Initial EntityResolver */
|
|
private final EntityResolver fInitEntityResolver;
|
|
|
|
private final XMLSecurityManager fSecurityManager;
|
|
private final XMLSecurityPropertyManager fSecurityPropertyMgr;
|
|
|
|
/**
|
|
* Create a SAX parser with the associated features
|
|
* @param features Map of SAX features, may be null
|
|
*/
|
|
SAXParserImpl(SAXParserFactoryImpl spf, Map<String, Boolean> features)
|
|
throws SAXException {
|
|
this(spf, features, false);
|
|
}
|
|
|
|
/**
|
|
* Create a SAX parser with the associated features
|
|
* @param features Map of SAX features, may be null
|
|
*/
|
|
SAXParserImpl(SAXParserFactoryImpl spf, Map<String, Boolean> features, boolean secureProcessing)
|
|
throws SAXException
|
|
{
|
|
fSecurityManager = new XMLSecurityManager(secureProcessing);
|
|
fSecurityPropertyMgr = new XMLSecurityPropertyManager();
|
|
// Instantiate a SAXParser directly and not through SAX so that we use the right ClassLoader
|
|
xmlReader = new JAXPSAXParser(this, fSecurityPropertyMgr, fSecurityManager);
|
|
|
|
// JAXP "namespaceAware" == SAX Namespaces feature
|
|
// Note: there is a compatibility problem here with default values:
|
|
// JAXP default is false while SAX 2 default is true!
|
|
xmlReader.setFeature0(NAMESPACES_FEATURE, spf.isNamespaceAware());
|
|
|
|
// SAX "namespaces" and "namespace-prefixes" features should not
|
|
// both be false. We make them opposite for backward compatibility
|
|
// since JAXP 1.0 apps may want to receive xmlns* attributes.
|
|
xmlReader.setFeature0(NAMESPACE_PREFIXES_FEATURE, !spf.isNamespaceAware());
|
|
|
|
// Avoid setting the XInclude processing feature if the value is false.
|
|
// This will keep the configuration from throwing an exception if it
|
|
// does not support XInclude.
|
|
if (spf.isXIncludeAware()) {
|
|
xmlReader.setFeature0(XINCLUDE_FEATURE, true);
|
|
}
|
|
|
|
xmlReader.setProperty0(XML_SECURITY_PROPERTY_MANAGER, fSecurityPropertyMgr);
|
|
|
|
xmlReader.setProperty0(SECURITY_MANAGER, fSecurityManager);
|
|
|
|
if (secureProcessing) {
|
|
/**
|
|
* By default, secure processing is set, no external access is allowed.
|
|
* However, we need to check if it is actively set on the factory since we
|
|
* allow the use of the System Property or jaxp.properties to override
|
|
* the default value
|
|
*/
|
|
if (features != null) {
|
|
|
|
Boolean temp = features.get(XMLConstants.FEATURE_SECURE_PROCESSING);
|
|
if (temp != null) {
|
|
if (temp && Constants.IS_JDK8_OR_ABOVE) {
|
|
fSecurityPropertyMgr.setValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_DTD,
|
|
XMLSecurityPropertyManager.State.FSP, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
|
|
fSecurityPropertyMgr.setValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_SCHEMA,
|
|
XMLSecurityPropertyManager.State.FSP, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set application's features, followed by validation features.
|
|
setFeatures(features);
|
|
|
|
// If validating, provide a default ErrorHandler that prints
|
|
// validation errors with a warning telling the user to set an
|
|
// ErrorHandler.
|
|
if (spf.isValidating()) {
|
|
fInitErrorHandler = new DefaultValidationErrorHandler(xmlReader.getLocale());
|
|
xmlReader.setErrorHandler(fInitErrorHandler);
|
|
}
|
|
else {
|
|
fInitErrorHandler = xmlReader.getErrorHandler();
|
|
}
|
|
xmlReader.setFeature0(VALIDATION_FEATURE, spf.isValidating());
|
|
|
|
// Get the Schema object from the factory
|
|
this.grammar = spf.getSchema();
|
|
if (grammar != null) {
|
|
XMLParserConfiguration config = xmlReader.getXMLParserConfiguration();
|
|
XMLComponent validatorComponent = null;
|
|
/** For Xerces grammars, use built-in schema validator. **/
|
|
if (grammar instanceof XSGrammarPoolContainer) {
|
|
validatorComponent = new XMLSchemaValidator();
|
|
fSchemaValidationManager = new ValidationManager();
|
|
fUnparsedEntityHandler = new UnparsedEntityHandler(fSchemaValidationManager);
|
|
config.setDTDHandler(fUnparsedEntityHandler);
|
|
fUnparsedEntityHandler.setDTDHandler(xmlReader);
|
|
xmlReader.setDTDSource(fUnparsedEntityHandler);
|
|
fSchemaValidatorComponentManager = new SchemaValidatorConfiguration(config,
|
|
(XSGrammarPoolContainer) grammar, fSchemaValidationManager);
|
|
}
|
|
/** For third party grammars, use the JAXP validator component. **/
|
|
else {
|
|
validatorComponent = new JAXPValidatorComponent(grammar.newValidatorHandler());
|
|
fSchemaValidationManager = null;
|
|
fUnparsedEntityHandler = null;
|
|
fSchemaValidatorComponentManager = config;
|
|
}
|
|
config.addRecognizedFeatures(validatorComponent.getRecognizedFeatures());
|
|
config.addRecognizedProperties(validatorComponent.getRecognizedProperties());
|
|
config.setDocumentHandler((XMLDocumentHandler) validatorComponent);
|
|
((XMLDocumentSource)validatorComponent).setDocumentHandler(xmlReader);
|
|
xmlReader.setDocumentSource((XMLDocumentSource) validatorComponent);
|
|
fSchemaValidator = validatorComponent;
|
|
}
|
|
else {
|
|
fSchemaValidationManager = null;
|
|
fUnparsedEntityHandler = null;
|
|
fSchemaValidatorComponentManager = null;
|
|
fSchemaValidator = null;
|
|
}
|
|
|
|
// Initial EntityResolver
|
|
fInitEntityResolver = xmlReader.getEntityResolver();
|
|
}
|
|
|
|
/**
|
|
* Set any features of our XMLReader based on any features set on the
|
|
* SAXParserFactory.
|
|
*
|
|
* XXX Does not handle possible conflicts between SAX feature names and
|
|
* JAXP specific feature names, eg. SAXParserFactory.isValidating()
|
|
*/
|
|
private void setFeatures(Map<String, Boolean> features)
|
|
throws SAXNotSupportedException, SAXNotRecognizedException {
|
|
if (features != null) {
|
|
for (Map.Entry<String, Boolean> entry : features.entrySet()) {
|
|
xmlReader.setFeature0(entry.getKey(), entry.getValue());
|
|
}
|
|
}
|
|
}
|
|
|
|
public Parser getParser() throws SAXException {
|
|
// Xerces2 AbstractSAXParser implements SAX1 Parser
|
|
// assert(xmlReader instanceof Parser);
|
|
return (Parser) xmlReader;
|
|
}
|
|
|
|
/**
|
|
* Returns the XMLReader that is encapsulated by the implementation of
|
|
* this class.
|
|
*/
|
|
public XMLReader getXMLReader() {
|
|
return xmlReader;
|
|
}
|
|
|
|
public boolean isNamespaceAware() {
|
|
try {
|
|
return xmlReader.getFeature(NAMESPACES_FEATURE);
|
|
}
|
|
catch (SAXException x) {
|
|
throw new IllegalStateException(x.getMessage());
|
|
}
|
|
}
|
|
|
|
public boolean isValidating() {
|
|
try {
|
|
return xmlReader.getFeature(VALIDATION_FEATURE);
|
|
}
|
|
catch (SAXException x) {
|
|
throw new IllegalStateException(x.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the XInclude processing mode for this parser
|
|
* @return the state of XInclude processing mode
|
|
*/
|
|
public boolean isXIncludeAware() {
|
|
try {
|
|
return xmlReader.getFeature(XINCLUDE_FEATURE);
|
|
}
|
|
catch (SAXException exc) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the particular property in the underlying implementation of
|
|
* org.xml.sax.XMLReader.
|
|
*/
|
|
public void setProperty(String name, Object value)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
xmlReader.setProperty(name, value);
|
|
}
|
|
|
|
/**
|
|
* returns the particular property requested for in the underlying
|
|
* implementation of org.xml.sax.XMLReader.
|
|
*/
|
|
public Object getProperty(String name)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
return xmlReader.getProperty(name);
|
|
}
|
|
|
|
public void parse(InputSource is, DefaultHandler dh)
|
|
throws SAXException, IOException {
|
|
if (is == null) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
if (dh != null) {
|
|
xmlReader.setContentHandler(dh);
|
|
xmlReader.setEntityResolver(dh);
|
|
xmlReader.setErrorHandler(dh);
|
|
xmlReader.setDTDHandler(dh);
|
|
xmlReader.setDocumentHandler(null);
|
|
}
|
|
xmlReader.parse(is);
|
|
}
|
|
|
|
public void parse(InputSource is, HandlerBase hb)
|
|
throws SAXException, IOException {
|
|
if (is == null) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
if (hb != null) {
|
|
xmlReader.setDocumentHandler(hb);
|
|
xmlReader.setEntityResolver(hb);
|
|
xmlReader.setErrorHandler(hb);
|
|
xmlReader.setDTDHandler(hb);
|
|
xmlReader.setContentHandler(null);
|
|
}
|
|
xmlReader.parse(is);
|
|
}
|
|
|
|
public Schema getSchema() {
|
|
return grammar;
|
|
}
|
|
|
|
public void reset() {
|
|
try {
|
|
/** Restore initial values of features and properties. **/
|
|
xmlReader.restoreInitState();
|
|
}
|
|
catch (SAXException exc) {
|
|
// This should never happen. We only store recognized
|
|
// features and properties in the hash maps. For now
|
|
// just ignore it.
|
|
}
|
|
/** Restore various handlers. **/
|
|
xmlReader.setContentHandler(null);
|
|
xmlReader.setDTDHandler(null);
|
|
if (xmlReader.getErrorHandler() != fInitErrorHandler) {
|
|
xmlReader.setErrorHandler(fInitErrorHandler);
|
|
}
|
|
if (xmlReader.getEntityResolver() != fInitEntityResolver) {
|
|
xmlReader.setEntityResolver(fInitEntityResolver);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* PSVIProvider methods
|
|
*/
|
|
|
|
public ElementPSVI getElementPSVI() {
|
|
return ((PSVIProvider)xmlReader).getElementPSVI();
|
|
}
|
|
|
|
public AttributePSVI getAttributePSVI(int index) {
|
|
return ((PSVIProvider)xmlReader).getAttributePSVI(index);
|
|
}
|
|
|
|
public AttributePSVI getAttributePSVIByName(String uri, String localname) {
|
|
return ((PSVIProvider)xmlReader).getAttributePSVIByName(uri, localname);
|
|
}
|
|
|
|
/**
|
|
* Extension of SAXParser. This class tracks changes to
|
|
* features and properties to allow the parser to be reset to
|
|
* its initial state.
|
|
*/
|
|
public static class JAXPSAXParser extends com.sun.org.apache.xerces.internal.parsers.SAXParser {
|
|
|
|
private final HashMap fInitFeatures = new HashMap();
|
|
private final HashMap fInitProperties = new HashMap();
|
|
private final SAXParserImpl fSAXParser;
|
|
private XMLSecurityManager fSecurityManager;
|
|
private XMLSecurityPropertyManager fSecurityPropertyMgr;
|
|
|
|
|
|
public JAXPSAXParser() {
|
|
this(null, null, null);
|
|
}
|
|
|
|
JAXPSAXParser(SAXParserImpl saxParser, XMLSecurityPropertyManager securityPropertyMgr,
|
|
XMLSecurityManager securityManager) {
|
|
super();
|
|
fSAXParser = saxParser;
|
|
fSecurityManager = securityManager;
|
|
fSecurityPropertyMgr = securityPropertyMgr;
|
|
/**
|
|
* This class may be used directly. So initialize the security manager if
|
|
* it is null.
|
|
*/
|
|
if (fSecurityManager == null) {
|
|
fSecurityManager = new XMLSecurityManager(true);
|
|
try {
|
|
super.setProperty(SECURITY_MANAGER, fSecurityManager);
|
|
} catch (SAXException e) {
|
|
throw new UnsupportedOperationException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
|
|
"property-not-recognized", new Object [] {SECURITY_MANAGER}), e);
|
|
}
|
|
}
|
|
if (fSecurityPropertyMgr == null) {
|
|
fSecurityPropertyMgr = new XMLSecurityPropertyManager();
|
|
try {
|
|
super.setProperty(XML_SECURITY_PROPERTY_MANAGER, fSecurityPropertyMgr);
|
|
} catch (SAXException e) {
|
|
throw new UnsupportedOperationException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
|
|
"property-not-recognized", new Object [] {SECURITY_MANAGER}), e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Override SAXParser's setFeature method to track the initial state
|
|
* of features. This keeps us from affecting the performance of the
|
|
* SAXParser when it is created with XMLReaderFactory.
|
|
*/
|
|
public synchronized void setFeature(String name, boolean value)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
if (name == null) {
|
|
// TODO: Add localized error message.
|
|
throw new NullPointerException();
|
|
}
|
|
if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
|
|
try {
|
|
fSecurityManager.setSecureProcessing(value);
|
|
setProperty(SECURITY_MANAGER, fSecurityManager);
|
|
}
|
|
catch (SAXNotRecognizedException exc) {
|
|
// If the property is not supported
|
|
// re-throw the exception if the value is true.
|
|
if (value) {
|
|
throw exc;
|
|
}
|
|
}
|
|
catch (SAXNotSupportedException exc) {
|
|
// If the property is not supported
|
|
// re-throw the exception if the value is true.
|
|
if (value) {
|
|
throw exc;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (!fInitFeatures.containsKey(name)) {
|
|
boolean current = super.getFeature(name);
|
|
fInitFeatures.put(name, current ? Boolean.TRUE : Boolean.FALSE);
|
|
}
|
|
/** Forward feature to the schema validator if there is one. **/
|
|
if (fSAXParser != null && fSAXParser.fSchemaValidator != null) {
|
|
setSchemaValidatorFeature(name, value);
|
|
}
|
|
super.setFeature(name, value);
|
|
}
|
|
|
|
public synchronized boolean getFeature(String name)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
if (name == null) {
|
|
// TODO: Add localized error message.
|
|
throw new NullPointerException();
|
|
}
|
|
if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
|
|
return fSecurityManager.isSecureProcessing();
|
|
}
|
|
return super.getFeature(name);
|
|
}
|
|
|
|
/**
|
|
* Override SAXParser's setProperty method to track the initial state
|
|
* of properties. This keeps us from affecting the performance of the
|
|
* SAXParser when it is created with XMLReaderFactory.
|
|
*/
|
|
public synchronized void setProperty(String name, Object value)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
if (name == null) {
|
|
// TODO: Add localized error message.
|
|
throw new NullPointerException();
|
|
}
|
|
if (fSAXParser != null) {
|
|
// JAXP 1.2 support
|
|
if (JAXP_SCHEMA_LANGUAGE.equals(name)) {
|
|
// The spec says if a schema is given via SAXParserFactory
|
|
// the JAXP 1.2 properties shouldn't be allowed.
|
|
if (fSAXParser.grammar != null) {
|
|
throw new SAXNotSupportedException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(), "schema-already-specified", new Object[] {name}));
|
|
}
|
|
if ( W3C_XML_SCHEMA.equals(value) ) {
|
|
//None of the properties will take effect till the setValidating(true) has been called
|
|
if( fSAXParser.isValidating() ) {
|
|
fSAXParser.schemaLanguage = W3C_XML_SCHEMA;
|
|
setFeature(XMLSCHEMA_VALIDATION_FEATURE, true);
|
|
// this will allow the parser not to emit DTD-related
|
|
// errors, as the spec demands
|
|
if (!fInitProperties.containsKey(JAXP_SCHEMA_LANGUAGE)) {
|
|
fInitProperties.put(JAXP_SCHEMA_LANGUAGE, super.getProperty(JAXP_SCHEMA_LANGUAGE));
|
|
}
|
|
super.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);
|
|
}
|
|
|
|
}
|
|
else if (value == null) {
|
|
fSAXParser.schemaLanguage = null;
|
|
setFeature(XMLSCHEMA_VALIDATION_FEATURE, false);
|
|
}
|
|
else {
|
|
// REVISIT: It would be nice if we could format this message
|
|
// using a user specified locale as we do in the underlying
|
|
// XMLReader -- mrglavas
|
|
throw new SAXNotSupportedException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(), "schema-not-supported", null));
|
|
}
|
|
return;
|
|
}
|
|
else if (JAXP_SCHEMA_SOURCE.equals(name)) {
|
|
// The spec says if a schema is given via SAXParserFactory
|
|
// the JAXP 1.2 properties shouldn't be allowed.
|
|
if (fSAXParser.grammar != null) {
|
|
throw new SAXNotSupportedException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(), "schema-already-specified", new Object[] {name}));
|
|
}
|
|
String val = (String)getProperty(JAXP_SCHEMA_LANGUAGE);
|
|
if ( val != null && W3C_XML_SCHEMA.equals(val) ) {
|
|
if (!fInitProperties.containsKey(JAXP_SCHEMA_SOURCE)) {
|
|
fInitProperties.put(JAXP_SCHEMA_SOURCE, super.getProperty(JAXP_SCHEMA_SOURCE));
|
|
}
|
|
super.setProperty(name, value);
|
|
}
|
|
else {
|
|
throw new SAXNotSupportedException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
|
|
"jaxp-order-not-supported",
|
|
new Object[] {JAXP_SCHEMA_LANGUAGE, JAXP_SCHEMA_SOURCE}));
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
/** Forward property to the schema validator if there is one. **/
|
|
if (fSAXParser != null && fSAXParser.fSchemaValidator != null) {
|
|
setSchemaValidatorProperty(name, value);
|
|
}
|
|
|
|
//check if the property is managed by security manager
|
|
if (fSecurityManager == null ||
|
|
!fSecurityManager.setLimit(name, XMLSecurityManager.State.APIPROPERTY, value)) {
|
|
//check if the property is managed by security property manager
|
|
if (fSecurityPropertyMgr == null ||
|
|
!fSecurityPropertyMgr.setValue(name, XMLSecurityPropertyManager.State.APIPROPERTY, value)) {
|
|
//fall back to the existing property manager
|
|
if (!fInitProperties.containsKey(name)) {
|
|
fInitProperties.put(name, super.getProperty(name));
|
|
}
|
|
super.setProperty(name, value);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public synchronized Object getProperty(String name)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
if (name == null) {
|
|
// TODO: Add localized error message.
|
|
throw new NullPointerException();
|
|
}
|
|
if (fSAXParser != null && JAXP_SCHEMA_LANGUAGE.equals(name)) {
|
|
// JAXP 1.2 support
|
|
return fSAXParser.schemaLanguage;
|
|
}
|
|
|
|
/** Check to see if the property is managed by the security manager **/
|
|
String propertyValue = (fSecurityManager != null) ?
|
|
fSecurityManager.getLimitAsString(name) : null;
|
|
if (propertyValue != null) {
|
|
return propertyValue;
|
|
} else {
|
|
propertyValue = (fSecurityPropertyMgr != null) ?
|
|
fSecurityPropertyMgr.getValue(name) : null;
|
|
if (propertyValue != null) {
|
|
return propertyValue;
|
|
}
|
|
}
|
|
|
|
return super.getProperty(name);
|
|
}
|
|
|
|
synchronized void restoreInitState()
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
Iterator iter;
|
|
if (!fInitFeatures.isEmpty()) {
|
|
iter = fInitFeatures.entrySet().iterator();
|
|
while (iter.hasNext()) {
|
|
Map.Entry entry = (Map.Entry) iter.next();
|
|
String name = (String) entry.getKey();
|
|
boolean value = ((Boolean) entry.getValue()).booleanValue();
|
|
super.setFeature(name, value);
|
|
}
|
|
fInitFeatures.clear();
|
|
}
|
|
if (!fInitProperties.isEmpty()) {
|
|
iter = fInitProperties.entrySet().iterator();
|
|
while (iter.hasNext()) {
|
|
Map.Entry entry = (Map.Entry) iter.next();
|
|
String name = (String) entry.getKey();
|
|
Object value = entry.getValue();
|
|
super.setProperty(name, value);
|
|
}
|
|
fInitProperties.clear();
|
|
}
|
|
}
|
|
|
|
public void parse(InputSource inputSource)
|
|
throws SAXException, IOException {
|
|
if (fSAXParser != null && fSAXParser.fSchemaValidator != null) {
|
|
if (fSAXParser.fSchemaValidationManager != null) {
|
|
fSAXParser.fSchemaValidationManager.reset();
|
|
fSAXParser.fUnparsedEntityHandler.reset();
|
|
}
|
|
resetSchemaValidator();
|
|
}
|
|
super.parse(inputSource);
|
|
}
|
|
|
|
public void parse(String systemId)
|
|
throws SAXException, IOException {
|
|
if (fSAXParser != null && fSAXParser.fSchemaValidator != null) {
|
|
if (fSAXParser.fSchemaValidationManager != null) {
|
|
fSAXParser.fSchemaValidationManager.reset();
|
|
fSAXParser.fUnparsedEntityHandler.reset();
|
|
}
|
|
resetSchemaValidator();
|
|
}
|
|
super.parse(systemId);
|
|
}
|
|
|
|
XMLParserConfiguration getXMLParserConfiguration() {
|
|
return fConfiguration;
|
|
}
|
|
|
|
void setFeature0(String name, boolean value)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
super.setFeature(name, value);
|
|
}
|
|
|
|
boolean getFeature0(String name)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
return super.getFeature(name);
|
|
}
|
|
|
|
void setProperty0(String name, Object value)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
super.setProperty(name, value);
|
|
}
|
|
|
|
Object getProperty0(String name)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
return super.getProperty(name);
|
|
}
|
|
|
|
Locale getLocale() {
|
|
return fConfiguration.getLocale();
|
|
}
|
|
|
|
private void setSchemaValidatorFeature(String name, boolean value)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
try {
|
|
fSAXParser.fSchemaValidator.setFeature(name, value);
|
|
}
|
|
// This should never be thrown from the schema validator.
|
|
catch (XMLConfigurationException e) {
|
|
String identifier = e.getIdentifier();
|
|
if (e.getType() == Status.NOT_RECOGNIZED) {
|
|
throw new SAXNotRecognizedException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
|
|
"feature-not-recognized", new Object [] {identifier}));
|
|
}
|
|
else {
|
|
throw new SAXNotSupportedException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
|
|
"feature-not-supported", new Object [] {identifier}));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setSchemaValidatorProperty(String name, Object value)
|
|
throws SAXNotRecognizedException, SAXNotSupportedException {
|
|
try {
|
|
fSAXParser.fSchemaValidator.setProperty(name, value);
|
|
}
|
|
// This should never be thrown from the schema validator.
|
|
catch (XMLConfigurationException e) {
|
|
String identifier = e.getIdentifier();
|
|
if (e.getType() == Status.NOT_RECOGNIZED) {
|
|
throw new SAXNotRecognizedException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
|
|
"property-not-recognized", new Object [] {identifier}));
|
|
}
|
|
else {
|
|
throw new SAXNotSupportedException(
|
|
SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
|
|
"property-not-supported", new Object [] {identifier}));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void resetSchemaValidator() throws SAXException {
|
|
try {
|
|
fSAXParser.fSchemaValidator.reset(fSAXParser.fSchemaValidatorComponentManager);
|
|
}
|
|
// This should never be thrown from the schema validator.
|
|
catch (XMLConfigurationException e) {
|
|
throw new SAXException(e);
|
|
}
|
|
}
|
|
}
|
|
}
|