?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 5.0.4.1
[LibreOffice.git] / sd / source / filter / ppt / propread.cxx
blob2f5fc73fb2ec30e0196329110039fdd9b93c2a39
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 <propread.hxx>
21 #include "rtl/tencinfo.h"
22 #include "rtl/textenc.h"
23 #include <osl/diagnose.h>
24
25 PropEntry::PropEntry( sal_uInt32 nId, const sal_uInt8* pBuf, sal_uInt32 nBufSize, sal_uInt16 nTextEnc ) :
26 mnId ( nId ),
27 mnSize ( nBufSize ),
28 mnTextEnc ( nTextEnc ),
29 mpBuf ( new sal_uInt8[ nBufSize ] )
30 {
31 memcpy( (void*)mpBuf, (void*)pBuf, nBufSize );
32 };
33
34 PropEntry::PropEntry( const PropEntry& rProp ) :
35 mnId ( rProp.mnId ),
36 mnSize ( rProp.mnSize ),
37 mnTextEnc ( rProp.mnTextEnc ),
38 mpBuf ( new sal_uInt8[ mnSize ] )
39 {
40 memcpy( (void*)mpBuf, (void*)rProp.mpBuf, mnSize );
41 };
42
43 PropEntry& PropEntry::operator=(const PropEntry& rPropEntry)
44 {
45 if ( this != &rPropEntry )
46 {
47 delete[] mpBuf;
48 mnId = rPropEntry.mnId;
49 mnSize = rPropEntry.mnSize;
50 mnTextEnc = rPropEntry.mnTextEnc;
51 mpBuf = new sal_uInt8[ mnSize ];
52 memcpy( (void*)mpBuf, (void*)rPropEntry.mpBuf, mnSize );
53 }
54 return *this;
55 }
56
57 void PropItem::Clear()
58 {
59 Seek( STREAM_SEEK_TO_BEGIN );
60 delete[] static_cast<sal_uInt8*>(SwitchBuffer());
61 }
62
63 static sal_Int32 lcl_getMaxSafeStrLen(sal_uInt32 nSize)
64 {
65 nSize -= 1; //Drop NULL terminator
66
67 //If it won't fit in a string, clip it to the max size that does
68 if (nSize > SAL_MAX_INT32)
69 nSize = SAL_MAX_INT32;
70
71 return static_cast< sal_Int32 >( nSize );
72 }
73
74 bool PropItem::Read( OUString& rString, sal_uInt32 nStringType, bool bAlign )
75 {
76 sal_uInt32 nType, nItemPos;
77 bool bRetValue = false;
78
79 nItemPos = Tell();
80
81 if ( nStringType == VT_EMPTY )
82 {
83 nType = VT_NULL; // Initialize in case stream fails.
84 ReadUInt32( nType );
85 }
86 else
87 nType = nStringType & VT_TYPEMASK;
88
89 sal_uInt32 nItemSize(0); // Initialize in case stream fails.
90 ReadUInt32(nItemSize);
91
92 switch( nType )
93 {
94 case VT_LPSTR :
95 {
96 if (nItemSize)
97 {
98 auto nMaxSizePossible = remainingSize();
99 if (nItemSize > nMaxSizePossible)
100 {
101 SAL_WARN("sd.filter", "String of Len " << nItemSize << " claimed, only " << nMaxSizePossible << " possible");
102 nItemSize = nMaxSizePossible;
103 }
104 }
105
106 if (nItemSize)
107 {
108 try
109 {
110 sal_Char* pString = new sal_Char[ nItemSize ];
111 if ( mnTextEnc == RTL_TEXTENCODING_UCS2 )
112 {
113 nItemSize >>= 1;
114 if ( nItemSize > 1 )
115 {
116 sal_Unicode* pWString = reinterpret_cast<sal_Unicode*>(pString);
117 for (sal_uInt32 i = 0; i < nItemSize; ++i)
118 ReadUInt16( pWString[ i ] );
119 rString = OUString(pWString, lcl_getMaxSafeStrLen(nItemSize));
120 }
121 else
122 rString.clear();
123 bRetValue = true;
124 }
125 else
126 {
127 SvMemoryStream::Read( pString, nItemSize );
128 if ( pString[ nItemSize - 1 ] == 0 )
129 {
130 if ( nItemSize > 1 )
131 rString = OUString(pString, rtl_str_getLength(pString), mnTextEnc);
132 else
133 rString.clear();
134 bRetValue = true;
135 }
136 }
137 delete[] pString;
138 }
139 catch( const std::bad_alloc& )
140 {
141 OSL_FAIL( "sd PropItem::Read bad alloc" );
142 }
143 }
144 if ( bAlign )
145 SeekRel( ( 4 - ( nItemSize & 3 ) ) & 3 ); // dword align
146 }
147 break;
148
149 case VT_LPWSTR :
150 {
151 if (nItemSize)
152 {
153 auto nMaxSizePossible = remainingSize() / sizeof(sal_Unicode);
154 if (nItemSize > nMaxSizePossible)
155 {
156 SAL_WARN("sd.filter", "String of Len " << nItemSize << " claimed, only " << nMaxSizePossible << " possible");
157 nItemSize = nMaxSizePossible;
158 }
159 }
160
161 if (nItemSize)
162 {
163 try
164 {
165 sal_Unicode* pString = new sal_Unicode[ nItemSize ];
166 for (sal_uInt32 i = 0; i < nItemSize; ++i)
167 ReadUInt16( pString[ i ] );
168 if ( pString[ nItemSize - 1 ] == 0 )
169 {
170 if ( (sal_uInt16)nItemSize > 1 )
171 rString = OUString(pString, lcl_getMaxSafeStrLen(nItemSize));
172 else
173 rString.clear();
174 bRetValue = true;
175 }
176 delete[] pString;
177 }
178 catch( const std::bad_alloc& )
179 {
180 OSL_FAIL( "sd PropItem::Read bad alloc" );
181 }
182 }
183 if ( bAlign && ( nItemSize & 1 ) )
184 SeekRel( 2 ); // dword align
185 }
186 break;
187 }
188 if ( !bRetValue )
189 Seek( nItemPos );
190 return bRetValue;
191 }
192
193 PropItem& PropItem::operator=( PropItem& rPropItem )
194 {
195 if ( this != &rPropItem )
196 {
197 Seek( STREAM_SEEK_TO_BEGIN );
198 delete[] static_cast<sal_uInt8*>(SwitchBuffer());
199
200 mnTextEnc = rPropItem.mnTextEnc;
201 sal_uInt32 nItemPos = rPropItem.Tell();
202 rPropItem.Seek( STREAM_SEEK_TO_END );
203 SvMemoryStream::Write( rPropItem.GetData(), rPropItem.Tell() );
204 rPropItem.Seek( nItemPos );
205 }
206 return *this;
207 }
208
209 Section::Section( const Section& rSection )
210 : mnTextEnc(rSection.mnTextEnc),
211 maEntries(rSection.maEntries.clone())
212 {
213 for ( int i = 0; i < 16; i++ )
214 aFMTID[ i ] = rSection.aFMTID[ i ];
215 }
216
217 Section::Section( const sal_uInt8* pFMTID )
218 {
219 mnTextEnc = RTL_TEXTENCODING_MS_1252;
220 for ( int i = 0; i < 16; i++ )
221 aFMTID[ i ] = pFMTID[ i ];
222 }
223
224 bool Section::GetProperty( sal_uInt32 nId, PropItem& rPropItem )
225 {
226 if ( nId )
227 {
228 boost::ptr_vector<PropEntry>::const_iterator iter;
229 for (iter = maEntries.begin(); iter != maEntries.end(); ++iter)
230 {
231 if (iter->mnId == nId)
232 break;
233 }
234
235 if (iter != maEntries.end())
236 {
237 rPropItem.Clear();
238 rPropItem.SetTextEncoding( mnTextEnc );
239 rPropItem.Write( iter->mpBuf,iter->mnSize );
240 rPropItem.Seek( STREAM_SEEK_TO_BEGIN );
241 return true;
242 }
243 }
244 return false;
245 }
246
247 void Section::AddProperty( sal_uInt32 nId, const sal_uInt8* pBuf, sal_uInt32 nBufSize )
248 {
249 // just a simple id check
250
251 if ( !nId )
252 return;
253 if ( nId == 0xffffffff )
254 nId = 0;
255
256 // do not allow same PropId's, sort
257 boost::ptr_vector<PropEntry>::iterator iter;
258 for ( iter = maEntries.begin(); iter != maEntries.end(); ++iter )
259 {
260 if ( iter->mnId == nId )
261 maEntries.replace( iter, new PropEntry( nId, pBuf, nBufSize, mnTextEnc ));
262 else if ( iter->mnId > nId )
263 maEntries.insert( iter, new PropEntry( nId, pBuf, nBufSize, mnTextEnc ));
264 else
265 continue;
266 return;
267 }
268
269 maEntries.push_back( new PropEntry( nId, pBuf, nBufSize, mnTextEnc ) );
270 }
271
272 void Section::GetDictionary(Dictionary& rDict)
273 {
274 boost::ptr_vector<PropEntry>::iterator iter;
275 for (iter = maEntries.begin(); iter != maEntries.end(); ++iter)
276 {
277 if ( iter->mnId == 0 )
278 break;
279 }
280
281 if (iter == maEntries.end())
282 return;
283
284 SvMemoryStream aStream( iter->mpBuf, iter->mnSize, StreamMode::READ );
285 aStream.Seek( STREAM_SEEK_TO_BEGIN );
286 sal_uInt32 nDictCount(0);
287 aStream.ReadUInt32( nDictCount );
288 for (sal_uInt32 i = 0; i < nDictCount; ++i)
289 {
290 sal_uInt32 nId(0), nSize(0);
291 aStream.ReadUInt32(nId).ReadUInt32(nSize);
292 if (!aStream.good() || nSize > aStream.remainingSize())
293 break;
294 if (mnTextEnc == RTL_TEXTENCODING_UCS2)
295 nSize >>= 1;
296 if (!nSize)
297 continue;
298 OUString aString;
299 try
300 {
301 if ( mnTextEnc == RTL_TEXTENCODING_UCS2 )
302 {
303 sal_Unicode* pWString = new sal_Unicode[nSize];
304 for (sal_uInt32 j = 0; j < nSize; ++j)
305 aStream.ReadUInt16(pWString[j]);
306 aString = OUString(pWString, lcl_getMaxSafeStrLen(nSize));
307 delete[] pWString;
308 }
309 else
310 {
311 sal_Char* pString = new sal_Char[nSize];
312 aStream.Read(pString, nSize);
313 aString = OUString(pString, lcl_getMaxSafeStrLen(nSize), mnTextEnc);
314 delete[] pString;
315 }
316 }
317 catch( const std::bad_alloc& )
318 {
319 OSL_FAIL( "sd Section::GetDictionary bad alloc" );
320 }
321 if (aString.isEmpty())
322 break;
323 rDict.insert( std::make_pair(aString,nId) );
324 }
325 }
326
327 void Section::Read( SotStorageStream *pStrm )
328 {
329 sal_uInt32 nSecOfs, nPropSize, nStrmSize;
330 nSecOfs = pStrm->Tell();
331
332 pStrm->Seek( STREAM_SEEK_TO_END );
333 nStrmSize = pStrm->Tell();
334 pStrm->Seek( nSecOfs );
335
336 mnTextEnc = RTL_TEXTENCODING_MS_1252;
337 sal_uInt32 nSecSize(0), nPropCount(0);
338 pStrm->ReadUInt32( nSecSize ).ReadUInt32( nPropCount );
339 while (nPropCount--)
340 {
341 sal_uInt32 nPropId(0), nPropOfs(0);
342 pStrm->ReadUInt32(nPropId).ReadUInt32(nPropOfs);
343 if (!pStrm->good())
344 break;
345 auto nCurrent = pStrm->Tell();
346 sal_uInt64 nOffset = nPropOfs + nSecOfs;
347 if (nOffset != pStrm->Seek(nOffset))
348 break;
349 if ( nPropId ) // do not read dictionary
350 {
351 sal_uInt32 nPropType(0), nVectorCount(0);
352 pStrm->ReadUInt32(nPropType);
353
354 nPropSize = 4;
355
356 if ( nPropType & VT_VECTOR )
357 {
358 pStrm->ReadUInt32( nVectorCount );
359 nPropType &=~VT_VECTOR;
360 nPropSize += 4;
361 }
362 else
363 nVectorCount = 1;
364
365 bool bVariant = ( nPropType == VT_VARIANT );
366
367 for (sal_uInt32 i = 0; nPropSize && ( i < nVectorCount ); ++i)
368 {
369 if ( bVariant )
370 {
371 pStrm->ReadUInt32( nPropType );
372 nPropSize += 4;
373 }
374 sal_uInt32 nTemp(0);
375 switch( nPropType )
376 {
377 case VT_UI1 :
378 nPropSize++;
379 break;
380
381 case VT_I2 :
382 case VT_UI2 :
383 case VT_BOOL :
384 nPropSize += 2;
385 break;
386
387 case VT_I4 :
388 case VT_R4 :
389 case VT_UI4 :
390 case VT_ERROR :
391 nPropSize += 4;
392 break;
393
394 case VT_I8 :
395 case VT_R8 :
396 case VT_CY :
397 case VT_UI8 :
398 case VT_DATE :
399 case VT_FILETIME :
400 nPropSize += 8;
401 break;
402
403 case VT_BSTR :
404 pStrm->ReadUInt32( nTemp );
405 nPropSize += ( nTemp + 4 );
406 break;
407
408 case VT_LPSTR :
409 pStrm->ReadUInt32( nTemp );
410 nPropSize += ( nTemp + 4 );
411 break;
412
413 case VT_LPWSTR :
414 {
415 pStrm->ReadUInt32( nTemp );
416 // looks like these are aligned to 4 bytes
417 sal_uInt32 nLength = nPropOfs + nSecOfs + nPropSize + ( nTemp << 1 ) + 4;
418 nPropSize += ( nTemp << 1 ) + 4 + (nLength % 4);
419 }
420 break;
421
422 case VT_BLOB_OBJECT :
423 case VT_BLOB :
424 case VT_CF :
425 pStrm->ReadUInt32( nTemp );
426 nPropSize += ( nTemp + 4 );
427 break;
428
429 case VT_CLSID :
430 case VT_STREAM :
431 case VT_STORAGE :
432 case VT_STREAMED_OBJECT :
433 case VT_STORED_OBJECT :
434 case VT_VARIANT :
435 case VT_VECTOR :
436 default :
437 nPropSize = 0;
438 }
439 if ( nPropSize )
440 {
441 if ( ( nVectorCount - i ) > 1 )
442 {
443 nOffset = nPropOfs + nSecOfs + nPropSize;
444 if (nOffset != pStrm->Seek(nOffset))
445 break;
446 }
447 }
448 else
449 break;
450 }
451 if ( nPropSize )
452 {
453 if ( nPropSize > nStrmSize )
454 {
455 nPropCount = 0;
456 break;
457 }
458 pStrm->Seek( nPropOfs + nSecOfs );
459 // make sure we don't overflow the section size
460 if( nPropSize > nSecSize - nSecOfs )
461 nPropSize = nSecSize - nSecOfs;
462 sal_uInt8* pBuf = new sal_uInt8[ nPropSize ];
463 nPropSize = pStrm->Read(pBuf, nPropSize);
464 AddProperty( nPropId, pBuf, nPropSize );
465 delete[] pBuf;
466 }
467 if ( nPropId == 1 )
468 {
469 PropItem aPropItem;
470 if ( GetProperty( 1, aPropItem ) )
471 {
472 aPropItem.ReadUInt32( nPropType );
473 if ( nPropType == VT_I2 )
474 {
475 sal_uInt16 nCodePage(0);
476 aPropItem.ReadUInt16(nCodePage);
477
478 if ( nCodePage == 1200 )
479 {
480 mnTextEnc = RTL_TEXTENCODING_UCS2;
481 }
482 else
483 {
484 mnTextEnc = rtl_getTextEncodingFromWindowsCodePage( nCodePage );
485 if ( mnTextEnc == RTL_TEXTENCODING_DONTKNOW )
486 mnTextEnc = RTL_TEXTENCODING_MS_1252;
487 }
488 }
489 else
490 {
491 mnTextEnc = RTL_TEXTENCODING_MS_1252;
492 }
493 }
494 }
495 }
496 else
497 {
498 sal_uInt32 nDictCount(0);
499 pStrm->ReadUInt32(nDictCount);
500 auto nMaxRecordsPossible = pStrm->remainingSize() / (sizeof(sal_uInt32)*2);
501 if (nDictCount > nMaxRecordsPossible)
502 {
503 SAL_WARN("sd.filter", "Dictionary count of " << nDictCount << " claimed, only " << nMaxRecordsPossible << " possible");
504 nDictCount = nMaxRecordsPossible;
505 }
506 for (sal_uInt32 i = 0; i < nDictCount; ++i)
507 {
508 sal_uInt32 nSize(0);
509 pStrm->ReadUInt32( nSize ).ReadUInt32( nSize );
510 if (!pStrm->good())
511 break;
512 sal_uInt64 nPos = pStrm->Tell() + nSize;
513 if (nPos != pStrm->Seek(nPos))
514 break;
515 }
516 sal_uInt32 nSize = pStrm->Tell();
517 pStrm->Seek( nPropOfs + nSecOfs );
518 nSize -= pStrm->Tell();
519 if ( nSize > nStrmSize )
520 {
521 nPropCount = 0;
522 break;
523 }
524 sal_uInt8* pBuf = new sal_uInt8[ nSize ];
525 nSize = pStrm->Read(pBuf, nSize);
526 AddProperty( 0xffffffff, pBuf, nSize );
527 delete[] pBuf;
528 }
529 pStrm->Seek(nCurrent);
530 }
531 pStrm->Seek( nSecOfs + nSecSize );
532 }
533
534 Section& Section::operator=( const Section& rSection )
535 {
536 if ( this != &rSection )
537 {
538 memcpy( (void*)aFMTID, (void*)rSection.aFMTID, 16 );
539
540 maEntries = rSection.maEntries.clone();
541 }
542 return *this;
543 }
544
545 PropRead::PropRead( SotStorage& rStorage, const OUString& rName ) :
546 mbStatus ( false ),
547 mnByteOrder ( 0xfffe ),
548 mnFormat ( 0 ),
549 mnVersionLo ( 4 ),
550 mnVersionHi ( 2 )
551 {
552 if ( rStorage.IsStream( rName ) )
553 {
554 mpSvStream = rStorage.OpenSotStream( rName, STREAM_STD_READ );
555 if ( mpSvStream )
556 {
557 mpSvStream->SetEndian( SvStreamEndian::LITTLE );
558 memset( mApplicationCLSID, 0, 16 );
559 mbStatus = true;
560 }
561 }
562 }
563
564 void PropRead::AddSection( Section& rSection )
565 {
566 maSections.push_back( new Section( rSection ) );
567 }
568
569 const Section* PropRead::GetSection( const sal_uInt8* pFMTID )
570 {
571 boost::ptr_vector<Section>::iterator it;
572 for ( it = maSections.begin(); it != maSections.end(); ++it)
573 {
574 if ( memcmp( it->GetFMTID(), pFMTID, 16 ) == 0 )
575 return &(*it);
576 }
577 return NULL;
578 }
579
580 void PropRead::Read()
581 {
582 maSections.clear();
583
584 if ( mbStatus )
585 {
586 sal_uInt32 nSections;
587 sal_uInt32 nSectionOfs;
588 sal_uInt32 nCurrent;
589 mpSvStream->ReadUInt16( mnByteOrder ).ReadUInt16( mnFormat ).ReadUInt16( mnVersionLo ).ReadUInt16( mnVersionHi );
590 if ( mnByteOrder == 0xfffe )
591 {
592 sal_uInt8* pSectCLSID = new sal_uInt8[ 16 ];
593 mpSvStream->Read( mApplicationCLSID, 16 );
594 mpSvStream->ReadUInt32( nSections );
595 if ( nSections > 2 ) // sj: PowerPoint documents are containing max 2 sections
596 {
597 mbStatus = false;
598 }
599 else for ( sal_uInt32 i = 0; i < nSections; i++ )
600 {
601 mpSvStream->Read( pSectCLSID, 16 );
602 mpSvStream->ReadUInt32( nSectionOfs );
603 nCurrent = mpSvStream->Tell();
604 mpSvStream->Seek( nSectionOfs );
605 Section aSection( pSectCLSID );
606 aSection.Read( mpSvStream );
607 AddSection( aSection );
608 mpSvStream->Seek( nCurrent );
609 }
610 delete[] pSectCLSID;
611 }
612 }
613 }
614
615 PropRead& PropRead::operator=( const PropRead& rPropRead )
616 {
617 if ( this != &rPropRead )
618 {
619 mbStatus = rPropRead.mbStatus;
620 mpSvStream = rPropRead.mpSvStream;
621
622 mnByteOrder = rPropRead.mnByteOrder;
623 mnFormat = rPropRead.mnFormat;
624 mnVersionLo = rPropRead.mnVersionLo;
625 mnVersionHi = rPropRead.mnVersionHi;
626 memcpy( mApplicationCLSID, rPropRead.mApplicationCLSID, 16 );
627
628 maSections = rPropRead.maSections.clone();
629 }
630 return *this;
631 }
632
633 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE