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