A POP3 Client in C# .NET

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace Email
{
    /// <summary>
    /// A client that allows for connecting to an email accounts using POP3.
    /// </summary>
    /// <seealso href="http://www.codeproject.com/KB/IP/despop3client.aspx"/>
    public class Pop3Client : IDisposable
    {
        #region Fields

        /// <summary>
        /// Contains the manual reset event that will assist in waiting for an entire email to be
        /// received.
        /// </summary>
        private readonly ManualResetEvent _resetEvent = new ManualResetEvent(false);

        /// <summary>
        /// Contains the email address of the email account that will be opened within the <see cref="_server"/>.
        /// </summary>
        private string _email;

        /// <summary>
        /// Contains the password for the <see cref="_email"/> that will be opened within the <see cref="_server"/>.
        /// </summary>
        private string _emailPassword;

        /// <summary>
        /// Contains the name of the server that contains the <see cref="Email"/> that will be opened.
        /// </summary>
        private string _server;

        #endregion
        #region Properties

        /// <summary>
        /// Gets or sets the email address of the email account that will be opened within the <see cref="Server"/>.
        /// </summary>
        public string Email
        {
            get
            {
                if (_email == null)
                {
                    _email = string.Empty;
                }
                return _email;
            }
            set
            {
                _email = value;
            }
        }

        /// <summary>
        /// Gets or sets the password for the <see cref="Email"/> that will be opened within the <see cref="Server"/>.
        /// </summary>
        public string EmailPassword
        {
            get
            {
                if (_emailPassword == null)
                {
                    _emailPassword = string.Empty;
                }
                return _emailPassword;
            }
            set
            {
                _emailPassword = value;
            }
        }

        /// <summary>
        /// Gets the manual reset event that will assist in waiting for an entire email to be
        /// received.
        /// </summary>
        protected ManualResetEvent ResetEvent
        {
            get { return _resetEvent;  }
        }

        /// <summary>
        /// Gets or sets the name of the server that contains the <see cref="Email"/> that will be opened.
        /// </summary>
        public string Server
        {
            get
            {
                if (_server == null)
                {
                    _server = string.Empty;
                }
                return _server;
            }
            set
            {
                _server = value;
            }
        }

        /// <summary>
        /// Gets or sets the socket that will contain the connection to the server.
        /// </summary>
        protected Socket ServerSocket { set; get; }

        #endregion
        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="Pop3Client"/> class.
        /// </summary>
        public Pop3Client()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Pop3Client"/> class with setting the
        /// <paramref name="email"/>, <paramref name="emailPassword"/>, and <paramref name="server"/>.
        /// </summary>
        /// <param name="email">The email address of the email account that will be opened within the <paramref name="server"/>.</param>
        /// <param name="emailPassword">The password for the <paramref name="email"/> that will be opened within the <paramref name="server"/>.</param>
        /// <param name="server">The name of the server that contains the <paramref name="server"/> that will be opened.</param>
        public Pop3Client(string email, string emailPassword, string server)
        {
            _email = email;
            _emailPassword = emailPassword;
            _server = server;
        }

        #endregion
        #region Methods

        /// <summary>
        /// Deletes the messages within the <see cref="Email"/> account.
        /// </summary>
        /// <param name="message">The message to be deleted.</param>
        /// <exception cref="ArgumentNullException">Thrown if the parameter <paramref name="message"/> is <c>null</c>.</exception>
        /// <remarks>
        /// After calling this function the email message will not be deleted but marked for
        /// deletion.  After this object is <see cref="Dispose"/>, then the email will be 
        /// successfully deleted.
        /// </remarks>
        /// <returns><c>true</c> is returned if the message is successfully marked for deletion; otherwise, <c>false</c>.</returns>
        public bool DeleteMessage(Pop3Message message)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }
            return DeleteMessageAt(message.InboxPosition);
        }

        /// <summary>
        /// Deletes a message at a given position within the <see cref="Email"/> account.
        /// </summary>
        /// <param name="messagePosition">The position of the message that is to be deleted within the <see cref="Email"/> account.</param>
        /// <remarks>
        /// After calling this function the email message at the specified position will not be deleted but marked
        /// for deletion.  After this object is <see cref="Dispose"/>, then the email will be successfully 
        /// deleted.
        /// </remarks>
        /// <returns><c>true</c> is returned if the message is successfully marked for deletion; otherwise, <c>false</c>.</returns>
        public bool DeleteMessageAt(long messagePosition)
        {
            // If the server socket is null then open the email to be read.
            if (ServerSocket == null)
            {
                OpenEmail();
            }

            SendData("dele " + messagePosition);
            var returned = ReadData();
            return Regex.Match(returned, @"^.*\+OK.*$").Success;
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            SendData("quit");
            ServerSocket = null;
        }

        /// <summary>
        /// Returns a total email count without receiving a collection of all the email from the 
        /// <see cref="Email"/> account.
        /// </summary>
        /// <exception cref="Pop3ReceiveException">Thrown if there is a problem converting the POP3 response into a valid email count.</exception>
        /// <returns>The number of email messages within the <see cref="Email"/> account are returned.</returns>
        public long GetEmailMessageCount()
        {
            // If the server socket is null then open the email to be read.
            if (ServerSocket == null)
            {
                OpenEmail();
            }

            SendData("stat");
            var returned = ReadData();

            // Contains the expression to be used when extracting the email count.
            const string expression = @"^.*\+OK[ |	]+([0-9]+)[ |	]+.*$";

            if (Regex.Match(returned, expression).Success)
            {
                long count;
                if (!long.TryParse(Regex.Replace(returned.Replace("\r\n", string.Empty), expression, "$1"), out count))
                {
                    throw new Pop3ReceiveException("The response from the POP3 connection could not be converted into a valid email count: " + returned);
                }
                return count;
            }

            return 0;
        }

        /// <summary>
        /// Returns a collection of all the emails within the specified <see cref="Email"/> account.
        /// </summary>
        /// <exception cref="Pop3MessageException">Thrown if there is a problem creating the collection of messages found in the <see cref="Email"/> account.</exception>
        /// <returns>A collection of all the emails will be returned that are within the email account.</returns>
        public Pop3MessageCollection GetEmailMessages()
        {
            // If the server socket is null then open the email to be read.
            if (ServerSocket == null)
            {
                OpenEmail();
            }

            // Create the collection of messages to be returned.
            var messages = new Pop3MessageCollection();

            // Start reading the messages at the first position.
            var position = 1;

            SendData("list " + position);
            var returned = ReadData();
            while (returned.Length >= 4 && string.CompareOrdinal(returned.Substring(0, 4), "-ERR") != 0)
            {
                messages.Add(GetEmailMessage(position));

                // Increase the position to read the next email message.
                position++;

                // Read the next email message.
                SendData("list " + position);
                returned = ReadData();
            }

            return messages;
        }

        /// <summary>
        /// Initializes the <see cref="ServerSocket"/> of the <see cref="Email"/> account.
        /// </summary>
        /// <exception cref="Pop3ConnectException">Thrown if there is the <see cref="Server"/> is <see cref="string.Empty"/> or <c>null</c>.</exception>
        /// <exception cref="Pop3ConnectException">Thrown if there is a problem connecting to the <see cref="Server"/>.</exception>
        protected void InitializeSocket()
        {
            try
            {
                // Get host related information.
                var hostEntry = Dns.GetHostEntry(Server);

                // Loop through the AddressList to obtain the supported 
                // AddressFamily. This is to avoid an exception that 
                // occurs when the host IP Address is not compatible 
                // with the address family 
                // (typical in the IPv6 case).

                foreach (var address in hostEntry.AddressList)
                {
                    var ipe = new IPEndPoint(address, 110);
                    var socket = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

                    socket.Connect(ipe);

                    if (socket.Connected)
                    {
                        // we have a connection and return this socket...
                        ServerSocket = socket;
                        return;
                    }
                }
            }
            catch (Exception ex)
            {
                // Wrap the connection as a Pop3ConnectionException...
                throw new Pop3ConnectException(ex.ToString(), ex);
            }

            // Since a connection could not be made throw an exception.
            throw new Pop3ConnectException("Error connecting to " + Server);
        }

        /// <summary>
        /// Returns the email message at the specified position within the <see cref="Email"/> account.
        /// </summary>
        /// <param name="position">The position of the email within the <see cref="Email"/> account to read the email.</param>
        /// <returns>The email message that was constructed.</returns>
        protected Pop3Message GetEmailMessage(int position)
        {
            var message = new Pop3Message
                              {
                                  InboxPosition = position
                              };

            // Tell the POP3 Server we want to start reading
            // email from inbox...
            SendData("retr " + message.InboxPosition);
            
            var state = new Pop3StateObject
                            {
                                Buffer = new byte[256],
                                WorkSocket = ServerSocket
                            };

            // This ensures that every time an email is read that it will wait until the "Set" method
            // is called.
            ResetEvent.Reset();

            // Read all the data returned from the email.
            ServerSocket.BeginReceive(state.Buffer, 0, state.Buffer.Length, 0, new AsyncCallback(ReceiveCallback), state);

            // wait until no more data to be read ...
            ResetEvent.WaitOne();

            var returned = state.Data;

            // Parse all the lines within the email.
            var lines = returned.Split(new[] { '\r' });

            var bodyStart = 0;
            var multipartBoundary = string.Empty;
            for (var i = 0; i < lines.Length; i++)
            {
                var currentLine = lines[i].Replace("\n", string.Empty);

                if (string.IsNullOrEmpty(currentLine))
                {
                    bodyStart = i + 1;
                    break;
                }

                if (Regex.Match(currentLine, "^From:.*$").Success)
                {
                    message.From = Pop3Parse.From(currentLine);
                    continue;
                }

                if (Regex.Match(currentLine, "^To:.*$").Success)
                {
                    message.To = Pop3Parse.To(currentLine);
                    continue;
                }

                if (Regex.Match(currentLine, "^Subject:.*$").Success)
                {
                    message.Subject = Pop3Parse.Subject(currentLine);
                    continue;
                }

                if (Regex.Match(currentLine, "^Content-Type:.*$").Success)
                {
                    message.ContentType = Pop3Parse.ContentType(currentLine).Trim();
                    message.IsMultipart = Pop3Parse.IsMultipart(message.ContentType);
                    if (message.IsMultipart)
                    {
                        if (message.ContentType.EndsWith(";"))
                        {
                            // If the boundary definition is on next line...
                            i++;
                            multipartBoundary = Pop3Parse.MultipartBoundary(lines[i].Replace("\n", string.Empty));
                        }
                        else
                        {
                            // If the boundary definition is on same line as the "Content-Type"...
                            multipartBoundary = Pop3Parse.MultipartBoundary(message.ContentType);
                        }
                    }
                }
            }

            // Gets a collection of all the components to the email.
            var messageComponents = new Pop3MessageComponents(lines, bodyStart, string.IsNullOrEmpty(multipartBoundary) ? null : multipartBoundary, message.ContentType);

            // Check to see the the body exists.
            var multipartEnumerator = messageComponents.ComponentEnumerator;
            while (multipartEnumerator.MoveNext())
            {
                var multipart = (Pop3Component)multipartEnumerator.Current;
                message.Components.Add(multipart);

                if (multipart.IsBody)
                {
                    message.Body = multipart.Data;
                }
            }

            return message;
        }

        /// <summary>
        /// Opens the connection to the email server.
        /// </summary>
        protected void OpenEmail()
        {
            // Before attempting to open the email make sure the Server is not null or empty.
            if (string.IsNullOrEmpty(Server))
            {
                throw new Pop3ConnectException("The server was not specified so a connection could not be made.");
            }

            // Before attempting to open the email make sure the Email is not null or empty.
            if (string.IsNullOrEmpty(Email))
            {
                throw new Pop3ConnectException("The email was not specified so a connection could not be made.");
            }

            // Before attempting to open the email make sure the EmailPassword is not null or empty.
            if (string.IsNullOrEmpty(EmailPassword))
            {
                throw new Pop3ConnectException("The email password was not specified so a connection could not be made.");
            }

            // Get a connection to the server.
            InitializeSocket();

            // Read the socket.
            var returned = ReadData();
            if (returned.Length < 3 || string.CompareOrdinal(returned.Substring(0, 3), "+OK") != 0)
            {
                throw new Pop3ReceiveException("An invalid message was received from the POP3 connection after the initial connection was made: " + returned);
            }

            // Send the UserName of the email account.
            SendData("user " + Email);
            returned = ReadData();
            if (returned.Length < 3 || string.CompareOrdinal(returned.Substring(0, 3), "+OK") != 0)
            {
                throw new Pop3ReceiveException("An invalid message was received from the POP3 connection after submitting the email address: " + returned);
            }

            // Send the Password of the email account.
            SendData("pass " + EmailPassword);
            returned = ReadData();
            if (returned.Length < 3 || string.CompareOrdinal(returned.Substring(0, 3), "+OK") != 0)
            {
                throw new Pop3ReceiveException("An invalid message was received from the POP3 connection after submitting the email and the email password: " + returned);
            }
        }

        /// <summary>
        /// Reads the data from the <see cref="ServerSocket"/> until the end is reached.
        /// </summary>
        /// <exception cref="Pop3ReceiveException">Thrown if the <see cref="ServerSocket"/> is <c>null</c>.</exception>
        /// <exception cref="Pop3ReceiveException">Thrown if there is any problems reading the data from the <see cref="ServerSocket"/>.</exception>
        /// <returns>Returns the string value of the information that is to be read on the <see cref="ServerSocket"/>.</returns>
        /// <seealso href="http://www.yoda.arachsys.com/csharp/readbinary.html" />
        protected string ReadData()
        {
            if (ServerSocket == null)
            {
                throw new Pop3ReceiveException("The POP3 connection to the server socket does not exist and cannot be read.");
            }

            try
            {
                var buffer = new byte[32768];
                using (var ms = new MemoryStream())
                {
                    while (true)
                    {
                        var read = ServerSocket.Receive(buffer, buffer.Length, SocketFlags.None);
                        ms.Write(buffer, 0, read);
                        if (read <= 0 || read < buffer.Length)
                        {
                            buffer = ms.ToArray();
                            return Encoding.ASCII.GetString(buffer, 0, buffer.Length);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Pop3ReceiveException("There was a problem receiving the data from the POP3 connection: " + ex.Message, ex);
            }
        }

        /// <summary>
        /// Receives the callback from an asynchronous call.
        /// </summary>
        /// <param name="ar">The asynchronous result.</param>
        private void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                // Retrieve the state object and the client socket 
                // from the asynchronous state object.
                var state = (Pop3StateObject)ar.AsyncState;
                var client = state.WorkSocket;

                // Read data from the remote device.
                var bytesRead = client.EndReceive(ar);
                if (bytesRead > 0)
                {
                    // There might be more data, 
                    // so store the data received so far.
                    state.Data += Encoding.ASCII.GetString(state.Buffer, 0, bytesRead);

                    // Check to see if more data is expected.  A literal "." (or more) followed by
                    // "\r\n" in an email is prefixed with "."...
                    if (!state.Data.EndsWith("\r\n.\r\n"))
                    {
                        ServerSocket.BeginReceive(state.Buffer, 0, state.Buffer.Length, 0, new AsyncCallback(ReceiveCallback), state);
                    }
                    else
                    {
                        // Allow the manual reset to stop waiting.
                        ResetEvent.Set();
                    }
                }
            }
            catch (Exception ex)
            {
                // Allow the manual reset to stop waiting.
                ResetEvent.Set();

                throw new Pop3ReceiveException("There was a RecieveCallback error: " + ex, ex);
            }
        }

        /// <summary>
        /// Sends the data throgh the <see cref="ServerSocket"/>.
        /// </summary>
        /// <param name="data">The data that is to be sent through the <see cref="ServerSocket"/>.</param>
        /// <exception cref="Pop3SendException">Thrown if the <see cref="ServerSocket"/> is <c>null</c>.</exception>
        /// <exception cref="Pop3SendException">Thrown if there is any problems sending the data through the <see cref="ServerSocket"/>.</exception>
        protected void SendData(string data)
        {
            if (ServerSocket == null)
            {
                throw new Pop3SendException("The POP3 connection to the server socket does not exist and cannot send any data through it.");
            }

            try
            {
                // Convert the string data to byte data using ASCII encoding.
                var byteData = Encoding.ASCII.GetBytes(data + "\r\n");

                // Begin sending the data to the remote device.
                ServerSocket.Send(byteData);
            }
            catch (Exception ex)
            {
                throw new Pop3SendException("There was a problem sending the data through the POP3 connection: " + ex, ex);
            }
        }

        #endregion
    }
}

using System;

namespace Email
{
    /// <summary>
    /// The actual email message.
    /// </summary>
    [Serializable]
    public class Pop3Message
    {
        #region Fields

        /// <summary>
        /// Contains a collection of all the components within the email message.
        /// </summary>
        private readonly Pop3ComponentCollection _components = new Pop3ComponentCollection();

        /// <summary>
        /// Contains the body of the email message.
        /// </summary>
        private string _body;

        /// <summary>
        /// Contains the content type of the email message.
        /// </summary>
        private string _contentType;

        /// <summary>
        /// Contains the from email address of the email message.
        /// </summary>
        private string _from;

        /// <summary>
        /// Contains the subject of the email message.
        /// </summary>
        private string _subject;

        /// <summary>
        /// Contains the to email address of the email message.
        /// </summary>
        private string _to;

        #endregion
        #region Properties

        /// <summary>
        /// Gets or sets the body of the email message.
        /// </summary>
        public string Body
        {
            get
            {
                if (_body == null)
                {
                    _body = string.Empty;
                }
                return _body;
            }
            set
            {
                _body = value;
            }
        }

        /// <summary>
        /// Gets or sets a collection of all the components within the email message.
        /// </summary>
        public Pop3ComponentCollection Components
        {
            get { return _components; }
        }

        /// <summary>
        /// Gets or sets the content type of the email message.
        /// </summary>
        public string ContentType
        {
            get
            {
                if (_contentType == null)
                {
                    _contentType = string.Empty;
                }
                return _contentType;
            }
            set
            {
                _contentType = value;
            }
        }

        /// <summary>
        /// Gets or sets the from email address of the email message.
        /// </summary>
        public string From
        {
            get
            {
                if (_from == null)
                {
                    _from = string.Empty;
                }
                return _from;
            }
            set
            {
                _from = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether or not the email message contains multiple parts.
        /// </summary>
        public bool IsMultipart { get; set; }

        /// <summary>
        /// Gets or sets the position of the email within the email account.
        /// </summary>
        public long InboxPosition { get; set; }

        /// <summary>
        /// Gets or sets the subject of the email message.
        /// </summary>
        public string Subject
        {
            get
            {
                if (_subject == null)
                {
                    _subject = string.Empty;
                }
                return _subject;
            }
            set
            {
                _subject = value;
            }
        }

        /// <summary>
        /// Gets or sets the to email address of the email message.
        /// </summary>
        public string To
        {
            get
            {
                if (_to == null)
                {
                    _to = string.Empty;
                }
                return _to;
            }
            set
            {
                _to = value;
            }
        }

        #endregion
    }
}

using System.Net.Sockets;

namespace Email
{
    /// <summary>
    /// Holds the current state of the client socket.
    /// </summary>
    public class Pop3StateObject
    {
        #region Fields

        /// <summary>
        /// Contains the data for the state object.
        /// </summary>
        private string _data;

        #endregion
        #region Properties

        /// <summary>
        /// Get or sets the buffer that is being used by the state object.
        /// </summary>
        public byte[] Buffer { get; set; }

        /// <summary>
        /// Gets or sets the data for the state object.
        /// </summary>
        public string Data
        {
            get
            {
                if (_data == null)
                {
                    _data = string.Empty;
                }
                return _data;
            }
            set
            {
                _data = value;
            }
        }

        /// <summary>
        /// Gets or sets the worker socket that is currently being used.
        /// </summary>
        public Socket WorkSocket { get; set; }

        #endregion
    }
}

using System;
using System.Collections.ObjectModel;

namespace Email
{
    /// <summary>
    /// A collection of POP3 components with the email.
    /// </summary>
    [Serializable]
    public class Pop3ComponentCollection : Collection<Pop3Component>
    {
    }
}

using System;
using System.Collections.ObjectModel;

namespace Email
{
    /// <summary>
    /// A collection of email messages.
    /// </summary>
    [Serializable]
    public class Pop3MessageCollection : Collection<Pop3Message>
    {
    }
}