oox/source/ole/axbinaryreader.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/ole/axbinaryreader.hxx>
  21
  22 #include <oox/ole/axfontdata.hxx>
  23 #include <oox/ole/olehelper.hxx>
  24
  25 #include <osl/diagnose.h>
  26
  27 namespace oox {
  28 namespace ole {
  29
  30 namespace {
  31
  32 const sal_uInt32 AX_STRING_SIZEMASK         = 0x7FFFFFFF;
  33 const sal_uInt32 AX_STRING_COMPRESSED       = 0x80000000;
  34
  35 } // namespace
  36
  37 AxAlignedInputStream::AxAlignedInputStream( BinaryInputStream& rInStrm ) :
  38     BinaryStreamBase( false ),
  39     mpInStrm( &rInStrm ),
  40     mnStrmPos( 0 ),
  41     mnStrmSize( rInStrm.getRemaining() )
  42 {
  43     mbEof = mbEof || rInStrm.isEof();
  44 }
  45
  46 sal_Int64 AxAlignedInputStream::size() const
  47 {
  48     return mpInStrm ? mnStrmSize : -1;
  49 }
  50
  51 sal_Int64 AxAlignedInputStream::tell() const
  52 {
  53     return mpInStrm ? mnStrmPos : -1;
  54 }
  55
  56 void AxAlignedInputStream::seek( sal_Int64 nPos )
  57 {
  58     mbEof = mbEof || (nPos < mnStrmPos);
  59     if( !mbEof )
  60         skip( static_cast< sal_Int32 >( nPos - mnStrmPos ) );
  61 }
  62
  63 void AxAlignedInputStream::close()
  64 {
  65     mpInStrm = nullptr;
  66     mbEof = true;
  67 }
  68
  69 sal_Int32 AxAlignedInputStream::readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t nAtomSize )
  70 {
  71     sal_Int32 nReadSize = 0;
  72     if( !mbEof )
  73     {
  74         nReadSize = mpInStrm->readData( orData, nBytes, nAtomSize );
  75         mnStrmPos += nReadSize;
  76         mbEof = mpInStrm->isEof();
  77     }
  78     return nReadSize;
  79 }
  80
  81 sal_Int32 AxAlignedInputStream::readMemory( void* opMem, sal_Int32 nBytes, size_t nAtomSize )
  82 {
  83     sal_Int32 nReadSize = 0;
  84     if( !mbEof )
  85     {
  86         nReadSize = mpInStrm->readMemory( opMem, nBytes, nAtomSize );
  87         mnStrmPos += nReadSize;
  88         mbEof = mpInStrm->isEof();
  89     }
  90     return nReadSize;
  91 }
  92
  93 void AxAlignedInputStream::skip( sal_Int32 nBytes, size_t nAtomSize )
  94 {
  95     if( !mbEof )
  96     {
  97         mpInStrm->skip( nBytes, nAtomSize );
  98         mnStrmPos += nBytes;
  99         mbEof = mpInStrm->isEof();
 100     }
 101 }
 102
 103 void AxAlignedInputStream::align( size_t nSize )
 104 {
 105     skip( static_cast< sal_Int32 >( (nSize - (mnStrmPos % nSize)) % nSize ) );
 106 }
 107
 108 namespace {
 109
 110 bool lclReadString( AxAlignedInputStream& rInStrm, OUString& rValue, sal_uInt32 nSize, bool bArrayString )
 111 {
 112     bool bCompressed = getFlag( nSize, AX_STRING_COMPRESSED );
 113     sal_uInt32 nBufSize = nSize & AX_STRING_SIZEMASK;
 114     // Unicode: simple strings store byte count, array strings store char count
 115     sal_Int32 nChars = static_cast< sal_Int32 >( nBufSize / ((bCompressed || bArrayString) ? 1 : 2) );
 116     bool bValidChars = nChars <= 65536;
 117     OSL_ENSURE( bValidChars, "lclReadString - string too long" );
 118     sal_Int64 nEndPos = rInStrm.tell() + nChars * (bCompressed ? 1 : 2);
 119     nChars = ::std::min< sal_Int32 >( nChars, 65536 );
 120     rValue = rInStrm.readCompressedUnicodeArray( nChars, bCompressed );
 121     rInStrm.seek( nEndPos );
 122     return bValidChars;
 123 }
 124
 125 } // namespace
 126
 127 AxBinaryPropertyReader::ComplexProperty::~ComplexProperty()
 128 {
 129 }
 130
 131 bool AxBinaryPropertyReader::PairProperty::readProperty( AxAlignedInputStream& rInStrm )
 132 {
 133     mrPairData.first = rInStrm.readInt32();
 134     mrPairData.second = rInStrm.readInt32();
 135     return true;
 136 }
 137
 138 bool AxBinaryPropertyReader::StringProperty::readProperty( AxAlignedInputStream& rInStrm )
 139 {
 140     return lclReadString( rInStrm, mrValue, mnSize, false );
 141 }
 142
 143 bool AxBinaryPropertyReader::ArrayStringProperty::readProperty( AxAlignedInputStream& rInStrm )
 144 {
 145     sal_Int64 nEndPos = rInStrm.tell() + mnSize;
 146     while( rInStrm.tell() < nEndPos )
 147     {
 148         OUString aString;
 149         if( !lclReadString( rInStrm, aString, rInStrm.readuInt32(), true ) )
 150             return false;
 151         mrArray.push_back( aString );
 152         // every array string is aligned on 4 byte boundaries
 153         rInStrm.align( 4 );
 154     }
 155     return true;
 156 }
 157
 158 bool AxBinaryPropertyReader::GuidProperty::readProperty( AxAlignedInputStream& rInStrm )
 159 {
 160     mrGuid = OleHelper::importGuid( rInStrm );
 161     return true;
 162 }
 163
 164 bool AxBinaryPropertyReader::FontProperty::readProperty( AxAlignedInputStream& rInStrm )
 165 {
 166     return mrFontData.importGuidAndFont( rInStrm );
 167 }
 168
 169 bool AxBinaryPropertyReader::PictureProperty::readProperty( AxAlignedInputStream& rInStrm )
 170 {
 171     return OleHelper::importStdPic( mrPicData, rInStrm );
 172 }
 173
 174 AxBinaryPropertyReader::AxBinaryPropertyReader( BinaryInputStream& rInStrm, bool b64BitPropFlags ) :
 175     maInStrm( rInStrm ),
 176     mbValid( true )
 177 {
 178     // version and size of property block
 179     maInStrm.skip( 2 );
 180     sal_uInt16 nBlockSize = maInStrm.readuInt16();
 181     mnPropsEnd = maInStrm.tell() + nBlockSize;
 182     // flagfield containing existing properties
 183     if( b64BitPropFlags )
 184         mnPropFlags = maInStrm.readInt64();
 185     else
 186         mnPropFlags = maInStrm.readuInt32();
 187     mnNextProp = 1;
 188 }
 189
 190 void AxBinaryPropertyReader::readBoolProperty( bool& orbValue, bool bReverse )
 191 {
 192     // there is no data, the boolean value is equivalent to the property flag itself
 193     orbValue = startNextProperty() != bReverse;
 194 }
 195
 196 void AxBinaryPropertyReader::readPairProperty( AxPairData& orPairData )
 197 {
 198     if( startNextProperty() )
 199         maLargeProps.push_back( ComplexPropVector::value_type( new PairProperty( orPairData ) ) );
 200 }
 201
 202 void AxBinaryPropertyReader::readStringProperty( OUString& orValue )
 203 {
 204     if( startNextProperty() )
 205     {
 206         sal_uInt32 nSize = maInStrm.readAligned< sal_uInt32 >();
 207         maLargeProps.push_back( ComplexPropVector::value_type( new StringProperty( orValue, nSize ) ) );
 208     }
 209 }
 210
 211 void AxBinaryPropertyReader::readArrayStringProperty( std::vector<OUString>& orValue )
 212 {
 213     if( startNextProperty() )
 214     {
 215         sal_uInt32 nSize = maInStrm.readAligned< sal_uInt32 >();
 216         maLargeProps.push_back( ComplexPropVector::value_type( new ArrayStringProperty( orValue, nSize ) ) );
 217     }
 218 }
 219
 220 void AxBinaryPropertyReader::readGuidProperty( OUString& orGuid )
 221 {
 222     if( startNextProperty() )
 223         maLargeProps.push_back( ComplexPropVector::value_type( new GuidProperty( orGuid ) ) );
 224 }
 225
 226 void AxBinaryPropertyReader::readFontProperty( AxFontData& orFontData )
 227 {
 228     if( startNextProperty() )
 229     {
 230         sal_Int16 nData = maInStrm.readAligned< sal_Int16 >();
 231         if( ensureValid( nData == -1 ) )
 232             maStreamProps.push_back( ComplexPropVector::value_type( new FontProperty( orFontData ) ) );
 233     }
 234 }
 235
 236 void AxBinaryPropertyReader::readPictureProperty( StreamDataSequence& orPicData )
 237 {
 238     if( startNextProperty() )
 239     {
 240         sal_Int16 nData = maInStrm.readAligned< sal_Int16 >();
 241         if( ensureValid( nData == -1 ) )
 242             maStreamProps.push_back( ComplexPropVector::value_type( new PictureProperty( orPicData ) ) );
 243     }
 244 }
 245
 246 bool AxBinaryPropertyReader::finalizeImport()
 247 {
 248     // read large properties
 249     maInStrm.align( 4 );
 250     if( ensureValid( mnPropFlags == 0 ) )
 251     {
 252         for (auto const& largeProp : maLargeProps)
 253         {
 254             if (!ensureValid())
 255                 break;
 256             ensureValid( largeProp->readProperty( maInStrm ) );
 257             maInStrm.align( 4 );
 258         }
 259     }
 260     maInStrm.seek( mnPropsEnd );
 261
 262     // read stream properties (no stream alignment between properties!)
 263     if( ensureValid() )
 264     {
 265         for (auto const& streamProp : maStreamProps)
 266         {
 267             if (!ensureValid())
 268                 break;
 269             ensureValid( streamProp->readProperty( maInStrm ) );
 270         }
 271     }
 272
 273     return mbValid;
 274 }
 275
 276 bool AxBinaryPropertyReader::ensureValid( bool bCondition )
 277 {
 278     mbValid = mbValid && bCondition && !maInStrm.isEof();
 279     return mbValid;
 280 }
 281
 282 bool AxBinaryPropertyReader::startNextProperty()
 283 {
 284     bool bHasProp = getFlag( mnPropFlags, mnNextProp );
 285     setFlag( mnPropFlags, mnNextProp, false );
 286     mnNextProp <<= 1;
 287     return ensureValid() && bHasProp;
 288 }
 289
 290 } // namespace ole
 291 } // namespace oox
 292
 293 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */