/// <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> /// Sets MIME entity parent entity. /// </summary> /// <param name="parent">Parent entity.</param> internal void SetParent(MIME_Entity parent) { m_pParent = parent; }
/// <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> /// 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; }