tools/source/inet/inetstrm.cxx

   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: inetstrm.cxx,v $
  10  * $Revision: 1.11 $
  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 "precompiled_tools.hxx"
  33 #include <sal/types.h>
  34 #include <rtl/memory.h>
  35 #include <tools/cachestr.hxx>
  36 #include <tools/debug.hxx>
  37 #include <tools/inetmsg.hxx>
  38 #include <tools/inetstrm.hxx>
  39
  40 #include <ctype.h> // toupper
  41
  42 inline sal_Bool SAL_CALL ascii_isWhitespace( sal_Unicode ch )
  43 {
  44     return ((ch <= 0x20) && ch);
  45 }
  46
  47 #define CONSTASCII_STRINGPARAM(a) (a), RTL_TEXTENCODING_ASCII_US
  48
  49 /*=======================================================================
  50  *
  51  * INetMessageEncodeQPStream Interface.
  52  * (Quoted-Printable Encoding)
  53  *
  54  *=====================================================================*/
  55 class INetMessageEncodeQPStream_Impl : public INetMessageIStream
  56 {
  57     SvStream               *pMsgStrm;
  58
  59     ULONG                   nMsgBufSiz;
  60     sal_Char               *pMsgBuffer;
  61     sal_Char               *pMsgRead;
  62     sal_Char               *pMsgWrite;
  63
  64     ULONG                   nTokBufSiz;
  65     sal_Char               *pTokBuffer;
  66     sal_Char               *pTokRead;
  67     sal_Char               *pTokWrite;
  68
  69     INetMessageStreamState  eState;
  70     BOOL                    bDone;
  71
  72     virtual int GetMsgLine (sal_Char *pData, ULONG nSize);
  73
  74 public:
  75     INetMessageEncodeQPStream_Impl (ULONG nMsgBufferSize = 1024);
  76     virtual ~INetMessageEncodeQPStream_Impl (void);
  77 };
  78
  79 /*=====================================================================
  80  *
  81  * INetMessageDecodeQPStream Interface.
  82  * (Quoted-Printable Decoding)
  83  *
  84  *====================================================================*/
  85 class INetMessageDecodeQPStream_Impl : public INetMessageOStream
  86 {
  87     INetMessageStreamState  eState;
  88     SvMemoryStream         *pMsgBuffer;
  89
  90     ULONG                   nTokBufLen;
  91     sal_Char                pTokBuffer[4];
  92
  93     virtual int PutMsgLine (const sal_Char *pData, ULONG nSize);
  94
  95 public:
  96     INetMessageDecodeQPStream_Impl (void);
  97     virtual ~INetMessageDecodeQPStream_Impl (void);
  98 };
  99
 100 /*======================================================================
 101  *
 102  * INetMessageEncode64Stream Interface.
 103  * (Base64 Encoding)
 104  *
 105  *====================================================================*/
 106 class INetMessageEncode64Stream_Impl : public INetMessageIStream
 107 {
 108     SvStream  *pMsgStrm;
 109
 110     ULONG      nMsgBufSiz;
 111     sal_uInt8 *pMsgBuffer;
 112     sal_uInt8 *pMsgRead;
 113     sal_uInt8 *pMsgWrite;
 114
 115     ULONG      nTokBufSiz;
 116     sal_Char  *pTokBuffer;
 117     sal_Char  *pTokRead;
 118     sal_Char  *pTokWrite;
 119
 120     BOOL       bDone;
 121
 122     virtual int GetMsgLine (sal_Char *pData, ULONG nSize);
 123
 124 public:
 125     INetMessageEncode64Stream_Impl (ULONG nMsgBufferSize = 2048);
 126     virtual ~INetMessageEncode64Stream_Impl (void);
 127 };
 128
 129 /*======================================================================
 130  *
 131  * INetMessageDecode64Stream Interface.
 132  * (Base64 Decoding)
 133  *
 134  *====================================================================*/
 135 class INetMessageDecode64Stream_Impl : public INetMessageOStream
 136 {
 137     INetMessageStreamState  eState;
 138
 139     ULONG                   nMsgBufSiz;
 140     sal_Char               *pMsgBuffer;
 141     sal_Char               *pMsgRead;
 142     sal_Char               *pMsgWrite;
 143
 144     virtual int PutMsgLine (const sal_Char *pData, ULONG nSize);
 145
 146 public:
 147     INetMessageDecode64Stream_Impl (ULONG nMsgBufferSize = 128);
 148     virtual ~INetMessageDecode64Stream_Impl (void);
 149 };
 150
 151 /*=========================================================================
 152  *
 153  * INetIStream Implementation.
 154  *
 155  *=======================================================================*/
 156 /*
 157  * INetIStream.
 158  */
 159 INetIStream::INetIStream ()
 160 {
 161 }
 162
 163 /*
 164  * ~INetIStream.
 165  */
 166 INetIStream::~INetIStream (void)
 167 {
 168 }
 169
 170 /*
 171  * Read.
 172  */
 173 int INetIStream::Read (sal_Char *pData, ULONG nSize)
 174 {
 175     return GetData (pData, nSize);
 176 }
 177
 178 /*
 179  * Decode64.
 180  */
 181 void INetIStream::Decode64 (SvStream& rIn, SvStream& rOut)
 182 {
 183     INetMessage aMsg;
 184     aMsg.SetDocumentLB(new SvAsyncLockBytes(&rOut, FALSE));
 185
 186     INetMessageDecode64Stream_Impl aStream (8192);
 187     aStream.SetTargetMessage (&aMsg);
 188
 189     sal_Char* pBuf = new sal_Char[8192];
 190
 191     int nRead = 0;
 192     while ((nRead = rIn.Read (pBuf, 8192)) > 0)
 193         aStream.Write( pBuf, nRead );
 194     aStream.Write ("\r\n", 2);
 195
 196     delete[] pBuf;
 197 }
 198
 199 /*
 200  * Encode64.
 201  */
 202 void INetIStream::Encode64 (SvStream& rIn, SvStream& rOut)
 203 {
 204     INetMessage aMsg;
 205     aMsg.SetDocumentLB (
 206         new SvLockBytes (&rIn, FALSE));
 207
 208     INetMessageEncode64Stream_Impl aStream (8192);
 209     aStream.SetSourceMessage (&aMsg);
 210
 211     sal_Char* pBuf = new sal_Char[8192];
 212
 213     int nRead = 0;
 214     while ((nRead = aStream.Read (pBuf, 8192)) > 0)
 215         rOut.Write( pBuf, nRead );
 216
 217     delete[] pBuf;
 218 }
 219
 220 /*=========================================================================
 221  *
 222  * INetOStream Implementation.
 223  *
 224  *=======================================================================*/
 225 /*
 226  * INetOStream.
 227  */
 228 INetOStream::INetOStream ()
 229 {
 230 }
 231
 232 /*
 233  * ~INetOStream.
 234  */
 235 INetOStream::~INetOStream (void)
 236 {
 237 }
 238
 239 /*
 240  * Write.
 241  */
 242 int INetOStream::Write (const sal_Char *pData, ULONG nSize)
 243 {
 244     return PutData (pData, nSize);
 245 }
 246
 247 /*=========================================================================
 248  *
 249  * INetMessageIStream Implementation.
 250  *
 251  *=======================================================================*/
 252 /*
 253  * INetMessageIStream.
 254  */
 255 INetMessageIStream::INetMessageIStream (ULONG nBufferSize)
 256     : pSourceMsg       (NULL),
 257       bHeaderGenerated (FALSE),
 258       nBufSiz          (nBufferSize),
 259       pMsgStrm         (NULL),
 260       pMsgBuffer       (new SvMemoryStream)
 261 {
 262     pMsgBuffer->SetStreamCharSet (RTL_TEXTENCODING_ASCII_US);
 263     pBuffer = new sal_Char[nBufSiz];
 264     pRead = pWrite = pBuffer;
 265 }
 266
 267 /*
 268  * ~INetMessageIStream.
 269  */
 270 INetMessageIStream::~INetMessageIStream (void)
 271 {
 272     delete [] pBuffer;
 273     delete pMsgBuffer;
 274     delete pMsgStrm;
 275 }
 276
 277 /*
 278  * GetData.
 279  */
 280 int INetMessageIStream::GetData (sal_Char *pData, ULONG nSize)
 281 {
 282     if (pSourceMsg == NULL) return INETSTREAM_STATUS_ERROR;
 283
 284     sal_Char *pWBuf = pData;
 285     sal_Char *pWEnd = pData + nSize;
 286
 287     while (pWBuf < pWEnd)
 288     {
 289         // Caller's buffer not yet filled.
 290         ULONG n = pRead - pWrite;
 291         if (n > 0)
 292         {
 293             // Bytes still in buffer.
 294             ULONG m = pWEnd - pWBuf;
 295             if (m < n) n = m;
 296             for (ULONG i = 0; i < n; i++) *pWBuf++ = *pWrite++;
 297         }
 298         else
 299         {
 300             // Buffer empty. Reset to <Begin-of-Buffer>.
 301             pRead = pWrite = pBuffer;
 302
 303             // Read next message line.
 304             int nRead = GetMsgLine (pBuffer, nBufSiz);
 305             if (nRead > 0)
 306             {
 307                 // Set read pointer.
 308                 pRead = pBuffer + nRead;
 309             }
 310             else
 311             {
 312                 if (!bHeaderGenerated)
 313                 {
 314                     // Header generated. Insert empty line.
 315                     bHeaderGenerated = TRUE;
 316                     *pRead++ = '\r';
 317                     *pRead++ = '\n';
 318                 }
 319                 else
 320                 {
 321                     // Body generated.
 322                     return (pWBuf - pData);
 323                 }
 324             }
 325         }
 326     }
 327     return (pWBuf - pData);
 328 }
 329
 330 /*
 331  * GetMsgLine.
 332  */
 333 int INetMessageIStream::GetMsgLine (sal_Char *pData, ULONG nSize)
 334 {
 335     if (pSourceMsg == NULL) return INETSTREAM_STATUS_ERROR;
 336
 337     sal_Char *pWBuf = pData;
 338     sal_Char *pWEnd = pData + nSize;
 339
 340     if (!bHeaderGenerated)
 341     {
 342         ULONG i, n;
 343
 344         if (pMsgBuffer->Tell() == 0)
 345         {
 346             // Insert formatted header into buffer.
 347             n = pSourceMsg->GetHeaderCount();
 348             for (i = 0; i < n; i++)
 349             {
 350                 INetMessageHeader aHeader (pSourceMsg->GetHeaderField(i));
 351                 if (aHeader.GetValue().Len())
 352                 {
 353                     // NYI: Folding long lines.
 354                     *pMsgBuffer << (sal_Char*)(aHeader.GetName().GetBuffer());
 355                     *pMsgBuffer << ": ";
 356                     *pMsgBuffer << (sal_Char*)(aHeader.GetValue().GetBuffer());
 357                     *pMsgBuffer << "\r\n";
 358                 }
 359             }
 360
 361             pMsgWrite = (sal_Char *)(pMsgBuffer->GetData());
 362             pMsgRead  = pMsgWrite + pMsgBuffer->Tell();
 363         }
 364
 365         n = pMsgRead - pMsgWrite;
 366         if (n > 0)
 367         {
 368             // Move to caller.
 369             if (nSize < n) n = nSize;
 370             for (i = 0; i < n; i++) *pWBuf++ = *pMsgWrite++;
 371         }
 372         else
 373         {
 374             // Reset buffer.
 375             pMsgBuffer->Seek (STREAM_SEEK_TO_BEGIN);
 376         }
 377     }
 378     else
 379     {
 380         if (pSourceMsg->GetDocumentLB())
 381         {
 382             if (pMsgStrm == NULL)
 383                 pMsgStrm = new SvStream (pSourceMsg->GetDocumentLB());
 384
 385             ULONG nRead = pMsgStrm->Read (pWBuf, (pWEnd - pWBuf));
 386             pWBuf += nRead;
 387         }
 388     }
 389     return (pWBuf - pData);
 390 }
 391
 392 /*=========================================================================
 393  *
 394  * INetMessageOStream Implementation.
 395  *
 396  *=======================================================================*/
 397 /*
 398  * INetMessageOStream.
 399  */
 400 INetMessageOStream::INetMessageOStream (void)
 401     : pTargetMsg    (NULL),
 402       bHeaderParsed (FALSE),
 403       eOState       (INETMSG_EOL_BEGIN),
 404       pMsgBuffer    (new SvMemoryStream)
 405 {
 406 }
 407
 408 /*
 409  * ~INetMessageOStream.
 410  */
 411 INetMessageOStream::~INetMessageOStream (void)
 412 {
 413     if (pMsgBuffer->Tell() > 0)
 414         PutMsgLine ((const sal_Char *) pMsgBuffer->GetData(), pMsgBuffer->Tell());
 415     delete pMsgBuffer;
 416
 417     if (pTargetMsg)
 418     {
 419         SvOpenLockBytes *pLB =
 420             PTR_CAST (SvOpenLockBytes, pTargetMsg->GetDocumentLB());
 421         if (pLB)
 422         {
 423             pLB->Flush();
 424             pLB->Terminate();
 425         }
 426     }
 427 }
 428
 429 /*
 430  * PutData.
 431  * (Simple Field Parsing (RFC822, Appendix B)).
 432  */
 433 int INetMessageOStream::PutData (const sal_Char *pData, ULONG nSize)
 434 {
 435     if (pTargetMsg == NULL) return INETSTREAM_STATUS_ERROR;
 436
 437     const sal_Char *pStop = (pData + nSize);
 438
 439     while (!bHeaderParsed && (pData < pStop))
 440     {
 441         if (eOState == INETMSG_EOL_BEGIN)
 442         {
 443             if ((*pData == '\r') || (*pData == '\n'))
 444             {
 445                 /*
 446                  * Empty Line. Separates header fields from message body.
 447                  * Skip this and any 2nd line break character (if any).
 448                  */
 449                 pData++;
 450                 if ((pData < pStop) && ((*pData == '\r') || (*pData == '\n')))
 451                     pData++;
 452
 453                 // Emit any buffered last header field.
 454                 if (pMsgBuffer->Tell() > 0)
 455                 {
 456                     *pMsgBuffer << '\0';
 457                     int status = PutMsgLine (
 458                         (const sal_Char *) pMsgBuffer->GetData(),
 459                         pMsgBuffer->Tell());
 460                     if (status != INETSTREAM_STATUS_OK) return status;
 461                 }
 462
 463                 // Reset to begin.
 464                 eOState = INETMSG_EOL_BEGIN;
 465                 pMsgBuffer->Seek (STREAM_SEEK_TO_BEGIN);
 466
 467                 // Mark header parsed.
 468                 bHeaderParsed = TRUE;
 469             }
 470             else if ((*pData == ' ') || (*pData == '\t'))
 471             {
 472                 // Continuation line. Unfold multi-line field-body.
 473                 *pMsgBuffer << ' ';
 474                 pData++;
 475             }
 476             else
 477             {
 478                 // Begin of new header field.
 479                 if (pMsgBuffer->Tell() > 0)
 480                 {
 481                     // Emit buffered header field now.
 482                     *pMsgBuffer << '\0';
 483                     int status = PutMsgLine (
 484                         (const sal_Char *) pMsgBuffer->GetData(),
 485                         pMsgBuffer->Tell());
 486                     if (status != INETSTREAM_STATUS_OK) return status;
 487                 }
 488
 489                 // Reset to begin of buffer.
 490                 pMsgBuffer->Seek (STREAM_SEEK_TO_BEGIN);
 491
 492                 // Insert current character into buffer.
 493                 *pMsgBuffer << *pData++;
 494             }
 495
 496             // Search for next line break character.
 497             if (!bHeaderParsed) eOState = INETMSG_EOL_SCR;
 498         }
 499         else if (eOState == INETMSG_EOL_FCR)
 500         {
 501             // Skip line break character.
 502             pData++;
 503
 504             // Mark begin of line.
 505             eOState = INETMSG_EOL_BEGIN;
 506         }
 507         else if ((*pData == '\r') || (*pData == '\n'))
 508         {
 509             if (*pData == '\r') pData++;
 510             eOState = INETMSG_EOL_FCR;
 511         }
 512         else if (ascii_isWhitespace (*pData & 0x7f))
 513         {
 514             // Any <LWS> is folded into a single <SP> character.
 515             sal_Char c = *((const sal_Char *) pMsgBuffer->GetData() + pMsgBuffer->Tell() - 1);
 516             if (!ascii_isWhitespace (c & 0x7f)) *pMsgBuffer << ' ';
 517
 518             // Skip over this <LWS> character.
 519             pData++;
 520         }
 521         else
 522         {
 523             // Any other character is inserted into line buffer.
 524             *pMsgBuffer << *pData++;
 525         }
 526     }
 527
 528     if (bHeaderParsed && (pData < pStop))
 529     {
 530         // Put message body down-stream.
 531         return PutMsgLine (pData, (pStop - pData));
 532     }
 533
 534     return INETSTREAM_STATUS_OK;
 535 }
 536
 537 /*
 538  * PutMsgLine.
 539  */
 540 int INetMessageOStream::PutMsgLine (const sal_Char *pData, ULONG nSize)
 541 {
 542     // Check for message container.
 543     if (pTargetMsg == NULL) return INETSTREAM_STATUS_ERROR;
 544
 545     // Check for header or body.
 546     if (!IsHeaderParsed())
 547     {
 548         ByteString aField (pData);
 549         USHORT nPos = aField.Search (':');
 550         if (nPos != STRING_NOTFOUND)
 551         {
 552             ByteString aName (
 553                 aField.Copy (0, nPos));
 554             ByteString aValue (
 555                 aField.Copy (nPos + 1, aField.Len() - nPos + 1));
 556             aValue.EraseLeadingChars (' ');
 557
 558             pTargetMsg->SetHeaderField (
 559                 INetMessageHeader (aName, aValue));
 560         }
 561     }
 562     else
 563     {
 564         SvOpenLockBytes *pLB =
 565             PTR_CAST(SvOpenLockBytes, pTargetMsg->GetDocumentLB());
 566         if (pLB == NULL)
 567             return INETSTREAM_STATUS_WOULDBLOCK;
 568
 569         sal_Size nDocSiz = pTargetMsg->GetDocumentSize();
 570         sal_Size nWrite  = 0;
 571
 572         pLB->FillAppend ((sal_Char *)pData, nSize, &nWrite);
 573         pTargetMsg->SetDocumentSize (nDocSiz + nWrite);
 574
 575         if (nWrite < nSize) return INETSTREAM_STATUS_ERROR;
 576     }
 577     return INETSTREAM_STATUS_OK;
 578 }
 579
 580 /*=========================================================================
 581  *
 582  * INetMessageIOStream Implementation.
 583  *
 584  *=======================================================================*/
 585 /*
 586  * INetMessageIOStream.
 587  */
 588 INetMessageIOStream::INetMessageIOStream (ULONG nBufferSize)
 589     : INetMessageIStream (nBufferSize),
 590       INetMessageOStream ()
 591 {
 592 }
 593
 594 /*
 595  * ~INetMessageIOStream.
 596  */
 597 INetMessageIOStream::~INetMessageIOStream (void)
 598 {
 599 }
 600
 601 /*=======================================================================
 602  *
 603  * INetMessageEncodeQPStream_Impl Implementation.
 604  * (Quoted-Printable Encoding)
 605  *
 606  *=====================================================================*/
 607 static const sal_Char hex2pr[16] = {
 608     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 609     'A', 'B', 'C', 'D', 'E', 'F'
 610 };
 611
 612 static const sal_Char ebcdic[] = {
 613     '!', '"', '#', '$', '@', '[', '\\', ']', '^', '`', '{', '|', '}', '~'
 614 };
 615
 616 /*
 617  * INetMessageEncodeQPStream_Impl.
 618  */
 619 INetMessageEncodeQPStream_Impl::INetMessageEncodeQPStream_Impl (
 620     ULONG nMsgBufferSize)
 621     : INetMessageIStream (),
 622       pMsgStrm   (NULL),
 623       nMsgBufSiz (nMsgBufferSize),
 624       nTokBufSiz (80),
 625       eState     (INETMSG_EOL_SCR),
 626       bDone      (FALSE)
 627 {
 628     GenerateHeader (FALSE);
 629
 630     pMsgBuffer = new sal_Char[nMsgBufSiz];
 631     pMsgRead = pMsgWrite = pMsgBuffer;
 632
 633     pTokBuffer = new sal_Char[nTokBufSiz];
 634     pTokRead = pTokWrite = pTokBuffer;
 635 }
 636
 637 /*
 638  * ~INetMessageEncodeQPStream_Impl.
 639  */
 640 INetMessageEncodeQPStream_Impl::~INetMessageEncodeQPStream_Impl (void)
 641 {
 642     delete pMsgStrm;
 643     delete [] pMsgBuffer;
 644     delete [] pTokBuffer;
 645 }
 646
 647 /*
 648  * GetMsgLine.
 649  */
 650 int INetMessageEncodeQPStream_Impl::GetMsgLine (sal_Char *pData, ULONG nSize)
 651 {
 652     INetMessage *pMsg = GetSourceMessage ();
 653     if (pMsg == NULL) return INETSTREAM_STATUS_ERROR;
 654
 655     if (pMsg->GetDocumentLB() == NULL) return 0;
 656     if (pMsgStrm == NULL) pMsgStrm = new SvStream (pMsg->GetDocumentLB());
 657
 658     sal_Char *pWBuf = pData;
 659     while (pWBuf < (pData + nSize))
 660     {
 661         // Caller's buffer not yet filled.
 662         if ((pMsgRead - pMsgWrite) > 0)
 663         {
 664             // Bytes still in message buffer.
 665             if ((eState != INETMSG_EOL_BEGIN) &&
 666                 ((pTokRead - pTokBuffer) < 72))
 667             {
 668                 // Token buffer not yet filled.
 669                 if (eState == INETMSG_EOL_FCR)
 670                 {
 671                     eState = INETMSG_EOL_BEGIN;
 672                     if (*pMsgWrite != '\n')
 673                     {
 674                         // Convert orphant <CR> into <CR><LF> sequence.
 675                         *pTokRead++ = '\n';
 676                     }
 677                     *pTokRead++ = *pMsgWrite++;
 678                 }
 679                 else if ((*pMsgWrite == ' ') || (*pMsgWrite == '\t'))
 680                 {
 681                     eState = INETMSG_EOL_FSP;
 682                     *pTokRead++ = *pMsgWrite++;
 683                 }
 684                 else if (*pMsgWrite == '\r')
 685                 {
 686                     // Found <CR>.
 687                     if (eState == INETMSG_EOL_FSP)
 688                     {
 689                         // Encode last (trailing space) character.
 690                         sal_uInt8 c = (sal_uInt8)(*(--pTokRead));
 691                         *pTokRead++ = '=';
 692                         *pTokRead++ = hex2pr[((c & 0xf0) >> 4)];
 693                         *pTokRead++ = hex2pr[((c & 0x0f)     )];
 694                     }
 695                     eState = INETMSG_EOL_FCR;
 696                     *pTokRead++ = *pMsgWrite++;
 697                 }
 698                 else if (*pMsgWrite == '\n')
 699                 {
 700                     // Found <LF> only.
 701                     if (eState == INETMSG_EOL_FSP)
 702                     {
 703                         // Encode last (trailing space) character.
 704                         sal_uInt8 c = (sal_uInt8)(*(--pTokRead));
 705                         *pTokRead++ = '=';
 706                         *pTokRead++ = hex2pr[((c & 0xf0) >> 4)];
 707                         *pTokRead++ = hex2pr[((c & 0x0f)     )];
 708                     }
 709                     eState = INETMSG_EOL_BEGIN;
 710
 711                     // Convert orphant <LF> into <CR><LF> sequence.
 712                     *pTokRead++ = '\r';
 713                     *pTokRead++ = *pMsgWrite++;
 714                 }
 715                 else if (*pMsgWrite == '=')
 716                 {
 717                     // Escape character itself MUST be encoded, of course.
 718                     sal_uInt8 c = (sal_uInt8)(*pMsgWrite++);
 719                     *pTokRead++ = '=';
 720                     *pTokRead++ = hex2pr[((c & 0xf0) >> 4)];
 721                     *pTokRead++ = hex2pr[((c & 0x0f)     )];
 722
 723                     eState = INETMSG_EOL_SCR;
 724                 }
 725                 else if (((sal_uInt8)(*pMsgWrite) > 0x20) &&
 726                          ((sal_uInt8)(*pMsgWrite) < 0x7f)    )
 727                 {
 728                     /*
 729                      * Some printable ASCII character.
 730                      * (Encode EBCDIC special characters (NYI)).
 731                      */
 732                     *pTokRead++ = *pMsgWrite++;
 733                     eState = INETMSG_EOL_SCR;
 734                 }
 735                 else
 736                 {
 737                     // Encode any other character.
 738                     sal_uInt8 c = (sal_uInt8)(*pMsgWrite++);
 739                     *pTokRead++ = '=';
 740                     *pTokRead++ = hex2pr[((c & 0xf0) >> 4)];
 741                     *pTokRead++ = hex2pr[((c & 0x0f)     )];
 742
 743                     eState = INETMSG_EOL_SCR;
 744                 }
 745             }
 746             else
 747             {
 748                 // Check for maximum line length.
 749                 if (eState != INETMSG_EOL_BEGIN)
 750                 {
 751                     // Insert soft line break.
 752                     *pTokRead++ = '=';
 753                     *pTokRead++ = '\r';
 754                     *pTokRead++ = '\n';
 755
 756                     eState = INETMSG_EOL_BEGIN;
 757                 }
 758
 759                 // Copy to caller's buffer.
 760                 if ((pTokRead - pTokWrite) > 0)
 761                 {
 762                     // Bytes still in token buffer.
 763                     *pWBuf++ = *pTokWrite++;
 764                 }
 765                 else
 766                 {
 767                     // Token buffer empty. Reset to <Begin-of-Buffer>.
 768                     pTokRead = pTokWrite = pTokBuffer;
 769                     eState = INETMSG_EOL_SCR;
 770                 }
 771             }
 772         }
 773         else
 774         {
 775             // Message buffer empty. Reset to <Begin-of-Buffer>.
 776             pMsgRead = pMsgWrite = pMsgBuffer;
 777
 778             // Read next message block.
 779             ULONG nRead = pMsgStrm->Read (pMsgBuffer, nMsgBufSiz);
 780             if (nRead > 0)
 781             {
 782                 // Set read pointer.
 783                 pMsgRead = (pMsgBuffer + nRead);
 784             }
 785             else
 786             {
 787                 // Nothing more ro read.
 788                 if (!bDone)
 789                 {
 790                     // Append final <CR><LF> and mark we're done.
 791                     *pTokRead++ = '\r';
 792                     *pTokRead++ = '\n';
 793
 794                     bDone = TRUE;
 795                 }
 796                 else
 797                 {
 798                     // Already done all encoding.
 799                     if ((pTokRead - pTokWrite) > 0)
 800                     {
 801                         // Bytes still in token buffer.
 802                         *pWBuf++ = *pTokWrite++;
 803                     }
 804                     else
 805                     {
 806                         // Token buffer empty. Reset to <Begin-of-Buffer>.
 807                         pTokRead = pTokWrite = pTokBuffer;
 808
 809                         // Return.
 810                         return (pWBuf - pData);
 811                     }
 812                 }
 813             }
 814         }
 815     }
 816     return (pWBuf - pData);
 817 }
 818
 819 /*=====================================================================
 820  *
 821  * INetMessageDecodeQPStream_Impl Implementation.
 822  * (Quoted-Printable Decoding)
 823  *
 824  *====================================================================*/
 825 static const sal_uInt8 pr2hex[128] = {
 826     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 827     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 828     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 829     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 830
 831     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 832     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 833     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 834     0x08, 0x09, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 835
 836     0x10, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
 837     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 838     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 839     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 840
 841     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 842     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 843     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
 844     0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10
 845 };
 846
 847 /*
 848  * INetMessageDecodeQPStream_Impl.
 849  */
 850 INetMessageDecodeQPStream_Impl::INetMessageDecodeQPStream_Impl (void)
 851     : INetMessageOStream (),
 852       eState     (INETMSG_EOL_BEGIN),
 853       pMsgBuffer (new SvMemoryStream),
 854       nTokBufLen (0)
 855 {
 856     ParseHeader (FALSE);
 857 }
 858
 859 /*
 860  * ~INetMessageDecodeQPStream_Impl.
 861  */
 862 INetMessageDecodeQPStream_Impl::~INetMessageDecodeQPStream_Impl (void)
 863 {
 864     delete pMsgBuffer;
 865 }
 866
 867 /*
 868  * PutMsgLine.
 869  */
 870 int INetMessageDecodeQPStream_Impl::PutMsgLine (
 871     const sal_Char *pData, ULONG nSize)
 872 {
 873     INetMessage *pMsg = GetTargetMessage();
 874     if (pMsg == NULL) return INETSTREAM_STATUS_ERROR;
 875
 876     SvOpenLockBytes * pLB = PTR_CAST(SvOpenLockBytes, pMsg->GetDocumentLB());
 877     if (pLB == NULL) return INETSTREAM_STATUS_WOULDBLOCK;
 878
 879     const sal_Char *pStop = pData + nSize;
 880     while (pData < pStop)
 881     {
 882         if (eState == INETMSG_EOL_FESC)
 883         {
 884             *(pTokBuffer + nTokBufLen++) = static_cast< char >(toupper(*pData));
 885             pData++;
 886             if (nTokBufLen == 2)
 887             {
 888                 if ((*pTokBuffer == '\r') || (*pTokBuffer == '\n'))
 889                 {
 890                     // Soft line break (=<CR><LF>). Emit buffer now.
 891                     eState = INETMSG_EOL_BEGIN;
 892                 }
 893                 else
 894                 {
 895                     // Decode token.
 896                     *pMsgBuffer << sal_uInt8 (
 897                         (pr2hex[(int)(pTokBuffer[0] & 0x7f)] << 4) |
 898                         (pr2hex[(int)(pTokBuffer[1] & 0x7f)] & 15)   );
 899
 900                     // Search for next <CR>.
 901                     eState = INETMSG_EOL_SCR;
 902                 }
 903
 904                 // Reset token buffer.
 905                 nTokBufLen = 0;
 906             }
 907         }
 908         else if (*pData == '=')
 909         {
 910             // Found escape character.
 911             pData++;
 912             eState = INETMSG_EOL_FESC;
 913         }
 914         else if (eState == INETMSG_EOL_FCR)
 915         {
 916             *pMsgBuffer << *pData++;
 917             eState = INETMSG_EOL_BEGIN;
 918         }
 919         else if (*pData == '\r')
 920         {
 921             *pMsgBuffer << *pData++;
 922             eState = INETMSG_EOL_FCR;
 923         }
 924         else
 925         {
 926             *pMsgBuffer << *pData++;
 927         }
 928
 929         if (eState == INETMSG_EOL_BEGIN)
 930         {
 931             sal_Size nRead = pMsgBuffer->Tell();
 932             if (nRead > 0)
 933             {
 934                 // Emit buffer.
 935                 sal_Size nDocSiz = pMsg->GetDocumentSize();
 936                 sal_Size nWrite  = 0;
 937
 938                 pLB->FillAppend (
 939                     (sal_Char *)(pMsgBuffer->GetData()), nRead, &nWrite);
 940                 pMsg->SetDocumentSize (nDocSiz + nWrite);
 941
 942                 if (nWrite < nRead) return INETSTREAM_STATUS_ERROR;
 943
 944                 pMsgBuffer->Seek (STREAM_SEEK_TO_BEGIN);
 945             }
 946             eState = INETMSG_EOL_SCR;
 947         }
 948     }
 949     return INETSTREAM_STATUS_OK;
 950 }
 951
 952 /*======================================================================
 953  *
 954  * INetMessageEncode64Stream_Impl Implementation.
 955  * (Base64 Encoding)
 956  *
 957  *====================================================================*/
 958 static const sal_Char six2pr[64] = {
 959     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
 960     'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 961     'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
 962     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
 963     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
 964 };
 965
 966 /*
 967  * INetMessageEncode64Stream_Impl.
 968  */
 969 INetMessageEncode64Stream_Impl::INetMessageEncode64Stream_Impl (
 970     ULONG nMsgBufferSize)
 971     : INetMessageIStream (),
 972       pMsgStrm   (NULL),
 973       nMsgBufSiz (nMsgBufferSize),
 974       nTokBufSiz (80),
 975       bDone      (FALSE)
 976 {
 977     GenerateHeader (FALSE);
 978
 979     pMsgBuffer = new sal_uInt8[nMsgBufSiz];
 980     pMsgRead = pMsgWrite = pMsgBuffer;
 981
 982     pTokBuffer = new sal_Char[nTokBufSiz];
 983     pTokRead = pTokWrite = pTokBuffer;
 984 }
 985
 986 /*
 987  * ~INetMessageEncode64Stream_Impl.
 988  */
 989 INetMessageEncode64Stream_Impl::~INetMessageEncode64Stream_Impl (void)
 990 {
 991     delete pMsgStrm;
 992     delete [] pMsgBuffer;
 993     delete [] pTokBuffer;
 994 }
 995
 996 /*
 997  * GetMsgLine.
 998  */
 999 int INetMessageEncode64Stream_Impl::GetMsgLine (sal_Char *pData, ULONG nSize)
