/*******************************************************************************
* Copyright (c) 2001, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.wsdl.validation.internal.wsdl11.xsd;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.apache.xerces.impl.Constants;
import org.apache.xerces.impl.xs.XSDDescription;
import org.apache.xerces.parsers.XMLGrammarPreparser;
import org.apache.xerces.util.XMLGrammarPoolImpl;
import org.apache.xerces.xni.grammars.Grammar;
import org.apache.xerces.xni.grammars.XMLGrammarDescription;
import org.apache.xerces.xni.grammars.XMLGrammarPool;
import org.apache.xerces.xni.grammars.XSGrammar;
import org.apache.xerces.xni.parser.XMLEntityResolver;
import org.apache.xerces.xni.parser.XMLInputSource;
import org.apache.xerces.xs.StringList;
import org.apache.xerces.xs.XSModel;
/**
* Validate schemas from files or String.
*/
public class XSDValidator
{
protected final String HONOUR_ALL_SCHEMA_LOCATIONS_FEATURE_ID = "http://apache.org/xml/features/honour-all-schemaLocations";
protected final String FILE_PREFIX = "file:";
protected final String XMLNS = "xmlns";
protected final String TARGETNAMESPACE = "targetNamespace";
protected final String NAMESPACE = "namespace";
protected final String IMPORT = "import";
protected final String SCHEMALOCATION = "schemaLocation";
protected final String TYPE = "type";
protected final String[] ignoreNamespaces =
{ "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/1999/XMLSchema" };
protected XSModel xsModel;
protected boolean isValidXSD;
protected List errors;
protected String filelocation;
/**
* Constructor.
*/
public XSDValidator()
{
xsModel = null;
isValidXSD = false;
errors = null;
}
/**
* Validate an inline schema.
*
* @param schema A schema represented as a string.
* @param targetNamespace The target namespace of the schema.
* @param fileloc The uri of the file that contains the schema.
*/
public void validateInlineSchema(String schema, String targetNamespace, String fileloc)
{
validateInlineSchema(schema, targetNamespace, fileloc, null, null, null);
}
/**
* Validate an inline schema and specify an entity resolver.
*
* @param schema This schema represented as a string.
* @param targetNamespace The target namespace of the schema.
* @param fileloc The uri of the file that contains this schema.
* @param entityResolverChain The entity resolver chain.
* @param inlineSchemaEntityResolver An inline schema resolver for this schema.
* @param grammarPool A Xerces XMLGrammarPool that holds precached schemas.
*/
public void validateInlineSchema(
String schema,
String targetNamespace,
String fileloc,
XMLEntityResolver entityResolverChain,
XMLEntityResolver inlineSchemaEntityResolver,
XMLGrammarPool grammarPool)
{
filelocation = fileloc;
validateXSD(schema, true, entityResolverChain,targetNamespace, inlineSchemaEntityResolver, grammarPool);
}
/**
* Validate the file located at the uri specified with the given entity resolver.
*
* @param uri An absolute uri for the schema location.
* @param entityResolver An entity resolver to be used.
* @param grammarPool A Xerces XMLGrammarPool that holds precached schemas.
*/
public void validate(String uri, XMLEntityResolver entityResolver, XMLGrammarPool grammarPool)
{
validateXSD(uri, false, entityResolver, null, null, grammarPool);
}
/**
* Validate the schema.
*
* @param schema The schema or it's location.
* @param inlineXSD True if an inline schema, false otherwise.
* @param entityResolver An entity resolver to use.
* @param targetNamespace The target namespace of the schema being validated.
* @param inlineSchemaEntityResolver An inline schema entity resolver.
* @param grammarPool A Xerces XMLGrammarPool that holds precached schemas.
*/
protected void validateXSD(String schema, boolean inlineXSD, XMLEntityResolver entityResolver, String targetNamespace, XMLEntityResolver inlineSchemaEntityResolver, XMLGrammarPool grammarPool)
{
ValidateErrorHandler errorHandler = new ValidateErrorHandler();
//errorHandler.getErrorMessages().clear();
try
{
XMLGrammarPreparser grammarPreparser = new XMLGrammarPreparser();
grammarPreparser.registerPreparser(XMLGrammarDescription.XML_SCHEMA,null/*schemaLoader*/);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.CONTINUE_AFTER_FATAL_ERROR_FEATURE, false);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE, true);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.NAMESPACE_PREFIXES_FEATURE, true);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.VALIDATION_FEATURE, true);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_VALIDATION_FEATURE, true);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_FULL_CHECKING, false);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.EXTERNAL_GENERAL_ENTITIES_FEATURE, true);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.EXTERNAL_PARAMETER_ENTITIES_FEATURE, true);
grammarPreparser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.WARN_ON_DUPLICATE_ATTDEF_FEATURE, true);
try
{
grammarPreparser.setFeature(HONOUR_ALL_SCHEMA_LOCATIONS_FEATURE_ID, true);
}
catch (Exception e)
{
// Catch the exception and ignore if we can't set this feature.
}
// cs : toggle the comments on these 2 lines to easily disable caching
// grammarPreparser.setGrammarPool(new XMLGrammarPoolImpl());
grammarPreparser.setGrammarPool(grammarPool != null ? grammarPool : new XMLGrammarPoolImpl());
grammarPreparser.setErrorHandler(errorHandler);
if (entityResolver != null)
{
grammarPreparser.setEntityResolver(entityResolver);
}
try
{
XMLInputSource is = null;
List oldGrammars = null;
XMLGrammarPoolImpl pool = null;
// This allows support for the inline schema in WSDL documents.
if (inlineXSD)
{
Reader reader = new StringReader(schema);
is = new XMLInputSource(null,filelocation,filelocation,reader,null);
((InlineXSDResolver)inlineSchemaEntityResolver).addReferringSchema(is,targetNamespace);
// In the case that 'shared' grammar pool is used we need to consider
// that we might have already added a schema to the pool with the same target namespace
// as the inline schema we're hoping to construct. In this case we need to remove
// the schema from the pool before constructing our inline schema. We can add it
// back when we're all done.
pool = (XMLGrammarPoolImpl)grammarPreparser.getGrammarPool();
oldGrammars = new ArrayList();
// Remove the inline schema namespace if it is listed directly
// in the pool. If it is indirectly listed as an import of a grammar listed
// directly in the pool hide the grammar to continue to get caching benefits
// from the cached grammar.
Grammar[] grammars = pool.retrieveInitialGrammarSet(XMLGrammarDescription.XML_SCHEMA);
int numGrammars = grammars.length;
for(int i = 0; i < numGrammars; i++)
{
XMLGrammarDescription desc = grammars[i].getGrammarDescription();
if(targetNamespace.equals(desc.getNamespace()))
{
oldGrammars.add(pool.removeGrammar(desc));
}
else
{
if(grammars[i] instanceof XSGrammar)
{
XSGrammar grammar = (XSGrammar)grammars[i];
StringList namespaces = grammar.toXSModel().getNamespaces();
if(namespaces.contains(targetNamespace))
{
oldGrammars.add(pool.removeGrammar(desc));
//pool.putGrammar(new XSGrammarHider(grammar, targetNamespace));
}
}
}
}
Set inlineNSs = ((InlineXSDResolver)inlineSchemaEntityResolver).getInlineSchemaNSs();
Iterator nsiter = inlineNSs.iterator();
while(nsiter.hasNext())
{
XSDDescription desc = new XSDDescription();
desc.setNamespace((String)nsiter.next());
Grammar oldGrammar = pool.removeGrammar(desc);
if(oldGrammar != null)
oldGrammars.add(oldGrammar);
}
}
// get the input source for an external schema file
else
{
is = new XMLInputSource(null,schema,schema);
}
XSGrammar grammar = (XSGrammar)grammarPreparser.preparseGrammar(XMLGrammarDescription.XML_SCHEMA,is);
xsModel = grammar.toXSModel();
// Here we add the temporiliy removed schema back.
if (inlineXSD && oldGrammars != null)
{
XSDDescription description = new XSDDescription();
description.setNamespace(targetNamespace);
pool.removeGrammar(description);
Set inlineNSs = ((InlineXSDResolver)inlineSchemaEntityResolver).getInlineSchemaNSs();
Iterator nsiter = inlineNSs.iterator();
while(nsiter.hasNext())
{
XSDDescription desc = new XSDDescription();
desc.setNamespace((String)nsiter.next());
pool.removeGrammar(desc);
}
Iterator oldGIter = oldGrammars.iterator();
while(oldGIter.hasNext())
{
Grammar oldGrammar = (Grammar)oldGIter.next();
if(oldGrammar != null)
pool.putGrammar(oldGrammar);
}
}
}
catch (Exception e)
{
// Parser will return null pointer exception if the document is structurally invalid.
// In this case we simply ignore the error.
//System.out.println(e);
}
errors = errorHandler.getErrorMessages();
}
catch (Exception e)
{
System.out.println(e);
}
if (errors.isEmpty())
{
isValidXSD = true;
}
}
/**
* Returns the XSModel created.
*
* @return The XSModel created.
*/
public XSModel getXSModel()
{
return xsModel;
}
/**
* Returns true if the schema is valid, false otherwise.
*
* @return True if the schema is valid, false otherwise.
*/
public boolean isValid()
{
return isValidXSD;
}
/**
* Return the error list.
*
* @return A list of error from the schema.
*/
public List getErrors()
{
return errors;
}
}