/*

 */

/*

 * Copyright 2005 The Apache Software Foundation.

 *

 * Licensed 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.impl ;

import com.sun.xml.internal.stream.StaxEntityResolverWrapper;

import com.sun.xml.internal.stream.StaxXMLInputSource;

import com.sun.xml.internal.stream.XMLEntityStorage;

import java.io.*;

import java.lang.reflect.Method;

import java.net.HttpURLConnection;

import java.net.URL;

import java.net.URLConnection;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Locale;

import java.util.Map;

import java.util.Stack;

/**

 * Will keep track of current entity.

 *

 * The entity manager handles the registration of general and parameter

 * entities; resolves entities; and starts entities. The entity manager

 * is a central component in a standard parser configuration and this

 * class works directly with the entity scanner to manage the underlying

 * xni.

 * <p>

 * This component requires the following features and properties from the

 * component manager that uses it:

 * <ul>

 *  <li>http://xml.org/sax/features/validation</li>

 *  <li>http://xml.org/sax/features/external-general-entities</li>

 *  <li>http://xml.org/sax/features/external-parameter-entities</li>

 *  <li>http://apache.org/xml/features/allow-java-encodings</li>

 *  <li>http://apache.org/xml/properties/internal/symbol-table</li>

 *  <li>http://apache.org/xml/properties/internal/error-reporter</li>

 *  <li>http://apache.org/xml/properties/internal/entity-resolver</li>

 * </ul>

 *

 *

 * @author Andy Clark, IBM

 * @author Arnaud  Le Hors, IBM

 * @author K.Venugopal SUN Microsystems

 * @author Neeraj Bajaj SUN Microsystems

 * @author Sunitha Reddy SUN Microsystems

 * @version $Id: XMLEntityManager.java,v 1.17 2010-11-01 04:39:41 joehw Exp $

 */

public class XMLEntityManager implements XMLComponent, XMLEntityResolver {

    //

    // Constants

    //

    /** Default buffer size (2048). */

    public static final int DEFAULT_BUFFER_SIZE = 8192;

    /** Default buffer size before we've finished with the XMLDecl:  */

    public static final int DEFAULT_XMLDECL_BUFFER_SIZE = 64;

    /** Default internal entity buffer size (1024). */

    public static final int DEFAULT_INTERNAL_BUFFER_SIZE = 1024;

    // feature identifiers

    /** Feature identifier: validation. */

    protected static final String VALIDATION =

            Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;

    /**

     * standard uri conformant (strict uri).

     * http://apache.org/xml/features/standard-uri-conformant

     */

    protected boolean fStrictURI;

    /** Feature identifier: external general entities. */

    protected static final String EXTERNAL_GENERAL_ENTITIES =

            Constants.SAX_FEATURE_PREFIX + Constants.EXTERNAL_GENERAL_ENTITIES_FEATURE;

    /** Feature identifier: external parameter entities. */

    protected static final String EXTERNAL_PARAMETER_ENTITIES =

            Constants.SAX_FEATURE_PREFIX + Constants.EXTERNAL_PARAMETER_ENTITIES_FEATURE;

    /** Feature identifier: allow Java encodings. */

    protected static final String ALLOW_JAVA_ENCODINGS =

            Constants.XERCES_FEATURE_PREFIX + Constants.ALLOW_JAVA_ENCODINGS_FEATURE;

    /** Feature identifier: warn on duplicate EntityDef */

    protected static final String WARN_ON_DUPLICATE_ENTITYDEF =

            Constants.XERCES_FEATURE_PREFIX +Constants.WARN_ON_DUPLICATE_ENTITYDEF_FEATURE;

    // property identifiers

    /** Property identifier: symbol table. */

    protected static final String SYMBOL_TABLE =

            Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;

    /** Property identifier: error reporter. */

    protected static final String ERROR_REPORTER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;

    /** Feature identifier: standard uri conformant */

    protected static final String STANDARD_URI_CONFORMANT =

            Constants.XERCES_FEATURE_PREFIX +Constants.STANDARD_URI_CONFORMANT_FEATURE;

    /** Property identifier: entity resolver. */

    protected static final String ENTITY_RESOLVER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_RESOLVER_PROPERTY;

    protected static final String STAX_ENTITY_RESOLVER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.STAX_ENTITY_RESOLVER_PROPERTY;

    // property identifier:  ValidationManager

    protected static final String VALIDATION_MANAGER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.VALIDATION_MANAGER_PROPERTY;

    /** property identifier: buffer size. */

    protected static final String BUFFER_SIZE =

            Constants.XERCES_PROPERTY_PREFIX + Constants.BUFFER_SIZE_PROPERTY;

    /** property identifier: security manager. */

    protected static final String SECURITY_MANAGER =

        Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;

        Constants.XERCES_FEATURE_PREFIX + Constants.PARSER_SETTINGS;

    // recognized features and properties

    /** Recognized features. */

    private static final String[] RECOGNIZED_FEATURES = {

                VALIDATION,

                EXTERNAL_GENERAL_ENTITIES,

                EXTERNAL_PARAMETER_ENTITIES,

                ALLOW_JAVA_ENCODINGS,

                WARN_ON_DUPLICATE_ENTITYDEF,

                STANDARD_URI_CONFORMANT

    };

    /** Feature defaults. */

    private static final Boolean[] FEATURE_DEFAULTS = {

                null,

                Boolean.TRUE,

                Boolean.TRUE,

                Boolean.TRUE,

                Boolean.FALSE,

                Boolean.FALSE

    };

    /** Recognized properties. */

    private static final String[] RECOGNIZED_PROPERTIES = {

                SYMBOL_TABLE,

                ERROR_REPORTER,

                ENTITY_RESOLVER,

                VALIDATION_MANAGER,

                BUFFER_SIZE,

                SECURITY_MANAGER,

    };

    /** Property defaults. */

    private static final Object[] PROPERTY_DEFAULTS = {

                null,

                null,

                null,

                null,

                new Integer(DEFAULT_BUFFER_SIZE),

    };

    private static final String XMLEntity = "[xml]".intern();

    private static final String DTDEntity = "[dtd]".intern();

    // debugging

    /**

     * Debug printing of buffer. This debugging flag works best when you

     * resize the DEFAULT_BUFFER_SIZE down to something reasonable like

     * 64 characters.

     */

    private static final boolean DEBUG_BUFFER = false;

    /** warn on duplicate Entity declaration.

     *  http://apache.org/xml/features/warn-on-duplicate-entitydef

     */

    protected boolean fWarnDuplicateEntityDef;

    /** Debug some basic entities. */

    private static final boolean DEBUG_ENTITIES = false;

    /** Debug switching readers for encodings. */

    private static final boolean DEBUG_ENCODINGS = false;

    // should be diplayed trace resolving messages

    private static final boolean DEBUG_RESOLVER = false ;

    //

    // Data

    //

    // features

    /**

     * Validation. This feature identifier is:

     * http://xml.org/sax/features/validation

     */

    protected boolean fValidation;

    /**

     * External general entities. This feature identifier is:

     * http://xml.org/sax/features/external-general-entities

     */

    protected boolean fExternalGeneralEntities;

    /**

     * External parameter entities. This feature identifier is:

     * http://xml.org/sax/features/external-parameter-entities

     */

    protected boolean fExternalParameterEntities;

    /**

     * Allow Java encoding names. This feature identifier is:

     * http://apache.org/xml/features/allow-java-encodings

     */

    protected boolean fAllowJavaEncodings = true ;

    // properties

    /**

     * Symbol table. This property identifier is:

     * http://apache.org/xml/properties/internal/symbol-table

     */

    protected SymbolTable fSymbolTable;

    /**

     * Error reporter. This property identifier is:

     * http://apache.org/xml/properties/internal/error-reporter

     */

    protected XMLErrorReporter fErrorReporter;

    /**

     * Entity resolver. This property identifier is:

     * http://apache.org/xml/properties/internal/entity-resolver

     */

    protected XMLEntityResolver fEntityResolver;

    /** Stax Entity Resolver. This property identifier is XMLInputFactory.ENTITY_RESOLVER */

    protected StaxEntityResolverWrapper fStaxEntityResolver;

    /** Property Manager. This is used from Stax */

    protected PropertyManager fPropertyManager ;

    // settings

    /**

     * Validation manager. This property identifier is:

     * http://apache.org/xml/properties/internal/validation-manager

     */

    protected ValidationManager fValidationManager;

    // settings

    /**

     * Buffer size. We get this value from a property. The default size

     * is used if the input buffer size property is not specified.

     * REVISIT: do we need a property for internal entity buffer size?

     */

    protected int fBufferSize = DEFAULT_BUFFER_SIZE;

    // stores defaults for entity expansion limit if it has

    // been set on the configuration.

    protected SecurityManager fSecurityManager = null;

    /**

     * True if the document entity is standalone. This should really

     * only be set by the document source (e.g. XMLDocumentScanner).

     */

    protected boolean fStandalone;

    // are the entities being parsed in the external subset?

    // NOTE:  this *is not* the same as whether they're external entities!

    protected boolean fInExternalSubset = false;

    // handlers

    /** Entity handler. */

    protected XMLEntityHandler fEntityHandler;

    /** Current entity scanner */

    protected XMLEntityScanner fEntityScanner ;

    /** XML 1.0 entity scanner. */

    protected XMLEntityScanner fXML10EntityScanner;

    /** XML 1.1 entity scanner. */

    protected XMLEntityScanner fXML11EntityScanner;

    /** entity expansion limit (contains useful data if and only if

    fSecurityManager is non-null) */

    protected int fEntityExpansionLimit = 0;

    /** count of entities expanded: */

    protected int fEntityExpansionCount = 0;

    // entities

    /** Entities. */

    protected Hashtable fEntities = new Hashtable();

    /** Entity stack. */

    protected Stack fEntityStack = new Stack();

    /** Current entity. */

    protected Entity.ScannedEntity fCurrentEntity = null;

    // shared context

    protected XMLEntityStorage fEntityStorage ;

    protected final Object [] defaultEncoding = new Object[]{"UTF-8", null};

    // temp vars

    /** Resource identifer. */

    private final XMLResourceIdentifierImpl fResourceIdentifier = new XMLResourceIdentifierImpl();

    /** Augmentations for entities. */

    private final Augmentations fEntityAugs = new AugmentationsImpl();

    /** Pool of character buffers. */

    private CharacterBufferPool fBufferPool = new CharacterBufferPool(fBufferSize, DEFAULT_INTERNAL_BUFFER_SIZE);

    //

    // Constructors

    //

    /**

     * If this constructor is used to create the object, reset() should be invoked on this object

     */

    public XMLEntityManager() {

        fEntityStorage = new XMLEntityStorage(this) ;

        setScannerVersion(Constants.XML_VERSION_1_0);

    } // <init>()

    /** Default constructor. */

    public XMLEntityManager(PropertyManager propertyManager) {

        fPropertyManager = propertyManager ;

        //pass a reference to current entity being scanned

        //fEntityStorage = new XMLEntityStorage(fCurrentEntity) ;

        fEntityStorage = new XMLEntityStorage(this) ;

        fEntityScanner = new XMLEntityScanner(propertyManager, this) ;

        reset(propertyManager);

    } // <init>()