1000 {
1001     INetMessage *pMsg = GetSourceMessage ();
1002     if (pMsg == NULL) return INETSTREAM_STATUS_ERROR;
1003
1004     if (pMsg->GetDocumentLB() == NULL) return 0;
1005     if (pMsgStrm == NULL) pMsgStrm = new SvStream (pMsg->GetDocumentLB());
1006
1007     sal_Char *pWBuf = pData;
1008     while (pWBuf < (pData + nSize))
1009     {
1010         // Caller's buffer not yet filled.
1011         if ((pMsgRead - pMsgWrite) > 0)
1012         {
1013             // Bytes still in message buffer.
1014             if ((pTokRead - pTokBuffer) < 72)
1015             {
1016                 // Token buffer not yet filled.
1017                 switch ((pTokRead - pTokBuffer) % 4)
1018                 {
1019                     case 0:
1020                         *pTokRead++ = six2pr[(int)(*pMsgWrite >> 2)];
1021                         break;
1022
1023                     case 1:
1024                         *pTokRead++ = six2pr[
1025                             (int)(((*pMsgWrite << 4) & 060) |
1026                                   (((*(pMsgWrite + 1)) >> 4) & 017))];
1027                         pMsgWrite++;
1028                         break;
1029
1030                     case 2:
1031                         *pTokRead++ = six2pr[
1032                             (int)(((*pMsgWrite << 2) & 074) |
1033                                   (((*(pMsgWrite + 1)) >> 6) & 003))];
1034                         pMsgWrite++;
1035                         break;
1036
1037                     default: // == case 3
1038                         *pTokRead++ = six2pr[(int)(*pMsgWrite & 077)];
1039                         pMsgWrite++;
1040                         break;
1041                 }
1042             }
1043             else if ((pTokRead - pTokBuffer) == 72)
1044             {
1045                 // Maximum line length. Append <CR><LF>.
1046                 *pTokRead++ = '\r';
1047                 *pTokRead++ = '\n';
1048             }
1049             else
1050             {
1051                 if ((pTokRead - pTokWrite) > 0)
1052                 {
1053                     // Bytes still in token buffer.
1054                     *pWBuf++ = *pTokWrite++;
1055                 }
1056                 else
1057                 {
1058                     // Token buffer empty. Reset to <Begin-of-Buffer>.
1059                     pTokRead = pTokWrite = pTokBuffer;
1060                 }
1061             }
1062         }
1063         else
1064         {
1065             // Message buffer empty. Reset to <Begin-of-Buffer>.
1066             pMsgRead = pMsgWrite = pMsgBuffer;
1067
1068             // Read next message block.
1069             ULONG nRead = pMsgStrm->Read (pMsgBuffer, nMsgBufSiz);
1070             if (nRead > 0)
1071             {
1072                 // Set read pointer.
1073                 pMsgRead = (pMsgBuffer + nRead);
1074             }
1075             else
1076             {
1077                 // Nothing more to read.
1078                 if (!bDone)
1079                 {
1080                     // Append pad character(s) and final <CR><LF>.
1081                     switch ((pTokRead - pTokBuffer) % 4)
1082                     {
1083                         case 2:
1084                             *pTokRead++ = '=';
1085                             // Fall through for 2nd pad character.
1086
1087                         case 3:
1088                             *pTokRead++ = '=';
1089                             break;
1090
1091                         default:
1092                             break;
1093                     }
1094                     *pTokRead++ = '\r';
1095                     *pTokRead++ = '\n';
1096
1097                     // Mark we're done.
1098                     bDone = TRUE;
1099                 }
1100                 else
1101                 {
1102                     // Already done all encoding.
1103                     if ((pTokRead - pTokWrite) > 0)
1104                     {
1105                         // Bytes still in token buffer.
1106                         *pWBuf++ = *pTokWrite++;
1107                     }
1108                     else
1109                     {
1110                         // Token buffer empty. Reset to <Begin-of-Buffer>.
1111                         pTokRead = pTokWrite = pTokBuffer;
1112
1113                         // Reset done flag, if everything has been done.
1114                         // if (pWBuf == pData) bDone = FALSE;
1115
1116                         // Return.
1117                         return (pWBuf - pData);
1118                     }
1119                 }
1120             }
1121         }
1122     } // while (pWBuf < (pData + nSize))
1123     return (pWBuf - pData);
1124 }
1125
1126 /*======================================================================
1127  *
1128  * INetMessageDecode64Stream_Impl Implementation.
1129  * (Base64 Decoding)
1130  *
1131  *====================================================================*/
1132 static const sal_uInt8 pr2six[256] = {
1133     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1134     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1135     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1136     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1137
1138     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1139     0x40, 0x40, 0x40, 0x3E, 0x40, 0x40, 0x40, 0x3F,
1140     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
1141     0x3C, 0x3D, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1142
1143     0x40, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
1144     0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
1145     0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
1146     0x17, 0x18, 0x19, 0x40, 0x40, 0x40, 0x40, 0x40,
1147
1148     0x40, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
1149     0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
1150     0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
1151     0x31, 0x32, 0x33, 0x40, 0x40, 0x40, 0x40, 0x40,
1152
1153     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1154     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1155     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1156     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1157
1158     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1159     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1160     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1161     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1162
1163     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1164     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1165     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1166     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1167
1168     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1169     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1170     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
1171     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
1172 };
1173
1174 /*
1175  * INetMessageDecode64Stream_Impl.
1176  */
1177 INetMessageDecode64Stream_Impl::INetMessageDecode64Stream_Impl (
1178     ULONG nMsgBufferSize)
1179     : INetMessageOStream (),
1180       eState     (INETMSG_EOL_SCR),
1181       nMsgBufSiz (nMsgBufferSize)
1182 {
1183     ParseHeader (FALSE);
1184
1185     pMsgBuffer = new sal_Char[nMsgBufSiz];
1186     pMsgRead = pMsgWrite = pMsgBuffer;
1187 }
1188
1189 /*
1190  * ~INetMessageDecode64Stream_Impl.
1191  */
1192 INetMessageDecode64Stream_Impl::~INetMessageDecode64Stream_Impl (void)
1193 {
1194     delete [] pMsgBuffer;
1195 }
1196
1197 /*
1198  * PutMsgLine.
1199  */
1200 int INetMessageDecode64Stream_Impl::PutMsgLine (
1201     const sal_Char *pData, ULONG nSize)
1202 {
1203     INetMessage *pMsg = GetTargetMessage ();
1204     if (pMsg == NULL) return INETSTREAM_STATUS_ERROR;
1205
1206     SvOpenLockBytes * pLB = PTR_CAST(SvOpenLockBytes, pMsg->GetDocumentLB());
1207     if (pLB == NULL) return INETSTREAM_STATUS_WOULDBLOCK;
1208
1209     const sal_Char *pStop = (pData + nSize);
1210     while (pData < pStop)
1211     {
1212         if (pr2six[(int)(*pData)] > 63)
1213         {
1214             /*
1215              * Character not in base64 alphabet.
1216              * Check for <End-of-Stream> or Junk.
1217              */
1218             if (*pData == '=')
1219             {
1220                 // Final pad character -> Done.
1221                 sal_Size nDocSiz = pMsg->GetDocumentSize();
1222                 sal_Size nRead   = pMsgWrite - pMsgBuffer;
1223                 sal_Size nWrite  = 0;
1224
1225                 pLB->FillAppend (pMsgBuffer, nRead, &nWrite);
1226                 pMsg->SetDocumentSize (nDocSiz + nWrite);
1227
1228                 if (nWrite < nRead)
1229                     return INETSTREAM_STATUS_ERROR;
1230                 else
1231                     return INETSTREAM_STATUS_LOADED;
1232             }
1233             else if (eState == INETMSG_EOL_FCR)
1234             {
1235                 // Skip any line break character.
1236                 if ((*pData == '\r') || (*pData == '\n')) pData++;
1237
1238                 // Store decoded message buffer contents.
1239                 sal_Size nDocSiz = pMsg->GetDocumentSize();
1240                 sal_Size nRead   = pMsgWrite - pMsgBuffer;
1241                 sal_Size nWrite  = 0;
1242
1243                 pLB->FillAppend (pMsgBuffer, nRead, &nWrite);
1244                 pMsg->SetDocumentSize (nDocSiz + nWrite);
1245
1246                 if (nWrite < nRead) return INETSTREAM_STATUS_ERROR;
1247
1248                 // Reset to <Begin-of-Buffer>.
1249                 pMsgWrite = pMsgBuffer;
1250                 eState = INETMSG_EOL_SCR;
1251             }
1252             else if ((*pData == '\r') || (*pData == '\n'))
1253             {
1254                 // Skip any line break character.
1255                 pData++;
1256                 eState = INETMSG_EOL_FCR;
1257             }
1258             else
1259             {
1260                 // Skip any junk character (may be transmission error).
1261                 pData++;
1262             }
1263         }
1264         else
1265         {
1266             // Decode any other character into message buffer.
1267             switch ((pMsgRead - pMsgBuffer) % 4)
1268             {
1269                 case 0:
1270                     *pMsgWrite    = (pr2six[(int)(*pData++)] << 2);
1271                     pMsgRead++;
1272                     break;
1273
1274                 case 1:
1275                     *pMsgWrite++ |= (pr2six[(int)(*pData  )] >> 4);
1276                     *pMsgWrite    = (pr2six[(int)(*pData++)] << 4);
1277                     pMsgRead++;
1278                     break;
1279
1280                 case 2:
1281                     *pMsgWrite++ |= (pr2six[(int)(*pData  )] >> 2);
1282                     *pMsgWrite    = (pr2six[(int)(*pData++)] << 6);
1283                     pMsgRead++;
1284                     break;
1285
1286                 default: // == case 3
1287                     *pMsgWrite++ |= (pr2six[(int)(*pData++)]);
1288                     pMsgRead = pMsgBuffer;
1289                     break;
1290             } // switch ((pMsgRead - pMsgBuffer) % 4)
1291         }
1292     } // while (pData < pStop)
1293     return INETSTREAM_STATUS_OK;
1294 }
1295
1296 /*=========================================================================
1297  *
1298  * INetMIMEMessageStream Implementation.
1299  *
1300  *=======================================================================*/
1301 /*
1302  * INetMIMEMessageStream.
1303  */
1304 INetMIMEMessageStream::INetMIMEMessageStream (ULONG nBufferSize)
1305     : INetMessageIOStream (nBufferSize),
1306       eState      (INETMSG_EOL_BEGIN),
1307       nChildIndex (0),
1308       pChildStrm  (NULL),
1309       eEncoding   (INETMSG_ENCODING_BINARY),
1310       pEncodeStrm (NULL),
1311       pDecodeStrm (NULL),
1312       pMsgBuffer  (NULL)
1313 {
1314 }
1315
1316 /*
1317  * ~INetMIMEMessageStream.
1318  */
1319 INetMIMEMessageStream::~INetMIMEMessageStream (void)
1320 {
1321     delete pChildStrm;
1322     delete pEncodeStrm;
1323     delete pDecodeStrm;
1324     delete pMsgBuffer;
1325 }
1326
1327 /*
1328  * GetMsgEncoding.
1329  */
1330 INetMessageEncoding
1331 INetMIMEMessageStream::GetMsgEncoding (const String& rContentType)
1332 {
1333     if ((rContentType.CompareIgnoreCaseToAscii ("message"  , 7) == 0) ||
1334         (rContentType.CompareIgnoreCaseToAscii ("multipart", 9) == 0)    )
1335         return INETMSG_ENCODING_7BIT;
1336
1337     if (rContentType.CompareIgnoreCaseToAscii ("text", 4) == 0)
1338     {
1339         if (rContentType.CompareIgnoreCaseToAscii ("text/plain", 10) == 0)
1340         {
1341             if (rContentType.GetTokenCount ('=') > 1)
1342             {
1343                 String aCharset (rContentType.GetToken (1, '='));
1344                 aCharset.EraseLeadingChars (' ');
1345                 aCharset.EraseLeadingChars ('"');
1346
1347                 if (aCharset.CompareIgnoreCaseToAscii ("us-ascii", 8) == 0)
1348                     return INETMSG_ENCODING_7BIT;
1349                 else
1350                     return INETMSG_ENCODING_QUOTED;
1351             }
1352             else
1353                 return INETMSG_ENCODING_7BIT;
1354         }
1355         else
1356             return INETMSG_ENCODING_QUOTED;
1357     }
1358
1359     return INETMSG_ENCODING_BASE64;
1360 }
1361
1362 /*
1363  * GetMsgLine.
1364  * (Message Generator).
1365  */
1366 int INetMIMEMessageStream::GetMsgLine (sal_Char *pData, ULONG nSize)
1367 {
1368     // Check for message container.
1369     INetMIMEMessage *pMsg = GetSourceMessage();
1370     if (pMsg == NULL) return INETSTREAM_STATUS_ERROR;
1371
1372     // Check for header or body.
1373     if (!IsHeaderGenerated())
1374     {
1375         if (eState == INETMSG_EOL_BEGIN)
1376         {
1377             // Prepare special header fields.
1378             if (pMsg->GetParent())
1379             {
1380                 String aPCT (pMsg->GetParent()->GetContentType());
1381                 if (aPCT.CompareIgnoreCaseToAscii ("message/rfc822", 14) == 0)
1382                     pMsg->SetMIMEVersion (
1383                         String(CONSTASCII_STRINGPARAM("1.0")));
1384                 else
1385                     pMsg->SetMIMEVersion (String());
1386             }
1387             else
1388             {
1389                 pMsg->SetMIMEVersion (String(CONSTASCII_STRINGPARAM("1.0")));
1390             }
1391
1392             // Check ContentType.
1393             String aContentType (pMsg->GetContentType());
1394             if (aContentType.Len())
1395             {
1396                 // Determine default Content-Type.
1397                 String aDefaultType;
1398                 pMsg->GetDefaultContentType (aDefaultType);
1399
1400                 if (aDefaultType.CompareIgnoreCaseToAscii (
1401                     aContentType, aContentType.Len()) == 0)
1402                 {
1403                     // No need to specify default.
1404                     pMsg->SetContentType (String());
1405                 }
1406             }
1407
1408             // Check Encoding.
1409             String aEncoding (pMsg->GetContentTransferEncoding());
1410             if (aEncoding.Len())
1411             {
1412                 // Use given Encoding.
1413                 if (aEncoding.CompareIgnoreCaseToAscii (
1414                     "base64", 6) == 0)
1415                     eEncoding = INETMSG_ENCODING_BASE64;
1416                 else if (aEncoding.CompareIgnoreCaseToAscii (
1417                     "quoted-printable", 16) == 0)
1418                     eEncoding = INETMSG_ENCODING_QUOTED;
1419                 else
1420                     eEncoding = INETMSG_ENCODING_7BIT;
1421             }
1422             else
1423             {
1424                 // Use default Encoding for (given|default) Content-Type.
1425                 if (aContentType.Len() == 0)
1426                 {
1427                     // Determine default Content-Type.
1428                     pMsg->GetDefaultContentType (aContentType);
1429                 }
1430                 eEncoding = GetMsgEncoding (aContentType);
1431             }
1432
1433             // Set Content-Transfer-Encoding header.
1434             if (eEncoding == INETMSG_ENCODING_BASE64)
1435             {
1436                 // Base64.
1437                 pMsg->SetContentTransferEncoding (
1438                     String(CONSTASCII_STRINGPARAM("base64")));
1439             }
1440             else if (eEncoding == INETMSG_ENCODING_QUOTED)
1441             {
1442                 // Quoted-Printable.
1443                 pMsg->SetContentTransferEncoding (
1444                     String(CONSTASCII_STRINGPARAM("quoted-printable")));
1445             }
1446             else
1447             {
1448                 // No need to specify default.
1449                 pMsg->SetContentTransferEncoding (String());
1450             }
1451
1452             // Mark we're done.
1453             eState = INETMSG_EOL_DONE;
1454         }
1455
1456         // Generate the message header.
1457         int nRead = INetMessageIOStream::GetMsgLine (pData, nSize);
1458         if (nRead <= 0)
1459         {
1460             // Reset state.
1461             eState = INETMSG_EOL_BEGIN;
1462         }
1463         return nRead;
1464     }
1465     else
1466     {
1467         // Generate the message body.
1468         if (pMsg->IsContainer())
1469         {
1470             // Encapsulated message body.
1471             while (eState == INETMSG_EOL_BEGIN)
1472             {
1473                 if (pChildStrm == NULL)
1474                 {
1475                     INetMIMEMessage *pChild = pMsg->GetChild (nChildIndex);
1476                     if (pChild)
1477                     {
1478                         // Increment child index.
1479                         nChildIndex++;
1480
1481                         // Create child stream.
1482                         pChildStrm = new INetMIMEMessageStream;
1483                         pChildStrm->SetSourceMessage (pChild);
1484
1485                         if (pMsg->IsMultipart())
1486                         {
1487                             // Insert multipart delimiter.
1488                             ByteString aDelim ("--");
1489                             aDelim += pMsg->GetMultipartBoundary();
1490                             aDelim += "\r\n";
1491
1492                             rtl_copyMemory (
1493                                 pData, aDelim.GetBuffer(), aDelim.Len());
1494                             return aDelim.Len();
1495                         }
1496                     }
1497                     else
1498                     {
1499                         // No more parts. Mark we're done.
1500                         eState = INETMSG_EOL_DONE;
1501                         nChildIndex = 0;
1502
1503                         if (pMsg->IsMultipart())
1504                         {
1505                             // Insert close delimiter.
1506                             ByteString aDelim ("--");
1507                             aDelim += pMsg->GetMultipartBoundary();
1508                             aDelim += "--\r\n";
1509
1510                             rtl_copyMemory (
1511                                 pData, aDelim.GetBuffer(), aDelim.Len());
1512                             return aDelim.Len();
1513                         }
1514                     }
1515                 }
1516                 else
1517                 {
1518                     // Read current child stream.
1519                     int nRead = pChildStrm->Read (pData, nSize);
1520                     if (nRead > 0)
1521                     {
1522                         return nRead;
1523                     }
1524                     else
1525                     {
1526                         // Cleanup exhausted child stream.
1527                         delete pChildStrm;
1528                         pChildStrm = NULL;
1529                     }
1530                 }
1531             }
1532             return 0;
1533         }
1534         else
1535         {
1536             // Single part message body.
1537             if (pMsg->GetDocumentLB() == NULL)
1538             {
1539                 // Empty message body.
1540                 return 0;
1541             }
1542             else
1543             {
1544                 // Check whether message body needs to be encoded.
1545                 if (eEncoding == INETMSG_ENCODING_7BIT)
1546                 {
1547                     // No Encoding.
1548                     return INetMessageIOStream::GetMsgLine (pData, nSize);
1549                 }
1550                 else
1551                 {
1552                     // Apply appropriate Encoding.
1553                     while (eState == INETMSG_EOL_BEGIN)
1554                     {
1555                         if (pEncodeStrm == NULL)
1556                         {
1557                             // Create encoder stream.
1558                             if (eEncoding == INETMSG_ENCODING_QUOTED)
1559                             {
1560                                 // Quoted-Printable Encoding.
1561                                 pEncodeStrm
1562                                  = new INetMessageEncodeQPStream_Impl;
1563                             }
1564                             else
1565                             {
1566                                 // Base64 Encoding.
1567                                 pEncodeStrm
1568                                  = new INetMessageEncode64Stream_Impl;
1569                             }
1570                             pEncodeStrm->SetSourceMessage (pMsg);
1571                         }
1572
1573                         // Read encoded message.
1574                         int nRead = pEncodeStrm->Read (pData, nSize);
1575                         if (nRead > 0)
1576                         {
1577                             return nRead;
1578                         }
1579                         else
1580                         {
1581                             // Cleanup exhausted encoder stream.
1582                             delete pEncodeStrm;
1583                             pEncodeStrm = NULL;
1584
1585                             // Mark we're done.
1586                             eState = INETMSG_EOL_DONE;
1587                         }
1588                     }
1589                     return 0;
1590                 }
1591             }
1592         }
1593     }
1594 }
1595
1596 /*
1597  * PutMsgLine.
1598  * (Message Parser).
1599  */
1600 int INetMIMEMessageStream::PutMsgLine (const sal_Char *pData, ULONG nSize)
1601 {
1602     // Check for message container.
1603     INetMIMEMessage *pMsg = GetTargetMessage();
1604     if (pMsg == NULL) return INETSTREAM_STATUS_ERROR;
1605
1606     // Check for header or body.
1607     if (!IsHeaderParsed())
1608     {
1609         // Parse the message header.
1610         int nRet = INetMessageIOStream::PutMsgLine (pData, nSize);
1611         return nRet;
1612     }
1613     else
1614     {
1615         pMsg->SetHeaderParsed();
1616         // Parse the message body.
1617         if (pMsg->IsContainer())
1618         {
1619
1620             // Content-Transfer-Encoding MUST be "7bit" (RFC1521).
1621             if (pMsg->IsMessage())
1622             {
1623                 if( !pChildStrm )
1624                 {
1625                     // Encapsulated message.
1626                     pMsg->SetChildCount( pMsg->GetChildCount() + 1);
1627                     INetMIMEMessage* pNewMessage = new INetMIMEMessage;
1628                     pNewMessage->SetDocumentLB (
1629                         new SvAsyncLockBytes(new SvCacheStream, FALSE));
1630                     pMsg->AttachChild( *pNewMessage, TRUE );
1631
1632                     // Encapsulated message body. Create message parser stream.
1633                     pChildStrm = new INetMIMEMessageStream;
1634                     pChildStrm->SetTargetMessage ( pNewMessage );
1635
1636                     // Initialize control variables.
1637                     eState = INETMSG_EOL_BEGIN;
1638                 }
1639                 if ( nSize > 0)
1640                 {
1641                     // Bytes still in buffer. Put message down-stream.
1642                     int status = pChildStrm->Write( pData, nSize );
1643                     if (status != INETSTREAM_STATUS_OK)
1644                         return status;
1645                 }
1646
1647                 return INetMessageIOStream::PutMsgLine (pData, nSize);
1648             }
1649             else
1650             {
1651
1652                 // Multipart message body. Initialize multipart delimiters.
1653                 // Multipart message.
1654                 if (pMsg->GetMultipartBoundary().Len() == 0)
1655                 {
1656                     // Determine boundary.
1657                     ByteString aType (
1658                         pMsg->GetContentType(), RTL_TEXTENCODING_ASCII_US);
1659                     ByteString aLowerType (aType);
1660                     aLowerType.ToLowerAscii();
1661
1662                     USHORT nPos = aLowerType.Search ("boundary=");
1663                     ByteString aBoundary (aType.Copy (nPos + 9));
1664
1665                     aBoundary.EraseLeadingAndTrailingChars (' ');
1666                     aBoundary.EraseLeadingAndTrailingChars ('"');
1667
1668                     // Save boundary.
1669                     pMsg->SetMultipartBoundary (aBoundary);
1670                 }
1671
1672                 ByteString aPlainDelim (pMsg->GetMultipartBoundary());
1673                 ByteString aDelim ("--");
1674                 aDelim += aPlainDelim;
1675
1676                 ByteString aPlainClose (aPlainDelim);
1677                 aPlainClose += "--";
1678
1679                 ByteString aClose (aDelim);
1680                 aClose += "--";
1681
1682                 if (pMsgBuffer == NULL) pMsgBuffer = new SvMemoryStream;
1683                 pMsgBuffer->Write (pData, nSize);
1684                 ULONG nBufSize = pMsgBuffer->Tell();
1685
1686                 const sal_Char* pChar;
1687                 const sal_Char* pOldPos;
1688                 for( pOldPos = pChar = (const sal_Char *) pMsgBuffer->GetData(); nBufSize--;
1689                      pChar++ )
1690                 {
1691                     int status;
1692                     if( *pChar == '\r' || *pChar == '\n' )
1693                     {
1694                         if( aDelim.CompareTo (pOldPos, aDelim.Len())
1695                             != COMPARE_EQUAL &&
1696                             aClose.CompareTo (pOldPos, aClose.Len())
1697                             != COMPARE_EQUAL &&
1698                             aPlainDelim.CompareTo (pOldPos, aPlainDelim.Len())
1699                             != COMPARE_EQUAL &&
1700                             aPlainClose.CompareTo(pOldPos, aPlainClose.Len())
1701                             != COMPARE_EQUAL )
1702                         {
1703                             if( nBufSize &&
1704                                 ( pChar[1] == '\r' || pChar[1] == '\n' ) )
1705                                 nBufSize--, pChar++;
1706                             if( pChildStrm )
1707                             {
1708                                 status = pChildStrm->Write(
1709                                     pOldPos, pChar - pOldPos + 1 );
1710                                 if( status != INETSTREAM_STATUS_OK )
1711                                     return status;
1712                             }
1713                             else {
1714                                 DBG_ERRORFILE( "Die Boundary nicht gefunden" );
1715                             }
1716                             status = INetMessageIOStream::PutMsgLine(
1717                                 pOldPos, pChar - pOldPos + 1 );
1718                             if( status != INETSTREAM_STATUS_OK )
1719                                 return status;
1720                             pOldPos = pChar + 1;
1721                         }
1722                         else
1723                         {
1724                             if( nBufSize &&
1725                                 ( pChar[1] == '\r' || pChar[1] == '\n' ) )
1726                                 nBufSize--, pChar++;
1727                             pOldPos = pChar + 1;
1728                             DELETEZ( pChildStrm );
1729
1730                             if (aClose.CompareTo (pOldPos, aClose.Len())
1731                                 != COMPARE_EQUAL &&
1732                                 aPlainClose.CompareTo (pOldPos, aClose.Len())
1733                                 != COMPARE_EQUAL )
1734                             {
1735                                 // Encapsulated message.
1736                                 pMsg->SetChildCount(pMsg->GetChildCount() + 1);
1737                                 INetMIMEMessage* pNewMessage =
1738                                     new INetMIMEMessage;
1739                                 pNewMessage->SetDocumentLB (
1740                                     new SvAsyncLockBytes (
1741                                         new SvCacheStream, FALSE));
1742
1743                                 pMsg->AttachChild( *pNewMessage, TRUE );
1744
1745                                 // Encapsulated message body. Create message parser stream.
1746                                 pChildStrm = new INetMIMEMessageStream;
1747                                 pChildStrm->SetTargetMessage ( pNewMessage );
1748
1749                                 // Initialize control variables.
1750                             }
1751                             eState = INETMSG_EOL_BEGIN;
1752                             status = INetMessageIOStream::PutMsgLine(
1753                                 pOldPos, pChar - pOldPos + 1 );
1754                             if( status != INETSTREAM_STATUS_OK )
1755                                 return status;
1756                         }
1757                     }
1758                 }
1759                 if( pOldPos < pChar )
1760                 {
1761                     SvMemoryStream* pNewStream = new SvMemoryStream;
1762                     pNewStream->Write( pOldPos, pChar - pOldPos );
1763                     SvMemoryStream* pTmp = pMsgBuffer;
1764                     pMsgBuffer = pNewStream;
1765                     delete pTmp;
1766                 }
1767                 else
1768                 {
1769                     pMsgBuffer->Seek( 0L );
1770                     pMsgBuffer->SetStreamSize( 0 );
1771                 }
1772                 return INETSTREAM_STATUS_OK;
1773             }
1774         }
1775         else
1776         {
1777             /*
1778              * Single part message.
1779              * Remove any ContentTransferEncoding.
1780              */
1781             if (pMsg->GetContentType().Len() == 0)
1782             {
1783                 String aDefaultCT;
1784                 pMsg->GetDefaultContentType (aDefaultCT);
1785                 pMsg->SetContentType (aDefaultCT);
1786             }
1787
1788             if (eEncoding == INETMSG_ENCODING_BINARY)
1789             {
1790                 String aEncoding (pMsg->GetContentTransferEncoding());
1791                 if (aEncoding.CompareIgnoreCaseToAscii (
1792                     "base64", 6) == COMPARE_EQUAL)
1793                     eEncoding = INETMSG_ENCODING_BASE64;
1794                 else if (aEncoding.CompareIgnoreCaseToAscii (
1795                     "quoted-printable", 16) == COMPARE_EQUAL)
1796                     eEncoding = INETMSG_ENCODING_QUOTED;
1797                 else
1798                     eEncoding = INETMSG_ENCODING_7BIT;
1799             }
1800
1801             if (eEncoding == INETMSG_ENCODING_7BIT)
1802             {
1803                 // No decoding necessary.
1804                 return INetMessageIOStream::PutMsgLine (pData, nSize);
1805             }
1806             else
1807             {
1808                 if (pDecodeStrm == NULL)
1809                 {
1810                     if (eEncoding == INETMSG_ENCODING_QUOTED)
1811                         pDecodeStrm = new INetMessageDecodeQPStream_Impl;
1812                     else
1813                         pDecodeStrm = new INetMessageDecode64Stream_Impl;
1814
1815                     pDecodeStrm->SetTargetMessage (pMsg);
1816                 }
1817                 return pDecodeStrm->Write (pData, nSize);
1818             }
1819         }
1820     }
1821 }
1822
1823
1824