?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merged tag ooo/OOO330_m14
[LibreOffice.git] / xmlsecurity / tools / demo / performance.cxx
blob061091611de7c27ff5dc3223eb8d2024c83f1f35
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2000, 2010 Oracle and/or its affiliates.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * This file is part of OpenOffice.org.
10 *
11 * OpenOffice.org is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License version 3
13 * only, as published by the Free Software Foundation.
14 *
15 * OpenOffice.org is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License version 3 for more details
19 * (a copy is included in the LICENSE file that accompanied this code).
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * version 3 along with OpenOffice.org. If not, see
23 * <http://www.openoffice.org/license.html>
24 * for a copy of the LGPLv3 License.
25 *
26 ************************************************************************/
27
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_xmlsecurity.hxx"
30
31 #include <stdio.h>
32 #include <string.h>
33
34 #include <rtl/ustring.hxx>
35 #include <cppuhelper/bootstrap.hxx>
36 #include <cppuhelper/servicefactory.hxx>
37 #include <com/sun/star/bridge/XUnoUrlResolver.hpp>
38 #include <com/sun/star/registry/XImplementationRegistration.hpp>
39 #include <com/sun/star/beans/XPropertySet.hpp>
40 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
41
42 #include <comphelper/processfactory.hxx>
43
44 #include <iostream>
45 #include <fstream>
46
47 #include <util.hxx>
48
49 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
50 #include <com/sun/star/io/XOutputStream.hpp>
51 #include <com/sun/star/io/XInputStream.hpp>
52 #include <com/sun/star/xml/sax/XParser.hpp>
53 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
54 #include <com/sun/star/xml/sax/XAttributeList.hpp>
55 #include <cppuhelper/implbase4.hxx>
56
57 #include <com/sun/star/xml/crypto/sax/XSignatureCreationResultListener.hpp>
58 #include <com/sun/star/xml/crypto/sax/XSignatureVerifyResultListener.hpp>
59 #include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeListener.hpp>
60 #include <com/sun/star/xml/crypto/sax/XSecuritySAXEventKeeper.hpp>
61 #include <com/sun/star/xml/crypto/sax/XReferenceResolvedListener.hpp>
62 #include <com/sun/star/xml/crypto/XXMLSignature.hpp>
63 #include <com/sun/star/xml/wrapper/XXMLDocumentWrapper.hpp>
64 #include <com/sun/star/xml/csax/XMLAttribute.hpp>
65 #include <com/sun/star/xml/crypto/XSEInitializer.hpp>
66 #include <com/sun/star/xml/crypto/SecurityOperationStatus.hpp>
67 #include <com/sun/star/io/XActiveDataSource.hpp>
68 #include <com/sun/star/lang/XInitialization.hpp>
69 #include <com/sun/star/xml/crypto/sax/XKeyCollector.hpp>
70 #include <com/sun/star/xml/crypto/sax/ElementMarkPriority.hpp>
71 #include <com/sun/star/xml/crypto/sax/XReferenceResolvedBroadcaster.hpp>
72 #include <com/sun/star/xml/crypto/sax/XMissionTaker.hpp>
73 #include <com/sun/star/xml/crypto/sax/XBlockerMonitor.hpp>
74 #include <com/sun/star/xml/crypto/sax/XSignatureCreationResultBroadcaster.hpp>
75 #include <com/sun/star/xml/crypto/sax/XSignatureVerifyResultBroadcaster.hpp>
76 #include <com/sun/star/xml/crypto/sax/XReferenceCollector.hpp>
77 #include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeBroadcaster.hpp>
78 #include <com/sun/star/xml/wrapper/XXMLDocumentWrapper.hpp>
79
80 #include <xmloff/attrlist.hxx>
81
82 //#include <malloc.h>
83 #include <stdio.h>
84 #include <stdlib.h>
85 #include <string.h>
86
87 /*
88 * Can not build under solaris.
89 * Delete the memory.h including by AF
90 #include <memory.h>
91 */
92
93 #include <sys/types.h>
94 #include <sys/stat.h>
95 #include <osl/time.h>
96
97
98
99 #ifndef INCLUDED_VECTOR
100 #include <vector>
101 #define INCLUDED_VECTOR
102 #endif
103
104 #ifndef INCLUDED_STACK
105 #include <stack>
106 #define INCLUDED_STACK
107 #endif
108
109 /* xml security framework components */
110 #define SIGNATURECREATOR_COMPONENT "com.sun.star.xml.crypto.sax.SignatureCreator"
111 #define SIGNATUREVERIFIER_COMPONENT "com.sun.star.xml.crypto.sax.SignatureVerifier"
112 #define JAVAFLATFILTER_COMPONENT "com.sun.star.xml.crypto.eval.JavaFlatFilter"
113 #define SAXEVENTKEEPER_COMPONENT "com.sun.star.xml.crypto.sax.SAXEventKeeper"
114
115 /* java based bridge components */
116 #define SEINITIALIZER_JAVA_COMPONENT "com.sun.star.xml.security.bridge.jxsec.SEInitializer_JxsecImpl"
117 #define XMLSIGNATURE_JAVA_COMPONENT "com.sun.star.xml.security.bridge.jxsec.XMLSignature_JxsecImpl"
118 #define XMLDOCUMENTWRAPPER_JAVA_COMPONENT "com.sun.star.xml.security.bridge.jxsec.XMLDocumentWrapper_JxsecImpl"
119
120 /* c based bridge components */
121 #define SEINITIALIZER_C_COMPONENT "com.sun.star.xml.crypto.SEInitializer"
122 #define XMLSIGNATURE_C_COMPONENT "com.sun.star.xml.crypto.XMLSignature"
123 #define XMLDOCUMENT_C_COMPONENT "com.sun.star.xml.wrapper.XMLDocumentWrapper"
124
125 /* security related elements and attributes */
126 #define SIGNATURE_STR "Signature"
127 #define REFERENCE_STR "Reference"
128 #define SIGNEDINFO_STR "SignedInfo"
129 #define KEYINFO_STR "KeyInfo"
130 #define KEYVALUE_STR "KeyValue"
131 #define KEYNAME_STR "KeyName"
132 #define X509DATA_STR "X509Data"
133 #define ENCRYPTEDKEY_STR "EncryptedKey"
134 #define RETRIEVALMETHOD_STR "RetrievalMethod"
135 #define OTHER_ELEMENT_STR "OTHER_ELEMENT_STR"
136 #define REFNUM_ATTR_STR "refNum"
137 #define URI_ATTR_STR "URI"
138
139
140 #define RTL_ASCII_USTRINGPARAM( asciiStr ) asciiStr, strlen( asciiStr ), RTL_TEXTENCODING_ASCII_US
141
142 namespace cssu = com::sun::star::uno;
143 namespace cssl = com::sun::star::lang;
144 namespace cssb = com::sun::star::beans;
145 namespace cssi = com::sun::star::io;
146 namespace cssxc = com::sun::star::xml::crypto;
147 namespace cssxs = com::sun::star::xml::sax;
148 namespace cssxw = com::sun::star::xml::wrapper;
149 namespace cssxcsax = com::sun::star::xml::csax;
150
151
152 using namespace ::com::sun::star;
153
154
155 class XSecTester;
156
157 /*
158 * The XSecTester class is a C++ version of SecurityFramworkController.java
159 *
160 */
161
162 class SecurityEntity
163 {
164 private:
165 static int m_nNextSecurityId;
166 rtl::OUString m_ouKeyURI;
167
168 protected:
169 com::sun::star::uno::Reference<
170 com::sun::star::lang::XMultiServiceFactory > mxMSF;
171
172 com::sun::star::uno::Reference<
173 com::sun::star::xml::crypto::sax::XReferenceResolvedListener >
174 m_xReferenceListener;
175
176 com::sun::star::uno::Reference<
177 com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >
178 m_xSAXEventKeeper;
179
180 com::sun::star::uno::Reference<
181 com::sun::star::xml::crypto::XXMLSecurityContext >
182 m_xXMLSecurityContext;
183
184 com::sun::star::uno::Reference<
185 com::sun::star::xml::crypto::XXMLSignature >
186 m_xXMLSignature;
187
188 int m_nSecurityId;
189
190 private:
191 int getNextSecurityId() const;
192
193 protected:
194 SecurityEntity(
195 const com::sun::star::uno::Reference<
196 com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >&
197 xSAXEventKeeper,
198 const com::sun::star::uno::Reference<
199 com::sun::star::xml::crypto::XXMLSecurityContext >&
200 xXMLSecurityContext,
201 const com::sun::star::uno::Reference<
202 com::sun::star::xml::crypto::XXMLSignature >&
203 xXMLSignature,
204 const com::sun::star::uno::Reference<
205 com::sun::star::lang::XMultiServiceFactory >&
206 rsMSF);
207
208 public:
209 void setKeyId(int nId);
210
211 int getSecurityId() const;
212
213 com::sun::star::uno::Reference<
214 com::sun::star::xml::crypto::sax::XReferenceResolvedListener >
215 getReferenceListener() const;
216
217 bool setKey( const rtl::OUString& ouUri, bool bIsExporting );
218
219 void setKeyURI(const rtl::OUString& ouUri);
220
221 bool endMission();
222 };
223
224
225 class SignatureEntity : public SecurityEntity
226 {
227 private:
228 std::vector< rtl::OUString > m_vReferenceIds;
229 int m_nSignatureElementCollectorId;
230
231 bool hasReference(const rtl::OUString& ouUri) const;
232
233 public:
234 SignatureEntity(
235 const com::sun::star::uno::Reference<
236 com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >&
237 xSAXEventKeeper,
238 bool bIsExporting,
239 XSecTester* pListener,
240 const com::sun::star::uno::Reference<
241 com::sun::star::xml::crypto::XXMLSecurityContext >&
242 xXMLSecurityContext,
243 const com::sun::star::uno::Reference<
244 com::sun::star::xml::crypto::XXMLSignature >&
245 xXMLSignature,
246 const com::sun::star::uno::Reference<
247 com::sun::star::lang::XMultiServiceFactory >&
248 rsMSF);
249 ~SignatureEntity(){};
250
251 void setReferenceNumber() const;
252 bool setReference( const rtl::OUString& ouUri, bool bIsExporting ) const;
253 void addReferenceURI( const rtl::OUString& ouUri );
254 };
255
256 struct AncestorEvent
257 {
258 AncestorEvent( sal_Int32 nAttrNum ):aAttributeList(nAttrNum){};
259
260 bool bIsStartElement;
261 rtl::OUString ouName;
262
263 com::sun::star::uno::Sequence<
264 com::sun::star::xml::csax::XMLAttribute >
265 aAttributeList;
266 };
267
268 class XSecTester : public cppu::WeakImplHelper4
269 <
270 com::sun::star::xml::crypto::sax::XSignatureCreationResultListener,
271 com::sun::star::xml::crypto::sax::XSignatureVerifyResultListener,
272 com::sun::star::xml::crypto::sax::XSAXEventKeeperStatusChangeListener,
273 com::sun::star::xml::sax::XDocumentHandler
274 >
275 {
276 private:
277 com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > mxMSF;
278
279 sal_Int32 m_nTotalSignatureNumber;
280 sal_Int32 m_nSuccessfulSignatureNumber;
281
282 com::sun::star::uno::Reference<
283 com::sun::star::xml::sax::XDocumentHandler >
284 m_xExportHandler;
285
286 com::sun::star::uno::Reference<
287 com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >
288 m_xSAXEventKeeper;
289
290 com::sun::star::uno::Reference<
291 com::sun::star::xml::wrapper::XXMLDocumentWrapper >
292 m_xXMLDocumentWrapper;
293
294 com::sun::star::uno::Reference<
295 com::sun::star::xml::sax::XDocumentHandler >
296 m_xOutputHandler;
297
298 com::sun::star::uno::Reference<
299 com::sun::star::xml::sax::XParser >
300 m_xSaxParser;
301
302 std::stack< void* > m_stCurrentPath;
303 std::stack< bool > m_stCurrentPathType;
304
305 std::vector< AncestorEvent* > m_vAncestorEvents;
306 std::vector< SignatureEntity* > m_vSignatureList;
307
308 std::vector< rtl::OUString > m_vUnsolvedReferenceURIs;
309 std::vector< int > m_vUnsolvedReferenceKeeperIds;
310 std::vector< int > m_vUnsolvedReferenceRefNums;
311
312 bool m_bIsExporting;
313 bool m_bIsBlocking;
314
315 bool m_bIsInsideCollectedElement;
316 bool m_bIsSAXEventKeeperOnTheSAXChain;
317
318 com::sun::star::uno::Reference<
319 com::sun::star::xml::crypto::XXMLSecurityContext >
320 m_xXMLSecurityContext;
321
322 com::sun::star::uno::Reference<
323 com::sun::star::xml::crypto::XXMLSignature >
324 m_xXMLSignature;
325
326 rtl::OUString m_ouJavaCryptokenDir;
327 rtl::OUString m_ouCCryptokenDir;
328 rtl::OUString m_ouXMLDocumentWrapperComponentName;
329
330 private:
331 com::sun::star::uno::Reference<
332 com::sun::star::io::XOutputStream >
333 createOutputStream( const rtl::OUString& ouFile );
334
335 rtl::OUString parseFile(
336 const rtl::OUString& ouInputFileName,
337 const rtl::OUString& ouOutputFileName,
338 bool bIsExporting,
339 bool bIsJavaBased);
340
341 void changeOutput();
342
343 bool foundSecurityRelated();
344
345 void findKeyOrReference(SecurityEntity* pSecurityEntity, const rtl::OUString& ouUri, bool bIsFindKey);
346
347 bool checkSecurityElement(
348 const rtl::OUString& ouLocalName,
349 const com::sun::star::uno::Reference<
350 com::sun::star::xml::sax::XAttributeList>& xAttribs);
351
352 void checkReference(
353 const rtl::OUString& ouLocalName,
354 const com::sun::star::uno::Reference<
355 com::sun::star::xml::sax::XAttributeList>& xAttribs,
356 const rtl::OUString& ouId);
357
358 void endMission();
359
360 void addStartAncestorEvent(
361 const rtl::OUString& ouName,
362 const com::sun::star::uno::Reference<
363 com::sun::star::xml::sax::XAttributeList>& xAttribs);
364
365 void addEndAncestorEvent( const rtl::OUString& ouName );
366
367 void flushAncestorEvents(
368 const com::sun::star::uno::Reference<
369 com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler);
370
371 void XSecTester::sendAncestorStartElementEvent(
372 const rtl::OUString& ouName,
373 const com::sun::star::uno::Sequence<
374 com::sun::star::xml::csax::XMLAttribute >& xAttrList,
375 const com::sun::star::uno::Reference<
376 com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const;
377
378 void XSecTester::sendAncestorEndElementEvent(
379 const rtl::OUString& ouName,
380 const com::sun::star::uno::Reference<
381 com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const;
382
383 std::vector< AncestorEvent* >::const_iterator XSecTester::checkAncestorStartElementEvent(
384 const std::vector< AncestorEvent* >::const_iterator& ii,
385 const com::sun::star::uno::Reference<
386 com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const;
387
388 public:
389 XSecTester(const com::sun::star::uno::Reference<
390 com::sun::star::lang::XMultiServiceFactory >& rxMSF)
391 :mxMSF( rxMSF ){};
392 virtual ~XSecTester(){};
393
394 /* XSignatureCreationResultListener */
395 virtual void SAL_CALL signatureCreated(
396 sal_Int32 securityId,
397 com::sun::star::xml::crypto::SecurityOperationStatus creationResult )
398 throw (com::sun::star::uno::RuntimeException);
399
400 /* XSignatureVerifyResultListener */
401 virtual void SAL_CALL signatureVerified(
402 sal_Int32 securityId,
403 com::sun::star::xml::crypto::SecurityOperationStatus verifyResult )
404 throw (com::sun::star::uno::RuntimeException);
405
406 /* XSAXEventKeeperStatusChangeListener */
407 virtual void SAL_CALL blockingStatusChanged( sal_Bool isBlocking )
408 throw (com::sun::star::uno::RuntimeException);
409 virtual void SAL_CALL collectionStatusChanged(
410 sal_Bool isInsideCollectedElement )
411 throw (com::sun::star::uno::RuntimeException);
412 virtual void SAL_CALL bufferStatusChanged( sal_Bool isBufferEmpty )
413 throw (com::sun::star::uno::RuntimeException);
414
415 /* XXMLSecTester */
416 virtual rtl::OUString SAL_CALL transfer_without_sec(
417 const rtl::OUString& inputFileName,
418 const rtl::OUString& outputFileName,
419 sal_Bool isBridgeInvolved)
420 throw (com::sun::star::uno::RuntimeException);
421 virtual rtl::OUString SAL_CALL export_xml(
422 const rtl::OUString& inputFileName,
423 const rtl::OUString& outputFileName,
424 sal_Bool isJavaBased)
425 throw (com::sun::star::uno::RuntimeException);
426 virtual rtl::OUString SAL_CALL import_xml(
427 const rtl::OUString& inputFileName,
428 const rtl::OUString& outputFileName,
429 sal_Bool isJavaBased)
430 throw (com::sun::star::uno::RuntimeException);
431
432 virtual void SAL_CALL setCryptoDir(
433 const rtl::OUString & javaDirName,
434 const rtl::OUString & cDirName)
435 throw (com::sun::star::uno::RuntimeException);
436
437 /* XDocumentHandler */
438 virtual void SAL_CALL endDocument()
439 throw (com::sun::star::uno::RuntimeException);
440 virtual void SAL_CALL startDocument()
441 throw (com::sun::star::uno::RuntimeException);
442 virtual void SAL_CALL characters(const class rtl::OUString&)
443 throw (com::sun::star::uno::RuntimeException);
444 virtual void SAL_CALL processingInstruction(const rtl::OUString&, const rtl::OUString&)
445 throw (com::sun::star::uno::RuntimeException);
446 virtual void SAL_CALL ignorableWhitespace(const rtl::OUString&)
447 throw (com::sun::star::uno::RuntimeException);
448 virtual void SAL_CALL startElement(
449 const rtl::OUString&,
450 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList >&)
451 throw (com::sun::star::uno::RuntimeException);
452 virtual void SAL_CALL endElement(const rtl::OUString&)
453 throw (com::sun::star::uno::RuntimeException);
454 virtual void SAL_CALL setDocumentLocator(
455 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XLocator >&)
456 throw (com::sun::star::uno::RuntimeException);
457 };
458
459 rtl::OUString XSecTester::parseFile(
460 const rtl::OUString& ouInputFileName,
461 const rtl::OUString& ouOutputFileName,
462 bool bIsExporting,
463 bool bIsJavaBased)
464 {
465 rtl::OUString ouMessage;
466
467 cssu::Reference<cssi::XInputStream> xInputStream = OpenInputStream(ouInputFileName);
468
469 if (xInputStream != NULL )
470 {
471 /* initialization */
472 rtl::OUString SEInitializer_comp;
473 rtl::OUString XMLSignature_comp;
474 rtl::OUString tokenPath;
475 cssu::Reference < cssxc::XSEInitializer > xSEInitializer;
476
477 if (bIsJavaBased)
478 {
479 SEInitializer_comp = rtl::OUString::createFromAscii( SEINITIALIZER_JAVA_COMPONENT );
480 XMLSignature_comp = rtl::OUString::createFromAscii( XMLSIGNATURE_JAVA_COMPONENT);
481 m_ouXMLDocumentWrapperComponentName = rtl::OUString::createFromAscii( XMLDOCUMENTWRAPPER_JAVA_COMPONENT );
482 tokenPath = m_ouJavaCryptokenDir;
483 }
484 else
485 {
486 SEInitializer_comp = rtl::OUString::createFromAscii( SEINITIALIZER_C_COMPONENT );
487 XMLSignature_comp = rtl::OUString::createFromAscii( XMLSIGNATURE_C_COMPONENT);
488 m_ouXMLDocumentWrapperComponentName = rtl::OUString::createFromAscii( XMLDOCUMENT_C_COMPONENT );
489 tokenPath = m_ouCCryptokenDir;
490 }
491
492 xSEInitializer = cssu::Reference < cssxc::XSEInitializer > (
493 mxMSF->createInstance( SEInitializer_comp ),
494 cssu::UNO_QUERY );
495
496 m_xXMLSignature = cssu::Reference<cssxc::XXMLSignature> (
497 mxMSF->createInstance( XMLSignature_comp ),
498 cssu::UNO_QUERY );
499
500 if ( xSEInitializer.is() && m_xXMLSignature.is())
501 {
502 /* create SAX Parser */
503 const rtl::OUString sSaxParser (
504 RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Parser") );
505 m_xSaxParser = cssu::Reference < cssxs::XParser > ( mxMSF->createInstance( sSaxParser ), cssu::UNO_QUERY );
506
507 /* create SAX Writer */
508 const rtl::OUString sSaxWriter (
509 RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Writer") );
510 cssu::Reference < cssi::XActiveDataSource > xSaxWriter
511 ( mxMSF->createInstance( sSaxWriter ), cssu::UNO_QUERY );
512
513 cssu::Reference< cssi::XOutputStream > xOutputStream = OpenOutputStream(ouOutputFileName);
514 xSaxWriter->setOutputStream( xOutputStream );
515
516 cssxs::InputSource aInput;
517 aInput.sSystemId = ouInputFileName;
518 aInput.aInputStream = xInputStream;
519
520 cssu::Reference < cssxs::XDocumentHandler > xSaxWriterHandler( xSaxWriter, cssu::UNO_QUERY);
521
522 m_xXMLSecurityContext =
523 xSEInitializer->createSecurityContext(tokenPath);
524
525 m_bIsExporting = bIsExporting;
526 m_xExportHandler = xSaxWriterHandler;
527 m_xOutputHandler = xSaxWriterHandler;
528
529 m_xXMLDocumentWrapper = NULL;
530 m_xSAXEventKeeper = NULL;
531 m_bIsSAXEventKeeperOnTheSAXChain = false;
532
533 m_bIsBlocking = false;
534 m_bIsInsideCollectedElement = false;
535
536 OSL_ASSERT(m_vSignatureList.size() == 0);
537 OSL_ASSERT(m_vUnsolvedReferenceURIs.size() == 0);
538 OSL_ASSERT(m_vUnsolvedReferenceKeeperIds.size() == 0);
539 OSL_ASSERT(m_vUnsolvedReferenceRefNums.size() == 0);
540 OSL_ASSERT(m_stCurrentPath.empty());
541 OSL_ASSERT(m_stCurrentPathType.empty());
542 OSL_ASSERT(m_vAncestorEvents.empty());
543
544 changeOutput();
545
546 /* foundSecurityRelated(); */
547
548 /* Begin to parse */
549 TimeValue startTime, endTime;
550 osl_getSystemTime( &startTime );
551
552 xSaxWriterHandler->startDocument();
553
554 if (m_bIsExporting)
555 {
556 m_xSaxParser->setDocumentHandler(this);
557 m_xSaxParser->parseStream(aInput);
558 }
559 else
560 {
561 m_xSaxParser->setDocumentHandler(this);
562 m_xSaxParser->parseStream(aInput);
563 }
564
565 endMission();
566 xSaxWriterHandler->endDocument();
567
568 osl_getSystemTime( &endTime );
569
570 flushAncestorEvents( NULL );
571
572 // Bug in SAXWriter, done in endDocument()
573 // xOutputStream->closeOutput();
574 xInputStream->closeInput();
575
576
577 /*
578 * Free the security context
579 */
580 xSEInitializer->freeSecurityContext(m_xXMLSecurityContext);
581 m_xXMLSecurityContext = NULL;
582
583 /* Calculate the time */
584 double diff = ((double)((endTime.Nanosec + endTime.Seconds*1000000000.0)
585 - (startTime.Nanosec + startTime.Seconds*1000000000.0))) /
586 ((double)1000000000.0);
587
588 char buf[32];
589 sprintf(buf, "%.2f", diff);
590 ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM(buf));
591 }
592 else
593 {
594 ouMessage += rtl::OUString::createFromAscii( "N/A" );
595 }
596
597 }
598 else
599 {
600 ouMessage += rtl::OUString::createFromAscii( "-" );
601 }
602
603 return ouMessage;
604 }
605
606 /* XSignatureCreationResultListener */
607 void SAL_CALL XSecTester::signatureCreated(
608 sal_Int32 securityId,
609 cssxc::SecurityOperationStatus creationResult )
610 throw (cssu::RuntimeException)
611 {
612 m_nTotalSignatureNumber++;
613 if (creationResult == cssxc::SecurityOperationStatus_OPERATION_SUCCEEDED)
614 {
615 m_nSuccessfulSignatureNumber++;
616 }
617 }
618
619 /* XSignatureVerifyResultListener */
620 void SAL_CALL XSecTester::signatureVerified(
621 sal_Int32 securityId,
622 cssxc::SecurityOperationStatus verifyResult )
623 throw (cssu::RuntimeException)
624 {
625 m_nTotalSignatureNumber++;
626 if (verifyResult == cssxc::SecurityOperationStatus_OPERATION_SUCCEEDED)
627 {
628 m_nSuccessfulSignatureNumber++;
629 }
630 }
631
632 /* XSAXEventKeeperStatusChangeListener */
633 void SAL_CALL XSecTester::blockingStatusChanged( sal_Bool isBlocking )
634 throw (cssu::RuntimeException)
635 {
636 this->m_bIsBlocking = isBlocking;
637 }
638
639 void SAL_CALL XSecTester::collectionStatusChanged( sal_Bool isInsideCollectedElement )
640 throw (cssu::RuntimeException)
641 {
642 this->m_bIsInsideCollectedElement = isInsideCollectedElement;
643
644 if ( !m_bIsInsideCollectedElement && !m_bIsBlocking)
645 {
646 m_bIsSAXEventKeeperOnTheSAXChain = false;
647 }
648 else
649 {
650 m_bIsSAXEventKeeperOnTheSAXChain = true;
651 }
652 changeOutput();
653 }
654
655 void SAL_CALL XSecTester::bufferStatusChanged( sal_Bool isBufferEmpty )
656 throw (cssu::RuntimeException)
657 {
658 if (isBufferEmpty)
659 {
660 m_xXMLDocumentWrapper = NULL;
661
662 m_xSAXEventKeeper = NULL;
663 m_bIsSAXEventKeeperOnTheSAXChain = false;
664 changeOutput();
665 }
666 }
667
668 /* XXMLSecTester */
669 rtl::OUString SAL_CALL XSecTester::export_xml( const rtl::OUString& inputFileName, const rtl::OUString& outputFileName, sal_Bool isJavaBased)
670 throw (cssu::RuntimeException)
671 {
672 rtl::OUString ouMessage;
673
674 m_nTotalSignatureNumber = 0;
675 m_nSuccessfulSignatureNumber = 0;
676
677 ouMessage += parseFile(inputFileName, outputFileName, sal_True, isJavaBased);
678
679 rtl::OUString ouRemark = rtl::OUString::valueOf(m_nSuccessfulSignatureNumber) +
680 rtl::OUString(RTL_ASCII_USTRINGPARAM( "/" ))
681 + rtl::OUString::valueOf(m_nTotalSignatureNumber);
682 ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM("\t")) + ouRemark;
683
684 return ouMessage;
685 }
686
687 rtl::OUString SAL_CALL XSecTester::import_xml( const rtl::OUString& inputFileName, const rtl::OUString& outputFileName, sal_Bool isJavaBased)
688 throw (cssu::RuntimeException)
689 {
690 rtl::OUString ouMessage;
691
692 m_nTotalSignatureNumber = 0;
693 m_nSuccessfulSignatureNumber = 0;
694
695 ouMessage += parseFile(inputFileName, outputFileName, sal_False, isJavaBased);
696
697 rtl::OUString ouRemark = rtl::OUString::valueOf(m_nSuccessfulSignatureNumber) +
698 rtl::OUString(RTL_ASCII_USTRINGPARAM( "/" ))
699 + rtl::OUString::valueOf(m_nTotalSignatureNumber);
700 ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM("\t")) + ouRemark;
701
702 return ouMessage;
703 }
704
705 rtl::OUString SAL_CALL XSecTester::transfer_without_sec(
706 const rtl::OUString& inputFileName,
707 const rtl::OUString& outputFileName,
708 sal_Bool isBridgeInvolved)
709 throw (cssu::RuntimeException)
710 {
711 rtl::OUString ouMessage;
712
713 cssu::Reference< cssi::XInputStream > xInputStream = OpenInputStream(inputFileName);
714
715 if (xInputStream != NULL )
716 {
717 /* create SAX Parser */
718 const rtl::OUString sSaxParser (
719 RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Parser") );
720 m_xSaxParser = cssu::Reference < cssxs::XParser > ( mxMSF->createInstance( sSaxParser ), cssu::UNO_QUERY );
721
722 /* create SAX Writer */
723 const rtl::OUString sSaxWriter (
724 RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Writer") );
725 cssu::Reference < cssi::XActiveDataSource > xSaxWriter
726 ( mxMSF->createInstance( sSaxWriter ), cssu::UNO_QUERY );
727 cssu::Reference < cssxs::XDocumentHandler > xSaxWriterHandler(
728 xSaxWriter, cssu::UNO_QUERY);
729
730 if (!isBridgeInvolved)
731 {
732 /* connect the SAX Parser and the SAX Writer */
733 m_xSaxParser->setDocumentHandler ( xSaxWriterHandler );
734 }
735 else
736 {
737 /* create Java Flat Filter */
738 const rtl::OUString sJavaFlatFilter(
739 RTL_CONSTASCII_USTRINGPARAM( JAVAFLATFILTER_COMPONENT ) );
740 cssu::Reference < cssxs::XParser > xJavaFilterParser
741 ( mxMSF->createInstance( sJavaFlatFilter ), cssu::UNO_QUERY );
742 cssu::Reference < cssxs::XDocumentHandler > xJavaFilterHandler(
743 xJavaFilterParser, cssu::UNO_QUERY );
744
745 if ( !xJavaFilterParser.is() )
746 return rtl::OUString::createFromAscii( "NO JAVA" );
747
748 /* connect the SAX Parser, the Java Flat Filter and the SAX Writer */
749 xJavaFilterParser->setDocumentHandler( xSaxWriterHandler );
750 m_xSaxParser->setDocumentHandler ( xJavaFilterHandler );
751 }
752
753
754 /* set output stream */
755 cssu::Reference< cssi::XOutputStream > xOutputStream =
756 OpenOutputStream(outputFileName);
757 xSaxWriter->setOutputStream( xOutputStream );
758
759 /* prepare input stream */
760 cssxs::InputSource aInput;
761 aInput.sSystemId = inputFileName;
762 aInput.aInputStream = xInputStream;
763
764 TimeValue startTime, endTime;
765 osl_getSystemTime( &startTime );
766
767 m_xSaxParser->parseStream ( aInput );
768
769 // xOutputStream->closeOutput();
770 xInputStream->closeInput();
771
772 osl_getSystemTime( &endTime );
773
774 double diff = ((double)((endTime.Nanosec + endTime.Seconds*1000000000.0)
775 - (startTime.Nanosec + startTime.Seconds*1000000000.0)))/((double)1000000000.0);
776 char buf[32];
777 sprintf(buf, "%.2f", diff);
778 ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM(buf));
779 }
780
781 return ouMessage;
782 }
783
784 void SAL_CALL XSecTester::setCryptoDir(const rtl::OUString & javaDirName, const rtl::OUString & cDirName)
785 throw (cssu::RuntimeException)
786 {
787 m_ouJavaCryptokenDir = javaDirName;
788 m_ouCCryptokenDir = cDirName;
789 }
790
791
792 cssu::Reference< cssu::XInterface > SAL_CALL XSecTester_createInstance(
793 const cssu::Reference< cssl::XMultiServiceFactory > & rSMgr)
794 throw( cssu::Exception )
795 {
796 return (cppu::OWeakObject*) new XSecTester( rSMgr );
797 }
798
799 int SecurityEntity::m_nNextSecurityId = 1;
800
801 SecurityEntity::SecurityEntity(
802 const cssu::Reference<cssxc::sax::XSecuritySAXEventKeeper>& xSAXEventKeeper,
803 const cssu::Reference<cssxc::XXMLSecurityContext>& xXMLSecurityContext,
804 const cssu::Reference<cssxc::XXMLSignature>& xXMLSignature,
805 const cssu::Reference< cssl::XMultiServiceFactory > &rsMSF)
806 :m_xSAXEventKeeper(xSAXEventKeeper),
807 m_xXMLSecurityContext(xXMLSecurityContext),
808 m_xXMLSignature(xXMLSignature),
809 mxMSF(rsMSF),
810 m_ouKeyURI(RTL_ASCII_USTRINGPARAM(""))
811 {
812 m_nSecurityId = getNextSecurityId();
813 }
814
815 int SecurityEntity::getNextSecurityId() const
816 {
817 int nId = m_nNextSecurityId++;
818 return nId;
819 }
820
821 void SecurityEntity::setKeyId(int nId)
822 {
823 cssu::Reference<cssxc::sax::XKeyCollector> keyCollector (m_xReferenceListener, cssu::UNO_QUERY);
824 keyCollector->setKeyId(nId);
825 }
826
827
828 void SecurityEntity::setKeyURI(const rtl::OUString& ouUri)
829 {
830 m_ouKeyURI = ouUri;
831 }
832
833 cssu::Reference<cssxc::sax::XReferenceResolvedListener> SecurityEntity::getReferenceListener() const
834 {
835 return m_xReferenceListener;
836 }
837
838 int SecurityEntity::getSecurityId() const
839 {
840 return m_nSecurityId;
841 }
842
843 bool SecurityEntity::setKey(const rtl::OUString& ouUri, bool bIsExporting)
844 {
845 bool rc = false;
846
847 if (m_ouKeyURI != rtl::OUString(RTL_ASCII_USTRINGPARAM("")) &&
848 m_ouKeyURI == ouUri)
849 {
850 int nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
851 bIsExporting ?
852 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY):
853 (cssxc::sax::ElementMarkPriority_AFTERMODIFY),
854 true);
855
856 setKeyId(nKeeperId);
857 m_xSAXEventKeeper->setSecurityId(nKeeperId, m_nSecurityId);
858
859 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster
860 (m_xSAXEventKeeper, cssu::UNO_QUERY);
861 xReferenceResolvedBroadcaster->addReferenceResolvedListener(nKeeperId,
862 m_xReferenceListener);
863
864 rc = true;
865 }
866
867 return rc;
868 }
869
870 bool SecurityEntity::endMission()
871 {
872 cssu::Reference<cssxc::sax::XMissionTaker> xMissionTaker
873 (m_xReferenceListener, cssu::UNO_QUERY);
874
875 return xMissionTaker->endMission();
876 }
877
878 SignatureEntity::SignatureEntity(
879 const cssu::Reference<cssxc::sax::XSecuritySAXEventKeeper>& xSAXEventKeeper,
880 bool bIsExporting,
881 XSecTester* pListener,
882 const cssu::Reference<cssxc::XXMLSecurityContext>& xXMLSecurityContext,
883 const cssu::Reference<cssxc::XXMLSignature>& xXMLSignature,
884 const cssu::Reference< cssl::XMultiServiceFactory >& rsMSF)
885 :SecurityEntity(xSAXEventKeeper,
886 xXMLSecurityContext,
887 xXMLSignature,
888 rsMSF)
889 {
890 if (bIsExporting)
891 {
892 m_nSignatureElementCollectorId =
893 m_xSAXEventKeeper->addSecurityElementCollector(
894 cssxc::sax::ElementMarkPriority_AFTERMODIFY,
895 true);
896
897 m_xSAXEventKeeper->setSecurityId(m_nSignatureElementCollectorId, m_nSecurityId);
898
899 m_xReferenceListener = cssu::Reference< cssxc::sax::XReferenceResolvedListener >(
900 mxMSF->createInstance( rtl::OUString::createFromAscii( SIGNATURECREATOR_COMPONENT )),
901 cssu::UNO_QUERY);
902
903 cssu::Reference<cssl::XInitialization> xInitialization(m_xReferenceListener, cssu::UNO_QUERY);
904
905 cssu::Sequence<cssu::Any> args(5);
906 char buf[16];
907
908 sprintf(buf, "%d", m_nSecurityId);
909 args[0] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)));
910 args[1] = cssu::makeAny(m_xSAXEventKeeper);
911
912 sprintf(buf, "%d", m_nSignatureElementCollectorId);
913 args[2] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)));
914 args[3] = cssu::makeAny(m_xXMLSecurityContext->getSecurityEnvironment());
915 args[4] = cssu::makeAny(m_xXMLSignature);
916
917 xInitialization->initialize(args);
918
919 int nBlockerId = m_xSAXEventKeeper->addBlocker();
920 m_xSAXEventKeeper->setSecurityId(nBlockerId, m_nSecurityId);
921
922 cssu::Reference<cssxc::sax::XBlockerMonitor> xBlockerMonitor(m_xReferenceListener, cssu::UNO_QUERY);
923 xBlockerMonitor->setBlockerId(nBlockerId);
924
925 cssu::Reference< cssxc::sax::XSignatureCreationResultBroadcaster > xSignatureCreationResultBroadcaster
926 (m_xReferenceListener, cssu::UNO_QUERY);
927 xSignatureCreationResultBroadcaster->addSignatureCreationResultListener(pListener);
928 }
929 else
930 {
931 m_nSignatureElementCollectorId =
932 m_xSAXEventKeeper->addSecurityElementCollector(
933 cssxc::sax::ElementMarkPriority_BEFOREMODIFY,
934 false);
935
936 m_xSAXEventKeeper->setSecurityId(m_nSignatureElementCollectorId, m_nSecurityId);
937
938 m_xReferenceListener = cssu::Reference< cssxc::sax::XReferenceResolvedListener >(
939 mxMSF->createInstance( rtl::OUString::createFromAscii( SIGNATUREVERIFIER_COMPONENT )),
940 cssu::UNO_QUERY);
941
942 cssu::Reference<cssl::XInitialization> xInitialization(m_xReferenceListener, cssu::UNO_QUERY);
943
944 cssu::Sequence<cssu::Any> args(5);
945 char buf[16];
946
947 sprintf(buf, "%d", m_nSecurityId);
948 args[0] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)));
949 args[1] = cssu::makeAny(m_xSAXEventKeeper);
950
951 sprintf(buf, "%d", m_nSignatureElementCollectorId);
952 args[2] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)));
953 args[3] = cssu::makeAny(m_xXMLSecurityContext);
954 args[4] = cssu::makeAny(m_xXMLSignature);
955 xInitialization->initialize(args);
956
957 cssu::Reference< cssxc::sax::XSignatureVerifyResultBroadcaster > xSignatureVerifyResultBroadcaster
958 (m_xReferenceListener, cssu::UNO_QUERY);
959 xSignatureVerifyResultBroadcaster->addSignatureVerifyResultListener(pListener);
960 }
961
962 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster
963 (m_xSAXEventKeeper, cssu::UNO_QUERY);
964 xReferenceResolvedBroadcaster->addReferenceResolvedListener(
965 m_nSignatureElementCollectorId, m_xReferenceListener);
966 }
967
968 void SignatureEntity::addReferenceURI(const rtl::OUString& ouUri)
969 {
970 m_vReferenceIds.push_back(ouUri);
971 }
972
973 void SignatureEntity::setReferenceNumber() const
974 {
975 cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector
976 (m_xReferenceListener, cssu::UNO_QUERY);
977 xReferenceCollector->setReferenceCount(m_vReferenceIds.size());
978 }
979
980 bool SignatureEntity::hasReference(const rtl::OUString& ouUri) const
981 {
982 bool rc = false;
983
984 std::vector<const rtl::OUString>::const_iterator ii;
985 for (ii = m_vReferenceIds.begin(); ii != m_vReferenceIds.end(); ++ii)
986 {
987 if (ouUri == *ii)
988 {
989 rc = true;
990 break;
991 }
992 }
993
994 return rc;
995 }
996
997 bool SignatureEntity::setReference(const rtl::OUString& ouUri, bool bIsExporting) const
998 {
999 bool rc = false;
1000
1001 if (hasReference(ouUri))
1002 {
1003 int nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
1004 bIsExporting ?
1005 (cssxc::sax::ElementMarkPriority_AFTERMODIFY):
1006 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY),
1007 false);
1008
1009 m_xSAXEventKeeper->setSecurityId(nKeeperId, m_nSecurityId);
1010
1011 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster
1012 (m_xSAXEventKeeper, cssu::UNO_QUERY);
1013 xReferenceResolvedBroadcaster->addReferenceResolvedListener(nKeeperId, m_xReferenceListener);
1014
1015 cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector
1016 (m_xReferenceListener, cssu::UNO_QUERY);
1017 xReferenceCollector->setReferenceId(nKeeperId);
1018
1019 rc = true;
1020 }
1021
1022 return rc;
1023 }
1024
1025 /* XDocumentHandler */
1026 void SAL_CALL XSecTester::startDocument()
1027 throw (cssu::RuntimeException)
1028 {
1029 }
1030
1031 void SAL_CALL XSecTester::endDocument()
1032 throw (cssu::RuntimeException)
1033 {
1034 }
1035
1036 void SAL_CALL XSecTester::characters(const class rtl::OUString & chars)
1037 throw (cssu::RuntimeException)
1038 {
1039 m_xExportHandler->characters(chars);
1040 }
1041
1042 void SAL_CALL XSecTester::processingInstruction(const rtl::OUString & target, const rtl::OUString &data)
1043 throw (cssu::RuntimeException)
1044 {
1045 m_xExportHandler->processingInstruction(target, data);
1046 }
1047
1048 void SAL_CALL XSecTester::ignorableWhitespace(const rtl::OUString &)
1049 throw (cssu::RuntimeException)
1050 {
1051
1052 }
1053
1054 void SAL_CALL XSecTester::startElement(const rtl::OUString & name, const cssu::Reference<cssxs::XAttributeList> &xAttribs)
1055 throw (cssu::RuntimeException)
1056 {
1057 rtl::OUString ouIdAttr = xAttribs->getValueByName(
1058 rtl::OUString(RTL_ASCII_USTRINGPARAM("id")));
1059
1060 if (ouIdAttr == NULL)
1061 {
1062 ouIdAttr = xAttribs->getValueByName(
1063 rtl::OUString(RTL_ASCII_USTRINGPARAM("Id")));
1064 }
1065
1066 bool bHasIdAttr = (ouIdAttr != NULL && ouIdAttr.getLength() > 0 );
1067 bool needResend = false;
1068
1069 if (bHasIdAttr || name.equalsAscii( SIGNATURE_STR ))
1070 {
1071 if (foundSecurityRelated() && ! m_bIsExporting)
1072 {
1073 needResend = true;
1074 }
1075 }
1076
1077 if ( !m_bIsSAXEventKeeperOnTheSAXChain )
1078 {
1079 addStartAncestorEvent(name, xAttribs);
1080 }
1081
1082 bool bSuppressingForwarding = checkSecurityElement(name, xAttribs);
1083
1084 checkReference(name, xAttribs, ouIdAttr);
1085
1086 if (needResend)
1087 {
1088 m_xSAXEventKeeper->setNextHandler(NULL);
1089
1090 cssu::Reference<cssxs::XDocumentHandler> xSAXEventKeeperHandler
1091 (m_xSAXEventKeeper, cssu::UNO_QUERY);
1092
1093 xSAXEventKeeperHandler->startElement(name, xAttribs);
1094 m_xSAXEventKeeper->setNextHandler(this);
1095 }
1096
1097 if (!bSuppressingForwarding)
1098 {
1099 m_xExportHandler->startElement(name, xAttribs);
1100 }
1101 }
1102
1103 void SAL_CALL XSecTester::endElement(const rtl::OUString& name)
1104 throw (cssu::RuntimeException)
1105 {
1106 if (!m_stCurrentPath.empty())
1107 {
1108 void* pSignedInfo = m_stCurrentPath.top();
1109 bool bIsStringType = m_stCurrentPathType.top();
1110
1111 m_stCurrentPath.pop();
1112 m_stCurrentPathType.pop();
1113
1114 if (bIsStringType && !strcmp((const char *)pSignedInfo, SIGNEDINFO_STR))
1115 {
1116 if (!m_stCurrentPath.empty())
1117 {
1118 void* pSignature = m_stCurrentPath.top();
1119 bIsStringType = m_stCurrentPathType.top();
1120
1121 if (!bIsStringType && pSignature != NULL)
1122 {
1123 ((SignatureEntity *) pSignature)->setReferenceNumber();
1124 }
1125 }
1126 }
1127 }
1128
1129 if ( !m_bIsSAXEventKeeperOnTheSAXChain )
1130 {
1131 addEndAncestorEvent(name);
1132 }
1133
1134 m_xExportHandler->endElement(name);
1135 }
1136
1137 void SAL_CALL XSecTester::setDocumentLocator( const cssu::Reference<cssxs::XLocator>& )
1138 throw (cssu::RuntimeException)
1139 {
1140 }
1141
1142 void XSecTester::changeOutput()
1143 {
1144 if (m_bIsExporting)
1145 {
1146 if (m_bIsSAXEventKeeperOnTheSAXChain)
1147 {
1148 m_xExportHandler = cssu::Reference<cssxs::XDocumentHandler>
1149 (m_xSAXEventKeeper, cssu::UNO_QUERY);
1150
1151 m_xSAXEventKeeper->setNextHandler(NULL);
1152
1153 flushAncestorEvents(m_xExportHandler);
1154
1155 m_xSAXEventKeeper->setNextHandler(m_xOutputHandler);
1156 }
1157 else
1158 {
1159 m_xExportHandler = m_xOutputHandler;
1160 }
1161 }
1162 else
1163 {
1164 if (m_bIsSAXEventKeeperOnTheSAXChain)
1165 {
1166 cssu::Reference<cssxs::XDocumentHandler> xSAXEventKeeperHandler
1167 (m_xSAXEventKeeper, cssu::UNO_QUERY);
1168
1169 m_xSAXEventKeeper->setNextHandler(NULL);
1170
1171 flushAncestorEvents(xSAXEventKeeperHandler);
1172
1173 m_xSaxParser->setDocumentHandler(xSAXEventKeeperHandler);
1174 m_xSAXEventKeeper->setNextHandler(this);
1175 }
1176 else
1177 {
1178 m_xSaxParser->setDocumentHandler(this);
1179 }
1180
1181 }
1182 }
1183
1184 bool XSecTester::foundSecurityRelated()
1185 {
1186 if (m_xSAXEventKeeper == NULL)
1187 {
1188 m_bIsBlocking = false;
1189 m_bIsInsideCollectedElement = false;
1190
1191 m_xXMLDocumentWrapper = cssu::Reference<cssxw::XXMLDocumentWrapper>
1192 (mxMSF->createInstance( m_ouXMLDocumentWrapperComponentName ),
1193 cssu::UNO_QUERY);
1194
1195 m_xSAXEventKeeper = cssu::Reference< cssxc::sax::XSecuritySAXEventKeeper >
1196 (mxMSF->createInstance( rtl::OUString::createFromAscii( SAXEVENTKEEPER_COMPONENT )),
1197 cssu::UNO_QUERY);
1198
1199 cssu::Reference<cssl::XInitialization> xInitialization(m_xSAXEventKeeper, cssu::UNO_QUERY);
1200
1201 cssu::Sequence <cssu::Any> arg(1);
1202 arg[0] = cssu::makeAny(m_xXMLDocumentWrapper);
1203 xInitialization->initialize(arg);
1204
1205 cssu::Reference<cssxc::sax::XSAXEventKeeperStatusChangeBroadcaster>
1206 xSAXEventKeeperStatusChangeBroadcaster(m_xSAXEventKeeper, cssu::UNO_QUERY);
1207 xSAXEventKeeperStatusChangeBroadcaster->addSAXEventKeeperStatusChangeListener(this);
1208 }
1209
1210 bool rc = false;
1211
1212 if (!m_bIsSAXEventKeeperOnTheSAXChain)
1213 {
1214 rc = true;
1215 }
1216
1217 m_bIsSAXEventKeeperOnTheSAXChain=true;
1218 changeOutput();
1219
1220 return rc;
1221 }
1222
1223 void XSecTester::findKeyOrReference(SecurityEntity* pSecurityEntity, const rtl::OUString& ouUri, bool bIsFindingKey)
1224 {
1225 std::vector<rtl::OUString>::iterator ii_referenceURIs;
1226 std::vector<int>::iterator ii_referenceKeeperIds;
1227 std::vector<int>::iterator ii_referenceRefNums;
1228
1229 for (ii_referenceURIs = m_vUnsolvedReferenceURIs.begin(),
1230 ii_referenceKeeperIds = m_vUnsolvedReferenceKeeperIds.begin(),
1231 ii_referenceRefNums = m_vUnsolvedReferenceRefNums.begin();
1232 ii_referenceURIs != m_vUnsolvedReferenceURIs.end(); )
1233 {
1234 rtl::OUString ouReferenceUri = *ii_referenceURIs;
1235
1236 if (ouReferenceUri == ouUri)
1237 {
1238 int nKeeperId = *ii_referenceKeeperIds;
1239 int nRefNum = *ii_referenceRefNums;
1240
1241 if ( bIsFindingKey )
1242 {
1243 int nClonedKeeperId = m_xSAXEventKeeper->cloneElementCollector(
1244 nKeeperId,
1245 m_bIsExporting?
1246 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY):
1247 (cssxc::sax::ElementMarkPriority_AFTERMODIFY));
1248
1249 pSecurityEntity->setKeyId(nClonedKeeperId);
1250
1251 m_xSAXEventKeeper->setSecurityId(nClonedKeeperId, pSecurityEntity->getSecurityId());
1252
1253 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster>
1254 xReferenceResolvedBroadcaster(m_xSAXEventKeeper, cssu::UNO_QUERY);
1255 xReferenceResolvedBroadcaster->addReferenceResolvedListener(
1256 nClonedKeeperId,
1257 pSecurityEntity->getReferenceListener());
1258 }
1259 else
1260 {
1261 int nClonedKeeperId = m_xSAXEventKeeper->cloneElementCollector(
1262 nKeeperId,
1263 m_bIsExporting?
1264 (cssxc::sax::ElementMarkPriority_AFTERMODIFY):
1265 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY));
1266
1267 m_xSAXEventKeeper->setSecurityId(nClonedKeeperId, pSecurityEntity->getSecurityId());
1268
1269 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster>
1270 xReferenceResolvedBroadcaster
1271 (m_xSAXEventKeeper, cssu::UNO_QUERY);
1272 xReferenceResolvedBroadcaster->addReferenceResolvedListener(
1273 nClonedKeeperId,
1274 pSecurityEntity->getReferenceListener());
1275
1276 cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector
1277 (pSecurityEntity->getReferenceListener(), cssu::UNO_QUERY);
1278 xReferenceCollector->setReferenceId(nClonedKeeperId);
1279 }
1280
1281 nRefNum--;
1282 if (nRefNum == 0)
1283 {
1284 m_xSAXEventKeeper->removeElementCollector(nKeeperId);
1285
1286 ii_referenceURIs = m_vUnsolvedReferenceURIs.erase(ii_referenceURIs);
1287 ii_referenceKeeperIds = m_vUnsolvedReferenceKeeperIds.erase(ii_referenceKeeperIds);
1288 ii_referenceRefNums = m_vUnsolvedReferenceRefNums.erase(ii_referenceRefNums);
1289 }
1290 else
1291 {
1292 (*ii_referenceRefNums) = nRefNum;
1293
1294 ii_referenceURIs++;
1295 ii_referenceKeeperIds++;
1296 ii_referenceRefNums++;
1297 }
1298
1299 if (bIsFindingKey)
1300 {
1301 break;
1302 }
1303 }
1304 else
1305 {
1306 ii_referenceURIs++;
1307 ii_referenceKeeperIds++;
1308 ii_referenceRefNums++;
1309 }
1310 }
1311 }
1312
1313 bool XSecTester::checkSecurityElement(
1314 const rtl::OUString& ouLocalName,
1315 const cssu::Reference<cssxs::XAttributeList>& xAttribs)
1316 {
1317 bool rc = false;
1318
1319 if (ouLocalName.equalsAscii(SIGNATURE_STR))
1320 {
1321 SignatureEntity* pSignatureEntity = new SignatureEntity(
1322 m_xSAXEventKeeper,
1323 m_bIsExporting,
1324 this,
1325 m_xXMLSecurityContext,
1326 m_xXMLSignature,
1327 mxMSF);
1328
1329 m_vSignatureList.push_back(pSignatureEntity);
1330
1331 m_stCurrentPath.push(pSignatureEntity);
1332 m_stCurrentPathType.push(false);
1333 }
1334 else if (ouLocalName.equalsAscii(REFERENCE_STR))
1335 {
1336 if (!m_stCurrentPath.empty())
1337 {
1338 void* pSignedInfo = m_stCurrentPath.top();
1339 bool bIsStringType = m_stCurrentPathType.top();
1340
1341 m_stCurrentPath.pop();
1342 m_stCurrentPathType.pop();
1343
1344 if (bIsStringType && !m_stCurrentPath.empty())
1345 {
1346 void* pSignature = m_stCurrentPath.top();
1347 bool bIsStringType2 = m_stCurrentPathType.top();
1348
1349 if (!strcmp((const char*)pSignedInfo, SIGNEDINFO_STR) && !bIsStringType2)
1350 {
1351 rtl::OUString ouUri = xAttribs->getValueByName
1352 (rtl::OUString(RTL_ASCII_USTRINGPARAM( URI_ATTR_STR )));
1353
1354 if (ouUri.matchAsciiL("#", 1, 0))
1355 {
1356 rtl::OUString uri = ouUri.copy(1);
1357 SignatureEntity* pSignatureEntity = (SignatureEntity *)pSignature;
1358
1359 if (uri != NULL && uri.getLength()>0)
1360 {
1361 pSignatureEntity->addReferenceURI(uri);
1362 findKeyOrReference(pSignatureEntity, uri, true);
1363 }
1364 }
1365 }
1366 }
1367 m_stCurrentPath.push(pSignedInfo);
1368 m_stCurrentPathType.push(bIsStringType);
1369 }
1370 m_stCurrentPath.push( (void *)REFERENCE_STR);
1371 m_stCurrentPathType.push(true);
1372 }
1373 else if(ouLocalName.equalsAscii(KEYVALUE_STR) ||
1374 ouLocalName.equalsAscii(KEYNAME_STR) ||
1375 ouLocalName.equalsAscii(X509DATA_STR) ||
1376 ouLocalName.equalsAscii(ENCRYPTEDKEY_STR))
1377 {
1378 if (!m_stCurrentPath.empty())
1379 {
1380 void* pKeyInfo = m_stCurrentPath.top();
1381 bool bIsStringType = m_stCurrentPathType.top();
1382
1383 m_stCurrentPath.pop();
1384 m_stCurrentPathType.pop();
1385
1386 if (bIsStringType && !m_stCurrentPath.empty())
1387 {
1388 bool bIsStringType2 = m_stCurrentPathType.top();
1389
1390 if (!bIsStringType2)
1391 {
1392 SecurityEntity *pSecurityEntity =
1393 (SecurityEntity *) (m_stCurrentPath.top());
1394 pSecurityEntity->setKeyId(0);
1395 }
1396 }
1397
1398 m_stCurrentPath.push(pKeyInfo);
1399 m_stCurrentPathType.push(bIsStringType);
1400 }
1401
1402 m_stCurrentPath.push((void *)KEYVALUE_STR);
1403 m_stCurrentPathType.push(true);
1404 }
1405 else if(ouLocalName.equalsAscii(RETRIEVALMETHOD_STR))
1406 {
1407 if (!m_stCurrentPath.empty())
1408 {
1409 void* pKeyInfo = m_stCurrentPath.top();
1410 bool bIsStringType = m_stCurrentPathType.top();
1411
1412 m_stCurrentPath.pop();
1413 m_stCurrentPathType.pop();
1414
1415 if (bIsStringType && !m_stCurrentPath.empty())
1416 {
1417 bool bIsStringType2 = m_stCurrentPathType.top();
1418
1419 if (!bIsStringType2)
1420 {
1421 SecurityEntity *pSecurityEntity =
1422 (SecurityEntity *) m_stCurrentPath.top();
1423 rtl::OUString ouUri = xAttribs->getValueByName(
1424 rtl::OUString(RTL_ASCII_USTRINGPARAM( URI_ATTR_STR )));
1425
1426 if (!strcmp((const char *)pKeyInfo, KEYINFO_STR) &&
1427 ouUri != NULL && ouUri.getLength()>0)
1428 {
1429 pSecurityEntity->setKeyURI(ouUri);
1430 findKeyOrReference(pSecurityEntity, ouUri, true);
1431 }
1432 }
1433
1434 }
1435
1436 m_stCurrentPath.push(pKeyInfo);
1437 m_stCurrentPathType.push(bIsStringType);
1438 }
1439
1440 m_stCurrentPath.push((void *)RETRIEVALMETHOD_STR);
1441 m_stCurrentPathType.push(true);
1442 }
1443 else if(ouLocalName.equalsAscii(KEYINFO_STR))
1444 {
1445 m_stCurrentPath.push((void *)KEYINFO_STR);
1446 m_stCurrentPathType.push(true);
1447 }
1448 else if(ouLocalName.equalsAscii(SIGNEDINFO_STR))
1449 {
1450 m_stCurrentPath.push((void *)SIGNEDINFO_STR);
1451 m_stCurrentPathType.push(true);
1452 }
1453 else
1454 {
1455 m_stCurrentPath.push((void *)OTHER_ELEMENT_STR);
1456 m_stCurrentPathType.push(true);
1457 }
1458
1459 return rc;
1460 }
1461
1462 void XSecTester::checkReference(
1463 const rtl::OUString& ouLocalName,
1464 const cssu::Reference<cssxs::XAttributeList>& xAttribs,
1465 const rtl::OUString& ouId)
1466 {
1467 rtl::OUString refNumStr =
1468 xAttribs->getValueByName(rtl::OUString(RTL_ASCII_USTRINGPARAM(REFNUM_ATTR_STR)));
1469
1470 if (ouId != NULL && ouId.getLength()>0 )
1471 {
1472 int nRefNum = 999;
1473 if (refNumStr != NULL && refNumStr.getLength()>0 )
1474 {
1475 nRefNum = refNumStr.toInt32();
1476 }
1477
1478 int nLength = m_vSignatureList.size();
1479 for (int i = 0; i<nLength; ++i)
1480 {
1481 SignatureEntity* pSignatureEntity = m_vSignatureList.at(i);
1482
1483 if (pSignatureEntity->setReference(ouId, m_bIsExporting))
1484 {
1485 nRefNum--;
1486 }
1487
1488 if (pSignatureEntity->setKey(ouId, m_bIsExporting))
1489 {
1490 nRefNum--;
1491 }
1492 }
1493
1494 if (nRefNum>0)
1495 {
1496 int nKeeperId;
1497
1498 if (ouLocalName.equalsAscii(ENCRYPTEDKEY_STR))
1499 {
1500 nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
1501 m_bIsExporting ?
1502 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY):
1503 (cssxc::sax::ElementMarkPriority_AFTERMODIFY),
1504 true);
1505 }
1506 else
1507 {
1508 nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
1509 m_bIsExporting?
1510 (cssxc::sax::ElementMarkPriority_AFTERMODIFY):
1511 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY),
1512 false);
1513 }
1514
1515 m_vUnsolvedReferenceURIs.push_back(ouId);
1516 m_vUnsolvedReferenceKeeperIds.push_back(nKeeperId);
1517 m_vUnsolvedReferenceRefNums.push_back(nRefNum);
1518 }
1519 }
1520 }
1521
1522 void XSecTester::endMission()
1523 {
1524 while (m_vSignatureList.size() > 0)
1525 {
1526 if (m_vSignatureList.size()>0)
1527 {
1528 SignatureEntity * pSignatureEntity = m_vSignatureList.at(0);
1529 m_vSignatureList.erase(m_vSignatureList.begin());
1530 pSignatureEntity->endMission();
1531 delete pSignatureEntity;
1532 }
1533 }
1534
1535 while (m_vUnsolvedReferenceURIs.size()>0)
1536 {
1537 int nKeeperId = m_vUnsolvedReferenceKeeperIds.at(0);
1538 m_xSAXEventKeeper->removeElementCollector(nKeeperId);
1539 m_vUnsolvedReferenceURIs.erase(m_vUnsolvedReferenceURIs.begin());
1540 m_vUnsolvedReferenceKeeperIds.erase(m_vUnsolvedReferenceKeeperIds.begin());
1541 m_vUnsolvedReferenceRefNums.erase(m_vUnsolvedReferenceRefNums.begin());
1542 }
1543 }
1544
1545 void XSecTester::addStartAncestorEvent(
1546 const rtl::OUString& ouName,
1547 const cssu::Reference< cssxs::XAttributeList >& xAttribs)
1548 {
1549 sal_Int32 nLength = xAttribs->getLength();
1550 AncestorEvent* ancestorEvent = new AncestorEvent( nLength );
1551
1552 ancestorEvent->bIsStartElement = true;
1553 ancestorEvent->ouName = ouName;
1554
1555 for (int i = 0; i<nLength; ++i)
1556 {
1557 (ancestorEvent->aAttributeList[i]).sName = xAttribs->getNameByIndex((short)i);
1558 (ancestorEvent->aAttributeList[i]).sValue =xAttribs->getValueByIndex((short)i);
1559 }
1560
1561 m_vAncestorEvents.push_back(ancestorEvent);
1562 }
1563
1564 void XSecTester::addEndAncestorEvent(const rtl::OUString& ouName)
1565 {
1566 AncestorEvent* ancestorEvent = new AncestorEvent(0);
1567
1568 ancestorEvent->bIsStartElement = false;
1569 ancestorEvent->ouName = ouName;
1570
1571 m_vAncestorEvents.push_back(ancestorEvent);
1572 }
1573
1574 void XSecTester::sendAncestorStartElementEvent(
1575 const rtl::OUString& ouName,
1576 const cssu::Sequence< cssxcsax::XMLAttribute >& attrList,
1577 const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const
1578 {
1579 SvXMLAttributeList* pAttributeList = new SvXMLAttributeList();
1580 cssu::Reference < cssxs::XAttributeList > xAttrList
1581 = cssu::Reference< cssxs::XAttributeList > (pAttributeList);
1582
1583 sal_Int32 nLength = attrList.getLength();
1584
1585 for (int i = 0; i<nLength; ++i)
1586 {
1587 pAttributeList->AddAttribute( attrList[i].sName, attrList[i].sValue);
1588 }
1589
1590 xDocumentHandler->startElement(ouName, xAttrList);
1591 }
1592
1593 void XSecTester::sendAncestorEndElementEvent(
1594 const rtl::OUString& ouName,
1595 const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const
1596 {
1597 xDocumentHandler->endElement(ouName);
1598 }
1599
1600 std::vector< AncestorEvent* >::const_iterator XSecTester::checkAncestorStartElementEvent(
1601 const std::vector< AncestorEvent* >::const_iterator& ii,
1602 const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const
1603 {
1604 std::vector< AncestorEvent* >::const_iterator next = ii+1;
1605
1606 if (next == m_vAncestorEvents.end())
1607 {
1608 sendAncestorStartElementEvent(
1609 (*ii)->ouName, (*ii)->aAttributeList, xDocumentHandler);
1610 }
1611 else
1612 {
1613 while ((next != m_vAncestorEvents.end()) && ((*next)->bIsStartElement))
1614 {
1615 next = checkAncestorStartElementEvent(next, xDocumentHandler);
1616 }
1617
1618 if (next != m_vAncestorEvents.end())
1619 {
1620 next++;
1621 }
1622 }
1623
1624 return next;
1625 }
1626
1627 void XSecTester::flushAncestorEvents(
1628 const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler)
1629 {
1630 std::vector< AncestorEvent* >::const_iterator ii;
1631
1632 if (xDocumentHandler != NULL)
1633 {
1634 ii = m_vAncestorEvents.begin();
1635
1636 while (ii != m_vAncestorEvents.end())
1637 {
1638 AncestorEvent* ancestorEvent = *ii;
1639
1640 if (ancestorEvent->bIsStartElement)
1641 {
1642 ii = checkAncestorStartElementEvent(ii, xDocumentHandler);
1643 }
1644 else
1645 {
1646 sendAncestorEndElementEvent((*ii)->ouName, xDocumentHandler);
1647 ii++;
1648 }
1649 }
1650 }
1651
1652 /* free the ancestor events list */
1653 std::vector< AncestorEvent* >::iterator jj;
1654
1655 while (m_vAncestorEvents.size()>0)
1656 {
1657 jj = m_vAncestorEvents.begin();
1658 delete *jj;
1659 m_vAncestorEvents.erase(jj);
1660 }
1661 }
1662
1663 /*
1664 * Get the length of a file in a platform independant fashion
1665 */
1666 int getLength(const char *pInputFileName)
1667 {
1668 int nSize = 0;
1669 std::ifstream data(pInputFileName);
1670
1671 data.seekg(0, std::ios_base::end);
1672 nSize = data.tellg();
1673
1674 return nSize;
1675 }
1676
1677 void outputHeader()
1678 {
1679 fprintf(stderr, "%16s%4s%8s%12s%12s%12s%12s\n", "File Name", "E/I", "Size", "-C++", "-Java", "Forw-O", "No S/E");
1680 fprintf(stderr, "===============================================================================\n");
1681 }
1682
1683 /*
1684 * print the output on the screen as well as in the GNUPlot data file
1685 */
1686 void output(const rtl::OUString& ouInputFileName,
1687 const rtl::OUString& ouTime_C,
1688 const rtl::OUString& ouTime_Java,
1689 const rtl::OUString& ouTime_NoSecurity,
1690 const rtl::OUString& ouTime_JavaForwardOnly,
1691 const rtl::OUString& ouRemark_C,
1692 const rtl::OUString& ouRemark_Java,
1693 bool bIsExporting)
1694 {
1695 int nSize = getLength(rtl::OString(ouInputFileName, ouInputFileName.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
1696 std::ofstream data;
1697
1698 /* print screen */
1699 int nPosition = ouInputFileName.lastIndexOf('\\');
1700 rtl::OUString fileName = ouInputFileName.copy(nPosition + 1);
1701
1702 fprintf(stderr, "%16s", rtl::OString(fileName, fileName.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
1703
1704 fprintf(stderr, "%4s", bIsExporting?"E":"I");
1705 fprintf(stderr, "%7dK", nSize/1024);
1706 fprintf(stderr, "%8s %3s",
1707 rtl::OString(ouTime_C, ouTime_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr(),
1708 rtl::OString(ouRemark_C, ouRemark_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
1709 fprintf(stderr, "%8s %3s",
1710 rtl::OString(ouTime_Java, ouTime_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr(),
1711 rtl::OString(ouRemark_Java, ouRemark_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
1712 fprintf(stderr, "%12s", rtl::OString(ouTime_JavaForwardOnly, ouTime_JavaForwardOnly.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
1713 fprintf(stderr, "%12s", rtl::OString(ouTime_NoSecurity, ouTime_NoSecurity.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
1714 fprintf(stderr, "\n");
1715
1716 /* output the data as GNUPlot data file */
1717 /*
1718 char str[32];
1719 sprintf(str, "%d %s", nSize, rtl::OString(ouTime_C, ouTime_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
1720 data.open("d:\\time_vs_size.txt", std::ios::app);
1721 data << str << std::endl;
1722 data.close();
1723
1724 sprintf(str, "%d %s", nSize, rtl::OString(ouTime_Java, ouTime_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr());
1725 data.open("d:\\time_vs_size_without_sec.txt", std::ios::app);
1726 data << str << std::endl;
1727 data.close();
1728 */
1729 }
1730
1731 int main( int argc, char **argv )
1732 {
1733 if (argc < 3)
1734 {
1735 fprintf(stderr, "Usage: testtool <exportbatchfile> <importbatchfile> [<cppcryptotoken>] [<javacryptotoken>]\n");
1736 exit (-1);
1737 }
1738
1739 rtl::OUString aExportBatchFile = rtl::OUString::createFromAscii(argv[1]);
1740 rtl::OUString aImportBatchFile = rtl::OUString::createFromAscii(argv[2]);
1741 rtl::OUString aCPPCryptoToken;
1742 if ( argc > 3 )
1743 aCPPCryptoToken = rtl::OUString::createFromAscii(argv[3]);
1744 rtl::OUString aJavaCryptoToken;
1745 if ( argc > 4 )
1746 aJavaCryptoToken = rtl::OUString::createFromAscii(argv[4]);
1747
1748 try
1749 {
1750 uno::Reference< lang::XMultiServiceFactory > xMSF = CreateDemoServiceFactory();
1751
1752 XSecTester* pTester = new XSecTester( xMSF );
1753 uno::Reference< xml::sax::XDocumentHandler > xKeepARef = pTester;
1754
1755 pTester->setCryptoDir( aJavaCryptoToken, aCPPCryptoToken );
1756
1757 rtl::OUString ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly;
1758 rtl::OUString ouInputFileName;
1759 rtl::OUString outputFileName1;
1760 rtl::OUString outputFileName2;
1761 rtl::OUString ouRemark_C, ouRemark_Java;
1762
1763 outputHeader();
1764
1765 std::ifstream batch_export, batch_import;
1766
1767 batch_export.open(OUStringToOString( aExportBatchFile, RTL_TEXTENCODING_ASCII_US ).getStr());
1768
1769 const int MAX_LINE = 80;
1770 char line[MAX_LINE + 1];
1771
1772 while (batch_export.getline(line, MAX_LINE))
1773 {
1774 ouInputFileName = rtl::OUString::createFromAscii(line);
1775 int nPosition = ouInputFileName.lastIndexOf('.');
1776 int nPosition1;
1777
1778 /*
1779 * export the file with signautre/encryption (C++)
1780 */
1781 outputFileName1 = ouInputFileName.copy(0, nPosition) +
1782 rtl::OUString::createFromAscii("-ex.xml");
1783 ouTime_C = pTester->export_xml(ouInputFileName, outputFileName1, sal_False);
1784 nPosition1 = ouTime_C.lastIndexOf('\t');
1785 ouRemark_C = ouTime_C.copy(nPosition1 + 1);
1786 ouTime_C = ouTime_C.copy(0, nPosition1);
1787
1788 /*
1789 * export the file with signautre/encryption (Java)
1790 */
1791 outputFileName1 = ouInputFileName.copy(0, nPosition) +
1792 rtl::OUString::createFromAscii("-ex2.xml");
1793 ouTime_Java = pTester->export_xml(ouInputFileName, outputFileName1, sal_True);
1794 nPosition1 = ouTime_Java.lastIndexOf('\t');
1795 ouRemark_Java = ouTime_Java.copy(nPosition1 + 1);
1796 ouTime_Java = ouTime_Java.copy(0, nPosition1);
1797
1798 /*
1799 * export the file without signautre/encryption
1800 */
1801 outputFileName2 = ouInputFileName.copy(0, nPosition) +
1802 rtl::OUString::createFromAscii("-ex-no.xml");
1803 ouTime_NoSecurity = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_False);
1804
1805 /*
1806 * export the file with Java Flat Filter
1807 */
1808 outputFileName2 = ouInputFileName.copy(0, nPosition) +
1809 rtl::OUString::createFromAscii("-ex-jf.xml");
1810 ouTime_JavaForwardOnly = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_True);
1811
1812 /*
1813 * print output
1814 */
1815 output(ouInputFileName, ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly, ouRemark_C, ouRemark_Java, true);
1816 }
1817
1818 batch_export.close();
1819
1820 batch_import.open(OUStringToOString( aImportBatchFile, RTL_TEXTENCODING_ASCII_US ).getStr());
1821
1822 while (batch_import.getline(line, MAX_LINE))
1823 {
1824 ouInputFileName = rtl::OUString::createFromAscii(line);
1825 int nPosition = ouInputFileName.lastIndexOf('.');
1826 int nPosition1;
1827
1828 /*
1829 * import the file with signautre/encryption (C++)
1830 */
1831 outputFileName1 = ouInputFileName.copy(0, nPosition) +
1832 rtl::OUString::createFromAscii("-im.xml");
1833 ouTime_C = pTester->import_xml(ouInputFileName, outputFileName1, sal_False);
1834 nPosition1 = ouTime_C.lastIndexOf('\t');
1835 ouRemark_C = ouTime_C.copy(nPosition1 + 1);
1836 ouTime_C = ouTime_C.copy(0, nPosition1);
1837
1838 /*
1839 * import the file with signautre/encryption (Java)
1840 */
1841 outputFileName1 = ouInputFileName.copy(0, nPosition) +
1842 rtl::OUString::createFromAscii("-im2.xml");
1843 ouTime_Java = pTester->import_xml(ouInputFileName, outputFileName1, sal_True);
1844 nPosition1 = ouTime_Java.lastIndexOf('\t');
1845 ouRemark_Java = ouTime_Java.copy(nPosition1 + 1);
1846 ouTime_Java = ouTime_Java.copy(0, nPosition1);
1847
1848 /*
1849 * import the file without signautre/encryption
1850 */
1851 outputFileName2 = ouInputFileName.copy(0, nPosition) +
1852 rtl::OUString::createFromAscii("-im-no.xml");
1853 ouTime_NoSecurity = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_False);
1854
1855 /*
1856 * import the file without signautre/encryption
1857 */
1858
1859 outputFileName2 = ouInputFileName.copy(0, nPosition) +
1860 rtl::OUString::createFromAscii("-im-jf.xml");
1861 ouTime_JavaForwardOnly = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_True);
1862
1863 /*
1864 * print output
1865 */
1866 output(ouInputFileName, ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly, ouRemark_C, ouRemark_Java, false);
1867 }
1868
1869 batch_import.close();
1870
1871 fprintf(stderr, "\n");
1872 }
1873 catch( cssu::Exception& e )
1874 {
1875 fprintf( stderr , "\nEXCEPTION! Error Message: %s\n" ,
1876 rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() ) ;
1877 }
1878
1879 return 0;
1880 }
FREE OFFICE SUITE