mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-01-31 09:57:14 +01:00
4a6bfc086c
Switched to POCO library for unified platform/library interface. Deprecated the external module API. It was creating more problems than solving. Removed most built-in libraries in favor of system libraries for easier maintenance. Cleaned and secured code with help from static analyzers.
359 lines
11 KiB
C++
359 lines
11 KiB
C++
//
|
|
// MailMessage.h
|
|
//
|
|
// Library: Net
|
|
// Package: Mail
|
|
// Module: MailMessage
|
|
//
|
|
// Definition of the MailMessage class.
|
|
//
|
|
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
|
|
// and Contributors.
|
|
//
|
|
// SPDX-License-Identifier: BSL-1.0
|
|
//
|
|
|
|
|
|
#ifndef Net_MailMessage_INCLUDED
|
|
#define Net_MailMessage_INCLUDED
|
|
|
|
|
|
#include "Poco/Net/Net.h"
|
|
#include "Poco/Net/MessageHeader.h"
|
|
#include "Poco/Net/MailRecipient.h"
|
|
#include "Poco/Net/PartStore.h"
|
|
#include "Poco/SharedPtr.h"
|
|
#include "Poco/Timestamp.h"
|
|
#include <sstream>
|
|
#include <vector>
|
|
|
|
|
|
namespace Poco {
|
|
namespace Net {
|
|
|
|
|
|
class MediaType;
|
|
class PartSource;
|
|
class PartHandler;
|
|
class MultipartWriter;
|
|
class MultipartSource;
|
|
|
|
|
|
class Net_API MailMessage: public MessageHeader
|
|
/// This class represents an e-mail message for
|
|
/// use with the SMTPClientSession and POPClientSession
|
|
/// classes.
|
|
///
|
|
/// MailMessage supports both old-style plain text messages,
|
|
/// as well as MIME multipart mail messages with attachments.
|
|
///
|
|
/// For multi-part messages, the following content transfer
|
|
/// encodings are supported: 7bit, 8bit, quoted-printable
|
|
/// and base64.
|
|
{
|
|
public:
|
|
using Recipients = std::vector<MailRecipient>;
|
|
|
|
enum ContentDisposition
|
|
{
|
|
CONTENT_INLINE,
|
|
CONTENT_ATTACHMENT
|
|
};
|
|
|
|
enum ContentTransferEncoding
|
|
{
|
|
ENCODING_7BIT,
|
|
ENCODING_8BIT,
|
|
ENCODING_QUOTED_PRINTABLE,
|
|
ENCODING_BASE64
|
|
};
|
|
|
|
struct Part
|
|
{
|
|
std::string name;
|
|
PartSource* pSource;
|
|
ContentDisposition disposition;
|
|
ContentTransferEncoding encoding;
|
|
};
|
|
|
|
using PartVec = std::vector<Part>;
|
|
|
|
MailMessage(PartStoreFactory* pStoreFactory = 0);
|
|
/// Creates an empty MailMessage.
|
|
///
|
|
/// If pStoreFactory is not null, message attachments will be
|
|
/// handled by the object created by the factory. Most
|
|
/// common reason is to temporarily save attachments to
|
|
/// the file system in order to avoid potential memory
|
|
/// exhaustion when attachment files are very large.
|
|
|
|
virtual ~MailMessage();
|
|
/// Destroys the MailMessage.
|
|
|
|
void addRecipient(const MailRecipient& recipient);
|
|
/// Adds a recipient for the message.
|
|
|
|
void setRecipients(const Recipients& recipient);
|
|
/// Clears existing and sets new recipient list for the message.
|
|
|
|
const Recipients& recipients() const;
|
|
/// Returns the recipients of the message.
|
|
|
|
void setSubject(const std::string& subject);
|
|
/// Sets the subject of the message.
|
|
///
|
|
/// The subject must not contain any non-ASCII
|
|
/// characters. To include non-ASCII characters
|
|
/// in the subject, use RFC 2047 word encoding
|
|
/// (see encodeWord()).
|
|
|
|
const std::string& getSubject() const;
|
|
/// Returns the subject of the message.
|
|
|
|
void setSender(const std::string& sender);
|
|
/// Sets the sender of the message (which
|
|
/// ends up in the From header field).
|
|
///
|
|
/// The sender must either be a valid email
|
|
/// address, or a real name followed by
|
|
/// an email address enclosed in < and >.
|
|
///
|
|
/// The sender must not contain any non-ASCII
|
|
/// characters. To include non-ASCII characters
|
|
/// in the sender, use RFC 2047 word encoding
|
|
/// (see encodeWord()).
|
|
|
|
const std::string& getSender() const;
|
|
/// Returns the sender of the message (taken
|
|
/// from the From header field).
|
|
|
|
void setContent(const std::string& content, ContentTransferEncoding encoding = ENCODING_QUOTED_PRINTABLE);
|
|
/// Sets the content of the mail message.
|
|
///
|
|
/// If the content transfer encoding is ENCODING_7BIT or
|
|
/// ENCODING_8BIT, the content string must be formatted
|
|
/// according to the rules of an internet email message.
|
|
///
|
|
/// The message will be sent as a single-part
|
|
/// message.
|
|
///
|
|
/// Note that single CR or LF characters as line delimiters must
|
|
/// not be used. Content lines always should be terminated with a
|
|
/// proper CRLF sequence.
|
|
|
|
const std::string& getContent() const;
|
|
/// Returns the content of the mail message.
|
|
///
|
|
/// A content will only be returned for single-part
|
|
/// messages. The content of multi-part mail messages
|
|
/// will be reported through the registered PartHandler.
|
|
|
|
void setContentType(const std::string& mediaType);
|
|
/// Sets the content type for the message.
|
|
|
|
void setContentType(const MediaType& mediaType);
|
|
/// Sets the content type for the message.
|
|
|
|
const std::string& getContentType() const;
|
|
/// Returns the content type for the message.
|
|
|
|
void setDate(const Poco::Timestamp& dateTime);
|
|
/// Sets the Date header to the given date/time value.
|
|
|
|
Poco::Timestamp getDate() const;
|
|
/// Returns the value of the Date header.
|
|
|
|
bool isMultipart() const;
|
|
/// Returns true iff the message is a multipart message.
|
|
|
|
void addPart(const std::string& name,
|
|
PartSource* pSource,
|
|
ContentDisposition disposition,
|
|
ContentTransferEncoding encoding);
|
|
/// Adds a part/attachment to the mail message.
|
|
///
|
|
/// The MailMessage takes ownership of the PartSource and deletes it
|
|
/// when it is no longer needed.
|
|
///
|
|
/// The MailMessage will be converted to a multipart message
|
|
/// if it is not already one.
|
|
///
|
|
/// The part name, and the filename specified in the part source
|
|
/// must not contain any non-ASCII characters.
|
|
/// To include non-ASCII characters in the part name or filename,
|
|
/// use RFC 2047 word encoding (see encodeWord()).
|
|
|
|
void addContent(PartSource* pSource,
|
|
ContentTransferEncoding encoding = ENCODING_QUOTED_PRINTABLE);
|
|
/// Adds a part to the mail message by calling
|
|
/// addPart("", pSource, CONTENT_INLINE, encoding);
|
|
///
|
|
/// The part name, and the filename specified in the part source
|
|
/// must not contain any non-ASCII characters.
|
|
/// To include non-ASCII characters in the part name or filename,
|
|
/// use RFC 2047 word encoding (see encodeWord()).
|
|
|
|
void addAttachment(const std::string& name,
|
|
PartSource* pSource,
|
|
ContentTransferEncoding encoding = ENCODING_BASE64);
|
|
/// Adds an attachment to the mail message by calling
|
|
/// addPart(name, pSource, CONTENT_ATTACHMENT, encoding);
|
|
///
|
|
/// The part name, and the filename specified in the part source
|
|
/// must not contain any non-ASCII characters.
|
|
/// To include non-ASCII characters in the part name or filename,
|
|
/// use RFC 2047 word encoding (see encodeWord()).
|
|
|
|
PartSource* createPartStore(const std::string& content,
|
|
const std::string& mediaType,
|
|
const std::string& filename = "");
|
|
/// Returns either default StringPartSource part store or,
|
|
/// if the part store factory was provided during construction,
|
|
/// the one created by PartStoreFactory.
|
|
/// Returned part store is allocated on the heap; it is caller's
|
|
/// responsibility to delete it after use. Typical use is handler
|
|
/// passing it back to MailMessage, which takes care of the cleanup.
|
|
|
|
const PartVec& parts() const;
|
|
/// Returns const reference to the vector containing part stores.
|
|
|
|
void read(std::istream& istr, PartHandler& handler);
|
|
/// Reads the MailMessage from the given input stream.
|
|
///
|
|
/// If the message has multiple parts, the parts
|
|
/// are reported to the PartHandler. If the message
|
|
/// is not a multi-part message, the content is stored
|
|
/// in a string available by calling getContent().
|
|
|
|
void read(std::istream& istr);
|
|
/// Reads the MailMessage from the given input stream.
|
|
///
|
|
/// The raw message (including all MIME parts) is stored
|
|
/// in a string and available by calling getContent().
|
|
|
|
void write(std::ostream& ostr) const;
|
|
/// Writes the mail message to the given output stream.
|
|
|
|
static std::string encodeWord(const std::string& text, const std::string& charset = "UTF-8");
|
|
/// If the given string contains non-ASCII characters,
|
|
/// encodes the given string using RFC 2047 "Q" word encoding.
|
|
///
|
|
/// The given text must already be encoded in the character set
|
|
/// given in charset (default is UTF-8).
|
|
///
|
|
/// Returns the encoded string, or the original string if it
|
|
/// consists only of ASCII characters.
|
|
|
|
static const std::string HEADER_SUBJECT;
|
|
static const std::string HEADER_FROM;
|
|
static const std::string HEADER_TO;
|
|
static const std::string HEADER_CC;
|
|
static const std::string HEADER_BCC;
|
|
static const std::string HEADER_DATE;
|
|
static const std::string HEADER_CONTENT_TYPE;
|
|
static const std::string HEADER_CONTENT_TRANSFER_ENCODING;
|
|
static const std::string HEADER_CONTENT_DISPOSITION;
|
|
static const std::string HEADER_CONTENT_ID;
|
|
static const std::string HEADER_MIME_VERSION;
|
|
static const std::string EMPTY_HEADER;
|
|
static const std::string TEXT_PLAIN;
|
|
static const std::string CTE_7BIT;
|
|
static const std::string CTE_8BIT;
|
|
static const std::string CTE_QUOTED_PRINTABLE;
|
|
static const std::string CTE_BASE64;
|
|
|
|
protected:
|
|
void makeMultipart();
|
|
void writeHeader(const MessageHeader& header, std::ostream& ostr) const;
|
|
void writeMultipart(MessageHeader& header, std::ostream& ostr) const;
|
|
static void writePart(MultipartWriter& writer, const Part& part);
|
|
static void writeEncoded(std::istream& istr, std::ostream& ostr, ContentTransferEncoding encoding);
|
|
void setRecipientHeaders(MessageHeader& headers) const;
|
|
void readHeader(std::istream& istr);
|
|
void readMultipart(std::istream& istr, PartHandler& handler);
|
|
void readPart(std::istream& istr, const MessageHeader& header, PartHandler& handler);
|
|
void handlePart(std::istream& istr, const MessageHeader& header, PartHandler& handler);
|
|
static const std::string& contentTransferEncodingToString(ContentTransferEncoding encoding);
|
|
static int lineLength(const std::string& str);
|
|
static void appendRecipient(const MailRecipient& recipient, std::string& str);
|
|
|
|
private:
|
|
MailMessage(const MailMessage&);
|
|
MailMessage& operator = (const MailMessage&);
|
|
|
|
Recipients _recipients;
|
|
PartVec _parts;
|
|
std::string _content;
|
|
ContentTransferEncoding _encoding;
|
|
mutable std::string _boundary;
|
|
PartStoreFactory* _pStoreFactory;
|
|
|
|
friend class MultipartSource;
|
|
};
|
|
|
|
|
|
class Net_API MultipartSource: public PartSource
|
|
/// This is a PartSource for constructing complex
|
|
/// mail messages consisting of multiple nested parts.
|
|
{
|
|
public:
|
|
explicit MultipartSource(const std::string contentType = "multipart/alternative");
|
|
/// Creates an empty MultipartSource.
|
|
///
|
|
/// At least one part must be added with addPart().
|
|
|
|
~MultipartSource();
|
|
/// Destroys the MultipartSource.
|
|
|
|
void addPart(const std::string& name,
|
|
PartSource* pSource,
|
|
MailMessage::ContentDisposition disposition,
|
|
MailMessage::ContentTransferEncoding encoding);
|
|
/// Adds a part/attachment to the MultipartSource.
|
|
///
|
|
/// The MultipartSource takes ownership of the PartSource and deletes it
|
|
/// when it is no longer needed.
|
|
///
|
|
/// The part name, and the filename specified in the part source
|
|
/// must not contain any non-ASCII characters.
|
|
/// To include non-ASCII characters in the part name or filename,
|
|
/// use RFC 2047 word encoding (see encodeWord()).
|
|
|
|
// PartSource
|
|
std::istream& stream();
|
|
|
|
protected:
|
|
static std::string contentTypeWithBoundary(const std::string& contentType);
|
|
|
|
private:
|
|
std::vector<MailMessage::Part> _parts;
|
|
std::stringstream _content;
|
|
};
|
|
|
|
|
|
//
|
|
// inlines
|
|
//
|
|
inline const MailMessage::Recipients& MailMessage::recipients() const
|
|
{
|
|
return _recipients;
|
|
}
|
|
|
|
|
|
inline const std::string& MailMessage::getContent() const
|
|
{
|
|
return _content;
|
|
}
|
|
|
|
|
|
inline const MailMessage::PartVec& MailMessage::parts() const
|
|
{
|
|
return _parts;
|
|
}
|
|
|
|
|
|
} } // namespace Poco::Net
|
|
|
|
|
|
#endif // Net_MailMessage_INCLUDED
|