/// <summary>
/// Stores MIME entity body to the specified stream.
/// </summary>
/// <param name="stream">Stream where to store body data.</param>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="headerReencode">If true always specified encoding is used for header. If false and header field value not modified,
/// original encoding is kept.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
protected internal override void ToStream(Stream stream,MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset,bool headerReencode)
{
if(stream == null){
throw new ArgumentNullException("stream");
}
m_pMessage.ToStream(stream,headerWordEncoder,headerParmetersCharset,headerReencode);
}
/// <summary>
/// Returns address as string value.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <returns>Returns address as string value.</returns>
public override string ToString(MIME_Encoding_EncodedWord wordEncoder)
{
StringBuilder retVal = new StringBuilder();
if(string.IsNullOrEmpty(m_DisplayName)){
retVal.Append(":");
}
else{
if(MIME_Encoding_EncodedWord.MustEncode(m_DisplayName)){
retVal.Append(wordEncoder.Encode(m_DisplayName) + ":");
}
else{
retVal.Append(TextUtils.QuoteString(m_DisplayName) + ":");
}
}
for(int i=0;i<m_pList.Count;i++){
retVal.Append(m_pList[i].ToString(wordEncoder));
if(i < (m_pList.Count - 1)){
retVal.Append(",");
}
}
retVal.Append(";");
return retVal.ToString();
}
/// <summary>
/// Stores header to the specified stream.
/// </summary>
/// <param name="stream">Stream where to store header.</param>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="reEncod">If true always specified encoding is used for header. If false and header field value not modified,
/// original encoding is kept.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
public void ToStream(Stream stream,MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset,bool reEncod)
{
if(stream == null){
throw new ArgumentNullException("stream");
}
byte[] header = Encoding.UTF8.GetBytes(ToString(wordEncoder,parmetersCharset,reEncod));
stream.Write(header,0,header.Length);
}
/// <summary>
/// Returns header field value as string.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.
/// If encoding needed, UTF-8 is strongly reccomended if not sure.</param>
/// <returns>Returns header field value as string.</returns>
public string ValueToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset)
{
return ToString(wordEncoder,parmetersCharset).Split(new char[]{':'},2)[1].TrimStart();
}
/// <summary>
/// Returns header field as string.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.
/// If encoding needed, UTF-8 is strongly reccomended if not sure.</param>
/// <returns>Returns header field as string.</returns>
public string ToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset)
{
return ToString(wordEncoder,parmetersCharset,false);
}
/// <summary>
/// Constructs ENVELOPE address structure.
/// </summary>
/// <param name="address">Mailbox address.</param>
/// <param name="wordEncoder">Unicode words encoder.</param>
/// <returns></returns>
private static string ConstructAddress(Mail_t_Mailbox address,MIME_Encoding_EncodedWord wordEncoder)
{
/* An address structure is a parenthesized list that describes an
electronic mail address. The fields of an address structure
are in the following order: personal name, [SMTP]
at-domain-list (source route), mailbox name, and host name.
*/
// NOTE: all header fields and parameters must in ENCODED form !!!
StringBuilder retVal = new StringBuilder();
retVal.Append("(");
// personal name
if(address.DisplayName != null){
retVal.Append(TextUtils.QuoteString(wordEncoder.Encode(RemoveCrlf(address.DisplayName))));
}
else{
retVal.Append("NIL");
}
// source route, always NIL (not used nowdays)
retVal.Append(" NIL");
// mailbox name
retVal.Append(" " + TextUtils.QuoteString(wordEncoder.Encode(RemoveCrlf(address.LocalPart))));
// host name
if(address.Domain != null){
retVal.Append(" " + TextUtils.QuoteString(wordEncoder.Encode(RemoveCrlf(address.Domain))));
}
else{
retVal.Append(" NIL");
}
retVal.Append(")");
return retVal.ToString();
}
/// <summary>
/// Returns header field as string.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
/// <param name="reEncode">If true always specified encoding is used. If false and header field value not modified, original encoding is kept.</param>
/// <returns>Returns header field as string.</returns>
public override string ToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset,bool reEncode)
{
if(string.IsNullOrEmpty(m_Address)){
return "Return-Path: <>\r\n";
}
else{
return "Return-Path: <" + m_Address + ">\r\n";
}
}
/// <summary>
/// Returns header field as string.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
/// <param name="reEncode">If true always specified encoding is used. If false and header field value not modified, original encoding is kept.</param>
/// <returns>Returns header field as string.</returns>
public override string ToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset,bool reEncode)
{
if(reEncode || this.IsModified){
StringBuilder retVal = new StringBuilder();
retVal.Append("Received: ");
retVal.Append("from " + m_From);
if(m_pFrom_TcpInfo != null){
retVal.Append(" (" + m_pFrom_TcpInfo.ToString() + ")");
}
retVal.Append(" by " + m_By);
if(m_pBy_TcpInfo != null){
retVal.Append(" (" + m_pBy_TcpInfo.ToString() + ")");
}
if(!string.IsNullOrEmpty(m_Via)){
retVal.Append(" via " + m_Via);
}
if(!string.IsNullOrEmpty(m_With)){
retVal.Append(" with " + m_With);
}
if(!string.IsNullOrEmpty(m_ID)){
retVal.Append(" id " + m_ID);
}
if(!string.IsNullOrEmpty(m_For)){
retVal.Append(" for " + m_For);
}
retVal.Append("; " + MIME_Utils.DateTimeToRfc2822(m_Time));
retVal.Append("\r\n");
/* Some servers doesnt like uppercase.
retVal.Append("Received: ");
retVal.Append("FROM " + m_From);
if(m_pFrom_TcpInfo != null){
retVal.Append(" (" + m_pFrom_TcpInfo.ToString() + ")");
}
retVal.Append(" BY " + m_By);
if(m_pBy_TcpInfo != null){
retVal.Append(" (" + m_pBy_TcpInfo.ToString() + ")");
}
if(!string.IsNullOrEmpty(m_Via)){
retVal.Append(" VIA " + m_Via);
}
if(!string.IsNullOrEmpty(m_With)){
retVal.Append(" WITH " + m_With);
}
if(!string.IsNullOrEmpty(m_ID)){
retVal.Append(" ID " + m_ID);
}
if(!string.IsNullOrEmpty(m_For)){
retVal.Append(" FOR " + m_For);
}
retVal.Append("; " + MIME_Utils.DateTimeToRfc2822(m_Time));
retVal.Append("\r\n");*/
return retVal.ToString();
}
else{
return m_ParseValue;
}
}
/// <summary>
/// Returns MIME entity as string.
/// </summary>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <returns>Returns MIME entity as string.</returns>
public string ToString(MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset)
{
return ToString(headerWordEncoder,headerParmetersCharset,false);
}
/// <summary> /// Returns address as string value. /// </summary> /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param> /// <returns>Returns address as string value.</returns> public abstract string ToString(MIME_Encoding_EncodedWord wordEncoder);
/// <summary>
/// Returns header field as string.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
/// <param name="reEncode">If true always specified encoding is used. If false and header field value not modified, original encoding is kept.</param>
/// <returns>Returns header field as string.</returns>
public override string ToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset,bool reEncode)
{
if(reEncode || this.IsModified){
StringBuilder retVal = new StringBuilder();
retVal.Append(this.Name + ": ");
for(int i=0;i<m_pAddresses.Count;i++){
if(i > 0){
retVal.Append("\t");
}
// Don't add ',' for last item.
if(i == (m_pAddresses.Count - 1)){
retVal.Append(m_pAddresses[i].ToString(wordEncoder) + "\r\n");
}
else{
retVal.Append(m_pAddresses[i].ToString(wordEncoder) + ",\r\n");
}
}
// No items, we need to add ending CRLF.
if(m_pAddresses.Count == 0){
retVal.Append("\r\n");
}
return retVal.ToString();
}
else{
return m_ParseValue;
}
}
/// <summary>
/// Returns address as string value.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <returns>Returns address as string value.</returns>
public override string ToString(MIME_Encoding_EncodedWord wordEncoder)
{
if(string.IsNullOrEmpty(m_DisplayName)){
return m_Address;
}
else{
if(wordEncoder != null && MIME_Encoding_EncodedWord.MustEncode(m_DisplayName)){
return wordEncoder.Encode(m_DisplayName) + " " + "<" + m_Address + ">";
}
else{
return TextUtils.QuoteString(m_DisplayName) + " " + "<" + m_Address + ">";
}
}
}
/// <summary>
/// Stores MIME entity body to the specified stream.
/// </summary>
/// <param name="stream">Stream where to store body data.</param>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="headerReencode">If true always specified encoding is used for header. If false and header field value not modified,
/// original encoding is kept.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
protected internal override void ToStream(Stream stream,MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset,bool headerReencode)
{
if(stream == null){
throw new ArgumentNullException("stream");
}
m_pMessageFields.ToStream(stream,headerWordEncoder,headerParmetersCharset,headerReencode);
stream.Write(new byte[]{(byte)'\r',(byte)'\n'},0,2);
foreach(MIME_h_Collection recipientBlock in m_pRecipientBlocks){
recipientBlock.ToStream(stream,headerWordEncoder,headerParmetersCharset,headerReencode);
stream.Write(new byte[]{(byte)'\r',(byte)'\n'},0,2);
}
}
/// <summary>
/// Returns header field as string.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
/// <param name="reEncode">If true always specified encoding is used. If false and header field value not modified, original encoding is kept.</param>
/// <returns>Returns header field as string.</returns>
public override string ToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset,bool reEncode)
{
return "TODO:";
}
/// <summary>
/// Returns MIME header as string.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="reEncode">If true always specified encoding is used. If false and header fields which value not modified, original encoding is kept.</param>
/// <returns>Returns MIME header as string.</returns>
public string ToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset,bool reEncode)
{
StringBuilder retVal = new StringBuilder();
foreach(MIME_h field in m_pFields){
retVal.Append(field.ToString(wordEncoder,parmetersCharset,reEncode));
}
return retVal.ToString();
}
/// <summary>
/// Store MIME enity to the specified stream.
/// </summary>
/// <param name="stream">Stream where to store MIME entity. Storing starts form stream current position.</param>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null.</exception>
public void ToStream(Stream stream,MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset)
{
ToStream(stream,headerWordEncoder,headerParmetersCharset,false);
}
/// <summary>
/// Store MIME enity to the specified stream.
/// </summary>
/// <param name="stream">Stream where to store MIME entity. Storing starts form stream current position.</param>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="headerReencode">If true always specified encoding is used for header. If false and header field value not modified,
/// original encoding is kept.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null.</exception>
public void ToStream(Stream stream,MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset,bool headerReencode)
{
if(stream == null){
throw new ArgumentNullException("stream");
}
m_pHeader.ToStream(stream,headerWordEncoder,headerParmetersCharset,headerReencode);
stream.Write(new byte[]{(int)'\r',(int)'\n'},0,2);
m_pBody.ToStream(stream,headerWordEncoder,headerParmetersCharset,headerReencode);
}
/// <summary>
/// Returns header field as string.
/// </summary>
/// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded.</param>
/// <param name="reEncode">If true always specified encoding is used. If false and header field value not modified, original encoding is kept.</param>
/// <returns>Returns header field as string.</returns>
public override string ToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset,bool reEncode)
{
if(!reEncode && m_ParseValue != null){
return m_ParseValue;
}
else{
return m_Name + ": " + m_pAddress.ToString(wordEncoder) + "\r\n";
}
}
/// <summary>
/// Returns MIME entity as string.
/// </summary>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="headerReencode">If true always specified encoding is used for header. If false and header field value not modified,
/// original encoding is kept.</param>
/// <returns>Returns MIME entity as string.</returns>
public string ToString(MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset,bool headerReencode)
{
using(MemoryStream ms = new MemoryStream()){
ToStream(ms,headerWordEncoder,headerParmetersCharset,headerReencode);
return Encoding.UTF8.GetString(ms.ToArray());
}
}
/// <summary>
/// 发送邮件
/// </summary>
/// <param name="mm">邮件对象</param>
/// <param name="from">发送人</param>
/// <param name="to">接收人</param>
private void send(Mail_Message mm, ASObject from, string[] to)
{
using (MemoryStreamEx stream = new MemoryStreamEx(32000))
{
MIME_Encoding_EncodedWord headerwordEncoder = new MIME_Encoding_EncodedWord(MIME_EncodedWordEncoding.Q, Encoding.UTF8);
mm.ToStream(stream, headerwordEncoder, Encoding.UTF8);
stream.Position = 0;
SMTP_Client.QuickSendSmartHost(null, from.getString("send_address", "stmp.sina.com"), from.getInt("send_port", 25),
from.getBoolean("is_send_ssl", false), from.getString("account"), PassUtil.Decrypt(from.getString("password")),
from.getString("account"), to, stream);
}
}
/// <summary>
/// Constructs specified entity and it's childentities bodystructure string.
/// </summary>
/// <param name="entity">Mime entity.</param>
/// <param name="bodystructure">Specifies if to construct BODY or BODYSTRUCTURE.</param>
/// <returns></returns>
private static string ConstructParts(MIME_Entity entity,bool bodystructure)
{
/* RFC 3501 7.4.2 BODYSTRUCTURE
BODY A form of BODYSTRUCTURE without extension data.
A parenthesized list that describes the [MIME-IMB] body
structure of a message. This is computed by the server by
parsing the [MIME-IMB] header fields, defaulting various fields
as necessary.
For example, a simple text message of 48 lines and 2279 octets
can have a body structure of: ("TEXT" "PLAIN" ("CHARSET"
"US-ASCII") NIL NIL "7BIT" 2279 48)
Multiple parts are indicated by parenthesis nesting. Instead
of a body type as the first element of the parenthesized list,
there is a sequence of one or more nested body structures. The
second element of the parenthesized list is the multipart
subtype (mixed, digest, parallel, alternative, etc.).
For example, a two part message consisting of a text and a
BASE64-encoded text attachment can have a body structure of:
(("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 1152
23)("TEXT" "PLAIN" ("CHARSET" "US-ASCII" "NAME" "cc.diff")
"<*****@*****.**>" "Compiler diff"
"BASE64" 4554 73) "MIXED")
Extension data follows the multipart subtype. Extension data
is never returned with the BODY fetch, but can be returned with
a BODYSTRUCTURE fetch. Extension data, if present, MUST be in
the defined order. The extension data of a multipart body part
are in the following order:
body parameter parenthesized list
A parenthesized list of attribute/value pairs [e.g., ("foo"
"bar" "baz" "rag") where "bar" is the value of "foo", and
"rag" is the value of "baz"] as defined in [MIME-IMB].
body disposition
A parenthesized list, consisting of a disposition type
string, followed by a parenthesized list of disposition
attribute/value pairs as defined in [DISPOSITION].
body language
A string or parenthesized list giving the body language
value as defined in [LANGUAGE-TAGS].
body location
A string list giving the body content URI as defined in [LOCATION].
Any following extension data are not yet defined in this
version of the protocol. Such extension data can consist of
zero or more NILs, strings, numbers, or potentially nested
parenthesized lists of such data. Client implementations that
do a BODYSTRUCTURE fetch MUST be prepared to accept such
extension data. Server implementations MUST NOT send such
extension data until it has been defined by a revision of this
protocol.
The basic fields of a non-multipart body part are in the
following order:
body type
A string giving the content media type name as defined in [MIME-IMB].
body subtype
A string giving the content subtype name as defined in [MIME-IMB].
body parameter parenthesized list
A parenthesized list of attribute/value pairs [e.g., ("foo"
"bar" "baz" "rag") where "bar" is the value of "foo" and
"rag" is the value of "baz"] as defined in [MIME-IMB].
body id
A string giving the content id as defined in [MIME-IMB].
body description
A string giving the content description as defined in [MIME-IMB].
body encoding
A string giving the content transfer encoding as defined in [MIME-IMB].
body size
A number giving the size of the body in octets. Note that
this size is the size in its transfer encoding and not the
resulting size after any decoding.
A body type of type MESSAGE and subtype RFC822 contains,
immediately after the basic fields, the envelope structure,
body structure, and size in text lines of the encapsulated
message.
A body type of type TEXT contains, immediately after the basic
fields, the size of the body in text lines. Note that this
size is the size in its content transfer encoding and not the
resulting size after any decoding.
Extension data follows the basic fields and the type-specific
fields listed above. Extension data is never returned with the
BODY fetch, but can be returned with a BODYSTRUCTURE fetch.
Extension data, if present, MUST be in the defined order.
The extension data of a non-multipart body part are in the
following order:
body MD5
A string giving the body MD5 value as defined in [MD5].
body disposition
A parenthesized list with the same content and function as
the body disposition for a multipart body part.
body language
A string or parenthesized list giving the body language
value as defined in [LANGUAGE-TAGS].
body location
A string list giving the body content URI as defined in [LOCATION].
Any following extension data are not yet defined in this
version of the protocol, and would be as described above under
multipart extension data.
// We don't construct extention fields like rfc says:
Server implementations MUST NOT send such
extension data until it has been defined by a revision of this
protocol.
contentTypeMainMediaType - Example: 'TEXT'
contentTypeSubMediaType - Example: 'PLAIN'
conentTypeParameters - Example: '("CHARSET" "iso-8859-1" ...)'
contentID - Content-ID: header field value.
contentDescription - Content-Description: header field value.
contentEncoding - Content-Transfer-Encoding: header field value.
contentSize - mimeEntity ENCODED data size
[envelope] - NOTE: included only if contentType = "message" !!!
[contentLines] - number of ENCODED data lines. NOTE: included only if contentType = "text" !!!
// Basic fields for multipart
(nestedMimeEntries) contentTypeSubMediaType
// Basic fields for non-multipart
contentTypeMainMediaType contentTypeSubMediaType (conentTypeParameters) contentID contentDescription contentEncoding contentSize [envelope] [contentLine]
*/
MIME_Encoding_EncodedWord wordEncoder = new MIME_Encoding_EncodedWord(MIME_EncodedWordEncoding.B,Encoding.UTF8);
wordEncoder.Split = false;
StringBuilder retVal = new StringBuilder();
// Multipart message
if(entity.Body is MIME_b_Multipart){
retVal.Append("(");
// Construct child entities.
foreach(MIME_Entity childEntity in ((MIME_b_Multipart)entity.Body).BodyParts){
// Construct child entity. This can be multipart or non multipart.
retVal.Append(ConstructParts(childEntity,bodystructure));
}
// Add contentTypeSubMediaType
if(entity.ContentType != null && entity.ContentType.SubType != null){
retVal.Append(" \"" + entity.ContentType.SubType + "\"");
}
else{
retVal.Append(" NIL");
}
retVal.Append(")");
}
// Single part message
else{
retVal.Append("(");
// NOTE: all header fields and parameters must in ENCODED form !!!
// Add contentTypeMainMediaType
if(entity.ContentType != null && entity.ContentType.Type != null){
retVal.Append("\"" + entity.ContentType.Type + "\"");
}
else{
retVal.Append("NIL");
}
// Add contentTypeSubMediaType
if(entity.ContentType != null && entity.ContentType.SubType != null){
retVal.Append(" \"" + entity.ContentType.SubType + "\"");
}
else{
retVal.Append(" NIL");
}
// conentTypeParameters - Syntax: {("name" SP "value" *(SP "name" SP "value"))}
if(entity.ContentType != null){
if(entity.ContentType.Parameters.Count > 0){
retVal.Append(" (");
bool first = true;
foreach(MIME_h_Parameter parameter in entity.ContentType.Parameters){
// For the first item, don't add SP.
if(first){
first = false;
}
else{
retVal.Append(" ");
}
retVal.Append("\"" + parameter.Name + "\" \"" + wordEncoder.Encode(parameter.Value) + "\"");
}
retVal.Append(")");
}
else{
retVal.Append(" NIL");
}
}
else{
retVal.Append(" NIL");
}
// contentID
string contentID = entity.ContentID;
if(contentID != null){
retVal.Append(" \"" + wordEncoder.Encode(contentID) + "\"");
}
else{
retVal.Append(" NIL");
}
// contentDescription
string contentDescription = entity.ContentDescription;
if(contentDescription != null){
retVal.Append(" \"" + wordEncoder.Encode(contentDescription) + "\"");
}
else{
retVal.Append(" NIL");
}
// contentEncoding
if(entity.ContentTransferEncoding != null){
retVal.Append(" \"" + wordEncoder.Encode(entity.ContentTransferEncoding) + "\"");
}
else{
// If not specified, then must be 7bit.
retVal.Append(" \"7bit\"");
}
// contentSize
if(entity.Body is MIME_b_SinglepartBase){
retVal.Append(" " + ((MIME_b_SinglepartBase)entity.Body).EncodedData.Length.ToString());
}
else{
retVal.Append(" 0");
}
// envelope ---> FOR ContentType: message/rfc822 ONLY ###
if(entity.Body is MIME_b_MessageRfc822){
retVal.Append(" " + IMAP_Envelope.ConstructEnvelope(((MIME_b_MessageRfc822)entity.Body).Message));
// TODO: BODYSTRUCTURE,LINES
}
// contentLines ---> FOR ContentType: text/xxx ONLY ###
if(entity.Body is MIME_b_Text){
long lineCount = 0;
StreamLineReader r = new StreamLineReader(new MemoryStream(((MIME_b_SinglepartBase)entity.Body).EncodedData));
byte[] line = r.ReadLine();
while(line != null){
lineCount++;
line = r.ReadLine();
}
retVal.Append(" " + lineCount.ToString());
}
retVal.Append(")");
}
return retVal.ToString();
}
/// <summary>
/// Stores MIME entity body to the specified stream.
/// </summary>
/// <param name="stream">Stream where to store body data.</param>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="headerReencode">If true always specified encoding is used for header. If false and header field value not modified,
/// original encoding is kept.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
protected internal override void ToStream(Stream stream,MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset,bool headerReencode)
{
if(stream == null){
throw new ArgumentNullException("stream");
}
/* RFC 2046 5.1.1.
NOTE: The CRLF preceding the boundary delimiter line is conceptually
attached to the boundary so that it is possible to have a part that
does not end with a CRLF (line break).
*/
// Set "preamble" text if any.
if(!string.IsNullOrEmpty(m_TextPreamble)){
byte[] preableBytes = Encoding.UTF8.GetBytes(m_TextPreamble);
stream.Write(preableBytes,0,preableBytes.Length);
}
for(int i=0;i<m_pBodyParts.Count;i++){
MIME_Entity bodyPart = m_pBodyParts[i];
// Start new body part.
byte[] bStart = Encoding.UTF8.GetBytes("\r\n--" + this.Entity.ContentType.Param_Boundary + "\r\n");
stream.Write(bStart,0,bStart.Length);
bodyPart.ToStream(stream,headerWordEncoder,headerParmetersCharset,headerReencode);
// Last body part, close boundary.
if(i == (m_pBodyParts.Count - 1)){
byte[] bEnd = Encoding.UTF8.GetBytes("\r\n--" + this.Entity.ContentType.Param_Boundary + "--\r\n");
stream.Write(bEnd,0,bEnd.Length);
}
}
// Set "epilogoue" text if any.
if(!string.IsNullOrEmpty(m_TextEpilogue)){
byte[] epilogoueBytes = Encoding.UTF8.GetBytes(m_TextEpilogue);
stream.Write(epilogoueBytes,0,epilogoueBytes.Length);
}
}
/// <summary>
/// Construct secified mime entity ENVELOPE string.
/// </summary>
/// <param name="entity">Mail message.</param>
/// <returns></returns>
public static string ConstructEnvelope(Mail_Message entity)
{
/* RFC 3501 7.4.2
ENVELOPE
A parenthesized list that describes the envelope structure of a
message. This is computed by the server by parsing the
[RFC-2822] header into the component parts, defaulting various
fields as necessary.
The fields of the envelope structure are in the following
order: date, subject, from, sender, reply-to, to, cc, bcc,
in-reply-to, and message-id. The date, subject, in-reply-to,
and message-id fields are strings. The from, sender, reply-to,
to, cc, and bcc fields are parenthesized lists of address
structures.
An address structure is a parenthesized list that describes an
electronic mail address. The fields of an address structure
are in the following order: personal name, [SMTP]
at-domain-list (source route), mailbox name, and host name.
[RFC-2822] group syntax is indicated by a special form of
address structure in which the host name field is NIL. If the
mailbox name field is also NIL, this is an end of group marker
(semi-colon in RFC 822 syntax). If the mailbox name field is
non-NIL, this is a start of group marker, and the mailbox name
field holds the group name phrase.
If the Date, Subject, In-Reply-To, and Message-ID header lines
are absent in the [RFC-2822] header, the corresponding member
of the envelope is NIL; if these header lines are present but
empty the corresponding member of the envelope is the empty
string.
Note: some servers may return a NIL envelope member in the
"present but empty" case. Clients SHOULD treat NIL and
empty string as identical.
Note: [RFC-2822] requires that all messages have a valid
Date header. Therefore, the date member in the envelope can
not be NIL or the empty string.
Note: [RFC-2822] requires that the In-Reply-To and
Message-ID headers, if present, have non-empty content.
Therefore, the in-reply-to and message-id members in the
envelope can not be the empty string.
If the From, To, cc, and bcc header lines are absent in the
[RFC-2822] header, or are present but empty, the corresponding
member of the envelope is NIL.
If the Sender or Reply-To lines are absent in the [RFC-2822]
header, or are present but empty, the server sets the
corresponding member of the envelope to be the same value as
the from member (the client is not expected to know to do
this).
Note: [RFC-2822] requires that all messages have a valid
From header. Therefore, the from, sender, and reply-to
members in the envelope can not be NIL.
ENVELOPE ("date" "subject" from sender reply-to to cc bcc "in-reply-to" "messageID")
*/
// NOTE: all header fields and parameters must in ENCODED form !!!
MIME_Encoding_EncodedWord wordEncoder = new MIME_Encoding_EncodedWord(MIME_EncodedWordEncoding.B,Encoding.UTF8);
wordEncoder.Split = false;
StringBuilder retVal = new StringBuilder();
retVal.Append("ENVELOPE (");
// date
try{
if(entity.Date != DateTime.MinValue){
retVal.Append(TextUtils.QuoteString(MIME_Utils.DateTimeToRfc2822(entity.Date)));
}
else{
retVal.Append("NIL");
}
}
catch{
retVal.Append("NIL");
}
// subject
if(entity.Subject != null){
//retVal.Append(" " + TextUtils.QuoteString(wordEncoder.Encode(entity.Subject)));
string val = wordEncoder.Encode(entity.Subject);
retVal.Append(" {" + val.Length + "}\r\n" + val);
}
else{
retVal.Append(" NIL");
}
// from
if(entity.From != null && entity.From.Count > 0){
retVal.Append(" " + ConstructAddresses(entity.From.ToArray(),wordEncoder));
}
else{
retVal.Append(" NIL");
}
// sender
// NOTE: There is confusing part, according rfc 2822 Sender: is MailboxAddress and not AddressList.
if(entity.Sender != null){
retVal.Append(" (");
retVal.Append(ConstructAddress(entity.Sender,wordEncoder));
retVal.Append(")");
}
else{
retVal.Append(" NIL");
}
// reply-to
if(entity.ReplyTo != null){
retVal.Append(" " + ConstructAddresses(entity.ReplyTo.Mailboxes,wordEncoder));
}
else{
retVal.Append(" NIL");
}
// to
if(entity.To != null && entity.To.Count > 0){
retVal.Append(" " + ConstructAddresses(entity.To.Mailboxes,wordEncoder));
}
else{
retVal.Append(" NIL");
}
// cc
if(entity.Cc != null && entity.Cc.Count > 0){
retVal.Append(" " + ConstructAddresses(entity.Cc.Mailboxes,wordEncoder));
}
else{
retVal.Append(" NIL");
}
// bcc
if(entity.Bcc != null && entity.Bcc.Count > 0){
retVal.Append(" " + ConstructAddresses(entity.Bcc.Mailboxes,wordEncoder));
}
else{
retVal.Append(" NIL");
}
// in-reply-to
if(entity.InReplyTo != null){
retVal.Append(" " + TextUtils.QuoteString(wordEncoder.Encode(entity.InReplyTo)));
}
else{
retVal.Append(" NIL");
}
// message-id
if(entity.MessageID != null){
retVal.Append(" " + TextUtils.QuoteString(wordEncoder.Encode(entity.MessageID)));
}
else{
retVal.Append(" NIL");
}
retVal.Append(")");
return retVal.ToString();
}
/// <summary>
/// Returns MIME entity as byte[].
/// </summary>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <returns>Returns MIME entity as byte[].</returns>
public byte[] ToByte(MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset)
{
return ToByte(headerWordEncoder,headerParmetersCharset,false);
}
/// <summary>
/// Constructs ENVELOPE addresses structure.
/// </summary>
/// <param name="mailboxes">Mailboxes.</param>
/// <param name="wordEncoder">Unicode words encoder.</param>
/// <returns></returns>
private static string ConstructAddresses(Mail_t_Mailbox[] mailboxes,MIME_Encoding_EncodedWord wordEncoder)
{
StringBuilder retVal = new StringBuilder();
retVal.Append("(");
foreach(Mail_t_Mailbox address in mailboxes){
retVal.Append(ConstructAddress(address,wordEncoder));
}
retVal.Append(")");
return retVal.ToString();
}
/// <summary>
/// Returns MIME entity as byte[].
/// </summary>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="headerReencode">If true always specified encoding is used for header. If false and header field value not modified,
/// original encoding is kept.</param>
/// <returns>Returns MIME entity as byte[].</returns>
public byte[] ToByte(MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset,bool headerReencode)
{
using(MemoryStream ms = new MemoryStream()){
ToStream(ms,headerWordEncoder,headerParmetersCharset,headerReencode);
return ms.ToArray();
}
}
/// <summary> /// Returns header field as string. /// </summary> /// <param name="wordEncoder">8-bit words ecnoder. Value null means that words are not encoded.</param> /// <param name="parmetersCharset">Charset to use to encode 8-bit characters. Value null means parameters not encoded. /// If encoding needed, UTF-8 is strongly reccomended if not sure.</param> /// <param name="reEncode">If true always specified encoding is used. If false and header field value not modified, original encoding is kept.</param> /// <returns>Returns header field as string.</returns> public abstract string ToString(MIME_Encoding_EncodedWord wordEncoder,Encoding parmetersCharset,bool reEncode);
/// <summary>
/// Stores MIME entity to the specified file.
/// </summary>
/// <param name="file">File name with path where to store MIME entity.</param>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>file</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public void ToFile(string file,MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset)
{
ToFile(file,headerWordEncoder,headerParmetersCharset,false);
}
/// <summary>
/// 发送阅读回折邮件
/// </summary>
/// <param name="sHtmlText">邮件内容</param>
/// <param name="from">发送人</param>
/// <param name="to">接收人</param>
public void sendReceiptMail(string sHtmlText, string subject, ASObject from, string[] to)
{
using (MemoryStreamEx stream = new MemoryStreamEx(32000))
{
Mail_Message m = new Mail_Message();
m.MimeVersion = "1.0";
m.Date = DateTime.Now;
m.MessageID = MIME_Utils.CreateMessageID();
m.Subject = subject;
StringBuilder sb = new StringBuilder();
foreach (string p in to)
{
if (sb.Length > 0)
sb.Append(",");
sb.Append(p);
}
m.To = Mail_t_AddressList.Parse(sb.ToString());
//--- multipart/alternative -----------------------------------------------------------------------------------------
MIME_h_ContentType contentType_multipartAlternative = new MIME_h_ContentType(MIME_MediaTypes.Multipart.alternative);
contentType_multipartAlternative.Param_Boundary = Guid.NewGuid().ToString().Replace('-', '.');
MIME_b_MultipartAlternative multipartAlternative = new MIME_b_MultipartAlternative(contentType_multipartAlternative);
m.Body = multipartAlternative;
//--- text/plain ----------------------------------------------------------------------------------------------------
MIME_Entity entity_text_plain = new MIME_Entity();
MIME_b_Text text_plain = new MIME_b_Text(MIME_MediaTypes.Text.plain);
entity_text_plain.Body = text_plain;
text_plain.SetText(MIME_TransferEncodings.QuotedPrintable, Encoding.UTF8, sHtmlText);
multipartAlternative.BodyParts.Add(entity_text_plain);
//--- text/html ------------------------------------------------------------------------------------------------------
MIME_Entity entity_text_html = new MIME_Entity();
MIME_b_Text text_html = new MIME_b_Text(MIME_MediaTypes.Text.html);
entity_text_html.Body = text_html;
text_html.SetText(MIME_TransferEncodings.QuotedPrintable, Encoding.UTF8, sHtmlText);
multipartAlternative.BodyParts.Add(entity_text_html);
MIME_Encoding_EncodedWord headerwordEncoder = new MIME_Encoding_EncodedWord(MIME_EncodedWordEncoding.Q, Encoding.UTF8);
m.ToStream(stream, headerwordEncoder, Encoding.UTF8);
stream.Position = 0;
SMTP_Client.QuickSendSmartHost(null, from.getString("send_address", "stmp.sina.com"), from.getInt("send_port", 25),
from.getBoolean("is_send_ssl", false), from.getString("account"), PassUtil.Decrypt(from.getString("password")),
from.getString("account"), to, stream);
}
}
/// <summary>
/// Stores MIME entity to the specified file.
/// </summary>
/// <param name="file">File name with path where to store MIME entity.</param>
/// <param name="headerWordEncoder">Header 8-bit words ecnoder. Value null means that words are not encoded.</param>
/// <param name="headerParmetersCharset">Charset to use to encode 8-bit header parameters. Value null means parameters not encoded.</param>
/// <param name="headerReencode">If true always specified encoding is used for header. If false and header field value not modified,
/// original encoding is kept.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>file</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public void ToFile(string file,MIME_Encoding_EncodedWord headerWordEncoder,Encoding headerParmetersCharset,bool headerReencode)
{
if(file == null){
throw new ArgumentNullException("file");
}
if(file == ""){
throw new ArgumentException("Argument 'file' value must be specified.");
}
using(FileStream fs = File.Create(file)){
ToStream(fs,headerWordEncoder,headerParmetersCharset,headerReencode);
}
}
