406 lines
12 KiB
C++
406 lines
12 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <ZipOutputEntry.hxx>
|
|
|
|
#include <com/sun/star/io/TempFile.hpp>
|
|
#include <com/sun/star/packages/zip/ZipConstants.hpp>
|
|
#include <com/sun/star/xml/crypto/CipherID.hpp>
|
|
|
|
#include <osl/diagnose.h>
|
|
|
|
#include <PackageConstants.hxx>
|
|
#include <ThreadedDeflater.hxx>
|
|
#include <ZipEntry.hxx>
|
|
#include <ZipFile.hxx>
|
|
#include <ZipPackageStream.hxx>
|
|
|
|
#include <algorithm>
|
|
#include <utility>
|
|
|
|
using namespace com::sun::star;
|
|
using namespace com::sun::star::io;
|
|
using namespace com::sun::star::uno;
|
|
using namespace com::sun::star::packages::zip::ZipConstants;
|
|
|
|
/** This class is used to deflate Zip entries
|
|
*/
|
|
ZipOutputEntryBase::ZipOutputEntryBase(
|
|
css::uno::Reference< css::io::XOutputStream > xOutput,
|
|
uno::Reference< uno::XComponentContext > xContext,
|
|
ZipEntry* pEntry,
|
|
ZipPackageStream* pStream,
|
|
bool bEncrypt,
|
|
bool checkStream)
|
|
: m_xContext(std::move(xContext))
|
|
, m_xOutStream(std::move(xOutput))
|
|
, m_pCurrentEntry(pEntry)
|
|
, m_nDigested(0)
|
|
, m_pCurrentStream(pStream)
|
|
, m_bEncryptCurrentEntry(bEncrypt)
|
|
{
|
|
assert(pEntry);
|
|
assert(m_pCurrentEntry->nMethod == DEFLATED && "Use ZipPackageStream::rawWrite() for STORED entries");
|
|
(void)checkStream;
|
|
assert(!checkStream || m_xOutStream.is());
|
|
if (m_bEncryptCurrentEntry)
|
|
{
|
|
m_xCipherContext = ZipFile::StaticGetCipher( m_xContext, pStream->GetEncryptionData(), true );
|
|
if (pStream->GetEncryptionData()->m_oCheckAlg)
|
|
{
|
|
assert(pStream->GetEncryptionData()->m_nEncAlg != xml::crypto::CipherID::AES_GCM_W3C);
|
|
m_xDigestContext = ZipFile::StaticGetDigestContextForChecksum(m_xContext, pStream->GetEncryptionData());
|
|
}
|
|
}
|
|
}
|
|
|
|
void ZipOutputEntryBase::closeEntry()
|
|
{
|
|
finishDeflater();
|
|
|
|
if ((m_pCurrentEntry->nFlag & 8) == 0)
|
|
{
|
|
if (m_pCurrentEntry->nSize != getDeflaterTotalIn())
|
|
{
|
|
OSL_FAIL("Invalid entry size");
|
|
}
|
|
if (m_pCurrentEntry->nCompressedSize != getDeflaterTotalOut())
|
|
{
|
|
// Different compression strategies make the merit of this
|
|
// test somewhat dubious
|
|
m_pCurrentEntry->nCompressedSize = getDeflaterTotalOut();
|
|
}
|
|
if (m_pCurrentEntry->nCrc != m_aCRC.getValue())
|
|
{
|
|
OSL_FAIL("Invalid entry CRC-32");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !m_bEncryptCurrentEntry )
|
|
{
|
|
m_pCurrentEntry->nSize = getDeflaterTotalIn();
|
|
m_pCurrentEntry->nCompressedSize = getDeflaterTotalOut();
|
|
}
|
|
m_pCurrentEntry->nCrc = m_aCRC.getValue();
|
|
}
|
|
deflaterReset();
|
|
m_aCRC.reset();
|
|
|
|
if (!m_bEncryptCurrentEntry)
|
|
return;
|
|
|
|
m_xCipherContext.clear();
|
|
|
|
uno::Sequence< sal_Int8 > aDigestSeq;
|
|
if ( m_xDigestContext.is() )
|
|
{
|
|
aDigestSeq = m_xDigestContext->finalizeDigestAndDispose();
|
|
m_xDigestContext.clear();
|
|
}
|
|
|
|
if ( m_pCurrentStream )
|
|
m_pCurrentStream->setDigest( aDigestSeq );
|
|
}
|
|
|
|
void ZipOutputEntryBase::processDeflated( const uno::Sequence< sal_Int8 >& deflateBuffer, sal_Int32 nLength )
|
|
{
|
|
if ( nLength > 0 )
|
|
{
|
|
uno::Sequence< sal_Int8 > aTmpBuffer( deflateBuffer.getConstArray(), nLength );
|
|
if (m_bEncryptCurrentEntry && m_xCipherContext.is())
|
|
{
|
|
// Need to update our digest before encryption...
|
|
sal_Int32 nDiff = n_ConstDigestLength - m_nDigested;
|
|
if (m_xDigestContext.is() && nDiff)
|
|
{
|
|
sal_Int32 nEat = ::std::min( nLength, nDiff );
|
|
uno::Sequence< sal_Int8 > aTmpSeq( aTmpBuffer.getConstArray(), nEat );
|
|
m_xDigestContext->updateDigest( aTmpSeq );
|
|
m_nDigested = m_nDigested + static_cast< sal_Int16 >( nEat );
|
|
}
|
|
|
|
// FIXME64: uno::Sequence not 64bit safe.
|
|
uno::Sequence< sal_Int8 > aEncryptionBuffer = m_xCipherContext->convertWithCipherContext( aTmpBuffer );
|
|
|
|
m_xOutStream->writeBytes( aEncryptionBuffer );
|
|
|
|
// the sizes as well as checksum for encrypted streams is calculated here
|
|
m_pCurrentEntry->nCompressedSize += aEncryptionBuffer.getLength();
|
|
m_pCurrentEntry->nSize = m_pCurrentEntry->nCompressedSize;
|
|
m_aCRC.update( aEncryptionBuffer );
|
|
}
|
|
else
|
|
{
|
|
m_xOutStream->writeBytes ( aTmpBuffer );
|
|
}
|
|
}
|
|
|
|
if (!(isDeflaterFinished() && m_bEncryptCurrentEntry && m_xCipherContext.is()))
|
|
return;
|
|
|
|
// FIXME64: sequence not 64bit safe.
|
|
uno::Sequence< sal_Int8 > aEncryptionBuffer = m_xCipherContext->finalizeCipherContextAndDispose();
|
|
if ( aEncryptionBuffer.hasElements() )
|
|
{
|
|
m_xOutStream->writeBytes( aEncryptionBuffer );
|
|
|
|
// the sizes as well as checksum for encrypted streams are calculated here
|
|
m_pCurrentEntry->nCompressedSize += aEncryptionBuffer.getLength();
|
|
m_pCurrentEntry->nSize = m_pCurrentEntry->nCompressedSize;
|
|
m_aCRC.update( aEncryptionBuffer );
|
|
}
|
|
}
|
|
|
|
void ZipOutputEntryBase::processInput( const uno::Sequence< sal_Int8 >& rBuffer )
|
|
{
|
|
if (!m_bEncryptCurrentEntry)
|
|
m_aCRC.updateSegment(rBuffer, rBuffer.getLength());
|
|
}
|
|
|
|
ZipOutputEntry::ZipOutputEntry(
|
|
const css::uno::Reference< css::io::XOutputStream >& rxOutput,
|
|
const uno::Reference< uno::XComponentContext >& rxContext,
|
|
ZipEntry* pEntry,
|
|
ZipPackageStream* pStream,
|
|
bool bEncrypt,
|
|
bool checkStream)
|
|
: ZipOutputEntryBase(rxOutput, rxContext, pEntry, pStream, bEncrypt, checkStream)
|
|
, m_aDeflateBuffer(n_ConstBufferSize)
|
|
, m_aDeflater(DEFAULT_COMPRESSION, true)
|
|
{
|
|
}
|
|
|
|
ZipOutputEntry::ZipOutputEntry(
|
|
const css::uno::Reference< css::io::XOutputStream >& rxOutput,
|
|
const uno::Reference< uno::XComponentContext >& rxContext,
|
|
ZipEntry* pEntry,
|
|
ZipPackageStream* pStream,
|
|
bool bEncrypt)
|
|
: ZipOutputEntry( rxOutput, rxContext, pEntry, pStream, bEncrypt, true)
|
|
{
|
|
}
|
|
|
|
void ZipOutputEntry::write( const Sequence< sal_Int8 >& rBuffer )
|
|
{
|
|
if (!m_aDeflater.finished())
|
|
{
|
|
m_aDeflater.setInputSegment(rBuffer);
|
|
while (!m_aDeflater.needsInput())
|
|
doDeflate();
|
|
processInput(rBuffer);
|
|
}
|
|
}
|
|
|
|
void ZipOutputEntry::doDeflate()
|
|
{
|
|
sal_Int32 nLength = m_aDeflater.doDeflateSegment(m_aDeflateBuffer, m_aDeflateBuffer.getLength());
|
|
processDeflated( m_aDeflateBuffer, nLength );
|
|
}
|
|
|
|
void ZipOutputEntry::finishDeflater()
|
|
{
|
|
m_aDeflater.finish();
|
|
while (!m_aDeflater.finished())
|
|
doDeflate();
|
|
}
|
|
|
|
sal_Int64 ZipOutputEntry::getDeflaterTotalIn() const
|
|
{
|
|
return m_aDeflater.getTotalIn();
|
|
}
|
|
|
|
sal_Int64 ZipOutputEntry::getDeflaterTotalOut() const
|
|
{
|
|
return m_aDeflater.getTotalOut();
|
|
}
|
|
|
|
void ZipOutputEntry::deflaterReset()
|
|
{
|
|
m_aDeflater.reset();
|
|
}
|
|
|
|
bool ZipOutputEntry::isDeflaterFinished() const
|
|
{
|
|
return m_aDeflater.finished();
|
|
}
|
|
|
|
|
|
ZipOutputEntryInThread::ZipOutputEntryInThread(
|
|
const uno::Reference< uno::XComponentContext >& rxContext,
|
|
std::unique_ptr<ZipEntry>&& pEntry,
|
|
ZipPackageStream* pStream,
|
|
bool bEncrypt)
|
|
: ZipOutputEntry( uno::Reference< css::io::XOutputStream >(), rxContext, pEntry.get(), pStream, bEncrypt, false )
|
|
, m_pOwnedZipEntry(std::move(pEntry))
|
|
, m_bFinished(false)
|
|
{
|
|
}
|
|
|
|
void ZipOutputEntryInThread::createBufferFile()
|
|
{
|
|
assert(!m_xOutStream && !m_xTempFile &&
|
|
"should only be called in the threaded mode where there is no existing stream yet");
|
|
m_xTempFile = new utl::TempFileFastService;
|
|
m_xOutStream = m_xTempFile->getOutputStream();
|
|
}
|
|
|
|
void ZipOutputEntryInThread::closeBufferFile()
|
|
{
|
|
m_xOutStream->closeOutput();
|
|
m_xOutStream.clear();
|
|
}
|
|
|
|
void ZipOutputEntryInThread::deleteBufferFile()
|
|
{
|
|
assert(!m_xOutStream.is() && m_xTempFile);
|
|
m_xTempFile.clear();
|
|
}
|
|
|
|
uno::Reference< io::XInputStream > ZipOutputEntryInThread::getData() const
|
|
{
|
|
return m_xTempFile->getInputStream();
|
|
}
|
|
|
|
class ZipOutputEntryInThread::Task : public comphelper::ThreadTask
|
|
{
|
|
ZipOutputEntryInThread *mpEntry;
|
|
uno::Reference< io::XInputStream > mxInStream;
|
|
|
|
public:
|
|
Task( const std::shared_ptr<comphelper::ThreadTaskTag>& pTag, ZipOutputEntryInThread *pEntry,
|
|
uno::Reference< io::XInputStream > xInStream )
|
|
: comphelper::ThreadTask(pTag)
|
|
, mpEntry(pEntry)
|
|
, mxInStream(std::move(xInStream))
|
|
{}
|
|
|
|
private:
|
|
virtual void doWork() override
|
|
{
|
|
try
|
|
{
|
|
mpEntry->createBufferFile();
|
|
mpEntry->writeStream(mxInStream);
|
|
mxInStream.clear();
|
|
mpEntry->closeBufferFile();
|
|
mpEntry->setFinished();
|
|
}
|
|
catch (...)
|
|
{
|
|
mpEntry->setParallelDeflateException(std::current_exception());
|
|
try
|
|
{
|
|
if (mpEntry->m_xOutStream.is())
|
|
mpEntry->closeBufferFile();
|
|
if (mpEntry->m_xTempFile)
|
|
mpEntry->deleteBufferFile();
|
|
}
|
|
catch (uno::Exception const&)
|
|
{
|
|
}
|
|
mpEntry->setFinished();
|
|
}
|
|
}
|
|
};
|
|
|
|
std::unique_ptr<comphelper::ThreadTask> ZipOutputEntryInThread::createTask(
|
|
const std::shared_ptr<comphelper::ThreadTaskTag>& pTag,
|
|
const uno::Reference< io::XInputStream >& xInStream )
|
|
{
|
|
return std::make_unique<Task>(pTag, this, xInStream);
|
|
}
|
|
|
|
void ZipOutputEntry::writeStream(const uno::Reference< io::XInputStream >& xInStream)
|
|
{
|
|
sal_Int32 nLength = 0;
|
|
uno::Sequence< sal_Int8 > aSeq(n_ConstBufferSize);
|
|
do
|
|
{
|
|
nLength = xInStream->readBytes(aSeq, n_ConstBufferSize);
|
|
if (nLength != n_ConstBufferSize)
|
|
aSeq.realloc(nLength);
|
|
|
|
write(aSeq);
|
|
}
|
|
while (nLength == n_ConstBufferSize);
|
|
closeEntry();
|
|
}
|
|
|
|
|
|
ZipOutputEntryParallel::ZipOutputEntryParallel(
|
|
const css::uno::Reference< css::io::XOutputStream >& rxOutput,
|
|
const uno::Reference< uno::XComponentContext >& rxContext,
|
|
ZipEntry* pEntry,
|
|
ZipPackageStream* pStream,
|
|
bool bEncrypt)
|
|
: ZipOutputEntryBase(rxOutput, rxContext, pEntry, pStream, bEncrypt, true)
|
|
, totalIn(0)
|
|
, totalOut(0)
|
|
, finished(false)
|
|
{
|
|
}
|
|
|
|
void ZipOutputEntryParallel::writeStream(const uno::Reference< io::XInputStream >& xInStream)
|
|
{
|
|
ZipUtils::ThreadedDeflater deflater( DEFAULT_COMPRESSION );
|
|
deflater.deflateWrite(xInStream,
|
|
[this](const uno::Sequence< sal_Int8 >& rBuffer, sal_Int32 nLen) {
|
|
if (!m_bEncryptCurrentEntry)
|
|
m_aCRC.updateSegment(rBuffer, nLen);
|
|
},
|
|
[this](const uno::Sequence< sal_Int8 >& rBuffer, sal_Int32 nLen) {
|
|
processDeflated(rBuffer, nLen);
|
|
}
|
|
);
|
|
finished = true;
|
|
processDeflated( uno::Sequence< sal_Int8 >(), 0 ); // finish encrypting, etc.
|
|
totalIn = deflater.getTotalIn();
|
|
totalOut = deflater.getTotalOut();
|
|
closeEntry();
|
|
}
|
|
|
|
void ZipOutputEntryParallel::finishDeflater()
|
|
{
|
|
// ThreadedDeflater is called synchronously in one call, so nothing to do here.
|
|
}
|
|
|
|
sal_Int64 ZipOutputEntryParallel::getDeflaterTotalIn() const
|
|
{
|
|
return totalIn;
|
|
}
|
|
|
|
sal_Int64 ZipOutputEntryParallel::getDeflaterTotalOut() const
|
|
{
|
|
return totalOut;
|
|
}
|
|
|
|
void ZipOutputEntryParallel::deflaterReset()
|
|
{
|
|
totalIn = 0;
|
|
totalOut = 0;
|
|
finished = false;
|
|
}
|
|
|
|
bool ZipOutputEntryParallel::isDeflaterFinished() const
|
|
{
|
|
return finished;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|