xref: /aoo42x/main/package/source/xstor/xstorage.cxx (revision 30acf5e8)
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/beans/PropertyValue.hpp>
27 #include <com/sun/star/embed/ElementModes.hpp>
28 #include <com/sun/star/embed/UseBackupException.hpp>
29 #include <com/sun/star/embed/StorageFormats.hpp>
30 #include <com/sun/star/ucb/XProgressHandler.hpp>
31 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
32 #include <com/sun/star/container/XEnumerationAccess.hpp>
33 #include <com/sun/star/container/XNamed.hpp>
34 #include <com/sun/star/util/XChangesBatch.hpp>
35 #include <com/sun/star/util/XCloneable.hpp>
36 
37 
38 #include <com/sun/star/lang/XUnoTunnel.hpp>
39 #include <com/sun/star/lang/XComponent.hpp>
40 #include <com/sun/star/lang/DisposedException.hpp>
41 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
42 #include <com/sun/star/beans/NamedValue.hpp>
43 
44 #include <PackageConstants.hxx>
45 
46 #include <cppuhelper/typeprovider.hxx>
47 #include <cppuhelper/exc_hlp.hxx>
48 #include <rtl/logfile.hxx>
49 #include <rtl/instance.hxx>
50 
51 #include <comphelper/processfactory.hxx>
52 #include <comphelper/componentcontext.hxx>
53 #include <comphelper/storagehelper.hxx>
54 #include <comphelper/ofopxmlhelper.hxx>
55 
56 #include "xstorage.hxx"
57 #include "owriteablestream.hxx"
58 #include "disposelistener.hxx"
59 #include "switchpersistencestream.hxx"
60 #include "ohierarchyholder.hxx"
61 
62 using namespace ::com::sun::star;
63 
64 //=========================================================
65 
66 typedef ::std::list< uno::WeakReference< lang::XComponent > > WeakComponentList;
67 
68 struct StorInternalData_Impl
69 {
70 	SotMutexHolderRef m_rSharedMutexRef;
71 	::cppu::OMultiTypeInterfaceContainerHelper m_aListenersContainer; // list of listeners
72 	::cppu::OTypeCollection* m_pTypeCollection;
73 	sal_Bool m_bIsRoot;
74 	sal_Int32 m_nStorageType; // the mode in which the storage is used
75 	sal_Bool m_bReadOnlyWrap;
76 
77 	OChildDispListener_Impl* m_pSubElDispListener;
78 
79 	WeakComponentList m_aOpenSubComponentsList;
80 
81 	::rtl::Reference< OHierarchyHolder_Impl > m_rHierarchyHolder;
82 
83 	// the mutex reference MUST NOT be empty
StorInternalData_ImplStorInternalData_Impl84 	StorInternalData_Impl( const SotMutexHolderRef& rMutexRef, sal_Bool bRoot, sal_Int32 nStorageType, sal_Bool bReadOnlyWrap )
85 	: m_rSharedMutexRef( rMutexRef )
86 	, m_aListenersContainer( rMutexRef->GetMutex() )
87 	, m_pTypeCollection( NULL )
88 	, m_bIsRoot( bRoot )
89 	, m_nStorageType( nStorageType )
90 	, m_bReadOnlyWrap( bReadOnlyWrap )
91 	, m_pSubElDispListener( NULL )
92 	{}
93 
94 	~StorInternalData_Impl();
95 };
96 
97 //=========================================================
98 ::rtl::OUString GetNewTempFileURL( const uno::Reference< lang::XMultiServiceFactory > xFactory );
99 
100 // static
completeStorageStreamCopy_Impl(const uno::Reference<io::XStream> & xSource,const uno::Reference<io::XStream> & xDest,sal_Int32 nStorageType,const uno::Sequence<uno::Sequence<beans::StringPair>> & aRelInfo)101 void OStorage_Impl::completeStorageStreamCopy_Impl(
102 							const uno::Reference< io::XStream >& xSource,
103 							const uno::Reference< io::XStream >& xDest,
104 							sal_Int32 nStorageType,
105 							const uno::Sequence< uno::Sequence< beans::StringPair > >& aRelInfo )
106 {
107 		uno::Reference< beans::XPropertySet > xSourceProps( xSource, uno::UNO_QUERY );
108 		uno::Reference< beans::XPropertySet > xDestProps( xDest, uno::UNO_QUERY );
109 		if ( !xSourceProps.is() || !xDestProps.is() )
110 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
111 
112 		uno::Reference< io::XOutputStream > xDestOutStream = xDest->getOutputStream();
113 		if ( !xDestOutStream.is() )
114 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
115 
116 		uno::Reference< io::XInputStream > xSourceInStream = xSource->getInputStream();
117 		if ( !xSourceInStream.is() )
118 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
119 
120 		// TODO: headers of encripted streams should be copied also
121 		::comphelper::OStorageHelper::CopyInputToOutput( xSourceInStream, xDestOutStream );
122 
123 		uno::Sequence< ::rtl::OUString > aPropNames( 1 );
124 		aPropNames[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Compressed" ) );
125 
126 		if ( nStorageType == embed::StorageFormats::PACKAGE )
127 		{
128 			aPropNames.realloc( 3 );
129 			aPropNames[1] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) );
130 			aPropNames[2] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseCommonStoragePasswordEncryption" ) );
131 		}
132 		else if ( nStorageType == embed::StorageFormats::OFOPXML )
133 		{
134 			// TODO/LATER: in future it might make sense to provide the stream if there is one
135 			uno::Reference< embed::XRelationshipAccess > xRelAccess( xDest, uno::UNO_QUERY_THROW );
136 			xRelAccess->clearRelationships();
137 			xRelAccess->insertRelationships( aRelInfo, sal_False );
138 
139 			aPropNames.realloc( 2 );
140 			aPropNames[1] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) );
141 		}
142 
143 		for ( int ind = 0; ind < aPropNames.getLength(); ind++ )
144 			xDestProps->setPropertyValue( aPropNames[ind], xSourceProps->getPropertyValue( aPropNames[ind] ) );
145 }
146 
GetSeekableTempCopy(uno::Reference<io::XInputStream> xInStream,uno::Reference<lang::XMultiServiceFactory> xFactory)147 uno::Reference< io::XInputStream > GetSeekableTempCopy( uno::Reference< io::XInputStream > xInStream,
148 														uno::Reference< lang::XMultiServiceFactory > xFactory )
149 {
150 	uno::Reference < io::XOutputStream > xTempOut(
151 						xFactory->createInstance ( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.TempFile" ) ) ),
152 						uno::UNO_QUERY );
153 	uno::Reference < io::XInputStream > xTempIn( xTempOut, uno::UNO_QUERY );
154 
155 	if ( !xTempOut.is() || !xTempIn.is() )
156 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
157 
158 	::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOut );
159 	xTempOut->closeOutput();
160 
161 	return xTempIn;
162 }
163 
~StorInternalData_Impl()164 StorInternalData_Impl::~StorInternalData_Impl()
165 {
166 	if ( m_pTypeCollection )
167 		delete m_pTypeCollection;
168 }
169 
170 
SotElement_Impl(const::rtl::OUString & rName,sal_Bool bStor,sal_Bool bNew)171 SotElement_Impl::SotElement_Impl( const ::rtl::OUString& rName, sal_Bool bStor, sal_Bool bNew )
172 : m_aName( rName )
173 , m_aOriginalName( rName )
174 , m_bIsRemoved( sal_False )
175 , m_bIsInserted( bNew )
176 , m_bIsStorage( bStor )
177 , m_pStorage( NULL )
178 , m_pStream( NULL )
179 {
180 }
181 
~SotElement_Impl()182 SotElement_Impl::~SotElement_Impl()
183 {
184 	if ( m_pStorage )
185 		delete m_pStorage;
186 
187 	if ( m_pStream )
188 		delete m_pStream;
189 }
190 
191 //-----------------------------------------------
192 // most of properties are holt by the storage but are not used
OStorage_Impl(uno::Reference<io::XInputStream> xInputStream,sal_Int32 nMode,uno::Sequence<beans::PropertyValue> xProperties,uno::Reference<lang::XMultiServiceFactory> xFactory,sal_Int32 nStorageType)193 OStorage_Impl::OStorage_Impl(	uno::Reference< io::XInputStream > xInputStream,
194 								sal_Int32 nMode,
195 								uno::Sequence< beans::PropertyValue > xProperties,
196 								uno::Reference< lang::XMultiServiceFactory > xFactory,
197 								sal_Int32 nStorageType )
198 : m_rMutexRef( new SotMutexHolder )
199 , m_pAntiImpl( NULL )
200 , m_nStorageMode( nMode & ~embed::ElementModes::SEEKABLE )
201 , m_bIsModified( ( nMode & ( embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE ) ) == ( embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE ) )
202 , m_bBroadcastModified( sal_False )
203 , m_bCommited( sal_False )
204 , m_bIsRoot( sal_True )
205 , m_bListCreated( sal_False )
206 , m_xFactory( xFactory )
207 , m_xProperties( xProperties )
208 , m_bHasCommonEncryptionData( sal_False )
209 , m_pParent( NULL )
210 , m_bControlMediaType( sal_False )
211 , m_bMTFallbackUsed( sal_False )
212 , m_bControlVersion( sal_False )
213 , m_pSwitchStream( NULL )
214 , m_nStorageType( nStorageType )
215 , m_pRelStorElement( NULL )
216 , m_nRelInfoStatus( RELINFO_NO_INIT )
217 {
218 	// all the checks done below by assertion statements must be done by factory
219 	OSL_ENSURE( xInputStream.is(), "No input stream is provided!\n" );
220 
221 	m_pSwitchStream = (SwitchablePersistenceStream*) new SwitchablePersistenceStream( xFactory, xInputStream );
222 	m_xInputStream = m_pSwitchStream->getInputStream();
223 
224 	if ( m_nStorageMode & embed::ElementModes::WRITE )
225 	{
226 		// check that the stream allows to write
227 		OSL_ENSURE( sal_False, "No stream for writing is provided!\n" );
228     }
229 }
230 
231 //-----------------------------------------------
232 // most of properties are holt by the storage but are not used
OStorage_Impl(uno::Reference<io::XStream> xStream,sal_Int32 nMode,uno::Sequence<beans::PropertyValue> xProperties,uno::Reference<lang::XMultiServiceFactory> xFactory,sal_Int32 nStorageType)233 OStorage_Impl::OStorage_Impl(	uno::Reference< io::XStream > xStream,
234 								sal_Int32 nMode,
235 								uno::Sequence< beans::PropertyValue > xProperties,
236 								uno::Reference< lang::XMultiServiceFactory > xFactory,
237 								sal_Int32 nStorageType )
238 : m_rMutexRef( new SotMutexHolder )
239 , m_pAntiImpl( NULL )
240 , m_nStorageMode( nMode & ~embed::ElementModes::SEEKABLE )
241 , m_bIsModified( ( nMode & ( embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE ) ) == ( embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE ) )
242 , m_bBroadcastModified( sal_False )
243 , m_bCommited( sal_False )
244 , m_bIsRoot( sal_True )
245 , m_bListCreated( sal_False )
246 , m_xFactory( xFactory )
247 , m_xProperties( xProperties )
248 , m_bHasCommonEncryptionData( sal_False )
249 , m_pParent( NULL )
250 , m_bControlMediaType( sal_False )
251 , m_bMTFallbackUsed( sal_False )
252 , m_bControlVersion( sal_False )
253 , m_pSwitchStream( NULL )
254 , m_nStorageType( nStorageType )
255 , m_pRelStorElement( NULL )
256 , m_nRelInfoStatus( RELINFO_NO_INIT )
257 {
258 	// all the checks done below by assertion statements must be done by factory
259 	OSL_ENSURE( xStream.is(), "No stream is provided!\n" );
260 
261 	if ( m_nStorageMode & embed::ElementModes::WRITE )
262 	{
263 		m_pSwitchStream = (SwitchablePersistenceStream*) new SwitchablePersistenceStream( xFactory, xStream );
264 		m_xStream = static_cast< io::XStream* >( m_pSwitchStream );
265     }
266 	else
267 	{
268 		m_pSwitchStream = (SwitchablePersistenceStream*) new SwitchablePersistenceStream( xFactory,
269 																						  xStream->getInputStream() );
270 		m_xInputStream = m_pSwitchStream->getInputStream();
271 	}
272 }
273 
274 //-----------------------------------------------
OStorage_Impl(OStorage_Impl * pParent,sal_Int32 nMode,uno::Reference<container::XNameContainer> xPackageFolder,uno::Reference<lang::XSingleServiceFactory> xPackage,uno::Reference<lang::XMultiServiceFactory> xFactory,sal_Int32 nStorageType)275 OStorage_Impl::OStorage_Impl(	OStorage_Impl* pParent,
276 								sal_Int32 nMode,
277 								uno::Reference< container::XNameContainer > xPackageFolder,
278 								uno::Reference< lang::XSingleServiceFactory > xPackage,
279 								uno::Reference< lang::XMultiServiceFactory > xFactory,
280 								sal_Int32 nStorageType )
281 : m_rMutexRef( new SotMutexHolder )
282 , m_pAntiImpl( NULL )
283 , m_nStorageMode( nMode & ~embed::ElementModes::SEEKABLE )
284 , m_bIsModified( ( nMode & ( embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE ) ) == ( embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE ) )
285 , m_bBroadcastModified( sal_False )
286 , m_bCommited( sal_False )
287 , m_bIsRoot( sal_False )
288 , m_bListCreated( sal_False )
289 , m_xPackageFolder( xPackageFolder )
290 , m_xPackage( xPackage )
291 , m_xFactory( xFactory )
292 , m_bHasCommonEncryptionData( sal_False )
293 , m_pParent( pParent ) // can be empty in case of temporary readonly substorages and relation storage
294 , m_bControlMediaType( sal_False )
295 , m_bMTFallbackUsed( sal_False )
296 , m_bControlVersion( sal_False )
297 , m_pSwitchStream( NULL )
298 , m_nStorageType( nStorageType )
299 , m_pRelStorElement( NULL )
300 , m_nRelInfoStatus( RELINFO_NO_INIT )
301 {
302 	OSL_ENSURE( xPackageFolder.is(), "No package folder!\n" );
303 }
304 
305 //-----------------------------------------------
~OStorage_Impl()306 OStorage_Impl::~OStorage_Impl()
307 {
308 	{
309 		::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
310 		if ( m_pAntiImpl ) // root storage wrapper must set this member to NULL before destruction of object
311 		{
312 			OSL_ENSURE( !m_bIsRoot, "The root storage wrapper must be disposed already" );
313 
314 			try {
315 				m_pAntiImpl->InternalDispose( sal_False );
316 			}
317 			catch ( uno::Exception& aException )
318             {
319                 AddLog( aException.Message );
320                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
321             }
322 			m_pAntiImpl = NULL;
323 		}
324 		else if ( !m_aReadOnlyWrapList.empty() )
325 		{
326 			for ( OStorageList_Impl::iterator pStorageIter = m_aReadOnlyWrapList.begin();
327 				  pStorageIter != m_aReadOnlyWrapList.end(); pStorageIter++ )
328 			{
329 				uno::Reference< embed::XStorage > xTmp = pStorageIter->m_xWeakRef;
330 				if ( xTmp.is() )
331 					try {
332 						pStorageIter->m_pPointer->InternalDispose( sal_False );
333 					} catch( uno::Exception& aException )
334                     {
335                         AddLog( aException.Message );
336                         AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
337                     }
338 			}
339 
340 			m_aReadOnlyWrapList.clear();
341 		}
342 
343 		m_pParent = NULL;
344 	}
345 
346 	for ( SotElementList_Impl::iterator pElementIter = m_aChildrenList.begin();
347 		  pElementIter != m_aChildrenList.end(); pElementIter++ )
348 		delete *pElementIter;
349 
350 	m_aChildrenList.clear();
351 
352 	for ( SotElementList_Impl::iterator pDeletedIter = m_aDeletedList.begin();
353 		  pDeletedIter != m_aDeletedList.end(); pDeletedIter++ )
354 		delete *pDeletedIter;
355 
356 	m_aDeletedList.clear();
357 
358 	if ( m_nStorageType == embed::StorageFormats::OFOPXML && m_pRelStorElement )
359 	{
360 		delete m_pRelStorElement;
361 		m_pRelStorElement = NULL;
362 	}
363 
364 	m_xPackageFolder = uno::Reference< container::XNameContainer >();
365 	m_xPackage = uno::Reference< lang::XSingleServiceFactory >();
366 
367 	::rtl::OUString aPropertyName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) );
368 	for ( sal_Int32 aInd = 0; aInd < m_xProperties.getLength(); aInd++ )
369 	{
370 		if ( m_xProperties[aInd].Name.equals( aPropertyName ) )
371 		{
372 			// the storage is URL based so all the streams are opened by factory and should be closed
373 			try
374 			{
375 				if ( m_xInputStream.is() )
376 				{
377 					m_xInputStream->closeInput();
378 					m_xInputStream = uno::Reference< io::XInputStream >();
379 				}
380 
381 				if ( m_xStream.is() )
382 				{
383 					uno::Reference< io::XInputStream > xInStr = m_xStream->getInputStream();
384 					if ( xInStr.is() )
385 						xInStr->closeInput();
386 
387 					uno::Reference< io::XOutputStream > xOutStr = m_xStream->getOutputStream();
388 					if ( xOutStr.is() )
389 						xOutStr->closeOutput();
390 
391 					m_xStream = uno::Reference< io::XStream >();
392 				}
393 			}
394 			catch( uno::Exception& aException )
395             {
396                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
397                 AddLog( aException.Message );
398             }
399 		}
400 	}
401 }
402 
403 //-----------------------------------------------
AddLog(const::rtl::OUString & aMessage)404 void OStorage_Impl::AddLog( const ::rtl::OUString& aMessage )
405 {
406     if ( !m_xLogRing.is() )
407     {
408         try
409         {
410             ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() );
411             if ( aContext.is() )
412                 m_xLogRing.set( aContext.getSingleton( "com.sun.star.logging.DocumentIOLogRing" ), uno::UNO_QUERY_THROW );
413         }
414         catch( uno::Exception& )
415         {
416             // No log
417         }
418     }
419 
420     if ( m_xLogRing.is() )
421         m_xLogRing->logString( aMessage );
422 }
423 
424 //-----------------------------------------------
SetReadOnlyWrap(OStorage & aStorage)425 void OStorage_Impl::SetReadOnlyWrap( OStorage& aStorage )
426 {
427 	// Weak reference is used inside the holder so the refcount must not be zero at this point
428 	OSL_ENSURE( aStorage.GetRefCount_Impl(), "There must be a reference alive to use this method!\n" );
429 	m_aReadOnlyWrapList.push_back( StorageHolder_Impl( &aStorage ) );
430 }
431 
432 //-----------------------------------------------
RemoveReadOnlyWrap(OStorage & aStorage)433 void OStorage_Impl::RemoveReadOnlyWrap( OStorage& aStorage )
434 {
435 	for ( OStorageList_Impl::iterator pStorageIter = m_aReadOnlyWrapList.begin();
436 	  pStorageIter != m_aReadOnlyWrapList.end();)
437 	{
438 		uno::Reference< embed::XStorage > xTmp = pStorageIter->m_xWeakRef;
439 		if ( !xTmp.is() || pStorageIter->m_pPointer == &aStorage )
440 		{
441 			try {
442 				pStorageIter->m_pPointer->InternalDispose( sal_False );
443 			} catch( uno::Exception& aException )
444             {
445                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
446                 AddLog( aException.Message );
447             }
448 
449 			OStorageList_Impl::iterator pIterToDelete( pStorageIter );
450 			pStorageIter++;
451 			m_aReadOnlyWrapList.erase( pIterToDelete );
452 		}
453 		else
454 			pStorageIter++;
455 	}
456 }
457 
458 //-----------------------------------------------
OpenOwnPackage()459 void OStorage_Impl::OpenOwnPackage()
460 {
461 	OSL_ENSURE( m_bIsRoot, "Opening of the package has no sense!\n" );
462 
463 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
464 
465 	if ( !m_xPackageFolder.is() )
466 	{
467 		if ( !m_xPackage.is() )
468 		{
469         	uno::Sequence< uno::Any > aArguments( 2 );
470 			if ( m_nStorageMode & embed::ElementModes::WRITE )
471 				aArguments[ 0 ] <<= m_xStream;
472 			else
473 			{
474 				OSL_ENSURE( m_xInputStream.is(), "Input stream must be set for readonly access!\n" );
475 				aArguments[ 0 ] <<= m_xInputStream;
476 				// TODO: if input stream is not seekable or XSeekable interface is supported
477 				// on XStream object a wrapper must be used
478 			}
479 
480 			// do not allow elements to remove themself from the old container in case of insertion to another container
481 			aArguments[ 1 ] <<= beans::NamedValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "AllowRemoveOnInsert" ) ),
482 													uno::makeAny( (sal_Bool)sal_False ) );
483 
484 			sal_Int32 nArgNum = 2;
485 			for ( sal_Int32 aInd = 0; aInd < m_xProperties.getLength(); aInd++ )
486 			{
487 				if ( m_xProperties[aInd].Name.equalsAscii( "RepairPackage" )
488 				  || m_xProperties[aInd].Name.equalsAscii( "ProgressHandler" ) )
489 				{
490 					beans::NamedValue aNamedValue( m_xProperties[aInd].Name,
491 													m_xProperties[aInd].Value );
492 					aArguments.realloc( ++nArgNum );
493 					aArguments[nArgNum-1] <<= aNamedValue;
494 				}
495 				else if ( m_xProperties[aInd].Name.equalsAscii( "Password" ) )
496 				{
497 					// TODO: implement password setting for documents
498 					// the password entry must be removed after setting
499 				}
500 			}
501 
502 			if ( m_nStorageType == embed::StorageFormats::ZIP )
503 			{
504 				// let the package support only plain zip format
505 				beans::NamedValue aNamedValue;
506 				aNamedValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StorageFormat" ) );
507 				aNamedValue.Value <<= ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ZipFormat" ) );
508 				aArguments.realloc( ++nArgNum );
509 				aArguments[nArgNum-1] <<= aNamedValue;
510 			}
511 			else if ( m_nStorageType == embed::StorageFormats::OFOPXML )
512 			{
513 				// let the package support OFOPXML media type handling
514 				beans::NamedValue aNamedValue;
515 				aNamedValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StorageFormat" ) );
516 				aNamedValue.Value <<= ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OFOPXMLFormat" ) );
517 				aArguments.realloc( ++nArgNum );
518 				aArguments[nArgNum-1] <<= aNamedValue;
519 			}
520 
521         	m_xPackage = uno::Reference< lang::XSingleServiceFactory > (
522 										GetServiceFactory()->createInstanceWithArguments(
523 											::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.packages.comp.ZipPackage" ) ),
524                 							aArguments ),
525 										uno::UNO_QUERY );
526 		}
527 
528 		uno::Reference< container::XHierarchicalNameAccess > xHNameAccess( m_xPackage, uno::UNO_QUERY );
529 		OSL_ENSURE( xHNameAccess.is(), "The package could not be created!\n" );
530 
531 		if ( xHNameAccess.is() )
532 		{
533 			uno::Any aFolder = xHNameAccess->getByHierarchicalName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) ) );
534 			aFolder >>= m_xPackageFolder;
535 		}
536 	}
537 
538 	OSL_ENSURE( m_xPackageFolder.is(), "The package root folder can not be opened!\n" );
539 	if ( !m_xPackageFolder.is() )
540 		throw embed::InvalidStorageException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
541 }
542 
543 //-----------------------------------------------
GetServiceFactory()544 uno::Reference< lang::XMultiServiceFactory > OStorage_Impl::GetServiceFactory()
545 {
546 	if ( m_xFactory.is() )
547 		return m_xFactory;
548 
549 	return ::comphelper::getProcessServiceFactory();
550 }
551 
552 //-----------------------------------------------
GetChildrenList()553 SotElementList_Impl& OStorage_Impl::GetChildrenList()
554 {
555 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
556 
557 	ReadContents();
558 	return m_aChildrenList;
559 }
560 
561 //-----------------------------------------------
GetStorageProperties()562 void OStorage_Impl::GetStorageProperties()
563 {
564 	if ( m_nStorageType == embed::StorageFormats::PACKAGE )
565     {
566         uno::Reference< beans::XPropertySet > xProps( m_xPackageFolder, uno::UNO_QUERY_THROW );
567 
568         if ( !m_bControlMediaType )
569         {
570             uno::Reference< beans::XPropertySet > xPackageProps( m_xPackage, uno::UNO_QUERY_THROW );
571             xPackageProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MEDIATYPE_FALLBACK_USED_PROPERTY ) ) ) >>= m_bMTFallbackUsed;
572 
573             xProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ) ) >>= m_aMediaType;
574             m_bControlMediaType = sal_True;
575         }
576 
577         if ( !m_bControlVersion )
578         {
579             xProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ) ) >>= m_aVersion;
580             m_bControlVersion = sal_True;
581         }
582     }
583 
584 	// the properties of OFOPXML will be handled directly
585 }
586 
587 //-----------------------------------------------
ReadRelInfoIfNecessary()588 void OStorage_Impl::ReadRelInfoIfNecessary()
589 {
590 	if ( m_nStorageType != embed::StorageFormats::OFOPXML )
591 		return;
592 
593 	if ( m_nRelInfoStatus == RELINFO_NO_INIT )
594 	{
595 		// Init from original stream
596 		uno::Reference< io::XInputStream > xRelInfoStream = GetRelInfoStreamForName( ::rtl::OUString() );
597 		if ( xRelInfoStream.is() )
598 			m_aRelInfo = ::comphelper::OFOPXMLHelper::ReadRelationsInfoSequence(
599 									xRelInfoStream,
600 									::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels/.rels" ) ),
601 									m_xFactory );
602 
603 		m_nRelInfoStatus = RELINFO_READ;
604 	}
605 	else if ( m_nRelInfoStatus == RELINFO_CHANGED_STREAM )
606 	{
607 		// Init from the new stream
608 		try
609 		{
610 			if ( m_xNewRelInfoStream.is() )
611 				m_aRelInfo = ::comphelper::OFOPXMLHelper::ReadRelationsInfoSequence(
612 										m_xNewRelInfoStream,
613 										::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels/.rels" ) ),
614 										m_xFactory );
615 
616 			m_nRelInfoStatus = RELINFO_CHANGED_STREAM_READ;
617 		}
618 		catch( uno::Exception )
619 		{
620 			m_nRelInfoStatus = RELINFO_CHANGED_BROKEN;
621 		}
622 	}
623 }
624 
625 //-----------------------------------------------
ReadContents()626 void OStorage_Impl::ReadContents()
627 {
628 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
629 
630     if ( m_bListCreated )
631         return;
632 
633 	if ( m_bIsRoot )
634 		OpenOwnPackage();
635 
636 	uno::Reference< container::XEnumerationAccess > xEnumAccess( m_xPackageFolder, uno::UNO_QUERY );
637 	if ( !xEnumAccess.is() )
638 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
639 
640 	uno::Reference< container::XEnumeration > xEnum = xEnumAccess->createEnumeration();
641 	if ( !xEnum.is() )
642 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
643 
644     m_bListCreated = sal_True;
645 
646 	while( xEnum->hasMoreElements() )
647 	{
648 		try {
649 			uno::Reference< container::XNamed > xNamed;
650 			xEnum->nextElement() >>= xNamed;
651 
652 			if ( !xNamed.is() )
653 			{
654 				OSL_ENSURE( sal_False, "XNamed is not supported!\n" );
655 				throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
656 			}
657 
658 			::rtl::OUString aName = xNamed->getName();
659 			OSL_ENSURE( aName.getLength(), "Empty name!\n" );
660 
661 			uno::Reference< container::XNameContainer > xNameContainer( xNamed, uno::UNO_QUERY );
662 
663 			SotElement_Impl* pNewElement = new SotElement_Impl( aName, xNameContainer.is(), sal_False );
664 			if ( m_nStorageType == embed::StorageFormats::OFOPXML && aName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
665 			{
666 				if ( !pNewElement->m_bIsStorage )
667 					throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: Unexpected format
668 
669 				m_pRelStorElement = pNewElement;
670 				CreateRelStorage();
671 			}
672 			else
673 			{
674 				if ( ( m_nStorageMode & embed::ElementModes::TRUNCATE ) == embed::ElementModes::TRUNCATE )
675 				{
676 					// if a storage is truncated all of it elements are marked as deleted
677 					pNewElement->m_bIsRemoved = sal_True;
678 				}
679 
680 				m_aChildrenList.push_back( pNewElement );
681 			}
682 		}
683 		catch( container::NoSuchElementException& aNoSuchElementException )
684         {
685             AddLog( aNoSuchElementException.Message );
686             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "NoSuchElement" ) ) );
687 
688 			OSL_ENSURE( sal_False, "hasMoreElements() implementation has problems!\n" );
689 			break;
690 		}
691 	}
692 	if ( ( m_nStorageMode & embed::ElementModes::TRUNCATE ) == embed::ElementModes::TRUNCATE )
693 	{
694 		// if a storage is truncated the relations information should be cleaned
695 		m_xNewRelInfoStream = uno::Reference< io::XInputStream >();
696 		m_aRelInfo = uno::Sequence< uno::Sequence< beans::StringPair > >();
697 		m_nRelInfoStatus = RELINFO_CHANGED;
698 	}
699 
700 	// cache changeable folder properties
701 	GetStorageProperties();
702 }
703 
704 //-----------------------------------------------
CopyToStorage(const uno::Reference<embed::XStorage> & xDest,sal_Bool bDirect)705 void OStorage_Impl::CopyToStorage( const uno::Reference< embed::XStorage >& xDest, sal_Bool bDirect )
706 {
707 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
708 
709 	uno::Reference< beans::XPropertySet > xPropSet( xDest, uno::UNO_QUERY );
710 	if ( !xPropSet.is() )
711 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 );
712 
713 	sal_Int32 nDestMode = embed::ElementModes::READ;
714 	xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ) ) ) >>= nDestMode;
715 
716 	if ( !( nDestMode & embed::ElementModes::WRITE ) )
717 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access_denied
718 
719 	ReadContents();
720 
721 	if ( !m_xPackageFolder.is() )
722 		throw embed::InvalidStorageException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
723 
724 	for ( SotElementList_Impl::iterator pElementIter = m_aChildrenList.begin();
725 		  pElementIter != m_aChildrenList.end(); pElementIter++ )
726     {
727 		if ( !(*pElementIter)->m_bIsRemoved )
728 			CopyStorageElement( *pElementIter, xDest, (*pElementIter)->m_aName, bDirect );
729 	}
730 
731 	// move storage properties to the destination one ( means changeable properties )
732 	if ( m_nStorageType == embed::StorageFormats::PACKAGE )
733 	{
734 		::rtl::OUString aMediaTypeString = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) );
735 		::rtl::OUString aVersionString = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) );
736 		xPropSet->setPropertyValue( aMediaTypeString, uno::makeAny( m_aMediaType ) );
737 		xPropSet->setPropertyValue( aVersionString, uno::makeAny( m_aVersion ) );
738 	}
739 
740 	if ( m_nStorageType == embed::StorageFormats::PACKAGE )
741 	{
742 		// if this is a root storage, the common key from current one should be moved there
743 		sal_Bool bIsRoot = sal_False;
744 		::rtl::OUString aRootString = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsRoot" ) );
745 		if ( ( xPropSet->getPropertyValue( aRootString ) >>= bIsRoot ) && bIsRoot )
746 		{
747 			try
748 			{
749 				uno::Reference< embed::XEncryptionProtectedStorage > xEncr( xDest, uno::UNO_QUERY );
750 				if ( xEncr.is() )
751                 {
752 					xEncr->setEncryptionData( GetCommonRootEncryptionData().getAsConstNamedValueList() );
753 
754                     uno::Sequence< beans::NamedValue > aAlgorithms;
755                     uno::Reference< beans::XPropertySet > xPackPropSet( m_xPackage, uno::UNO_QUERY_THROW );
756                     xPackPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ENCRYPTION_ALGORITHMS_PROPERTY ) ) )
757                         >>= aAlgorithms;
758                     xEncr->setEncryptionAlgorithms( aAlgorithms );
759                 }
760 			}
761 			catch( packages::NoEncryptionException& aNoEncryptionException )
762             {
763                 AddLog( aNoEncryptionException.Message );
764                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "No Encryption" ) ) );
765             }
766 		}
767 	}
768 	else if ( m_nStorageType == embed::StorageFormats::OFOPXML )
769 	{
770 
771 		// TODO/LATER: currently the optimization is not active
772 		// uno::Reference< io::XInputStream > xRelInfoStream = GetRelInfoStreamForName( ::rtl::OUString() ); // own stream
773 		// if ( xRelInfoStream.is() )
774 		// {
775 		// 	// Relations info stream is a writeonly property, introduced only to optimyze copying
776 		// 	// Should be used carefuly since no check for stream consistency is done, and the stream must not stay locked
777 		//
778 		// 	::rtl::OUString aRelInfoString = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RelationsInfoStream" ) );
779 		// 	xPropSet->setPropertyValue( aRelInfoString, uno::makeAny( GetSeekableTempCopy( xRelInfoStream, m_xFactory ) ) );
780 		// }
781 
782 		uno::Reference< embed::XRelationshipAccess > xRels( xDest, uno::UNO_QUERY );
783 		if ( !xRels.is() )
784 			throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 );
785 
786 		xRels->insertRelationships( GetAllRelationshipsIfAny(), sal_False );
787 	}
788 
789 	// if possible the destination storage should be committed after successful copying
790 	uno::Reference< embed::XTransactedObject > xObjToCommit( xDest, uno::UNO_QUERY );
791 	if ( xObjToCommit.is() )
792 		xObjToCommit->commit();
793 }
794 
795 //-----------------------------------------------
CopyStorageElement(SotElement_Impl * pElement,uno::Reference<embed::XStorage> xDest,::rtl::OUString aName,sal_Bool bDirect)796 void OStorage_Impl::CopyStorageElement( SotElement_Impl* pElement,
797 										uno::Reference< embed::XStorage > xDest,
798 										::rtl::OUString aName,
799 										sal_Bool bDirect )
800 {
801 	OSL_ENSURE( xDest.is(), "No destination storage!\n" );
802 	OSL_ENSURE( aName.getLength(), "Empty element name!\n" );
803 
804 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
805 
806 	uno::Reference< container::XNameAccess > xDestAccess( xDest, uno::UNO_QUERY );
807 	if ( !xDestAccess.is() )
808 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
809 
810 	if ( xDestAccess->hasByName( aName )
811 	  && !( pElement->m_bIsStorage && xDest->isStorageElement( aName ) ) )
812 		xDest->removeElement( aName );
813 
814 	if ( pElement->m_bIsStorage )
815 	{
816 		uno::Reference< embed::XStorage > xSubDest =
817 									xDest->openStorageElement(  aName,
818 																embed::ElementModes::WRITE );
819 
820 		OSL_ENSURE( xSubDest.is(), "No destination substorage!\n" );
821 
822 		if ( !pElement->m_pStorage )
823 		{
824 			OpenSubStorage( pElement, embed::ElementModes::READ );
825 			if ( !pElement->m_pStorage )
826 				throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
827 		}
828 
829 		pElement->m_pStorage->CopyToStorage( xSubDest, bDirect );
830 	}
831 	else
832 	{
833 		if ( !pElement->m_pStream )
834 		{
835 			OpenSubStream( pElement );
836 			if ( !pElement->m_pStream )
837 				throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
838 		}
839 
840 		if ( !pElement->m_pStream->IsEncrypted() )
841 		{
842 			if ( bDirect )
843 			{
844 				// fill in the properties for the stream
845 				uno::Sequence< beans::PropertyValue > aStrProps(0);
846 				uno::Sequence< beans::PropertyValue > aSrcPkgProps = pElement->m_pStream->GetStreamProperties();
847 				sal_Int32 nNum = 0;
848 				for ( int ind = 0; ind < aSrcPkgProps.getLength(); ind++ )
849 				{
850 					if ( aSrcPkgProps[ind].Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "MediaType" ) ) )
851 					  || aSrcPkgProps[ind].Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "Compressed" ) ) ) )
852 					{
853 						aStrProps.realloc( ++nNum );
854 						aStrProps[nNum-1].Name = aSrcPkgProps[ind].Name;
855 						aStrProps[nNum-1].Value = aSrcPkgProps[ind].Value;
856 					}
857 				}
858 
859 				if ( m_nStorageType == embed::StorageFormats::PACKAGE )
860 				{
861 					aStrProps.realloc( ++nNum );
862 					aStrProps[nNum-1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseCommonStoragePasswordEncryption" ) );
863 					aStrProps[nNum-1].Value <<= (sal_Bool)( pElement->m_pStream->UsesCommonEncryption_Impl() );
864 				}
865 				else if ( m_nStorageType == embed::StorageFormats::OFOPXML )
866 				{
867 					// TODO/LATER: currently the optimization is not active
868 					// uno::Reference< io::XInputStream > xInStream = GetRelInfoStreamForName( ::rtl::OUString() ); // own rels stream
869 					// if ( xInStream.is() )
870 					// {
871 					// 	aStrProps.realloc( ++nNum );
872 					// 	aStrProps[nNum-1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RelationsInfoStream" ) );
873 					// 	aStrProps[nNum-1].Value <<= GetSeekableTempCopy( xInStream, m_xFactory );
874 					// }
875 
876 					uno::Reference< embed::XRelationshipAccess > xRels( xDest, uno::UNO_QUERY );
877 					if ( !xRels.is() )
878 						throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 );
879 
880 					xRels->insertRelationships( GetAllRelationshipsIfAny(), sal_False );
881 				}
882 
883 				uno::Reference< embed::XOptimizedStorage > xOptDest( xDest, uno::UNO_QUERY_THROW );
884 				uno::Reference < io::XInputStream > xInputToInsert;
885 
886 				if ( pElement->m_pStream->HasTempFile_Impl() || !pElement->m_pStream->m_xPackageStream.is() )
887 				{
888 					OSL_ENSURE( pElement->m_pStream->m_xPackageStream.is(), "No package stream!" );
889 
890 					// if the stream is modified - the temporary file must be used for insertion
891 					xInputToInsert = pElement->m_pStream->GetTempFileAsInputStream();
892 				}
893 				else
894 				{
895 					// for now get just nonseekable access to the stream
896 					// TODO/LATER: the raw stream can be used
897 
898 					xInputToInsert = pElement->m_pStream->m_xPackageStream->getDataStream();
899 				}
900 
901 				if ( !xInputToInsert.is() )
902 						throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
903 
904 				xOptDest->insertStreamElementDirect( aName, xInputToInsert, aStrProps );
905 			}
906 			else
907 			{
908 				uno::Reference< io::XStream > xSubStr =
909 											xDest->openStreamElement( aName,
910 											embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
911 				OSL_ENSURE( xSubStr.is(), "No destination substream!\n" );
912 
913 				pElement->m_pStream->CopyInternallyTo_Impl( xSubStr );
914 			}
915 		}
916 		else if ( m_nStorageType != embed::StorageFormats::PACKAGE )
917 		{
918 			OSL_ENSURE( sal_False, "Encryption is only supported in package storage!\n" );
919 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
920 		}
921 		else if ( pElement->m_pStream->HasCachedEncryptionData()
922 			 && ( pElement->m_pStream->IsModified() || pElement->m_pStream->HasWriteOwner_Impl() ) )
923 		{
924             ::comphelper::SequenceAsHashMap aCommonEncryptionData;
925 			sal_Bool bHasCommonEncryptionData = sal_False;
926 			try
927 			{
928 				aCommonEncryptionData = GetCommonRootEncryptionData();
929 				bHasCommonEncryptionData = sal_True;
930 			}
931 			catch( packages::NoEncryptionException& aNoEncryptionException )
932             {
933                 AddLog( aNoEncryptionException.Message );
934                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "No Encryption" ) ) );
935             }
936 
937 			if ( bHasCommonEncryptionData && ::package::PackageEncryptionDatasEqual( pElement->m_pStream->GetCachedEncryptionData(), aCommonEncryptionData ) )
938 			{
939 				// If the stream can be opened with the common storage password
940 				// it must be stored with the common storage password as well
941 				uno::Reference< io::XStream > xDestStream =
942 											xDest->openStreamElement( aName,
943 												embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
944 
945 				pElement->m_pStream->CopyInternallyTo_Impl( xDestStream );
946 
947 				uno::Reference< beans::XPropertySet > xProps( xDestStream, uno::UNO_QUERY_THROW );
948 				xProps->setPropertyValue(
949 					::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseCommonStoragePasswordEncryption" ) ),
950 					uno::Any( (sal_Bool) sal_True ) );
951 			}
952 			else
953 			{
954 				// the stream is already opened for writing or was changed
955                 uno::Reference< embed::XStorage2 > xDest2( xDest, uno::UNO_QUERY_THROW );
956 				uno::Reference< io::XStream > xSubStr =
957 											xDest2->openEncryptedStream( aName,
958 												embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE,
959 												pElement->m_pStream->GetCachedEncryptionData().getAsConstNamedValueList() );
960 				OSL_ENSURE( xSubStr.is(), "No destination substream!\n" );
961 
962 				pElement->m_pStream->CopyInternallyTo_Impl( xSubStr, pElement->m_pStream->GetCachedEncryptionData() );
963 			}
964 		}
965 		else
966 		{
967 			// the stream is not opened at all, so it can be just opened for reading
968 			try
969 			{
970 				// If the stream can be opened with the common storage password
971 				// it must be stored with the common storage password as well
972 
973 				uno::Reference< io::XStream > xOwnStream = pElement->m_pStream->GetStream( embed::ElementModes::READ,
974 																							sal_False );
975 				uno::Reference< io::XStream > xDestStream =
976 											xDest->openStreamElement( aName,
977 												embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
978 				OSL_ENSURE( xDestStream.is(), "No destination substream!\n" );
979 				completeStorageStreamCopy_Impl( xOwnStream, xDestStream, m_nStorageType, GetAllRelationshipsIfAny() );
980 
981 				uno::Reference< beans::XPropertySet > xProps( xDestStream, uno::UNO_QUERY_THROW );
982 				xProps->setPropertyValue(
983 					::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseCommonStoragePasswordEncryption" ) ),
984 					uno::Any( (sal_Bool) sal_True ) );
985 			}
986 			catch( packages::WrongPasswordException& aWrongPasswordException )
987 			{
988                 AddLog( aWrongPasswordException.Message );
989                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Handled exception" ) ) );
990 
991 				// If the common storage password does not allow to open the stream
992 				// it could be copyed in raw way, the problem is that the StartKey should be the same
993                 // in the ODF1.2 package, so an invalid package could be produced if the stream
994                 // is copied from ODF1.1 package, where it is allowed to have different StartKeys
995 				uno::Reference< embed::XStorageRawAccess > xRawDest( xDest, uno::UNO_QUERY_THROW );
996 				uno::Reference< io::XInputStream > xRawInStream = pElement->m_pStream->GetRawInStream();
997 				xRawDest->insertRawEncrStreamElement( aName, xRawInStream );
998 			}
999 		}
1000 	}
1001 }
1002 
1003 //-----------------------------------------------
GetAllRelationshipsIfAny()1004 uno::Sequence< uno::Sequence< beans::StringPair > > OStorage_Impl::GetAllRelationshipsIfAny()
1005 {
1006 	if ( m_nStorageType != embed::StorageFormats::OFOPXML )
1007 		return uno::Sequence< uno::Sequence< beans::StringPair > >();
1008 
1009 	ReadRelInfoIfNecessary();
1010 
1011 	if ( m_nRelInfoStatus == RELINFO_READ
1012 	  || m_nRelInfoStatus == RELINFO_CHANGED_STREAM_READ || m_nRelInfoStatus == RELINFO_CHANGED )
1013 		return m_aRelInfo;
1014 	else // m_nRelInfoStatus == RELINFO_CHANGED_BROKEN || m_nRelInfoStatus == RELINFO_BROKEN
1015 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Wrong relinfo stream!" ) ),
1016 									uno::Reference< uno::XInterface >() );
1017 }
1018 
1019 //-----------------------------------------------
CopyLastCommitTo(const uno::Reference<embed::XStorage> & xNewStor)1020 void OStorage_Impl::CopyLastCommitTo( const uno::Reference< embed::XStorage >& xNewStor )
1021 {
1022 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1023 
1024 	OSL_ENSURE( m_xPackageFolder.is(), "A committed storage is incomplete!\n" );
1025 	if ( !m_xPackageFolder.is() )
1026 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1027 
1028 	OStorage_Impl aTempRepresent( NULL,
1029 								embed::ElementModes::READ,
1030 								m_xPackageFolder,
1031 								m_xPackage,
1032 								m_xFactory,
1033 								m_nStorageType);
1034 
1035 	// TODO/LATER: could use direct copying
1036 	aTempRepresent.CopyToStorage( xNewStor, sal_False );
1037 }
1038 
1039 //-----------------------------------------------
InsertIntoPackageFolder(const::rtl::OUString & aName,const uno::Reference<container::XNameContainer> & xParentPackageFolder)1040 void OStorage_Impl::InsertIntoPackageFolder( const ::rtl::OUString& aName,
1041 											 const uno::Reference< container::XNameContainer >& xParentPackageFolder )
1042 {
1043 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1044 
1045 	OSL_ENSURE( m_xPackageFolder.is(), "An inserted storage is incomplete!\n" );
1046 	uno::Reference< lang::XUnoTunnel > xTunnel( m_xPackageFolder, uno::UNO_QUERY );
1047 	if ( !xTunnel.is() )
1048 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1049 
1050 	xParentPackageFolder->insertByName( aName, uno::makeAny( xTunnel ) );
1051 
1052 	m_bCommited = sal_False;
1053 }
1054 
1055 //-----------------------------------------------
Commit()1056 void OStorage_Impl::Commit()
1057 {
1058 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1059 
1060 	if ( !m_bIsModified )
1061 		return;
1062 
1063 	// in case of a new empty storage it is possible that the contents are still not read
1064 	// ( the storage of course has no contents, but the initialization is postponed till the first use,
1065 	//   thus if a new storage was created and committed immediately it must be initialized here )
1066 	ReadContents();
1067 
1068 	// if storage is committed it should have a valid Package representation
1069 	OSL_ENSURE( m_xPackageFolder.is(), "The package representation should exist!\n" );
1070 	if ( !m_xPackageFolder.is() )
1071 		throw embed::InvalidStorageException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1072 
1073 	OSL_ENSURE( m_nStorageMode & embed::ElementModes::WRITE,
1074 				"Commit of readonly storage, should be detected before!\n" );
1075 
1076 	uno::Reference< container::XNameContainer > xNewPackageFolder;
1077 
1078 	// here the storage will switch to the temporary package folder
1079 	// if the storage was already committed and the parent was not committed after that
1080 	// the switch should not be done since the package folder in use is a temporary one;
1081 	// it can be detected by m_bCommited flag ( root storage doesn't need temporary representation )
1082 	if ( !m_bCommited && !m_bIsRoot )
1083 	{
1084 		uno::Sequence< uno::Any > aSeq( 1 );
1085 		aSeq[0] <<= sal_True;
1086 
1087 		xNewPackageFolder = uno::Reference< container::XNameContainer >(
1088 													m_xPackage->createInstanceWithArguments( aSeq ),
1089 													uno::UNO_QUERY );
1090 	}
1091 	else
1092 		xNewPackageFolder = m_xPackageFolder;
1093 
1094 	// remove replaced removed elements
1095 	for ( SotElementList_Impl::iterator pDeletedIter = m_aDeletedList.begin();
1096 		  pDeletedIter != m_aDeletedList.end();
1097 		  pDeletedIter++ )
1098 	{
1099 
1100 		if ( m_nStorageType == embed::StorageFormats::OFOPXML && !(*pDeletedIter)->m_bIsStorage )
1101 			RemoveStreamRelInfo( (*pDeletedIter)->m_aOriginalName );
1102 
1103 		// the removed elements are not in new temporary storage
1104 		if ( m_bCommited || m_bIsRoot )
1105 			xNewPackageFolder->removeByName( (*pDeletedIter)->m_aOriginalName );
1106 		delete *pDeletedIter;
1107 		*pDeletedIter = NULL;
1108 	}
1109 	m_aDeletedList.clear();
1110 
1111 	// remove removed elements
1112 	SotElementList_Impl::iterator pElementIter = m_aChildrenList.begin();
1113 	while (  pElementIter != m_aChildrenList.end() )
1114     {
1115 		// renamed and inserted elements must be really inserted to package later
1116 		// since thay can conflict with removed elements
1117 
1118 		if ( (*pElementIter)->m_bIsRemoved )
1119 		{
1120 			if ( m_nStorageType == embed::StorageFormats::OFOPXML && !(*pElementIter)->m_bIsStorage )
1121 				RemoveStreamRelInfo( (*pElementIter)->m_aOriginalName );
1122 
1123 			// the removed elements are not in new temporary storage
1124 			if ( m_bCommited || m_bIsRoot )
1125 				xNewPackageFolder->removeByName( (*pElementIter)->m_aOriginalName );
1126 
1127 			SotElement_Impl* pToDelete = *pElementIter;
1128 
1129 			pElementIter++; // to let the iterator be valid it should be increased before removing
1130 
1131 			m_aChildrenList.remove( pToDelete );
1132 			delete pToDelete;
1133 		}
1134 		else
1135 			pElementIter++;
1136 	}
1137 
1138 	// there should be no more deleted elements
1139 	for ( pElementIter = m_aChildrenList.begin(); pElementIter != m_aChildrenList.end(); pElementIter++ )
1140     {
1141 		// if it is a 'duplicate commit' inserted elements must be really inserted to package later
1142 		// since thay can conflict with renamed elements
1143 
1144 		if ( !(*pElementIter)->m_bIsInserted )
1145 		{
1146 			// for now stream is opened in direct mode that means that in case
1147 			// storage is committed all the streams from it are committed in current state.
1148 			// following two steps are separated to allow easily implement transacted mode
1149 			// for streams if we need it in future.
1150 			// Only hierarchical access uses transacted streams currently
1151 			if ( !(*pElementIter)->m_bIsStorage && (*pElementIter)->m_pStream
1152 			  && !(*pElementIter)->m_pStream->IsTransacted() )
1153 				(*pElementIter)->m_pStream->Commit();
1154 
1155 			// if the storage was not open, there is no need to commit it ???
1156 			// the storage should be checked that it is committed
1157 			if ( (*pElementIter)->m_bIsStorage && (*pElementIter)->m_pStorage && (*pElementIter)->m_pStorage->m_bCommited )
1158 			{
1159 				// it's temporary PackageFolder should be inserted instead of current one
1160 				// also the new copy of PackageFolder should be used by the children storages
1161 
1162 				// the renamed elements are not in new temporary storage
1163 				if ( m_bCommited || m_bIsRoot )
1164 					xNewPackageFolder->removeByName( (*pElementIter)->m_aOriginalName );
1165 
1166 				(*pElementIter)->m_pStorage->InsertIntoPackageFolder( (*pElementIter)->m_aName, xNewPackageFolder );
1167 			}
1168 			else if ( !(*pElementIter)->m_bIsStorage && (*pElementIter)->m_pStream && (*pElementIter)->m_pStream->m_bFlushed )
1169 			{
1170 				if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1171 					CommitStreamRelInfo( *pElementIter );
1172 
1173 				// the renamed elements are not in new temporary storage
1174 				if ( m_bCommited || m_bIsRoot )
1175 					xNewPackageFolder->removeByName( (*pElementIter)->m_aOriginalName );
1176 
1177 				(*pElementIter)->m_pStream->InsertIntoPackageFolder( (*pElementIter)->m_aName, xNewPackageFolder );
1178 			}
1179 			else if ( !m_bCommited && !m_bIsRoot )
1180 			{
1181 				// the element must be just copied to the new temporary package folder
1182 				// the connection with the original package should not be lost just because
1183 				// the element is still referred by the folder in the original hierarchy
1184 				uno::Any aPackageElement = m_xPackageFolder->getByName( (*pElementIter)->m_aOriginalName );
1185 				xNewPackageFolder->insertByName( (*pElementIter)->m_aName, aPackageElement );
1186 			}
1187 			else if ( (*pElementIter)->m_aName.compareTo( (*pElementIter)->m_aOriginalName ) )
1188 			{
1189 				// this is the case when xNewPackageFolder refers to m_xPackageFolder
1190 				// in case the name was changed and it is not a changed storage - rename the element
1191 				uno::Reference< container::XNamed > xNamed;
1192 				uno::Any aPackageElement = xNewPackageFolder->getByName( (*pElementIter)->m_aOriginalName );
1193 				xNewPackageFolder->removeByName( (*pElementIter)->m_aOriginalName );
1194 				xNewPackageFolder->insertByName( (*pElementIter)->m_aName, aPackageElement );
1195 
1196 				if ( m_nStorageType == embed::StorageFormats::OFOPXML && !(*pElementIter)->m_bIsStorage )
1197 				{
1198 					if ( !(*pElementIter)->m_pStream )
1199 					{
1200 						OpenSubStream( *pElementIter );
1201 						if ( !(*pElementIter)->m_pStream )
1202 							throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1203 					}
1204 
1205 					CommitStreamRelInfo( *pElementIter );
1206 				}
1207 			}
1208 
1209 			(*pElementIter)->m_aOriginalName = (*pElementIter)->m_aName;
1210 		}
1211 	}
1212 
1213 	for ( pElementIter = m_aChildrenList.begin(); pElementIter != m_aChildrenList.end(); pElementIter++ )
1214     {
1215 		// now inserted elements can be inserted to the package
1216 		if ( (*pElementIter)->m_bIsInserted )
1217 		{
1218 			(*pElementIter)->m_aOriginalName = (*pElementIter)->m_aName;
1219 			uno::Reference< lang::XUnoTunnel > xNewElement;
1220 
1221 			if ( (*pElementIter)->m_bIsStorage )
1222 			{
1223 				if ( (*pElementIter)->m_pStorage->m_bCommited )
1224 				{
1225 					OSL_ENSURE( (*pElementIter)->m_pStorage, "An inserted storage is incomplete!\n" );
1226 					if ( !(*pElementIter)->m_pStorage )
1227 						throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1228 
1229 					(*pElementIter)->m_pStorage->InsertIntoPackageFolder( (*pElementIter)->m_aName, xNewPackageFolder );
1230 
1231 					(*pElementIter)->m_bIsInserted = sal_False;
1232 				}
1233 			}
1234 			else
1235 			{
1236 				OSL_ENSURE( (*pElementIter)->m_pStream, "An inserted stream is incomplete!\n" );
1237 				if ( !(*pElementIter)->m_pStream )
1238 					throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1239 
1240 				if ( !(*pElementIter)->m_pStream->IsTransacted() )
1241 					(*pElementIter)->m_pStream->Commit();
1242 
1243 				if ( (*pElementIter)->m_pStream->m_bFlushed )
1244 				{
1245 					if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1246 						CommitStreamRelInfo( *pElementIter );
1247 
1248 					(*pElementIter)->m_pStream->InsertIntoPackageFolder( (*pElementIter)->m_aName, xNewPackageFolder );
1249 
1250 					(*pElementIter)->m_bIsInserted = sal_False;
1251 				}
1252 			}
1253 		}
1254 	}
1255 
1256 	if ( m_nStorageType == embed::StorageFormats::PACKAGE )
1257 	{
1258 		// move properties to the destination package folder
1259 		uno::Reference< beans::XPropertySet > xProps( xNewPackageFolder, uno::UNO_QUERY );
1260 		if ( !xProps.is() )
1261 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1262 
1263 		xProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ), uno::makeAny( m_aMediaType ) );
1264 		xProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ), uno::makeAny( m_aVersion ) );
1265 	}
1266 
1267 	if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1268 		CommitRelInfo( xNewPackageFolder ); // store own relations and commit complete relations storage
1269 
1270 	if ( m_bIsRoot )
1271 	{
1272 		uno::Reference< util::XChangesBatch > xChangesBatch( m_xPackage, uno::UNO_QUERY );
1273 
1274 		OSL_ENSURE( xChangesBatch.is(), "Impossible to commit package!\n" );
1275 		if ( !xChangesBatch.is() )
1276 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1277 
1278 		try
1279 		{
1280 			xChangesBatch->commitChanges();
1281 		}
1282 		catch( lang::WrappedTargetException& r )
1283 		{
1284 			// the wrapped UseBackupException means that the target medium can be corrupted
1285 			embed::UseBackupException aException;
1286 			if ( r.TargetException >>= aException )
1287 			{
1288 				m_xStream = uno::Reference< io::XStream >();
1289 				m_xInputStream = uno::Reference< io::XInputStream >();
1290 				throw aException;
1291 			}
1292 
1293             AddLog( aException.Message );
1294             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
1295             throw;
1296 		}
1297 	}
1298 	else if ( !m_bCommited )
1299 	{
1300 		m_xPackageFolder = xNewPackageFolder;
1301 		m_bCommited = sal_True;
1302 	}
1303 
1304 	// after commit the mediatype treated as the correct one
1305 	m_bMTFallbackUsed = sal_False;
1306 }
1307 
1308 //-----------------------------------------------
Revert()1309 void OStorage_Impl::Revert()
1310 {
1311 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1312 
1313 	if ( !( m_nStorageMode & embed::ElementModes::WRITE ) )
1314 		return; // nothing to do
1315 
1316 	// all the children must be removed
1317 	// they will be created later on demand
1318 
1319 	SotElementList_Impl::iterator pElementIter = m_aChildrenList.begin();
1320 	while (  pElementIter != m_aChildrenList.end() )
1321     {
1322 		if ( (*pElementIter)->m_bIsInserted )
1323 		{
1324 			SotElement_Impl* pToDelete = *pElementIter;
1325 
1326 			pElementIter++; // to let the iterator be valid it should be increased before removing
1327 
1328 			m_aChildrenList.remove( pToDelete );
1329 			delete pToDelete;
1330 		}
1331 		else
1332 		{
1333 			ClearElement( *pElementIter );
1334 
1335 			(*pElementIter)->m_aName = (*pElementIter)->m_aOriginalName;
1336 			(*pElementIter)->m_bIsRemoved = sal_False;
1337 
1338 			pElementIter++;
1339 		}
1340 	}
1341 
1342 	// return replaced removed elements
1343 	for ( SotElementList_Impl::iterator pDeletedIter = m_aDeletedList.begin();
1344 		  pDeletedIter != m_aDeletedList.end();
1345 		  pDeletedIter++ )
1346 	{
1347 		m_aChildrenList.push_back( (*pDeletedIter) );
1348 
1349 		ClearElement( *pDeletedIter );
1350 
1351 		(*pDeletedIter)->m_aName = (*pDeletedIter)->m_aOriginalName;
1352 		(*pDeletedIter)->m_bIsRemoved = sal_False;
1353 	}
1354 	m_aDeletedList.clear();
1355 
1356     m_bControlMediaType = sal_False;
1357     m_bControlVersion = sal_False;
1358 
1359 	GetStorageProperties();
1360 
1361 	if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1362 	{
1363 		// currently the relations storage is changed only on commit
1364 		m_xNewRelInfoStream = uno::Reference< io::XInputStream >();
1365 		m_aRelInfo = uno::Sequence< uno::Sequence< beans::StringPair > >();
1366 		m_nRelInfoStatus = RELINFO_NO_INIT;
1367 	}
1368 }
1369 
1370 //-----------------------------------------------
GetCommonRootEncryptionData()1371 ::comphelper::SequenceAsHashMap OStorage_Impl::GetCommonRootEncryptionData()
1372 	throw ( packages::NoEncryptionException )
1373 {
1374 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() ) ;
1375 
1376 	if ( m_nStorageType != embed::StorageFormats::PACKAGE )
1377 		throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1378 
1379 	if ( m_bIsRoot )
1380 	{
1381 		if ( !m_bHasCommonEncryptionData )
1382 			throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1383 
1384 		return m_aCommonEncryptionData;
1385 	}
1386 	else
1387 	{
1388 		if ( !m_pParent )
1389 			throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1390 
1391 		return m_pParent->GetCommonRootEncryptionData();
1392 	}
1393 }
1394 
1395 //-----------------------------------------------
FindElement(const::rtl::OUString & rName)1396 SotElement_Impl* OStorage_Impl::FindElement( const ::rtl::OUString& rName )
1397 {
1398     OSL_ENSURE( rName.getLength(), "Name is empty!" );
1399 
1400 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1401 
1402 	ReadContents();
1403 
1404 	for ( SotElementList_Impl::iterator pElementIter = m_aChildrenList.begin();
1405 		  pElementIter != m_aChildrenList.end(); pElementIter++ )
1406     {
1407         if ( (*pElementIter)->m_aName == rName && !(*pElementIter)->m_bIsRemoved )
1408             return *pElementIter;
1409 	}
1410 
1411     return NULL;
1412 }
1413 
1414 //-----------------------------------------------
InsertStream(::rtl::OUString aName,sal_Bool bEncr)1415 SotElement_Impl* OStorage_Impl::InsertStream( ::rtl::OUString aName, sal_Bool bEncr )
1416 {
1417 	OSL_ENSURE( m_xPackage.is(), "Not possible to refer to package as to factory!\n" );
1418 	if ( !m_xPackage.is() )
1419 		throw embed::InvalidStorageException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1420 
1421 	uno::Sequence< uno::Any > aSeq( 1 );
1422 	aSeq[0] <<= sal_False;
1423 	uno::Reference< lang::XUnoTunnel > xNewElement( m_xPackage->createInstanceWithArguments( aSeq ),
1424 													uno::UNO_QUERY );
1425 
1426 	OSL_ENSURE( xNewElement.is(), "Not possible to create a new stream!\n" );
1427 	if ( !xNewElement.is() )
1428 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1429 
1430 	uno::Reference< packages::XDataSinkEncrSupport > xPackageSubStream( xNewElement, uno::UNO_QUERY );
1431 	if ( !xPackageSubStream.is() )
1432 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1433 
1434 	OSL_ENSURE( m_nStorageType == embed::StorageFormats::PACKAGE || !bEncr, "Only package storage supports encryption!\n" );
1435 	if ( m_nStorageType != embed::StorageFormats::PACKAGE && bEncr )
1436 		throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1437 
1438 	// the mode is not needed for storage stream internal implementation
1439 	SotElement_Impl* pNewElement = InsertElement( aName, sal_False );
1440 	pNewElement->m_pStream = new OWriteStream_Impl( this, xPackageSubStream, m_xPackage, m_xFactory, bEncr, m_nStorageType, sal_True );
1441 
1442 	m_aChildrenList.push_back( pNewElement );
1443 	m_bIsModified = sal_True;
1444 	m_bBroadcastModified = sal_True;
1445 
1446 	return pNewElement;
1447 }
1448 
1449 //-----------------------------------------------
InsertRawStream(::rtl::OUString aName,const uno::Reference<io::XInputStream> & xInStream)1450 SotElement_Impl* OStorage_Impl::InsertRawStream( ::rtl::OUString aName, const uno::Reference< io::XInputStream >& xInStream )
1451 {
1452 	// insert of raw stream means insert and commit
1453 	OSL_ENSURE( m_xPackage.is(), "Not possible to refer to package as to factory!\n" );
1454 	if ( !m_xPackage.is() )
1455 		throw embed::InvalidStorageException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1456 
1457 	if ( m_nStorageType != embed::StorageFormats::PACKAGE )
1458 		throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1459 
1460 	uno::Reference< io::XSeekable > xSeek( xInStream, uno::UNO_QUERY );
1461 	uno::Reference< io::XInputStream > xInStrToInsert = xSeek.is() ? xInStream :
1462 																	 GetSeekableTempCopy( xInStream, GetServiceFactory() );
1463 
1464 	uno::Sequence< uno::Any > aSeq( 1 );
1465 	aSeq[0] <<= sal_False;
1466 	uno::Reference< lang::XUnoTunnel > xNewElement( m_xPackage->createInstanceWithArguments( aSeq ),
1467 													uno::UNO_QUERY );
1468 
1469 	OSL_ENSURE( xNewElement.is(), "Not possible to create a new stream!\n" );
1470 	if ( !xNewElement.is() )
1471 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1472 
1473 	uno::Reference< packages::XDataSinkEncrSupport > xPackageSubStream( xNewElement, uno::UNO_QUERY );
1474 	if ( !xPackageSubStream.is() )
1475 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1476 
1477 	xPackageSubStream->setRawStream( xInStrToInsert );
1478 
1479 	// the mode is not needed for storage stream internal implementation
1480 	SotElement_Impl* pNewElement = InsertElement( aName, sal_False );
1481 	pNewElement->m_pStream = new OWriteStream_Impl( this, xPackageSubStream, m_xPackage, m_xFactory, sal_True, m_nStorageType, sal_False );
1482 	// the stream is inserted and must be treated as a committed one
1483 	pNewElement->m_pStream->SetToBeCommited();
1484 
1485 	m_aChildrenList.push_back( pNewElement );
1486 	m_bIsModified = sal_True;
1487 	m_bBroadcastModified = sal_True;
1488 
1489 	return pNewElement;
1490 }
1491 
1492 //-----------------------------------------------
CreateNewStorageImpl(sal_Int32 nStorageMode)1493 OStorage_Impl* OStorage_Impl::CreateNewStorageImpl( sal_Int32 nStorageMode )
1494 {
1495 	OSL_ENSURE( m_xPackage.is(), "Not possible to refer to package as to factory!\n" );
1496 	if ( !m_xPackage.is() )
1497 		throw embed::InvalidStorageException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1498 
1499 	uno::Sequence< uno::Any > aSeq( 1 );
1500 	aSeq[0] <<= sal_True;
1501 	uno::Reference< lang::XUnoTunnel > xNewElement( m_xPackage->createInstanceWithArguments( aSeq ),
1502 													uno::UNO_QUERY );
1503 
1504 	OSL_ENSURE( xNewElement.is(), "Not possible to create a new storage!\n" );
1505 	if ( !xNewElement.is() )
1506 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1507 
1508 	uno::Reference< container::XNameContainer > xPackageSubFolder( xNewElement, uno::UNO_QUERY );
1509 	if ( !xPackageSubFolder.is() )
1510 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1511 
1512 	OStorage_Impl* pResult =
1513 			new OStorage_Impl( this, nStorageMode, xPackageSubFolder, m_xPackage, m_xFactory, m_nStorageType );
1514 	pResult->m_bIsModified = sal_True;
1515 
1516 	return pResult;
1517 }
1518 
1519 //-----------------------------------------------
InsertStorage(::rtl::OUString aName,sal_Int32 nStorageMode)1520 SotElement_Impl* OStorage_Impl::InsertStorage( ::rtl::OUString aName, sal_Int32 nStorageMode )
1521 {
1522 	SotElement_Impl* pNewElement = InsertElement( aName, sal_True );
1523 
1524 	pNewElement->m_pStorage = CreateNewStorageImpl( nStorageMode );
1525 
1526 	m_aChildrenList.push_back( pNewElement );
1527 
1528 	return pNewElement;
1529 }
1530 
1531 //-----------------------------------------------
InsertElement(::rtl::OUString aName,sal_Bool bIsStorage)1532 SotElement_Impl* OStorage_Impl::InsertElement( ::rtl::OUString aName, sal_Bool bIsStorage )
1533 {
1534     OSL_ENSURE( FindElement( aName ) == NULL, "Should not try to insert existing element" );
1535 
1536 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1537 
1538     SotElement_Impl* pDeletedElm = NULL;
1539 
1540 	for ( SotElementList_Impl::iterator pElementIter = m_aChildrenList.begin();
1541 		  pElementIter != m_aChildrenList.end(); pElementIter++ )
1542     {
1543         if ( (*pElementIter)->m_aName == aName )
1544 		{
1545 			OSL_ENSURE( (*pElementIter)->m_bIsRemoved, "Try to insert an element instead of existing one!\n" );
1546 			if ( (*pElementIter)->m_bIsRemoved )
1547 			{
1548 				OSL_ENSURE( !(*pElementIter)->m_bIsInserted, "Inserted elements must be deleted immediately!\n" );
1549             	pDeletedElm = *pElementIter;
1550 				break;
1551 			}
1552 		}
1553     }
1554 
1555 	if ( pDeletedElm )
1556 	{
1557 		if ( pDeletedElm->m_bIsStorage )
1558 			OpenSubStorage( pDeletedElm, embed::ElementModes::READWRITE );
1559 		else
1560 			OpenSubStream( pDeletedElm );
1561 
1562         m_aChildrenList.remove( pDeletedElm );  // correct usage of list ???
1563 		m_aDeletedList.push_back( pDeletedElm );
1564 	}
1565 
1566 	// create new element
1567 	return new SotElement_Impl( aName, bIsStorage, sal_True );
1568 }
1569 
1570 //-----------------------------------------------
OpenSubStorage(SotElement_Impl * pElement,sal_Int32 nStorageMode)1571 void OStorage_Impl::OpenSubStorage( SotElement_Impl* pElement, sal_Int32 nStorageMode )
1572 {
1573 	OSL_ENSURE( pElement, "pElement is not set!\n" );
1574 	OSL_ENSURE( pElement->m_bIsStorage, "Storage flag is not set!\n" );
1575 
1576 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1577 
1578 	if ( !pElement->m_pStorage )
1579 	{
1580 		OSL_ENSURE( !pElement->m_bIsInserted, "Inserted element must be created already!\n" );
1581 
1582 		uno::Reference< lang::XUnoTunnel > xTunnel;
1583 		m_xPackageFolder->getByName( pElement->m_aOriginalName ) >>= xTunnel;
1584 		if ( !xTunnel.is() )
1585 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1586 
1587 		uno::Reference< container::XNameContainer > xPackageSubFolder( xTunnel, uno::UNO_QUERY );
1588 
1589 		OSL_ENSURE( xPackageSubFolder.is(), "Can not get XNameContainer interface from folder!\n" );
1590 
1591 		if ( !xPackageSubFolder.is() )
1592 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1593 
1594 		pElement->m_pStorage = new OStorage_Impl( this, nStorageMode, xPackageSubFolder, m_xPackage, m_xFactory, m_nStorageType );
1595 	}
1596 }
1597 
1598 //-----------------------------------------------
OpenSubStream(SotElement_Impl * pElement)1599 void OStorage_Impl::OpenSubStream( SotElement_Impl* pElement )
1600 {
1601 	OSL_ENSURE( pElement, "pElement is not set!\n" );
1602 	OSL_ENSURE( !pElement->m_bIsStorage, "Storage flag is set!\n" );
1603 
1604 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1605 
1606 	if ( !pElement->m_pStream )
1607 	{
1608 		OSL_ENSURE( !pElement->m_bIsInserted, "Inserted element must be created already!\n" );
1609 
1610 		uno::Reference< lang::XUnoTunnel > xTunnel;
1611 		m_xPackageFolder->getByName( pElement->m_aOriginalName ) >>= xTunnel;
1612 		if ( !xTunnel.is() )
1613 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1614 
1615 		uno::Reference< packages::XDataSinkEncrSupport > xPackageSubStream( xTunnel, uno::UNO_QUERY );
1616 		if ( !xPackageSubStream.is() )
1617 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1618 
1619 		// the stream can never be inserted here, because inserted stream element holds the stream till commit or destruction
1620         pElement->m_pStream = new OWriteStream_Impl( this, xPackageSubStream, m_xPackage, m_xFactory, sal_False, m_nStorageType, sal_False, GetRelInfoStreamForName( pElement->m_aOriginalName ) );
1621 	}
1622 }
1623 
1624 //-----------------------------------------------
GetElementNames()1625 uno::Sequence< ::rtl::OUString > OStorage_Impl::GetElementNames()
1626 {
1627 	::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
1628 
1629 	ReadContents();
1630 
1631 	sal_uInt32 nSize = m_aChildrenList.size();
1632 	uno::Sequence< ::rtl::OUString > aElementNames( nSize );
1633 
1634 	sal_uInt32 nInd = 0;
1635     for ( SotElementList_Impl::iterator pElementIter = m_aChildrenList.begin();
1636 		  pElementIter != m_aChildrenList.end(); pElementIter++ )
1637 	{
1638 		if ( !(*pElementIter)->m_bIsRemoved )
1639         	aElementNames[nInd++] = (*pElementIter)->m_aName;
1640 	}
1641 
1642 	aElementNames.realloc( nInd );
1643     return aElementNames;
1644 }
1645 
1646 //-----------------------------------------------
RemoveElement(SotElement_Impl * pElement)1647 void OStorage_Impl::RemoveElement( SotElement_Impl* pElement )
1648 {
1649 	OSL_ENSURE( pElement, "Element must be provided!" );
1650 
1651 	if ( !pElement )
1652 		return;
1653 
1654 	if ( (pElement->m_pStorage && ( pElement->m_pStorage->m_pAntiImpl || !pElement->m_pStorage->m_aReadOnlyWrapList.empty() ))
1655 	  || (pElement->m_pStream && ( pElement->m_pStream->m_pAntiImpl || !pElement->m_pStream->m_aInputStreamsList.empty() )) )
1656 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: Access denied
1657 
1658 	if ( pElement->m_bIsInserted )
1659 	{
1660 		m_aChildrenList.remove( pElement );
1661 		delete pElement; // ???
1662 	}
1663 	else
1664 	{
1665 		pElement->m_bIsRemoved = sal_True;
1666 		ClearElement( pElement );
1667 	}
1668 
1669 	// TODO/OFOPXML: the rel stream should be removed as well
1670 }
1671 
1672 //-----------------------------------------------
ClearElement(SotElement_Impl * pElement)1673 void OStorage_Impl::ClearElement( SotElement_Impl* pElement )
1674 {
1675 	if ( pElement->m_pStorage )
1676 	{
1677 		delete pElement->m_pStorage;
1678 		pElement->m_pStorage = NULL;
1679 	}
1680 
1681 	if ( pElement->m_pStream )
1682 	{
1683 		delete pElement->m_pStream;
1684 		pElement->m_pStream = NULL;
1685 	}
1686 }
1687 
1688 //-----------------------------------------------
CloneStreamElement(const::rtl::OUString & aStreamName,sal_Bool bEncryptionDataProvided,const::comphelper::SequenceAsHashMap & aEncryptionData,uno::Reference<io::XStream> & xTargetStream)1689 void OStorage_Impl::CloneStreamElement( const ::rtl::OUString& aStreamName,
1690 										sal_Bool bEncryptionDataProvided,
1691 										const ::comphelper::SequenceAsHashMap& aEncryptionData,
1692 										uno::Reference< io::XStream >& xTargetStream )
1693 		throw ( embed::InvalidStorageException,
1694 				lang::IllegalArgumentException,
1695 				packages::WrongPasswordException,
1696 				io::IOException,
1697 				embed::StorageWrappedTargetException,
1698 				uno::RuntimeException )
1699 {
1700     SotElement_Impl *pElement = FindElement( aStreamName );
1701     if ( !pElement )
1702     {
1703         // element does not exist, throw exception
1704 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access_denied
1705     }
1706 	else if ( pElement->m_bIsStorage )
1707 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1708 
1709 	if ( !pElement->m_pStream )
1710 		OpenSubStream( pElement );
1711 
1712 	if ( pElement->m_pStream && pElement->m_pStream->m_xPackageStream.is() )
1713     {
1714 		// the existence of m_pAntiImpl of the child is not interesting,
1715 		// the copy will be created internally
1716 
1717 		// usual copying is not applicable here, only last flushed version of the
1718 		// child stream should be used for copiing. Probably the childs m_xPackageStream
1719 		// can be used as a base of a new stream, that would be copied to result
1720 		// storage. The only problem is that some package streams can be accessed from outside
1721 		// at the same time ( now solwed by wrappers that remember own position ).
1722 
1723 		if ( bEncryptionDataProvided )
1724 			pElement->m_pStream->GetCopyOfLastCommit( xTargetStream, aEncryptionData );
1725 		else
1726 			pElement->m_pStream->GetCopyOfLastCommit( xTargetStream );
1727 	}
1728 	else
1729 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: general_error
1730 }
1731 
1732 //-----------------------------------------------
RemoveStreamRelInfo(const::rtl::OUString & aOriginalName)1733 void OStorage_Impl::RemoveStreamRelInfo( const ::rtl::OUString& aOriginalName )
1734 {
1735 	// this method should be used only in OStorage_Impl::Commit() method
1736 	// the aOriginalName can be empty, in this case the storage relation info should be removed
1737 
1738 	if ( m_nStorageType == embed::StorageFormats::OFOPXML && m_xRelStorage.is() )
1739 	{
1740 		::rtl::OUString aRelStreamName = aOriginalName;
1741 		aRelStreamName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".rels" ) );
1742 
1743 		if ( m_xRelStorage->hasByName( aRelStreamName ) )
1744 			m_xRelStorage->removeElement( aRelStreamName );
1745 	}
1746 }
1747 
1748 //-----------------------------------------------
CreateRelStorage()1749 void OStorage_Impl::CreateRelStorage()
1750 {
1751 	if ( m_nStorageType != embed::StorageFormats::OFOPXML )
1752 		return;
1753 
1754 	if ( !m_xRelStorage.is() )
1755 	{
1756 		if ( !m_pRelStorElement )
1757 		{
1758 			m_pRelStorElement = new SotElement_Impl( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ), sal_True, sal_True );
1759 			m_pRelStorElement->m_pStorage = CreateNewStorageImpl( embed::ElementModes::WRITE );
1760 			if ( m_pRelStorElement->m_pStorage )
1761 				m_pRelStorElement->m_pStorage->m_pParent = NULL; // the relation storage is completely controlled by parent
1762 		}
1763 
1764 		if ( !m_pRelStorElement->m_pStorage )
1765 			OpenSubStorage( m_pRelStorElement, embed::ElementModes::WRITE );
1766 
1767 		if ( !m_pRelStorElement->m_pStorage )
1768 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1769 
1770 		OStorage* pResultStorage = new OStorage( m_pRelStorElement->m_pStorage, sal_False );
1771 		m_xRelStorage = uno::Reference< embed::XStorage >( (embed::XStorage*) pResultStorage );
1772 	}
1773 }
1774 
1775 //-----------------------------------------------
CommitStreamRelInfo(SotElement_Impl * pStreamElement)1776 void OStorage_Impl::CommitStreamRelInfo( SotElement_Impl* pStreamElement )
1777 {
1778 	// this method should be used only in OStorage_Impl::Commit() method
1779 
1780 	// the stream element must be provided
1781 	if ( !pStreamElement )
1782 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1783 
1784 	if ( m_nStorageType == embed::StorageFormats::OFOPXML && pStreamElement->m_pStream )
1785 	{
1786 		OSL_ENSURE( pStreamElement->m_aName.getLength(), "The name must not be empty!\n" );
1787 
1788 		if ( !m_xRelStorage.is() )
1789 		{
1790 			// Create new rels storage, this is commit scenario so it must be possible
1791 			CreateRelStorage();
1792 		}
1793 
1794 		pStreamElement->m_pStream->CommitStreamRelInfo( m_xRelStorage, pStreamElement->m_aOriginalName, pStreamElement->m_aName );
1795 	}
1796 }
1797 
1798 //-----------------------------------------------
GetRelInfoStreamForName(const::rtl::OUString & aName)1799 uno::Reference< io::XInputStream > OStorage_Impl::GetRelInfoStreamForName( const ::rtl::OUString& aName )
1800 {
1801 	if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1802 	{
1803 		ReadContents();
1804 		if ( m_xRelStorage.is() )
1805 		{
1806 			::rtl::OUString aRelStreamName = aName;
1807 			aRelStreamName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".rels" ) );
1808 			if ( m_xRelStorage->hasByName( aRelStreamName ) )
1809 			{
1810 				uno::Reference< io::XStream > xStream = m_xRelStorage->openStreamElement( aRelStreamName, embed::ElementModes::READ );
1811 				if ( xStream.is() )
1812 					return xStream->getInputStream();
1813 			}
1814 		}
1815 	}
1816 
1817 	return uno::Reference< io::XInputStream >();
1818 }
1819 
1820 //-----------------------------------------------
CommitRelInfo(const uno::Reference<container::XNameContainer> & xNewPackageFolder)1821 void OStorage_Impl::CommitRelInfo( const uno::Reference< container::XNameContainer >& xNewPackageFolder )
1822 {
1823 	// this method should be used only in OStorage_Impl::Commit() method
1824 	::rtl::OUString aRelsStorName( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) );
1825 
1826 	if ( !xNewPackageFolder.is() )
1827 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1828 
1829 	if ( m_nStorageType == embed::StorageFormats::OFOPXML )
1830 	{
1831 		if ( m_nRelInfoStatus == RELINFO_BROKEN || m_nRelInfoStatus == RELINFO_CHANGED_BROKEN )
1832 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1833 
1834 		if ( m_nRelInfoStatus == RELINFO_CHANGED
1835 		  || m_nRelInfoStatus == RELINFO_CHANGED_STREAM_READ
1836 		  || m_nRelInfoStatus == RELINFO_CHANGED_STREAM )
1837 		{
1838 			if ( m_nRelInfoStatus == RELINFO_CHANGED )
1839 			{
1840 				if ( m_aRelInfo.getLength() )
1841 				{
1842 					CreateRelStorage();
1843 
1844 					uno::Reference< io::XStream > xRelsStream =
1845 						m_xRelStorage->openStreamElement( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".rels" ) ),
1846 															embed::ElementModes::TRUNCATE | embed::ElementModes::READWRITE );
1847 
1848 					uno::Reference< io::XOutputStream > xOutStream = xRelsStream->getOutputStream();
1849 					if ( !xOutStream.is() )
1850 						throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1851 
1852 					::comphelper::OFOPXMLHelper::WriteRelationsInfoSequence( xOutStream, m_aRelInfo, m_xFactory );
1853 
1854 					// set the mediatype
1855 					uno::Reference< beans::XPropertySet > xPropSet( xRelsStream, uno::UNO_QUERY_THROW );
1856 					xPropSet->setPropertyValue(
1857 						::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ),
1858 						uno::makeAny( ::rtl::OUString(
1859 						 	RTL_CONSTASCII_USTRINGPARAM( "application/vnd.openxmlformats-package.relationships+xml" ) ) ) );
1860 
1861 					m_nRelInfoStatus = RELINFO_READ;
1862 				}
1863 				else if ( m_xRelStorage.is() )
1864 					RemoveStreamRelInfo( ::rtl::OUString() ); // remove own rel info
1865 			}
1866 			else if ( m_nRelInfoStatus == RELINFO_CHANGED_STREAM_READ
1867 		  			|| m_nRelInfoStatus == RELINFO_CHANGED_STREAM )
1868 			{
1869 				CreateRelStorage();
1870 
1871 				uno::Reference< io::XStream > xRelsStream =
1872 					m_xRelStorage->openStreamElement( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".rels" ) ),
1873 														embed::ElementModes::TRUNCATE | embed::ElementModes::READWRITE );
1874 
1875 				uno::Reference< io::XOutputStream > xOutputStream = xRelsStream->getOutputStream();
1876 				if ( !xOutputStream.is() )
1877 					throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
1878 
1879 				uno::Reference< io::XSeekable > xSeek( m_xNewRelInfoStream, uno::UNO_QUERY_THROW );
1880 				xSeek->seek( 0 );
1881 				::comphelper::OStorageHelper::CopyInputToOutput( m_xNewRelInfoStream, xOutputStream );
1882 
1883 				// set the mediatype
1884 				uno::Reference< beans::XPropertySet > xPropSet( xRelsStream, uno::UNO_QUERY_THROW );
1885 				xPropSet->setPropertyValue(
1886 					::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ),
1887 					uno::makeAny( ::rtl::OUString(
1888 					 	RTL_CONSTASCII_USTRINGPARAM( "application/vnd.openxmlformats-package.relationships+xml" ) ) ) );
1889 
1890 				m_xNewRelInfoStream = uno::Reference< io::XInputStream >();
1891 		  		if ( m_nRelInfoStatus == RELINFO_CHANGED_STREAM )
1892 				{
1893 					m_aRelInfo = uno::Sequence< uno::Sequence< beans::StringPair > >();
1894 					m_nRelInfoStatus = RELINFO_NO_INIT;
1895 				}
1896 				else
1897 					m_nRelInfoStatus = RELINFO_READ;
1898 			}
1899 		}
1900 
1901 		if ( m_xRelStorage.is() )
1902 		{
1903 			if ( m_xRelStorage->hasElements() )
1904 			{
1905 				uno::Reference< embed::XTransactedObject > xTrans( m_xRelStorage, uno::UNO_QUERY_THROW );
1906 				if ( xTrans.is() )
1907 					xTrans->commit();
1908 			}
1909 
1910 			if ( xNewPackageFolder.is() && xNewPackageFolder->hasByName( aRelsStorName ) )
1911 				xNewPackageFolder->removeByName( aRelsStorName );
1912 
1913 			if ( !m_xRelStorage->hasElements() )
1914 			{
1915 				// the empty relations storage should not be created
1916 				delete m_pRelStorElement;
1917 				m_pRelStorElement = NULL;
1918 				m_xRelStorage = uno::Reference< embed::XStorage >();
1919 			}
1920 			else if ( m_pRelStorElement && m_pRelStorElement->m_pStorage && xNewPackageFolder.is() )
1921 				m_pRelStorElement->m_pStorage->InsertIntoPackageFolder( aRelsStorName, xNewPackageFolder );
1922 		}
1923 	}
1924 }
1925 
1926 //=====================================================
1927 // OStorage implementation
1928 //=====================================================
1929 
1930 //-----------------------------------------------
OStorage(uno::Reference<io::XInputStream> xInputStream,sal_Int32 nMode,uno::Sequence<beans::PropertyValue> xProperties,uno::Reference<lang::XMultiServiceFactory> xFactory,sal_Int32 nStorageType)1931 OStorage::OStorage(	uno::Reference< io::XInputStream > xInputStream,
1932 					sal_Int32 nMode,
1933 					uno::Sequence< beans::PropertyValue > xProperties,
1934 					uno::Reference< lang::XMultiServiceFactory > xFactory,
1935 					sal_Int32 nStorageType )
1936 : m_pImpl( new OStorage_Impl( xInputStream, nMode, xProperties, xFactory, nStorageType ) )
1937 {
1938 	m_pImpl->m_pAntiImpl = this;
1939 	m_pData = new StorInternalData_Impl( m_pImpl->m_rMutexRef, m_pImpl->m_bIsRoot, m_pImpl->m_nStorageType, sal_False );
1940 }
1941 
1942 //-----------------------------------------------
OStorage(uno::Reference<io::XStream> xStream,sal_Int32 nMode,uno::Sequence<beans::PropertyValue> xProperties,uno::Reference<lang::XMultiServiceFactory> xFactory,sal_Int32 nStorageType)1943 OStorage::OStorage(	uno::Reference< io::XStream > xStream,
1944 					sal_Int32 nMode,
1945 					uno::Sequence< beans::PropertyValue > xProperties,
1946 					uno::Reference< lang::XMultiServiceFactory > xFactory,
1947 					sal_Int32 nStorageType )
1948 : m_pImpl( new OStorage_Impl( xStream, nMode, xProperties, xFactory, nStorageType ) )
1949 {
1950 	m_pImpl->m_pAntiImpl = this;
1951 	m_pData = new StorInternalData_Impl( m_pImpl->m_rMutexRef, m_pImpl->m_bIsRoot, m_pImpl->m_nStorageType, sal_False );
1952 }
1953 
1954 //-----------------------------------------------
OStorage(OStorage_Impl * pImpl,sal_Bool bReadOnlyWrap)1955 OStorage::OStorage(	OStorage_Impl* pImpl, sal_Bool bReadOnlyWrap )
1956 : m_pImpl( pImpl )
1957 {
1958 	// this call can be done only from OStorage_Impl implementation to create child storage
1959 	OSL_ENSURE( m_pImpl && m_pImpl->m_rMutexRef.Is(), "The provided pointer & mutex MUST NOT be empty!\n" );
1960 
1961 	m_pData = new StorInternalData_Impl( m_pImpl->m_rMutexRef, m_pImpl->m_bIsRoot, m_pImpl->m_nStorageType, bReadOnlyWrap );
1962 
1963 	OSL_ENSURE( ( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE ) == embed::ElementModes::WRITE ||
1964 					m_pData->m_bReadOnlyWrap,
1965 				"The wrapper can not allow writing in case implementation does not!\n" );
1966 
1967 	if ( !bReadOnlyWrap )
1968 		m_pImpl->m_pAntiImpl = this;
1969 }
1970 
1971 //-----------------------------------------------
~OStorage()1972 OStorage::~OStorage()
1973 {
1974 	{
1975 		::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
1976 		if ( m_pImpl )
1977 		{
1978 			m_refCount++; // to call dispose
1979 			try {
1980 				dispose();
1981 			}
1982 			catch( uno::RuntimeException& aRuntimeException )
1983 			{
1984                 m_pImpl->AddLog( aRuntimeException.Message );
1985                 m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Handled exception" ) ) );
1986             }
1987 		}
1988 	}
1989 
1990 	if ( m_pData )
1991 	{
1992 		if ( m_pData->m_pSubElDispListener )
1993 		{
1994 			m_pData->m_pSubElDispListener->release();
1995 			m_pData->m_pSubElDispListener = NULL;
1996 		}
1997 
1998 		if ( m_pData->m_pTypeCollection )
1999 		{
2000 			delete m_pData->m_pTypeCollection;
2001 			m_pData->m_pTypeCollection = NULL;
2002 		}
2003 
2004 		delete m_pData;
2005 	}
2006 }
2007 
2008 //-----------------------------------------------
InternalDispose(sal_Bool bNotifyImpl)2009 void SAL_CALL OStorage::InternalDispose( sal_Bool bNotifyImpl )
2010 {
2011 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::InternalDispose" );
2012 
2013 	if ( !m_pImpl )
2014     {
2015         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
2016         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2017     }
2018 
2019 	// the source object is also a kind of locker for the current object
2020 	// since the listeners could dispose the object while being notified
2021    	lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
2022 	m_pData->m_aListenersContainer.disposeAndClear( aSource );
2023 
2024 	if ( m_pData->m_bReadOnlyWrap )
2025 	{
2026 		OSL_ENSURE( !m_pData->m_aOpenSubComponentsList.size() || m_pData->m_pSubElDispListener,
2027 					"If any subelements are open the listener must exist!\n" );
2028 
2029 		if ( m_pData->m_pSubElDispListener )
2030 		{
2031 			m_pData->m_pSubElDispListener->OwnerIsDisposed();
2032 
2033 			// iterate through m_pData->m_aOpenSubComponentsList
2034 			// deregister m_pData->m_pSubElDispListener and dispose all of them
2035 			if ( !m_pData->m_aOpenSubComponentsList.empty() )
2036 			{
2037 				for ( WeakComponentList::iterator pCompIter = m_pData->m_aOpenSubComponentsList.begin();
2038 				  	pCompIter != m_pData->m_aOpenSubComponentsList.end(); pCompIter++ )
2039 				{
2040 					uno::Reference< lang::XComponent > xTmp = (*pCompIter);
2041 					if ( xTmp.is() )
2042 					{
2043 						xTmp->removeEventListener( uno::Reference< lang::XEventListener >(
2044 									static_cast< lang::XEventListener* >( m_pData->m_pSubElDispListener ) ) );
2045 
2046 						try {
2047 							xTmp->dispose();
2048 						} catch( uno::Exception& aException )
2049                         {
2050                             m_pImpl->AddLog( aException.Message );
2051                             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
2052                         }
2053 					}
2054 				}
2055 
2056 				m_pData->m_aOpenSubComponentsList.clear();
2057 			}
2058 		}
2059 
2060 		if ( bNotifyImpl )
2061 			m_pImpl->RemoveReadOnlyWrap( *this );
2062 	}
2063 	else
2064 	{
2065 		m_pImpl->m_pAntiImpl = NULL;
2066 
2067 		if ( bNotifyImpl )
2068 		{
2069 			if ( m_pData->m_bIsRoot )
2070 				delete m_pImpl;
2071 			else
2072 			{
2073 				// the noncommited changes for the storage must be removed
2074 				m_pImpl->Revert();
2075 			}
2076 		}
2077 	}
2078 
2079 	m_pImpl = NULL;
2080 }
2081 
2082 //-----------------------------------------------
ChildIsDisposed(const uno::Reference<uno::XInterface> & xChild)2083 void OStorage::ChildIsDisposed( const uno::Reference< uno::XInterface >& xChild )
2084 {
2085 	// this method can only be called by child disposing listener
2086 
2087 	// this method must not contain any locking
2088 	// the locking is done in the listener
2089 
2090 	if ( !m_pData->m_aOpenSubComponentsList.empty() )
2091 	{
2092 		for ( WeakComponentList::iterator pCompIter = m_pData->m_aOpenSubComponentsList.begin();
2093 		  	pCompIter != m_pData->m_aOpenSubComponentsList.end(); )
2094 		{
2095 			uno::Reference< lang::XComponent > xTmp = (*pCompIter);
2096 			if ( !xTmp.is() || xTmp == xChild )
2097 			{
2098 				WeakComponentList::iterator pIterToRemove = pCompIter;
2099 				pCompIter++;
2100 				m_pData->m_aOpenSubComponentsList.erase( pIterToRemove );
2101 			}
2102 			else
2103 				pCompIter++;
2104 		}
2105 	}
2106 }
2107 
2108 //-----------------------------------------------
BroadcastModifiedIfNecessary()2109 void OStorage::BroadcastModifiedIfNecessary()
2110 {
2111 	// no need to lock mutex here for the checking of m_pImpl, and m_pData is alive until the object is destructed
2112 	if ( !m_pImpl )
2113     {
2114         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
2115         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2116     }
2117 
2118 	if ( !m_pImpl->m_bBroadcastModified )
2119 		return;
2120 
2121 	m_pImpl->m_bBroadcastModified = sal_False;
2122 
2123 	OSL_ENSURE( !m_pData->m_bReadOnlyWrap, "The storage can not be modified at all!\n" );
2124 
2125    	lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
2126 
2127    	::cppu::OInterfaceContainerHelper* pContainer =
2128 			m_pData->m_aListenersContainer.getContainer(
2129 				::getCppuType( ( const uno::Reference< util::XModifyListener >*) NULL ) );
2130    	if ( pContainer )
2131 	{
2132        	::cppu::OInterfaceIteratorHelper pIterator( *pContainer );
2133        	while ( pIterator.hasMoreElements( ) )
2134        	{
2135            	( ( util::XModifyListener* )pIterator.next( ) )->modified( aSource );
2136        	}
2137 	}
2138 }
2139 
2140 //-----------------------------------------------
BroadcastTransaction(sal_Int8 nMessage)2141 void OStorage::BroadcastTransaction( sal_Int8 nMessage )
2142 /*
2143 	1 - preCommit
2144 	2 - committed
2145 	3 - preRevert
2146 	4 - reverted
2147 */
2148 {
2149 	// no need to lock mutex here for the checking of m_pImpl, and m_pData is alive until the object is destructed
2150 	if ( !m_pImpl )
2151     {
2152         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
2153         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2154     }
2155 
2156 	OSL_ENSURE( !m_pData->m_bReadOnlyWrap, "The storage can not be modified at all!\n" );
2157 
2158    	lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
2159 
2160    	::cppu::OInterfaceContainerHelper* pContainer =
2161 			m_pData->m_aListenersContainer.getContainer(
2162 				::getCppuType( ( const uno::Reference< embed::XTransactionListener >*) NULL ) );
2163    	if ( pContainer )
2164 	{
2165        	::cppu::OInterfaceIteratorHelper pIterator( *pContainer );
2166        	while ( pIterator.hasMoreElements( ) )
2167        	{
2168 			OSL_ENSURE( nMessage >= 1 && nMessage <= 4, "Wrong internal notification code is used!\n" );
2169 
2170 			switch( nMessage )
2171 			{
2172 				case STOR_MESS_PRECOMMIT:
2173            			( ( embed::XTransactionListener* )pIterator.next( ) )->preCommit( aSource );
2174 					break;
2175 				case STOR_MESS_COMMITED:
2176            			( ( embed::XTransactionListener* )pIterator.next( ) )->commited( aSource );
2177 					break;
2178 				case STOR_MESS_PREREVERT:
2179            			( ( embed::XTransactionListener* )pIterator.next( ) )->preRevert( aSource );
2180 					break;
2181 				case STOR_MESS_REVERTED:
2182            			( ( embed::XTransactionListener* )pIterator.next( ) )->reverted( aSource );
2183 					break;
2184 			}
2185        	}
2186 	}
2187 }
2188 
2189 //-----------------------------------------------
OpenStreamElement_Impl(const::rtl::OUString & aStreamName,sal_Int32 nOpenMode,sal_Bool bEncr)2190 SotElement_Impl* OStorage::OpenStreamElement_Impl( const ::rtl::OUString& aStreamName, sal_Int32 nOpenMode, sal_Bool bEncr )
2191 {
2192 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
2193 
2194 	OSL_ENSURE( !m_pData->m_bReadOnlyWrap || ( nOpenMode & embed::ElementModes::WRITE ) != embed::ElementModes::WRITE,
2195 				"An element can not be opened for writing in readonly storage!\n" );
2196 
2197     SotElement_Impl *pElement = m_pImpl->FindElement( aStreamName );
2198     if ( !pElement )
2199     {
2200         // element does not exist, check if creation is allowed
2201 		if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE )
2202           || (( nOpenMode & embed::ElementModes::WRITE ) != embed::ElementModes::WRITE )
2203           || ( nOpenMode & embed::ElementModes::NOCREATE ) == embed::ElementModes::NOCREATE )
2204 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access_denied
2205 
2206         // create a new StreamElement and insert it into the list
2207 		pElement = m_pImpl->InsertStream( aStreamName, bEncr );
2208     }
2209 	else if ( pElement->m_bIsStorage )
2210 	{
2211 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2212 	}
2213 
2214 	OSL_ENSURE( pElement, "In case element can not be created an exception must be thrown!" );
2215 
2216 	if ( !pElement->m_pStream )
2217 		m_pImpl->OpenSubStream( pElement );
2218 
2219 	if ( !pElement->m_pStream )
2220 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2221 
2222 	return pElement;
2223 }
2224 
2225 //-----------------------------------------------
MakeLinkToSubComponent_Impl(const uno::Reference<lang::XComponent> & xComponent)2226 void OStorage::MakeLinkToSubComponent_Impl( const uno::Reference< lang::XComponent >& xComponent )
2227 {
2228 	if ( !xComponent.is() )
2229 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2230 
2231 	if ( !m_pData->m_pSubElDispListener )
2232 	{
2233 		m_pData->m_pSubElDispListener = new OChildDispListener_Impl( *this );
2234 		m_pData->m_pSubElDispListener->acquire();
2235 	}
2236 
2237 	xComponent->addEventListener( uno::Reference< lang::XEventListener >(
2238 		static_cast< ::cppu::OWeakObject* >( m_pData->m_pSubElDispListener ), uno::UNO_QUERY ) );
2239 
2240 	m_pData->m_aOpenSubComponentsList.push_back( xComponent );
2241 }
2242 
2243 //____________________________________________________________________________________________________
2244 //	XInterface
2245 //____________________________________________________________________________________________________
2246 
2247 //-----------------------------------------------
queryInterface(const uno::Type & rType)2248 uno::Any SAL_CALL OStorage::queryInterface( const uno::Type& rType )
2249 		throw( uno::RuntimeException )
2250 {
2251 	uno::Any aReturn;
2252 
2253 	// common interfaces
2254 	aReturn <<= ::cppu::queryInterface
2255 				(	rType
2256 				,	static_cast<lang::XTypeProvider*> ( this )
2257 				,	static_cast<embed::XStorage*> ( this )
2258 				,	static_cast<embed::XStorage2*> ( this )
2259 				,	static_cast<embed::XTransactedObject*> ( this )
2260 				,	static_cast<embed::XTransactionBroadcaster*> ( this )
2261 				,	static_cast<util::XModifiable*> ( this )
2262 				,	static_cast<container::XNameAccess*> ( this )
2263 				,	static_cast<container::XElementAccess*> ( this )
2264 				,	static_cast<lang::XComponent*> ( this )
2265 				,	static_cast<beans::XPropertySet*> ( this )
2266 				,	static_cast<embed::XOptimizedStorage*> ( this ) );
2267 
2268 	if ( aReturn.hasValue() == sal_True )
2269 		return aReturn ;
2270 
2271 	aReturn <<= ::cppu::queryInterface
2272 				(	rType
2273 				,	static_cast<embed::XHierarchicalStorageAccess*> ( this )
2274 				,	static_cast<embed::XHierarchicalStorageAccess2*> ( this ) );
2275 
2276 	if ( aReturn.hasValue() == sal_True )
2277 		return aReturn ;
2278 
2279 	if ( m_pData->m_nStorageType == embed::StorageFormats::PACKAGE )
2280 	{
2281 		if ( m_pData->m_bIsRoot )
2282 		{
2283 			aReturn <<= ::cppu::queryInterface
2284 						(	rType
2285 						,	static_cast<embed::XStorageRawAccess*> ( this )
2286 						,	static_cast<embed::XEncryptionProtectedSource*> ( this )
2287 						,	static_cast<embed::XEncryptionProtectedSource2*> ( this )
2288 						,	static_cast<embed::XEncryptionProtectedStorage*> ( this ) );
2289 		}
2290 		else
2291 		{
2292 			aReturn <<= ::cppu::queryInterface
2293 						(	rType
2294 						,	static_cast<embed::XStorageRawAccess*> ( this ) );
2295 		}
2296 	}
2297 	else if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML )
2298 	{
2299 		aReturn <<= ::cppu::queryInterface
2300 					(	rType
2301 					,	static_cast<embed::XRelationshipAccess*> ( this ) );
2302 	}
2303 
2304 	if ( aReturn.hasValue() == sal_True )
2305 		return aReturn ;
2306 
2307 	return OWeakObject::queryInterface( rType );
2308 }
2309 
2310 //-----------------------------------------------
acquire()2311 void SAL_CALL OStorage::acquire() throw()
2312 {
2313 	OWeakObject::acquire();
2314 }
2315 
2316 //-----------------------------------------------
release()2317 void SAL_CALL OStorage::release() throw()
2318 {
2319 	OWeakObject::release();
2320 }
2321 
2322 //____________________________________________________________________________________________________
2323 //	XTypeProvider
2324 //____________________________________________________________________________________________________
2325 
2326 //-----------------------------------------------
getTypes()2327 uno::Sequence< uno::Type > SAL_CALL OStorage::getTypes()
2328 		throw( uno::RuntimeException )
2329 {
2330 	if ( m_pData->m_pTypeCollection == NULL )
2331 	{
2332 		::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
2333 
2334 		if ( m_pData->m_pTypeCollection == NULL )
2335 		{
2336 			if ( m_pData->m_nStorageType == embed::StorageFormats::PACKAGE )
2337 			{
2338 				if ( m_pData->m_bIsRoot )
2339 				{
2340 					m_pData->m_pTypeCollection = new ::cppu::OTypeCollection
2341 									(	::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
2342 									,	::getCppuType( ( const uno::Reference< embed::XStorage >* )NULL )
2343 									,	::getCppuType( ( const uno::Reference< embed::XStorage2 >* )NULL )
2344 									,	::getCppuType( ( const uno::Reference< embed::XStorageRawAccess >* )NULL )
2345 									,	::getCppuType( ( const uno::Reference< embed::XTransactedObject >* )NULL )
2346 									,	::getCppuType( ( const uno::Reference< embed::XTransactionBroadcaster >* )NULL )
2347 									,	::getCppuType( ( const uno::Reference< util::XModifiable >* )NULL )
2348 									,	::getCppuType( ( const uno::Reference< embed::XEncryptionProtectedStorage >* )NULL )
2349 									,	::getCppuType( ( const uno::Reference< embed::XEncryptionProtectedSource2 >* )NULL )
2350 									,	::getCppuType( ( const uno::Reference< embed::XEncryptionProtectedSource >* )NULL )
2351 									,	::getCppuType( ( const uno::Reference< beans::XPropertySet >* )NULL ) );
2352 				}
2353 				else
2354 				{
2355 					m_pData->m_pTypeCollection = new ::cppu::OTypeCollection
2356 									(	::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
2357 									,	::getCppuType( ( const uno::Reference< embed::XStorage >* )NULL )
2358 									,	::getCppuType( ( const uno::Reference< embed::XStorage2 >* )NULL )
2359 									,	::getCppuType( ( const uno::Reference< embed::XStorageRawAccess >* )NULL )
2360 									,	::getCppuType( ( const uno::Reference< embed::XTransactedObject >* )NULL )
2361 									,	::getCppuType( ( const uno::Reference< embed::XTransactionBroadcaster >* )NULL )
2362 									,	::getCppuType( ( const uno::Reference< util::XModifiable >* )NULL )
2363 									,	::getCppuType( ( const uno::Reference< beans::XPropertySet >* )NULL ) );
2364 				}
2365 			}
2366 			else if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML )
2367 			{
2368 				m_pData->m_pTypeCollection = new ::cppu::OTypeCollection
2369 								(	::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
2370 								,	::getCppuType( ( const uno::Reference< embed::XStorage >* )NULL )
2371 								,	::getCppuType( ( const uno::Reference< embed::XTransactedObject >* )NULL )
2372 								,	::getCppuType( ( const uno::Reference< embed::XTransactionBroadcaster >* )NULL )
2373 								,	::getCppuType( ( const uno::Reference< util::XModifiable >* )NULL )
2374 								,	::getCppuType( ( const uno::Reference< embed::XRelationshipAccess >* )NULL )
2375 								,	::getCppuType( ( const uno::Reference< beans::XPropertySet >* )NULL ) );
2376 			}
2377 			else
2378 			{
2379 				m_pData->m_pTypeCollection = new ::cppu::OTypeCollection
2380 								(	::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
2381 								,	::getCppuType( ( const uno::Reference< embed::XStorage >* )NULL )
2382 								,	::getCppuType( ( const uno::Reference< embed::XTransactedObject >* )NULL )
2383 								,	::getCppuType( ( const uno::Reference< embed::XTransactionBroadcaster >* )NULL )
2384 								,	::getCppuType( ( const uno::Reference< util::XModifiable >* )NULL )
2385 								,	::getCppuType( ( const uno::Reference< beans::XPropertySet >* )NULL ) );
2386 			}
2387 		}
2388 	}
2389 
2390 	return m_pData->m_pTypeCollection->getTypes() ;
2391 }
2392 
2393 namespace { struct lcl_ImplId : public rtl::Static< ::cppu::OImplementationId, lcl_ImplId > {}; }
2394 
2395 //-----------------------------------------------
getImplementationId()2396 uno::Sequence< sal_Int8 > SAL_CALL OStorage::getImplementationId()
2397 		throw( uno::RuntimeException )
2398 {
2399     ::cppu::OImplementationId &rID = lcl_ImplId::get();
2400     return rID.getImplementationId();
2401 }
2402 
2403 //____________________________________________________________________________________________________
2404 //	XStorage
2405 //____________________________________________________________________________________________________
2406 
2407 
2408 //-----------------------------------------------
copyToStorage(const uno::Reference<embed::XStorage> & xDest)2409 void SAL_CALL OStorage::copyToStorage( const uno::Reference< embed::XStorage >& xDest )
2410 		throw ( embed::InvalidStorageException,
2411 				io::IOException,
2412 				lang::IllegalArgumentException,
2413 				embed::StorageWrappedTargetException,
2414 				uno::RuntimeException )
2415 {
2416 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::copyToStorage" );
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( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2424     }
2425 
2426 	if ( !xDest.is() || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject*> ( this ), uno::UNO_QUERY ) )
2427 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 );
2428 
2429 	try {
2430 		m_pImpl->CopyToStorage( xDest, sal_False );
2431 	}
2432 	catch( embed::InvalidStorageException& aInvalidStorageException )
2433     {
2434         m_pImpl->AddLog( aInvalidStorageException.Message );
2435         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2436         throw;
2437 	}
2438 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
2439     {
2440         m_pImpl->AddLog( aIllegalArgumentException.Message );
2441         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2442         throw;
2443 	}
2444 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
2445     {
2446         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
2447         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2448         throw;
2449 	}
2450 	catch( io::IOException& aIOException )
2451     {
2452         m_pImpl->AddLog( aIOException.Message );
2453         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2454         throw;
2455 	}
2456 	catch( uno::RuntimeException& aRuntimeException )
2457     {
2458         m_pImpl->AddLog( aRuntimeException.Message );
2459         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2460         throw;
2461 	}
2462 	catch( uno::Exception& aException )
2463 	{
2464       	m_pImpl->AddLog( aException.Message );
2465       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2466 
2467       	uno::Any aCaught( ::cppu::getCaughtException() );
2468 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't copy storage!" ) ),
2469 												 uno::Reference< io::XInputStream >(),
2470 												 aCaught );
2471 	}
2472 }
2473 
2474 //-----------------------------------------------
openStreamElement(const::rtl::OUString & aStreamName,sal_Int32 nOpenMode)2475 uno::Reference< io::XStream > SAL_CALL OStorage::openStreamElement(
2476 	const ::rtl::OUString& aStreamName, sal_Int32 nOpenMode )
2477 		throw ( embed::InvalidStorageException,
2478 				lang::IllegalArgumentException,
2479 				packages::WrongPasswordException,
2480 				io::IOException,
2481 				embed::StorageWrappedTargetException,
2482 				uno::RuntimeException )
2483 {
2484 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::openStreamElement" );
2485 
2486 	::osl::ResettableMutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
2487 
2488 	if ( !m_pImpl )
2489     {
2490         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
2491         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2492     }
2493 
2494 	if ( !aStreamName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStreamName, sal_False ) )
2495 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
2496 
2497 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
2498 	  && aStreamName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
2499 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // unacceptable element name
2500 
2501 	if ( ( nOpenMode & embed::ElementModes::WRITE ) && m_pData->m_bReadOnlyWrap )
2502 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
2503 
2504 	uno::Reference< io::XStream > xResult;
2505 	try
2506 	{
2507     	SotElement_Impl *pElement = OpenStreamElement_Impl( aStreamName, nOpenMode, sal_False );
2508 		OSL_ENSURE( pElement && pElement->m_pStream, "In case element can not be created an exception must be thrown!" );
2509 
2510 		xResult = pElement->m_pStream->GetStream( nOpenMode, sal_False );
2511 		OSL_ENSURE( xResult.is(), "The method must throw exception instead of removing empty result!\n" );
2512 
2513 		if ( m_pData->m_bReadOnlyWrap )
2514 		{
2515 			// before the storage disposes the stream it must deregister itself as listener
2516 			uno::Reference< lang::XComponent > xStreamComponent( xResult, uno::UNO_QUERY );
2517 			if ( !xStreamComponent.is() )
2518 				throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2519 
2520 			MakeLinkToSubComponent_Impl( xStreamComponent );
2521 		}
2522 	}
2523 	catch( embed::InvalidStorageException& aInvalidStorageException )
2524     {
2525         m_pImpl->AddLog( aInvalidStorageException.Message );
2526         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2527         throw;
2528 	}
2529 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
2530     {
2531         m_pImpl->AddLog( aIllegalArgumentException.Message );
2532         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2533         throw;
2534 	}
2535 	catch( packages::WrongPasswordException& aWrongPasswordException )
2536     {
2537         m_pImpl->AddLog( aWrongPasswordException.Message );
2538         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2539         throw;
2540 	}
2541 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
2542     {
2543         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
2544         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2545         throw;
2546 	}
2547 	catch( io::IOException& aIOException )
2548     {
2549         m_pImpl->AddLog( aIOException.Message );
2550         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2551         throw;
2552 	}
2553 	catch( uno::RuntimeException& aRuntimeException )
2554     {
2555         m_pImpl->AddLog( aRuntimeException.Message );
2556         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2557         throw;
2558 	}
2559 	catch( uno::Exception& aException )
2560 	{
2561       	m_pImpl->AddLog( aException.Message );
2562       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2563 
2564       	uno::Any aCaught( ::cppu::getCaughtException() );
2565 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't open stream element!" ) ),
2566 												 uno::Reference< io::XInputStream >(),
2567 												 aCaught );
2568 	}
2569 
2570 	aGuard.clear();
2571 
2572 	BroadcastModifiedIfNecessary();
2573 
2574 	return xResult;
2575 }
2576 
2577 //-----------------------------------------------
openEncryptedStreamElement(const::rtl::OUString & aStreamName,sal_Int32 nOpenMode,const::rtl::OUString & aPass)2578 uno::Reference< io::XStream > SAL_CALL OStorage::openEncryptedStreamElement(
2579 	const ::rtl::OUString& aStreamName, sal_Int32 nOpenMode, const ::rtl::OUString& aPass )
2580 		throw ( embed::InvalidStorageException,
2581 				lang::IllegalArgumentException,
2582 				packages::NoEncryptionException,
2583 				packages::WrongPasswordException,
2584 				io::IOException,
2585 				embed::StorageWrappedTargetException,
2586 				uno::RuntimeException )
2587 {
2588 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::openEncryptedStreamElement" );
2589 
2590     return openEncryptedStream( aStreamName, nOpenMode, ::comphelper::OStorageHelper::CreatePackageEncryptionData( aPass ) );
2591 }
2592 
2593 //-----------------------------------------------
openStorageElement(const::rtl::OUString & aStorName,sal_Int32 nStorageMode)2594 uno::Reference< embed::XStorage > SAL_CALL OStorage::openStorageElement(
2595 			const ::rtl::OUString& aStorName, sal_Int32 nStorageMode )
2596 		throw ( embed::InvalidStorageException,
2597 				lang::IllegalArgumentException,
2598 				io::IOException,
2599 				embed::StorageWrappedTargetException,
2600 				uno::RuntimeException )
2601 {
2602 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::openStorageElement" );
2603 
2604 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
2605 
2606 	if ( !m_pImpl )
2607     {
2608         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
2609         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2610     }
2611 
2612 	if ( !aStorName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStorName, sal_False ) )
2613 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
2614 
2615 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
2616 	  && aStorName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
2617 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // unacceptable storage name
2618 
2619 	if ( ( nStorageMode & embed::ElementModes::WRITE ) && m_pData->m_bReadOnlyWrap )
2620 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
2621 
2622 	if ( ( nStorageMode & embed::ElementModes::TRUNCATE )
2623 	  && !( nStorageMode & embed::ElementModes::WRITE ) )
2624 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
2625 
2626 	// it's always possible to read written storage in this implementation
2627 	nStorageMode |= embed::ElementModes::READ;
2628 
2629 	uno::Reference< embed::XStorage > xResult;
2630 	try
2631 	{
2632     	SotElement_Impl *pElement = m_pImpl->FindElement( aStorName );
2633     	if ( !pElement )
2634     	{
2635         	// element does not exist, check if creation is allowed
2636 			if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE )
2637           	|| (( nStorageMode & embed::ElementModes::WRITE ) != embed::ElementModes::WRITE )
2638           	|| ( nStorageMode & embed::ElementModes::NOCREATE ) == embed::ElementModes::NOCREATE )
2639 				throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access_denied
2640 
2641         	// create a new StorageElement and insert it into the list
2642 			pElement = m_pImpl->InsertStorage( aStorName, nStorageMode );
2643     	}
2644 		else if ( !pElement->m_bIsStorage )
2645 		{
2646 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2647 		}
2648 		else if ( pElement->m_pStorage )
2649     	{
2650         	// storage has already been opened; it may be opened another time, if it the mode allows to do so
2651         	if ( pElement->m_pStorage->m_pAntiImpl )
2652         	{
2653 				throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access_denied
2654         	}
2655 			else if ( !pElement->m_pStorage->m_aReadOnlyWrapList.empty()
2656 					&& ( nStorageMode & embed::ElementModes::WRITE ) )
2657 			{
2658 				throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access_denied
2659 			}
2660         	else
2661         	{
2662 				// in case parent storage allows writing the readonly mode of the child storage is
2663 				// virtual, that means that it is just enough to change the flag to let it be writable
2664 				// and since there is no AntiImpl nobody should be notified about it
2665 				pElement->m_pStorage->m_nStorageMode = nStorageMode | embed::ElementModes::READ;
2666 
2667 				if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) )
2668 				{
2669 					for ( SotElementList_Impl::iterator pElementIter = pElement->m_pStorage->m_aChildrenList.begin();
2670  				  		pElementIter != pElement->m_pStorage->m_aChildrenList.end(); )
2671    					{
2672 						SotElement_Impl* pElementToDel = (*pElementIter);
2673 						pElementIter++;
2674 
2675 						m_pImpl->RemoveElement( pElementToDel );
2676    					}
2677 				}
2678         	}
2679     	}
2680 
2681 		if ( !pElement->m_pStorage )
2682 			m_pImpl->OpenSubStorage( pElement, nStorageMode );
2683 
2684 		if ( !pElement->m_pStorage )
2685 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: general_error
2686 
2687 		sal_Bool bReadOnlyWrap = ( ( nStorageMode & embed::ElementModes::WRITE ) != embed::ElementModes::WRITE );
2688 		OStorage* pResultStorage = new OStorage( pElement->m_pStorage, bReadOnlyWrap );
2689 		xResult = uno::Reference< embed::XStorage >( (embed::XStorage*) pResultStorage );
2690 
2691 		if ( bReadOnlyWrap )
2692 		{
2693 			// Before this call is done the object must be refcounted already
2694 			pElement->m_pStorage->SetReadOnlyWrap( *pResultStorage );
2695 
2696 			// before the storage disposes the stream it must deregister itself as listener
2697 			uno::Reference< lang::XComponent > xStorageComponent( xResult, uno::UNO_QUERY );
2698 			if ( !xStorageComponent.is() )
2699 				throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2700 
2701 			MakeLinkToSubComponent_Impl( xStorageComponent );
2702 		}
2703 	}
2704 	catch( embed::InvalidStorageException& aInvalidStorageException )
2705     {
2706         m_pImpl->AddLog( aInvalidStorageException.Message );
2707         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2708         throw;
2709 	}
2710 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
2711     {
2712         m_pImpl->AddLog( aIllegalArgumentException.Message );
2713         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2714         throw;
2715 	}
2716 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
2717     {
2718         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
2719         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2720         throw;
2721 	}
2722 	catch( io::IOException& aIOException )
2723     {
2724         m_pImpl->AddLog( aIOException.Message );
2725         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2726         throw;
2727 	}
2728 	catch( uno::RuntimeException& aRuntimeException )
2729     {
2730         m_pImpl->AddLog( aRuntimeException.Message );
2731         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2732         throw;
2733 	}
2734 	catch( uno::Exception& aException )
2735 	{
2736       	m_pImpl->AddLog( aException.Message );
2737       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2738 
2739       	uno::Any aCaught( ::cppu::getCaughtException() );
2740 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't open storage!" ) ),
2741 												 uno::Reference< io::XInputStream >(),
2742 												 aCaught );
2743 	}
2744 
2745 	return xResult;
2746 }
2747 
2748 //-----------------------------------------------
cloneStreamElement(const::rtl::OUString & aStreamName)2749 uno::Reference< io::XStream > SAL_CALL OStorage::cloneStreamElement( const ::rtl::OUString& aStreamName )
2750 		throw ( embed::InvalidStorageException,
2751 				lang::IllegalArgumentException,
2752 				packages::WrongPasswordException,
2753 				io::IOException,
2754 				embed::StorageWrappedTargetException,
2755 				uno::RuntimeException )
2756 {
2757 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::cloneStreamElement" );
2758 
2759 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
2760 
2761 	if ( !m_pImpl )
2762     {
2763         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
2764         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2765     }
2766 
2767 	if ( !aStreamName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStreamName, sal_False ) )
2768 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
2769 
2770 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
2771 	  && aStreamName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
2772 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // unacceptable storage name
2773 
2774 	try
2775 	{
2776 		uno::Reference< io::XStream > xResult;
2777 		m_pImpl->CloneStreamElement( aStreamName, sal_False, ::comphelper::SequenceAsHashMap(), xResult );
2778 		if ( !xResult.is() )
2779 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2780 		return xResult;
2781 	}
2782 	catch( embed::InvalidStorageException& aInvalidStorageException )
2783     {
2784         m_pImpl->AddLog( aInvalidStorageException.Message );
2785         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2786         throw;
2787 	}
2788 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
2789     {
2790         m_pImpl->AddLog( aIllegalArgumentException.Message );
2791         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2792         throw;
2793 	}
2794 	catch( packages::WrongPasswordException& aWrongPasswordException )
2795     {
2796         m_pImpl->AddLog( aWrongPasswordException.Message );
2797         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2798         throw;
2799 	}
2800 	catch( io::IOException& aIOException )
2801     {
2802         m_pImpl->AddLog( aIOException.Message );
2803         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2804         throw;
2805 	}
2806 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
2807     {
2808         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
2809         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2810         throw;
2811 	}
2812 	catch( uno::RuntimeException& aRuntimeException )
2813     {
2814         m_pImpl->AddLog( aRuntimeException.Message );
2815         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2816         throw;
2817 	}
2818 	catch( uno::Exception& aException )
2819 	{
2820       	m_pImpl->AddLog( aException.Message );
2821       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2822 
2823       	uno::Any aCaught( ::cppu::getCaughtException() );
2824 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't clone stream!" ) ),
2825 												 uno::Reference< io::XInputStream >(),
2826 												 aCaught );
2827 	}
2828 }
2829 
2830 //-----------------------------------------------
cloneEncryptedStreamElement(const::rtl::OUString & aStreamName,const::rtl::OUString & aPass)2831 uno::Reference< io::XStream > SAL_CALL OStorage::cloneEncryptedStreamElement(
2832 	const ::rtl::OUString& aStreamName,
2833 	const ::rtl::OUString& aPass )
2834 		throw ( embed::InvalidStorageException,
2835 				lang::IllegalArgumentException,
2836 				packages::NoEncryptionException,
2837 				packages::WrongPasswordException,
2838 				io::IOException,
2839 				embed::StorageWrappedTargetException,
2840 				uno::RuntimeException )
2841 {
2842 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::cloneEncryptedStreamElement" );
2843 
2844     return cloneEncryptedStream( aStreamName, ::comphelper::OStorageHelper::CreatePackageEncryptionData( aPass ) );
2845 }
2846 
2847 //-----------------------------------------------
copyLastCommitTo(const uno::Reference<embed::XStorage> & xTargetStorage)2848 void SAL_CALL OStorage::copyLastCommitTo(
2849 			const uno::Reference< embed::XStorage >& xTargetStorage )
2850 		throw ( embed::InvalidStorageException,
2851 				lang::IllegalArgumentException,
2852 				io::IOException,
2853 				embed::StorageWrappedTargetException,
2854 				uno::RuntimeException )
2855 {
2856 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::copyLastCommitTo" );
2857 
2858 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
2859 
2860 	if ( !m_pImpl )
2861     {
2862         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
2863         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2864     }
2865 
2866 	try
2867 	{
2868 		m_pImpl->CopyLastCommitTo( xTargetStorage );
2869 	}
2870 	catch( embed::InvalidStorageException& aInvalidStorageException )
2871     {
2872         m_pImpl->AddLog( aInvalidStorageException.Message );
2873         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2874         throw;
2875 	}
2876 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
2877     {
2878         m_pImpl->AddLog( aIllegalArgumentException.Message );
2879         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2880         throw;
2881 	}
2882 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
2883     {
2884         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
2885         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2886         throw;
2887 	}
2888 	catch( io::IOException& aIOException )
2889     {
2890         m_pImpl->AddLog( aIOException.Message );
2891         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2892         throw;
2893 	}
2894 	catch( uno::RuntimeException& aRuntimeException )
2895     {
2896         m_pImpl->AddLog( aRuntimeException.Message );
2897         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2898         throw;
2899 	}
2900 	catch( uno::Exception& aException )
2901 	{
2902       	m_pImpl->AddLog( aException.Message );
2903       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2904 
2905       	uno::Any aCaught( ::cppu::getCaughtException() );
2906 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't copy last commit version!" ) ),
2907 												 uno::Reference< io::XInputStream >(),
2908 												 aCaught );
2909 	}
2910 
2911 }
2912 
2913 //-----------------------------------------------
copyStorageElementLastCommitTo(const::rtl::OUString & aStorName,const uno::Reference<embed::XStorage> & xTargetStorage)2914 void SAL_CALL OStorage::copyStorageElementLastCommitTo(
2915 			const ::rtl::OUString& aStorName,
2916 			const uno::Reference< embed::XStorage >& xTargetStorage )
2917 		throw ( embed::InvalidStorageException,
2918 				lang::IllegalArgumentException,
2919 				io::IOException,
2920 				embed::StorageWrappedTargetException,
2921 				uno::RuntimeException )
2922 {
2923 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::copyStorageElementLastCommitTo" );
2924 
2925 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
2926 
2927 	if ( !m_pImpl )
2928     {
2929         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
2930         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2931     }
2932 
2933 	if ( !aStorName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStorName, sal_False ) )
2934 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
2935 
2936 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
2937 	  && aStorName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
2938 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // unacceptable storage name
2939 
2940 	// it's always possible to read written storage in this implementation
2941 	sal_Int32 nStorageMode = embed::ElementModes::READ;
2942 
2943 	try
2944 	{
2945     	SotElement_Impl *pElement = m_pImpl->FindElement( aStorName );
2946     	if ( !pElement )
2947     	{
2948         	// element does not exist, throw exception
2949 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access_denied
2950     	}
2951 		else if ( !pElement->m_bIsStorage )
2952 		{
2953 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
2954 		}
2955 
2956 		if ( !pElement->m_pStorage )
2957 			m_pImpl->OpenSubStorage( pElement, nStorageMode );
2958 
2959 		uno::Reference< embed::XStorage > xResult;
2960 		if ( pElement->m_pStorage )
2961     	{
2962 			// the existence of m_pAntiImpl of the child is not interesting,
2963 			// the copy will be created internally
2964 
2965 			pElement->m_pStorage->CopyLastCommitTo( xTargetStorage );
2966 		}
2967 		else
2968 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: general_error
2969 	}
2970 	catch( embed::InvalidStorageException& aInvalidStorageException )
2971     {
2972         m_pImpl->AddLog( aInvalidStorageException.Message );
2973         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2974         throw;
2975 	}
2976 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
2977     {
2978         m_pImpl->AddLog( aIllegalArgumentException.Message );
2979         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2980         throw;
2981 	}
2982 	catch( io::IOException& aIOException )
2983     {
2984         m_pImpl->AddLog( aIOException.Message );
2985         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2986         throw;
2987 	}
2988 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
2989     {
2990         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
2991         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2992         throw;
2993 	}
2994 	catch( uno::RuntimeException& aRuntimeException )
2995     {
2996         m_pImpl->AddLog( aRuntimeException.Message );
2997         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
2998         throw;
2999 	}
3000 	catch( uno::Exception& aException )
3001 	{
3002       	m_pImpl->AddLog( aException.Message );
3003       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3004 
3005       	uno::Any aCaught( ::cppu::getCaughtException() );
3006 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't copy last commit element version!" ) ),
3007 												 uno::Reference< io::XInputStream >(),
3008 												 aCaught );
3009 	}
3010 }
3011 
3012 //-----------------------------------------------
isStreamElement(const::rtl::OUString & aElementName)3013 sal_Bool SAL_CALL OStorage::isStreamElement( const ::rtl::OUString& aElementName )
3014 		throw ( embed::InvalidStorageException,
3015 				lang::IllegalArgumentException,
3016 				container::NoSuchElementException,
3017 				uno::RuntimeException )
3018 {
3019 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3020 
3021 	if ( !m_pImpl )
3022     {
3023         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3024         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3025     }
3026 
3027 	if ( !aElementName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aElementName, sal_False ) )
3028 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
3029 
3030 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
3031 	  && aElementName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
3032 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // unacceptable name
3033 
3034 	SotElement_Impl* pElement = NULL;
3035 
3036 	try
3037 	{
3038 		pElement = m_pImpl->FindElement( aElementName );
3039 	}
3040 	catch( embed::InvalidStorageException& aInvalidStorageException )
3041     {
3042         m_pImpl->AddLog( aInvalidStorageException.Message );
3043         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3044         throw;
3045 	}
3046 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3047     {
3048         m_pImpl->AddLog( aIllegalArgumentException.Message );
3049         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3050         throw;
3051 	}
3052 	catch( container::NoSuchElementException& aNoSuchElementException )
3053     {
3054         m_pImpl->AddLog( aNoSuchElementException.Message );
3055         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3056         throw;
3057 	}
3058 	catch( uno::RuntimeException& aRuntimeException )
3059     {
3060         m_pImpl->AddLog( aRuntimeException.Message );
3061         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3062         throw;
3063 	}
3064 	catch( uno::Exception& aException )
3065 	{
3066       	m_pImpl->AddLog( aException.Message );
3067       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3068 
3069       	uno::Any aCaught( ::cppu::getCaughtException() );
3070 		throw lang::WrappedTargetRuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't detect whether it is a stream!" ) ),
3071 												 uno::Reference< io::XInputStream >(),
3072 												 aCaught );
3073 	}
3074 
3075 	if ( !pElement )
3076 		throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); //???
3077 
3078 	return !pElement->m_bIsStorage;
3079 }
3080 
3081 //-----------------------------------------------
isStorageElement(const::rtl::OUString & aElementName)3082 sal_Bool SAL_CALL OStorage::isStorageElement( const ::rtl::OUString& aElementName )
3083 		throw ( embed::InvalidStorageException,
3084 				lang::IllegalArgumentException,
3085 				container::NoSuchElementException,
3086 				uno::RuntimeException )
3087 {
3088 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3089 
3090 	if ( !m_pImpl )
3091     {
3092         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3093         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3094     }
3095 
3096 	if ( !aElementName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aElementName, sal_False ) )
3097 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
3098 
3099 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
3100 	  && aElementName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
3101 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 );
3102 
3103 	SotElement_Impl* pElement = NULL;
3104 
3105 	try
3106 	{
3107 		pElement = m_pImpl->FindElement( aElementName );
3108 	}
3109 	catch( embed::InvalidStorageException& aInvalidStorageException )
3110     {
3111         m_pImpl->AddLog( aInvalidStorageException.Message );
3112         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3113         throw;
3114 	}
3115 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3116     {
3117         m_pImpl->AddLog( aIllegalArgumentException.Message );
3118         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3119         throw;
3120 	}
3121 	catch( container::NoSuchElementException& aNoSuchElementException )
3122     {
3123         m_pImpl->AddLog( aNoSuchElementException.Message );
3124         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3125         throw;
3126 	}
3127 	catch( uno::RuntimeException& aRuntimeException )
3128     {
3129         m_pImpl->AddLog( aRuntimeException.Message );
3130         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3131         throw;
3132 	}
3133 	catch( uno::Exception& aException )
3134 	{
3135       	m_pImpl->AddLog( aException.Message );
3136       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3137 
3138       	uno::Any aCaught( ::cppu::getCaughtException() );
3139 		throw lang::WrappedTargetRuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "can't detect whether it is a storage" ) ),
3140 												 uno::Reference< io::XInputStream >(),
3141 												 aCaught );
3142 	}
3143 
3144 	if ( !pElement )
3145 		throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); //???
3146 
3147 	return pElement->m_bIsStorage;
3148 }
3149 
3150 //-----------------------------------------------
removeElement(const::rtl::OUString & aElementName)3151 void SAL_CALL OStorage::removeElement( const ::rtl::OUString& aElementName )
3152 		throw ( embed::InvalidStorageException,
3153 				lang::IllegalArgumentException,
3154 				container::NoSuchElementException,
3155 				io::IOException,
3156 				embed::StorageWrappedTargetException,
3157 				uno::RuntimeException )
3158 {
3159 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::removeElement" );
3160 
3161 	::osl::ResettableMutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3162 
3163 	if ( !m_pImpl )
3164     {
3165         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3166         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3167     }
3168 
3169 	if ( !aElementName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aElementName, sal_False ) )
3170 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
3171 
3172 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
3173 	  && aElementName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
3174 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // TODO: unacceptable name
3175 
3176 	if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE ) )
3177 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
3178 
3179 	try
3180 	{
3181 		SotElement_Impl* pElement = m_pImpl->FindElement( aElementName );
3182 
3183 		if ( !pElement )
3184 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); //???
3185 
3186 		m_pImpl->RemoveElement( pElement );
3187 
3188 		m_pImpl->m_bIsModified = sal_True;
3189 		m_pImpl->m_bBroadcastModified = sal_True;
3190 	}
3191 	catch( embed::InvalidStorageException& aInvalidStorageException )
3192     {
3193         m_pImpl->AddLog( aInvalidStorageException.Message );
3194         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3195         throw;
3196 	}
3197 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3198     {
3199         m_pImpl->AddLog( aIllegalArgumentException.Message );
3200         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3201         throw;
3202 	}
3203 	catch( container::NoSuchElementException& aNoSuchElementException )
3204     {
3205         m_pImpl->AddLog( aNoSuchElementException.Message );
3206         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3207         throw;
3208 	}
3209 	catch( io::IOException& aIOException )
3210     {
3211         m_pImpl->AddLog( aIOException.Message );
3212         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3213         throw;
3214 	}
3215 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
3216     {
3217         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
3218         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3219         throw;
3220 	}
3221 	catch( uno::RuntimeException& aRuntimeException )
3222     {
3223         m_pImpl->AddLog( aRuntimeException.Message );
3224         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3225         throw;
3226 	}
3227 	catch( uno::Exception& aException )
3228 	{
3229       	m_pImpl->AddLog( aException.Message );
3230       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3231 
3232       	uno::Any aCaught( ::cppu::getCaughtException() );
3233 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't remove element!" ) ),
3234 												 uno::Reference< io::XInputStream >(),
3235 												 aCaught );
3236 	}
3237 
3238 	aGuard.clear();
3239 
3240 	BroadcastModifiedIfNecessary();
3241 }
3242 
3243 //-----------------------------------------------
renameElement(const::rtl::OUString & aElementName,const::rtl::OUString & aNewName)3244 void SAL_CALL OStorage::renameElement( const ::rtl::OUString& aElementName, const ::rtl::OUString& aNewName )
3245 		throw ( embed::InvalidStorageException,
3246 				lang::IllegalArgumentException,
3247 				container::NoSuchElementException,
3248 				container::ElementExistException,
3249 				io::IOException,
3250 				embed::StorageWrappedTargetException,
3251 				uno::RuntimeException )
3252 {
3253 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::renameElement" );
3254 
3255 	::osl::ResettableMutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3256 
3257 	if ( !m_pImpl )
3258     {
3259         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3260         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3261     }
3262 
3263 	if ( !aElementName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aElementName, sal_False )
3264 	  || !aNewName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aNewName, sal_False ) )
3265 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
3266 
3267 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
3268 	  && ( aElementName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) )
3269 	    || aNewName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) ) )
3270 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 ); // TODO: unacceptable element name
3271 
3272 	if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE ) )
3273 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
3274 
3275 	try
3276 	{
3277 		SotElement_Impl* pRefElement = m_pImpl->FindElement( aNewName );
3278 		if ( pRefElement )
3279 			throw container::ElementExistException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); //???
3280 
3281 		SotElement_Impl* pElement = m_pImpl->FindElement( aElementName );
3282 		if ( !pElement )
3283 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); //???
3284 
3285 		pElement->m_aName = aNewName;
3286 
3287 		m_pImpl->m_bIsModified = sal_True;
3288 		m_pImpl->m_bBroadcastModified = sal_True;
3289 	}
3290 	catch( embed::InvalidStorageException& aInvalidStorageException )
3291     {
3292         m_pImpl->AddLog( aInvalidStorageException.Message );
3293         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3294         throw;
3295 	}
3296 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3297     {
3298         m_pImpl->AddLog( aIllegalArgumentException.Message );
3299         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3300         throw;
3301 	}
3302 	catch( container::NoSuchElementException& aNoSuchElementException )
3303     {
3304         m_pImpl->AddLog( aNoSuchElementException.Message );
3305         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3306         throw;
3307 	}
3308 	catch( container::ElementExistException& aElementExistException )
3309     {
3310         m_pImpl->AddLog( aElementExistException.Message );
3311         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3312         throw;
3313 	}
3314 	catch( io::IOException& aIOException )
3315     {
3316         m_pImpl->AddLog( aIOException.Message );
3317         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3318         throw;
3319 	}
3320 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
3321     {
3322         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
3323         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3324         throw;
3325 	}
3326 	catch( uno::RuntimeException& aRuntimeException )
3327     {
3328         m_pImpl->AddLog( aRuntimeException.Message );
3329         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3330         throw;
3331 	}
3332 	catch( uno::Exception& aException )
3333 	{
3334       	m_pImpl->AddLog( aException.Message );
3335       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3336 
3337       	uno::Any aCaught( ::cppu::getCaughtException() );
3338 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't rename element!" ) ),
3339 												 uno::Reference< io::XInputStream >(),
3340 												 aCaught );
3341 	}
3342 
3343 	aGuard.clear();
3344 
3345 	BroadcastModifiedIfNecessary();
3346 }
3347 
3348 //-----------------------------------------------
copyElementTo(const::rtl::OUString & aElementName,const uno::Reference<embed::XStorage> & xDest,const::rtl::OUString & aNewName)3349 void SAL_CALL OStorage::copyElementTo(	const ::rtl::OUString& aElementName,
3350 										const uno::Reference< embed::XStorage >& xDest,
3351 										const ::rtl::OUString& aNewName )
3352 		throw ( embed::InvalidStorageException,
3353 				lang::IllegalArgumentException,
3354 				container::NoSuchElementException,
3355 				container::ElementExistException,
3356 				io::IOException,
3357 				embed::StorageWrappedTargetException,
3358 				uno::RuntimeException )
3359 {
3360 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::copyElementTo" );
3361 
3362 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3363 
3364 	if ( !m_pImpl )
3365     {
3366         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3367         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3368     }
3369 
3370 	if ( !aElementName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aElementName, sal_False )
3371 	  || !aNewName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aNewName, sal_False ) )
3372 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
3373 
3374 	if ( !xDest.is() )
3375 		// || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ), uno::UNO_QUERY ) )
3376 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 2 );
3377 
3378 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
3379 	  && ( aElementName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) )
3380 	    || aNewName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) ) )
3381 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 ); // unacceptable element name
3382 
3383 	try
3384 	{
3385 		SotElement_Impl* pElement = m_pImpl->FindElement( aElementName );
3386 		if ( !pElement )
3387 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3388 
3389 		uno::Reference< XNameAccess > xNameAccess( xDest, uno::UNO_QUERY );
3390 		if ( !xNameAccess.is() )
3391 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3392 
3393 		if ( xNameAccess->hasByName( aNewName ) )
3394 			throw container::ElementExistException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3395 
3396 		m_pImpl->CopyStorageElement( pElement, xDest, aNewName, sal_False );
3397 	}
3398 	catch( embed::InvalidStorageException& aInvalidStorageException )
3399     {
3400         m_pImpl->AddLog( aInvalidStorageException.Message );
3401         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3402         throw;
3403 	}
3404 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3405     {
3406         m_pImpl->AddLog( aIllegalArgumentException.Message );
3407         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3408         throw;
3409 	}
3410 	catch( container::NoSuchElementException& aNoSuchElementException )
3411     {
3412         m_pImpl->AddLog( aNoSuchElementException.Message );
3413         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3414         throw;
3415 	}
3416 	catch( container::ElementExistException& aElementExistException )
3417     {
3418         m_pImpl->AddLog( aElementExistException.Message );
3419         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3420         throw;
3421 	}
3422 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
3423     {
3424         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
3425         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3426         throw;
3427 	}
3428 	catch( io::IOException& aIOException )
3429     {
3430         m_pImpl->AddLog( aIOException.Message );
3431         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3432         throw;
3433 	}
3434 	catch( uno::RuntimeException& aRuntimeException )
3435     {
3436         m_pImpl->AddLog( aRuntimeException.Message );
3437         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3438         throw;
3439 	}
3440 	catch( uno::Exception& aException )
3441 	{
3442       	m_pImpl->AddLog( aException.Message );
3443       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3444 
3445       	uno::Any aCaught( ::cppu::getCaughtException() );
3446 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't copy element!" ) ),
3447 												 uno::Reference< io::XInputStream >(),
3448 												 aCaught );
3449 	}
3450 }
3451 
3452 
3453 //-----------------------------------------------
moveElementTo(const::rtl::OUString & aElementName,const uno::Reference<embed::XStorage> & xDest,const::rtl::OUString & aNewName)3454 void SAL_CALL OStorage::moveElementTo(	const ::rtl::OUString& aElementName,
3455 										const uno::Reference< embed::XStorage >& xDest,
3456 										const ::rtl::OUString& aNewName )
3457 		throw ( embed::InvalidStorageException,
3458 				lang::IllegalArgumentException,
3459 				container::NoSuchElementException,
3460 				container::ElementExistException,
3461 				io::IOException,
3462 				embed::StorageWrappedTargetException,
3463 				uno::RuntimeException )
3464 {
3465 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::moveElementTo" );
3466 
3467 	::osl::ResettableMutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3468 
3469 	if ( !m_pImpl )
3470     {
3471         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3472         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3473     }
3474 
3475 	if ( !aElementName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aElementName, sal_False )
3476 	  || !aNewName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aNewName, sal_False ) )
3477 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
3478 
3479 	if ( !xDest.is() || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ), uno::UNO_QUERY ) )
3480 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 2 );
3481 
3482 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
3483 	  && ( aElementName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) )
3484 	    || aNewName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) ) )
3485 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 ); // unacceptable element name
3486 
3487 	if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE ) )
3488 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
3489 
3490 	try
3491 	{
3492 		SotElement_Impl* pElement = m_pImpl->FindElement( aElementName );
3493 		if ( !pElement )
3494 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); //???
3495 
3496 		uno::Reference< XNameAccess > xNameAccess( xDest, uno::UNO_QUERY );
3497 		if ( !xNameAccess.is() )
3498 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3499 
3500 		if ( xNameAccess->hasByName( aNewName ) )
3501 			throw container::ElementExistException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3502 
3503 		m_pImpl->CopyStorageElement( pElement, xDest, aNewName, sal_False );
3504 
3505 		m_pImpl->RemoveElement( pElement );
3506 
3507 		m_pImpl->m_bIsModified = sal_True;
3508 		m_pImpl->m_bBroadcastModified = sal_True;
3509 	}
3510 	catch( embed::InvalidStorageException& aInvalidStorageException )
3511     {
3512         m_pImpl->AddLog( aInvalidStorageException.Message );
3513         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3514         throw;
3515 	}
3516 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3517     {
3518         m_pImpl->AddLog( aIllegalArgumentException.Message );
3519         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3520         throw;
3521 	}
3522 	catch( container::NoSuchElementException& aNoSuchElementException )
3523     {
3524         m_pImpl->AddLog( aNoSuchElementException.Message );
3525         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3526         throw;
3527 	}
3528 	catch( container::ElementExistException& aElementExistException )
3529     {
3530         m_pImpl->AddLog( aElementExistException.Message );
3531         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3532         throw;
3533 	}
3534 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
3535     {
3536         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
3537         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3538         throw;
3539 	}
3540 	catch( io::IOException& aIOException )
3541     {
3542         m_pImpl->AddLog( aIOException.Message );
3543         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3544         throw;
3545 	}
3546 	catch( uno::RuntimeException& aRuntimeException )
3547     {
3548         m_pImpl->AddLog( aRuntimeException.Message );
3549         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3550         throw;
3551 	}
3552 	catch( uno::Exception& aException )
3553 	{
3554       	m_pImpl->AddLog( aException.Message );
3555       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3556 
3557       	uno::Any aCaught( ::cppu::getCaughtException() );
3558 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't move element!" ) ),
3559 												 uno::Reference< io::XInputStream >(),
3560 												 aCaught );
3561 	}
3562 
3563 	aGuard.clear();
3564 
3565 	BroadcastModifiedIfNecessary();
3566 }
3567 
3568 //____________________________________________________________________________________________________
3569 //	XStorage2
3570 //____________________________________________________________________________________________________
3571 
3572 //-----------------------------------------------
openEncryptedStream(const::rtl::OUString & aStreamName,sal_Int32 nOpenMode,const uno::Sequence<beans::NamedValue> & aEncryptionData)3573 uno::Reference< io::XStream > SAL_CALL OStorage::openEncryptedStream(
3574 	const ::rtl::OUString& aStreamName, sal_Int32 nOpenMode, const uno::Sequence< beans::NamedValue >& aEncryptionData )
3575 		throw ( embed::InvalidStorageException,
3576 				lang::IllegalArgumentException,
3577 				packages::NoEncryptionException,
3578 				packages::WrongPasswordException,
3579 				io::IOException,
3580 				embed::StorageWrappedTargetException,
3581 				uno::RuntimeException )
3582 {
3583 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::openEncryptedStream" );
3584 
3585 	::osl::ResettableMutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3586 
3587 	if ( !m_pImpl )
3588     {
3589         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3590         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3591     }
3592 
3593 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
3594 		packages::NoEncryptionException();
3595 
3596 	if ( ( nOpenMode & embed::ElementModes::WRITE ) && m_pData->m_bReadOnlyWrap )
3597 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
3598 
3599 	if ( !aEncryptionData.getLength() )
3600 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 3 );
3601 
3602 	uno::Reference< io::XStream > xResult;
3603 	try
3604 	{
3605     	SotElement_Impl *pElement = OpenStreamElement_Impl( aStreamName, nOpenMode, sal_True );
3606 		OSL_ENSURE( pElement && pElement->m_pStream, "In case element can not be created an exception must be thrown!" );
3607 
3608 		xResult = pElement->m_pStream->GetStream( nOpenMode, aEncryptionData, sal_False );
3609 		OSL_ENSURE( xResult.is(), "The method must throw exception instead of removing empty result!\n" );
3610 
3611 		if ( m_pData->m_bReadOnlyWrap )
3612 		{
3613 			// before the storage disposes the stream it must deregister itself as listener
3614 			uno::Reference< lang::XComponent > xStreamComponent( xResult, uno::UNO_QUERY );
3615 			if ( !xStreamComponent.is() )
3616 				throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3617 
3618 			MakeLinkToSubComponent_Impl( xStreamComponent );
3619 		}
3620 	}
3621 	catch( embed::InvalidStorageException& aInvalidStorageException )
3622     {
3623         m_pImpl->AddLog( aInvalidStorageException.Message );
3624         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3625         throw;
3626 	}
3627 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3628     {
3629         m_pImpl->AddLog( aIllegalArgumentException.Message );
3630         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3631         throw;
3632 	}
3633 	catch( packages::NoEncryptionException& aNoEncryptionException )
3634     {
3635         m_pImpl->AddLog( aNoEncryptionException.Message );
3636         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3637         throw;
3638 	}
3639 	catch( packages::WrongPasswordException& aWrongPasswordException )
3640     {
3641         m_pImpl->AddLog( aWrongPasswordException.Message );
3642         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3643         throw;
3644 	}
3645 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
3646     {
3647         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
3648         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3649         throw;
3650 	}
3651 	catch( io::IOException& aIOException )
3652     {
3653         m_pImpl->AddLog( aIOException.Message );
3654         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3655         throw;
3656 	}
3657 	catch( uno::RuntimeException& aRuntimeException )
3658     {
3659         m_pImpl->AddLog( aRuntimeException.Message );
3660         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3661         throw;
3662 	}
3663 	catch( uno::Exception& aException )
3664 	{
3665       	m_pImpl->AddLog( aException.Message );
3666       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3667 
3668       	uno::Any aCaught( ::cppu::getCaughtException() );
3669 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't open encrypted stream stream!" ) ),
3670 												 uno::Reference< io::XInputStream >(),
3671 												 aCaught );
3672 	}
3673 
3674 	aGuard.clear();
3675 
3676 	BroadcastModifiedIfNecessary();
3677 
3678 	return xResult;
3679 }
3680 
3681 //-----------------------------------------------
cloneEncryptedStream(const::rtl::OUString & aStreamName,const uno::Sequence<beans::NamedValue> & aEncryptionData)3682 uno::Reference< io::XStream > SAL_CALL OStorage::cloneEncryptedStream(
3683 	const ::rtl::OUString& aStreamName,
3684 	const uno::Sequence< beans::NamedValue >& aEncryptionData )
3685 		throw ( embed::InvalidStorageException,
3686 				lang::IllegalArgumentException,
3687 				packages::NoEncryptionException,
3688 				packages::WrongPasswordException,
3689 				io::IOException,
3690 				embed::StorageWrappedTargetException,
3691 				uno::RuntimeException )
3692 {
3693 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::cloneEncryptedStream" );
3694 
3695 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3696 
3697 	if ( !m_pImpl )
3698     {
3699         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3700         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3701     }
3702 
3703 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
3704 		packages::NoEncryptionException();
3705 
3706 	if ( !aEncryptionData.getLength() )
3707 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 2 );
3708 
3709 	try
3710 	{
3711 		uno::Reference< io::XStream > xResult;
3712 		m_pImpl->CloneStreamElement( aStreamName, sal_True, aEncryptionData, xResult );
3713 		if ( !xResult.is() )
3714 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3715 		return xResult;
3716 	}
3717 	catch( embed::InvalidStorageException& aInvalidStorageException )
3718     {
3719         m_pImpl->AddLog( aInvalidStorageException.Message );
3720         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3721         throw;
3722 	}
3723 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3724     {
3725         m_pImpl->AddLog( aIllegalArgumentException.Message );
3726         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3727         throw;
3728 	}
3729 	catch( packages::NoEncryptionException& aNoEncryptionException )
3730     {
3731         m_pImpl->AddLog( aNoEncryptionException.Message );
3732         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3733         throw;
3734 	}
3735 	catch( packages::WrongPasswordException& aWrongPasswordException )
3736     {
3737         m_pImpl->AddLog( aWrongPasswordException.Message );
3738         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3739         throw;
3740 	}
3741 	catch( io::IOException& aIOException )
3742     {
3743         m_pImpl->AddLog( aIOException.Message );
3744         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3745         throw;
3746 	}
3747 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
3748     {
3749         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
3750         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3751         throw;
3752 	}
3753 	catch( uno::RuntimeException& aRuntimeException )
3754     {
3755         m_pImpl->AddLog( aRuntimeException.Message );
3756         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3757         throw;
3758 	}
3759 	catch( uno::Exception& aException )
3760 	{
3761       	m_pImpl->AddLog( aException.Message );
3762       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3763 
3764       	uno::Any aCaught( ::cppu::getCaughtException() );
3765 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't clone encrypted stream!" ) ),
3766 												 uno::Reference< io::XInputStream >(),
3767 												 aCaught );
3768 	}
3769 }
3770 
3771 
3772 //____________________________________________________________________________________________________
3773 //	XStorageRawAccess
3774 //____________________________________________________________________________________________________
3775 
3776 //-----------------------------------------------
getPlainRawStreamElement(const::rtl::OUString & sStreamName)3777 uno::Reference< io::XInputStream > SAL_CALL OStorage::getPlainRawStreamElement(
3778 			const ::rtl::OUString& sStreamName )
3779 		throw ( embed::InvalidStorageException,
3780 				lang::IllegalArgumentException,
3781 				container::NoSuchElementException,
3782 				io::IOException,
3783 				embed::StorageWrappedTargetException,
3784 				uno::RuntimeException )
3785 {
3786 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::getPlainRawStreamElement" );
3787 
3788 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3789 
3790 	if ( !m_pImpl )
3791     {
3792         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3793         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3794     }
3795 
3796 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML )
3797 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // the interface is not supported and must not be accessible
3798 
3799 	if ( !sStreamName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( sStreamName, sal_False ) )
3800 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
3801 
3802 	uno::Reference < io::XInputStream > xTempIn;
3803 	try
3804 	{
3805 		SotElement_Impl* pElement = m_pImpl->FindElement( sStreamName );
3806 		if ( !pElement )
3807 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3808 
3809 		if ( !pElement->m_pStream )
3810 		{
3811 			m_pImpl->OpenSubStream( pElement );
3812 			if ( !pElement->m_pStream )
3813 				throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3814 		}
3815 
3816 		uno::Reference< io::XInputStream > xRawInStream = pElement->m_pStream->GetPlainRawInStream();
3817 		if ( !xRawInStream.is() )
3818 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3819 
3820 		uno::Reference < io::XOutputStream > xTempOut(
3821 							m_pImpl->GetServiceFactory()->createInstance (
3822 									::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.TempFile" ) ) ),
3823 							uno::UNO_QUERY );
3824 		xTempIn = uno::Reference < io::XInputStream >( xTempOut, uno::UNO_QUERY );
3825 		uno::Reference < io::XSeekable > xSeek( xTempOut, uno::UNO_QUERY );
3826 
3827 		if ( !xTempOut.is() || !xTempIn.is() || !xSeek.is() )
3828 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3829 
3830 		// Copy temporary file to a new one
3831 		::comphelper::OStorageHelper::CopyInputToOutput( xRawInStream, xTempOut );
3832 		xTempOut->closeOutput();
3833 		xSeek->seek( 0 );
3834 	}
3835 	catch( embed::InvalidStorageException& aInvalidStorageException )
3836     {
3837         m_pImpl->AddLog( aInvalidStorageException.Message );
3838         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3839         throw;
3840 	}
3841 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3842     {
3843         m_pImpl->AddLog( aIllegalArgumentException.Message );
3844         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3845         throw;
3846 	}
3847 	catch( container::NoSuchElementException& aNoSuchElementException )
3848     {
3849         m_pImpl->AddLog( aNoSuchElementException.Message );
3850         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3851         throw;
3852 	}
3853 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
3854     {
3855         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
3856         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3857         throw;
3858 	}
3859 	catch( io::IOException& aIOException )
3860     {
3861         m_pImpl->AddLog( aIOException.Message );
3862         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3863         throw;
3864 	}
3865 	catch( uno::RuntimeException& aRuntimeException )
3866     {
3867         m_pImpl->AddLog( aRuntimeException.Message );
3868         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3869         throw;
3870 	}
3871 	catch( uno::Exception& aException )
3872 	{
3873       	m_pImpl->AddLog( aException.Message );
3874       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3875 
3876       	uno::Any aCaught( ::cppu::getCaughtException() );
3877 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't get plain raw stream!" ) ),
3878 												 uno::Reference< io::XInputStream >(),
3879 												 aCaught );
3880 	}
3881 
3882 	return xTempIn;
3883 }
3884 
3885 //-----------------------------------------------
getRawEncrStreamElement(const::rtl::OUString & sStreamName)3886 uno::Reference< io::XInputStream > SAL_CALL OStorage::getRawEncrStreamElement(
3887 			const ::rtl::OUString& sStreamName )
3888 		throw ( embed::InvalidStorageException,
3889 				lang::IllegalArgumentException,
3890 				packages::NoEncryptionException,
3891 				container::NoSuchElementException,
3892 				io::IOException,
3893 				embed::StorageWrappedTargetException,
3894 				uno::RuntimeException )
3895 {
3896 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::getRawEncrStreamElement" );
3897 
3898 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
3899 
3900 	if ( !m_pImpl )
3901     {
3902         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
3903         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3904     }
3905 
3906 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
3907 		throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3908 
3909 	if ( !sStreamName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( sStreamName, sal_False ) )
3910 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
3911 
3912 	uno::Reference < io::XInputStream > xTempIn;
3913 	try
3914 	{
3915 		SotElement_Impl* pElement = m_pImpl->FindElement( sStreamName );
3916 		if ( !pElement )
3917 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3918 
3919 		if ( !pElement->m_pStream )
3920 		{
3921 			m_pImpl->OpenSubStream( pElement );
3922 			if ( !pElement->m_pStream )
3923 				throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3924 		}
3925 
3926 		if ( !pElement->m_pStream->IsEncrypted() )
3927 			throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3928 
3929 		uno::Reference< io::XInputStream > xRawInStream = pElement->m_pStream->GetRawInStream();
3930 		if ( !xRawInStream.is() )
3931 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3932 
3933 		uno::Reference < io::XOutputStream > xTempOut(
3934 							m_pImpl->GetServiceFactory()->createInstance (
3935 									::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.TempFile" ) ) ),
3936 							uno::UNO_QUERY );
3937 		xTempIn = uno::Reference < io::XInputStream >( xTempOut, uno::UNO_QUERY );
3938 		uno::Reference < io::XSeekable > xSeek( xTempOut, uno::UNO_QUERY );
3939 
3940 		if ( !xTempOut.is() || !xTempIn.is() || !xSeek.is() )
3941 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
3942 
3943 		// Copy temporary file to a new one
3944 		::comphelper::OStorageHelper::CopyInputToOutput( xRawInStream, xTempOut );
3945 		xTempOut->closeOutput();
3946 		xSeek->seek( 0 );
3947 
3948 	}
3949 	catch( embed::InvalidStorageException& aInvalidStorageException )
3950     {
3951         m_pImpl->AddLog( aInvalidStorageException.Message );
3952         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3953         throw;
3954 	}
3955 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
3956     {
3957         m_pImpl->AddLog( aIllegalArgumentException.Message );
3958         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3959         throw;
3960 	}
3961 	catch( packages::NoEncryptionException& aNoEncryptionException )
3962     {
3963         m_pImpl->AddLog( aNoEncryptionException.Message );
3964         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3965         throw;
3966 	}
3967 	catch( container::NoSuchElementException& aNoSuchElementException )
3968     {
3969         m_pImpl->AddLog( aNoSuchElementException.Message );
3970         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3971         throw;
3972 	}
3973 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
3974     {
3975         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
3976         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3977         throw;
3978 	}
3979 	catch( io::IOException& aIOException )
3980     {
3981         m_pImpl->AddLog( aIOException.Message );
3982         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3983         throw;
3984 	}
3985 	catch( uno::RuntimeException& aRuntimeException )
3986     {
3987         m_pImpl->AddLog( aRuntimeException.Message );
3988         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3989         throw;
3990 	}
3991 	catch( uno::Exception& aException )
3992 	{
3993       	m_pImpl->AddLog( aException.Message );
3994       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
3995 
3996       	uno::Any aCaught( ::cppu::getCaughtException() );
3997 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't get raw stream!" ) ),
3998 												 uno::Reference< io::XInputStream >(),
3999 												 aCaught );
4000 	}
4001 
4002 	return xTempIn;
4003 }
4004 
4005 //-----------------------------------------------
insertRawEncrStreamElement(const::rtl::OUString & aStreamName,const uno::Reference<io::XInputStream> & xInStream)4006 void SAL_CALL OStorage::insertRawEncrStreamElement( const ::rtl::OUString& aStreamName,
4007 								const uno::Reference< io::XInputStream >& xInStream )
4008 		throw ( embed::InvalidStorageException,
4009 				lang::IllegalArgumentException,
4010 				packages::NoRawFormatException,
4011 				container::ElementExistException,
4012 				io::IOException,
4013 				embed::StorageWrappedTargetException,
4014 				uno::RuntimeException)
4015 {
4016 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::insertRawEncrStreamElement" );
4017 
4018 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4019 
4020 	if ( !m_pImpl )
4021     {
4022         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4023         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4024     }
4025 
4026 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
4027 		throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4028 
4029 	if ( !aStreamName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStreamName, sal_False ) )
4030 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
4031 
4032 	if ( !xInStream.is() )
4033 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 2 );
4034 
4035 	if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE ) )
4036 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
4037 
4038 	try
4039 	{
4040 		SotElement_Impl* pElement = m_pImpl->FindElement( aStreamName );
4041 		if ( pElement )
4042 			throw container::ElementExistException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4043 
4044 		m_pImpl->InsertRawStream( aStreamName, xInStream );
4045 	}
4046 	catch( embed::InvalidStorageException& aInvalidStorageException )
4047     {
4048         m_pImpl->AddLog( aInvalidStorageException.Message );
4049         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4050         throw;
4051 	}
4052 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
4053     {
4054         m_pImpl->AddLog( aIllegalArgumentException.Message );
4055         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4056         throw;
4057 	}
4058 	catch( packages::NoRawFormatException& aNoRawFormatException )
4059     {
4060         m_pImpl->AddLog( aNoRawFormatException.Message );
4061         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4062         throw;
4063 	}
4064 	catch( container::ElementExistException& aElementExistException )
4065     {
4066         m_pImpl->AddLog( aElementExistException.Message );
4067         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4068         throw;
4069 	}
4070 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
4071     {
4072         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
4073         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4074         throw;
4075 	}
4076 	catch( io::IOException& aIOException )
4077     {
4078         m_pImpl->AddLog( aIOException.Message );
4079         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4080         throw;
4081 	}
4082 	catch( uno::RuntimeException& aRuntimeException )
4083     {
4084         m_pImpl->AddLog( aRuntimeException.Message );
4085         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4086         throw;
4087 	}
4088 	catch( uno::Exception& aException )
4089 	{
4090       	m_pImpl->AddLog( aException.Message );
4091       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4092 
4093       	uno::Any aCaught( ::cppu::getCaughtException() );
4094 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't insert raw stream!" ) ),
4095 												 uno::Reference< io::XInputStream >(),
4096 												 aCaught );
4097 	}
4098 }
4099 
4100 //____________________________________________________________________________________________________
4101 //	XTransactedObject
4102 //____________________________________________________________________________________________________
4103 
4104 //-----------------------------------------------
commit()4105 void SAL_CALL OStorage::commit()
4106 		throw ( io::IOException,
4107 				embed::StorageWrappedTargetException,
4108 				uno::RuntimeException )
4109 {
4110 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::commit" );
4111 
4112 	uno::Reference< util::XModifiable > xParentModif;
4113 
4114 	try {
4115 		BroadcastTransaction( STOR_MESS_PRECOMMIT );
4116 
4117 		::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4118 
4119 		if ( !m_pImpl )
4120         {
4121             ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4122             throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4123         }
4124 
4125     	if ( m_pData->m_bReadOnlyWrap )
4126 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access_denied
4127 
4128 		m_pImpl->Commit(); // the root storage initiates the storing to source
4129 
4130 		// when the storage is committed the parent is modified
4131 		if ( m_pImpl->m_pParent && m_pImpl->m_pParent->m_pAntiImpl )
4132 			xParentModif = (util::XModifiable*)m_pImpl->m_pParent->m_pAntiImpl;
4133 	}
4134 	catch( io::IOException& aIOException )
4135     {
4136         m_pImpl->AddLog( aIOException.Message );
4137         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4138         throw;
4139 	}
4140 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
4141     {
4142         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
4143         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4144         throw;
4145 	}
4146 	catch( uno::RuntimeException& aRuntimeException )
4147     {
4148         m_pImpl->AddLog( aRuntimeException.Message );
4149         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4150         throw;
4151 	}
4152 	catch( uno::Exception& aException )
4153 	{
4154         m_pImpl->AddLog( aException.Message );
4155         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4156 
4157         uno::Any aCaught( ::cppu::getCaughtException() );
4158 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Problems on commit!" ) ),
4159 								  uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >( this ) ),
4160 								  aCaught );
4161 	}
4162 
4163 	setModified( sal_False );
4164 	if ( xParentModif.is() )
4165 		xParentModif->setModified( sal_True );
4166 
4167 	BroadcastTransaction( STOR_MESS_COMMITED );
4168 }
4169 
4170 //-----------------------------------------------
revert()4171 void SAL_CALL OStorage::revert()
4172 		throw ( io::IOException,
4173 				embed::StorageWrappedTargetException,
4174 				uno::RuntimeException )
4175 {
4176 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::revert" );
4177 
4178 	// the method removes all the changes done after last commit
4179 
4180 	BroadcastTransaction( STOR_MESS_PREREVERT );
4181 
4182 	::osl::ResettableMutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4183 
4184 	if ( !m_pImpl )
4185     {
4186         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4187         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4188     }
4189 
4190 	for ( SotElementList_Impl::iterator pElementIter = m_pImpl->m_aChildrenList.begin();
4191 		  pElementIter != m_pImpl->m_aChildrenList.end(); pElementIter++ )
4192 	{
4193 		if ( ((*pElementIter)->m_pStorage
4194 				&& ( (*pElementIter)->m_pStorage->m_pAntiImpl || !(*pElementIter)->m_pStorage->m_aReadOnlyWrapList.empty() ))
4195 		  || ((*pElementIter)->m_pStream
4196 		  		&& ( (*pElementIter)->m_pStream->m_pAntiImpl || !(*pElementIter)->m_pStream->m_aInputStreamsList.empty()) ) )
4197 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
4198 	}
4199 
4200 	if ( m_pData->m_bReadOnlyWrap || !m_pImpl->m_bListCreated )
4201 		return; // nothing to do
4202 
4203 	try {
4204 		m_pImpl->Revert();
4205 		m_pImpl->m_bIsModified = sal_False;
4206 		m_pImpl->m_bBroadcastModified = sal_True;
4207 	}
4208 	catch( io::IOException& aIOException )
4209     {
4210         m_pImpl->AddLog( aIOException.Message );
4211         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4212         throw;
4213 	}
4214 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
4215     {
4216         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
4217         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4218         throw;
4219 	}
4220 	catch( uno::RuntimeException& aRuntimeException )
4221     {
4222         m_pImpl->AddLog( aRuntimeException.Message );
4223         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4224         throw;
4225 	}
4226 	catch( uno::Exception& aException )
4227 	{
4228         m_pImpl->AddLog( aException.Message );
4229         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4230 
4231         uno::Any aCaught( ::cppu::getCaughtException() );
4232 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Problems on revert!" ) ),
4233 								  uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >( this ) ),
4234 								  aCaught );
4235 	}
4236 
4237 	aGuard.clear();
4238 
4239 	setModified( sal_False );
4240 	BroadcastTransaction( STOR_MESS_REVERTED );
4241 }
4242 
4243 //____________________________________________________________________________________________________
4244 //	XTransactionBroadcaster
4245 //____________________________________________________________________________________________________
4246 
4247 //-----------------------------------------------
addTransactionListener(const uno::Reference<embed::XTransactionListener> & aListener)4248 void SAL_CALL OStorage::addTransactionListener( const uno::Reference< embed::XTransactionListener >& aListener )
4249 		throw ( uno::RuntimeException )
4250 {
4251 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4252 
4253 	if ( !m_pImpl )
4254     {
4255         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4256         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4257     }
4258 
4259 	m_pData->m_aListenersContainer.addInterface( ::getCppuType((const uno::Reference< embed::XTransactionListener >*)0),
4260 												aListener );
4261 }
4262 
4263 //-----------------------------------------------
removeTransactionListener(const uno::Reference<embed::XTransactionListener> & aListener)4264 void SAL_CALL OStorage::removeTransactionListener( const uno::Reference< embed::XTransactionListener >& aListener )
4265 		throw ( uno::RuntimeException )
4266 {
4267 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4268 
4269 	if ( !m_pImpl )
4270     {
4271         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4272         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4273     }
4274 
4275 	m_pData->m_aListenersContainer.removeInterface( ::getCppuType((const uno::Reference< embed::XTransactionListener >*)0),
4276 													aListener );
4277 }
4278 
4279 //____________________________________________________________________________________________________
4280 //	XModifiable
4281 //  TODO: if there will be no demand on this interface it will be removed from implementation,
4282 //		  I do not want to remove it now since it is still possible that it will be inserted
4283 //		  to the service back.
4284 //____________________________________________________________________________________________________
4285 
4286 //-----------------------------------------------
isModified()4287 sal_Bool SAL_CALL OStorage::isModified()
4288 		throw ( uno::RuntimeException )
4289 {
4290 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4291 
4292 	if ( !m_pImpl )
4293     {
4294         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4295         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4296     }
4297 
4298 	return m_pImpl->m_bIsModified;
4299 }
4300 
4301 
4302 //-----------------------------------------------
setModified(sal_Bool bModified)4303 void SAL_CALL OStorage::setModified( sal_Bool bModified )
4304 		throw ( beans::PropertyVetoException,
4305 				uno::RuntimeException )
4306 {
4307 	::osl::ResettableMutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4308 
4309 	if ( !m_pImpl )
4310     {
4311         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4312         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4313     }
4314 
4315 	if ( m_pData->m_bReadOnlyWrap )
4316 		throw beans::PropertyVetoException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
4317 
4318 	if ( m_pImpl->m_bIsModified != bModified )
4319 		m_pImpl->m_bIsModified = bModified;
4320 
4321 	aGuard.clear();
4322 	if ( bModified )
4323 	{
4324 		m_pImpl->m_bBroadcastModified = sal_True;
4325 		BroadcastModifiedIfNecessary();
4326 	}
4327 }
4328 
4329 //-----------------------------------------------
addModifyListener(const uno::Reference<util::XModifyListener> & aListener)4330 void SAL_CALL OStorage::addModifyListener(
4331 			const uno::Reference< util::XModifyListener >& aListener )
4332 		throw ( uno::RuntimeException )
4333 {
4334 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4335 
4336 	if ( !m_pImpl )
4337     {
4338         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4339         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4340     }
4341 
4342 	m_pData->m_aListenersContainer.addInterface(
4343 								::getCppuType( ( const uno::Reference< util::XModifyListener >* )0 ), aListener );
4344 }
4345 
4346 
4347 //-----------------------------------------------
removeModifyListener(const uno::Reference<util::XModifyListener> & aListener)4348 void SAL_CALL OStorage::removeModifyListener(
4349 			const uno::Reference< util::XModifyListener >& aListener )
4350 		throw ( uno::RuntimeException )
4351 {
4352 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4353 
4354 	if ( !m_pImpl )
4355     {
4356         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4357         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4358     }
4359 
4360 	m_pData->m_aListenersContainer.removeInterface(
4361 								::getCppuType( ( const uno::Reference< util::XModifyListener >* )0 ), aListener );
4362 }
4363 
4364 //____________________________________________________________________________________________________
4365 //	XNameAccess
4366 //____________________________________________________________________________________________________
4367 
4368 //-----------------------------------------------
getByName(const::rtl::OUString & aName)4369 uno::Any SAL_CALL OStorage::getByName( const ::rtl::OUString& aName )
4370 		throw ( container::NoSuchElementException,
4371 				lang::WrappedTargetException,
4372 				uno::RuntimeException )
4373 {
4374 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::getByName" );
4375 
4376 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4377 
4378 	if ( !m_pImpl )
4379     {
4380         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4381         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4382     }
4383 
4384 	if ( !aName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aName, sal_False ) )
4385 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
4386 
4387 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
4388 	  && aName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
4389 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // unacceptable element name
4390 
4391 	uno::Any aResult;
4392 	try
4393 	{
4394 		SotElement_Impl* pElement = m_pImpl->FindElement( aName );
4395 		if ( !pElement )
4396 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4397 
4398 		if ( pElement->m_bIsStorage )
4399 			aResult <<= openStorageElement( aName, embed::ElementModes::READ );
4400 		else
4401 			aResult <<= openStreamElement( aName, embed::ElementModes::READ );
4402 	}
4403 	catch( container::NoSuchElementException& aNoSuchElementException )
4404     {
4405         m_pImpl->AddLog( aNoSuchElementException.Message );
4406         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4407         throw;
4408 	}
4409 	catch( lang::WrappedTargetException& aWrappedTargetException )
4410     {
4411         m_pImpl->AddLog( aWrappedTargetException.Message );
4412         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4413         throw;
4414 	}
4415 	catch( uno::RuntimeException& aRuntimeException )
4416     {
4417         m_pImpl->AddLog( aRuntimeException.Message );
4418         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4419         throw;
4420 	}
4421 	catch ( uno::Exception& aException )
4422 	{
4423    		m_pImpl->AddLog( aException.Message );
4424    		m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4425 
4426    		uno::Any aCaught( ::cppu::getCaughtException() );
4427 		throw lang::WrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open storage!\n" ) ),
4428 											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
4429 																				uno::UNO_QUERY ),
4430 											aCaught );
4431 	}
4432 
4433 	return aResult;
4434 }
4435 
4436 
4437 //-----------------------------------------------
getElementNames()4438 uno::Sequence< ::rtl::OUString > SAL_CALL OStorage::getElementNames()
4439 		throw ( uno::RuntimeException )
4440 {
4441 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::getElementNames" );
4442 
4443 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4444 
4445 	if ( !m_pImpl )
4446     {
4447         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4448         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4449     }
4450 
4451 	try
4452 	{
4453 		return m_pImpl->GetElementNames();
4454 	}
4455 	catch( uno::RuntimeException& aRuntimeException )
4456     {
4457         m_pImpl->AddLog( aRuntimeException.Message );
4458         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4459         throw;
4460 	}
4461 	catch ( uno::Exception& aException )
4462 	{
4463    		m_pImpl->AddLog( aException.Message );
4464    		m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4465 
4466    		uno::Any aCaught( ::cppu::getCaughtException() );
4467 		throw lang::WrappedTargetRuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open storage!\n" ) ),
4468 											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
4469 																				uno::UNO_QUERY ),
4470 											aCaught );
4471 	}
4472 }
4473 
4474 
4475 //-----------------------------------------------
hasByName(const::rtl::OUString & aName)4476 sal_Bool SAL_CALL OStorage::hasByName( const ::rtl::OUString& aName )
4477 		throw ( uno::RuntimeException )
4478 {
4479 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::hasByName" );
4480 
4481 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4482 
4483 	if ( !m_pImpl )
4484     {
4485         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4486         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4487     }
4488 
4489 	if ( !aName.getLength() )
4490 		return sal_False;
4491 
4492 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
4493 	  && aName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
4494 		return sal_False;
4495 
4496 	SotElement_Impl* pElement = NULL;
4497 	try
4498 	{
4499 		pElement = m_pImpl->FindElement( aName );
4500 	}
4501 	catch( uno::RuntimeException& aRuntimeException )
4502     {
4503         m_pImpl->AddLog( aRuntimeException.Message );
4504         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4505         throw;
4506 	}
4507 	catch ( uno::Exception& aException )
4508 	{
4509    		m_pImpl->AddLog( aException.Message );
4510    		m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4511 
4512    		uno::Any aCaught( ::cppu::getCaughtException() );
4513 		throw lang::WrappedTargetRuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open storage!\n" ) ),
4514 											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
4515 																				uno::UNO_QUERY ),
4516 											aCaught );
4517 	}
4518 
4519 	return ( pElement != NULL );
4520 }
4521 
4522 
4523 //-----------------------------------------------
getElementType()4524 uno::Type SAL_CALL OStorage::getElementType()
4525 		throw ( uno::RuntimeException )
4526 {
4527 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4528 
4529 	if ( !m_pImpl )
4530     {
4531         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4532         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4533     }
4534 
4535 	// it is a multitype container
4536 	return uno::Type();
4537 }
4538 
4539 
4540 //-----------------------------------------------
hasElements()4541 sal_Bool SAL_CALL OStorage::hasElements()
4542 		throw ( uno::RuntimeException )
4543 {
4544 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::hasElements" );
4545 
4546 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4547 
4548 	if ( !m_pImpl )
4549     {
4550         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4551         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4552     }
4553 
4554 	try
4555 	{
4556 		return ( m_pImpl->GetChildrenList().size() != 0 );
4557 	}
4558 	catch( uno::RuntimeException& aRuntimeException )
4559     {
4560         m_pImpl->AddLog( aRuntimeException.Message );
4561         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4562         throw;
4563 	}
4564 	catch ( uno::Exception& aException )
4565 	{
4566    		m_pImpl->AddLog( aException.Message );
4567    		m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4568 
4569    		uno::Any aCaught( ::cppu::getCaughtException() );
4570 		throw lang::WrappedTargetRuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open storage!\n" ) ),
4571 											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
4572 																				uno::UNO_QUERY ),
4573 											aCaught );
4574 	}
4575 }
4576 
4577 
4578 //____________________________________________________________________________________________________
4579 //	XComponent
4580 //____________________________________________________________________________________________________
4581 
4582 //-----------------------------------------------
dispose()4583 void SAL_CALL OStorage::dispose()
4584 		throw ( uno::RuntimeException )
4585 {
4586 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4587 
4588 	if ( !m_pImpl )
4589     {
4590         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4591         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4592     }
4593 
4594 	try
4595 	{
4596 		InternalDispose( sal_True );
4597 	}
4598 	catch( uno::RuntimeException& aRuntimeException )
4599     {
4600         m_pImpl->AddLog( aRuntimeException.Message );
4601         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4602         throw;
4603 	}
4604 	catch ( uno::Exception& aException )
4605 	{
4606    		m_pImpl->AddLog( aException.Message );
4607    		m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4608 
4609    		uno::Any aCaught( ::cppu::getCaughtException() );
4610 		throw lang::WrappedTargetRuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open storage!\n" ) ),
4611 											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
4612 																				uno::UNO_QUERY ),
4613 											aCaught );
4614 	}
4615 }
4616 
4617 //-----------------------------------------------
addEventListener(const uno::Reference<lang::XEventListener> & xListener)4618 void SAL_CALL OStorage::addEventListener(
4619 			const uno::Reference< lang::XEventListener >& xListener )
4620 		throw ( uno::RuntimeException )
4621 {
4622 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4623 
4624 	if ( !m_pImpl )
4625     {
4626         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4627         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4628     }
4629 
4630 	m_pData->m_aListenersContainer.addInterface(
4631 								::getCppuType( ( const uno::Reference< lang::XEventListener >* )0 ), xListener );
4632 }
4633 
4634 //-----------------------------------------------
removeEventListener(const uno::Reference<lang::XEventListener> & xListener)4635 void SAL_CALL OStorage::removeEventListener(
4636 			const uno::Reference< lang::XEventListener >& xListener )
4637 		throw ( uno::RuntimeException )
4638 {
4639 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4640 
4641 	if ( !m_pImpl )
4642     {
4643         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4644         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4645     }
4646 
4647 	m_pData->m_aListenersContainer.removeInterface(
4648 								::getCppuType( ( const uno::Reference< lang::XEventListener >* )0 ), xListener );
4649 }
4650 
4651 //____________________________________________________________________________________________________
4652 //	XEncryptionProtectedSource
4653 //____________________________________________________________________________________________________
4654 
setEncryptionPassword(const::rtl::OUString & aPass)4655 void SAL_CALL OStorage::setEncryptionPassword( const ::rtl::OUString& aPass )
4656 	throw ( uno::RuntimeException,
4657 			io::IOException )
4658 {
4659 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::setEncryptionPassword" );
4660     setEncryptionData( ::comphelper::OStorageHelper::CreatePackageEncryptionData( aPass ) );
4661 }
4662 
4663 //-----------------------------------------------
removeEncryption()4664 void SAL_CALL OStorage::removeEncryption()
4665 	throw ( uno::RuntimeException,
4666 			io::IOException )
4667 {
4668 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::removeEncryption" );
4669 
4670 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4671 
4672 	if ( !m_pImpl )
4673     {
4674         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4675         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4676     }
4677 
4678 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
4679 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // the interface must be visible only for package storage
4680 
4681 	OSL_ENSURE( m_pData->m_bIsRoot, "removeEncryption() method is not available for nonroot storages!\n" );
4682 	if ( m_pData->m_bIsRoot )
4683 	{
4684 		try {
4685 			m_pImpl->ReadContents();
4686 		}
4687 		catch ( uno::RuntimeException& aRuntimeException )
4688         {
4689             m_pImpl->AddLog( aRuntimeException.Message );
4690             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4691             throw;
4692 		}
4693 		catch ( uno::Exception& aException )
4694         {
4695             m_pImpl->AddLog( aException.Message );
4696             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4697 
4698         	uno::Any aCaught( ::cppu::getCaughtException() );
4699 			throw lang::WrappedTargetRuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open package!\n" ) ),
4700 												uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
4701 																					uno::UNO_QUERY ),
4702 												aCaught );
4703 		}
4704 
4705 		// TODO: check if the password is valid
4706 		// update all streams that was encrypted with old password
4707 
4708 		uno::Reference< beans::XPropertySet > xPackPropSet( m_pImpl->m_xPackage, uno::UNO_QUERY_THROW );
4709 		try
4710 		{
4711 			xPackPropSet->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STORAGE_ENCRYPTION_KEYS_PROPERTY ) ),
4712 											uno::makeAny( uno::Sequence< beans::NamedValue >() ) );
4713 
4714 			m_pImpl->m_bHasCommonEncryptionData = sal_False;
4715 			m_pImpl->m_aCommonEncryptionData.clear();
4716 		}
4717         catch( uno::RuntimeException& aRException )
4718         {
4719             m_pImpl->AddLog( aRException.Message );
4720             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4721 
4722 			OSL_ENSURE( sal_False, "The call must not fail, it is pretty simple!" );
4723 			throw;
4724         }
4725 		catch( uno::Exception& aException )
4726 		{
4727             m_pImpl->AddLog( aException.Message );
4728             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4729 
4730 			OSL_ENSURE( sal_False, "The call must not fail, it is pretty simple!" );
4731 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4732 		}
4733 	}
4734 }
4735 
4736 //____________________________________________________________________________________________________
4737 //	XEncryptionProtectedSource2
4738 //____________________________________________________________________________________________________
4739 
setEncryptionData(const uno::Sequence<beans::NamedValue> & aEncryptionData)4740 void SAL_CALL OStorage::setEncryptionData( const uno::Sequence< beans::NamedValue >& aEncryptionData )
4741     throw ( io::IOException,
4742             uno::RuntimeException )
4743 {
4744 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::setEncryptionData" );
4745 
4746 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4747 
4748 	if ( !m_pImpl )
4749     {
4750         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4751         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4752     }
4753 
4754 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
4755 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // the interface must be visible only for package storage
4756 
4757     if ( !aEncryptionData.getLength() )
4758 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected empty encryption data!") ), uno::Reference< uno::XInterface >() );
4759 
4760 	OSL_ENSURE( m_pData->m_bIsRoot, "setEncryptionData() method is not available for nonroot storages!\n" );
4761 	if ( m_pData->m_bIsRoot )
4762 	{
4763 		try {
4764 			m_pImpl->ReadContents();
4765 		}
4766 		catch ( uno::RuntimeException& aRuntimeException )
4767         {
4768             m_pImpl->AddLog( aRuntimeException.Message );
4769             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4770             throw;
4771 		}
4772 		catch ( uno::Exception& aException )
4773         {
4774             m_pImpl->AddLog( aException.Message );
4775             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4776 
4777         	uno::Any aCaught( ::cppu::getCaughtException() );
4778 			throw lang::WrappedTargetRuntimeException(
4779                                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open package!\n" ) ),
4780 								uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ), uno::UNO_QUERY ),
4781 								aCaught );
4782 		}
4783 
4784 		uno::Reference< beans::XPropertySet > xPackPropSet( m_pImpl->m_xPackage, uno::UNO_QUERY_THROW );
4785 		try
4786 		{
4787             ::comphelper::SequenceAsHashMap aEncryptionMap( aEncryptionData );
4788 			xPackPropSet->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STORAGE_ENCRYPTION_KEYS_PROPERTY ) ),
4789 											uno::makeAny( aEncryptionMap.getAsConstNamedValueList() ) );
4790 
4791 			m_pImpl->m_bHasCommonEncryptionData = sal_True;
4792 			m_pImpl->m_aCommonEncryptionData = aEncryptionMap;
4793 		}
4794 		catch( uno::Exception& aException )
4795 		{
4796             m_pImpl->AddLog( aException.Message );
4797             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4798 
4799 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4800 		}
4801 	}
4802 }
4803 
4804 //____________________________________________________________________________________________________
4805 //	XEncryptionProtectedStorage
4806 //____________________________________________________________________________________________________
4807 
4808 //-----------------------------------------------
setEncryptionAlgorithms(const uno::Sequence<beans::NamedValue> & aAlgorithms)4809 void SAL_CALL OStorage::setEncryptionAlgorithms( const uno::Sequence< beans::NamedValue >& aAlgorithms )
4810     throw (lang::IllegalArgumentException, uno::RuntimeException)
4811 {
4812 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::setEncryptionAlgorithms" );
4813 
4814 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4815 
4816 	if ( !m_pImpl )
4817     {
4818         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4819         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4820     }
4821 
4822 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
4823 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // the interface must be visible only for package storage
4824 
4825     if ( !aAlgorithms.getLength() )
4826 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected empty encryption algorithms list!") ), uno::Reference< uno::XInterface >() );
4827 
4828 	OSL_ENSURE( m_pData->m_bIsRoot, "setEncryptionAlgorithms() method is not available for nonroot storages!\n" );
4829 	if ( m_pData->m_bIsRoot )
4830 	{
4831 		try {
4832 			m_pImpl->ReadContents();
4833 		}
4834 		catch ( uno::RuntimeException& aRuntimeException )
4835         {
4836             m_pImpl->AddLog( aRuntimeException.Message );
4837             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4838             throw;
4839 		}
4840 		catch ( uno::Exception& aException )
4841         {
4842             m_pImpl->AddLog( aException.Message );
4843             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4844 
4845         	uno::Any aCaught( ::cppu::getCaughtException() );
4846 			throw lang::WrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open package!\n" ) ),
4847 												uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
4848 																					uno::UNO_QUERY ),
4849 												aCaught );
4850 		}
4851 
4852 		uno::Reference< beans::XPropertySet > xPackPropSet( m_pImpl->m_xPackage, uno::UNO_QUERY_THROW );
4853 		try
4854 		{
4855 			xPackPropSet->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ENCRYPTION_ALGORITHMS_PROPERTY ) ),
4856 											uno::makeAny( aAlgorithms ) );
4857 		}
4858 		catch ( uno::RuntimeException& aRuntimeException )
4859         {
4860             m_pImpl->AddLog( aRuntimeException.Message );
4861             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4862             throw;
4863 		}
4864         catch( lang::IllegalArgumentException& aIAException )
4865         {
4866             m_pImpl->AddLog( aIAException.Message );
4867             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4868 
4869             throw;
4870         }
4871 		catch( uno::Exception& aException )
4872 		{
4873             m_pImpl->AddLog( aException.Message );
4874             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4875 
4876 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4877 		}
4878     }
4879 }
4880 
4881 //-----------------------------------------------
getEncryptionAlgorithms()4882 uno::Sequence< beans::NamedValue > SAL_CALL OStorage::getEncryptionAlgorithms()
4883     throw (uno::RuntimeException)
4884 {
4885 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::getEncryptionAlgorithms" );
4886 
4887 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4888 
4889 	if ( !m_pImpl )
4890     {
4891         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4892         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4893     }
4894 
4895 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
4896 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // the interface must be visible only for package storage
4897 
4898     uno::Sequence< beans::NamedValue > aResult;
4899 	OSL_ENSURE( m_pData->m_bIsRoot, "getEncryptionAlgorithms() method is not available for nonroot storages!\n" );
4900 	if ( m_pData->m_bIsRoot )
4901 	{
4902 		try {
4903 			m_pImpl->ReadContents();
4904 		}
4905 		catch ( uno::RuntimeException& aRuntimeException )
4906         {
4907             m_pImpl->AddLog( aRuntimeException.Message );
4908             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4909             throw;
4910 		}
4911 		catch ( uno::Exception& aException )
4912         {
4913             m_pImpl->AddLog( aException.Message );
4914             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4915 
4916         	uno::Any aCaught( ::cppu::getCaughtException() );
4917 			throw lang::WrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open package!\n" ) ),
4918 												uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
4919 																					uno::UNO_QUERY ),
4920 												aCaught );
4921 		}
4922 
4923 		uno::Reference< beans::XPropertySet > xPackPropSet( m_pImpl->m_xPackage, uno::UNO_QUERY_THROW );
4924 		try
4925 		{
4926 			xPackPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ENCRYPTION_ALGORITHMS_PROPERTY ) ) ) >>= aResult;
4927 		}
4928 		catch ( uno::RuntimeException& aRuntimeException )
4929         {
4930             m_pImpl->AddLog( aRuntimeException.Message );
4931             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4932             throw;
4933 		}
4934 		catch( uno::Exception& aException )
4935 		{
4936             m_pImpl->AddLog( aException.Message );
4937             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
4938 
4939 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4940 		}
4941     }
4942 
4943     return aResult;
4944 }
4945 
4946 
4947 //____________________________________________________________________________________________________
4948 //	XPropertySet
4949 //____________________________________________________________________________________________________
4950 
4951 //-----------------------------------------------
getPropertySetInfo()4952 uno::Reference< beans::XPropertySetInfo > SAL_CALL OStorage::getPropertySetInfo()
4953 		throw ( uno::RuntimeException )
4954 {
4955 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4956 
4957 	if ( !m_pImpl )
4958     {
4959         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4960         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4961     }
4962 
4963 	//TODO:
4964 	return uno::Reference< beans::XPropertySetInfo >();
4965 }
4966 
4967 
4968 //-----------------------------------------------
setPropertyValue(const::rtl::OUString & aPropertyName,const uno::Any & aValue)4969 void SAL_CALL OStorage::setPropertyValue( const ::rtl::OUString& aPropertyName, const uno::Any& aValue )
4970 		throw ( beans::UnknownPropertyException,
4971 				beans::PropertyVetoException,
4972 				lang::IllegalArgumentException,
4973 				lang::WrappedTargetException,
4974 				uno::RuntimeException )
4975 {
4976 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::setPropertyValue" );
4977 
4978 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
4979 
4980 	if ( !m_pImpl )
4981     {
4982         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
4983         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4984     }
4985 
4986 	//TODO: think about interaction handler
4987 
4988     // WORKAROUND:
4989     // The old document might have no version in the manifest.xml, so we have to allow to set the version
4990     // even for readonly storages, so that the version from content.xml can be used.
4991 	if ( m_pData->m_bReadOnlyWrap && !aPropertyName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ) ) )
4992 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: Access denied
4993 
4994 	if ( m_pData->m_nStorageType == embed::StorageFormats::ZIP )
4995 		throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
4996 	else if ( m_pData->m_nStorageType == embed::StorageFormats::PACKAGE )
4997 	{
4998 		if ( aPropertyName.equalsAscii( "MediaType" ) )
4999 		{
5000 			aValue >>= m_pImpl->m_aMediaType;
5001 			m_pImpl->m_bControlMediaType = sal_True;
5002 
5003             m_pImpl->m_bBroadcastModified = sal_True;
5004             m_pImpl->m_bIsModified = sal_True;
5005 		}
5006 		else if ( aPropertyName.equalsAscii( "Version" ) )
5007 		{
5008 			aValue >>= m_pImpl->m_aVersion;
5009 			m_pImpl->m_bControlVersion = sal_True;
5010 
5011             // this property can be set even for readonly storage
5012             if ( !m_pData->m_bReadOnlyWrap )
5013             {
5014                 m_pImpl->m_bBroadcastModified = sal_True;
5015                 m_pImpl->m_bIsModified = sal_True;
5016             }
5017 		}
5018 		else if ( ( m_pData->m_bIsRoot && ( aPropertyName.equalsAscii( HAS_ENCRYPTED_ENTRIES_PROPERTY )
5019 									|| aPropertyName.equalsAscii( HAS_NONENCRYPTED_ENTRIES_PROPERTY )
5020 									|| aPropertyName.equalsAscii( IS_INCONSISTENT_PROPERTY )
5021 									|| aPropertyName.equalsAscii( "URL" )
5022 									|| aPropertyName.equalsAscii( "RepairPackage" ) ) )
5023 		   || aPropertyName.equalsAscii( "IsRoot" )
5024 		   || aPropertyName.equalsAscii( MEDIATYPE_FALLBACK_USED_PROPERTY ) )
5025 			throw beans::PropertyVetoException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5026 		else
5027 			throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5028 	}
5029 	else if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML )
5030 	{
5031 		if ( aPropertyName.equalsAscii( "RelationsInfoStream" ) )
5032 		{
5033 			uno::Reference< io::XInputStream > xInRelStream;
5034 			if ( ( aValue >>= xInRelStream ) && xInRelStream.is() )
5035 			{
5036 				uno::Reference< io::XSeekable > xSeek( xInRelStream, uno::UNO_QUERY );
5037 				if ( !xSeek.is() )
5038 				{
5039 					// currently this is an internal property that is used for optimization
5040 					// and the stream must support XSeekable interface
5041 					// TODO/LATER: in future it can be changed if property is used from outside
5042 					throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 );
5043 				}
5044 
5045 				m_pImpl->m_xNewRelInfoStream = xInRelStream;
5046 				m_pImpl->m_aRelInfo = uno::Sequence< uno::Sequence< beans::StringPair > >();
5047 				m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED_STREAM;
5048 				m_pImpl->m_bBroadcastModified = sal_True;
5049 				m_pImpl->m_bIsModified = sal_True;
5050 			}
5051 			else
5052 				throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 );
5053 		}
5054 		else if ( aPropertyName.equalsAscii( "RelationsInfo" ) )
5055 		{
5056 			if ( aValue >>= m_pImpl->m_aRelInfo )
5057 			{
5058 				m_pImpl->m_xNewRelInfoStream = uno::Reference< io::XInputStream >();
5059 				m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
5060 				m_pImpl->m_bBroadcastModified = sal_True;
5061 				m_pImpl->m_bIsModified = sal_True;
5062 			}
5063 			else
5064 				throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 );
5065 		}
5066 		else if ( ( m_pData->m_bIsRoot && ( aPropertyName.equalsAscii( "URL" )
5067 									|| aPropertyName.equalsAscii( "RepairPackage" ) ) )
5068 		   || aPropertyName.equalsAscii( "IsRoot" ) )
5069 			throw beans::PropertyVetoException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5070 		else
5071 			throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5072 	}
5073 	else
5074 		throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5075 
5076 	BroadcastModifiedIfNecessary();
5077 }
5078 
5079 
5080 //-----------------------------------------------
getPropertyValue(const::rtl::OUString & aPropertyName)5081 uno::Any SAL_CALL OStorage::getPropertyValue( const ::rtl::OUString& aPropertyName )
5082 		throw ( beans::UnknownPropertyException,
5083 				lang::WrappedTargetException,
5084 				uno::RuntimeException )
5085 {
5086 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::getPropertyValue" );
5087 
5088 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5089 
5090 	if ( !m_pImpl )
5091     {
5092         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5093         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5094     }
5095 
5096 	if ( m_pData->m_nStorageType == embed::StorageFormats::PACKAGE
5097 	  && ( aPropertyName.equalsAscii( "MediaType" )
5098         || aPropertyName.equalsAscii( MEDIATYPE_FALLBACK_USED_PROPERTY )
5099 	    || aPropertyName.equalsAscii( "Version" ) ) )
5100 	{
5101 		try
5102 		{
5103 			m_pImpl->ReadContents();
5104 		}
5105 		catch ( uno::RuntimeException& aRuntimeException )
5106         {
5107             m_pImpl->AddLog( aRuntimeException.Message );
5108             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5109             throw;
5110 		}
5111 		catch ( uno::Exception& aException )
5112         {
5113             m_pImpl->AddLog( aException.Message );
5114             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5115 
5116         	uno::Any aCaught( ::cppu::getCaughtException() );
5117 			throw lang::WrappedTargetException(
5118 										::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Can't read contents!" ) ),
5119 										uno::Reference< XInterface >( static_cast< OWeakObject* >( this ), uno::UNO_QUERY ),
5120 										aCaught );
5121 		}
5122 
5123 		if ( aPropertyName.equalsAscii( "MediaType" ) )
5124 			return uno::makeAny( m_pImpl->m_aMediaType );
5125 		else if ( aPropertyName.equalsAscii( "Version" ) )
5126 			return uno::makeAny( m_pImpl->m_aVersion );
5127 		else
5128 			return uno::makeAny( m_pImpl->m_bMTFallbackUsed );
5129 	}
5130 	else if ( aPropertyName.equalsAscii( "IsRoot" ) )
5131 	{
5132 		return uno::makeAny( m_pData->m_bIsRoot );
5133 	}
5134 	else if ( aPropertyName.equalsAscii( "OpenMode" ) )
5135 	{
5136 		return uno::makeAny( m_pImpl->m_nStorageMode );
5137 	}
5138 	else if ( m_pData->m_bIsRoot )
5139 	{
5140 		if ( aPropertyName.equalsAscii( "URL" )
5141 		  || aPropertyName.equalsAscii( "RepairPackage" ) )
5142 		{
5143 			for ( sal_Int32 aInd = 0; aInd < m_pImpl->m_xProperties.getLength(); aInd++ )
5144 			{
5145 				if ( m_pImpl->m_xProperties[aInd].Name.equals( aPropertyName ) )
5146 					return m_pImpl->m_xProperties[aInd].Value;
5147 			}
5148 
5149 			if ( aPropertyName.equalsAscii( "URL" ) )
5150 				return uno::makeAny( ::rtl::OUString() );
5151 
5152 			return uno::makeAny( sal_False ); // RepairPackage
5153 		}
5154         else if ( m_pData->m_nStorageType == embed::StorageFormats::PACKAGE
5155           && ( aPropertyName.equalsAscii( HAS_ENCRYPTED_ENTRIES_PROPERTY )
5156             || aPropertyName.equalsAscii( HAS_NONENCRYPTED_ENTRIES_PROPERTY )
5157             || aPropertyName.equalsAscii( IS_INCONSISTENT_PROPERTY ) ) )
5158 		{
5159 			try {
5160 				m_pImpl->ReadContents();
5161 				uno::Reference< beans::XPropertySet > xPackPropSet( m_pImpl->m_xPackage, uno::UNO_QUERY );
5162 				if ( !xPackPropSet.is() )
5163 					throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5164 
5165 				return xPackPropSet->getPropertyValue( aPropertyName );
5166 			}
5167 			catch ( uno::RuntimeException& aRuntimeException )
5168             {
5169                 m_pImpl->AddLog( aRuntimeException.Message );
5170                 m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5171                 throw;
5172 			}
5173 			catch ( uno::Exception& aException )
5174             {
5175                 m_pImpl->AddLog( aException.Message );
5176                 m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5177 
5178         		uno::Any aCaught( ::cppu::getCaughtException() );
5179 				throw lang::WrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can not open package!\n" ) ),
5180 													uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
5181 																						uno::UNO_QUERY ),
5182 													aCaught );
5183 			}
5184 		}
5185 	}
5186 
5187 	throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5188 }
5189 
5190 
5191 //-----------------------------------------------
addPropertyChangeListener(const::rtl::OUString &,const uno::Reference<beans::XPropertyChangeListener> &)5192 void SAL_CALL OStorage::addPropertyChangeListener(
5193     const ::rtl::OUString& /*aPropertyName*/,
5194     const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
5195 		throw ( beans::UnknownPropertyException,
5196 				lang::WrappedTargetException,
5197 				uno::RuntimeException )
5198 {
5199 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5200 
5201 	if ( !m_pImpl )
5202     {
5203         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5204         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5205     }
5206 
5207 	//TODO:
5208 }
5209 
5210 
5211 //-----------------------------------------------
removePropertyChangeListener(const::rtl::OUString &,const uno::Reference<beans::XPropertyChangeListener> &)5212 void SAL_CALL OStorage::removePropertyChangeListener(
5213     const ::rtl::OUString& /*aPropertyName*/,
5214     const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
5215 		throw ( beans::UnknownPropertyException,
5216 				lang::WrappedTargetException,
5217 				uno::RuntimeException )
5218 {
5219 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5220 
5221 	if ( !m_pImpl )
5222     {
5223         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5224         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5225     }
5226 
5227 	//TODO:
5228 }
5229 
5230 
5231 //-----------------------------------------------
addVetoableChangeListener(const::rtl::OUString &,const uno::Reference<beans::XVetoableChangeListener> &)5232 void SAL_CALL OStorage::addVetoableChangeListener(
5233     const ::rtl::OUString& /*PropertyName*/,
5234     const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
5235 		throw ( beans::UnknownPropertyException,
5236 				lang::WrappedTargetException,
5237 				uno::RuntimeException )
5238 {
5239 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5240 
5241 	if ( !m_pImpl )
5242     {
5243         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5244         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5245     }
5246 
5247 	//TODO:
5248 }
5249 
5250 
5251 //-----------------------------------------------
removeVetoableChangeListener(const::rtl::OUString &,const uno::Reference<beans::XVetoableChangeListener> &)5252 void SAL_CALL OStorage::removeVetoableChangeListener(
5253     const ::rtl::OUString& /*PropertyName*/,
5254     const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
5255 		throw ( beans::UnknownPropertyException,
5256 				lang::WrappedTargetException,
5257 				uno::RuntimeException )
5258 {
5259 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5260 
5261 	if ( !m_pImpl )
5262     {
5263         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5264         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5265     }
5266 
5267 	//TODO:
5268 }
5269 
5270 //____________________________________________________________________________________________________
5271 //	XRelationshipAccess
5272 //____________________________________________________________________________________________________
5273 
5274 // TODO/LATER: the storage and stream implementations of this interface are very similar, they could use a helper class
5275 
5276 //-----------------------------------------------
hasByID(const::rtl::OUString & sID)5277 sal_Bool SAL_CALL OStorage::hasByID(  const ::rtl::OUString& sID )
5278 		throw ( io::IOException,
5279 				uno::RuntimeException )
5280 {
5281 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5282 
5283 	if ( !m_pImpl )
5284     {
5285         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5286         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5287     }
5288 
5289 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5290 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5291 
5292 	try
5293 	{
5294 		getRelationshipByID( sID );
5295 		return sal_True;
5296 	}
5297 	catch( container::NoSuchElementException& aNoSuchElementException )
5298 	{
5299         m_pImpl->AddLog( aNoSuchElementException.Message );
5300         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
5301     }
5302 
5303 	return sal_False;
5304 }
5305 
5306 //-----------------------------------------------
getTargetByID(const::rtl::OUString & sID)5307 ::rtl::OUString SAL_CALL OStorage::getTargetByID(  const ::rtl::OUString& sID  )
5308 		throw ( container::NoSuchElementException,
5309 				io::IOException,
5310 				uno::RuntimeException )
5311 {
5312 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5313 
5314 	if ( !m_pImpl )
5315     {
5316         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5317         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5318     }
5319 
5320 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5321 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5322 
5323 	uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
5324 	for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
5325 		if ( aSeq[nInd].First.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Target" ) ) )
5326 			return aSeq[nInd].Second;
5327 
5328 	return ::rtl::OUString();
5329 }
5330 
5331 //-----------------------------------------------
getTypeByID(const::rtl::OUString & sID)5332 ::rtl::OUString SAL_CALL OStorage::getTypeByID(  const ::rtl::OUString& sID  )
5333 		throw ( container::NoSuchElementException,
5334 				io::IOException,
5335 				uno::RuntimeException )
5336 {
5337 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5338 
5339 	if ( !m_pImpl )
5340     {
5341         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5342         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5343     }
5344 
5345 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5346 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5347 
5348 	uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
5349 	for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
5350 		if ( aSeq[nInd].First.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Type" ) ) )
5351 			return aSeq[nInd].Second;
5352 
5353 	return ::rtl::OUString();
5354 }
5355 
5356 //-----------------------------------------------
getRelationshipByID(const::rtl::OUString & sID)5357 uno::Sequence< beans::StringPair > SAL_CALL OStorage::getRelationshipByID(  const ::rtl::OUString& sID  )
5358 		throw ( container::NoSuchElementException,
5359 				io::IOException,
5360 				uno::RuntimeException )
5361 {
5362 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5363 
5364 	if ( !m_pImpl )
5365     {
5366         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5367         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5368     }
5369 
5370 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5371 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5372 
5373 	// TODO/LATER: in future the unification of the ID could be checked
5374 	uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
5375 	for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
5376 		for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
5377 			if ( aSeq[nInd1][nInd2].First.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Id" ) ) )
5378 			{
5379 				if ( aSeq[nInd1][nInd2].Second.equals( sID ) )
5380 					return aSeq[nInd1];
5381 				break;
5382 			}
5383 
5384 	throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5385 }
5386 
5387 //-----------------------------------------------
getRelationshipsByType(const::rtl::OUString & sType)5388 uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OStorage::getRelationshipsByType(  const ::rtl::OUString& sType  )
5389 		throw ( io::IOException,
5390 				uno::RuntimeException )
5391 {
5392 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5393 
5394 	if ( !m_pImpl )
5395     {
5396         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5397         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5398     }
5399 
5400 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5401 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5402 
5403 	uno::Sequence< uno::Sequence< beans::StringPair > > aResult;
5404 	sal_Int32 nEntriesNum = 0;
5405 
5406 	// TODO/LATER: in future the unification of the ID could be checked
5407 	uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
5408 	for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
5409 		for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
5410 			if ( aSeq[nInd1][nInd2].First.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Type" ) ) )
5411 			{
5412                 // the type is usually an URL, so the check should be case insensitive
5413 				if ( aSeq[nInd1][nInd2].Second.equalsIgnoreAsciiCase( sType ) )
5414 				{
5415 					aResult.realloc( ++nEntriesNum );
5416 					aResult[nEntriesNum-1] = aSeq[nInd1];
5417 				}
5418 				break;
5419 			}
5420 
5421 	return aResult;
5422 }
5423 
5424 //-----------------------------------------------
getAllRelationships()5425 uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OStorage::getAllRelationships()
5426 		throw (io::IOException, uno::RuntimeException)
5427 {
5428 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5429 
5430 	if ( !m_pImpl )
5431     {
5432         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5433         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5434     }
5435 
5436 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5437 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5438 
5439 	return m_pImpl->GetAllRelationshipsIfAny();
5440 }
5441 
5442 //-----------------------------------------------
insertRelationshipByID(const::rtl::OUString & sID,const uno::Sequence<beans::StringPair> & aEntry,::sal_Bool bReplace)5443 void SAL_CALL OStorage::insertRelationshipByID(  const ::rtl::OUString& sID, const uno::Sequence< beans::StringPair >& aEntry, ::sal_Bool bReplace  )
5444 		throw ( container::ElementExistException,
5445 				io::IOException,
5446 				uno::RuntimeException )
5447 {
5448 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5449 
5450 	if ( !m_pImpl )
5451     {
5452         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5453         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5454     }
5455 
5456 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5457 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5458 
5459 	::rtl::OUString aIDTag( RTL_CONSTASCII_USTRINGPARAM( "Id" ) );
5460 
5461 	sal_Int32 nIDInd = -1;
5462 
5463 	// TODO/LATER: in future the unification of the ID could be checked
5464 	uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
5465 	for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
5466 		for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
5467 			if ( aSeq[nInd1][nInd2].First.equals( aIDTag ) )
5468 			{
5469 				if ( aSeq[nInd1][nInd2].Second.equals( sID ) )
5470 					nIDInd = nInd1;
5471 
5472 				break;
5473 			}
5474 
5475 	if ( nIDInd == -1 || bReplace )
5476 	{
5477 		if ( nIDInd == -1 )
5478 		{
5479 			nIDInd = aSeq.getLength();
5480 			aSeq.realloc( nIDInd + 1 );
5481 		}
5482 
5483 		aSeq[nIDInd].realloc( aEntry.getLength() + 1 );
5484 
5485 		aSeq[nIDInd][0].First = aIDTag;
5486 		aSeq[nIDInd][0].Second = sID;
5487 		sal_Int32 nIndTarget = 1;
5488 		for ( sal_Int32 nIndOrig = 0;
5489 			  nIndOrig < aEntry.getLength();
5490 			  nIndOrig++ )
5491 		{
5492 			if ( !aEntry[nIndOrig].First.equals( aIDTag ) )
5493 				aSeq[nIDInd][nIndTarget++] = aEntry[nIndOrig];
5494 		}
5495 
5496 		aSeq[nIDInd].realloc( nIndTarget );
5497 	}
5498 	else
5499 		throw container::ElementExistException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5500 
5501 
5502 	m_pImpl->m_aRelInfo = aSeq;
5503 	m_pImpl->m_xNewRelInfoStream = uno::Reference< io::XInputStream >();
5504 	m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
5505 }
5506 
5507 //-----------------------------------------------
removeRelationshipByID(const::rtl::OUString & sID)5508 void SAL_CALL OStorage::removeRelationshipByID(  const ::rtl::OUString& sID  )
5509 		throw ( container::NoSuchElementException,
5510 				io::IOException,
5511 				uno::RuntimeException )
5512 {
5513 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5514 
5515 	if ( !m_pImpl )
5516     {
5517         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5518         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5519     }
5520 
5521 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5522 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5523 
5524 	uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
5525 	for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
5526 		for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
5527 			if ( aSeq[nInd1][nInd2].First.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Id" ) ) )
5528 			{
5529 				if ( aSeq[nInd1][nInd2].Second.equals( sID ) )
5530 				{
5531 					sal_Int32 nLength = aSeq.getLength();
5532 					aSeq[nInd1] = aSeq[nLength-1];
5533 					aSeq.realloc( nLength - 1 );
5534 
5535 					m_pImpl->m_aRelInfo = aSeq;
5536 					m_pImpl->m_xNewRelInfoStream = uno::Reference< io::XInputStream >();
5537 					m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
5538 
5539 					// TODO/LATER: in future the unification of the ID could be checked
5540 					return;
5541 				}
5542 
5543 				break;
5544 			}
5545 
5546 	throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5547 }
5548 
5549 //-----------------------------------------------
insertRelationships(const uno::Sequence<uno::Sequence<beans::StringPair>> & aEntries,::sal_Bool bReplace)5550 void SAL_CALL OStorage::insertRelationships(  const uno::Sequence< uno::Sequence< beans::StringPair > >& aEntries, ::sal_Bool bReplace  )
5551 		throw ( container::ElementExistException,
5552 				io::IOException,
5553 				uno::RuntimeException )
5554 {
5555 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5556 
5557 	if ( !m_pImpl )
5558     {
5559         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5560         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5561     }
5562 
5563 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5564 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5565 
5566 	::rtl::OUString aIDTag( RTL_CONSTASCII_USTRINGPARAM( "Id" ) );
5567 	uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
5568 	uno::Sequence< uno::Sequence< beans::StringPair > > aResultSeq( aSeq.getLength() + aEntries.getLength() );
5569 	sal_Int32 nResultInd = 0;
5570 
5571 	for ( sal_Int32 nIndTarget1 = 0; nIndTarget1 < aSeq.getLength(); nIndTarget1++ )
5572 		for ( sal_Int32 nIndTarget2 = 0; nIndTarget2 < aSeq[nIndTarget1].getLength(); nIndTarget2++ )
5573 			if ( aSeq[nIndTarget1][nIndTarget2].First.equals( aIDTag ) )
5574 			{
5575 				sal_Int32 nIndSourceSame = -1;
5576 
5577 				for ( sal_Int32 nIndSource1 = 0; nIndSource1 < aEntries.getLength(); nIndSource1++ )
5578 					for ( sal_Int32 nIndSource2 = 0; nIndSource2 < aEntries[nIndSource1].getLength(); nIndSource2++ )
5579 					{
5580 						if ( aEntries[nIndSource1][nIndSource2].First.equals( aIDTag ) )
5581 						{
5582 							if ( aEntries[nIndSource1][nIndSource2].Second.equals( aSeq[nIndTarget1][nIndTarget2].Second ) )
5583 							{
5584 								if ( !bReplace )
5585 									throw container::ElementExistException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5586 
5587 								nIndSourceSame = nIndSource1;
5588 							}
5589 
5590 							break;
5591 						}
5592 					}
5593 
5594 				if ( nIndSourceSame == -1 )
5595 				{
5596 					// no such element in the provided sequence
5597 					aResultSeq[nResultInd++] = aSeq[nIndTarget1];
5598 				}
5599 
5600 				break;
5601 			}
5602 
5603 	for ( sal_Int32 nIndSource1 = 0; nIndSource1 < aEntries.getLength(); nIndSource1++ )
5604 	{
5605 		aResultSeq[nResultInd].realloc( aEntries[nIndSource1].getLength() );
5606 		sal_Bool bHasID = sal_False;
5607 		sal_Int32 nResInd2 = 1;
5608 
5609 		for ( sal_Int32 nIndSource2 = 0; nIndSource2 < aEntries[nIndSource1].getLength(); nIndSource2++ )
5610 			if ( aEntries[nIndSource1][nIndSource2].First.equals( aIDTag ) )
5611 			{
5612 				aResultSeq[nResultInd][0] = aEntries[nIndSource1][nIndSource2];
5613 				bHasID = sal_True;
5614 			}
5615 			else if ( nResInd2 < aResultSeq[nResultInd].getLength() )
5616 				aResultSeq[nResultInd][nResInd2++] = aEntries[nIndSource1][nIndSource2];
5617 			else
5618 				throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: illegal relation ( no ID )
5619 
5620 		if ( !bHasID )
5621 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: illegal relations
5622 
5623 		nResultInd++;
5624 	}
5625 
5626 	aResultSeq.realloc( nResultInd );
5627 	m_pImpl->m_aRelInfo = aResultSeq;
5628 	m_pImpl->m_xNewRelInfoStream = uno::Reference< io::XInputStream >();
5629 	m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
5630 }
5631 
5632 //-----------------------------------------------
clearRelationships()5633 void SAL_CALL OStorage::clearRelationships()
5634 		throw ( io::IOException,
5635 				uno::RuntimeException )
5636 {
5637 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5638 
5639 	if ( !m_pImpl )
5640     {
5641         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5642         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5643     }
5644 
5645 	if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
5646 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5647 
5648 	m_pImpl->m_aRelInfo.realloc( 0 );
5649 	m_pImpl->m_xNewRelInfoStream = uno::Reference< io::XInputStream >();
5650 	m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
5651 }
5652 
5653 //____________________________________________________________________________________________________
5654 //	XOptimizedStorage
5655 //____________________________________________________________________________________________________
5656 //-----------------------------------------------
insertRawNonEncrStreamElementDirect(const::rtl::OUString &,const uno::Reference<io::XInputStream> &)5657 void SAL_CALL OStorage::insertRawNonEncrStreamElementDirect(
5658 			const ::rtl::OUString& /*sStreamName*/,
5659 			const uno::Reference< io::XInputStream >& /*xInStream*/ )
5660 		throw ( embed::InvalidStorageException,
5661 				lang::IllegalArgumentException,
5662 				packages::NoRawFormatException,
5663 				container::ElementExistException,
5664 				io::IOException,
5665 				embed::StorageWrappedTargetException,
5666 				uno::RuntimeException )
5667 {
5668 	// not implemented currently because there is still no demand
5669 	// might need to be implemented if direct copying of compressed streams is used
5670 	throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5671 }
5672 
5673 //-----------------------------------------------
insertStreamElementDirect(const::rtl::OUString & aStreamName,const uno::Reference<io::XInputStream> & xInStream,const uno::Sequence<beans::PropertyValue> & aProps)5674 void SAL_CALL OStorage::insertStreamElementDirect(
5675 			const ::rtl::OUString& aStreamName,
5676 			const uno::Reference< io::XInputStream >& xInStream,
5677 			const uno::Sequence< beans::PropertyValue >& aProps )
5678 		throw ( embed::InvalidStorageException,
5679 				lang::IllegalArgumentException,
5680 				container::ElementExistException,
5681 				io::IOException,
5682 				embed::StorageWrappedTargetException,
5683 				uno::RuntimeException )
5684 {
5685 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::insertStreamElementDirect" );
5686 
5687 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5688 
5689 	if ( !m_pImpl )
5690     {
5691         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5692         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5693     }
5694 
5695 	if ( !aStreamName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStreamName, sal_False ) )
5696 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
5697 
5698 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
5699 	  && aStreamName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
5700 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // unacceptable storage name
5701 
5702 	if ( m_pData->m_bReadOnlyWrap )
5703 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: access denied
5704 
5705 	try
5706 	{
5707 		SotElement_Impl* pElement = m_pImpl->FindElement( aStreamName );
5708 
5709 		if ( pElement )
5710 			throw container::ElementExistException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5711 
5712     	pElement = OpenStreamElement_Impl( aStreamName, embed::ElementModes::READWRITE, sal_False );
5713 		OSL_ENSURE( pElement && pElement->m_pStream, "In case element can not be created an exception must be thrown!" );
5714 
5715 		pElement->m_pStream->InsertStreamDirectly( xInStream, aProps );
5716 	}
5717 	catch( embed::InvalidStorageException& aInvalidStorageException )
5718     {
5719         m_pImpl->AddLog( aInvalidStorageException.Message );
5720         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5721         throw;
5722 	}
5723 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
5724     {
5725         m_pImpl->AddLog( aIllegalArgumentException.Message );
5726         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5727         throw;
5728 	}
5729 	catch( container::ElementExistException& aElementExistException )
5730     {
5731         m_pImpl->AddLog( aElementExistException.Message );
5732         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5733         throw;
5734 	}
5735 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
5736     {
5737         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
5738         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5739         throw;
5740 	}
5741 	catch( io::IOException& aIOException )
5742     {
5743         m_pImpl->AddLog( aIOException.Message );
5744         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5745         throw;
5746 	}
5747 	catch( uno::RuntimeException& aRuntimeException )
5748     {
5749         m_pImpl->AddLog( aRuntimeException.Message );
5750         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5751         throw;
5752 	}
5753 	catch( uno::Exception& aException )
5754 	{
5755       	m_pImpl->AddLog( aException.Message );
5756       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5757 
5758       	uno::Any aCaught( ::cppu::getCaughtException() );
5759 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't insert stream directly!" ) ),
5760 												 uno::Reference< io::XInputStream >(),
5761 												 aCaught );
5762 	}
5763 }
5764 
5765 //-----------------------------------------------
copyElementDirectlyTo(const::rtl::OUString & aElementName,const uno::Reference<embed::XOptimizedStorage> & xDest,const::rtl::OUString & aNewName)5766 void SAL_CALL OStorage::copyElementDirectlyTo(
5767 			const ::rtl::OUString& aElementName,
5768 			const uno::Reference< embed::XOptimizedStorage >& xDest,
5769 			const ::rtl::OUString& aNewName )
5770 		throw ( embed::InvalidStorageException,
5771 				lang::IllegalArgumentException,
5772 				container::NoSuchElementException,
5773 				container::ElementExistException,
5774 				io::IOException,
5775 				embed::StorageWrappedTargetException,
5776 				uno::RuntimeException )
5777 {
5778 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::copyElementDirectlyTo" );
5779 
5780 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5781 
5782 	if ( !m_pImpl )
5783     {
5784         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5785         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5786     }
5787 
5788 	if ( !aElementName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aElementName, sal_False )
5789 	  || !aNewName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aNewName, sal_False ) )
5790 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
5791 
5792 	if ( !xDest.is() || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ), uno::UNO_QUERY ) )
5793 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 2 );
5794 
5795 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
5796 	  && ( aElementName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) )
5797 	    || aNewName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) ) )
5798 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 ); // unacceptable name
5799 
5800 	try
5801 	{
5802 		SotElement_Impl* pElement = m_pImpl->FindElement( aElementName );
5803 		if ( !pElement )
5804 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5805 
5806 		uno::Reference< XNameAccess > xNameAccess( xDest, uno::UNO_QUERY );
5807 		if ( !xNameAccess.is() )
5808 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5809 
5810 		if ( xNameAccess->hasByName( aNewName ) )
5811 			throw container::ElementExistException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5812 
5813 		// let the element be copied directly
5814 		uno::Reference< embed::XStorage > xStorDest( xDest, uno::UNO_QUERY_THROW );
5815 		m_pImpl->CopyStorageElement( pElement, xStorDest, aNewName, sal_True );
5816 	}
5817 	catch( embed::InvalidStorageException& aInvalidStorageException )
5818     {
5819         m_pImpl->AddLog( aInvalidStorageException.Message );
5820         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5821         throw;
5822 	}
5823 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
5824     {
5825         m_pImpl->AddLog( aIllegalArgumentException.Message );
5826         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5827         throw;
5828 	}
5829 	catch( container::NoSuchElementException& aNoSuchElementException )
5830     {
5831         m_pImpl->AddLog( aNoSuchElementException.Message );
5832         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5833         throw;
5834 	}
5835 	catch( container::ElementExistException& aElementExistException )
5836     {
5837         m_pImpl->AddLog( aElementExistException.Message );
5838         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5839         throw;
5840 	}
5841 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
5842     {
5843         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
5844         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5845         throw;
5846 	}
5847 	catch( io::IOException& aIOException )
5848     {
5849         m_pImpl->AddLog( aIOException.Message );
5850         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5851         throw;
5852 	}
5853 	catch( uno::RuntimeException& aRuntimeException )
5854     {
5855         m_pImpl->AddLog( aRuntimeException.Message );
5856         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5857         throw;
5858 	}
5859 	catch( uno::Exception& aException )
5860 	{
5861       	m_pImpl->AddLog( aException.Message );
5862       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5863 
5864       	uno::Any aCaught( ::cppu::getCaughtException() );
5865 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't copy element direcly!" ) ),
5866 												 uno::Reference< io::XInputStream >(),
5867 												 aCaught );
5868 	}
5869 }
5870 
5871 //-----------------------------------------------
writeAndAttachToStream(const uno::Reference<io::XStream> & xStream)5872 void SAL_CALL OStorage::writeAndAttachToStream( const uno::Reference< io::XStream >& xStream )
5873 		throw ( embed::InvalidStorageException,
5874 				lang::IllegalArgumentException,
5875 				io::IOException,
5876 				embed::StorageWrappedTargetException,
5877 				uno::RuntimeException )
5878 {
5879 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::writeAndAttachToStream" );
5880 
5881 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5882 
5883 	if ( !m_pImpl )
5884     {
5885         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5886         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5887     }
5888 
5889 	if ( !m_pData->m_bIsRoot )
5890 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 );
5891 
5892 	if ( !m_pImpl->m_pSwitchStream )
5893 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5894 
5895 	try
5896 	{
5897 		m_pImpl->m_pSwitchStream->CopyAndSwitchPersistenceTo( xStream );
5898 	}
5899 	catch( embed::InvalidStorageException& aInvalidStorageException )
5900     {
5901         m_pImpl->AddLog( aInvalidStorageException.Message );
5902         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5903         throw;
5904 	}
5905 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
5906     {
5907         m_pImpl->AddLog( aIllegalArgumentException.Message );
5908         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5909         throw;
5910 	}
5911 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
5912     {
5913         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
5914         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5915         throw;
5916 	}
5917 	catch( io::IOException& aIOException )
5918     {
5919         m_pImpl->AddLog( aIOException.Message );
5920         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5921         throw;
5922 	}
5923 	catch( uno::RuntimeException& aRuntimeException )
5924     {
5925         m_pImpl->AddLog( aRuntimeException.Message );
5926         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5927         throw;
5928 	}
5929 	catch( uno::Exception& aException )
5930 	{
5931       	m_pImpl->AddLog( aException.Message );
5932       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5933 
5934       	uno::Any aCaught( ::cppu::getCaughtException() );
5935 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't write and attach to stream!" ) ),
5936 												 uno::Reference< io::XInputStream >(),
5937 												 aCaught );
5938 	}
5939 
5940 }
5941 
5942 //-----------------------------------------------
attachToURL(const::rtl::OUString & sURL,sal_Bool bReadOnly)5943 void SAL_CALL OStorage::attachToURL( const ::rtl::OUString& sURL,
5944 									sal_Bool bReadOnly )
5945 		throw ( embed::InvalidStorageException,
5946 				lang::IllegalArgumentException,
5947 				io::IOException,
5948 				embed::StorageWrappedTargetException,
5949 				uno::RuntimeException )
5950 {
5951 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::attachToURL" );
5952 
5953 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
5954 
5955 	if ( !m_pImpl )
5956     {
5957         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
5958         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5959     }
5960 
5961 	if ( !m_pData->m_bIsRoot )
5962 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 );
5963 
5964 	if ( !m_pImpl->m_pSwitchStream )
5965 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
5966 
5967 	uno::Reference < ucb::XSimpleFileAccess > xAccess(
5968 			m_pImpl->m_xFactory->createInstance (
5969 					::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.SimpleFileAccess" ) ) ),
5970 			uno::UNO_QUERY_THROW );
5971 
5972 	try
5973 	{
5974 		if ( bReadOnly )
5975 		{
5976 			uno::Reference< io::XInputStream > xInputStream = xAccess->openFileRead( sURL );
5977 			m_pImpl->m_pSwitchStream->SwitchPersistenceTo( xInputStream );
5978 		}
5979 		else
5980 		{
5981 			uno::Reference< io::XStream > xStream = xAccess->openFileReadWrite( sURL );
5982 			m_pImpl->m_pSwitchStream->SwitchPersistenceTo( xStream );
5983 		}
5984 	}
5985 	catch( embed::InvalidStorageException& aInvalidStorageException )
5986     {
5987         m_pImpl->AddLog( aInvalidStorageException.Message );
5988         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5989         throw;
5990 	}
5991 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
5992     {
5993         m_pImpl->AddLog( aIllegalArgumentException.Message );
5994         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
5995         throw;
5996 	}
5997 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
5998     {
5999         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
6000         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6001         throw;
6002 	}
6003 	catch( io::IOException& aIOException )
6004     {
6005         m_pImpl->AddLog( aIOException.Message );
6006         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6007         throw;
6008 	}
6009 	catch( uno::RuntimeException& aRuntimeException )
6010     {
6011         m_pImpl->AddLog( aRuntimeException.Message );
6012         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6013         throw;
6014 	}
6015 	catch( uno::Exception& aException )
6016 	{
6017       	m_pImpl->AddLog( aException.Message );
6018       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6019 
6020       	uno::Any aCaught( ::cppu::getCaughtException() );
6021 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't attach to URL!" ) ),
6022 												 uno::Reference< io::XInputStream >(),
6023 												 aCaught );
6024 	}
6025 }
6026 
6027 //-----------------------------------------------
getElementPropertyValue(const::rtl::OUString & aElementName,const::rtl::OUString & aPropertyName)6028 uno::Any SAL_CALL OStorage::getElementPropertyValue( const ::rtl::OUString& aElementName, const ::rtl::OUString& aPropertyName )
6029 		throw ( embed::InvalidStorageException,
6030 				lang::IllegalArgumentException,
6031 				container::NoSuchElementException,
6032 				io::IOException,
6033 				beans::UnknownPropertyException,
6034 				beans::PropertyVetoException,
6035 				embed::StorageWrappedTargetException,
6036 				uno::RuntimeException)
6037 {
6038 	RTL_LOGFILE_CONTEXT( aLog, "package (mv76033) OStorage::getElementPropertyValue" );
6039 
6040 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
6041 
6042 	if ( !m_pImpl )
6043     {
6044         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
6045         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6046     }
6047 
6048 	if ( !aElementName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aElementName, sal_False ) )
6049 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
6050 
6051 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
6052 	  && aElementName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
6053 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // TODO: unacceptable name
6054 
6055 	try
6056 	{
6057     	SotElement_Impl *pElement = m_pImpl->FindElement( aElementName );
6058     	if ( !pElement )
6059 			throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6060 
6061 		// TODO/LATER: Currently it is only implemented for MediaType property of substorages, might be changed in future
6062 		if ( !pElement->m_bIsStorage || m_pData->m_nStorageType != embed::StorageFormats::PACKAGE || !aPropertyName.equalsAscii( "MediaType" ) )
6063 			throw beans::PropertyVetoException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6064 
6065 		if ( !pElement->m_pStorage )
6066 			m_pImpl->OpenSubStorage( pElement, embed::ElementModes::READ );
6067 
6068 		if ( !pElement->m_pStorage )
6069 			throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: general_error
6070 
6071 		pElement->m_pStorage->ReadContents();
6072 		return uno::makeAny( pElement->m_pStorage->m_aMediaType );
6073 	}
6074 	catch( embed::InvalidStorageException& aInvalidStorageException )
6075     {
6076         m_pImpl->AddLog( aInvalidStorageException.Message );
6077         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6078         throw;
6079 	}
6080 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
6081     {
6082         m_pImpl->AddLog( aIllegalArgumentException.Message );
6083         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6084         throw;
6085 	}
6086 	catch( container::NoSuchElementException& aNoSuchElementException )
6087     {
6088         m_pImpl->AddLog( aNoSuchElementException.Message );
6089         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6090         throw;
6091 	}
6092 	catch( beans::UnknownPropertyException& aUnknownPropertyException )
6093     {
6094         m_pImpl->AddLog( aUnknownPropertyException.Message );
6095         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6096         throw;
6097 	}
6098 	catch( beans::PropertyVetoException& aPropertyVetoException )
6099     {
6100         m_pImpl->AddLog( aPropertyVetoException.Message );
6101         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6102         throw;
6103 	}
6104 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
6105     {
6106         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
6107         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6108         throw;
6109 	}
6110 	catch( io::IOException& aIOException )
6111     {
6112         m_pImpl->AddLog( aIOException.Message );
6113         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6114         throw;
6115 	}
6116 	catch( uno::RuntimeException& aRuntimeException )
6117     {
6118         m_pImpl->AddLog( aRuntimeException.Message );
6119         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6120         throw;
6121 	}
6122 	catch( uno::Exception& aException )
6123 	{
6124       	m_pImpl->AddLog( aException.Message );
6125       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6126 
6127       	uno::Any aCaught( ::cppu::getCaughtException() );
6128 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't get element property!" ) ),
6129 												 uno::Reference< io::XInputStream >(),
6130 												 aCaught );
6131 	}
6132 }
6133 
6134 //-----------------------------------------------
copyStreamElementData(const::rtl::OUString & aStreamName,const uno::Reference<io::XStream> & xTargetStream)6135 void SAL_CALL OStorage::copyStreamElementData( const ::rtl::OUString& aStreamName, const uno::Reference< io::XStream >& xTargetStream )
6136 		throw ( embed::InvalidStorageException,
6137 				lang::IllegalArgumentException,
6138 				packages::WrongPasswordException,
6139 				io::IOException,
6140 				embed::StorageWrappedTargetException,
6141 				uno::RuntimeException )
6142 {
6143 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
6144 
6145 	if ( !m_pImpl )
6146     {
6147         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
6148         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6149     }
6150 
6151 	if ( !aStreamName.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStreamName, sal_False ) )
6152 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
6153 
6154 	if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML
6155 	  && aStreamName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_rels" ) ) ) )
6156 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 ); // unacceptable name
6157 
6158 	if ( !xTargetStream.is() )
6159 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 2 );
6160 
6161 	try
6162 	{
6163 		uno::Reference< io::XStream > xNonconstRef = xTargetStream;
6164 		m_pImpl->CloneStreamElement( aStreamName, sal_False, ::comphelper::SequenceAsHashMap(), xNonconstRef );
6165 
6166 		OSL_ENSURE( xNonconstRef == xTargetStream, "The provided stream reference seems not be filled in correctly!\n" );
6167 		if ( xNonconstRef != xTargetStream )
6168 			throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // if the stream reference is set it must not be changed!
6169 	}
6170 	catch( embed::InvalidStorageException& aInvalidStorageException )
6171     {
6172         m_pImpl->AddLog( aInvalidStorageException.Message );
6173         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6174         throw;
6175 	}
6176 	catch( lang::IllegalArgumentException& aIllegalArgumentException )
6177     {
6178         m_pImpl->AddLog( aIllegalArgumentException.Message );
6179         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6180         throw;
6181 	}
6182 	catch( packages::WrongPasswordException& aWrongPasswordException )
6183     {
6184         m_pImpl->AddLog( aWrongPasswordException.Message );
6185         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6186         throw;
6187 	}
6188 	catch( io::IOException& aIOException )
6189     {
6190         m_pImpl->AddLog( aIOException.Message );
6191         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6192         throw;
6193 	}
6194 	catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
6195     {
6196         m_pImpl->AddLog( aStorageWrappedTargetException.Message );
6197         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6198         throw;
6199 	}
6200 	catch( uno::RuntimeException& aRuntimeException )
6201     {
6202         m_pImpl->AddLog( aRuntimeException.Message );
6203         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6204         throw;
6205 	}
6206 	catch( uno::Exception& aException )
6207 	{
6208       	m_pImpl->AddLog( aException.Message );
6209       	m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
6210 
6211       	uno::Any aCaught( ::cppu::getCaughtException() );
6212 		throw embed::StorageWrappedTargetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't copy stream data!" ) ),
6213 												 uno::Reference< io::XInputStream >(),
6214 												 aCaught );
6215 	}
6216 
6217 
6218 }
6219 
6220 //____________________________________________________________________________________________________
6221 // XHierarchicalStorageAccess
6222 //____________________________________________________________________________________________________
6223 
6224 //-----------------------------------------------
openStreamElementByHierarchicalName(const::rtl::OUString & aStreamPath,::sal_Int32 nOpenMode)6225 uno::Reference< embed::XExtendedStorageStream > SAL_CALL OStorage::openStreamElementByHierarchicalName( const ::rtl::OUString& aStreamPath, ::sal_Int32 nOpenMode )
6226 		throw ( embed::InvalidStorageException,
6227 				lang::IllegalArgumentException,
6228 				packages::WrongPasswordException,
6229 				io::IOException,
6230 				embed::StorageWrappedTargetException,
6231 				uno::RuntimeException )
6232 {
6233 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
6234 
6235 	if ( !m_pImpl )
6236     {
6237         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
6238         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6239     }
6240 
6241 	if ( !aStreamPath.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStreamPath, sal_True ) )
6242 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
6243 
6244 	if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE )
6245 	  && ( nOpenMode & embed::ElementModes::WRITE ) )
6246 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // Access denied
6247 
6248 	OStringList_Impl aListPath = OHierarchyHolder_Impl::GetListPathFromString( aStreamPath );
6249 	OSL_ENSURE( aListPath.size(), "The result list must not be empty!" );
6250 
6251 	uno::Reference< embed::XExtendedStorageStream > xResult;
6252 	if ( aListPath.size() == 1 )
6253 	{
6254 		// that must be a direct request for a stream
6255 		// the transacted version of the stream should be opened
6256 
6257     	SotElement_Impl *pElement = OpenStreamElement_Impl( aStreamPath, nOpenMode, sal_False );
6258 		OSL_ENSURE( pElement && pElement->m_pStream, "In case element can not be created an exception must be thrown!" );
6259 
6260 		xResult = uno::Reference< embed::XExtendedStorageStream >(
6261 						pElement->m_pStream->GetStream( nOpenMode, sal_True ),
6262 						uno::UNO_QUERY_THROW );
6263 	}
6264 	else
6265 	{
6266 		// there are still storages in between
6267 		if ( !m_pData->m_rHierarchyHolder.is() )
6268 			m_pData->m_rHierarchyHolder = new OHierarchyHolder_Impl(
6269 				uno::Reference< embed::XStorage >( static_cast< embed::XStorage* >( this ) ) );
6270 
6271 		xResult = m_pData->m_rHierarchyHolder->GetStreamHierarchically(
6272 												( m_pImpl->m_nStorageMode & embed::ElementModes::READWRITE ),
6273 												aListPath,
6274 												nOpenMode );
6275 	}
6276 
6277 	if ( !xResult.is() )
6278 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6279 
6280 	return xResult;
6281 }
6282 
6283 //-----------------------------------------------
openEncryptedStreamElementByHierarchicalName(const::rtl::OUString & aStreamPath,::sal_Int32 nOpenMode,const::rtl::OUString & sPassword)6284 uno::Reference< embed::XExtendedStorageStream > SAL_CALL OStorage::openEncryptedStreamElementByHierarchicalName( const ::rtl::OUString& aStreamPath, ::sal_Int32 nOpenMode, const ::rtl::OUString& sPassword )
6285 		throw ( embed::InvalidStorageException,
6286 				lang::IllegalArgumentException,
6287 				packages::NoEncryptionException,
6288 				packages::WrongPasswordException,
6289 				io::IOException,
6290 				embed::StorageWrappedTargetException,
6291 				uno::RuntimeException )
6292 {
6293     return openEncryptedStreamByHierarchicalName( aStreamPath, nOpenMode, ::comphelper::OStorageHelper::CreatePackageEncryptionData( sPassword ) );
6294 }
6295 
6296 //-----------------------------------------------
removeStreamElementByHierarchicalName(const::rtl::OUString & aStreamPath)6297 void SAL_CALL OStorage::removeStreamElementByHierarchicalName( const ::rtl::OUString& aStreamPath )
6298 		throw ( embed::InvalidStorageException,
6299 				lang::IllegalArgumentException,
6300 				container::NoSuchElementException,
6301 				io::IOException,
6302 				embed::StorageWrappedTargetException,
6303 				uno::RuntimeException )
6304 {
6305 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
6306 
6307 	if ( !m_pImpl )
6308     {
6309         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
6310         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6311     }
6312 
6313 	if ( !aStreamPath.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStreamPath, sal_True ) )
6314 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
6315 
6316 	if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE ) )
6317 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // Access denied
6318 
6319 	OStringList_Impl aListPath = OHierarchyHolder_Impl::GetListPathFromString( aStreamPath );
6320 	OSL_ENSURE( aListPath.size(), "The result list must not be empty!" );
6321 
6322 	if ( !m_pData->m_rHierarchyHolder.is() )
6323 		m_pData->m_rHierarchyHolder = new OHierarchyHolder_Impl(
6324 			uno::Reference< embed::XStorage >( static_cast< embed::XStorage* >( this ) ) );
6325 
6326 	m_pData->m_rHierarchyHolder->RemoveStreamHierarchically( aListPath );
6327 }
6328 
6329 //____________________________________________________________________________________________________
6330 // XHierarchicalStorageAccess2
6331 //____________________________________________________________________________________________________
6332 
openEncryptedStreamByHierarchicalName(const::rtl::OUString & aStreamPath,::sal_Int32 nOpenMode,const uno::Sequence<beans::NamedValue> & aEncryptionData)6333 uno::Reference< embed::XExtendedStorageStream > SAL_CALL OStorage::openEncryptedStreamByHierarchicalName( const ::rtl::OUString& aStreamPath, ::sal_Int32 nOpenMode, const uno::Sequence< beans::NamedValue >& aEncryptionData )
6334 		throw ( embed::InvalidStorageException,
6335 				lang::IllegalArgumentException,
6336 				packages::NoEncryptionException,
6337 				packages::WrongPasswordException,
6338 				io::IOException,
6339 				embed::StorageWrappedTargetException,
6340 				uno::RuntimeException )
6341 {
6342 	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
6343 
6344 	if ( !m_pImpl )
6345     {
6346         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Disposed!" ) ) );
6347         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6348     }
6349 
6350 	if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
6351 		throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6352 
6353 	if ( !aStreamPath.getLength() || !::comphelper::OStorageHelper::IsValidZipEntryFileName( aStreamPath, sal_True ) )
6354 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected entry name syntax." ) ), uno::Reference< uno::XInterface >(), 1 );
6355 
6356 	if ( !aEncryptionData.getLength() )
6357 		throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 3 );
6358 
6359 	if ( !( m_pImpl->m_nStorageMode & embed::ElementModes::WRITE )
6360 	  && ( nOpenMode & embed::ElementModes::WRITE ) )
6361 		throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // Access denied
6362 
6363 	OStringList_Impl aListPath = OHierarchyHolder_Impl::GetListPathFromString( aStreamPath );
6364 	OSL_ENSURE( aListPath.size(), "The result list must not be empty!" );
6365 
6366 	uno::Reference< embed::XExtendedStorageStream > xResult;
6367 	if ( aListPath.size() == 1 )
6368 	{
6369 		// that must be a direct request for a stream
6370 		// the transacted version of the stream should be opened
6371 
6372     	SotElement_Impl *pElement = OpenStreamElement_Impl( aStreamPath, nOpenMode, sal_True );
6373 		OSL_ENSURE( pElement && pElement->m_pStream, "In case element can not be created an exception must be thrown!" );
6374 
6375 		xResult = uno::Reference< embed::XExtendedStorageStream >(
6376 						pElement->m_pStream->GetStream( nOpenMode, aEncryptionData, sal_True ),
6377 						uno::UNO_QUERY_THROW );
6378 	}
6379 	else
6380 	{
6381 		// there are still storages in between
6382 		if ( !m_pData->m_rHierarchyHolder.is() )
6383 			m_pData->m_rHierarchyHolder = new OHierarchyHolder_Impl(
6384 				uno::Reference< embed::XStorage >( static_cast< embed::XStorage* >( this ) ) );
6385 
6386 		xResult = m_pData->m_rHierarchyHolder->GetStreamHierarchically(
6387 												( m_pImpl->m_nStorageMode & embed::ElementModes::READWRITE ),
6388 												aListPath,
6389 												nOpenMode,
6390 												aEncryptionData );
6391 	}
6392 
6393 	if ( !xResult.is() )
6394 		throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
6395 
6396 	return xResult;
6397 }
6398 
6399 
6400