?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update ooo310-m15
[ooovba.git] / sc / source / filter / excel / xestream.cxx
blob0f8262c712ea6e820968501f5001288c53cdaeb7
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: xestream.cxx,v $
10 * $Revision: 1.11.30.2 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include <stdarg.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <utility>
36
37 #include <rtl/ustring.hxx>
38 #include <sax/fshelper.hxx>
39 #include <unotools/streamwrap.hxx>
40
41 #include "precompiled_sc.hxx"
42 #include "docuno.hxx"
43 #include "xestream.hxx"
44 #include "xladdress.hxx"
45 #include "xlstring.hxx"
46 #include "xeroot.hxx"
47 #include "xestyle.hxx"
48 #include "rangelst.hxx"
49 #include "compiler.hxx"
50
51 #include <oox/core/tokens.hxx>
52 #include <formula/grammar.hxx>
53
54 #define DEBUG_XL_ENCRYPTION 0
55
56 using ::std::vector;
57
58 using ::com::sun::star::beans::PropertyValue;
59 using ::com::sun::star::io::XOutputStream;
60 using ::com::sun::star::io::XStream;
61 using ::com::sun::star::lang::XComponent;
62 using ::com::sun::star::lang::XMultiServiceFactory;
63 using ::com::sun::star::lang::XServiceInfo;
64 using ::com::sun::star::uno::Reference;
65 using ::com::sun::star::uno::Sequence;
66 using ::com::sun::star::uno::UNO_QUERY;
67 using ::rtl::OString;
68 using ::rtl::OUString;
69 using ::utl::OStreamWrapper;
70 using namespace formula;
71 // ============================================================================
72
73 XclExpStream::XclExpStream( SvStream& rOutStrm, const XclExpRoot& rRoot, sal_uInt16 nMaxRecSize ) :
74 mrStrm( rOutStrm ),
75 mrRoot( rRoot ),
76 mnMaxRecSize( nMaxRecSize ),
77 mnCurrMaxSize( 0 ),
78 mnMaxSliceSize( 0 ),
79 mnHeaderSize( 0 ),
80 mnCurrSize( 0 ),
81 mnSliceSize( 0 ),
82 mnPredictSize( 0 ),
83 mnLastSizePos( 0 ),
84 mbInRec( false )
85 {
86 if( mnMaxRecSize == 0 )
87 mnMaxRecSize = (mrRoot.GetBiff() <= EXC_BIFF5) ? EXC_MAXRECSIZE_BIFF5 : EXC_MAXRECSIZE_BIFF8;
88 mnMaxContSize = mnMaxRecSize;
89 }
90
91 XclExpStream::~XclExpStream()
92 {
93 mrStrm.Flush();
94 }
95
96 void XclExpStream::StartRecord( sal_uInt16 nRecId, sal_Size nRecSize )
97 {
98 DBG_ASSERT( !mbInRec, "XclExpStream::StartRecord - another record still open" );
99 DisableEncryption();
100 mnMaxContSize = mnCurrMaxSize = mnMaxRecSize;
101 mnPredictSize = nRecSize;
102 mbInRec = true;
103 InitRecord( nRecId );
104 SetSliceSize( 0 );
105 EnableEncryption();
106 }
107
108 void XclExpStream::EndRecord()
109 {
110 DBG_ASSERT( mbInRec, "XclExpStream::EndRecord - no record open" );
111 DisableEncryption();
112 UpdateRecSize();
113 mrStrm.Seek( STREAM_SEEK_TO_END );
114 mbInRec = false;
115 }
116
117 void XclExpStream::SetSliceSize( sal_uInt16 nSize )
118 {
119 mnMaxSliceSize = nSize;
120 mnSliceSize = 0;
121 }
122
123 XclExpStream& XclExpStream::operator<<( sal_Int8 nValue )
124 {
125 PrepareWrite( 1 );
126 if (mbUseEncrypter && HasValidEncrypter())
127 mxEncrypter->Encrypt(mrStrm, nValue);
128 else
129 mrStrm << nValue;
130 return *this;
131 }
132
133 XclExpStream& XclExpStream::operator<<( sal_uInt8 nValue )
134 {
135 PrepareWrite( 1 );
136 if (mbUseEncrypter && HasValidEncrypter())
137 mxEncrypter->Encrypt(mrStrm, nValue);
138 else
139 mrStrm << nValue;
140 return *this;
141 }
142
143 XclExpStream& XclExpStream::operator<<( sal_Int16 nValue )
144 {
145 PrepareWrite( 2 );
146 if (mbUseEncrypter && HasValidEncrypter())
147 mxEncrypter->Encrypt(mrStrm, nValue);
148 else
149 mrStrm << nValue;
150 return *this;
151 }
152
153 XclExpStream& XclExpStream::operator<<( sal_uInt16 nValue )
154 {
155 PrepareWrite( 2 );
156 if (mbUseEncrypter && HasValidEncrypter())
157 mxEncrypter->Encrypt(mrStrm, nValue);
158 else
159 mrStrm << nValue;
160 return *this;
161 }
162
163 XclExpStream& XclExpStream::operator<<( sal_Int32 nValue )
164 {
165 PrepareWrite( 4 );
166 if (mbUseEncrypter && HasValidEncrypter())
167 mxEncrypter->Encrypt(mrStrm, nValue);
168 else
169 mrStrm << nValue;
170 return *this;
171 }
172
173 XclExpStream& XclExpStream::operator<<( sal_uInt32 nValue )
174 {
175 PrepareWrite( 4 );
176 if (mbUseEncrypter && HasValidEncrypter())
177 mxEncrypter->Encrypt(mrStrm, nValue);
178 else
179 mrStrm << nValue;
180 return *this;
181 }
182
183 XclExpStream& XclExpStream::operator<<( float fValue )
184 {
185 PrepareWrite( 4 );
186 if (mbUseEncrypter && HasValidEncrypter())
187 mxEncrypter->Encrypt(mrStrm, fValue);
188 else
189 mrStrm << fValue;
190 return *this;
191 }
192
193 XclExpStream& XclExpStream::operator<<( double fValue )
194 {
195 PrepareWrite( 8 );
196 if (mbUseEncrypter && HasValidEncrypter())
197 mxEncrypter->Encrypt(mrStrm, fValue);
198 else
199 mrStrm << fValue;
200 return *this;
201 }
202
203 sal_Size XclExpStream::Write( const void* pData, sal_Size nBytes )
204 {
205 sal_Size nRet = 0;
206 if( pData && (nBytes > 0) )
207 {
208 if( mbInRec )
209 {
210 const sal_uInt8* pBuffer = reinterpret_cast< const sal_uInt8* >( pData );
211 sal_Size nBytesLeft = nBytes;
212 bool bValid = true;
213
214 while( bValid && (nBytesLeft > 0) )
215 {
216 sal_Size nWriteLen = ::std::min< sal_Size >( PrepareWrite(), nBytesLeft );
217 sal_Size nWriteRet = nWriteLen;
218 if (mbUseEncrypter && HasValidEncrypter())
219 {
220 DBG_ASSERT(nWriteLen > 0, "XclExpStream::Write: write length is 0!");
221 vector<sal_uInt8> aBytes(nWriteLen);
222 memcpy(&aBytes[0], pBuffer, nWriteLen);
223 mxEncrypter->EncryptBytes(mrStrm, aBytes);
224 // TODO: How do I check if all the bytes have been successfully written ?
225 }
226 else
227 {
228 nWriteRet = mrStrm.Write( pBuffer, nWriteLen );
229 bValid = (nWriteLen == nWriteRet);
230 DBG_ASSERT( bValid, "XclExpStream::Write - stream write error" );
231 }
232 pBuffer += nWriteRet;
233 nRet += nWriteRet;
234 nBytesLeft -= nWriteRet;
235 UpdateSizeVars( nWriteRet );
236 }
237 }
238 else
239 nRet = mrStrm.Write( pData, nBytes );
240 }
241 return nRet;
242 }
243
244 void XclExpStream::WriteZeroBytes( sal_Size nBytes )
245 {
246 if( mbInRec )
247 {
248 sal_Size nBytesLeft = nBytes;
249 while( nBytesLeft > 0 )
250 {
251 sal_Size nWriteLen = ::std::min< sal_Size >( PrepareWrite(), nBytesLeft );
252 WriteRawZeroBytes( nWriteLen );
253 nBytesLeft -= nWriteLen;
254 UpdateSizeVars( nWriteLen );
255 }
256 }
257 else
258 WriteRawZeroBytes( nBytes );
259 }
260
261 sal_Size XclExpStream::CopyFromStream( SvStream& rInStrm, sal_Size nBytes )
262 {
263 sal_Size nStrmPos = rInStrm.Tell();
264 rInStrm.Seek( STREAM_SEEK_TO_END );
265 sal_Size nStrmSize = rInStrm.Tell();
266 rInStrm.Seek( nStrmPos );
267
268 sal_Size nBytesLeft = ::std::min( nBytes, nStrmSize - nStrmPos );
269 sal_Size nRet = 0;
270 if( nBytesLeft > 0 )
271 {
272 const sal_Size nMaxBuffer = 4096;
273 sal_uInt8* pBuffer = new sal_uInt8[ ::std::min( nBytesLeft, nMaxBuffer ) ];
274 bool bValid = true;
275
276 while( bValid && (nBytesLeft > 0) )
277 {
278 sal_Size nWriteLen = ::std::min( nBytesLeft, nMaxBuffer );
279 rInStrm.Read( pBuffer, nWriteLen );
280 sal_Size nWriteRet = Write( pBuffer, nWriteLen );
281 bValid = (nWriteLen == nWriteRet);
282 nRet += nWriteRet;
283 nBytesLeft -= nWriteRet;
284 }
285 delete[] pBuffer;
286 }
287 return nRet;
288 }
289
290 //UNUSED2008-05 void XclExpStream::WriteUnicodeBuffer( const sal_uInt16* pBuffer, sal_Size nChars, sal_uInt8 nFlags )
291 //UNUSED2008-05 {
292 //UNUSED2008-05 SetSliceSize( 0 );
293 //UNUSED2008-05 if( pBuffer && (nChars > 0) )
294 //UNUSED2008-05 {
295 //UNUSED2008-05 sal_uInt16 nCharLen = (nFlags & EXC_STRF_16BIT) ? 2 : 1;
296 //UNUSED2008-05 for( sal_Size nIndex = 0; nIndex < nChars; ++nIndex )
297 //UNUSED2008-05 {
298 //UNUSED2008-05 if( mbInRec && (mnCurrSize + nCharLen > mnCurrMaxSize) )
299 //UNUSED2008-05 {
300 //UNUSED2008-05 StartContinue();
301 //UNUSED2008-05 // repeat only 16bit flag
302 //UNUSED2008-05 operator<<( static_cast< sal_uInt8 >( nFlags & EXC_STRF_16BIT ) );
303 //UNUSED2008-05 }
304 //UNUSED2008-05 if( nCharLen == 2 )
305 //UNUSED2008-05 operator<<( pBuffer[ nIndex ] );
306 //UNUSED2008-05 else
307 //UNUSED2008-05 operator<<( static_cast< sal_uInt8 >( pBuffer[ nIndex ] ) );
308 //UNUSED2008-05 }
309 //UNUSED2008-05 }
310 //UNUSED2008-05 }
311
312 void XclExpStream::WriteUnicodeBuffer( const ScfUInt16Vec& rBuffer, sal_uInt8 nFlags )
313 {
314 SetSliceSize( 0 );
315 nFlags &= EXC_STRF_16BIT; // repeat only 16bit flag
316 sal_uInt16 nCharLen = nFlags ? 2 : 1;
317
318 ScfUInt16Vec::const_iterator aEnd = rBuffer.end();
319 for( ScfUInt16Vec::const_iterator aIter = rBuffer.begin(); aIter != aEnd; ++aIter )
320 {
321 if( mbInRec && (mnCurrSize + nCharLen > mnCurrMaxSize) )
322 {
323 StartContinue();
324 operator<<( nFlags );
325 }
326 if( nCharLen == 2 )
327 operator<<( *aIter );
328 else
329 operator<<( static_cast< sal_uInt8 >( *aIter ) );
330 }
331 }
332
333 //UNUSED2008-05 void XclExpStream::WriteByteStringBuffer( const ByteString& rString, sal_uInt16 nMaxLen )
334 //UNUSED2008-05 {
335 //UNUSED2008-05 SetSliceSize( 0 );
336 //UNUSED2008-05 Write( rString.GetBuffer(), ::std::min< sal_Size >( rString.Len(), nMaxLen ) );
337 //UNUSED2008-05 }
338
339 // ER: #71367# Xcl has an obscure sense of whether starting a new record or not,
340 // and crashes if it encounters the string header at the very end of a record.
341 // Thus we add 1 to give some room, seems like they do it that way but with another count (10?)
342 void XclExpStream::WriteByteString( const ByteString& rString, sal_uInt16 nMaxLen, bool b16BitCount )
343 {
344 SetSliceSize( 0 );
345 sal_Size nLen = ::std::min< sal_Size >( rString.Len(), nMaxLen );
346 if( !b16BitCount )
347 nLen = ::std::min< sal_Size >( nLen, 0xFF );
348
349 sal_uInt16 nLeft = PrepareWrite();
350 sal_uInt16 nLenFieldSize = b16BitCount ? 2 : 1;
351 if( mbInRec && (nLeft <= nLenFieldSize) )
352 StartContinue();
353
354 if( b16BitCount )
355 operator<<( static_cast< sal_uInt16 >( nLen ) );
356 else
357 operator<<( static_cast< sal_uInt8 >( nLen ) );
358 Write( rString.GetBuffer(), nLen );
359 }
360
361 void XclExpStream::WriteCharBuffer( const ScfUInt8Vec& rBuffer )
362 {
363 SetSliceSize( 0 );
364 Write( &rBuffer[ 0 ], rBuffer.size() );
365 }
366
367 void XclExpStream::SetEncrypter( XclExpEncrypterRef xEncrypter )
368 {
369 mxEncrypter = xEncrypter;
370 }
371
372 bool XclExpStream::HasValidEncrypter() const
373 {
374 return mxEncrypter.is() && mxEncrypter->IsValid();
375 }
376
377 void XclExpStream::EnableEncryption( bool bEnable )
378 {
379 mbUseEncrypter = bEnable && HasValidEncrypter();
380 }
381
382 void XclExpStream::DisableEncryption()
383 {
384 EnableEncryption(false);
385 }
386
387 sal_Size XclExpStream::SetSvStreamPos( sal_Size nPos )
388 {
389 DBG_ASSERT( !mbInRec, "XclExpStream::SetSvStreamPos - not allowed inside of a record" );
390 return mbInRec ? 0 : mrStrm.Seek( nPos );
391 }
392
393 // private --------------------------------------------------------------------
394
395 void XclExpStream::InitRecord( sal_uInt16 nRecId )
396 {
397 mrStrm.Seek( STREAM_SEEK_TO_END );
398 mrStrm << nRecId;
399
400 mnLastSizePos = mrStrm.Tell();
401 mnHeaderSize = static_cast< sal_uInt16 >( ::std::min< sal_Size >( mnPredictSize, mnCurrMaxSize ) );
402 mrStrm << mnHeaderSize;
403 mnCurrSize = mnSliceSize = 0;
404 }
405
406 void XclExpStream::UpdateRecSize()
407 {
408 if( mnCurrSize != mnHeaderSize )
409 {
410 mrStrm.Seek( mnLastSizePos );
411 mrStrm << mnCurrSize;
412 }
413 }
414
415 void XclExpStream::UpdateSizeVars( sal_Size nSize )
416 {
417 DBG_ASSERT( mnCurrSize + nSize <= mnCurrMaxSize, "XclExpStream::UpdateSizeVars - record overwritten" );
418 mnCurrSize = mnCurrSize + static_cast< sal_uInt16 >( nSize );
419
420 if( mnMaxSliceSize > 0 )
421 {
422 DBG_ASSERT( mnSliceSize + nSize <= mnMaxSliceSize, "XclExpStream::UpdateSizeVars - slice overwritten" );
423 mnSliceSize = mnSliceSize + static_cast< sal_uInt16 >( nSize );
424 if( mnSliceSize >= mnMaxSliceSize )
425 mnSliceSize = 0;
426 }
427 }
428
429 void XclExpStream::StartContinue()
430 {
431 UpdateRecSize();
432 mnCurrMaxSize = mnMaxContSize;
433 mnPredictSize -= mnCurrSize;
434 InitRecord( EXC_ID_CONT );
435 }
436
437 void XclExpStream::PrepareWrite( sal_uInt16 nSize )
438 {
439 if( mbInRec )
440 {
441 if( (mnCurrSize + nSize > mnCurrMaxSize) ||
442 ((mnMaxSliceSize > 0) && (mnSliceSize == 0) && (mnCurrSize + mnMaxSliceSize > mnCurrMaxSize)) )
443 StartContinue();
444 UpdateSizeVars( nSize );
445 }
446 }
447
448 sal_uInt16 XclExpStream::PrepareWrite()
449 {
450 sal_uInt16 nRet = 0;
451 if( mbInRec )
452 {
453 if( (mnCurrSize >= mnCurrMaxSize) ||
454 ((mnMaxSliceSize > 0) && (mnSliceSize == 0) && (mnCurrSize + mnMaxSliceSize > mnCurrMaxSize)) )
455 StartContinue();
456 UpdateSizeVars( 0 );
457
458 nRet = (mnMaxSliceSize > 0) ? (mnMaxSliceSize - mnSliceSize) : (mnCurrMaxSize - mnCurrSize);
459 }
460 return nRet;
461 }
462
463 void XclExpStream::WriteRawZeroBytes( sal_Size nBytes )
464 {
465 const sal_uInt32 nData = 0;
466 sal_Size nBytesLeft = nBytes;
467 while( nBytesLeft >= sizeof( nData ) )
468 {
469 mrStrm << nData;
470 nBytesLeft -= sizeof( nData );
471 }
472 if( nBytesLeft )
473 mrStrm.Write( &nData, nBytesLeft );
474 }
475
476 // ============================================================================
477
478 XclExpBiff8Encrypter::XclExpBiff8Encrypter( const XclExpRoot& rRoot, const sal_uInt8 nDocId[16],
479 const sal_uInt8 nSalt[16] ) :
480 mrRoot(rRoot),
481 mnOldPos(STREAM_SEEK_TO_END),
482 mbValid(false)
483 {
484 String aPass = rRoot.GetPassword();
485 if (aPass.Len() == 0)
486 // Empty password. Get the default biff8 password.
487 aPass = XclCryptoHelper::GetBiff8WbProtPassword();
488 Init(aPass, nDocId, nSalt);
489 }
490
491 XclExpBiff8Encrypter::~XclExpBiff8Encrypter()
492 {
493 }
494
495 bool XclExpBiff8Encrypter::IsValid() const
496 {
497 return mbValid;
498 }
499
500 void XclExpBiff8Encrypter::GetSaltDigest( sal_uInt8 nSaltDigest[16] ) const
501 {
502 memcpy(nSaltDigest, mnSaltDigest, 16);
503 }
504
505 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_uInt8 nData )
506 {
507 vector<sal_uInt8> aByte(1);
508 aByte[0] = nData;
509 EncryptBytes(rStrm, aByte);
510 }
511
512 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_uInt16 nData )
513 {
514 ::std::vector<sal_uInt8> pnBytes(2);
515 pnBytes[0] = nData & 0xFF;
516 pnBytes[1] = (nData >> 8) & 0xFF;
517 EncryptBytes(rStrm, pnBytes);
518 }
519
520 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_uInt32 nData )
521 {
522 ::std::vector<sal_uInt8> pnBytes(4);
523 pnBytes[0] = nData & 0xFF;
524 pnBytes[1] = (nData >> 8) & 0xFF;
525 pnBytes[2] = (nData >> 16) & 0xFF;
526 pnBytes[3] = (nData >> 24) & 0xFF;
527 EncryptBytes(rStrm, pnBytes);
528 }
529
530 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, float fValue )
531 {
532 ::std::vector<sal_uInt8> pnBytes(4);
533 memcpy(&pnBytes[0], &fValue, 4);
534 EncryptBytes(rStrm, pnBytes);
535 }
536
537 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, double fValue )
538 {
539 ::std::vector<sal_uInt8> pnBytes(8);
540 memcpy(&pnBytes[0], &fValue, 8);
541 EncryptBytes(rStrm, pnBytes);
542 }
543
544 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_Int8 nData )
545 {
546 Encrypt(rStrm, static_cast<sal_uInt8>(nData));
547 }
548
549 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_Int16 nData )
550 {
551 Encrypt(rStrm, static_cast<sal_uInt16>(nData));
552 }
553
554 void XclExpBiff8Encrypter::Encrypt( SvStream& rStrm, sal_Int32 nData )
555 {
556 Encrypt(rStrm, static_cast<sal_uInt32>(nData));
557 }
558
559 void XclExpBiff8Encrypter::Init( const String& aPass, const sal_uInt8 nDocId[16],
560 const sal_uInt8 nSalt[16] )
561 {
562 memset(mnSaltDigest, 0, sizeof(mnSaltDigest));
563
564 xub_StrLen nLen = aPass.Len();
565 bool bValid = (0 < nLen) && (nLen < 16);
566 if ( bValid )
567 {
568 // transform String to sal_uInt16 array
569 memset(mnPassw, 0, sizeof(mnPassw));
570 for (xub_StrLen nChar = 0; nChar < nLen; ++nChar)
571 mnPassw[nChar] = static_cast<sal_uInt16>(aPass.GetChar(nChar));
572
573 // copy document ID
574 memcpy(mnDocId, nDocId, sizeof(mnDocId));
575
576 // init codec
577 maCodec.InitKey(mnPassw, mnDocId);
578
579 // generate salt hash.
580 ::svx::MSCodec_Std97 aCodec;
581 aCodec.InitKey(mnPassw, mnDocId);
582 aCodec.CreateSaltDigest(nSalt, mnSaltDigest);
583
584 // verify to make sure it's in good shape.
585 bValid = maCodec.VerifyKey(nSalt, mnSaltDigest);
586 }
587
588 mbValid = bValid;
589 }
590
591 sal_uInt32 XclExpBiff8Encrypter::GetBlockPos( sal_Size nStrmPos ) const
592 {
593 return static_cast<sal_uInt32>(nStrmPos / EXC_ENCR_BLOCKSIZE);
594 }
595
596 sal_uInt16 XclExpBiff8Encrypter::GetOffsetInBlock( sal_Size nStrmPos ) const
597 {
598 return static_cast<sal_uInt16>(nStrmPos % EXC_ENCR_BLOCKSIZE);
599 }
600
601 void XclExpBiff8Encrypter::EncryptBytes( SvStream& rStrm, vector<sal_uInt8>& aBytes )
602 {
603 sal_Size nStrmPos = rStrm.Tell();
604 sal_uInt16 nBlockOffset = GetOffsetInBlock(nStrmPos);
605 sal_uInt16 nBlockPos = GetBlockPos(nStrmPos);
606
607 #if DEBUG_XL_ENCRYPTION
608 fprintf(stdout, "XclExpBiff8Encrypter::EncryptBytes: stream pos = %ld offset in block = %d block pos = %ld\n",
609 nStrmPos, nBlockOffset, nBlockPos);
610 #endif
611
612 sal_uInt16 nSize = aBytes.size();
613 if (nSize == 0)
614 return;
615
616 #if DEBUG_XL_ENCRYPTION
617 fprintf(stdout, "RAW: ");
618 for (sal_uInt16 i = 0; i < nSize; ++i)
619 fprintf(stdout, "%2.2X ", aBytes[i]);
620 fprintf(stdout, "\n");
621 #endif
622
623 if (mnOldPos != nStrmPos)
624 {
625 sal_uInt16 nOldOffset = GetOffsetInBlock(mnOldPos);
626 sal_uInt16 nOldBlockPos = GetBlockPos(mnOldPos);
627
628 if ( (nBlockPos != nOldBlockPos) || (nBlockOffset < nOldOffset) )
629 {
630 maCodec.InitCipher(nBlockPos);
631 nOldOffset = 0;
632 }
633
634 if (nBlockOffset > nOldOffset)
635 maCodec.Skip(nBlockOffset - nOldOffset);
636 }
637
638 sal_uInt16 nBytesLeft = nSize;
639 sal_uInt16 nPos = 0;
640 while (nBytesLeft > 0)
641 {
642 sal_uInt16 nBlockLeft = EXC_ENCR_BLOCKSIZE - nBlockOffset;
643 sal_uInt16 nEncBytes = ::std::min(nBlockLeft, nBytesLeft);
644
645 bool bRet = maCodec.Encode(&aBytes[nPos], nEncBytes, &aBytes[nPos], nEncBytes);
646 DBG_ASSERT(bRet, "XclExpBiff8Encrypter::EncryptBytes: encryption failed!!");
647
648 sal_Size nRet = rStrm.Write(&aBytes[nPos], nEncBytes);
649 DBG_ASSERT(nRet == nEncBytes, "XclExpBiff8Encrypter::EncryptBytes: fail to write to stream!!");
650
651 nStrmPos = rStrm.Tell();
652 nBlockOffset = GetOffsetInBlock(nStrmPos);
653 nBlockPos = GetBlockPos(nStrmPos);
654 if (nBlockOffset == 0)
655 maCodec.InitCipher(nBlockPos);
656
657 nBytesLeft -= nEncBytes;
658 nPos += nEncBytes;
659 }
660 mnOldPos = nStrmPos;
661 }
662 rtl::OUString XclXmlUtils::GetStreamName( const char* sStreamDir, const char* sStream, sal_Int32 nId )
663 {
664 rtl::OUStringBuffer sBuf;
665 if( sStreamDir )
666 sBuf.appendAscii( sStreamDir );
667 sBuf.appendAscii( sStream );
668 if( nId )
669 sBuf.append( nId );
670 sBuf.appendAscii( ".xml" );
671 return sBuf.makeStringAndClear();
672 }
673
674 rtl::OString XclXmlUtils::ToOString( const Color& rColor )
675 {
676 char buf[9];
677 sprintf( buf, "%.2X%.2X%.2X%.2X", rColor.GetTransparency(), rColor.GetRed(), rColor.GetGreen(), rColor.GetBlue() );
678 buf[8] = '\0';
679 return OString( buf );
680 }
681
682 rtl::OString XclXmlUtils::ToOString( const ::rtl::OUString& s )
683 {
684 return OUStringToOString( s, RTL_TEXTENCODING_UTF8 );
685 }
686
687 rtl::OString XclXmlUtils::ToOString( const String& s )
688 {
689 return rtl::OString( s.GetBuffer(), s.Len(), RTL_TEXTENCODING_UTF8 );
690 }
691
692 rtl::OString XclXmlUtils::ToOString( const ScAddress& rAddress )
693 {
694 String sAddress;
695 rAddress.Format( sAddress, SCA_VALID, NULL, ScAddress::Details( FormulaGrammar::CONV_XL_A1 ) );
696 return ToOString( sAddress );
697 }
698
699 rtl::OString XclXmlUtils::ToOString( const ScfUInt16Vec& rBuffer )
700 {
701 const sal_uInt16* pBuffer = &rBuffer [0];
702 return ::rtl::OString( pBuffer, rBuffer.size(), RTL_TEXTENCODING_UTF8 );
703 }
704
705 rtl::OString XclXmlUtils::ToOString( const ScRange& rRange )
706 {
707 String sRange;
708 rRange.Format( sRange, SCA_VALID, NULL, ScAddress::Details( FormulaGrammar::CONV_XL_A1 ) );
709 return ToOString( sRange );
710 }
711
712 rtl::OString XclXmlUtils::ToOString( const ScRangeList& rRangeList )
713 {
714 String s;
715 rRangeList.Format( s, SCA_VALID, NULL, FormulaGrammar::CONV_XL_A1, ' ' );
716 return ToOString( s );
717 }
718
719 static ScAddress lcl_ToAddress( const XclAddress& rAddress )
720 {
721 ScAddress aAddress;
722
723 // For some reason, ScRange::Format() returns omits row numbers if
724 // the row is >= MAXROW or the column is >= MAXCOL, and Excel doesn't
725 // like "A:IV" (i.e. no row numbers). Prevent this.
726 aAddress.SetRow( std::min<sal_Int32>( rAddress.mnRow, MAXROW-1 ) );
727 aAddress.SetCol( static_cast<sal_Int16>(std::min<sal_Int32>( rAddress.mnCol, MAXCOL-1 )) );
728
729 return aAddress;
730 }
731
732 rtl::OString XclXmlUtils::ToOString( const XclAddress& rAddress )
733 {
734 return ToOString( lcl_ToAddress( rAddress ) );
735 }
736
737 rtl::OString XclXmlUtils::ToOString( const XclExpString& s )
738 {
739 DBG_ASSERT( !s.IsRich(), "XclXmlUtils::ToOString(XclExpString): rich text string found!" );
740 return ToOString( s.GetUnicodeBuffer() );
741 }
742
743 static ScRange lcl_ToRange( const XclRange& rRange )
744 {
745 ScRange aRange;
746
747 aRange.aStart = lcl_ToAddress( rRange.maFirst );
748 aRange.aEnd = lcl_ToAddress( rRange.maLast );
749
750 return aRange;
751 }
752
753 rtl::OString XclXmlUtils::ToOString( const XclRangeList& rRanges )
754 {
755 ScRangeList aRanges;
756 for( XclRangeList::const_iterator i = rRanges.begin(), end = rRanges.end();
757 i != end; ++i )
758 {
759 aRanges.Append( lcl_ToRange( *i ) );
760 }
761 return ToOString( aRanges );
762 }
763
764 OUString XclXmlUtils::ToOUString( const char* s )
765 {
766 return OUString( s, (sal_Int32) strlen( s ), RTL_TEXTENCODING_ASCII_US );
767 }
768
769 OUString XclXmlUtils::ToOUString( const ScfUInt16Vec& rBuf, sal_Int32 nStart, sal_Int32 nLength )
770 {
771 if( nLength == -1 )
772 nLength = rBuf.size();
773
774 return OUString( &rBuf[nStart], nLength );
775 }
776
777 OUString XclXmlUtils::ToOUString( const String& s )
778 {
779 return OUString( s.GetBuffer(), s.Len() );
780 }
781
782 rtl::OUString XclXmlUtils::ToOUString( ScDocument& rDocument, const ScAddress& rAddress, ScTokenArray* pTokenArray )
783 {
784 ScCompiler aCompiler( &rDocument, rAddress, *pTokenArray);
785 aCompiler.SetGrammar(FormulaGrammar::GRAM_NATIVE_XL_A1);
786 String s;
787 aCompiler.CreateStringFromTokenArray( s );
788 return ToOUString( s );
789 }
790
791 OUString XclXmlUtils::ToOUString( const XclExpString& s )
792 {
793 DBG_ASSERT( !s.IsRich(), "XclXmlUtils::ToOString(XclExpString): rich text string found!" );
794 return ToOUString( s.GetUnicodeBuffer() );
795 }
796
797 const char* XclXmlUtils::ToPsz( bool b )
798 {
799 return b ? "true" : "false";
800 }
801
802 // ============================================================================
803
804 XclExpXmlStream::XclExpXmlStream( const Reference< XMultiServiceFactory >& rSMgr, SvStream& rStrm, const XclExpRoot& rRoot )
805 : XmlFilterBase( rSMgr )
806 , mrRoot( rRoot )
807 {
808 Sequence< PropertyValue > aArgs( 1 );
809 const OUString sStream( RTL_CONSTASCII_USTRINGPARAM( "StreamForOutput" ) );
810 aArgs[0].Name = sStream;
811 aArgs[0].Value <<= Reference< XStream > ( new OStreamWrapper( rStrm ) );
812
813 XServiceInfo* pInfo = rRoot.GetDocModelObj();
814 Reference< XComponent > aComponent( pInfo, UNO_QUERY );
815 setSourceDocument( aComponent );
816 filter( aArgs );
817
818 PushStream( CreateOutputStream(
819 OUString::createFromAscii( "xl/workbook.xml" ),
820 OUString::createFromAscii( "xl/workbook.xml" ),
821 Reference< XOutputStream >(),
822 "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
823 "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" ) );
824 }
825
826 XclExpXmlStream::~XclExpXmlStream()
827 {
828 }
829
830 sax_fastparser::FSHelperPtr& XclExpXmlStream::GetCurrentStream()
831 {
832 DBG_ASSERT( !maStreams.empty(), "XclExpXmlStream::GetCurrentStream - no current stream" );
833 return maStreams.top();
834 }
835
836 void XclExpXmlStream::PushStream( sax_fastparser::FSHelperPtr aStream )
837 {
838 maStreams.push( aStream );
839 }
840
841 void XclExpXmlStream::PopStream()
842 {
843 DBG_ASSERT( !maStreams.empty(), "XclExpXmlStream::PopStream - stack is empty!" );
844 maStreams.pop();
845 }
846
847 OUString XclExpXmlStream::GetIdForPath( const OUString& sPath )
848 {
849 if( maOpenedStreamMap.find( sPath ) == maOpenedStreamMap.end() )
850 return OUString();
851 return maOpenedStreamMap[ sPath ].first;
852 }
853
854 sax_fastparser::FSHelperPtr XclExpXmlStream::GetStreamForPath( const OUString& sPath )
855 {
856 if( maOpenedStreamMap.find( sPath ) == maOpenedStreamMap.end() )
857 return sax_fastparser::FSHelperPtr();
858 return maOpenedStreamMap[ sPath ].second;
859 }
860
861 sax_fastparser::FSHelperPtr& XclExpXmlStream::WriteAttributes( sal_Int32 nAttribute, ... )
862 {
863 sax_fastparser::FSHelperPtr& rStream = GetCurrentStream();
864
865 va_list args;
866 va_start( args, nAttribute );
867 do {
868 const char* pValue = va_arg( args, const char* );
869 if( pValue )
870 {
871 rStream->write( " " )
872 ->writeId( nAttribute )
873 ->write( "=\"" )
874 ->writeEscaped( pValue )
875 ->write( "\"" );
876 }
877
878 nAttribute = va_arg( args, sal_Int32 );
879 if( nAttribute == FSEND )
880 break;
881 } while( true );
882 va_end( args );
883
884 return rStream;
885 }
886
887 static void lcl_WriteValue( sax_fastparser::FSHelperPtr& rStream, sal_Int32 nElement, const char* pValue )
888 {
889 if( !pValue )
890 return;
891 rStream->singleElement( nElement,
892 XML_val, pValue,
893 FSEND );
894 }
895
896 static const char* lcl_GetUnderlineStyle( FontUnderline eUnderline, bool& bHaveUnderline )
897 {
898 bHaveUnderline = true;
899 switch( eUnderline )
900 {
901 // OOXTODO: doubleAccounting, singleAccounting
902 // OOXTODO: what should be done with the other FontUnderline values?
903 case UNDERLINE_SINGLE: return "single";
904 case UNDERLINE_DOUBLE: return "double";
905 case UNDERLINE_NONE:
906 default: bHaveUnderline = false; return "none";
907 }
908 }
909
910 static const char* lcl_ToVerticalAlignmentRun( SvxEscapement eEscapement, bool& bHaveAlignment )
911 {
912 bHaveAlignment = true;
913 switch( eEscapement )
914 {
915 case SVX_ESCAPEMENT_SUPERSCRIPT: return "superscript";
916 case SVX_ESCAPEMENT_SUBSCRIPT: return "subscript";
917 case SVX_ESCAPEMENT_OFF:
918 default: bHaveAlignment = false; return "baseline";
919 }
920 }
921
922 sax_fastparser::FSHelperPtr& XclExpXmlStream::WriteFontData( const XclFontData& rFontData, sal_Int32 nFontId )
923 {
924 bool bHaveUnderline, bHaveVertAlign;
925 const char* pUnderline = lcl_GetUnderlineStyle( rFontData.GetScUnderline(), bHaveUnderline );
926 const char* pVertAlign = lcl_ToVerticalAlignmentRun( rFontData.GetScEscapement(), bHaveVertAlign );
927
928 sax_fastparser::FSHelperPtr& rStream = GetCurrentStream();
929
930 lcl_WriteValue( rStream, nFontId, XclXmlUtils::ToOString( rFontData.maName ).getStr() );
931 lcl_WriteValue( rStream, XML_charset, rFontData.mnCharSet != 0 ? OString::valueOf( (sal_Int32) rFontData.mnCharSet ).getStr() : NULL );
932 lcl_WriteValue( rStream, XML_family, OString::valueOf( (sal_Int32) rFontData.mnFamily ).getStr() );
933 lcl_WriteValue( rStream, XML_b, rFontData.mnWeight > 400 ? XclXmlUtils::ToPsz( rFontData.mnWeight > 400 ) : NULL );
934 lcl_WriteValue( rStream, XML_i, rFontData.mbItalic ? XclXmlUtils::ToPsz( rFontData.mbItalic ) : NULL );
935 lcl_WriteValue( rStream, XML_strike, rFontData.mbStrikeout ? XclXmlUtils::ToPsz( rFontData.mbStrikeout ) : NULL );
936 lcl_WriteValue( rStream, XML_outline, rFontData.mbOutline ? XclXmlUtils::ToPsz( rFontData.mbOutline ) : NULL );
937 lcl_WriteValue( rStream, XML_shadow, rFontData.mbShadow ? XclXmlUtils::ToPsz( rFontData.mbShadow ) : NULL );
938 // OOXTODO: lcl_WriteValue( rStream, XML_condense, ); // mac compatibility setting
939 // OOXTODO: lcl_WriteValue( rStream, XML_extend, ); // compatibility setting
940 if( rFontData.maColor != Color( 0xFF, 0xFF, 0xFF, 0xFF ) )
941 rStream->singleElement( XML_color,
942 // OOXTODO: XML_auto, bool
943 // OOXTODO: XML_indexed, uint
944 XML_rgb, XclXmlUtils::ToOString( rFontData.maColor ).getStr(),
945 // OOXTODO: XML_theme, index into <clrScheme/>
946 // OOXTODO: XML_tint, double
947 FSEND );
948 lcl_WriteValue( rStream, XML_sz, OString::valueOf( (double) (rFontData.mnHeight / 20.0) ) ); // Twips->Pt
949 lcl_WriteValue( rStream, XML_u, bHaveUnderline ? pUnderline : NULL );
950 lcl_WriteValue( rStream, XML_vertAlign, bHaveVertAlign ? pVertAlign : NULL );
951
952 return rStream;
953 }
954
955 sax_fastparser::FSHelperPtr XclExpXmlStream::CreateOutputStream (
956 const OUString& sFullStream,
957 const OUString& sRelativeStream,
958 const Reference< XOutputStream >& xParentRelation,
959 const char* sContentType,
960 const char* sRelationshipType,
961 ::rtl::OUString* pRelationshipId )
962 {
963 OUString sRelationshipId;
964 if (xParentRelation.is())
965 sRelationshipId = addRelation( xParentRelation, OUString::createFromAscii( sRelationshipType), sRelativeStream );
966 else
967 sRelationshipId = addRelation( OUString::createFromAscii( sRelationshipType ), sRelativeStream );
968
969 if( pRelationshipId )
970 *pRelationshipId = sRelationshipId;
971
972 sax_fastparser::FSHelperPtr p = openOutputStreamWithSerializer( sFullStream, OUString::createFromAscii( sContentType ) );
973
974 maOpenedStreamMap[ sFullStream ] = std::make_pair( sRelationshipId, p );
975
976 return p;
977 }
978
979 bool XclExpXmlStream::importDocument() throw()
980 {
981 return false;
982 }
983
984 sal_Int32 XclExpXmlStream::getSchemeClr( sal_Int32 /*nColorSchemeToken*/ ) const
985 {
986 return -1;
987 }
988
989 const oox::vml::DrawingPtr XclExpXmlStream::getDrawings()
990 {
991 return oox::vml::DrawingPtr();
992 }
993
994 const oox::drawingml::Theme* XclExpXmlStream::getCurrentTheme() const
995 {
996 return NULL;
997 }
998
999 const oox::drawingml::table::TableStyleListPtr XclExpXmlStream::getTableStyles()
1000 {
1001 return oox::drawingml::table::TableStyleListPtr();
1002 }
1003
1004 oox::drawingml::chart::ChartConverter* XclExpXmlStream::getChartConverter()
1005 {
1006 return NULL;
1007 }
1008
1009 bool XclExpXmlStream::exportDocument() throw()
1010 {
1011 return false;
1012 }
1013
1014 ::rtl::OUString XclExpXmlStream::implGetImplementationName() const
1015 {
1016 return CREATE_OUSTRING( "TODO" );
1017 }
1018
1019 void XclExpXmlStream::Trace( const char* format, ...)
1020 {
1021 va_list ap;
1022 va_start( ap, format );
1023 vfprintf( stderr, format, ap );
1024 va_end( ap );
1025 }
1026
vba interoperability for OOo