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 <com/sun/star/beans/PropertyValue.hpp>
21 : #include <com/sun/star/embed/ElementModes.hpp>
22 : #include <com/sun/star/embed/XTransactedObject.hpp>
23 : #include <com/sun/star/ucb/NameClash.hpp>
24 : #include <com/sun/star/ucb/UniversalContentBroker.hpp>
25 : #include <com/sun/star/ucb/XProgressHandler.hpp>
26 : #include <com/sun/star/ucb/XContentAccess.hpp>
27 : #include <com/sun/star/ucb/SimpleFileAccess.hpp>
28 :
29 : #include <com/sun/star/ucb/InteractiveIOException.hpp>
30 : #include <com/sun/star/ucb/IOErrorCode.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 : #include <com/sun/star/lang/XUnoTunnel.hpp>
37 : #include <com/sun/star/lang/XComponent.hpp>
38 : #include <com/sun/star/lang/DisposedException.hpp>
39 : #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
40 : #include <com/sun/star/io/IOException.hpp>
41 : #include <com/sun/star/io/XTruncate.hpp>
42 : #include <com/sun/star/io/TempFile.hpp>
43 : #include <com/sun/star/sdbc/XResultSet.hpp>
44 : #include <com/sun/star/sdbc/XRow.hpp>
45 :
46 :
47 : #include <comphelper/processfactory.hxx>
48 : #include <comphelper/storagehelper.hxx>
49 : #include <cppuhelper/typeprovider.hxx>
50 : #include <cppuhelper/exc_hlp.hxx>
51 :
52 : #include <tools/urlobj.hxx>
53 : #include <unotools/ucbhelper.hxx>
54 : #include <unotools/ucbstreamhelper.hxx>
55 : #include <unotools/streamwrap.hxx>
56 : #include <ucbhelper/fileidentifierconverter.hxx>
57 : #include <ucbhelper/content.hxx>
58 :
59 : #include "fsstorage.hxx"
60 : #include "oinputstreamcontainer.hxx"
61 : #include "ostreamcontainer.hxx"
62 :
63 : using namespace ::com::sun::star;
64 :
65 :
66 : // TODO: move to a standard helper
67 0 : bool isLocalFile_Impl( const OUString& aURL )
68 : {
69 0 : OUString aSystemPath;
70 :
71 : try
72 : {
73 0 : aSystemPath = ::ucbhelper::getSystemPathFromFileURL(
74 : ucb::UniversalContentBroker::create(
75 : comphelper::getProcessComponentContext() ),
76 0 : aURL );
77 : }
78 0 : catch ( uno::Exception& )
79 : {
80 : }
81 :
82 0 : return ( !aSystemPath.isEmpty() );
83 : }
84 :
85 :
86 :
87 : struct FSStorage_Impl
88 : {
89 : OUString m_aURL;
90 :
91 : ::ucbhelper::Content* m_pContent;
92 : sal_Int32 m_nMode;
93 :
94 : ::cppu::OInterfaceContainerHelper* m_pListenersContainer; // list of listeners
95 : ::cppu::OTypeCollection* m_pTypeCollection;
96 :
97 : uno::Reference< uno::XComponentContext > m_xContext;
98 :
99 :
100 0 : FSStorage_Impl( const ::ucbhelper::Content& aContent, sal_Int32 nMode, uno::Reference< uno::XComponentContext > xContext )
101 0 : : m_aURL( aContent.getURL() )
102 0 : , m_pContent( new ::ucbhelper::Content( aContent ) )
103 : , m_nMode( nMode )
104 : , m_pListenersContainer( NULL )
105 : , m_pTypeCollection( NULL )
106 0 : , m_xContext( xContext )
107 : {
108 : OSL_ENSURE( !m_aURL.isEmpty(), "The URL must not be empty" );
109 0 : }
110 :
111 : ~FSStorage_Impl();
112 : };
113 :
114 :
115 0 : FSStorage_Impl::~FSStorage_Impl()
116 : {
117 0 : if ( m_pListenersContainer )
118 0 : delete m_pListenersContainer;
119 0 : if ( m_pTypeCollection )
120 0 : delete m_pTypeCollection;
121 0 : if ( m_pContent )
122 0 : delete m_pContent;
123 0 : }
124 :
125 : // FSStorage implementation
126 :
127 0 : FSStorage::FSStorage( const ::ucbhelper::Content& aContent,
128 : sal_Int32 nMode,
129 : uno::Reference< uno::XComponentContext > xContext )
130 0 : : m_pImpl( new FSStorage_Impl( aContent, nMode, xContext ) )
131 : {
132 : // TODO: use properties
133 0 : if ( !xContext.is() )
134 0 : throw uno::RuntimeException();
135 :
136 0 : GetContent();
137 0 : }
138 :
139 0 : FSStorage::~FSStorage()
140 : {
141 : {
142 0 : ::osl::MutexGuard aGuard( m_aMutex );
143 0 : m_refCount++; // to call dispose
144 : try {
145 0 : dispose();
146 : }
147 0 : catch( uno::RuntimeException& )
148 0 : {}
149 : }
150 0 : }
151 :
152 0 : bool FSStorage::MakeFolderNoUI( const OUString& rFolder )
153 : {
154 0 : INetURLObject aURL( rFolder );
155 0 : OUString aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
156 0 : aURL.removeSegment();
157 0 : ::ucbhelper::Content aParent;
158 0 : ::ucbhelper::Content aResultContent;
159 :
160 0 : if ( ::ucbhelper::Content::create( aURL.GetMainURL( INetURLObject::NO_DECODE ),
161 : uno::Reference< ucb::XCommandEnvironment >(),
162 : comphelper::getProcessComponentContext(),
163 0 : aParent ) )
164 0 : return ::utl::UCBContentHelper::MakeFolder( aParent, aTitle, aResultContent, false );
165 :
166 0 : return false;
167 : }
168 :
169 0 : ::ucbhelper::Content* FSStorage::GetContent()
170 : {
171 0 : ::osl::MutexGuard aGuard( m_aMutex );
172 0 : if ( !m_pImpl->m_pContent )
173 : {
174 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
175 :
176 : try
177 : {
178 0 : m_pImpl->m_pContent = new ::ucbhelper::Content( m_pImpl->m_aURL, xDummyEnv, comphelper::getProcessComponentContext() );
179 : }
180 0 : catch( uno::Exception& )
181 : {
182 0 : }
183 : }
184 :
185 0 : return m_pImpl->m_pContent;
186 : }
187 :
188 0 : void FSStorage::CopyStreamToSubStream( const OUString& aSourceURL,
189 : const uno::Reference< embed::XStorage >& xDest,
190 : const OUString& aNewEntryName )
191 : {
192 0 : if ( !xDest.is() )
193 0 : throw uno::RuntimeException();
194 :
195 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
196 0 : ::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv, comphelper::getProcessComponentContext() );
197 0 : uno::Reference< io::XInputStream > xSourceInput = aSourceContent.openStream();
198 :
199 0 : if ( !xSourceInput.is() )
200 0 : throw io::IOException(); // TODO: error handling
201 :
202 0 : uno::Reference< io::XStream > xSubStream = xDest->openStreamElement(
203 : aNewEntryName,
204 0 : embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
205 0 : if ( !xSubStream.is() )
206 0 : throw uno::RuntimeException();
207 :
208 0 : uno::Reference< io::XOutputStream > xDestOutput = xSubStream->getOutputStream();
209 0 : if ( !xDestOutput.is() )
210 0 : throw uno::RuntimeException();
211 :
212 0 : ::comphelper::OStorageHelper::CopyInputToOutput( xSourceInput, xDestOutput );
213 0 : xDestOutput->closeOutput();
214 0 : }
215 :
216 0 : void FSStorage::CopyContentToStorage_Impl( ::ucbhelper::Content* pContent, const uno::Reference< embed::XStorage >& xDest )
217 : {
218 0 : if ( !pContent )
219 0 : throw uno::RuntimeException();
220 :
221 : // get list of contents of the Content
222 : // create cursor for access to children
223 0 : uno::Sequence< OUString > aProps( 2 );
224 0 : OUString* pProps = aProps.getArray();
225 0 : pProps[0] = "TargetURL";
226 0 : pProps[1] = "IsFolder";
227 0 : ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
228 :
229 : try
230 : {
231 0 : uno::Reference< sdbc::XResultSet > xResultSet = pContent->createCursor( aProps, eInclude );
232 0 : uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
233 0 : uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
234 0 : if ( xResultSet.is() )
235 : {
236 : // go through the list: insert files as streams, insert folders as substorages using recursion
237 0 : while ( xResultSet->next() )
238 : {
239 0 : OUString aSourceURL( xRow->getString( 1 ) );
240 0 : bool bIsFolder( xRow->getBoolean(2) );
241 :
242 : // TODO/LATER: not sure whether the entry name must be encoded
243 : OUString aNewEntryName( INetURLObject( aSourceURL ).getName( INetURLObject::LAST_SEGMENT,
244 : true,
245 0 : INetURLObject::NO_DECODE ) );
246 0 : if ( bIsFolder )
247 : {
248 0 : uno::Reference< embed::XStorage > xSubStorage = xDest->openStorageElement( aNewEntryName,
249 0 : embed::ElementModes::READWRITE );
250 0 : if ( !xSubStorage.is() )
251 0 : throw uno::RuntimeException();
252 :
253 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
254 0 : ::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv, comphelper::getProcessComponentContext() );
255 0 : CopyContentToStorage_Impl( &aSourceContent, xSubStorage );
256 : }
257 : else
258 : {
259 0 : CopyStreamToSubStream( aSourceURL, xDest, aNewEntryName );
260 : }
261 0 : }
262 : }
263 :
264 0 : uno::Reference< embed::XTransactedObject > xTransact( xDest, uno::UNO_QUERY );
265 0 : if ( xTransact.is() )
266 0 : xTransact->commit();
267 : }
268 0 : catch( ucb::InteractiveIOException& r )
269 : {
270 0 : if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
271 : OSL_FAIL( "The folder does not exist!\n" );
272 : else
273 0 : throw;
274 0 : }
275 0 : }
276 :
277 : // XInterface
278 :
279 0 : uno::Any SAL_CALL FSStorage::queryInterface( const uno::Type& rType )
280 : throw( uno::RuntimeException, std::exception )
281 : {
282 0 : uno::Any aReturn;
283 0 : aReturn <<= ::cppu::queryInterface
284 : ( rType
285 : , static_cast<lang::XTypeProvider*> ( this )
286 : , static_cast<embed::XStorage*> ( this )
287 : , static_cast<embed::XHierarchicalStorageAccess*> ( this )
288 : , static_cast<container::XNameAccess*> ( this )
289 : , static_cast<container::XElementAccess*> ( this )
290 : , static_cast<lang::XComponent*> ( this )
291 0 : , static_cast<beans::XPropertySet*> ( this ) );
292 :
293 0 : if ( aReturn.hasValue() )
294 0 : return aReturn ;
295 :
296 0 : return OWeakObject::queryInterface( rType );
297 : }
298 :
299 0 : void SAL_CALL FSStorage::acquire() throw()
300 : {
301 0 : OWeakObject::acquire();
302 0 : }
303 :
304 0 : void SAL_CALL FSStorage::release() throw()
305 : {
306 0 : OWeakObject::release();
307 0 : }
308 :
309 : // XTypeProvider
310 :
311 0 : uno::Sequence< uno::Type > SAL_CALL FSStorage::getTypes()
312 : throw( uno::RuntimeException, std::exception )
313 : {
314 0 : if ( m_pImpl->m_pTypeCollection == NULL )
315 : {
316 0 : ::osl::MutexGuard aGuard( m_aMutex );
317 :
318 0 : if ( m_pImpl->m_pTypeCollection == NULL )
319 : {
320 : m_pImpl->m_pTypeCollection = new ::cppu::OTypeCollection
321 : ( ::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
322 : , ::getCppuType( ( const uno::Reference< embed::XStorage >* )NULL )
323 : , ::getCppuType( ( const uno::Reference< embed::XHierarchicalStorageAccess >* )NULL )
324 0 : , ::getCppuType( ( const uno::Reference< beans::XPropertySet >* )NULL ) );
325 0 : }
326 : }
327 :
328 0 : return m_pImpl->m_pTypeCollection->getTypes() ;
329 : }
330 :
331 0 : uno::Sequence< sal_Int8 > SAL_CALL FSStorage::getImplementationId()
332 : throw( uno::RuntimeException, std::exception )
333 : {
334 0 : return css::uno::Sequence<sal_Int8>();
335 : }
336 :
337 : // XStorage
338 :
339 0 : void SAL_CALL FSStorage::copyToStorage( const uno::Reference< embed::XStorage >& xDest )
340 : throw ( embed::InvalidStorageException,
341 : io::IOException,
342 : lang::IllegalArgumentException,
343 : embed::StorageWrappedTargetException,
344 : uno::RuntimeException, std::exception )
345 : {
346 0 : ::osl::MutexGuard aGuard( m_aMutex );
347 :
348 0 : if ( !m_pImpl )
349 0 : throw lang::DisposedException();
350 :
351 0 : if ( !xDest.is() || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject*> ( this ), uno::UNO_QUERY ) )
352 0 : throw lang::IllegalArgumentException(); // TODO:
353 :
354 0 : if ( !GetContent() )
355 0 : throw io::IOException(); // TODO: error handling
356 :
357 : try
358 : {
359 0 : CopyContentToStorage_Impl( GetContent(), xDest );
360 : }
361 0 : catch( embed::InvalidStorageException& )
362 : {
363 0 : throw;
364 : }
365 0 : catch( lang::IllegalArgumentException& )
366 : {
367 0 : throw;
368 : }
369 0 : catch( embed::StorageWrappedTargetException& )
370 : {
371 0 : throw;
372 : }
373 0 : catch( io::IOException& )
374 : {
375 0 : throw;
376 : }
377 0 : catch( uno::RuntimeException& )
378 : {
379 0 : throw;
380 : }
381 0 : catch( uno::Exception& )
382 : {
383 0 : uno::Any aCaught( ::cppu::getCaughtException() );
384 : throw embed::StorageWrappedTargetException("Can't copy raw stream",
385 : uno::Reference< io::XInputStream >(),
386 0 : aCaught );
387 0 : }
388 0 : }
389 :
390 0 : uno::Reference< io::XStream > SAL_CALL FSStorage::openStreamElement(
391 : const OUString& aStreamName, sal_Int32 nOpenMode )
392 : throw ( embed::InvalidStorageException,
393 : lang::IllegalArgumentException,
394 : packages::WrongPasswordException,
395 : io::IOException,
396 : embed::StorageWrappedTargetException,
397 : uno::RuntimeException, std::exception )
398 : {
399 0 : ::osl::MutexGuard aGuard( m_aMutex );
400 :
401 0 : if ( !m_pImpl )
402 0 : throw lang::DisposedException();
403 :
404 0 : if ( !GetContent() )
405 0 : throw io::IOException(); // TODO: error handling
406 :
407 : // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
408 0 : INetURLObject aFileURL( m_pImpl->m_aURL );
409 0 : aFileURL.Append( aStreamName );
410 :
411 0 : if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
412 0 : throw io::IOException();
413 :
414 0 : if ( ( nOpenMode & embed::ElementModes::NOCREATE )
415 0 : && !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
416 0 : throw io::IOException(); // TODO:
417 :
418 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
419 0 : uno::Reference< io::XStream > xResult;
420 : try
421 : {
422 0 : if ( nOpenMode & embed::ElementModes::WRITE )
423 : {
424 0 : if ( isLocalFile_Impl( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
425 : {
426 : uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess(
427 0 : ucb::SimpleFileAccess::create( m_pImpl->m_xContext ) );
428 0 : xResult = xSimpleFileAccess->openFileReadWrite( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) );
429 : }
430 : else
431 : {
432 : // TODO: test whether it really works for http and fwp
433 : SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::NO_DECODE ),
434 0 : STREAM_STD_WRITE );
435 0 : if ( pStream )
436 : {
437 0 : if ( !pStream->GetError() )
438 0 : xResult = uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
439 : else
440 0 : delete pStream;
441 : }
442 : }
443 :
444 0 : if ( !xResult.is() )
445 0 : throw io::IOException();
446 :
447 0 : if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
448 : {
449 0 : uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
450 0 : xTrunc->truncate();
451 : }
452 : }
453 : else
454 : {
455 0 : if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
456 0 : || !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
457 0 : throw io::IOException(); // TODO: access denied
458 :
459 0 : ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
460 0 : uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
461 0 : xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
462 : }
463 : }
464 0 : catch( embed::InvalidStorageException& )
465 : {
466 0 : throw;
467 : }
468 0 : catch( lang::IllegalArgumentException& )
469 : {
470 0 : throw;
471 : }
472 0 : catch( packages::WrongPasswordException& )
473 : {
474 0 : throw;
475 : }
476 0 : catch( embed::StorageWrappedTargetException& )
477 : {
478 0 : throw;
479 : }
480 0 : catch( io::IOException& )
481 : {
482 0 : throw;
483 : }
484 0 : catch( uno::RuntimeException& )
485 : {
486 0 : throw;
487 : }
488 0 : catch( uno::Exception& )
489 : {
490 0 : uno::Any aCaught( ::cppu::getCaughtException() );
491 : throw embed::StorageWrappedTargetException("Can't copy raw stream",
492 : uno::Reference< io::XInputStream >(),
493 0 : aCaught );
494 : }
495 :
496 0 : return xResult;
497 : }
498 :
499 0 : uno::Reference< io::XStream > SAL_CALL FSStorage::openEncryptedStreamElement(
500 : const OUString&, sal_Int32, const OUString& )
501 : throw ( embed::InvalidStorageException,
502 : lang::IllegalArgumentException,
503 : packages::NoEncryptionException,
504 : packages::WrongPasswordException,
505 : io::IOException,
506 : embed::StorageWrappedTargetException,
507 : uno::RuntimeException, std::exception )
508 : {
509 0 : throw packages::NoEncryptionException();
510 : }
511 :
512 0 : uno::Reference< embed::XStorage > SAL_CALL FSStorage::openStorageElement(
513 : const OUString& aStorName, sal_Int32 nStorageMode )
514 : throw ( embed::InvalidStorageException,
515 : lang::IllegalArgumentException,
516 : io::IOException,
517 : embed::StorageWrappedTargetException,
518 : uno::RuntimeException, std::exception )
519 : {
520 0 : ::osl::MutexGuard aGuard( m_aMutex );
521 :
522 0 : if ( !m_pImpl )
523 0 : throw lang::DisposedException();
524 :
525 0 : if ( !GetContent() )
526 0 : throw io::IOException(); // TODO: error handling
527 :
528 0 : if ( ( nStorageMode & embed::ElementModes::WRITE )
529 0 : && !( m_pImpl->m_nMode & embed::ElementModes::WRITE ) )
530 0 : throw io::IOException(); // TODO: error handling
531 :
532 : // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
533 0 : INetURLObject aFolderURL( m_pImpl->m_aURL );
534 0 : aFolderURL.Append( aStorName );
535 :
536 0 : bool bFolderExists = ::utl::UCBContentHelper::IsFolder( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
537 0 : if ( !bFolderExists && ::utl::UCBContentHelper::IsDocument( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
538 0 : throw io::IOException(); // TODO:
539 :
540 0 : if ( ( nStorageMode & embed::ElementModes::NOCREATE ) && !bFolderExists )
541 0 : throw io::IOException(); // TODO:
542 :
543 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
544 0 : uno::Reference< embed::XStorage > xResult;
545 : try
546 : {
547 0 : if ( nStorageMode & embed::ElementModes::WRITE )
548 : {
549 0 : if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) && bFolderExists )
550 : {
551 0 : ::utl::UCBContentHelper::Kill( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
552 : bFolderExists =
553 0 : MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ); // TODO: not atomic :(
554 : }
555 0 : else if ( !bFolderExists )
556 : {
557 : bFolderExists =
558 0 : MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ); // TODO: not atomic :(
559 : }
560 : }
561 0 : else if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) )
562 0 : throw io::IOException(); // TODO: access denied
563 :
564 0 : if ( !bFolderExists )
565 0 : throw io::IOException(); // there is no such folder
566 :
567 0 : ::ucbhelper::Content aResultContent( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
568 0 : xResult = uno::Reference< embed::XStorage >(
569 : static_cast< OWeakObject* >( new FSStorage( aResultContent,
570 : nStorageMode,
571 0 : m_pImpl->m_xContext ) ),
572 0 : uno::UNO_QUERY );
573 : }
574 0 : catch( embed::InvalidStorageException& )
575 : {
576 0 : throw;
577 : }
578 0 : catch( lang::IllegalArgumentException& )
579 : {
580 0 : throw;
581 : }
582 0 : catch( embed::StorageWrappedTargetException& )
583 : {
584 0 : throw;
585 : }
586 0 : catch( io::IOException& )
587 : {
588 0 : throw;
589 : }
590 0 : catch( uno::RuntimeException& )
591 : {
592 0 : throw;
593 : }
594 0 : catch( uno::Exception& )
595 : {
596 0 : uno::Any aCaught( ::cppu::getCaughtException() );
597 : throw embed::StorageWrappedTargetException("Can't copy raw stream",
598 : uno::Reference< io::XInputStream >(),
599 0 : aCaught );
600 : }
601 :
602 0 : return xResult;
603 : }
604 :
605 0 : uno::Reference< io::XStream > SAL_CALL FSStorage::cloneStreamElement( const OUString& aStreamName )
606 : throw ( embed::InvalidStorageException,
607 : lang::IllegalArgumentException,
608 : packages::WrongPasswordException,
609 : io::IOException,
610 : embed::StorageWrappedTargetException,
611 : uno::RuntimeException, std::exception )
612 : {
613 0 : ::osl::MutexGuard aGuard( m_aMutex );
614 :
615 0 : if ( !m_pImpl )
616 0 : throw lang::DisposedException();
617 :
618 0 : if ( !GetContent() )
619 0 : throw io::IOException(); // TODO: error handling
620 :
621 : // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
622 0 : INetURLObject aFileURL( m_pImpl->m_aURL );
623 0 : aFileURL.Append( aStreamName );
624 :
625 0 : uno::Reference < io::XStream > xTempResult;
626 : try
627 : {
628 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
629 0 : ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
630 0 : uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
631 :
632 0 : xTempResult = io::TempFile::create(m_pImpl->m_xContext);
633 0 : uno::Reference < io::XOutputStream > xTempOut = xTempResult->getOutputStream();
634 0 : uno::Reference < io::XInputStream > xTempIn = xTempResult->getInputStream();
635 :
636 0 : if ( !xTempOut.is() || !xTempIn.is() )
637 0 : throw io::IOException();
638 :
639 0 : ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOut );
640 0 : xTempOut->closeOutput();
641 : }
642 0 : catch( embed::InvalidStorageException& )
643 : {
644 0 : throw;
645 : }
646 0 : catch( lang::IllegalArgumentException& )
647 : {
648 0 : throw;
649 : }
650 0 : catch( packages::WrongPasswordException& )
651 : {
652 0 : throw;
653 : }
654 0 : catch( io::IOException& )
655 : {
656 0 : throw;
657 : }
658 0 : catch( embed::StorageWrappedTargetException& )
659 : {
660 0 : throw;
661 : }
662 0 : catch( uno::RuntimeException& )
663 : {
664 0 : throw;
665 : }
666 0 : catch( uno::Exception& )
667 : {
668 0 : uno::Any aCaught( ::cppu::getCaughtException() );
669 : throw embed::StorageWrappedTargetException("Can't copy raw stream",
670 : uno::Reference< io::XInputStream >(),
671 0 : aCaught );
672 : }
673 :
674 0 : return xTempResult;
675 : }
676 :
677 0 : uno::Reference< io::XStream > SAL_CALL FSStorage::cloneEncryptedStreamElement(
678 : const OUString&,
679 : const OUString& )
680 : throw ( embed::InvalidStorageException,
681 : lang::IllegalArgumentException,
682 : packages::NoEncryptionException,
683 : packages::WrongPasswordException,
684 : io::IOException,
685 : embed::StorageWrappedTargetException,
686 : uno::RuntimeException, std::exception )
687 : {
688 0 : throw packages::NoEncryptionException();
689 : }
690 :
691 0 : void SAL_CALL FSStorage::copyLastCommitTo(
692 : const uno::Reference< embed::XStorage >& xTargetStorage )
693 : throw ( embed::InvalidStorageException,
694 : lang::IllegalArgumentException,
695 : io::IOException,
696 : embed::StorageWrappedTargetException,
697 : uno::RuntimeException, std::exception )
698 : {
699 0 : copyToStorage( xTargetStorage );
700 0 : }
701 :
702 0 : void SAL_CALL FSStorage::copyStorageElementLastCommitTo(
703 : const OUString& aStorName,
704 : const uno::Reference< embed::XStorage >& xTargetStorage )
705 : throw ( embed::InvalidStorageException,
706 : lang::IllegalArgumentException,
707 : io::IOException,
708 : embed::StorageWrappedTargetException,
709 : uno::RuntimeException, std::exception )
710 : {
711 0 : ::osl::MutexGuard aGuard( m_aMutex );
712 :
713 0 : if ( !m_pImpl )
714 0 : throw lang::DisposedException();
715 :
716 0 : uno::Reference< embed::XStorage > xSourceStor( openStorageElement( aStorName, embed::ElementModes::READ ),
717 0 : uno::UNO_QUERY_THROW );
718 0 : xSourceStor->copyToStorage( xTargetStorage );
719 0 : }
720 :
721 0 : sal_Bool SAL_CALL FSStorage::isStreamElement( const OUString& aElementName )
722 : throw ( embed::InvalidStorageException,
723 : lang::IllegalArgumentException,
724 : container::NoSuchElementException,
725 : uno::RuntimeException, std::exception )
726 : {
727 0 : ::osl::MutexGuard aGuard( m_aMutex );
728 :
729 0 : if ( !m_pImpl )
730 0 : throw lang::DisposedException();
731 :
732 0 : if ( !GetContent() )
733 0 : throw embed::InvalidStorageException(); // TODO: error handling
734 :
735 0 : INetURLObject aURL( m_pImpl->m_aURL );
736 0 : aURL.Append( aElementName );
737 :
738 0 : return !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
739 : }
740 :
741 0 : sal_Bool SAL_CALL FSStorage::isStorageElement( const OUString& aElementName )
742 : throw ( embed::InvalidStorageException,
743 : lang::IllegalArgumentException,
744 : container::NoSuchElementException,
745 : uno::RuntimeException, std::exception )
746 : {
747 0 : ::osl::MutexGuard aGuard( m_aMutex );
748 :
749 0 : if ( !m_pImpl )
750 0 : throw lang::DisposedException();
751 :
752 0 : if ( !GetContent() )
753 0 : throw embed::InvalidStorageException(); // TODO: error handling
754 :
755 0 : INetURLObject aURL( m_pImpl->m_aURL );
756 0 : aURL.Append( aElementName );
757 :
758 0 : return ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
759 : }
760 :
761 0 : void SAL_CALL FSStorage::removeElement( const OUString& aElementName )
762 : throw ( embed::InvalidStorageException,
763 : lang::IllegalArgumentException,
764 : container::NoSuchElementException,
765 : io::IOException,
766 : embed::StorageWrappedTargetException,
767 : uno::RuntimeException, std::exception )
768 : {
769 0 : ::osl::MutexGuard aGuard( m_aMutex );
770 :
771 0 : if ( !m_pImpl )
772 0 : throw lang::DisposedException();
773 :
774 0 : if ( !GetContent() )
775 0 : throw io::IOException(); // TODO: error handling
776 :
777 0 : INetURLObject aURL( m_pImpl->m_aURL );
778 0 : aURL.Append( aElementName );
779 :
780 0 : if ( !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
781 0 : && !::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
782 0 : throw container::NoSuchElementException(); // TODO:
783 :
784 0 : ::utl::UCBContentHelper::Kill( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
785 0 : }
786 :
787 0 : void SAL_CALL FSStorage::renameElement( const OUString& aElementName, const OUString& aNewName )
788 : throw ( embed::InvalidStorageException,
789 : lang::IllegalArgumentException,
790 : container::NoSuchElementException,
791 : container::ElementExistException,
792 : io::IOException,
793 : embed::StorageWrappedTargetException,
794 : uno::RuntimeException, std::exception )
795 : {
796 0 : ::osl::MutexGuard aGuard( m_aMutex );
797 :
798 0 : if ( !m_pImpl )
799 0 : throw lang::DisposedException();
800 :
801 0 : if ( !GetContent() )
802 0 : throw io::IOException(); // TODO: error handling
803 :
804 0 : INetURLObject aOldURL( m_pImpl->m_aURL );
805 0 : aOldURL.Append( aElementName );
806 :
807 0 : INetURLObject aNewURL( m_pImpl->m_aURL );
808 0 : aNewURL.Append( aNewName );
809 :
810 0 : if ( !::utl::UCBContentHelper::IsFolder( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) )
811 0 : && !::utl::UCBContentHelper::IsDocument( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
812 0 : throw container::NoSuchElementException(); // TODO:
813 :
814 0 : if ( ::utl::UCBContentHelper::IsFolder( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) )
815 0 : || ::utl::UCBContentHelper::IsDocument( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
816 0 : throw container::ElementExistException(); // TODO:
817 :
818 : try
819 : {
820 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
821 0 : ::ucbhelper::Content aSourceContent( aOldURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
822 :
823 0 : if ( !GetContent()->transferContent( aSourceContent,
824 : ::ucbhelper::InsertOperation_MOVE,
825 : aNewName,
826 0 : ucb::NameClash::ERROR ) )
827 0 : throw io::IOException(); // TODO: error handling
828 : }
829 0 : catch( embed::InvalidStorageException& )
830 : {
831 0 : throw;
832 : }
833 0 : catch( lang::IllegalArgumentException& )
834 : {
835 0 : throw;
836 : }
837 0 : catch( container::NoSuchElementException& )
838 : {
839 0 : throw;
840 : }
841 0 : catch( container::ElementExistException& )
842 : {
843 0 : throw;
844 : }
845 0 : catch( io::IOException& )
846 : {
847 0 : throw;
848 : }
849 0 : catch( embed::StorageWrappedTargetException& )
850 : {
851 0 : throw;
852 : }
853 0 : catch( uno::RuntimeException& )
854 : {
855 0 : throw;
856 : }
857 0 : catch( uno::Exception& )
858 : {
859 0 : uno::Any aCaught( ::cppu::getCaughtException() );
860 : throw embed::StorageWrappedTargetException("Can't copy raw stream",
861 : uno::Reference< io::XInputStream >(),
862 0 : aCaught );
863 0 : }
864 0 : }
865 :
866 0 : void SAL_CALL FSStorage::copyElementTo( const OUString& aElementName,
867 : const uno::Reference< embed::XStorage >& xDest,
868 : const OUString& aNewName )
869 : throw ( embed::InvalidStorageException,
870 : lang::IllegalArgumentException,
871 : container::NoSuchElementException,
872 : container::ElementExistException,
873 : io::IOException,
874 : embed::StorageWrappedTargetException,
875 : uno::RuntimeException, std::exception )
876 : {
877 0 : ::osl::MutexGuard aGuard( m_aMutex );
878 :
879 0 : if ( !m_pImpl )
880 0 : throw lang::DisposedException();
881 :
882 0 : if ( !xDest.is() )
883 0 : throw uno::RuntimeException();
884 :
885 0 : if ( !GetContent() )
886 0 : throw io::IOException(); // TODO: error handling
887 :
888 0 : INetURLObject aOwnURL( m_pImpl->m_aURL );
889 0 : aOwnURL.Append( aElementName );
890 :
891 0 : if ( xDest->hasByName( aNewName ) )
892 0 : throw container::ElementExistException(); // TODO:
893 :
894 : try
895 : {
896 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
897 0 : if ( ::utl::UCBContentHelper::IsFolder( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
898 : {
899 0 : ::ucbhelper::Content aSourceContent( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
900 : uno::Reference< embed::XStorage > xDestSubStor(
901 0 : xDest->openStorageElement( aNewName, embed::ElementModes::READWRITE ),
902 0 : uno::UNO_QUERY_THROW );
903 :
904 0 : CopyContentToStorage_Impl( &aSourceContent, xDestSubStor );
905 : }
906 0 : else if ( ::utl::UCBContentHelper::IsDocument( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
907 : {
908 0 : CopyStreamToSubStream( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDest, aNewName );
909 : }
910 : else
911 0 : throw container::NoSuchElementException(); // TODO:
912 : }
913 0 : catch( embed::InvalidStorageException& )
914 : {
915 0 : throw;
916 : }
917 0 : catch( lang::IllegalArgumentException& )
918 : {
919 0 : throw;
920 : }
921 0 : catch( container::NoSuchElementException& )
922 : {
923 0 : throw;
924 : }
925 0 : catch( container::ElementExistException& )
926 : {
927 0 : throw;
928 : }
929 0 : catch( embed::StorageWrappedTargetException& )
930 : {
931 0 : throw;
932 : }
933 0 : catch( io::IOException& )
934 : {
935 0 : throw;
936 : }
937 0 : catch( uno::RuntimeException& )
938 : {
939 0 : throw;
940 : }
941 0 : catch( uno::Exception& )
942 : {
943 0 : uno::Any aCaught( ::cppu::getCaughtException() );
944 : throw embed::StorageWrappedTargetException("Can't copy raw stream",
945 : uno::Reference< io::XInputStream >(),
946 0 : aCaught );
947 0 : }
948 0 : }
949 :
950 0 : void SAL_CALL FSStorage::moveElementTo( const OUString& aElementName,
951 : const uno::Reference< embed::XStorage >& xDest,
952 : const OUString& aNewName )
953 : throw ( embed::InvalidStorageException,
954 : lang::IllegalArgumentException,
955 : container::NoSuchElementException,
956 : container::ElementExistException,
957 : io::IOException,
958 : embed::StorageWrappedTargetException,
959 : uno::RuntimeException, std::exception )
960 : {
961 0 : ::osl::MutexGuard aGuard( m_aMutex );
962 0 : copyElementTo( aElementName, xDest, aNewName );
963 :
964 0 : INetURLObject aOwnURL( m_pImpl->m_aURL );
965 0 : aOwnURL.Append( aElementName );
966 0 : if ( !::utl::UCBContentHelper::Kill( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
967 0 : throw io::IOException(); // TODO: error handling
968 0 : }
969 :
970 : // XNameAccess
971 :
972 0 : uno::Any SAL_CALL FSStorage::getByName( const OUString& aName )
973 : throw ( container::NoSuchElementException,
974 : lang::WrappedTargetException,
975 : uno::RuntimeException, std::exception )
976 : {
977 0 : ::osl::MutexGuard aGuard( m_aMutex );
978 :
979 0 : if ( !m_pImpl )
980 0 : throw lang::DisposedException();
981 :
982 0 : if ( !GetContent() )
983 0 : throw io::IOException(); // TODO: error handling
984 :
985 0 : if ( aName.isEmpty() )
986 0 : throw lang::IllegalArgumentException();
987 :
988 0 : INetURLObject aURL( m_pImpl->m_aURL );
989 0 : aURL.Append( aName );
990 :
991 0 : uno::Any aResult;
992 : try
993 : {
994 0 : if ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
995 : {
996 0 : aResult <<= openStorageElement( aName, embed::ElementModes::READ );
997 : }
998 0 : else if ( ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
999 : {
1000 0 : aResult <<= openStreamElement( aName, embed::ElementModes::READ );
1001 : }
1002 : else
1003 0 : throw container::NoSuchElementException(); // TODO:
1004 : }
1005 0 : catch( container::NoSuchElementException& )
1006 : {
1007 0 : throw;
1008 : }
1009 0 : catch( lang::WrappedTargetException& )
1010 : {
1011 0 : throw;
1012 : }
1013 0 : catch( uno::RuntimeException& )
1014 : {
1015 0 : throw;
1016 : }
1017 0 : catch ( uno::Exception& )
1018 : {
1019 0 : uno::Any aCaught( ::cppu::getCaughtException() );
1020 : throw lang::WrappedTargetException( OUString("Can not open element!\n"),
1021 : uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ),
1022 : uno::UNO_QUERY ),
1023 0 : aCaught );
1024 : }
1025 :
1026 0 : return aResult;
1027 : }
1028 :
1029 :
1030 0 : uno::Sequence< OUString > SAL_CALL FSStorage::getElementNames()
1031 : throw ( uno::RuntimeException, std::exception )
1032 : {
1033 0 : ::osl::MutexGuard aGuard( m_aMutex );
1034 :
1035 0 : if ( !m_pImpl )
1036 0 : throw lang::DisposedException();
1037 :
1038 0 : if ( !GetContent() )
1039 0 : throw io::IOException(); // TODO: error handling
1040 :
1041 0 : uno::Sequence< OUString > aProps( 1 );
1042 0 : aProps[0] = "Title";
1043 0 : ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
1044 :
1045 0 : uno::Sequence< OUString > aResult;
1046 0 : sal_Int32 nSize = 0;
1047 :
1048 : try
1049 : {
1050 0 : uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
1051 0 : uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
1052 0 : uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
1053 0 : if ( xResultSet.is() )
1054 : {
1055 : // go through the list
1056 0 : while ( xResultSet->next() )
1057 : {
1058 0 : OUString aName( xRow->getString( 1 ) );
1059 0 : aResult.realloc( ++nSize );
1060 0 : aResult[nSize-1] = aName;
1061 0 : }
1062 0 : }
1063 : }
1064 0 : catch( const ucb::InteractiveIOException& r )
1065 : {
1066 0 : if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
1067 : OSL_FAIL( "The folder does not exist!\n" );
1068 : else
1069 : {
1070 0 : uno::Any aCaught( ::cppu::getCaughtException() );
1071 : throw lang::WrappedTargetRuntimeException( OUString("Can not open storage!\n"),
1072 : uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ),
1073 : uno::UNO_QUERY ),
1074 0 : aCaught );
1075 : }
1076 : }
1077 0 : catch( uno::RuntimeException& )
1078 : {
1079 0 : throw;
1080 : }
1081 0 : catch ( uno::Exception& )
1082 : {
1083 0 : uno::Any aCaught( ::cppu::getCaughtException() );
1084 : throw lang::WrappedTargetRuntimeException( OUString("Can not open storage!\n"),
1085 : uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ),
1086 : uno::UNO_QUERY ),
1087 0 : aCaught );
1088 : }
1089 :
1090 0 : return aResult;
1091 : }
1092 :
1093 :
1094 0 : sal_Bool SAL_CALL FSStorage::hasByName( const OUString& aName )
1095 : throw ( uno::RuntimeException, std::exception )
1096 : {
1097 0 : ::osl::MutexGuard aGuard( m_aMutex );
1098 :
1099 0 : if ( !m_pImpl )
1100 0 : throw lang::DisposedException();
1101 :
1102 : try
1103 : {
1104 0 : if ( !GetContent() )
1105 0 : throw io::IOException(); // TODO: error handling
1106 :
1107 0 : if ( aName.isEmpty() )
1108 0 : throw lang::IllegalArgumentException();
1109 : }
1110 0 : catch( uno::RuntimeException& )
1111 : {
1112 0 : throw;
1113 : }
1114 0 : catch ( uno::Exception& )
1115 : {
1116 0 : uno::Any aCaught( ::cppu::getCaughtException() );
1117 : throw lang::WrappedTargetRuntimeException( OUString("Can not open storage!\n"),
1118 : uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ),
1119 : uno::UNO_QUERY ),
1120 0 : aCaught );
1121 : }
1122 :
1123 0 : INetURLObject aURL( m_pImpl->m_aURL );
1124 0 : aURL.Append( aName );
1125 :
1126 0 : return ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
1127 0 : || ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) );
1128 : }
1129 :
1130 0 : uno::Type SAL_CALL FSStorage::getElementType()
1131 : throw ( uno::RuntimeException, std::exception )
1132 : {
1133 0 : ::osl::MutexGuard aGuard( m_aMutex );
1134 :
1135 0 : if ( !m_pImpl )
1136 0 : throw lang::DisposedException();
1137 :
1138 : // it is a multitype container
1139 0 : return uno::Type();
1140 : }
1141 :
1142 0 : sal_Bool SAL_CALL FSStorage::hasElements()
1143 : throw ( uno::RuntimeException, std::exception )
1144 : {
1145 0 : ::osl::MutexGuard aGuard( m_aMutex );
1146 :
1147 0 : if ( !m_pImpl )
1148 0 : throw lang::DisposedException();
1149 :
1150 0 : if ( !GetContent() )
1151 0 : throw io::IOException(); // TODO: error handling
1152 :
1153 0 : uno::Sequence< OUString > aProps( 1 );
1154 0 : aProps[0] = "TargetURL";
1155 0 : ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
1156 :
1157 : try
1158 : {
1159 0 : uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
1160 0 : return ( xResultSet.is() && xResultSet->next() );
1161 : }
1162 0 : catch( uno::Exception& )
1163 : {
1164 0 : throw uno::RuntimeException();
1165 0 : }
1166 : }
1167 :
1168 :
1169 : // XDisposable
1170 :
1171 0 : void SAL_CALL FSStorage::dispose()
1172 : throw ( uno::RuntimeException, std::exception )
1173 : {
1174 0 : ::osl::MutexGuard aGuard( m_aMutex );
1175 :
1176 0 : if ( !m_pImpl )
1177 0 : throw lang::DisposedException();
1178 :
1179 0 : if ( m_pImpl->m_pListenersContainer )
1180 : {
1181 0 : lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
1182 0 : m_pImpl->m_pListenersContainer->disposeAndClear( aSource );
1183 : }
1184 :
1185 0 : delete m_pImpl;
1186 0 : m_pImpl = NULL;
1187 0 : }
1188 :
1189 0 : void SAL_CALL FSStorage::addEventListener(
1190 : const uno::Reference< lang::XEventListener >& xListener )
1191 : throw ( uno::RuntimeException, std::exception )
1192 : {
1193 0 : ::osl::MutexGuard aGuard( m_aMutex );
1194 :
1195 0 : if ( !m_pImpl )
1196 0 : throw lang::DisposedException();
1197 :
1198 0 : if ( !m_pImpl->m_pListenersContainer )
1199 0 : m_pImpl->m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );
1200 :
1201 0 : m_pImpl->m_pListenersContainer->addInterface( xListener );
1202 0 : }
1203 :
1204 0 : void SAL_CALL FSStorage::removeEventListener(
1205 : const uno::Reference< lang::XEventListener >& xListener )
1206 : throw ( uno::RuntimeException, std::exception )
1207 : {
1208 0 : ::osl::MutexGuard aGuard( m_aMutex );
1209 :
1210 0 : if ( !m_pImpl )
1211 0 : throw lang::DisposedException();
1212 :
1213 0 : if ( m_pImpl->m_pListenersContainer )
1214 0 : m_pImpl->m_pListenersContainer->removeInterface( xListener );
1215 0 : }
1216 :
1217 : // XPropertySet
1218 :
1219 0 : uno::Reference< beans::XPropertySetInfo > SAL_CALL FSStorage::getPropertySetInfo()
1220 : throw ( uno::RuntimeException, std::exception )
1221 : {
1222 0 : ::osl::MutexGuard aGuard( m_aMutex );
1223 :
1224 0 : if ( !m_pImpl )
1225 0 : throw lang::DisposedException();
1226 :
1227 : //TODO:
1228 0 : return uno::Reference< beans::XPropertySetInfo >();
1229 : }
1230 :
1231 :
1232 0 : void SAL_CALL FSStorage::setPropertyValue( const OUString& aPropertyName, const uno::Any& )
1233 : throw ( beans::UnknownPropertyException,
1234 : beans::PropertyVetoException,
1235 : lang::IllegalArgumentException,
1236 : lang::WrappedTargetException,
1237 : uno::RuntimeException, std::exception )
1238 : {
1239 0 : ::osl::MutexGuard aGuard( m_aMutex );
1240 :
1241 0 : if ( !m_pImpl )
1242 0 : throw lang::DisposedException();
1243 :
1244 0 : if ( aPropertyName == "URL" || aPropertyName == "OpenMode" )
1245 0 : throw beans::PropertyVetoException(); // TODO
1246 : else
1247 0 : throw beans::UnknownPropertyException(); // TODO
1248 : }
1249 :
1250 :
1251 0 : uno::Any SAL_CALL FSStorage::getPropertyValue( const OUString& aPropertyName )
1252 : throw ( beans::UnknownPropertyException,
1253 : lang::WrappedTargetException,
1254 : uno::RuntimeException, std::exception )
1255 : {
1256 0 : ::osl::MutexGuard aGuard( m_aMutex );
1257 :
1258 0 : if ( !m_pImpl )
1259 0 : throw lang::DisposedException();
1260 :
1261 0 : if ( aPropertyName == "URL" )
1262 0 : return uno::makeAny( m_pImpl->m_aURL );
1263 0 : else if ( aPropertyName == "OpenMode" )
1264 0 : return uno::makeAny( m_pImpl->m_nMode );
1265 :
1266 0 : throw beans::UnknownPropertyException(); // TODO
1267 : }
1268 :
1269 :
1270 0 : void SAL_CALL FSStorage::addPropertyChangeListener(
1271 : const OUString& /*aPropertyName*/,
1272 : const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
1273 : throw ( beans::UnknownPropertyException,
1274 : lang::WrappedTargetException,
1275 : uno::RuntimeException, std::exception )
1276 : {
1277 0 : ::osl::MutexGuard aGuard( m_aMutex );
1278 :
1279 0 : if ( !m_pImpl )
1280 0 : throw lang::DisposedException();
1281 :
1282 : //TODO:
1283 0 : }
1284 :
1285 :
1286 0 : void SAL_CALL FSStorage::removePropertyChangeListener(
1287 : const OUString& /*aPropertyName*/,
1288 : const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
1289 : throw ( beans::UnknownPropertyException,
1290 : lang::WrappedTargetException,
1291 : uno::RuntimeException, std::exception )
1292 : {
1293 0 : ::osl::MutexGuard aGuard( m_aMutex );
1294 :
1295 0 : if ( !m_pImpl )
1296 0 : throw lang::DisposedException();
1297 :
1298 : //TODO:
1299 0 : }
1300 :
1301 :
1302 0 : void SAL_CALL FSStorage::addVetoableChangeListener(
1303 : const OUString& /*PropertyName*/,
1304 : const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
1305 : throw ( beans::UnknownPropertyException,
1306 : lang::WrappedTargetException,
1307 : uno::RuntimeException, std::exception )
1308 : {
1309 0 : ::osl::MutexGuard aGuard( m_aMutex );
1310 :
1311 0 : if ( !m_pImpl )
1312 0 : throw lang::DisposedException();
1313 :
1314 : //TODO:
1315 0 : }
1316 :
1317 :
1318 0 : void SAL_CALL FSStorage::removeVetoableChangeListener(
1319 : const OUString& /*PropertyName*/,
1320 : const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
1321 : throw ( beans::UnknownPropertyException,
1322 : lang::WrappedTargetException,
1323 : uno::RuntimeException, std::exception )
1324 : {
1325 0 : ::osl::MutexGuard aGuard( m_aMutex );
1326 :
1327 0 : if ( !m_pImpl )
1328 0 : throw lang::DisposedException();
1329 :
1330 : //TODO:
1331 0 : }
1332 :
1333 : // XHierarchicalStorageAccess
1334 0 : uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openStreamElementByHierarchicalName( const OUString& sStreamPath, ::sal_Int32 nOpenMode )
1335 : throw ( embed::InvalidStorageException,
1336 : lang::IllegalArgumentException,
1337 : packages::WrongPasswordException,
1338 : io::IOException,
1339 : embed::StorageWrappedTargetException,
1340 : uno::RuntimeException, std::exception )
1341 : {
1342 0 : ::osl::MutexGuard aGuard( m_aMutex );
1343 :
1344 0 : if ( !m_pImpl )
1345 0 : throw lang::DisposedException();
1346 :
1347 0 : if ( sStreamPath.toChar() == '/' )
1348 0 : throw lang::IllegalArgumentException();
1349 :
1350 0 : if ( !GetContent() )
1351 0 : throw io::IOException(); // TODO: error handling
1352 :
1353 0 : INetURLObject aBaseURL( m_pImpl->m_aURL );
1354 0 : if ( !aBaseURL.setFinalSlash() )
1355 0 : throw uno::RuntimeException();
1356 :
1357 : OUString aFileURL = INetURLObject::GetAbsURL(
1358 : aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
1359 0 : sStreamPath );
1360 :
1361 0 : if ( ::utl::UCBContentHelper::IsFolder( aFileURL ) )
1362 0 : throw io::IOException();
1363 :
1364 0 : if ( ( nOpenMode & embed::ElementModes::NOCREATE )
1365 0 : && !::utl::UCBContentHelper::IsDocument( aFileURL ) )
1366 0 : throw io::IOException(); // TODO:
1367 :
1368 0 : uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
1369 0 : uno::Reference< io::XStream > xResult;
1370 : try
1371 : {
1372 0 : if ( nOpenMode & embed::ElementModes::WRITE )
1373 : {
1374 0 : if ( isLocalFile_Impl( aFileURL ) )
1375 : {
1376 : uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess(
1377 0 : ucb::SimpleFileAccess::create( m_pImpl->m_xContext ) );
1378 : uno::Reference< io::XStream > xStream =
1379 0 : xSimpleFileAccess->openFileReadWrite( aFileURL );
1380 :
1381 0 : xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
1382 : }
1383 : else
1384 : {
1385 : // TODO: test whether it really works for http and fwp
1386 : SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL,
1387 0 : STREAM_STD_WRITE );
1388 0 : if ( pStream )
1389 : {
1390 0 : if ( !pStream->GetError() )
1391 : {
1392 : uno::Reference< io::XStream > xStream =
1393 0 : uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
1394 0 : xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
1395 : }
1396 : else
1397 0 : delete pStream;
1398 : }
1399 : }
1400 :
1401 0 : if ( !xResult.is() )
1402 0 : throw io::IOException();
1403 :
1404 0 : if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
1405 : {
1406 0 : uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
1407 0 : xTrunc->truncate();
1408 : }
1409 : }
1410 : else
1411 : {
1412 0 : if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
1413 0 : || !::utl::UCBContentHelper::IsDocument( aFileURL ) )
1414 0 : throw io::IOException(); // TODO: access denied
1415 :
1416 0 : ::ucbhelper::Content aResultContent( aFileURL, xDummyEnv, comphelper::getProcessComponentContext() );
1417 0 : uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
1418 0 : xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
1419 : }
1420 : }
1421 0 : catch( embed::InvalidStorageException& )
1422 : {
1423 0 : throw;
1424 : }
1425 0 : catch( lang::IllegalArgumentException& )
1426 : {
1427 0 : throw;
1428 : }
1429 0 : catch( packages::WrongPasswordException& )
1430 : {
1431 0 : throw;
1432 : }
1433 0 : catch( embed::StorageWrappedTargetException& )
1434 : {
1435 0 : throw;
1436 : }
1437 0 : catch( io::IOException& )
1438 : {
1439 0 : throw;
1440 : }
1441 0 : catch( uno::RuntimeException& )
1442 : {
1443 0 : throw;
1444 : }
1445 0 : catch( uno::Exception& )
1446 : {
1447 0 : uno::Any aCaught( ::cppu::getCaughtException() );
1448 : throw embed::StorageWrappedTargetException("Can't copy raw stream",
1449 : uno::Reference< io::XInputStream >(),
1450 0 : aCaught );
1451 : }
1452 :
1453 0 : return uno::Reference< embed::XExtendedStorageStream >( xResult, uno::UNO_QUERY_THROW );
1454 : }
1455 :
1456 0 : uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openEncryptedStreamElementByHierarchicalName( const OUString& /*sStreamName*/, ::sal_Int32 /*nOpenMode*/, const OUString& /*sPassword*/ )
1457 : throw ( embed::InvalidStorageException,
1458 : lang::IllegalArgumentException,
1459 : packages::NoEncryptionException,
1460 : packages::WrongPasswordException,
1461 : io::IOException,
1462 : embed::StorageWrappedTargetException,
1463 : uno::RuntimeException, std::exception )
1464 : {
1465 0 : throw packages::NoEncryptionException();
1466 : }
1467 :
1468 0 : void SAL_CALL FSStorage::removeStreamElementByHierarchicalName( const OUString& sStreamPath )
1469 : throw ( embed::InvalidStorageException,
1470 : lang::IllegalArgumentException,
1471 : container::NoSuchElementException,
1472 : io::IOException,
1473 : embed::StorageWrappedTargetException,
1474 : uno::RuntimeException, std::exception )
1475 : {
1476 0 : ::osl::MutexGuard aGuard( m_aMutex );
1477 :
1478 0 : if ( !m_pImpl )
1479 0 : throw lang::DisposedException();
1480 :
1481 0 : if ( !GetContent() )
1482 0 : throw io::IOException(); // TODO: error handling
1483 :
1484 : // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
1485 0 : INetURLObject aBaseURL( m_pImpl->m_aURL );
1486 0 : if ( !aBaseURL.setFinalSlash() )
1487 0 : throw uno::RuntimeException();
1488 :
1489 : OUString aFileURL = INetURLObject::GetAbsURL(
1490 : aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
1491 0 : sStreamPath );
1492 :
1493 0 : if ( !::utl::UCBContentHelper::IsDocument( aFileURL ) )
1494 : {
1495 0 : if ( ::utl::UCBContentHelper::IsFolder( aFileURL ) )
1496 0 : throw lang::IllegalArgumentException();
1497 : else
1498 0 : throw container::NoSuchElementException(); // TODO:
1499 : }
1500 :
1501 0 : if ( !::utl::UCBContentHelper::Kill( aFileURL ) )
1502 0 : throw io::IOException(); // TODO: error handling
1503 0 : }
1504 :
1505 :
1506 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
