public void SendMessage() {
string msg = "";
switch (CurrEmailType) {
case EmailType.PRENOTA:
msg = PrenotaSubject;
FromMailAddress = PrenotaFromAddress;
break;
case EmailType.INFO:
msg = InfoSubject;
FromMailAddress = InfoFromAddress;
break;
}
string subject = string.Format(msg, Message.Nome, DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss"));
string body = string.Format("Nome : {0}\nNumero : {1}\nE-Mail : {2}\nMessaggio :\n{3}", Message.Nome, Message.Telefono, Message.Email, Message.Messaggio);
var message = new MimeMessage();
message.From.Add(FromMailAddress);
message.To.Add(ToAddress);
message.Subject = subject;
message.Body = new TextPart("plain") {Text = body};
try {
using (var client = new SmtpClient()) {
client.Connect("smtp.gmail.com", 465, true);
client.AuthenticationMechanisms.Remove("XOAUTH");
client.Authenticate("*****@*****.**", "At066bn1!");
client.Send(message);
client.Disconnect(true);
}
Result = EmailResult.SUCCESS;
MessageResult = "Messaggio inviato correttamente";
} catch (Exception ex) {
Result = EmailResult.FAIL;
MessageResult = ex.Message;
}
}
/*
* tries to sign a MimeEntity
*/
public static MimeEntity SignEntity(MimeEntity entity, MailboxAddress signer)
{
using (WindowsSecureMimeContext ctx = new WindowsSecureMimeContext(sys.StoreLocation.CurrentUser))
{
return MultipartSigned.Create(ctx, signer, DigestAlgorithm.Sha1, entity);
}
}
public void TestEncodingMailboxWithArabicName()
{
var mailbox = new MailboxAddress ("هل تتكلم اللغة الإنجليزية /العربية؟", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var expected = "=?utf-8?b?2YfZhCDYqtiq2YPZhNmFINin2YTZhNi62Kk=?=\n =?utf-8?b?INin2YTYpdmG2KzZhNmK2LLZitipIC/Yp9mE2LnYsdio2YrYqdif?=\n\t<*****@*****.**>";
var actual = list.ToString (UnixFormatOptions, true);
Assert.AreEqual (expected, actual, "Encoding arabic mailbox did not match expected result: {0}", expected);
Assert.IsTrue (InternetAddressList.TryParse (actual, out list), "Failed to parse arabic mailbox");
Assert.AreEqual (mailbox.Name, list[0].Name);
}
public void TestPgpMimeSigning ()
{
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
var cleartext = new TextPart ("plain");
cleartext.Text = "This is some cleartext that we'll end up signing...";
using (var ctx = new DummyOpenPgpContext ()) {
var multipart = MultipartSigned.Create (ctx, self, DigestAlgorithm.Sha1, cleartext);
Assert.AreEqual (2, multipart.Count, "The multipart/signed has an unexpected number of children.");
var protocol = multipart.ContentType.Parameters["protocol"];
Assert.AreEqual (ctx.SignatureProtocol, protocol, "The multipart/signed protocol does not match.");
Assert.IsInstanceOfType (typeof (TextPart), multipart[0], "The first child is not a text part.");
Assert.IsInstanceOfType (typeof (ApplicationPgpSignature), multipart[1], "The second child is not a detached signature.");
var signatures = multipart.Verify (ctx);
Assert.AreEqual (1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures) {
try {
bool valid = signature.Verify ();
Assert.IsTrue (valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail ("Failed to verify signature: {0}", ex);
}
}
}
}
public void FormPasswordResetEmailModel(User user, string token,
string passwordResetTemplate, IConfiguration configuration)
{
Reciever = new MimeKit.MailboxAddress(user.Email);
Subject = Constants.Constants.PASSWORD_RESET_EMAIL_SUBJECT;
Message = EmailHelper.PasswordResetTemplateGenerator(user, token, passwordResetTemplate, configuration);
}
public void TestSimpleAddrSpec ()
{
var expected = new InternetAddressList ();
var mailbox = new MailboxAddress ("", "");
InternetAddressList result;
string text;
expected.Add (mailbox);
text = "*****@*****.**";
mailbox.Address = "*****@*****.**";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
text = "fejj";
mailbox.Address = "fejj";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
}
public void TestDecodedMailboxHasCorrectCharsetEncoding()
{
var latin1 = Encoding.GetEncoding ("iso-8859-1");
var mailbox = new MailboxAddress (latin1, "Kristoffer Brånemyr", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var encoded = list.ToString (UnixFormatOptions, true);
InternetAddressList parsed;
Assert.IsTrue (InternetAddressList.TryParse (encoded, out parsed), "Failed to parse address");
Assert.AreEqual (latin1.HeaderName, parsed[0].Encoding.HeaderName, "Parsed charset does not match");
}
/*
* returns true if email address can sign email
*/
public static bool CanSign(string email)
{
try
{
MailboxAddress signer = new MailboxAddress("", email);
TextPart entity = new TextPart("text");
using (WindowsSecureMimeContext ctx = new WindowsSecureMimeContext(sys.StoreLocation.CurrentUser))
{
MultipartSigned.Create(ctx, signer, DigestAlgorithm.Sha1, entity);
return true;
}
}
catch
{
return false;
}
}
public void TestArgumentExceptions ()
{
var mailbox = new MailboxAddress ("MimeKit Unit Tests", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (new MailboxAddress ("Example User", "*****@*****.**"));
Assert.Throws<ArgumentNullException> (() => new InternetAddressList (null));
Assert.Throws<ArgumentNullException> (() => list.Add (null));
Assert.Throws<ArgumentNullException> (() => list.AddRange (null));
Assert.Throws<ArgumentNullException> (() => list.CompareTo (null));
Assert.Throws<ArgumentNullException> (() => list.Contains (null));
Assert.Throws<ArgumentNullException> (() => list.CopyTo (null, 0));
Assert.Throws<ArgumentOutOfRangeException> (() => list.CopyTo (new InternetAddress[0], -1));
Assert.Throws<ArgumentNullException> (() => list.IndexOf (null));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, mailbox));
Assert.Throws<ArgumentNullException> (() => list.Insert (0, null));
Assert.Throws<ArgumentNullException> (() => list.Remove (null));
Assert.Throws<ArgumentOutOfRangeException> (() => list.RemoveAt (-1));
Assert.Throws<ArgumentOutOfRangeException> (() => list[-1] = mailbox);
Assert.Throws<ArgumentNullException> (() => list[0] = null);
}
public void TestPgpMimeEncryption()
{
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
var recipients = new List<MailboxAddress> ();
// encrypt to ourselves...
recipients.Add (self);
var cleartext = new TextPart ("plain");
cleartext.Text = "This is some cleartext that we'll end up encrypting...";
using (var ctx = new DummyOpenPgpContext ()) {
var encrypted = MultipartEncrypted.Create (ctx, recipients, cleartext);
//using (var file = File.Create ("pgp-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt (ctx);
Assert.IsInstanceOfType (typeof (TextPart), decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual (cleartext.Text, ((TextPart) decrypted).Text, "Decrypted content is not the same as the original.");
}
}
public void TestMimeMessageSign ()
{
var body = new TextPart ("plain") { Text = "This is some cleartext that we'll end up signing..." };
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
var message = new MimeMessage { Subject = "Test of signing with OpenPGP" };
message.From.Add (self);
message.Body = body;
using (var ctx = new DummyOpenPgpContext ()) {
message.Sign (ctx);
Assert.IsInstanceOf<MultipartSigned> (message.Body);
var multipart = (MultipartSigned) message.Body;
Assert.AreEqual (2, multipart.Count, "The multipart/signed has an unexpected number of children.");
var protocol = multipart.ContentType.Parameters["protocol"];
Assert.AreEqual (ctx.SignatureProtocol, protocol, "The multipart/signed protocol does not match.");
Assert.IsInstanceOf<TextPart> (multipart[0], "The first child is not a text part.");
Assert.IsInstanceOf<ApplicationPgpSignature> (multipart[1], "The second child is not a detached signature.");
var signatures = multipart.Verify (ctx);
Assert.AreEqual (1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures) {
try {
bool valid = signature.Verify ();
Assert.IsTrue (valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail ("Failed to verify signature: {0}", ex);
}
}
}
}
public void MessagesAvailable()
{
RunE2ETest(context => {
string messageSubject = Guid.NewGuid().ToString();
using (SmtpClient smtpClient = new SmtpClient())
{
smtpClient.SslProtocols = System.Security.Authentication.SslProtocols.Tls12;
smtpClient.ServerCertificateValidationCallback = (s, c, h, e) => true;
smtpClient.CheckCertificateRevocation = false;
MimeMessage message = new MimeMessage();
message.To.Add(MailboxAddress.Parse("*****@*****.**"));
message.From.Add(MailboxAddress.Parse("*****@*****.**"));
message.Subject = messageSubject;
message.Body = new TextPart()
{
Text = "Body of end to end test"
};
smtpClient.Connect("localhost", context.SmtpPortNumber, SecureSocketOptions.StartTls, new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
smtpClient.Send(message);
smtpClient.Disconnect(true, new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
}
using (ImapClient imapClient = new ImapClient())
{
imapClient.Connect("localhost", context.ImapPortNumber);
imapClient.Authenticate("user", "password");
imapClient.Inbox.Open(MailKit.FolderAccess.ReadOnly);
var imapMessage = imapClient.Inbox.FirstOrDefault();
Assert.NotNull(imapMessage);
Assert.Equal(messageSubject, imapMessage.Subject);
}
});
}
private void RunSending(IDatabase database, Mailing mailing)
{
int remainingCount = 0;
foreach (var sending in database.Query <Sending>(DC.Equal("mailingid", mailing.Id.Value)))
{
if (sending.Status.Value == SendingStatus.Created)
{
if (_maxMailsCount > 0)
{
_maxMailsCount--;
var header = mailing.Header.Value;
var footer = mailing.Footer.Value;
var htmlText = mailing.HtmlText.Value;
var plainText = mailing.PlainText.Value;
if (header != null)
{
htmlText = HtmlWorker.ConcatHtml(header.HtmlText.Value, htmlText);
plainText = header.PlainText.Value + plainText;
}
if (footer != null)
{
htmlText = HtmlWorker.ConcatHtml(htmlText, footer.HtmlText.Value);
plainText = plainText + footer.PlainText.Value;
}
var translation = new Translation(database);
var translator = new Translator(translation, sending.Address.Value.Contact.Value.Language.Value);
var templator = new Templator(new ContactContentProvider(translator, sending.Address.Value.Contact.Value));
htmlText = templator.Apply(htmlText);
plainText = templator.Apply(plainText);
try
{
var language = sending.Address.Value.Contact.Value.Language.Value;
var from = new MimeKit.MailboxAddress(
mailing.Sender.Value.MailName.Value[language],
mailing.Sender.Value.MailAddress.Value[language]);
var to = new MimeKit.MailboxAddress(
sending.Address.Value.Contact.Value.ShortHand,
sending.Address.Value.Address.Value);
var senderKey = mailing.Sender.Value.GpgKeyId.Value == null ? null :
new GpgPrivateKeyInfo(
mailing.Sender.Value.GpgKeyId.Value,
mailing.Sender.Value.GpgKeyPassphrase.Value);
var content = new Multipart("alternative");
var textPart = new TextPart("plain")
{
Text = plainText
};
textPart.ContentTransferEncoding = ContentEncoding.QuotedPrintable;
content.Add(textPart);
var htmlPart = new TextPart("html")
{
Text = htmlText
};
htmlPart.ContentTransferEncoding = ContentEncoding.QuotedPrintable;
content.Add(htmlPart);
Global.Mail.Send(from, to, senderKey, null, mailing.Subject.Value, content);
sending.Status.Value = SendingStatus.Sent;
sending.SentDate.Value = DateTime.UtcNow;
database.Save(sending);
Journal(database, mailing, sending.Address.Value.Contact.Value,
"MailTask.Journal.Sent",
"Journal entry sent mail",
"Task sent mail {0}",
t => mailing.Title.Value);
}
catch (Exception exception)
{
sending.Status.Value = SendingStatus.Failed;
sending.FailureMessage.Value = exception.Message;
sending.SentDate.Value = DateTime.UtcNow;
database.Save(sending);
Journal(database, mailing, sending.Address.Value.Contact.Value,
"MailTask.Journal.Failed",
"Journal entry sending mail failed",
"Task failed sending mail {0}",
t => mailing.Title.Value);
}
}
else
{
remainingCount++;
}
}
}
if (remainingCount < 1)
{
mailing.Status.Value = MailingStatus.Sent;
mailing.SentDate.Value = DateTime.UtcNow;
database.Save(mailing);
Global.Log.Notice("Mailing {0} has finished sending", mailing.Title);
}
else
{
Global.Log.Notice("Mailing {0} needs to send {1} more mails", mailing.Title, remainingCount);
}
}
/// <summary>
/// Tries to parse the given input buffer into a new <see cref="MimeKit.MailboxAddress"/> instance.
/// </summary>
/// <remarks>
/// Parses a single <see cref="MailboxAddress"/>. If the address is not a mailbox address or
/// there is more than a single mailbox address, then parsing will fail.
/// </remarks>
/// <returns><c>true</c>, if the address was successfully parsed, <c>false</c> otherwise.</returns>
/// <param name="options">The parser options to use.</param>
/// <param name="buffer">The input buffer.</param>
/// <param name="startIndex">The starting index of the input buffer.</param>
/// <param name="mailbox">The parsed mailbox address.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="options"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="buffer"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> is out of range.
/// </exception>
public static bool TryParse(ParserOptions options, byte[] buffer, int startIndex, out MailboxAddress mailbox)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (startIndex < 0 || startIndex >= buffer.Length)
{
throw new ArgumentOutOfRangeException("startIndex");
}
int endIndex = buffer.Length;
int index = startIndex;
if (!TryParse(options, buffer, ref index, endIndex, false, out mailbox))
{
return(false);
}
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false) || index != endIndex)
{
mailbox = null;
return(false);
}
return(true);
}
internal static bool TryParse(ParserOptions options, byte[] text, ref int index, int endIndex, bool throwOnError, out MailboxAddress mailbox)
{
var flags = AddressParserFlags.AllowMailboxAddress;
InternetAddress address;
if (throwOnError)
{
flags |= AddressParserFlags.ThrowOnError;
}
if (!TryParse(options, text, ref index, endIndex, 0, flags, out address))
{
mailbox = null;
return(false);
}
mailbox = (MailboxAddress)address;
return(true);
}
/// <summary>
/// Try to parse the given input buffer into a new <see cref="MailboxAddress"/> instance.
/// </summary>
/// <remarks>
/// Parses a single <see cref="MailboxAddress"/>. If the address is not a mailbox address or
/// there is more than a single mailbox address, then parsing will fail.
/// </remarks>
/// <returns><c>true</c>, if the address was successfully parsed, <c>false</c> otherwise.</returns>
/// <param name="buffer">The input buffer.</param>
/// <param name="startIndex">The starting index of the input buffer.</param>
/// <param name="length">The number of bytes in the input buffer to parse.</param>
/// <param name="mailbox">The parsed mailbox address.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="buffer"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> and <paramref name="length"/> do not specify
/// a valid range in the byte array.
/// </exception>
public static bool TryParse(byte[] buffer, int startIndex, int length, out MailboxAddress mailbox)
{
return(TryParse(ParserOptions.Default, buffer, startIndex, length, out mailbox));
}
/// <summary>
/// Try to parse the given input buffer into a new <see cref="MailboxAddress"/> instance.
/// </summary>
/// <remarks>
/// Parses a single <see cref="MailboxAddress"/>. If the address is not a mailbox address or
/// there is more than a single mailbox address, then parsing will fail.
/// </remarks>
/// <returns><c>true</c>, if the address was successfully parsed, <c>false</c> otherwise.</returns>
/// <param name="options">The parser options to use.</param>
/// <param name="buffer">The input buffer.</param>
/// <param name="startIndex">The starting index of the input buffer.</param>
/// <param name="mailbox">The parsed mailbox address.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="options"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="buffer"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> is out of range.
/// </exception>
public static bool TryParse(ParserOptions options, byte[] buffer, int startIndex, out MailboxAddress mailbox)
{
ParseUtils.ValidateArguments(options, buffer, startIndex);
int endIndex = buffer.Length;
int index = startIndex;
if (!TryParse(options, buffer, ref index, endIndex, false, out mailbox))
{
return(false);
}
if (!ParseUtils.SkipCommentsAndWhiteSpace(buffer, ref index, endIndex, false) || index != endIndex)
{
mailbox = null;
return(false);
}
return(true);
}
/*
* tries to sign and encrypt a MimeEntity
*/
public static MimeEntity SignAndEncryptEntity(MimeEntity entity, MailboxAddress signer, IEnumerable<MailboxAddress> list)
{
using (WindowsSecureMimeContext ctx = new WindowsSecureMimeContext(sys.StoreLocation.CurrentUser))
{
return ApplicationPkcs7Mime.SignAndEncrypt(ctx, signer, DigestAlgorithm.Sha1, list, entity);
}
}
/// <summary>
/// Send the specified message using the supplied sender and recipients.
/// </summary>
/// <remarks>
/// Sends the message by uploading it to an SMTP server using the supplied sender and recipients.
/// </remarks>
/// <param name="options">The formatting options.</param>
/// <param name="message">The message.</param>
/// <param name="sender">The mailbox address to use for sending the message.</param>
/// <param name="recipients">The mailbox addresses that should receive the message.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress reporting mechanism.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="options"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="message"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="sender"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="recipients"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// The <see cref="SmtpClient"/> has been disposed.
/// </exception>
/// <exception cref="ServiceNotConnectedException">
/// The <see cref="SmtpClient"/> is not connected.
/// </exception>
/// <exception cref="ServiceNotAuthenticatedException">
/// Authentication is required before sending a message.
/// </exception>
/// <exception cref="System.InvalidOperationException">
/// <para>A sender has not been specified.</para>
/// <para>-or-</para>
/// <para>No recipients have been specified.</para>
/// </exception>
/// <exception cref="System.NotSupportedException">
/// Internationalized formatting was requested but is not supported by the server.
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// The operation has been canceled.
/// </exception>
/// <exception cref="System.IO.IOException">
/// An I/O error occurred.
/// </exception>
/// <exception cref="SmtpCommandException">
/// The SMTP command failed.
/// </exception>
/// <exception cref="SmtpProtocolException">
/// An SMTP protocol exception occurred.
/// </exception>
public override void Send (FormatOptions options, MimeMessage message, MailboxAddress sender, IEnumerable<MailboxAddress> recipients, CancellationToken cancellationToken = default (CancellationToken), ITransferProgress progress = null)
{
if (options == null)
throw new ArgumentNullException ("options");
if (message == null)
throw new ArgumentNullException ("message");
if (sender == null)
throw new ArgumentNullException ("sender");
if (recipients == null)
throw new ArgumentNullException ("recipients");
var rcpts = recipients.ToList ();
if (rcpts.Count == 0)
throw new InvalidOperationException ("No recipients have been specified.");
Send (options, message, sender, rcpts, cancellationToken, progress);
}
void RcptTo (MimeMessage message, MailboxAddress mailbox, CancellationToken cancellationToken)
{
var command = string.Format ("RCPT TO:<{0}>", mailbox.Address);
if ((capabilities & SmtpCapabilities.Dsn) != 0) {
var notify = GetDeliveryStatusNotifications (message, mailbox);
if (notify.HasValue)
command += " NOTIFY=" + GetNotifyString (notify.Value);
}
if ((capabilities & SmtpCapabilities.Pipelining) != 0) {
QueueCommand (SmtpCommand.RcptTo, command, cancellationToken);
return;
}
ProcessRcptToResponse (SendCommand (command, cancellationToken), mailbox);
}
/// <summary>
/// Try to parse the given text into a new <see cref="MailboxAddress"/> instance.
/// </summary>
/// <remarks>
/// Parses a single <see cref="MailboxAddress"/>. If the address is not a mailbox address or
/// there is more than a single mailbox address, then parsing will fail.
/// </remarks>
/// <returns><c>true</c>, if the address was successfully parsed, <c>false</c> otherwise.</returns>
/// <param name="text">The text.</param>
/// <param name="mailbox">The parsed mailbox address.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="text"/> is <c>null</c>.
/// </exception>
public static bool TryParse(string text, out MailboxAddress mailbox)
{
return(TryParse(ParserOptions.Default, text, out mailbox));
}
/// <summary>
/// Try to parse the given input buffer into a new <see cref="MailboxAddress"/> instance.
/// </summary>
/// <remarks>
/// Parses a single <see cref="MailboxAddress"/>. If the address is not a mailbox address or
/// there is more than a single mailbox address, then parsing will fail.
/// </remarks>
/// <returns><c>true</c>, if the address was successfully parsed, <c>false</c> otherwise.</returns>
/// <param name="buffer">The input buffer.</param>
/// <param name="mailbox">The parsed mailbox address.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="buffer"/> is <c>null</c>.
/// </exception>
public static bool TryParse(byte[] buffer, out MailboxAddress mailbox)
{
return(TryParse(ParserOptions.Default, buffer, out mailbox));
}
void Send (FormatOptions options, MimeMessage message, MailboxAddress sender, IList<MailboxAddress> recipients, CancellationToken cancellationToken, ITransferProgress progress)
{
CheckDisposed ();
if (!IsConnected)
throw new ServiceNotConnectedException ("The SmtpClient is not connected.");
var format = options.Clone ();
format.International = format.International || sender.IsInternational || recipients.Any (x => x.IsInternational);
format.HiddenHeaders.Add (HeaderId.ContentLength);
format.HiddenHeaders.Add (HeaderId.ResentBcc);
format.HiddenHeaders.Add (HeaderId.Bcc);
format.NewLineFormat = NewLineFormat.Dos;
if (format.International && (Capabilities & SmtpCapabilities.UTF8) == 0)
throw new NotSupportedException ("The SMTP server does not support the SMTPUTF8 extension.");
if (format.International && (Capabilities & SmtpCapabilities.EightBitMime) == 0)
throw new NotSupportedException ("The SMTP server does not support the 8BITMIME extension.");
// prepare the message
if ((Capabilities & SmtpCapabilities.BinaryMime) != 0)
message.Prepare (EncodingConstraint.None, MaxLineLength);
else if ((Capabilities & SmtpCapabilities.EightBitMime) != 0)
message.Prepare (EncodingConstraint.EightBit, MaxLineLength);
else
message.Prepare (EncodingConstraint.SevenBit, MaxLineLength);
// figure out which SMTP extensions we need to use
var visitor = new ContentTransferEncodingVisitor (capabilities);
visitor.Visit (message);
var extensions = visitor.SmtpExtensions;
if (format.International)
extensions |= SmtpExtension.UTF8;
try {
// Note: if PIPELINING is supported, MailFrom() and RcptTo() will
// queue their commands instead of sending them immediately.
MailFrom (message, sender, extensions, cancellationToken);
var unique = new HashSet<string> (StringComparer.OrdinalIgnoreCase);
foreach (var recipient in recipients) {
if (unique.Add (recipient.Address))
RcptTo (message, recipient, cancellationToken);
}
// Note: if PIPELINING is supported, this will flush all outstanding
// MAIL FROM and RCPT TO commands to the server and then process all
// of their responses.
FlushCommandQueue (sender, recipients, cancellationToken);
if ((extensions & SmtpExtension.BinaryMime) != 0)
Bdat (format, message, cancellationToken, progress);
else
Data (format, message, cancellationToken, progress);
} catch (ServiceNotAuthenticatedException) {
// do not disconnect
throw;
} catch (SmtpCommandException) {
Reset (cancellationToken);
throw;
} catch {
Disconnect ();
throw;
}
}
internal static bool TryParseMailbox(ParserOptions options, byte[] text, int startIndex, ref int index, int endIndex, string name, int codepage, bool throwOnError, out InternetAddress address)
{
DomainList route = null;
Encoding encoding;
try {
encoding = Encoding.GetEncoding(codepage);
} catch {
encoding = Encoding.UTF8;
}
address = null;
// skip over the '<'
index++;
if (index >= endIndex)
{
if (throwOnError)
{
throw new ParseException(string.Format("Incomplete mailbox at offset {0}", startIndex), startIndex, index);
}
return(false);
}
if (text[index] == (byte)'@')
{
if (!DomainList.TryParse(text, ref index, endIndex, throwOnError, out route))
{
if (throwOnError)
{
throw new ParseException(string.Format("Invalid route in mailbox at offset {0}", startIndex), startIndex, index);
}
return(false);
}
if (index + 1 >= endIndex || text[index] != (byte)':')
{
if (throwOnError)
{
throw new ParseException(string.Format("Incomplete route in mailbox at offset {0}", startIndex), startIndex, index);
}
return(false);
}
index++;
}
string addrspec;
if (!TryParseAddrspec(text, ref index, endIndex, (byte)'>', throwOnError, out addrspec))
{
return(false);
}
if (!ParseUtils.SkipCommentsAndWhiteSpace(text, ref index, endIndex, throwOnError))
{
return(false);
}
if (index >= endIndex || text[index] != (byte)'>')
{
if (options.AddressParserComplianceMode == RfcComplianceMode.Strict)
{
if (throwOnError)
{
throw new ParseException(string.Format("Unexpected end of mailbox at offset {0}", startIndex), startIndex, index);
}
return(false);
}
}
else
{
index++;
}
if (route != null)
{
address = new MailboxAddress(encoding, name, route, addrspec);
}
else
{
address = new MailboxAddress(encoding, name, addrspec);
}
return(true);
}
void FlushCommandQueue (MailboxAddress sender, IList<MailboxAddress> recipients, CancellationToken cancellationToken)
{
if (queued.Count == 0)
return;
try {
var responses = new List<SmtpResponse> ();
Exception rex = null;
int rcpt = 0;
// Note: queued commands are buffered by the stream
Stream.Flush (cancellationToken);
// Note: we need to read all responses from the server before we can process
// them in case any of them have any errors so that we can RSET the state.
try {
for (int i = 0; i < queued.Count; i++)
responses.Add (Stream.ReadResponse (cancellationToken));
} catch (Exception ex) {
// Note: save this exception for later (it may be related to
// an error response for a MAIL FROM or RCPT TO command).
rex = ex;
}
for (int i = 0; i < responses.Count; i++) {
switch (queued[i]) {
case SmtpCommand.MailFrom:
ProcessMailFromResponse (responses[i], sender);
break;
case SmtpCommand.RcptTo:
ProcessRcptToResponse (responses[i], recipients[rcpt++]);
break;
}
}
if (rex != null)
throw new SmtpProtocolException ("Error reading a response from the SMTP server.", rex);
} finally {
queued.Clear ();
}
}
internal static bool TryParse(ParserOptions options, byte[] text, ref int index, int endIndex, bool throwOnError, out InternetAddress address)
{
address = null;
if (!ParseUtils.SkipCommentsAndWhiteSpace(text, ref index, endIndex, throwOnError))
{
return(false);
}
if (index == endIndex)
{
if (throwOnError)
{
throw new ParseException("No address found.", index, index);
}
return(false);
}
// keep track of the start & length of the phrase
int startIndex = index;
int length = 0;
while (index < endIndex && ParseUtils.SkipWord(text, ref index, endIndex, throwOnError))
{
length = index - startIndex;
do
{
if (!ParseUtils.SkipCommentsAndWhiteSpace(text, ref index, endIndex, throwOnError))
{
return(false);
}
// Note: some clients don't quote dots in the name
if (index >= endIndex || text[index] != (byte)'.')
{
break;
}
index++;
} while (true);
}
if (!ParseUtils.SkipCommentsAndWhiteSpace(text, ref index, endIndex, throwOnError))
{
return(false);
}
// specials = "(" / ")" / "<" / ">" / "@" ; Must be in quoted-
// / "," / ";" / ":" / "\" / <"> ; string, to use
// / "." / "[" / "]" ; within a word.
if (index >= endIndex || text[index] == (byte)',' || text[index] == ';')
{
// we've completely gobbled up an addr-spec w/o a domain
byte sentinel = index < endIndex ? text[index] : (byte)',';
string name, addrspec;
// rewind back to the beginning of the local-part
index = startIndex;
if (!TryParseAddrspec(text, ref index, endIndex, sentinel, throwOnError, out addrspec))
{
return(false);
}
ParseUtils.SkipWhiteSpace(text, ref index, endIndex);
if (index < endIndex && text[index] == '(')
{
int comment = index;
if (!ParseUtils.SkipComment(text, ref index, endIndex))
{
if (throwOnError)
{
throw new ParseException(string.Format("Incomplete comment token at offset {0}", comment), comment, index);
}
return(false);
}
comment++;
name = Rfc2047.DecodePhrase(options, text, comment, (index - 1) - comment).Trim();
}
else
{
name = string.Empty;
}
address = new MailboxAddress(name, addrspec);
return(true);
}
if (text[index] == (byte)':')
{
// rfc2822 group address
int codepage = -1;
string name;
if (length > 0)
{
name = Rfc2047.DecodePhrase(options, text, startIndex, length, out codepage);
}
else
{
name = string.Empty;
}
if (codepage == -1)
{
codepage = 65001;
}
return(TryParseGroup(options, text, startIndex, ref index, endIndex, MimeUtils.Unquote(name), codepage, throwOnError, out address));
}
if (text[index] == (byte)'<')
{
// rfc2822 angle-addr token
int codepage = -1;
string name;
if (length > 0)
{
name = Rfc2047.DecodePhrase(options, text, startIndex, length, out codepage);
}
else
{
name = string.Empty;
}
if (codepage == -1)
{
codepage = 65001;
}
return(TryParseMailbox(options, text, startIndex, ref index, endIndex, MimeUtils.Unquote(name), codepage, throwOnError, out address));
}
if (text[index] == (byte)'@')
{
// we're either in the middle of an addr-spec token or we completely gobbled up an addr-spec w/o a domain
string name, addrspec;
// rewind back to the beginning of the local-part
index = startIndex;
if (!TryParseAddrspec(text, ref index, endIndex, (byte)',', throwOnError, out addrspec))
{
return(false);
}
ParseUtils.SkipWhiteSpace(text, ref index, endIndex);
if (index < endIndex && text[index] == '(')
{
int comment = index;
if (!ParseUtils.SkipComment(text, ref index, endIndex))
{
if (throwOnError)
{
throw new ParseException(string.Format("Incomplete comment token at offset {0}", comment), comment, index);
}
return(false);
}
comment++;
name = Rfc2047.DecodePhrase(options, text, comment, (index - 1) - comment).Trim();
}
else
{
name = string.Empty;
}
address = new MailboxAddress(name, addrspec);
return(true);
}
if (throwOnError)
{
throw new ParseException(string.Format("Invalid address token at offset {0}", startIndex), startIndex, index);
}
return(false);
}
internal static bool TryParseMailbox(ParserOptions options, byte[] text, int startIndex, ref int index, int endIndex, string name, int codepage, bool throwOnError, out InternetAddress address)
{
Encoding encoding = Encoding.GetEncoding (codepage);
DomainList route = null;
address = null;
// skip over the '<'
index++;
if (index >= endIndex) {
if (throwOnError)
throw new ParseException (string.Format ("Incomplete mailbox at offset {0}", startIndex), startIndex, index);
return false;
}
if (text[index] == (byte) '@') {
if (!DomainList.TryParse (text, ref index, endIndex, throwOnError, out route)) {
if (throwOnError)
throw new ParseException (string.Format ("Invalid route in mailbox at offset {0}", startIndex), startIndex, index);
return false;
}
if (index + 1 >= endIndex || text[index] != (byte) ':') {
if (throwOnError)
throw new ParseException (string.Format ("Incomplete route in mailbox at offset {0}", startIndex), startIndex, index);
return false;
}
index++;
}
string addrspec;
if (!TryParseAddrspec (text, ref index, endIndex, (byte) '>', throwOnError, out addrspec))
return false;
if (!ParseUtils.SkipCommentsAndWhiteSpace (text, ref index, endIndex, throwOnError))
return false;
if (index >= endIndex || text[index] != (byte) '>') {
if (options.AddressParserComplianceMode == RfcComplianceMode.Strict) {
if (throwOnError)
throw new ParseException (string.Format ("Unexpected end of mailbox at offset {0}", startIndex), startIndex, index);
return false;
}
} else {
index++;
}
if (route != null)
address = new MailboxAddress (encoding, name, route, addrspec);
else
address = new MailboxAddress (encoding, name, addrspec);
return true;
}
internal static bool TryParse(ParserOptions options, byte[] text, ref int index, int endIndex, bool throwOnError, out InternetAddress address)
{
address = null;
if (!ParseUtils.SkipCommentsAndWhiteSpace (text, ref index, endIndex, throwOnError))
return false;
if (index == endIndex) {
if (throwOnError)
throw new ParseException ("No address found.", index, index);
return false;
}
// keep track of the start & length of the phrase
int startIndex = index;
int length = 0;
while (index < endIndex && ParseUtils.Skip8bitWord (text, ref index, endIndex, throwOnError)) {
length = index - startIndex;
do {
if (!ParseUtils.SkipCommentsAndWhiteSpace (text, ref index, endIndex, throwOnError))
return false;
// Note: some clients don't quote dots in the name
if (index >= endIndex || text[index] != (byte) '.')
break;
index++;
} while (true);
}
if (!ParseUtils.SkipCommentsAndWhiteSpace (text, ref index, endIndex, throwOnError))
return false;
// specials = "(" / ")" / "<" / ">" / "@" ; Must be in quoted-
// / "," / ";" / ":" / "\" / <"> ; string, to use
// / "." / "[" / "]" ; within a word.
if (index >= endIndex || text[index] == (byte) ',' || text[index] == ';') {
// we've completely gobbled up an addr-spec w/o a domain
byte sentinel = index < endIndex ? text[index] : (byte) ',';
string name, addrspec;
// rewind back to the beginning of the local-part
index = startIndex;
if (!TryParseAddrspec (text, ref index, endIndex, sentinel, throwOnError, out addrspec))
return false;
ParseUtils.SkipWhiteSpace (text, ref index, endIndex);
if (index < endIndex && text[index] == '(') {
int comment = index;
if (!ParseUtils.SkipComment (text, ref index, endIndex)) {
if (throwOnError)
throw new ParseException (string.Format ("Incomplete comment token at offset {0}", comment), comment, index);
return false;
}
comment++;
name = Rfc2047.DecodePhrase (options, text, comment, (index - 1) - comment).Trim ();
} else {
name = string.Empty;
}
address = new MailboxAddress (name, addrspec);
return true;
}
if (text[index] == (byte) ':') {
// rfc2822 group address
int codepage = -1;
string name;
if (length > 0) {
name = Rfc2047.DecodePhrase (options, text, startIndex, length, out codepage);
} else {
name = string.Empty;
}
if (codepage == -1)
codepage = 65001;
return TryParseGroup (options, text, startIndex, ref index, endIndex, MimeUtils.Unquote (name), codepage, throwOnError, out address);
}
if (text[index] == (byte) '<') {
// rfc2822 angle-addr token
int codepage = -1;
string name;
if (length > 0) {
name = Rfc2047.DecodePhrase (options, text, startIndex, length, out codepage);
} else {
name = string.Empty;
}
if (codepage == -1)
codepage = 65001;
return TryParseMailbox (options, text, startIndex, ref index, endIndex, MimeUtils.Unquote (name), codepage, throwOnError, out address);
}
if (text[index] == (byte) '@') {
// we're either in the middle of an addr-spec token or we completely gobbled up an addr-spec w/o a domain
string name, addrspec;
// rewind back to the beginning of the local-part
index = startIndex;
if (!TryParseAddrspec (text, ref index, endIndex, (byte) ',', throwOnError, out addrspec))
return false;
ParseUtils.SkipWhiteSpace (text, ref index, endIndex);
if (index < endIndex && text[index] == '(') {
int comment = index;
if (!ParseUtils.SkipComment (text, ref index, endIndex)) {
if (throwOnError)
throw new ParseException (string.Format ("Incomplete comment token at offset {0}", comment), comment, index);
return false;
}
comment++;
name = Rfc2047.DecodePhrase (options, text, comment, (index - 1) - comment).Trim ();
} else {
name = string.Empty;
}
address = new MailboxAddress (name, addrspec);
return true;
}
if (throwOnError)
throw new ParseException (string.Format ("Invalid address token at offset {0}", startIndex), startIndex, index);
return false;
}
/// <summary>
/// Tries to parse the given input buffer into a new <see cref="MimeKit.MailboxAddress"/> instance.
/// </summary>
/// <remarks>
/// Parses a single <see cref="MailboxAddress"/>. If the the address is not a mailbox address or
/// there is more than a single mailbox address, then parsing will fail.
/// </remarks>
/// <returns><c>true</c>, if the address was successfully parsed, <c>false</c> otherwise.</returns>
/// <param name="options">The parser options to use.</param>
/// <param name="buffer">The input buffer.</param>
/// <param name="startIndex">The starting index of the input buffer.</param>
/// <param name="mailbox">The parsed mailbox address.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="options"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="buffer"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> is out of range.
/// </exception>
public static bool TryParse(ParserOptions options, byte[] buffer, int startIndex, out MailboxAddress mailbox)
{
InternetAddress address;
if (!InternetAddress.TryParse(options, buffer, startIndex, out address))
{
mailbox = null;
return(false);
}
mailbox = address as MailboxAddress;
return(mailbox != null);
}
static void ProcessRcptToResponse(SmtpResponse response, MailboxAddress mailbox)
{
switch (response.StatusCode) {
case SmtpStatusCode.UserNotLocalWillForward:
case SmtpStatusCode.Ok:
break;
case SmtpStatusCode.UserNotLocalTryAlternatePath:
case SmtpStatusCode.MailboxNameNotAllowed:
case SmtpStatusCode.MailboxUnavailable:
case SmtpStatusCode.MailboxBusy:
throw new SmtpCommandException (SmtpErrorCode.RecipientNotAccepted, response.StatusCode, mailbox, response.Response);
case SmtpStatusCode.AuthenticationRequired:
throw new UnauthorizedAccessException (response.Response);
default:
throw new SmtpCommandException (SmtpErrorCode.UnexpectedStatusCode, response.StatusCode, response.Response);
}
}
void FlushCommandQueue(MailboxAddress sender, IList<MailboxAddress> recipients, CancellationToken cancellationToken)
{
if (queued.Count == 0)
return;
try {
var responses = new List<SmtpResponse> ();
int rcpt = 0;
int nread;
queue.Position = 0;
while ((nread = queue.Read (input, 0, input.Length)) > 0) {
cancellationToken.ThrowIfCancellationRequested ();
stream.Write (input, 0, nread);
logger.LogClient (input, 0, nread);
}
// Note: we need to read all responses from the server before we can process
// them in case any of them have any errors so that we can RSET the state.
for (int i = 0; i < queued.Count; i++)
responses.Add (ReadResponse (cancellationToken));
for (int i = 0; i < queued.Count; i++) {
switch (queued [i]) {
case SmtpCommand.MailFrom:
ProcessMailFromResponse (responses[i], sender);
break;
case SmtpCommand.RcptTo:
ProcessRcptToResponse (responses[i], recipients[rcpt++]);
break;
}
}
} finally {
queue.SetLength (0);
queued.Clear ();
}
}
static string GetMailFromCommand(MailboxAddress mailbox, SmtpExtension extensions)
{
if ((extensions & SmtpExtension.BinaryMime) != 0)
return string.Format ("MAIL FROM:<{0}> BODY=BINARYMIME", mailbox.Address);
if ((extensions & SmtpExtension.EightBitMime) != 0)
return string.Format ("MAIL FROM:<{0}> BODY=8BITMIME", mailbox.Address);
return string.Format ("MAIL FROM:<{0}>", mailbox.Address);
}
static void ProcessMailFromResponse(SmtpResponse response, MailboxAddress mailbox)
{
switch (response.StatusCode) {
case SmtpStatusCode.Ok:
break;
case SmtpStatusCode.MailboxNameNotAllowed:
case SmtpStatusCode.MailboxUnavailable:
throw new SmtpCommandException (SmtpErrorCode.SenderNotAccepted, response.StatusCode, mailbox, response.Response);
case SmtpStatusCode.AuthenticationRequired:
throw new UnauthorizedAccessException (response.Response);
default:
throw new SmtpCommandException (SmtpErrorCode.UnexpectedStatusCode, response.StatusCode, response.Response);
}
}
void Send(MimeMessage message, MailboxAddress sender, IList<MailboxAddress> recipients, CancellationToken cancellationToken)
{
CheckDisposed ();
if (!IsConnected)
throw new InvalidOperationException ("The SmtpClient is not connected.");
var extensions = PrepareMimeEntity (message);
try {
// Note: if PIPELINING is supported, MailFrom() and RcptTo() will
// queue their commands instead of sending them immediately.
MailFrom (sender, extensions, cancellationToken);
foreach (var recipient in recipients)
RcptTo (recipient, cancellationToken);
// Note: if PIPELINING is supported, this will flush all outstanding
// MAIL FROM and RCPT TO commands to the server and then process all
// of their responses.
FlushCommandQueue (sender, recipients, cancellationToken);
Data (message, cancellationToken);
} catch (UnauthorizedAccessException) {
// do not disconnect
throw;
} catch (SmtpCommandException) {
Reset (cancellationToken);
throw;
} catch {
Disconnect ();
throw;
}
}
/// <summary>
/// Send the specified message using the supplied sender and recipients.
/// </summary>
/// <remarks>
/// Sends the message by uploading it to an SMTP server using the supplied sender and recipients.
/// </remarks>
/// <param name="message">The message.</param>
/// <param name="sender">The mailbox address to use for sending the message.</param>
/// <param name="recipients">The mailbox addresses that should receive the message.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="message"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="sender"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="recipients"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// The <see cref="SmtpClient"/> has been disposed.
/// </exception>
/// <exception cref="System.InvalidOperationException">
/// <para>The <see cref="SmtpClient"/> is not connected.</para>
/// <para>-or-</para>
/// <para>A sender has not been specified.</para>
/// <para>-or-</para>
/// <para>No recipients have been specified.</para>
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// The operation has been canceled.
/// </exception>
/// <exception cref="System.UnauthorizedAccessException">
/// Authentication is required before sending a message.
/// </exception>
/// <exception cref="System.IO.IOException">
/// An I/O error occurred.
/// </exception>
/// <exception cref="SmtpCommandException">
/// The SMTP command failed.
/// </exception>
/// <exception cref="SmtpProtocolException">
/// An SMTP protocol exception occurred.
/// </exception>
public void Send(MimeMessage message, MailboxAddress sender, IEnumerable<MailboxAddress> recipients, CancellationToken cancellationToken = default (CancellationToken))
{
if (message == null)
throw new ArgumentNullException ("message");
if (sender == null)
throw new ArgumentNullException ("sender");
if (recipients == null)
throw new ArgumentNullException ("recipients");
var rcpts = recipients.ToList ();
if (rcpts.Count == 0)
throw new InvalidOperationException ("No recipients have been specified.");
Send (message, sender, rcpts, cancellationToken);
}
void MailFrom(MailboxAddress mailbox, SmtpExtension extensions, CancellationToken cancellationToken)
{
var command = GetMailFromCommand (mailbox, extensions);
if ((capabilities & SmtpCapabilities.Pipelining) != 0) {
QueueCommand (SmtpCommand.MailFrom, command);
return;
}
ProcessMailFromResponse (SendCommand (command, cancellationToken), mailbox);
}
void RcptTo(MailboxAddress mailbox, CancellationToken cancellationToken)
{
var command = string.Format ("RCPT TO:<{0}>", mailbox.Address);
if ((capabilities & SmtpCapabilities.Pipelining) != 0) {
QueueCommand (SmtpCommand.RcptTo, command);
return;
}
ProcessRcptToResponse (SendCommand (command, cancellationToken), mailbox);
}
void HeadersChanged (object o, HeaderListChangedEventArgs e)
{
InternetAddressList list;
InternetAddress address;
byte[] rawValue;
int index = 0;
switch (e.Action) {
case HeaderListChangedAction.Added:
if (addresses.TryGetValue (e.Header.Field, out list)) {
AddAddresses (e.Header, list);
break;
}
rawValue = e.Header.RawValue;
switch (e.Header.Id) {
case HeaderId.MimeVersion:
MimeUtils.TryParse (rawValue, 0, rawValue.Length, out version);
break;
case HeaderId.References:
references.Changed -= ReferencesChanged;
foreach (var msgid in MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length))
references.Add (msgid);
references.Changed += ReferencesChanged;
break;
case HeaderId.InReplyTo:
inreplyto = MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length).FirstOrDefault ();
break;
case HeaderId.ResentMessageId:
resentMessageId = MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length).FirstOrDefault ();
break;
case HeaderId.MessageId:
messageId = MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length).FirstOrDefault ();
break;
case HeaderId.ResentSender:
if (InternetAddress.TryParse (Headers.Options, rawValue, ref index, rawValue.Length, false, out address))
resentSender = address as MailboxAddress;
break;
case HeaderId.Sender:
if (InternetAddress.TryParse (Headers.Options, rawValue, ref index, rawValue.Length, false, out address))
sender = address as MailboxAddress;
break;
case HeaderId.ResentDate:
DateUtils.TryParse (rawValue, 0, rawValue.Length, out resentDate);
break;
case HeaderId.Importance:
switch (e.Header.Value.ToLowerInvariant ().Trim ()) {
case "high": importance = MessageImportance.High; break;
case "low": importance = MessageImportance.Low; break;
default: importance = MessageImportance.Normal; break;
}
break;
case HeaderId.Priority:
switch (e.Header.Value.ToLowerInvariant ().Trim ()) {
case "non-urgent": priority = MessagePriority.NonUrgent; break;
case "urgent": priority = MessagePriority.Urgent; break;
default: priority = MessagePriority.Normal; break;
}
break;
case HeaderId.Date:
DateUtils.TryParse (rawValue, 0, rawValue.Length, out date);
break;
}
break;
case HeaderListChangedAction.Changed:
case HeaderListChangedAction.Removed:
if (addresses.TryGetValue (e.Header.Field, out list)) {
ReloadAddressList (e.Header.Id, list);
break;
}
ReloadHeader (e.Header.Id);
break;
case HeaderListChangedAction.Cleared:
foreach (var kvp in addresses) {
kvp.Value.Changed -= InternetAddressListChanged;
kvp.Value.Clear ();
kvp.Value.Changed += InternetAddressListChanged;
}
references.Changed -= ReferencesChanged;
references.Clear ();
references.Changed += ReferencesChanged;
importance = MessageImportance.Normal;
priority = MessagePriority.Normal;
resentMessageId = null;
resentSender = null;
inreplyto = null;
messageId = null;
version = null;
sender = null;
break;
default:
throw new ArgumentOutOfRangeException ();
}
}
void ReloadHeader (HeaderId id)
{
if (id == HeaderId.Unknown)
return;
switch (id) {
case HeaderId.ResentMessageId:
resentMessageId = null;
break;
case HeaderId.ResentSender:
resentSender = null;
break;
case HeaderId.ResentDate:
resentDate = DateTimeOffset.MinValue;
break;
case HeaderId.References:
references.Changed -= ReferencesChanged;
references.Clear ();
references.Changed += ReferencesChanged;
break;
case HeaderId.InReplyTo:
inreplyto = null;
break;
case HeaderId.MessageId:
messageId = null;
break;
case HeaderId.Sender:
sender = null;
break;
case HeaderId.Importance:
importance = MessageImportance.Normal;
break;
case HeaderId.Priority:
priority = MessagePriority.Normal;
break;
case HeaderId.Date:
date = DateTimeOffset.MinValue;
break;
}
foreach (var header in Headers) {
if (header.Id != id)
continue;
var rawValue = header.RawValue;
InternetAddress address;
int index = 0;
switch (id) {
case HeaderId.MimeVersion:
if (MimeUtils.TryParse (rawValue, 0, rawValue.Length, out version))
return;
break;
case HeaderId.References:
references.Changed -= ReferencesChanged;
foreach (var msgid in MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length))
references.Add (msgid);
references.Changed += ReferencesChanged;
break;
case HeaderId.InReplyTo:
inreplyto = MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length).FirstOrDefault ();
break;
case HeaderId.ResentMessageId:
resentMessageId = MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length).FirstOrDefault ();
if (resentMessageId != null)
return;
break;
case HeaderId.MessageId:
messageId = MimeUtils.EnumerateReferences (rawValue, 0, rawValue.Length).FirstOrDefault ();
if (messageId != null)
return;
break;
case HeaderId.ResentSender:
if (InternetAddress.TryParse (Headers.Options, rawValue, ref index, rawValue.Length, false, out address))
resentSender = address as MailboxAddress;
if (resentSender != null)
return;
break;
case HeaderId.Sender:
if (InternetAddress.TryParse (Headers.Options, rawValue, ref index, rawValue.Length, false, out address))
sender = address as MailboxAddress;
if (sender != null)
return;
break;
case HeaderId.ResentDate:
if (DateUtils.TryParse (rawValue, 0, rawValue.Length, out resentDate))
return;
break;
case HeaderId.Importance:
switch (header.Value.ToLowerInvariant ().Trim ()) {
case "high": importance = MessageImportance.High; break;
case "low": importance = MessageImportance.Low; break;
default: importance = MessageImportance.Normal; break;
}
break;
case HeaderId.Priority:
switch (header.Value.ToLowerInvariant ().Trim ()) {
case "non-urgent": priority = MessagePriority.NonUrgent; break;
case "urgent": priority = MessagePriority.Urgent; break;
default: priority = MessagePriority.Normal; break;
}
break;
case HeaderId.Date:
if (DateUtils.TryParse (rawValue, 0, rawValue.Length, out date))
return;
break;
}
}
}
/// <summary>
/// Gets the <see cref="CmsSigner"/> for the specified mailbox.
/// </summary>
/// <returns>A <see cref="CmsSigner"/>.</returns>
/// <param name="mailbox">The mailbox.</param>
/// <param name="digestAlgo">The preferred digest algorithm.</param>
/// <exception cref="CertificateNotFoundException">
/// A certificate for the specified <paramref name="mailbox"/> could not be found.
/// </exception>
protected override CmsSigner GetCmsSigner (MailboxAddress mailbox, DigestAlgorithm digestAlgo)
{
var now = DateTime.Now;
foreach (var certificate in certificates) {
AsymmetricKeyParameter key;
if (certificate.NotBefore > now || certificate.NotAfter < now)
continue;
var keyUsage = certificate.GetKeyUsageFlags ();
if (keyUsage != 0 && (keyUsage & SecureMimeContext.DigitalSignatureKeyUsageFlags) == 0)
continue;
if (!keys.TryGetValue (certificate, out key))
continue;
if (certificate.GetSubjectEmailAddress () == mailbox.Address) {
var signer = new CmsSigner (certificate, key);
signer.DigestAlgorithm = digestAlgo;
return signer;
}
}
throw new CertificateNotFoundException (mailbox, "A valid signing certificate could not be found.");
}
/// <summary>
/// Gets the <see cref="CmsRecipient"/> for the specified mailbox.
/// </summary>
/// <returns>A <see cref="CmsRecipient"/>.</returns>
/// <param name="mailbox">The mailbox.</param>
/// <exception cref="CertificateNotFoundException">
/// A certificate for the specified <paramref name="mailbox"/> could not be found.
/// </exception>
protected override CmsRecipient GetCmsRecipient (MailboxAddress mailbox)
{
var now = DateTime.Now;
foreach (var certificate in certificates) {
if (certificate.NotBefore > now || certificate.NotAfter < now)
continue;
var keyUsage = certificate.GetKeyUsageFlags ();
if (keyUsage != 0 && (keyUsage & X509KeyUsageFlags.KeyEncipherment) == 0)
continue;
if (certificate.GetSubjectEmailAddress () == mailbox.Address) {
var recipient = new CmsRecipient (certificate);
EncryptionAlgorithm[] algorithms;
if (capabilities.TryGetValue (certificate, out algorithms))
recipient.EncryptionAlgorithms = algorithms;
return recipient;
}
}
throw new CertificateNotFoundException (mailbox, "A valid certificate could not be found.");
}
public IActionResult Submit(ContactForm form)
{
if (!ModelState.IsValid)
return View("Index", form);
var emailMessage = new MimeMessage();
var address = new MailboxAddress(Settings.Title, Settings.EmailFromAndTo);
emailMessage.From.Add(address);
emailMessage.To.Add(address);
emailMessage.Subject = Settings.EmailSubject;
var message = "Name: " + form.Name + Environment.NewLine
+ "Company: " + form.Company + Environment.NewLine
+ form.PreferredMethod + ": " + form.Email + form.Phone + Environment.NewLine
+ "Message:" + Environment.NewLine
+ form.Message;
emailMessage.Body = new TextPart("plain") { Text = message };
using (var client = new SmtpClient())
{
client.Connect(Settings.EmailServer, 465);
client.Authenticate(Settings.EmailUser, Cache.Config["EmailPassword"]);
client.Send(emailMessage);
client.Disconnect(true);
}
return View("Thanks");
}