tools/source/inet/inetstrm.cxx

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