LCOV - code coverage report
Current view: top level - oox/source/ole - vbainputstream.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 89 0.0 %
Date: 2014-04-14 Functions: 0 10 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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/ole/vbainputstream.hxx"
      21             : #include <osl/diagnose.h>
      22             : 
      23             : namespace oox {
      24             : namespace ole {
      25             : 
      26             : 
      27             : 
      28             : namespace {
      29             : 
      30             : const sal_uInt8 VBASTREAM_SIGNATURE         = 1;
      31             : 
      32             : const sal_uInt16 VBACHUNK_SIGMASK           = 0x7000;
      33             : const sal_uInt16 VBACHUNK_SIG               = 0x3000;
      34             : const sal_uInt16 VBACHUNK_COMPRESSED        = 0x8000;
      35             : const sal_uInt16 VBACHUNK_LENMASK           = 0x0FFF;
      36             : 
      37             : } // namespace
      38             : 
      39             : 
      40             : 
      41           0 : VbaInputStream::VbaInputStream( BinaryInputStream& rInStrm ) :
      42             :     BinaryStreamBase( false ),
      43             :     mpInStrm( &rInStrm ),
      44           0 :     mnChunkPos( 0 )
      45             : {
      46           0 :     maChunk.reserve( 4096 );
      47             : 
      48           0 :     sal_uInt8 nSig = rInStrm.readuInt8();
      49             :     OSL_ENSURE( nSig == VBASTREAM_SIGNATURE, "VbaInputStream::VbaInputStream - wrong signature" );
      50           0 :     mbEof = mbEof || rInStrm.isEof() || (nSig != VBASTREAM_SIGNATURE);
      51           0 : }
      52             : 
      53           0 : sal_Int64 VbaInputStream::size() const
      54             : {
      55           0 :     return -1;
      56             : }
      57             : 
      58           0 : sal_Int64 VbaInputStream::tell() const
      59             : {
      60           0 :     return -1;
      61             : }
      62             : 
      63           0 : void VbaInputStream::seek( sal_Int64 )
      64             : {
      65           0 : }
      66             : 
      67           0 : void VbaInputStream::close()
      68             : {
      69           0 :     mpInStrm = 0;
      70           0 :     mbEof = true;
      71           0 : }
      72             : 
      73           0 : sal_Int32 VbaInputStream::readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t nAtomSize )
      74             : {
      75           0 :     sal_Int32 nRet = 0;
      76           0 :     if( !mbEof )
      77             :     {
      78           0 :         orData.realloc( ::std::max< sal_Int32 >( nBytes, 0 ) );
      79           0 :         if( nBytes > 0 )
      80             :         {
      81           0 :             nRet = readMemory( orData.getArray(), nBytes, nAtomSize );
      82           0 :             if( nRet < nBytes )
      83           0 :                 orData.realloc( nRet );
      84             :         }
      85             :     }
      86           0 :     return nRet;
      87             : }
      88             : 
      89           0 : sal_Int32 VbaInputStream::readMemory( void* opMem, sal_Int32 nBytes, size_t /*nAtomSize*/ )
      90             : {
      91           0 :     sal_Int32 nRet = 0;
      92           0 :     sal_uInt8* opnMem = reinterpret_cast< sal_uInt8* >( opMem );
      93           0 :     while( (nBytes > 0) && updateChunk() )
      94             :     {
      95           0 :         sal_Int32 nChunkLeft = static_cast< sal_Int32 >( maChunk.size() - mnChunkPos );
      96           0 :         sal_Int32 nReadBytes = ::std::min( nBytes, nChunkLeft );
      97           0 :         memcpy( opnMem, &*(maChunk.begin() + mnChunkPos), nReadBytes );
      98           0 :         opnMem += nReadBytes;
      99           0 :         mnChunkPos += static_cast< size_t >( nReadBytes );
     100           0 :         nBytes -= nReadBytes;
     101           0 :         nRet += nReadBytes;
     102             :     }
     103           0 :     return nRet;
     104             : }
     105             : 
     106           0 : void VbaInputStream::skip( sal_Int32 nBytes, size_t /*nAtomSize*/ )
     107             : {
     108           0 :     while( (nBytes > 0) && updateChunk() )
     109             :     {
     110           0 :         sal_Int32 nChunkLeft = static_cast< sal_Int32 >( maChunk.size() - mnChunkPos );
     111           0 :         sal_Int32 nSkipBytes = ::std::min( nBytes, nChunkLeft );
     112           0 :         mnChunkPos += static_cast< size_t >( nSkipBytes );
     113           0 :         nBytes -= nSkipBytes;
     114             :     }
     115           0 : }
     116             : 
     117             : // private --------------------------------------------------------------------
     118             : 
     119           0 : bool VbaInputStream::updateChunk()
     120             : {
     121           0 :     if( mbEof || (mnChunkPos < maChunk.size()) ) return !mbEof;
     122             :     // try to read next chunk header, this may trigger EOF
     123           0 :     sal_uInt16 nHeader = mpInStrm->readuInt16();
     124             : 
     125           0 :     mbEof = mpInStrm->isEof();
     126           0 :     if( mbEof ) return false;
     127             : 
     128             :     // check header signature
     129           0 :     bool bIgnoreBrokenSig = !( (nHeader & VBACHUNK_SIGMASK) == VBACHUNK_SIG );
     130             : 
     131             :     // decode length of chunk data and compression flag
     132           0 :     bool bCompressed = getFlag( nHeader, VBACHUNK_COMPRESSED );
     133           0 :     sal_uInt16 nChunkLen = (nHeader & VBACHUNK_LENMASK) + 1;
     134             :     OSL_ENSURE( bCompressed || (nChunkLen == 4096), "VbaInputStream::updateChunk - invalid uncompressed chunk size" );
     135             : 
     136             :     // From the amazing bit detective work of Valek Filippov<frob@gnome.org>
     137             :     // this tweak and the one at the bottom of the method to seek to the
     138             :     // start of the next chunk we can read those strange broken
     139             :     // ( I guess from a MSO bug ) commpessed streams > 4k
     140             : 
     141           0 :     if ( bIgnoreBrokenSig )
     142             :     {
     143           0 :         bCompressed = true;
     144           0 :         nChunkLen = 4094;
     145             :     }
     146             : 
     147           0 :     sal_Int64 target = mpInStrm->tell() + nChunkLen;
     148           0 :     if( bCompressed )
     149             :     {
     150           0 :         maChunk.clear();
     151           0 :         sal_uInt8 nBitCount = 4;
     152           0 :         sal_uInt16 nChunkPos = 0;
     153           0 :         while( !mbEof && !mpInStrm->isEof() && (nChunkPos < nChunkLen) )
     154             :         {
     155           0 :             sal_uInt8 nTokenFlags = mpInStrm->readuInt8();
     156           0 :             ++nChunkPos;
     157           0 :             for( int nBit = 0; !mbEof && !mpInStrm->isEof() && (nBit < 8) && (nChunkPos < nChunkLen); ++nBit, nTokenFlags >>= 1 )
     158             :             {
     159           0 :                 if( nTokenFlags & 1 )
     160             :                 {
     161           0 :                     sal_uInt16 nCopyToken = mpInStrm->readuInt16();
     162           0 :                     nChunkPos = nChunkPos + 2;
     163             :                     // update bit count used for offset/length in the token
     164           0 :                     while( static_cast< size_t >( 1 << nBitCount ) < maChunk.size() ) ++nBitCount;
     165             :                     // extract length from lower (16-nBitCount) bits, plus 3
     166           0 :                     sal_uInt16 nLength = extractValue< sal_uInt16 >( nCopyToken, 0, 16 - nBitCount ) + 3;
     167             :                     // extract offset from high nBitCount bits, plus 1
     168           0 :                     sal_uInt16 nOffset = extractValue< sal_uInt16 >( nCopyToken, 16 - nBitCount, nBitCount ) + 1;
     169           0 :                     mbEof = (nOffset > maChunk.size()) || (maChunk.size() + nLength > 4096);
     170             :                     OSL_ENSURE( !mbEof, "VbaInputStream::updateChunk - invalid offset or size in copy token" );
     171           0 :                     if( !mbEof )
     172             :                     {
     173             :                         // append data to buffer
     174           0 :                         maChunk.resize( maChunk.size() + nLength );
     175           0 :                         sal_uInt8* pnTo = &*(maChunk.end() - nLength);
     176           0 :                         const sal_uInt8* pnEnd = pnTo + nLength;
     177           0 :                         const sal_uInt8* pnFrom = pnTo - nOffset;
     178             :                         // offset may be less than length, effectively duplicating source data several times
     179           0 :                         size_t nRunLen = ::std::min< size_t >( nLength, nOffset );
     180           0 :                         while( pnTo < pnEnd )
     181             :                         {
     182           0 :                             size_t nStepLen = ::std::min< size_t >( nRunLen, pnEnd - pnTo );
     183           0 :                             memcpy( pnTo, pnFrom, nStepLen );
     184           0 :                             pnTo += nStepLen;
     185             :                         }
     186             :                     }
     187             :                 }
     188             :                 // we suspect this will never be called
     189             :                 else
     190             :                 {
     191           0 :                     maChunk.resize( maChunk.size() + 1 );
     192           0 :                     *mpInStrm >> maChunk.back();
     193           0 :                     ++nChunkPos;
     194             :                 }
     195             :             }
     196             :         }
     197             :     }
     198             :     else
     199             :     {
     200           0 :         maChunk.resize( nChunkLen );
     201           0 :         mpInStrm->readMemory( &maChunk.front(), nChunkLen );
     202             :     }
     203             :     // decompression sometimes leaves the stream pos offset 1 place ( at
     204             :     // least ) past or before the expected stream pos.
     205             :     // here we make sure we are on the chunk boundry
     206           0 :     mpInStrm->seek( target );
     207           0 :     mnChunkPos = 0;
     208           0 :     return !mbEof;
     209             : }
     210             : 
     211             : 
     212             : 
     213             : } // namespace ole
     214             : } // namespace oox
     215             : 
     216             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10