summaryrefslogtreecommitdiff
path: root/xmlsecurity
diff options
context:
space:
mode:
authorRĂ¼diger Timm <rt@openoffice.org>2005-05-18 09:01:55 +0000
committerRĂ¼diger Timm <rt@openoffice.org>2005-05-18 09:01:55 +0000
commitd8790f17bf2af1e162cd96868f4c6441dea25369 (patch)
tree8e8308bfaf95bfc98ccfc292c4a9f1a254f37c70 /xmlsecurity
parent99a2ea74e9fadd3e76f0973745bdcc233a92aff7 (diff)
INTEGRATION: CWS xmlsec12 (1.1.2); FILE ADDED
2005/04/15 14:17:41 mt 1.1.2.1: cleanups...
Diffstat (limited to 'xmlsecurity')
-rw-r--r--xmlsecurity/tools/demo/performance.cxx1911
1 files changed, 1911 insertions, 0 deletions
diff --git a/xmlsecurity/tools/demo/performance.cxx b/xmlsecurity/tools/demo/performance.cxx
new file mode 100644
index 000000000000..1f6c5a6264fe
--- /dev/null
+++ b/xmlsecurity/tools/demo/performance.cxx
@@ -0,0 +1,1911 @@
+/*************************************************************************
+ *
+ * $RCSfile: performance.cxx,v $
+ *
+ * $Revision: 1.2 $
+ *
+ * last change: $Author: rt $ $Date: 2005-05-18 10:01:55 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library 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 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (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.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#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;
+}