?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 6.1.4.1, tag libreoffice-6.1.4.1
[LibreOffice.git] / tools / source / stream / stream.cxx
blobb482758197393f771b61cc8e8691429943b1110d
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 // TODO: Read->RefreshBuffer-> React to changes from m_nBufActualLen
21
22 #include <cstddef>
23 #include <memory>
24
25 #include <string.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28
29 #include <osl/endian.h>
30 #include <osl/diagnose.h>
31 #include <sal/log.hxx>
32
33 #include <comphelper/fileformat.h>
34 #include <comphelper/string.hxx>
35
36 #define SWAPNIBBLES(c) \
37 unsigned char nSwapTmp=c; \
38 nSwapTmp <<= 4; \
39 c >>= 4; \
40 c |= nSwapTmp;
41
42 #include <tools/debug.hxx>
43 #include <tools/stream.hxx>
44 #include <osl/thread.h>
45 #include <algorithm>
46
47 // !!! Do not inline if already the operators <<,>> are inline
48 inline static void SwapUShort( sal_uInt16& r )
49 { r = OSL_SWAPWORD(r); }
50 inline static void SwapShort( short& r )
51 { r = OSL_SWAPWORD(r); }
52 inline static void SwapULong( sal_uInt32& r )
53 { r = OSL_SWAPDWORD(r); }
54 inline static void SwapLongInt( sal_Int32& r )
55 { r = OSL_SWAPDWORD(r); }
56
57 inline static void SwapUInt64( sal_uInt64& r )
58 {
59 union
60 {
61 sal_uInt64 n;
62 sal_uInt32 c[2];
63 } s;
64
65 s.n = r;
66 s.c[0] ^= s.c[1]; // swap the 32 bit words
67 s.c[1] ^= s.c[0];
68 s.c[0] ^= s.c[1];
69 // swap the bytes in the words
70 s.c[0] = OSL_SWAPDWORD(s.c[0]);
71 s.c[1] = OSL_SWAPDWORD(s.c[1]);
72 r = s.n;
73 }
74 inline static void SwapInt64( sal_Int64& r )
75 {
76 union
77 {
78 sal_Int64 n;
79 sal_Int32 c[2];
80 } s;
81
82 s.n = r;
83 s.c[0] ^= s.c[1]; // swap the 32 bit words
84 s.c[1] ^= s.c[0];
85 s.c[0] ^= s.c[1];
86 // swap the bytes in the words
87 s.c[0] = OSL_SWAPDWORD(s.c[0]);
88 s.c[1] = OSL_SWAPDWORD(s.c[1]);
89 r = s.n;
90 }
91
92 #ifdef UNX
93 inline static void SwapFloat( float& r )
94 {
95 union
96 {
97 float f;
98 sal_uInt32 c;
99 } s;
100
101 s.f = r;
102 s.c = OSL_SWAPDWORD( s.c );
103 r = s.f;
104 }
105
106 inline static void SwapDouble( double& r )
107 {
108 if( sizeof(double) != 8 )
109 {
110 SAL_WARN( "tools.stream", "Can only swap 8-Byte-doubles" );
111 }
112 else
113 {
114 union
115 {
116 double d;
117 sal_uInt32 c[2];
118 } s;
119
120 s.d = r;
121 s.c[0] ^= s.c[1]; // swap 32-bit values in situ
122 s.c[1] ^= s.c[0];
123 s.c[0] ^= s.c[1];
124 s.c[0] = OSL_SWAPDWORD(s.c[0]); // swap dword itself in situ
125 s.c[1] = OSL_SWAPDWORD(s.c[1]);
126 r = s.d;
127 }
128 }
129 #endif
130
131 static void SwapUnicode(sal_Unicode & r) { r = OSL_SWAPWORD(r); }
132
133 //SDO
134
135 void SvStream::readNumberWithoutSwap_(void * pDataDest, int nDataSize)
136 {
137 if (m_isIoRead && nDataSize <= m_nBufFree)
138 {
139 for (int i = 0; i < nDataSize; i++)
140 static_cast<char*>(pDataDest)[i] = m_pBufPos[i];
141 m_nBufActualPos += nDataSize;
142 m_pBufPos += nDataSize;
143 m_nBufFree -= nDataSize;
144 }
145 else
146 {
147 ReadBytes( pDataDest, nDataSize );
148 }
149 }
150
151
152 void SvStream::writeNumberWithoutSwap_(const void * pDataSrc, int nDataSize)
153 {
154 if (m_isIoWrite && nDataSize <= m_nBufFree)
155 {
156 for (int i = 0; i < nDataSize; i++)
157 m_pBufPos[i] = static_cast<const char*>(pDataSrc)[i];
158 m_nBufFree -= nDataSize;
159 m_nBufActualPos += nDataSize;
160 if (m_nBufActualPos > m_nBufActualLen)
161 m_nBufActualLen = m_nBufActualPos;
162 m_pBufPos += nDataSize;
163 m_isDirty = true;
164 }
165 else
166 {
167 WriteBytes( pDataSrc, nDataSize );
168 }
169 }
170
171 // class SvLockBytes
172
173 void SvLockBytes::close()
174 {
175 if (m_bOwner)
176 delete m_pStream;
177 m_pStream = nullptr;
178 }
179
180
181 // virtual
182 ErrCode SvLockBytes::ReadAt(sal_uInt64 const nPos, void * pBuffer, std::size_t nCount,
183 std::size_t * pRead) const
184 {
185 if (!m_pStream)
186 {
187 OSL_FAIL("SvLockBytes::ReadAt(): Bad stream");
188 return ERRCODE_NONE;
189 }
190
191 m_pStream->Seek(nPos);
192 std::size_t nTheRead = m_pStream->ReadBytes(pBuffer, nCount);
193 if (pRead)
194 *pRead = nTheRead;
195 return m_pStream->GetErrorCode();
196 }
197
198 // virtual
199 ErrCode SvLockBytes::WriteAt(sal_uInt64 const nPos, const void * pBuffer, std::size_t nCount,
200 std::size_t * pWritten)
201 {
202 if (!m_pStream)
203 {
204 OSL_FAIL("SvLockBytes::WriteAt(): Bad stream");
205 return ERRCODE_NONE;
206 }
207
208 m_pStream->Seek(nPos);
209 std::size_t nTheWritten = m_pStream->WriteBytes(pBuffer, nCount);
210 if (pWritten)
211 *pWritten = nTheWritten;
212 return m_pStream->GetErrorCode();
213 }
214
215 // virtual
216 ErrCode SvLockBytes::Flush() const
217 {
218 if (!m_pStream)
219 {
220 OSL_FAIL("SvLockBytes::Flush(): Bad stream");
221 return ERRCODE_NONE;
222 }
223
224 m_pStream->Flush();
225 return m_pStream->GetErrorCode();
226 }
227
228 // virtual
229 ErrCode SvLockBytes::SetSize(sal_uInt64 const nSize)
230 {
231 if (!m_pStream)
232 {
233 OSL_FAIL("SvLockBytes::SetSize(): Bad stream");
234 return ERRCODE_NONE;
235 }
236
237 m_pStream->SetStreamSize(nSize);
238 return m_pStream->GetErrorCode();
239 }
240
241 ErrCode SvLockBytes::Stat(SvLockBytesStat * pStat, SvLockBytesStatFlag) const
242 {
243 if (!m_pStream)
244 {
245 OSL_FAIL("SvLockBytes::Stat(): Bad stream");
246 return ERRCODE_NONE;
247 }
248
249 if (pStat)
250 {
251 sal_uInt64 const nPos = m_pStream->Tell();
252 pStat->nSize = m_pStream->Seek(STREAM_SEEK_TO_END);
253 m_pStream->Seek(nPos);
254 }
255 return ERRCODE_NONE;
256 }
257
258 // class SvStream
259
260 std::size_t SvStream::GetData( void* pData, std::size_t nSize )
261 {
262 if( !GetError() )
263 {
264 DBG_ASSERT( m_xLockBytes.is(), "pure virtual function" );
265 std::size_t nRet(0);
266 m_nError = m_xLockBytes->ReadAt(m_nActPos, pData, nSize, &nRet);
267 m_nActPos += nRet;
268 return nRet;
269 }
270 else return 0;
271 }
272
273 std::size_t SvStream::PutData( const void* pData, std::size_t nSize )
274 {
275 if( !GetError() )
276 {
277 DBG_ASSERT( m_xLockBytes.is(), "pure virtual function" );
278 std::size_t nRet(0);
279 m_nError = m_xLockBytes->WriteAt(m_nActPos, pData, nSize, &nRet);
280 m_nActPos += nRet;
281 return nRet;
282 }
283 else return 0;
284 }
285
286 sal_uInt64 SvStream::SeekPos(sal_uInt64 const nPos)
287 {
288 // check if a truncated STREAM_SEEK_TO_END was passed
289 assert(nPos != SAL_MAX_UINT32);
290 if( !GetError() && nPos == STREAM_SEEK_TO_END )
291 {
292 DBG_ASSERT( m_xLockBytes.is(), "pure virtual function" );
293 SvLockBytesStat aStat;
294 m_xLockBytes->Stat( &aStat, SVSTATFLAG_DEFAULT );
295 m_nActPos = aStat.nSize;
296 }
297 else
298 m_nActPos = nPos;
299 return m_nActPos;
300 }
301
302 void SvStream::FlushData()
303 {
304 if( !GetError() )
305 {
306 DBG_ASSERT( m_xLockBytes.is(), "pure virtual function" );
307 m_nError = m_xLockBytes->Flush();
308 }
309 }
310
311 void SvStream::SetSize(sal_uInt64 const nSize)
312 {
313 DBG_ASSERT( m_xLockBytes.is(), "pure virtual function" );
314 m_nError = m_xLockBytes->SetSize( nSize );
315 }
316
317 SvStream::SvStream() :
318 m_nActPos(0)
319
320 , m_pRWBuf(nullptr)
321 , m_pBufPos(nullptr)
322 , m_nBufSize(0)
323 , m_nBufActualLen(0)
324 , m_nBufActualPos(0)
325 , m_nBufFree(0)
326 , m_isIoRead(false)
327 , m_isIoWrite(false)
328
329 , m_isDirty(false)
330 , m_isConsistent(true)
331 , m_isEof(false)
332
333 , m_nCompressMode(SvStreamCompressFlags::NONE)
334 #if defined UNX
335 , m_eLineDelimiter(LINEEND_LF) // UNIX-Format
336 #else
337 , m_eLineDelimiter(LINEEND_CRLF) // DOS-Format
338 #endif
339 , m_eStreamCharSet(osl_getThreadTextEncoding())
340
341 , m_nCryptMask(0)
342
343 , m_nVersion(0)
344
345 , m_nBufFilePos(0)
346 , m_eStreamMode(StreamMode::NONE)
347 , m_isWritable(true)
348
349 {
350 SetEndian( SvStreamEndian::LITTLE );
351
352 ClearError();
353 }
354
355 SvStream::SvStream( SvLockBytes* pLockBytesP ) : SvStream()
356 {
357 m_xLockBytes = pLockBytesP;
358 if( pLockBytesP ) {
359 const SvStream* pStrm = pLockBytesP->GetStream();
360 if( pStrm ) {
361 SetError( pStrm->GetErrorCode() );
362 }
363 }
364 SetBufferSize( 256 );
365 }
366
367 SvStream::~SvStream()
368 {
369 if (m_xLockBytes.is())
370 Flush();
371 }
372
373 void SvStream::ClearError()
374 {
375 m_isEof = false;
376 m_nError = ERRCODE_NONE;
377 }
378
379 void SvStream::SetError( ErrCode nErrorCode )
380 {
381 if (m_nError == ERRCODE_NONE)
382 m_nError = nErrorCode;
383 }
384
385 void SvStream::SetEndian( SvStreamEndian nNewFormat )
386 {
387 m_nEndian = nNewFormat;
388 m_isSwap = false;
389 #ifdef OSL_BIGENDIAN
390 if (m_nEndian == SvStreamEndian::LITTLE)
391 m_isSwap = true;
392 #else
393 if (m_nEndian == SvStreamEndian::BIG)
394 m_isSwap = true;
395 #endif
396 }
397
398 void SvStream::SetBufferSize( sal_uInt16 nBufferSize )
399 {
400 sal_uInt64 const nActualFilePos = Tell();
401 bool bDontSeek = (m_pRWBuf == nullptr);
402
403 if (m_isDirty && m_isConsistent && m_isWritable) // due to Windows NT: Access denied
404 Flush();
405
406 if (m_nBufSize)
407 {
408 m_pRWBuf.reset();
409 m_nBufFilePos += m_nBufActualPos;
410 }
411
412 m_pRWBuf = nullptr;
413 m_nBufActualLen = 0;
414 m_nBufActualPos = 0;
415 m_nBufSize = nBufferSize;
416 if (m_nBufSize)
417 m_pRWBuf.reset(new sal_uInt8[ m_nBufSize ]);
418 m_isConsistent = true;
419 m_pBufPos = m_pRWBuf.get();
420 m_isIoRead = m_isIoWrite = false;
421 if( !bDontSeek )
422 SeekPos( nActualFilePos );
423 }
424
425 void SvStream::ClearBuffer()
426 {
427 m_nBufActualLen = 0;
428 m_nBufActualPos = 0;
429 m_nBufFilePos = 0;
430 m_pBufPos = m_pRWBuf.get();
431 m_isDirty = false;
432 m_isConsistent = true;
433 m_isIoRead = m_isIoWrite = false;
434
435 m_isEof = false;
436 }
437
438 void SvStream::ResetError()
439 {
440 ClearError();
441 }
442
443 bool SvStream::ReadByteStringLine( OUString& rStr, rtl_TextEncoding eSrcCharSet,
444 sal_Int32 nMaxBytesToRead )
445 {
446 OString aStr;
447 bool bRet = ReadLine( aStr, nMaxBytesToRead);
448 rStr = OStringToOUString(aStr, eSrcCharSet);
449 return bRet;
450 }
451
452 bool SvStream::ReadLine( OString& rStr, sal_Int32 nMaxBytesToRead )
453 {
454 sal_Char buf[256+1];
455 bool bEnd = false;
456 sal_uInt64 nOldFilePos = Tell();
457 sal_Char c = 0;
458 std::size_t nTotalLen = 0;
459
460 OStringBuffer aBuf(4096);
461 while( !bEnd && !GetError() ) // Don't test for EOF as we
462 // are reading block-wise!
463 {
464 sal_uInt16 nLen = static_cast<sal_uInt16>(ReadBytes(buf, sizeof(buf)-1));
465 if ( !nLen )
466 {
467 if ( aBuf.isEmpty() )
468 {
469 // Exit on first block-read error
470 m_isEof = true;
471 rStr.clear();
472 return false;
473 }
474 else
475 break;
476 }
477
478 sal_uInt16 j, n;
479 for( j = n = 0; j < nLen ; ++j )
480 {
481 c = buf[j];
482 if ( c == '\n' || c == '\r' )
483 {
484 bEnd = true;
485 break;
486 }
487 if ( n < j )
488 buf[n] = c;
489 ++n;
490 }
491 nTotalLen += j;
492 if (nTotalLen > static_cast<std::size_t>(nMaxBytesToRead))
493 {
494 n -= nTotalLen - nMaxBytesToRead;
495 nTotalLen = nMaxBytesToRead;
496 bEnd = true;
497 }
498 if ( n )
499 aBuf.append(buf, n);
500 }
501
502 if ( !bEnd && !GetError() && !aBuf.isEmpty() )
503 bEnd = true;
504
505 nOldFilePos += nTotalLen;
506 if( Tell() > nOldFilePos )
507 nOldFilePos++;
508 Seek( nOldFilePos ); // Seek pointer due to BlockRead above
509
510 if ( bEnd && (c=='\r' || c=='\n') ) // Special treatment for DOS files
511 {
512 char cTemp;
513 std::size_t nLen = ReadBytes(&cTemp, sizeof(cTemp));
514 if ( nLen ) {
515 if( cTemp == c || (cTemp != '\n' && cTemp != '\r') )
516 Seek( nOldFilePos );
517 }
518 }
519
520 if ( bEnd )
521 m_isEof = false;
522 rStr = aBuf.makeStringAndClear();
523 return bEnd;
524 }
525
526 bool SvStream::ReadUniStringLine( OUString& rStr, sal_Int32 nMaxCodepointsToRead )
527 {
528 sal_Unicode buf[256+1];
529 bool bEnd = false;
530 sal_uInt64 nOldFilePos = Tell();
531 sal_Unicode c = 0;
532 std::size_t nTotalLen = 0;
533
534 DBG_ASSERT( sizeof(sal_Unicode) == sizeof(sal_uInt16), "ReadUniStringLine: swapping sizeof(sal_Unicode) not implemented" );
535
536 OUStringBuffer aBuf(4096);
537 while( !bEnd && !GetError() ) // Don't test for EOF as we
538 // are reading block-wise!
539 {
540 sal_uInt16 nLen = static_cast<sal_uInt16>(ReadBytes( buf, sizeof(buf)-sizeof(sal_Unicode)));
541 nLen /= sizeof(sal_Unicode);
542 if ( !nLen )
543 {
544 if ( aBuf.isEmpty() )
545 {
546 // exit on first BlockRead error
547 m_isEof = true;
548 rStr.clear();
549 return false;
550 }
551 else
552 break;
553 }
554
555 sal_uInt16 j, n;
556 for( j = n = 0; j < nLen ; ++j )
557 {
558 if (m_isSwap)
559 SwapUnicode( buf[n] );
560 c = buf[j];
561 if ( c == '\n' || c == '\r' )
562 {
563 bEnd = true;
564 break;
565 }
566 // erAck 26.02.01: Old behavior was no special treatment of '\0'
567 // character here, but a following rStr+=c did ignore it. Is this
568 // really intended? Or should a '\0' better terminate a line?
569 // The nOldFilePos stuff wasn't correct then anyways.
570 if ( c )
571 {
572 if ( n < j )
573 buf[n] = c;
574 ++n;
575 }
576 }
577 nTotalLen += j;
578 if (nTotalLen > static_cast<std::size_t>(nMaxCodepointsToRead))
579 {
580 n -= nTotalLen - nMaxCodepointsToRead;
581 nTotalLen = nMaxCodepointsToRead;
582 bEnd = true;
583 }
584 if ( n )
585 aBuf.append( buf, n );
586 }
587
588 if ( !bEnd && !GetError() && !aBuf.isEmpty() )
589 bEnd = true;
590
591 nOldFilePos += nTotalLen * sizeof(sal_Unicode);
592 if( Tell() > nOldFilePos )
593 nOldFilePos += sizeof(sal_Unicode);
594 Seek( nOldFilePos ); // seek due to BlockRead above
595
596 if ( bEnd && (c=='\r' || c=='\n') ) // special treatment for DOS files
597 {
598 sal_Unicode cTemp;
599 ReadBytes( &cTemp, sizeof(cTemp) );
600 if (m_isSwap)
601 SwapUnicode( cTemp );
602 if( cTemp == c || (cTemp != '\n' && cTemp != '\r') )
603 Seek( nOldFilePos );
604 }
605
606 if ( bEnd )
607 m_isEof = false;
608 rStr = aBuf.makeStringAndClear();
609 return bEnd;
610 }
611
612 bool SvStream::ReadUniOrByteStringLine( OUString& rStr, rtl_TextEncoding eSrcCharSet,
613 sal_Int32 nMaxCodepointsToRead )
614 {
615 if ( eSrcCharSet == RTL_TEXTENCODING_UNICODE )
616 return ReadUniStringLine( rStr, nMaxCodepointsToRead );
617 else
618 return ReadByteStringLine( rStr, eSrcCharSet, nMaxCodepointsToRead );
619 }
620
621 OString read_zeroTerminated_uInt8s_ToOString(SvStream& rStream)
622 {
623 OStringBuffer aOutput(256);
624
625 sal_Char buf[ 256 + 1 ];
626 bool bEnd = false;
627 sal_uInt64 nFilePos = rStream.Tell();
628
629 while( !bEnd && !rStream.GetError() )
630 {
631 std::size_t nLen = rStream.ReadBytes(buf, sizeof(buf)-1);
632 if (!nLen)
633 break;
634
635 std::size_t nReallyRead = nLen;
636 const sal_Char* pPtr = buf;
637 while (nLen && *pPtr)
638 {
639 ++pPtr;
640 --nLen;
641 }
642
643 bEnd = ( nReallyRead < sizeof(buf)-1 ) // read less than attempted to read
644 || ( ( nLen > 0 ) // OR it is inside the block we read
645 && ( 0 == *pPtr ) // AND found a string terminator
646 );
647
648 aOutput.append(buf, pPtr - buf);
649 }
650
651 nFilePos += aOutput.getLength();
652 if (rStream.Tell() > nFilePos)
653 rStream.Seek(nFilePos+1); // seek due to FileRead above
654 return aOutput.makeStringAndClear();
655 }
656
657 OUString read_zeroTerminated_uInt8s_ToOUString(SvStream& rStream, rtl_TextEncoding eEnc)
658 {
659 return OStringToOUString(
660 read_zeroTerminated_uInt8s_ToOString(rStream), eEnc);
661 }
662
663 /** Attempt to write a prefixed sequence of nUnits 16bit units from an OUString,
664 returned value is number of bytes written */
665 std::size_t write_uInt16s_FromOUString(SvStream& rStrm, const OUString& rStr,
666 std::size_t nUnits)
667 {
668 DBG_ASSERT( sizeof(sal_Unicode) == sizeof(sal_uInt16), "write_uInt16s_FromOUString: swapping sizeof(sal_Unicode) not implemented" );
669 std::size_t nWritten;
670 if (!rStrm.IsEndianSwap())
671 nWritten = rStrm.WriteBytes(rStr.getStr(), nUnits * sizeof(sal_Unicode));
672 else
673 {
674 std::size_t nLen = nUnits;
675 sal_Unicode aBuf[384];
676 sal_Unicode* const pTmp = ( nLen > 384 ? new sal_Unicode[nLen] : aBuf);
677 memcpy( pTmp, rStr.getStr(), nLen * sizeof(sal_Unicode) );
678 sal_Unicode* p = pTmp;
679 const sal_Unicode* const pStop = pTmp + nLen;
680 while ( p < pStop )
681 {
682 SwapUnicode( *p );
683 p++;
684 }
685 nWritten = rStrm.WriteBytes( pTmp, nLen * sizeof(sal_Unicode) );
686 if ( pTmp != aBuf )
687 delete [] pTmp;
688 }
689 return nWritten;
690 }
691
692 bool SvStream::WriteUnicodeOrByteText( const OUString& rStr, rtl_TextEncoding eDestCharSet )
693 {
694 if ( eDestCharSet == RTL_TEXTENCODING_UNICODE )
695 {
696 write_uInt16s_FromOUString(*this, rStr, rStr.getLength());
697 return m_nError == ERRCODE_NONE;
698 }
699 else
700 {
701 OString aStr(OUStringToOString(rStr, eDestCharSet));
702 write_uInt8s_FromOString(*this, aStr, aStr.getLength());
703 return m_nError == ERRCODE_NONE;
704 }
705 }
706
707 bool SvStream::WriteByteStringLine( const OUString& rStr, rtl_TextEncoding eDestCharSet )
708 {
709 return WriteLine(OUStringToOString(rStr, eDestCharSet));
710 }
711
712 bool SvStream::WriteLine(const OString& rStr)
713 {
714 WriteBytes(rStr.getStr(), rStr.getLength());
715 endl(*this);
716 return m_nError == ERRCODE_NONE;
717 }
718
719 bool SvStream::WriteUniOrByteChar( sal_Unicode ch, rtl_TextEncoding eDestCharSet )
720 {
721 if ( eDestCharSet == RTL_TEXTENCODING_UNICODE )
722 WriteUnicode(ch);
723 else
724 {
725 OString aStr(&ch, 1, eDestCharSet);
726 WriteBytes(aStr.getStr(), aStr.getLength());
727 }
728 return m_nError == ERRCODE_NONE;
729 }
730
731 void SvStream::StartWritingUnicodeText()
732 {
733 // BOM, Byte Order Mark, U+FEFF, see
734 // http://www.unicode.org/faq/utf_bom.html#BOM
735 // Upon read: 0xfeff(-257) => no swap; 0xfffe(-2) => swap
736 writeNumberWithoutSwap(sal_uInt16(0xfeff)); // write native format
737 }
738
739 void SvStream::StartReadingUnicodeText( rtl_TextEncoding eReadBomCharSet )
740 {
741 if (!( eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
742 eReadBomCharSet == RTL_TEXTENCODING_UNICODE ||
743 eReadBomCharSet == RTL_TEXTENCODING_UTF8))
744 return; // nothing to read
745
746 bool bTryUtf8 = false;
747 sal_uInt16 nFlag(0);
748 sal_sSize nBack = sizeof(nFlag);
749 ReadUInt16( nFlag );
750 switch ( nFlag )
751 {
752 case 0xfeff :
753 // native UTF-16
754 if ( eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
755 eReadBomCharSet == RTL_TEXTENCODING_UNICODE)
756 nBack = 0;
757 break;
758 case 0xfffe :
759 // swapped UTF-16
760 if ( eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
761 eReadBomCharSet == RTL_TEXTENCODING_UNICODE)
762 {
763 SetEndian( m_nEndian == SvStreamEndian::BIG ? SvStreamEndian::LITTLE : SvStreamEndian::BIG );
764 nBack = 0;
765 }
766 break;
767 case 0xefbb :
768 if (m_nEndian == SvStreamEndian::BIG &&
769 (eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
770 eReadBomCharSet == RTL_TEXTENCODING_UTF8))
771 bTryUtf8 = true;
772 break;
773 case 0xbbef :
774 if (m_nEndian == SvStreamEndian::LITTLE &&
775 (eReadBomCharSet == RTL_TEXTENCODING_DONTKNOW ||
776 eReadBomCharSet == RTL_TEXTENCODING_UTF8))
777 bTryUtf8 = true;
778 break;
779 default:
780 ; // nothing
781 }
782 if (bTryUtf8)
783 {
784 unsigned char nChar(0);
785 nBack += sizeof(nChar);
786 ReadUChar( nChar );
787 if (nChar == 0xbf)
788 nBack = 0; // it is UTF-8
789 }
790 if (nBack)
791 SeekRel( -nBack ); // no BOM, pure data
792 }
793
794 sal_uInt64 SvStream::SeekRel(sal_Int64 const nPos)
795 {
796 sal_uInt64 nActualPos = Tell();
797
798 if ( nPos >= 0 )
799 {
800 if (SAL_MAX_UINT64 - nActualPos > static_cast<sal_uInt64>(nPos))
801 nActualPos += nPos;
802 }
803 else
804 {
805 sal_uInt64 const nAbsPos = static_cast<sal_uInt64>(-nPos);
806 if ( nActualPos >= nAbsPos )
807 nActualPos -= nAbsPos;
808 }
809
810 m_pBufPos = m_pRWBuf.get() + nActualPos;
811 return Seek( nActualPos );
812 }
813
814 SvStream& SvStream::ReadUInt16(sal_uInt16& r)
815 {
816 sal_uInt16 n = 0;
817 readNumberWithoutSwap(n);
818 if (good())
819 {
820 if (m_isSwap)
821 SwapUShort(n);
822 r = n;
823 }
824 return *this;
825 }
826
827 SvStream& SvStream::ReadUInt32(sal_uInt32& r)
828 {
829 sal_uInt32 n = 0;
830 readNumberWithoutSwap(n);
831 if (good())
832 {
833 if (m_isSwap)
834 SwapULong(n);
835 r = n;
836 }
837 return *this;
838 }
839
840 SvStream& SvStream::ReadUInt64(sal_uInt64& r)
841 {
842 sal_uInt64 n = 0;
843 readNumberWithoutSwap(n);
844 if (good())
845 {
846 if (m_isSwap)
847 SwapUInt64(n);
848 r = n;
849 }
850 return *this;
851 }
852
853 SvStream& SvStream::ReadInt16(sal_Int16& r)
854 {
855 sal_Int16 n = 0;
856 readNumberWithoutSwap(n);
857 if (good())
858 {
859 if (m_isSwap)
860 SwapShort(n);
861 r = n;
862 }
863 return *this;
864 }
865
866 SvStream& SvStream::ReadInt32(sal_Int32& r)
867 {
868 sal_Int32 n = 0;
869 readNumberWithoutSwap(n);
870 if (good())
871 {
872 if (m_isSwap)
873 SwapLongInt(n);
874 r = n;
875 }
876 return *this;
877 }
878
879 SvStream& SvStream::ReadInt64(sal_Int64& r)
880 {
881 sal_Int64 n = 0;
882 readNumberWithoutSwap(n);
883 if (good())
884 {
885 if (m_isSwap)
886 SwapInt64(n);
887 r = n;
888 }
889 return *this;
890 }
891
892 SvStream& SvStream::ReadSChar( signed char& r )
893 {
894 if ((m_isIoRead || !m_isConsistent) &&
895 sizeof(signed char) <= m_nBufFree)
896 {
897 r = *m_pBufPos;
898 m_nBufActualPos += sizeof(signed char);
899 m_pBufPos += sizeof(signed char);
900 m_nBufFree -= sizeof(signed char);
901 }
902 else
903 ReadBytes( &r, sizeof(signed char) );
904 return *this;
905 }
906
907 // Special treatment for Chars due to PutBack
908
909 SvStream& SvStream::ReadChar( char& r )
910 {
911 if ((m_isIoRead || !m_isConsistent) &&
912 sizeof(char) <= m_nBufFree)
913 {
914 r = *m_pBufPos;
915 m_nBufActualPos += sizeof(char);
916 m_pBufPos += sizeof(char);
917 m_nBufFree -= sizeof(char);
918 }
919 else
920 ReadBytes( &r, sizeof(char) );
921 return *this;
922 }
923
924 SvStream& SvStream::ReadUChar( unsigned char& r )
925 {
926 if ((m_isIoRead || !m_isConsistent) &&
927 sizeof(char) <= m_nBufFree)
928 {
929 r = *m_pBufPos;
930 m_nBufActualPos += sizeof(char);
931 m_pBufPos += sizeof(char);
932 m_nBufFree -= sizeof(char);
933 }
934 else
935 ReadBytes( &r, sizeof(char) );
936 return *this;
937 }
938
939 SvStream& SvStream::ReadUtf16(sal_Unicode& r)
940 {
941 sal_uInt16 n = 0;
942 readNumberWithoutSwap(n);
943 if (good())
944 {
945 if (m_isSwap)
946 SwapUShort(n);
947 r = sal_Unicode(n);
948 }
949 return *this;
950 }
951
952 SvStream& SvStream::ReadCharAsBool( bool& r )
953 {
954 if ((m_isIoRead || !m_isConsistent) &&
955 sizeof(char) <= m_nBufFree)
956 {
957 SAL_WARN_IF(
958 *m_pBufPos > 1, "tools.stream", unsigned(*m_pBufPos) << " not 0/1");
959 r = *m_pBufPos != 0;
960 m_nBufActualPos += sizeof(char);
961 m_pBufPos += sizeof(char);
962 m_nBufFree -= sizeof(char);
963 }
964 else
965 {
966 unsigned char c;
967 if (ReadBytes(&c, 1) == 1)
968 {
969 SAL_WARN_IF(c > 1, "tools.stream", unsigned(c) << " not 0/1");
970 r = c != 0;
971 }
972 }
973 return *this;
974 }
975
976 SvStream& SvStream::ReadFloat(float& r)
977 {
978 float n = 0;
979 readNumberWithoutSwap(n);
980 if (good())
981 {
982 #if defined UNX
983 if (m_isSwap)
984 SwapFloat(n);
985 #endif
986 r = n;
987 }
988 return *this;
989 }
990
991 SvStream& SvStream::ReadDouble(double& r)
992 {
993 double n = 0;
994 readNumberWithoutSwap(n);
995 if (good())
996 {
997 #if defined UNX
998 if (m_isSwap)
999 SwapDouble(n);
1000 #endif
1001 r = n;
1002 }
1003 return *this;
1004 }
1005
1006 SvStream& SvStream::ReadStream( SvStream& rStream )
1007 {
1008 const sal_uInt32 cBufLen = 0x8000;
1009 std::unique_ptr<char[]> pBuf( new char[ cBufLen ] );
1010
1011 sal_uInt32 nCount;
1012 do {
1013 nCount = ReadBytes( pBuf.get(), cBufLen );
1014 rStream.WriteBytes( pBuf.get(), nCount );
1015 } while( nCount == cBufLen );
1016
1017 return *this;
1018 }
1019
1020 SvStream& SvStream::WriteUInt16( sal_uInt16 v )
1021 {
1022 if (m_isSwap)
1023 SwapUShort(v);
1024 writeNumberWithoutSwap(v);
1025 return *this;
1026 }
1027
1028 SvStream& SvStream::WriteUInt32( sal_uInt32 v )
1029 {
1030 if (m_isSwap)
1031 SwapULong(v);
1032 writeNumberWithoutSwap(v);
1033 return *this;
1034 }
1035
1036 SvStream& SvStream::WriteUInt64( sal_uInt64 v )
1037 {
1038 if (m_isSwap)
1039 SwapUInt64(v);
1040 writeNumberWithoutSwap(v);
1041 return *this;
1042 }
1043
1044 SvStream& SvStream::WriteInt16( sal_Int16 v )
1045 {
1046 if (m_isSwap)
1047 SwapShort(v);
1048 writeNumberWithoutSwap(v);
1049 return *this;
1050 }
1051
1052 SvStream& SvStream::WriteInt32( sal_Int32 v )
1053 {
1054 if (m_isSwap)
1055 SwapLongInt(v);
1056 writeNumberWithoutSwap(v);
1057 return *this;
1058 }
1059
1060 SvStream& SvStream::WriteInt64 (sal_Int64 v)
1061 {
1062 if (m_isSwap)
1063 SwapInt64(v);
1064 writeNumberWithoutSwap(v);
1065 return *this;
1066 }
1067
1068 SvStream& SvStream::WriteSChar( signed char v )
1069 {
1070 //SDO
1071 if (m_isIoWrite && sizeof(signed char) <= m_nBufFree)
1072 {
1073 *m_pBufPos = v;
1074 m_pBufPos++; // sizeof(char);
1075 m_nBufActualPos++;
1076 if (m_nBufActualPos > m_nBufActualLen) // Append ?
1077 m_nBufActualLen = m_nBufActualPos;
1078 m_nBufFree--; // = sizeof(char);
1079 m_isDirty = true;
1080 }
1081 else
1082 WriteBytes( &v, sizeof(signed char) );
1083 return *this;
1084 }
1085
1086 // Special treatment for Chars due to PutBack
1087
1088 SvStream& SvStream::WriteChar( char v )
1089 {
1090 //SDO
1091 if (m_isIoWrite && sizeof(char) <= m_nBufFree)
1092 {
1093 *m_pBufPos = v;
1094 m_pBufPos++; // sizeof(char);
1095 m_nBufActualPos++;
1096 if (m_nBufActualPos > m_nBufActualLen) // Append ?
1097 m_nBufActualLen = m_nBufActualPos;
1098 m_nBufFree--; // = sizeof(char);
1099 m_isDirty = true;
1100 }
1101 else
1102 WriteBytes( &v, sizeof(char) );
1103 return *this;
1104 }
1105
1106 SvStream& SvStream::WriteUChar( unsigned char v )
1107 {
1108 //SDO
1109 if (m_isIoWrite && sizeof(char) <= m_nBufFree)
1110 {
1111 *reinterpret_cast<unsigned char*>(m_pBufPos) = v;
1112 m_pBufPos++; // = sizeof(char);
1113 m_nBufActualPos++; // = sizeof(char);
1114 if (m_nBufActualPos > m_nBufActualLen) // Append ?
1115 m_nBufActualLen = m_nBufActualPos;
1116 m_nBufFree--;
1117 m_isDirty = true;
1118 }
1119 else
1120 WriteBytes( &v, sizeof(char) );
1121 return *this;
1122 }
1123
1124 SvStream& SvStream::WriteUInt8( sal_uInt8 v )
1125 {
1126 return WriteUChar(v);
1127 }
1128
1129 SvStream& SvStream::WriteUnicode( sal_Unicode v )
1130 {
1131 return WriteUInt16(v);
1132 }
1133
1134 SvStream& SvStream::WriteFloat( float v )
1135 {
1136 #ifdef UNX
1137 if (m_isSwap)
1138 SwapFloat(v);
1139 #endif
1140 writeNumberWithoutSwap(v);
1141 return *this;
1142 }
1143
1144 SvStream& SvStream::WriteDouble ( const double& r )
1145 {
1146 #if defined UNX
1147 if (m_isSwap)
1148 {
1149 double nHelp = r;
1150 SwapDouble(nHelp);
1151 writeNumberWithoutSwap(nHelp);
1152 return *this;
1153 }
1154 else
1155 #endif
1156 {
1157 writeNumberWithoutSwap(r);
1158 }
1159 return *this;
1160 }
1161
1162 SvStream& SvStream::WriteCharPtr( const char* pBuf )
1163 {
1164 WriteBytes( pBuf, strlen(pBuf) );
1165 return *this;
1166 }
1167
1168 SvStream& SvStream::WriteStream( SvStream& rStream )
1169 {
1170 const sal_uInt32 cBufLen = 0x8000;
1171 std::unique_ptr<char[]> pBuf( new char[ cBufLen ] );
1172 sal_uInt32 nCount;
1173 do {
1174 nCount = rStream.ReadBytes( pBuf.get(), cBufLen );
1175 WriteBytes( pBuf.get(), nCount );
1176 } while( nCount == cBufLen );
1177
1178 return *this;
1179 }
1180
1181 sal_uInt64 SvStream::WriteStream( SvStream& rStream, sal_uInt64 nSize )
1182 {
1183 const sal_uInt32 cBufLen = 0x8000;
1184 std::unique_ptr<char[]> pBuf( new char[ cBufLen ] );
1185 sal_uInt32 nCurBufLen = cBufLen;
1186 sal_uInt32 nCount;
1187 sal_uInt64 nWriteSize = nSize;
1188
1189 do
1190 {
1191 nCurBufLen = std::min<sal_uInt64>(nCurBufLen, nWriteSize);
1192 nCount = rStream.ReadBytes(pBuf.get(), nCurBufLen);
1193 WriteBytes( pBuf.get(), nCount );
1194 nWriteSize -= nCount;
1195 }
1196 while( nWriteSize && nCount == nCurBufLen );
1197
1198 return nSize - nWriteSize;
1199 }
1200
1201 OUString SvStream::ReadUniOrByteString( rtl_TextEncoding eSrcCharSet )
1202 {
1203 // read UTF-16 string directly from stream ?
1204 if (eSrcCharSet == RTL_TEXTENCODING_UNICODE)
1205 return read_uInt32_lenPrefixed_uInt16s_ToOUString(*this);
1206 return read_uInt16_lenPrefixed_uInt8s_ToOUString(*this, eSrcCharSet);
1207 }
1208
1209 SvStream& SvStream::WriteUniOrByteString( const OUString& rStr, rtl_TextEncoding eDestCharSet )
1210 {
1211 // write UTF-16 string directly into stream ?
1212 if (eDestCharSet == RTL_TEXTENCODING_UNICODE)
1213 write_uInt32_lenPrefixed_uInt16s_FromOUString(*this, rStr);
1214 else
1215 write_uInt16_lenPrefixed_uInt8s_FromOUString(*this, rStr, eDestCharSet);
1216 return *this;
1217 }
1218
1219 void SvStream::FlushBuffer(bool isConsistent)
1220 {
1221 if (m_isDirty && isConsistent) // Does stream require a flush?
1222 {
1223 SeekPos(m_nBufFilePos);
1224 if (m_nCryptMask)
1225 CryptAndWriteBuffer(m_pRWBuf.get(), m_nBufActualLen);
1226 else if (PutData(m_pRWBuf.get(), m_nBufActualLen) != m_nBufActualLen)
1227 SetError(SVSTREAM_WRITE_ERROR);
1228 m_isDirty = false;
1229 }
1230 }
1231
1232 std::size_t SvStream::ReadBytes( void* pData, std::size_t nCount )
1233 {
1234 std::size_t nSaveCount = nCount;
1235 if (!m_isConsistent)
1236 RefreshBuffer();
1237
1238 if (!m_pRWBuf)
1239 {
1240 nCount = GetData( pData,nCount);
1241 if (m_nCryptMask)
1242 EncryptBuffer(pData, nCount);
1243 m_nBufFilePos += nCount;
1244 }
1245 else
1246 {
1247 // check if block is completely within buffer
1248 m_isIoRead = true;
1249 m_isIoWrite = false;
1250 if (nCount <= static_cast<std::size_t>(m_nBufActualLen - m_nBufActualPos))
1251 {
1252 // => yes
1253 if (nCount != 0)
1254 memcpy(pData, m_pBufPos, static_cast<size_t>(nCount));
1255 m_nBufActualPos = m_nBufActualPos + static_cast<sal_uInt16>(nCount);
1256 m_pBufPos += nCount;
1257 m_nBufFree = m_nBufFree - static_cast<sal_uInt16>(nCount);
1258 }
1259 else
1260 {
1261 FlushBuffer(true);
1262
1263 // Does data block fit into buffer?
1264 if (nCount > m_nBufSize)
1265 {
1266 // => No! Thus read directly
1267 // into target area without using the buffer
1268
1269 m_isIoRead = false;
1270
1271 SeekPos(m_nBufFilePos + m_nBufActualPos);
1272 m_nBufActualLen = 0;
1273 m_pBufPos = m_pRWBuf.get();
1274 nCount = GetData( pData, nCount );
1275 if (m_nCryptMask)
1276 EncryptBuffer(pData, nCount);
1277 m_nBufFilePos += nCount;
1278 m_nBufFilePos += m_nBufActualPos;
1279 m_nBufActualPos = 0;
1280 }
1281 else
1282 {
1283 // => Yes. Fill buffer first, then copy to target area
1284
1285 m_nBufFilePos += m_nBufActualPos;
1286 SeekPos(m_nBufFilePos);
1287
1288 // TODO: Typecast before GetData, sal_uInt16 nCountTmp
1289 std::size_t nCountTmp = GetData( m_pRWBuf.get(), m_nBufSize );
1290 if (m_nCryptMask)
1291 EncryptBuffer(m_pRWBuf.get(), nCountTmp);
1292 m_nBufActualLen = static_cast<sal_uInt16>(nCountTmp);
1293 if( nCount > nCountTmp )
1294 {
1295 nCount = nCountTmp; // trim count back, EOF see below
1296 }
1297 memcpy( pData, m_pRWBuf.get(), static_cast<size_t>(nCount) );
1298 m_nBufActualPos = static_cast<sal_uInt16>(nCount);
1299 m_pBufPos = m_pRWBuf.get() + nCount;
1300 }
1301 }
1302 }
1303 m_isEof = false;
1304 m_nBufFree = m_nBufActualLen - m_nBufActualPos;
1305 if (nCount != nSaveCount && m_nError != ERRCODE_IO_PENDING)
1306 m_isEof = true;
1307 if (nCount == nSaveCount && m_nError == ERRCODE_IO_PENDING)
1308 m_nError = ERRCODE_NONE;
1309 return nCount;
1310 }
1311
1312 std::size_t SvStream::WriteBytes( const void* pData, std::size_t nCount )
1313 {
1314 if( !nCount )
1315 return 0;
1316
1317 if (!m_isWritable)
1318 {
1319 SetError( ERRCODE_IO_CANTWRITE );
1320 return 0;
1321 }
1322 if (!m_isConsistent)
1323 RefreshBuffer(); // Remove changes in buffer through PutBack
1324
1325 if (!m_pRWBuf)
1326 {
1327 if (m_nCryptMask)
1328 nCount = CryptAndWriteBuffer( pData, nCount );
1329 else
1330 nCount = PutData( pData, nCount );
1331 m_nBufFilePos += nCount;
1332 return nCount;
1333 }
1334
1335 m_isIoRead = false;
1336 m_isIoWrite = true;
1337 if (nCount <= static_cast<std::size_t>(m_nBufSize - m_nBufActualPos))
1338 {
1339 memcpy( m_pBufPos, pData, static_cast<size_t>(nCount) );
1340 m_nBufActualPos = m_nBufActualPos + static_cast<sal_uInt16>(nCount);
1341 // Update length if buffer was updated
1342 if (m_nBufActualPos > m_nBufActualLen)
1343 m_nBufActualLen = m_nBufActualPos;
1344
1345 m_pBufPos += nCount;
1346 m_isDirty = true;
1347 }
1348 else
1349 {
1350 FlushBuffer(true);
1351
1352 // Does data block fit into buffer?
1353 if (nCount > m_nBufSize)
1354 {
1355 m_isIoWrite = false;
1356 m_nBufFilePos += m_nBufActualPos;
1357 m_nBufActualLen = 0;
1358 m_nBufActualPos = 0;
1359 m_pBufPos = m_pRWBuf.get();
1360 SeekPos(m_nBufFilePos);
1361 if (m_nCryptMask)
1362 nCount = CryptAndWriteBuffer( pData, nCount );
1363 else
1364 nCount = PutData( pData, nCount );
1365 m_nBufFilePos += nCount;
1366 }
1367 else
1368 {
1369 // Copy block to buffer
1370 memcpy( m_pRWBuf.get(), pData, static_cast<size_t>(nCount) );
1371
1372 // Mind the order!
1373 m_nBufFilePos += m_nBufActualPos;
1374 m_nBufActualPos = static_cast<sal_uInt16>(nCount);
1375 m_pBufPos = m_pRWBuf.get() + nCount;
1376 m_nBufActualLen = static_cast<sal_uInt16>(nCount);
1377 m_isDirty = true;
1378 }
1379 }
1380 m_nBufFree = m_nBufSize - m_nBufActualPos;
1381 return nCount;
1382 }
1383
1384 sal_uInt64 SvStream::Seek(sal_uInt64 const nFilePos)
1385 {
1386 m_isIoRead = m_isIoWrite = false;
1387 m_isEof = false;
1388 if (!m_pRWBuf)
1389 {
1390 m_nBufFilePos = SeekPos( nFilePos );
1391 DBG_ASSERT(Tell() == m_nBufFilePos,"Out Of Sync!");
1392 return m_nBufFilePos;
1393 }
1394
1395 // Is seek position within buffer?
1396 if (nFilePos >= m_nBufFilePos && nFilePos <= (m_nBufFilePos + m_nBufActualLen))
1397 {
1398 m_nBufActualPos = static_cast<sal_uInt16>(nFilePos - m_nBufFilePos);
1399 m_pBufPos = m_pRWBuf.get() + m_nBufActualPos;
1400 // Update m_nBufFree to avoid crash upon PutBack
1401 m_nBufFree = m_nBufActualLen - m_nBufActualPos;
1402 }
1403 else
1404 {
1405 FlushBuffer(m_isConsistent);
1406 m_nBufActualLen = 0;
1407 m_nBufActualPos = 0;
1408 m_pBufPos = m_pRWBuf.get();
1409 m_nBufFilePos = SeekPos( nFilePos );
1410 }
1411 return m_nBufFilePos + m_nBufActualPos;
1412 }
1413
1414 bool checkSeek(SvStream &rSt, sal_uInt64 nOffset)
1415 {
1416 const sal_uInt64 nMaxSeek(rSt.Tell() + rSt.remainingSize());
1417 return (nOffset <= nMaxSeek && rSt.Seek(nOffset) == nOffset);
1418 }
1419
1420 //STREAM_SEEK_TO_END in the some of the Seek backends is special cased to be
1421 //efficient, in others e.g. SotStorageStream it's really horribly slow, and in
1422 //those this should be overridden
1423 sal_uInt64 SvStream::remainingSize()
1424 {
1425 sal_uInt64 const nCurr = Tell();
1426 sal_uInt64 const nEnd = Seek(STREAM_SEEK_TO_END);
1427 sal_uInt64 nMaxAvailable = nEnd > nCurr ? (nEnd-nCurr) : 0;
1428 Seek(nCurr);
1429 return nMaxAvailable;
1430 }
1431
1432 void SvStream::Flush()
1433 {
1434 FlushBuffer(m_isConsistent);
1435 if (m_isWritable)
1436 FlushData();
1437 }
1438
1439 void SvStream::RefreshBuffer()
1440 {
1441 FlushBuffer(m_isConsistent);
1442 SeekPos(m_nBufFilePos);
1443 m_nBufActualLen = static_cast<sal_uInt16>(GetData( m_pRWBuf.get(), m_nBufSize ));
1444 if (m_nBufActualLen && m_nError == ERRCODE_IO_PENDING)
1445 m_nError = ERRCODE_NONE;
1446 if (m_nCryptMask)
1447 EncryptBuffer(m_pRWBuf.get(), static_cast<std::size_t>(m_nBufActualLen));
1448 m_isConsistent = true;
1449 m_isIoRead = m_isIoWrite = false;
1450 }
1451
1452 SvStream& SvStream::WriteInt32AsString(sal_Int32 nInt32)
1453 {
1454 char buffer[12];
1455 std::size_t nLen = sprintf(buffer, "%" SAL_PRIdINT32, nInt32);
1456 WriteBytes(buffer, nLen);
1457 return *this;
1458 }
1459
1460 SvStream& SvStream::WriteUInt32AsString(sal_uInt32 nUInt32)
1461 {
1462 char buffer[11];
1463 std::size_t nLen = sprintf(buffer, "%" SAL_PRIuUINT32, nUInt32);
1464 WriteBytes(buffer, nLen);
1465 return *this;
1466 }
1467
1468 #define CRYPT_BUFSIZE 1024
1469
1470 /// Encrypt and write
1471 std::size_t SvStream::CryptAndWriteBuffer( const void* pStart, std::size_t nLen)
1472 {
1473 unsigned char pTemp[CRYPT_BUFSIZE];
1474 unsigned char const * pDataPtr = static_cast<unsigned char const *>(pStart);
1475 std::size_t nCount = 0;
1476 std::size_t nBufCount;
1477 unsigned char nMask = m_nCryptMask;
1478 do
1479 {
1480 if( nLen >= CRYPT_BUFSIZE )
1481 nBufCount = CRYPT_BUFSIZE;
1482 else
1483 nBufCount = nLen;
1484 nLen -= nBufCount;
1485 memcpy( pTemp, pDataPtr, static_cast<sal_uInt16>(nBufCount) );
1486 // ******** Encrypt ********
1487 for (unsigned char & rn : pTemp)
1488 {
1489 unsigned char aCh = rn;
1490 aCh ^= nMask;
1491 SWAPNIBBLES(aCh)
1492 rn = aCh;
1493 }
1494 // *************************
1495 nCount += PutData( pTemp, nBufCount );
1496 pDataPtr += nBufCount;
1497 }
1498 while ( nLen );
1499 return nCount;
1500 }
1501
1502 bool SvStream::EncryptBuffer(void* pStart, std::size_t nLen) const
1503 {
1504 unsigned char* pTemp = static_cast<unsigned char*>(pStart);
1505 unsigned char nMask = m_nCryptMask;
1506
1507 for ( std::size_t n=0; n < nLen; n++, pTemp++ )
1508 {
1509 unsigned char aCh = *pTemp;
1510 SWAPNIBBLES(aCh)
1511 aCh ^= nMask;
1512 *pTemp = aCh;
1513 }
1514 return true;
1515 }
1516
1517 static unsigned char implGetCryptMask(const sal_Char* pStr, sal_Int32 nLen, long nVersion)
1518 {
1519 unsigned char nCryptMask = 0;
1520
1521 if (!nLen)
1522 return nCryptMask;
1523
1524 if( nVersion <= SOFFICE_FILEFORMAT_31 )
1525 {
1526 while( nLen )
1527 {
1528 nCryptMask ^= *pStr;
1529 pStr++;
1530 nLen--;
1531 }
1532 }
1533 else // BugFix #25888#
1534 {
1535 for( sal_Int32 i = 0; i < nLen; i++ ) {
1536 nCryptMask ^= pStr[i];
1537 if( nCryptMask & 0x80 ) {
1538 nCryptMask <<= 1;
1539 nCryptMask++;
1540 }
1541 else
1542 nCryptMask <<= 1;
1543 }
1544 }
1545
1546 if( !nCryptMask )
1547 nCryptMask = 67;
1548
1549 return nCryptMask;
1550 }
1551
1552 void SvStream::SetCryptMaskKey(const OString& rCryptMaskKey)
1553 {
1554 m_aCryptMaskKey = rCryptMaskKey;
1555 m_nCryptMask = implGetCryptMask(m_aCryptMaskKey.getStr(),
1556 m_aCryptMaskKey.getLength(), GetVersion());
1557 }
1558
1559 bool SvStream::SetStreamSize(sal_uInt64 const nSize)
1560 {
1561 #ifdef DBG_UTIL
1562 sal_uInt64 nFPos = Tell();
1563 #endif
1564 sal_uInt16 nBuf = m_nBufSize;
1565 SetBufferSize( 0 );
1566 SetSize( nSize );
1567 SetBufferSize( nBuf );
1568 #ifdef DBG_UTIL
1569 DBG_ASSERT(Tell()==nFPos,"SetStreamSize failed");
1570 #endif
1571 return (m_nError == ERRCODE_NONE);
1572 }
1573
1574 SvStream& endl( SvStream& rStr )
1575 {
1576 LineEnd eDelim = rStr.GetLineDelimiter();
1577 if ( eDelim == LINEEND_CR )
1578 rStr.WriteChar('\r');
1579 else if( eDelim == LINEEND_LF )
1580 rStr.WriteChar('\n');
1581 else
1582 rStr.WriteChar('\r').WriteChar('\n');
1583 return rStr;
1584 }
1585
1586 SvStream& endlu( SvStream& rStrm )
1587 {
1588 switch ( rStrm.GetLineDelimiter() )
1589 {
1590 case LINEEND_CR :
1591 rStrm.WriteUnicode('\r');
1592 break;
1593 case LINEEND_LF :
1594 rStrm.WriteUnicode('\n');
1595 break;
1596 default:
1597 rStrm.WriteUnicode('\r').WriteUnicode('\n');
1598 }
1599 return rStrm;
1600 }
1601
1602 SvStream& endlub( SvStream& rStrm )
1603 {
1604 if ( rStrm.GetStreamCharSet() == RTL_TEXTENCODING_UNICODE )
1605 return endlu( rStrm );
1606 else
1607 return endl( rStrm );
1608 }
1609
1610 SvMemoryStream::SvMemoryStream( void* pBuffer, std::size_t bufSize,
1611 StreamMode eMode )
1612 {
1613 if( eMode & StreamMode::WRITE )
1614 m_isWritable = true;
1615 else
1616 m_isWritable = false;
1617 nEndOfData = bufSize;
1618 bOwnsData = false;
1619 pBuf = static_cast<sal_uInt8 *>(pBuffer);
1620 nResize = 0;
1621 nSize = bufSize;
1622 nPos = 0;
1623 SetBufferSize( 0 );
1624 }
1625
1626 SvMemoryStream::SvMemoryStream( std::size_t nInitSize, std::size_t nResizeOffset )
1627 {
1628 m_isWritable = true;
1629 bOwnsData = true;
1630 nEndOfData = 0;
1631 nResize = nResizeOffset;
1632 nPos = 0;
1633 pBuf = nullptr;
1634 if( nResize != 0 && nResize < 16 )
1635 nResize = 16;
1636 if( nInitSize && !AllocateMemory( nInitSize ) )
1637 {
1638 SetError( SVSTREAM_OUTOFMEMORY );
1639 nSize = 0;
1640 }
1641 else
1642 nSize = nInitSize;
1643 SetBufferSize( 64 );
1644 }
1645
1646 SvMemoryStream::~SvMemoryStream()
1647 {
1648 if( pBuf )
1649 {
1650 if( bOwnsData )
1651 FreeMemory();
1652 else
1653 Flush();
1654 }
1655 }
1656
1657 const void* SvMemoryStream::GetBuffer()
1658 {
1659 return GetData();
1660 }
1661
1662 sal_uInt64 SvMemoryStream::GetSize()
1663 {
1664 Flush();
1665 sal_uInt64 const nTemp = Tell();
1666 sal_uInt64 const nLength = Seek( STREAM_SEEK_TO_END );
1667 Seek( nTemp );
1668 return nLength;
1669 }
1670
1671 void SvMemoryStream::SetBuffer( void* pNewBuf, std::size_t nCount,
1672 std::size_t nEOF )
1673 {
1674 SetBufferSize( 0 ); // Init buffering in the base class
1675 Seek( 0 );
1676 if( bOwnsData )
1677 {
1678 if( pNewBuf != pBuf )
1679 FreeMemory();
1680 }
1681
1682 pBuf = static_cast<sal_uInt8 *>(pNewBuf);
1683 nPos = 0;
1684 nSize = nCount;
1685 nResize = 0;
1686 bOwnsData = false;
1687
1688 if( nEOF > nCount )
1689 nEOF = nCount;
1690 nEndOfData = nEOF;
1691
1692 ResetError();
1693 }
1694
1695 std::size_t SvMemoryStream::GetData( void* pData, std::size_t nCount )
1696 {
1697 std::size_t nMaxCount = nEndOfData-nPos;
1698 if( nCount > nMaxCount )
1699 nCount = nMaxCount;
1700 if (nCount != 0)
1701 {
1702 memcpy( pData, pBuf+nPos, static_cast<size_t>(nCount) );
1703 }
1704 nPos += nCount;
1705 return nCount;
1706 }
1707
1708 std::size_t SvMemoryStream::PutData( const void* pData, std::size_t nCount )
1709 {
1710 if( GetError() )
1711 return 0L;
1712
1713 std::size_t nMaxCount = nSize-nPos;
1714
1715 // check for overflow
1716 if( nCount > nMaxCount )
1717 {
1718 if( nResize == 0 )
1719 {
1720 // copy as much as possible
1721 nCount = nMaxCount;
1722 SetError( SVSTREAM_OUTOFMEMORY );
1723 }
1724 else
1725 {
1726 long nNewResize;
1727 if( nSize && nSize > nResize )
1728 nNewResize = nSize;
1729 else
1730 nNewResize = nResize;
1731
1732 if( (nCount-nMaxCount) < nResize )
1733 {
1734 // lacking memory is smaller than nResize,
1735 // resize accordingly
1736 if( !ReAllocateMemory( nNewResize) )
1737 {
1738 nCount = 0;
1739 SetError( SVSTREAM_WRITE_ERROR );
1740 }
1741 }
1742 else
1743 {
1744 // lacking memory is larger than nResize,
1745 // resize by (nCount-nMaxCount) + resize offset
1746 if( !ReAllocateMemory( nCount-nMaxCount+nNewResize ) )
1747 {
1748 nCount = 0;
1749 SetError( SVSTREAM_WRITE_ERROR );
1750 }
1751 }
1752 }
1753 }
1754 assert(pBuf && "Possibly Reallocate failed");
1755 memcpy( pBuf+nPos, pData, static_cast<size_t>(nCount));
1756
1757 nPos += nCount;
1758 if( nPos > nEndOfData )
1759 nEndOfData = nPos;
1760 return nCount;
1761 }
1762
1763 sal_uInt64 SvMemoryStream::SeekPos(sal_uInt64 const nNewPos)
1764 {
1765 // nEndOfData: First position in stream not allowed to read from
1766 // nSize: Size of allocated buffer
1767
1768 // check if a truncated STREAM_SEEK_TO_END was passed
1769 assert(nNewPos != SAL_MAX_UINT32);
1770 if( nNewPos < nEndOfData )
1771 nPos = nNewPos;
1772 else if( nNewPos == STREAM_SEEK_TO_END )
1773 nPos = nEndOfData;
1774 else
1775 {
1776 if( nNewPos >= nSize ) // Does buffer need extension?
1777 {
1778 if( nResize ) // Is extension possible?
1779 {
1780 long nDiff = static_cast<long>(nNewPos - nSize + 1);
1781 nDiff += static_cast<long>(nResize);
1782 ReAllocateMemory( nDiff );
1783 nPos = nNewPos;
1784 nEndOfData = nNewPos;
1785 }
1786 else // Extension not possible, set pos to end of data
1787 {
1788 // SetError( SVSTREAM_OUTOFMEMORY );
1789 nPos = nEndOfData;
1790 }
1791 }
1792 else // Expand buffer size
1793 {
1794 nPos = nNewPos;
1795 nEndOfData = nNewPos;
1796 }
1797 }
1798 return nPos;
1799 }
1800
1801 void SvMemoryStream::FlushData()
1802 {
1803 }
1804
1805 void SvMemoryStream::ResetError()
1806 {
1807 SvStream::ClearError();
1808 }
1809
1810 bool SvMemoryStream::AllocateMemory( std::size_t nNewSize )
1811 {
1812 pBuf = new sal_uInt8[nNewSize];
1813 return( pBuf != nullptr );
1814 }
1815
1816 // (using Bozo algorithm)
1817 bool SvMemoryStream::ReAllocateMemory( long nDiff )
1818 {
1819 if (!m_isWritable || !bOwnsData)
1820 return false;
1821
1822 bool bRetVal = false;
1823 long nTemp = static_cast<long>(nSize);
1824 nTemp += nDiff;
1825 std::size_t nNewSize = static_cast<std::size_t>(nTemp);
1826
1827 if( nNewSize )
1828 {
1829 sal_uInt8* pNewBuf = new sal_uInt8[nNewSize];
1830
1831 bRetVal = true; // Success!
1832 if( nNewSize < nSize ) // Are we shrinking?
1833 {
1834 memcpy( pNewBuf, pBuf, static_cast<size_t>(nNewSize) );
1835 if( nPos > nNewSize )
1836 nPos = 0;
1837 if( nEndOfData >= nNewSize )
1838 nEndOfData = nNewSize-1;
1839 }
1840 else
1841 {
1842 if (nSize != 0)
1843 {
1844 memcpy( pNewBuf, pBuf, static_cast<size_t>(nSize) );
1845 }
1846 memset(pNewBuf + nSize, 0x00, nNewSize - nSize);
1847 }
1848
1849 FreeMemory();
1850
1851 pBuf = pNewBuf;
1852 nSize = nNewSize;
1853 }
1854 else
1855 {
1856 bRetVal = true;
1857 FreeMemory();
1858 pBuf = nullptr;
1859 nSize = 0;
1860 nEndOfData = 0;
1861 nPos = 0;
1862 }
1863
1864 return bRetVal;
1865 }
1866
1867 void SvMemoryStream::FreeMemory()
1868 {
1869 assert(bOwnsData);
1870 if (bOwnsData)
1871 {
1872 delete[] pBuf;
1873 pBuf = nullptr;
1874 }
1875 }
1876
1877 void* SvMemoryStream::SwitchBuffer()
1878 {
1879 Flush();
1880 if( !bOwnsData )
1881 return nullptr;
1882 Seek( STREAM_SEEK_TO_BEGIN );
1883
1884 void* pRetVal = pBuf;
1885 pBuf = nullptr;
1886 nEndOfData = 0;
1887 nResize = 64;
1888 nPos = 0;
1889
1890 if( nResize != 0 && nResize < 16 )
1891 nResize = 16;
1892
1893 ResetError();
1894
1895 std::size_t nInitSize = 512;
1896 if( !AllocateMemory(nInitSize) )
1897 {
1898 SetError( SVSTREAM_OUTOFMEMORY );
1899 nSize = 0;
1900 }
1901 else
1902 nSize = nInitSize;
1903
1904 SetBufferSize( 64 );
1905 return pRetVal;
1906 }
1907
1908 void SvMemoryStream::SetSize(sal_uInt64 const nNewSize)
1909 {
1910 if (!m_isWritable)
1911 {
1912 SetError(SVSTREAM_INVALID_HANDLE);
1913 return;
1914 }
1915
1916 long nDiff = static_cast<long>(nNewSize) - static_cast<long>(nSize);
1917 ReAllocateMemory( nDiff );
1918 }
1919
1920 //Create a OString of nLen bytes from rStream
1921 OString read_uInt8s_ToOString(SvStream& rStrm, std::size_t nLen)
1922 {
1923 rtl_String *pStr = nullptr;
1924 if (nLen)
1925 {
1926 nLen = std::min<std::size_t>(nLen, SAL_MAX_INT32);
1927 //limit allocation to size of file, but + 1 to set eof state
1928 nLen = std::min<sal_uInt64>(nLen, rStrm.remainingSize() + 1);
1929 //alloc a (ref-count 1) rtl_String of the desired length.
1930 //rtl_String's buffer is uninitialized, except for null termination
1931 pStr = rtl_string_alloc(sal::static_int_cast<sal_Int32>(nLen));
1932 SAL_WARN_IF(!pStr, "tools.stream", "allocation failed");
1933 if (pStr)
1934 {
1935 std::size_t nWasRead = rStrm.ReadBytes(pStr->buffer, nLen);
1936 if (nWasRead != nLen)
1937 {
1938 //on (typically unlikely) short read set length to what we could
1939 //read, and null terminate. Excess buffer capacity remains of
1940 //course, could create a (true) replacement OString if it matters.
1941 pStr->length = sal::static_int_cast<sal_Int32>(nWasRead);
1942 pStr->buffer[pStr->length] = 0;
1943 }
1944 }
1945 }
1946
1947 //take ownership of buffer and return, otherwise return empty string
1948 return pStr ? OString(pStr, SAL_NO_ACQUIRE) : OString();
1949 }
1950
1951 //Create a OUString of nLen sal_Unicode code units from rStream
1952 OUString read_uInt16s_ToOUString(SvStream& rStrm, std::size_t nLen)
1953 {
1954 rtl_uString *pStr = nullptr;
1955 if (nLen)
1956 {
1957 nLen = std::min<std::size_t>(nLen, SAL_MAX_INT32);
1958 //limit allocation to size of file, but + 1 to set eof state
1959 nLen = std::min<sal_uInt64>(nLen, (rStrm.remainingSize() + 2) / 2);
1960 //alloc a (ref-count 1) rtl_uString of the desired length.
1961 //rtl_String's buffer is uninitialized, except for null termination
1962 pStr = rtl_uString_alloc(sal::static_int_cast<sal_Int32>(nLen));
1963 SAL_WARN_IF(!pStr, "tools.stream", "allocation failed");
1964 if (pStr)
1965 {
1966 std::size_t nWasRead = rStrm.ReadBytes(pStr->buffer, nLen*2)/2;
1967 if (nWasRead != nLen)
1968 {
1969 //on (typically unlikely) short read set length to what we could
1970 //read, and null terminate. Excess buffer capacity remains of
1971 //course, could create a (true) replacement OUString if it matters.
1972 pStr->length = sal::static_int_cast<sal_Int32>(nWasRead);
1973 pStr->buffer[pStr->length] = 0;
1974 }
1975 if (rStrm.IsEndianSwap())
1976 {
1977 for (sal_Int32 i = 0; i < pStr->length; ++i)
1978 pStr->buffer[i] = OSL_SWAPWORD(pStr->buffer[i]);
1979 }
1980 }
1981 }
1982
1983 //take ownership of buffer and return, otherwise return empty string
1984 return pStr ? OUString(pStr, SAL_NO_ACQUIRE) : OUString();
1985 }
1986
1987 namespace
1988 {
1989 template <typename T, typename O> T tmpl_convertLineEnd(const T &rIn, LineEnd eLineEnd)
1990 {
1991 // Determine linebreaks and compute length
1992 bool bConvert = false; // Needs conversion
1993 sal_Int32 nStrLen = rIn.getLength();
1994 sal_Int32 nLineEndLen = (eLineEnd == LINEEND_CRLF) ? 2 : 1;
1995 sal_Int32 nLen = 0; // Target length
1996 sal_Int32 i = 0; // Source counter
1997
1998 while (i < nStrLen)
1999 {
2000 // \r or \n causes linebreak
2001 if ( (rIn[i] == '\r') || (rIn[i] == '\n') )
2002 {
2003 nLen = nLen + nLineEndLen;
2004
2005 // If set already, skip expensive test
2006 if ( !bConvert )
2007 {
2008 // Do we need to convert?
2009 if ( ((eLineEnd != LINEEND_LF) && (rIn[i] == '\n')) ||
2010 ((eLineEnd == LINEEND_CRLF) && (i+1) < nStrLen && (rIn[i+1] != '\n')) ||
2011 ((eLineEnd == LINEEND_LF) &&
2012 ((rIn[i] == '\r') || ((i+1) < nStrLen && rIn[i+1] == '\r'))) ||
2013 ((eLineEnd == LINEEND_CR) &&
2014 ((rIn[i] == '\n') || ((i+1) < nStrLen && rIn[i+1] == '\n'))) )
2015 bConvert = true;
2016 }
2017
2018 // skip char if \r\n or \n\r
2019 if ( (i+1) < nStrLen && ((rIn[i+1] == '\r') || (rIn[i+1] == '\n')) &&
2020 (rIn[i] != rIn[i+1]) )
2021 ++i;
2022 }
2023 else
2024 ++nLen;
2025 ++i;
2026 }
2027
2028 if (!bConvert)
2029 return rIn;
2030
2031 // convert linebreaks, insert string
2032 O aNewData(nLen);
2033 i = 0;
2034 while (i < nStrLen)
2035 {
2036 // \r or \n causes linebreak
2037 if ( (rIn[i] == '\r') || (rIn[i] == '\n') )
2038 {
2039 if ( eLineEnd == LINEEND_CRLF )
2040 {
2041 aNewData.append('\r');
2042 aNewData.append('\n');
2043 }
2044 else
2045 {
2046 if ( eLineEnd == LINEEND_CR )
2047 aNewData.append('\r');
2048 else
2049 aNewData.append('\n');
2050 }
2051
2052 if ( (i+1) < nStrLen && ((rIn[i+1] == '\r') || (rIn[i+1] == '\n')) &&
2053 (rIn[i] != rIn[i+1]) )
2054 ++i;
2055 }
2056 else
2057 {
2058 aNewData.append(rIn[i]);
2059 }
2060
2061 ++i;
2062 }
2063
2064 return aNewData.makeStringAndClear();
2065 }
2066 }
2067
2068 OString convertLineEnd(const OString &rIn, LineEnd eLineEnd)
2069 {
2070 return tmpl_convertLineEnd<OString, OStringBuffer>(rIn, eLineEnd);
2071 }
2072
2073 OUString convertLineEnd(const OUString &rIn, LineEnd eLineEnd)
2074 {
2075 return tmpl_convertLineEnd<OUString, OUStringBuffer>(rIn, eLineEnd);
2076 }
2077
2078 std::size_t write_uInt32_lenPrefixed_uInt16s_FromOUString(SvStream& rStrm,
2079 const OUString &rStr)
2080 {
2081 std::size_t nWritten = 0;
2082 sal_uInt32 nUnits = std::min<std::size_t>(rStr.getLength(), std::numeric_limits<sal_uInt32>::max());
2083 SAL_WARN_IF(static_cast<std::size_t>(nUnits) != static_cast<std::size_t>(rStr.getLength()),
2084 "tools.stream",
2085 "string too long for prefix count to fit in output type");
2086 rStrm.WriteUInt32(nUnits);
2087 if (rStrm.good())
2088 {
2089 nWritten += sizeof(sal_uInt32);
2090 nWritten += write_uInt16s_FromOUString(rStrm, rStr, nUnits);
2091 }
2092 return nWritten;
2093 }
2094
2095 std::size_t write_uInt16_lenPrefixed_uInt16s_FromOUString(SvStream& rStrm,
2096 const OUString &rStr)
2097 {
2098 std::size_t nWritten = 0;
2099 sal_uInt16 nUnits = std::min<std::size_t>(rStr.getLength(), std::numeric_limits<sal_uInt16>::max());
2100 SAL_WARN_IF(nUnits != rStr.getLength(),
2101 "tools.stream",
2102 "string too long for prefix count to fit in output type");
2103 rStrm.WriteUInt16(nUnits);
2104 if (rStrm.good())
2105 {
2106 nWritten += sizeof(nUnits);
2107 nWritten += write_uInt16s_FromOUString(rStrm, rStr, nUnits);
2108 }
2109 return nWritten;
2110 }
2111
2112 std::size_t write_uInt16_lenPrefixed_uInt8s_FromOString(SvStream& rStrm,
2113 const OString &rStr)
2114 {
2115 std::size_t nWritten = 0;
2116 sal_uInt16 nUnits = std::min<std::size_t>(rStr.getLength(), std::numeric_limits<sal_uInt16>::max());
2117 SAL_WARN_IF(static_cast<std::size_t>(nUnits) != static_cast<std::size_t>(rStr.getLength()),
2118 "tools.stream",
2119 "string too long for sal_uInt16 count to fit in output type");
2120 rStrm.WriteUInt16( nUnits );
2121 if (rStrm.good())
2122 {
2123 nWritten += sizeof(sal_uInt16);
2124 nWritten += write_uInt8s_FromOString(rStrm, rStr, nUnits);
2125 }
2126 return nWritten;
2127 }
2128
2129 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE