SMTP Login class

Thanks for this simple mail class. Actually a class that really works... in contrast to System.Net.Mail.SmtpClient (awww how i hate this one! D'Oh! | :doh:

).

Unfortunately your code design is quite unfavorable, so i decided to redesign the class completely. Wink | ;)

Now it has 180 loc (including very detailed documentation) in opposite of the 420 loc your solution had.

Additionally I made 3 fixes:
- added a "TO:"-field in the data section to show the real recipient in the mail client instead of just "undisclosed-recipients:;"
- changed encoding to UTF-8 and specified it in the mail body to show umlaute like äöü and other special characters in the right way on every mail client
- added a name to the EHLO command ("EHLO MailClient") since initiating a connection doesn't work with just "EHLO".

Due to the redesign the class is now used in a slightly different way:

MailClient smtp = new MailClient();
smtp.Connect("server", 25, "username", "password");
//or smtp.Connect("server", 25); if no authentication is needed
smtp.SendMail("from", "to", "subject", "msg");
...
smtp.SendMail("from", "to", "subject", "msg");
smtp.Close();

The main advantage is, that it's possible to send more than one mail per connection which leads to less time and resource usage as well as mail server stress.

Hope anyone might need this class! Again, thanks for the idea behind, Benjamin! Smile | :)

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

namespace YAQv2.Tools
{
public class MailClient
{
/// <summary>
/// Tcp connection used for communication to the server.
/// </summary>
private TcpClient _client;

/// <summary>
/// Network stream used for sending/reading data to/from the server.
/// </summary>
private NetworkStream _netStream;

/// <summary>
/// Encoder used for translating text into bytes and vice versa.
/// </summary>
private static UTF8Encoding _encoder = new UTF8Encoding();

/// <summary>
/// Connects to the mail server. Needs to be called before SendMail().
/// </summary>
/// <param name="server">Server name to connect to.</param>
/// <param name="port">Port to connect to.</param>
internal void Connect(string server, int port)
{
Connect(server, port, null, null);
}

/// <summary>
/// Connects to the mail server including authentication. Needs to be called before SendMail().
/// </summary>
/// <param name="server">Server name to connect to.</param>
/// <param name="port">Port to connect to.</param>
/// <param name="username">The username of the account sending the message.</param>
/// <param name="password">The password of the account sending the message.</param>
internal void Connect(string server, int port, string username, string password)
{
//create new connection
_client = new TcpClient();

try
{
_client.Connect(server, port);
}
catch (SocketException se)
{
throw new Exception("Could not connect to the mail server " + server + ":" + port, se);
}

//set the stream to the mail client
_netStream = _client.GetStream();

//check for established connection
if (!ReadData().StartsWith("220"))
throw new Exception("220: Error connecting to SMTP server.");

//initialize connection
SendData("EHLO MailClient"); //send greeting (ehlo)
if (!ReadData().StartsWith("250")) //check for OK message
throw new Exception("250: Error talking to SMTP server.");

//skip authentication process?
if (username != null && password != null)
{
SendData("AUTH LOGIN"); //send authentication command
if (!ReadData().StartsWith("334 VXNlcm5hbWU6")) //check for user name challenge
throw new Exception("334: Error initializing authentication method of SMTP Server.");

SendData(Convert.ToBase64String(_encoder.GetBytes(username))); //send username (64bit encoded)
if (!ReadData().StartsWith("334 UGFzc3dvcmQ6")) //check for password challenge
throw new Exception("334: Error sending username to SMTP server.");

SendData(Convert.ToBase64String(_encoder.GetBytes(password))); //send password (64bit encoded)
if (!ReadData().StartsWith("235")) //check for authentication successful
throw new Exception("235: Error authenticating to SMTP server.");
}
}

/// <summary>
/// Used to send mail according to SMTP AUTH.
/// </summary>
/// <param name="from">Email address of person sending the mail.</param>
/// <param name="to">Email of recipient.</param>
/// <param name="subject">This is the email subject.</param>
/// <param name="message">The actual message to be sent.</param>
internal void SendMail(string from, string to, string subject, string message)
{
//if connection hasn't been established
if (_client == null || !_client.Connected)
return;

//send email
SendData("MAIL FROM:" + from); //send author of the mail
if (!ReadData().StartsWith("250")) //check for OK message
throw new Exception("250: Error with orgin address: " + from);

SendData("RCPT TO: " + to); //send recipients
if (!ReadData().StartsWith("250")) //check for OK message
throw new Exception("250: Error with destination address: " + to);

SendData("DATA"); //beginn body transmission
if (!ReadData().StartsWith("354")) //check for waiting for "." message
throw new Exception("354: Error while trying to send subject & body.");

SendData("Subject:" + subject); //send subject
SendData("To:" + to); //send recipients
SendData("Content-Type: text/plain; charset=UTF-8"); //set character encoding;
SendData(message); //send the message itself
SendData("."); //end transmission
if (!ReadData().StartsWith("250")) //check for OK message
throw new Exception("250: Error while attempting to close message on server.");
}

/// <summary>
/// Disconnects from the mail server. Needs to be called after SendMail();
/// </summary>
internal void Disconnect()
{
if (_netStream != null)
_netStream.Close();
if (_client != null)
_client.Close();
}

/// <summary>
/// Sends the passed data to the mail server.
/// </summary>
/// <param name="data">Data to be sent.</param>
private void SendData(string data)
{
//convert characters to bytes
data += "\r\n";
byte[] rawData = _encoder.GetBytes(data);

//send data
_netStream.Write(rawData, 0, rawData.Length);
}

/// <summary>
/// Reads data received from the mail server.
/// </summary>
/// <returns>Received data.</returns>
private string ReadData()
{
//check for data
if (!WaitForResponse())
throw new Exception("Server did not respond.");

//read data
int bytesRead;
string data = String.Empty;
byte[] rawData = new byte[1024];

while (_netStream.DataAvailable && (bytesRead = _netStream.Read(rawData, 0, rawData.Length)) > 0)
//convert bytes to characters
data += _encoder.GetString(rawData);

return data;
}

/// <summary>
/// Waits until the mail server responds, but at most 10 seconds.
/// </summary>
/// <returns>Whether the mail server responded or not.</returns>
private bool WaitForResponse()
{
DateTime maxTime = DateTime.Now.AddSeconds(10);
while (!_netStream.DataAvailable && maxTime > DateTime.Now)
Thread.Sleep(100);

return _netStream.DataAvailable;
}
}
}

