merge the formfield patch from ooo-build

[ooovba.git] / xmlsecurity / tools / uno / XMLSecurityFrameworkController.java

/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * $RCSfile: XMLSecurityFrameworkController.java,v $
 * $Revision: 1.4 $
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

package com.sun.star.xml.security.uno;

import java.util.Stack;
import java.util.Vector;

/* uno classes */
import com.sun.star.uno.UnoRuntime;
import com.sun.star.lang.XMultiComponentFactory;
import com.sun.star.lang.XInitialization;
import com.sun.star.uno.XComponentContext;
import com.sun.star.xml.sax.XDocumentHandler;
import com.sun.star.xml.sax.XAttributeList;
import com.sun.star.xml.sax.SAXException;

import com.sun.star.xml.crypto.*;
import com.sun.star.xml.crypto.sax.*;
import com.sun.star.xml.wrapper.*;

/*
 * the XMLSecurityFrameworkController class is used to controll the xml security framework.
 */
public class XMLSecurityFrameworkController 
    implements XDocumentHandler, XSignatureCreationResultListener, XSignatureVerifyResultListener,
           XEncryptionResultListener, XDecryptionResultListener, XSAXEventKeeperStatusChangeListener
{
    /*
     * UNO framework component
     */
    private XMultiComponentFactory  m_xRemoteServiceManager;
    private XComponentContext       m_xRemoteContext;
    
    /*
     * xml security related UNO components
     */
    private XSecuritySAXEventKeeper m_xSAXEventKeeper;
    private XXMLDocumentWrapper     m_xXMLDocumentWrapper;
    private XDocumentHandler        m_xOutputHandler;
    private XXMLSecurityContext     m_xXMLSecurityContext;
    private XXMLSignature           m_xXMLSignature;
    private XXMLEncryption          m_xXMLEncryption;
    
        /*
         * used to reserve the current SAX ancestor path
         */
    private Stack  m_currentPath;
    
    /*
     * maintains all SignatureEntities.
     */
    private Vector m_signatureList;
    
    /*
     * maintains all EncryptionEntities.
     */
    private Vector m_encryptionList;
    
    /*
     * maintains all unsolved reference Ids.
     * These ids are strings which is the value of the id attribute
     * of the referenced element.
     */
    private Vector m_vUnsolvedReferenceIds;
    
    /*
     * maintains all unsolved reference keeper ids.
     * The keeper id is used to uniquely identify a bufferred element
     * by the SAXEventKeeper.
     */
    private Vector m_vUnsolvedReferencedKeeperIds;
    
    /*
     * maintains the left time that each unsolved reference can be 
     * claimed.
     */
    private Vector m_vUnsolvedReferenceRefNum;
    
    /*
     * whether exporting or importing
     */
    private boolean m_bIsExporting;
    
    /*
     * whether java or c
     */
    private boolean m_bIsJavaBased;
    
    /*
     * whether the SAXEventKeeper is blocking
     */
    private boolean m_bIsBlocking;
    
    /*
     * whether it is collecting a bufferred element
     */
    private boolean m_bIsInsideCollectedElement;
    
    /*
     * whether a SAXEventKeeper is in the SAX chain
     */
    private boolean m_bSAXEventKeeperIncluded;

    /*
     * the ParsingThread used to parse the document
     */
    private ParsingThread m_parsingThread;
    
    /*
     * the next document handler that will receives SAX events
     * from the parsing thread.
     * if the SAXEventKeeper is on the SAX chain, then this
     * variable will be the SAXEventKeeper, otherwise, this
     * variable will be the xOutputHandler.
     */
    private XDocumentHandler m_xExportHandler;
    
    /*
     * the TestTool used to feedback information
     */
    private TestTool m_testTool;
    
    /*
     * for encryption target
     */
    private boolean m_bIsEncryptionTarget;
    private EncryptionEntity m_EncryptionForTarget;
    
    XMLSecurityFrameworkController(
        TestTool testTool,
        boolean bIsExporting,
        boolean bIsJavaBased,
        XDocumentHandler xOutputHandler,
        ParsingThread parsingThread,
        XXMLSecurityContext xXMLSecurityContext,
        XXMLSignature xXMLSignature,
        XXMLEncryption xXMLEncryption,
        XMultiComponentFactory xRemoteServiceManager,
        XComponentContext xRemoteContext)
    {
        m_bIsExporting = bIsExporting;
        m_bIsJavaBased = bIsJavaBased;
        
        m_xOutputHandler = xOutputHandler;
        m_xXMLSecurityContext = xXMLSecurityContext;
        m_xXMLSignature = xXMLSignature;
        m_xXMLEncryption = xXMLEncryption;
        m_xRemoteServiceManager = xRemoteServiceManager;
        m_xRemoteContext = xRemoteContext;
        
        m_testTool = testTool;
        m_parsingThread = parsingThread;
        
        m_signatureList = new Vector();
        m_encryptionList = new Vector();
        
        m_vUnsolvedReferenceIds = new Vector();
        m_vUnsolvedReferencedKeeperIds = new Vector();
        m_vUnsolvedReferenceRefNum = new Vector();
        
        m_xXMLDocumentWrapper = null;
        m_xSAXEventKeeper = null;
        
        m_bSAXEventKeeperIncluded = false;
        m_bIsBlocking = false;
        m_bIsInsideCollectedElement = false;
        
        m_bIsEncryptionTarget = false;
        m_EncryptionForTarget = null;

        changeOutput();
        
        m_currentPath = new Stack();
        
        foundSecurityRelated();
    }
    
/**************************************************************************************
 * private methods
 **************************************************************************************/
 
        /*
         * changes the output document handler.
         */
        private void changeOutput()
        {
        if (m_bIsExporting)
        {
            m_parsingThread.setHandler(this);
            
            /*
             * If the SAXEventKeeper is in the SAX chain, then redirects output
             * to the SAXEventKeeper, otherwise, to the m_xOutputHandler
             */
            if (m_bSAXEventKeeperIncluded)
            {
                m_xExportHandler = (XDocumentHandler)UnoRuntime.queryInterface(
                            XDocumentHandler.class, m_xSAXEventKeeper);
                m_xSAXEventKeeper.setNextHandler(m_xOutputHandler);
                
                m_testTool.updatesSAXChainInformation("XMLExporter -> SAXEventKeeper -> SAXWriter");
            }
            else
            {
                m_xExportHandler = m_xOutputHandler;
                m_testTool.updatesSAXChainInformation("XMLExporter -> SAXWriter");
            }
        }
        else
        {
            if (m_bSAXEventKeeperIncluded)
            {
                m_parsingThread.setHandler(
                    (XDocumentHandler)UnoRuntime.queryInterface(XDocumentHandler.class, m_xSAXEventKeeper));
                m_xSAXEventKeeper.setNextHandler(this);
                m_testTool.updatesSAXChainInformation("SAXParser -> SAXEventKeeper -> XMLImporter");
            }
            else
            {
                m_parsingThread.setHandler(this);
                m_testTool.updatesSAXChainInformation("SAXParser -> XMLImporter");
            }
            m_xExportHandler = m_xOutputHandler;
        }
    }
        
        /*
         * handles the situation when a security related element is found.
         * if the SAXEventKeeper is not initialized, then creates a
         * SAXEventKeeper.
         * the return value represents whether the SAXEventKeeper is newly
         * created.
         */     
    private boolean foundSecurityRelated()
    {
        if (m_xSAXEventKeeper == null)
        {
            m_testTool.showMessage("Message from : "+
                        (m_bIsExporting?"XMLExporter":"XMLImporter")+
                        "\n\nA security related content found, a SAXEventKeeper is created.\n ");
            
            m_bIsBlocking = false;
            m_bIsInsideCollectedElement = false;

            try
            {
                /*
                 * creates an XMLDocumentWrapper component.
                 */
                Object xmlDocumentObj = null;
                
                if (m_bIsJavaBased)
                {
                    xmlDocumentObj = m_xRemoteServiceManager.createInstanceWithContext(
                        TestTool.XMLDOCUMENTWRAPPER_COMPONENT_JAVA, m_xRemoteContext);
                }
                else
                {
                    xmlDocumentObj = m_xRemoteServiceManager.createInstanceWithContext(
                        TestTool.XMLDOCUMENTWRAPPER_COMPONENT_C, m_xRemoteContext);
                }
                
                m_xXMLDocumentWrapper = (XXMLDocumentWrapper)UnoRuntime.queryInterface(
                    XXMLDocumentWrapper.class, xmlDocumentObj);
                    
                /*
                 * creates a SAXEventKeeper component.
                 */
                Object saxEventKeeperObj = m_xRemoteServiceManager.createInstanceWithContext(
                    TestTool.SAXEVENTKEEPER_COMPONENT, m_xRemoteContext);

                m_xSAXEventKeeper = 
                    (XSecuritySAXEventKeeper)UnoRuntime.queryInterface(
                        XSecuritySAXEventKeeper.class, saxEventKeeperObj); 
                            
                            /*
                             * initializes the SAXEventKeeper component with the XMLDocumentWrapper component.
                             */
                XInitialization xInitialization = 
                    (XInitialization)UnoRuntime.queryInterface(
                        XInitialization.class, m_xSAXEventKeeper);
                Object args[]=new Object[1];
                args[0] = m_xXMLDocumentWrapper;
                xInitialization.initialize(args);
            }
            catch( com.sun.star.uno.Exception e)
            {
                e.printStackTrace();
            }
            
            /*
             * configures the SAXEventKeeper's status change listener.
             */
            XSAXEventKeeperStatusChangeBroadcaster xSaxEventKeeperStatusChangeBroadcaster = 
                (XSAXEventKeeperStatusChangeBroadcaster)UnoRuntime.queryInterface(
                    XSAXEventKeeperStatusChangeBroadcaster.class, m_xSAXEventKeeper); 
            xSaxEventKeeperStatusChangeBroadcaster.addSAXEventKeeperStatusChangeListener(this);
        }
        
        boolean rc = !m_bSAXEventKeeperIncluded;
        
        /*
         * changes the export document handler.
         */
        m_bSAXEventKeeperIncluded=true;
        changeOutput();

        return rc;
    }

    /*
     * finds key element or referenced element for a signature.
     */
    private void findKeyOrReference(SecurityEntity signatureEntity, String uriStr, boolean isFindingKey)
    {
        int i=0;
        
        while (i<m_vUnsolvedReferenceIds.size())
        {
            String id = (String)m_vUnsolvedReferenceIds.elementAt(i);
            
            if (id.equals(uriStr))
            {
                int refNum = ((Integer)m_vUnsolvedReferenceRefNum.elementAt(i)).intValue();
                int keeperId = ((Integer)m_vUnsolvedReferencedKeeperIds.elementAt(i)).intValue();
                
                if (isFindingKey)
                {
                    /*
                     * clones a new ElementCollector for the key element.
                     */
                    int cloneKeeperId = m_xSAXEventKeeper.cloneElementCollector(
                        keeperId,
                        m_bIsExporting?
                        (ElementMarkPriority.BEFOREMODIFY):(ElementMarkPriority.AFTERMODIFY));
                    
                    /*
                     * notifies the key keeper id.
                     */
                    signatureEntity.setKeyId(cloneKeeperId);
                    
                    /*
                     * sets the security id for the key.
                     */
                    m_xSAXEventKeeper.setSecurityId(cloneKeeperId, signatureEntity.getSecurityId());
    
                    /*
                     * sets the resolve listener.
                     */
                    XReferenceResolvedBroadcaster xReferenceResolvedBroadcaster =
                        (XReferenceResolvedBroadcaster)UnoRuntime.queryInterface(
                            XReferenceResolvedBroadcaster.class, m_xSAXEventKeeper);
                    xReferenceResolvedBroadcaster.addReferenceResolvedListener(
                        cloneKeeperId,
                        signatureEntity.getReferenceListener());
                }
                else
                {
                    /*
                     * clones a new ElementCollector for the referenced element.
                     */
                    int cloneKeeperId = m_xSAXEventKeeper.cloneElementCollector(
                        keeperId, 
                        m_bIsExporting?
                        (ElementMarkPriority.AFTERMODIFY):(ElementMarkPriority.BEFOREMODIFY));
                    
                    /*
                     * sets the security id.
                     */
                    m_xSAXEventKeeper.setSecurityId(cloneKeeperId, signatureEntity.getSecurityId());
                    
                    /*
                     * sets the resolve listener.
                     */
                    XReferenceResolvedBroadcaster xReferenceResolvedBroadcaster =
                        (XReferenceResolvedBroadcaster)UnoRuntime.queryInterface(
                            XReferenceResolvedBroadcaster.class, m_xSAXEventKeeper);
                    xReferenceResolvedBroadcaster.addReferenceResolvedListener(cloneKeeperId,
                        signatureEntity.getReferenceListener());
                        
                    try{
                        XReferenceCollector xReferenceCollector =
                            (XReferenceCollector)UnoRuntime.queryInterface(
                                XReferenceCollector.class, signatureEntity.getReferenceListener());
                        xReferenceCollector.setReferenceId(cloneKeeperId);
                    }
                    catch( com.sun.star.uno.Exception e)
                    {
                        e.printStackTrace();
                    }
                }
                    
                /*
                 * if this unsolved reference reaches its max reference number, remove this reference
                 * from all vectors.
                 */
                refNum--;
                if (refNum == 0)
                {
                    m_xSAXEventKeeper.removeElementCollector(keeperId);
                    m_vUnsolvedReferenceIds.remove(i);
                    m_vUnsolvedReferencedKeeperIds.remove(i);
                    m_vUnsolvedReferenceRefNum.remove(i);
                }
                else
                {
                    m_vUnsolvedReferenceRefNum.setElementAt(new Integer(refNum),(i));
                    ++i;
                }
                
                /*
                 * If it is find a key, then no further search is needed, one
                 * signature has one key at most.
                 */
                if (isFindingKey)
                {
                    break;
                }
            }
            else
            {
                ++i;
            }
        }
    }
        
    /*
     * checks whether a startElement event represents any security related information.
     * return true if this event can't be forwarded into the SAX chain.
     */
    private boolean checkSecurityElement(String localName, com.sun.star.xml.sax.XAttributeList xattribs)
    {
        boolean rc = false;
        
        if (localName.equals("Signature"))
        /*
         * this element is a Signature element.
         */
        {
            SignatureEntity signatureEntity = new SignatureEntity(
                m_xSAXEventKeeper,
                m_bIsExporting,
                this,
                m_xXMLSecurityContext,
                m_xXMLSignature,
                m_xXMLEncryption,
                m_xRemoteServiceManager,
                m_xRemoteContext);

            m_signatureList.add(signatureEntity);
            m_currentPath.push(signatureEntity);
        }
        else if(localName.equals("Reference"))
        {
            if (!m_currentPath.empty())
            {
                Object signedInfo = m_currentPath.pop();
                
                if (!m_currentPath.empty())
                {
                    Object objSignature = m_currentPath.peek();
            
                    if ((objSignature instanceof SignatureEntity) && signedInfo.toString().equals("SignedInfo"))
                    /*
                     * this element is a Reference element in a signature.
                     */
                    {
                        String uriStr = xattribs.getValueByName("URI");
                        
                        if (uriStr.charAt(0) == '#')
                        {
                            uriStr = uriStr.substring(1);
                            SignatureEntity signatureEntity = (SignatureEntity)objSignature;
            
                            if (uriStr != null && uriStr.length()>0)
                            {
                                signatureEntity.addReferenceId(uriStr);
                                findKeyOrReference(signatureEntity, uriStr, false);
                            }
                        }
                    }
                }
                m_currentPath.push(signedInfo);
            }
            m_currentPath.push(localName);
        }
        else if(localName.equals("KeyValue") || 
                localName.equals("KeyName") ||
                localName.equals("X509Data") ||
                localName.equals("EncryptedKey"))
        {
            if (!m_currentPath.empty())
            {
                Object keyInfo = m_currentPath.pop();
                
                if (!m_currentPath.empty())
                {
                    Object objSorE = m_currentPath.peek();
                    
                    if ((objSorE instanceof SignatureEntity) && keyInfo.toString().equals("KeyInfo"))
                    /*
                     * this element is the key element of a signature.
                     */
                    {
                        SignatureEntity signatureEntity = (SignatureEntity)objSorE;
                        signatureEntity.setKeyId(0);
                    }
                    else if ((objSorE instanceof EncryptionEntity) && keyInfo.toString().equals("KeyInfo"))
                    /*
                     * this element is the key element of an encryption.
                     */
                    {
                        EncryptionEntity theEncryption = (EncryptionEntity)objSorE;
                        theEncryption.setKeyId(0);
                    }
                }
                m_currentPath.push(keyInfo);
            }
            
            m_currentPath.push(localName);
        }
        else if(localName.equals("RetrievalMethod"))
        {
            if (!m_currentPath.empty())
            {
                Object keyInfo = m_currentPath.pop();
                
                if (!m_currentPath.empty())
                {
                    Object objSorE = m_currentPath.peek();
                    
                    if ((objSorE instanceof SignatureEntity) && keyInfo.toString().equals("KeyInfo"))
                    /*
                     * this element is the RetrievalMethod element in a signature,
                     * which will include the key uri of this signature.
                     */
                    {
                        String uriStr = xattribs.getValueByName("URI");
                        SignatureEntity signatureEntity = (SignatureEntity)objSorE;
        
                        if (uriStr != null && uriStr.length()>0)
                        {
                            signatureEntity.setKeyURI(uriStr);
                            findKeyOrReference(signatureEntity,uriStr, true);
                        }
                    }
                    else if ((objSorE instanceof EncryptionEntity) && keyInfo.toString().equals("KeyInfo"))
                    /*
                     * this element is the RetrievalMethod element in an encryption,
                     * which will include the key uri of this encryption.
                     */
                    {
                        String uriStr = xattribs.getValueByName("URI");
                        EncryptionEntity theEncryption = (EncryptionEntity)objSorE;
        
                        if (uriStr != null && uriStr.length()>0)
                        {
                            theEncryption.setKeyURI(uriStr);
                            findKeyOrReference(theEncryption, uriStr, true);
                        }
                    }
                }
                m_currentPath.push(keyInfo);
            }
            m_currentPath.push(localName);
        }
        else if (localName.equals("EncryptedData")) /* || localName.equals("EncryptedKey")) */
        /*
         * this element is an Encryption element.
         */
        {
            EncryptionEntity theEncryption = new EncryptionEntity(
                m_xSAXEventKeeper,
                m_bIsExporting,
                this,
                m_xXMLSecurityContext,
                m_xXMLSignature,
                m_xXMLEncryption,
                m_xRemoteServiceManager,
                m_xRemoteContext);
                
            m_encryptionList.add(theEncryption);
            
            if (m_bIsExporting)
            {
                m_currentPath.push(theEncryption);
            }
            else
            {
                String uriStr = xattribs.getValueByName("keyURI");
                if (uriStr != null && uriStr.length()>0)
                {
                    theEncryption.setKeyURI(uriStr);
                    findKeyOrReference(theEncryption,uriStr, true);
                }
                else
                {
                    theEncryption.setKeyId(0);
                }
                
                rc = true;
            }
        }
        else
        /*
         * not a security related element.
         */
        {
            m_currentPath.push(localName);
        }
        
        return rc;
    }
    
    /*
     * checks whether a startElement event is referenced by any security entity.
     */
    private void checkReference(String localName, com.sun.star.xml.sax.XAttributeList xattribs, String id)
    {
        String refNumStr = xattribs.getValueByName("refNum");
        
        if ( m_bIsEncryptionTarget )
        {
            m_EncryptionForTarget.setReference(m_bIsExporting);
            m_bIsEncryptionTarget = false;
        }
        
        if (id != null && id.length()>0 )
        /*
         * only if this element has id attribute, then it can be referenced by
         * a security entity.
         */
        {
            /*
             * if this element has an "refNum" attribute, then the value will be
             * the max referencing number on this element, otherwise, set the max
             * referencing number to 999.
             */
            int refNum = 999;
            
            if (refNumStr != null && refNumStr.length()>0 )
            {
                refNum = new Integer(refNumStr).intValue();
            }
            
            int length;
                
            /*
             * searches the signature list to check whether any sigture has
             * reference on this element.
             */
            length = m_signatureList.size();
            for (int i=0; i<length; ++i)
            {
                SignatureEntity signatureEntity = (SignatureEntity)m_signatureList.elementAt(i);
                
                if (signatureEntity.setReference(id, m_bIsExporting))
                {
                    refNum--;
                }
                
                if (signatureEntity.setKey(id, m_bIsExporting))
                {
                    refNum--;
                }
            }
            
            /*
             * searches the encryption list for reference.
             */
            length = m_encryptionList.size();
            for (int i=0; i<length; ++i)
            {
                EncryptionEntity theEncryption = (EncryptionEntity)m_encryptionList.elementAt(i);
                
                if (theEncryption.setKey(id, m_bIsExporting))
                {
                    refNum--;
                }
            }
            
            /*
             * if the max referencing number is not reached, then add this element
             * into the unsolved reference list.
             */
            if (refNum>0)
            {
                int keeperId;
                
                if (localName.equals("EncryptedKey"))
                {
                    keeperId = m_xSAXEventKeeper.addSecurityElementCollector(
                        m_bIsExporting?
                        (ElementMarkPriority.BEFOREMODIFY):(ElementMarkPriority.AFTERMODIFY),
                        true);
                }
                else
                {
                    keeperId = m_xSAXEventKeeper.addSecurityElementCollector(
                        m_bIsExporting?
                        (ElementMarkPriority.AFTERMODIFY):(ElementMarkPriority.BEFOREMODIFY),
                        false);
                }
                    
                m_vUnsolvedReferenceIds.add(id);
                m_vUnsolvedReferencedKeeperIds.add(new Integer(keeperId));
                m_vUnsolvedReferenceRefNum.add(new Integer(refNum));
            }
        }
    }
    
    /*
     * configures the output handler.
     */
    private void setOutputHandler(XDocumentHandler handler)
    {
        m_xOutputHandler = handler;
        changeOutput();
    }
    
    
/**************************************************************************************
 * protected methods
 **************************************************************************************/
        
        /*
         * methods used to transfer unsolved reference information.
         */
    protected Vector getUnsolvedReferenceIds()
    {
        return m_vUnsolvedReferenceIds;
    }
    
    protected Vector getUnsolvedReferenceKeeperIds()
    {
        return m_vUnsolvedReferencedKeeperIds;
    }

    protected Vector getUnsolvedReferenceRefNum()
    {
        return m_vUnsolvedReferenceRefNum;
    }
    
    protected String getBufferNodeTreeInformation()
    {
        if (m_xSAXEventKeeper != null)
        {
            return m_xSAXEventKeeper.printBufferNodeTree();
        }
        else
        {
            return null;
        }
    }
    
    protected void getDocument(XDocumentHandler handler)
    {
        if (m_xXMLDocumentWrapper != null)
        {
            try
            {
                m_xXMLDocumentWrapper.getTree(handler);
            }
            catch(SAXException e)
            {
                e.printStackTrace();
            }
        }
    }
    
    protected void endMission()
    {
        while (m_signatureList.size()>0 || m_encryptionList.size()>0)
        {
            if (m_signatureList.size()>0)
            {
                SignatureEntity signatureEntity = (SignatureEntity)m_signatureList.elementAt(0);
                m_signatureList.remove(0);
                signatureEntity.endMission();
            }
            else if (m_encryptionList.size()>0)
            {
                EncryptionEntity theEncryption = (EncryptionEntity)m_encryptionList.elementAt(0);
                m_encryptionList.remove(0);
                theEncryption.endMission();
            }
        }
        
        while (m_vUnsolvedReferenceIds.size()>0)
        {
            int keeperId = ((Integer)m_vUnsolvedReferencedKeeperIds.elementAt(0)).intValue();
            m_xSAXEventKeeper.removeElementCollector(keeperId);
            m_vUnsolvedReferenceIds.remove(0);
            m_vUnsolvedReferencedKeeperIds.remove(0);
            m_vUnsolvedReferenceRefNum.remove(0);
        }
        
        m_xSAXEventKeeper.setNextHandler(null);
        
        XSAXEventKeeperStatusChangeBroadcaster xSaxEventKeeperStatusChangeBroadcaster = 
            (XSAXEventKeeperStatusChangeBroadcaster)UnoRuntime.queryInterface(
                XSAXEventKeeperStatusChangeBroadcaster.class, m_xSAXEventKeeper); 
        xSaxEventKeeperStatusChangeBroadcaster.addSAXEventKeeperStatusChangeListener(null);
        
        m_xSAXEventKeeper = null;
        m_xXMLDocumentWrapper = null;
        m_xOutputHandler = null;
        m_xXMLSecurityContext = null;
        m_xXMLSignature = null;
        m_xXMLEncryption = null;
        
        m_xExportHandler = null;
        m_parsingThread.setHandler(null);
    }

/**************************************************************************************
 * public methods
 **************************************************************************************/

    /*
     * XDocumentHandler
     */
        public void startDocument()
    {
        try{
            m_xExportHandler.startDocument();
        }
        catch( com.sun.star.xml.sax.SAXException e)
        {
            e.printStackTrace();
        }
        
    }

        public void endDocument()
    {
        try{
            m_xExportHandler.endDocument();
        }
        catch( com.sun.star.xml.sax.SAXException e)
        {
            e.printStackTrace();
        }
    }
    
    public void startElement (String str, com.sun.star.xml.sax.XAttributeList xattribs)
    {
        try{
            String idAttr = xattribs.getValueByName("id");
            if (idAttr == null)
            {
                idAttr = xattribs.getValueByName("Id");
            }
            
            boolean hasIdAttr = (idAttr != null && idAttr.length()>0 );
            boolean needResend = false;
            
            if (hasIdAttr ||
                (str.equals("Signature")||str.equals("EncryptedData")))/* || str.equals("EncryptedKey"))) */
            {
                if (foundSecurityRelated() && !m_bIsExporting)
                {
                    needResend = true;
                }
            }
            
            boolean suppressToNext = checkSecurityElement(str, xattribs);
            
            checkReference(str, xattribs, idAttr);
            
            if (needResend)
            {
                m_xSAXEventKeeper.setNextHandler(null);
                
                XDocumentHandler saxEventKeeperHandler = 
                    (XDocumentHandler)UnoRuntime.queryInterface(
                        XDocumentHandler.class, m_xSAXEventKeeper);
                saxEventKeeperHandler.startElement(str, xattribs);
                m_xSAXEventKeeper.setNextHandler((XDocumentHandler)this);
            }

            if (!suppressToNext)
            {
                m_xExportHandler.startElement(str, xattribs);
            }
        }
        catch( com.sun.star.xml.sax.SAXException e)
        {
            e.printStackTrace();
        }
    }

    public void endElement(String str)
    {
        if (!m_currentPath.empty())
        {
                Object obj = m_currentPath.pop();
            
                if (obj.toString().equals("SignedInfo"))
                {
                if (!m_currentPath.empty())
                {
                        Object objSignature = m_currentPath.peek();
                        if (objSignature != null && objSignature instanceof SignatureEntity)
                        {
                            ((SignatureEntity)objSignature).setReferenceNumber();
                        }
                    }
                }
                else if (obj instanceof EncryptionEntity)
                {
                       m_bIsEncryptionTarget = true;
                m_EncryptionForTarget = (EncryptionEntity)obj;

                }
            }
        
        try{
            m_xExportHandler.endElement(str);
        }
        catch( com.sun.star.xml.sax.SAXException e)
        {
            e.printStackTrace();
        }
    }
    
    public void characters(String str)
    {
        try{
                m_xExportHandler.characters(str);
        }
        catch( com.sun.star.xml.sax.SAXException e)
        {
            e.printStackTrace();
        }
    }
    
    public void ignorableWhitespace(String str)
    {
    }
    
    public void processingInstruction(String aTarget, String aData)
    {
        try{
            m_xExportHandler.processingInstruction(aTarget, aData);
        }
        catch( com.sun.star.xml.sax.SAXException e)
        {
            e.printStackTrace();
        }
    }

    public void setDocumentLocator (com.sun.star.xml.sax.XLocator xLocator ) 
        throws com.sun.star.xml.sax.SAXException
    {
    }
    
    
    /*
     * XSignatureCreationResultListener
     */
    public void signatureCreated(int securityId, SecurityOperationStatus creationResult)
    {
        String message = new String();
        message += "A Signature is created:";
        message += "\nSecurity Id = "+securityId;
        message += "\nCreation result = "+((creationResult==SecurityOperationStatus.OPERATION_SUCCEEDED)?"Succeed":"Fail");
        
        m_testTool.showMessage("Message from : SignatureCreator\n\n"+message+"\n ");
    }

    /*
     * XSignatureVerifyResultListener
     */
    public void signatureVerified(int securityId, SecurityOperationStatus verifyResult)
    {
        String message = new String();
        message += "A Signature is verified:";
        message += "\nSecurity Id = "+securityId;
        message += "\nVerify result = "+((verifyResult==SecurityOperationStatus.OPERATION_SUCCEEDED)?"Succeed":"Fail");
        
        m_testTool.showMessage("Message from : SignatureVerifier\n\n"+message+"\n ");
    }

    /*
     * XEncryptionResultListener
     */
    public void encrypted(int securityId, SecurityOperationStatus encryptionResult)
    {
        String message = new String();
        message += "An EncryptedData is encrypted:";
        message += "\nSecurity Id = "+securityId;
        message += "\nEncrypt result = "+((encryptionResult==SecurityOperationStatus.OPERATION_SUCCEEDED)?"Succeed":"Fail");
        
        m_testTool.showMessage("Message from : Encryptor\n\n"+message+"\n ");
    }
    
    /*
     * XDecryptionResultListener methods
     */
    public void decrypted(int securityId, SecurityOperationStatus decryptionResult)
    {
        String message = new String();
        message += "An EncryptedData is decrypted:";
        message += "\nSecurity Id = "+securityId;
        message += "\nDecrypt result = "+((decryptionResult==SecurityOperationStatus.OPERATION_SUCCEEDED)?"Succeed":"Fail");
        
        m_testTool.showMessage("Message from : Decryptor\n\n"+message+"\n ");
    }
    
    /*
     * XSAXEventKeeperStatusChangeListener methods
     */
    public void blockingStatusChanged(boolean isBlocking)
    {
        m_testTool.showMessage("Message from : SAXEventKeeper\n\n"+
                    (isBlocking?"The SAX event stream is blocked.":"The SAX event stream is unblocked.")+
                    "\n ");
        
        this.m_bIsBlocking = isBlocking;
    }
    
    public void collectionStatusChanged(boolean isInsideCollectedElement)
    {
        m_testTool.showMessage("Message from : SAXEventKeeper\n\n"+
                    (isInsideCollectedElement?"Begin to buffer data ...":"End of data bufferring.")+
                    "\n ");
                    
        /*
        this.m_bIsInsideCollectedElement = isInsideCollectedElement;
        
        if ( !m_bIsInsideCollectedElement && !m_bIsBlocking)
        {
            m_bSAXEventKeeperIncluded = false;
        }
        else
        {
            m_bSAXEventKeeperIncluded = true;
        }
        changeOutput();
        */
    }
    
    public void bufferStatusChanged(boolean isBufferEmpty)
    {
        m_testTool.showMessage("Message from : SAXEventKeeper\n\n"+
                    (isBufferEmpty?"All bufferred data are released, the SAXEventKeeper is destroyed.":"buffer data appears.")+
                    "\n ");
        /*
        if (isBufferEmpty)
        {
            m_xXMLDocumentWrapper = null;
            m_xSAXEventKeeper = null;
            m_bSAXEventKeeperIncluded = false;
            changeOutput();
        }
        */
    }
}