| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_tools.hxx" | |
| #include <sal/types.h> | |
| #include <tools/datetime.hxx> | |
| #ifndef _TOOLS_INETMIME_HXX | |
| #include <tools/inetmime.hxx> | |
| #endif | |
| #include <tools/inetmsg.hxx> | |
| #include <tools/inetstrm.hxx> | |
| #include <rtl/instance.hxx> | |
| #include <stdio.h> | |
| //======================================================================= | |
| inline sal_Bool ascii_isDigit( sal_Unicode ch ) | |
| { | |
| return ((ch >= 0x0030) && (ch <= 0x0039)); | |
| } | |
| inline sal_Bool ascii_isLetter( sal_Unicode ch ) | |
| { | |
| return (( (ch >= 0x0041) && (ch <= 0x005A)) || ((ch >= 0x0061) && (ch <= 0x007A))); | |
| } | |
| inline sal_Unicode ascii_toLowerCase( sal_Unicode ch ) | |
| { | |
| if ( (ch >= 0x0041) && (ch <= 0x005A) ) | |
| return ch + 0x20; | |
| else | |
| return ch; | |
| } | |
| /*======================================================================= | |
| * | |
| * INetMessage Implementation. | |
| * | |
| *=====================================================================*/ | |
| #define CONSTASCII_STRINGPARAM(a) (a), RTL_TEXTENCODING_ASCII_US | |
| #define HEADERFIELD INetMessageHeader | |
| /* | |
| * ~INetMessage. | |
| */ | |
| INetMessage::~INetMessage (void) | |
| { | |
| ListCleanup_Impl(); | |
| } | |
| /* | |
| * ListCleanup_Impl. | |
| */ | |
| void INetMessage::ListCleanup_Impl (void) | |
| { | |
| // Cleanup. | |
| sal_uIntPtr i, n = m_aHeaderList.Count(); | |
| for (i = 0; i < n; i++) | |
| delete ((HEADERFIELD*)(m_aHeaderList.GetObject(i))); | |
| m_aHeaderList.Clear(); | |
| } | |
| /* | |
| * ListCopy. | |
| */ | |
| void INetMessage::ListCopy (const INetMessage &rMsg) | |
| { | |
| if (!(this == &rMsg)) | |
| { | |
| // Cleanup. | |
| ListCleanup_Impl(); | |
| // Copy. | |
| sal_uIntPtr i, n = rMsg.GetHeaderCount(); | |
| for (i = 0; i < n; i++) | |
| { | |
| HEADERFIELD *p = (HEADERFIELD*)(rMsg.m_aHeaderList.GetObject(i)); | |
| m_aHeaderList.Insert (new HEADERFIELD(*p), LIST_APPEND); | |
| } | |
| } | |
| } | |
| /* | |
| * SetHeaderField_Impl. | |
| */ | |
| void INetMessage::SetHeaderField_Impl ( | |
| INetMIME::HeaderFieldType eType, | |
| const ByteString &rName, | |
| const UniString &rValue, | |
| sal_uIntPtr &rnIndex) | |
| { | |
| INetMIMEStringOutputSink aSink (0, STRING_MAXLEN); | |
| INetMIME::writeHeaderFieldBody ( | |
| aSink, eType, rValue, gsl_getSystemTextEncoding(), false); | |
| SetHeaderField_Impl ( | |
| INetMessageHeader (rName, aSink.takeBuffer()), rnIndex); | |
| } | |
| /* | |
| * SetHeaderField. | |
| */ | |
| sal_uIntPtr INetMessage::SetHeaderField ( | |
| const UniString& rName, const UniString& rValue, sal_uIntPtr nIndex) | |
| { | |
| sal_uIntPtr nResult = nIndex; | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| ByteString (rName, RTL_TEXTENCODING_ASCII_US), rValue, | |
| nResult); | |
| return nResult; | |
| } | |
| /* | |
| * SetHeaderField. | |
| */ | |
| sal_uIntPtr INetMessage::SetHeaderField ( | |
| const INetMessageHeader &rHeader, sal_uIntPtr nIndex) | |
| { | |
| sal_uIntPtr nResult = nIndex; | |
| SetHeaderField_Impl (rHeader, nResult); | |
| return nResult; | |
| } | |
| /* | |
| * operator<< | |
| */ | |
| SvStream& INetMessage::operator<< (SvStream& rStrm) const | |
| { | |
| rStrm << static_cast<sal_uInt32>(m_nDocSize); | |
| rStrm.WriteByteString (m_aDocName, RTL_TEXTENCODING_UTF8); | |
| sal_uIntPtr i, n = m_aHeaderList.Count(); | |
| rStrm << static_cast<sal_uInt32>(n); | |
| for (i = 0; i < n; i++) | |
| rStrm << *((HEADERFIELD *)(m_aHeaderList.GetObject(i))); | |
| return rStrm; | |
| } | |
| /* | |
| * operator>> | |
| */ | |
| SvStream& INetMessage::operator>> (SvStream& rStrm) | |
| { | |
| // Cleanup. | |
| m_nDocSize = 0; | |
| m_xDocLB.Clear(); | |
| ListCleanup_Impl(); | |
| sal_uInt32 nTemp; | |
| // Copy. | |
| rStrm >> nTemp; | |
| m_nDocSize = nTemp; | |
| rStrm.ReadByteString (m_aDocName, RTL_TEXTENCODING_UTF8); | |
| sal_uIntPtr i, n = 0; | |
| rStrm >> nTemp; | |
| n = nTemp; | |
| for (i = 0; i < n; i++) | |
| { | |
| HEADERFIELD *p = new HEADERFIELD(); | |
| rStrm >> *p; | |
| m_aHeaderList.Insert (p, LIST_APPEND); | |
| } | |
| // Done. | |
| return rStrm; | |
| } | |
| /*======================================================================= | |
| * | |
| * INetMessageHeaderIterator Implementation. | |
| * | |
| *=====================================================================*/ | |
| INetMessageHeaderIterator::INetMessageHeaderIterator ( | |
| const INetMessage& rMsg, const UniString& rHdrName) | |
| { | |
| sal_uIntPtr i, n = rMsg.GetHeaderCount(); | |
| for (i = 0; i < n; i++) | |
| { | |
| if (rHdrName.CompareIgnoreCaseToAscii (rMsg.GetHeaderName(i)) == 0) | |
| { | |
| UniString *pValue = new UniString (rMsg.GetHeaderValue(i)); | |
| aValueList.Insert (pValue, LIST_APPEND); | |
| } | |
| } | |
| nValueCount = aValueList.Count(); | |
| } | |
| INetMessageHeaderIterator::~INetMessageHeaderIterator (void) | |
| { | |
| sal_uIntPtr i, n = aValueList.Count(); | |
| for (i = 0; i < n; i++) | |
| delete ((UniString*)(aValueList.GetObject(i))); | |
| aValueList.Clear(); | |
| } | |
| /*======================================================================= | |
| * | |
| * INetRFC822Message Implementation. | |
| * | |
| *=====================================================================*/ | |
| /* | |
| * ImplINetRFC822MessageHeaderData. | |
| */ | |
| namespace | |
| { | |
| struct ImplINetRFC822MessageHeaderDataImpl | |
| { | |
| const ByteString* operator()() | |
| { | |
| static const ByteString _ImplINetRFC822MessageHeaderData[] = | |
| { | |
| ByteString ("BCC"), | |
| ByteString ("CC"), | |
| ByteString ("Comments"), | |
| ByteString ("Date"), | |
| ByteString ("From"), | |
| ByteString ("In-Reply-To"), | |
| ByteString ("Keywords"), | |
| ByteString ("Message-ID"), | |
| ByteString ("References"), | |
| ByteString ("Reply-To"), | |
| ByteString ("Return-Path"), | |
| ByteString ("Subject"), | |
| ByteString ("Sender"), | |
| ByteString ("To"), | |
| ByteString ("X-Mailer"), | |
| ByteString ("Return-Receipt-To") | |
| }; | |
| return &_ImplINetRFC822MessageHeaderData[0]; | |
| } | |
| }; | |
| struct ImplINetRFC822MessageHeaderData | |
| : public rtl::StaticAggregate< const ByteString, ImplINetRFC822MessageHeaderDataImpl > {}; | |
| } | |
| #define HDR(n) ImplINetRFC822MessageHeaderData::get()[(n)] | |
| /* | |
| * _ImplINetRFC822MessageHeaderState. | |
| */ | |
| enum _ImplINetRFC822MessageHeaderState | |
| { | |
| INETMSG_RFC822_BEGIN, | |
| INETMSG_RFC822_CHECK, | |
| INETMSG_RFC822_OK, | |
| INETMSG_RFC822_JUNK, | |
| INETMSG_RFC822_TOKEN_RE, | |
| INETMSG_RFC822_TOKEN_RETURNMINUS, | |
| INETMSG_RFC822_TOKEN_XMINUS, | |
| INETMSG_RFC822_LETTER_C, | |
| INETMSG_RFC822_LETTER_S | |
| }; | |
| /* | |
| * INetRFC822Message. | |
| */ | |
| INetRFC822Message::INetRFC822Message (void) | |
| : INetMessage() | |
| { | |
| for (sal_uInt16 i = 0; i < INETMSG_RFC822_NUMHDR; i++) | |
| m_nIndex[i] = LIST_ENTRY_NOTFOUND; | |
| } | |
| INetRFC822Message::INetRFC822Message (const INetRFC822Message& rMsg) | |
| : INetMessage (rMsg) | |
| { | |
| for (sal_uInt16 i = 0; i < INETMSG_RFC822_NUMHDR; i++) | |
| m_nIndex[i] = rMsg.m_nIndex[i]; | |
| } | |
| /* | |
| * operator= | |
| */ | |
| INetRFC822Message& INetRFC822Message::operator= (const INetRFC822Message& rMsg) | |
| { | |
| if (this != &rMsg) | |
| { | |
| INetMessage::operator= (rMsg); | |
| for (sal_uInt16 i = 0; i < INETMSG_RFC822_NUMHDR; i++) | |
| m_nIndex[i] = rMsg.m_nIndex[i]; | |
| } | |
| return *this; | |
| } | |
| /* | |
| * ~INetRFC822Message. | |
| */ | |
| INetRFC822Message::~INetRFC822Message (void) | |
| { | |
| } | |
| /* | |
| * <Generate|Parse>DateField and local helper functions. | |
| * | |
| * GenerateDateField. | |
| * Generates a String from Date and Time objects in format: | |
| * Wkd, 00 Mon 0000 00:00:00 [GMT] (rfc822, rfc1123) | |
| * | |
| * ParseDateField. | |
| * Parses a String in (implied) GMT format into class Date and Time objects. | |
| * Four formats are accepted: | |
| * | |
| * [Wkd,] 1*2DIGIT Mon 2*4DIGIT 00:00:00 [GMT] (rfc1123) | |
| * [Wkd,] 00 Mon 0000 00:00:00 [GMT]) (rfc822, rfc1123) | |
| * Weekday, 00-Mon-00 00:00:00 [GMT] (rfc850, rfc1036) | |
| * Wkd Mon 00 00:00:00 0000 [GMT] (ctime) | |
| * 1*DIGIT (delta seconds) | |
| * | |
| */ | |
| // Months and Weekdays. | |
| static const sal_Char *months[12] = | |
| { | |
| "Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
| "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" | |
| }; | |
| static const sal_Char *wkdays[7] = | |
| { | |
| "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" | |
| }; | |
| /* | |
| * GenerateDateField. | |
| */ | |
| sal_Bool INetRFC822Message::GenerateDateField ( | |
| const DateTime& rDateTime, UniString& rDateFieldW) | |
| { | |
| // Check arguments. | |
| if (!rDateTime.IsValid() || | |
| (rDateTime.GetSec() > 59) || | |
| (rDateTime.GetMin() > 59) || | |
| (rDateTime.GetHour() > 23) ) return sal_False; | |
| // Prepare output string. | |
| ByteString rDateField; | |
| // Insert Date. | |
| rDateField += wkdays[(sal_uInt16)(rDateTime.GetDayOfWeek())]; | |
| rDateField += ", "; | |
| sal_uInt16 nNum = rDateTime.GetDay(); | |
| if (nNum < 10) rDateField += '0'; | |
| rDateField += ByteString::CreateFromInt32(nNum); | |
| rDateField += ' '; | |
| rDateField += months[(sal_uInt16)(rDateTime.GetMonth() - 1)]; | |
| rDateField += ' '; | |
| rDateField += ByteString::CreateFromInt32(rDateTime.GetYear()); | |
| rDateField += ' '; | |
| // Insert Time. | |
| nNum = rDateTime.GetHour(); | |
| if (nNum < 10) rDateField += '0'; | |
| rDateField += ByteString::CreateFromInt32(nNum); | |
| rDateField += ':'; | |
| nNum = rDateTime.GetMin(); | |
| if (nNum < 10) rDateField += '0'; | |
| rDateField += ByteString::CreateFromInt32(nNum); | |
| rDateField += ':'; | |
| nNum = rDateTime.GetSec(); | |
| if (nNum < 10) rDateField += '0'; | |
| rDateField += ByteString::CreateFromInt32(nNum); | |
| rDateField += " GMT"; | |
| // Done. | |
| rDateFieldW = UniString (rDateField, RTL_TEXTENCODING_ASCII_US); | |
| return sal_True; | |
| } | |
| /* | |
| * ParseDateField and local helper functions. | |
| */ | |
| static sal_uInt16 ParseNumber (const ByteString& rStr, sal_uInt16& nIndex) | |
| { | |
| sal_uInt16 n = nIndex; | |
| while ((n < rStr.Len()) && ascii_isDigit(rStr.GetChar(n))) n++; | |
| ByteString aNum (rStr.Copy (nIndex, (n - nIndex))); | |
| nIndex = n; | |
| return (sal_uInt16)(aNum.ToInt32()); | |
| } | |
| static sal_uInt16 ParseMonth (const ByteString& rStr, sal_uInt16& nIndex) | |
| { | |
| sal_uInt16 n = nIndex; | |
| while ((n < rStr.Len()) && ascii_isLetter(rStr.GetChar(n))) n++; | |
| ByteString aMonth (rStr.Copy (nIndex, 3)); | |
| nIndex = n; | |
| sal_uInt16 i; | |
| for (i = 0; i < 12; i++) | |
| if (aMonth.CompareIgnoreCaseToAscii (months[i]) == 0) break; | |
| return (i + 1); | |
| } | |
| sal_Bool INetRFC822Message::ParseDateField ( | |
| const UniString& rDateFieldW, DateTime& rDateTime) | |
| { | |
| ByteString rDateField (rDateFieldW, RTL_TEXTENCODING_ASCII_US); | |
| if (rDateField.Len() == 0) return sal_False; | |
| if (rDateField.Search (':') != STRING_NOTFOUND) | |
| { | |
| // Some DateTime format. | |
| sal_uInt16 nIndex = 0; | |
| // Skip over <Wkd> or <Weekday>, leading and trailing space. | |
| while ((nIndex < rDateField.Len()) && | |
| (rDateField.GetChar(nIndex) == ' ')) | |
| nIndex++; | |
| while ( | |
| (nIndex < rDateField.Len()) && | |
| (ascii_isLetter (rDateField.GetChar(nIndex)) || | |
| (rDateField.GetChar(nIndex) == ',') )) | |
| nIndex++; | |
| while ((nIndex < rDateField.Len()) && | |
| (rDateField.GetChar(nIndex) == ' ')) | |
| nIndex++; | |
| if (ascii_isLetter (rDateField.GetChar(nIndex))) | |
| { | |
| // Format: ctime(). | |
| if ((rDateField.Len() - nIndex) < 20) return sal_False; | |
| rDateTime.SetMonth (ParseMonth (rDateField, nIndex)); nIndex++; | |
| rDateTime.SetDay (ParseNumber (rDateField, nIndex)); nIndex++; | |
| rDateTime.SetHour (ParseNumber (rDateField, nIndex)); nIndex++; | |
| rDateTime.SetMin (ParseNumber (rDateField, nIndex)); nIndex++; | |
| rDateTime.SetSec (ParseNumber (rDateField, nIndex)); nIndex++; | |
| rDateTime.Set100Sec (0); | |
| sal_uInt16 nYear = ParseNumber (rDateField, nIndex); | |
| if (nYear < 100) nYear += 1900; | |
| rDateTime.SetYear (nYear); | |
| } | |
| else | |
| { | |
| // Format: RFC1036 or RFC1123. | |
| if ((rDateField.Len() - nIndex) < 17) return sal_False; | |
| rDateTime.SetDay (ParseNumber (rDateField, nIndex)); nIndex++; | |
| rDateTime.SetMonth (ParseMonth (rDateField, nIndex)); nIndex++; | |
| sal_uInt16 nYear = ParseNumber (rDateField, nIndex); nIndex++; | |
| if (nYear < 100) nYear += 1900; | |
| rDateTime.SetYear (nYear); | |
| rDateTime.SetHour (ParseNumber (rDateField, nIndex)); nIndex++; | |
| rDateTime.SetMin (ParseNumber (rDateField, nIndex)); nIndex++; | |
| rDateTime.SetSec (ParseNumber (rDateField, nIndex)); nIndex++; | |
| rDateTime.Set100Sec (0); | |
| if ((rDateField.GetChar(nIndex) == '+') || | |
| (rDateField.GetChar(nIndex) == '-') ) | |
| { | |
| // Offset from GMT: "(+|-)HHMM". | |
| sal_Bool bEast = (rDateField.GetChar(nIndex++) == '+'); | |
| sal_uInt16 nOffset = ParseNumber (rDateField, nIndex); | |
| if (nOffset > 0) | |
| { | |
| Time aDiff; | |
| aDiff.SetHour (nOffset / 100); | |
| aDiff.SetMin (nOffset % 100); | |
| aDiff.SetSec (0); | |
| aDiff.Set100Sec (0); | |
| if (bEast) | |
| rDateTime -= aDiff; | |
| else | |
| rDateTime += aDiff; | |
| } | |
| } | |
| } | |
| } | |
| else if (rDateField.IsNumericAscii()) | |
| { | |
| // Format: delta seconds. | |
| Time aDelta (0); | |
| aDelta.SetTime (rDateField.ToInt32() * 100); | |
| DateTime aNow; | |
| aNow += aDelta; | |
| aNow.ConvertToUTC(); | |
| rDateTime.SetDate (aNow.GetDate()); | |
| rDateTime.SetTime (aNow.GetTime()); | |
| } | |
| else | |
| { | |
| // Junk. | |
| return sal_False; | |
| } | |
| return (rDateTime.IsValid() && | |
| !((rDateTime.GetSec() > 59) || | |
| (rDateTime.GetMin() > 59) || | |
| (rDateTime.GetHour() > 23) )); | |
| } | |
| /* | |
| * SetHeaderField. | |
| * (Header Field Parser). | |
| */ | |
| sal_uIntPtr INetRFC822Message::SetHeaderField ( | |
| const INetMessageHeader &rHeader, sal_uIntPtr nNewIndex) | |
| { | |
| ByteString aName (rHeader.GetName()); | |
| const sal_Char *pData = aName.GetBuffer(); | |
| const sal_Char *pStop = pData + aName.Len() + 1; | |
| const sal_Char *check = ""; | |
| sal_uIntPtr nIdx = LIST_APPEND; | |
| int eState = INETMSG_RFC822_BEGIN; | |
| int eOkState = INETMSG_RFC822_OK; | |
| while (pData < pStop) | |
| { | |
| switch (eState) | |
| { | |
| case INETMSG_RFC822_BEGIN: | |
| eState = INETMSG_RFC822_CHECK; | |
| eOkState = INETMSG_RFC822_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'b': | |
| check = "cc"; | |
| nIdx = INETMSG_RFC822_BCC; | |
| break; | |
| case 'c': | |
| eState = INETMSG_RFC822_LETTER_C; | |
| break; | |
| case 'd': | |
| check = "ate"; | |
| nIdx = INETMSG_RFC822_DATE; | |
| break; | |
| case 'f': | |
| check = "rom"; | |
| nIdx = INETMSG_RFC822_FROM; | |
| break; | |
| case 'i': | |
| check = "n-reply-to"; | |
| nIdx = INETMSG_RFC822_IN_REPLY_TO; | |
| break; | |
| case 'k': | |
| check = "eywords"; | |
| nIdx = INETMSG_RFC822_KEYWORDS; | |
| break; | |
| case 'm': | |
| check = "essage-id"; | |
| nIdx = INETMSG_RFC822_MESSAGE_ID; | |
| break; | |
| case 'r': | |
| check = "e"; | |
| eOkState = INETMSG_RFC822_TOKEN_RE; | |
| break; | |
| case 's': | |
| eState = INETMSG_RFC822_LETTER_S; | |
| break; | |
| case 't': | |
| check = "o"; | |
| nIdx = INETMSG_RFC822_TO; | |
| break; | |
| case 'x': | |
| check = "-"; | |
| eOkState = INETMSG_RFC822_TOKEN_XMINUS; | |
| break; | |
| default: | |
| eState = INETMSG_RFC822_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_RFC822_TOKEN_RE: | |
| eState = INETMSG_RFC822_CHECK; | |
| eOkState = INETMSG_RFC822_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'f': | |
| check = "erences"; | |
| nIdx = INETMSG_RFC822_REFERENCES; | |
| break; | |
| case 'p': | |
| check = "ly-to"; | |
| nIdx = INETMSG_RFC822_REPLY_TO; | |
| break; | |
| case 't': | |
| check = "urn-"; | |
| eOkState = INETMSG_RFC822_TOKEN_RETURNMINUS; | |
| break; | |
| default: | |
| eState = INETMSG_RFC822_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_RFC822_TOKEN_RETURNMINUS: | |
| eState = INETMSG_RFC822_CHECK; | |
| eOkState = INETMSG_RFC822_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'p': | |
| check = "ath"; | |
| nIdx = INETMSG_RFC822_RETURN_PATH; | |
| break; | |
| case 'r': | |
| check = "eceipt-to"; | |
| nIdx = INETMSG_RFC822_RETURN_RECEIPT_TO; | |
| break; | |
| default: | |
| eState = INETMSG_RFC822_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_RFC822_TOKEN_XMINUS: | |
| eState = INETMSG_RFC822_CHECK; | |
| eOkState = INETMSG_RFC822_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'm': | |
| check = "ailer"; | |
| nIdx = INETMSG_RFC822_X_MAILER; | |
| break; | |
| #if 0 /* NYI */ | |
| case 'p': | |
| check = "riority"; | |
| eOkState = INETMSG_RFC822_X_PRIORITY; | |
| break; | |
| #endif /* NYI */ | |
| default: | |
| eState = INETMSG_RFC822_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_RFC822_LETTER_C: | |
| eState = INETMSG_RFC822_CHECK; | |
| eOkState = INETMSG_RFC822_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'c': | |
| check = ""; | |
| nIdx = INETMSG_RFC822_CC; | |
| break; | |
| case 'o': | |
| check = "mments"; | |
| nIdx = INETMSG_RFC822_COMMENTS; | |
| break; | |
| default: | |
| eState = INETMSG_RFC822_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_RFC822_LETTER_S: | |
| eState = INETMSG_RFC822_CHECK; | |
| eOkState = INETMSG_RFC822_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'e': | |
| check = "nder"; | |
| nIdx = INETMSG_RFC822_SENDER; | |
| break; | |
| case 'u': | |
| check = "bject"; | |
| nIdx = INETMSG_RFC822_SUBJECT; | |
| break; | |
| default: | |
| eState = INETMSG_RFC822_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_RFC822_CHECK: | |
| if (*check) | |
| { | |
| while (*pData && *check && | |
| (ascii_toLowerCase (*pData) == *check)) | |
| { | |
| pData++; | |
| check++; | |
| } | |
| } | |
| else | |
| { | |
| check = pData; | |
| } | |
| eState = (*check == '\0') ? eOkState : INETMSG_RFC822_JUNK; | |
| break; | |
| case INETMSG_RFC822_OK: | |
| pData = pStop; | |
| SetHeaderField_Impl ( | |
| HEADERFIELD (HDR(nIdx), rHeader.GetValue()), | |
| m_nIndex[nIdx]); | |
| nNewIndex = m_nIndex[nIdx]; | |
| break; | |
| default: // INETMSG_RFC822_JUNK | |
| pData = pStop; | |
| nNewIndex = INetMessage::SetHeaderField (rHeader, nNewIndex); | |
| break; | |
| } | |
| } | |
| return nNewIndex; | |
| } | |
| /* | |
| * Specific Set-Methods. | |
| */ | |
| void INetRFC822Message::SetBCC (const UniString& rBCC) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, | |
| HDR(INETMSG_RFC822_BCC), rBCC, | |
| m_nIndex[INETMSG_RFC822_BCC]); | |
| } | |
| void INetRFC822Message::SetCC (const UniString& rCC) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, | |
| HDR(INETMSG_RFC822_CC), rCC, | |
| m_nIndex[INETMSG_RFC822_CC]); | |
| } | |
| void INetRFC822Message::SetComments (const UniString& rComments) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| HDR(INETMSG_RFC822_COMMENTS), rComments, | |
| m_nIndex[INETMSG_RFC822_COMMENTS]); | |
| } | |
| void INetRFC822Message::SetDate (const UniString& rDate) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_STRUCTURED, | |
| HDR(INETMSG_RFC822_DATE), rDate, | |
| m_nIndex[INETMSG_RFC822_DATE]); | |
| } | |
| void INetRFC822Message::SetFrom (const UniString& rFrom) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, | |
| HDR(INETMSG_RFC822_FROM), rFrom, | |
| m_nIndex[INETMSG_RFC822_FROM]); | |
| } | |
| void INetRFC822Message::SetInReplyTo (const UniString& rInReplyTo) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, // ??? MESSAGE_ID ??? | |
| HDR(INETMSG_RFC822_IN_REPLY_TO), rInReplyTo, | |
| m_nIndex[INETMSG_RFC822_IN_REPLY_TO]); | |
| } | |
| void INetRFC822Message::SetKeywords (const UniString& rKeywords) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_PHRASE, | |
| HDR(INETMSG_RFC822_KEYWORDS), rKeywords, | |
| m_nIndex[INETMSG_RFC822_KEYWORDS]); | |
| } | |
| void INetRFC822Message::SetMessageID (const UniString& rMessageID) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_MESSAGE_ID, | |
| HDR(INETMSG_RFC822_MESSAGE_ID), rMessageID, | |
| m_nIndex[INETMSG_RFC822_MESSAGE_ID]); | |
| } | |
| void INetRFC822Message::SetReferences (const UniString& rReferences) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_MESSAGE_ID, | |
| HDR(INETMSG_RFC822_REFERENCES), rReferences, | |
| m_nIndex[INETMSG_RFC822_REFERENCES]); | |
| } | |
| void INetRFC822Message::SetReplyTo (const UniString& rReplyTo) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, | |
| HDR(INETMSG_RFC822_REPLY_TO), rReplyTo, | |
| m_nIndex[INETMSG_RFC822_REPLY_TO]); | |
| } | |
| void INetRFC822Message::SetReturnPath (const UniString& rReturnPath) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, | |
| HDR(INETMSG_RFC822_RETURN_PATH), rReturnPath, | |
| m_nIndex[INETMSG_RFC822_RETURN_PATH]); | |
| } | |
| void INetRFC822Message::SetReturnReceiptTo (const UniString& rValue) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, | |
| HDR(INETMSG_RFC822_RETURN_RECEIPT_TO), rValue, | |
| m_nIndex[INETMSG_RFC822_RETURN_RECEIPT_TO]); | |
| } | |
| void INetRFC822Message::SetSender (const UniString& rSender) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, | |
| HDR(INETMSG_RFC822_SENDER), rSender, | |
| m_nIndex[INETMSG_RFC822_SENDER]); | |
| } | |
| void INetRFC822Message::SetSubject (const UniString& rSubject) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| HDR(INETMSG_RFC822_SUBJECT), rSubject, | |
| m_nIndex[INETMSG_RFC822_SUBJECT]); | |
| } | |
| void INetRFC822Message::SetTo (const UniString& rTo) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_ADDRESS, | |
| HDR(INETMSG_RFC822_TO), rTo, | |
| m_nIndex[INETMSG_RFC822_TO]); | |
| } | |
| void INetRFC822Message::SetXMailer (const UniString& rXMailer) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| HDR(INETMSG_RFC822_X_MAILER), rXMailer, | |
| m_nIndex[INETMSG_RFC822_X_MAILER]); | |
| } | |
| /* | |
| * operator<< | |
| */ | |
| SvStream& INetRFC822Message::operator<< (SvStream& rStrm) const | |
| { | |
| INetMessage::operator<< (rStrm); | |
| for (sal_uInt16 i = 0; i < INETMSG_RFC822_NUMHDR; i++) | |
| rStrm << static_cast<sal_uInt32>(m_nIndex[i]); | |
| return rStrm; | |
| } | |
| /* | |
| * operator>> | |
| */ | |
| SvStream& INetRFC822Message::operator>> (SvStream& rStrm) | |
| { | |
| INetMessage::operator>> (rStrm); | |
| sal_uInt32 nTemp; | |
| for (sal_uInt16 i = 0; i < INETMSG_RFC822_NUMHDR; i++) | |
| { | |
| rStrm >> nTemp; | |
| m_nIndex[i] = nTemp; | |
| } | |
| return rStrm; | |
| } | |
| /*======================================================================= | |
| * | |
| * INetMIMEMessage Implementation. | |
| * | |
| *=====================================================================*/ | |
| /* | |
| * _ImplINetMIMEMessageHeaderData. | |
| */ | |
| namespace | |
| { | |
| struct ImplINetMIMEMessageHeaderDataImpl | |
| { | |
| const ByteString* operator()() | |
| { | |
| static const ByteString _ImplINetMIMEMessageHeaderData[] = | |
| { | |
| ByteString ("MIME-Version"), | |
| ByteString ("Content-Description"), | |
| ByteString ("Content-Disposition"), | |
| ByteString ("Content-ID"), | |
| ByteString ("Content-Type"), | |
| ByteString ("Content-Transfer-Encoding") | |
| }; | |
| return &_ImplINetMIMEMessageHeaderData[0]; | |
| } | |
| }; | |
| struct ImplINetMIMEMessageHeaderData | |
| : public rtl::StaticAggregate< const ByteString, ImplINetMIMEMessageHeaderDataImpl > {}; | |
| } | |
| #define MIMEHDR(n) ImplINetMIMEMessageHeaderData::get()[(n)] | |
| /* | |
| * _ImplINetMIMEMessageHeaderState. | |
| */ | |
| enum _ImplINetMIMEMessageHeaderState | |
| { | |
| INETMSG_MIME_BEGIN, | |
| INETMSG_MIME_CHECK, | |
| INETMSG_MIME_OK, | |
| INETMSG_MIME_JUNK, | |
| INETMSG_MIME_TOKEN_CONTENT, | |
| INETMSG_MIME_TOKEN_CONTENT_D, | |
| INETMSG_MIME_TOKEN_CONTENT_T | |
| }; | |
| /* | |
| * INetMIMEMessage. | |
| */ | |
| INetMIMEMessage::INetMIMEMessage (void) | |
| : INetRFC822Message (), | |
| pParent (NULL), | |
| nNumChildren (0), | |
| bHeaderParsed (sal_False) | |
| { | |
| for (sal_uInt16 i = 0; i < INETMSG_MIME_NUMHDR; i++) | |
| m_nIndex[i] = LIST_ENTRY_NOTFOUND; | |
| } | |
| INetMIMEMessage::INetMIMEMessage (const INetMIMEMessage& rMsg) | |
| : INetRFC822Message (rMsg) | |
| { | |
| // Copy. | |
| CopyImp (rMsg); | |
| } | |
| /* | |
| * operator= | |
| */ | |
| INetMIMEMessage& INetMIMEMessage::operator= ( | |
| const INetMIMEMessage& rMsg) | |
| { | |
| if (this != &rMsg) | |
| { | |
| // Assign base. | |
| INetRFC822Message::operator= (rMsg); | |
| // Cleanup. | |
| CleanupImp(); | |
| // Copy. | |
| CopyImp (rMsg); | |
| } | |
| return *this; | |
| } | |
| /* | |
| * ~INetMIMEMessage. | |
| */ | |
| INetMIMEMessage::~INetMIMEMessage (void) | |
| { | |
| // Cleanup. | |
| CleanupImp(); | |
| } | |
| /* | |
| * CleanupImp. | |
| */ | |
| void INetMIMEMessage::CleanupImp (void) | |
| { | |
| INetMIMEMessage *pChild = NULL; | |
| while ((pChild = (INetMIMEMessage *)(aChildren.Remove())) != NULL) | |
| if (pChild->pParent == this) delete pChild; | |
| } | |
| /* | |
| * CopyImp. | |
| */ | |
| void INetMIMEMessage::CopyImp (const INetMIMEMessage& rMsg) | |
| { | |
| bHeaderParsed = rMsg.bHeaderParsed; | |
| sal_uInt16 i; | |
| for (i = 0; i < INETMSG_MIME_NUMHDR; i++) | |
| m_nIndex[i] = rMsg.m_nIndex[i]; | |
| m_aBoundary = rMsg.m_aBoundary; | |
| nNumChildren = rMsg.nNumChildren; | |
| for (i = 0; i < rMsg.aChildren.Count(); i++) | |
| { | |
| INetMIMEMessage *pChild = | |
| (INetMIMEMessage *)(rMsg.aChildren.GetObject (i)); | |
| if (pChild->pParent == &rMsg) | |
| { | |
| pChild = pChild->CreateMessage (*pChild); | |
| pChild->pParent = this; | |
| } | |
| aChildren.Insert (pChild, LIST_APPEND); | |
| } | |
| } | |
| /* | |
| * CreateMessage. | |
| */ | |
| INetMIMEMessage *INetMIMEMessage::CreateMessage ( | |
| const INetMIMEMessage& rMsg) const | |
| { | |
| return (new INetMIMEMessage (rMsg)); | |
| } | |
| /* | |
| * SetHeaderField. | |
| * (Header Field Parser). | |
| */ | |
| sal_uIntPtr INetMIMEMessage::SetHeaderField ( | |
| const INetMessageHeader &rHeader, sal_uIntPtr nNewIndex) | |
| { | |
| ByteString aName (rHeader.GetName()); | |
| const sal_Char *pData = aName.GetBuffer(); | |
| const sal_Char *pStop = pData + aName.Len() + 1; | |
| const sal_Char *check = ""; | |
| sal_uIntPtr nIdx = LIST_APPEND; | |
| int eState = INETMSG_MIME_BEGIN; | |
| int eOkState = INETMSG_MIME_OK; | |
| while (pData < pStop) | |
| { | |
| switch (eState) | |
| { | |
| case INETMSG_MIME_BEGIN: | |
| eState = INETMSG_MIME_CHECK; | |
| eOkState = INETMSG_MIME_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'c': | |
| check = "ontent-"; | |
| eOkState = INETMSG_MIME_TOKEN_CONTENT; | |
| break; | |
| case 'm': | |
| check = "ime-version"; | |
| nIdx = INETMSG_MIME_VERSION; | |
| break; | |
| default: | |
| eState = INETMSG_MIME_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_MIME_TOKEN_CONTENT: | |
| eState = INETMSG_MIME_CHECK; | |
| eOkState = INETMSG_MIME_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'd': | |
| eState = INETMSG_MIME_TOKEN_CONTENT_D; | |
| break; | |
| case 'i': | |
| check = "d"; | |
| nIdx = INETMSG_MIME_CONTENT_ID; | |
| break; | |
| case 't': | |
| eState = INETMSG_MIME_TOKEN_CONTENT_T; | |
| break; | |
| default: | |
| eState = INETMSG_MIME_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_MIME_TOKEN_CONTENT_D: | |
| eState = INETMSG_MIME_CHECK; | |
| eOkState = INETMSG_MIME_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'e': | |
| check = "scription"; | |
| nIdx = INETMSG_MIME_CONTENT_DESCRIPTION; | |
| break; | |
| case 'i': | |
| check = "sposition"; | |
| nIdx = INETMSG_MIME_CONTENT_DISPOSITION; | |
| break; | |
| default: | |
| eState = INETMSG_MIME_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_MIME_TOKEN_CONTENT_T: | |
| eState = INETMSG_MIME_CHECK; | |
| eOkState = INETMSG_MIME_OK; | |
| switch (ascii_toLowerCase (*pData)) | |
| { | |
| case 'r': | |
| check = "ansfer-encoding"; | |
| nIdx = INETMSG_MIME_CONTENT_TRANSFER_ENCODING; | |
| break; | |
| case 'y': | |
| check = "pe"; | |
| nIdx = INETMSG_MIME_CONTENT_TYPE; | |
| break; | |
| default: | |
| eState = INETMSG_MIME_JUNK; | |
| break; | |
| } | |
| pData++; | |
| break; | |
| case INETMSG_MIME_CHECK: | |
| if (*check) | |
| { | |
| while (*pData && *check && | |
| (ascii_toLowerCase (*pData) == *check)) | |
| { | |
| pData++; | |
| check++; | |
| } | |
| } | |
| else | |
| { | |
| check = pData; | |
| } | |
| eState = (*check == '\0') ? eOkState : INETMSG_MIME_JUNK; | |
| break; | |
| case INETMSG_MIME_OK: | |
| pData = pStop; | |
| SetHeaderField_Impl ( | |
| HEADERFIELD (MIMEHDR(nIdx), rHeader.GetValue()), | |
| m_nIndex[nIdx]); | |
| nNewIndex = m_nIndex[nIdx]; | |
| break; | |
| default: // INETMSG_MIME_JUNK | |
| pData = pStop; | |
| nNewIndex = INetRFC822Message::SetHeaderField ( | |
| rHeader, nNewIndex); | |
| break; | |
| } | |
| } | |
| return nNewIndex; | |
| } | |
| /* | |
| * Specific Set-Methods. | |
| */ | |
| void INetMIMEMessage::SetMIMEVersion (const UniString& rVersion) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| MIMEHDR(INETMSG_MIME_VERSION), rVersion, | |
| m_nIndex[INETMSG_MIME_VERSION]); | |
| } | |
| void INetMIMEMessage::SetContentDescription (const String& rDescription) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| MIMEHDR(INETMSG_MIME_CONTENT_DESCRIPTION), rDescription, | |
| m_nIndex[INETMSG_MIME_CONTENT_DESCRIPTION]); | |
| } | |
| void INetMIMEMessage::SetContentDisposition (const String& rDisposition) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| MIMEHDR(INETMSG_MIME_CONTENT_DISPOSITION), rDisposition, | |
| m_nIndex[INETMSG_MIME_CONTENT_DISPOSITION]); | |
| } | |
| void INetMIMEMessage::SetContentID (const String& rID) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| MIMEHDR(INETMSG_MIME_CONTENT_ID), rID, | |
| m_nIndex[INETMSG_MIME_CONTENT_ID]); | |
| } | |
| void INetMIMEMessage::SetContentType (const String& rType) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| MIMEHDR(INETMSG_MIME_CONTENT_TYPE), rType, | |
| m_nIndex[INETMSG_MIME_CONTENT_TYPE]); | |
| } | |
| void INetMIMEMessage::SetContentTransferEncoding ( | |
| const String& rEncoding) | |
| { | |
| SetHeaderField_Impl ( | |
| INetMIME::HEADER_FIELD_TEXT, | |
| MIMEHDR(INETMSG_MIME_CONTENT_TRANSFER_ENCODING), rEncoding, | |
| m_nIndex[INETMSG_MIME_CONTENT_TRANSFER_ENCODING]); | |
| } | |
| /* | |
| * GetDefaultContentType. | |
| */ | |
| void INetMIMEMessage::GetDefaultContentType (String& rContentType) | |
| { | |
| String aDefaultCT ( | |
| "text/plain; charset=us-ascii", RTL_TEXTENCODING_ASCII_US); | |
| if (pParent == NULL) | |
| { | |
| rContentType = aDefaultCT; | |
| } | |
| else | |
| { | |
| String aParentCT (pParent->GetContentType()); | |
| if (aParentCT.Len() == 0) | |
| pParent->GetDefaultContentType (aParentCT); | |
| if (aParentCT.CompareIgnoreCaseToAscii ("message/", 8) == 0) | |
| { | |
| rContentType = aDefaultCT; | |
| } | |
| else if (aParentCT.CompareIgnoreCaseToAscii ("multipart/", 10) == 0) | |
| { | |
| if (aParentCT.CompareIgnoreCaseToAscii ("multipart/digest") == 0) | |
| rContentType.AssignAscii ("message/rfc822"); | |
| else | |
| rContentType = aDefaultCT; | |
| } | |
| else | |
| { | |
| rContentType = aDefaultCT; | |
| } | |
| } | |
| } | |
| /* | |
| * EnableAttachChild. | |
| */ | |
| sal_Bool INetMIMEMessage::EnableAttachChild (INetMessageContainerType eType) | |
| { | |
| // Check context. | |
| if (IsContainer()) | |
| return sal_False; | |
| // Setup Content-Type header field. | |
| ByteString aContentType; | |
| switch (eType) | |
| { | |
| case INETMSG_MESSAGE_RFC822: | |
| aContentType = "message/rfc822"; | |
| break; | |
| case INETMSG_MULTIPART_ALTERNATIVE: | |
| aContentType = "multipart/alternative"; | |
| break; | |
| case INETMSG_MULTIPART_DIGEST: | |
| aContentType = "multipart/digest"; | |
| break; | |
| case INETMSG_MULTIPART_PARALLEL: | |
| aContentType = "multipart/parallel"; | |
| break; | |
| case INETMSG_MULTIPART_RELATED: | |
| aContentType = "multipart/related"; | |
| break; | |
| case INETMSG_MULTIPART_FORM_DATA: | |
| aContentType = "multipart/form-data"; | |
| break; | |
| default: | |
| aContentType = "multipart/mixed"; | |
| break; | |
| } | |
| // Setup boundary for multipart types. | |
| if (aContentType.CompareIgnoreCaseToAscii ("multipart/", 10) == 0) | |
| { | |
| // Generate a unique boundary from current time. | |
| sal_Char sTail[16 + 1]; | |
| Time aCurTime; | |
| sal_uInt64 nThis = reinterpret_cast< sal_uIntPtr >( this ); // we can be on a 64bit architecture | |
| nThis = ( ( nThis >> 32 ) ^ nThis ) & SAL_MAX_UINT32; | |
| sprintf (sTail, "%08X%08X", | |
| static_cast< unsigned int >(aCurTime.GetTime()), | |
| static_cast< unsigned int >(nThis)); | |
| m_aBoundary = "------------_4D48"; | |
| m_aBoundary += sTail; | |
| // Append boundary as ContentType parameter. | |
| aContentType += "; boundary="; | |
| aContentType += m_aBoundary; | |
| } | |
| // Set header fields. | |
| SetMIMEVersion (String (CONSTASCII_STRINGPARAM("1.0"))); | |
| SetContentType (String (aContentType, RTL_TEXTENCODING_ASCII_US)); | |
| SetContentTransferEncoding (String (CONSTASCII_STRINGPARAM("7bit"))); | |
| // Done. | |
| return sal_True; | |
| } | |
| /* | |
| * AttachChild. | |
| */ | |
| sal_Bool INetMIMEMessage::AttachChild ( | |
| INetMIMEMessage& rChildMsg, sal_Bool bOwner) | |
| { | |
| if (IsContainer() /*&& rChildMsg.GetContentType().Len() */) | |
| { | |
| if (bOwner) rChildMsg.pParent = this; | |
| aChildren.Insert (&rChildMsg, LIST_APPEND); | |
| nNumChildren = aChildren.Count(); | |
| return sal_True; | |
| } | |
| return sal_False; | |
| } | |
| /* | |
| * DetachChild. | |
| */ | |
| sal_Bool INetMIMEMessage::DetachChild ( | |
| sal_uIntPtr nIndex, INetMIMEMessage& rChildMsg) const | |
| { | |
| if (IsContainer()) | |
| { | |
| // Check document stream. | |
| if (GetDocumentLB() == NULL) return sal_False; | |
| SvStream *pDocStrm = new SvStream (GetDocumentLB()); | |
| // Initialize message buffer. | |
| char pMsgBuffer[1024]; | |
| char *pMsgRead, *pMsgWrite; | |
| pMsgRead = pMsgWrite = pMsgBuffer; | |
| // Initialize message parser stream. | |
| INetMIMEMessageStream *pMsgStrm = NULL; | |
| // Check for "multipart/uvw" or "message/xyz". | |
| if (IsMultipart()) | |
| { | |
| // Multipart message body. Initialize multipart delimiters. | |
| ByteString aDelim ("--"); | |
| aDelim += GetMultipartBoundary(); | |
| ByteString aClose = aDelim; | |
| aClose += "--"; | |
| // Initialize line buffer. | |
| SvMemoryStream aLineBuf; | |
| // Initialize control variables. | |
| INetMessageStreamState eState = INETMSG_EOL_SCR; | |
| int nCurIndex = -1; | |
| // Go! | |
| while (nCurIndex < (int)(nIndex + 1)) | |
| { | |
| if ((pMsgRead - pMsgWrite) > 0) | |
| { | |
| // Bytes still in buffer. | |
| if (eState == INETMSG_EOL_FCR) | |
| { | |
| // Check for 2nd line break character. | |
| if ((*pMsgWrite == '\r') || (*pMsgWrite == '\n')) | |
| aLineBuf << *pMsgWrite++; | |
| // Check current index. | |
| if (nCurIndex == (int)nIndex) | |
| { | |
| // Found requested part. | |
| if (pMsgStrm == NULL) | |
| { | |
| // Create message parser stream. | |
| pMsgStrm = new INetMIMEMessageStream; | |
| pMsgStrm->SetTargetMessage (&rChildMsg); | |
| } | |
| // Put message down-stream. | |
| int status = pMsgStrm->Write ( | |
| (const sal_Char *) aLineBuf.GetData(), aLineBuf.Tell()); | |
| if (status != INETSTREAM_STATUS_OK) | |
| { | |
| // Cleanup. | |
| delete pDocStrm; | |
| delete pMsgStrm; | |
| // Finish. | |
| return (!(status == INETSTREAM_STATUS_OK)); | |
| } | |
| } | |
| // Reset to <Begin-of-Line>. | |
| aLineBuf.Seek (STREAM_SEEK_TO_BEGIN); | |
| eState = INETMSG_EOL_SCR; | |
| } | |
| else if ((*pMsgWrite == '\r') || (*pMsgWrite == '\n')) | |
| { | |
| /* | |
| * Found any line break character. | |
| * Compare buffered line with part/close delimiter. | |
| * Increment current part index upon match. | |
| */ | |
| sal_uInt16 nLen = (sal_uInt16)(aLineBuf.Tell() & 0xffff); | |
| if (nLen == aDelim.Len()) | |
| { | |
| if (aDelim.CompareTo ((const sal_Char *) aLineBuf.GetData(), nLen) | |
| == COMPARE_EQUAL) nCurIndex++; | |
| } | |
| else if (nLen == aClose.Len()) | |
| { | |
| if (aClose.CompareTo ((const sal_Char *) aLineBuf.GetData(), nLen) | |
| == COMPARE_EQUAL) nCurIndex++; | |
| } | |
| aLineBuf << *pMsgWrite++; | |
| eState = INETMSG_EOL_FCR; | |
| } | |
| else | |
| { | |
| // Insert into line buffer. | |
| aLineBuf << *pMsgWrite; | |
| } | |
| } | |
| else | |
| { | |
| // Buffer empty. Reset to <Begin-of-Buffer>. | |
| pMsgRead = pMsgWrite = pMsgBuffer; | |
| // Read document stream. | |
| sal_uIntPtr nRead = pDocStrm->Read ( | |
| pMsgBuffer, sizeof (pMsgBuffer)); | |
| if (nRead > 0) | |
| { | |
| // Set read pointer. | |
| pMsgRead += nRead; | |
| } | |
| else | |
| { | |
| // Premature end. | |
| if (pMsgStrm) | |
| { | |
| // Assume end of requested part. | |
| nCurIndex++; | |
| } | |
| else | |
| { | |
| // Requested part not found. | |
| delete pDocStrm; | |
| return sal_False; | |
| } | |
| } | |
| } | |
| } // while (nCurIndex < (nIndex + 1)) | |
| } | |
| else | |
| { | |
| // Encapsulated message body. Create message parser stream. | |
| pMsgStrm = new INetMIMEMessageStream; | |
| pMsgStrm->SetTargetMessage (&rChildMsg); | |
| // Initialize control variables. | |
| INetMessageStreamState eState = INETMSG_EOL_BEGIN; | |
| // Go. | |
| while (eState == INETMSG_EOL_BEGIN) | |
| { | |
| if ((pMsgRead - pMsgWrite) > 0) | |
| { | |
| // Bytes still in buffer. Put message down-stream. | |
| int status = pMsgStrm->Write ( | |
| pMsgBuffer, (pMsgRead - pMsgWrite)); | |
| if (status != INETSTREAM_STATUS_OK) | |
| { | |
| // Cleanup. | |
| delete pDocStrm; | |
| delete pMsgStrm; | |
| // Finish. | |
| return (!(status == INETSTREAM_STATUS_ERROR)); | |
| } | |
| pMsgWrite = pMsgBuffer + (pMsgRead - pMsgWrite); | |
| } | |
| else | |
| { | |
| // Buffer empty. Reset to <Begin-of-Buffer>. | |
| pMsgRead = pMsgWrite = pMsgBuffer; | |
| // Read document stream. | |
| sal_uIntPtr nRead = pDocStrm->Read ( | |
| pMsgBuffer, sizeof (pMsgBuffer)); | |
| if (nRead > 0) | |
| { | |
| // Set read pointer. | |
| pMsgRead += nRead; | |
| } | |
| else | |
| { | |
| // Mark we're done. | |
| eState = INETMSG_EOL_DONE; | |
| } | |
| } | |
| } // while (eState == INETMSG_EOL_BEGIN) | |
| } | |
| // Done. | |
| if (pDocStrm) delete pDocStrm; | |
| if (pMsgStrm) delete pMsgStrm; | |
| return sal_True; | |
| } | |
| return sal_False; | |
| } | |
| /* | |
| * operator<< | |
| */ | |
| SvStream& INetMIMEMessage::operator<< (SvStream& rStrm) const | |
| { | |
| INetRFC822Message::operator<< (rStrm); | |
| for (sal_uInt16 i = 0; i < INETMSG_MIME_NUMHDR; i++) | |
| rStrm << static_cast<sal_uInt32>(m_nIndex[i]); | |
| #ifdef ENABLE_BYTESTRING_STREAM_OPERATORS | |
| rStrm << m_aBoundary; | |
| #else | |
| rStrm.WriteByteString (m_aBoundary); | |
| #endif | |
| rStrm << static_cast<sal_uInt32>(nNumChildren); | |
| return rStrm; | |
| } | |
| /* | |
| * operator>> | |
| */ | |
| SvStream& INetMIMEMessage::operator>> (SvStream& rStrm) | |
| { | |
| INetRFC822Message::operator>> (rStrm); | |
| sal_uInt32 nTemp; | |
| for (sal_uInt16 i = 0; i < INETMSG_MIME_NUMHDR; i++) | |
| { | |
| rStrm >> nTemp; | |
| m_nIndex[i] = nTemp; | |
| } | |
| #ifdef ENABLE_BYTESTRING_STREAM_OPERATORS | |
| rStrm >> m_aBoundary; | |
| #else | |
| rStrm.ReadByteString (m_aBoundary); | |
| #endif | |
| rStrm >> nTemp; | |
| nNumChildren = nTemp; | |
| return rStrm; | |
| } |