yo, you need to add "\r\n" before the message(at least for my server anyway)
so the send message line should look as follows...

//Send message
SmtpServer.SendData("\r\n" + message + "\r\n");

hope that helps some people!

Thanks to Benjamin L. Miller for the original code!!!

Not work with exchange server.

True, it may not work with exchange server. But I think the build in mail classes in .Net handle exchange far better than a custom class would.

I'm using a different SMTP class which does aproximately the same thing..... the only thing i took from your class was the AUTH LOGIN part....

for some reason though your code doesnt work ... im assuming it's because you are writing for Web applications, and im doing windows applications.... so that that GetBytes method is diff..... this is how i used it and for some reason i cant authenticate to the server:

Encoder uniEncoder = Encoding.Unicode.GetEncoder();

byteCount = uniEncoder.GetByteCount(username.ToCharArray(), 0, username.ToCharArray().Length, true);
bytes = new Byte[byteCount];
uniEncoder.GetBytes(username.ToCharArray(), 0, username.ToCharArray().Length, bytes, 0, true);

EncodedUser = Convert.ToBase64String(bytes);

Can you help?

adiance

I integrated this into an application that runs in the background and ocassionally sends an SMTP message as needed. I frequently got a server timeout error. (At first I thought it was the Norton Email Proxy.) To resolve the problem, I added the following code as a method of cleanup. Just thought you should include this for basic cleanup.

SendMail.NetworkClass.DisConnect():
try
{
TheStream.Close(); //Close the stream to ensure the server doesn't expect any more communication
TheClient.Close();
return true;
}

Thank you for the good class. I was looking mail functionality that supports authenitcation and I found it her Smile | :)

e.

This class busy waits on the response from the server. Look at this line.

CurTime = CurTime.AddSeconds(10);
while (CurTime > DateTime.Now & SmtpServer.DataWaiting == false)
{
}

That's up to 10 seconds of pegged CPU waiting for network traffic.

Asynchronous IO would be the best way to do it but in this sort of situation where you want to take a shortcut, at least throw in a Thread.Sleep(100) in the loop. That way you're still polling, but only 10 times a second so the impact on CPU is negligible.

How would you add attachments to this script?

RK-----

Hi.

I did a similar class that uses auth login, but I didn't manage to get cram md5 login to work. I did everything described in the RFC documents, but the authentication always fails. Do you or somebody know about this?

Kalme

Oh, btw: don't use GOTOs!

--
http://www.kalme.de

I have never worked with MD5 so really don't have a solution for you.

As for the GOTO.. it was a quick hack so someone could use the class on a server that didn't need auth.. the code for my final release would never contain a GOTO..

Hi,

I wrote a similar class because the SMTP class in the framework doesn't work on NT4. You can find it there : http://dotnet.developpez.com/codessources/SMTP/[^] (it's a french site). I just added the attachments.

I read that the camel(STMP/POP3/IMAP) library will be written in C#. I don't know when.

http://dotnet.developpez.com/codessources/SMTP/[^]

Good,

R. LOPES
Just programmer.

SMTP Login class

Introduction

Using the code

Connecting to the server

Sending the Message

Closing the Message

Points of Interest

History

License

Comments and Discussions