AOO410/main/xmlsecurity/tools/demo/performance.cxx

/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_xmlsecurity.hxx"

#include <stdio.h>
#include <string.h>

#include <rtl/ustring.hxx>
#include <cppuhelper/bootstrap.hxx>
#include <cppuhelper/servicefactory.hxx>
#include <com/sun/star/bridge/XUnoUrlResolver.hpp>
#include <com/sun/star/registry/XImplementationRegistration.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/lang/XMultiComponentFactory.hpp>

#include <comphelper/processfactory.hxx>

#include <iostream>
#include <fstream>

#include <util.hxx>

#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/io/XOutputStream.hpp>
#include <com/sun/star/io/XInputStream.hpp>
#include <com/sun/star/xml/sax/XParser.hpp>
#include <com/sun/star/xml/sax/XDocumentHandler.hpp>
#include <com/sun/star/xml/sax/XAttributeList.hpp>
#include <cppuhelper/implbase4.hxx>

#include <com/sun/star/xml/crypto/sax/XSignatureCreationResultListener.hpp>
#include <com/sun/star/xml/crypto/sax/XSignatureVerifyResultListener.hpp>
#include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeListener.hpp>
#include <com/sun/star/xml/crypto/sax/XSecuritySAXEventKeeper.hpp>
#include <com/sun/star/xml/crypto/sax/XReferenceResolvedListener.hpp>
#include <com/sun/star/xml/crypto/XXMLSignature.hpp>
#include <com/sun/star/xml/wrapper/XXMLDocumentWrapper.hpp>
#include <com/sun/star/xml/csax/XMLAttribute.hpp>
#include <com/sun/star/xml/crypto/XSEInitializer.hpp>
#include <com/sun/star/xml/crypto/SecurityOperationStatus.hpp>
#include <com/sun/star/io/XActiveDataSource.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/xml/crypto/sax/XKeyCollector.hpp>
#include <com/sun/star/xml/crypto/sax/ElementMarkPriority.hpp>
#include <com/sun/star/xml/crypto/sax/XReferenceResolvedBroadcaster.hpp>
#include <com/sun/star/xml/crypto/sax/XMissionTaker.hpp>
#include <com/sun/star/xml/crypto/sax/XBlockerMonitor.hpp>
#include <com/sun/star/xml/crypto/sax/XSignatureCreationResultBroadcaster.hpp>
#include <com/sun/star/xml/crypto/sax/XSignatureVerifyResultBroadcaster.hpp>
#include <com/sun/star/xml/crypto/sax/XReferenceCollector.hpp>
#include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeBroadcaster.hpp>
#include <com/sun/star/xml/wrapper/XXMLDocumentWrapper.hpp>

#include <xmloff/attrlist.hxx>

//#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
 * Can not build under solaris.
 * Delete the memory.h including by AF
#include <memory.h>
*/

#include <sys/types.h>
#include <sys/stat.h>
#include <osl/time.h>



#ifndef INCLUDED_VECTOR
#include <vector>
#define INCLUDED_VECTOR
#endif

#ifndef INCLUDED_STACK
#include <stack>
#define INCLUDED_STACK
#endif

/* xml security framework components */
#define SIGNATURECREATOR_COMPONENT  "com.sun.star.xml.crypto.sax.SignatureCreator"
#define SIGNATUREVERIFIER_COMPONENT "com.sun.star.xml.crypto.sax.SignatureVerifier"
#define JAVAFLATFILTER_COMPONENT    "com.sun.star.xml.crypto.eval.JavaFlatFilter"
#define SAXEVENTKEEPER_COMPONENT    "com.sun.star.xml.crypto.sax.SAXEventKeeper"

/* java based bridge components */
#define SEINITIALIZER_JAVA_COMPONENT      "com.sun.star.xml.security.bridge.jxsec.SEInitializer_JxsecImpl"
#define XMLSIGNATURE_JAVA_COMPONENT       "com.sun.star.xml.security.bridge.jxsec.XMLSignature_JxsecImpl"
#define XMLDOCUMENTWRAPPER_JAVA_COMPONENT "com.sun.star.xml.security.bridge.jxsec.XMLDocumentWrapper_JxsecImpl"

/* c based bridge components */
#define SEINITIALIZER_C_COMPONENT "com.sun.star.xml.crypto.SEInitializer"
#define XMLSIGNATURE_C_COMPONENT "com.sun.star.xml.crypto.XMLSignature"
#define XMLDOCUMENT_C_COMPONENT "com.sun.star.xml.wrapper.XMLDocumentWrapper"

/* security related elements and attributes */
#define SIGNATURE_STR       "Signature"
#define REFERENCE_STR       "Reference"
#define SIGNEDINFO_STR      "SignedInfo"
#define KEYINFO_STR         "KeyInfo"
#define KEYVALUE_STR        "KeyValue"
#define KEYNAME_STR         "KeyName"
#define X509DATA_STR        "X509Data"
#define ENCRYPTEDKEY_STR    "EncryptedKey"
#define RETRIEVALMETHOD_STR "RetrievalMethod"
#define OTHER_ELEMENT_STR   "OTHER_ELEMENT_STR"
#define REFNUM_ATTR_STR     "refNum"
#define URI_ATTR_STR        "URI"


#define RTL_ASCII_USTRINGPARAM( asciiStr ) asciiStr, strlen( asciiStr ), RTL_TEXTENCODING_ASCII_US

namespace cssu = com::sun::star::uno;
namespace cssl = com::sun::star::lang;
namespace cssb = com::sun::star::beans;
namespace cssi = com::sun::star::io;
namespace cssxc = com::sun::star::xml::crypto;
namespace cssxs = com::sun::star::xml::sax;
namespace cssxw = com::sun::star::xml::wrapper;
namespace cssxcsax = com::sun::star::xml::csax;


using namespace ::com::sun::star;


class XSecTester;

/*
 * The XSecTester class is a C++ version of SecurityFramworkController.java
 *
 */
 
class SecurityEntity
{
private:
	static int m_nNextSecurityId;
	rtl::OUString m_ouKeyURI;

protected:
	com::sun::star::uno::Reference< 
		com::sun::star::lang::XMultiServiceFactory > mxMSF;
		
	com::sun::star::uno::Reference< 
		com::sun::star::xml::crypto::sax::XReferenceResolvedListener > 
		m_xReferenceListener;
		
	com::sun::star::uno::Reference< 
		com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper > 
		m_xSAXEventKeeper;

	com::sun::star::uno::Reference< 
		com::sun::star::xml::crypto::XXMLSecurityContext > 
		m_xXMLSecurityContext;

	com::sun::star::uno::Reference< 
		com::sun::star::xml::crypto::XXMLSignature > 
		m_xXMLSignature;
	
	int m_nSecurityId;

private:	
	int getNextSecurityId() const;

protected:
	SecurityEntity(
		const com::sun::star::uno::Reference< 
			com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >& 
			xSAXEventKeeper,
		const com::sun::star::uno::Reference< 
			com::sun::star::xml::crypto::XXMLSecurityContext >& 
			xXMLSecurityContext,
		const com::sun::star::uno::Reference< 
			com::sun::star::xml::crypto::XXMLSignature >& 
			xXMLSignature,
		const com::sun::star::uno::Reference< 
			com::sun::star::lang::XMultiServiceFactory >&
			rsMSF);
	
public:
	void setKeyId(int nId);
	
	int getSecurityId() const;
	
	com::sun::star::uno::Reference< 
		com::sun::star::xml::crypto::sax::XReferenceResolvedListener > 
		getReferenceListener() const;
		
	bool setKey( const rtl::OUString& ouUri, bool bIsExporting );
	
	void setKeyURI(const rtl::OUString& ouUri);
	
	bool endMission();
};


class SignatureEntity : public SecurityEntity
{
private:
	std::vector< rtl::OUString > m_vReferenceIds;
	int m_nSignatureElementCollectorId;

	bool hasReference(const rtl::OUString& ouUri) const;

public:
	SignatureEntity(
		const com::sun::star::uno::Reference< 
			com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >&
			xSAXEventKeeper,
		bool bIsExporting, 
		XSecTester* pListener,
		const com::sun::star::uno::Reference< 
			com::sun::star::xml::crypto::XXMLSecurityContext >&
			xXMLSecurityContext,
		const com::sun::star::uno::Reference<
			com::sun::star::xml::crypto::XXMLSignature >&
			xXMLSignature,
		const com::sun::star::uno::Reference<
			com::sun::star::lang::XMultiServiceFactory >&
			rsMSF);
	~SignatureEntity(){};
	
	void setReferenceNumber() const;
	bool setReference( const rtl::OUString& ouUri, bool bIsExporting ) const;
	void addReferenceURI( const rtl::OUString& ouUri );
};

struct AncestorEvent
{
	AncestorEvent( sal_Int32 nAttrNum ):aAttributeList(nAttrNum){};
	
	bool bIsStartElement;
	rtl::OUString ouName;
	
	com::sun::star::uno::Sequence< 
		com::sun::star::xml::csax::XMLAttribute >
		aAttributeList;
};
	
class XSecTester : public cppu::WeakImplHelper4
< 
	com::sun::star::xml::crypto::sax::XSignatureCreationResultListener,
	com::sun::star::xml::crypto::sax::XSignatureVerifyResultListener,
	com::sun::star::xml::crypto::sax::XSAXEventKeeperStatusChangeListener,
	com::sun::star::xml::sax::XDocumentHandler
>
{
private:
	com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > mxMSF;
	
	sal_Int32 m_nTotalSignatureNumber;
	sal_Int32 m_nSuccessfulSignatureNumber;

	com::sun::star::uno::Reference<
		com::sun::star::xml::sax::XDocumentHandler > 
		m_xExportHandler;
		
	com::sun::star::uno::Reference<
		com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >
		m_xSAXEventKeeper;
		
	com::sun::star::uno::Reference<
		com::sun::star::xml::wrapper::XXMLDocumentWrapper > 
		m_xXMLDocumentWrapper;
		
	com::sun::star::uno::Reference<
		com::sun::star::xml::sax::XDocumentHandler > 
		m_xOutputHandler;
		
	com::sun::star::uno::Reference< 
		com::sun::star::xml::sax::XParser >
		m_xSaxParser;

	std::stack< void* > m_stCurrentPath;
	std::stack< bool > m_stCurrentPathType;
	
	std::vector< AncestorEvent* > m_vAncestorEvents;
	std::vector< SignatureEntity* > m_vSignatureList;
	
	std::vector< rtl::OUString > m_vUnsolvedReferenceURIs;
	std::vector< int > m_vUnsolvedReferenceKeeperIds;
	std::vector< int > m_vUnsolvedReferenceRefNums;
	
	bool m_bIsExporting;
	bool m_bIsBlocking;
	
	bool m_bIsInsideCollectedElement;
	bool m_bIsSAXEventKeeperOnTheSAXChain;
	
	com::sun::star::uno::Reference<
		com::sun::star::xml::crypto::XXMLSecurityContext > 
		m_xXMLSecurityContext;
		
	com::sun::star::uno::Reference<
		com::sun::star::xml::crypto::XXMLSignature > 
		m_xXMLSignature;
	
	rtl::OUString m_ouJavaCryptokenDir;
	rtl::OUString m_ouCCryptokenDir;
	rtl::OUString m_ouXMLDocumentWrapperComponentName;
	
private:
	com::sun::star::uno::Reference< 
		com::sun::star::io::XOutputStream > 
		createOutputStream( const rtl::OUString& ouFile );
		
	rtl::OUString parseFile(
		const rtl::OUString& ouInputFileName, 
		const rtl::OUString& ouOutputFileName, 
		bool bIsExporting,
		bool bIsJavaBased);
		
	void changeOutput();
	
	bool foundSecurityRelated();
	
	void findKeyOrReference(SecurityEntity* pSecurityEntity, const rtl::OUString& ouUri, bool bIsFindKey);
	
	bool checkSecurityElement(
		const rtl::OUString& ouLocalName,
		const com::sun::star::uno::Reference<
			com::sun::star::xml::sax::XAttributeList>& xAttribs);
			
	void checkReference(
		const rtl::OUString& ouLocalName,
		const com::sun::star::uno::Reference<
			com::sun::star::xml::sax::XAttributeList>& xAttribs,
		const rtl::OUString& ouId);
		
	void endMission();
	
	void addStartAncestorEvent(
		const rtl::OUString& ouName,
		const com::sun::star::uno::Reference<
			com::sun::star::xml::sax::XAttributeList>& xAttribs);
		
	void addEndAncestorEvent( const rtl::OUString& ouName );
	
	void flushAncestorEvents(
		const com::sun::star::uno::Reference<
			com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler);
	
	void XSecTester::sendAncestorStartElementEvent(
		const rtl::OUString& ouName, 
		const com::sun::star::uno::Sequence<
			com::sun::star::xml::csax::XMLAttribute >& xAttrList,
		const com::sun::star::uno::Reference<
			com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const;
		
	void XSecTester::sendAncestorEndElementEvent(
		const rtl::OUString& ouName,
		const com::sun::star::uno::Reference<
			com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const;
		
	std::vector< AncestorEvent* >::const_iterator XSecTester::checkAncestorStartElementEvent( 
		const std::vector< AncestorEvent* >::const_iterator& ii,
		const com::sun::star::uno::Reference<
			com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const;
	
public:
	XSecTester(const com::sun::star::uno::Reference<
		com::sun::star::lang::XMultiServiceFactory >& rxMSF)
		:mxMSF( rxMSF ){};
	virtual ~XSecTester(){};
	
	/* XSignatureCreationResultListener */
	virtual void SAL_CALL signatureCreated( 
		sal_Int32 securityId, 
		com::sun::star::xml::crypto::SecurityOperationStatus creationResult )
		throw (com::sun::star::uno::RuntimeException);

	/* XSignatureVerifyResultListener */
	virtual void SAL_CALL signatureVerified( 
		sal_Int32 securityId, 
		com::sun::star::xml::crypto::SecurityOperationStatus verifyResult )
		throw (com::sun::star::uno::RuntimeException);
		
	/* XSAXEventKeeperStatusChangeListener */
	virtual void SAL_CALL blockingStatusChanged( sal_Bool isBlocking )
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL collectionStatusChanged( 
		sal_Bool isInsideCollectedElement )
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL bufferStatusChanged( sal_Bool isBufferEmpty )
		throw (com::sun::star::uno::RuntimeException);
	
	/* XXMLSecTester */
	virtual rtl::OUString SAL_CALL transfer_without_sec( 
		const rtl::OUString& inputFileName, 
		const rtl::OUString& outputFileName,
		sal_Bool isBridgeInvolved)
		throw (com::sun::star::uno::RuntimeException);
	virtual rtl::OUString SAL_CALL export_xml(
		const rtl::OUString& inputFileName, 
		const rtl::OUString& outputFileName,
		sal_Bool isJavaBased)
		throw (com::sun::star::uno::RuntimeException);
	virtual rtl::OUString SAL_CALL import_xml(
		const rtl::OUString& inputFileName, 
		const rtl::OUString& outputFileName,
		sal_Bool isJavaBased)
		throw (com::sun::star::uno::RuntimeException);
		
	virtual void SAL_CALL setCryptoDir(
		const rtl::OUString & javaDirName,
		const rtl::OUString & cDirName)
		throw (com::sun::star::uno::RuntimeException);

	/* XDocumentHandler */
	virtual void SAL_CALL endDocument()
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL startDocument()
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL characters(const class rtl::OUString&)
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL processingInstruction(const rtl::OUString&, const rtl::OUString&)
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL ignorableWhitespace(const rtl::OUString&)
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL startElement(
		const rtl::OUString&, 
		const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList >&)
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL endElement(const rtl::OUString&)
		throw (com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL setDocumentLocator(
		const com::sun::star::uno::Reference< com::sun::star::xml::sax::XLocator >&)
		throw (com::sun::star::uno::RuntimeException);
};

rtl::OUString XSecTester::parseFile(
	const rtl::OUString& ouInputFileName, 
	const rtl::OUString& ouOutputFileName, 
	bool bIsExporting,
	bool bIsJavaBased)
{
	rtl::OUString ouMessage;
	
	cssu::Reference<cssi::XInputStream> xInputStream = OpenInputStream(ouInputFileName);
	
	if (xInputStream != NULL ) 
	{
		/* initialization */
		rtl::OUString SEInitializer_comp;
		rtl::OUString XMLSignature_comp;
		rtl::OUString tokenPath;
		cssu::Reference < cssxc::XSEInitializer > xSEInitializer;
		
		if (bIsJavaBased)
		{
			SEInitializer_comp = rtl::OUString::createFromAscii( SEINITIALIZER_JAVA_COMPONENT );
			XMLSignature_comp = rtl::OUString::createFromAscii( XMLSIGNATURE_JAVA_COMPONENT);
			m_ouXMLDocumentWrapperComponentName = rtl::OUString::createFromAscii( XMLDOCUMENTWRAPPER_JAVA_COMPONENT );
			tokenPath = m_ouJavaCryptokenDir;
		}
		else
		{
			SEInitializer_comp = rtl::OUString::createFromAscii( SEINITIALIZER_C_COMPONENT );
			XMLSignature_comp = rtl::OUString::createFromAscii( XMLSIGNATURE_C_COMPONENT);
			m_ouXMLDocumentWrapperComponentName = rtl::OUString::createFromAscii( XMLDOCUMENT_C_COMPONENT );
			tokenPath = m_ouCCryptokenDir;
		}
		
		xSEInitializer = cssu::Reference < cssxc::XSEInitializer > (
			 mxMSF->createInstance( SEInitializer_comp ),
			 cssu::UNO_QUERY );		
			 
		m_xXMLSignature = cssu::Reference<cssxc::XXMLSignature> (
			mxMSF->createInstance( XMLSignature_comp ),
			cssu::UNO_QUERY );
			
		if ( xSEInitializer.is() && m_xXMLSignature.is())
		{
			/* create SAX Parser */
			const rtl::OUString sSaxParser ( 
				RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Parser") );
			m_xSaxParser = cssu::Reference < cssxs::XParser > ( mxMSF->createInstance( sSaxParser ), cssu::UNO_QUERY );
	
			/* create SAX Writer */
			const rtl::OUString sSaxWriter ( 
				RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Writer") );
			cssu::Reference < cssi::XActiveDataSource > xSaxWriter
				( mxMSF->createInstance( sSaxWriter ), cssu::UNO_QUERY );
			
			cssu::Reference< cssi::XOutputStream > xOutputStream = OpenOutputStream(ouOutputFileName);
			xSaxWriter->setOutputStream( xOutputStream );
	
			cssxs::InputSource aInput;
			aInput.sSystemId = ouInputFileName;
			aInput.aInputStream = xInputStream;
			
			cssu::Reference < cssxs::XDocumentHandler > xSaxWriterHandler( xSaxWriter, cssu::UNO_QUERY);
	
			m_xXMLSecurityContext = 
				xSEInitializer->createSecurityContext(tokenPath);
			
			m_bIsExporting = bIsExporting;
			m_xExportHandler = xSaxWriterHandler;
			m_xOutputHandler = xSaxWriterHandler;
			
			m_xXMLDocumentWrapper = NULL;
			m_xSAXEventKeeper = NULL;
			m_bIsSAXEventKeeperOnTheSAXChain = false;
	
			m_bIsBlocking = false;
			m_bIsInsideCollectedElement = false;
			
			OSL_ASSERT(m_vSignatureList.size() == 0);
			OSL_ASSERT(m_vUnsolvedReferenceURIs.size() == 0);
			OSL_ASSERT(m_vUnsolvedReferenceKeeperIds.size() == 0);
			OSL_ASSERT(m_vUnsolvedReferenceRefNums.size() == 0);
			OSL_ASSERT(m_stCurrentPath.empty());
			OSL_ASSERT(m_stCurrentPathType.empty());
			OSL_ASSERT(m_vAncestorEvents.empty());
	
			changeOutput();
	
			/* foundSecurityRelated(); */
			
			/* Begin to parse */
			TimeValue startTime, endTime;
			osl_getSystemTime( &startTime );
			
			xSaxWriterHandler->startDocument();
			
			if (m_bIsExporting) 
			{
				m_xSaxParser->setDocumentHandler(this);
				m_xSaxParser->parseStream(aInput);
			}
			else 
			{
				m_xSaxParser->setDocumentHandler(this);
				m_xSaxParser->parseStream(aInput);
			}
			
			endMission();
			xSaxWriterHandler->endDocument();
	
			osl_getSystemTime( &endTime );
	
			flushAncestorEvents( NULL );
			
			// Bug in SAXWriter, done in endDocument()
			// xOutputStream->closeOutput();
			xInputStream->closeInput();
			
			
			/*
			 * Free the security context
			 */
			xSEInitializer->freeSecurityContext(m_xXMLSecurityContext);
			m_xXMLSecurityContext = NULL;
			
			/* Calculate the time */
			double diff = ((double)((endTime.Nanosec + endTime.Seconds*1000000000.0)
					- (startTime.Nanosec + startTime.Seconds*1000000000.0))) / 
				((double)1000000000.0);
	
			char buf[32];
			sprintf(buf, "%.2f", diff);
			ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM(buf));
		}
		else
		{
			ouMessage += rtl::OUString::createFromAscii( "N/A" );
		}
		
	}
	else
	{
		ouMessage += rtl::OUString::createFromAscii( "-" );
	}
	
	return ouMessage;
}

/* XSignatureCreationResultListener */
void SAL_CALL XSecTester::signatureCreated(
	sal_Int32 securityId, 
	cssxc::SecurityOperationStatus creationResult )
	throw (cssu::RuntimeException)
{
	m_nTotalSignatureNumber++;
	if (creationResult == cssxc::SecurityOperationStatus_OPERATION_SUCCEEDED) 
	{
		m_nSuccessfulSignatureNumber++;
	}
}

/* XSignatureVerifyResultListener */
void SAL_CALL XSecTester::signatureVerified(
	sal_Int32 securityId, 
	cssxc::SecurityOperationStatus verifyResult )
	throw (cssu::RuntimeException)
{
	m_nTotalSignatureNumber++;
	if (verifyResult == cssxc::SecurityOperationStatus_OPERATION_SUCCEEDED) 
	{
		m_nSuccessfulSignatureNumber++;
	}
}
	
/* XSAXEventKeeperStatusChangeListener */
void SAL_CALL XSecTester::blockingStatusChanged( sal_Bool isBlocking )
	throw (cssu::RuntimeException)
{
	this->m_bIsBlocking = isBlocking;
}
	
void SAL_CALL XSecTester::collectionStatusChanged( sal_Bool isInsideCollectedElement )
	throw (cssu::RuntimeException)
{
	this->m_bIsInsideCollectedElement = isInsideCollectedElement;
	
	if ( !m_bIsInsideCollectedElement && !m_bIsBlocking)
	{
		m_bIsSAXEventKeeperOnTheSAXChain = false;
	}
	else
	{
		m_bIsSAXEventKeeperOnTheSAXChain = true;
	}
	changeOutput();
}
	
void SAL_CALL XSecTester::bufferStatusChanged( sal_Bool isBufferEmpty )
	throw (cssu::RuntimeException)
{
	if (isBufferEmpty)
	{
		m_xXMLDocumentWrapper = NULL;
		
		m_xSAXEventKeeper = NULL;
		m_bIsSAXEventKeeperOnTheSAXChain = false;
		changeOutput();
	}
}

/* XXMLSecTester */
rtl::OUString SAL_CALL XSecTester::export_xml( const rtl::OUString& inputFileName, const rtl::OUString& outputFileName, sal_Bool isJavaBased)
	throw (cssu::RuntimeException)
{
	rtl::OUString ouMessage;
	
	m_nTotalSignatureNumber = 0;
	m_nSuccessfulSignatureNumber = 0;
	
	ouMessage += parseFile(inputFileName, outputFileName, sal_True, isJavaBased);
	
	rtl::OUString ouRemark = rtl::OUString::valueOf(m_nSuccessfulSignatureNumber) +
		rtl::OUString(RTL_ASCII_USTRINGPARAM( "/" ))
		+ rtl::OUString::valueOf(m_nTotalSignatureNumber);
	ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM("\t")) + ouRemark;

	return ouMessage;
}
	
rtl::OUString SAL_CALL XSecTester::import_xml( const rtl::OUString& inputFileName, const rtl::OUString& outputFileName, sal_Bool isJavaBased)
	throw (cssu::RuntimeException)
{
	rtl::OUString ouMessage;

	m_nTotalSignatureNumber = 0;
	m_nSuccessfulSignatureNumber = 0;

	ouMessage += parseFile(inputFileName, outputFileName, sal_False, isJavaBased);

	rtl::OUString ouRemark = rtl::OUString::valueOf(m_nSuccessfulSignatureNumber) +
		rtl::OUString(RTL_ASCII_USTRINGPARAM( "/" ))
		+ rtl::OUString::valueOf(m_nTotalSignatureNumber);
	ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM("\t")) + ouRemark;

	return ouMessage;
}

rtl::OUString SAL_CALL XSecTester::transfer_without_sec( 
	const rtl::OUString& inputFileName, 
	const rtl::OUString& outputFileName,
	sal_Bool isBridgeInvolved)
	throw (cssu::RuntimeException)
{
	rtl::OUString ouMessage;
	
	cssu::Reference< cssi::XInputStream > xInputStream = OpenInputStream(inputFileName);
	
	if (xInputStream != NULL ) 
	{
		/* create SAX Parser */
		const rtl::OUString sSaxParser ( 
			RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Parser") );
		m_xSaxParser = cssu::Reference < cssxs::XParser > ( mxMSF->createInstance( sSaxParser ), cssu::UNO_QUERY );

		/* create SAX Writer */
		const rtl::OUString sSaxWriter ( 
			RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Writer") );
		cssu::Reference < cssi::XActiveDataSource > xSaxWriter
			( mxMSF->createInstance( sSaxWriter ), cssu::UNO_QUERY );
		cssu::Reference < cssxs::XDocumentHandler > xSaxWriterHandler( 
			xSaxWriter, cssu::UNO_QUERY);
			
		if (!isBridgeInvolved)
		{
			/* connect the SAX Parser and the SAX Writer */
			m_xSaxParser->setDocumentHandler ( xSaxWriterHandler );
		}
		else
		{
			/* create Java Flat Filter */
			const rtl::OUString sJavaFlatFilter( 
				RTL_CONSTASCII_USTRINGPARAM( JAVAFLATFILTER_COMPONENT ) );
			cssu::Reference < cssxs::XParser > xJavaFilterParser
				( mxMSF->createInstance( sJavaFlatFilter ), cssu::UNO_QUERY );
			cssu::Reference < cssxs::XDocumentHandler > xJavaFilterHandler(
				xJavaFilterParser, cssu::UNO_QUERY );

			if ( !xJavaFilterParser.is() )
				return rtl::OUString::createFromAscii( "NO JAVA" );

			/* connect the SAX Parser, the Java Flat Filter and the SAX Writer */
			xJavaFilterParser->setDocumentHandler( xSaxWriterHandler );
			m_xSaxParser->setDocumentHandler ( xJavaFilterHandler );
		}
		

		/* set output stream */
		cssu::Reference< cssi::XOutputStream > xOutputStream =
				OpenOutputStream(outputFileName);
		xSaxWriter->setOutputStream( xOutputStream );

		/* prepare input stream */
		cssxs::InputSource aInput;
		aInput.sSystemId = inputFileName;
		aInput.aInputStream = xInputStream;
		
		TimeValue startTime, endTime;
		osl_getSystemTime( &startTime );

		m_xSaxParser->parseStream ( aInput );
		
		// xOutputStream->closeOutput();
		xInputStream->closeInput();
		
		osl_getSystemTime( &endTime );
		
		double diff = ((double)((endTime.Nanosec + endTime.Seconds*1000000000.0)
				 - (startTime.Nanosec + startTime.Seconds*1000000000.0)))/((double)1000000000.0);
		char buf[32];
		sprintf(buf, "%.2f", diff);
		ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM(buf));
	}

	return ouMessage;
}

void SAL_CALL XSecTester::setCryptoDir(const rtl::OUString & javaDirName, const rtl::OUString & cDirName)
	throw (cssu::RuntimeException)
{
	m_ouJavaCryptokenDir = javaDirName;
	m_ouCCryptokenDir = cDirName;
}


cssu::Reference< cssu::XInterface > SAL_CALL XSecTester_createInstance( 
	const cssu::Reference< cssl::XMultiServiceFactory > & rSMgr)
	throw( cssu::Exception )
{
	return (cppu::OWeakObject*) new XSecTester( rSMgr );
}

int SecurityEntity::m_nNextSecurityId = 1;

SecurityEntity::SecurityEntity(
	const cssu::Reference<cssxc::sax::XSecuritySAXEventKeeper>& xSAXEventKeeper,
	const cssu::Reference<cssxc::XXMLSecurityContext>& xXMLSecurityContext,
	const cssu::Reference<cssxc::XXMLSignature>& xXMLSignature,
	const cssu::Reference< cssl::XMultiServiceFactory > &rsMSF)
	:m_xSAXEventKeeper(xSAXEventKeeper),
	 m_xXMLSecurityContext(xXMLSecurityContext),
	 m_xXMLSignature(xXMLSignature),
	 mxMSF(rsMSF),
	 m_ouKeyURI(RTL_ASCII_USTRINGPARAM(""))
{
	m_nSecurityId = getNextSecurityId();
}
	
int SecurityEntity::getNextSecurityId() const
{
	int nId = m_nNextSecurityId++;
	return nId;
}

void SecurityEntity::setKeyId(int nId)
{
	cssu::Reference<cssxc::sax::XKeyCollector> keyCollector (m_xReferenceListener, cssu::UNO_QUERY);
	keyCollector->setKeyId(nId);
}


void SecurityEntity::setKeyURI(const rtl::OUString& ouUri)
{
	m_ouKeyURI = ouUri;
}

cssu::Reference<cssxc::sax::XReferenceResolvedListener> SecurityEntity::getReferenceListener() const
{
	return m_xReferenceListener;
}

int SecurityEntity::getSecurityId() const
{
	return m_nSecurityId;
}

bool SecurityEntity::setKey(const rtl::OUString& ouUri, bool bIsExporting)
{
	bool rc = false;
	
 	if (m_ouKeyURI != rtl::OUString(RTL_ASCII_USTRINGPARAM("")) &&
 		m_ouKeyURI == ouUri)
	{
		int nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
			bIsExporting ?
			(cssxc::sax::ElementMarkPriority_BEFOREMODIFY):
			(cssxc::sax::ElementMarkPriority_AFTERMODIFY), 
			true);
			
		setKeyId(nKeeperId);
		m_xSAXEventKeeper->setSecurityId(nKeeperId, m_nSecurityId);

		cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster
			(m_xSAXEventKeeper, cssu::UNO_QUERY);
		xReferenceResolvedBroadcaster->addReferenceResolvedListener(nKeeperId,
			m_xReferenceListener);
			
		rc = true;
	}
	
	return rc;
}

bool SecurityEntity::endMission()
{
	cssu::Reference<cssxc::sax::XMissionTaker> xMissionTaker 
		(m_xReferenceListener, cssu::UNO_QUERY);
		
	return xMissionTaker->endMission();
}

SignatureEntity::SignatureEntity(
	const cssu::Reference<cssxc::sax::XSecuritySAXEventKeeper>& xSAXEventKeeper,
	bool bIsExporting, 
	XSecTester* pListener,
	const cssu::Reference<cssxc::XXMLSecurityContext>& xXMLSecurityContext,
	const cssu::Reference<cssxc::XXMLSignature>& xXMLSignature,
	const cssu::Reference< cssl::XMultiServiceFactory >& rsMSF)
	:SecurityEntity(xSAXEventKeeper,
			xXMLSecurityContext,
			xXMLSignature,
			rsMSF)
{
	if (bIsExporting) 
	{
		m_nSignatureElementCollectorId = 
			m_xSAXEventKeeper->addSecurityElementCollector(
				cssxc::sax::ElementMarkPriority_AFTERMODIFY,
				true);

		m_xSAXEventKeeper->setSecurityId(m_nSignatureElementCollectorId, m_nSecurityId);

		m_xReferenceListener = cssu::Reference< cssxc::sax::XReferenceResolvedListener >(
			mxMSF->createInstance( rtl::OUString::createFromAscii( SIGNATURECREATOR_COMPONENT )),
			cssu::UNO_QUERY);

		cssu::Reference<cssl::XInitialization> xInitialization(m_xReferenceListener, cssu::UNO_QUERY);
		
		cssu::Sequence<cssu::Any> args(5);
		char buf[16];
		
		sprintf(buf, "%d", m_nSecurityId);
		args[0] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)));
		args[1] = cssu::makeAny(m_xSAXEventKeeper);
		
		sprintf(buf, "%d", m_nSignatureElementCollectorId);
		args[2] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)));
		args[3] = cssu::makeAny(m_xXMLSecurityContext->getSecurityEnvironment());
		args[4] = cssu::makeAny(m_xXMLSignature);
		
		xInitialization->initialize(args);
		
		int nBlockerId = m_xSAXEventKeeper->addBlocker();
		m_xSAXEventKeeper->setSecurityId(nBlockerId, m_nSecurityId);
	
		cssu::Reference<cssxc::sax::XBlockerMonitor> xBlockerMonitor(m_xReferenceListener, cssu::UNO_QUERY);
		xBlockerMonitor->setBlockerId(nBlockerId);
		
		cssu::Reference< cssxc::sax::XSignatureCreationResultBroadcaster > xSignatureCreationResultBroadcaster
			(m_xReferenceListener, cssu::UNO_QUERY);
		xSignatureCreationResultBroadcaster->addSignatureCreationResultListener(pListener);
	}
	else 
	{
		m_nSignatureElementCollectorId = 
			m_xSAXEventKeeper->addSecurityElementCollector(
				cssxc::sax::ElementMarkPriority_BEFOREMODIFY,
				false);
			
		m_xSAXEventKeeper->setSecurityId(m_nSignatureElementCollectorId, m_nSecurityId);

		m_xReferenceListener = cssu::Reference< cssxc::sax::XReferenceResolvedListener >(
			mxMSF->createInstance( rtl::OUString::createFromAscii( SIGNATUREVERIFIER_COMPONENT )),
			cssu::UNO_QUERY);	
		
		cssu::Reference<cssl::XInitialization> xInitialization(m_xReferenceListener, cssu::UNO_QUERY);
		
		cssu::Sequence<cssu::Any> args(5);
		char buf[16];
		
		sprintf(buf, "%d", m_nSecurityId);
		args[0] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)));
		args[1] = cssu::makeAny(m_xSAXEventKeeper);
		
		sprintf(buf, "%d", m_nSignatureElementCollectorId);
		args[2] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)));
		args[3] = cssu::makeAny(m_xXMLSecurityContext);
		args[4] = cssu::makeAny(m_xXMLSignature);
		xInitialization->initialize(args);
		
		cssu::Reference< cssxc::sax::XSignatureVerifyResultBroadcaster > xSignatureVerifyResultBroadcaster
			(m_xReferenceListener, cssu::UNO_QUERY);
		xSignatureVerifyResultBroadcaster->addSignatureVerifyResultListener(pListener);
	}

	cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster
		(m_xSAXEventKeeper, cssu::UNO_QUERY);
	xReferenceResolvedBroadcaster->addReferenceResolvedListener(
		m_nSignatureElementCollectorId, m_xReferenceListener);
}

