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