package/source/zippackage/zipfileaccess.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: zipfileaccess.cxx,v $
  10  * $Revision: 1.11 $
  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/lang/DisposedException.hpp>
  34 #ifndef _COM_SUN_STAR_LANG_INVALIDARGUMENTEXCEPTION_HPP_
  35 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  36 #endif
  37 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  38 #include <com/sun/star/io/XActiveDataSink.hpp>
  39 #include <com/sun/star/io/XStream.hpp>
  40 #include <com/sun/star/io/XSeekable.hpp>
  41
  42 #include <zipfileaccess.hxx>
  43 #include <ZipEnumeration.hxx>
  44 #include <ZipPackageSink.hxx>
  45 #include <EncryptionData.hxx>
  46
  47 #include <ucbhelper/content.hxx>
  48
  49 #include <memory>
  50
  51
  52 using namespace ::com::sun::star;
  53
  54 // ----------------------------------------------------------------
  55 OZipFileAccess::OZipFileAccess( const uno::Reference< lang::XMultiServiceFactory >& xFactory )
  56 : m_aMutexHolder( new SotMutexHolder )
  57 , m_xFactory( xFactory )
  58 , m_pZipFile( NULL )
  59 , m_pListenersContainer( NULL )
  60 , m_bDisposed( sal_False )
  61 {
  62     if ( !xFactory.is() )
  63         throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
  64 }
  65
  66 // ----------------------------------------------------------------
  67 OZipFileAccess::~OZipFileAccess()
  68 {
  69     {
  70         ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
  71         if ( !m_bDisposed )
  72         {
  73             try {
  74                 m_refCount++; // dispose will use refcounting so the further distruction must be avoided
  75                 dispose();
  76             } catch( uno::Exception& )
  77             {}
  78         }
  79     }
  80 }
  81
  82 // ----------------------------------------------------------------
  83 uno::Sequence< ::rtl::OUString > OZipFileAccess::GetPatternsFromString_Impl( const ::rtl::OUString& aString )
  84 {
  85     if ( !aString.getLength() )
  86         return uno::Sequence< ::rtl::OUString >();
  87
  88     uno::Sequence< ::rtl::OUString > aPattern( 1 );
  89     sal_Int32 nInd = 0;
  90
  91     const sal_Unicode* pString = aString.getStr();
  92     while( *pString )
  93     {
  94         if ( *pString == (sal_Unicode)'\\' )
  95         {
  96             pString++;
  97
  98             if ( *pString == (sal_Unicode)'\\' )
  99             {
 100                 aPattern[nInd] += ::rtl::OUString::valueOf( (sal_Unicode)'\\' );
 101                 pString++;
 102             }
 103             else if ( *pString == (sal_Unicode)'*' )
 104             {
 105                 aPattern[nInd] += ::rtl::OUString::valueOf( (sal_Unicode)'*' );
 106                 pString++;
 107             }
 108             else
 109             {
 110                 OSL_ENSURE( sal_False, "The backslash is not guarded!\n" );
 111                 aPattern[nInd] += ::rtl::OUString::valueOf( (sal_Unicode)'\\' );
 112             }
 113         }
 114         else if ( *pString == (sal_Unicode)'*' )
 115         {
 116             aPattern.realloc( ( ++nInd ) + 1 );
 117             pString++;
 118         }
 119         else
 120         {
 121             aPattern[nInd] += ::rtl::OUString::valueOf( *pString );
 122             pString++;
 123         }
 124     }
 125
 126     return aPattern;
 127 }
 128
 129 // ----------------------------------------------------------------
 130 sal_Bool OZipFileAccess::StringGoodForPattern_Impl( const ::rtl::OUString& aString,
 131                                                     const uno::Sequence< ::rtl::OUString >& aPattern )
 132 {
 133     sal_Int32 nInd = aPattern.getLength() - 1;
 134     if ( nInd < 0 )
 135         return sal_False;
 136
 137     if ( nInd == 0 )
 138     {
 139         if ( !aPattern[0].getLength() )
 140             return sal_True;
 141
 142         return aString.equals( aPattern[0] );
 143     }
 144
 145     sal_Int32 nBeginInd = aPattern[0].getLength();
 146     sal_Int32 nEndInd = aString.getLength() - aPattern[nInd].getLength();
 147     if ( nEndInd >= nBeginInd
 148       && ( nEndInd == aString.getLength() || aString.copy( nEndInd ).equals( aPattern[nInd] ) )
 149       && ( nBeginInd == 0 || aString.copy( 0, nBeginInd ).equals( aPattern[0] ) ) )
 150     {
 151         for ( sal_Int32 nCurInd = aPattern.getLength() - 2; nCurInd > 0; nCurInd-- )
 152         {
 153             if ( !aPattern[nCurInd].getLength() )
 154                 continue;
 155
 156             if ( nEndInd == nBeginInd )
 157                 return sal_False;
 158
 159             // check that search does not use nEndInd position
 160             sal_Int32 nLastInd = aString.lastIndexOf( aPattern[nCurInd], nEndInd - 1 );
 161
 162             if ( nLastInd == -1 )
 163                 return sal_False;
 164
 165             if ( nLastInd < nBeginInd )
 166                 return sal_False;
 167
 168             nEndInd = nLastInd;
 169         }
 170
 171         return sal_True;
 172     }
 173
 174     return sal_False;
 175 }
 176
 177 // XInitialization
 178 // ----------------------------------------------------------------
 179 void SAL_CALL OZipFileAccess::initialize( const uno::Sequence< uno::Any >& aArguments )
 180     throw ( uno::Exception,
 181             uno::RuntimeException )
 182 {
 183     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 184
 185     if ( m_bDisposed )
 186         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 187
 188     if ( m_pZipFile )
 189         throw uno::Exception( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // initialization is allowed only one time
 190
 191     if ( !aArguments.getLength() )
 192         throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 );
 193
 194     OSL_ENSURE( aArguments.getLength() == 1, "Too meny arguments are provided, only the first one will be used!\n" );
 195
 196     ::rtl::OUString aParamURL;
 197     uno::Reference< io::XStream > xStream;
 198     uno::Reference< io::XSeekable > xSeekable;
 199
 200     if ( ( aArguments[0] >>= aParamURL ) )
 201     {
 202         ::ucbhelper::Content aContent ( aParamURL, uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >() );
 203         uno::Reference < io::XActiveDataSink > xSink = new ZipPackageSink;
 204         if ( aContent.openStream ( xSink ) )
 205         {
 206             m_xContentStream = xSink->getInputStream();
 207             xSeekable = uno::Reference< io::XSeekable >( m_xContentStream, uno::UNO_QUERY );
 208         }
 209     }
 210     else if ( (aArguments[0] >>= xStream ) )
 211     {
 212         // a writable stream can implement both XStream & XInputStream
 213         m_xContentStream = xStream->getInputStream();
 214         xSeekable = uno::Reference< io::XSeekable >( xStream, uno::UNO_QUERY );
 215     }
 216     else if ( !( aArguments[0] >>= m_xContentStream ) )
 217     {
 218         xSeekable = uno::Reference< io::XSeekable >( m_xContentStream, uno::UNO_QUERY );
 219     }
 220     else
 221         throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 );
 222
 223     if ( !m_xContentStream.is() )
 224         throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 225
 226     if ( !xSeekable.is() )
 227     {
 228         // TODO: after fwkbugfix02 is integrated a helper class can be used to make the stream seekable
 229         throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 230     }
 231
 232     // TODO: in case xSeekable is implemented on separated XStream implementation a wrapper is required
 233     m_pZipFile = new ZipFile(
 234                 m_xContentStream,
 235                 m_xFactory,
 236                 sal_True );
 237 }
 238
 239 // XNameAccess
 240 // ----------------------------------------------------------------
 241 uno::Any SAL_CALL OZipFileAccess::getByName( const ::rtl::OUString& aName )
 242     throw ( container::NoSuchElementException,
 243             lang::WrappedTargetException,
 244             uno::RuntimeException )
 245 {
 246     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 247
 248     if ( m_bDisposed )
 249         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 250
 251     if ( !m_pZipFile )
 252         throw io::NotConnectedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 253
 254     EntryHash::iterator aIter = m_pZipFile->GetEntryHash().find( aName );
 255     if ( aIter == m_pZipFile->GetEntryHash().end() )
 256         throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 257
 258     uno::Reference< io::XInputStream > xEntryStream( m_pZipFile->getDataStream( (*aIter).second,
 259                                                                                 new EncryptionData(),
 260                                                                                 sal_False,
 261                                                                                 m_aMutexHolder ) );
 262
 263     if ( !xEntryStream.is() )
 264         throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 265
 266     return uno::makeAny ( xEntryStream );
 267 }
 268
 269 // ----------------------------------------------------------------
 270 uno::Sequence< ::rtl::OUString > SAL_CALL OZipFileAccess::getElementNames()
 271     throw ( uno::RuntimeException )
 272 {
 273     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 274
 275     if ( m_bDisposed )
 276         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 277
 278     if ( !m_pZipFile )
 279         throw io::NotConnectedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 280
 281     uno::Sequence< ::rtl::OUString > aNames( m_pZipFile->GetEntryHash().size() );
 282     sal_Int32 nLen = 0;
 283
 284     for ( EntryHash::iterator aIter = m_pZipFile->GetEntryHash().begin(); aIter != m_pZipFile->GetEntryHash().end(); aIter++ )
 285     {
 286         if ( aNames.getLength() < ++nLen )
 287         {
 288             OSL_ENSURE( sal_False, "The size must be the same!\n" );
 289             aNames.realloc( nLen );
 290         }
 291
 292         aNames[nLen-1] = (*aIter).second.sName;
 293     }
 294
 295     if ( aNames.getLength() != nLen )
 296     {
 297         OSL_ENSURE( sal_False, "The size must be the same!\n" );
 298         aNames.realloc( nLen );
 299     }
 300
 301     return aNames;
 302 }
 303
 304 // ----------------------------------------------------------------
 305 sal_Bool SAL_CALL OZipFileAccess::hasByName( const ::rtl::OUString& aName )
 306     throw (uno::RuntimeException)
 307 {
 308     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 309
 310     if ( m_bDisposed )
 311         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 312
 313     if ( !m_pZipFile )
 314         throw io::NotConnectedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 315
 316     EntryHash::iterator aIter = m_pZipFile->GetEntryHash().find( aName );
 317
 318     return ( aIter != m_pZipFile->GetEntryHash().end() );
 319 }
 320
 321 // ----------------------------------------------------------------
 322 uno::Type SAL_CALL OZipFileAccess::getElementType()
 323     throw ( uno::RuntimeException )
 324 {
 325     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 326
 327     if ( m_bDisposed )
 328         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 329
 330     if ( !m_pZipFile )
 331         throw io::NotConnectedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 332
 333     return getCppuType( ( const uno::Reference< io::XInputStream >* )NULL );
 334 }
 335
 336 // ----------------------------------------------------------------
 337 sal_Bool SAL_CALL OZipFileAccess::hasElements()
 338     throw ( uno::RuntimeException )
 339 {
 340     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 341
 342     if ( m_bDisposed )
 343         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 344
 345     if ( !m_pZipFile )
 346         throw io::NotConnectedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 347
 348     return ( m_pZipFile->GetEntryHash().size() != 0 );
 349 }
 350
 351 // XZipFileAccess
 352 // ----------------------------------------------------------------
 353 uno::Reference< io::XInputStream > SAL_CALL OZipFileAccess::getStreamByPattern( const ::rtl::OUString& aPatternString )
 354     throw ( container::NoSuchElementException,
 355             io::IOException,
 356             uno::RuntimeException )
 357 {
 358     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 359
 360     if ( m_bDisposed )
 361         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 362
 363     if ( !m_pZipFile )
 364         throw io::NotConnectedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 365
 366     // Code to compare strings by patterns
 367     uno::Sequence< ::rtl::OUString > aPattern = GetPatternsFromString_Impl( aPatternString );
 368
 369     for ( EntryHash::iterator aIter = m_pZipFile->GetEntryHash().begin(); aIter != m_pZipFile->GetEntryHash().end(); aIter++ )
 370     {
 371         if ( StringGoodForPattern_Impl( (*aIter).second.sName, aPattern ) )
 372         {
 373             uno::Reference< io::XInputStream > xEntryStream( m_pZipFile->getDataStream( (*aIter).second,
 374                                                                                         new EncryptionData(),
 375                                                                                         sal_False,
 376                                                                                         m_aMutexHolder ) );
 377
 378             if ( !xEntryStream.is() )
 379                 throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 380             return xEntryStream;
 381         }
 382     }
 383
 384     throw container::NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 385 }
 386
 387 // XComponent
 388 // ----------------------------------------------------------------
 389 void SAL_CALL OZipFileAccess::dispose()
 390     throw ( uno::RuntimeException )
 391 {
 392     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 393
 394     if ( m_bDisposed )
 395         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 396
 397     if ( m_pListenersContainer )
 398     {
 399            lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
 400         m_pListenersContainer->disposeAndClear( aSource );
 401         delete m_pListenersContainer;
 402         m_pListenersContainer = NULL;
 403     }
 404
 405     if ( m_pZipFile )
 406     {
 407         delete m_pZipFile;
 408         m_pZipFile = NULL;
 409     }
 410
 411     if ( m_xContentStream.is() )
 412         try {
 413             m_xContentStream->closeInput();
 414         } catch( uno::Exception& )
 415         {}
 416
 417     m_bDisposed = sal_True;
 418 }
 419
 420 // ----------------------------------------------------------------
 421 void SAL_CALL OZipFileAccess::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 422     throw ( uno::RuntimeException )
 423 {
 424     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 425
 426     if ( m_bDisposed )
 427         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 428
 429     if ( !m_pListenersContainer )
 430         m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutexHolder->GetMutex() );
 431     m_pListenersContainer->addInterface( xListener );
 432 }
 433
 434 // ----------------------------------------------------------------
 435 void SAL_CALL OZipFileAccess::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 436     throw ( uno::RuntimeException )
 437 {
 438     ::osl::MutexGuard aGuard( m_aMutexHolder->GetMutex() );
 439
 440     if ( m_bDisposed )
 441         throw lang::DisposedException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 442
 443     if ( m_pListenersContainer )
 444         m_pListenersContainer->removeInterface( xListener );
 445 }
 446
 447 //-------------------------------------------------------------------------
 448 uno::Sequence< ::rtl::OUString > SAL_CALL OZipFileAccess::impl_staticGetSupportedServiceNames()
 449 {
 450     uno::Sequence< ::rtl::OUString > aRet(2);
 451     aRet[0] = ::rtl::OUString::createFromAscii("com.sun.star.packages.zip.ZipFileAccess");
 452     aRet[1] = ::rtl::OUString::createFromAscii("com.sun.star.comp.packages.zip.ZipFileAccess");
 453     return aRet;
 454 }
 455
 456 //-------------------------------------------------------------------------
 457 ::rtl::OUString SAL_CALL OZipFileAccess::impl_staticGetImplementationName()
 458 {
 459     return ::rtl::OUString::createFromAscii("com.sun.star.comp.package.zip.ZipFileAccess");
 460 }
 461
 462 //-------------------------------------------------------------------------
 463 uno::Reference< uno::XInterface > SAL_CALL OZipFileAccess::impl_staticCreateSelfInstance(
 464             const uno::Reference< lang::XMultiServiceFactory >& xServiceManager )
 465 {
 466     return uno::Reference< uno::XInterface >( *new OZipFileAccess( xServiceManager ) );
 467 }
 468
 469 //-------------------------------------------------------------------------
 470 ::rtl::OUString SAL_CALL OZipFileAccess::getImplementationName()
 471     throw ( uno::RuntimeException )
 472 {
 473     return impl_staticGetImplementationName();
 474 }
 475
 476 //-------------------------------------------------------------------------
 477 sal_Bool SAL_CALL OZipFileAccess::supportsService( const ::rtl::OUString& ServiceName )
 478     throw ( uno::RuntimeException )
 479 {
 480     uno::Sequence< ::rtl::OUString > aSeq = impl_staticGetSupportedServiceNames();
 481
 482     for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
 483         if ( ServiceName.compareTo( aSeq[nInd] ) == 0 )
 484             return sal_True;
 485
 486     return sal_False;
 487 }
 488
 489 //-------------------------------------------------------------------------
 490 uno::Sequence< ::rtl::OUString > SAL_CALL OZipFileAccess::getSupportedServiceNames()
 491     throw ( uno::RuntimeException )
 492 {
 493     return impl_staticGetSupportedServiceNames();
 494 }
 495