void SignatureEntity::addReferenceURI(const rtl::OUString& ouUri)
{
	m_vReferenceIds.push_back(ouUri);
}
	
void SignatureEntity::setReferenceNumber() const
{
	cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector
		(m_xReferenceListener, cssu::UNO_QUERY);
	xReferenceCollector->setReferenceCount(m_vReferenceIds.size());
}
	
bool SignatureEntity::hasReference(const rtl::OUString& ouUri) const
{
	bool rc = false;
	
	std::vector<const rtl::OUString>::const_iterator ii;
	for (ii = m_vReferenceIds.begin(); ii != m_vReferenceIds.end(); ++ii) 
	{
		if (ouUri == *ii) 
		{
			rc = true;
			break;
		}
	}
		
	return rc;
}
	
bool SignatureEntity::setReference(const rtl::OUString& ouUri, bool bIsExporting) const
{
	bool rc = false;
	
	if (hasReference(ouUri)) 
	{
		int nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
				bIsExporting ?
				(cssxc::sax::ElementMarkPriority_AFTERMODIFY):
				(cssxc::sax::ElementMarkPriority_BEFOREMODIFY),
				false);
				
		m_xSAXEventKeeper->setSecurityId(nKeeperId, m_nSecurityId);

		cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster  
			(m_xSAXEventKeeper, cssu::UNO_QUERY);
		xReferenceResolvedBroadcaster->addReferenceResolvedListener(nKeeperId, m_xReferenceListener);
		
		cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector
			(m_xReferenceListener, cssu::UNO_QUERY);
		xReferenceCollector->setReferenceId(nKeeperId);
				
		rc = true;
	}
	
	return rc;
}

