Ejemplo n.º 1
0
 /**
  * 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);
 }
Ejemplo n.º 2
0
    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);
    }
  /** Constructs a component manager suitable for Xerces' schema validator. */
  public XMLSchemaValidatorComponentManager(XSGrammarPoolContainer grammarContainer) {
    // setup components
    fEntityManager = new XMLEntityManager();
    fComponents.put(ENTITY_MANAGER, fEntityManager);

    fErrorReporter = new XMLErrorReporter();
    fComponents.put(ERROR_REPORTER, fErrorReporter);

    fNamespaceContext = new NamespaceSupport();
    fComponents.put(NAMESPACE_CONTEXT, fNamespaceContext);

    fSchemaValidator = new XMLSchemaValidator();
    fComponents.put(SCHEMA_VALIDATOR, fSchemaValidator);

    fValidationManager = new ValidationManager();
    fComponents.put(VALIDATION_MANAGER, fValidationManager);

    // setup other properties
    fComponents.put(ENTITY_RESOLVER, null);
    fComponents.put(ERROR_HANDLER, null);

    fComponents.put(SYMBOL_TABLE, new SymbolTable());

    // setup grammar pool
    fComponents.put(XMLGRAMMAR_POOL, grammarContainer.getGrammarPool());
    fUseGrammarPoolOnly = grammarContainer.isFullyComposed();

    // add schema message formatter to error reporter
    fErrorReporter.putMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN, new XSMessageFormatter());

    // add all recognized features and properties and apply their defaults
    addRecognizedParamsAndSetDefaults(fEntityManager, grammarContainer);
    addRecognizedParamsAndSetDefaults(fErrorReporter, grammarContainer);
    addRecognizedParamsAndSetDefaults(fSchemaValidator, grammarContainer);

    boolean secureProcessing = grammarContainer.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING);
    if (System.getSecurityManager() != null) {
      _isSecureMode = true;
      secureProcessing = true;
    }

    fInitSecurityManager = (XMLSecurityManager) grammarContainer.getProperty(SECURITY_MANAGER);
    if (fInitSecurityManager != null) {
      fInitSecurityManager.setSecureProcessing(secureProcessing);
    } else {
      fInitSecurityManager = new XMLSecurityManager(secureProcessing);
    }

    setProperty(SECURITY_MANAGER, fInitSecurityManager);

    // pass on properties set on SchemaFactory
    fSecurityPropertyMgr =
        (XMLSecurityPropertyManager)
            grammarContainer.getProperty(Constants.XML_SECURITY_PROPERTY_MANAGER);
    setProperty(XML_SECURITY_PROPERTY_MANAGER, fSecurityPropertyMgr);
  }
Ejemplo n.º 4
0
 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);
 }
 /**
  * Returns the state of a feature.
  *
  * @param featureId The feature identifier.
  * @return true if the feature is supported
  * @throws XMLConfigurationException Thrown for configuration error. In general, components should
  *     only throw this exception if it is <strong>really</strong> a critical error.
  */
 public FeatureState getFeatureState(String featureId) throws XMLConfigurationException {
   if (PARSER_SETTINGS.equals(featureId)) {
     return FeatureState.is(fConfigUpdated);
   } else if (VALIDATION.equals(featureId) || SCHEMA_VALIDATION.equals(featureId)) {
     return FeatureState.is(true);
   } else if (USE_GRAMMAR_POOL_ONLY.equals(featureId)) {
     return FeatureState.is(fUseGrammarPoolOnly);
   } else if (XMLConstants.FEATURE_SECURE_PROCESSING.equals(featureId)) {
     return FeatureState.is(fInitSecurityManager.isSecureProcessing());
   } else if (SCHEMA_ELEMENT_DEFAULT.equals(featureId)) {
     return FeatureState.is(
         true); // pre-condition: VALIDATION and SCHEMA_VALIDATION are always true
   }
   return super.getFeatureState(featureId);
 }
  /**
   * Set the value of any property in a SAX2 parser. The parser might not recognize the property,
   * and if it does recognize it, it might not support the requested value.
   *
   * @param propertyId The unique identifier (URI) of the property being set.
   * @param value The value to which the property is being set.
   * @exception SAXNotRecognizedException If the requested property is not known.
   * @exception SAXNotSupportedException If the requested property is known, but the requested value
   *     is not supported.
   */
  public void setProperty(String propertyId, Object value)
      throws SAXNotRecognizedException, SAXNotSupportedException {
    /**
     * It's possible for users to set a security manager through the interface. If it's the old
     * SecurityManager, convert it to the new XMLSecurityManager
     */
    if (propertyId.equals(Constants.SECURITY_MANAGER)) {
      securityManager = XMLSecurityManager.convert(value, securityManager);
      setProperty0(Constants.SECURITY_MANAGER, securityManager);
      return;
    }
    if (propertyId.equals(Constants.XML_SECURITY_PROPERTY_MANAGER)) {
      if (value == null) {
        securityPropertyManager = new XMLSecurityPropertyManager();
      } else {
        securityPropertyManager = (XMLSecurityPropertyManager) value;
      }
      setProperty0(Constants.XML_SECURITY_PROPERTY_MANAGER, securityPropertyManager);
      return;
    }

    if (securityManager == null) {
      securityManager = new XMLSecurityManager(true);
      setProperty0(Constants.SECURITY_MANAGER, securityManager);
    }

    if (securityPropertyManager == null) {
      securityPropertyManager = new XMLSecurityPropertyManager();
      setProperty0(Constants.XML_SECURITY_PROPERTY_MANAGER, securityPropertyManager);
    }
    int index = securityPropertyManager.getIndex(propertyId);

    if (index > -1) {
      /**
       * this is a direct call to this parser, not a subclass since internally the support of this
       * property is done through XMLSecurityPropertyManager
       */
      securityPropertyManager.setValue(
          index, XMLSecurityPropertyManager.State.APIPROPERTY, (String) value);
    } else {
      // check if the property is managed by security manager
      if (!securityManager.setLimit(propertyId, XMLSecurityManager.State.APIPROPERTY, value)) {
        // fall back to the default configuration to handle the property
        setProperty0(propertyId, value);
      }
    }
  }
  /**
   * Sets the state of a property.
   *
   * @param propertyId The unique identifier (URI) of the property.
   * @param value The requested state of the property.
   * @exception XMLConfigurationException If the requested property is not known.
   */
  public void setProperty(String propertyId, Object value) throws XMLConfigurationException {
    if (ENTITY_MANAGER.equals(propertyId)
        || ERROR_REPORTER.equals(propertyId)
        || NAMESPACE_CONTEXT.equals(propertyId)
        || SCHEMA_VALIDATOR.equals(propertyId)
        || SYMBOL_TABLE.equals(propertyId)
        || VALIDATION_MANAGER.equals(propertyId)
        || XMLGRAMMAR_POOL.equals(propertyId)) {
      throw new XMLConfigurationException(Status.NOT_SUPPORTED, propertyId);
    }
    fConfigUpdated = true;
    fEntityManager.setProperty(propertyId, value);
    fErrorReporter.setProperty(propertyId, value);
    fSchemaValidator.setProperty(propertyId, value);
    if (ENTITY_RESOLVER.equals(propertyId)
        || ERROR_HANDLER.equals(propertyId)
        || SECURITY_MANAGER.equals(propertyId)) {
      fComponents.put(propertyId, value);
      return;
    } else if (LOCALE.equals(propertyId)) {
      setLocale((Locale) value);
      fComponents.put(propertyId, value);
      return;
    }

    // check if the property is managed by security manager
    if (fInitSecurityManager == null
        || !fInitSecurityManager.setLimit(
            propertyId, XMLSecurityManager.State.APIPROPERTY, value)) {
      // check if the property is managed by security property manager
      if (fSecurityPropertyMgr == null
          || !fSecurityPropertyMgr.setValue(
              propertyId, XMLSecurityPropertyManager.State.APIPROPERTY, value)) {
        // fall back to the existing property manager
        if (!fInitProperties.containsKey(propertyId)) {
          fInitProperties.put(propertyId, super.getProperty(propertyId));
        }
        super.setProperty(propertyId, value);
      }
    }
  }
  /**
   * Set the state of a feature.
   *
   * @param featureId The unique identifier (URI) of the feature.
   * @param state The requested state of the feature (true or false).
   * @exception XMLConfigurationException If the requested feature is not known.
   */
  public void setFeature(String featureId, boolean value) throws XMLConfigurationException {
    if (PARSER_SETTINGS.equals(featureId)) {
      throw new XMLConfigurationException(Status.NOT_SUPPORTED, featureId);
    } else if (value == false
        && (VALIDATION.equals(featureId) || SCHEMA_VALIDATION.equals(featureId))) {
      throw new XMLConfigurationException(Status.NOT_SUPPORTED, featureId);
    } else if (USE_GRAMMAR_POOL_ONLY.equals(featureId) && value != fUseGrammarPoolOnly) {
      throw new XMLConfigurationException(Status.NOT_SUPPORTED, featureId);
    }
    if (XMLConstants.FEATURE_SECURE_PROCESSING.equals(featureId)) {
      if (_isSecureMode && !value) {
        throw new XMLConfigurationException(
            Status.NOT_ALLOWED, XMLConstants.FEATURE_SECURE_PROCESSING);
      }
      fInitSecurityManager.setSecureProcessing(value);
      setProperty(SECURITY_MANAGER, fInitSecurityManager);

      if (value && 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);
        setProperty(XML_SECURITY_PROPERTY_MANAGER, fSecurityPropertyMgr);
      }

      return;
    }
    fConfigUpdated = true;
    fEntityManager.setFeature(featureId, value);
    fErrorReporter.setFeature(featureId, value);
    fSchemaValidator.setFeature(featureId, value);
    if (!fInitFeatures.containsKey(featureId)) {
      boolean current = super.getFeature(featureId);
      fInitFeatures.put(featureId, current ? Boolean.TRUE : Boolean.FALSE);
    }
    super.setFeature(featureId, value);
  }
Ejemplo n.º 9
0
    /**
     * 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);
        }
      }
    }