package/source/zipapi/ZipOutputEntry.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 <ZipOutputEntry.hxx>
  21
  22 #include <com/sun/star/io/TempFile.hpp>
  23 #include <com/sun/star/packages/zip/ZipConstants.hpp>
  24 #include <com/sun/star/xml/crypto/CipherID.hpp>
  25
  26 #include <osl/diagnose.h>
  27
  28 #include <PackageConstants.hxx>
  29 #include <ThreadedDeflater.hxx>
  30 #include <ZipEntry.hxx>
  31 #include <ZipFile.hxx>
  32 #include <ZipPackageStream.hxx>
  33
  34 #include <algorithm>
  35 #include <utility>
  36
  37 using namespace com::sun::star;
  38 using namespace com::sun::star::io;
  39 using namespace com::sun::star::uno;
  40 using namespace com::sun::star::packages::zip::ZipConstants;
  41
  42 /** This class is used to deflate Zip entries
  43  */
  44 ZipOutputEntryBase::ZipOutputEntryBase(
  45         css::uno::Reference< css::io::XOutputStream > xOutput,
  46         uno::Reference< uno::XComponentContext > xContext,
  47         ZipEntry* pEntry,
  48         ZipPackageStream* pStream,
  49         bool bEncrypt,
  50         bool checkStream)
  51 : m_xContext(std::move(xContext))
  52 , m_xOutStream(std::move(xOutput))
  53 , m_pCurrentEntry(pEntry)
  54 , m_nDigested(0)
  55 , m_pCurrentStream(pStream)
  56 , m_bEncryptCurrentEntry(bEncrypt)
  57 {
  58     assert(pEntry);
  59     assert(m_pCurrentEntry->nMethod == DEFLATED && "Use ZipPackageStream::rawWrite() for STORED entries");
  60     (void)checkStream;
  61     assert(!checkStream || m_xOutStream.is());
  62     if (m_bEncryptCurrentEntry)
  63     {
  64         m_xCipherContext = ZipFile::StaticGetCipher( m_xContext, pStream->GetEncryptionData(), true );
  65         if (pStream->GetEncryptionData()->m_oCheckAlg)
  66         {
  67             assert(pStream->GetEncryptionData()->m_nEncAlg != xml::crypto::CipherID::AES_GCM_W3C);
  68             m_xDigestContext = ZipFile::StaticGetDigestContextForChecksum(m_xContext, pStream->GetEncryptionData());
  69         }
  70     }
  71 }
  72
  73 void ZipOutputEntryBase::closeEntry()
  74 {
  75     finishDeflater();
  76
  77     if ((m_pCurrentEntry->nFlag & 8) == 0)
  78     {
  79         if (m_pCurrentEntry->nSize != getDeflaterTotalIn())
  80         {
  81             OSL_FAIL("Invalid entry size");
  82         }
  83         if (m_pCurrentEntry->nCompressedSize != getDeflaterTotalOut())
  84         {
  85             // Different compression strategies make the merit of this
  86             // test somewhat dubious
  87             m_pCurrentEntry->nCompressedSize = getDeflaterTotalOut();
  88         }
  89         if (m_pCurrentEntry->nCrc != m_aCRC.getValue())
  90         {
  91             OSL_FAIL("Invalid entry CRC-32");
  92         }
  93     }
  94     else
  95     {
  96         if ( !m_bEncryptCurrentEntry )
  97         {
  98             m_pCurrentEntry->nSize = getDeflaterTotalIn();
  99             m_pCurrentEntry->nCompressedSize = getDeflaterTotalOut();
 100         }
 101         m_pCurrentEntry->nCrc = m_aCRC.getValue();
 102     }
 103     deflaterReset();
 104     m_aCRC.reset();
 105
 106     if (!m_bEncryptCurrentEntry)
 107         return;
 108
 109     m_xCipherContext.clear();
 110
 111     uno::Sequence< sal_Int8 > aDigestSeq;
 112     if ( m_xDigestContext.is() )
 113     {
 114         aDigestSeq = m_xDigestContext->finalizeDigestAndDispose();
 115         m_xDigestContext.clear();
 116     }
 117
 118     if ( m_pCurrentStream )
 119         m_pCurrentStream->setDigest( aDigestSeq );
 120 }
 121
 122 void ZipOutputEntryBase::processDeflated( const uno::Sequence< sal_Int8 >& deflateBuffer, sal_Int32 nLength )
 123 {
 124     if ( nLength > 0 )
 125     {
 126         uno::Sequence< sal_Int8 > aTmpBuffer( deflateBuffer.getConstArray(), nLength );
 127         if (m_bEncryptCurrentEntry && m_xCipherContext.is())
 128         {
 129             // Need to update our digest before encryption...
 130             sal_Int32 nDiff = n_ConstDigestLength - m_nDigested;
 131             if (m_xDigestContext.is() && nDiff)
 132             {
 133                 sal_Int32 nEat = ::std::min( nLength, nDiff );
 134                 uno::Sequence< sal_Int8 > aTmpSeq( aTmpBuffer.getConstArray(), nEat );
 135                 m_xDigestContext->updateDigest( aTmpSeq );
 136                 m_nDigested = m_nDigested + static_cast< sal_Int16 >( nEat );
 137             }
 138
 139             // FIXME64: uno::Sequence not 64bit safe.
 140             uno::Sequence< sal_Int8 > aEncryptionBuffer = m_xCipherContext->convertWithCipherContext( aTmpBuffer );
 141
 142             m_xOutStream->writeBytes( aEncryptionBuffer );
 143
 144             // the sizes as well as checksum for encrypted streams is calculated here
 145             m_pCurrentEntry->nCompressedSize += aEncryptionBuffer.getLength();
 146             m_pCurrentEntry->nSize = m_pCurrentEntry->nCompressedSize;
 147             m_aCRC.update( aEncryptionBuffer );
 148         }
 149         else
 150         {
 151             m_xOutStream->writeBytes ( aTmpBuffer );
 152         }
 153     }
 154
 155     if (!(isDeflaterFinished() && m_bEncryptCurrentEntry && m_xCipherContext.is()))
 156         return;
 157
 158     // FIXME64: sequence not 64bit safe.
 159     uno::Sequence< sal_Int8 > aEncryptionBuffer = m_xCipherContext->finalizeCipherContextAndDispose();
 160     if ( aEncryptionBuffer.hasElements() )
 161     {
 162         m_xOutStream->writeBytes( aEncryptionBuffer );
 163
 164         // the sizes as well as checksum for encrypted streams are calculated here
 165         m_pCurrentEntry->nCompressedSize += aEncryptionBuffer.getLength();
 166         m_pCurrentEntry->nSize = m_pCurrentEntry->nCompressedSize;
 167         m_aCRC.update( aEncryptionBuffer );
 168     }
 169 }
 170
 171 void ZipOutputEntryBase::processInput( const uno::Sequence< sal_Int8 >& rBuffer )
 172 {
 173     if (!m_bEncryptCurrentEntry)
 174         m_aCRC.updateSegment(rBuffer, rBuffer.getLength());
 175 }
 176
 177 ZipOutputEntry::ZipOutputEntry(
 178         const css::uno::Reference< css::io::XOutputStream >& rxOutput,
 179         const uno::Reference< uno::XComponentContext >& rxContext,
 180         ZipEntry* pEntry,
 181         ZipPackageStream* pStream,
 182         bool bEncrypt,
 183         bool checkStream)
 184 : ZipOutputEntryBase(rxOutput, rxContext, pEntry, pStream, bEncrypt, checkStream)
 185 , m_aDeflateBuffer(n_ConstBufferSize)
 186 , m_aDeflater(DEFAULT_COMPRESSION, true)
 187 {
 188 }
 189
 190 ZipOutputEntry::ZipOutputEntry(
 191         const css::uno::Reference< css::io::XOutputStream >& rxOutput,
 192         const uno::Reference< uno::XComponentContext >& rxContext,
 193         ZipEntry* pEntry,
 194         ZipPackageStream* pStream,
 195         bool bEncrypt)
 196 : ZipOutputEntry( rxOutput, rxContext, pEntry, pStream, bEncrypt, true)
 197 {
 198 }
 199
 200 void ZipOutputEntry::write( const Sequence< sal_Int8 >& rBuffer )
 201 {
 202     if (!m_aDeflater.finished())
 203     {
 204         m_aDeflater.setInputSegment(rBuffer);
 205         while (!m_aDeflater.needsInput())
 206             doDeflate();
 207         processInput(rBuffer);
 208     }
 209 }
 210
 211 void ZipOutputEntry::doDeflate()
 212 {
 213     sal_Int32 nLength = m_aDeflater.doDeflateSegment(m_aDeflateBuffer, m_aDeflateBuffer.getLength());
 214     processDeflated( m_aDeflateBuffer, nLength );
 215 }
 216
 217 void ZipOutputEntry::finishDeflater()
 218 {
 219     m_aDeflater.finish();
 220     while (!m_aDeflater.finished())
 221         doDeflate();
 222 }
 223
 224 sal_Int64 ZipOutputEntry::getDeflaterTotalIn() const
 225 {
 226     return m_aDeflater.getTotalIn();
 227 }
 228
 229 sal_Int64 ZipOutputEntry::getDeflaterTotalOut() const
 230 {
 231     return m_aDeflater.getTotalOut();
 232 }
 233
 234 void ZipOutputEntry::deflaterReset()
 235 {
 236     m_aDeflater.reset();
 237 }
 238
 239 bool ZipOutputEntry::isDeflaterFinished() const
 240 {
 241     return m_aDeflater.finished();
 242 }
 243
 244
 245 ZipOutputEntryInThread::ZipOutputEntryInThread(
 246         const uno::Reference< uno::XComponentContext >& rxContext,
 247         std::unique_ptr<ZipEntry>&& pEntry,
 248         ZipPackageStream* pStream,
 249         bool bEncrypt)
 250 : ZipOutputEntry( uno::Reference< css::io::XOutputStream >(), rxContext, pEntry.get(), pStream, bEncrypt, false )
 251 , m_pOwnedZipEntry(std::move(pEntry))
 252 , m_bFinished(false)
 253 {
 254 }
 255
 256 void ZipOutputEntryInThread::createBufferFile()
 257 {
 258     assert(!m_xOutStream && !m_xTempFile &&
 259            "should only be called in the threaded mode where there is no existing stream yet");
 260     m_xTempFile = new utl::TempFileFastService;
 261     m_xOutStream = m_xTempFile->getOutputStream();
 262 }
 263
 264 void ZipOutputEntryInThread::closeBufferFile()
 265 {
 266     m_xOutStream->closeOutput();
 267     m_xOutStream.clear();
 268 }
 269
 270 void ZipOutputEntryInThread::deleteBufferFile()
 271 {
 272     assert(!m_xOutStream.is() && m_xTempFile);
 273     m_xTempFile.clear();
 274 }
 275
 276 uno::Reference< io::XInputStream > ZipOutputEntryInThread::getData() const
 277 {
 278     return m_xTempFile->getInputStream();
 279 }
 280
 281 class ZipOutputEntryInThread::Task : public comphelper::ThreadTask
 282 {
 283     ZipOutputEntryInThread *mpEntry;
 284     uno::Reference< io::XInputStream > mxInStream;
 285
 286 public:
 287     Task( const std::shared_ptr<comphelper::ThreadTaskTag>& pTag, ZipOutputEntryInThread *pEntry,
 288           uno::Reference< io::XInputStream > xInStream )
 289         : comphelper::ThreadTask(pTag)
 290         , mpEntry(pEntry)
 291         , mxInStream(std::move(xInStream))
 292     {}
 293
 294 private:
 295     virtual void doWork() override
 296     {
 297         try
 298         {
 299             mpEntry->createBufferFile();
 300             mpEntry->writeStream(mxInStream);
 301             mxInStream.clear();
 302             mpEntry->closeBufferFile();
 303             mpEntry->setFinished();
 304         }
 305         catch (...)
 306         {
 307             mpEntry->setParallelDeflateException(std::current_exception());
 308             try
 309             {
 310                 if (mpEntry->m_xOutStream.is())
 311                     mpEntry->closeBufferFile();
 312                 if (mpEntry->m_xTempFile)
 313                     mpEntry->deleteBufferFile();
 314             }
 315             catch (uno::Exception const&)
 316             {
 317             }
 318             mpEntry->setFinished();
 319         }
 320     }
 321 };
 322
 323 std::unique_ptr<comphelper::ThreadTask> ZipOutputEntryInThread::createTask(
 324     const std::shared_ptr<comphelper::ThreadTaskTag>& pTag,
 325     const uno::Reference< io::XInputStream >& xInStream )
 326 {
 327     return std::make_unique<Task>(pTag, this, xInStream);
 328 }
 329
 330 void ZipOutputEntry::writeStream(const uno::Reference< io::XInputStream >& xInStream)
 331 {
 332     sal_Int32 nLength = 0;
 333     uno::Sequence< sal_Int8 > aSeq(n_ConstBufferSize);
 334     do
 335     {
 336         nLength = xInStream->readBytes(aSeq, n_ConstBufferSize);
 337         if (nLength != n_ConstBufferSize)
 338             aSeq.realloc(nLength);
 339
 340         write(aSeq);
 341     }
 342     while (nLength == n_ConstBufferSize);
 343     closeEntry();
 344 }
 345
 346
 347 ZipOutputEntryParallel::ZipOutputEntryParallel(
 348         const css::uno::Reference< css::io::XOutputStream >& rxOutput,
 349         const uno::Reference< uno::XComponentContext >& rxContext,
 350         ZipEntry* pEntry,
 351         ZipPackageStream* pStream,
 352         bool bEncrypt)
 353 : ZipOutputEntryBase(rxOutput, rxContext, pEntry, pStream, bEncrypt, true)
 354 , totalIn(0)
 355 , totalOut(0)
 356 , finished(false)
 357 {
 358 }
 359
 360 void ZipOutputEntryParallel::writeStream(const uno::Reference< io::XInputStream >& xInStream)
 361 {
 362     ZipUtils::ThreadedDeflater deflater( DEFAULT_COMPRESSION );
 363     deflater.deflateWrite(xInStream,
 364             [this](const uno::Sequence< sal_Int8 >& rBuffer, sal_Int32 nLen) {
 365                 if (!m_bEncryptCurrentEntry)
 366                     m_aCRC.updateSegment(rBuffer, nLen);
 367             },
 368             [this](const uno::Sequence< sal_Int8 >& rBuffer, sal_Int32 nLen) {
 369                 processDeflated(rBuffer, nLen);
 370             }
 371     );
 372     finished = true;
 373     processDeflated( uno::Sequence< sal_Int8 >(), 0 ); // finish encrypting, etc.
 374     totalIn = deflater.getTotalIn();
 375     totalOut = deflater.getTotalOut();
 376     closeEntry();
 377 }
 378
 379 void ZipOutputEntryParallel::finishDeflater()
 380 {
 381     // ThreadedDeflater is called synchronously in one call, so nothing to do here.
 382 }
 383
 384 sal_Int64 ZipOutputEntryParallel::getDeflaterTotalIn() const
 385 {
 386     return totalIn;
 387 }
 388
 389 sal_Int64 ZipOutputEntryParallel::getDeflaterTotalOut() const
 390 {
 391     return totalOut;
 392 }
 393
 394 void ZipOutputEntryParallel::deflaterReset()
 395 {
 396     totalIn = 0;
 397     totalOut = 0;
 398     finished = false;
 399 }
 400
 401 bool ZipOutputEntryParallel::isDeflaterFinished() const
 402 {
 403     return finished;
 404 }
 405
 406 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */