/* -*- 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 <algorithm>
#include <limits>
#include <set>
#include <string.h>
#include <com/sun/star/io/IOException.hpp>
#include <com/sun/star/io/XInputStream.hpp>
#include <com/sun/star/io/XOutputStream.hpp>
#include <com/sun/star/io/XSeekable.hpp>
#include <o3tl/safeint.hxx>
#include <osl/diagnose.h>
#include <svl/instrm.hxx>
#include <svl/outstrm.hxx>
#include <utility>
using namespace com::sun::star;
class SvDataPipe_Impl
{
public:
enum SeekResult { SEEK_BEFORE_MARKED, SEEK_OK, SEEK_PAST_END };
private:
struct Page
{
Page * m_pPrev;
Page * m_pNext;
sal_Int8 * m_pStart;
sal_Int8 * m_pRead;
sal_Int8 * m_pEnd;
sal_uInt32 m_nOffset;
sal_Int8 m_aBuffer[1];
};
static const sal_uInt32 m_nPageSize = 1000;
std::multiset< sal_uInt32 > m_aMarks;
Page * m_pFirstPage;
Page * m_pReadPage;
Page * m_pWritePage;
sal_Int8 * m_pReadBuffer;
sal_uInt32 m_nReadBufferSize;
sal_uInt32 m_nReadBufferFilled;
sal_uInt32 m_nPages;
bool m_bEOF;
void remove(Page * pPage);
public:
inline SvDataPipe_Impl();
~SvDataPipe_Impl();
inline void setReadBuffer(sal_Int8 * pBuffer, sal_uInt32 nSize);
sal_uInt32 read();
void clearReadBuffer() { m_pReadBuffer = nullptr; }
void write(sal_Int8
const * pBuffer, sal_uInt32 nSize);
void setEOF() { m_bEOF =
true; }
inline bool isEOF()
const;
SeekResult setReadPosition(sal_uInt32 nPosition);
};
SvDataPipe_Impl::SvDataPipe_Impl()
: m_pFirstPage( nullptr )
, m_pReadPage( nullptr )
, m_pWritePage( nullptr )
, m_pReadBuffer( nullptr )
, m_nReadBufferSize( 0 )
, m_nReadBufferFilled( 0 )
, m_nPages( 0 )
, m_bEOF(
false )
{}
inline void SvDataPipe_Impl::setReadBuffer(sal_Int8 * pBuffer,
sal_uInt32 nSize)
{
m_pReadBuffer = pBuffer;
m_nReadBufferSize = nSize;
m_nReadBufferFilled = 0;
}
inline bool SvDataPipe_Impl::isEOF()
const
{
return m_bEOF && m_pReadPage == m_pWritePage
&& (!m_pReadPage || m_pReadPage->m_pRead == m_pReadPage->m_pEnd);
}
// SvInputStream
bool SvInputStream::open()
{
if (GetError() != ERRCODE_NONE)
return false;
if (!(m_xSeekable.is() || m_pPipe))
{
if (!m_xStream.is())
{
SetError(ERRCODE_IO_INVALIDDEVICE);
return false;
}
m_xSeekable.set(m_xStream, uno::UNO_QUERY);
if (!m_xSeekable.is())
m_pPipe.reset(
new SvDataPipe_Impl );
}
return true;
}
// virtual
std::size_t SvInputStream::GetData(
void * pData, std::size_t
const nSize)
{
if (!open())
{
SetError(ERRCODE_IO_CANTREAD);
return 0;
}
// check if a truncated STREAM_SEEK_TO_END was passed
assert(m_nSeekedFrom != SAL_MAX_UINT32);
sal_uInt32 nRead = 0;
if (m_xSeekable.is())
{
if (m_nSeekedFrom != STREAM_SEEK_TO_END)
{
try
{
m_xSeekable->seek(m_nSeekedFrom);
}
catch (
const io::IOException&)
{
SetError(ERRCODE_IO_CANTREAD);
return 0;
}
m_nSeekedFrom = STREAM_SEEK_TO_END;
}
for (;;)
{
sal_Int32 nRemain
= sal_Int32(
std::min(std::size_t(nSize - nRead),
std::size_t(std::numeric_limits<sal_Int32>::max())));
if (nRemain == 0)
break;
uno::Sequence< sal_Int8 > aBuffer;
sal_Int32 nCount;
try
{
nCount = m_xStream->readBytes(aBuffer, nRemain);
}
catch (
const io::IOException&)
{
SetError(ERRCODE_IO_CANTREAD);
return nRead;
}
memcpy(
static_cast< sal_Int8 * >(pData) + nRead,
aBuffer.getConstArray(), sal_uInt32(nCount));
nRead += nCount;
if (nCount < nRemain)
break;
}
}
else
{
if (m_nSeekedFrom != STREAM_SEEK_TO_END)
{
SetError(ERRCODE_IO_CANTREAD);
return 0;
}
m_pPipe->setReadBuffer(
static_cast< sal_Int8 * >(pData), nSize);
nRead = m_pPipe->read();
if (nRead < nSize && !m_pPipe->isEOF())
for (;;)
{
sal_Int32 nRemain
= sal_Int32(
std::min(
std::size_t(nSize - nRead),
std::size_t(std::numeric_limits<sal_Int32>::max())));
if (nRemain == 0)
break;
uno::Sequence< sal_Int8 > aBuffer;
sal_Int32 nCount;
try
{
nCount = m_xStream->readBytes(aBuffer, nRemain);
}
catch (
const io::IOException&)
{
SetError(ERRCODE_IO_CANTREAD);
break;
}
m_pPipe->write(aBuffer.getConstArray(), sal_uInt32(nCount));
nRead += m_pPipe->read();
if (nCount < nRemain)
{
m_xStream->closeInput();
m_pPipe->setEOF();
break;
}
}
m_pPipe->clearReadBuffer();
}
return nRead;
}
// virtual
std::size_t SvInputStream::PutData(
void const *, std::size_t)
{
SetError(ERRCODE_IO_NOTSUPPORTED);
return 0;
}
// virtual
void SvInputStream::FlushData()
{}
// virtual
sal_uInt64 SvInputStream::SeekPos(sal_uInt64
const nPos)
{
// check if a truncated STREAM_SEEK_TO_END was passed
assert(nPos != SAL_MAX_UINT32);
if (open())
{
if (nPos == STREAM_SEEK_TO_END)
{
if (m_nSeekedFrom == STREAM_SEEK_TO_END)
{
if (m_xSeekable.is())
try
{
sal_Int64 nLength = m_xSeekable->getLength();
OSL_ASSERT(nLength >= 0);
if (o3tl::make_unsigned(nLength)
< STREAM_SEEK_TO_END)
{
m_nSeekedFrom = Tell();
return sal_uInt64(nLength);
}
}
catch (
const io::IOException&)
{
}
else
return Tell();
//@@@
}
else
return Tell();
}
else if (nPos == m_nSeekedFrom)
{
m_nSeekedFrom = STREAM_SEEK_TO_END;
return nPos;
}
else if (m_xSeekable.is())
{
try
{
m_xSeekable->seek(nPos);
m_nSeekedFrom = STREAM_SEEK_TO_END;
return nPos;
}
catch (
const io::IOException&)
{
}
}
else if (m_pPipe->setReadPosition(nPos) == SvDataPipe_Impl::SEEK_OK)
{
m_nSeekedFrom = STREAM_SEEK_TO_END;
return nPos;
}
else if ( nPos > Tell() )
{
// Read out the bytes
sal_Int32 nRead = nPos - Tell();
uno::Sequence< sal_Int8 > aBuffer;
m_xStream->readBytes( aBuffer, nRead );
return nPos;
}
else if ( nPos == Tell() )
return nPos;
}
SetError(ERRCODE_IO_CANTSEEK);
return Tell();
}
// virtual
void SvInputStream::SetSize(sal_uInt64)
{
SetError(ERRCODE_IO_NOTSUPPORTED);
}
SvInputStream::SvInputStream( css::uno::Reference< css::io::XInputStream > xTheStream)
:
m_xStream(std::move(xTheStream)),
m_nSeekedFrom(STREAM_SEEK_TO_END)
{
SetBufferSize(0);
}
// virtual
SvInputStream::~SvInputStream()
{
if (m_xStream.is())
{
try
{
m_xStream->closeInput();
}
catch (const io::IOException&)
{
}
}
}
// SvOutputStream
// virtual
std::size_t SvOutputStream::GetData(void *, std::size_t)
{
SetError(ERRCODE_IO_NOTSUPPORTED);
return 0;
}
// virtual
std::size_t SvOutputStream::PutData(void const * pData, std::size_t nSize)
{
if (!m_xStream.is())
{
SetError(ERRCODE_IO_CANTWRITE);
return 0;
}
std::size_t nWritten = 0;
for (;;)
{
sal_Int32 nRemain
= sal_Int32(
std::min(std::size_t(nSize - nWritten),
std::size_t(std::numeric_limits<sal_Int32>::max())));
if (nRemain == 0)
break;
try
{
m_xStream->writeBytes(uno::Sequence< sal_Int8 >(
static_cast<const sal_Int8 * >(pData)
+ nWritten,
nRemain));
}
catch (const io::IOException&)
{
SetError(ERRCODE_IO_CANTWRITE);
break;
}
nWritten += nRemain;
}
return nWritten;
}
// virtual
sal_uInt64 SvOutputStream::SeekPos(sal_uInt64)
{
SetError(ERRCODE_IO_NOTSUPPORTED);
return 0;
}
// virtual
void SvOutputStream::FlushData()
{
if (!m_xStream.is())
{
SetError(ERRCODE_IO_INVALIDDEVICE);
return;
}
try
{
m_xStream->flush();
}
catch (const io::IOException&)
{
}
}
// virtual
void SvOutputStream::SetSize(sal_uInt64)
{
SetError(ERRCODE_IO_NOTSUPPORTED);
}
SvOutputStream::SvOutputStream(uno::Reference< io::XOutputStream > xTheStream):
m_xStream(std::move(xTheStream))
{
SetBufferSize(0);
}
// virtual
SvOutputStream::~SvOutputStream()
{
if (m_xStream.is())
{
try
{
m_xStream->closeOutput();
}
catch (const io::IOException&)
{
}
}
}
// SvDataPipe_Impl
void SvDataPipe_Impl::remove(Page * pPage)
{
if (
pPage != m_pFirstPage ||
m_pReadPage == m_pFirstPage ||
(
!m_aMarks.empty() &&
*m_aMarks.begin() < m_pFirstPage->m_nOffset + m_nPageSize
)
)
{
return;
}
m_pFirstPage = m_pFirstPage->m_pNext;
if (m_nPages <= 100) // min pages
return;
pPage->m_pPrev->m_pNext = pPage->m_pNext;
pPage->m_pNext->m_pPrev = pPage->m_pPrev;
std::free(pPage);
--m_nPages;
}
SvDataPipe_Impl::~SvDataPipe_Impl()
{
if (m_pFirstPage != nullptr)
for (Page * pPage = m_pFirstPage;;)
{
Page * pNext = pPage->m_pNext;
std::free(pPage);
if (pNext == m_pFirstPage)
break;
pPage = pNext;
}
}
sal_uInt32 SvDataPipe_Impl::read()
{
if (m_pReadBuffer == nullptr || m_nReadBufferSize == 0 || m_pReadPage == nullptr)
return 0;
sal_uInt32 nSize = m_nReadBufferSize;
sal_uInt32 nRemain = m_nReadBufferSize - m_nReadBufferFilled;
m_pReadBuffer += m_nReadBufferFilled;
m_nReadBufferSize -= m_nReadBufferFilled;
m_nReadBufferFilled = 0;
while (nRemain > 0)
{
sal_uInt32 nBlock = std::min(sal_uInt32(m_pReadPage->m_pEnd
- m_pReadPage->m_pRead),
nRemain);
memcpy(m_pReadBuffer, m_pReadPage->m_pRead, nBlock);
m_pReadPage->m_pRead += nBlock;
m_pReadBuffer += nBlock;
m_nReadBufferSize -= nBlock;
m_nReadBufferFilled = 0;
nRemain -= nBlock;
if (m_pReadPage == m_pWritePage)
break;
if (m_pReadPage->m_pRead == m_pReadPage->m_pEnd)
{
Page * pRemove = m_pReadPage;
m_pReadPage = pRemove->m_pNext;
remove(pRemove);
}
}
return nSize - nRemain;
}
void SvDataPipe_Impl::write(sal_Int8 const * pBuffer, sal_uInt32 nSize)
{
if (nSize == 0)
return;
if (m_pWritePage == nullptr)
{
m_pFirstPage
= static_cast< Page * >(std::malloc(sizeof (Page)
+ m_nPageSize
- 1));
m_pFirstPage->m_pPrev = m_pFirstPage;
m_pFirstPage->m_pNext = m_pFirstPage;
m_pFirstPage->m_pStart = m_pFirstPage->m_aBuffer;
m_pFirstPage->m_pRead = m_pFirstPage->m_aBuffer;
m_pFirstPage->m_pEnd = m_pFirstPage->m_aBuffer;
m_pFirstPage->m_nOffset = 0;
m_pReadPage = m_pFirstPage;
m_pWritePage = m_pFirstPage;
++m_nPages;
}
sal_uInt32 nRemain = nSize;
if (m_pReadBuffer != nullptr && m_pReadPage == m_pWritePage
&& m_pReadPage->m_pRead == m_pWritePage->m_pEnd)
{
sal_uInt32 nBlock = std::min(nRemain,
sal_uInt32(m_nReadBufferSize
- m_nReadBufferFilled));
sal_uInt32 nPosition = m_pWritePage->m_nOffset
+ (m_pWritePage->m_pEnd
- m_pWritePage->m_aBuffer);
if (!m_aMarks.empty())
nBlock = *m_aMarks.begin() > nPosition ?
std::min(nBlock, sal_uInt32(*m_aMarks.begin()
- nPosition)) :
0;
if (nBlock > 0)
{
memcpy(m_pReadBuffer + m_nReadBufferFilled, pBuffer,
nBlock);
m_nReadBufferFilled += nBlock;
nRemain -= nBlock;
nPosition += nBlock;
m_pWritePage->m_nOffset = (nPosition / m_nPageSize) * m_nPageSize;
m_pWritePage->m_pStart = m_pWritePage->m_aBuffer
+ nPosition % m_nPageSize;
m_pWritePage->m_pRead = m_pWritePage->m_pStart;
m_pWritePage->m_pEnd = m_pWritePage->m_pStart;
}
}
if (nRemain <= 0)
return;
for (;;)
{
sal_uInt32 nBlock
= std::min(sal_uInt32(m_pWritePage->m_aBuffer + m_nPageSize
- m_pWritePage->m_pEnd),
nRemain);
memcpy(m_pWritePage->m_pEnd, pBuffer, nBlock);
m_pWritePage->m_pEnd += nBlock;
pBuffer += nBlock;
nRemain -= nBlock;
if (nRemain == 0)
break;
if (m_pWritePage->m_pNext == m_pFirstPage)
{
if (m_nPages == std::numeric_limits< sal_uInt32 >::max())
break;
Page * pNew
= static_cast< Page * >(std::malloc(
sizeof (Page) + m_nPageSize
- 1));
assert(pNew && "Don't handle OOM conditions");
pNew->m_pPrev = m_pWritePage;
pNew->m_pNext = m_pWritePage->m_pNext;
m_pWritePage->m_pNext->m_pPrev = pNew;
m_pWritePage->m_pNext = pNew;
++m_nPages;
}
m_pWritePage->m_pNext->m_nOffset = m_pWritePage->m_nOffset
+ m_nPageSize;
m_pWritePage = m_pWritePage->m_pNext;
m_pWritePage->m_pStart = m_pWritePage->m_aBuffer;
m_pWritePage->m_pRead = m_pWritePage->m_aBuffer;
m_pWritePage->m_pEnd = m_pWritePage->m_aBuffer;
}
}
SvDataPipe_Impl::SeekResult SvDataPipe_Impl::setReadPosition(sal_uInt32
nPosition)
{
if (m_pFirstPage == nullptr)
return nPosition == 0 ? SEEK_OK : SEEK_PAST_END;
if (nPosition
<= m_pReadPage->m_nOffset
+ (m_pReadPage->m_pRead - m_pReadPage->m_aBuffer))
{
if (nPosition
< m_pFirstPage->m_nOffset
+ (m_pFirstPage->m_pStart - m_pFirstPage->m_aBuffer))
return SEEK_BEFORE_MARKED;
while (nPosition < m_pReadPage->m_nOffset)
{
m_pReadPage->m_pRead = m_pReadPage->m_pStart;
m_pReadPage = m_pReadPage->m_pPrev;
}
}
else
{
if (nPosition
> m_pWritePage->m_nOffset
+ (m_pWritePage->m_pEnd - m_pWritePage->m_aBuffer))
return SEEK_PAST_END;
while (m_pReadPage != m_pWritePage
&& nPosition >= m_pReadPage->m_nOffset + m_nPageSize)
{
Page * pRemove = m_pReadPage;
m_pReadPage = pRemove->m_pNext;
remove(pRemove);
}
}
m_pReadPage->m_pRead = m_pReadPage->m_aBuffer
+ (nPosition - m_pReadPage->m_nOffset);
return SEEK_OK;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