    /**

     * Adds an internal entity declaration.

     * <p>

     * <strong>Note:</strong> This method ignores subsequent entity

     * declarations.

     * <p>

     * <strong>Note:</strong> The name should be a unique symbol. The

     * SymbolTable can be used for this purpose.

     *

     * @param name The name of the entity.

     * @param text The text of the entity.

     *

     * @see SymbolTable

     */

    public void addInternalEntity(String name, String text) {

        if (!fEntities.containsKey(name)) {

            Entity entity = new Entity.InternalEntity(name, text, fInExternalSubset);

            fEntities.put(name, entity);

        } else{

            if(fWarnDuplicateEntityDef){

                fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,

                        "MSG_DUPLICATE_ENTITY_DEFINITION",

                        new Object[]{ name },

                        XMLErrorReporter.SEVERITY_WARNING );

            }

        }

    } // addInternalEntity(String,String)

    /**

     * Adds an external entity declaration.

     * <p>

     * <strong>Note:</strong> This method ignores subsequent entity

     * declarations.

     * <p>

     * <strong>Note:</strong> The name should be a unique symbol. The

     * SymbolTable can be used for this purpose.

     *

     * @param name         The name of the entity.

     * @param publicId     The public identifier of the entity.

     * @param literalSystemId     The system identifier of the entity.

     * @param baseSystemId The base system identifier of the entity.

     *                     This is the system identifier of the entity

     *                     where <em>the entity being added</em> and

     *                     is used to expand the system identifier when

     *                     the system identifier is a relative URI.

     *                     When null the system identifier of the first

     *                     external entity on the stack is used instead.

     *

     * @see SymbolTable

     */

    public void addExternalEntity(String name,

            String publicId, String literalSystemId,

            String baseSystemId) throws IOException {

        if (!fEntities.containsKey(name)) {

            if (baseSystemId == null) {

                // search for the first external entity on the stack

                int size = fEntityStack.size();

                if (size == 0 && fCurrentEntity != null && fCurrentEntity.entityLocation != null) {

                    baseSystemId = fCurrentEntity.entityLocation.getExpandedSystemId();

                }

                for (int i = size - 1; i >= 0 ; i--) {

                    Entity.ScannedEntity externalEntity =

                            (Entity.ScannedEntity)fEntityStack.elementAt(i);

                    if (externalEntity.entityLocation != null && externalEntity.entityLocation.getExpandedSystemId() != null) {

                        baseSystemId = externalEntity.entityLocation.getExpandedSystemId();

                        break;

                    }

                }

            }

            Entity entity = new Entity.ExternalEntity(name,

                    new XMLEntityDescriptionImpl(name, publicId, literalSystemId, baseSystemId,

                    expandSystemId(literalSystemId, baseSystemId, false)), null, fInExternalSubset);

            fEntities.put(name, entity);

        } else{

            if(fWarnDuplicateEntityDef){

                fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,

                        "MSG_DUPLICATE_ENTITY_DEFINITION",

                        new Object[]{ name },

                        XMLErrorReporter.SEVERITY_WARNING );

            }

        }

    } // addExternalEntity(String,String,String,String)

    /**

     * Adds an unparsed entity declaration.

     * <p>

     * <strong>Note:</strong> This method ignores subsequent entity

     * declarations.

     * <p>

     * <strong>Note:</strong> The name should be a unique symbol. The

     * SymbolTable can be used for this purpose.

     *

     * @param name     The name of the entity.

     * @param publicId The public identifier of the entity.

     * @param systemId The system identifier of the entity.

     * @param notation The name of the notation.

     *

     * @see SymbolTable

     */

    public void addUnparsedEntity(String name,

            String publicId, String systemId,

            String baseSystemId, String notation) {

        if (!fEntities.containsKey(name)) {

            Entity.ExternalEntity entity = new Entity.ExternalEntity(name,

                    new XMLEntityDescriptionImpl(name, publicId, systemId, baseSystemId, null),

                    notation, fInExternalSubset);

            fEntities.put(name, entity);

        } else{