tools/source/inet/inetmsg.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: inetmsg.cxx,v $
  10  * $Revision: 1.12 $
  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 <tools/datetime.hxx>
  35 #ifndef _TOOLS_INETMIME_HXX
  36 #include <tools/inetmime.hxx>
  37 #endif
  38 #include <tools/inetmsg.hxx>
  39 #include <tools/inetstrm.hxx>
  40 #include <rtl/instance.hxx>
  41
  42 #include <stdio.h>
  43
  44 //=======================================================================
  45
  46 inline sal_Bool ascii_isDigit( sal_Unicode ch )
  47 {
  48     return ((ch >= 0x0030) && (ch <= 0x0039));
  49 }
  50
  51 inline sal_Bool ascii_isLetter( sal_Unicode ch )
  52 {
  53     return (( (ch >= 0x0041) && (ch <= 0x005A)) || ((ch >= 0x0061) && (ch <= 0x007A)));
  54 }
  55
  56 inline sal_Unicode ascii_toLowerCase( sal_Unicode ch )
  57 {
  58     if ( (ch >= 0x0041) && (ch <= 0x005A) )
  59         return ch + 0x20;
  60     else
  61         return ch;
  62 }
  63
  64 /*=======================================================================
  65  *
  66  * INetMessage Implementation.
  67  *
  68  *=====================================================================*/
  69 #define CONSTASCII_STRINGPARAM(a) (a), RTL_TEXTENCODING_ASCII_US
  70 #define HEADERFIELD INetMessageHeader
  71
  72 /*
  73  * ~INetMessage.
  74  */
  75 INetMessage::~INetMessage (void)
  76 {
  77     ListCleanup_Impl();
  78 }
  79
  80 /*
  81  * ListCleanup_Impl.
  82  */
  83 void INetMessage::ListCleanup_Impl (void)
  84 {
  85     // Cleanup.
  86     ULONG i, n = m_aHeaderList.Count();
  87     for (i = 0; i < n; i++)
  88         delete ((HEADERFIELD*)(m_aHeaderList.GetObject(i)));
  89     m_aHeaderList.Clear();
  90 }
  91
  92 /*
  93  * ListCopy.
  94  */
  95 void INetMessage::ListCopy (const INetMessage &rMsg)
  96 {
  97     if (!(this == &rMsg))
  98     {
  99         // Cleanup.
 100         ListCleanup_Impl();
 101
 102         // Copy.
 103         ULONG i, n = rMsg.GetHeaderCount();
 104         for (i = 0; i < n; i++)
 105         {
 106             HEADERFIELD *p = (HEADERFIELD*)(rMsg.m_aHeaderList.GetObject(i));
 107             m_aHeaderList.Insert (new HEADERFIELD(*p), LIST_APPEND);
 108         }
 109     }
 110 }
 111
 112 /*
 113  * SetHeaderField_Impl.
 114  */
 115 void INetMessage::SetHeaderField_Impl (
 116     INetMIME::HeaderFieldType  eType,
 117     const ByteString          &rName,
 118     const UniString           &rValue,
 119     ULONG                     &rnIndex)
 120 {
 121     INetMIMEStringOutputSink aSink (0, STRING_MAXLEN);
 122     INetMIME::writeHeaderFieldBody (
 123         aSink, eType, rValue, gsl_getSystemTextEncoding(), false);
 124     SetHeaderField_Impl (
 125         INetMessageHeader (rName, aSink.takeBuffer()), rnIndex);
 126 }
 127
 128 /*
 129  * SetHeaderField.
 130  */
 131 ULONG INetMessage::SetHeaderField (
 132     const UniString& rName, const UniString& rValue, ULONG nIndex)
 133 {
 134     ULONG nResult = nIndex;
 135     SetHeaderField_Impl (
 136         INetMIME::HEADER_FIELD_TEXT,
 137         ByteString (rName, RTL_TEXTENCODING_ASCII_US), rValue,
 138         nResult);
 139     return nResult;
 140 }
 141
 142 /*
 143  * SetHeaderField.
 144  */
 145 ULONG INetMessage::SetHeaderField (
 146     const INetMessageHeader &rHeader, ULONG nIndex)
 147 {
 148     ULONG nResult = nIndex;
 149     SetHeaderField_Impl (rHeader, nResult);
 150     return nResult;
 151 }
 152
 153
 154 /*
 155  * operator<<
 156  */
 157 SvStream& INetMessage::operator<< (SvStream& rStrm) const
 158 {
 159     rStrm << static_cast<sal_uInt32>(m_nDocSize);
 160     rStrm.WriteByteString (m_aDocName, RTL_TEXTENCODING_UTF8);
 161
 162     ULONG i, n = m_aHeaderList.Count();
 163     rStrm << static_cast<sal_uInt32>(n);
 164
 165     for (i = 0; i < n; i++)
 166         rStrm << *((HEADERFIELD *)(m_aHeaderList.GetObject(i)));
 167
 168     return rStrm;
 169 }
 170
 171 /*
 172  * operator>>
 173  */
 174 SvStream& INetMessage::operator>> (SvStream& rStrm)
 175 {
 176     // Cleanup.
 177     m_nDocSize = 0;
 178     m_xDocLB.Clear();
 179     ListCleanup_Impl();
 180
 181     sal_uInt32 nTemp;
 182
 183     // Copy.
 184     rStrm >> nTemp;
 185     m_nDocSize = nTemp;
 186     rStrm.ReadByteString (m_aDocName, RTL_TEXTENCODING_UTF8);
 187
 188     ULONG i, n = 0;
 189     rStrm >> nTemp;
 190     n = nTemp;
 191
 192     for (i = 0; i < n; i++)
 193     {
 194         HEADERFIELD *p = new HEADERFIELD();
 195         rStrm >> *p;
 196         m_aHeaderList.Insert (p, LIST_APPEND);
 197     }
 198
 199     // Done.
 200     return rStrm;
 201 }
 202
 203 /*=======================================================================
 204  *
 205  * INetMessageHeaderIterator Implementation.
 206  *
 207  *=====================================================================*/
 208 INetMessageHeaderIterator::INetMessageHeaderIterator (
 209     const INetMessage& rMsg, const UniString& rHdrName)
 210 {
 211     ULONG i, n = rMsg.GetHeaderCount();
 212     for (i = 0; i < n; i++)
 213     {
 214         if (rHdrName.CompareIgnoreCaseToAscii (rMsg.GetHeaderName(i)) == 0)
 215         {
 216             UniString *pValue = new UniString (rMsg.GetHeaderValue(i));
 217             aValueList.Insert (pValue, LIST_APPEND);
 218         }
 219     }
 220     nValueCount = aValueList.Count();
 221 }
 222
 223 INetMessageHeaderIterator::~INetMessageHeaderIterator (void)
 224 {
 225     ULONG i, n = aValueList.Count();
 226     for (i = 0; i < n; i++)
 227         delete ((UniString*)(aValueList.GetObject(i)));
 228     aValueList.Clear();
 229 }
 230
 231 /*=======================================================================
 232  *
 233  * INetRFC822Message Implementation.
 234  *
 235  *=====================================================================*/
 236 /*
 237  * ImplINetRFC822MessageHeaderData.
 238  */
 239 namespace
 240 {
 241     struct ImplINetRFC822MessageHeaderDataImpl
 242     {
 243         const ByteString* operator()()
 244         {
 245             static const ByteString _ImplINetRFC822MessageHeaderData[] =
 246             {
 247                 ByteString ("BCC"),
 248                 ByteString ("CC"),
 249                 ByteString ("Comments"),
 250                 ByteString ("Date"),
 251                 ByteString ("From"),
 252                 ByteString ("In-Reply-To"),
 253                 ByteString ("Keywords"),
 254                 ByteString ("Message-ID"),
 255                 ByteString ("References"),
 256                 ByteString ("Reply-To"),
 257                 ByteString ("Return-Path"),
 258                 ByteString ("Subject"),
 259                 ByteString ("Sender"),
 260                 ByteString ("To"),
 261                 ByteString ("X-Mailer"),
 262                 ByteString ("Return-Receipt-To")
 263             };
 264             return &_ImplINetRFC822MessageHeaderData[0];
 265         }
 266     };
 267
 268     struct ImplINetRFC822MessageHeaderData
 269         : public rtl::StaticAggregate< const ByteString, ImplINetRFC822MessageHeaderDataImpl > {};
 270 }
 271
 272 #define HDR(n) ImplINetRFC822MessageHeaderData::get()[(n)]
 273
 274 /*
 275  * _ImplINetRFC822MessageHeaderState.
 276  */
 277 enum _ImplINetRFC822MessageHeaderState
 278 {
 279     INETMSG_RFC822_BEGIN,
 280     INETMSG_RFC822_CHECK,
 281     INETMSG_RFC822_OK,
 282     INETMSG_RFC822_JUNK,
 283
 284     INETMSG_RFC822_TOKEN_RE,
 285     INETMSG_RFC822_TOKEN_RETURNMINUS,
 286     INETMSG_RFC822_TOKEN_XMINUS,
 287     INETMSG_RFC822_LETTER_C,
 288     INETMSG_RFC822_LETTER_S
 289 };
 290
 291 /*
 292  * INetRFC822Message.
 293  */
 294 INetRFC822Message::INetRFC822Message (void)
 295     : INetMessage()
 296 {
 297     for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++)
 298         m_nIndex[i] = LIST_ENTRY_NOTFOUND;
 299 }
 300
 301 INetRFC822Message::INetRFC822Message (const INetRFC822Message& rMsg)
 302     : INetMessage (rMsg)
 303 {
 304     for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++)
 305         m_nIndex[i] = rMsg.m_nIndex[i];
 306 }
 307
 308 /*
 309  * operator=
 310  */
 311 INetRFC822Message& INetRFC822Message::operator= (const INetRFC822Message& rMsg)
 312 {
 313     if (this != &rMsg)
 314     {
 315         INetMessage::operator= (rMsg);
 316
 317         for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++)
 318             m_nIndex[i] = rMsg.m_nIndex[i];
 319     }
 320     return *this;
 321 }
 322
 323 /*
 324  * ~INetRFC822Message.
 325  */
 326 INetRFC822Message::~INetRFC822Message (void)
 327 {
 328 }
 329
 330 /*
 331  * <Generate|Parse>DateField and local helper functions.
 332  *
 333  * GenerateDateField.
 334  * Generates a String from Date and Time objects in format:
 335  *   Wkd, 00 Mon 0000 00:00:00 [GMT]            (rfc822, rfc1123)
 336  *
 337  * ParseDateField.
 338  * Parses a String in (implied) GMT format into class Date and Time objects.
 339  * Four formats are accepted:
 340  *
 341  *  [Wkd,] 1*2DIGIT Mon 2*4DIGIT 00:00:00 [GMT]  (rfc1123)
 342  *  [Wkd,] 00 Mon 0000 00:00:00 [GMT])           (rfc822, rfc1123)
 343  *   Weekday, 00-Mon-00 00:00:00 [GMT]           (rfc850, rfc1036)
 344  *   Wkd Mon 00 00:00:00 0000 [GMT]              (ctime)
 345  *   1*DIGIT                                     (delta seconds)
 346  *
 347  */
 348
 349 // Months and Weekdays.
 350 static const sal_Char *months[12] =
 351 {
 352     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 353     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 354 };
 355
 356 static const sal_Char *wkdays[7] =
 357 {
 358     "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
 359 };
 360
 361 /*
 362  * GenerateDateField.
 363  */
 364 BOOL INetRFC822Message::GenerateDateField (
 365     const DateTime& rDateTime, UniString& rDateFieldW)
 366 {
 367     // Check arguments.
 368     if (!rDateTime.IsValid()       ||
 369         (rDateTime.GetSec()  > 59) ||
 370         (rDateTime.GetMin()  > 59) ||
 371         (rDateTime.GetHour() > 23)    ) return FALSE;
 372
 373     // Prepare output string.
 374     ByteString rDateField;
 375
 376     // Insert Date.
 377     rDateField += wkdays[(USHORT)(rDateTime.GetDayOfWeek())];
 378     rDateField += ", ";
 379
 380     USHORT nNum = rDateTime.GetDay();
 381     if (nNum < 10) rDateField += '0';
 382     rDateField += ByteString::CreateFromInt32(nNum);
 383     rDateField += ' ';
 384
 385     rDateField += months[(USHORT)(rDateTime.GetMonth() - 1)];
 386     rDateField += ' ';
 387
 388     rDateField += ByteString::CreateFromInt32(rDateTime.GetYear());
 389     rDateField += ' ';
 390
 391     // Insert Time.
 392     nNum = rDateTime.GetHour();
 393     if (nNum < 10) rDateField += '0';
 394     rDateField += ByteString::CreateFromInt32(nNum);
 395     rDateField += ':';
 396
 397     nNum = rDateTime.GetMin();
 398     if (nNum < 10) rDateField += '0';
 399     rDateField += ByteString::CreateFromInt32(nNum);
 400     rDateField += ':';
 401
 402     nNum = rDateTime.GetSec();
 403     if (nNum < 10) rDateField += '0';
 404     rDateField += ByteString::CreateFromInt32(nNum);
 405     rDateField += " GMT";
 406
 407     // Done.
 408     rDateFieldW = UniString (rDateField, RTL_TEXTENCODING_ASCII_US);
 409     return TRUE;
 410 }
 411
 412 /*
 413  * ParseDateField and local helper functions.
 414  */
 415 static USHORT ParseNumber (const ByteString& rStr, USHORT& nIndex)
 416 {
 417     USHORT n = nIndex;
 418     while ((n < rStr.Len()) && ascii_isDigit(rStr.GetChar(n))) n++;
 419
 420     ByteString aNum (rStr.Copy (nIndex, (n - nIndex)));
 421     nIndex = n;
 422
 423     return (USHORT)(aNum.ToInt32());
 424 }
 425
 426 static USHORT ParseMonth (const ByteString& rStr, USHORT& nIndex)
 427 {
 428     USHORT n = nIndex;
 429     while ((n < rStr.Len()) && ascii_isLetter(rStr.GetChar(n))) n++;
 430
 431     ByteString aMonth (rStr.Copy (nIndex, 3));
 432     nIndex = n;
 433
 434     USHORT i;
 435     for (i = 0; i < 12; i++)
 436         if (aMonth.CompareIgnoreCaseToAscii (months[i]) == 0) break;
 437     return (i + 1);
 438 }
 439
 440 BOOL INetRFC822Message::ParseDateField (
 441     const UniString& rDateFieldW, DateTime& rDateTime)
 442 {
 443     ByteString rDateField (rDateFieldW, RTL_TEXTENCODING_ASCII_US);
 444     if (rDateField.Len() == 0) return FALSE;
 445
 446     if (rDateField.Search (':') != STRING_NOTFOUND)
 447     {
 448         // Some DateTime format.
 449         USHORT nIndex = 0;
 450
 451         // Skip over <Wkd> or <Weekday>, leading and trailing space.
 452         while ((nIndex < rDateField.Len()) &&
 453                (rDateField.GetChar(nIndex) == ' '))
 454             nIndex++;
 455
 456         while (
 457             (nIndex < rDateField.Len()) &&
 458             (ascii_isLetter (rDateField.GetChar(nIndex)) ||
 459              (rDateField.GetChar(nIndex) == ',')     ))
 460             nIndex++;
 461
 462         while ((nIndex < rDateField.Len()) &&
 463                (rDateField.GetChar(nIndex) == ' '))
 464             nIndex++;
 465
 466         if (ascii_isLetter (rDateField.GetChar(nIndex)))
 467         {
 468             // Format: ctime().
 469             if ((rDateField.Len() - nIndex) < 20) return FALSE;
 470
 471             rDateTime.SetMonth  (ParseMonth  (rDateField, nIndex)); nIndex++;
 472             rDateTime.SetDay    (ParseNumber (rDateField, nIndex)); nIndex++;
 473
 474             rDateTime.SetHour   (ParseNumber (rDateField, nIndex)); nIndex++;
 475             rDateTime.SetMin    (ParseNumber (rDateField, nIndex)); nIndex++;
 476             rDateTime.SetSec    (ParseNumber (rDateField, nIndex)); nIndex++;
 477             rDateTime.Set100Sec (0);
 478
 479             USHORT nYear = ParseNumber (rDateField, nIndex);
 480             if (nYear < 100) nYear += 1900;
 481             rDateTime.SetYear   (nYear);
 482         }
 483         else
 484         {
 485             // Format: RFC1036 or RFC1123.
 486             if ((rDateField.Len() - nIndex) < 17) return FALSE;
 487
 488             rDateTime.SetDay    (ParseNumber (rDateField, nIndex)); nIndex++;
 489             rDateTime.SetMonth  (ParseMonth  (rDateField, nIndex)); nIndex++;
 490
 491             USHORT nYear  = ParseNumber (rDateField, nIndex);  nIndex++;
 492             if (nYear < 100) nYear += 1900;
 493             rDateTime.SetYear   (nYear);
 494
 495             rDateTime.SetHour   (ParseNumber (rDateField, nIndex)); nIndex++;
 496             rDateTime.SetMin    (ParseNumber (rDateField, nIndex)); nIndex++;
 497             rDateTime.SetSec    (ParseNumber (rDateField, nIndex)); nIndex++;
 498             rDateTime.Set100Sec (0);
 499
 500             if ((rDateField.GetChar(nIndex) == '+') ||
 501                 (rDateField.GetChar(nIndex) == '-')    )
 502             {
 503                 // Offset from GMT: "(+|-)HHMM".
 504                 BOOL   bEast   = (rDateField.GetChar(nIndex++) == '+');
 505                 USHORT nOffset = ParseNumber (rDateField, nIndex);
 506                 if (nOffset > 0)
 507                 {
 508                     Time aDiff;
 509                     aDiff.SetHour   (nOffset / 100);
 510                     aDiff.SetMin    (nOffset % 100);
 511                     aDiff.SetSec    (0);
 512                     aDiff.Set100Sec (0);
 513
 514                     if (bEast)
 515                         rDateTime -= aDiff;
 516                     else
 517                         rDateTime += aDiff;
 518                 }
 519             }
 520         }
 521     }
 522     else if (rDateField.IsNumericAscii())
 523     {
 524         // Format: delta seconds.
 525         Time aDelta (0);
 526         aDelta.SetTime (rDateField.ToInt32() * 100);
 527
 528         DateTime aNow;
 529         aNow += aDelta;
 530         aNow.ConvertToUTC();
 531
 532         rDateTime.SetDate (aNow.GetDate());
 533         rDateTime.SetTime (aNow.GetTime());
 534     }
 535     else
 536     {
 537         // Junk.
 538         return FALSE;
 539     }
 540
 541     return (rDateTime.IsValid() &&
 542             !((rDateTime.GetSec()  > 59) ||
 543               (rDateTime.GetMin()  > 59) ||
 544               (rDateTime.GetHour() > 23)    ));
 545 }
 546
 547 /*
 548  * SetHeaderField.
 549  * (Header Field Parser).
 550  */
 551 ULONG INetRFC822Message::SetHeaderField (
 552     const INetMessageHeader &rHeader, ULONG nNewIndex)
 553 {
 554     ByteString aName (rHeader.GetName());
 555     const sal_Char *pData = aName.GetBuffer();
 556     const sal_Char *pStop = pData + aName.Len() + 1;
 557     const sal_Char *check = "";
 558
 559     ULONG       nIdx     = LIST_APPEND;
 560     int         eState   = INETMSG_RFC822_BEGIN;
 561     int         eOkState = INETMSG_RFC822_OK;
 562
 563     while (pData < pStop)
 564     {
 565         switch (eState)
 566         {
 567             case INETMSG_RFC822_BEGIN:
 568                 eState = INETMSG_RFC822_CHECK;
 569                 eOkState = INETMSG_RFC822_OK;
 570
 571                 switch (ascii_toLowerCase (*pData))
 572                 {
 573                     case 'b':
 574                         check = "cc";
 575                         nIdx = INETMSG_RFC822_BCC;
 576                         break;
 577
 578                     case 'c':
 579                         eState = INETMSG_RFC822_LETTER_C;
 580                         break;
 581
 582                     case 'd':
 583                         check = "ate";
 584                         nIdx = INETMSG_RFC822_DATE;
 585                         break;
 586
 587                     case 'f':
 588                         check = "rom";
 589                         nIdx = INETMSG_RFC822_FROM;
 590                         break;
 591
 592                     case 'i':
 593                         check = "n-reply-to";
 594                         nIdx = INETMSG_RFC822_IN_REPLY_TO;
 595                         break;
 596
 597                     case 'k':
 598                         check = "eywords";
 599                         nIdx = INETMSG_RFC822_KEYWORDS;
 600                         break;
 601
 602                     case 'm':
 603                         check = "essage-id";
 604                         nIdx = INETMSG_RFC822_MESSAGE_ID;
 605                         break;
 606
 607                     case 'r':
 608                         check = "e";
 609                         eOkState = INETMSG_RFC822_TOKEN_RE;
 610                         break;
 611
 612                     case 's':
 613                         eState = INETMSG_RFC822_LETTER_S;
 614                         break;
 615
 616                     case 't':
 617                         check = "o";
 618                         nIdx = INETMSG_RFC822_TO;
 619                         break;
 620
 621                     case 'x':
 622                         check = "-";
 623                         eOkState = INETMSG_RFC822_TOKEN_XMINUS;
 624                         break;
 625
 626                     default:
 627                         eState = INETMSG_RFC822_JUNK;
 628                         break;
 629                 }
 630                 pData++;
 631                 break;
 632
 633             case INETMSG_RFC822_TOKEN_RE:
 634                 eState = INETMSG_RFC822_CHECK;
 635                 eOkState = INETMSG_RFC822_OK;
 636
 637                 switch (ascii_toLowerCase (*pData))
 638                 {
 639                     case 'f':
 640                         check = "erences";
 641                         nIdx = INETMSG_RFC822_REFERENCES;
 642                         break;
 643
 644                     case 'p':
 645                         check = "ly-to";
 646                         nIdx = INETMSG_RFC822_REPLY_TO;
 647                         break;
 648
 649                     case 't':
 650                         check = "urn-";
 651                         eOkState = INETMSG_RFC822_TOKEN_RETURNMINUS;
 652                         break;
 653
 654                     default:
 655                         eState = INETMSG_RFC822_JUNK;
 656                         break;
 657                 }
 658                 pData++;
 659                 break;
 660
 661             case INETMSG_RFC822_TOKEN_RETURNMINUS:
 662                 eState = INETMSG_RFC822_CHECK;
 663                 eOkState = INETMSG_RFC822_OK;
 664
 665                 switch (ascii_toLowerCase (*pData))
 666                 {
 667                     case 'p':
 668                         check = "ath";
 669                         nIdx = INETMSG_RFC822_RETURN_PATH;
 670                         break;
 671
 672                     case 'r':
 673                         check = "eceipt-to";
 674                         nIdx = INETMSG_RFC822_RETURN_RECEIPT_TO;
 675                         break;
 676
 677                     default:
 678                         eState = INETMSG_RFC822_JUNK;
 679                         break;
 680                 }
 681                 pData++;
 682                 break;
 683
 684             case INETMSG_RFC822_TOKEN_XMINUS:
 685                 eState = INETMSG_RFC822_CHECK;
 686                 eOkState = INETMSG_RFC822_OK;
 687
 688                 switch (ascii_toLowerCase (*pData))
 689                 {
 690                     case 'm':
 691                         check = "ailer";
 692                         nIdx = INETMSG_RFC822_X_MAILER;
 693                         break;
 694
 695 #if 0  /* NYI */
 696                     case 'p':
 697                         check = "riority";
 698                         eOkState = INETMSG_RFC822_X_PRIORITY;
 699                         break;
 700 #endif /* NYI */
 701
 702                     default:
 703                         eState = INETMSG_RFC822_JUNK;
 704                         break;
 705                 }
 706                 pData++;
 707                 break;
 708
 709             case INETMSG_RFC822_LETTER_C:
 710                 eState = INETMSG_RFC822_CHECK;
 711                 eOkState = INETMSG_RFC822_OK;
 712
 713                 switch (ascii_toLowerCase (*pData))
 714                 {
 715                     case 'c':
 716                         check = "";
 717                         nIdx = INETMSG_RFC822_CC;
 718                         break;
 719
 720                     case 'o':
 721                         check = "mments";
 722                         nIdx = INETMSG_RFC822_COMMENTS;
 723                         break;
 724
 725                     default:
 726                         eState = INETMSG_RFC822_JUNK;
 727                         break;
 728                 }
 729                 pData++;
 730                 break;
 731
 732             case INETMSG_RFC822_LETTER_S:
 733                 eState = INETMSG_RFC822_CHECK;
 734                 eOkState = INETMSG_RFC822_OK;
 735
 736                 switch (ascii_toLowerCase (*pData))
 737                 {
 738                     case 'e':
 739                         check = "nder";
 740                         nIdx = INETMSG_RFC822_SENDER;
 741                         break;
 742
 743                     case 'u':
 744                         check = "bject";
 745                         nIdx = INETMSG_RFC822_SUBJECT;
 746                         break;
 747
 748                     default:
 749                         eState = INETMSG_RFC822_JUNK;
 750                         break;
 751                 }
 752                 pData++;
 753                 break;
 754
 755             case INETMSG_RFC822_CHECK:
 756                 if (*check)
 757                 {
 758                     while (*pData && *check &&
 759                            (ascii_toLowerCase (*pData) == *check))
 760                     {
 761                         pData++;
 762                         check++;
 763                     }
 764                 }
 765                 else
 766                 {
 767                     check = pData;
 768                 }
 769                 eState = (*check == '\0') ? eOkState : INETMSG_RFC822_JUNK;
 770                 break;
 771
 772             case INETMSG_RFC822_OK:
 773                 pData = pStop;
 774                 SetHeaderField_Impl (
 775                     HEADERFIELD (HDR(nIdx), rHeader.GetValue()),
 776                     m_nIndex[nIdx]);
 777                 nNewIndex = m_nIndex[nIdx];
 778                 break;
 779
 780             default: // INETMSG_RFC822_JUNK
 781                 pData = pStop;
 782                 nNewIndex = INetMessage::SetHeaderField (rHeader, nNewIndex);
 783                 break;
 784         }
 785     }
 786     return nNewIndex;
 787 }
 788
 789 /*
 790  * Specific Set-Methods.
 791  */
 792 void INetRFC822Message::SetBCC (const UniString& rBCC)
 793 {
 794     SetHeaderField_Impl (
 795         INetMIME::HEADER_FIELD_ADDRESS,
 796         HDR(INETMSG_RFC822_BCC), rBCC,
 797         m_nIndex[INETMSG_RFC822_BCC]);
 798 }
 799
 800 void INetRFC822Message::SetCC (const UniString& rCC)
 801 {
 802     SetHeaderField_Impl (
 803         INetMIME::HEADER_FIELD_ADDRESS,
 804         HDR(INETMSG_RFC822_CC), rCC,
 805         m_nIndex[INETMSG_RFC822_CC]);
 806 }
 807
 808 void INetRFC822Message::SetComments (const UniString& rComments)
 809 {
 810     SetHeaderField_Impl (
 811         INetMIME::HEADER_FIELD_TEXT,
 812         HDR(INETMSG_RFC822_COMMENTS), rComments,
 813         m_nIndex[INETMSG_RFC822_COMMENTS]);
 814 }
 815
 816 void INetRFC822Message::SetDate (const UniString& rDate)
 817 {
 818     SetHeaderField_Impl (
 819         INetMIME::HEADER_FIELD_STRUCTURED,
 820         HDR(INETMSG_RFC822_DATE), rDate,
 821         m_nIndex[INETMSG_RFC822_DATE]);
 822 }
 823
 824 void INetRFC822Message::SetFrom (const UniString& rFrom)
 825 {
 826     SetHeaderField_Impl (
 827         INetMIME::HEADER_FIELD_ADDRESS,
 828         HDR(INETMSG_RFC822_FROM), rFrom,
 829         m_nIndex[INETMSG_RFC822_FROM]);
 830 }
 831
 832 void INetRFC822Message::SetInReplyTo (const UniString& rInReplyTo)
 833 {
 834     SetHeaderField_Impl (
 835         INetMIME::HEADER_FIELD_ADDRESS, // ??? MESSAGE_ID ???
 836         HDR(INETMSG_RFC822_IN_REPLY_TO), rInReplyTo,
 837         m_nIndex[INETMSG_RFC822_IN_REPLY_TO]);
 838 }
 839
 840 void INetRFC822Message::SetKeywords (const UniString& rKeywords)
 841 {
 842     SetHeaderField_Impl (
 843         INetMIME::HEADER_FIELD_PHRASE,
 844         HDR(INETMSG_RFC822_KEYWORDS), rKeywords,
 845         m_nIndex[INETMSG_RFC822_KEYWORDS]);
 846 }
 847
 848 void INetRFC822Message::SetMessageID (const UniString& rMessageID)
 849 {
 850     SetHeaderField_Impl (
 851         INetMIME::HEADER_FIELD_MESSAGE_ID,
 852         HDR(INETMSG_RFC822_MESSAGE_ID), rMessageID,
 853         m_nIndex[INETMSG_RFC822_MESSAGE_ID]);
 854 }
 855
 856 void INetRFC822Message::SetReferences (const UniString& rReferences)
 857 {
 858     SetHeaderField_Impl (
 859         INetMIME::HEADER_FIELD_MESSAGE_ID,
 860         HDR(INETMSG_RFC822_REFERENCES), rReferences,
 861         m_nIndex[INETMSG_RFC822_REFERENCES]);
 862 }
 863
 864 void INetRFC822Message::SetReplyTo (const UniString& rReplyTo)
 865 {
 866     SetHeaderField_Impl (
 867         INetMIME::HEADER_FIELD_ADDRESS,
 868         HDR(INETMSG_RFC822_REPLY_TO), rReplyTo,
 869         m_nIndex[INETMSG_RFC822_REPLY_TO]);
 870 }
 871
 872 void INetRFC822Message::SetReturnPath (const UniString& rReturnPath)
 873 {
 874     SetHeaderField_Impl (
 875         INetMIME::HEADER_FIELD_ADDRESS,
 876         HDR(INETMSG_RFC822_RETURN_PATH), rReturnPath,
 877         m_nIndex[INETMSG_RFC822_RETURN_PATH]);
 878 }
 879
 880 void INetRFC822Message::SetReturnReceiptTo (const UniString& rValue)
 881 {
 882     SetHeaderField_Impl (
 883         INetMIME::HEADER_FIELD_ADDRESS,
 884         HDR(INETMSG_RFC822_RETURN_RECEIPT_TO), rValue,
 885         m_nIndex[INETMSG_RFC822_RETURN_RECEIPT_TO]);
 886 }
 887
 888 void INetRFC822Message::SetSender (const UniString& rSender)
 889 {
 890     SetHeaderField_Impl (
 891         INetMIME::HEADER_FIELD_ADDRESS,
 892         HDR(INETMSG_RFC822_SENDER), rSender,
 893         m_nIndex[INETMSG_RFC822_SENDER]);
 894 }
 895
 896 void INetRFC822Message::SetSubject (const UniString& rSubject)
 897 {
 898     SetHeaderField_Impl (
 899         INetMIME::HEADER_FIELD_TEXT,
 900         HDR(INETMSG_RFC822_SUBJECT), rSubject,
 901         m_nIndex[INETMSG_RFC822_SUBJECT]);
 902 }
 903
 904 void INetRFC822Message::SetTo (const UniString& rTo)
 905 {
 906     SetHeaderField_Impl (
 907         INetMIME::HEADER_FIELD_ADDRESS,
 908         HDR(INETMSG_RFC822_TO), rTo,
 909         m_nIndex[INETMSG_RFC822_TO]);
 910 }
 911
 912 void INetRFC822Message::SetXMailer (const UniString& rXMailer)
 913 {
 914     SetHeaderField_Impl (
 915         INetMIME::HEADER_FIELD_TEXT,
 916         HDR(INETMSG_RFC822_X_MAILER), rXMailer,
 917         m_nIndex[INETMSG_RFC822_X_MAILER]);
 918 }
 919
 920 /*
 921  * operator<<
 922  */
 923 SvStream& INetRFC822Message::operator<< (SvStream& rStrm) const
 924 {
 925     INetMessage::operator<< (rStrm);
 926
 927     for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++)
 928         rStrm << static_cast<sal_uInt32>(m_nIndex[i]);
 929
 930     return rStrm;
 931 }
 932
 933 /*
 934  * operator>>
 935  */
 936 SvStream& INetRFC822Message::operator>> (SvStream& rStrm)
 937 {
 938     INetMessage::operator>> (rStrm);
 939
 940     sal_uInt32 nTemp;
 941     for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++)
 942     {
 943         rStrm >> nTemp;
 944         m_nIndex[i] = nTemp;
 945     }
 946
 947     return rStrm;
 948 }
 949
 950 /*=======================================================================
 951  *
 952  * INetMIMEMessage Implementation.
 953  *
 954  *=====================================================================*/
 955 /*
 956  * _ImplINetMIMEMessageHeaderData.
 957  */
 958 namespace
 959 {
 960     struct ImplINetMIMEMessageHeaderDataImpl
 961     {
 962         const ByteString* operator()()
 963         {
 964             static const ByteString _ImplINetMIMEMessageHeaderData[] =
 965             {
 966                 ByteString ("MIME-Version"),
 967                 ByteString ("Content-Description"),
 968                 ByteString ("Content-Disposition"),
 969                 ByteString ("Content-ID"),
 970                 ByteString ("Content-Type"),
 971                 ByteString ("Content-Transfer-Encoding")
 972             };
 973             return &_ImplINetMIMEMessageHeaderData[0];
 974         }
 975     };
 976
 977     struct ImplINetMIMEMessageHeaderData
 978         : public rtl::StaticAggregate< const ByteString, ImplINetMIMEMessageHeaderDataImpl > {};
 979 }
 980
 981 #define MIMEHDR(n) ImplINetMIMEMessageHeaderData::get()[(n)]
 982
 983 /*
 984  * _ImplINetMIMEMessageHeaderState.
 985  */
 986 enum _ImplINetMIMEMessageHeaderState
 987 {
 988     INETMSG_MIME_BEGIN,
 989     INETMSG_MIME_CHECK,
 990     INETMSG_MIME_OK,
 991     INETMSG_MIME_JUNK,
 992
 993     INETMSG_MIME_TOKEN_CONTENT,
 994     INETMSG_MIME_TOKEN_CONTENT_D,
 995     INETMSG_MIME_TOKEN_CONTENT_T
 996 };
 997
 998 /*
 999  * INetMIMEMessage.
1000  */
1001 INetMIMEMessage::INetMIMEMessage (void)
1002     : INetRFC822Message (),
1003       pParent       (NULL),
1004       nNumChildren  (0),
1005       bHeaderParsed (FALSE)
1006 {
1007     for (USHORT i = 0; i < INETMSG_MIME_NUMHDR; i++)
1008         m_nIndex[i] = LIST_ENTRY_NOTFOUND;
1009 }
1010
1011 INetMIMEMessage::INetMIMEMessage (const INetMIMEMessage& rMsg)
1012     : INetRFC822Message (rMsg)
1013 {
1014     // Copy.
1015     CopyImp (rMsg);
1016 }
1017
1018 /*
1019  * operator=
1020  */
1021 INetMIMEMessage& INetMIMEMessage::operator= (
1022     const INetMIMEMessage& rMsg)
1023 {
1024     if (this != &rMsg)
1025     {
1026         // Assign base.
1027         INetRFC822Message::operator= (rMsg);
1028
1029         // Cleanup.
1030         CleanupImp();
1031
1032         // Copy.
1033         CopyImp (rMsg);
1034     }
1035     return *this;
1036 }
1037
1038 /*
1039  * ~INetMIMEMessage.
1040  */
1041 INetMIMEMessage::~INetMIMEMessage (void)
1042 {
1043     // Cleanup.
1044     CleanupImp();
1045 }
1046
1047 /*
1048  * CleanupImp.
1049  */
1050 void INetMIMEMessage::CleanupImp (void)
1051 {
1052     INetMIMEMessage *pChild = NULL;
1053     while ((pChild = (INetMIMEMessage *)(aChildren.Remove())) != NULL)
1054         if (pChild->pParent == this) delete pChild;
1055 }
1056
1057 /*
1058  * CopyImp.
1059  */
1060 void INetMIMEMessage::CopyImp (const INetMIMEMessage& rMsg)
1061 {
1062     bHeaderParsed = rMsg.bHeaderParsed;
1063
1064     USHORT i;
1065     for (i = 0; i < INETMSG_MIME_NUMHDR; i++)
1066         m_nIndex[i] = rMsg.m_nIndex[i];
1067
1068     m_aBoundary = rMsg.m_aBoundary;
1069     nNumChildren = rMsg.nNumChildren;
1070
1071     for (i = 0; i < rMsg.aChildren.Count(); i++)
1072     {
1073         INetMIMEMessage *pChild =
1074             (INetMIMEMessage *)(rMsg.aChildren.GetObject (i));
1075
1076         if (pChild->pParent == &rMsg)
1077         {
1078             pChild = pChild->CreateMessage (*pChild);
1079             pChild->pParent = this;
1080         }
1081         aChildren.Insert (pChild, LIST_APPEND);
1082     }
1083 }
1084
1085 /*
1086  * CreateMessage.
1087  */
1088 INetMIMEMessage *INetMIMEMessage::CreateMessage (
1089     const INetMIMEMessage& rMsg) const
1090 {
1091     return (new INetMIMEMessage (rMsg));
1092 }
1093
1094 /*
1095  * SetHeaderField.
1096  * (Header Field Parser).
1097  */
1098 ULONG INetMIMEMessage::SetHeaderField (
1099     const INetMessageHeader &rHeader, ULONG nNewIndex)
1100 {
1101     ByteString aName (rHeader.GetName());
1102     const sal_Char *pData = aName.GetBuffer();
1103     const sal_Char *pStop = pData + aName.Len() + 1;
1104     const sal_Char *check = "";
1105
1106     ULONG      nIdx     = LIST_APPEND;
1107     int        eState   = INETMSG_MIME_BEGIN;
1108     int        eOkState = INETMSG_MIME_OK;
1109
1110     while (pData < pStop)
1111     {
1112         switch (eState)
1113         {
1114             case INETMSG_MIME_BEGIN:
1115                 eState = INETMSG_MIME_CHECK;
1116                 eOkState = INETMSG_MIME_OK;
1117
1118                 switch (ascii_toLowerCase (*pData))
1119                 {
1120                     case 'c':
1121                         check = "ontent-";
1122                         eOkState = INETMSG_MIME_TOKEN_CONTENT;
1123                         break;
1124
1125                     case 'm':
1126                         check = "ime-version";
1127                         nIdx = INETMSG_MIME_VERSION;
1128                         break;
1129
1130                     default:
1131                         eState = INETMSG_MIME_JUNK;
1132                         break;
1133                 }
1134                 pData++;
1135                 break;
1136
1137             case INETMSG_MIME_TOKEN_CONTENT:
1138                 eState = INETMSG_MIME_CHECK;
1139                 eOkState = INETMSG_MIME_OK;
1140
1141                 switch (ascii_toLowerCase (*pData))
1142                 {
1143                     case 'd':
1144                         eState = INETMSG_MIME_TOKEN_CONTENT_D;
1145                         break;
1146
1147                     case 'i':
1148                         check = "d";
1149                         nIdx = INETMSG_MIME_CONTENT_ID;
1150                         break;
1151
1152                     case 't':
1153                         eState = INETMSG_MIME_TOKEN_CONTENT_T;
1154                         break;
1155
1156                     default:
1157                         eState = INETMSG_MIME_JUNK;
1158                         break;
1159                 }
1160                 pData++;
1161                 break;
1162
1163             case INETMSG_MIME_TOKEN_CONTENT_D:
1164                 eState = INETMSG_MIME_CHECK;
1165                 eOkState = INETMSG_MIME_OK;
1166
1167                 switch (ascii_toLowerCase (*pData))
1168                 {
1169                     case 'e':
1170                         check = "scription";
1171                         nIdx = INETMSG_MIME_CONTENT_DESCRIPTION;
1172                         break;
1173
1174                     case 'i':
1175                         check = "sposition";
1176                         nIdx = INETMSG_MIME_CONTENT_DISPOSITION;
1177                         break;
1178
1179                     default:
1180                         eState = INETMSG_MIME_JUNK;
1181                         break;
1182                 }
1183                 pData++;
1184                 break;
1185
1186             case INETMSG_MIME_TOKEN_CONTENT_T:
1187                 eState = INETMSG_MIME_CHECK;
1188                 eOkState = INETMSG_MIME_OK;
1189
1190                 switch (ascii_toLowerCase (*pData))
1191                 {
1192                     case 'r':
1193                         check = "ansfer-encoding";
1194                         nIdx = INETMSG_MIME_CONTENT_TRANSFER_ENCODING;
1195                         break;
1196
1197                     case 'y':
1198                         check = "pe";
1199                         nIdx = INETMSG_MIME_CONTENT_TYPE;
1200                         break;
1201
1202                     default:
1203                         eState = INETMSG_MIME_JUNK;
1204                         break;
1205                 }
1206                 pData++;
1207                 break;
1208
1209             case INETMSG_MIME_CHECK:
1210                 if (*check)
1211                 {
1212                     while (*pData && *check &&
1213                            (ascii_toLowerCase (*pData) == *check))
1214                     {
1215                         pData++;
1216                         check++;
1217                     }
1218                 }
1219                 else
1220                 {
1221                     check = pData;
1222                 }
1223                 eState = (*check == '\0') ? eOkState : INETMSG_MIME_JUNK;
1224                 break;
1225
1226             case INETMSG_MIME_OK:
1227                 pData = pStop;
1228                 SetHeaderField_Impl (
1229                     HEADERFIELD (MIMEHDR(nIdx), rHeader.GetValue()),
1230                     m_nIndex[nIdx]);
1231                 nNewIndex = m_nIndex[nIdx];
1232                 break;
1233
1234             default: // INETMSG_MIME_JUNK
1235                 pData = pStop;
1236                 nNewIndex = INetRFC822Message::SetHeaderField (
1237                     rHeader, nNewIndex);
1238                 break;
1239         }
1240     }
1241     return nNewIndex;
1242 }
1243
1244 /*
1245  * Specific Set-Methods.
1246  */
1247 void INetMIMEMessage::SetMIMEVersion (const UniString& rVersion)
1248 {
1249     SetHeaderField_Impl (
1250         INetMIME::HEADER_FIELD_TEXT,
1251         MIMEHDR(INETMSG_MIME_VERSION), rVersion,
1252         m_nIndex[INETMSG_MIME_VERSION]);
1253 }
1254
1255 void INetMIMEMessage::SetContentDescription (const String& rDescription)
1256 {
1257     SetHeaderField_Impl (
1258         INetMIME::HEADER_FIELD_TEXT,
1259         MIMEHDR(INETMSG_MIME_CONTENT_DESCRIPTION), rDescription,
1260         m_nIndex[INETMSG_MIME_CONTENT_DESCRIPTION]);
1261 }
1262
1263 void INetMIMEMessage::SetContentDisposition (const String& rDisposition)
1264 {
1265     SetHeaderField_Impl (
1266         INetMIME::HEADER_FIELD_TEXT,
1267         MIMEHDR(INETMSG_MIME_CONTENT_DISPOSITION), rDisposition,
1268         m_nIndex[INETMSG_MIME_CONTENT_DISPOSITION]);
1269 }
1270
1271 void INetMIMEMessage::SetContentID (const String& rID)
1272 {
1273     SetHeaderField_Impl (
1274         INetMIME::HEADER_FIELD_TEXT,
1275         MIMEHDR(INETMSG_MIME_CONTENT_ID), rID,
1276         m_nIndex[INETMSG_MIME_CONTENT_ID]);
1277 }
1278
1279 void INetMIMEMessage::SetContentType (const String& rType)
1280 {
1281     SetHeaderField_Impl (
1282         INetMIME::HEADER_FIELD_TEXT,
1283         MIMEHDR(INETMSG_MIME_CONTENT_TYPE), rType,
1284         m_nIndex[INETMSG_MIME_CONTENT_TYPE]);
1285 }
1286
1287 void INetMIMEMessage::SetContentTransferEncoding (
1288     const String& rEncoding)
1289 {
1290     SetHeaderField_Impl (
1291         INetMIME::HEADER_FIELD_TEXT,
1292         MIMEHDR(INETMSG_MIME_CONTENT_TRANSFER_ENCODING), rEncoding,
1293         m_nIndex[INETMSG_MIME_CONTENT_TRANSFER_ENCODING]);
1294 }
1295
1296 /*
1297  * GetDefaultContentType.
1298  */
1299 void INetMIMEMessage::GetDefaultContentType (String& rContentType)
1300 {
1301     String aDefaultCT (
1302         "text/plain; charset=us-ascii", RTL_TEXTENCODING_ASCII_US);
1303     if (pParent == NULL)
1304     {
1305         rContentType = aDefaultCT;
1306     }
1307     else
1308     {
1309         String aParentCT (pParent->GetContentType());
1310         if (aParentCT.Len() == 0)
1311             pParent->GetDefaultContentType (aParentCT);
1312
1313         if (aParentCT.CompareIgnoreCaseToAscii ("message/", 8) == 0)
1314         {
1315             rContentType = aDefaultCT;
1316         }
1317         else if (aParentCT.CompareIgnoreCaseToAscii ("multipart/", 10) == 0)
1318         {
1319             if (aParentCT.CompareIgnoreCaseToAscii ("multipart/digest") == 0)
1320                 rContentType.AssignAscii ("message/rfc822");
1321             else
1322                 rContentType = aDefaultCT;
1323         }
1324         else
1325         {
1326             rContentType = aDefaultCT;
1327         }
1328     }
1329 }
1330
1331 /*
1332  * EnableAttachChild.
1333  */
1334 BOOL INetMIMEMessage::EnableAttachChild (INetMessageContainerType eType)
1335 {
1336     // Check context.
1337     if (IsContainer())
1338         return FALSE;
1339
1340     // Setup Content-Type header field.
1341     ByteString aContentType;
1342     switch (eType)
1343     {
1344         case INETMSG_MESSAGE_RFC822:
1345             aContentType = "message/rfc822";
1346             break;
1347
1348         case INETMSG_MULTIPART_ALTERNATIVE:
1349             aContentType = "multipart/alternative";
1350             break;
1351
1352         case INETMSG_MULTIPART_DIGEST:
1353             aContentType = "multipart/digest";
1354             break;
1355
1356         case INETMSG_MULTIPART_PARALLEL:
1357             aContentType = "multipart/parallel";
1358             break;
1359
1360         case INETMSG_MULTIPART_RELATED:
1361             aContentType = "multipart/related";
1362             break;
1363
1364         case INETMSG_MULTIPART_FORM_DATA:
1365             aContentType = "multipart/form-data";
1366             break;
1367
1368         default:
1369             aContentType = "multipart/mixed";
1370             break;
1371     }
1372
1373     // Setup boundary for multipart types.
1374     if (aContentType.CompareIgnoreCaseToAscii ("multipart/", 10) == 0)
1375     {
1376         // Generate a unique boundary from current time.
1377         sal_Char sTail[16 + 1];
1378         Time aCurTime;
1379         sal_uInt64 nThis = reinterpret_cast< sal_uIntPtr >( this ); // we can be on a 64bit architecture
1380         nThis = ( ( nThis >> 32 ) ^ nThis ) & SAL_MAX_UINT32;
1381         sprintf (sTail, "%08X%08X",
1382                  static_cast< unsigned int >(aCurTime.GetTime()),
1383                  static_cast< unsigned int >(nThis));
1384         m_aBoundary = "------------_4D48";
1385         m_aBoundary += sTail;
1386
1387         // Append boundary as ContentType parameter.
1388         aContentType += "; boundary=";
1389         aContentType += m_aBoundary;
1390     }
1391
1392     // Set header fields.
1393     SetMIMEVersion (String (CONSTASCII_STRINGPARAM("1.0")));
1394     SetContentType (String (aContentType, RTL_TEXTENCODING_ASCII_US));
1395     SetContentTransferEncoding (String (CONSTASCII_STRINGPARAM("7bit")));
1396
1397     // Done.
1398     return TRUE;
1399 }
1400
1401 /*
1402  * AttachChild.
1403  */
1404 BOOL INetMIMEMessage::AttachChild (
1405     INetMIMEMessage& rChildMsg, BOOL bOwner)
1406 {
1407     if (IsContainer() /*&& rChildMsg.GetContentType().Len() */)
1408     {
1409         if (bOwner) rChildMsg.pParent = this;
1410         aChildren.Insert (&rChildMsg, LIST_APPEND);
1411         nNumChildren = aChildren.Count();
1412
1413         return TRUE;
1414     }
1415     return FALSE;
1416 }
1417
1418 /*
1419  * DetachChild.
1420  */
1421 BOOL INetMIMEMessage::DetachChild (
1422     ULONG nIndex, INetMIMEMessage& rChildMsg) const
1423 {
1424     if (IsContainer())
1425     {
1426         // Check document stream.
1427         if (GetDocumentLB() == NULL) return FALSE;
1428         SvStream *pDocStrm = new SvStream (GetDocumentLB());
1429
1430         // Initialize message buffer.
1431         char pMsgBuffer[1024];
1432         char *pMsgRead, *pMsgWrite;
1433         pMsgRead = pMsgWrite = pMsgBuffer;
1434
1435         // Initialize message parser stream.
1436         INetMIMEMessageStream *pMsgStrm = NULL;
1437
1438         // Check for "multipart/uvw" or "message/xyz".
1439         if (IsMultipart())
1440         {
1441             // Multipart message body. Initialize multipart delimiters.
1442             ByteString aDelim ("--");
1443             aDelim += GetMultipartBoundary();
1444             ByteString aClose = aDelim;
1445             aClose += "--";
1446
1447             // Initialize line buffer.
1448             SvMemoryStream aLineBuf;
1449
1450             // Initialize control variables.
1451             INetMessageStreamState eState = INETMSG_EOL_SCR;
1452             int nCurIndex = -1;
1453
1454             // Go!
1455             while (nCurIndex < (int)(nIndex + 1))
1456             {
1457                 if ((pMsgRead - pMsgWrite) > 0)
1458                 {
1459                     // Bytes still in buffer.
1460                     if (eState == INETMSG_EOL_FCR)
1461                     {
1462                         // Check for 2nd line break character.
1463                         if ((*pMsgWrite == '\r') || (*pMsgWrite == '\n'))
1464                             aLineBuf << *pMsgWrite++;
1465
1466                         // Check current index.
1467                         if (nCurIndex == (int)nIndex)
1468                         {
1469                             // Found requested part.
1470                             if (pMsgStrm == NULL)
1471                             {
1472                                 // Create message parser stream.
1473                                 pMsgStrm = new INetMIMEMessageStream;
1474                                 pMsgStrm->SetTargetMessage (&rChildMsg);
1475                             }
1476
1477                             // Put message down-stream.
1478                             int status = pMsgStrm->Write (
1479                                 (const sal_Char *) aLineBuf.GetData(), aLineBuf.Tell());
1480                             if (status != INETSTREAM_STATUS_OK)
1481                             {
1482                                 // Cleanup.
1483                                 delete pDocStrm;
1484                                 delete pMsgStrm;
1485
1486                                 // Finish.
1487                                 return (!(status == INETSTREAM_STATUS_OK));
1488                             }
1489                         }
1490
1491                         // Reset to <Begin-of-Line>.
1492                         aLineBuf.Seek (STREAM_SEEK_TO_BEGIN);
1493                         eState = INETMSG_EOL_SCR;
1494                     }
1495                     else if ((*pMsgWrite == '\r') || (*pMsgWrite == '\n'))
1496                     {
1497                         /*
1498                          * Found any line break character.
1499                          * Compare buffered line with part/close delimiter.
1500                          * Increment current part index upon match.
1501                          */
1502                         USHORT nLen = (USHORT)(aLineBuf.Tell() & 0xffff);
1503                         if (nLen == aDelim.Len())
1504                         {
1505                             if (aDelim.CompareTo ((const sal_Char *) aLineBuf.GetData(), nLen)
1506                                 == COMPARE_EQUAL) nCurIndex++;
1507                         }
1508                         else if (nLen == aClose.Len())
1509                         {
1510                             if (aClose.CompareTo ((const sal_Char *) aLineBuf.GetData(), nLen)
1511                                 == COMPARE_EQUAL) nCurIndex++;
1512                         }
1513                         aLineBuf << *pMsgWrite++;
1514                         eState = INETMSG_EOL_FCR;
1515                     }
1516                     else
1517                     {
1518                         // Insert into line buffer.
1519                         aLineBuf << *pMsgWrite;
1520                     }
1521                 }
1522                 else
1523                 {
1524                     // Buffer empty. Reset to <Begin-of-Buffer>.
1525                     pMsgRead = pMsgWrite = pMsgBuffer;
1526
1527                     // Read document stream.
1528                     ULONG nRead = pDocStrm->Read (
1529                         pMsgBuffer, sizeof (pMsgBuffer));
1530                     if (nRead > 0)
1531                     {
1532                         // Set read pointer.
1533                         pMsgRead += nRead;
1534                     }
1535                     else
1536                     {
1537                         // Premature end.
1538                         if (pMsgStrm)
1539                         {
1540                             // Assume end of requested part.
1541                             nCurIndex++;
1542                         }
1543                         else
1544                         {
1545                             // Requested part not found.
1546                             delete pDocStrm;
1547                             return FALSE;
1548                         }
1549                     }
1550                 }
1551             } // while (nCurIndex < (nIndex + 1))
1552         }
1553         else
1554         {
1555             // Encapsulated message body. Create message parser stream.
1556             pMsgStrm = new INetMIMEMessageStream;
1557             pMsgStrm->SetTargetMessage (&rChildMsg);
1558
1559             // Initialize control variables.
1560             INetMessageStreamState eState = INETMSG_EOL_BEGIN;
1561
1562             // Go.
1563             while (eState == INETMSG_EOL_BEGIN)
1564             {
1565                 if ((pMsgRead - pMsgWrite) > 0)
1566                 {
1567                     // Bytes still in buffer. Put message down-stream.
1568                     int status = pMsgStrm->Write (
1569                         pMsgBuffer, (pMsgRead - pMsgWrite));
1570                     if (status != INETSTREAM_STATUS_OK)
1571                     {
1572                         // Cleanup.
1573                         delete pDocStrm;
1574                         delete pMsgStrm;
1575
1576                         // Finish.
1577                         return (!(status == INETSTREAM_STATUS_ERROR));
1578                     }
1579                     pMsgWrite = pMsgBuffer + (pMsgRead - pMsgWrite);
1580                 }
1581                 else
1582                 {
1583                     // Buffer empty. Reset to <Begin-of-Buffer>.
1584                     pMsgRead = pMsgWrite = pMsgBuffer;
1585
1586                     // Read document stream.
1587                     ULONG nRead = pDocStrm->Read (
1588                         pMsgBuffer, sizeof (pMsgBuffer));
1589                     if (nRead > 0)
1590                     {
1591                         // Set read pointer.
1592                         pMsgRead += nRead;
1593                     }
1594                     else
1595                     {
1596                         // Mark we're done.
1597                         eState = INETMSG_EOL_DONE;
1598                     }
1599                 }
1600             } // while (eState == INETMSG_EOL_BEGIN)
1601         }
1602
1603         // Done.
1604         if (pDocStrm) delete pDocStrm;
1605         if (pMsgStrm) delete pMsgStrm;
1606         return TRUE;
1607     }
1608     return FALSE;
1609 }
1610
1611 /*
1612  * operator<<
1613  */
1614 SvStream& INetMIMEMessage::operator<< (SvStream& rStrm) const
1615 {
1616     INetRFC822Message::operator<< (rStrm);
1617
1618     for (USHORT i = 0; i < INETMSG_MIME_NUMHDR; i++)
1619         rStrm << static_cast<sal_uInt32>(m_nIndex[i]);
1620
1621 #ifdef ENABLE_BYTESTRING_STREAM_OPERATORS
1622     rStrm << m_aBoundary;
1623 #else
1624     rStrm.WriteByteString (m_aBoundary);
1625 #endif
1626     rStrm << static_cast<sal_uInt32>(nNumChildren);
1627
1628     return rStrm;
1629 }
1630
1631 /*
1632  * operator>>
1633  */
1634 SvStream& INetMIMEMessage::operator>> (SvStream& rStrm)
1635 {
1636     INetRFC822Message::operator>> (rStrm);
1637
1638     sal_uInt32 nTemp;
1639     for (USHORT i = 0; i < INETMSG_MIME_NUMHDR; i++)
1640     {
1641         rStrm >> nTemp;
1642         m_nIndex[i] = nTemp;
1643     }
1644
1645 #ifdef ENABLE_BYTESTRING_STREAM_OPERATORS
1646     rStrm >> m_aBoundary;
1647 #else
1648     rStrm.ReadByteString (m_aBoundary);
1649 #endif
1650     rStrm >> nTemp;
1651     nNumChildren = nTemp;
1652
1653     return rStrm;
1654 }
1655
1656