oox/source/helper/binaryinputstream.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 "oox/helper/binaryinputstream.hxx"
  21
  22 #include <com/sun/star/io/XInputStream.hpp>
  23 #include <com/sun/star/io/XSeekable.hpp>
  24 #include <string.h>
  25 #include <vector>
  26 #include <rtl/strbuf.hxx>
  27 #include <rtl/ustrbuf.hxx>
  28 #include <osl/diagnose.h>
  29 #include "oox/helper/binaryoutputstream.hxx"
  30
  31 namespace oox {
  32
  33 using namespace ::com::sun::star::io;
  34 using namespace ::com::sun::star::uno;
  35
  36 namespace {
  37
  38 const sal_Int32 INPUTSTREAM_BUFFERSIZE      = 0x8000;
  39
  40 } // namespace
  41
  42 OUString BinaryInputStream::readNulUnicodeArray()
  43 {
  44     OUStringBuffer aBuffer;
  45     for (;;)
  46     {
  47       sal_uInt16 nChar = readuInt16();
  48       if ( mbEof || (nChar == 0) ) break;
  49       aBuffer.append( static_cast< sal_Unicode >( nChar ) );
  50     }
  51     return aBuffer.makeStringAndClear();
  52 }
  53
  54 OString BinaryInputStream::readCharArray( sal_Int32 nChars, bool bAllowNulChars )
  55 {
  56     if( nChars <= 0 )
  57         return OString();
  58
  59     ::std::vector< sal_uInt8 > aBuffer;
  60     sal_Int32 nCharsRead = readArray( aBuffer, nChars );
  61     if( nCharsRead <= 0 )
  62         return OString();
  63
  64     aBuffer.resize( static_cast< size_t >( nCharsRead ) );
  65     if( !bAllowNulChars )
  66         ::std::replace( aBuffer.begin(), aBuffer.end(), '\0', '?' );
  67
  68     return OString( reinterpret_cast< sal_Char* >( &aBuffer.front() ), nCharsRead );
  69 }
  70
  71 OUString BinaryInputStream::readCharArrayUC( sal_Int32 nChars, rtl_TextEncoding eTextEnc, bool bAllowNulChars )
  72 {
  73     return OStringToOUString( readCharArray( nChars, bAllowNulChars ), eTextEnc );
  74 }
  75
  76 OUString BinaryInputStream::readUnicodeArray( sal_Int32 nChars, bool bAllowNulChars )
  77 {
  78     if( nChars <= 0 )
  79         return OUString();
  80
  81     ::std::vector< sal_uInt16 > aBuffer;
  82     sal_Int32 nCharsRead = readArray( aBuffer, nChars );
  83     if( nCharsRead <= 0 )
  84         return OUString();
  85
  86     aBuffer.resize( static_cast< size_t >( nCharsRead ) );
  87     if( !bAllowNulChars )
  88         ::std::replace( aBuffer.begin(), aBuffer.begin() + nCharsRead, '\0', '?' );
  89
  90     OUStringBuffer aStringBuffer;
  91     aStringBuffer.ensureCapacity( nCharsRead );
  92     for( ::std::vector< sal_uInt16 >::iterator aIt = aBuffer.begin(), aEnd = aBuffer.end(); aIt != aEnd; ++aIt )
  93         aStringBuffer.append( static_cast< sal_Unicode >( *aIt ) );
  94     return aStringBuffer.makeStringAndClear();
  95 }
  96
  97 OUString BinaryInputStream::readCompressedUnicodeArray( sal_Int32 nChars, bool bCompressed, bool bAllowNulChars )
  98 {
  99     return bCompressed ?
 100          // ISO-8859-1 maps all byte values 0xHH to the same Unicode code point U+00HH
 101         readCharArrayUC( nChars, RTL_TEXTENCODING_ISO_8859_1, bAllowNulChars ) :
 102         readUnicodeArray( nChars, bAllowNulChars );
 103 }
 104
 105 void BinaryInputStream::copyToStream( BinaryOutputStream& rOutStrm, sal_Int64 nBytes, sal_Int32 nAtomSize )
 106 {
 107     if( nBytes > 0 )
 108     {
 109         // make buffer size a multiple of the passed atom size
 110         sal_Int32 nBufferSize = getLimitedValue< sal_Int32, sal_Int64 >( nBytes, 0, (INPUTSTREAM_BUFFERSIZE / nAtomSize) * nAtomSize );
 111         StreamDataSequence aBuffer( nBufferSize );
 112         while( nBytes > 0 )
 113         {
 114             sal_Int32 nReadSize = getLimitedValue< sal_Int32, sal_Int64 >( nBytes, 0, nBufferSize );
 115             sal_Int32 nBytesRead = readData( aBuffer, nReadSize, nAtomSize );
 116             rOutStrm.writeData( aBuffer );
 117             if( nReadSize == nBytesRead )
 118                 nBytes -= nReadSize;
 119             else
 120                 nBytes = 0;
 121         }
 122     }
 123 }
 124
 125 BinaryXInputStream::BinaryXInputStream( const Reference< XInputStream >& rxInStrm, bool bAutoClose ) :
 126     BinaryStreamBase( Reference< XSeekable >( rxInStrm, UNO_QUERY ).is() ),
 127     BinaryXSeekableStream( Reference< XSeekable >( rxInStrm, UNO_QUERY ) ),
 128     maBuffer( INPUTSTREAM_BUFFERSIZE ),
 129     mxInStrm( rxInStrm ),
 130     mbAutoClose( bAutoClose && rxInStrm.is() )
 131 {
 132     mbEof = !mxInStrm.is();
 133 }
 134
 135 BinaryXInputStream::~BinaryXInputStream()
 136 {
 137     close();
 138 }
 139
 140 void BinaryXInputStream::close()
 141 {
 142     OSL_ENSURE( !mbAutoClose || mxInStrm.is(), "BinaryXInputStream::close - invalid call" );
 143     if( mxInStrm.is() ) try
 144     {
 145         mxInStrm->closeInput();
 146     }
 147     catch( Exception& )
 148     {
 149         OSL_FAIL( "BinaryXInputStream::close - closing input stream failed" );
 150     }
 151     mxInStrm.clear();
 152     mbAutoClose = false;
 153     BinaryXSeekableStream::close();
 154 }
 155
 156 sal_Int32 BinaryXInputStream::readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t /*nAtomSize*/ )
 157 {
 158     sal_Int32 nRet = 0;
 159     if( !mbEof && (nBytes > 0) ) try
 160     {
 161         nRet = mxInStrm->readBytes( orData, nBytes );
 162         mbEof = nRet != nBytes;
 163     }
 164     catch( Exception& )
 165     {
 166         mbEof = true;
 167     }
 168     return nRet;
 169 }
 170
 171 sal_Int32 BinaryXInputStream::readMemory( void* opMem, sal_Int32 nBytes, size_t nAtomSize )
 172 {
 173     sal_Int32 nRet = 0;
 174     if( !mbEof && (nBytes > 0) )
 175     {
 176         sal_Int32 nBufferSize = getLimitedValue< sal_Int32, sal_Int32 >( nBytes, 0, INPUTSTREAM_BUFFERSIZE );
 177         sal_uInt8* opnMem = static_cast< sal_uInt8* >( opMem );
 178         while( !mbEof && (nBytes > 0) )
 179         {
 180             sal_Int32 nReadSize = getLimitedValue< sal_Int32, sal_Int32 >( nBytes, 0, nBufferSize );
 181             sal_Int32 nBytesRead = readData( maBuffer, nReadSize, nAtomSize );
 182             if( nBytesRead > 0 )
 183                 memcpy( opnMem, maBuffer.getConstArray(), static_cast< size_t >( nBytesRead ) );
 184             opnMem += nBytesRead;
 185             nBytes -= nBytesRead;
 186             nRet += nBytesRead;
 187         }
 188     }
 189     return nRet;
 190 }
 191
 192 void BinaryXInputStream::skip( sal_Int32 nBytes, size_t /*nAtomSize*/ )
 193 {
 194     if( !mbEof ) try
 195     {
 196         mxInStrm->skipBytes( nBytes );
 197     }
 198     catch( Exception& )
 199     {
 200         mbEof = true;
 201     }
 202 }
 203
 204 SequenceInputStream::SequenceInputStream( const StreamDataSequence& rData ) :
 205     BinaryStreamBase( true ),
 206     SequenceSeekableStream( rData )
 207 {
 208 }
 209
 210 sal_Int32 SequenceInputStream::readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t /*nAtomSize*/ )
 211 {
 212     sal_Int32 nReadBytes = 0;
 213     if( !mbEof )
 214     {
 215         nReadBytes = getMaxBytes( nBytes );
 216         orData.realloc( nReadBytes );
 217         if( nReadBytes > 0 )
 218             memcpy( orData.getArray(), mpData->getConstArray() + mnPos, static_cast< size_t >( nReadBytes ) );
 219         mnPos += nReadBytes;
 220         mbEof = nReadBytes < nBytes;
 221     }
 222     return nReadBytes;
 223 }
 224
 225 sal_Int32 SequenceInputStream::readMemory( void* opMem, sal_Int32 nBytes, size_t /*nAtomSize*/ )
 226 {
 227     sal_Int32 nReadBytes = 0;
 228     if( !mbEof )
 229     {
 230         nReadBytes = getMaxBytes( nBytes );
 231         if( nReadBytes > 0 )
 232             memcpy( opMem, mpData->getConstArray() + mnPos, static_cast< size_t >( nReadBytes ) );
 233         mnPos += nReadBytes;
 234         mbEof = nReadBytes < nBytes;
 235     }
 236     return nReadBytes;
 237 }
 238
 239 void SequenceInputStream::skip( sal_Int32 nBytes, size_t /*nAtomSize*/ )
 240 {
 241     if( !mbEof )
 242     {
 243         sal_Int32 nSkipBytes = getMaxBytes( nBytes );
 244         mnPos += nSkipBytes;
 245         mbEof = nSkipBytes < nBytes;
 246     }
 247 }
 248
 249 RelativeInputStream::RelativeInputStream( BinaryInputStream& rInStrm, sal_Int64 nSize ) :
 250     BinaryStreamBase( rInStrm.isSeekable() ),
 251     mpInStrm( &rInStrm ),
 252     mnStartPos( rInStrm.tell() ),
 253     mnRelPos( 0 )
 254 {
 255     sal_Int64 nRemaining = rInStrm.getRemaining();
 256     mnSize = (nRemaining >= 0) ? ::std::min( nSize, nRemaining ) : nSize;
 257     mbEof = mbEof || rInStrm.isEof() || (mnSize < 0);
 258 }
 259
 260 sal_Int64 RelativeInputStream::size() const
 261 {
 262     return mpInStrm ? mnSize : -1;
 263 }
 264
 265 sal_Int64 RelativeInputStream::tell() const
 266 {
 267     return mpInStrm ? mnRelPos : -1;
 268 }
 269
 270 void RelativeInputStream::seek( sal_Int64 nPos )
 271 {
 272     if( mpInStrm && isSeekable() && (mnStartPos >= 0) )
 273     {
 274         mnRelPos = getLimitedValue< sal_Int64, sal_Int64 >( nPos, 0, mnSize );
 275         mpInStrm->seek( mnStartPos + mnRelPos );
 276         mbEof = (mnRelPos != nPos) || mpInStrm->isEof();
 277     }
 278 }
 279
 280 void RelativeInputStream::close()
 281 {
 282     mpInStrm = 0;
 283     mbEof = true;
 284 }
 285
 286 sal_Int32 RelativeInputStream::readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t nAtomSize )
 287 {
 288     sal_Int32 nReadBytes = 0;
 289     if( !mbEof )
 290     {
 291         sal_Int32 nMaxBytes = getMaxBytes( nBytes );
 292         nReadBytes = mpInStrm->readData( orData, nMaxBytes, nAtomSize );
 293         mnRelPos += nReadBytes;
 294         mbEof = (nMaxBytes < nBytes) || mpInStrm->isEof();
 295     }
 296     return nReadBytes;
 297 }
 298
 299 sal_Int32 RelativeInputStream::readMemory( void* opMem, sal_Int32 nBytes, size_t nAtomSize )
 300 {
 301     sal_Int32 nReadBytes = 0;
 302     if( !mbEof )
 303     {
 304         sal_Int32 nMaxBytes = getMaxBytes( nBytes );
 305         nReadBytes = mpInStrm->readMemory( opMem, nMaxBytes, nAtomSize );
 306         mnRelPos += nReadBytes;
 307         mbEof = (nMaxBytes < nBytes) || mpInStrm->isEof();
 308     }
 309     return nReadBytes;
 310 }
 311
 312 void RelativeInputStream::skip( sal_Int32 nBytes, size_t nAtomSize )
 313 {
 314     if( !mbEof )
 315     {
 316         sal_Int32 nSkipBytes = getMaxBytes( nBytes );
 317         mpInStrm->skip( nSkipBytes, nAtomSize );
 318         mnRelPos += nSkipBytes;
 319         mbEof = nSkipBytes < nBytes;
 320     }
 321 }
 322
 323 } // namespace oox
 324
 325 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */