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 _TOOLS_INETMSG_HXX
  20 #define _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
  31 class DateTime;
  32
  33 class INetMessageHeader
  34 {
  35     OString m_aName;
  36     OString m_aValue;
  37
  38 public:
  39     INetMessageHeader()
  40     {}
  41
  42     INetMessageHeader (
  43         const OString& rName, const OString& rValue)
  44         : m_aName (rName), m_aValue (rValue)
  45     {}
  46
  47     INetMessageHeader (
  48         const INetMessageHeader& rHdr)
  49         : m_aName (rHdr.m_aName), m_aValue (rHdr.m_aValue)
  50     {}
  51
  52     ~INetMessageHeader()
  53     {}
  54
  55     INetMessageHeader& operator= (const INetMessageHeader& rHdr)
  56     {
  57         m_aName  = rHdr.m_aName;
  58         m_aValue = rHdr.m_aValue;
  59         return *this;
  60     }
  61
  62     const OString& GetName() const { return m_aName; }
  63     const OString& GetValue() const { return m_aValue; }
  64
  65     friend SvStream& operator<< (
  66         SvStream& rStrm, const INetMessageHeader& rHdr)
  67     {
  68         write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(rStrm, rHdr.m_aName);
  69         write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(rStrm, rHdr.m_aValue);
  70         return rStrm;
  71     }
  72
  73     friend SvStream& operator>> (
  74         SvStream& rStrm, INetMessageHeader& rHdr)
  75     {
  76         rHdr.m_aName = read_lenPrefixed_uInt8s_ToOString<sal_uInt16>(rStrm);
  77         rHdr.m_aValue = read_lenPrefixed_uInt8s_ToOString<sal_uInt16>(rStrm);
  78         return rStrm;
  79     }
  80 };
  81
  82 typedef ::std::vector< INetMessageHeader* > HeaderList_impl;
  83
  84 class INetMessage
  85 {
  86     HeaderList_impl m_aHeaderList;
  87
  88     sal_uIntPtr     m_nDocSize;
  89     OUString        m_aDocName;
  90     SvLockBytesRef  m_xDocLB;
  91
  92     void ListCleanup_Impl();
  93     void ListCopy (const INetMessage& rMsg);
  94
  95 protected:
  96     OUString GetHeaderName_Impl (
  97         sal_uIntPtr nIndex, rtl_TextEncoding eEncoding) const
  98     {
  99         if ( nIndex < m_aHeaderList.size() ) {
 100             return OStringToOUString(m_aHeaderList[ nIndex ]->GetName(), eEncoding);
 101         } else {
 102             return OUString();
 103         }
 104     }
 105
 106     OUString GetHeaderValue_Impl (
 107         sal_uIntPtr nIndex, INetMIME::HeaderFieldType eType) const
 108     {
 109         if ( nIndex < m_aHeaderList.size() ) {
 110             return INetMIME::decodeHeaderFieldBody(eType, m_aHeaderList[ nIndex ]->GetValue());
 111         } else {
 112             return OUString();
 113         }
 114     }
 115
 116     void SetHeaderField_Impl (
 117         const INetMessageHeader &rHeader, sal_uIntPtr &rnIndex)
 118     {
 119         INetMessageHeader *p = new INetMessageHeader (rHeader);
 120         if (m_aHeaderList.size() <= rnIndex)
 121         {
 122             rnIndex = m_aHeaderList.size();
 123             m_aHeaderList.push_back( p );
 124         }
 125         else
 126         {
 127             delete m_aHeaderList[ rnIndex ];
 128             m_aHeaderList[ rnIndex ] = p;
 129         }
 130     }
 131
 132     void SetHeaderField_Impl (
 133         INetMIME::HeaderFieldType  eType,
 134         const OString &rName,
 135         const OUString &rValue,
 136         sal_uIntPtr &rnIndex);
 137
 138     virtual SvStream& operator<< (SvStream& rStrm) const;
 139     virtual SvStream& operator>> (SvStream& rStrm);
 140
 141 public:
 142     INetMessage() : m_nDocSize(0) {}
 143     virtual ~INetMessage();
 144
 145     INetMessage (const INetMessage& rMsg)
 146         : m_nDocSize (rMsg.m_nDocSize),
 147           m_aDocName (rMsg.m_aDocName),
 148           m_xDocLB   (rMsg.m_xDocLB)
 149     {
 150         ListCopy (rMsg);
 151     }
 152
 153     INetMessage& operator= (const INetMessage& rMsg)
 154     {
 155         m_nDocSize = rMsg.m_nDocSize;
 156         m_aDocName = rMsg.m_aDocName;
 157         m_xDocLB   = rMsg.m_xDocLB;
 158         ListCopy (rMsg);
 159         return *this;
 160     }
 161
 162     sal_uIntPtr GetHeaderCount() const { return m_aHeaderList.size(); }
 163
 164     OUString GetHeaderName (sal_uIntPtr nIndex) const
 165     {
 166         return GetHeaderName_Impl (nIndex, RTL_TEXTENCODING_ASCII_US);
 167     }
 168
 169     OUString GetHeaderValue (sal_uIntPtr nIndex) const
 170     {
 171         return GetHeaderValue_Impl (nIndex, INetMIME::HEADER_FIELD_TEXT);
 172     }
 173
 174     INetMessageHeader GetHeaderField (sal_uIntPtr nIndex) const
 175     {
 176         if ( nIndex < m_aHeaderList.size() ) {
 177             return INetMessageHeader( *m_aHeaderList[ nIndex ] );
 178         } else {
 179             return INetMessageHeader();
 180         }
 181     }
 182
 183     virtual sal_uIntPtr SetHeaderField (
 184         const INetMessageHeader &rField,
 185         sal_uIntPtr nIndex = ((sal_uIntPtr)-1)
 186     );
 187
 188     sal_uIntPtr GetDocumentSize() const { return m_nDocSize; }
 189     void  SetDocumentSize (sal_uIntPtr nSize) { m_nDocSize = nSize; }
 190
 191     const OUString& GetDocumentName() const { return m_aDocName; }
 192     void  SetDocumentName (const OUString& rName) { m_aDocName = rName; }
 193
 194     SvLockBytes* GetDocumentLB() const { return m_xDocLB; }
 195     void         SetDocumentLB (SvLockBytes *pDocLB) { m_xDocLB = pDocLB; }
 196
 197     friend SvStream& operator<< (
 198         SvStream& rStrm, const INetMessage& rMsg)
 199     {
 200         return rMsg.operator<< (rStrm);
 201     }
 202
 203     friend SvStream& operator>> (
 204         SvStream& rStrm, INetMessage& rMsg)
 205     {
 206         return rMsg.operator>> (rStrm);
 207     }
 208 };
 209
 210 #define INETMSG_RFC822_BCC                 0
 211 #define INETMSG_RFC822_CC                  1
 212 #define INETMSG_RFC822_COMMENTS            2
 213 #define INETMSG_RFC822_DATE                3
 214 #define INETMSG_RFC822_FROM                4
 215 #define INETMSG_RFC822_IN_REPLY_TO         5
 216 #define INETMSG_RFC822_KEYWORDS            6
 217 #define INETMSG_RFC822_MESSAGE_ID          7
 218 #define INETMSG_RFC822_REFERENCES          8
 219 #define INETMSG_RFC822_REPLY_TO            9
 220 #define INETMSG_RFC822_RETURN_PATH        10
 221 #define INETMSG_RFC822_SENDER             11
 222 #define INETMSG_RFC822_SUBJECT            12
 223 #define INETMSG_RFC822_TO                 13
 224 #define INETMSG_RFC822_X_MAILER           14
 225 #define INETMSG_RFC822_RETURN_RECEIPT_TO  15
 226 #define INETMSG_RFC822_NUMHDR             16
 227
 228 class TOOLS_DLLPUBLIC INetRFC822Message : public INetMessage
 229 {
 230     sal_uIntPtr m_nIndex[INETMSG_RFC822_NUMHDR];
 231
 232 protected:
 233     virtual SvStream& operator<< (SvStream& rStrm) const;
 234     virtual SvStream& operator>> (SvStream& rStrm);
 235
 236 public:
 237     INetRFC822Message();
 238     INetRFC822Message (const INetRFC822Message& rMsg);
 239     virtual ~INetRFC822Message();
 240
 241     INetRFC822Message& operator= (const INetRFC822Message& rMsg);
 242
 243     static bool ParseDateField (
 244         const OUString& rDateField, DateTime& rDateTime);
 245
 246     using INetMessage::SetHeaderField;
 247     virtual sal_uIntPtr SetHeaderField (
 248         const INetMessageHeader &rHeader,
 249         sal_uIntPtr nIndex = ((sal_uIntPtr)-1)
 250     );
 251
 252     // Header fields.
 253
 254     OUString GetBCC() const
 255     {
 256         return GetHeaderValue_Impl (
 257             m_nIndex[INETMSG_RFC822_BCC],
 258             INetMIME::HEADER_FIELD_ADDRESS);
 259     }
 260
 261     OUString GetCC() const
 262     {
 263         return GetHeaderValue_Impl (
 264             m_nIndex[INETMSG_RFC822_CC],
 265             INetMIME::HEADER_FIELD_ADDRESS);
 266     }
 267
 268     OUString GetComments() const
 269     {
 270         return GetHeaderValue_Impl (
 271             m_nIndex[INETMSG_RFC822_COMMENTS],
 272             INetMIME::HEADER_FIELD_TEXT);
 273     }
 274
 275     OUString GetDate() const
 276     {
 277         return GetHeaderValue_Impl (
 278             m_nIndex[INETMSG_RFC822_DATE],
 279             INetMIME::HEADER_FIELD_STRUCTURED);
 280     }
 281
 282     OUString GetFrom() const
 283     {
 284         return GetHeaderValue_Impl (
 285             m_nIndex[INETMSG_RFC822_FROM],
 286             INetMIME::HEADER_FIELD_ADDRESS);
 287     }
 288
 289     OUString GetInReplyTo() const
 290     {
 291         return GetHeaderValue_Impl (
 292             m_nIndex[INETMSG_RFC822_IN_REPLY_TO],
 293             INetMIME::HEADER_FIELD_ADDRESS); // ??? MESSAGE_ID ???
 294     }
 295
 296     OUString GetKeywords() const
 297     {
 298         return GetHeaderValue_Impl (
 299             m_nIndex[INETMSG_RFC822_KEYWORDS],
 300             INetMIME::HEADER_FIELD_PHRASE);
 301     }
 302
 303     OUString GetMessageID() const
 304     {
 305         return GetHeaderValue_Impl (
 306             m_nIndex[INETMSG_RFC822_MESSAGE_ID],
 307             INetMIME::HEADER_FIELD_MESSAGE_ID);
 308     }
 309
 310     OUString GetReferences() const
 311     {
 312         return GetHeaderValue_Impl (
 313             m_nIndex[INETMSG_RFC822_REFERENCES],
 314             INetMIME::HEADER_FIELD_ADDRESS);
 315     }
 316
 317     OUString GetReplyTo() const
 318     {
 319         return GetHeaderValue_Impl (
 320             m_nIndex[INETMSG_RFC822_REPLY_TO],
 321             INetMIME::HEADER_FIELD_ADDRESS);
 322     }
 323
 324     OUString GetReturnPath() const
 325     {
 326         return GetHeaderValue_Impl (
 327             m_nIndex[INETMSG_RFC822_RETURN_PATH],
 328             INetMIME::HEADER_FIELD_ADDRESS);
 329     }
 330
 331     OUString GetReturnReceiptTo() const
 332     {
 333         return GetHeaderValue_Impl (
 334             m_nIndex[INETMSG_RFC822_RETURN_RECEIPT_TO],
 335             INetMIME::HEADER_FIELD_ADDRESS);
 336     }
 337
 338     OUString GetSender() const
 339     {
 340         return GetHeaderValue_Impl (
 341             m_nIndex[INETMSG_RFC822_SENDER],
 342             INetMIME::HEADER_FIELD_ADDRESS);
 343     }
 344
 345     OUString GetSubject() const
 346     {
 347         return GetHeaderValue_Impl (
 348             m_nIndex[INETMSG_RFC822_SUBJECT],
 349             INetMIME::HEADER_FIELD_TEXT);
 350     }
 351
 352     OUString GetTo() const
 353     {
 354         return GetHeaderValue_Impl (
 355             m_nIndex[INETMSG_RFC822_TO],
 356             INetMIME::HEADER_FIELD_TEXT);
 357     }
 358
 359     // Stream operators.
 360
 361     friend SvStream& operator<< (
 362         SvStream& rStrm, const INetRFC822Message& rMsg)
 363     {
 364         return rMsg.operator<< (rStrm);
 365     }
 366
 367     friend SvStream& operator>> (
 368         SvStream& rStrm, INetRFC822Message& rMsg)
 369     {
 370         return rMsg.operator>> (rStrm);
 371     }
 372 };
 373
 374 #define INETMSG_MIME_VERSION                    0
 375 #define INETMSG_MIME_CONTENT_DESCRIPTION        1
 376 #define INETMSG_MIME_CONTENT_DISPOSITION        2
 377 #define INETMSG_MIME_CONTENT_ID                 3
 378 #define INETMSG_MIME_CONTENT_TYPE               4
 379 #define INETMSG_MIME_CONTENT_TRANSFER_ENCODING  5
 380 #define INETMSG_MIME_NUMHDR                     6
 381
 382 enum INetMessageContainerType
 383 {
 384     INETMSG_MESSAGE_RFC822,
 385     INETMSG_MULTIPART_MIXED,
 386     INETMSG_MULTIPART_ALTERNATIVE,
 387     INETMSG_MULTIPART_DIGEST,
 388     INETMSG_MULTIPART_PARALLEL,
 389     INETMSG_MULTIPART_RELATED,
 390     INETMSG_MULTIPART_FORM_DATA
 391 };
 392
 393 class INetMIMEMessage;
 394 typedef ::std::vector< INetMIMEMessage* > INetMIMEMessgeList_impl;
 395
 396 class TOOLS_DLLPUBLIC INetMIMEMessage : public INetRFC822Message
 397 {
 398     sal_uIntPtr             m_nIndex[INETMSG_MIME_NUMHDR];
 399     INetMIMEMessage*        pParent;
 400     INetMIMEMessgeList_impl aChildren;
 401     OString                 m_aBoundary;
 402     bool                    bHeaderParsed;
 403
 404     friend class INetMIMEMessageStream;
 405
 406     const OString& GetMultipartBoundary() const { return m_aBoundary; }
 407     void SetMultipartBoundary (const OString& rBnd) { m_aBoundary = rBnd; }
 408
 409     void CleanupImp();
 410     void CopyImp    (const INetMIMEMessage& rMsg);
 411     void SetHeaderParsed() { bHeaderParsed = sal_True; }
 412
 413 protected:
 414     virtual SvStream& operator<< (SvStream& rStrm) const;
 415     virtual SvStream& operator>> (SvStream& rStrm);
 416
 417 public:
 418     INetMIMEMessage();
 419     INetMIMEMessage (const INetMIMEMessage& rMsg);
 420     virtual ~INetMIMEMessage();
 421
 422     INetMIMEMessage& operator= (const INetMIMEMessage& rMsg);
 423
 424     bool HeaderParsed() const { return bHeaderParsed; }
 425
 426     virtual INetMIMEMessage* CreateMessage (
 427         const INetMIMEMessage& rMsg) const;
 428
 429     using INetRFC822Message::SetHeaderField;
 430     virtual sal_uIntPtr SetHeaderField (
 431         const INetMessageHeader &rHeader,
 432         sal_uIntPtr nIndex = ((sal_uIntPtr)-1)
 433     );
 434
 435     // Header fields.
 436
 437     void     SetMIMEVersion (const OUString& rVersion);
 438     OUString GetMIMEVersion() const
 439     {
 440         return GetHeaderValue (m_nIndex[INETMSG_MIME_VERSION]);
 441     }
 442
 443     OUString GetContentDescription() const
 444     {
 445         return GetHeaderValue (m_nIndex[INETMSG_MIME_CONTENT_DESCRIPTION]);
 446     }
 447
 448     void     SetContentDisposition (const OUString& rDisposition);
 449     OUString GetContentDisposition() const
 450     {
 451         return GetHeaderValue (m_nIndex[INETMSG_MIME_CONTENT_DISPOSITION]);
 452     }
 453
 454     OUString GetContentID() const
 455     {
 456         return GetHeaderValue (m_nIndex[INETMSG_MIME_CONTENT_ID]);
 457     }
 458
 459     void     SetContentType (const OUString& rType);
 460     OUString GetContentType() const
 461     {
 462         return GetHeaderValue (m_nIndex[INETMSG_MIME_CONTENT_TYPE]);
 463     }
 464
 465     void     SetContentTransferEncoding (const OUString& rEncoding);
 466     OUString GetContentTransferEncoding() const
 467     {
 468         return GetHeaderValue (m_nIndex[INETMSG_MIME_CONTENT_TRANSFER_ENCODING]);
 469     }
 470
 471     OUString GetDefaultContentType ();
 472
 473     // Message container methods.
 474
 475     bool IsContainer() const
 476     {
 477         return (IsMessage() || IsMultipart());
 478     }
 479     bool IsMessage() const
 480     {
 481         OUString aType (GetContentType());
 482         return aType.matchIgnoreAsciiCase("message/");
 483     }
 484     bool IsMultipart() const
 485     {
 486         OUString aType (GetContentType());
 487         return aType.matchIgnoreAsciiCase("multipart/");
 488     }
 489
 490     INetMIMEMessage* GetChild (sal_uIntPtr nIndex) const
 491     {
 492         return ( nIndex < aChildren.size() ) ? aChildren[ nIndex ] : NULL;
 493     }
 494     INetMIMEMessage* GetParent() const { return pParent; }
 495
 496     bool EnableAttachChild (
 497         INetMessageContainerType eType = INETMSG_MULTIPART_MIXED);
 498     bool AttachChild (
 499         INetMIMEMessage& rChildMsg, bool bOwner = true );
 500
 501     // Stream operators.
 502
 503     friend SvStream& operator<< (
 504         SvStream& rStrm, const INetMIMEMessage& rMsg)
 505     {
 506         return rMsg.operator<< (rStrm);
 507     }
 508
 509     friend SvStream& operator>> (
 510         SvStream& rStrm, INetMIMEMessage& rMsg)
 511     {
 512         return rMsg.operator>> (rStrm);
 513     }
 514 };
 515
 516 #endif
 517
 518 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */