/// <summary>
/// Removes specified MIME entity from the collection.
/// </summary>
/// <param name="entity">MIME entity.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>field</b> is null reference.</exception>
public void Remove(MIME_Entity entity)
{
if (entity == null)
{
throw new ArgumentNullException("field");
}
m_pCollection.Remove(entity);
m_IsModified = true;
}
/// <summary>
/// Inserts a new MIME entity into the collection at the specified location.
/// </summary>
/// <param name="index">The location in the collection where you want to add the MIME entity.</param>
/// <param name="entity">MIME entity.</param>
/// <exception cref="IndexOutOfRangeException">Is raised when <b>index</b> is out of range.</exception>
/// <exception cref="ArgumentNullException">Is raised when <b>entity</b> is null reference.</exception>
public void Insert(int index, MIME_Entity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
m_pCollection.Insert(index, entity);
m_IsModified = true;
}
/// <summary>
/// Adds specified MIME enity to the collection.
/// </summary>
/// <param name="entity">MIME entity.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>entity</b> is null reference.</exception>
public void Add(MIME_Entity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
m_pCollection.Add(entity);
m_IsModified = true;
}
/// <summary>
/// Cleans up any resources being used. This method is thread-safe.
/// </summary>
public void Dispose()
{
lock (this)
{
if (m_IsDisposed)
{
return;
}
m_IsDisposed = true;
m_pHeader = null;
m_pParent = null;
}
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="mediaType">MIME media type. For example: text/plain.</param>
/// <param name="stream">Stream from where to read body.</param>
/// <returns>Returns parsed body.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>, <b>mediaType</b> or <b>stream</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected static MIME_b Parse(MIME_Entity owner, string mediaType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (mediaType == null)
{
throw new ArgumentNullException("mediaType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
throw new NotImplementedException("Body provider class does not implement required Parse method.");
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="mediaType">MIME media type. For example: text/plain.</param>
/// <param name="stream">Stream from where to read body.</param>
/// <returns>Returns parsed body.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>, <b>mediaType</b> or <b>strean</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected new static MIME_b Parse(MIME_Entity owner, string mediaType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (mediaType == null)
{
throw new ArgumentNullException("mediaType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
MIME_b_Video retVal = new MIME_b_Video(mediaType);
Net_Utils.StreamCopy(stream, retVal.EncodedStream, Workaround.Definitions.MaxStreamLineLength);
return retVal;
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="mediaType">MIME media type. For example: text/plain.</param>
/// <param name="stream">Stream from where to read body.</param>
/// <returns>Returns parsed body.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>, <b>mediaType</b> or <b>stream</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected new static MIME_b Parse(MIME_Entity owner, string mediaType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (mediaType == null)
{
throw new ArgumentNullException("mediaType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
MIME_b_Text retVal = new MIME_b_Text(mediaType);
Net_Utils.StreamCopy(stream, retVal.EncodedStream, Workaround.Definitions.MaxStreamLineLength);
return(retVal);
}
/// <summary>
/// Internal body parsing.
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="mediaType">MIME media type. For example: text/plain.</param>
/// <param name="stream">Stream from where to read body.</param>
/// <param name="body">Multipart body instance.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>, <b>mediaType</b>, <b>stream</b> or <b>body</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected static void ParseInternal(MIME_Entity owner,
string mediaType,
SmartStream stream,
MIME_b_Multipart body)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (mediaType == null)
{
throw new ArgumentNullException("mediaType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (owner.ContentType == null || owner.ContentType.Param_Boundary == null)
{
throw new ParseException("Multipart entity has not required 'boundary' parameter.");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
_MultipartReader multipartReader = new _MultipartReader(stream, owner.ContentType.Param_Boundary);
while (multipartReader.Next())
{
MIME_Entity entity = new MIME_Entity();
entity.Parse(new SmartStream(multipartReader, false), body.DefaultBodyPartContentType);
body.m_pBodyParts.Add(entity);
entity.SetParent(owner);
}
body.m_TextPreamble = multipartReader.TextPreamble;
body.m_TextEpilogue = multipartReader.TextEpilogue;
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="mediaType">MIME media type. For example: text/plain.</param>
/// <param name="stream">Stream from where to read body.</param>
/// <returns>Returns parsed body.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>, <b>mediaType</b> or <b>stream</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected new static MIME_b Parse(MIME_Entity owner, string mediaType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (mediaType == null)
{
throw new ArgumentNullException("mediaType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (owner.ContentType == null || owner.ContentType.Param_Boundary == null)
{
throw new ParseException("Multipart entity has not required 'boundary' paramter.");
}
MIME_b_MultipartAlternative retVal = new MIME_b_MultipartAlternative(owner.ContentType);
ParseInternal(owner, mediaType, stream, retVal);
return retVal;
}
/// <summary>
/// Parses MIME entity body from specified stream.
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="stream">Stream from where to parse entity body.</param>
/// <param name="defaultContentType">Default content type.</param>
/// <returns>Returns parsed body.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>owner</b>, <b>strean</b> or <b>defaultContentType</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when header field parsing errors.</exception>
public MIME_b Parse(MIME_Entity owner, SmartStream stream, MIME_h_ContentType defaultContentType)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (defaultContentType == null)
{
throw new ArgumentNullException("defaultContentType");
}
string mediaType = defaultContentType.TypeWithSubype;
string mediaTypeWithParams = defaultContentType.ToString().Split(':')[1].TrimStart(' ');
if (owner.ContentType != null)
{
mediaType = owner.ContentType.TypeWithSubype;
mediaTypeWithParams = owner.ContentType.ToString().Split(':')[1].TrimStart(' ');
}
Type bodyType = null;
// We have exact body provider for specified mediaType.
if (m_pBodyTypes.ContainsKey(mediaType))
{
bodyType = m_pBodyTypes[mediaType];
}
// Use default mediaType.
else
{
// Registered list of mediaTypes are available: http://www.iana.org/assignments/media-types/.
string mediaRootType = mediaType.Split('/')[0].ToLowerInvariant();
if (mediaRootType == "application")
{
bodyType = typeof(MIME_b_Application);
}
else if (mediaRootType == "audio")
{
bodyType = typeof(MIME_b_Audio);
}
else if (mediaRootType == "image")
{
bodyType = typeof(MIME_b_Image);
}
else if (mediaRootType == "message")
{
bodyType = typeof(MIME_b_Message);
}
else if (mediaRootType == "multipart")
{
bodyType = typeof(MIME_b_Multipart);
}
else if (mediaRootType == "text")
{
bodyType = typeof(MIME_b_Text);
}
else if (mediaRootType == "video")
{
bodyType = typeof(MIME_b_Video);
}
else
{
throw new ParseException("Invalid media-type '" + mediaType + "'.");
}
}
return
((MIME_b)
bodyType.GetMethod("Parse",
BindingFlags.Static | BindingFlags.NonPublic |
BindingFlags.FlattenHierarchy).Invoke(null,
new object[] { owner, mediaTypeWithParams, stream }));
}
/// <summary>
/// Sets body parent.
/// </summary>
/// <param name="entity">Owner entity.</param>
internal void SetParent(MIME_Entity entity)
{
m_pEntity = entity;
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="mediaType">MIME media type. For example: text/plain.</param>
/// <param name="stream">Stream from where to read body.</param>
/// <returns>Returns parsed body.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>, <b>mediaType</b> or <b>stream</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected static MIME_b Parse(MIME_Entity owner, string mediaType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (mediaType == null)
{
throw new ArgumentNullException("mediaType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
throw new NotImplementedException("Body provider class does not implement required Parse method.");
}
/// <summary>
/// Internal body parsing.
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="mediaType">MIME media type. For example: text/plain.</param>
/// <param name="stream">Stream from where to read body.</param>
/// <param name="body">Multipart body instance.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>, <b>mediaType</b>, <b>stream</b> or <b>body</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected static void ParseInternal(MIME_Entity owner,
string mediaType,
SmartStream stream,
MIME_b_Multipart body)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (mediaType == null)
{
throw new ArgumentNullException("mediaType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (owner.ContentType == null || owner.ContentType.Param_Boundary == null)
{
throw new ParseException("Multipart entity has not required 'boundary' parameter.");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
_MultipartReader multipartReader = new _MultipartReader(stream, owner.ContentType.Param_Boundary);
while (multipartReader.Next())
{
MIME_Entity entity = new MIME_Entity();
entity.Parse(new SmartStream(multipartReader, false), body.DefaultBodyPartContentType);
body.m_pBodyParts.Add(entity);
entity.SetParent(owner);
}
body.m_TextPreamble = multipartReader.TextPreamble;
body.m_TextEpilogue = multipartReader.TextEpilogue;
}
/// <summary>
/// Sets MIME entity parent entity.
/// </summary>
/// <param name="parent">Parent entity.</param>
internal void SetParent(MIME_Entity parent)
{
m_pParent = parent;
}
/// <summary>
/// Sets body parent.
/// </summary>
/// <param name="entity">Owner entity.</param>
internal void SetParent(MIME_Entity entity)
{
m_pEntity = entity;
}
/// <summary>
/// Removes specified MIME entity from the collection.
/// </summary>
/// <param name="entity">MIME entity.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>field</b> is null reference.</exception>
public void Remove(MIME_Entity entity)
{
if (entity == null)
{
throw new ArgumentNullException("field");
}
m_pCollection.Remove(entity);
m_IsModified = true;
}
/// <summary>
/// Sets MIME entity parent entity.
/// </summary>
/// <param name="parent">Parent entity.</param>
internal void SetParent(MIME_Entity parent)
{
m_pParent = parent;
}
/// <summary>
/// Adds specified MIME enity to the collection.
/// </summary>
/// <param name="entity">MIME entity.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>entity</b> is null reference.</exception>
public void Add(MIME_Entity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
m_pCollection.Add(entity);
m_IsModified = true;
}
/// <summary>
/// Inserts a new MIME entity into the collection at the specified location.
/// </summary>
/// <param name="index">The location in the collection where you want to add the MIME entity.</param>
/// <param name="entity">MIME entity.</param>
/// <exception cref="IndexOutOfRangeException">Is raised when <b>index</b> is out of range.</exception>
/// <exception cref="ArgumentNullException">Is raised when <b>entity</b> is null reference.</exception>
public void Insert(int index, MIME_Entity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
m_pCollection.Insert(index, entity);
m_IsModified = true;
}
/// <summary>
/// Creates attachment entity.
/// </summary>
/// <param name="file">File name with optional path.</param>
/// <returns>Returns created attachment entity.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>file</b> is null reference.</exception>
public static MIME_Entity CreateAttachment(string file)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
MIME_Entity retVal = new MIME_Entity();
MIME_b_Application body = new MIME_b_Application(MIME_MediaTypes.Application.octet_stream);
retVal.Body = body;
body.SetBodyDataFromFile(file, MIME_TransferEncodings.Base64);
retVal.ContentType.Param_Name = Path.GetFileName(file);
FileInfo fileInfo = new FileInfo(file);
MIME_h_ContentDisposition disposition =
new MIME_h_ContentDisposition(MIME_DispositionTypes.Attachment);
disposition.Param_FileName = Path.GetFileName(file);
disposition.Param_Size = fileInfo.Length;
disposition.Param_CreationDate = fileInfo.CreationTime;
disposition.Param_ModificationDate = fileInfo.LastWriteTime;
disposition.Param_ReadDate = fileInfo.LastAccessTime;
retVal.ContentDisposition = disposition;
return retVal;
}
private static bool IsAttachment(MIME_Entity entity)
{
return entity.Body.ContentType != null && entity.Body.ContentType.TypeWithSubype != null
&& entity.ContentDisposition != null && entity.ContentDisposition.DispositionType == MIME_DispositionTypes.Attachment
&& (!string.IsNullOrEmpty(entity.ContentDisposition.Param_FileName) || !string.IsNullOrEmpty(entity.ContentType.Param_Name))
&& entity.Body is MIME_b_SinglepartBase;
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="mediaType">MIME media type. For example: text/plain.</param>
/// <param name="stream">Stream from where to read body.</param>
/// <returns>Returns parsed body.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>, <b>mediaType</b> or <b>stream</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected new static MIME_b Parse(MIME_Entity owner, string mediaType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (mediaType == null)
{
throw new ArgumentNullException("mediaType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
MIME_b_MessageRfc822 retVal = new MIME_b_MessageRfc822();
if (owner.ContentTransferEncoding != null && owner.ContentTransferEncoding.Equals("base64", StringComparison.OrdinalIgnoreCase))
{
Stream decodedDataStream = new MemoryStream();
using (StreamReader reader = new StreamReader(stream))
{
byte[] decoded = Convert.FromBase64String(reader.ReadToEnd());
decodedDataStream.Write(decoded, 0, decoded.Length);
decodedDataStream.Seek(0, SeekOrigin.Begin);
}
//Create base64 decoder
stream = new SmartStream(decodedDataStream,true);
}
retVal.m_pMessage = Mail_Message.ParseFromStream(stream);
return retVal;
}
/// <summary>
/// Cleans up any resources being used. This method is thread-safe.
/// </summary>
public void Dispose()
{
lock (this)
{
if (m_IsDisposed)
{
return;
}
m_IsDisposed = true;
m_pHeader = null;
m_pParent = null;
}
}
/// <summary>
/// Gets if the collection contains specified MIME entity.
/// </summary>
/// <param name="entity">MIME entity.</param>
/// <returns>Returns true if the specified MIME entity exists in the collection, otherwise false.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>entity</b> is null.</exception>
public bool Contains(MIME_Entity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
return m_pCollection.Contains(entity);
}
/// <summary>
/// Parses MIME entity body from specified stream.
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="stream">Stream from where to parse entity body.</param>
/// <param name="defaultContentType">Default content type.</param>
/// <returns>Returns parsed body.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>owner</b>, <b>strean</b> or <b>defaultContentType</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when header field parsing errors.</exception>
public MIME_b Parse(MIME_Entity owner, SmartStream stream, MIME_h_ContentType defaultContentType)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (defaultContentType == null)
{
throw new ArgumentNullException("defaultContentType");
}
string mediaType = defaultContentType.TypeWithSubype;
string mediaTypeWithParams = defaultContentType.ToString().Split(':')[1].TrimStart(' ');
if (owner.ContentType != null)
{
mediaType = owner.ContentType.TypeWithSubype;
mediaTypeWithParams = owner.ContentType.ToString().Split(':')[1].TrimStart(' ');
}
Type bodyType = null;
// We have exact body provider for specified mediaType.
if (m_pBodyTypes.ContainsKey(mediaType))
{
bodyType = m_pBodyTypes[mediaType];
}
// Use default mediaType.
else
{
// Registered list of mediaTypes are available: http://www.iana.org/assignments/media-types/.
string mediaRootType = mediaType.Split('/')[0].ToLowerInvariant();
if (mediaRootType == "application")
{
bodyType = typeof (MIME_b_Application);
}
else if (mediaRootType == "audio")
{
bodyType = typeof (MIME_b_Audio);
}
else if (mediaRootType == "image")
{
bodyType = typeof (MIME_b_Image);
}
else if (mediaRootType == "message")
{
bodyType = typeof (MIME_b_Message);
}
else if (mediaRootType == "multipart")
{
bodyType = typeof (MIME_b_Multipart);
}
else if (mediaRootType == "text")
{
bodyType = typeof (MIME_b_Text);
}
else if (mediaRootType == "video")
{
bodyType = typeof (MIME_b_Video);
}
else
{
throw new ParseException("Invalid media-type '" + mediaType + "'.");
}
}
return
(MIME_b)
bodyType.GetMethod("Parse",
BindingFlags.Static | BindingFlags.NonPublic |
BindingFlags.FlattenHierarchy).Invoke(null,
new object[] { owner, mediaTypeWithParams, stream });
}
private static RequestFileInfo GetAsAttachment(MIME_Entity entity)
{
var attachment = new RequestFileInfo
{
Body = ((MIME_b_SinglepartBase)entity.Body).Data
};
if (!string.IsNullOrEmpty(entity.ContentDisposition.Param_FileName))
{
attachment.Name = entity.ContentDisposition.Param_FileName;
}
else if (!string.IsNullOrEmpty(entity.ContentType.Param_Name))
{
attachment.Name = entity.ContentType.Param_Name;
}
attachment.ContentType = MimeMapping.GetMimeMapping(attachment.Name);
return attachment;
}