sot/source/sdstor/storage.cxx

   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 <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <com/sun/star/embed/XStorage.hpp>
  24 #include <com/sun/star/embed/ElementModes.hpp>
  25 #include <com/sun/star/beans/XPropertySet.hpp>
  26
  27 #include <osl/file.hxx>
  28 #include <sot/stg.hxx>
  29 #include <sot/storinfo.hxx>
  30 #include <sot/storage.hxx>
  31 #include <sot/formats.hxx>
  32 #include <sot/exchange.hxx>
  33 #include <unotools/ucbstreamhelper.hxx>
  34 #include <comphelper/diagnose_ex.hxx>
  35 #include <tools/debug.hxx>
  36 #include <tools/urlobj.hxx>
  37 #include <unotools/ucbhelper.hxx>
  38 #include <comphelper/fileformat.h>
  39 #include <com/sun/star/uno/Reference.h>
  40
  41 #include <memory>
  42
  43 using namespace ::com::sun::star;
  44
  45 static SvLockBytesRef MakeLockBytes_Impl( const OUString & rName, StreamMode nMode )
  46 {
  47     SvLockBytesRef xLB;
  48     if( !rName.isEmpty() )
  49     {
  50         SvStream * pFileStm = new SvFileStream( rName, nMode );
  51         xLB = new SvLockBytes( pFileStm, true );
  52     }
  53     else
  54     {
  55         SvStream * pCacheStm = new SvMemoryStream();
  56         xLB = new SvLockBytes( pCacheStm, true );
  57     }
  58     return xLB;
  59 }
  60
  61 SotTempStream::SotTempStream( const OUString & rName, StreamMode nMode )
  62     : SvStream( MakeLockBytes_Impl( rName, nMode ).get() )
  63 {
  64     if( nMode & StreamMode::WRITE )
  65         m_isWritable = true;
  66     else
  67         m_isWritable = false;
  68 }
  69
  70 SotTempStream::~SotTempStream()
  71 {
  72     FlushBuffer();
  73 }
  74
  75 void SotTempStream::CopyTo( SotTempStream * pDestStm )
  76 {
  77     FlushBuffer(); // write all data
  78
  79     sal_uInt64 nPos = Tell();    // save position
  80     Seek( 0 );
  81     pDestStm->SetSize( 0 ); // empty target stream
  82
  83     constexpr int BUFSIZE = 64 * 1024;
  84     std::unique_ptr<sal_uInt8[]> pMem(new sal_uInt8[ BUFSIZE ]);
  85     sal_Int32  nRead;
  86     while (0 != (nRead = ReadBytes(pMem.get(), BUFSIZE)))
  87     {
  88         if (nRead != static_cast<sal_Int32>(pDestStm->WriteBytes(pMem.get(), nRead)))
  89         {
  90             SetError( SVSTREAM_GENERALERROR );
  91             break;
  92         }
  93     }
  94     pMem.reset();
  95
  96     // set position
  97     pDestStm->Seek( nPos );
  98     Seek( nPos );
  99 }
 100
 101 SotStorageStream::SotStorageStream( BaseStorageStream * pStm )
 102     : pOwnStm(pStm)
 103 {
 104     assert( pStm );
 105     if( StreamMode::WRITE & pStm->GetMode() )
 106         m_isWritable = true;
 107     else
 108         m_isWritable = false;
 109
 110     SetError( pStm->GetError() );
 111     pStm->ResetError();
 112 }
 113
 114 SotStorageStream::~SotStorageStream()
 115 {
 116     Flush();
 117     delete pOwnStm;
 118 }
 119
 120 void SotStorageStream::ResetError()
 121 {
 122     SvStream::ResetError();
 123     pOwnStm->ResetError();
 124 }
 125
 126 std::size_t SotStorageStream::GetData(void* pData, std::size_t const nSize)
 127 {
 128     std::size_t nRet = pOwnStm->Read( pData, nSize );
 129     SetError( pOwnStm->GetError() );
 130     return nRet;
 131 }
 132
 133 std::size_t SotStorageStream::PutData(const void* pData, std::size_t const nSize)
 134 {
 135     std::size_t nRet = pOwnStm->Write( pData, nSize );
 136     SetError( pOwnStm->GetError() );
 137     return nRet;
 138 }
 139
 140 sal_uInt64 SotStorageStream::SeekPos(sal_uInt64 nPos)
 141 {
 142     sal_uInt64 nRet = pOwnStm->Seek( nPos );
 143     SetError( pOwnStm->GetError() );
 144     return nRet;
 145 }
 146
 147 void SotStorageStream::FlushData()
 148 {
 149     pOwnStm->Flush();
 150     SetError( pOwnStm->GetError() );
 151 }
 152
 153 void SotStorageStream::SetSize(sal_uInt64 const nNewSize)
 154 {
 155     sal_uInt64 const nPos = Tell();
 156     pOwnStm->SetSize( nNewSize );
 157     SetError( pOwnStm->GetError() );
 158
 159     if( nNewSize < nPos )
 160         // jump to the end
 161         Seek( nNewSize );
 162 }
 163
 164 sal_uInt32 SotStorageStream::GetSize() const
 165 {
 166     sal_uInt64 nSize = const_cast<SotStorageStream*>(this)->TellEnd();
 167     return nSize;
 168 }
 169
 170 sal_uInt64 SotStorageStream::TellEnd()
 171 {
 172     // Need to flush the buffer so we materialise the stream and return the correct answer
 173     // otherwise we return a 0 value from StgEntry::GetSize
 174     FlushBuffer();
 175
 176     return pOwnStm->GetSize();
 177 }
 178
 179 void SotStorageStream::Commit()
 180 {
 181     pOwnStm->Flush();
 182     if( pOwnStm->GetError() == ERRCODE_NONE )
 183         pOwnStm->Commit();
 184     SetError( pOwnStm->GetError() );
 185 }
 186
 187 bool SotStorageStream::SetProperty( const OUString& rName, const css::uno::Any& rValue )
 188 {
 189     UCBStorageStream* pStg =  dynamic_cast<UCBStorageStream*>( pOwnStm );
 190     if ( pStg )
 191     {
 192         return pStg->SetProperty( rName, rValue );
 193     }
 194     else
 195     {
 196         OSL_FAIL("Not implemented!");
 197         return false;
 198     }
 199 }
 200
 201 /**
 202  * SotStorage::SotStorage()
 203  *
 204  * A I... object must be passed to SvObject, because otherwise itself will
 205  * create and define an IUnknown, so that all other I... objects would be
 206  * destroyed with delete (Owner() == true).
 207  * But IStorage objects are only used and not implemented by ourselves,
 208  * therefore we pretend the IStorage object was passed from the outside
 209  * and it will be freed with Release().
 210  * The CreateStorage methods are needed to create an IStorage object before the
 211  * call of SvObject (Own, !Own automatic).
 212  * If CreateStorage has created an object, then the RefCounter was already
 213  * incremented.
 214  * The transfer is done in pStorageCTor and the variable is NULL, if it didn't
 215  * work.
 216  */
 217 #define INIT_SotStorage()                     \
 218     : m_pOwnStg( nullptr )                       \
 219     , m_pStorStm( nullptr )                      \
 220     , m_nError( ERRCODE_NONE )                 \
 221     , m_bIsRoot( false )                      \
 222     , m_bDelStm( false )                      \
 223     , m_nVersion( SOFFICE_FILEFORMAT_CURRENT )
 224
 225 #define ERASEMASK  ( StreamMode::TRUNC | StreamMode::WRITE | StreamMode::SHARE_DENYALL )
 226
 227 SotStorage::SotStorage( const OUString & rName, StreamMode nMode )
 228     INIT_SotStorage()
 229 {
 230     m_aName = rName; // save name
 231     CreateStorage( true, nMode );
 232     if ( IsOLEStorage() )
 233         m_nVersion = SOFFICE_FILEFORMAT_50;
 234 }
 235
 236 void SotStorage::CreateStorage( bool bForceUCBStorage, StreamMode nMode )
 237 {
 238     DBG_ASSERT( !m_pStorStm && !m_pOwnStg, "Use only in ctor!" );
 239     if( !m_aName.isEmpty() )
 240     {
 241         // named storage
 242         if( ( nMode & ERASEMASK ) == ERASEMASK )
 243             ::utl::UCBContentHelper::Kill( m_aName );
 244
 245         INetURLObject aObj( m_aName );
 246         if ( aObj.GetProtocol() == INetProtocol::NotValid )
 247         {
 248             OUString aURL;
 249             osl::FileBase::getFileURLFromSystemPath( m_aName, aURL );
 250             aObj.SetURL( aURL );
 251             m_aName = aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
 252         }
 253
 254         // check the stream
 255         m_pStorStm = ::utl::UcbStreamHelper::CreateStream( m_aName, nMode ).release();
 256         if ( m_pStorStm && m_pStorStm->GetError() )
 257         {
 258             delete m_pStorStm;
 259             m_pStorStm = nullptr;
 260         }
 261
 262         if ( m_pStorStm )
 263         {
 264             // try as UCBStorage, next try as OLEStorage
 265             bool bIsUCBStorage = UCBStorage::IsStorageFile( m_pStorStm );
 266             if ( !bIsUCBStorage && bForceUCBStorage )
 267                 // if UCBStorage has priority, it should not be used only if it is really an OLEStorage
 268                 bIsUCBStorage = !Storage::IsStorageFile( m_pStorStm );
 269
 270             if ( bIsUCBStorage )
 271             {
 272                 // UCBStorage always works directly on the UCB content, so discard the stream first
 273                 delete m_pStorStm;
 274                 m_pStorStm = nullptr;
 275                 m_pOwnStg = new UCBStorage( m_aName, nMode, true, true/*bIsRoot*/ );
 276             }
 277             else
 278             {
 279                 // OLEStorage can be opened with a stream
 280                 m_pOwnStg = new Storage( *m_pStorStm, true );
 281                 m_bDelStm = true;
 282             }
 283         }
 284         else if ( bForceUCBStorage )
 285         {
 286             m_pOwnStg = new UCBStorage( m_aName, nMode, true, true/*bIsRoot*/ );
 287             SetError( ERRCODE_IO_NOTSUPPORTED );
 288         }
 289         else
 290         {
 291             m_pOwnStg = new Storage( m_aName, nMode, true );
 292             SetError( ERRCODE_IO_NOTSUPPORTED );
 293         }
 294     }
 295     else
 296     {
 297         // temporary storage
 298         if ( bForceUCBStorage )
 299             m_pOwnStg = new UCBStorage( m_aName, nMode, true, true/*bIsRoot*/ );
 300         else
 301             m_pOwnStg = new Storage( m_aName, nMode, true );
 302         m_aName = m_pOwnStg->GetName();
 303     }
 304
 305     SetError( m_pOwnStg->GetError() );
 306
 307     SignAsRoot( m_pOwnStg->IsRoot() );
 308 }
 309
 310 SotStorage::SotStorage( bool bUCBStorage, const OUString & rName, StreamMode nMode )
 311     INIT_SotStorage()
 312 {
 313     m_aName = rName;
 314     CreateStorage( bUCBStorage, nMode );
 315     if ( IsOLEStorage() )
 316         m_nVersion = SOFFICE_FILEFORMAT_50;
 317 }
 318
 319 SotStorage::SotStorage( BaseStorage * pStor )
 320     INIT_SotStorage()
 321 {
 322     if ( pStor )
 323     {
 324         m_aName = pStor->GetName(); // save name
 325         SignAsRoot( pStor->IsRoot() );
 326         SetError( pStor->GetError() );
 327     }
 328
 329     m_pOwnStg = pStor;
 330     const ErrCode nErr = m_pOwnStg ? m_pOwnStg->GetError() : SVSTREAM_CANNOT_MAKE;
 331     SetError( nErr );
 332     if ( IsOLEStorage() )
 333         m_nVersion = SOFFICE_FILEFORMAT_50;
 334 }
 335
 336 SotStorage::SotStorage( bool bUCBStorage, SvStream & rStm )
 337     INIT_SotStorage()
 338 {
 339     SetError( rStm.GetError() );
 340
 341     // try as UCBStorage, next try as OLEStorage
 342     if ( UCBStorage::IsStorageFile( &rStm ) || bUCBStorage )
 343         m_pOwnStg = new UCBStorage( rStm, false );
 344     else
 345         m_pOwnStg = new Storage( rStm, false );
 346
 347     SetError( m_pOwnStg->GetError() );
 348
 349     if ( IsOLEStorage() )
 350         m_nVersion = SOFFICE_FILEFORMAT_50;
 351
 352     SignAsRoot( m_pOwnStg->IsRoot() );
 353 }
 354
 355 SotStorage::SotStorage( SvStream & rStm )
 356     INIT_SotStorage()
 357 {
 358     SetError( rStm.GetError() );
 359
 360     // try as UCBStorage, next try as OLEStorage
 361     if ( UCBStorage::IsStorageFile( &rStm ) )
 362         m_pOwnStg = new UCBStorage( rStm, false );
 363     else
 364         m_pOwnStg = new Storage( rStm, false );
 365
 366     SetError( m_pOwnStg->GetError() );
 367
 368     if ( IsOLEStorage() )
 369         m_nVersion = SOFFICE_FILEFORMAT_50;
 370
 371     SignAsRoot( m_pOwnStg->IsRoot() );
 372 }
 373
 374 SotStorage::SotStorage( SvStream * pStm, bool bDelete )
 375     INIT_SotStorage()
 376 {
 377     SetError( pStm->GetError() );
 378
 379     // try as UCBStorage, next try as OLEStorage
 380     if ( UCBStorage::IsStorageFile( pStm ) )
 381         m_pOwnStg = new UCBStorage( *pStm, false );
 382     else
 383         m_pOwnStg = new Storage( *pStm, false );
 384
 385     SetError( m_pOwnStg->GetError() );
 386
 387     m_pStorStm = pStm;
 388     m_bDelStm = bDelete;
 389     if ( IsOLEStorage() )
 390         m_nVersion = SOFFICE_FILEFORMAT_50;
 391
 392     SignAsRoot( m_pOwnStg->IsRoot() );
 393 }
 394
 395 SotStorage::~SotStorage()
 396 {
 397     delete m_pOwnStg;
 398     if( m_bDelStm )
 399         delete m_pStorStm;
 400 }
 401
 402 std::unique_ptr<SvMemoryStream> SotStorage::CreateMemoryStream()
 403 {
 404     std::unique_ptr<SvMemoryStream> pStm(new SvMemoryStream( 0x8000, 0x8000 ));
 405     tools::SvRef<SotStorage> aStg = new SotStorage( *pStm );
 406     if( CopyTo( aStg.get() ) )
 407     {
 408         aStg->Commit();
 409     }
 410     else
 411     {
 412         aStg.clear(); // release storage beforehand
 413         pStm.reset();
 414     }
 415     return pStm;
 416 }
 417
 418 bool SotStorage::IsStorageFile( const OUString & rFileName )
 419 {
 420     OUString aName( rFileName );
 421     INetURLObject aObj( aName );
 422     if ( aObj.GetProtocol() == INetProtocol::NotValid )
 423     {
 424         OUString aURL;
 425         osl::FileBase::getFileURLFromSystemPath( aName, aURL );
 426         aObj.SetURL( aURL );
 427         aName = aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
 428     }
 429
 430     std::unique_ptr<SvStream> pStm(::utl::UcbStreamHelper::CreateStream( aName, StreamMode::STD_READ ));
 431     bool bRet = SotStorage::IsStorageFile( pStm.get() );
 432     return bRet;
 433 }
 434
 435 bool SotStorage::IsStorageFile( SvStream* pStream )
 436 {
 437     /** code for new storages must come first! **/
 438     if ( pStream )
 439     {
 440         sal_uInt64 nPos = pStream->Tell();
 441         bool bRet = UCBStorage::IsStorageFile( pStream );
 442         if ( !bRet )
 443             bRet = Storage::IsStorageFile( pStream );
 444         pStream->Seek( nPos );
 445         return bRet;
 446     }
 447     else
 448         return false;
 449 }
 450
 451 const OUString & SotStorage::GetName() const
 452 {
 453     if( m_aName.isEmpty() && m_pOwnStg )
 454         const_cast<SotStorage *>(this)->m_aName = m_pOwnStg->GetName();
 455     return m_aName;
 456 }
 457
 458 void SotStorage::SetClass( const SvGlobalName & rName,
 459                            SotClipboardFormatId nOriginalClipFormat,
 460                            const OUString & rUserTypeName )
 461 {
 462     if( m_pOwnStg )
 463         m_pOwnStg->SetClass( rName, nOriginalClipFormat, rUserTypeName );
 464     else
 465         SetError( SVSTREAM_GENERALERROR );
 466 }
 467
 468 SvGlobalName SotStorage::GetClassName()
 469 {
 470     SvGlobalName aGN;
 471     if( m_pOwnStg )
 472         aGN = m_pOwnStg->GetClassName();
 473     else
 474         SetError( SVSTREAM_GENERALERROR );
 475     return aGN;
 476 }
 477
 478 SotClipboardFormatId SotStorage::GetFormat()
 479 {
 480     SotClipboardFormatId nFormat = SotClipboardFormatId::NONE;
 481     if( m_pOwnStg )
 482         nFormat = m_pOwnStg->GetFormat();
 483     else
 484         SetError( SVSTREAM_GENERALERROR );
 485     return nFormat;
 486 }
 487
 488 OUString SotStorage::GetUserName()
 489 {
 490     OUString aName;
 491     if( m_pOwnStg )
 492         aName = m_pOwnStg->GetUserName();
 493     else
 494         SetError( SVSTREAM_GENERALERROR );
 495     return aName;
 496 }
 497
 498 void SotStorage::FillInfoList( SvStorageInfoList * pFillList ) const
 499 {
 500     if( m_pOwnStg )
 501         m_pOwnStg->FillInfoList( pFillList );
 502 }
 503
 504 bool SotStorage::CopyTo( SotStorage * pDestStg )
 505 {
 506     if( m_pOwnStg && pDestStg->m_pOwnStg )
 507     {
 508         m_pOwnStg->CopyTo( pDestStg->m_pOwnStg );
 509         SetError( m_pOwnStg->GetError() );
 510         pDestStg->m_aKey = m_aKey;
 511         pDestStg->m_nVersion = m_nVersion;
 512     }
 513     else
 514         SetError( SVSTREAM_GENERALERROR );
 515
 516     return ERRCODE_NONE == GetError();
 517 }
 518
 519 bool SotStorage::Commit()
 520 {
 521     if( m_pOwnStg )
 522     {
 523         if( !m_pOwnStg->Commit() )
 524             SetError( m_pOwnStg->GetError() );
 525     }
 526     else
 527         SetError( SVSTREAM_GENERALERROR );
 528
 529     return ERRCODE_NONE == GetError();
 530 }
 531
 532 tools::SvRef<SotStorageStream> SotStorage::OpenSotStream( const OUString & rEleName,
 533                                               StreamMode nMode )
 534 {
 535     tools::SvRef<SotStorageStream> pStm;
 536     if( m_pOwnStg )
 537     {
 538         // enable full Ole patches,
 539         // regardless what is coming, only exclusively allowed
 540         nMode |= StreamMode::SHARE_DENYALL;
 541         ErrCode nE = m_pOwnStg->GetError();
 542         BaseStorageStream * p = m_pOwnStg->OpenStream( rEleName, nMode );
 543         pStm = new SotStorageStream( p );
 544
 545         if( !nE )
 546             m_pOwnStg->ResetError(); // don't set error
 547         if( nMode & StreamMode::TRUNC )
 548             pStm->SetSize( 0 );
 549     }
 550     else
 551         SetError( SVSTREAM_GENERALERROR );
 552
 553     return pStm;
 554 }
 555
 556 SotStorage * SotStorage::OpenSotStorage( const OUString & rEleName,
 557                                          StreamMode nMode,
 558                                          bool transacted )
 559 {
 560     if( m_pOwnStg )
 561     {
 562         nMode |= StreamMode::SHARE_DENYALL;
 563         ErrCode nE = m_pOwnStg->GetError();
 564         BaseStorage * p = m_pOwnStg->OpenStorage(rEleName, nMode, !transacted);
 565         if( p )
 566         {
 567             SotStorage * pStor = new SotStorage( p );
 568             if( !nE )
 569                 m_pOwnStg->ResetError(); // don't set error
 570
 571             return pStor;
 572         }
 573     }
 574
 575     SetError( SVSTREAM_GENERALERROR );
 576
 577     return nullptr;
 578 }
 579
 580 bool SotStorage::IsStorage( const OUString & rEleName ) const
 581 {
 582     // a little bit faster
 583     if( m_pOwnStg )
 584         return m_pOwnStg->IsStorage( rEleName );
 585
 586     return false;
 587 }
 588
 589 bool SotStorage::IsStream( const OUString & rEleName ) const
 590 {
 591     // a little bit faster
 592     if( m_pOwnStg )
 593         return m_pOwnStg->IsStream( rEleName );
 594
 595     return false;
 596 }
 597
 598 bool SotStorage::IsContained( const OUString & rEleName ) const
 599 {
 600     // a little bit faster
 601     if( m_pOwnStg )
 602         return m_pOwnStg->IsContained( rEleName );
 603
 604     return false;
 605 }
 606
 607 bool SotStorage::Remove( const OUString & rEleName )
 608 {
 609     if( m_pOwnStg )
 610     {
 611         m_pOwnStg->Remove( rEleName );
 612         SetError( m_pOwnStg->GetError() );
 613     }
 614     else
 615         SetError( SVSTREAM_GENERALERROR );
 616
 617     return ERRCODE_NONE == GetError();
 618 }
 619
 620 bool SotStorage::CopyTo( const OUString & rEleName,
 621                          SotStorage * pNewSt, const OUString & rNewName )
 622 {
 623     if( m_pOwnStg )
 624     {
 625         m_pOwnStg->CopyTo( rEleName, pNewSt->m_pOwnStg, rNewName );
 626         SetError( m_pOwnStg->GetError() );
 627         SetError( pNewSt->GetError() );
 628     }
 629     else
 630         SetError( SVSTREAM_GENERALERROR );
 631
 632     return ERRCODE_NONE == GetError();
 633 }
 634
 635 bool SotStorage::Validate()
 636 {
 637     DBG_ASSERT( m_bIsRoot, "Validate only if root storage" );
 638     if( m_pOwnStg )
 639         return m_pOwnStg->ValidateFAT();
 640     else
 641         return true;
 642 }
 643
 644 bool SotStorage::IsOLEStorage() const
 645 {
 646     UCBStorage* pStg =  dynamic_cast<UCBStorage*>( m_pOwnStg );
 647     return !pStg;
 648 }
 649
 650 bool SotStorage::IsOLEStorage( const OUString & rFileName )
 651 {
 652     return Storage::IsStorageFile( rFileName );
 653 }
 654
 655 bool SotStorage::IsOLEStorage( SvStream* pStream )
 656 {
 657     return Storage::IsStorageFile( pStream );
 658 }
 659
 660 SotStorage* SotStorage::OpenOLEStorage( const css::uno::Reference < css::embed::XStorage >& xStorage,
 661                                         const OUString& rEleName, StreamMode nMode )
 662 {
 663     sal_Int32 nEleMode = embed::ElementModes::SEEKABLEREAD;
 664     if ( nMode & StreamMode::WRITE )
 665         nEleMode |= embed::ElementModes::WRITE;
 666     if ( nMode & StreamMode::TRUNC )
 667         nEleMode |= embed::ElementModes::TRUNCATE;
 668     if ( nMode & StreamMode::NOCREATE )
 669         nEleMode |= embed::ElementModes::NOCREATE;
 670
 671     std::unique_ptr<SvStream> pStream;
 672     try
 673     {
 674         uno::Reference < io::XStream > xStream = xStorage->openStreamElement( rEleName, nEleMode );
 675
 676         // TODO/LATER: should it be done this way?
 677         if ( nMode & StreamMode::WRITE )
 678         {
 679             uno::Reference < beans::XPropertySet > xStreamProps( xStream, uno::UNO_QUERY_THROW );
 680             xStreamProps->setPropertyValue( "MediaType",
 681                                             uno::Any( OUString(  "application/vnd.sun.star.oleobject"  ) ) );
 682         }
 683
 684         pStream = utl::UcbStreamHelper::CreateStream( xStream );
 685     }
 686     catch ( uno::Exception& )
 687     {
 688         //TODO/LATER: ErrorHandling
 689         pStream.reset( new SvMemoryStream );
 690         pStream->SetError( ERRCODE_IO_GENERAL );
 691     }
 692
 693     return new SotStorage( pStream.release(), true );
 694 }
 695
 696 SotClipboardFormatId SotStorage::GetFormatID( const css::uno::Reference < css::embed::XStorage >& xStorage )
 697 {
 698     uno::Reference< beans::XPropertySet > xProps( xStorage, uno::UNO_QUERY );
 699     if ( !xProps.is() )
 700         return SotClipboardFormatId::NONE;
 701
 702     OUString aMediaType;
 703     try
 704     {
 705         xProps->getPropertyValue("MediaType") >>= aMediaType;
 706     }
 707     catch (uno::Exception const&)
 708     {
 709         TOOLS_INFO_EXCEPTION("sot", "SotStorage::GetFormatID");
 710     }
 711
 712     if ( !aMediaType.isEmpty() )
 713     {
 714         css::datatransfer::DataFlavor aDataFlavor;
 715         aDataFlavor.MimeType = aMediaType;
 716         return SotExchange::GetFormat( aDataFlavor );
 717     }
 718
 719     return SotClipboardFormatId::NONE;
 720 }
 721
 722 sal_Int32 SotStorage::GetVersion( const css::uno::Reference < css::embed::XStorage >& xStorage )
 723 {
 724     SotClipboardFormatId nSotFormatID = SotStorage::GetFormatID( xStorage );
 725     switch( nSotFormatID )
 726     {
 727     case SotClipboardFormatId::STARWRITER_8:
 728     case SotClipboardFormatId::STARWRITER_8_TEMPLATE:
 729     case SotClipboardFormatId::STARWRITERWEB_8:
 730     case SotClipboardFormatId::STARWRITERGLOB_8:
 731     case SotClipboardFormatId::STARWRITERGLOB_8_TEMPLATE:
 732     case SotClipboardFormatId::STARDRAW_8:
 733     case SotClipboardFormatId::STARDRAW_8_TEMPLATE:
 734     case SotClipboardFormatId::STARIMPRESS_8:
 735     case SotClipboardFormatId::STARIMPRESS_8_TEMPLATE:
 736     case SotClipboardFormatId::STARCALC_8:
 737     case SotClipboardFormatId::STARCALC_8_TEMPLATE:
 738     case SotClipboardFormatId::STARCHART_8:
 739     case SotClipboardFormatId::STARCHART_8_TEMPLATE:
 740     case SotClipboardFormatId::STARMATH_8:
 741     case SotClipboardFormatId::STARMATH_8_TEMPLATE:
 742         return SOFFICE_FILEFORMAT_8;
 743     case SotClipboardFormatId::STARWRITER_60:
 744     case SotClipboardFormatId::STARWRITERWEB_60:
 745     case SotClipboardFormatId::STARWRITERGLOB_60:
 746     case SotClipboardFormatId::STARDRAW_60:
 747     case SotClipboardFormatId::STARIMPRESS_60:
 748     case SotClipboardFormatId::STARCALC_60:
 749     case SotClipboardFormatId::STARCHART_60:
 750     case SotClipboardFormatId::STARMATH_60:
 751         return SOFFICE_FILEFORMAT_60;
 752     default: break;
 753     }
 754
 755     return 0;
 756 }
 757
 758 namespace
 759 {
 760     void traverse(const tools::SvRef<SotStorage>& rStorage, std::vector<unsigned char>& rBuf)
 761     {
 762         SvStorageInfoList infos;
 763
 764         rStorage->FillInfoList(&infos);
 765
 766         for (const auto& info: infos)
 767         {
 768             if (info.IsStream())
 769             {
 770                 // try to open and read all content
 771                 tools::SvRef<SotStorageStream> xStream(rStorage->OpenSotStream(info.GetName(), StreamMode::STD_READ));
 772                 const size_t nSize = xStream->GetSize();
 773                 const size_t nRead = xStream->ReadBytes(rBuf.data(), nSize);
 774                 SAL_INFO("sot", "Read " << nRead << "bytes");
 775             }
 776             else if (info.IsStorage())
 777             {
 778                 tools::SvRef<SotStorage> xStorage(rStorage->OpenSotStorage(info.GetName(), StreamMode::STD_READ));
 779
 780                 // continue with children
 781                 traverse(xStorage, rBuf);
 782             }
 783         }
 784     }
 785 }
 786
 787 extern "C" SAL_DLLPUBLIC_EXPORT bool TestImportOLE2(SvStream &rStream)
 788 {
 789     try
 790     {
 791         size_t nSize = rStream.remainingSize();
 792         tools::SvRef<SotStorage> xRootStorage(new SotStorage(&rStream, false));
 793         std::vector<unsigned char> aTmpBuf(nSize);
 794         traverse(xRootStorage, aTmpBuf);
 795     }
 796     catch (...)
 797     {
 798         return false;
 799     }
 800     return true;
 801 }
 802
 803 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */