package/source/zippackage/ZipPackageStream.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ZipPackageStream.cxx,v $
  10  * $Revision: 1.51 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_package.hxx"
  33 #include <com/sun/star/packages/zip/ZipConstants.hpp>
  34 #include <com/sun/star/packages/zip/ZipIOException.hpp>
  35 #include <com/sun/star/io/XInputStream.hpp>
  36 #include <com/sun/star/io/XOutputStream.hpp>
  37 #include <com/sun/star/io/XStream.hpp>
  38 #include <com/sun/star/io/XSeekable.hpp>
  39
  40
  41 #include <ZipPackageStream.hxx>
  42 #include <ZipPackage.hxx>
  43 #include <ZipFile.hxx>
  44 #include <EncryptedDataHeader.hxx>
  45 #include <vos/diagnose.hxx>
  46 #include "wrapstreamforshare.hxx"
  47
  48 #include <comphelper/seekableinput.hxx>
  49 #include <comphelper/storagehelper.hxx>
  50
  51 #include <PackageConstants.hxx>
  52
  53 using namespace com::sun::star::packages::zip::ZipConstants;
  54 using namespace com::sun::star::packages::zip;
  55 using namespace com::sun::star::uno;
  56 using namespace com::sun::star::lang;
  57 using namespace com::sun::star;
  58 using namespace cppu;
  59 using namespace rtl;
  60
  61 Sequence < sal_Int8 > ZipPackageStream::aImplementationId = Sequence < sal_Int8 > ();
  62
  63
  64 ZipPackageStream::ZipPackageStream ( ZipPackage & rNewPackage,
  65                                     const Reference< XMultiServiceFactory >& xFactory,
  66                                     sal_Bool bAllowRemoveOnInsert )
  67 : m_xFactory( xFactory )
  68 , rZipPackage(rNewPackage)
  69 , bToBeCompressed ( sal_True )
  70 , bToBeEncrypted ( sal_False )
  71 , bHaveOwnKey ( sal_False )
  72 , bIsEncrypted ( sal_False )
  73 , xEncryptionData ( )
  74 , m_nStreamMode( PACKAGE_STREAM_NOTSET )
  75 , m_nMagicalHackPos( 0 )
  76 , m_nMagicalHackSize( 0 )
  77 , m_bHasSeekable( sal_False )
  78 , m_bCompressedIsSetFromOutside( sal_False )
  79 {
  80     OSL_ENSURE( m_xFactory.is(), "No factory is provided to ZipPackageStream!\n" );
  81
  82     this->mbAllowRemoveOnInsert = bAllowRemoveOnInsert;
  83
  84     SetFolder ( sal_False );
  85     aEntry.nVersion             = -1;
  86     aEntry.nFlag                = 0;
  87     aEntry.nMethod              = -1;
  88     aEntry.nTime                = -1;
  89     aEntry.nCrc                 = -1;
  90     aEntry.nCompressedSize      = -1;
  91     aEntry.nSize                = -1;
  92     aEntry.nOffset              = -1;
  93     aEntry.nNameLen             = -1;
  94     aEntry.nExtraLen    = -1;
  95
  96     if ( !aImplementationId.getLength() )
  97         {
  98             aImplementationId = getImplementationId();
  99         }
 100 }
 101
 102 ZipPackageStream::~ZipPackageStream( void )
 103 {
 104 }
 105
 106 void ZipPackageStream::setZipEntryOnLoading( const ZipEntry &rInEntry)
 107 {
 108     aEntry.nVersion = rInEntry.nVersion;
 109     aEntry.nFlag = rInEntry.nFlag;
 110     aEntry.nMethod = rInEntry.nMethod;
 111     aEntry.nTime = rInEntry.nTime;
 112     aEntry.nCrc = rInEntry.nCrc;
 113     aEntry.nCompressedSize = rInEntry.nCompressedSize;
 114     aEntry.nSize = rInEntry.nSize;
 115     aEntry.nOffset = rInEntry.nOffset;
 116     aEntry.sName = rInEntry.sName;
 117     aEntry.nNameLen = rInEntry.nNameLen;
 118     aEntry.nExtraLen = rInEntry.nExtraLen;
 119
 120     if ( aEntry.nMethod == STORED )
 121         bToBeCompressed = sal_False;
 122 }
 123
 124 //--------------------------------------------------------------------------
 125 void ZipPackageStream::CloseOwnStreamIfAny()
 126 {
 127     if ( xStream.is() )
 128     {
 129         xStream->closeInput();
 130         xStream = uno::Reference< io::XInputStream >();
 131         m_bHasSeekable = sal_False;
 132     }
 133 }
 134
 135 //--------------------------------------------------------------------------
 136 uno::Reference< io::XInputStream >& ZipPackageStream::GetOwnSeekStream()
 137 {
 138     if ( !m_bHasSeekable && xStream.is() )
 139     {
 140         // The package component requires that every stream either be FROM a package or it must support XSeekable!
 141         // The only exception is a nonseekable stream that is provided only for storing, if such a stream
 142         // is accessed before commit it MUST be wrapped.
 143         // Wrap the stream in case it is not seekable
 144         xStream = ::comphelper::OSeekableInputWrapper::CheckSeekableCanWrap( xStream, m_xFactory );
 145         Reference< io::XSeekable > xSeek( xStream, UNO_QUERY );
 146         if ( !xSeek.is() )
 147             throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "The stream must support XSeekable!" ) ),
 148                                     Reference< XInterface >() );
 149
 150         m_bHasSeekable = sal_True;
 151     }
 152
 153     return xStream;
 154 }
 155
 156 //--------------------------------------------------------------------------
 157 uno::Reference< io::XInputStream > ZipPackageStream::GetRawEncrStreamNoHeaderCopy()
 158 {
 159     if ( m_nStreamMode != PACKAGE_STREAM_RAW || !GetOwnSeekStream().is() )
 160         throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 161
 162     if ( xEncryptionData.isEmpty() )
 163         throw ZipIOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Encrypted stream without encryption data!\n" ) ),
 164                             Reference< XInterface >() );
 165
 166     uno::Reference< io::XSeekable > xSeek( GetOwnSeekStream(), UNO_QUERY );
 167     if ( !xSeek.is() )
 168         throw ZipIOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "The stream must be seekable!\n" ) ),
 169                             Reference< XInterface >() );
 170
 171     // skip header
 172     xSeek->seek( n_ConstHeaderSize + xEncryptionData->aInitVector.getLength() +
 173                     xEncryptionData->aSalt.getLength() + xEncryptionData->aDigest.getLength() );
 174
 175     // create temporary stream
 176     uno::Reference < io::XOutputStream > xTempOut(
 177                         m_xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.TempFile" ) ) ),
 178                         uno::UNO_QUERY );
 179     uno::Reference < io::XInputStream > xTempIn( xTempOut, UNO_QUERY );
 180     uno::Reference < io::XSeekable > xTempSeek( xTempOut, UNO_QUERY );
 181     if ( !xTempOut.is() || !xTempIn.is() || !xTempSeek.is() )
 182         throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 183
 184     // copy the raw stream to the temporary file starting from the current position
 185     ::comphelper::OStorageHelper::CopyInputToOutput( GetOwnSeekStream(), xTempOut );
 186     xTempOut->closeOutput();
 187     xTempSeek->seek( 0 );
 188
 189     return xTempIn;
 190 }
 191
 192 //--------------------------------------------------------------------------
 193 Reference< io::XInputStream > ZipPackageStream::TryToGetRawFromDataStream( sal_Bool bAddHeaderForEncr )
 194 {
 195     if ( m_nStreamMode != PACKAGE_STREAM_DATA || !GetOwnSeekStream().is() || (bAddHeaderForEncr && !bToBeEncrypted) )
 196         throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 197
 198     Sequence< sal_Int8 > aKey;
 199
 200     if ( bToBeEncrypted )
 201     {
 202         aKey = ( xEncryptionData.isEmpty() || !bHaveOwnKey ) ? rZipPackage.getEncryptionKey() :
 203                                                                                 xEncryptionData->aKey;
 204         if ( !aKey.getLength() )
 205             throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 206     }
 207
 208     try
 209     {
 210         // create temporary file
 211         uno::Reference < io::XStream > xTempStream(
 212                             m_xFactory->createInstance ( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.TempFile" ) ) ),
 213                             uno::UNO_QUERY );
 214         if ( !xTempStream.is() )
 215             throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 216
 217         // create a package based on it
 218         ZipPackage* pPackage = new ZipPackage( m_xFactory );
 219         Reference< XSingleServiceFactory > xPackageAsFactory( static_cast< XSingleServiceFactory* >( pPackage ) );
 220         if ( !xPackageAsFactory.is() )
 221             throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 222
 223         Sequence< Any > aArgs( 1 );
 224         aArgs[0] <<= xTempStream;
 225         pPackage->initialize( aArgs );
 226
 227         // create a new package stream
 228         Reference< XDataSinkEncrSupport > xNewPackStream( xPackageAsFactory->createInstance(), UNO_QUERY );
 229         if ( !xNewPackStream.is() )
 230             throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 231
 232         xNewPackStream->setDataStream( static_cast< io::XInputStream* >(
 233                                                     new WrapStreamForShare( GetOwnSeekStream(), rZipPackage.GetSharedMutexRef() ) ) );
 234
 235         Reference< XPropertySet > xNewPSProps( xNewPackStream, UNO_QUERY );
 236         if ( !xNewPSProps.is() )
 237             throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 238
 239         // copy all the properties of this stream to the new stream
 240         xNewPSProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ), makeAny( sMediaType ) );
 241         xNewPSProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Compressed" ) ), makeAny( bToBeCompressed ) );
 242         if ( bToBeEncrypted )
 243         {
 244             xNewPSProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "EncryptionKey" ) ), makeAny( aKey ) );
 245             xNewPSProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Encrypted" ) ), makeAny( sal_True ) );
 246         }
 247
 248         // insert a new stream in the package
 249         Reference< XUnoTunnel > xTunnel;
 250         Any aRoot = pPackage->getByHierarchicalName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) ) );
 251         aRoot >>= xTunnel;
 252         Reference< container::XNameContainer > xRootNameContainer( xTunnel, UNO_QUERY );
 253         if ( !xRootNameContainer.is() )
 254             throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 255
 256         Reference< XUnoTunnel > xNPSTunnel( xNewPackStream, UNO_QUERY );
 257         xRootNameContainer->insertByName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "dummy" ) ), makeAny( xNPSTunnel ) );
 258
 259         // commit the temporary package
 260         pPackage->commitChanges();
 261
 262         // get raw stream from the temporary package
 263         Reference< io::XInputStream > xInRaw;
 264         if ( bAddHeaderForEncr )
 265             xInRaw = xNewPackStream->getRawStream();
 266         else
 267             xInRaw = xNewPackStream->getPlainRawStream();
 268
 269         // create another temporary file
 270         uno::Reference < io::XOutputStream > xTempOut(
 271                             m_xFactory->createInstance ( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.TempFile" ) ) ),
 272                             uno::UNO_QUERY );
 273         uno::Reference < io::XInputStream > xTempIn( xTempOut, UNO_QUERY );
 274         uno::Reference < io::XSeekable > xTempSeek( xTempOut, UNO_QUERY );
 275         if ( !xTempOut.is() || !xTempIn.is() || !xTempSeek.is() )
 276             throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 277
 278         // copy the raw stream to the temporary file
 279         ::comphelper::OStorageHelper::CopyInputToOutput( xInRaw, xTempOut );
 280         xTempOut->closeOutput();
 281         xTempSeek->seek( 0 );
 282
 283         // close raw stream, package stream and folder
 284         xInRaw = Reference< io::XInputStream >();
 285         xNewPSProps = Reference< XPropertySet >();
 286         xNPSTunnel = Reference< XUnoTunnel >();
 287         xNewPackStream = Reference< XDataSinkEncrSupport >();
 288         xTunnel = Reference< XUnoTunnel >();
 289         xRootNameContainer = Reference< container::XNameContainer >();
 290
 291         // return the stream representing the first temporary file
 292         return xTempIn;
 293     }
 294     catch ( RuntimeException& )
 295     {
 296         throw;
 297     }
 298     catch ( Exception& )
 299     {
 300     }
 301
 302     throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 303 }
 304
 305 //--------------------------------------------------------------------------
 306 sal_Bool ZipPackageStream::ParsePackageRawStream()
 307 {
 308     OSL_ENSURE( GetOwnSeekStream().is(), "A stream must be provided!\n" );
 309
 310     if ( !GetOwnSeekStream().is() )
 311         return sal_False;
 312
 313     sal_Bool bOk = sal_False;
 314
 315     vos::ORef < EncryptionData > xTempEncrData;
 316     sal_Int32 nMagHackSize = 0;
 317     Sequence < sal_Int8 > aHeader ( 4 );
 318
 319     try
 320     {
 321         if ( GetOwnSeekStream()->readBytes ( aHeader, 4 ) == 4 )
 322         {
 323             const sal_Int8 *pHeader = aHeader.getConstArray();
 324             sal_uInt32 nHeader = ( pHeader [0] & 0xFF )       |
 325                                  ( pHeader [1] & 0xFF ) << 8  |
 326                                  ( pHeader [2] & 0xFF ) << 16 |
 327                                  ( pHeader [3] & 0xFF ) << 24;
 328             if ( nHeader == n_ConstHeader )
 329             {
 330                 // this is one of our god-awful, but extremely devious hacks, everyone cheer
 331                 xTempEncrData = new EncryptionData;
 332
 333                 ::rtl::OUString aMediaType;
 334                 if ( ZipFile::StaticFillData ( xTempEncrData, nMagHackSize, aMediaType, GetOwnSeekStream() ) )
 335                 {
 336                     // We'll want to skip the data we've just read, so calculate how much we just read
 337                     // and remember it
 338                     m_nMagicalHackPos = n_ConstHeaderSize + xTempEncrData->aSalt.getLength()
 339                                                         + xTempEncrData->aInitVector.getLength()
 340                                                         + xTempEncrData->aDigest.getLength()
 341                                                         + aMediaType.getLength() * sizeof( sal_Unicode );
 342                     m_nMagicalHackSize = nMagHackSize;
 343                     sMediaType = aMediaType;
 344
 345                     bOk = sal_True;
 346                 }
 347             }
 348         }
 349     }
 350     catch( Exception& )
 351     {
 352     }
 353
 354     if ( !bOk )
 355     {
 356         // the provided stream is not a raw stream
 357         return sal_False;
 358     }
 359
 360     xEncryptionData = xTempEncrData;
 361     SetIsEncrypted ( sal_True );
 362     // it's already compressed and encrypted
 363     bToBeEncrypted = bToBeCompressed = sal_False;
 364
 365     return sal_True;
 366 }
 367
 368 void ZipPackageStream::SetPackageMember( sal_Bool bNewValue )
 369 {
 370     if ( bNewValue )
 371     {
 372         m_nStreamMode = PACKAGE_STREAM_PACKAGEMEMBER;
 373         m_nMagicalHackPos = 0;
 374         m_nMagicalHackSize = 0;
 375     }
 376     else if ( m_nStreamMode == PACKAGE_STREAM_PACKAGEMEMBER )
 377         m_nStreamMode = PACKAGE_STREAM_NOTSET; // must be reset
 378 }
 379
 380 // XActiveDataSink
 381 //--------------------------------------------------------------------------
 382 void SAL_CALL ZipPackageStream::setInputStream( const Reference< io::XInputStream >& aStream )
 383         throw(RuntimeException)
 384 {
 385     // if seekable access is required the wrapping will be done on demand
 386     xStream = aStream;
 387     m_bHasSeekable = sal_False;
 388     SetPackageMember ( sal_False );
 389     aEntry.nTime = -1;
 390     m_nStreamMode = PACKAGE_STREAM_DETECT;
 391 }
 392
 393 //--------------------------------------------------------------------------
 394 Reference< io::XInputStream > SAL_CALL ZipPackageStream::getRawData()
 395         throw(RuntimeException)
 396 {
 397     try
 398     {
 399         if (IsPackageMember())
 400         {
 401             if ( !xEncryptionData.isEmpty() && !bHaveOwnKey )
 402                 xEncryptionData->aKey = rZipPackage.getEncryptionKey();
 403             return rZipPackage.getZipFile().getRawData( aEntry, xEncryptionData, bIsEncrypted, rZipPackage.GetSharedMutexRef() );
 404         }
 405         else if ( GetOwnSeekStream().is() )
 406         {
 407             return new WrapStreamForShare( GetOwnSeekStream(), rZipPackage.GetSharedMutexRef() );
 408         }
 409         else
 410             return Reference < io::XInputStream > ();
 411     }
 412     catch (ZipException &)//rException)
 413     {
 414         VOS_ENSURE( 0, "ZipException thrown");//rException.Message);
 415         return Reference < io::XInputStream > ();
 416     }
 417     catch (Exception &)
 418     {
 419         VOS_ENSURE( 0, "Exception is thrown during stream wrapping!\n");
 420         return Reference < io::XInputStream > ();
 421     }
 422 }
 423
 424 //--------------------------------------------------------------------------
 425 Reference< io::XInputStream > SAL_CALL ZipPackageStream::getInputStream(  )
 426         throw(RuntimeException)
 427 {
 428     try
 429     {
 430         if (IsPackageMember())
 431         {
 432             if ( !xEncryptionData.isEmpty() && !bHaveOwnKey )
 433                 xEncryptionData->aKey = rZipPackage.getEncryptionKey();
 434             return rZipPackage.getZipFile().getInputStream( aEntry, xEncryptionData, bIsEncrypted, rZipPackage.GetSharedMutexRef() );
 435         }
 436         else if ( GetOwnSeekStream().is() )
 437         {
 438             return new WrapStreamForShare( GetOwnSeekStream(), rZipPackage.GetSharedMutexRef() );
 439         }
 440         else
 441             return Reference < io::XInputStream > ();
 442     }
 443     catch (ZipException &)//rException)
 444     {
 445         VOS_ENSURE( 0,"ZipException thrown");//rException.Message);
 446         return Reference < io::XInputStream > ();
 447     }
 448     catch (Exception &)
 449     {
 450         VOS_ENSURE( 0, "Exception is thrown during stream wrapping!\n");
 451         return Reference < io::XInputStream > ();
 452     }
 453 }
 454
 455 // XDataSinkEncrSupport
 456 //--------------------------------------------------------------------------
 457 Reference< io::XInputStream > SAL_CALL ZipPackageStream::getDataStream()
 458         throw ( packages::WrongPasswordException,
 459                 io::IOException,
 460                 RuntimeException )
 461 {
 462     // There is no stream attached to this object
 463     if ( m_nStreamMode == PACKAGE_STREAM_NOTSET )
 464         return Reference< io::XInputStream >();
 465
 466     // this method can not be used together with old approach
 467     if ( m_nStreamMode == PACKAGE_STREAM_DETECT )
 468         throw packages::zip::ZipIOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 469
 470     if ( !xEncryptionData.isEmpty() && !bHaveOwnKey )
 471         xEncryptionData->aKey = rZipPackage.getEncryptionKey();
 472
 473     if (IsPackageMember())
 474     {
 475         if ( !xEncryptionData.isEmpty() && !bHaveOwnKey )
 476             xEncryptionData->aKey = rZipPackage.getEncryptionKey();
 477
 478         return rZipPackage.getZipFile().getDataStream( aEntry, xEncryptionData, bIsEncrypted, rZipPackage.GetSharedMutexRef() );
 479     }
 480     else if ( m_nStreamMode == PACKAGE_STREAM_RAW )
 481         return ZipFile::StaticGetDataFromRawStream( GetOwnSeekStream(), xEncryptionData );
 482     else if ( GetOwnSeekStream().is() )
 483     {
 484         return new WrapStreamForShare( GetOwnSeekStream(), rZipPackage.GetSharedMutexRef() );
 485     }
 486     else
 487         return uno::Reference< io::XInputStream >();
 488 }
 489
 490 //--------------------------------------------------------------------------
 491 Reference< io::XInputStream > SAL_CALL ZipPackageStream::getRawStream()
 492         throw ( packages::NoEncryptionException,
 493                 io::IOException,
 494                 uno::RuntimeException )
 495 {
 496     // There is no stream attached to this object
 497     if ( m_nStreamMode == PACKAGE_STREAM_NOTSET )
 498         return Reference< io::XInputStream >();
 499
 500     // this method can not be used together with old approach
 501     if ( m_nStreamMode == PACKAGE_STREAM_DETECT )
 502         throw packages::zip::ZipIOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 503
 504     if (IsPackageMember())
 505     {
 506         if ( !bIsEncrypted || xEncryptionData.isEmpty() )
 507             throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 508
 509         return rZipPackage.getZipFile().getWrappedRawStream( aEntry, xEncryptionData, sMediaType, rZipPackage.GetSharedMutexRef() );
 510     }
 511     else if ( GetOwnSeekStream().is() )
 512     {
 513         if ( m_nStreamMode == PACKAGE_STREAM_RAW )
 514         {
 515             return new WrapStreamForShare( GetOwnSeekStream(), rZipPackage.GetSharedMutexRef() );
 516         }
 517         else if ( m_nStreamMode == PACKAGE_STREAM_DATA && bToBeEncrypted )
 518             return TryToGetRawFromDataStream( sal_True );
 519     }
 520
 521     throw packages::NoEncryptionException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 522 }
 523
 524
 525 //--------------------------------------------------------------------------
 526 void SAL_CALL ZipPackageStream::setDataStream( const Reference< io::XInputStream >& aStream )
 527         throw ( io::IOException,
 528                 RuntimeException )
 529 {
 530     setInputStream( aStream );
 531     m_nStreamMode = PACKAGE_STREAM_DATA;
 532 }
 533
 534 //--------------------------------------------------------------------------
 535 void SAL_CALL ZipPackageStream::setRawStream( const Reference< io::XInputStream >& aStream )
 536         throw ( packages::EncryptionNotAllowedException,
 537                 packages::NoRawFormatException,
 538                 io::IOException,
 539                 RuntimeException)
 540 {
 541     // wrap the stream in case it is not seekable
 542     Reference< io::XInputStream > xNewStream = ::comphelper::OSeekableInputWrapper::CheckSeekableCanWrap( aStream, m_xFactory );
 543     Reference< io::XSeekable > xSeek( xNewStream, UNO_QUERY );
 544     if ( !xSeek.is() )
 545         throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "The stream must support XSeekable!" ) ),
 546                                     Reference< XInterface >() );
 547
 548     xSeek->seek( 0 );
 549     Reference< io::XInputStream > xOldStream = xStream;
 550     xStream = xNewStream;
 551     if ( !ParsePackageRawStream() )
 552     {
 553         xStream = xOldStream;
 554         throw packages::NoRawFormatException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 555     }
 556
 557     // the raw stream MUST have seekable access
 558     m_bHasSeekable = sal_True;
 559
 560     SetPackageMember ( sal_False );
 561     aEntry.nTime = -1;
 562     m_nStreamMode = PACKAGE_STREAM_RAW;
 563 }
 564
 565 //--------------------------------------------------------------------------
 566 uno::Reference< io::XInputStream > SAL_CALL ZipPackageStream::getPlainRawStream()
 567         throw ( io::IOException,
 568                 uno::RuntimeException )
 569 {
 570     // There is no stream attached to this object
 571     if ( m_nStreamMode == PACKAGE_STREAM_NOTSET )
 572         return Reference< io::XInputStream >();
 573
 574     // this method can not be used together with old approach
 575     if ( m_nStreamMode == PACKAGE_STREAM_DETECT )
 576         throw packages::zip::ZipIOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 577
 578     if (IsPackageMember())
 579     {
 580         return rZipPackage.getZipFile().getRawData( aEntry, xEncryptionData, bIsEncrypted, rZipPackage.GetSharedMutexRef() );
 581     }
 582     else if ( GetOwnSeekStream().is() )
 583     {
 584         if ( m_nStreamMode == PACKAGE_STREAM_RAW )
 585         {
 586             // the header should not be returned here
 587             return GetRawEncrStreamNoHeaderCopy();
 588         }
 589         else if ( m_nStreamMode == PACKAGE_STREAM_DATA )
 590             return TryToGetRawFromDataStream( sal_False );
 591     }
 592
 593     return Reference< io::XInputStream >();
 594 }
 595
 596 // XUnoTunnel
 597
 598 //--------------------------------------------------------------------------
 599 sal_Int64 SAL_CALL ZipPackageStream::getSomething( const Sequence< sal_Int8 >& aIdentifier )
 600     throw(RuntimeException)
 601 {
 602     sal_Int64 nMe = 0;
 603     if ( aIdentifier.getLength() == 16 &&
 604          0 == rtl_compareMemory( static_getImplementationId().getConstArray(), aIdentifier.getConstArray(), 16 ) )
 605         nMe = reinterpret_cast < sal_Int64 > ( this );
 606     return nMe;
 607 }
 608
 609 // XPropertySet
 610 //--------------------------------------------------------------------------
 611 void SAL_CALL ZipPackageStream::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
 612         throw(beans::UnknownPropertyException, beans::PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
 613 {
 614     if (aPropertyName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("MediaType")))
 615     {
 616         if ( rZipPackage.getFormat() != PACKAGE_FORMAT && rZipPackage.getFormat() != OFOPXML_FORMAT )
 617             throw beans::PropertyVetoException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 618
 619         if ( aValue >>= sMediaType )
 620         {
 621             if (sMediaType.getLength() > 0)
 622             {
 623                 if ( sMediaType.indexOf (OUString( RTL_CONSTASCII_USTRINGPARAM ( "text" ) ) ) != -1
 624                  || sMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM ( "application/vnd.sun.star.oleobject" ) ) ) )
 625                     bToBeCompressed = sal_True;
 626                 else if ( !m_bCompressedIsSetFromOutside )
 627                     bToBeCompressed = sal_False;
 628             }
 629         }
 630         else
 631             throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "MediaType must be a string!\n" ) ),
 632                                             Reference< XInterface >(),
 633                                             2 );
 634
 635     }
 636     else if (aPropertyName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("Size") ) )
 637     {
 638         if ( !( aValue >>= aEntry.nSize ) )
 639             throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Wrong type for Size property!\n" ) ),
 640                                             Reference< XInterface >(),
 641                                             2 );
 642     }
 643     else if (aPropertyName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("Encrypted") ) )
 644     {
 645         if ( rZipPackage.getFormat() != PACKAGE_FORMAT )
 646             throw beans::PropertyVetoException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 647
 648         sal_Bool bEnc = sal_False;
 649         if ( aValue >>= bEnc )
 650         {
 651             // In case of new raw stream, the stream must not be encrypted on storing
 652             if ( bEnc && m_nStreamMode == PACKAGE_STREAM_RAW )
 653                 throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Raw stream can not be encrypted on storing" ) ),
 654                                                 Reference< XInterface >(),
 655                                                 2 );
 656
 657             bToBeEncrypted = bEnc;
 658             if ( bToBeEncrypted && xEncryptionData.isEmpty())
 659                 xEncryptionData = new EncryptionData;
 660         }
 661         else
 662             throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Wrong type for Encrypted property!\n" ) ),
 663                                             Reference< XInterface >(),
 664                                             2 );
 665
 666     }
 667     else if (aPropertyName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("EncryptionKey") ) )
 668     {
 669         if ( rZipPackage.getFormat() != PACKAGE_FORMAT )
 670             throw beans::PropertyVetoException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 671
 672         Sequence < sal_Int8 > aNewKey;
 673
 674         if ( !( aValue >>= aNewKey ) )
 675         {
 676             OUString sTempString;
 677             if ( ( aValue >>= sTempString ) )
 678             {
 679                 sal_Int32 nNameLength = sTempString.getLength();
 680                 Sequence < sal_Int8 > aSequence ( nNameLength );
 681                 sal_Int8 *pArray = aSequence.getArray();
 682                 const sal_Unicode *pChar = sTempString.getStr();
 683                 for ( sal_Int16 i = 0; i < nNameLength; i++)
 684                     pArray[i] = static_cast < const sal_Int8 > (pChar[i]);
 685                 aNewKey = aSequence;
 686             }
 687             else
 688                 throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Wrong type for EncryptionKey property!\n" ) ),
 689                                                 Reference< XInterface >(),
 690                                                 2 );
 691         }
 692
 693         if ( aNewKey.getLength() )
 694         {
 695             if ( xEncryptionData.isEmpty())
 696                 xEncryptionData = new EncryptionData;
 697
 698             xEncryptionData->aKey = aNewKey;
 699             // In case of new raw stream, the stream must not be encrypted on storing
 700             bHaveOwnKey = sal_True;
 701             if ( m_nStreamMode != PACKAGE_STREAM_RAW )
 702                 bToBeEncrypted = sal_True;
 703         }
 704         else
 705             bHaveOwnKey = sal_False;
 706     }
 707     else if (aPropertyName.equalsAsciiL ( RTL_CONSTASCII_STRINGPARAM ( "Compressed" ) ) )
 708     {
 709         sal_Bool bCompr = sal_False;
 710
 711         if ( aValue >>= bCompr )
 712         {
 713             // In case of new raw stream, the stream must not be encrypted on storing
 714             if ( bCompr && m_nStreamMode == PACKAGE_STREAM_RAW )
 715                 throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Raw stream can not be encrypted on storing" ) ),
 716                                                 Reference< XInterface >(),
 717                                                 2 );
 718
 719             bToBeCompressed = bCompr;
 720             m_bCompressedIsSetFromOutside = sal_True;
 721         }
 722         else
 723             throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Wrong type for Compressed property!\n" ) ),
 724                                             Reference< XInterface >(),
 725                                             2 );
 726     }
 727     else
 728         throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 729 }
 730
 731 //--------------------------------------------------------------------------
 732 Any SAL_CALL ZipPackageStream::getPropertyValue( const OUString& PropertyName )
 733         throw(beans::UnknownPropertyException, WrappedTargetException, RuntimeException)
 734 {
 735     Any aAny;
 736     if (PropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "MediaType" ) ) )
 737     {
 738         aAny <<= sMediaType;
 739         return aAny;
 740     }
 741     else if (PropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "Size" ) ) )
 742     {
 743         aAny <<= aEntry.nSize;
 744         return aAny;
 745     }
 746     else if (PropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "Encrypted" ) ) )
 747     {
 748         aAny <<= ( m_nStreamMode == PACKAGE_STREAM_RAW ) ? sal_True : bToBeEncrypted;
 749         return aAny;
 750     }
 751     else if (PropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "WasEncrypted" ) ) )
 752     {
 753         aAny <<= bIsEncrypted;
 754         return aAny;
 755     }
 756     else if (PropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "Compressed" ) ) )
 757     {
 758         aAny <<= bToBeCompressed;
 759         return aAny;
 760     }
 761     else if (PropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "EncryptionKey" ) ) )
 762     {
 763         aAny <<= xEncryptionData.isEmpty () ? Sequence < sal_Int8 > () : xEncryptionData->aKey;
 764         return aAny;
 765     }
 766     else
 767         throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 768 }
 769
 770 //--------------------------------------------------------------------------
 771 void ZipPackageStream::setSize (const sal_Int32 nNewSize)
 772 {
 773     if (aEntry.nCompressedSize != nNewSize )
 774         aEntry.nMethod = DEFLATED;
 775     aEntry.nSize = nNewSize;
 776 }
 777 //--------------------------------------------------------------------------
 778 OUString ZipPackageStream::getImplementationName()
 779     throw (RuntimeException)
 780 {
 781     return OUString ( RTL_CONSTASCII_USTRINGPARAM ( "ZipPackageStream" ) );
 782 }
 783
 784 //--------------------------------------------------------------------------
 785 Sequence< OUString > ZipPackageStream::getSupportedServiceNames()
 786     throw (RuntimeException)
 787 {
 788     Sequence< OUString > aNames(1);
 789     aNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.packages.PackageStream" ) );
 790     return aNames;
 791 }
 792 //--------------------------------------------------------------------------
 793 sal_Bool SAL_CALL ZipPackageStream::supportsService( OUString const & rServiceName )
 794     throw (RuntimeException)
 795 {
 796     return rServiceName == getSupportedServiceNames()[0];
 797 }
 798