?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 7.6.3.2-android
[LibreOffice.git] / package / source / xstor / owriteablestream.cxx
blob97b78249f6d8557f7d048b05b7532d2b69767151
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <sal/config.h>
21
22 #include <cassert>
23 #include <memory>
24 #include <sal/log.hxx>
25
26 #include <com/sun/star/packages/NoEncryptionException.hpp>
27 #include <com/sun/star/packages/WrongPasswordException.hpp>
28 #include <com/sun/star/uno/XComponentContext.hpp>
29 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
30 #include <com/sun/star/lang/DisposedException.hpp>
31 #include <com/sun/star/lang/XTypeProvider.hpp>
32 #include <com/sun/star/io/NotConnectedException.hpp>
33 #include <com/sun/star/io/TempFile.hpp>
34 #include <com/sun/star/io/XInputStream.hpp>
35 #include <com/sun/star/io/IOException.hpp>
36 #include <com/sun/star/embed/ElementModes.hpp>
37 #include <com/sun/star/embed/StorageFormats.hpp>
38 #include <com/sun/star/embed/StorageWrappedTargetException.hpp>
39 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
40 #include <cppuhelper/typeprovider.hxx>
41 #include <cppuhelper/queryinterface.hxx>
42 #include <cppuhelper/exc_hlp.hxx>
43 #include <osl/diagnose.h>
44
45 #include <comphelper/processfactory.hxx>
46 #include <comphelper/servicehelper.hxx>
47 #include <comphelper/storagehelper.hxx>
48 #include <comphelper/ofopxmlhelper.hxx>
49 #include <comphelper/refcountedmutex.hxx>
50 #include <comphelper/sequence.hxx>
51
52 #include <comphelper/diagnose_ex.hxx>
53
54 #include <PackageConstants.hxx>
55 #include <utility>
56
57 #include "selfterminatefilestream.hxx"
58 #include "owriteablestream.hxx"
59 #include "oseekinstream.hxx"
60 #include "xstorage.hxx"
61
62 // since the copying uses 32000 blocks usually, it makes sense to have a smaller size
63 #define MAX_STORCACHE_SIZE 30000
64
65 using namespace ::com::sun::star;
66
67 namespace package
68 {
69
70 static void CopyInputToOutput(
71 const css::uno::Reference< css::io::XInputStream >& xInput,
72 SvStream& rOutput )
73 {
74 static const sal_Int32 nConstBufferSize = 32000;
75
76 if (auto pByteReader = dynamic_cast< comphelper::ByteReader* >( xInput.get() ))
77 {
78 sal_Int32 nRead;
79 sal_Int8 aTempBuf[ nConstBufferSize ];
80 do
81 {
82 nRead = pByteReader->readSomeBytes ( aTempBuf, nConstBufferSize );
83 rOutput.WriteBytes ( aTempBuf, nRead );
84 }
85 while ( nRead == nConstBufferSize );
86 }
87 else
88 {
89 sal_Int32 nRead;
90 uno::Sequence < sal_Int8 > aSequence ( nConstBufferSize );
91
92 do
93 {
94 nRead = xInput->readBytes ( aSequence, nConstBufferSize );
95 rOutput.WriteBytes ( aSequence.getConstArray(), nRead );
96 }
97 while ( nRead == nConstBufferSize );
98 }
99 }
100
101 bool PackageEncryptionDataLessOrEqual( const ::comphelper::SequenceAsHashMap& aHash1, const ::comphelper::SequenceAsHashMap& aHash2 )
102 {
103 // tdf#93389: aHash2 may contain more than in aHash1, if it contains also data for other package
104 // formats (as in case of autorecovery)
105 bool bResult = !aHash1.empty() && aHash1.size() <= aHash2.size();
106 for ( ::comphelper::SequenceAsHashMap::const_iterator aIter = aHash1.begin();
107 bResult && aIter != aHash1.end();
108 ++aIter )
109 {
110 uno::Sequence< sal_Int8 > aKey1;
111 bResult = ( ( aIter->second >>= aKey1 ) && aKey1.hasElements() );
112 if ( bResult )
113 {
114 const uno::Sequence< sal_Int8 > aKey2 = aHash2.getUnpackedValueOrDefault( aIter->first.maString, uno::Sequence< sal_Int8 >() );
115 bResult = aKey1.getLength() == aKey2.getLength()
116 && std::equal(std::cbegin(aKey1), std::cend(aKey1), aKey2.begin(), aKey2.end());
117 }
118 }
119
120 return bResult;
121 }
122
123 } // namespace package
124
125 namespace
126 {
127
128 void SetEncryptionKeyProperty_Impl( const uno::Reference< beans::XPropertySet >& xPropertySet,
129 const uno::Sequence< beans::NamedValue >& aKey )
130 {
131 SAL_WARN_IF( !xPropertySet.is(), "package.xstor", "No property set is provided!" );
132 if ( !xPropertySet.is() )
133 throw uno::RuntimeException();
134
135 try {
136 xPropertySet->setPropertyValue( STORAGE_ENCRYPTION_KEYS_PROPERTY, uno::Any( aKey ) );
137 }
138 catch ( const uno::Exception& ex )
139 {
140 TOOLS_WARN_EXCEPTION( "package.xstor", "Can't write encryption related properties");
141 throw io::IOException(ex.Message); // TODO
142 }
143 }
144
145 uno::Any GetEncryptionKeyProperty_Impl( const uno::Reference< beans::XPropertySet >& xPropertySet )
146 {
147 SAL_WARN_IF( !xPropertySet.is(), "package.xstor", "No property set is provided!" );
148 if ( !xPropertySet.is() )
149 throw uno::RuntimeException();
150
151 try {
152 return xPropertySet->getPropertyValue(STORAGE_ENCRYPTION_KEYS_PROPERTY);
153 }
154 catch ( const uno::Exception& ex )
155 {
156 TOOLS_WARN_EXCEPTION( "package.xstor", "Can't get encryption related properties");
157 throw io::IOException(ex.Message); // TODO
158 }
159 }
160
161 bool SequencesEqual( const uno::Sequence< sal_Int8 >& aSequence1, const uno::Sequence< sal_Int8 >& aSequence2 )
162 {
163 return aSequence1.getLength() == aSequence2.getLength()
164 && std::equal(aSequence1.begin(), aSequence1.end(), aSequence2.begin(), aSequence2.end());
165 }
166
167 bool SequencesEqual( const uno::Sequence< beans::NamedValue >& aSequence1, const uno::Sequence< beans::NamedValue >& aSequence2 )
168 {
169 if ( aSequence1.getLength() != aSequence2.getLength() )
170 return false;
171
172 for ( const auto& rProp1 : aSequence1 )
173 {
174 bool bHasMember = false;
175 uno::Sequence< sal_Int8 > aMember1;
176 sal_Int32 nMember1 = 0;
177 if ( rProp1.Value >>= aMember1 )
178 {
179 for ( const auto& rProp2 : aSequence2 )
180 {
181 if ( rProp1.Name == rProp2.Name )
182 {
183 bHasMember = true;
184
185 uno::Sequence< sal_Int8 > aMember2;
186 if ( !( rProp2.Value >>= aMember2 ) || !SequencesEqual( aMember1, aMember2 ) )
187 return false;
188 }
189 }
190 }
191 else if ( rProp1.Value >>= nMember1 )
192 {
193 for ( const auto& rProp2 : aSequence2 )
194 {
195 if ( rProp1.Name == rProp2.Name )
196 {
197 bHasMember = true;
198
199 sal_Int32 nMember2 = 0;
200 if ( !( rProp2.Value >>= nMember2 ) || nMember1 != nMember2 )
201 return false;
202 }
203 }
204 }
205 else
206 return false;
207
208 if ( !bHasMember )
209 return false;
210 }
211
212 return true;
213 }
214
215 uno::Reference< io::XStream > CreateMemoryStream( const uno::Reference< uno::XComponentContext >& rContext )
216 {
217 static constexpr OUStringLiteral sName(u"com.sun.star.comp.MemoryStream");
218 return uno::Reference< io::XStream >(
219 rContext->getServiceManager()->createInstanceWithContext(sName, rContext),
220 uno::UNO_QUERY_THROW);
221 }
222
223 const beans::StringPair* lcl_findPairByName(const uno::Sequence<beans::StringPair>& rSeq, const OUString& rName)
224 {
225 return std::find_if(rSeq.begin(), rSeq.end(),
226 [&rName](const beans::StringPair& rPair) { return rPair.First == rName; });
227 }
228
229 } // anonymous namespace
230
231 OWriteStream_Impl::OWriteStream_Impl( OStorage_Impl* pParent,
232 const uno::Reference< packages::XDataSinkEncrSupport >& xPackageStream,
233 const uno::Reference< lang::XSingleServiceFactory >& xPackage,
234 uno::Reference< uno::XComponentContext > xContext,
235 bool bForceEncrypted,
236 sal_Int32 nStorageType,
237 bool bDefaultCompress,
238 uno::Reference< io::XInputStream > xRelInfoStream )
239 : m_xMutex( new comphelper::RefCountedMutex )
240 , m_pAntiImpl( nullptr )
241 , m_bHasDataToFlush( false )
242 , m_bFlushed( false )
243 , m_xPackageStream( xPackageStream )
244 , m_xContext(std::move( xContext ))
245 , m_pParent( pParent )
246 , m_bForceEncrypted( bForceEncrypted )
247 , m_bUseCommonEncryption( !bForceEncrypted && nStorageType == embed::StorageFormats::PACKAGE )
248 , m_bHasCachedEncryptionData( false )
249 , m_bCompressedSetExplicit( !bDefaultCompress )
250 , m_xPackage( xPackage )
251 , m_bHasInsertedStreamOptimization( false )
252 , m_nStorageType( nStorageType )
253 , m_xOrigRelInfoStream(std::move( xRelInfoStream ))
254 , m_bOrigRelInfoBroken( false )
255 , m_nRelInfoStatus( RELINFO_NO_INIT )
256 , m_nRelId( 1 )
257 {
258 SAL_WARN_IF( !xPackageStream.is(), "package.xstor", "No package stream is provided!" );
259 SAL_WARN_IF( !xPackage.is(), "package.xstor", "No package component is provided!" );
260 SAL_WARN_IF( !m_xContext.is(), "package.xstor", "No package stream is provided!" );
261 OSL_ENSURE( pParent, "No parent storage is provided!" );
262 OSL_ENSURE( m_nStorageType == embed::StorageFormats::OFOPXML || !m_xOrigRelInfoStream.is(), "The Relations info makes sense only for OFOPXML format!" );
263 }
264
265 OWriteStream_Impl::~OWriteStream_Impl()
266 {
267 DisposeWrappers();
268
269 m_oTempFile.reset();
270
271 CleanCacheStream();
272 }
273
274 void OWriteStream_Impl::CleanCacheStream()
275 {
276 if ( !m_xCacheStream.is() )
277 return;
278
279 try
280 {
281 uno::Reference< io::XInputStream > xInputCache = m_xCacheStream->getInputStream();
282 if ( xInputCache.is() )
283 xInputCache->closeInput();
284 }
285 catch( const uno::Exception& )
286 {}
287
288 try
289 {
290 uno::Reference< io::XOutputStream > xOutputCache = m_xCacheStream->getOutputStream();
291 if ( xOutputCache.is() )
292 xOutputCache->closeOutput();
293 }
294 catch( const uno::Exception& )
295 {}
296
297 m_xCacheStream.clear();
298 m_xCacheSeek.clear();
299 }
300
301 void OWriteStream_Impl::InsertIntoPackageFolder( const OUString& aName,
302 const uno::Reference< container::XNameContainer >& xParentPackageFolder )
303 {
304 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() );
305
306 SAL_WARN_IF( !m_bFlushed, "package.xstor", "This method must not be called for nonflushed streams!" );
307 if ( m_bFlushed )
308 {
309 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "An inserted stream is incomplete!" );
310 uno::Reference< uno::XInterface > xTmp( m_xPackageStream, uno::UNO_QUERY_THROW );
311 xParentPackageFolder->insertByName( aName, uno::Any( xTmp ) );
312
313 m_bFlushed = false;
314 m_bHasInsertedStreamOptimization = false;
315 }
316 }
317 bool OWriteStream_Impl::IsEncrypted()
318 {
319 if ( m_nStorageType != embed::StorageFormats::PACKAGE )
320 return false;
321
322 if ( m_bForceEncrypted || m_bHasCachedEncryptionData )
323 return true;
324
325 if ( m_oTempFile.has_value() || m_xCacheStream.is() )
326 return false;
327
328 GetStreamProperties();
329
330 // the following value can not be cached since it can change after root commit
331 bool bWasEncr = false;
332 uno::Reference< beans::XPropertySet > xPropSet( m_xPackageStream, uno::UNO_QUERY );
333 if ( xPropSet.is() )
334 {
335 uno::Any aValue = xPropSet->getPropertyValue("WasEncrypted");
336 if ( !( aValue >>= bWasEncr ) )
337 {
338 SAL_WARN( "package.xstor", "The property WasEncrypted has wrong type!" );
339 }
340 }
341
342 bool bToBeEncr = false;
343 for ( const auto& rProp : std::as_const(m_aProps) )
344 {
345 if ( rProp.Name == "Encrypted" )
346 {
347 if ( !( rProp.Value >>= bToBeEncr ) )
348 {
349 SAL_WARN( "package.xstor", "The property has wrong type!" );
350 }
351 }
352 }
353
354 // since a new key set to the package stream it should not be removed except the case when
355 // the stream becomes nonencrypted
356 uno::Sequence< beans::NamedValue > aKey;
357 if ( bToBeEncr )
358 GetEncryptionKeyProperty_Impl( xPropSet ) >>= aKey;
359
360 // If the properties must be investigated the stream is either
361 // was never changed or was changed, the parent was committed
362 // and the stream was closed.
363 // That means that if it is intended to use common storage key
364 // it is already has no encryption but is marked to be stored
365 // encrypted and the key is empty.
366 if ( !bWasEncr && bToBeEncr && !aKey.hasElements() )
367 {
368 // the stream is intended to use common storage password
369 m_bUseCommonEncryption = true;
370 return false;
371 }
372 else
373 return bToBeEncr;
374 }
375
376 void OWriteStream_Impl::SetDecrypted()
377 {
378 SAL_WARN_IF( m_nStorageType != embed::StorageFormats::PACKAGE, "package.xstor", "The encryption is supported only for package storages!" );
379 if ( m_nStorageType != embed::StorageFormats::PACKAGE )
380 throw uno::RuntimeException();
381
382 GetStreamProperties();
383
384 // let the stream be modified
385 FillTempGetFileName();
386 m_bHasDataToFlush = true;
387
388 // remove encryption
389 m_bForceEncrypted = false;
390 m_bHasCachedEncryptionData = false;
391 m_aEncryptionData.clear();
392
393 for ( auto& rProp : asNonConstRange(m_aProps) )
394 {
395 if ( rProp.Name == "Encrypted" )
396 rProp.Value <<= false;
397 }
398 }
399
400 void OWriteStream_Impl::SetEncrypted( const ::comphelper::SequenceAsHashMap& aEncryptionData )
401 {
402 SAL_WARN_IF( m_nStorageType != embed::StorageFormats::PACKAGE, "package.xstor", "The encryption is supported only for package storages!" );
403 if ( m_nStorageType != embed::StorageFormats::PACKAGE )
404 throw uno::RuntimeException();
405
406 if ( aEncryptionData.empty() )
407 throw uno::RuntimeException();
408
409 GetStreamProperties();
410
411 // let the stream be modified
412 FillTempGetFileName();
413 m_bHasDataToFlush = true;
414
415 // introduce encryption info
416 for ( auto& rProp : asNonConstRange(m_aProps) )
417 {
418 if ( rProp.Name == "Encrypted" )
419 rProp.Value <<= true;
420 }
421
422 m_bUseCommonEncryption = false; // very important to set it to false
423
424 m_bHasCachedEncryptionData = true;
425 m_aEncryptionData = aEncryptionData;
426 }
427
428 void OWriteStream_Impl::DisposeWrappers()
429 {
430 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() );
431 if ( m_pAntiImpl )
432 {
433 try {
434 m_pAntiImpl->dispose();
435 }
436 catch ( const uno::RuntimeException& )
437 {
438 TOOLS_INFO_EXCEPTION("package.xstor", "Quiet exception");
439 }
440
441 m_pAntiImpl = nullptr;
442 }
443 m_pParent = nullptr;
444
445 if ( m_aInputStreamsVector.empty() )
446 return;
447
448 for ( auto& pStream : m_aInputStreamsVector )
449 {
450 if ( pStream )
451 {
452 pStream->InternalDispose();
453 pStream = nullptr;
454 }
455 }
456
457 m_aInputStreamsVector.clear();
458 }
459
460 void OWriteStream_Impl::GetFilledTempFileIfNo( const uno::Reference< io::XInputStream >& xStream )
461 {
462 if ( !m_oTempFile.has_value() )
463 {
464 m_oTempFile.emplace();
465
466 try {
467 if ( xStream.is() )
468 {
469 // the current position of the original stream should be still OK, copy further
470 package::CopyInputToOutput( xStream, *m_oTempFile->GetStream(StreamMode::READWRITE) );
471 }
472 }
473 catch( const packages::WrongPasswordException& )
474 {
475 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
476 m_oTempFile.reset();
477 throw;
478 }
479 catch( const uno::Exception& )
480 {
481 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
482 m_oTempFile.reset();
483 throw;
484 }
485
486 if ( m_oTempFile.has_value() )
487 CleanCacheStream();
488 }
489 }
490
491 void OWriteStream_Impl::FillTempGetFileName()
492 {
493 // should try to create cache first, if the amount of contents is too big, the temp file should be taken
494 if ( !m_xCacheStream.is() && !m_oTempFile.has_value() )
495 {
496 uno::Reference< io::XInputStream > xOrigStream = m_xPackageStream->getDataStream();
497 if ( !xOrigStream.is() )
498 {
499 // in case of new inserted package stream it is possible that input stream still was not set
500 uno::Reference< io::XStream > xCacheStream = CreateMemoryStream( m_xContext );
501 SAL_WARN_IF( !xCacheStream.is(), "package.xstor", "If the stream can not be created an exception must be thrown!" );
502 m_xCacheSeek.set( xCacheStream, uno::UNO_QUERY_THROW );
503 m_xCacheStream = xCacheStream;
504 }
505 else
506 {
507 sal_Int32 nRead = 0;
508 uno::Sequence< sal_Int8 > aData( MAX_STORCACHE_SIZE + 1 );
509 nRead = xOrigStream->readBytes( aData, MAX_STORCACHE_SIZE + 1 );
510 if ( aData.getLength() > nRead )
511 aData.realloc( nRead );
512
513 if ( nRead <= MAX_STORCACHE_SIZE )
514 {
515 uno::Reference< io::XStream > xCacheStream = CreateMemoryStream( m_xContext );
516 SAL_WARN_IF( !xCacheStream.is(), "package.xstor", "If the stream can not be created an exception must be thrown!" );
517
518 if ( nRead )
519 {
520 uno::Reference< io::XOutputStream > xOutStream( xCacheStream->getOutputStream(), uno::UNO_SET_THROW );
521 xOutStream->writeBytes( aData );
522 }
523 m_xCacheSeek.set( xCacheStream, uno::UNO_QUERY_THROW );
524 m_xCacheStream = xCacheStream;
525 m_xCacheSeek->seek( 0 );
526 }
527 else if ( !m_oTempFile.has_value() )
528 {
529 m_oTempFile.emplace();
530
531 try {
532 // copy stream contents to the file
533 SvStream* pStream = m_oTempFile->GetStream(StreamMode::READWRITE);
534 pStream->WriteBytes( aData.getConstArray(), aData.getLength() );
535
536 // the current position of the original stream should be still OK, copy further
537 package::CopyInputToOutput( xOrigStream, *pStream );
538 }
539 catch( const packages::WrongPasswordException& )
540 {
541 m_oTempFile.reset();
542 throw;
543 }
544 catch( const uno::Exception& )
545 {
546 m_oTempFile.reset();
547 }
548 }
549 }
550 }
551 }
552
553 uno::Reference< io::XStream > OWriteStream_Impl::GetTempFileAsStream()
554 {
555 uno::Reference< io::XStream > xTempStream;
556
557 if ( !m_xCacheStream.is() )
558 {
559 if ( !m_oTempFile.has_value() )
560 FillTempGetFileName();
561
562 if ( m_oTempFile.has_value() )
563 {
564 // the temporary file is not used if the cache is used
565 try
566 {
567 SvStream* pStream = m_oTempFile->GetStream(StreamMode::READWRITE);
568 pStream->Seek(0);
569 xTempStream = new utl::OStreamWrapper(pStream, /*bOwner*/false);
570 }
571 catch( const uno::Exception& )
572 {
573 TOOLS_INFO_EXCEPTION("package.xstor", "Quiet exception");
574 }
575 }
576 }
577
578 if ( m_xCacheStream.is() )
579 xTempStream = m_xCacheStream;
580
581 // the method must always return a stream
582 // in case the stream can not be open
583 // an exception should be thrown
584 if ( !xTempStream.is() )
585 throw io::IOException("no temp stream"); //TODO:
586
587 return xTempStream;
588 }
589
590 uno::Reference< io::XInputStream > OWriteStream_Impl::GetTempFileAsInputStream()
591 {
592 uno::Reference< io::XInputStream > xInputStream;
593
594 if ( !m_xCacheStream.is() )
595 {
596 if ( !m_oTempFile.has_value() )
597 FillTempGetFileName();
598
599 if ( m_oTempFile.has_value() )
600 {
601 // the temporary file is not used if the cache is used
602 try
603 {
604 SvStream* pStream = m_oTempFile->GetStream(StreamMode::READWRITE);
605 pStream->Seek(0);
606 xInputStream = new utl::OStreamWrapper(pStream, /*bOwner*/false);
607 }
608 catch( const uno::Exception& )
609 {
610 TOOLS_INFO_EXCEPTION("package.xstor", "Quiet exception");
611 }
612 }
613 }
614
615 if ( m_xCacheStream.is() )
616 xInputStream = m_xCacheStream->getInputStream();
617
618 // the method must always return a stream
619 // in case the stream can not be open
620 // an exception should be thrown
621 if ( !xInputStream.is() )
622 throw io::IOException(); // TODO:
623
624 return xInputStream;
625 }
626
627 void OWriteStream_Impl::InsertStreamDirectly( const uno::Reference< io::XInputStream >& xInStream,
628 const uno::Sequence< beans::PropertyValue >& aProps )
629 {
630 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
631
632 // this call can be made only during parent storage commit
633 // the parent storage is responsible for the correct handling
634 // of deleted and renamed contents
635
636 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "No package stream is set!" );
637
638 if ( m_bHasDataToFlush )
639 throw io::IOException("m_bHasDataToFlush==true");
640
641 OSL_ENSURE( !m_oTempFile.has_value() && !m_xCacheStream.is(), "The temporary must not exist!" );
642
643 // use new file as current persistent representation
644 // the new file will be removed after it's stream is closed
645 m_xPackageStream->setDataStream( xInStream );
646
647 // copy properties to the package stream
648 uno::Reference< beans::XPropertySet > xPropertySet( m_xPackageStream, uno::UNO_QUERY_THROW );
649
650 // The storage-package communication has a problem
651 // the storage caches properties, thus if the package changes one of them itself
652 // the storage does not know about it
653
654 // Depending from MediaType value the package can change the compressed property itself
655 // Thus if Compressed property is provided it must be set as the latest one
656 bool bCompressedIsSet = false;
657 bool bCompressed = false;
658 OUString aComprPropName( "Compressed" );
659 OUString aMedTypePropName( "MediaType" );
660 for ( const auto& rProp : aProps )
661 {
662 if ( rProp.Name == aComprPropName )
663 {
664 bCompressedIsSet = true;
665 rProp.Value >>= bCompressed;
666 }
667 else if ( ( m_nStorageType == embed::StorageFormats::OFOPXML || m_nStorageType == embed::StorageFormats::PACKAGE )
668 && rProp.Name == aMedTypePropName )
669 {
670 xPropertySet->setPropertyValue( rProp.Name, rProp.Value );
671 }
672 else if ( m_nStorageType == embed::StorageFormats::PACKAGE && rProp.Name == "UseCommonStoragePasswordEncryption" )
673 rProp.Value >>= m_bUseCommonEncryption;
674 else
675 throw lang::IllegalArgumentException();
676
677 // if there are cached properties update them
678 if ( rProp.Name == aMedTypePropName || rProp.Name == aComprPropName )
679 for ( auto& rMemProp : asNonConstRange(m_aProps) )
680 {
681 if ( rProp.Name == rMemProp.Name )
682 rMemProp.Value = rProp.Value;
683 }
684 }
685
686 if ( bCompressedIsSet )
687 {
688 xPropertySet->setPropertyValue( aComprPropName, uno::Any( bCompressed ) );
689 m_bCompressedSetExplicit = true;
690 }
691
692 if ( m_bUseCommonEncryption )
693 {
694 if ( m_nStorageType != embed::StorageFormats::PACKAGE )
695 throw uno::RuntimeException();
696
697 // set to be encrypted but do not use encryption key
698 xPropertySet->setPropertyValue( STORAGE_ENCRYPTION_KEYS_PROPERTY,
699 uno::Any( uno::Sequence< beans::NamedValue >() ) );
700 xPropertySet->setPropertyValue( "Encrypted", uno::Any( true ) );
701 }
702
703 // the stream should be free soon, after package is stored
704 m_bHasDataToFlush = false;
705 m_bFlushed = true; // will allow to use transaction on stream level if will need it
706 m_bHasInsertedStreamOptimization = true;
707 }
708
709 void OWriteStream_Impl::Commit()
710 {
711 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
712
713 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "No package stream is set!" );
714
715 if ( !m_bHasDataToFlush )
716 return;
717
718 uno::Reference< packages::XDataSinkEncrSupport > xNewPackageStream;
719 uno::Sequence< uno::Any > aSeq{ uno::Any(false) };
720
721 if ( m_xCacheStream.is() )
722 {
723 if ( m_pAntiImpl )
724 m_pAntiImpl->DeInit();
725
726 uno::Reference< io::XInputStream > xInStream( m_xCacheStream->getInputStream(), uno::UNO_SET_THROW );
727
728 xNewPackageStream.set( m_xPackage->createInstanceWithArguments( aSeq ), uno::UNO_QUERY_THROW );
729
730 xNewPackageStream->setDataStream( xInStream );
731
732 m_xCacheStream.clear();
733 m_xCacheSeek.clear();
734
735 }
736 else if ( m_oTempFile.has_value() )
737 {
738 if ( m_pAntiImpl )
739 m_pAntiImpl->DeInit();
740
741 uno::Reference< io::XInputStream > xInStream;
742 try
743 {
744 xInStream = new OSelfTerminateFileStream(m_xContext, std::move(*m_oTempFile));
745 }
746 catch( const uno::Exception& )
747 {
748 TOOLS_WARN_EXCEPTION("package", "");
749 }
750
751 if ( !xInStream.is() )
752 throw io::IOException();
753
754 xNewPackageStream.set( m_xPackage->createInstanceWithArguments( aSeq ), uno::UNO_QUERY_THROW );
755
756 // TODO/NEW: Let the temporary file be removed after commit
757 xNewPackageStream->setDataStream( xInStream );
758 m_oTempFile.reset();
759 }
760 else // if ( m_bHasInsertedStreamOptimization )
761 {
762 // if the optimization is used the stream can be accessed directly
763 xNewPackageStream = m_xPackageStream;
764 }
765
766 // copy properties to the package stream
767 uno::Reference< beans::XPropertySet > xPropertySet( xNewPackageStream, uno::UNO_QUERY_THROW );
768
769 for ( auto& rProp : asNonConstRange(m_aProps) )
770 {
771 if ( rProp.Name == "Size" )
772 {
773 if ( m_pAntiImpl && !m_bHasInsertedStreamOptimization && m_pAntiImpl->m_xSeekable.is() )
774 {
775 rProp.Value <<= m_pAntiImpl->m_xSeekable->getLength();
776 xPropertySet->setPropertyValue( rProp.Name, rProp.Value );
777 }
778 }
779 else
780 xPropertySet->setPropertyValue( rProp.Name, rProp.Value );
781 }
782
783 if ( m_bUseCommonEncryption )
784 {
785 if ( m_nStorageType != embed::StorageFormats::PACKAGE )
786 throw uno::RuntimeException();
787
788 // set to be encrypted but do not use encryption key
789 xPropertySet->setPropertyValue( STORAGE_ENCRYPTION_KEYS_PROPERTY,
790 uno::Any( uno::Sequence< beans::NamedValue >() ) );
791 xPropertySet->setPropertyValue( "Encrypted",
792 uno::Any( true ) );
793 }
794 else if ( m_bHasCachedEncryptionData )
795 {
796 if ( m_nStorageType != embed::StorageFormats::PACKAGE )
797 throw uno::RuntimeException();
798
799 xPropertySet->setPropertyValue( STORAGE_ENCRYPTION_KEYS_PROPERTY,
800 uno::Any( m_aEncryptionData.getAsConstNamedValueList() ) );
801 }
802
803 // the stream should be free soon, after package is stored
804 m_xPackageStream = xNewPackageStream;
805 m_bHasDataToFlush = false;
806 m_bFlushed = true; // will allow to use transaction on stream level if will need it
807 }
808
809 void OWriteStream_Impl::Revert()
810 {
811 // can be called only from parent storage
812 // means complete reload of the stream
813
814 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
815
816 if ( !m_bHasDataToFlush )
817 return; // nothing to do
818
819 OSL_ENSURE( m_oTempFile.has_value() || m_xCacheStream.is(), "The temporary must exist!" );
820
821 if ( m_xCacheStream.is() )
822 {
823 m_xCacheStream.clear();
824 m_xCacheSeek.clear();
825 }
826
827 m_oTempFile.reset();
828
829 m_aProps.realloc( 0 );
830
831 m_bHasDataToFlush = false;
832
833 m_bUseCommonEncryption = true;
834 m_bHasCachedEncryptionData = false;
835 m_aEncryptionData.clear();
836
837 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
838 return;
839
840 // currently the relations storage is changed only on commit
841 m_xNewRelInfoStream.clear();
842 m_aNewRelInfo = uno::Sequence< uno::Sequence< beans::StringPair > >();
843 if ( m_xOrigRelInfoStream.is() )
844 {
845 // the original stream is still here, that means that it was not parsed
846 m_aOrigRelInfo = uno::Sequence< uno::Sequence< beans::StringPair > >();
847 m_nRelInfoStatus = RELINFO_NO_INIT;
848 }
849 else
850 {
851 // the original stream was already parsed
852 if ( !m_bOrigRelInfoBroken )
853 m_nRelInfoStatus = RELINFO_READ;
854 else
855 m_nRelInfoStatus = RELINFO_BROKEN;
856 }
857 }
858
859 uno::Sequence< beans::PropertyValue > const & OWriteStream_Impl::GetStreamProperties()
860 {
861 if ( !m_aProps.hasElements() )
862 m_aProps = ReadPackageStreamProperties();
863
864 return m_aProps;
865 }
866
867 uno::Sequence< beans::PropertyValue > OWriteStream_Impl::InsertOwnProps(
868 const uno::Sequence< beans::PropertyValue >& aProps,
869 bool bUseCommonEncryption )
870 {
871 uno::Sequence< beans::PropertyValue > aResult( aProps );
872 beans::PropertyValue aPropVal;
873
874 if ( m_nStorageType == embed::StorageFormats::PACKAGE )
875 {
876 aPropVal.Name = "UseCommonStoragePasswordEncryption";
877 aPropVal.Value <<= bUseCommonEncryption;
878 }
879 else if ( m_nStorageType == embed::StorageFormats::OFOPXML )
880 {
881 ReadRelInfoIfNecessary();
882
883 aPropVal.Name = "RelationsInfo";
884 if ( m_nRelInfoStatus == RELINFO_READ )
885 aPropVal.Value <<= m_aOrigRelInfo;
886 else if ( m_nRelInfoStatus == RELINFO_CHANGED_STREAM_READ || m_nRelInfoStatus == RELINFO_CHANGED )
887 aPropVal.Value <<= m_aNewRelInfo;
888 else // m_nRelInfoStatus == RELINFO_CHANGED_BROKEN || m_nRelInfoStatus == RELINFO_BROKEN
889 throw io::IOException( "Wrong relinfo stream!" );
890 }
891 if (!aPropVal.Name.isEmpty())
892 {
893 sal_Int32 i = 0;
894 for (auto p = aResult.getConstArray(); i < aResult.getLength(); ++i)
895 if (p[i].Name == aPropVal.Name)
896 break;
897 if (i == aResult.getLength())
898 aResult.realloc(i + 1);
899 aResult.getArray()[i] = aPropVal;
900 }
901
902 return aResult;
903 }
904
905 bool OWriteStream_Impl::IsTransacted()
906 {
907 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
908 return ( m_pAntiImpl && m_pAntiImpl->m_bTransacted );
909 }
910
911 void OWriteStream_Impl::ReadRelInfoIfNecessary()
912 {
913 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
914 return;
915
916 if ( m_nRelInfoStatus == RELINFO_NO_INIT )
917 {
918 try
919 {
920 // Init from original stream
921 if ( m_xOrigRelInfoStream.is() )
922 m_aOrigRelInfo = ::comphelper::OFOPXMLHelper::ReadRelationsInfoSequence(
923 m_xOrigRelInfoStream,
924 u"_rels/*.rels",
925 m_xContext );
926
927 // in case of success the stream must be thrown away, that means that the OrigRelInfo is initialized
928 // the reason for this is that the original stream might not be seekable ( at the same time the new
929 // provided stream must be seekable ), so it must be read only once
930 m_xOrigRelInfoStream.clear();
931 m_nRelInfoStatus = RELINFO_READ;
932 }
933 catch( const uno::Exception& )
934 {
935 TOOLS_INFO_EXCEPTION("package.xstor", "Quiet exception");
936
937 m_nRelInfoStatus = RELINFO_BROKEN;
938 m_bOrigRelInfoBroken = true;
939 }
940 }
941 else if ( m_nRelInfoStatus == RELINFO_CHANGED_STREAM )
942 {
943 // Init from the new stream
944 try
945 {
946 if ( m_xNewRelInfoStream.is() )
947 m_aNewRelInfo = ::comphelper::OFOPXMLHelper::ReadRelationsInfoSequence(
948 m_xNewRelInfoStream,
949 u"_rels/*.rels",
950 m_xContext );
951
952 m_nRelInfoStatus = RELINFO_CHANGED_STREAM_READ;
953 }
954 catch( const uno::Exception& )
955 {
956 m_nRelInfoStatus = RELINFO_CHANGED_BROKEN;
957 }
958 }
959 }
960
961 uno::Sequence< beans::PropertyValue > OWriteStream_Impl::ReadPackageStreamProperties()
962 {
963 sal_Int32 nPropNum = 0;
964 if ( m_nStorageType == embed::StorageFormats::ZIP )
965 nPropNum = 2;
966 else if ( m_nStorageType == embed::StorageFormats::OFOPXML )
967 nPropNum = 3;
968 else if ( m_nStorageType == embed::StorageFormats::PACKAGE )
969 nPropNum = 4;
970 assert(nPropNum >= 2);
971 uno::Sequence< beans::PropertyValue > aResult( nPropNum );
972 auto aResultRange = asNonConstRange(aResult);
973
974 // The "Compressed" property must be set after "MediaType" property,
975 // since the setting of the last one can change the value of the first one
976 static constexpr OUStringLiteral sMediaType = u"MediaType";
977 static constexpr OUStringLiteral sCompressed = u"Compressed";
978 static constexpr OUStringLiteral sSize = u"Size";
979 static constexpr OUStringLiteral sEncrypted = u"Encrypted";
980 if ( m_nStorageType == embed::StorageFormats::OFOPXML || m_nStorageType == embed::StorageFormats::PACKAGE )
981 {
982 aResultRange[0].Name = sMediaType;
983 aResultRange[1].Name = sCompressed;
984 aResultRange[2].Name = sSize;
985
986 if ( m_nStorageType == embed::StorageFormats::PACKAGE )
987 aResultRange[3].Name = sEncrypted;
988 }
989 else
990 {
991 aResultRange[0].Name = sCompressed;
992 aResultRange[1].Name = sSize;
993 }
994
995 // TODO: may be also raw stream should be marked
996
997 uno::Reference< beans::XPropertySet > xPropSet( m_xPackageStream, uno::UNO_QUERY_THROW );
998 for ( auto& rProp : aResultRange )
999 {
1000 try {
1001 rProp.Value = xPropSet->getPropertyValue( rProp.Name );
1002 }
1003 catch( const uno::Exception& )
1004 {
1005 TOOLS_WARN_EXCEPTION( "package.xstor", "A property can't be retrieved" );
1006 }
1007 }
1008
1009 return aResult;
1010 }
1011
1012 void OWriteStream_Impl::CopyInternallyTo_Impl( const uno::Reference< io::XStream >& xDestStream,
1013 const ::comphelper::SequenceAsHashMap& aEncryptionData )
1014 {
1015 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
1016
1017 SAL_WARN_IF( m_bUseCommonEncryption, "package.xstor", "The stream can not be encrypted!" );
1018
1019 if ( m_nStorageType != embed::StorageFormats::PACKAGE )
1020 throw packages::NoEncryptionException();
1021
1022 if ( m_pAntiImpl )
1023 {
1024 m_pAntiImpl->CopyToStreamInternally_Impl( xDestStream );
1025 }
1026 else
1027 {
1028 uno::Reference< io::XStream > xOwnStream = GetStream( embed::ElementModes::READ, aEncryptionData, false );
1029 if ( !xOwnStream.is() )
1030 throw io::IOException(); // TODO
1031
1032 OStorage_Impl::completeStorageStreamCopy_Impl( xOwnStream, xDestStream, m_nStorageType, GetAllRelationshipsIfAny() );
1033 }
1034
1035 uno::Reference< embed::XEncryptionProtectedSource2 > xEncr( xDestStream, uno::UNO_QUERY );
1036 if ( xEncr.is() )
1037 xEncr->setEncryptionData( aEncryptionData.getAsConstNamedValueList() );
1038 }
1039
1040 uno::Sequence< uno::Sequence< beans::StringPair > > OWriteStream_Impl::GetAllRelationshipsIfAny()
1041 {
1042 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
1043 return uno::Sequence< uno::Sequence< beans::StringPair > >();
1044
1045 ReadRelInfoIfNecessary();
1046
1047 if ( m_nRelInfoStatus == RELINFO_READ )
1048 return m_aOrigRelInfo;
1049 else if ( m_nRelInfoStatus == RELINFO_CHANGED_STREAM_READ || m_nRelInfoStatus == RELINFO_CHANGED )
1050 return m_aNewRelInfo;
1051 else // m_nRelInfoStatus == RELINFO_CHANGED_BROKEN || m_nRelInfoStatus == RELINFO_BROKEN
1052 throw io::IOException( "Wrong relinfo stream!" );
1053 }
1054
1055 void OWriteStream_Impl::CopyInternallyTo_Impl( const uno::Reference< io::XStream >& xDestStream )
1056 {
1057 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
1058
1059 if ( m_pAntiImpl )
1060 {
1061 m_pAntiImpl->CopyToStreamInternally_Impl( xDestStream );
1062 }
1063 else
1064 {
1065 uno::Reference< io::XStream > xOwnStream = GetStream( embed::ElementModes::READ, false );
1066 if ( !xOwnStream.is() )
1067 throw io::IOException(); // TODO
1068
1069 OStorage_Impl::completeStorageStreamCopy_Impl( xOwnStream, xDestStream, m_nStorageType, GetAllRelationshipsIfAny() );
1070 }
1071 }
1072
1073 uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMode, const ::comphelper::SequenceAsHashMap& aEncryptionData, bool bHierarchyAccess )
1074 {
1075 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
1076
1077 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "No package stream is set!" );
1078
1079 if ( m_pAntiImpl )
1080 throw io::IOException(); // TODO:
1081
1082 if ( !IsEncrypted() )
1083 throw packages::NoEncryptionException();
1084
1085 uno::Reference< io::XStream > xResultStream;
1086
1087 uno::Reference< beans::XPropertySet > xPropertySet( m_xPackageStream, uno::UNO_QUERY_THROW );
1088
1089 if ( m_bHasCachedEncryptionData )
1090 {
1091 if ( !::package::PackageEncryptionDataLessOrEqual( m_aEncryptionData, aEncryptionData ) )
1092 throw packages::WrongPasswordException();
1093
1094 // the correct key must be set already
1095 xResultStream = GetStream_Impl( nStreamMode, bHierarchyAccess );
1096 }
1097 else
1098 {
1099 SetEncryptionKeyProperty_Impl( xPropertySet, aEncryptionData.getAsConstNamedValueList() );
1100
1101 try {
1102 xResultStream = GetStream_Impl( nStreamMode, bHierarchyAccess );
1103
1104 m_bUseCommonEncryption = false; // very important to set it to false
1105 m_bHasCachedEncryptionData = true;
1106 m_aEncryptionData = aEncryptionData;
1107 }
1108 catch( const packages::WrongPasswordException& )
1109 {
1110 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
1111 SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
1112 throw;
1113 }
1114 catch ( const uno::Exception& ex )
1115 {
1116 TOOLS_WARN_EXCEPTION( "package.xstor", "Can't write encryption related properties");
1117 SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
1118 throw io::IOException(ex.Message); // TODO:
1119 }
1120 }
1121
1122 SAL_WARN_IF( !xResultStream.is(), "package.xstor", "In case stream can not be retrieved an exception must be thrown!" );
1123
1124 return xResultStream;
1125 }
1126
1127 uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMode, bool bHierarchyAccess )
1128 {
1129 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
1130
1131 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "No package stream is set!" );
1132
1133 if ( m_pAntiImpl )
1134 throw io::IOException(); // TODO:
1135
1136 uno::Reference< io::XStream > xResultStream;
1137
1138 if ( IsEncrypted() )
1139 {
1140 ::comphelper::SequenceAsHashMap aGlobalEncryptionData;
1141 try
1142 {
1143 aGlobalEncryptionData = GetCommonRootEncryptionData();
1144 }
1145 catch( const packages::NoEncryptionException& )
1146 {
1147 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
1148 throw packages::WrongPasswordException();
1149 }
1150
1151 xResultStream = GetStream( nStreamMode, aGlobalEncryptionData, bHierarchyAccess );
1152 }
1153 else
1154 xResultStream = GetStream_Impl( nStreamMode, bHierarchyAccess );
1155
1156 return xResultStream;
1157 }
1158
1159 uno::Reference< io::XStream > OWriteStream_Impl::GetStream_Impl( sal_Int32 nStreamMode, bool bHierarchyAccess )
1160 {
1161 // private method, no mutex is used
1162 GetStreamProperties();
1163
1164 // TODO/LATER: this info might be read later, on demand in future
1165 ReadRelInfoIfNecessary();
1166
1167 if ( ( nStreamMode & embed::ElementModes::READWRITE ) == embed::ElementModes::READ )
1168 {
1169 uno::Reference< io::XInputStream > xInStream;
1170 if ( m_xCacheStream.is() || m_oTempFile.has_value() )
1171 xInStream = GetTempFileAsInputStream(); //TODO:
1172 else
1173 xInStream = m_xPackageStream->getDataStream();
1174
1175 // The stream does not exist in the storage
1176 if ( !xInStream.is() )
1177 throw io::IOException();
1178
1179 rtl::Reference<OInputCompStream> pStream = new OInputCompStream( *this, xInStream, InsertOwnProps( m_aProps, m_bUseCommonEncryption ), m_nStorageType );
1180 m_aInputStreamsVector.push_back( pStream.get() );
1181 return pStream;
1182 }
1183 else if ( ( nStreamMode & embed::ElementModes::READWRITE ) == embed::ElementModes::SEEKABLEREAD )
1184 {
1185 if ( !m_xCacheStream.is() && !m_oTempFile.has_value() && !( m_xPackageStream->getDataStream().is() ) )
1186 {
1187 // The stream does not exist in the storage
1188 throw io::IOException();
1189 }
1190
1191 uno::Reference< io::XInputStream > xInStream = GetTempFileAsInputStream(); //TODO:
1192
1193 if ( !xInStream.is() )
1194 throw io::IOException();
1195
1196 rtl::Reference<OInputSeekStream> pStream = new OInputSeekStream( *this, xInStream, InsertOwnProps( m_aProps, m_bUseCommonEncryption ), m_nStorageType );
1197 m_aInputStreamsVector.push_back( pStream.get() );
1198 return pStream;
1199 }
1200 else if ( ( nStreamMode & embed::ElementModes::WRITE ) == embed::ElementModes::WRITE )
1201 {
1202 if ( !m_aInputStreamsVector.empty() )
1203 throw io::IOException(); // TODO:
1204
1205 uno::Reference< io::XStream > xStream;
1206 if ( ( nStreamMode & embed::ElementModes::TRUNCATE ) == embed::ElementModes::TRUNCATE )
1207 {
1208 m_oTempFile.reset();
1209 if ( m_xCacheStream.is() )
1210 CleanCacheStream();
1211
1212 m_bHasDataToFlush = true;
1213
1214 // this call is triggered by the parent and it will recognize the change of the state
1215 if ( m_pParent )
1216 m_pParent->m_bIsModified = true;
1217
1218 xStream = CreateMemoryStream( m_xContext );
1219 m_xCacheSeek.set( xStream, uno::UNO_QUERY_THROW );
1220 m_xCacheStream = xStream;
1221 }
1222 else if ( !m_bHasInsertedStreamOptimization )
1223 {
1224 if ( !m_oTempFile.has_value() && !m_xCacheStream.is() && !( m_xPackageStream->getDataStream().is() ) )
1225 {
1226 // The stream does not exist in the storage
1227 m_bHasDataToFlush = true;
1228
1229 // this call is triggered by the parent and it will recognize the change of the state
1230 if ( m_pParent )
1231 m_pParent->m_bIsModified = true;
1232 xStream = GetTempFileAsStream();
1233 }
1234
1235 // if the stream exists the temporary file is created on demand
1236 // xStream = GetTempFileAsStream();
1237 }
1238
1239 rtl::Reference<OWriteStream> tmp;
1240 assert(m_xMutex.is() && "No mutex!");
1241 if ( !xStream.is() )
1242 tmp = new OWriteStream( *this, bHierarchyAccess );
1243 else
1244 tmp = new OWriteStream( *this, xStream, bHierarchyAccess );
1245
1246 m_pAntiImpl = tmp.get();
1247 return tmp;
1248 }
1249
1250 throw lang::IllegalArgumentException(); // TODO
1251 }
1252
1253 uno::Reference< io::XInputStream > OWriteStream_Impl::GetPlainRawInStream()
1254 {
1255 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
1256
1257 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "No package stream is set!" );
1258
1259 // this method is used only internally, this stream object should not go outside of this implementation
1260 // if ( m_pAntiImpl )
1261 // throw io::IOException(); // TODO:
1262
1263 return m_xPackageStream->getPlainRawStream();
1264 }
1265
1266 uno::Reference< io::XInputStream > OWriteStream_Impl::GetRawInStream()
1267 {
1268 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
1269
1270 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "No package stream is set!" );
1271
1272 if ( m_pAntiImpl )
1273 throw io::IOException(); // TODO:
1274
1275 SAL_WARN_IF( !IsEncrypted(), "package.xstor", "Impossible to get raw representation for nonencrypted stream!" );
1276 if ( !IsEncrypted() )
1277 throw packages::NoEncryptionException();
1278
1279 return m_xPackageStream->getRawStream();
1280 }
1281
1282 ::comphelper::SequenceAsHashMap OWriteStream_Impl::GetCommonRootEncryptionData()
1283 {
1284 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() ) ;
1285
1286 if ( m_nStorageType != embed::StorageFormats::PACKAGE || !m_pParent )
1287 throw packages::NoEncryptionException();
1288
1289 return m_pParent->GetCommonRootEncryptionData();
1290 }
1291
1292 void OWriteStream_Impl::InputStreamDisposed( OInputCompStream* pStream )
1293 {
1294 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() );
1295 m_aInputStreamsVector.erase(std::remove(m_aInputStreamsVector.begin(), m_aInputStreamsVector.end(), pStream ));
1296 }
1297
1298 void OWriteStream_Impl::CreateReadonlyCopyBasedOnData( const uno::Reference< io::XInputStream >& xDataToCopy, const uno::Sequence< beans::PropertyValue >& aProps, uno::Reference< io::XStream >& xTargetStream )
1299 {
1300 uno::Reference < io::XStream > xTempFile;
1301 if ( !xTargetStream.is() )
1302 xTempFile = new utl::TempFileFastService;
1303 else
1304 xTempFile = xTargetStream;
1305
1306 uno::Reference < io::XSeekable > xTempSeek( xTempFile, uno::UNO_QUERY_THROW );
1307
1308 uno::Reference < io::XOutputStream > xTempOut = xTempFile->getOutputStream();
1309 if ( !xTempOut.is() )
1310 throw uno::RuntimeException();
1311
1312 if ( xDataToCopy.is() )
1313 ::comphelper::OStorageHelper::CopyInputToOutput( xDataToCopy, xTempOut );
1314
1315 xTempOut->closeOutput();
1316 xTempSeek->seek( 0 );
1317
1318 uno::Reference< io::XInputStream > xInStream = xTempFile->getInputStream();
1319 if ( !xInStream.is() )
1320 throw io::IOException();
1321
1322 // TODO: remember last state of m_bUseCommonEncryption
1323 if ( !xTargetStream.is() )
1324 xTargetStream.set(
1325 static_cast< ::cppu::OWeakObject* >(
1326 new OInputSeekStream( xInStream, InsertOwnProps( aProps, m_bUseCommonEncryption ), m_nStorageType ) ),
1327 uno::UNO_QUERY_THROW );
1328 }
1329
1330 void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTargetStream )
1331 {
1332 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() );
1333
1334 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "The source stream for copying is incomplete!" );
1335 if ( !m_xPackageStream.is() )
1336 throw uno::RuntimeException();
1337
1338 uno::Reference< io::XInputStream > xDataToCopy;
1339 if ( IsEncrypted() )
1340 {
1341 // an encrypted stream must contain input stream
1342 ::comphelper::SequenceAsHashMap aGlobalEncryptionData;
1343 try
1344 {
1345 aGlobalEncryptionData = GetCommonRootEncryptionData();
1346 }
1347 catch( const packages::NoEncryptionException& )
1348 {
1349 TOOLS_INFO_EXCEPTION("package.xstor", "No Element");
1350 throw packages::WrongPasswordException();
1351 }
1352
1353 GetCopyOfLastCommit( xTargetStream, aGlobalEncryptionData );
1354 }
1355 else
1356 {
1357 xDataToCopy = m_xPackageStream->getDataStream();
1358
1359 // in case of new inserted package stream it is possible that input stream still was not set
1360 GetStreamProperties();
1361
1362 CreateReadonlyCopyBasedOnData( xDataToCopy, m_aProps, xTargetStream );
1363 }
1364 }
1365
1366 void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTargetStream, const ::comphelper::SequenceAsHashMap& aEncryptionData )
1367 {
1368 ::osl::MutexGuard aGuard( m_xMutex->GetMutex() );
1369
1370 SAL_WARN_IF( !m_xPackageStream.is(), "package.xstor", "The source stream for copying is incomplete!" );
1371 if ( !m_xPackageStream.is() )
1372 throw uno::RuntimeException();
1373
1374 if ( !IsEncrypted() )
1375 throw packages::NoEncryptionException();
1376
1377 uno::Reference< io::XInputStream > xDataToCopy;
1378
1379 if ( m_bHasCachedEncryptionData )
1380 {
1381 // TODO: introduce last committed cashed password information and use it here
1382 // that means "use common pass" also should be remembered on flash
1383 uno::Sequence< beans::NamedValue > aKey = aEncryptionData.getAsConstNamedValueList();
1384
1385 uno::Reference< beans::XPropertySet > xProps( m_xPackageStream, uno::UNO_QUERY_THROW );
1386
1387 bool bEncr = false;
1388 xProps->getPropertyValue( "Encrypted" ) >>= bEncr;
1389 if ( !bEncr )
1390 throw packages::NoEncryptionException();
1391
1392 uno::Sequence< beans::NamedValue > aPackKey;
1393 xProps->getPropertyValue( STORAGE_ENCRYPTION_KEYS_PROPERTY ) >>= aPackKey;
1394 if ( !SequencesEqual( aKey, aPackKey ) )
1395 throw packages::WrongPasswordException();
1396
1397 // the correct key must be set already
1398 xDataToCopy = m_xPackageStream->getDataStream();
1399 }
1400 else
1401 {
1402 uno::Reference< beans::XPropertySet > xPropertySet( m_xPackageStream, uno::UNO_QUERY );
1403 SetEncryptionKeyProperty_Impl( xPropertySet, aEncryptionData.getAsConstNamedValueList() );
1404
1405 try {
1406 xDataToCopy = m_xPackageStream->getDataStream();
1407
1408 if ( !xDataToCopy.is() )
1409 {
1410 SAL_WARN( "package.xstor", "Encrypted ZipStream must already have input stream inside!" );
1411 SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
1412 }
1413 }
1414 catch( const uno::Exception& )
1415 {
1416 TOOLS_WARN_EXCEPTION( "package.xstor", "Can't open encrypted stream");
1417 SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
1418 throw;
1419 }
1420
1421 SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
1422 }
1423
1424 // in case of new inserted package stream it is possible that input stream still was not set
1425 GetStreamProperties();
1426
1427 CreateReadonlyCopyBasedOnData( xDataToCopy, m_aProps, xTargetStream );
1428 }
1429
1430 void OWriteStream_Impl::CommitStreamRelInfo( const uno::Reference< embed::XStorage >& xRelStorage, std::u16string_view aOrigStreamName, std::u16string_view aNewStreamName )
1431 {
1432 // at this point of time the old stream must be already cleaned
1433 OSL_ENSURE( m_nStorageType == embed::StorageFormats::OFOPXML, "The method should be used only with OFOPXML format!" );
1434
1435 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
1436 return;
1437
1438 OSL_ENSURE( !aOrigStreamName.empty() && !aNewStreamName.empty() && xRelStorage.is(),
1439 "Wrong relation persistence information is provided!" );
1440
1441 if ( !xRelStorage.is() || aOrigStreamName.empty() || aNewStreamName.empty() )
1442 throw uno::RuntimeException();
1443
1444 if ( m_nRelInfoStatus == RELINFO_BROKEN || m_nRelInfoStatus == RELINFO_CHANGED_BROKEN )
1445 throw io::IOException(); // TODO:
1446
1447 OUString aOrigRelStreamName = OUString::Concat(aOrigStreamName) + ".rels";
1448 OUString aNewRelStreamName = OUString::Concat(aNewStreamName) + ".rels";
1449
1450 bool bRenamed = aOrigRelStreamName != aNewRelStreamName;
1451 if ( m_nRelInfoStatus == RELINFO_CHANGED
1452 || m_nRelInfoStatus == RELINFO_CHANGED_STREAM_READ
1453 || m_nRelInfoStatus == RELINFO_CHANGED_STREAM )
1454 {
1455 if ( bRenamed && xRelStorage->hasByName( aOrigRelStreamName ) )
1456 xRelStorage->removeElement( aOrigRelStreamName );
1457
1458 if ( m_nRelInfoStatus == RELINFO_CHANGED )
1459 {
1460 if ( m_aNewRelInfo.hasElements() )
1461 {
1462 uno::Reference< io::XStream > xRelsStream =
1463 xRelStorage->openStreamElement( aNewRelStreamName,
1464 embed::ElementModes::TRUNCATE | embed::ElementModes::READWRITE );
1465
1466 uno::Reference< io::XOutputStream > xOutStream = xRelsStream->getOutputStream();
1467 if ( !xOutStream.is() )
1468 throw uno::RuntimeException();
1469
1470 ::comphelper::OFOPXMLHelper::WriteRelationsInfoSequence( xOutStream, m_aNewRelInfo, m_xContext );
1471
1472 // set the mediatype
1473 uno::Reference< beans::XPropertySet > xPropSet( xRelsStream, uno::UNO_QUERY_THROW );
1474 xPropSet->setPropertyValue(
1475 "MediaType",
1476 uno::Any( OUString("application/vnd.openxmlformats-package.relationships+xml" ) ) );
1477
1478 m_nRelInfoStatus = RELINFO_READ;
1479 }
1480 }
1481 else if ( m_nRelInfoStatus == RELINFO_CHANGED_STREAM_READ
1482 || m_nRelInfoStatus == RELINFO_CHANGED_STREAM )
1483 {
1484 uno::Reference< io::XStream > xRelsStream =
1485 xRelStorage->openStreamElement( aNewRelStreamName,
1486 embed::ElementModes::TRUNCATE | embed::ElementModes::READWRITE );
1487
1488 uno::Reference< io::XOutputStream > xOutputStream = xRelsStream->getOutputStream();
1489 if ( !xOutputStream.is() )
1490 throw uno::RuntimeException();
1491
1492 uno::Reference< io::XSeekable > xSeek( m_xNewRelInfoStream, uno::UNO_QUERY_THROW );
1493 xSeek->seek( 0 );
1494 ::comphelper::OStorageHelper::CopyInputToOutput( m_xNewRelInfoStream, xOutputStream );
1495 xSeek->seek( 0 );
1496
1497 // set the mediatype
1498 uno::Reference< beans::XPropertySet > xPropSet( xRelsStream, uno::UNO_QUERY_THROW );
1499 xPropSet->setPropertyValue("MediaType",
1500 uno::Any( OUString("application/vnd.openxmlformats-package.relationships+xml" ) ) );
1501
1502 if ( m_nRelInfoStatus == RELINFO_CHANGED_STREAM )
1503 m_nRelInfoStatus = RELINFO_NO_INIT;
1504 else
1505 {
1506 // the information is already parsed and the stream is stored, no need in temporary stream any more
1507 m_xNewRelInfoStream.clear();
1508 m_nRelInfoStatus = RELINFO_READ;
1509 }
1510 }
1511
1512 // the original stream makes no sense after this step
1513 m_xOrigRelInfoStream = m_xNewRelInfoStream;
1514 m_aOrigRelInfo = m_aNewRelInfo;
1515 m_bOrigRelInfoBroken = false;
1516 m_aNewRelInfo = uno::Sequence< uno::Sequence< beans::StringPair > >();
1517 m_xNewRelInfoStream.clear();
1518 }
1519 else
1520 {
1521 // the stream is not changed but it might be renamed
1522 if ( bRenamed && xRelStorage->hasByName( aOrigRelStreamName ) )
1523 xRelStorage->renameElement( aOrigRelStreamName, aNewRelStreamName );
1524 }
1525 }
1526
1527 // OWriteStream implementation
1528
1529 OWriteStream::OWriteStream( OWriteStream_Impl& rImpl, bool bTransacted )
1530 : m_pImpl( &rImpl )
1531 , m_xSharedMutex( rImpl.m_xMutex )
1532 , m_aListenersContainer( rImpl.m_xMutex->GetMutex() )
1533 , m_nStorageType( m_pImpl->m_nStorageType )
1534 , m_bInStreamDisconnected( false )
1535 , m_bInitOnDemand( true )
1536 , m_nInitPosition( 0 )
1537 , m_bTransacted( bTransacted )
1538 {
1539 }
1540
1541 OWriteStream::OWriteStream( OWriteStream_Impl& rImpl, uno::Reference< io::XStream > const & xStream, bool bTransacted )
1542 : m_pImpl( &rImpl )
1543 , m_xSharedMutex( rImpl.m_xMutex )
1544 , m_aListenersContainer( rImpl.m_xMutex->GetMutex() )
1545 , m_nStorageType( m_pImpl->m_nStorageType )
1546 , m_bInStreamDisconnected( false )
1547 , m_bInitOnDemand( false )
1548 , m_nInitPosition( 0 )
1549 , m_bTransacted( bTransacted )
1550 {
1551 if ( xStream.is() )
1552 {
1553 m_xInStream = xStream->getInputStream();
1554 m_xOutStream = xStream->getOutputStream();
1555 m_xSeekable.set( xStream, uno::UNO_QUERY );
1556 OSL_ENSURE( m_xInStream.is() && m_xOutStream.is() && m_xSeekable.is(), "Stream implementation is incomplete!" );
1557 }
1558 }
1559
1560 OWriteStream::~OWriteStream()
1561 {
1562 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1563 if ( m_pImpl )
1564 {
1565 osl_atomic_increment(&m_refCount);
1566 try {
1567 dispose();
1568 }
1569 catch( const uno::RuntimeException& )
1570 {
1571 TOOLS_INFO_EXCEPTION("package.xstor", "Quiet exception");
1572 }
1573 }
1574 }
1575
1576 void OWriteStream::DeInit()
1577 {
1578 if ( !m_pImpl )
1579 return; // do nothing
1580
1581 if ( m_xSeekable.is() )
1582 m_nInitPosition = m_xSeekable->getPosition();
1583
1584 m_xInStream.clear();
1585 m_xOutStream.clear();
1586 m_xSeekable.clear();
1587 m_bInitOnDemand = true;
1588 }
1589
1590 void OWriteStream::CheckInitOnDemand()
1591 {
1592 if ( !m_pImpl )
1593 {
1594 SAL_INFO("package.xstor", "Disposed!");
1595 throw lang::DisposedException();
1596 }
1597
1598 if ( !m_bInitOnDemand )
1599 return;
1600
1601 SAL_INFO( "package.xstor", "package (mv76033) OWriteStream::CheckInitOnDemand, initializing" );
1602 uno::Reference< io::XStream > xStream = m_pImpl->GetTempFileAsStream();
1603 if ( xStream.is() )
1604 {
1605 m_xInStream.set( xStream->getInputStream(), uno::UNO_SET_THROW );
1606 m_xOutStream.set( xStream->getOutputStream(), uno::UNO_SET_THROW );
1607 m_xSeekable.set( xStream, uno::UNO_QUERY_THROW );
1608 m_xSeekable->seek( m_nInitPosition );
1609
1610 m_nInitPosition = 0;
1611 m_bInitOnDemand = false;
1612 }
1613 }
1614
1615 void OWriteStream::CopyToStreamInternally_Impl( const uno::Reference< io::XStream >& xDest )
1616 {
1617 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1618
1619 CheckInitOnDemand();
1620
1621 if ( !m_xInStream.is() )
1622 throw uno::RuntimeException();
1623
1624 if ( !m_xSeekable.is() )
1625 throw uno::RuntimeException();
1626
1627 uno::Reference< beans::XPropertySet > xDestProps( xDest, uno::UNO_QUERY_THROW );
1628
1629 uno::Reference< io::XOutputStream > xDestOutStream = xDest->getOutputStream();
1630 if ( !xDestOutStream.is() )
1631 throw io::IOException(); // TODO
1632
1633 sal_Int64 nCurPos = m_xSeekable->getPosition();
1634 m_xSeekable->seek( 0 );
1635
1636 uno::Exception eThrown;
1637 bool bThrown = false;
1638 try {
1639 ::comphelper::OStorageHelper::CopyInputToOutput( m_xInStream, xDestOutStream );
1640 }
1641 catch ( const uno::Exception& e )
1642 {
1643 eThrown = e;
1644 bThrown = true;
1645 }
1646
1647 // position-related section below is critical
1648 // if it fails the stream will become invalid
1649 try {
1650 m_xSeekable->seek( nCurPos );
1651 }
1652 catch ( const uno::Exception& )
1653 {
1654 // TODO: set the stream in invalid state or dispose
1655 TOOLS_WARN_EXCEPTION( "package.xstor", "The stream become invalid during copying" );
1656 throw uno::RuntimeException();
1657 }
1658
1659 if ( bThrown )
1660 throw eThrown;
1661
1662 // now the properties can be copied
1663 // the order of the properties setting is not important for StorageStream API
1664 OUString aPropName ("Compressed");
1665 xDestProps->setPropertyValue( aPropName, getPropertyValue( aPropName ) );
1666 if ( m_nStorageType == embed::StorageFormats::PACKAGE || m_nStorageType == embed::StorageFormats::OFOPXML )
1667 {
1668 aPropName = "MediaType";
1669 xDestProps->setPropertyValue( aPropName, getPropertyValue( aPropName ) );
1670
1671 if ( m_nStorageType == embed::StorageFormats::PACKAGE )
1672 {
1673 aPropName = "UseCommonStoragePasswordEncryption";
1674 xDestProps->setPropertyValue( aPropName, getPropertyValue( aPropName ) );
1675 }
1676 }
1677 }
1678
1679 void OWriteStream::ModifyParentUnlockMutex_Impl(osl::ClearableMutexGuard& aGuard)
1680 {
1681 if ( m_pImpl->m_pParent )
1682 {
1683 if ( m_pImpl->m_pParent->HasModifiedListener() )
1684 {
1685 uno::Reference< util::XModifiable > xParentModif( static_cast<util::XModifiable*>(m_pImpl->m_pParent->m_pAntiImpl) );
1686 aGuard.clear();
1687 xParentModif->setModified( true );
1688 }
1689 else
1690 m_pImpl->m_pParent->m_bIsModified = true;
1691 }
1692 }
1693
1694 uno::Any SAL_CALL OWriteStream::queryInterface( const uno::Type& rType )
1695 {
1696 // common interfaces
1697 uno::Any aReturn = ::cppu::queryInterface
1698 ( rType
1699 , static_cast<lang::XTypeProvider*> ( this )
1700 , static_cast<io::XInputStream*> ( this )
1701 , static_cast<io::XOutputStream*> ( this )
1702 , static_cast<io::XStream*> ( this )
1703 , static_cast<embed::XExtendedStorageStream*> ( this )
1704 , static_cast<io::XSeekable*> ( this )
1705 , static_cast<io::XTruncate*> ( this )
1706 , static_cast<lang::XComponent*> ( this )
1707 , static_cast<beans::XPropertySet*> ( this ) );
1708
1709 if ( aReturn.hasValue() )
1710 return aReturn ;
1711
1712 if ( m_nStorageType == embed::StorageFormats::PACKAGE )
1713 {
1714 aReturn = ::cppu::queryInterface
1715 ( rType
1716 , static_cast<embed::XEncryptionProtectedSource2*> ( this )
1717 , static_cast<embed::XEncryptionProtectedSource*> ( this ) );
1718 }
1719 else if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1720 {
1721 aReturn = ::cppu::queryInterface
1722 ( rType
1723 , static_cast<embed::XRelationshipAccess*> ( this ) );
1724 }
1725
1726 if ( aReturn.hasValue() )
1727 return aReturn ;
1728
1729 if ( m_bTransacted )
1730 {
1731 aReturn = ::cppu::queryInterface
1732 ( rType
1733 , static_cast<embed::XTransactedObject*> ( this )
1734 , static_cast<embed::XTransactionBroadcaster*> ( this ) );
1735
1736 if ( aReturn.hasValue() )
1737 return aReturn ;
1738 }
1739
1740 return OWeakObject::queryInterface( rType );
1741 }
1742
1743 void SAL_CALL OWriteStream::acquire() noexcept
1744 {
1745 OWeakObject::acquire();
1746 }
1747
1748 void SAL_CALL OWriteStream::release() noexcept
1749 {
1750 OWeakObject::release();
1751 }
1752
1753 uno::Sequence< uno::Type > SAL_CALL OWriteStream::getTypes()
1754 {
1755 if (! m_oTypeCollection)
1756 {
1757 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1758
1759 if (! m_oTypeCollection)
1760 {
1761 if ( m_bTransacted )
1762 {
1763 if ( m_nStorageType == embed::StorageFormats::PACKAGE )
1764 {
1765 ::cppu::OTypeCollection aTmpCollection
1766 ( cppu::UnoType<lang::XTypeProvider>::get()
1767 , cppu::UnoType<io::XInputStream>::get()
1768 , cppu::UnoType<io::XOutputStream>::get()
1769 , cppu::UnoType<io::XStream>::get()
1770 , cppu::UnoType<io::XSeekable>::get()
1771 , cppu::UnoType<io::XTruncate>::get()
1772 , cppu::UnoType<lang::XComponent>::get()
1773 , cppu::UnoType<embed::XEncryptionProtectedSource2>::get()
1774 , cppu::UnoType<embed::XEncryptionProtectedSource>::get()
1775 , cppu::UnoType<embed::XExtendedStorageStream>::get()
1776 , cppu::UnoType<embed::XTransactedObject>::get()
1777 , cppu::UnoType<embed::XTransactionBroadcaster>::get());
1778
1779 m_oTypeCollection.emplace(
1780 cppu::UnoType<beans::XPropertySet>::get()
1781 , aTmpCollection.getTypes());
1782 }
1783 else if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1784 {
1785 m_oTypeCollection.emplace(
1786 cppu::UnoType<lang::XTypeProvider>::get()
1787 , cppu::UnoType<io::XInputStream>::get()
1788 , cppu::UnoType<io::XOutputStream>::get()
1789 , cppu::UnoType<io::XStream>::get()
1790 , cppu::UnoType<io::XSeekable>::get()
1791 , cppu::UnoType<io::XTruncate>::get()
1792 , cppu::UnoType<lang::XComponent>::get()
1793 , cppu::UnoType<embed::XRelationshipAccess>::get()
1794 , cppu::UnoType<embed::XExtendedStorageStream>::get()
1795 , cppu::UnoType<embed::XTransactedObject>::get()
1796 , cppu::UnoType<embed::XTransactionBroadcaster>::get()
1797 , cppu::UnoType<beans::XPropertySet>::get());
1798 }
1799 else // if ( m_pData->m_nStorageType == embed::StorageFormats::ZIP )
1800 {
1801 m_oTypeCollection.emplace(
1802 cppu::UnoType<lang::XTypeProvider>::get()
1803 , cppu::UnoType<io::XInputStream>::get()
1804 , cppu::UnoType<io::XOutputStream>::get()
1805 , cppu::UnoType<io::XStream>::get()
1806 , cppu::UnoType<io::XSeekable>::get()
1807 , cppu::UnoType<io::XTruncate>::get()
1808 , cppu::UnoType<lang::XComponent>::get()
1809 , cppu::UnoType<embed::XExtendedStorageStream>::get()
1810 , cppu::UnoType<embed::XTransactedObject>::get()
1811 , cppu::UnoType<embed::XTransactionBroadcaster>::get()
1812 , cppu::UnoType<beans::XPropertySet>::get());
1813 }
1814 }
1815 else
1816 {
1817 if ( m_nStorageType == embed::StorageFormats::PACKAGE )
1818 {
1819 m_oTypeCollection.emplace(
1820 cppu::UnoType<lang::XTypeProvider>::get()
1821 , cppu::UnoType<io::XInputStream>::get()
1822 , cppu::UnoType<io::XOutputStream>::get()
1823 , cppu::UnoType<io::XStream>::get()
1824 , cppu::UnoType<io::XSeekable>::get()
1825 , cppu::UnoType<io::XTruncate>::get()
1826 , cppu::UnoType<lang::XComponent>::get()
1827 , cppu::UnoType<embed::XEncryptionProtectedSource2>::get()
1828 , cppu::UnoType<embed::XEncryptionProtectedSource>::get()
1829 , cppu::UnoType<beans::XPropertySet>::get());
1830 }
1831 else if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1832 {
1833 m_oTypeCollection.emplace(
1834 cppu::UnoType<lang::XTypeProvider>::get()
1835 , cppu::UnoType<io::XInputStream>::get()
1836 , cppu::UnoType<io::XOutputStream>::get()
1837 , cppu::UnoType<io::XStream>::get()
1838 , cppu::UnoType<io::XSeekable>::get()
1839 , cppu::UnoType<io::XTruncate>::get()
1840 , cppu::UnoType<lang::XComponent>::get()
1841 , cppu::UnoType<embed::XRelationshipAccess>::get()
1842 , cppu::UnoType<beans::XPropertySet>::get());
1843 }
1844 else // if ( m_pData->m_nStorageType == embed::StorageFormats::ZIP )
1845 {
1846 m_oTypeCollection.emplace(
1847 cppu::UnoType<lang::XTypeProvider>::get()
1848 , cppu::UnoType<io::XInputStream>::get()
1849 , cppu::UnoType<io::XOutputStream>::get()
1850 , cppu::UnoType<io::XStream>::get()
1851 , cppu::UnoType<io::XSeekable>::get()
1852 , cppu::UnoType<io::XTruncate>::get()
1853 , cppu::UnoType<lang::XComponent>::get()
1854 , cppu::UnoType<beans::XPropertySet>::get());
1855 }
1856 }
1857 }
1858 }
1859
1860 return m_oTypeCollection->getTypes() ;
1861 }
1862
1863 uno::Sequence< sal_Int8 > SAL_CALL OWriteStream::getImplementationId()
1864 {
1865 static const comphelper::UnoIdInit lcl_ImplId;
1866 return lcl_ImplId.getSeq();
1867 }
1868
1869 sal_Int32 SAL_CALL OWriteStream::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
1870 {
1871 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1872
1873 CheckInitOnDemand();
1874
1875 if ( !m_pImpl )
1876 {
1877 SAL_INFO("package.xstor", "Disposed!");
1878 throw lang::DisposedException();
1879 }
1880
1881 if ( !m_xInStream.is() )
1882 throw io::NotConnectedException();
1883
1884 return m_xInStream->readBytes( aData, nBytesToRead );
1885 }
1886
1887 sal_Int32 SAL_CALL OWriteStream::readSomeBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
1888 {
1889 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1890
1891 CheckInitOnDemand();
1892
1893 if ( !m_pImpl )
1894 {
1895 SAL_INFO("package.xstor", "Disposed!");
1896 throw lang::DisposedException();
1897 }
1898
1899 if ( !m_xInStream.is() )
1900 throw io::NotConnectedException();
1901
1902 return m_xInStream->readSomeBytes( aData, nMaxBytesToRead );
1903 }
1904
1905 void SAL_CALL OWriteStream::skipBytes( sal_Int32 nBytesToSkip )
1906 {
1907 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1908
1909 CheckInitOnDemand();
1910
1911 if ( !m_pImpl )
1912 {
1913 SAL_INFO("package.xstor", "Disposed!");
1914 throw lang::DisposedException();
1915 }
1916
1917 if ( !m_xInStream.is() )
1918 throw io::NotConnectedException();
1919
1920 m_xInStream->skipBytes( nBytesToSkip );
1921 }
1922
1923 sal_Int32 SAL_CALL OWriteStream::available( )
1924 {
1925 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1926
1927 CheckInitOnDemand();
1928
1929 if ( !m_pImpl )
1930 {
1931 SAL_INFO("package.xstor", "Disposed!");
1932 throw lang::DisposedException();
1933 }
1934
1935 if ( !m_xInStream.is() )
1936 throw io::NotConnectedException();
1937
1938 return m_xInStream->available();
1939
1940 }
1941
1942 void SAL_CALL OWriteStream::closeInput( )
1943 {
1944 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1945
1946 if ( !m_pImpl )
1947 {
1948 SAL_INFO("package.xstor", "Disposed!");
1949 throw lang::DisposedException();
1950 }
1951
1952 if ( !m_bInitOnDemand && ( m_bInStreamDisconnected || !m_xInStream.is() ) )
1953 throw io::NotConnectedException();
1954
1955 // the input part of the stream stays open for internal purposes (to allow reading during copying)
1956 // since it can not be reopened until output part is closed, it will be closed with output part.
1957 m_bInStreamDisconnected = true;
1958 // m_xInStream->closeInput();
1959 // m_xInStream.clear();
1960
1961 if ( !m_xOutStream.is() )
1962 dispose();
1963 }
1964
1965 uno::Reference< io::XInputStream > SAL_CALL OWriteStream::getInputStream()
1966 {
1967 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1968
1969 if ( !m_pImpl )
1970 {
1971 SAL_INFO("package.xstor", "Disposed!");
1972 throw lang::DisposedException();
1973 }
1974
1975 if ( !m_bInitOnDemand && ( m_bInStreamDisconnected || !m_xInStream.is() ) )
1976 return uno::Reference< io::XInputStream >();
1977
1978 return this;
1979 }
1980
1981 uno::Reference< io::XOutputStream > SAL_CALL OWriteStream::getOutputStream()
1982 {
1983 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
1984
1985 try
1986 {
1987 CheckInitOnDemand();
1988 }
1989 catch( const io::IOException& r )
1990 {
1991 throw lang::WrappedTargetRuntimeException("OWriteStream::getOutputStream: Could not create backing temp file",
1992 static_cast < OWeakObject * > ( this ), css::uno::Any ( r ) );
1993 }
1994
1995 if ( !m_pImpl )
1996 {
1997 SAL_INFO("package.xstor", "Disposed!");
1998 throw lang::DisposedException();
1999 }
2000
2001 if ( !m_xOutStream.is() )
2002 return uno::Reference< io::XOutputStream >();
2003
2004 return this;
2005 }
2006
2007 void SAL_CALL OWriteStream::writeBytes( const uno::Sequence< sal_Int8 >& aData )
2008 {
2009 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
2010
2011 // the write method makes initialization itself, since it depends from the aData length
2012 // NO CheckInitOnDemand()!
2013
2014 if ( !m_pImpl )
2015 {
2016 SAL_INFO("package.xstor", "Disposed!");
2017 throw lang::DisposedException();
2018 }
2019
2020 if ( !m_bInitOnDemand )
2021 {
2022 if ( !m_xOutStream.is() || !m_xSeekable.is())
2023 throw io::NotConnectedException();
2024
2025 if ( m_pImpl->m_xCacheStream.is() )
2026 {
2027 // check whether the cache should be turned off
2028 sal_Int64 nPos = m_xSeekable->getPosition();
2029 if ( nPos + aData.getLength() > MAX_STORCACHE_SIZE )
2030 {
2031 // disconnect the cache and copy the data to the temporary file
2032 m_xSeekable->seek( 0 );
2033
2034 // it is enough to copy the cached stream, the cache should already contain everything
2035 m_pImpl->GetFilledTempFileIfNo( m_xInStream );
2036 if ( m_pImpl->m_oTempFile.has_value() )
2037 {
2038 DeInit();
2039 // the last position is known and it is differs from the current stream position
2040 m_nInitPosition = nPos;
2041 }
2042 }
2043 }
2044 }
2045
2046 if ( m_bInitOnDemand )
2047 {
2048 SAL_INFO( "package.xstor", "package (mv76033) OWriteStream::CheckInitOnDemand, initializing" );
2049 uno::Reference< io::XStream > xStream = m_pImpl->GetTempFileAsStream();
2050 if ( xStream.is() )
2051 {
2052 m_xInStream.set( xStream->getInputStream(), uno::UNO_SET_THROW );
2053 m_xOutStream.set( xStream->getOutputStream(), uno::UNO_SET_THROW );
2054 m_xSeekable.set( xStream, uno::UNO_QUERY_THROW );
2055 m_xSeekable->seek( m_nInitPosition );
2056
2057 m_nInitPosition = 0;
2058 m_bInitOnDemand = false;
2059 }
2060 }
2061
2062 if ( !m_xOutStream.is() )
2063 throw io::NotConnectedException();
2064
2065 m_xOutStream->writeBytes( aData );
2066 m_pImpl->m_bHasDataToFlush = true;
2067
2068 ModifyParentUnlockMutex_Impl( aGuard );
2069 }
2070
2071 void OWriteStream::writeBytes( const sal_Int8* pData, sal_Int32 nBytesToWrite )
2072 {
2073 assert(nBytesToWrite >= 0);
2074
2075 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
2076
2077 // the write method makes initialization itself, since it depends from the aData length
2078 // NO CheckInitOnDemand()!
2079
2080 if ( !m_pImpl )
2081 {
2082 SAL_INFO("package.xstor", "Disposed!");
2083 throw lang::DisposedException();
2084 }
2085
2086 if ( !m_bInitOnDemand )
2087 {
2088 if ( !m_xOutStream.is() || !m_xSeekable.is())
2089 throw io::NotConnectedException();
2090
2091 if ( m_pImpl->m_xCacheStream.is() )
2092 {
2093 // check whether the cache should be turned off
2094 sal_Int64 nPos = m_xSeekable->getPosition();
2095 if ( nPos + nBytesToWrite > MAX_STORCACHE_SIZE )
2096 {
2097 // disconnect the cache and copy the data to the temporary file
2098 m_xSeekable->seek( 0 );
2099
2100 // it is enough to copy the cached stream, the cache should already contain everything
2101 m_pImpl->GetFilledTempFileIfNo( m_xInStream );
2102 if ( m_pImpl->m_oTempFile.has_value() )
2103 {
2104 DeInit();
2105 // the last position is known and it is differs from the current stream position
2106 m_nInitPosition = nPos;
2107 }
2108 }
2109 }
2110 }
2111
2112 if ( m_bInitOnDemand )
2113 {
2114 SAL_INFO( "package.xstor", "package (mv76033) OWriteStream::CheckInitOnDemand, initializing" );
2115 uno::Reference< io::XStream > xStream = m_pImpl->GetTempFileAsStream();
2116 if ( xStream.is() )
2117 {
2118 m_xInStream.set( xStream->getInputStream(), uno::UNO_SET_THROW );
2119 m_xOutStream.set( xStream->getOutputStream(), uno::UNO_SET_THROW );
2120 m_xSeekable.set( xStream, uno::UNO_QUERY_THROW );
2121 m_xSeekable->seek( m_nInitPosition );
2122
2123 m_nInitPosition = 0;
2124 m_bInitOnDemand = false;
2125 }
2126 }
2127
2128 if ( !m_xOutStream.is() )
2129 throw io::NotConnectedException();
2130
2131 if (auto pByteWriter = dynamic_cast< comphelper::ByteWriter* >( m_xOutStream.get() ))
2132 pByteWriter->writeBytes(pData, nBytesToWrite);
2133 else
2134 {
2135 uno::Sequence<sal_Int8> aData(pData, nBytesToWrite);
2136 m_xOutStream->writeBytes( aData );
2137 }
2138 m_pImpl->m_bHasDataToFlush = true;
2139
2140 ModifyParentUnlockMutex_Impl( aGuard );
2141 }
2142
2143 void SAL_CALL OWriteStream::flush()
2144 {
2145 // In case stream is flushed its current version becomes visible
2146 // to the parent storage. Usually parent storage flushes the stream
2147 // during own commit but a user can explicitly flush the stream
2148 // so the changes will be available through cloning functionality.
2149
2150 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2151
2152 if ( !m_pImpl )
2153 {
2154 SAL_INFO("package.xstor", "Disposed!");
2155 throw lang::DisposedException();
2156 }
2157
2158 if ( !m_bInitOnDemand )
2159 {
2160 if ( !m_xOutStream.is() )
2161 throw io::NotConnectedException();
2162
2163 m_xOutStream->flush();
2164 m_pImpl->Commit();
2165 }
2166 }
2167
2168 void OWriteStream::CloseOutput_Impl()
2169 {
2170 // all the checks must be done in calling method
2171
2172 m_xOutStream->closeOutput();
2173 m_xOutStream.clear();
2174
2175 if ( m_bInitOnDemand )
2176 return;
2177
2178 // after the stream is disposed it can be committed
2179 // so transport correct size property
2180 if ( !m_xSeekable.is() )
2181 throw uno::RuntimeException();
2182
2183 for ( auto& rProp : asNonConstRange(m_pImpl->m_aProps) )
2184 {
2185 if ( rProp.Name == "Size" )
2186 rProp.Value <<= m_xSeekable->getLength();
2187 }
2188 }
2189
2190 void SAL_CALL OWriteStream::closeOutput()
2191 {
2192 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2193
2194 CheckInitOnDemand();
2195
2196 if ( !m_pImpl )
2197 {
2198 SAL_INFO("package.xstor", "Disposed!");
2199 throw lang::DisposedException();
2200 }
2201
2202 if ( !m_xOutStream.is() )
2203 throw io::NotConnectedException();
2204
2205 CloseOutput_Impl();
2206
2207 if ( m_bInStreamDisconnected || !m_xInStream.is() )
2208 dispose();
2209 }
2210
2211 void SAL_CALL OWriteStream::seek( sal_Int64 location )
2212 {
2213 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2214
2215 CheckInitOnDemand();
2216
2217 if ( !m_pImpl )
2218 {
2219 SAL_INFO("package.xstor", "Disposed!");
2220 throw lang::DisposedException();
2221 }
2222
2223 if ( !m_xSeekable.is() )
2224 throw uno::RuntimeException();
2225
2226 m_xSeekable->seek( location );
2227 }
2228
2229 sal_Int64 SAL_CALL OWriteStream::getPosition()
2230 {
2231 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2232
2233 CheckInitOnDemand();
2234
2235 if ( !m_pImpl )
2236 {
2237 SAL_INFO("package.xstor", "Disposed!");
2238 throw lang::DisposedException();
2239 }
2240
2241 if ( !m_xSeekable.is() )
2242 throw uno::RuntimeException();
2243
2244 return m_xSeekable->getPosition();
2245 }
2246
2247 sal_Int64 SAL_CALL OWriteStream::getLength()
2248 {
2249 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2250
2251 CheckInitOnDemand();
2252
2253 if ( !m_pImpl )
2254 {
2255 SAL_INFO("package.xstor", "Disposed!");
2256 throw lang::DisposedException();
2257 }
2258
2259 if ( !m_xSeekable.is() )
2260 throw uno::RuntimeException();
2261
2262 return m_xSeekable->getLength();
2263 }
2264
2265 void SAL_CALL OWriteStream::truncate()
2266 {
2267 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
2268
2269 CheckInitOnDemand();
2270
2271 if ( !m_pImpl )
2272 {
2273 SAL_INFO("package.xstor", "Disposed!");
2274 throw lang::DisposedException();
2275 }
2276
2277 if ( !m_xOutStream.is() )
2278 throw uno::RuntimeException();
2279
2280 uno::Reference< io::XTruncate > xTruncate( m_xOutStream, uno::UNO_QUERY_THROW );
2281 xTruncate->truncate();
2282
2283 m_pImpl->m_bHasDataToFlush = true;
2284
2285 ModifyParentUnlockMutex_Impl( aGuard );
2286 }
2287
2288 void SAL_CALL OWriteStream::dispose()
2289 {
2290 // should be an internal method since it can be called only from parent storage
2291 {
2292 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2293
2294 if ( !m_pImpl )
2295 {
2296 SAL_INFO("package.xstor", "Disposed!");
2297 throw lang::DisposedException();
2298 }
2299
2300 if ( m_xOutStream.is() )
2301 CloseOutput_Impl();
2302
2303 if ( m_xInStream.is() )
2304 {
2305 m_xInStream->closeInput();
2306 m_xInStream.clear();
2307 }
2308
2309 m_xSeekable.clear();
2310
2311 m_pImpl->m_pAntiImpl = nullptr;
2312
2313 if ( !m_bInitOnDemand )
2314 {
2315 try
2316 {
2317 if ( !m_bTransacted )
2318 {
2319 m_pImpl->Commit();
2320 }
2321 else
2322 {
2323 // throw away all the changes
2324 m_pImpl->Revert();
2325 }
2326 }
2327 catch( const uno::Exception& )
2328 {
2329 uno::Any aCaught( ::cppu::getCaughtException() );
2330 SAL_INFO("package.xstor", "Rethrow: " << exceptionToString(aCaught));
2331 throw lang::WrappedTargetRuntimeException("Can not commit/revert the storage!",
2332 static_cast< OWeakObject* >( this ),
2333 aCaught );
2334 }
2335 }
2336
2337 m_pImpl = nullptr;
2338 }
2339
2340 // the listener might try to get rid of parent storage, and the storage would delete this object;
2341 // for now the listener is just notified at the end of the method to workaround the problem
2342 // in future a more elegant way should be found
2343
2344 lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
2345 m_aListenersContainer.disposeAndClear( aSource );
2346 }
2347
2348 void SAL_CALL OWriteStream::addEventListener(
2349 const uno::Reference< lang::XEventListener >& xListener )
2350 {
2351 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2352
2353 if ( !m_pImpl )
2354 {
2355 SAL_INFO("package.xstor", "Disposed!");
2356 throw lang::DisposedException();
2357 }
2358
2359 m_aListenersContainer.addInterface( cppu::UnoType<lang::XEventListener>::get(),
2360 xListener );
2361 }
2362
2363 void SAL_CALL OWriteStream::removeEventListener(
2364 const uno::Reference< lang::XEventListener >& xListener )
2365 {
2366 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2367
2368 if ( !m_pImpl )
2369 {
2370 SAL_INFO("package.xstor", "Disposed!");
2371 throw lang::DisposedException();
2372 }
2373
2374 m_aListenersContainer.removeInterface( cppu::UnoType<lang::XEventListener>::get(),
2375 xListener );
2376 }
2377
2378 void SAL_CALL OWriteStream::setEncryptionPassword( const OUString& aPass )
2379 {
2380 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
2381
2382 CheckInitOnDemand();
2383
2384 if ( !m_pImpl )
2385 {
2386 SAL_INFO("package.xstor", "Disposed!");
2387 throw lang::DisposedException();
2388 }
2389
2390 OSL_ENSURE( m_pImpl->m_xPackageStream.is(), "No package stream is set!" );
2391
2392 m_pImpl->SetEncrypted( ::comphelper::OStorageHelper::CreatePackageEncryptionData( aPass ) );
2393
2394 ModifyParentUnlockMutex_Impl( aGuard );
2395 }
2396
2397 void SAL_CALL OWriteStream::removeEncryption()
2398 {
2399 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
2400
2401 CheckInitOnDemand();
2402
2403 if ( !m_pImpl )
2404 {
2405 SAL_INFO("package.xstor", "Disposed!");
2406 throw lang::DisposedException();
2407 }
2408
2409 OSL_ENSURE( m_pImpl->m_xPackageStream.is(), "No package stream is set!" );
2410
2411 m_pImpl->SetDecrypted();
2412
2413 ModifyParentUnlockMutex_Impl( aGuard );
2414 }
2415
2416 void SAL_CALL OWriteStream::setEncryptionData( const uno::Sequence< beans::NamedValue >& aEncryptionData )
2417 {
2418 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
2419
2420 CheckInitOnDemand();
2421
2422 if ( !m_pImpl )
2423 {
2424 SAL_INFO("package.xstor", "Disposed!");
2425 throw lang::DisposedException();
2426 }
2427
2428 OSL_ENSURE( m_pImpl->m_xPackageStream.is(), "No package stream is set!" );
2429
2430 m_pImpl->SetEncrypted( aEncryptionData );
2431
2432 ModifyParentUnlockMutex_Impl( aGuard );
2433 }
2434
2435 sal_Bool SAL_CALL OWriteStream::hasEncryptionData()
2436 {
2437 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
2438
2439 if (!m_pImpl)
2440 return false;
2441
2442 bool bRet = false;
2443
2444 try
2445 {
2446 bRet = m_pImpl->IsEncrypted();
2447
2448 if (!bRet && m_pImpl->m_bUseCommonEncryption && m_pImpl->m_pParent)
2449 bRet = m_pImpl->m_pParent->m_bHasCommonEncryptionData;
2450 }
2451 catch( const uno::RuntimeException& )
2452 {
2453 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
2454 throw;
2455 }
2456 catch( const uno::Exception& )
2457 {
2458 uno::Any aCaught( ::cppu::getCaughtException() );
2459 SAL_INFO("package.xstor", "Rethrow: " << exceptionToString(aCaught));
2460 throw lang::WrappedTargetRuntimeException( "Problems on hasEncryptionData!",
2461 static_cast< ::cppu::OWeakObject* >( this ),
2462 aCaught );
2463 }
2464
2465 return bRet;
2466 }
2467
2468 sal_Bool SAL_CALL OWriteStream::hasByID( const OUString& sID )
2469 {
2470 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2471
2472 if ( !m_pImpl )
2473 {
2474 SAL_INFO("package.xstor", "Disposed!");
2475 throw lang::DisposedException();
2476 }
2477
2478 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2479 throw uno::RuntimeException();
2480
2481 try
2482 {
2483 getRelationshipByID( sID );
2484 return true;
2485 }
2486 catch( const container::NoSuchElementException& )
2487 {
2488 TOOLS_INFO_EXCEPTION("package.xstor", "No Element");
2489 }
2490
2491 return false;
2492 }
2493
2494 OUString SAL_CALL OWriteStream::getTargetByID( const OUString& sID )
2495 {
2496 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2497
2498 if ( !m_pImpl )
2499 {
2500 SAL_INFO("package.xstor", "Disposed!");
2501 throw lang::DisposedException();
2502 }
2503
2504 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2505 throw uno::RuntimeException();
2506
2507 const uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
2508 auto pRel = lcl_findPairByName(aSeq, "Target");
2509 if (pRel != aSeq.end())
2510 return pRel->Second;
2511
2512 return OUString();
2513 }
2514
2515 OUString SAL_CALL OWriteStream::getTypeByID( const OUString& sID )
2516 {
2517 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2518
2519 if ( !m_pImpl )
2520 {
2521 SAL_INFO("package.xstor", "Disposed!");
2522 throw lang::DisposedException();
2523 }
2524
2525 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2526 throw uno::RuntimeException();
2527
2528 const uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
2529 auto pRel = lcl_findPairByName(aSeq, "Type");
2530 if (pRel != aSeq.end())
2531 return pRel->Second;
2532
2533 return OUString();
2534 }
2535
2536 uno::Sequence< beans::StringPair > SAL_CALL OWriteStream::getRelationshipByID( const OUString& sID )
2537 {
2538 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2539
2540 if ( !m_pImpl )
2541 {
2542 SAL_INFO("package.xstor", "Disposed!");
2543 throw lang::DisposedException();
2544 }
2545
2546 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2547 throw uno::RuntimeException();
2548
2549 // TODO/LATER: in future the unification of the ID could be checked
2550 const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
2551 const beans::StringPair aIDRel("Id", sID);
2552 auto pRel = std::find_if(aSeq.begin(), aSeq.end(),
2553 [&aIDRel](const uno::Sequence<beans::StringPair>& rRel) {
2554 return std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end(); });
2555 if (pRel != aSeq.end())
2556 return *pRel;
2557
2558 throw container::NoSuchElementException();
2559 }
2560
2561 uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OWriteStream::getRelationshipsByType( const OUString& sType )
2562 {
2563 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2564
2565 if ( !m_pImpl )
2566 {
2567 SAL_INFO("package.xstor", "Disposed!");
2568 throw lang::DisposedException();
2569 }
2570
2571 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2572 throw uno::RuntimeException();
2573
2574 // TODO/LATER: in future the unification of the ID could be checked
2575 const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
2576 const beans::StringPair aTypeRel("Type", sType);
2577 std::vector< uno::Sequence<beans::StringPair> > aResult;
2578 aResult.reserve(aSeq.getLength());
2579
2580 std::copy_if(aSeq.begin(), aSeq.end(), std::back_inserter(aResult),
2581 [&aTypeRel](const uno::Sequence<beans::StringPair>& rRel) {
2582 return std::find(rRel.begin(), rRel.end(), aTypeRel) != rRel.end(); });
2583
2584 return comphelper::containerToSequence(aResult);
2585 }
2586
2587 uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OWriteStream::getAllRelationships()
2588 {
2589 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2590
2591 if ( !m_pImpl )
2592 {
2593 SAL_INFO("package.xstor", "Disposed!");
2594 throw lang::DisposedException();
2595 }
2596
2597 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2598 throw uno::RuntimeException();
2599
2600 return m_pImpl->GetAllRelationshipsIfAny();
2601 }
2602
2603 void SAL_CALL OWriteStream::insertRelationshipByID( const OUString& sID, const uno::Sequence< beans::StringPair >& aEntry, sal_Bool bReplace )
2604 {
2605 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2606
2607 if ( !m_pImpl )
2608 {
2609 SAL_INFO("package.xstor", "Disposed!");
2610 throw lang::DisposedException();
2611 }
2612
2613 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2614 throw uno::RuntimeException();
2615
2616 const beans::StringPair aIDRel("Id", sID);
2617
2618 uno::Sequence<beans::StringPair>* pPair = nullptr;
2619
2620 // TODO/LATER: in future the unification of the ID could be checked
2621 uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
2622 for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
2623 {
2624 const auto& rRel = aSeq[nInd];
2625 if (std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end())
2626 pPair = &aSeq.getArray()[nInd];
2627 }
2628
2629 if ( pPair && !bReplace )
2630 throw container::ElementExistException(); // TODO
2631
2632 if ( !pPair )
2633 {
2634 sal_Int32 nIDInd = aSeq.getLength();
2635 aSeq.realloc( nIDInd + 1 );
2636 pPair = &aSeq.getArray()[nIDInd];
2637 }
2638
2639 std::vector<beans::StringPair> aResult;
2640 aResult.reserve(aEntry.getLength() + 1);
2641
2642 aResult.push_back(aIDRel);
2643 std::copy_if(aEntry.begin(), aEntry.end(), std::back_inserter(aResult),
2644 [](const beans::StringPair& rRel) { return rRel.First != "Id"; });
2645
2646 *pPair = comphelper::containerToSequence(aResult);
2647
2648 m_pImpl->m_aNewRelInfo = aSeq;
2649 m_pImpl->m_xNewRelInfoStream.clear();
2650 m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
2651 }
2652
2653 void SAL_CALL OWriteStream::removeRelationshipByID( const OUString& sID )
2654 {
2655 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2656
2657 if ( !m_pImpl )
2658 {
2659 SAL_INFO("package.xstor", "Disposed!");
2660 throw lang::DisposedException();
2661 }
2662
2663 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2664 throw uno::RuntimeException();
2665
2666 uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
2667 const beans::StringPair aIDRel("Id", sID);
2668 auto pRel = std::find_if(std::cbegin(aSeq), std::cend(aSeq),
2669 [&aIDRel](const uno::Sequence< beans::StringPair >& rRel) {
2670 return std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end(); });
2671 if (pRel != std::cend(aSeq))
2672 {
2673 auto nInd = static_cast<sal_Int32>(std::distance(std::cbegin(aSeq), pRel));
2674 comphelper::removeElementAt(aSeq, nInd);
2675
2676 m_pImpl->m_aNewRelInfo = aSeq;
2677 m_pImpl->m_xNewRelInfoStream.clear();
2678 m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
2679
2680 // TODO/LATER: in future the unification of the ID could be checked
2681 return;
2682 }
2683
2684 throw container::NoSuchElementException();
2685 }
2686
2687 void SAL_CALL OWriteStream::insertRelationships( const uno::Sequence< uno::Sequence< beans::StringPair > >& aEntries, sal_Bool bReplace )
2688 {
2689 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2690
2691 if ( !m_pImpl )
2692 {
2693 SAL_INFO("package.xstor", "Disposed!");
2694 throw lang::DisposedException();
2695 }
2696
2697 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2698 throw uno::RuntimeException();
2699
2700 OUString aIDTag( "Id" );
2701 const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
2702 std::vector< uno::Sequence<beans::StringPair> > aResultVec;
2703 aResultVec.reserve(aSeq.getLength() + aEntries.getLength());
2704
2705 std::copy_if(aSeq.begin(), aSeq.end(), std::back_inserter(aResultVec),
2706 [&aIDTag, &aEntries, bReplace](const uno::Sequence<beans::StringPair>& rTargetRel) {
2707 auto pTargetPair = lcl_findPairByName(rTargetRel, aIDTag);
2708 if (pTargetPair == rTargetRel.end())
2709 return false;
2710
2711 bool bIsSourceSame = std::any_of(aEntries.begin(), aEntries.end(),
2712 [&pTargetPair](const uno::Sequence<beans::StringPair>& rSourceEntry) {
2713 return std::find(rSourceEntry.begin(), rSourceEntry.end(), *pTargetPair) != rSourceEntry.end(); });
2714
2715 if ( bIsSourceSame && !bReplace )
2716 throw container::ElementExistException();
2717
2718 // if no such element in the provided sequence
2719 return !bIsSourceSame;
2720 });
2721
2722 std::transform(aEntries.begin(), aEntries.end(), std::back_inserter(aResultVec),
2723 [&aIDTag](const uno::Sequence<beans::StringPair>& rEntry) -> uno::Sequence<beans::StringPair> {
2724 auto pPair = lcl_findPairByName(rEntry, aIDTag);
2725 if (pPair == rEntry.end())
2726 throw io::IOException(); // TODO: illegal relation ( no ID )
2727
2728 auto aResult = comphelper::sequenceToContainer<std::vector<beans::StringPair>>(rEntry);
2729 auto nIDInd = std::distance(rEntry.begin(), pPair);
2730 std::rotate(aResult.begin(), std::next(aResult.begin(), nIDInd), std::next(aResult.begin(), nIDInd + 1));
2731
2732 return comphelper::containerToSequence(aResult);
2733 });
2734
2735 m_pImpl->m_aNewRelInfo = comphelper::containerToSequence(aResultVec);
2736 m_pImpl->m_xNewRelInfoStream.clear();
2737 m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
2738 }
2739
2740 void SAL_CALL OWriteStream::clearRelationships()
2741 {
2742 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2743
2744 if ( !m_pImpl )
2745 {
2746 SAL_INFO("package.xstor", "Disposed!");
2747 throw lang::DisposedException();
2748 }
2749
2750 if ( m_nStorageType != embed::StorageFormats::OFOPXML )
2751 throw uno::RuntimeException();
2752
2753 m_pImpl->m_aNewRelInfo.realloc( 0 );
2754 m_pImpl->m_xNewRelInfoStream.clear();
2755 m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
2756 }
2757
2758 uno::Reference< beans::XPropertySetInfo > SAL_CALL OWriteStream::getPropertySetInfo()
2759 {
2760 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2761
2762 //TODO:
2763 return uno::Reference< beans::XPropertySetInfo >();
2764 }
2765
2766 void SAL_CALL OWriteStream::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
2767 {
2768 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
2769
2770 if ( !m_pImpl )
2771 {
2772 SAL_INFO("package.xstor", "Disposed!");
2773 throw lang::DisposedException();
2774 }
2775
2776 m_pImpl->GetStreamProperties();
2777 static constexpr OUStringLiteral aCompressedString( u"Compressed" );
2778 static constexpr OUStringLiteral aMediaTypeString( u"MediaType" );
2779 if ( m_nStorageType == embed::StorageFormats::PACKAGE && aPropertyName == aMediaTypeString )
2780 {
2781 // if the "Compressed" property is not set explicitly, the MediaType can change the default value
2782 bool bCompressedValueFromType = true;
2783 OUString aType;
2784 aValue >>= aType;
2785
2786 if ( !m_pImpl->m_bCompressedSetExplicit )
2787 {
2788 if ( aType == "image/jpeg" || aType == "image/png" || aType == "image/gif" )
2789 bCompressedValueFromType = false;
2790 }
2791
2792 for ( auto& rProp : asNonConstRange(m_pImpl->m_aProps) )
2793 {
2794 if ( aPropertyName == rProp.Name )
2795 rProp.Value = aValue;
2796 else if ( !m_pImpl->m_bCompressedSetExplicit && aCompressedString == rProp.Name )
2797 rProp.Value <<= bCompressedValueFromType;
2798 }
2799 }
2800 else if ( aPropertyName == aCompressedString )
2801 {
2802 // if the "Compressed" property is not set explicitly, the MediaType can change the default value
2803 m_pImpl->m_bCompressedSetExplicit = true;
2804 for ( auto& rProp : asNonConstRange(m_pImpl->m_aProps) )
2805 {
2806 if ( aPropertyName == rProp.Name )
2807 rProp.Value = aValue;
2808 }
2809 }
2810 else if ( m_nStorageType == embed::StorageFormats::PACKAGE
2811 && aPropertyName == "UseCommonStoragePasswordEncryption" )
2812 {
2813 bool bUseCommonEncryption = false;
2814 if ( !(aValue >>= bUseCommonEncryption) )
2815 throw lang::IllegalArgumentException(); //TODO
2816
2817 if ( m_bInitOnDemand && m_pImpl->m_bHasInsertedStreamOptimization )
2818 {
2819 // the data stream is provided to the packagestream directly
2820 m_pImpl->m_bUseCommonEncryption = bUseCommonEncryption;
2821 }
2822 else if ( bUseCommonEncryption )
2823 {
2824 if ( !m_pImpl->m_bUseCommonEncryption )
2825 {
2826 m_pImpl->SetDecrypted();
2827 m_pImpl->m_bUseCommonEncryption = true;
2828 }
2829 }
2830 else
2831 m_pImpl->m_bUseCommonEncryption = false;
2832 }
2833 else if ( m_nStorageType == embed::StorageFormats::OFOPXML && aPropertyName == aMediaTypeString )
2834 {
2835 for ( auto& rProp : asNonConstRange(m_pImpl->m_aProps) )
2836 {
2837 if ( aPropertyName == rProp.Name )
2838 rProp.Value = aValue;
2839 }
2840 }
2841 else if ( m_nStorageType == embed::StorageFormats::OFOPXML && aPropertyName == "RelationsInfoStream" )
2842 {
2843 uno::Reference< io::XInputStream > xInRelStream;
2844 if ( !( aValue >>= xInRelStream ) || !xInRelStream.is() )
2845 throw lang::IllegalArgumentException(); // TODO
2846
2847 uno::Reference< io::XSeekable > xSeek( xInRelStream, uno::UNO_QUERY );
2848 if ( !xSeek.is() )
2849 {
2850 // currently this is an internal property that is used for optimization
2851 // and the stream must support XSeekable interface
2852 // TODO/LATER: in future it can be changed if property is used from outside
2853 throw lang::IllegalArgumentException(); // TODO
2854 }
2855
2856 m_pImpl->m_xNewRelInfoStream = xInRelStream;
2857 m_pImpl->m_aNewRelInfo = uno::Sequence< uno::Sequence< beans::StringPair > >();
2858 m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED_STREAM;
2859 }
2860 else if ( m_nStorageType == embed::StorageFormats::OFOPXML && aPropertyName == "RelationsInfo" )
2861 {
2862 if ( !(aValue >>= m_pImpl->m_aNewRelInfo) )
2863 throw lang::IllegalArgumentException(); // TODO
2864 }
2865 else if ( aPropertyName == "Size" )
2866 throw beans::PropertyVetoException(); // TODO
2867 else if ( m_nStorageType == embed::StorageFormats::PACKAGE
2868 && ( aPropertyName == "IsEncrypted" || aPropertyName == "Encrypted" ) )
2869 throw beans::PropertyVetoException(); // TODO
2870 else if ( aPropertyName == "RelId" )
2871 {
2872 aValue >>= m_pImpl->m_nRelId;
2873 }
2874 else
2875 throw beans::UnknownPropertyException(aPropertyName); // TODO
2876
2877 m_pImpl->m_bHasDataToFlush = true;
2878 ModifyParentUnlockMutex_Impl( aGuard );
2879 }
2880
2881 uno::Any SAL_CALL OWriteStream::getPropertyValue( const OUString& aProp )
2882 {
2883 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2884
2885 if ( !m_pImpl )
2886 {
2887 SAL_INFO("package.xstor", "Disposed!");
2888 throw lang::DisposedException();
2889 }
2890
2891 if ( aProp == "RelId" )
2892 {
2893 return uno::Any( m_pImpl->GetNewRelId() );
2894 }
2895
2896 OUString aPropertyName;
2897 if ( aProp == "IsEncrypted" )
2898 aPropertyName = "Encrypted";
2899 else
2900 aPropertyName = aProp;
2901
2902 if ( ( ( m_nStorageType == embed::StorageFormats::PACKAGE || m_nStorageType == embed::StorageFormats::OFOPXML )
2903 && aPropertyName == "MediaType" )
2904 || ( m_nStorageType == embed::StorageFormats::PACKAGE && aPropertyName == "Encrypted" )
2905 || aPropertyName == "Compressed" )
2906 {
2907 m_pImpl->GetStreamProperties();
2908
2909 auto pProp = std::find_if(std::cbegin(m_pImpl->m_aProps), std::cend(m_pImpl->m_aProps),
2910 [&aPropertyName](const css::beans::PropertyValue& rProp){ return aPropertyName == rProp.Name; });
2911 if (pProp != std::cend(m_pImpl->m_aProps))
2912 return pProp->Value;
2913 }
2914 else if ( m_nStorageType == embed::StorageFormats::PACKAGE
2915 && aPropertyName == "UseCommonStoragePasswordEncryption" )
2916 return uno::Any( m_pImpl->m_bUseCommonEncryption );
2917 else if ( aPropertyName == "Size" )
2918 {
2919 bool bThrow = false;
2920 try
2921 {
2922 CheckInitOnDemand();
2923 }
2924 catch (const io::IOException&)
2925 {
2926 bThrow = true;
2927 }
2928 if (bThrow || !m_xSeekable.is())
2929 throw uno::RuntimeException();
2930
2931 return uno::Any( m_xSeekable->getLength() );
2932 }
2933
2934 throw beans::UnknownPropertyException(aPropertyName); // TODO
2935 }
2936
2937 void SAL_CALL OWriteStream::addPropertyChangeListener(
2938 const OUString& /*aPropertyName*/,
2939 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
2940 {
2941 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2942
2943 if ( !m_pImpl )
2944 {
2945 SAL_INFO("package.xstor", "Disposed!");
2946 throw lang::DisposedException();
2947 }
2948
2949 //TODO:
2950 }
2951
2952 void SAL_CALL OWriteStream::removePropertyChangeListener(
2953 const OUString& /*aPropertyName*/,
2954 const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
2955 {
2956 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2957
2958 if ( !m_pImpl )
2959 {
2960 SAL_INFO("package.xstor", "Disposed!");
2961 throw lang::DisposedException();
2962 }
2963
2964 //TODO:
2965 }
2966
2967 void SAL_CALL OWriteStream::addVetoableChangeListener(
2968 const OUString& /*PropertyName*/,
2969 const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
2970 {
2971 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2972
2973 if ( !m_pImpl )
2974 {
2975 SAL_INFO("package.xstor", "Disposed!");
2976 throw lang::DisposedException();
2977 }
2978
2979 //TODO:
2980 }
2981
2982 void SAL_CALL OWriteStream::removeVetoableChangeListener(
2983 const OUString& /*PropertyName*/,
2984 const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
2985 {
2986 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
2987
2988 if ( !m_pImpl )
2989 {
2990 SAL_INFO("package.xstor", "Disposed!");
2991 throw lang::DisposedException();
2992 }
2993
2994 //TODO:
2995 }
2996
2997 // XTransactedObject
2998
2999 void OWriteStream::BroadcastTransaction( sal_Int8 nMessage )
3000 /*
3001 1 - preCommit
3002 2 - committed
3003 3 - preRevert
3004 4 - reverted
3005 */
3006 {
3007 // no need to lock mutex here for the checking of m_pImpl, and m_pData is alive until the object is destructed
3008 if ( !m_pImpl )
3009 {
3010 SAL_INFO("package.xstor", "Disposed!");
3011 throw lang::DisposedException();
3012 }
3013
3014 lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
3015
3016 comphelper::OInterfaceContainerHelper2* pContainer =
3017 m_aListenersContainer.getContainer(
3018 cppu::UnoType<embed::XTransactionListener>::get());
3019 if ( !pContainer )
3020 return;
3021
3022 comphelper::OInterfaceIteratorHelper2 pIterator( *pContainer );
3023 while ( pIterator.hasMoreElements( ) )
3024 {
3025 OSL_ENSURE( nMessage >= 1 && nMessage <= 4, "Wrong internal notification code is used!" );
3026
3027 switch( nMessage )
3028 {
3029 case STOR_MESS_PRECOMMIT:
3030 static_cast<embed::XTransactionListener*>( pIterator.next( ) )->preCommit( aSource );
3031 break;
3032 case STOR_MESS_COMMITTED:
3033 static_cast<embed::XTransactionListener*>( pIterator.next( ) )->commited( aSource );
3034 break;
3035 case STOR_MESS_PREREVERT:
3036 static_cast<embed::XTransactionListener*>( pIterator.next( ) )->preRevert( aSource );
3037 break;
3038 case STOR_MESS_REVERTED:
3039 static_cast< embed::XTransactionListener*>( pIterator.next( ) )->reverted( aSource );
3040 break;
3041 }
3042 }
3043 }
3044 void SAL_CALL OWriteStream::commit()
3045 {
3046 SAL_INFO( "package.xstor", "package (mv76033) OWriteStream::commit" );
3047
3048 if ( !m_pImpl )
3049 {
3050 SAL_INFO("package.xstor", "Disposed!");
3051 throw lang::DisposedException();
3052 }
3053
3054 if ( !m_bTransacted )
3055 throw uno::RuntimeException();
3056
3057 try {
3058 BroadcastTransaction( STOR_MESS_PRECOMMIT );
3059
3060 osl::ClearableMutexGuard aGuard(m_xSharedMutex->GetMutex());
3061
3062 if ( !m_pImpl )
3063 {
3064 SAL_INFO("package.xstor", "Disposed!");
3065 throw lang::DisposedException();
3066 }
3067
3068 m_pImpl->Commit();
3069
3070 // when the storage is committed the parent is modified
3071 ModifyParentUnlockMutex_Impl( aGuard );
3072 }
3073 catch( const io::IOException& )
3074 {
3075 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
3076 throw;
3077 }
3078 catch( const embed::StorageWrappedTargetException& )
3079 {
3080 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
3081 throw;
3082 }
3083 catch( const uno::RuntimeException& )
3084 {
3085 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
3086 throw;
3087 }
3088 catch( const uno::Exception& )
3089 {
3090 uno::Any aCaught( ::cppu::getCaughtException() );
3091 SAL_INFO("package.xstor", "Rethrow: " << exceptionToString(aCaught));
3092 throw embed::StorageWrappedTargetException( "Problems on commit!",
3093 static_cast< ::cppu::OWeakObject* >( this ),
3094 aCaught );
3095 }
3096
3097 BroadcastTransaction( STOR_MESS_COMMITTED );
3098 }
3099
3100 void SAL_CALL OWriteStream::revert()
3101 {
3102 SAL_INFO( "package.xstor", "package (mv76033) OWriteStream::revert" );
3103
3104 // the method removes all the changes done after last commit
3105
3106 if ( !m_pImpl )
3107 {
3108 SAL_INFO("package.xstor", "Disposed!");
3109 throw lang::DisposedException();
3110 }
3111
3112 if ( !m_bTransacted )
3113 throw uno::RuntimeException();
3114
3115 BroadcastTransaction( STOR_MESS_PREREVERT );
3116
3117 {
3118 osl::MutexGuard aGuard(m_xSharedMutex->GetMutex());
3119
3120 if (!m_pImpl)
3121 {
3122 SAL_INFO("package.xstor", "Disposed!");
3123 throw lang::DisposedException();
3124 }
3125
3126 try {
3127 m_pImpl->Revert();
3128 }
3129 catch (const io::IOException&)
3130 {
3131 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
3132 throw;
3133 }
3134 catch (const embed::StorageWrappedTargetException&)
3135 {
3136 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
3137 throw;
3138 }
3139 catch (const uno::RuntimeException&)
3140 {
3141 TOOLS_INFO_EXCEPTION("package.xstor", "Rethrow");
3142 throw;
3143 }
3144 catch (const uno::Exception&)
3145 {
3146 uno::Any aCaught(::cppu::getCaughtException());
3147 SAL_INFO("package.xstor", "Rethrow: " << exceptionToString(aCaught));
3148 throw embed::StorageWrappedTargetException("Problems on revert!",
3149 static_cast<::cppu::OWeakObject*>(this),
3150 aCaught);
3151 }
3152 }
3153
3154 BroadcastTransaction( STOR_MESS_REVERTED );
3155 }
3156
3157 // XTransactionBroadcaster
3158
3159 void SAL_CALL OWriteStream::addTransactionListener( const uno::Reference< embed::XTransactionListener >& aListener )
3160 {
3161 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
3162
3163 if ( !m_pImpl )
3164 {
3165 SAL_INFO("package.xstor", "Disposed!");
3166 throw lang::DisposedException();
3167 }
3168
3169 if ( !m_bTransacted )
3170 throw uno::RuntimeException();
3171
3172 m_aListenersContainer.addInterface( cppu::UnoType<embed::XTransactionListener>::get(),
3173 aListener );
3174 }
3175
3176 void SAL_CALL OWriteStream::removeTransactionListener( const uno::Reference< embed::XTransactionListener >& aListener )
3177 {
3178 ::osl::MutexGuard aGuard( m_xSharedMutex->GetMutex() );
3179
3180 if ( !m_pImpl )
3181 {
3182 SAL_INFO("package.xstor", "Disposed!");
3183 throw lang::DisposedException();
3184 }
3185
3186 if ( !m_bTransacted )
3187 throw uno::RuntimeException();
3188
3189 m_aListenersContainer.removeInterface( cppu::UnoType<embed::XTransactionListener>::get(),
3190 aListener );
3191 }
3192
3193 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE