1 /*
   2  * Copyright (c) 2007, 2016, 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.xs.XMLSchemaLoader;
  25 import com.sun.org.apache.xerces.internal.util.DOMEntityResolverWrapper;
  26 import com.sun.org.apache.xerces.internal.util.DOMInputSource;
  27 import com.sun.org.apache.xerces.internal.util.ErrorHandlerWrapper;
  28 import com.sun.org.apache.xerces.internal.util.SAXInputSource;
  29 import com.sun.org.apache.xerces.internal.util.SAXMessageFormatter;
  30 import com.sun.org.apache.xerces.internal.util.StAXInputSource;
  31 import com.sun.org.apache.xerces.internal.util.Status;
  32 import com.sun.org.apache.xerces.internal.util.XMLGrammarPoolImpl;
  33 import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager;
  34 import com.sun.org.apache.xerces.internal.utils.XMLSecurityPropertyManager;
  35 import com.sun.org.apache.xerces.internal.xni.XNIException;
  36 import com.sun.org.apache.xerces.internal.xni.grammars.Grammar;
  37 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
  38 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarPool;
  39 import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
  40 import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
  41 import java.io.IOException;
  42 import java.io.InputStream;
  43 import java.io.Reader;
  44 import javax.xml.XMLConstants;
  45 import javax.xml.catalog.CatalogFeatures.Feature;
  46 import javax.xml.stream.XMLEventReader;
  47 import javax.xml.transform.Source;
  48 import javax.xml.transform.dom.DOMSource;
  49 import javax.xml.transform.sax.SAXSource;
  50 import javax.xml.transform.stax.StAXSource;
  51 import javax.xml.transform.stream.StreamSource;
  52 import javax.xml.validation.Schema;
  53 import javax.xml.validation.SchemaFactory;
  54 import jdk.xml.internal.JdkXmlUtils;
  55 import org.w3c.dom.Node;
  56 import org.w3c.dom.ls.LSResourceResolver;
  57 import org.xml.sax.ErrorHandler;
  58 import org.xml.sax.InputSource;
  59 import org.xml.sax.SAXException;
  60 import org.xml.sax.SAXNotRecognizedException;
  61 import org.xml.sax.SAXNotSupportedException;
  62 import org.xml.sax.SAXParseException;
  63 
  64 /**
  65  * {@link SchemaFactory} for XML Schema.
  66  *
  67  * @author Kohsuke Kawaguchi
  68  */
  69 public final class XMLSchemaFactory extends SchemaFactory {
  70 
  71     // feature identifiers
  72 
  73     /** JAXP Source feature prefix. */
  74     private static final String JAXP_SOURCE_FEATURE_PREFIX = "http://javax.xml.transform";
  75 
  76     /** Feature identifier: schema full checking. */
  77     private static final String SCHEMA_FULL_CHECKING =
  78         Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_FULL_CHECKING;
  79 
  80     /** Feature identifier: use grammar pool only. */
  81     private static final String USE_GRAMMAR_POOL_ONLY =
  82         Constants.XERCES_FEATURE_PREFIX + Constants.USE_GRAMMAR_POOL_ONLY_FEATURE;
  83 
  84     // property identifiers
  85 
  86     /** Property identifier: grammar pool. */
  87     private static final String XMLGRAMMAR_POOL =
  88         Constants.XERCES_PROPERTY_PREFIX + Constants.XMLGRAMMAR_POOL_PROPERTY;
  89 
  90     /** Property identifier: XMLSecurityManager. */
  91     private static final String SECURITY_MANAGER =
  92         Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;
  93 
  94     /** Property identifier: Security property manager. */
  95     private static final String XML_SECURITY_PROPERTY_MANAGER =
  96             Constants.XML_SECURITY_PROPERTY_MANAGER;
  97 
  98 
  99     //
 100     // Data
 101     //
 102 
 103     /** The XMLSchemaLoader */
 104     private final XMLSchemaLoader fXMLSchemaLoader = new XMLSchemaLoader();
 105 
 106     /** User-specified ErrorHandler; can be null. */
 107     private ErrorHandler fErrorHandler;
 108 
 109     /** The LSResrouceResolver */
 110     private LSResourceResolver fLSResourceResolver;
 111 
 112     /** The DOMEntityResolverWrapper */
 113     private final DOMEntityResolverWrapper fDOMEntityResolverWrapper;
 114 
 115     /** The ErrorHandlerWrapper */
 116     private final ErrorHandlerWrapper fErrorHandlerWrapper;
 117 
 118     /** The SecurityManager. */
 119     private XMLSecurityManager fSecurityManager;
 120 
 121     /** The Security property manager. */
 122     private XMLSecurityPropertyManager fSecurityPropertyMgr;
 123 
 124     /** The container for the real grammar pool. */
 125     private final XMLGrammarPoolWrapper fXMLGrammarPoolWrapper;
 126 
 127     /** Whether or not to allow new schemas to be added to the grammar pool */
 128     private boolean fUseGrammarPoolOnly;
 129 
 130     /**
 131      * Indicates whether implementation parts should use
 132      *   service loader (or similar).
 133      * Note the default value (false) is the safe option..
 134      */
 135     private final boolean fUseServicesMechanism;
 136 
 137 
 138     public XMLSchemaFactory() {
 139         this(true);
 140     }
 141     public static XMLSchemaFactory newXMLSchemaFactoryNoServiceLoader() {
 142         return new XMLSchemaFactory(false);
 143     }
 144     private XMLSchemaFactory(boolean useServicesMechanism) {
 145         fUseServicesMechanism = useServicesMechanism;
 146         fErrorHandlerWrapper = new ErrorHandlerWrapper(DraconianErrorHandler.getInstance());
 147         fDOMEntityResolverWrapper = new DOMEntityResolverWrapper();
 148         fXMLGrammarPoolWrapper = new XMLGrammarPoolWrapper();
 149         fXMLSchemaLoader.setFeature(SCHEMA_FULL_CHECKING, true);
 150         fXMLSchemaLoader.setProperty(XMLGRAMMAR_POOL, fXMLGrammarPoolWrapper);
 151         fXMLSchemaLoader.setEntityResolver(fDOMEntityResolverWrapper);
 152         fXMLSchemaLoader.setErrorHandler(fErrorHandlerWrapper);
 153         fUseGrammarPoolOnly = true;
 154 
 155         // Enable secure processing feature by default
 156         fSecurityManager = new XMLSecurityManager(true);
 157         fXMLSchemaLoader.setProperty(SECURITY_MANAGER, fSecurityManager);
 158 
 159         fSecurityPropertyMgr = new XMLSecurityPropertyManager();
 160         fXMLSchemaLoader.setProperty(XML_SECURITY_PROPERTY_MANAGER,
 161                 fSecurityPropertyMgr);
 162 
 163         // use catalog
 164         fXMLSchemaLoader.setFeature(XMLConstants.USE_CATALOG, JdkXmlUtils.USE_CATALOG_DEFAULT);
 165         for (Feature f : Feature.values()) {
 166             fXMLSchemaLoader.setProperty(f.getPropertyName(), null);
 167         }
 168 
 169         fXMLSchemaLoader.setProperty(JdkXmlUtils.CDATA_CHUNK_SIZE, JdkXmlUtils.CDATA_CHUNK_SIZE_DEFAULT);
 170     }
 171 
 172     /**
 173      * <p>Is specified schema supported by this <code>SchemaFactory</code>?</p>
 174      *
 175      * @param schemaLanguage Specifies the schema language which the returned <code>SchemaFactory</code> will understand.
 176      *    <code>schemaLanguage</code> must specify a <a href="#schemaLanguage">valid</a> schema language.
 177      *
 178      * @return <code>true</code> if <code>SchemaFactory</code> supports <code>schemaLanguage</code>, else <code>false</code>.
 179      *
 180      * @throws NullPointerException If <code>schemaLanguage</code> is <code>null</code>.
 181      * @throws IllegalArgumentException If <code>schemaLanguage.length() == 0</code>
 182      *   or <code>schemaLanguage</code> does not specify a <a href="#schemaLanguage">valid</a> schema language.
 183      */
 184     public boolean isSchemaLanguageSupported(String schemaLanguage) {
 185         if (schemaLanguage == null) {
 186             throw new NullPointerException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 187                     "SchemaLanguageNull", null));
 188         }
 189         if (schemaLanguage.length() == 0) {
 190             throw new IllegalArgumentException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 191                     "SchemaLanguageLengthZero", null));
 192         }
 193         // only W3C XML Schema 1.0 is supported
 194         return schemaLanguage.equals(XMLConstants.W3C_XML_SCHEMA_NS_URI) ||
 195                 schemaLanguage.equals(Constants.W3C_XML_SCHEMA10_NS_URI);
 196     }
 197 
 198     public LSResourceResolver getResourceResolver() {
 199         return fLSResourceResolver;
 200     }
 201 
 202     public void setResourceResolver(LSResourceResolver resourceResolver) {
 203         fLSResourceResolver = resourceResolver;
 204         fDOMEntityResolverWrapper.setEntityResolver(resourceResolver);
 205         fXMLSchemaLoader.setEntityResolver(fDOMEntityResolverWrapper);
 206     }
 207 
 208     public ErrorHandler getErrorHandler() {
 209         return fErrorHandler;
 210     }
 211 
 212     public void setErrorHandler(ErrorHandler errorHandler) {
 213         fErrorHandler = errorHandler;
 214         fErrorHandlerWrapper.setErrorHandler(errorHandler != null ? errorHandler : DraconianErrorHandler.getInstance());
 215         fXMLSchemaLoader.setErrorHandler(fErrorHandlerWrapper);
 216     }
 217 
 218     public Schema newSchema( Source[] schemas ) throws SAXException {
 219 
 220         // this will let the loader store parsed Grammars into the pool.
 221         XMLGrammarPoolImplExtension pool = new XMLGrammarPoolImplExtension();
 222         fXMLGrammarPoolWrapper.setGrammarPool(pool);
 223 
 224         XMLInputSource[] xmlInputSources = new XMLInputSource[schemas.length];
 225         InputStream inputStream;
 226         Reader reader;
 227         for (int i = 0; i < schemas.length; ++i) {
 228             Source source = schemas[i];
 229             if (source instanceof StreamSource) {
 230                 StreamSource streamSource = (StreamSource) source;
 231                 String publicId = streamSource.getPublicId();
 232                 String systemId = streamSource.getSystemId();
 233                 inputStream = streamSource.getInputStream();
 234                 reader = streamSource.getReader();
 235                 XMLInputSource xmlInputSource = new XMLInputSource(publicId, systemId, null, false);
 236                 xmlInputSource.setByteStream(inputStream);
 237                 xmlInputSource.setCharacterStream(reader);
 238                 xmlInputSources[i] = xmlInputSource;
 239             }
 240             else if (source instanceof SAXSource) {
 241                 SAXSource saxSource = (SAXSource) source;
 242                 InputSource inputSource = saxSource.getInputSource();
 243                 if (inputSource == null) {
 244                     throw new SAXException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 245                             "SAXSourceNullInputSource", null));
 246                 }
 247                 xmlInputSources[i] = new SAXInputSource(saxSource.getXMLReader(), inputSource);
 248             }
 249             else if (source instanceof DOMSource) {
 250                 DOMSource domSource = (DOMSource) source;
 251                 Node node = domSource.getNode();
 252                 String systemID = domSource.getSystemId();
 253                 xmlInputSources[i] = new DOMInputSource(node, systemID);
 254             }
 255              else if (source instanceof StAXSource) {
 256                 StAXSource staxSource = (StAXSource) source;
 257                 XMLEventReader eventReader = staxSource.getXMLEventReader();
 258                 if (eventReader != null) {
 259                     xmlInputSources[i] = new StAXInputSource(eventReader);
 260                 }
 261                 else {
 262                     xmlInputSources[i] = new StAXInputSource(staxSource.getXMLStreamReader());
 263                 }
 264             }
 265             else if (source == null) {
 266                 throw new NullPointerException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 267                         "SchemaSourceArrayMemberNull", null));
 268             }
 269             else {
 270                 throw new IllegalArgumentException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 271                         "SchemaFactorySourceUnrecognized",
 272                         new Object [] {source.getClass().getName()}));
 273             }
 274         }
 275 
 276         try {
 277             fXMLSchemaLoader.loadGrammar(xmlInputSources);
 278         }
 279         catch (XNIException e) {
 280             // this should have been reported to users already.
 281             throw Util.toSAXException(e);
 282         }
 283         catch (IOException e) {
 284             // this hasn't been reported, so do so now.
 285             SAXParseException se = new SAXParseException(e.getMessage(),null,e);
 286             if (fErrorHandler != null) {
 287                 fErrorHandler.error(se);
 288             }
 289             throw se; // and we must throw it.
 290         }
 291 
 292         // Clear reference to grammar pool.
 293         fXMLGrammarPoolWrapper.setGrammarPool(null);
 294 
 295         // Select Schema implementation based on grammar count.
 296         final int grammarCount = pool.getGrammarCount();
 297         AbstractXMLSchema schema = null;
 298         if (fUseGrammarPoolOnly) {
 299             if (grammarCount > 1) {
 300                 schema = new XMLSchema(new ReadOnlyGrammarPool(pool));
 301             }
 302             else if (grammarCount == 1) {
 303                 Grammar[] grammars = pool.retrieveInitialGrammarSet(XMLGrammarDescription.XML_SCHEMA);
 304                 schema = new SimpleXMLSchema(grammars[0]);
 305             }
 306             else {
 307                 schema = new EmptyXMLSchema();
 308             }
 309         }
 310         else {
 311             schema = new XMLSchema(new ReadOnlyGrammarPool(pool), false);
 312         }
 313         propagateFeatures(schema);
 314         propagateProperties(schema);
 315         return schema;
 316     }
 317 
 318     public Schema newSchema() throws SAXException {
 319         /*
 320          * It would make sense to return an EmptyXMLSchema object here, if
 321          * fUseGrammarPoolOnly is set to true. However, because the default
 322          * value of this feature is true, doing so would change the default
 323          * behaviour of this method. Thus, we return a WeakReferenceXMLSchema
 324          * regardless of the value of fUseGrammarPoolOnly. -PM
 325          */
 326 
 327         // Use a Schema that uses the system id as the equality source.
 328         AbstractXMLSchema schema = new WeakReferenceXMLSchema();
 329         propagateFeatures(schema);
 330         propagateProperties(schema);
 331         return schema;
 332     }
 333 
 334     public Schema newSchema(XMLGrammarPool pool) throws SAXException {
 335         // If the "use-grammar-pool-only" feature is set to true
 336         // prevent the application's grammar pool from being mutated
 337         // by wrapping it in a ReadOnlyGrammarPool.
 338         final AbstractXMLSchema schema = (fUseGrammarPoolOnly) ?
 339             new XMLSchema(new ReadOnlyGrammarPool(pool)) :
 340             new XMLSchema(pool, false);
 341         propagateFeatures(schema);
 342         return schema;
 343     }
 344 
 345     public boolean getFeature(String name)
 346         throws SAXNotRecognizedException, SAXNotSupportedException {
 347         if (name == null) {
 348             throw new NullPointerException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 349                     "FeatureNameNull", null));
 350         }
 351         if (name.startsWith(JAXP_SOURCE_FEATURE_PREFIX)) {
 352             // Indicates to the caller that this SchemaFactory supports a specific JAXP Source.
 353             if (name.equals(StreamSource.FEATURE) ||
 354                 name.equals(SAXSource.FEATURE) ||
 355                 name.equals(DOMSource.FEATURE) ||
 356                 name.equals(StAXSource.FEATURE)) {
 357                 return true;
 358             }
 359         }
 360         if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
 361             return (fSecurityManager != null && fSecurityManager.isSecureProcessing());
 362         }
 363         else if (name.equals(USE_GRAMMAR_POOL_ONLY)) {
 364             return fUseGrammarPoolOnly;
 365         }
 366         try {
 367             return fXMLSchemaLoader.getFeature(name);
 368         }
 369         catch (XMLConfigurationException e) {
 370             String identifier = e.getIdentifier();
 371             if (e.getType() == Status.NOT_RECOGNIZED) {
 372                 throw new SAXNotRecognizedException(
 373                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 374                         "feature-not-recognized", new Object [] {identifier}));
 375             }
 376             else {
 377                 throw new SAXNotSupportedException(
 378                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 379                         "feature-not-supported", new Object [] {identifier}));
 380             }
 381         }
 382     }
 383 
 384     public Object getProperty(String name)
 385         throws SAXNotRecognizedException, SAXNotSupportedException {
 386         if (name == null) {
 387             throw new NullPointerException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 388                     "ProperyNameNull", null));
 389         }
 390         if (name.equals(SECURITY_MANAGER)) {
 391             return fSecurityManager;
 392         }
 393         else if (name.equals(XMLGRAMMAR_POOL)) {
 394             throw new SAXNotSupportedException(
 395                     SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 396                     "property-not-supported", new Object [] {name}));
 397         }
 398         try {
 399             return fXMLSchemaLoader.getProperty(name);
 400         }
 401         catch (XMLConfigurationException e) {
 402             String identifier = e.getIdentifier();
 403             if (e.getType() == Status.NOT_RECOGNIZED) {
 404                 throw new SAXNotRecognizedException(
 405                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 406                         "property-not-recognized", new Object [] {identifier}));
 407             }
 408             else {
 409                 throw new SAXNotSupportedException(
 410                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 411                         "property-not-supported", new Object [] {identifier}));
 412             }
 413         }
 414     }
 415 
 416     public void setFeature(String name, boolean value)
 417         throws SAXNotRecognizedException, SAXNotSupportedException {
 418         if (name == null) {
 419             throw new NullPointerException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 420                     "FeatureNameNull", null));
 421         }
 422         if (name.startsWith(JAXP_SOURCE_FEATURE_PREFIX)) {
 423             if (name.equals(StreamSource.FEATURE) ||
 424                 name.equals(SAXSource.FEATURE) ||
 425                 name.equals(DOMSource.FEATURE) ||
 426                 name.equals(StAXSource.FEATURE)) {
 427                 throw new SAXNotSupportedException(
 428                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 429                         "feature-read-only", new Object [] {name}));
 430             }
 431         }
 432         if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
 433             if (System.getSecurityManager() != null && (!value)) {
 434                 throw new SAXNotSupportedException(
 435                         SAXMessageFormatter.formatMessage(null,
 436                         "jaxp-secureprocessing-feature", null));
 437             }
 438 
 439             fSecurityManager.setSecureProcessing(value);
 440             if (value) {
 441                 fSecurityPropertyMgr.setValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_DTD,
 442                         XMLSecurityPropertyManager.State.FSP, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
 443                 fSecurityPropertyMgr.setValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_SCHEMA,
 444                         XMLSecurityPropertyManager.State.FSP, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
 445             }
 446 
 447             fXMLSchemaLoader.setProperty(SECURITY_MANAGER, fSecurityManager);
 448             return;
 449         }
 450         else if (name.equals(USE_GRAMMAR_POOL_ONLY)) {
 451             fUseGrammarPoolOnly = value;
 452             return;
 453         }
 454         else if (name.equals(Constants.ORACLE_FEATURE_SERVICE_MECHANISM)) {
 455             //in secure mode, let _useServicesMechanism be determined by the constructor
 456             if (System.getSecurityManager() != null)
 457                 return;
 458         }
 459         try {
 460             fXMLSchemaLoader.setFeature(name, value);
 461         }
 462         catch (XMLConfigurationException e) {
 463             String identifier = e.getIdentifier();
 464             if (e.getType() == Status.NOT_RECOGNIZED) {
 465                 throw new SAXNotRecognizedException(
 466                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 467                         "feature-not-recognized", new Object [] {identifier}));
 468             }
 469             else {
 470                 throw new SAXNotSupportedException(
 471                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 472                         "feature-not-supported", new Object [] {identifier}));
 473             }
 474         }
 475     }
 476 
 477     public void setProperty(String name, Object object)
 478         throws SAXNotRecognizedException, SAXNotSupportedException {
 479         if (name == null) {
 480             throw new NullPointerException(JAXPValidationMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 481                     "ProperyNameNull", null));
 482         }
 483         if (name.equals(SECURITY_MANAGER)) {
 484             fSecurityManager = XMLSecurityManager.convert(object, fSecurityManager);
 485             fXMLSchemaLoader.setProperty(SECURITY_MANAGER, fSecurityManager);
 486             return;
 487         } else if (name.equals(Constants.XML_SECURITY_PROPERTY_MANAGER)) {
 488             if (object == null) {
 489                 fSecurityPropertyMgr = new XMLSecurityPropertyManager();
 490             } else {
 491                 fSecurityPropertyMgr = (XMLSecurityPropertyManager)object;
 492             }
 493             fXMLSchemaLoader.setProperty(Constants.XML_SECURITY_PROPERTY_MANAGER, fSecurityPropertyMgr);
 494             return;
 495         }
 496         else if (name.equals(XMLGRAMMAR_POOL)) {
 497             throw new SAXNotSupportedException(
 498                     SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 499                     "property-not-supported", new Object [] {name}));
 500         }
 501         try {
 502             //check if the property is managed by security manager
 503             if (fSecurityManager == null ||
 504                     !fSecurityManager.setLimit(name, XMLSecurityManager.State.APIPROPERTY, object)) {
 505                 //check if the property is managed by security property manager
 506                 if (fSecurityPropertyMgr == null ||
 507                         !fSecurityPropertyMgr.setValue(name, XMLSecurityPropertyManager.State.APIPROPERTY, object)) {
 508                     //fall back to the existing property manager
 509                     fXMLSchemaLoader.setProperty(name, object);
 510                 }
 511             }
 512         }
 513         catch (XMLConfigurationException e) {
 514             String identifier = e.getIdentifier();
 515             if (e.getType() == Status.NOT_RECOGNIZED) {
 516                 throw new SAXNotRecognizedException(
 517                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 518                         "property-not-recognized", new Object [] {identifier}));
 519             }
 520             else {
 521                 throw new SAXNotSupportedException(
 522                         SAXMessageFormatter.formatMessage(fXMLSchemaLoader.getLocale(),
 523                         "property-not-supported", new Object [] {identifier}));
 524             }
 525         }
 526     }
 527 
 528     private void propagateFeatures(AbstractXMLSchema schema) {
 529         schema.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING,
 530                 (fSecurityManager != null && fSecurityManager.isSecureProcessing()));
 531         schema.setFeature(Constants.ORACLE_FEATURE_SERVICE_MECHANISM, fUseServicesMechanism);
 532         String[] features = fXMLSchemaLoader.getRecognizedFeatures();
 533         for (int i = 0; i < features.length; ++i) {
 534             boolean state = fXMLSchemaLoader.getFeature(features[i]);
 535             schema.setFeature(features[i], state);
 536         }
 537     }
 538 
 539     private void propagateProperties(AbstractXMLSchema schema) {
 540         String[] properties = fXMLSchemaLoader.getRecognizedProperties();
 541         for (int i = 0; i < properties.length; ++i) {
 542             Object state = fXMLSchemaLoader.getProperty(properties[i]);
 543             schema.setProperty(properties[i], state);
 544         }
 545     }
 546 
 547 
 548     /**
 549      * Extension of XMLGrammarPoolImpl which exposes the number of
 550      * grammars stored in the grammar pool.
 551      */
 552     static class XMLGrammarPoolImplExtension extends XMLGrammarPoolImpl {
 553 
 554         /** Constructs a grammar pool with a default number of buckets. */
 555         public XMLGrammarPoolImplExtension() {
 556             super();
 557         }
 558 
 559         /** Constructs a grammar pool with a specified number of buckets. */
 560         public XMLGrammarPoolImplExtension(int initialCapacity) {
 561             super(initialCapacity);
 562         }
 563 
 564         /** Returns the number of grammars contained in this pool. */
 565         int getGrammarCount() {
 566             return fGrammarCount;
 567         }
 568 
 569     } // XMLSchemaFactory.XMLGrammarPoolImplExtension
 570 
 571     /**
 572      * A grammar pool which wraps another.
 573      */
 574     static class XMLGrammarPoolWrapper implements XMLGrammarPool {
 575 
 576         private XMLGrammarPool fGrammarPool;
 577 
 578         /*
 579          * XMLGrammarPool methods
 580          */
 581 
 582         public Grammar[] retrieveInitialGrammarSet(String grammarType) {
 583             return fGrammarPool.retrieveInitialGrammarSet(grammarType);
 584         }
 585 
 586         public void cacheGrammars(String grammarType, Grammar[] grammars) {
 587             fGrammarPool.cacheGrammars(grammarType, grammars);
 588         }
 589 
 590         public Grammar retrieveGrammar(XMLGrammarDescription desc) {
 591             return fGrammarPool.retrieveGrammar(desc);
 592         }
 593 
 594         public void lockPool() {
 595             fGrammarPool.lockPool();
 596         }
 597 
 598         public void unlockPool() {
 599             fGrammarPool.unlockPool();
 600         }
 601 
 602         public void clear() {
 603             fGrammarPool.clear();
 604         }
 605 
 606         /*
 607          * Other methods
 608          */
 609 
 610         void setGrammarPool(XMLGrammarPool grammarPool) {
 611             fGrammarPool = grammarPool;
 612         }
 613 
 614         XMLGrammarPool getGrammarPool() {
 615             return fGrammarPool;
 616         }
 617 
 618     } // XMLSchemaFactory.XMLGrammarPoolWrapper
 619 
 620 } // XMLSchemaFactory