include/tools/inetmsg.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #ifndef INCLUDED_TOOLS_INETMSG_HXX
  20 #define INCLUDED_TOOLS_INETMSG_HXX
  21
  22 #include <tools/toolsdllapi.h>
  23 #include <rtl/string.hxx>
  24 #include <rtl/textenc.h>
  25 #include <rtl/ustring.hxx>
  26 #include <tools/inetmime.hxx>
  27 #include <tools/stream.hxx>
  28
  29 #include <vector>
  30 #include <map>
  31
  32 class DateTime;
  33
  34 class INetMessageHeader
  35 {
  36     OString m_aName;
  37     OString m_aValue;
  38
  39 public:
  40     INetMessageHeader()
  41     {}
  42
  43     INetMessageHeader (
  44         const OString& rName, const OString& rValue)
  45         : m_aName (rName), m_aValue (rValue)
  46     {}
  47
  48     INetMessageHeader (
  49         const INetMessageHeader& rHdr)
  50         : m_aName (rHdr.m_aName), m_aValue (rHdr.m_aValue)
  51     {}
  52
  53     ~INetMessageHeader()
  54     {}
  55
  56     INetMessageHeader& operator= (const INetMessageHeader& rHdr)
  57     {
  58         m_aName  = rHdr.m_aName;
  59         m_aValue = rHdr.m_aValue;
  60         return *this;
  61     }
  62
  63     const OString& GetName() const { return m_aName; }
  64     const OString& GetValue() const { return m_aValue; }
  65
  66     friend SvStream& WriteINetMessageHeader(
  67         SvStream& rStrm, const INetMessageHeader& rHdr)
  68     {
  69         write_uInt16_lenPrefixed_uInt8s_FromOString(rStrm, rHdr.m_aName);
  70         write_uInt16_lenPrefixed_uInt8s_FromOString(rStrm, rHdr.m_aValue);
  71         return rStrm;
  72     }
  73
  74     friend SvStream& ReadINetMessageHeader (
  75         SvStream& rStrm, INetMessageHeader& rHdr)
  76     {
  77         rHdr.m_aName = read_uInt16_lenPrefixed_uInt8s_ToOString(rStrm);
  78         rHdr.m_aValue = read_uInt16_lenPrefixed_uInt8s_ToOString(rStrm);
  79         return rStrm;
  80     }
  81 };
  82
  83 typedef ::std::vector< INetMessageHeader* > HeaderList_impl;
  84
  85 /**
  86   RFC822 fields
  87 */
  88 enum class InetMessageField
  89 {
  90     BCC                =  0,
  91     CC                 =  1,
  92     COMMENTS           =  2,
  93     DATE               =  3,
  94     FROM               =  4,
  95     IN_REPLY_TO        =  5,
  96     KEYWORDS           =  6,
  97     MESSAGE_ID         =  7,
  98     REFERENCES         =  8,
  99     REPLY_TO           =  9,
 100     RETURN_PATH        = 10,
 101     SENDER             = 11,
 102     SUBJECT            = 12,
 103     TO                 = 13,
 104     X_MAILER           = 14,
 105     RETURN_RECEIPT_TO  = 15,
 106     NUMHDR             = 16,
 107 };
 108
 109 enum class InetMessageMime
 110 {
 111     VERSION                    = 0,
 112     CONTENT_DESCRIPTION        = 1,
 113     CONTENT_DISPOSITION        = 2,
 114     CONTENT_ID                 = 3,
 115     CONTENT_TYPE               = 4,
 116     CONTENT_TRANSFER_ENCODING  = 5,
 117     NUMHDR                     = 6,
 118 };
 119
 120 enum INetMessageContainerType
 121 {
 122     INETMSG_MESSAGE_RFC822,
 123     INETMSG_MULTIPART_MIXED,
 124     INETMSG_MULTIPART_ALTERNATIVE,
 125     INETMSG_MULTIPART_DIGEST,
 126     INETMSG_MULTIPART_PARALLEL,
 127     INETMSG_MULTIPART_RELATED,
 128     INETMSG_MULTIPART_FORM_DATA
 129 };
 130
 131 class INetMIMEMessage;
 132 typedef ::std::vector< INetMIMEMessage* > INetMIMEMessgeList_impl;
 133
 134 class TOOLS_DLLPUBLIC INetMIMEMessage
 135 {
 136     HeaderList_impl m_aHeaderList;
 137
 138     sal_uIntPtr     m_nDocSize;
 139     OUString        m_aDocName;
 140     SvLockBytesRef  m_xDocLB;
 141
 142     void ListCleanup_Impl();
 143     void ListCopy (const INetMIMEMessage& rMsg);
 144
 145     ::std::map<InetMessageField, sal_uIntPtr> m_nRFC822Index;
 146
 147     ::std::map<InetMessageMime, sal_uIntPtr>  m_nMIMEIndex;
 148     INetMIMEMessage*        pParent;
 149     INetMIMEMessgeList_impl aChildren;
 150     OString                 m_aBoundary;
 151     bool                    bHeaderParsed;
 152
 153     friend class INetMIMEMessageStream;
 154
 155     const OString& GetMultipartBoundary() const { return m_aBoundary; }
 156     void SetMultipartBoundary (const OString& rBnd) { m_aBoundary = rBnd; }
 157
 158     void CleanupImp();
 159     void CopyImp    (const INetMIMEMessage& rMsg);
 160     void SetHeaderParsed() { bHeaderParsed = true; }
 161
 162     OUString GetHeaderName_Impl (
 163         sal_uIntPtr nIndex, rtl_TextEncoding eEncoding) const
 164     {
 165         if ( nIndex < m_aHeaderList.size() ) {
 166             return OStringToOUString(m_aHeaderList[ nIndex ]->GetName(), eEncoding);
 167         } else {
 168             return OUString();
 169         }
 170     }
 171
 172     OUString GetHeaderValue_Impl (
 173         sal_uIntPtr nIndex, INetMIME::HeaderFieldType eType) const
 174     {
 175         if ( nIndex < m_aHeaderList.size() ) {
 176             return INetMIME::decodeHeaderFieldBody(eType, m_aHeaderList[ nIndex ]->GetValue());
 177         } else {
 178             return OUString();
 179         }
 180     }
 181
 182     void SetHeaderField_Impl (
 183         const INetMessageHeader &rHeader, sal_uIntPtr &rnIndex)
 184     {
 185         INetMessageHeader *p = new INetMessageHeader (rHeader);
 186         if (m_aHeaderList.size() <= rnIndex)
 187         {
 188             rnIndex = m_aHeaderList.size();
 189             m_aHeaderList.push_back( p );
 190         }
 191         else
 192         {
 193             delete m_aHeaderList[ rnIndex ];
 194             m_aHeaderList[ rnIndex ] = p;
 195         }
 196     }
 197
 198     void SetHeaderField_Impl (
 199         INetMIME::HeaderFieldType  eType,
 200         const OString &rName,
 201         const OUString &rValue,
 202         sal_uIntPtr &rnIndex);
 203
 204     sal_uIntPtr SetRFC822HeaderField (
 205         const INetMessageHeader &rHeader, sal_uIntPtr nNewIndex);
 206
 207 public:
 208     INetMIMEMessage();
 209     INetMIMEMessage (const INetMIMEMessage& rMsg);
 210     ~INetMIMEMessage();
 211
 212     INetMIMEMessage& operator= (const INetMIMEMessage& rMsg);
 213
 214     sal_uIntPtr GetHeaderCount() const { return m_aHeaderList.size(); }
 215
 216     OUString GetHeaderName (sal_uIntPtr nIndex) const
 217     {
 218         return GetHeaderName_Impl (nIndex, RTL_TEXTENCODING_ASCII_US);
 219     }
 220
 221     OUString GetHeaderValue (sal_uIntPtr nIndex) const
 222     {
 223         return GetHeaderValue_Impl (nIndex, INetMIME::HEADER_FIELD_TEXT);
 224     }
 225
 226     INetMessageHeader GetHeaderField (sal_uIntPtr nIndex) const
 227     {
 228         if ( nIndex < m_aHeaderList.size() ) {
 229             return INetMessageHeader( *m_aHeaderList[ nIndex ] );
 230         } else {
 231             return INetMessageHeader();
 232         }
 233     }
 234
 235     sal_uIntPtr SetHeaderField (
 236         const INetMessageHeader &rField,
 237         sal_uIntPtr nIndex = ((sal_uIntPtr)-1)
 238     );
 239
 240     sal_uIntPtr GetDocumentSize() const { return m_nDocSize; }
 241     void  SetDocumentSize (sal_uIntPtr nSize) { m_nDocSize = nSize; }
 242
 243     const OUString& GetDocumentName() const { return m_aDocName; }
 244     void  SetDocumentName (const OUString& rName) { m_aDocName = rName; }
 245
 246     SvLockBytes* GetDocumentLB() const { return m_xDocLB; }
 247     void         SetDocumentLB (SvLockBytes *pDocLB) { m_xDocLB = pDocLB; }
 248
 249     static bool ParseDateField (
 250         const OUString& rDateField, DateTime& rDateTime);
 251
 252     bool HeaderParsed() const { return bHeaderParsed; }
 253
 254     static INetMIMEMessage* CreateMessage (
 255         const INetMIMEMessage& rMsg);
 256
 257     // Header fields.
 258
 259     OUString GetBCC() const
 260     {
 261         return GetHeaderValue_Impl (
 262             m_nRFC822Index.at(InetMessageField::BCC),
 263             INetMIME::HEADER_FIELD_ADDRESS);
 264     }
 265
 266     OUString GetCC() const
 267     {
 268         return GetHeaderValue_Impl (
 269             m_nRFC822Index.at(InetMessageField::CC),
 270             INetMIME::HEADER_FIELD_ADDRESS);
 271     }
 272
 273     OUString GetComments() const
 274     {
 275         return GetHeaderValue_Impl (
 276             m_nRFC822Index.at(InetMessageField::COMMENTS),
 277             INetMIME::HEADER_FIELD_TEXT);
 278     }
 279
 280     OUString GetDate() const
 281     {
 282         return GetHeaderValue_Impl (
 283             m_nRFC822Index.at(InetMessageField::DATE),
 284             INetMIME::HEADER_FIELD_STRUCTURED);
 285     }
 286
 287     OUString GetFrom() const
 288     {
 289         return GetHeaderValue_Impl (
 290             m_nRFC822Index.at(InetMessageField::FROM),
 291             INetMIME::HEADER_FIELD_ADDRESS);
 292     }
 293
 294     OUString GetInReplyTo() const
 295     {
 296         return GetHeaderValue_Impl (
 297             m_nRFC822Index.at(InetMessageField::REPLY_TO),
 298             INetMIME::HEADER_FIELD_ADDRESS); // ??? MESSAGE_ID ???
 299     }
 300
 301     OUString GetKeywords() const
 302     {
 303         return GetHeaderValue_Impl (
 304             m_nRFC822Index.at(InetMessageField::KEYWORDS),
 305             INetMIME::HEADER_FIELD_PHRASE);
 306     }
 307
 308     OUString GetMessageID() const
 309     {
 310         return GetHeaderValue_Impl (
 311             m_nRFC822Index.at(InetMessageField::MESSAGE_ID),
 312             INetMIME::HEADER_FIELD_MESSAGE_ID);
 313     }
 314
 315     OUString GetReferences() const
 316     {
 317         return GetHeaderValue_Impl (
 318             m_nRFC822Index.at(InetMessageField::REFERENCES),
 319             INetMIME::HEADER_FIELD_ADDRESS);
 320     }
 321
 322     OUString GetReplyTo() const
 323     {
 324         return GetHeaderValue_Impl (
 325             m_nRFC822Index.at(InetMessageField::REPLY_TO),
 326             INetMIME::HEADER_FIELD_ADDRESS);
 327     }
 328
 329     OUString GetReturnPath() const
 330     {
 331         return GetHeaderValue_Impl (
 332             m_nRFC822Index.at(InetMessageField::RETURN_PATH),
 333             INetMIME::HEADER_FIELD_ADDRESS);
 334     }
 335
 336     OUString GetReturnReceiptTo() const
 337     {
 338         return GetHeaderValue_Impl (
 339             m_nRFC822Index.at(InetMessageField::RETURN_RECEIPT_TO),
 340             INetMIME::HEADER_FIELD_ADDRESS);
 341     }
 342
 343     OUString GetSender() const
 344     {
 345         return GetHeaderValue_Impl (
 346             m_nRFC822Index.at(InetMessageField::SENDER),
 347             INetMIME::HEADER_FIELD_ADDRESS);
 348     }
 349
 350     OUString GetSubject() const
 351     {
 352         return GetHeaderValue_Impl (
 353             m_nRFC822Index.at(InetMessageField::SUBJECT),
 354             INetMIME::HEADER_FIELD_TEXT);
 355     }
 356
 357     OUString GetTo() const
 358     {
 359         return GetHeaderValue_Impl (
 360             m_nRFC822Index.at(InetMessageField::TO),
 361             INetMIME::HEADER_FIELD_TEXT);
 362     }
 363
 364     void     SetMIMEVersion (const OUString& rVersion);
 365     OUString GetMIMEVersion() const
 366     {
 367         return GetHeaderValue (m_nMIMEIndex.at(InetMessageMime::VERSION));
 368     }
 369
 370     OUString GetContentDescription() const
 371     {
 372         return GetHeaderValue (m_nMIMEIndex.at(InetMessageMime::CONTENT_DESCRIPTION));
 373     }
 374
 375     void     SetContentDisposition (const OUString& rDisposition);
 376     OUString GetContentDisposition() const
 377     {
 378         return GetHeaderValue (m_nMIMEIndex.at(InetMessageMime::CONTENT_DISPOSITION));
 379     }
 380
 381     OUString GetContentID() const
 382     {
 383         return GetHeaderValue (m_nMIMEIndex.at(InetMessageMime::CONTENT_ID));
 384     }
 385
 386     void     SetContentType (const OUString& rType);
 387     OUString GetContentType() const
 388     {
 389         return GetHeaderValue (m_nMIMEIndex.at(InetMessageMime::CONTENT_TYPE));
 390     }
 391
 392     void     SetContentTransferEncoding (const OUString& rEncoding);
 393     OUString GetContentTransferEncoding() const
 394     {
 395         return GetHeaderValue (m_nMIMEIndex.at(InetMessageMime::CONTENT_TRANSFER_ENCODING));
 396     }
 397
 398     OUString GetDefaultContentType ();
 399
 400     // Message container methods.
 401
 402     bool IsContainer() const
 403     {
 404         return (IsMessage() || IsMultipart());
 405     }
 406     bool IsMessage() const
 407     {
 408         OUString aType (GetContentType());
 409         return aType.matchIgnoreAsciiCase("message/");
 410     }
 411     bool IsMultipart() const
 412     {
 413         OUString aType (GetContentType());
 414         return aType.matchIgnoreAsciiCase("multipart/");
 415     }
 416
 417     INetMIMEMessage* GetChild (sal_uIntPtr nIndex) const
 418     {
 419         return ( nIndex < aChildren.size() ) ? aChildren[ nIndex ] : NULL;
 420     }
 421     INetMIMEMessage* GetParent() const { return pParent; }
 422
 423     bool EnableAttachChild (
 424         INetMessageContainerType eType = INETMSG_MULTIPART_MIXED);
 425     bool AttachChild (
 426         INetMIMEMessage& rChildMsg, bool bOwner = true );
 427 };
 428
 429 #endif
 430
 431 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */