xref: /aoo41x/main/oox/source/ole/axbinaryreader.cxx (revision ca5ec200)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 #include "oox/ole/axbinaryreader.hxx"
25 
26 #include "oox/ole/olehelper.hxx"
27 
28 namespace oox {
29 namespace ole {
30 
31 // ============================================================================
32 
33 using ::rtl::OUString;
34 
35 // ============================================================================
36 
37 namespace {
38 
39 const sal_uInt32 AX_STRING_SIZEMASK         = 0x7FFFFFFF;
40 const sal_uInt32 AX_STRING_COMPRESSED       = 0x80000000;
41 
42 } // namespace
43 
44 // ============================================================================
45 
AxAlignedInputStream(BinaryInputStream & rInStrm)46 AxAlignedInputStream::AxAlignedInputStream( BinaryInputStream& rInStrm ) :
47     BinaryStreamBase( false ),
48     mpInStrm( &rInStrm ),
49     mnStrmPos( 0 ),
50     mnStrmSize( rInStrm.getRemaining() )
51 {
52     mbEof = mbEof || rInStrm.isEof();
53 }
54 
size() const55 sal_Int64 AxAlignedInputStream::size() const
56 {
57     return mpInStrm ? mnStrmSize : -1;
58 }
59 
tell() const60 sal_Int64 AxAlignedInputStream::tell() const
61 {
62     return mpInStrm ? mnStrmPos : -1;
63 }
64 
seek(sal_Int64 nPos)65 void AxAlignedInputStream::seek( sal_Int64 nPos )
66 {
67     mbEof = mbEof || (nPos < mnStrmPos);
68     if( !mbEof )
69         skip( static_cast< sal_Int32 >( nPos - mnStrmPos ) );
70 }
71 
close()72 void AxAlignedInputStream::close()
73 {
74     mpInStrm = 0;
75     mbEof = true;
76 }
77 
readData(StreamDataSequence & orData,sal_Int32 nBytes,size_t nAtomSize)78 sal_Int32 AxAlignedInputStream::readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t nAtomSize )
79 {
80     sal_Int32 nReadSize = 0;
81     if( !mbEof )
82     {
83         nReadSize = mpInStrm->readData( orData, nBytes, nAtomSize );
84         mnStrmPos += nReadSize;
85         mbEof = mpInStrm->isEof();
86     }
87     return nReadSize;
88 }
89 
readMemory(void * opMem,sal_Int32 nBytes,size_t nAtomSize)90 sal_Int32 AxAlignedInputStream::readMemory( void* opMem, sal_Int32 nBytes, size_t nAtomSize )
91 {
92     sal_Int32 nReadSize = 0;
93     if( !mbEof )
94     {
95         nReadSize = mpInStrm->readMemory( opMem, nBytes, nAtomSize );
96         mnStrmPos += nReadSize;
97         mbEof = mpInStrm->isEof();
98     }
99     return nReadSize;
100 }
101 
skip(sal_Int32 nBytes,size_t nAtomSize)102 void AxAlignedInputStream::skip( sal_Int32 nBytes, size_t nAtomSize )
103 {
104     if( !mbEof )
105     {
106         mpInStrm->skip( nBytes, nAtomSize );
107         mnStrmPos += nBytes;
108         mbEof = mpInStrm->isEof();
109     }
110 }
111 
align(size_t nSize)112 void AxAlignedInputStream::align( size_t nSize )
113 {
114     skip( static_cast< sal_Int32 >( (nSize - (mnStrmPos % nSize)) % nSize ) );
115 }
116 
117 // ============================================================================
118 
AxFontData()119 AxFontData::AxFontData() :
120     mnFontEffects( 0 ),
121     mnFontHeight( 160 ),
122     mnFontCharSet( WINDOWS_CHARSET_DEFAULT ),
123     mnHorAlign( AX_FONTDATA_LEFT ),
124     mbDblUnderline( false )
125 {
126 }
127 
getHeightPoints() const128 sal_Int16 AxFontData::getHeightPoints() const
129 {
130     /*  MSO uses weird font sizes:
131         1pt->30, 2pt->45, 3pt->60, 4pt->75, 5pt->105, 6pt->120, 7pt->135,
132         8pt->165, 9pt->180, 10pt->195, 11pt->225, ... */
133     return getLimitedValue< sal_Int16, sal_Int32 >( (mnFontHeight + 10) / 20, 1, SAL_MAX_INT16 );
134 }
135 
setHeightPoints(sal_Int16 nPoints)136 void AxFontData::setHeightPoints( sal_Int16 nPoints )
137 {
138     mnFontHeight = getLimitedValue< sal_Int32, sal_Int32 >( ((nPoints * 4 + 1) / 3) * 15, 30, 4294967 );
139 }
140 
importBinaryModel(BinaryInputStream & rInStrm)141 bool AxFontData::importBinaryModel( BinaryInputStream& rInStrm )
142 {
143     AxBinaryPropertyReader aReader( rInStrm );
144     aReader.readStringProperty( maFontName );
145     aReader.readIntProperty< sal_uInt32 >( mnFontEffects );
146     aReader.readIntProperty< sal_Int32 >( mnFontHeight );
147     aReader.skipIntProperty< sal_Int32 >(); // font offset
148     aReader.readIntProperty< sal_uInt8 >( mnFontCharSet );
149     aReader.skipIntProperty< sal_uInt8 >(); // font pitch/family
150     aReader.readIntProperty< sal_uInt8 >( mnHorAlign );
151     aReader.skipIntProperty< sal_uInt16 >(); // font weight
152     mbDblUnderline = false;
153     return aReader.finalizeImport();
154 }
155 
importStdFont(BinaryInputStream & rInStrm)156 bool AxFontData::importStdFont( BinaryInputStream& rInStrm )
157 {
158     StdFontInfo aFontInfo;
159     if( OleHelper::importStdFont( aFontInfo, rInStrm, false ) )
160     {
161         maFontName = aFontInfo.maName;
162         mnFontEffects = 0;
163         setFlag( mnFontEffects, AX_FONTDATA_BOLD,      aFontInfo.mnWeight >= OLE_STDFONT_BOLD );
164         setFlag( mnFontEffects, AX_FONTDATA_ITALIC,    getFlag( aFontInfo.mnFlags, OLE_STDFONT_ITALIC ) );
165         setFlag( mnFontEffects, AX_FONTDATA_UNDERLINE, getFlag( aFontInfo.mnFlags, OLE_STDFONT_UNDERLINE ) );
166         setFlag( mnFontEffects, AX_FONTDATA_STRIKEOUT, getFlag( aFontInfo.mnFlags,OLE_STDFONT_STRIKE ) );
167         mbDblUnderline = false;
168         // StdFont stores font height in 1/10,000 of points
169         setHeightPoints( getLimitedValue< sal_Int16, sal_Int32 >( aFontInfo.mnHeight / 10000, 0, SAL_MAX_INT16 ) );
170         mnFontCharSet = aFontInfo.mnCharSet;
171         mnHorAlign = AX_FONTDATA_LEFT;
172         return true;
173     }
174     return false;
175 }
176 
importGuidAndFont(BinaryInputStream & rInStrm)177 bool AxFontData::importGuidAndFont( BinaryInputStream& rInStrm )
178 {
179     OUString aGuid = OleHelper::importGuid( rInStrm );
180     if( aGuid.equalsAscii( AX_GUID_CFONT ) )
181         return importBinaryModel( rInStrm );
182     if( aGuid.equalsAscii( OLE_GUID_STDFONT ) )
183         return importStdFont( rInStrm );
184     return false;
185 }
186 
187 // ============================================================================
188 
189 namespace {
190 
lclReadString(AxAlignedInputStream & rInStrm,OUString & rValue,sal_uInt32 nSize,bool bArrayString)191 bool lclReadString( AxAlignedInputStream& rInStrm, OUString& rValue, sal_uInt32 nSize, bool bArrayString )
192 {
193     bool bCompressed = getFlag( nSize, AX_STRING_COMPRESSED );
194     sal_uInt32 nBufSize = nSize & AX_STRING_SIZEMASK;
195     // Unicode: simple strings store byte count, array strings store char count
196     sal_Int32 nChars = static_cast< sal_Int32 >( nBufSize / ((bCompressed || bArrayString) ? 1 : 2) );
197     bool bValidChars = nChars <= 65536;
198     OSL_ENSURE( bValidChars, "lclReadString - string too long" );
199     sal_Int64 nEndPos = rInStrm.tell() + nChars * (bCompressed ? 1 : 2);
200     nChars = ::std::min< sal_Int32 >( nChars, 65536 );
201     rValue = rInStrm.readCompressedUnicodeArray( nChars, bCompressed );
202     rInStrm.seek( nEndPos );
203     return bValidChars;
204 }
205 
206 } // namespace
207 
208 // ----------------------------------------------------------------------------
209 
~ComplexProperty()210 AxBinaryPropertyReader::ComplexProperty::~ComplexProperty()
211 {
212 }
213 
readProperty(AxAlignedInputStream & rInStrm)214 bool AxBinaryPropertyReader::PairProperty::readProperty( AxAlignedInputStream& rInStrm )
215 {
216     rInStrm >> mrPairData.first >> mrPairData.second;
217     return true;
218 }
219 
readProperty(AxAlignedInputStream & rInStrm)220 bool AxBinaryPropertyReader::StringProperty::readProperty( AxAlignedInputStream& rInStrm )
221 {
222     return lclReadString( rInStrm, mrValue, mnSize, false );
223 }
224 
readProperty(AxAlignedInputStream & rInStrm)225 bool AxBinaryPropertyReader::StringArrayProperty::readProperty( AxAlignedInputStream& rInStrm )
226 {
227     sal_Int64 nEndPos = rInStrm.tell() + mnSize;
228     while( rInStrm.tell() < nEndPos )
229     {
230         OUString aString;
231         if( !lclReadString( rInStrm, aString, rInStrm.readuInt32(), true ) )
232             return false;
233         mrArray.push_back( aString );
234         // every array string is aligned on 4 byte boundries
235         rInStrm.align( 4 );
236     }
237     return true;
238 }
239 
readProperty(AxAlignedInputStream & rInStrm)240 bool AxBinaryPropertyReader::GuidProperty::readProperty( AxAlignedInputStream& rInStrm )
241 {
242     mrGuid = OleHelper::importGuid( rInStrm );
243     return true;
244 }
245 
readProperty(AxAlignedInputStream & rInStrm)246 bool AxBinaryPropertyReader::FontProperty::readProperty( AxAlignedInputStream& rInStrm )
247 {
248     return mrFontData.importGuidAndFont( rInStrm );
249 }
250 
readProperty(AxAlignedInputStream & rInStrm)251 bool AxBinaryPropertyReader::PictureProperty::readProperty( AxAlignedInputStream& rInStrm )
252 {
253     return OleHelper::importStdPic( mrPicData, rInStrm, true );
254 }
255 
256 // ----------------------------------------------------------------------------
257 
AxBinaryPropertyReader(BinaryInputStream & rInStrm,bool b64BitPropFlags)258 AxBinaryPropertyReader::AxBinaryPropertyReader( BinaryInputStream& rInStrm, bool b64BitPropFlags ) :
259     maInStrm( rInStrm ),
260     mbValid( true )
261 {
262     // version and size of property block
263     maInStrm.skip( 2 );
264     sal_uInt16 nBlockSize = maInStrm.readValue< sal_uInt16 >();
265     mnPropsEnd = maInStrm.tell() + nBlockSize;
266     // flagfield containing existing properties
267     if( b64BitPropFlags )
268         maInStrm >> mnPropFlags;
269     else
270         mnPropFlags = maInStrm.readuInt32();
271     mnNextProp = 1;
272 }
273 
readBoolProperty(bool & orbValue,bool bReverse)274 void AxBinaryPropertyReader::readBoolProperty( bool& orbValue, bool bReverse )
275 {
276     // there is no data, the boolean value is equivalent to the property flag itself
277     orbValue = startNextProperty() != bReverse;
278 }
279 
readPairProperty(AxPairData & orPairData)280 void AxBinaryPropertyReader::readPairProperty( AxPairData& orPairData )
281 {
282     if( startNextProperty() )
283         maLargeProps.push_back( ComplexPropVector::value_type( new PairProperty( orPairData ) ) );
284 }
285 
readStringProperty(OUString & orValue)286 void AxBinaryPropertyReader::readStringProperty( OUString& orValue )
287 {
288     if( startNextProperty() )
289     {
290         sal_uInt32 nSize = maInStrm.readAligned< sal_uInt32 >();
291         maLargeProps.push_back( ComplexPropVector::value_type( new StringProperty( orValue, nSize ) ) );
292     }
293 }
294 
readStringArrayProperty(AxStringArray & orArray)295 void AxBinaryPropertyReader::readStringArrayProperty( AxStringArray& orArray )
296 {
297     if( startNextProperty() )
298     {
299         sal_uInt32 nSize = maInStrm.readAligned< sal_uInt32 >();
300         maLargeProps.push_back( ComplexPropVector::value_type( new StringArrayProperty( orArray, nSize ) ) );
301     }
302 }
303 
readGuidProperty(::rtl::OUString & orGuid)304 void AxBinaryPropertyReader::readGuidProperty( ::rtl::OUString& orGuid )
305 {
306     if( startNextProperty() )
307         maLargeProps.push_back( ComplexPropVector::value_type( new GuidProperty( orGuid ) ) );
308 }
309 
readFontProperty(AxFontData & orFontData)310 void AxBinaryPropertyReader::readFontProperty( AxFontData& orFontData )
311 {
312     if( startNextProperty() )
313     {
314         sal_Int16 nData = maInStrm.readAligned< sal_Int16 >();
315         if( ensureValid( nData == -1 ) )
316             maStreamProps.push_back( ComplexPropVector::value_type( new FontProperty( orFontData ) ) );
317     }
318 }
319 
readPictureProperty(StreamDataSequence & orPicData)320 void AxBinaryPropertyReader::readPictureProperty( StreamDataSequence& orPicData )
321 {
322     if( startNextProperty() )
323     {
324         sal_Int16 nData = maInStrm.readAligned< sal_Int16 >();
325         if( ensureValid( nData == -1 ) )
326             maStreamProps.push_back( ComplexPropVector::value_type( new PictureProperty( orPicData ) ) );
327     }
328 }
329 
finalizeImport()330 bool AxBinaryPropertyReader::finalizeImport()
331 {
332     // read large properties
333     maInStrm.align( 4 );
334     if( ensureValid( mnPropFlags == 0 ) && !maLargeProps.empty() )
335     {
336         for( ComplexPropVector::iterator aIt = maLargeProps.begin(), aEnd = maLargeProps.end(); ensureValid() && (aIt != aEnd); ++aIt )
337         {
338             ensureValid( (*aIt)->readProperty( maInStrm ) );
339             maInStrm.align( 4 );
340         }
341     }
342     maInStrm.seek( mnPropsEnd );
343 
344     // read stream properties (no stream alignment between properties!)
345     if( ensureValid() && !maStreamProps.empty() )
346         for( ComplexPropVector::iterator aIt = maStreamProps.begin(), aEnd = maStreamProps.end(); ensureValid() && (aIt != aEnd); ++aIt )
347             ensureValid( (*aIt)->readProperty( maInStrm ) );
348 
349     return mbValid;
350 }
351 
ensureValid(bool bCondition)352 bool AxBinaryPropertyReader::ensureValid( bool bCondition )
353 {
354     mbValid = mbValid && bCondition && !maInStrm.isEof();
355     return mbValid;
356 }
357 
startNextProperty()358 bool AxBinaryPropertyReader::startNextProperty()
359 {
360     bool bHasProp = getFlag( mnPropFlags, mnNextProp );
361     setFlag( mnPropFlags, mnNextProp, false );
362     mnNextProp <<= 1;
363     return ensureValid() && bHasProp;
364 }
365 
366 // ============================================================================
367 
368 } // namespace ole
369 } // namespace oox
370