/*

 */

/*

 *

 *      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.xinclude;

import java.io.CharConversionException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.Locale;

import java.util.Stack;

import java.util.StringTokenizer;

import javax.xml.XMLConstants;

import com.sun.org.apache.xerces.internal.impl.Constants;

import com.sun.org.apache.xerces.internal.impl.XMLEntityManager;

import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;

import com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceException;

import com.sun.org.apache.xerces.internal.impl.msg.XMLMessageFormatter;

import com.sun.org.apache.xerces.internal.util.AugmentationsImpl;

import com.sun.org.apache.xerces.internal.util.HTTPInputSource;

import com.sun.org.apache.xerces.internal.util.IntStack;

import com.sun.org.apache.xerces.internal.util.ParserConfigurationSettings;

import com.sun.org.apache.xerces.internal.util.SymbolTable;

import com.sun.org.apache.xerces.internal.util.URI;

import com.sun.org.apache.xerces.internal.util.XMLAttributesImpl;

import com.sun.org.apache.xerces.internal.util.XMLResourceIdentifierImpl;

import com.sun.org.apache.xerces.internal.util.XMLChar;

import com.sun.org.apache.xerces.internal.util.XMLSymbols;

import com.sun.org.apache.xerces.internal.util.URI.MalformedURIException;

import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager;

import com.sun.org.apache.xerces.internal.xni.Augmentations;

import com.sun.org.apache.xerces.internal.xni.NamespaceContext;

import com.sun.org.apache.xerces.internal.xni.QName;

import com.sun.org.apache.xerces.internal.xni.XMLAttributes;

import com.sun.org.apache.xerces.internal.xni.XMLDTDHandler;

import com.sun.org.apache.xerces.internal.xni.XMLDocumentHandler;

import com.sun.org.apache.xerces.internal.xni.XMLLocator;

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier;

import com.sun.org.apache.xerces.internal.xni.XMLString;

import com.sun.org.apache.xerces.internal.xni.XNIException;

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.XMLDTDFilter;

import com.sun.org.apache.xerces.internal.xni.parser.XMLDTDSource;

import com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentFilter;

import com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentSource;

import com.sun.org.apache.xerces.internal.xni.parser.XMLEntityResolver;

import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;

import com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfiguration;

import com.sun.org.apache.xerces.internal.xpointer.XPointerHandler;

import com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor;

import com.sun.org.apache.xerces.internal.utils.ObjectFactory;

import com.sun.org.apache.xerces.internal.utils.XMLSecurityPropertyManager;

import java.util.Objects;

/**

 * <p>

 * This is a pipeline component which performs XInclude handling, according to the

 * W3C specification for XML Inclusions.

 * </p>

 * <p>

 * This component analyzes each event in the pipeline, looking for <include>

 * elements. An <include> element is one which has a namespace of

 * <code>http://www.w3.org/2001/XInclude</code> and a localname of <code>include</code>.

 * When it finds an <include> element, it attempts to include the file specified

 * in the <code>href</code> attribute of the element.  If inclusion succeeds, all

 * children of the <include> element are ignored (with the exception of

 * checking for invalid children as outlined in the specification).  If the inclusion

 * fails, the <fallback> child of the <include> element is processed.

 * </p>

 * <p>

 * See the <a href="http://www.w3.org/TR/xinclude/">XInclude specification</a> for

 * more information on how XInclude is to be used.

 * </p>

 * <p>

 * This component requires the following features and properties from the

 * component manager that uses it:

 * <ul>

 *  <li>http://xml.org/sax/features/allow-dtd-events-after-endDTD</li>

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

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

 * </ul>

 * Optional property:

 * <ul>

 *  <li>http://apache.org/xml/properties/input-buffer-size</li>

 * </ul>

 *

 * Furthermore, the <code>NamespaceContext</code> used in the pipeline is required

 * to be an instance of <code>XIncludeNamespaceSupport</code>.

 * </p>

 * <p>

 * Currently, this implementation has only partial support for the XInclude specification.

 * Specifically, it is missing support for XPointer document fragments.  Thus, only whole

 * documents can be included using this component in the pipeline.

 * </p>

 *

 * @author Peter McCracken, IBM

 * @author Michael Glavassevich, IBM

 *

 *

 * @see XIncludeNamespaceSupport

 */

public class XIncludeHandler

    implements XMLComponent, XMLDocumentFilter, XMLDTDFilter {

    public final static String XINCLUDE_DEFAULT_CONFIGURATION =

        "com.sun.org.apache.xerces.internal.parsers.XIncludeParserConfiguration";

    public final static String HTTP_ACCEPT = "Accept";

    public final static String HTTP_ACCEPT_LANGUAGE = "Accept-Language";

    public final static String XPOINTER = "xpointer";

    public final static String XINCLUDE_NS_URI =

        "http://www.w3.org/2001/XInclude".intern();

    public final static String XINCLUDE_INCLUDE = "include".intern();

    public final static String XINCLUDE_FALLBACK = "fallback".intern();

    public final static String XINCLUDE_PARSE_XML = "xml".intern();

    public final static String XINCLUDE_PARSE_TEXT = "text".intern();

    public final static String XINCLUDE_ATTR_HREF = "href".intern();

    public final static String XINCLUDE_ATTR_PARSE = "parse".intern();

    public final static String XINCLUDE_ATTR_ENCODING = "encoding".intern();

    public final static String XINCLUDE_ATTR_ACCEPT = "accept".intern();

    public final static String XINCLUDE_ATTR_ACCEPT_LANGUAGE = "accept-language".intern();

    // Top Level Information Items have [included] property in infoset

    public final static String XINCLUDE_INCLUDED = "[included]".intern();

    /** The identifier for the Augmentation that contains the current base URI */

    public final static String CURRENT_BASE_URI = "currentBaseURI";

    // used for adding [base URI] attributes

    public final static String XINCLUDE_BASE = "base".intern();

    public final static QName XML_BASE_QNAME =

        new QName(

            XMLSymbols.PREFIX_XML,

            XINCLUDE_BASE,

            (XMLSymbols.PREFIX_XML + ":" + XINCLUDE_BASE).intern(),

            NamespaceContext.XML_URI);

    // used for adding [language] attributes

    public final static String XINCLUDE_LANG = "lang".intern();

    public final static QName XML_LANG_QNAME =

        new QName(

            XMLSymbols.PREFIX_XML,

            XINCLUDE_LANG,

            (XMLSymbols.PREFIX_XML + ":" + XINCLUDE_LANG).intern(),

            NamespaceContext.XML_URI);

    public final static QName NEW_NS_ATTR_QNAME =

        new QName(

            XMLSymbols.PREFIX_XMLNS,

            "",

            XMLSymbols.PREFIX_XMLNS + ":",

            NamespaceContext.XMLNS_URI);

    // Processing States

    private final static int STATE_NORMAL_PROCESSING = 1;

    // we go into this state after a successful include (thus we ignore the children

    // of the include) or after a fallback

    private final static int STATE_IGNORE = 2;

    // we go into this state after a failed include.  If we don't encounter a fallback

    // before we reach the end include tag, it's a fatal error

    private final static int STATE_EXPECT_FALLBACK = 3;

    // recognized features and properties

    /** Feature identifier: validation. */

    protected static final String VALIDATION =

        Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;

    /** Feature identifier: schema validation. */

    protected static final String SCHEMA_VALIDATION =

        Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_VALIDATION_FEATURE;

    /** Feature identifier: dynamic validation. */

    protected static final String DYNAMIC_VALIDATION =

        Constants.XERCES_FEATURE_PREFIX + Constants.DYNAMIC_VALIDATION_FEATURE;

    /** Feature identifier: allow notation and unparsed entity events to be sent out of order. */

    protected static final String ALLOW_UE_AND_NOTATION_EVENTS =

        Constants.SAX_FEATURE_PREFIX

            + Constants.ALLOW_DTD_EVENTS_AFTER_ENDDTD_FEATURE;

    /** Feature identifier: fixup base URIs. */

    protected static final String XINCLUDE_FIXUP_BASE_URIS =

        Constants.XERCES_FEATURE_PREFIX + Constants.XINCLUDE_FIXUP_BASE_URIS_FEATURE;

    /** Feature identifier: fixup language. */

    protected static final String XINCLUDE_FIXUP_LANGUAGE =

        Constants.XERCES_FEATURE_PREFIX + Constants.XINCLUDE_FIXUP_LANGUAGE_FEATURE;

    /** 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;

    /** Property identifier: entity resolver. */

    protected static final String ENTITY_RESOLVER =

        Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_RESOLVER_PROPERTY;

    /** property identifier: security manager. */

    protected static final String SECURITY_MANAGER =

        Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;

    /** property identifier: buffer size. */

    public static final String BUFFER_SIZE =

        Constants.XERCES_PROPERTY_PREFIX + Constants.BUFFER_SIZE_PROPERTY;

    protected static final String PARSER_SETTINGS =

        Constants.XERCES_FEATURE_PREFIX + Constants.PARSER_SETTINGS;

    /** property identifier: XML security property manager. */

    protected static final String XML_SECURITY_PROPERTY_MANAGER =

            Constants.XML_SECURITY_PROPERTY_MANAGER;

    /** Recognized features. */

    private static final String[] RECOGNIZED_FEATURES =

        { ALLOW_UE_AND_NOTATION_EVENTS, XINCLUDE_FIXUP_BASE_URIS, XINCLUDE_FIXUP_LANGUAGE };

    /** Feature defaults. */

    private static final Boolean[] FEATURE_DEFAULTS = { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE };

    /** Recognized properties. */

    private static final String[] RECOGNIZED_PROPERTIES =

        { ERROR_REPORTER, ENTITY_RESOLVER, SECURITY_MANAGER, BUFFER_SIZE };

    /** Property defaults. */

    // instance variables

    // for XMLDocumentFilter

    protected XMLDocumentHandler fDocumentHandler;

    protected XMLDocumentSource fDocumentSource;

    // for XMLDTDFilter

    protected XMLDTDHandler fDTDHandler;

    protected XMLDTDSource fDTDSource;

    // for XIncludeHandler

    protected XIncludeHandler fParentXIncludeHandler;

    // for buffer size in XIncludeTextReader

    protected int fBufferSize = XMLEntityManager.DEFAULT_BUFFER_SIZE;

    // It "feels wrong" to store this value here.  However,

    // calculating it can be time consuming, so we cache it.

    // It's never going to change in the lifetime of this XIncludeHandler

    protected String fParentRelativeURI;

    // we cache the child parser configuration, so we don't have to re-create

    // the objects when the parser is re-used

    protected XMLParserConfiguration fChildConfig;

    // The cached child parser configuration, may contain a

    // XInclude or XPointer Handler.  Cache both these

    protected XMLParserConfiguration fXIncludeChildConfig;

    protected XMLParserConfiguration fXPointerChildConfig;

    // The XPointerProcessor

    protected XPointerProcessor fXPtrProcessor = null;

    protected XMLLocator fDocLocation;

    protected XIncludeMessageFormatter fXIncludeMessageFormatter = new XIncludeMessageFormatter();

    protected XIncludeNamespaceSupport fNamespaceContext;

    protected SymbolTable fSymbolTable;

    protected XMLErrorReporter fErrorReporter;

    protected XMLEntityResolver fEntityResolver;

    protected XMLSecurityManager fSecurityManager;

    protected XMLSecurityPropertyManager fSecurityPropertyMgr;

    // these are needed for text include processing

    protected XIncludeTextReader fXInclude10TextReader;

    protected XIncludeTextReader fXInclude11TextReader;

    // these are needed for XML Base processing

    protected XMLResourceIdentifier fCurrentBaseURI;

    protected IntStack fBaseURIScope;

    protected Stack fBaseURI;

    protected Stack fLiteralSystemID;

    protected Stack fExpandedSystemID;

    // these are needed for Language Fixup

    protected IntStack fLanguageScope;

    protected Stack fLanguageStack;

    protected String fCurrentLanguage;

    // used for passing features on to child XIncludeHandler objects

    protected ParserConfigurationSettings fSettings;

    // The current element depth.  We start at depth 0 (before we've reached any elements).

    // The first element is at depth 1.

    private int fDepth;

    // The current element depth of the result infoset.

    private int fResultDepth;

    // this value must be at least 1

    private static final int INITIAL_SIZE = 8;

    // Used to ensure that fallbacks are always children of include elements,

    // and that include elements are never children of other include elements.

    // An index contains true if the ancestor of the current element which resides

    // at that depth was an include element.

    private boolean[] fSawInclude = new boolean[INITIAL_SIZE];

    // Ensures that only one fallback element can be at a single depth.

    // An index contains true if we have seen any fallback elements at that depth,

    // and it is only reset to false when the end tag of the parent is encountered.

    private boolean[] fSawFallback = new boolean[INITIAL_SIZE];

    // The state of the processor at each given depth.

    private int[] fState = new int[INITIAL_SIZE];

    // buffering the necessary DTD events

    // flags which control whether base URI or language fixup is performed.

    private boolean fFixupBaseURIs = true;

    private boolean fFixupLanguage = true;

    // for SAX compatibility.

    // Has the value of the ALLOW_UE_AND_NOTATION_EVENTS feature

    private boolean fSendUEAndNotationEvents;

    // track the version of the document being parsed

    private boolean fIsXML11;

    // track whether a DTD is being parsed

    private boolean fInDTD;

    // track whether the root element of the result infoset has been processed

    private boolean fSeenRootElement;

    // track whether the child config needs its features refreshed

    private boolean fNeedCopyFeatures = true;

    // Constructors

    public XIncludeHandler() {

        fDepth = 0;

        fSawFallback[fDepth] = false;

        fSawInclude[fDepth] = false;

        fState[fDepth] = STATE_NORMAL_PROCESSING;

        fBaseURIScope = new IntStack();

        fBaseURI = new Stack();

        fLiteralSystemID = new Stack();

        fExpandedSystemID = new Stack();

        fCurrentBaseURI = new XMLResourceIdentifierImpl();

        fLanguageScope = new IntStack();

        fLanguageStack = new Stack();

        fCurrentLanguage = null;

    }

    // XMLComponent methods

    @Override

    public void reset(XMLComponentManager componentManager)

        throws XNIException {

        fNamespaceContext = null;

        fDepth = 0;

        fResultDepth = isRootDocument() ? 0 : fParentXIncludeHandler.getResultDepth();

        fNotations.clear();

        fUnparsedEntities.clear();

        fParentRelativeURI = null;

        fIsXML11 = false;

        fInDTD = false;

        fSeenRootElement = false;

        fBaseURIScope.clear();

        fBaseURI.clear();

        fLiteralSystemID.clear();

        fExpandedSystemID.clear();

        fLanguageScope.clear();

        fLanguageStack.clear();

        // REVISIT: Find a better method for maintaining

        // the state of the XInclude processor. These arrays

        // can potentially grow quite large. Cleaning them

        // out on reset may be very time consuming. -- mrglavas

        //

        // clear the previous settings from the arrays

        for (int i = 0; i < fState.length; ++i) {

            fState[i] = STATE_NORMAL_PROCESSING;

        }

        for (int i = 0; i < fSawFallback.length; ++i) {

            fSawFallback[i] = false;

        }

        for (int i = 0; i < fSawInclude.length; ++i) {

            fSawInclude[i] = false;

        }

        try {

            if (!componentManager.getFeature(PARSER_SETTINGS)) {

                // if parser settings have not changed return.

                return;

            }

        }

        catch (XMLConfigurationException e) {}

        // parser settings changed. Need to refresh features on child config.

        fNeedCopyFeatures = true;

        try {

            fSendUEAndNotationEvents =

                componentManager.getFeature(ALLOW_UE_AND_NOTATION_EVENTS);

            if (fChildConfig != null) {

                fChildConfig.setFeature(

                    ALLOW_UE_AND_NOTATION_EVENTS,

                    fSendUEAndNotationEvents);

            }

        }

        catch (XMLConfigurationException e) {

        }

        try {

            fFixupBaseURIs =

                componentManager.getFeature(XINCLUDE_FIXUP_BASE_URIS);

            if (fChildConfig != null) {

                fChildConfig.setFeature(

                    XINCLUDE_FIXUP_BASE_URIS,

                    fFixupBaseURIs);

            }

        }

        catch (XMLConfigurationException e) {

            fFixupBaseURIs = true;

        }

        try {

            fFixupLanguage =

                componentManager.getFeature(XINCLUDE_FIXUP_LANGUAGE);

            if (fChildConfig != null) {

                fChildConfig.setFeature(

                    XINCLUDE_FIXUP_LANGUAGE,

                    fFixupLanguage);

            }

        }

        catch (XMLConfigurationException e) {

            fFixupLanguage = true;

        }

        // Get symbol table.

        try {

            SymbolTable value =

                (SymbolTable)componentManager.getProperty(SYMBOL_TABLE);

            if (value != null) {

                fSymbolTable = value;

                if (fChildConfig != null) {

                    fChildConfig.setProperty(SYMBOL_TABLE, value);

                }

            }

        }

        catch (XMLConfigurationException e) {

            fSymbolTable = null;

        }

        // Get error reporter.

        try {

            XMLErrorReporter value =

                (XMLErrorReporter)componentManager.getProperty(ERROR_REPORTER);

            if (value != null) {

                setErrorReporter(value);

                if (fChildConfig != null) {

                    fChildConfig.setProperty(ERROR_REPORTER, value);

                }

            }

        }

        catch (XMLConfigurationException e) {

            fErrorReporter = null;

        }

        // Get entity resolver.

        try {

            XMLEntityResolver value =

                (XMLEntityResolver)componentManager.getProperty(