/// <summary>
/// Parses header field from the specified value.
/// </summary>
/// <param name="value">Header field value. Header field name must be included. For example: 'Content-Type: text/plain'.</param>
/// <returns>Returns parsed header field.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>value</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when header field parsing errors.</exception>
public static MIME_h_ContentType Parse(string value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
// We should not have encoded words here, but some email clients do this, so encoded them if any.
string valueDecoded = MIME_Encoding_EncodedWord.DecodeS(value);
MIME_h_ContentType retVal = new MIME_h_ContentType();
string[] name_value = valueDecoded.Split(new char[] { ':' }, 2);
if (name_value.Length != 2)
{
throw new ParseException("Invalid Content-Type: header field value '" + value + "'.");
}
MIME_Reader r = new MIME_Reader(name_value[1]);
string type = r.Token();
if (type == null)
{
throw new ParseException("Invalid Content-Type: header field value '" + value + "'.");
}
retVal.m_Type = type;
if (r.Char(false) != '/')
{
throw new ParseException("Invalid Content-Type: header field value '" + value + "'.");
}
string subtype = r.Token();
if (subtype == null)
{
throw new ParseException("Invalid Content-Type: header field value '" + value + "'.");
}
retVal.m_SubType = subtype;
if (r.Available > 0)
{
retVal.m_pParameters.Parse(r);
}
retVal.m_ParseValue = value;
retVal.m_IsModified = false;
return(retVal);
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="contentType">Content type.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>contentType</b> is null reference.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public MIME_b_Multipart(MIME_h_ContentType contentType) : base(contentType)
{
if (contentType == null)
{
throw new ArgumentNullException("contentType");
}
if (string.IsNullOrEmpty(contentType.Param_Boundary))
{
throw new ArgumentException("Argument 'contentType' doesn't contain required boundary parameter.");
}
m_pContentType = contentType;
m_pBodyParts = new MIME_EntityCollection();
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="defaultContentType">Default content-type for this body.</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>defaultContentType</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, MIME_h_ContentType defaultContentType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (defaultContentType == null)
{
throw new ArgumentNullException("defaultContentType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
throw new NotImplementedException("Body provider class does not implement required Parse method.");
}
/// <summary>
/// Parses MIME entiry from the specified stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <param name="headerEncoding">Header reading encoding. If not sure UTF-8 is recommended.</param>
/// <param name="defaultContentType">Default content type.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b>,<b>headerEncoding</b> or <b>defaultContentType</b> is null reference.</exception>
internal protected void Parse(SmartStream stream, Encoding headerEncoding, MIME_h_ContentType defaultContentType)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (headerEncoding == null)
{
throw new ArgumentNullException("headerEncoding");
}
if (defaultContentType == null)
{
throw new ArgumentNullException("defaultContentType");
}
m_pHeader.Parse(stream, headerEncoding);
m_pBody = m_pBodyProvider.Parse(this, stream, defaultContentType);
m_pBody.SetParent(this, false);
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="defaultContentType">Default content-type for this body.</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>defaultContentType</b> or <b>strean</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected static new MIME_b Parse(MIME_Entity owner, MIME_h_ContentType defaultContentType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (defaultContentType == null)
{
throw new ArgumentNullException("defaultContentType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
MIME_b_ApplicationPkcs7Mime retVal = new MIME_b_ApplicationPkcs7Mime();
Net_Utils.StreamCopy(stream, retVal.EncodedStream, 32000);
return(retVal);
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="defaultContentType">Default content-type for this body.</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>defaultContentType</b> or <b>stream</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected static new MIME_b Parse(MIME_Entity owner, MIME_h_ContentType defaultContentType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (defaultContentType == null)
{
throw new ArgumentNullException("defaultContentType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
MIME_b_MessageRfc822 retVal = new MIME_b_MessageRfc822();
retVal.m_pMessage = Mail_Message.ParseFromStream(stream);
return(retVal);
}
/// <summary>
/// Parses body from the specified stream
/// </summary>
/// <param name="owner">Owner MIME entity.</param>
/// <param name="defaultContentType">Default content-type for this body.</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>defaultContentType</b> or <b>stream</b> is null reference.</exception>
/// <exception cref="ParseException">Is raised when any parsing errors.</exception>
protected static new MIME_b Parse(MIME_Entity owner, MIME_h_ContentType defaultContentType, SmartStream stream)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (defaultContentType == null)
{
throw new ArgumentNullException("defaultContentType");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
// We need to buffer all body data, otherwise we don't know if we have readed all data
// from stream.
MemoryStream msBuffer = new MemoryStream();
Net_Utils.StreamCopy(stream, msBuffer, 32000);
msBuffer.Position = 0;
SmartStream parseStream = new SmartStream(msBuffer, true);
MIME_b_MessageDeliveryStatus retVal = new MIME_b_MessageDeliveryStatus();
//Pare per-message fields.
retVal.m_pMessageFields.Parse(parseStream);
// Parse per-recipient fields.
while (parseStream.Position - parseStream.BytesInReadBuffer < parseStream.Length)
{
MIME_h_Collection recipientFields = new MIME_h_Collection(new MIME_h_Provider());
recipientFields.Parse(parseStream);
retVal.m_pRecipientBlocks.Add(recipientFields);
}
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.TypeWithSubtype;
try{
if (owner.ContentType != null)
{
mediaType = owner.ContentType.TypeWithSubtype;
}
}
catch {
// Do nothing, content will be MIME_b_Unknown.
mediaType = "unknown/unknown";
}
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
{
bodyType = typeof(MIME_b_Unknown);
}
}
return((MIME_b)bodyType.GetMethod("Parse", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.FlattenHierarchy).Invoke(null, new object[] { owner, defaultContentType, stream }));
}
