Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <memory>
21 :
22 : #include "com/sun/star/beans/XPropertySet.hpp"
23 : #include "com/sun/star/embed/ElementModes.hpp"
24 : #include "com/sun/star/embed/StorageFactory.hpp"
25 : #include "comphelper/processfactory.hxx"
26 :
27 : #include "tdoc_uri.hxx"
28 : #include "tdoc_docmgr.hxx"
29 : #include "tdoc_stgelems.hxx"
30 :
31 : #include "tdoc_storage.hxx"
32 :
33 : using namespace com::sun::star;
34 : using namespace tdoc_ucp;
35 :
36 :
37 : //=========================================================================
38 : //=========================================================================
39 : //
40 : // StorageElementFactory Implementation.
41 : //
42 : //=========================================================================
43 : //=========================================================================
44 :
45 7 : StorageElementFactory::StorageElementFactory(
46 : const uno::Reference< uno::XComponentContext > & rxContext,
47 : const rtl::Reference< OfficeDocumentsManager > & xDocsMgr )
48 : : m_xDocsMgr( xDocsMgr ),
49 7 : m_xContext( rxContext )
50 : {
51 7 : }
52 :
53 : //=========================================================================
54 14 : StorageElementFactory::~StorageElementFactory()
55 : {
56 : OSL_ENSURE( m_aMap.empty(),
57 : "StorageElementFactory::~StorageElementFactory - Dangling storages!" );
58 14 : }
59 :
60 : //=========================================================================
61 : uno::Reference< embed::XStorage >
62 0 : StorageElementFactory::createTemporaryStorage()
63 : throw ( uno::Exception,
64 : uno::RuntimeException )
65 : {
66 0 : uno::Reference< embed::XStorage > xStorage;
67 0 : uno::Reference< lang::XSingleServiceFactory > xStorageFac;
68 0 : if ( m_xContext.is() )
69 : {
70 0 : xStorageFac = embed::StorageFactory::create( m_xContext );
71 : }
72 :
73 : OSL_ENSURE( xStorageFac.is(), "Can't create storage factory!" );
74 0 : if ( xStorageFac.is() )
75 : xStorage = uno::Reference< embed::XStorage >(
76 0 : xStorageFac->createInstance(),
77 0 : uno::UNO_QUERY );
78 :
79 0 : if ( !xStorage.is() )
80 0 : throw uno::RuntimeException();
81 :
82 0 : return xStorage;
83 : }
84 :
85 : //=========================================================================
86 : uno::Reference< embed::XStorage >
87 5 : StorageElementFactory::createStorage( const rtl::OUString & rUri,
88 : StorageAccessMode eMode )
89 : throw ( embed::InvalidStorageException,
90 : lang::IllegalArgumentException,
91 : io::IOException,
92 : embed::StorageWrappedTargetException,
93 : uno::RuntimeException )
94 : {
95 5 : osl::MutexGuard aGuard( m_aMutex );
96 :
97 5 : if ( ( eMode != READ ) &&
98 : ( eMode != READ_WRITE_NOCREATE ) &&
99 : ( eMode != READ_WRITE_CREATE ) )
100 : throw lang::IllegalArgumentException(
101 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
102 : "Invalid open mode!" ) ),
103 : uno::Reference< uno::XInterface >(),
104 0 : sal_Int16( 2 ) );
105 :
106 5 : Uri aUri( rUri );
107 5 : if ( aUri.isRoot() )
108 : {
109 : throw lang::IllegalArgumentException(
110 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
111 : "Root never has a storage!" ) ),
112 : uno::Reference< uno::XInterface >(),
113 0 : sal_Int16( 1 ) );
114 : }
115 :
116 : rtl::OUString aUriKey
117 5 : ( ( rUri.getStr()[ rUri.getLength() - 1 ] == sal_Unicode( '/' ) )
118 0 : ? rUri.copy( 0, rUri.getLength() - 1 )
119 5 : : rUri );
120 :
121 5 : StorageMap::iterator aIt ( m_aMap.begin() );
122 5 : StorageMap::iterator aEnd( m_aMap.end() );
123 :
124 10 : while ( aIt != aEnd )
125 : {
126 0 : if ( (*aIt).first.first == aUriKey )
127 : {
128 : // URI matches. Now, check open mode.
129 0 : bool bMatch = true;
130 0 : switch ( eMode )
131 : {
132 : case READ:
133 : // No need to check; storage is at least readable.
134 0 : bMatch = true;
135 0 : break;
136 :
137 : case READ_WRITE_NOCREATE:
138 : case READ_WRITE_CREATE:
139 : // If found storage is writable, it can be used.
140 : // If not, a new one must be created.
141 0 : bMatch = (*aIt).first.second;
142 0 : break;
143 : }
144 :
145 0 : if ( bMatch )
146 0 : break;
147 : }
148 0 : ++aIt;
149 : }
150 :
151 5 : if ( aIt == aEnd )
152 : {
153 5 : uno::Reference< embed::XStorage > xParentStorage;
154 :
155 : // documents never have a parent storage.
156 5 : if ( !aUri.isDocument() )
157 : {
158 0 : xParentStorage = queryParentStorage( aUriKey, eMode );
159 :
160 0 : if ( !xParentStorage.is() )
161 : {
162 : // requested to create new storage, but failed?
163 : OSL_ENSURE( eMode != READ_WRITE_CREATE,
164 : "Unable to create parent storage!" );
165 0 : return xParentStorage;
166 : }
167 : }
168 :
169 : uno::Reference< embed::XStorage > xStorage
170 5 : = queryStorage( xParentStorage, aUriKey, eMode );
171 :
172 5 : if ( !xStorage.is() )
173 : {
174 : // requested to create new storage, but failed?
175 : OSL_ENSURE( eMode != READ_WRITE_CREATE,
176 : "Unable to create storage!" );
177 0 : return xStorage;
178 : }
179 :
180 : bool bWritable = ( ( eMode == READ_WRITE_NOCREATE )
181 5 : || ( eMode == READ_WRITE_CREATE ) );
182 :
183 : std::auto_ptr< Storage > xElement(
184 5 : new Storage( m_xContext, this, aUriKey, xParentStorage, xStorage ) );
185 :
186 : aIt = m_aMap.insert(
187 : StorageMap::value_type(
188 : std::pair< rtl::OUString, bool >( aUriKey, bWritable ),
189 5 : xElement.get() ) ).first;
190 :
191 5 : aIt->second->m_aContainerIt = aIt;
192 5 : xElement.release();
193 5 : return aIt->second;
194 : }
195 0 : else if ( osl_atomic_increment( &aIt->second->m_refCount ) > 1 )
196 : {
197 0 : rtl::Reference< Storage > xElement( aIt->second );
198 0 : osl_atomic_decrement( &aIt->second->m_refCount );
199 0 : return aIt->second;
200 : }
201 : else
202 : {
203 0 : osl_atomic_decrement( &aIt->second->m_refCount );
204 0 : aIt->second->m_aContainerIt = m_aMap.end();
205 :
206 0 : uno::Reference< embed::XStorage > xParentStorage;
207 :
208 : // documents never have a parent storage.
209 0 : if ( !aUri.isDocument() )
210 : {
211 0 : xParentStorage = queryParentStorage( aUriKey, eMode );
212 :
213 0 : if ( !xParentStorage.is() )
214 : {
215 : // requested to create new storage, but failed?
216 : OSL_ENSURE( eMode != READ_WRITE_CREATE,
217 : "Unable to create parent storage!" );
218 0 : return xParentStorage;
219 : }
220 : }
221 :
222 : uno::Reference< embed::XStorage > xStorage
223 0 : = queryStorage( xParentStorage, aUriKey, eMode );
224 :
225 0 : if ( !xStorage.is() )
226 : {
227 : // requested to create new storage, but failed?
228 : OSL_ENSURE( eMode != READ_WRITE_CREATE,
229 : "Unable to create storage!" );
230 0 : return xStorage;
231 : }
232 :
233 0 : aIt->second = new Storage( m_xContext, this, aUriKey, xParentStorage, xStorage );
234 0 : aIt->second->m_aContainerIt = aIt;
235 0 : return aIt->second;
236 5 : }
237 : }
238 :
239 : //=========================================================================
240 : uno::Reference< io::XInputStream >
241 0 : StorageElementFactory::createInputStream( const rtl::OUString & rUri,
242 : const rtl::OUString & rPassword )
243 : throw ( embed::InvalidStorageException,
244 : lang::IllegalArgumentException,
245 : io::IOException,
246 : embed::StorageWrappedTargetException,
247 : packages::WrongPasswordException,
248 : uno::RuntimeException )
249 : {
250 0 : osl::MutexGuard aGuard( m_aMutex );
251 :
252 : uno::Reference< embed::XStorage > xParentStorage
253 0 : = queryParentStorage( rUri, READ );
254 :
255 : // Each stream must have a parent storage.
256 0 : if ( !xParentStorage.is() )
257 0 : return uno::Reference< io::XInputStream >();
258 :
259 : uno::Reference< io::XStream > xStream
260 0 : = queryStream( xParentStorage, rUri, rPassword, READ, false );
261 :
262 0 : if ( !xStream.is() )
263 0 : return uno::Reference< io::XInputStream >();
264 :
265 0 : return xStream->getInputStream();
266 : }
267 :
268 : //=========================================================================
269 : uno::Reference< io::XOutputStream >
270 0 : StorageElementFactory::createOutputStream( const rtl::OUString & rUri,
271 : const rtl::OUString & rPassword,
272 : bool bTruncate )
273 : throw ( embed::InvalidStorageException,
274 : lang::IllegalArgumentException,
275 : io::IOException,
276 : embed::StorageWrappedTargetException,
277 : packages::WrongPasswordException,
278 : uno::RuntimeException )
279 : {
280 0 : osl::MutexGuard aGuard( m_aMutex );
281 :
282 : uno::Reference< embed::XStorage > xParentStorage
283 0 : = queryParentStorage( rUri, READ_WRITE_CREATE );
284 :
285 : // Each stream must have a parent storage.
286 0 : if ( !xParentStorage.is() )
287 : {
288 : OSL_FAIL( "StorageElementFactory::createOutputStream - "
289 : "Unable to create parent storage!" );
290 0 : return uno::Reference< io::XOutputStream >();
291 : }
292 :
293 : uno::Reference< io::XStream > xStream
294 : = queryStream(
295 0 : xParentStorage, rUri, rPassword, READ_WRITE_CREATE, bTruncate );
296 :
297 0 : if ( !xStream.is() )
298 : {
299 : OSL_FAIL( "StorageElementFactory::createOutputStream - "
300 : "Unable to create stream!" );
301 0 : return uno::Reference< io::XOutputStream >();
302 : }
303 :
304 : // Note: We need a wrapper to hold a reference to the parent storage to
305 : // ensure that nobody else owns it at the moment we want to commit
306 : // our changes. (There can be only one writable instance at a time
307 : // and even no writable instance if there is already another
308 : // read-only instance!)
309 : return uno::Reference< io::XOutputStream >(
310 0 : new OutputStream( m_xContext, rUri, xParentStorage, xStream->getOutputStream() ) );
311 : }
312 :
313 : //=========================================================================
314 : uno::Reference< io::XStream >
315 0 : StorageElementFactory::createStream( const rtl::OUString & rUri,
316 : const rtl::OUString & rPassword,
317 : bool bTruncate )
318 : throw ( embed::InvalidStorageException,
319 : lang::IllegalArgumentException,
320 : io::IOException,
321 : embed::StorageWrappedTargetException,
322 : packages::WrongPasswordException,
323 : uno::RuntimeException )
324 : {
325 0 : osl::MutexGuard aGuard( m_aMutex );
326 :
327 : uno::Reference< embed::XStorage > xParentStorage
328 0 : = queryParentStorage( rUri, READ_WRITE_CREATE );
329 :
330 : // Each stream must have a parent storage.
331 0 : if ( !xParentStorage.is() )
332 : {
333 : OSL_FAIL( "StorageElementFactory::createStream - "
334 : "Unable to create parent storage!" );
335 0 : return uno::Reference< io::XStream >();
336 : }
337 :
338 : uno::Reference< io::XStream > xStream
339 : = queryStream(
340 0 : xParentStorage, rUri, rPassword, READ_WRITE_NOCREATE, bTruncate );
341 :
342 0 : if ( !xStream.is() )
343 : {
344 : OSL_FAIL( "StorageElementFactory::createStream - "
345 : "Unable to create stream!" );
346 0 : return uno::Reference< io::XStream >();
347 : }
348 :
349 : return uno::Reference< io::XStream >(
350 0 : new Stream( m_xContext, rUri, xParentStorage, xStream ) );
351 : }
352 :
353 : //=========================================================================
354 5 : void StorageElementFactory::releaseElement( Storage * pElement ) SAL_THROW(())
355 : {
356 : OSL_ASSERT( pElement );
357 5 : osl::MutexGuard aGuard( m_aMutex );
358 5 : if ( pElement->m_aContainerIt != m_aMap.end() )
359 5 : m_aMap.erase( pElement->m_aContainerIt );
360 5 : }
361 :
362 : //=========================================================================
363 : //
364 : // Non-UNO interface
365 : //
366 : //=========================================================================
367 :
368 0 : uno::Reference< embed::XStorage > StorageElementFactory::queryParentStorage(
369 : const rtl::OUString & rUri, StorageAccessMode eMode )
370 : throw ( embed::InvalidStorageException,
371 : lang::IllegalArgumentException,
372 : io::IOException,
373 : embed::StorageWrappedTargetException,
374 : uno::RuntimeException )
375 : {
376 0 : uno::Reference< embed::XStorage > xParentStorage;
377 :
378 0 : Uri aUri( rUri );
379 0 : Uri aParentUri( aUri.getParentUri() );
380 0 : if ( !aParentUri.isRoot() )
381 : {
382 0 : xParentStorage = createStorage( aUri.getParentUri(), eMode );
383 : OSL_ENSURE( xParentStorage.is()
384 : // requested to create new storage, but failed?
385 : || ( eMode != READ_WRITE_CREATE ),
386 : "StorageElementFactory::queryParentStorage - No storage!" );
387 : }
388 0 : return xParentStorage;
389 : }
390 :
391 : //=========================================================================
392 5 : uno::Reference< embed::XStorage > StorageElementFactory::queryStorage(
393 : const uno::Reference< embed::XStorage > & xParentStorage,
394 : const rtl::OUString & rUri,
395 : StorageAccessMode eMode )
396 : throw ( embed::InvalidStorageException,
397 : lang::IllegalArgumentException,
398 : io::IOException,
399 : embed::StorageWrappedTargetException,
400 : uno::RuntimeException )
401 : {
402 5 : uno::Reference< embed::XStorage > xStorage;
403 :
404 5 : Uri aUri( rUri );
405 :
406 5 : if ( !xParentStorage.is() )
407 : {
408 : // document storage
409 :
410 5 : xStorage = m_xDocsMgr->queryStorage( aUri.getDocumentId() );
411 :
412 5 : if ( !xStorage.is() )
413 : {
414 0 : if ( eMode == READ_WRITE_CREATE )
415 : throw lang::IllegalArgumentException(
416 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
417 : "Invalid open mode: document storages cannot be "
418 : "created!" ) ),
419 : uno::Reference< uno::XInterface >(),
420 0 : sal_Int16( 2 ) );
421 : else
422 : throw embed::InvalidStorageException(
423 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
424 : "Invalid document id!" ) ),
425 0 : uno::Reference< uno::XInterface >() );
426 : }
427 :
428 : // match xStorage's open mode against requested open mode
429 :
430 : uno::Reference< beans::XPropertySet > xPropSet(
431 5 : xStorage, uno::UNO_QUERY );
432 : OSL_ENSURE( xPropSet.is(),
433 : "StorageElementFactory::queryStorage - "
434 : "No XPropertySet interface!" );
435 : try
436 : {
437 5 : uno::Any aPropValue = xPropSet->getPropertyValue(
438 : rtl::OUString(
439 5 : RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ) ) );
440 :
441 5 : sal_Int32 nOpenMode = 0;
442 5 : if ( aPropValue >>= nOpenMode )
443 : {
444 5 : switch ( eMode )
445 : {
446 : case READ:
447 5 : if ( !( nOpenMode & embed::ElementModes::READ ) )
448 : {
449 : // document opened, but not readable.
450 : throw embed::InvalidStorageException(
451 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
452 : "Storage is open, but not readable!" ) ),
453 0 : uno::Reference< uno::XInterface >() );
454 : }
455 : // storage okay
456 5 : break;
457 :
458 : case READ_WRITE_NOCREATE:
459 : case READ_WRITE_CREATE:
460 0 : if ( !( nOpenMode & embed::ElementModes::WRITE ) )
461 : {
462 : // document opened, but not writable.
463 : throw embed::InvalidStorageException(
464 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
465 : "Storage is open, but not writable!" ) ),
466 0 : uno::Reference< uno::XInterface >() );
467 : }
468 : // storage okay
469 0 : break;
470 : }
471 : }
472 : else
473 : {
474 : OSL_FAIL(
475 : "Bug! Value of property OpenMode has wrong type!" );
476 :
477 : throw uno::RuntimeException(
478 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
479 : "Bug! Value of property OpenMode has wrong type!" ) ),
480 0 : uno::Reference< uno::XInterface >() );
481 5 : }
482 : }
483 0 : catch ( beans::UnknownPropertyException const & e )
484 : {
485 : OSL_FAIL( "Property OpenMode not supported!" );
486 :
487 : throw embed::StorageWrappedTargetException(
488 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
489 : "Bug! Value of property OpenMode has wrong type!" ) ),
490 : uno::Reference< uno::XInterface >(),
491 0 : uno::makeAny( e ) );
492 : }
493 0 : catch ( lang::WrappedTargetException const & e )
494 : {
495 : OSL_FAIL( "Caught WrappedTargetException!" );
496 :
497 : throw embed::StorageWrappedTargetException(
498 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
499 : "WrappedTargetException during getPropertyValue!" ) ),
500 : uno::Reference< uno::XInterface >(),
501 0 : uno::makeAny( e ) );
502 5 : }
503 : }
504 : else
505 : {
506 : // sub storage
507 :
508 0 : const rtl::OUString & rName = aUri.getDecodedName();
509 :
510 0 : if ( eMode == READ )
511 : {
512 : try
513 : {
514 : sal_Int32 nOpenMode = embed::ElementModes::READ
515 0 : | embed::ElementModes::NOCREATE;
516 : xStorage
517 0 : = xParentStorage->openStorageElement( rName, nOpenMode );
518 : }
519 0 : catch ( io::IOException const & )
520 : {
521 : // Another chance: Try to clone storage.
522 0 : xStorage = createTemporaryStorage();
523 0 : xParentStorage->copyStorageElementLastCommitTo( rName,
524 0 : xStorage );
525 : }
526 : }
527 : else
528 : {
529 0 : sal_Int32 nOpenMode = embed::ElementModes::READWRITE;
530 0 : if ( eMode == READ_WRITE_NOCREATE )
531 0 : nOpenMode |= embed::ElementModes::NOCREATE;
532 :
533 0 : xStorage = xParentStorage->openStorageElement( rName, nOpenMode );
534 : }
535 : }
536 :
537 : OSL_ENSURE( xStorage.is() || ( eMode != READ_WRITE_CREATE ),
538 : "StorageElementFactory::queryStorage - No storage!" );
539 5 : return xStorage;
540 : }
541 :
542 : //=========================================================================
543 : uno::Reference< io::XStream >
544 0 : StorageElementFactory::queryStream(
545 : const uno::Reference< embed::XStorage > & xParentStorage,
546 : const rtl::OUString & rUri,
547 : const rtl::OUString & rPassword,
548 : StorageAccessMode eMode,
549 : bool bTruncate )
550 : throw ( embed::InvalidStorageException,
551 : lang::IllegalArgumentException,
552 : io::IOException,
553 : embed::StorageWrappedTargetException,
554 : packages::WrongPasswordException,
555 : uno::RuntimeException )
556 : {
557 0 : osl::MutexGuard aGuard( m_aMutex );
558 :
559 0 : if ( !xParentStorage.is() )
560 : {
561 : throw lang::IllegalArgumentException(
562 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
563 : "No parent storage!" ) ),
564 : uno::Reference< uno::XInterface >(),
565 0 : sal_Int16( 2 ) );
566 : }
567 :
568 0 : Uri aUri( rUri );
569 0 : if ( aUri.isRoot() )
570 : {
571 : throw lang::IllegalArgumentException(
572 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
573 : "Root never is a stream!" ) ),
574 : uno::Reference< uno::XInterface >(),
575 0 : sal_Int16( 2 ) );
576 : }
577 0 : else if ( aUri.isDocument() )
578 : {
579 : throw lang::IllegalArgumentException(
580 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
581 : "A document never is a stream!" ) ),
582 : uno::Reference< uno::XInterface >(),
583 0 : sal_Int16( 2 ) );
584 : }
585 :
586 : sal_Int32 nOpenMode;
587 0 : switch ( eMode )
588 : {
589 : case READ:
590 : nOpenMode = embed::ElementModes::READ
591 : | embed::ElementModes::NOCREATE
592 0 : | embed::ElementModes::SEEKABLE;
593 0 : break;
594 :
595 : case READ_WRITE_NOCREATE:
596 : nOpenMode = embed::ElementModes::READWRITE
597 : | embed::ElementModes::NOCREATE
598 0 : | embed::ElementModes::SEEKABLE;
599 :
600 0 : if ( bTruncate )
601 0 : nOpenMode |= embed::ElementModes::TRUNCATE;
602 :
603 0 : break;
604 :
605 : case READ_WRITE_CREATE:
606 : nOpenMode = embed::ElementModes::READWRITE
607 0 : | embed::ElementModes::SEEKABLE;
608 :
609 0 : if ( bTruncate )
610 0 : nOpenMode |= embed::ElementModes::TRUNCATE;
611 :
612 0 : break;
613 :
614 : default:
615 : OSL_FAIL( "StorageElementFactory::queryStream : Unknown open mode!" );
616 :
617 : throw embed::InvalidStorageException(
618 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
619 : "Unknown open mode!" ) ),
620 0 : uno::Reference< uno::XInterface >() );
621 : }
622 :
623 : // No object re-usage mechanism; streams are seekable => not stateless.
624 :
625 0 : uno::Reference< io::XStream > xStream;
626 0 : if ( !rPassword.isEmpty() )
627 : {
628 0 : if ( eMode == READ )
629 : {
630 : try
631 : {
632 0 : xStream = xParentStorage->cloneEncryptedStreamElement(
633 0 : aUri.getDecodedName(),
634 0 : rPassword );
635 : }
636 0 : catch ( packages::NoEncryptionException const & )
637 : {
638 : xStream
639 0 : = xParentStorage->cloneStreamElement( aUri.getDecodedName() );
640 : }
641 : }
642 : else
643 : {
644 : try
645 : {
646 0 : xStream = xParentStorage->openEncryptedStreamElement(
647 0 : aUri.getDecodedName(),
648 : nOpenMode,
649 0 : rPassword );
650 : }
651 0 : catch ( packages::NoEncryptionException const & )
652 : {
653 : xStream
654 0 : = xParentStorage->openStreamElement( aUri.getDecodedName(),
655 0 : nOpenMode );
656 : }
657 : }
658 : }
659 : else
660 : {
661 0 : if ( eMode == READ )
662 : {
663 0 : xStream = xParentStorage->cloneStreamElement( aUri.getDecodedName() );
664 : }
665 : else
666 : {
667 0 : xStream = xParentStorage->openStreamElement( aUri.getDecodedName(),
668 0 : nOpenMode );
669 : }
670 : }
671 :
672 0 : if ( !xStream.is() )
673 : {
674 : throw embed::InvalidStorageException(
675 : rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
676 : "No stream!" ) ),
677 0 : uno::Reference< uno::XInterface >() );
678 : }
679 :
680 0 : return xStream;
681 : }
682 :
683 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