/* XDocumentHandler */
void SAL_CALL XSecTester::startDocument()
	throw (cssu::RuntimeException)
{
}

void SAL_CALL XSecTester::endDocument()
	throw (cssu::RuntimeException)
{
}

void SAL_CALL XSecTester::characters(const class rtl::OUString & chars)
	throw (cssu::RuntimeException)
{
	m_xExportHandler->characters(chars);
}

void SAL_CALL XSecTester::processingInstruction(const rtl::OUString & target, const rtl::OUString &data)
	throw (cssu::RuntimeException)
{
	m_xExportHandler->processingInstruction(target, data);
}

void SAL_CALL XSecTester::ignorableWhitespace(const rtl::OUString &)
	throw (cssu::RuntimeException)
{

}

void SAL_CALL XSecTester::startElement(const rtl::OUString & name, const cssu::Reference<cssxs::XAttributeList> &xAttribs)
	throw (cssu::RuntimeException)
{
	rtl::OUString ouIdAttr = xAttribs->getValueByName(
		rtl::OUString(RTL_ASCII_USTRINGPARAM("id")));
		
	if (ouIdAttr == NULL) 
	{
		ouIdAttr = xAttribs->getValueByName(
			rtl::OUString(RTL_ASCII_USTRINGPARAM("Id")));
	}
			
	bool bHasIdAttr = (ouIdAttr != NULL && ouIdAttr.getLength() > 0 );
	bool needResend = false;
			
	if (bHasIdAttr || name.equalsAscii( SIGNATURE_STR )) 
	{
		if (foundSecurityRelated() && ! m_bIsExporting) 
		{
			needResend = true;
		}
	}
	
	if ( !m_bIsSAXEventKeeperOnTheSAXChain )
	{
		addStartAncestorEvent(name, xAttribs);
	}
	
	bool bSuppressingForwarding = checkSecurityElement(name, xAttribs);
			
	checkReference(name, xAttribs, ouIdAttr);
			
	if (needResend) 
	{
		m_xSAXEventKeeper->setNextHandler(NULL);
				
		cssu::Reference<cssxs::XDocumentHandler> xSAXEventKeeperHandler 
			(m_xSAXEventKeeper, cssu::UNO_QUERY);
			
		xSAXEventKeeperHandler->startElement(name, xAttribs);
		m_xSAXEventKeeper->setNextHandler(this);
	}
	
	if (!bSuppressingForwarding) 
	{
		m_xExportHandler->startElement(name, xAttribs);
	}
}

