/************************************************************************* * * $RCSfile: ZipPackage.cxx,v $ * * $Revision: 1.39 $ * * last change: $Author: mtg $ $Date: 2001-04-23 15:34:21 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses * * - GNU Lesser General Public License Version 2.1 * - Sun Industry Standards Source License Version 1.1 * * Sun Microsystems Inc., October, 2000 * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2000 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * * * Sun Industry Standards Source License Version 1.1 * ================================================= * The contents of this file are subject to the Sun Industry Standards * Source License Version 1.1 (the "License"); You may not use this file * except in compliance with the License. You may obtain a copy of the * License at http://www.openoffice.org/license.html. * * Software provided under this License is provided on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. * See the License for the specific provisions governing your rights and * obligations concerning the Software. * * The Initial Developer of the Original Code is: Sun Microsystems, Inc. * * Copyright: 2000 by Sun Microsystems, Inc. * * All Rights Reserved. * * Contributor(s): Martin Gallwey (gallwey@sun.com) * * ************************************************************************/ #ifndef _ZIP_PACKAGE_HXX #include #endif #ifndef _ZIP_PACKAGE_SINK_HXX #include #endif #ifndef _ZIP_PACKAGE_STREAM_HXX #include #endif #ifndef _ZIP_PACKAGE_FOLDER_HXX #include #endif #ifndef _ZIP_OUTPUT_STREAM_HXX #include #endif #ifndef _ZIP_FILE_HXX #include #endif #ifndef _COM_SUN_STAR_UCB_COMMANDABORTEDEXCEPTION_HPP_ #include #endif #ifndef _COM_SUN_STAR_BEANS_PROPERTYVALUE_HPP_ #include #endif #ifndef _COM_SUN_STAR_PACKAGES_ZIPCONSTANTS_HPP_ #include #endif #ifndef _COM_SUN_STAR_PACKAGES_MANIFEST_XMANIFESTREADER_HPP_ #include #endif #ifndef _COM_SUN_STAR_PACKAGES_MANIFEST_XMANIFESTWRITER_HPP_ #include #endif using namespace rtl; using namespace std; using namespace com::sun::star::io; using namespace com::sun::star::registry; using namespace com::sun::star::util; using namespace com::sun::star::uno; using namespace com::sun::star::container; using namespace com::sun::star::lang; using namespace com::sun::star::beans; using namespace com::sun::star::packages; using namespace com::sun::star::packages::manifest; using namespace com::sun::star::packages::ZipConstants; ZipPackage::ZipPackage (const Reference < XMultiServiceFactory > &xNewFactory) : pContent(NULL) , pZipFile(NULL) , pRootFolder(NULL) , xContentStream (NULL) , xContentSeek (NULL) , xRootFolder (NULL) , xZipFile (NULL) , xFactory(xNewFactory) { pRootFolder = new ZipPackageFolder(); xRootFolder = Reference < XNameContainer > (pRootFolder ); } ZipPackage::~ZipPackage( void ) { if (pContent) delete pContent; // As all folders and streams contain references to their parents, // we must remove these references so that they will be deleted when // the hash_map of the root folder is cleared, releasing all subfolders // and substreams which in turn release theirs, etc. When xRootFolder is // released when this destructor completes, the folder tree should be // deleted fully (and automagically). pRootFolder->releaseUpwardRef(); } void ZipPackage::getZipFileContents() { Reference< XEnumeration > xEnum = pZipFile->entries(); Reference< XNameContainer > xCurrent; ZipPackageStream *pPkgStream; ZipPackageFolder *pPkgFolder; ZipEntry aEntry; Any aAny; while (xEnum->hasMoreElements()) { xCurrent = xRootFolder; sal_Int32 nOldIndex =0,nIndex = 0; aAny = xEnum->nextElement(); aAny >>= aEntry; OUString &rName = aEntry.sName; if (rName.lastIndexOf('/') == rName.getLength()-1) { while ((nIndex = rName.indexOf('/', nOldIndex)) != -1) { OUString sTemp = rName.copy (nOldIndex, nIndex - nOldIndex); if (nIndex == nOldIndex) break; if (!xCurrent->hasByName(sTemp)) { pPkgFolder = new ZipPackageFolder(); pPkgFolder->setName(sTemp); try { pPkgFolder->setParent( Reference < XInterface > (xCurrent, UNO_QUERY) ); } catch ( NoSupportException& ) { VOS_ENSURE(0, "setParent threw an exception: attempted to set Parent to non-existing interface!"); } xCurrent = Reference < XNameContainer > (pPkgFolder); } else { Reference < XUnoTunnel> xRef; aAny = xCurrent->getByName(sTemp); aAny >>= xRef; xCurrent = Reference < XNameContainer > (xRef, UNO_QUERY); } nOldIndex = nIndex+1; } } else { while ((nIndex = rName.indexOf('/', nOldIndex)) != -1) { OUString sTemp = rName.copy (nOldIndex, nIndex - nOldIndex); if (nIndex == nOldIndex) break; if (!xCurrent->hasByName(sTemp)) { pPkgFolder = new ZipPackageFolder(); pPkgFolder->setName(sTemp); try { pPkgFolder->setParent( Reference < XInterface >(xCurrent, UNO_QUERY)); } catch ( NoSupportException& ) { VOS_ENSURE( 0, "setParent threw an exception: attempted to set Parent to non-existing interface!"); } xCurrent = Reference < XNameContainer > (pPkgFolder); } else { Reference < XUnoTunnel> xRef; aAny = xCurrent->getByName(sTemp); aAny >>= xRef; xCurrent = Reference < XNameContainer > (xRef, UNO_QUERY); } nOldIndex = nIndex+1; } OUString sStreamName = rName.copy( nOldIndex, rName.getLength() - nOldIndex); pPkgStream = new ZipPackageStream( pZipFile ); pPkgStream->bPackageMember = sal_True; pPkgStream->setZipEntry( aEntry ); pPkgStream->setName( sStreamName ); try { pPkgStream->setParent( Reference < XInterface > (xCurrent, UNO_QUERY)); } catch ( NoSupportException& ) { VOS_ENSURE( 0, "setParent threw an exception: attempted to set Parent to non-existing interface!"); } } } const OUString sManifest (RTL_CONSTASCII_USTRINGPARAM( "META-INF/manifest.xml") ); if (hasByHierarchicalName( sManifest ) ) { Reference < XUnoTunnel > xTunnel; aAny = getByHierarchicalName( sManifest ); aAny >>= xTunnel; Reference < XActiveDataSink > xSink (xTunnel, UNO_QUERY); if (xSink.is()) { OUString sManifestReader ( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.packages.manifest.ManifestReader" ) ); Reference < XManifestReader > xReader (xFactory->createInstance( sManifestReader ), UNO_QUERY ); if ( xReader.is() ) { const OUString sFullPath ( RTL_CONSTASCII_USTRINGPARAM ( "FullPath" ) ); const OUString sMediaType ( RTL_CONSTASCII_USTRINGPARAM ( "MediaType" ) ); Sequence < Sequence < PropertyValue > > aManifestSequence = xReader->readManifestSequence ( xSink->getInputStream() ); sal_Int32 nLength = aManifestSequence.getLength(); const Sequence < PropertyValue > *pSequence = aManifestSequence.getConstArray(); for (sal_Int32 i = 0; i < nLength ; i++, pSequence++) { OUString sPath; Any aValueAny; const PropertyValue *pValue = pSequence->getConstArray(); for (sal_Int32 j = 0, nNum = pSequence->getLength(); j < nNum; j++ ) { if (pValue[j].Name.equals( sFullPath ) ) pValue[j].Value >>= sPath; else if (pValue[j].Name.equals( sMediaType ) ) aValueAny = pValue[j].Value; } if (sPath.getLength() && aValueAny.getValueTypeClass() == TypeClass_STRING) { if ( hasByHierarchicalName ( sPath ) ) { Any aAny = getByHierarchicalName( sPath ); Reference < XUnoTunnel > xTunnel; aAny >>= xTunnel; Reference < XPropertySet > xProps ( xTunnel, UNO_QUERY ); xProps->setPropertyValue ( sMediaType, aValueAny ); } } } } } } } // XInitialization void SAL_CALL ZipPackage::initialize( const Sequence< Any >& aArguments ) throw(Exception, RuntimeException) { OUString sURL; aArguments[0] >>= sURL; pContent = new ::ucb::Content(sURL, Reference < com::sun::star::ucb::XCommandEnvironment >() ); Reference < XActiveDataSink > xSink = new ZipPackageSink; try { if (pContent->openStream ( xSink) ) xContentStream = xSink->getInputStream(); xContentSeek = Reference < XSeekable > (xContentStream, UNO_QUERY); try { pZipFile = new ZipFile(xContentStream, sal_True); xZipFile = Reference < XZipFile > ( pZipFile ); getZipFileContents(); } catch (ZipException&)// rException) { // clean up the memory, throw an assertion, and tell the UCB about the error delete pZipFile; pZipFile = NULL; VOS_ENSURE( 0, "ZipException thrown - bad Zip File"); //rException.Message); throw; } } catch (::com::sun::star::ucb::CommandAbortedException&) { // File doesn't exist, we'll create it at commitChanges time } } Any SAL_CALL ZipPackage::getByHierarchicalName( const OUString& aName ) throw(NoSuchElementException, RuntimeException) { OUString sTemp, sRoot( RTL_CONSTASCII_USTRINGPARAM ( "/" ) ); sal_Int32 nOldIndex =0, nIndex; Any aAny; Reference < XNameContainer > xCurrent (xRootFolder); Reference < XNameContainer > xPrevious (NULL); if (aName[nOldIndex] == '/') nOldIndex++; if (aName == sRoot) aAny <<= Reference < XUnoTunnel > (pRootFolder); else if (aName.lastIndexOf('/') == (nIndex = aName.getLength()-1)) { if ( aRecent.count(aName) && (nOldIndex = aName.lastIndexOf('/', nIndex)) != -1) { sTemp = aName.copy(++nOldIndex, nIndex-nOldIndex); if (aRecent[aName]->hasByName(sTemp) ) return aRecent[aName]->getByName(sTemp); else aRecent.erase(aName); } nOldIndex=0; while ((nIndex = aName.indexOf('/', nOldIndex)) != -1) { sTemp = aName.copy (nOldIndex, nIndex - nOldIndex); Reference < XUnoTunnel > xRef; if (nIndex == nOldIndex) break; if (xCurrent->hasByName(sTemp)) { aAny = xCurrent->getByName(sTemp); aAny >>= xRef; xCurrent = Reference < XNameContainer > (xRef, UNO_QUERY); } else throw NoSuchElementException(); nOldIndex = nIndex+1; } aRecent[aName] = xPrevious; } else { if ( aRecent.count(aName) && (nOldIndex = aName.lastIndexOf('/', nIndex)) != -1) { sTemp = aName.copy(++nOldIndex, nIndex-nOldIndex); if (aRecent[aName]->hasByName(sTemp) ) return aRecent[aName]->getByName(sTemp); else aRecent.erase(aName); } nOldIndex=0; while ((nIndex = aName.indexOf('/', nOldIndex)) != -1) { sTemp = aName.copy (nOldIndex, nIndex - nOldIndex); Reference < XUnoTunnel > xChildRef; if (nIndex == nOldIndex) break; if (xCurrent->hasByName(sTemp)) { aAny = xCurrent->getByName(sTemp); aAny >>= xChildRef; xCurrent = Reference < XNameContainer > (xChildRef, UNO_QUERY); } else throw NoSuchElementException(); nOldIndex = nIndex+1; } OUString sStreamName = aName.copy( nOldIndex, aName.getLength() - nOldIndex); if (xCurrent->hasByName(sStreamName)) { aRecent[aName] = xCurrent; return xCurrent->getByName(sStreamName); } else throw NoSuchElementException(); } return aAny; } sal_Bool SAL_CALL ZipPackage::hasByHierarchicalName( const OUString& aName ) throw(RuntimeException) { OUString sTemp, sRoot( RTL_CONSTASCII_USTRINGPARAM ( "/" ) ); sal_Int32 nOldIndex = 0, nIndex; Any aAny; Reference < XNameContainer > xCurrent (xRootFolder); Reference < XNameContainer > xPrevious (NULL); if (aName[nOldIndex] == '/') nOldIndex++; if (aName == sRoot) return sal_True; else if (aName.lastIndexOf('/') == (nIndex = aName.getLength()-1)) { if ( aRecent.count(aName) && (nOldIndex = aName.lastIndexOf('/', nIndex)) != -1) { sTemp = aName.copy(++nOldIndex, nIndex - nOldIndex); if (aRecent[aName]->hasByName(sTemp) ) return sal_True; else aRecent.erase(aName); } nOldIndex=0; while ((nIndex = aName.indexOf('/', nOldIndex)) != -1) { sTemp = aName.copy (nOldIndex, nIndex - nOldIndex); Reference < XUnoTunnel > xRef; if (nIndex == nOldIndex) break; if (xCurrent->hasByName(sTemp)) { aAny = xCurrent->getByName(sTemp); aAny >>= xRef; xPrevious = xCurrent; xCurrent = Reference < XNameContainer > (xRef, UNO_QUERY); } else return sal_False; nOldIndex = nIndex+1; } aRecent[aName] = xPrevious; return sal_True; } else { if ( aRecent.count(aName) && (nOldIndex = aName.lastIndexOf('/', nIndex)) != -1) { sTemp = aName.copy(++nOldIndex, nIndex - nOldIndex); if (aRecent[aName]->hasByName(sTemp) ) return sal_True; else aRecent.erase(aName); } nOldIndex=0; while ((nIndex = aName.indexOf('/', nOldIndex)) != -1) { sTemp = aName.copy (nOldIndex, nIndex - nOldIndex); Reference < XUnoTunnel > xChildRef; if (nIndex == nOldIndex) break; if (xCurrent->hasByName(sTemp)) { aAny = xCurrent->getByName(sTemp); aAny >>= xChildRef; xCurrent = Reference < XNameContainer > (xChildRef, UNO_QUERY); } else return sal_False; nOldIndex = nIndex+1; } OUString sStreamName = aName.copy( nOldIndex, aName.getLength() - nOldIndex); if (xCurrent->hasByName(sStreamName)) { aRecent[aName] = xCurrent; return sal_True; } return sal_False; } } // XSingleServiceFactory Reference< XInterface > SAL_CALL ZipPackage::createInstance( ) throw(Exception, RuntimeException) { Reference < XInterface > xRef = *(new ZipPackageStream ( pZipFile )); return xRef; } Reference< XInterface > SAL_CALL ZipPackage::createInstanceWithArguments( const Sequence< Any >& aArguments ) throw(Exception, RuntimeException) { sal_Bool bArg; Reference < XInterface > xRef; aArguments[0] >>= bArg; if (bArg) xRef = *new ZipPackageFolder ( ); else xRef = *new ZipPackageStream ( pZipFile ); return xRef; } // XChangesBatch void SAL_CALL ZipPackage::commitChanges( ) throw(WrappedTargetException, RuntimeException) { std::vector < Sequence < PropertyValue > > aManList; // Set up output buffer. ZipPackageBuffer implements both // XInputStream and XOutputStream as the UCB requires an XInputStream // and the ZipOutputStream writes to an XOutputStream ZipPackageBuffer *pZipBuffer = new ZipPackageBuffer( 65535 ); Reference < XOutputStream > xOutStream (pZipBuffer); ZipOutputStream *pZipOut = new ZipOutputStream( xOutStream, 65535 ); // Make a reference to the manifest output stream so it persists // until the call to ZipOutputStream->finish() Reference < XOutputStream > xManOutStream; ZipPackageStream *pManifestStream = NULL; Reference < XZipOutputStream > xZipOut (pZipOut); pZipOut->setMethod(DEFLATED); pZipOut->setLevel(DEFAULT_COMPRESSION); // Remove the old META-INF directory as this will be re-generated below. // Pass save-contents a vector which will be used to store the entries which // are placed inside the Manifest et al. Note: saveContents is called // recursively. const OUString sMeta ( RTL_CONSTASCII_USTRINGPARAM ( "META-INF" ) ); const OUString sMediaType ( RTL_CONSTASCII_USTRINGPARAM ( "MediaType" ) ); const OUString sFullPath ( RTL_CONSTASCII_USTRINGPARAM ( "FullPath" ) ); if (xRootFolder->hasByName( sMeta ) ) xRootFolder->removeByName( sMeta ); Sequence < PropertyValue > aPropSeq ( 2 ); aPropSeq [0].Name = sMediaType; aPropSeq [0].Value <<= pRootFolder->getPropertyValue( sMediaType ) ; aPropSeq [1].Name = sFullPath; aPropSeq [1].Value <<= OUString ( RTL_CONSTASCII_USTRINGPARAM ( "/" ) ); aManList.push_back( aPropSeq ); pRootFolder->saveContents(OUString(), aManList, *pZipOut); OUString sManifestWriter( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.packages.manifest.ManifestWriter" ) ); Reference < XManifestWriter > xWriter (xFactory->createInstance( sManifestWriter ), UNO_QUERY ); if ( xWriter.is() ) { ZipEntry * pEntry = new ZipEntry; ZipPackageBuffer *pBuffer = new ZipPackageBuffer(65535); xManOutStream = Reference < XOutputStream > (*pBuffer, UNO_QUERY); pEntry->sName = OUString( RTL_CONSTASCII_USTRINGPARAM ( "META-INF/manifest.xml") ); pEntry->nMethod = STORED; Sequence < Sequence < PropertyValue > > aManifestSequence ( aManList.size()); Sequence < PropertyValue > * pSequence = aManifestSequence.getArray(); for (vector < Sequence < PropertyValue > >::const_iterator aIter = aManList.begin(), aEnd = aManList.end(); aIter != aEnd; aIter++, pSequence++) *pSequence= (*aIter); xWriter->writeManifestSequence ( xManOutStream, aManifestSequence ); pEntry->nSize = pEntry->nCompressedSize = static_cast < sal_Int32 > (pBuffer->getPosition()); pBuffer->aBuffer.realloc(pEntry->nSize); CRC32 aCRC; aCRC.update(pBuffer->aBuffer); pEntry->nCrc = aCRC.getValue(); try { pZipOut->putNextEntry(*pEntry); pZipOut->write(pBuffer->aBuffer, 0, pEntry->nSize); pZipOut->closeEntry(); } catch (::com::sun::star::io::IOException & ) { VOS_ENSURE( 0, "Error adding META-INF/manifest.xml to the ZipOutputStream" ); } } try { pZipOut->finish(); } catch (::com::sun::star::io::IOException & ) { VOS_ENSURE( 0, "Error writing ZIP file to disk" ); } xContentStream = Reference < XInputStream > (pZipBuffer); xContentSeek = Reference < XSeekable > (pZipBuffer); pZipFile->setInputStream ( xContentStream ); pZipBuffer->seek(0); try { pContent->writeStream( Reference < XInputStream > (pZipBuffer), sal_True ); } catch (::com::sun::star::ucb::CommandAbortedException&) { VOS_ENSURE( 0, "Unable to write Zip File to disk!"); } } sal_Bool SAL_CALL ZipPackage::hasPendingChanges( ) throw(RuntimeException) { return sal_False; } Sequence< ElementChange > SAL_CALL ZipPackage::getPendingChanges( ) throw(RuntimeException) { return Sequence < ElementChange > ( NULL, 0 ); } /** * Function to create a new component instance; is needed by factory helper implementation. * @param xMgr service manager to if the components needs other component instances */ Reference < XInterface >SAL_CALL ZipPackage_createInstance( const Reference< XMultiServiceFactory > & xMgr ) { return Reference< XInterface >( *new ZipPackage(xMgr) ); } OUString ZipPackage::getImplementationName() { #if SUPD>625 return OUString( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.packages.comp.ZipPackage" ) ); #else return OUString( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.package.Package" ) ); #endif } Sequence< OUString > ZipPackage::getSupportedServiceNames() { Sequence< OUString > aNames(1); #if SUPD>625 aNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.packages.comp.ZipPackage" ) ); #else aNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.package.Package" ) ); #endif return aNames; } sal_Bool SAL_CALL ZipPackage::supportsService( OUString const & rServiceName ) throw (RuntimeException) { return rServiceName == getSupportedServiceNames()[0]; } Reference < XSingleServiceFactory > ZipPackage::createServiceFactory( Reference < XMultiServiceFactory > const & rServiceFactory ) { return cppu::createSingleFactory (rServiceFactory, getImplementationName(), ZipPackage_createInstance, getSupportedServiceNames()); } //XInterface Any SAL_CALL ZipPackage::queryInterface( const Type& rType ) throw(RuntimeException) { return ::cppu::queryInterface ( rType , // OWeakObject interfaces reinterpret_cast< XInterface* > ( this ) , static_cast< XWeak* > ( this ) , // my own interfaces static_cast< XInitialization* > ( this ) , static_cast< XSingleServiceFactory* > ( this ) , static_cast< XUnoTunnel* > ( this ) , static_cast< XHierarchicalNameAccess* > ( this ) , static_cast< XChangesBatch* > ( this ) ); } void SAL_CALL ZipPackage::acquire( ) throw() { OWeakObject::acquire(); } void SAL_CALL ZipPackage::release( ) throw() { OWeakObject::release(); } // XUnoTunnel Sequence< sal_Int8 > ZipPackage::getUnoTunnelImplementationId( void ) throw (RuntimeException) { static ::cppu::OImplementationId * pId = 0; if (! pId) { ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ); if (! pId) { static ::cppu::OImplementationId aId; pId = &aId; } } return pId->getImplementationId(); } sal_Int64 SAL_CALL ZipPackage::getSomething( const Sequence< sal_Int8 >& aIdentifier ) throw(RuntimeException) { if (aIdentifier.getLength() == 16 && 0 == rtl_compareMemory(getUnoTunnelImplementationId().getConstArray(), aIdentifier.getConstArray(), 16 ) ) return reinterpret_cast < sal_Int64 > ( this ); return 0; }