void SAL_CALL XSecTester::endElement(const rtl::OUString& name)
	throw (cssu::RuntimeException)
{
	if (!m_stCurrentPath.empty()) 
	{
		void* pSignedInfo = m_stCurrentPath.top();
		bool bIsStringType = m_stCurrentPathType.top();
		
		m_stCurrentPath.pop();
		m_stCurrentPathType.pop();
        	
		if (bIsStringType && !strcmp((const char *)pSignedInfo, SIGNEDINFO_STR))
		{
			if (!m_stCurrentPath.empty()) 
			{
				void* pSignature = m_stCurrentPath.top();
				bIsStringType = m_stCurrentPathType.top();
				
				if (!bIsStringType && pSignature != NULL)
				{
					((SignatureEntity *) pSignature)->setReferenceNumber();
				}
			}
		}
	}
	
	if ( !m_bIsSAXEventKeeperOnTheSAXChain )
	{
		addEndAncestorEvent(name);
	}
		
	m_xExportHandler->endElement(name);
}

void SAL_CALL XSecTester::setDocumentLocator( const cssu::Reference<cssxs::XLocator>& )
	throw (cssu::RuntimeException)
{
}

void XSecTester::changeOutput()
{
	if (m_bIsExporting) 
	{
		if (m_bIsSAXEventKeeperOnTheSAXChain) 
		{
			m_xExportHandler = cssu::Reference<cssxs::XDocumentHandler>
				(m_xSAXEventKeeper, cssu::UNO_QUERY);
				
			m_xSAXEventKeeper->setNextHandler(NULL);
			
			flushAncestorEvents(m_xExportHandler);

			m_xSAXEventKeeper->setNextHandler(m_xOutputHandler);
		}
		else 
		{
			m_xExportHandler = m_xOutputHandler;
		}
	}
 	else 
 	{
		if (m_bIsSAXEventKeeperOnTheSAXChain) 
		{
			cssu::Reference<cssxs::XDocumentHandler> xSAXEventKeeperHandler
				(m_xSAXEventKeeper, cssu::UNO_QUERY);
				
			m_xSAXEventKeeper->setNextHandler(NULL);
			
			flushAncestorEvents(xSAXEventKeeperHandler);

			m_xSaxParser->setDocumentHandler(xSAXEventKeeperHandler);
			m_xSAXEventKeeper->setNextHandler(this);
		}
		else 
		{
			m_xSaxParser->setDocumentHandler(this);
		}

	}
}

bool XSecTester::foundSecurityRelated()
{
	if (m_xSAXEventKeeper == NULL) 
	{
		m_bIsBlocking = false;
		m_bIsInsideCollectedElement = false;

		m_xXMLDocumentWrapper = cssu::Reference<cssxw::XXMLDocumentWrapper>
			(mxMSF->createInstance( m_ouXMLDocumentWrapperComponentName ),
			 cssu::UNO_QUERY);

		m_xSAXEventKeeper = cssu::Reference< cssxc::sax::XSecuritySAXEventKeeper >
			(mxMSF->createInstance( rtl::OUString::createFromAscii( SAXEVENTKEEPER_COMPONENT )),
			 cssu::UNO_QUERY);

		cssu::Reference<cssl::XInitialization> xInitialization(m_xSAXEventKeeper,  cssu::UNO_QUERY);

		cssu::Sequence <cssu::Any> arg(1);
		arg[0] = cssu::makeAny(m_xXMLDocumentWrapper);
		xInitialization->initialize(arg);
		
		cssu::Reference<cssxc::sax::XSAXEventKeeperStatusChangeBroadcaster>
			xSAXEventKeeperStatusChangeBroadcaster(m_xSAXEventKeeper, cssu::UNO_QUERY); 
		xSAXEventKeeperStatusChangeBroadcaster->addSAXEventKeeperStatusChangeListener(this);
	}
		
	bool rc = false;
	
	if (!m_bIsSAXEventKeeperOnTheSAXChain) 
	{
		rc = true;
	}
		
	m_bIsSAXEventKeeperOnTheSAXChain=true;
	changeOutput();

	return rc;
}

void XSecTester::findKeyOrReference(SecurityEntity* pSecurityEntity, const rtl::OUString& ouUri, bool bIsFindingKey)
{
	std::vector<rtl::OUString>::iterator ii_referenceURIs;
	std::vector<int>::iterator ii_referenceKeeperIds;
	std::vector<int>::iterator ii_referenceRefNums;

	for (ii_referenceURIs = m_vUnsolvedReferenceURIs.begin(),
	     ii_referenceKeeperIds = m_vUnsolvedReferenceKeeperIds.begin(),
	     ii_referenceRefNums = m_vUnsolvedReferenceRefNums.begin();
 	     ii_referenceURIs != m_vUnsolvedReferenceURIs.end(); ) 
	{
		rtl::OUString ouReferenceUri = *ii_referenceURIs;
			
		if (ouReferenceUri == ouUri) 
		{
			int nKeeperId = *ii_referenceKeeperIds;
			int nRefNum = *ii_referenceRefNums;
			
			if ( bIsFindingKey )
			{
			 	int nClonedKeeperId = m_xSAXEventKeeper->cloneElementCollector(
			 		nKeeperId,
			 		m_bIsExporting?
			 		(cssxc::sax::ElementMarkPriority_BEFOREMODIFY):
					(cssxc::sax::ElementMarkPriority_AFTERMODIFY));
	
			 	pSecurityEntity->setKeyId(nClonedKeeperId);
	
			 	m_xSAXEventKeeper->setSecurityId(nClonedKeeperId, pSecurityEntity->getSecurityId());
	
			 	cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster>
					xReferenceResolvedBroadcaster(m_xSAXEventKeeper, cssu::UNO_QUERY);
				xReferenceResolvedBroadcaster->addReferenceResolvedListener(
			 		nClonedKeeperId,
			 		pSecurityEntity->getReferenceListener());
			}
			else
			{
				int nClonedKeeperId = m_xSAXEventKeeper->cloneElementCollector(
					nKeeperId, 
					m_bIsExporting?
					(cssxc::sax::ElementMarkPriority_AFTERMODIFY):
					(cssxc::sax::ElementMarkPriority_BEFOREMODIFY));
					
				m_xSAXEventKeeper->setSecurityId(nClonedKeeperId, pSecurityEntity->getSecurityId());
				
				cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster>
					xReferenceResolvedBroadcaster 
					(m_xSAXEventKeeper, cssu::UNO_QUERY);
				xReferenceResolvedBroadcaster->addReferenceResolvedListener(
					nClonedKeeperId,
					pSecurityEntity->getReferenceListener());
					
				cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector 
						(pSecurityEntity->getReferenceListener(), cssu::UNO_QUERY);
				xReferenceCollector->setReferenceId(nClonedKeeperId);
			}

			nRefNum--;
			if (nRefNum == 0) 
			{
				m_xSAXEventKeeper->removeElementCollector(nKeeperId);
				
				ii_referenceURIs = m_vUnsolvedReferenceURIs.erase(ii_referenceURIs);
				ii_referenceKeeperIds = m_vUnsolvedReferenceKeeperIds.erase(ii_referenceKeeperIds);
				ii_referenceRefNums = m_vUnsolvedReferenceRefNums.erase(ii_referenceRefNums);
			}
			else 
			{
				(*ii_referenceRefNums) = nRefNum;

				ii_referenceURIs++;
				ii_referenceKeeperIds++;
				ii_referenceRefNums++;
			}
			
			if (bIsFindingKey)
			{
				break;
			}
		}
		else 
		{
			ii_referenceURIs++;
			ii_referenceKeeperIds++;
			ii_referenceRefNums++;
		}
	}
}

bool XSecTester::checkSecurityElement(
	const rtl::OUString& ouLocalName,
	const cssu::Reference<cssxs::XAttributeList>& xAttribs)
{
	bool rc = false;
		
	if (ouLocalName.equalsAscii(SIGNATURE_STR))
	{
		SignatureEntity* pSignatureEntity = new SignatureEntity(
			m_xSAXEventKeeper,
			m_bIsExporting,
			this,
			m_xXMLSecurityContext,
			m_xXMLSignature,
			mxMSF);
		
		m_vSignatureList.push_back(pSignatureEntity);
		
		m_stCurrentPath.push(pSignatureEntity);
		m_stCurrentPathType.push(false);
	}
	else if (ouLocalName.equalsAscii(REFERENCE_STR))
	{
		if (!m_stCurrentPath.empty()) 
		{
	 		void* pSignedInfo = m_stCurrentPath.top();
	 		bool bIsStringType = m_stCurrentPathType.top();
	 		
			m_stCurrentPath.pop();
			m_stCurrentPathType.pop();
 			
			if (bIsStringType && !m_stCurrentPath.empty()) 
			{
				void* pSignature = m_stCurrentPath.top();
				bool bIsStringType2 = m_stCurrentPathType.top();

				if (!strcmp((const char*)pSignedInfo, SIGNEDINFO_STR) && !bIsStringType2)
				{
					rtl::OUString ouUri = xAttribs->getValueByName
						(rtl::OUString(RTL_ASCII_USTRINGPARAM( URI_ATTR_STR )));
					
					if (ouUri.matchAsciiL("#", 1, 0))
					{
						rtl::OUString uri = ouUri.copy(1);
 						SignatureEntity* pSignatureEntity = (SignatureEntity *)pSignature;
		
						if (uri != NULL && uri.getLength()>0) 
						{
							pSignatureEntity->addReferenceURI(uri);
							findKeyOrReference(pSignatureEntity, uri, true);
						}
					}
				}
			}
			m_stCurrentPath.push(pSignedInfo);
			m_stCurrentPathType.push(bIsStringType);
		}
		m_stCurrentPath.push( (void *)REFERENCE_STR);
		m_stCurrentPathType.push(true);
	}
	else if(ouLocalName.equalsAscii(KEYVALUE_STR) || 
		ouLocalName.equalsAscii(KEYNAME_STR) || 
		ouLocalName.equalsAscii(X509DATA_STR) || 
		ouLocalName.equalsAscii(ENCRYPTEDKEY_STR)) 
	{
		if (!m_stCurrentPath.empty()) 
		{
			void* pKeyInfo = m_stCurrentPath.top();
			bool bIsStringType = m_stCurrentPathType.top();
			
			m_stCurrentPath.pop();
			m_stCurrentPathType.pop();
			
 			if (bIsStringType && !m_stCurrentPath.empty()) 
 			{
				bool bIsStringType2 = m_stCurrentPathType.top();
				
				if (!bIsStringType2)
				{
					SecurityEntity *pSecurityEntity = 
						(SecurityEntity *) (m_stCurrentPath.top());
					pSecurityEntity->setKeyId(0);
				}
 			}
 			
			m_stCurrentPath.push(pKeyInfo);
			m_stCurrentPathType.push(bIsStringType);
		}
		
		m_stCurrentPath.push((void *)KEYVALUE_STR);
		m_stCurrentPathType.push(true);
	}
	else if(ouLocalName.equalsAscii(RETRIEVALMETHOD_STR)) 
	{
		if (!m_stCurrentPath.empty()) 
		{
			void* pKeyInfo = m_stCurrentPath.top();
			bool bIsStringType = m_stCurrentPathType.top();
			
			m_stCurrentPath.pop();
			m_stCurrentPathType.pop();
			
			if (bIsStringType && !m_stCurrentPath.empty()) 
			{
				bool bIsStringType2 = m_stCurrentPathType.top();
				
				if (!bIsStringType2)
				{
					SecurityEntity *pSecurityEntity = 
						(SecurityEntity *) m_stCurrentPath.top();
					rtl::OUString ouUri = xAttribs->getValueByName(
						rtl::OUString(RTL_ASCII_USTRINGPARAM( URI_ATTR_STR )));
					
					if (!strcmp((const char *)pKeyInfo, KEYINFO_STR) && 
						ouUri != NULL && ouUri.getLength()>0) 
					{
						pSecurityEntity->setKeyURI(ouUri);
						findKeyOrReference(pSecurityEntity, ouUri, true);
					}
				}
				
			}
			
			m_stCurrentPath.push(pKeyInfo);
			m_stCurrentPathType.push(bIsStringType);
		}
		
		m_stCurrentPath.push((void *)RETRIEVALMETHOD_STR);
		m_stCurrentPathType.push(true);
	}
	else if(ouLocalName.equalsAscii(KEYINFO_STR)) 
	{
		m_stCurrentPath.push((void *)KEYINFO_STR);
		m_stCurrentPathType.push(true);
	}
	else if(ouLocalName.equalsAscii(SIGNEDINFO_STR)) 
	{
		m_stCurrentPath.push((void *)SIGNEDINFO_STR);
		m_stCurrentPathType.push(true);
	}
	else
	{
		m_stCurrentPath.push((void *)OTHER_ELEMENT_STR);
		m_stCurrentPathType.push(true);
	}
	
	return rc;
}

void XSecTester::checkReference(
	const rtl::OUString& ouLocalName,
	const cssu::Reference<cssxs::XAttributeList>& xAttribs,
	const rtl::OUString& ouId)
{
	rtl::OUString refNumStr = 
		xAttribs->getValueByName(rtl::OUString(RTL_ASCII_USTRINGPARAM(REFNUM_ATTR_STR)));
		
	if (ouId != NULL && ouId.getLength()>0 ) 
	{
		int nRefNum = 999;
		if (refNumStr != NULL && refNumStr.getLength()>0 ) 
		{
			nRefNum = refNumStr.toInt32();
		}
		
		int nLength = m_vSignatureList.size();
		for (int i = 0; i<nLength; ++i) 
		{
			SignatureEntity* pSignatureEntity = m_vSignatureList.at(i);
				
			if (pSignatureEntity->setReference(ouId, m_bIsExporting)) 
			{
				nRefNum--;
			}
				
			if (pSignatureEntity->setKey(ouId, m_bIsExporting)) 
			{
				nRefNum--;
			}
		}
		
		if (nRefNum>0) 
		{
			int nKeeperId;
			
			if (ouLocalName.equalsAscii(ENCRYPTEDKEY_STR)) 
			{
				nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
					m_bIsExporting ?
					(cssxc::sax::ElementMarkPriority_BEFOREMODIFY):
					(cssxc::sax::ElementMarkPriority_AFTERMODIFY),
					true);
			}
			else 
			{
				nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
					m_bIsExporting?
					(cssxc::sax::ElementMarkPriority_AFTERMODIFY):
					(cssxc::sax::ElementMarkPriority_BEFOREMODIFY),
					false);
			}
					
			m_vUnsolvedReferenceURIs.push_back(ouId);
			m_vUnsolvedReferenceKeeperIds.push_back(nKeeperId);
			m_vUnsolvedReferenceRefNums.push_back(nRefNum);
		}
	}
}

void XSecTester::endMission()
{
	while (m_vSignatureList.size() > 0)
	{
		if (m_vSignatureList.size()>0) 
		{
			SignatureEntity * pSignatureEntity = m_vSignatureList.at(0);
			m_vSignatureList.erase(m_vSignatureList.begin());
			pSignatureEntity->endMission();
			delete pSignatureEntity;
		}
	}
		
	while (m_vUnsolvedReferenceURIs.size()>0) 
	{
		int nKeeperId = m_vUnsolvedReferenceKeeperIds.at(0);
		m_xSAXEventKeeper->removeElementCollector(nKeeperId);
		m_vUnsolvedReferenceURIs.erase(m_vUnsolvedReferenceURIs.begin());
		m_vUnsolvedReferenceKeeperIds.erase(m_vUnsolvedReferenceKeeperIds.begin());
		m_vUnsolvedReferenceRefNums.erase(m_vUnsolvedReferenceRefNums.begin());
	}
}

void XSecTester::addStartAncestorEvent(
	const rtl::OUString& ouName,
	const cssu::Reference< cssxs::XAttributeList >& xAttribs)
{
	sal_Int32 nLength = xAttribs->getLength();
	AncestorEvent* ancestorEvent = new AncestorEvent( nLength );
	
	ancestorEvent->bIsStartElement = true;
	ancestorEvent->ouName = ouName;
	
	for (int i = 0; i<nLength; ++i) 
	{
		(ancestorEvent->aAttributeList[i]).sName = xAttribs->getNameByIndex((short)i);
		(ancestorEvent->aAttributeList[i]).sValue =xAttribs->getValueByIndex((short)i);
	}
	
	m_vAncestorEvents.push_back(ancestorEvent);
}

void XSecTester::addEndAncestorEvent(const rtl::OUString& ouName)
{
	AncestorEvent* ancestorEvent = new AncestorEvent(0);
	
	ancestorEvent->bIsStartElement = false;
	ancestorEvent->ouName = ouName;
	
	m_vAncestorEvents.push_back(ancestorEvent);
}

void XSecTester::sendAncestorStartElementEvent(
	const rtl::OUString& ouName, 
	const cssu::Sequence< cssxcsax::XMLAttribute >& attrList,
	const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const
{
	SvXMLAttributeList* pAttributeList = new SvXMLAttributeList();
	cssu::Reference < cssxs::XAttributeList > xAttrList
		= cssu::Reference< cssxs::XAttributeList > (pAttributeList);

	sal_Int32 nLength = attrList.getLength();
	
	for (int i = 0; i<nLength; ++i) 
	{
		pAttributeList->AddAttribute( attrList[i].sName, attrList[i].sValue);
	}
	
	xDocumentHandler->startElement(ouName, xAttrList);
}

void XSecTester::sendAncestorEndElementEvent(
	const rtl::OUString& ouName,
	const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const
{
	xDocumentHandler->endElement(ouName);
}

std::vector< AncestorEvent* >::const_iterator XSecTester::checkAncestorStartElementEvent( 
	const std::vector< AncestorEvent* >::const_iterator& ii,
	const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const
{
	std::vector< AncestorEvent* >::const_iterator next = ii+1;
	
	if (next == m_vAncestorEvents.end())
	{
		sendAncestorStartElementEvent(
			(*ii)->ouName, (*ii)->aAttributeList, xDocumentHandler);
	}
	else
	{
		while ((next != m_vAncestorEvents.end()) && ((*next)->bIsStartElement))
		{
			next = checkAncestorStartElementEvent(next, xDocumentHandler);
		}
		
		if (next != m_vAncestorEvents.end())
		{
			next++;
		}
	}
	
	return next;
}
	
void XSecTester::flushAncestorEvents(
	const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler)
{
	std::vector< AncestorEvent* >::const_iterator ii;
	
	if (xDocumentHandler != NULL)
	{
		ii = m_vAncestorEvents.begin();
		
		while (ii != m_vAncestorEvents.end())
		{
			AncestorEvent* ancestorEvent = *ii;
			
			if (ancestorEvent->bIsStartElement)
			{
				ii = checkAncestorStartElementEvent(ii, xDocumentHandler);
			}
			else
			{
				sendAncestorEndElementEvent((*ii)->ouName, xDocumentHandler);
				ii++;
			}
		}
	}
	
	/* free the ancestor events list */
	std::vector< AncestorEvent* >::iterator jj;
	
	while (m_vAncestorEvents.size()>0) 
	{
		jj = m_vAncestorEvents.begin();
		delete *jj;
		m_vAncestorEvents.erase(jj);
	}
}

/*
 * Get the length of a file in a platform independant fashion
 */
int getLength(const char *pInputFileName)
{
	int nSize = 0;
	std::ifstream data(pInputFileName);

	data.seekg(0, std::ios_base::end);
	nSize = data.tellg();

	return nSize;
}

void outputHeader()
{
	fprintf(stderr, "%16s%4s%8s%12s%12s%12s%12s\n", "File Name", "E/I", "Size", "-C++", "-Java", "Forw-O", "No S/E");
	fprintf(stderr, "===============================================================================\n");
}

/*
 * print the output on the screen as well as in the GNUPlot data file
 */
void output(const rtl::OUString& ouInputFileName, 
	const rtl::OUString& ouTime_C, 
	const rtl::OUString& ouTime_Java,
	const rtl::OUString& ouTime_NoSecurity,
	const rtl::OUString& ouTime_JavaForwardOnly,
	const rtl::OUString& ouRemark_C,
	const rtl::OUString& ouRemark_Java,
	bool bIsExporting)
{
	int nSize = getLength(rtl::OString(ouInputFileName, ouInputFileName.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
	std::ofstream data;

	/* print screen */
	int nPosition = ouInputFileName.lastIndexOf('\\');
	rtl::OUString fileName = ouInputFileName.copy(nPosition + 1);

	fprintf(stderr, "%16s", rtl::OString(fileName, fileName.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());

	fprintf(stderr, "%4s", bIsExporting?"E":"I");
	fprintf(stderr, "%7dK", nSize/1024);
	fprintf(stderr, "%8s %3s", 
		rtl::OString(ouTime_C, ouTime_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr(),
		rtl::OString(ouRemark_C, ouRemark_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
	fprintf(stderr, "%8s %3s", 
		rtl::OString(ouTime_Java, ouTime_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr(),
		rtl::OString(ouRemark_Java, ouRemark_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
	fprintf(stderr, "%12s", rtl::OString(ouTime_JavaForwardOnly, ouTime_JavaForwardOnly.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
	fprintf(stderr, "%12s", rtl::OString(ouTime_NoSecurity, ouTime_NoSecurity.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
	fprintf(stderr, "\n");
	
	/* output the data as GNUPlot data file */
	/*
	char str[32];
	sprintf(str, "%d %s", nSize, rtl::OString(ouTime_C, ouTime_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
	data.open("d:\\time_vs_size.txt", std::ios::app);
	data <<  str << std::endl;
	data.close();

	sprintf(str, "%d %s", nSize, rtl::OString(ouTime_Java, ouTime_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
	data.open("d:\\time_vs_size_without_sec.txt", std::ios::app);
	data <<  str << std::endl;
	data.close();
	*/
}

int main( int argc, char **argv )
{
	if (argc < 3) 
	{
		fprintf(stderr, "Usage: testtool <exportbatchfile> <importbatchfile> [<cppcryptotoken>] [<javacryptotoken>]\n");
		exit (-1);
	}

	rtl::OUString aExportBatchFile = rtl::OUString::createFromAscii(argv[1]);
	rtl::OUString aImportBatchFile = rtl::OUString::createFromAscii(argv[2]);
	rtl::OUString aCPPCryptoToken;
	if ( argc > 3 )
	    aCPPCryptoToken = rtl::OUString::createFromAscii(argv[3]);
	rtl::OUString aJavaCryptoToken;
	if ( argc > 4 )
	    aJavaCryptoToken = rtl::OUString::createFromAscii(argv[4]);

	try 
	{
		uno::Reference< lang::XMultiServiceFactory > xMSF = CreateDemoServiceFactory();

		XSecTester* pTester = new XSecTester( xMSF );
		uno::Reference< xml::sax::XDocumentHandler > xKeepARef = pTester;
		
		pTester->setCryptoDir( aJavaCryptoToken, aCPPCryptoToken );
		
		rtl::OUString ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly;
		rtl::OUString ouInputFileName;
		rtl::OUString outputFileName1;
		rtl::OUString outputFileName2;
		rtl::OUString ouRemark_C, ouRemark_Java;

		outputHeader();

		std::ifstream batch_export, batch_import;

		batch_export.open(OUStringToOString( aExportBatchFile, RTL_TEXTENCODING_ASCII_US ).getStr());

		const int MAX_LINE = 80;
		char line[MAX_LINE + 1];
		
		while (batch_export.getline(line, MAX_LINE)) 
		{
			ouInputFileName = rtl::OUString::createFromAscii(line);
			int nPosition = ouInputFileName.lastIndexOf('.');
			int nPosition1;
			
			/*
			 * export the file with signautre/encryption (C++)
			 */
			outputFileName1 = ouInputFileName.copy(0, nPosition) + 
				rtl::OUString::createFromAscii("-ex.xml");
			ouTime_C = pTester->export_xml(ouInputFileName, outputFileName1, sal_False);
			nPosition1 = ouTime_C.lastIndexOf('\t');
			ouRemark_C = ouTime_C.copy(nPosition1 + 1);
			ouTime_C = ouTime_C.copy(0, nPosition1);

			/*
			 * export the file with signautre/encryption (Java)
			 */
			outputFileName1 = ouInputFileName.copy(0, nPosition) + 
				rtl::OUString::createFromAscii("-ex2.xml");
			ouTime_Java = pTester->export_xml(ouInputFileName, outputFileName1, sal_True);
			nPosition1 = ouTime_Java.lastIndexOf('\t');
			ouRemark_Java = ouTime_Java.copy(nPosition1 + 1);
			ouTime_Java = ouTime_Java.copy(0, nPosition1);
			
			/*
			 * export the file without signautre/encryption
			 */
			outputFileName2 = ouInputFileName.copy(0, nPosition) + 
				rtl::OUString::createFromAscii("-ex-no.xml");
			ouTime_NoSecurity = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_False);

			/*
			 * export the file with Java Flat Filter
			 */
			outputFileName2 = ouInputFileName.copy(0, nPosition) + 
				rtl::OUString::createFromAscii("-ex-jf.xml");
			ouTime_JavaForwardOnly = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_True);
			
			/*
			 * print output
			 */
			output(ouInputFileName, ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly, ouRemark_C, ouRemark_Java, true);
		}

		batch_export.close();

		batch_import.open(OUStringToOString( aImportBatchFile, RTL_TEXTENCODING_ASCII_US ).getStr());

		while (batch_import.getline(line, MAX_LINE)) 
		{
			ouInputFileName = rtl::OUString::createFromAscii(line);
			int nPosition = ouInputFileName.lastIndexOf('.');
			int nPosition1;
			
			/*
			 * import the file with signautre/encryption (C++)
			 */
			outputFileName1 = ouInputFileName.copy(0, nPosition) + 
				rtl::OUString::createFromAscii("-im.xml");
			ouTime_C = pTester->import_xml(ouInputFileName, outputFileName1, sal_False);
			nPosition1 = ouTime_C.lastIndexOf('\t');
			ouRemark_C = ouTime_C.copy(nPosition1 + 1);
			ouTime_C = ouTime_C.copy(0, nPosition1);

			/*
			 * import the file with signautre/encryption (Java)
			 */
			outputFileName1 = ouInputFileName.copy(0, nPosition) + 
				rtl::OUString::createFromAscii("-im2.xml");
			ouTime_Java = pTester->import_xml(ouInputFileName, outputFileName1, sal_True);
			nPosition1 = ouTime_Java.lastIndexOf('\t');
			ouRemark_Java = ouTime_Java.copy(nPosition1 + 1);
			ouTime_Java = ouTime_Java.copy(0, nPosition1);

			/*
			 * import the file without signautre/encryption
			 */
			outputFileName2 = ouInputFileName.copy(0, nPosition) + 
				rtl::OUString::createFromAscii("-im-no.xml");
			ouTime_NoSecurity = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_False);

			/*
			 * import the file without signautre/encryption
			 */

			outputFileName2 = ouInputFileName.copy(0, nPosition) + 
				rtl::OUString::createFromAscii("-im-jf.xml");
			ouTime_JavaForwardOnly = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_True);
			
			/*
			 * print output
			 */
			output(ouInputFileName, ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly, ouRemark_C, ouRemark_Java, false);
		}

		batch_import.close();

		fprintf(stderr, "\n");
	}
	catch( cssu::Exception& e ) 
	{
		fprintf( stderr , "\nEXCEPTION! Error Message: %s\n" , 
				 rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() ) ;
	}

	return 0;
}