?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-06 Jb Evain <jbevain@novell.com>
[mcs.git] / class / System / System.Net.Mail / SmtpClient.cs
blob8fe2b6ae83df9d688041155c05132b316e178951
1 //
2 // System.Net.Mail.SmtpClient.cs
3 //
4 // Author:
5 // Tim Coleman (tim@timcoleman.com)
6 //
7 // Copyright (C) Tim Coleman, 2004
8 //
9
10 //
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
18 //
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
21 //
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30
31 #if NET_2_0
32
33 #if SECURITY_DEP
34 extern alias PrebuiltSystem;
35 #endif
36
37 using System;
38 using System.Collections.Generic;
39 using System.ComponentModel;
40 using System.Globalization;
41 using System.IO;
42 using System.Net;
43 using System.Net.Mime;
44 using System.Net.Sockets;
45 using System.Security.Cryptography.X509Certificates;
46 using System.Text;
47 using System.Threading;
48 using System.Reflection;
49 using System.Net.Configuration;
50 using System.Configuration;
51 using System.Net.Security;
52 using System.Security.Authentication;
53
54 #if SECURITY_DEP
55 using X509CertificateCollection = PrebuiltSystem::System.Security.Cryptography.X509Certificates.X509CertificateCollection;
56 #endif
57
58 namespace System.Net.Mail {
59 public class SmtpClient
60 {
61 #region Fields
62
63 string host;
64 int port;
65 int timeout = 100000;
66 ICredentialsByHost credentials;
67 string pickupDirectoryLocation;
68 SmtpDeliveryMethod deliveryMethod;
69 bool enableSsl;
70 #if SECURITY_DEP
71 X509CertificateCollection clientCertificates;
72 #endif
73
74 TcpClient client;
75 Stream stream;
76 StreamWriter writer;
77 StreamReader reader;
78 int boundaryIndex;
79 MailAddress defaultFrom;
80
81 MailMessage messageInProcess;
82
83 BackgroundWorker worker;
84 object user_async_state;
85
86 // ESMTP state
87 [Flags]
88 enum AuthMechs {
89 None = 0,
90 CramMD5 = 0x01,
91 DigestMD5 = 0x02,
92 GssAPI = 0x04,
93 Kerberos4 = 0x08,
94 Login = 0x10,
95 Plain = 0x20,
96 }
97
98 class CancellationException : Exception
99 {
100 }
101
102 AuthMechs authMechs = AuthMechs.None;
103 Mutex mutex = new Mutex ();
104
105 #endregion // Fields
106
107 #region Constructors
108
109 public SmtpClient ()
110 : this (null, 0)
111 {
112 }
113
114 public SmtpClient (string host)
115 : this (host, 0)
116 {
117 }
118
119 public SmtpClient (string host, int port) {
120 #if CONFIGURATION_DEP
121 SmtpSection cfg = (SmtpSection) ConfigurationManager.GetSection ("system.net/mailSettings/smtp");
122
123 if (cfg != null) {
124 this.host = cfg.Network.Host;
125 this.port = cfg.Network.Port;
126 TargetName = cfg.Network.TargetName;
127 if (this.TargetName == null)
128 TargetName = "SMTPSVC/" + (host != null ? host : "");
129
130
131 if (cfg.Network.UserName != null) {
132 string password = String.Empty;
133
134 if (cfg.Network.Password != null)
135 password = cfg.Network.Password;
136
137 Credentials = new CCredentialsByHost (cfg.Network.UserName, password);
138 }
139
140 if (cfg.From != null)
141 defaultFrom = new MailAddress (cfg.From);
142 }
143 #else
144 // Just to eliminate the warning, this codepath does not end up in production.
145 defaultFrom = null;
146 #endif
147
148 if (!String.IsNullOrEmpty (host))
149 this.host = host;
150
151 if (port != 0)
152 this.port = port;
153 }
154
155 #endregion // Constructors
156
157 #region Properties
158
159 #if SECURITY_DEP
160 [MonoTODO("Client certificates not used")]
161 public X509CertificateCollection ClientCertificates {
162 get {
163 if (clientCertificates == null)
164 clientCertificates = new X509CertificateCollection ();
165 return clientCertificates;
166 }
167 }
168 #endif
169
170 #if NET_4_0
171 public
172 #endif
173 string TargetName { get; set; }
174
175 public ICredentialsByHost Credentials {
176 get { return credentials; }
177 set {
178 CheckState ();
179 credentials = value;
180 }
181 }
182
183 public SmtpDeliveryMethod DeliveryMethod {
184 get { return deliveryMethod; }
185 set {
186 CheckState ();
187 deliveryMethod = value;
188 }
189 }
190
191 public bool EnableSsl {
192 get { return enableSsl; }
193 set {
194 CheckState ();
195 enableSsl = value;
196 }
197 }
198
199 public string Host {
200 get { return host; }
201 set {
202 if (value == null)
203 throw new ArgumentNullException ("value");
204 if (value.Length == 0)
205 throw new ArgumentException ("An empty string is not allowed.", "value");
206 CheckState ();
207 host = value;
208 }
209 }
210
211 public string PickupDirectoryLocation {
212 get { return pickupDirectoryLocation; }
213 set { pickupDirectoryLocation = value; }
214 }
215
216 public int Port {
217 get { return port; }
218 set {
219 if (value <= 0)
220 throw new ArgumentOutOfRangeException ("value");
221 CheckState ();
222 port = value;
223 }
224 }
225
226 [MonoTODO]
227 public ServicePoint ServicePoint {
228 get { throw new NotImplementedException (); }
229 }
230
231 public int Timeout {
232 get { return timeout; }
233 set {
234 if (value < 0)
235 throw new ArgumentOutOfRangeException ("value");
236 CheckState ();
237 timeout = value;
238 }
239 }
240
241 public bool UseDefaultCredentials {
242 get { return false; }
243 [MonoNotSupported ("no DefaultCredential support in Mono")]
244 set {
245 if (value)
246 throw new NotImplementedException ("Default credentials are not supported");
247 CheckState ();
248 }
249 }
250
251 #endregion // Properties
252
253 #region Events
254
255 public event SendCompletedEventHandler SendCompleted;
256
257 #endregion // Events
258
259 #region Methods
260
261 private void CheckState ()
262 {
263 if (messageInProcess != null)
264 throw new InvalidOperationException ("Cannot set Timeout while Sending a message");
265 }
266
267 private static string EncodeAddress(MailAddress address)
268 {
269 string encodedDisplayName = ContentType.EncodeSubjectRFC2047 (address.DisplayName, Encoding.UTF8);
270 return "\"" + encodedDisplayName + "\" <" + address.Address + ">";
271 }
272
273 private static string EncodeAddresses(MailAddressCollection addresses)
274 {
275 StringBuilder sb = new StringBuilder();
276 bool first = true;
277 foreach (MailAddress address in addresses) {
278 if (!first) {
279 sb.Append(", ");
280 }
281 sb.Append(EncodeAddress(address));
282 first = false;
283 }
284 return sb.ToString();
285 }
286
287 private string EncodeSubjectRFC2047 (MailMessage message)
288 {
289 return ContentType.EncodeSubjectRFC2047 (message.Subject, message.SubjectEncoding);
290 }
291
292 private string EncodeBody (MailMessage message)
293 {
294 string body = message.Body;
295 Encoding encoding = message.BodyEncoding;
296 // RFC 2045 encoding
297 switch (message.ContentTransferEncoding) {
298 case TransferEncoding.SevenBit:
299 return body;
300 case TransferEncoding.Base64:
301 return Convert.ToBase64String (encoding.GetBytes (body), Base64FormattingOptions.InsertLineBreaks);
302 default:
303 return ToQuotedPrintable (body, encoding);
304 }
305 }
306
307 private string EncodeBody (AlternateView av)
308 {
309 //Encoding encoding = av.ContentType.CharSet != null ? Encoding.GetEncoding (av.ContentType.CharSet) : Encoding.UTF8;
310
311 byte [] bytes = new byte [av.ContentStream.Length];
312 av.ContentStream.Read (bytes, 0, bytes.Length);
313
314 // RFC 2045 encoding
315 switch (av.TransferEncoding) {
316 case TransferEncoding.SevenBit:
317 return Encoding.ASCII.GetString (bytes);
318 case TransferEncoding.Base64:
319 return Convert.ToBase64String (bytes, Base64FormattingOptions.InsertLineBreaks);
320 default:
321 return ToQuotedPrintable (bytes);
322 }
323 }
324
325
326 private void EndSection (string section)
327 {
328 SendData (String.Format ("--{0}--", section));
329 SendData (string.Empty);
330 }
331
332 private string GenerateBoundary ()
333 {
334 string output = GenerateBoundary (boundaryIndex);
335 boundaryIndex += 1;
336 return output;
337 }
338
339 private static string GenerateBoundary (int index)
340 {
341 return String.Format ("--boundary_{0}_{1}", index, Guid.NewGuid ().ToString ("D"));
342 }
343
344 private bool IsError (SmtpResponse status)
345 {
346 return ((int) status.StatusCode) >= 400;
347 }
348
349 protected void OnSendCompleted (AsyncCompletedEventArgs e)
350 {
351 try {
352 if (SendCompleted != null)
353 SendCompleted (this, e);
354 } finally {
355 worker = null;
356 user_async_state = null;
357 }
358 }
359
360 private void CheckCancellation ()
361 {
362 if (worker != null && worker.CancellationPending)
363 throw new CancellationException ();
364 }
365
366 private SmtpResponse Read () {
367 byte [] buffer = new byte [512];
368 int position = 0;
369 bool lastLine = false;
370
371 do {
372 CheckCancellation ();
373
374 int readLength = stream.Read (buffer, position, buffer.Length - position);
375 if (readLength > 0) {
376 int available = position + readLength - 1;
377 if (available > 4 && (buffer [available] == '\n' || buffer [available] == '\r'))
378 for (int index = available - 3; ; index--) {
379 if (index < 0 || buffer [index] == '\n' || buffer [index] == '\r') {
380 lastLine = buffer [index + 4] == ' ';
381 break;
382 }
383 }
384
385 // move position
386 position += readLength;
387
388 // check if buffer is full
389 if (position == buffer.Length) {
390 byte [] newBuffer = new byte [buffer.Length * 2];
391 Array.Copy (buffer, 0, newBuffer, 0, buffer.Length);
392 buffer = newBuffer;
393 }
394 }
395 else {
396 break;
397 }
398 } while (!lastLine);
399
400 if (position > 0) {
401 Encoding encoding = new ASCIIEncoding ();
402
403 string line = encoding.GetString (buffer, 0, position - 1);
404
405 // parse the line to the lastResponse object
406 SmtpResponse response = SmtpResponse.Parse (line);
407
408 return response;
409 } else {
410 throw new System.IO.IOException ("Connection closed");
411 }
412 }
413
414 void ResetExtensions()
415 {
416 authMechs = AuthMechs.None;
417 }
418
419 void ParseExtensions (string extens)
420 {
421 char[] delims = new char [1] { ' ' };
422 string[] parts = extens.Split ('\n');
423
424 foreach (string part in parts) {
425 if (part.Length < 4)
426 continue;
427
428 string start = part.Substring (4);
429 if (start.StartsWith ("AUTH ", StringComparison.Ordinal)) {
430 string[] options = start.Split (delims);
431 for (int k = 1; k < options.Length; k++) {
432 string option = options[k].Trim();
433 switch (option) {
434 case "CRAM-MD5":
435 authMechs |= AuthMechs.CramMD5;
436 break;
437 case "DIGEST-MD5":
438 authMechs |= AuthMechs.DigestMD5;
439 break;
440 case "GSSAPI":
441 authMechs |= AuthMechs.GssAPI;
442 break;
443 case "KERBEROS_V4":
444 authMechs |= AuthMechs.Kerberos4;
445 break;
446 case "LOGIN":
447 authMechs |= AuthMechs.Login;
448 break;
449 case "PLAIN":
450 authMechs |= AuthMechs.Plain;
451 break;
452 }
453 }
454 }
455 }
456 }
457
458 public void Send (MailMessage message)
459 {
460 if (message == null)
461 throw new ArgumentNullException ("message");
462
463 if (deliveryMethod == SmtpDeliveryMethod.Network && (Host == null || Host.Trim ().Length == 0))
464 throw new InvalidOperationException ("The SMTP host was not specified");
465 else if (deliveryMethod == SmtpDeliveryMethod.PickupDirectoryFromIis)
466 throw new NotSupportedException("IIS delivery is not supported");
467
468 if (port == 0)
469 port = 25;
470
471 // Block while sending
472 mutex.WaitOne ();
473 try {
474 messageInProcess = message;
475 if (deliveryMethod == SmtpDeliveryMethod.SpecifiedPickupDirectory)
476 SendToFile (message);
477 else
478 SendInternal (message);
479 } catch (CancellationException) {
480 // This exception is introduced for convenient cancellation process.
481 } catch (SmtpException) {
482 throw;
483 } catch (Exception ex) {
484 throw new SmtpException ("Message could not be sent.", ex);
485 } finally {
486 // Release the mutex to allow other threads access
487 mutex.ReleaseMutex ();
488 messageInProcess = null;
489 }
490 }
491
492 private void SendInternal (MailMessage message)
493 {
494 CheckCancellation ();
495
496 try {
497 client = new TcpClient (host, port);
498 stream = client.GetStream ();
499 // FIXME: this StreamWriter creation is bogus.
500 // It expects as if a Stream were able to switch to SSL
501 // mode (such behavior is only in Mainsoft Socket API).
502 writer = new StreamWriter (stream);
503 reader = new StreamReader (stream);
504
505 SendCore (message);
506 } finally {
507 if (writer != null)
508 writer.Close ();
509 if (reader != null)
510 reader.Close ();
511 if (stream != null)
512 stream.Close ();
513 if (client != null)
514 client.Close ();
515 }
516 }
517
518 // FIXME: simple implementation, could be brushed up.
519 private void SendToFile (MailMessage message)
520 {
521 if (!Path.IsPathRooted (pickupDirectoryLocation))
522 throw new SmtpException("Only absolute directories are allowed for pickup directory.");
523
524 string filename = Path.Combine (pickupDirectoryLocation,
525 Guid.NewGuid() + ".eml");
526
527 try {
528 writer = new StreamWriter(filename);
529
530 MailAddress from = message.From;
531
532 if (from == null)
533 from = defaultFrom;
534
535 SendHeader (HeaderName.Date, DateTime.Now.ToString ("ddd, dd MMM yyyy HH':'mm':'ss zzz", DateTimeFormatInfo.InvariantInfo));
536 SendHeader (HeaderName.From, from.ToString ());
537 SendHeader (HeaderName.To, message.To.ToString ());
538 if (message.CC.Count > 0)
539 SendHeader (HeaderName.Cc, message.CC.ToString ());
540 SendHeader (HeaderName.Subject, EncodeSubjectRFC2047 (message));
541
542 foreach (string s in message.Headers.AllKeys)
543 SendHeader (s, message.Headers [s]);
544
545 AddPriorityHeader (message);
546
547 boundaryIndex = 0;
548 if (message.Attachments.Count > 0)
549 SendWithAttachments (message);
550 else
551 SendWithoutAttachments (message, null, false);
552
553
554 } finally {
555 if (writer != null) writer.Close(); writer = null;
556 }
557 }
558
559 private void SendCore (MailMessage message)
560 {
561 SmtpResponse status;
562
563 status = Read ();
564 if (IsError (status))
565 throw new SmtpException (status.StatusCode, status.Description);
566
567 // EHLO
568
569 // FIXME: parse the list of extensions so we don't bother wasting
570 // our time trying commands if they aren't supported.
571 status = SendCommand ("EHLO " + Dns.GetHostName ());
572
573 if (IsError (status)) {
574 status = SendCommand ("HELO " + Dns.GetHostName ());
575
576 if (IsError (status))
577 throw new SmtpException (status.StatusCode, status.Description);
578 } else {
579 // Parse ESMTP extensions
580 string extens = status.Description;
581
582 if (extens != null)
583 ParseExtensions (extens);
584 }
585
586 if (enableSsl) {
587 InitiateSecureConnection ();
588 ResetExtensions();
589 writer = new StreamWriter (stream);
590 reader = new StreamReader (stream);
591 status = SendCommand ("EHLO " + Dns.GetHostName ());
592
593 if (IsError (status)) {
594 status = SendCommand ("HELO " + Dns.GetHostName ());
595
596 if (IsError (status))
597 throw new SmtpException (status.StatusCode, status.Description);
598 } else {
599 // Parse ESMTP extensions
600 string extens = status.Description;
601 if (extens != null)
602 ParseExtensions (extens);
603 }
604 }
605
606 if (authMechs != AuthMechs.None)
607 Authenticate ();
608
609 MailAddress from = message.From;
610
611 if (from == null)
612 from = defaultFrom;
613
614 // MAIL FROM:
615 status = SendCommand ("MAIL FROM:<" + from.Address + '>');
616 if (IsError (status)) {
617 throw new SmtpException (status.StatusCode, status.Description);
618 }
619
620 // Send RCPT TO: for all recipients
621 List<SmtpFailedRecipientException> sfre = new List<SmtpFailedRecipientException> ();
622
623 for (int i = 0; i < message.To.Count; i ++) {
624 status = SendCommand ("RCPT TO:<" + message.To [i].Address + '>');
625 if (IsError (status))
626 sfre.Add (new SmtpFailedRecipientException (status.StatusCode, message.To [i].Address));
627 }
628 for (int i = 0; i < message.CC.Count; i ++) {
629 status = SendCommand ("RCPT TO:<" + message.CC [i].Address + '>');
630 if (IsError (status))
631 sfre.Add (new SmtpFailedRecipientException (status.StatusCode, message.CC [i].Address));
632 }
633 for (int i = 0; i < message.Bcc.Count; i ++) {
634 status = SendCommand ("RCPT TO:<" + message.Bcc [i].Address + '>');
635 if (IsError (status))
636 sfre.Add (new SmtpFailedRecipientException (status.StatusCode, message.Bcc [i].Address));
637 }
638
639 #if TARGET_JVM // List<T>.ToArray () is not supported
640 if (sfre.Count > 0) {
641 SmtpFailedRecipientException[] xs = new SmtpFailedRecipientException[sfre.Count];
642 sfre.CopyTo (xs);
643 throw new SmtpFailedRecipientsException ("failed recipients", xs);
644 }
645 #else
646 if (sfre.Count >0)
647 throw new SmtpFailedRecipientsException ("failed recipients", sfre.ToArray ());
648 #endif
649
650 // DATA
651 status = SendCommand ("DATA");
652 if (IsError (status))
653 throw new SmtpException (status.StatusCode, status.Description);
654
655 // Send message headers
656 string dt = DateTime.Now.ToString ("ddd, dd MMM yyyy HH':'mm':'ss zzz", DateTimeFormatInfo.InvariantInfo);
657 // remove ':' from time zone offset (e.g. from "+01:00")
658 dt = dt.Remove (dt.Length - 3, 1);
659 SendHeader (HeaderName.Date, dt);
660
661 SendHeader (HeaderName.From, EncodeAddress (from));
662 SendHeader (HeaderName.To, EncodeAddresses (message.To));
663 if (message.CC.Count > 0)
664 SendHeader (HeaderName.Cc, EncodeAddresses (message.CC));
665 SendHeader (HeaderName.Subject, EncodeSubjectRFC2047 (message));
666
667 string v = "normal";
668
669 switch (message.Priority){
670 case MailPriority.Normal:
671 v = "normal";
672 break;
673
674 case MailPriority.Low:
675 v = "non-urgent";
676 break;
677
678 case MailPriority.High:
679 v = "urgent";
680 break;
681 }
682 SendHeader ("Priority", v);
683 if (message.Sender != null)
684 SendHeader ("Sender", EncodeAddress (message.Sender));
685 if (message.ReplyToList.Count > 0)
686 SendHeader ("Reply-To", EncodeAddresses (message.ReplyToList));
687
688 #if NET_4_0
689 foreach (string s in message.Headers.AllKeys)
690 SendHeader (s, ContentType.EncodeSubjectRFC2047 (message.Headers [s], message.HeadersEncoding));
691 #else
692 foreach (string s in message.Headers.AllKeys)
693 SendHeader (s, message.Headers [s]);
694 #endif
695
696 AddPriorityHeader (message);
697
698 boundaryIndex = 0;
699 if (message.Attachments.Count > 0)
700 SendWithAttachments (message);
701 else
702 SendWithoutAttachments (message, null, false);
703
704 SendDot ();
705
706 status = Read ();
707 if (IsError (status))
708 throw new SmtpException (status.StatusCode, status.Description);
709
710 try {
711 status = SendCommand ("QUIT");
712 } catch (System.IO.IOException) {
713 // We excuse server for the rude connection closing as a response to QUIT
714 }
715 }
716
717 public void Send (string from, string to, string subject, string body)
718 {
719 Send (new MailMessage (from, to, subject, body));
720 }
721
722 private void SendDot()
723 {
724 writer.Write(".\r\n");
725 writer.Flush();
726 }
727
728 private void SendData (string data)
729 {
730 if (String.IsNullOrEmpty (data)) {
731 writer.Write("\r\n");
732 writer.Flush();
733 return;
734 }
735
736 StringReader sr = new StringReader (data);
737 string line;
738 bool escapeDots = deliveryMethod == SmtpDeliveryMethod.Network;
739 while ((line = sr.ReadLine ()) != null) {
740 CheckCancellation ();
741
742 if (escapeDots) {
743 int i;
744 for (i = 0; i < line.Length; i++) {
745 if (line[i] != '.')
746 break;
747 }
748 if (i > 0 && i == line.Length) {
749 line += ".";
750 }
751 }
752 writer.Write (line);
753 writer.Write ("\r\n");
754 }
755 writer.Flush ();
756 }
757
758 public void SendAsync (MailMessage message, object userToken)
759 {
760 if (worker != null)
761 throw new InvalidOperationException ("Another SendAsync operation is in progress");
762
763 worker = new BackgroundWorker ();
764 worker.DoWork += delegate (object o, DoWorkEventArgs ea) {
765 try {
766 user_async_state = ea.Argument;
767 Send (message);
768 } catch (Exception ex) {
769 ea.Result = ex;
770 throw ex;
771 }
772 };
773 worker.WorkerSupportsCancellation = true;
774 worker.RunWorkerCompleted += delegate (object o, RunWorkerCompletedEventArgs ea) {
775 // Note that RunWorkerCompletedEventArgs.UserState cannot be used (LAMESPEC)
776 OnSendCompleted (new AsyncCompletedEventArgs (ea.Error, ea.Cancelled, user_async_state));
777 };
778 worker.RunWorkerAsync (userToken);
779 }
780
781 public void SendAsync (string from, string to, string subject, string body, object userToken)
782 {
783 SendAsync (new MailMessage (from, to, subject, body), userToken);
784 }
785
786 public void SendAsyncCancel ()
787 {
788 if (worker == null)
789 throw new InvalidOperationException ("SendAsync operation is not in progress");
790 worker.CancelAsync ();
791 }
792
793 private void AddPriorityHeader (MailMessage message) {
794 switch (message.Priority) {
795 case MailPriority.High:
796 SendHeader (HeaderName.Priority, "Urgent");
797 SendHeader (HeaderName.Importance, "high");
798 SendHeader (HeaderName.XPriority, "1");
799 break;
800 case MailPriority.Low:
801 SendHeader (HeaderName.Priority, "Non-Urgent");
802 SendHeader (HeaderName.Importance, "low");
803 SendHeader (HeaderName.XPriority, "5");
804 break;
805 }
806 }
807
808 private void SendSimpleBody (MailMessage message) {
809 SendHeader (HeaderName.ContentType, message.BodyContentType.ToString ());
810 if (message.ContentTransferEncoding != TransferEncoding.SevenBit)
811 SendHeader (HeaderName.ContentTransferEncoding, GetTransferEncodingName (message.ContentTransferEncoding));
812 SendData (string.Empty);
813
814 SendData (EncodeBody (message));
815 }
816
817 private void SendBodylessSingleAlternate (AlternateView av) {
818 SendHeader (HeaderName.ContentType, av.ContentType.ToString ());
819 if (av.TransferEncoding != TransferEncoding.SevenBit)
820 SendHeader (HeaderName.ContentTransferEncoding, GetTransferEncodingName (av.TransferEncoding));
821 SendData (string.Empty);
822
823 SendData (EncodeBody (av));
824 }
825
826 private void SendWithoutAttachments (MailMessage message, string boundary, bool attachmentExists)
827 {
828 if (message.Body == null && message.AlternateViews.Count == 1)
829 SendBodylessSingleAlternate (message.AlternateViews [0]);
830 else if (message.AlternateViews.Count > 0)
831 SendBodyWithAlternateViews (message, boundary, attachmentExists);
832 else
833 SendSimpleBody (message);
834 }
835
836
837 private void SendWithAttachments (MailMessage message) {
838 string boundary = GenerateBoundary ();
839
840 // first "multipart/mixed"
841 ContentType messageContentType = new ContentType ();
842 messageContentType.Boundary = boundary;
843 messageContentType.MediaType = "multipart/mixed";
844 messageContentType.CharSet = null;
845
846 SendHeader (HeaderName.ContentType, messageContentType.ToString ());
847 SendData (String.Empty);
848
849 // body section
850 Attachment body = null;
851
852 if (message.AlternateViews.Count > 0)
853 SendWithoutAttachments (message, boundary, true);
854 else {
855 body = Attachment.CreateAttachmentFromString (message.Body, null, message.BodyEncoding, message.IsBodyHtml ? "text/html" : "text/plain");
856 message.Attachments.Insert (0, body);
857 }
858
859 try {
860 SendAttachments (message, body, boundary);
861 } finally {
862 if (body != null)
863 message.Attachments.Remove (body);
864 }
865
866 EndSection (boundary);
867 }
868
869 private void SendBodyWithAlternateViews (MailMessage message, string boundary, bool attachmentExists)
870 {
871 AlternateViewCollection alternateViews = message.AlternateViews;
872
873 string inner_boundary = GenerateBoundary ();
874
875 ContentType messageContentType = new ContentType ();
876 messageContentType.Boundary = inner_boundary;
877 messageContentType.MediaType = "multipart/alternative";
878
879 if (!attachmentExists) {
880 SendHeader (HeaderName.ContentType, messageContentType.ToString ());
881 SendData (String.Empty);
882 }
883
884 // body section
885 AlternateView body = null;
886 if (message.Body != null) {
887 body = AlternateView.CreateAlternateViewFromString (message.Body, message.BodyEncoding, message.IsBodyHtml ? "text/html" : "text/plain");
888 alternateViews.Insert (0, body);
889 StartSection (boundary, messageContentType);
890 }
891
892 try {
893 // alternate view sections
894 foreach (AlternateView av in alternateViews) {
895
896 string alt_boundary = null;
897 ContentType contentType;
898 if (av.LinkedResources.Count > 0) {
899 alt_boundary = GenerateBoundary ();
900 contentType = new ContentType ("multipart/related");
901 contentType.Boundary = alt_boundary;
902
903 contentType.Parameters ["type"] = av.ContentType.ToString ();
904 StartSection (inner_boundary, contentType);
905 StartSection (alt_boundary, av.ContentType, av.TransferEncoding);
906 } else {
907 contentType = new ContentType (av.ContentType.ToString ());
908 StartSection (inner_boundary, contentType, av.TransferEncoding);
909 }
910
911 switch (av.TransferEncoding) {
912 case TransferEncoding.Base64:
913 byte [] content = new byte [av.ContentStream.Length];
914 av.ContentStream.Read (content, 0, content.Length);
915 #if TARGET_JVM
916 SendData (Convert.ToBase64String (content));
917 #else
918 SendData (Convert.ToBase64String (content, Base64FormattingOptions.InsertLineBreaks));
919 #endif
920 break;
921 case TransferEncoding.QuotedPrintable:
922 byte [] bytes = new byte [av.ContentStream.Length];
923 av.ContentStream.Read (bytes, 0, bytes.Length);
924 SendData (ToQuotedPrintable (bytes));
925 break;
926 case TransferEncoding.SevenBit:
927 case TransferEncoding.Unknown:
928 content = new byte [av.ContentStream.Length];
929 av.ContentStream.Read (content, 0, content.Length);
930 SendData (Encoding.ASCII.GetString (content));
931 break;
932 }
933
934 if (av.LinkedResources.Count > 0) {
935 SendLinkedResources (message, av.LinkedResources, alt_boundary);
936 EndSection (alt_boundary);
937 }
938
939 if (!attachmentExists)
940 SendData (string.Empty);
941 }
942
943 } finally {
944 if (body != null)
945 alternateViews.Remove (body);
946 }
947 EndSection (inner_boundary);
948 }
949
950 private void SendLinkedResources (MailMessage message, LinkedResourceCollection resources, string boundary)
951 {
952 foreach (LinkedResource lr in resources) {
953 StartSection (boundary, lr.ContentType, lr.TransferEncoding, lr);
954
955 switch (lr.TransferEncoding) {
956 case TransferEncoding.Base64:
957 byte [] content = new byte [lr.ContentStream.Length];
958 lr.ContentStream.Read (content, 0, content.Length);
959 #if TARGET_JVM
960 SendData (Convert.ToBase64String (content));
961 #else
962 SendData (Convert.ToBase64String (content, Base64FormattingOptions.InsertLineBreaks));
963 #endif
964 break;
965 case TransferEncoding.QuotedPrintable:
966 byte [] bytes = new byte [lr.ContentStream.Length];
967 lr.ContentStream.Read (bytes, 0, bytes.Length);
968 SendData (ToQuotedPrintable (bytes));
969 break;
970 case TransferEncoding.SevenBit:
971 case TransferEncoding.Unknown:
972 content = new byte [lr.ContentStream.Length];
973 lr.ContentStream.Read (content, 0, content.Length);
974 SendData (Encoding.ASCII.GetString (content));
975 break;
976 }
977 }
978 }
979
980 private void SendAttachments (MailMessage message, Attachment body, string boundary) {
981 foreach (Attachment att in message.Attachments) {
982 ContentType contentType = new ContentType (att.ContentType.ToString ());
983 if (att.Name != null) {
984 contentType.Name = att.Name;
985 if (att.NameEncoding != null)
986 contentType.CharSet = att.NameEncoding.HeaderName;
987 att.ContentDisposition.FileName = att.Name;
988 }
989 StartSection (boundary, contentType, att.TransferEncoding, att == body ? null : att.ContentDisposition);
990
991 byte [] content = new byte [att.ContentStream.Length];
992 att.ContentStream.Read (content, 0, content.Length);
993 switch (att.TransferEncoding) {
994 case TransferEncoding.Base64:
995 #if TARGET_JVM
996 SendData (Convert.ToBase64String (content));
997 #else
998 SendData (Convert.ToBase64String (content, Base64FormattingOptions.InsertLineBreaks));
999 #endif
1000 break;
1001 case TransferEncoding.QuotedPrintable:
1002 SendData (ToQuotedPrintable (content));
1003 break;
1004 case TransferEncoding.SevenBit:
1005 case TransferEncoding.Unknown:
1006 SendData (Encoding.ASCII.GetString (content));
1007 break;
1008 }
1009
1010 SendData (string.Empty);
1011 }
1012 }
1013
1014 private SmtpResponse SendCommand (string command)
1015 {
1016 writer.Write (command);
1017 // Certain SMTP servers will reject mail sent with unix line-endings; see http://cr.yp.to/docs/smtplf.html
1018 writer.Write ("\r\n");
1019 writer.Flush ();
1020 return Read ();
1021 }
1022
1023 private void SendHeader (string name, string value)
1024 {
1025 SendData (String.Format ("{0}: {1}", name, value));
1026 }
1027
1028 private void StartSection (string section, ContentType sectionContentType)
1029 {
1030 SendData (String.Format ("--{0}", section));
1031 SendHeader ("content-type", sectionContentType.ToString ());
1032 SendData (string.Empty);
1033 }
1034
1035 private void StartSection (string section, ContentType sectionContentType,TransferEncoding transferEncoding)
1036 {
1037 SendData (String.Format ("--{0}", section));
1038 SendHeader ("content-type", sectionContentType.ToString ());
1039 SendHeader ("content-transfer-encoding", GetTransferEncodingName (transferEncoding));
1040 SendData (string.Empty);
1041 }
1042
1043 private void StartSection(string section, ContentType sectionContentType, TransferEncoding transferEncoding, LinkedResource lr)
1044 {
1045 SendData (String.Format("--{0}", section));
1046 SendHeader ("content-type", sectionContentType.ToString ());
1047 SendHeader ("content-transfer-encoding", GetTransferEncodingName (transferEncoding));
1048
1049 if (lr.ContentId != null && lr.ContentId.Length > 0)
1050 SendHeader("content-ID", "<" + lr.ContentId + ">");
1051
1052 SendData (string.Empty);
1053 }
1054
1055 private void StartSection (string section, ContentType sectionContentType, TransferEncoding transferEncoding, ContentDisposition contentDisposition) {
1056 SendData (String.Format ("--{0}", section));
1057 SendHeader ("content-type", sectionContentType.ToString ());
1058 SendHeader ("content-transfer-encoding", GetTransferEncodingName (transferEncoding));
1059 if (contentDisposition != null)
1060 SendHeader ("content-disposition", contentDisposition.ToString ());
1061 SendData (string.Empty);
1062 }
1063
1064 // use proper encoding to escape input
1065 private string ToQuotedPrintable (string input, Encoding enc)
1066 {
1067 byte [] bytes = enc.GetBytes (input);
1068 return ToQuotedPrintable (bytes);
1069 }
1070
1071 private string ToQuotedPrintable (byte [] bytes)
1072 {
1073 StringWriter writer = new StringWriter ();
1074 int charsInLine = 0;
1075 int curLen;
1076 StringBuilder sb = new StringBuilder("=", 3);
1077 byte equalSign = (byte)'=';
1078 char c = (char)0;
1079
1080 foreach (byte i in bytes) {
1081 if (i > 127 || i == equalSign) {
1082 sb.Length = 1;
1083 sb.Append(Convert.ToString (i, 16).ToUpperInvariant ());
1084 curLen = 3;
1085 } else {
1086 c = Convert.ToChar (i);
1087 if (c == '\r' || c == '\n') {
1088 writer.Write (c);
1089 charsInLine = 0;
1090 continue;
1091 }
1092 curLen = 1;
1093 }
1094
1095 charsInLine += curLen;
1096 if (charsInLine > 75) {
1097 writer.Write ("=\r\n");
1098 charsInLine = curLen;
1099 }
1100 if (curLen == 1)
1101 writer.Write (c);
1102 else
1103 writer.Write (sb.ToString ());
1104 }
1105
1106 return writer.ToString ();
1107 }
1108 private static string GetTransferEncodingName (TransferEncoding encoding)
1109 {
1110 switch (encoding) {
1111 case TransferEncoding.QuotedPrintable:
1112 return "quoted-printable";
1113 case TransferEncoding.SevenBit:
1114 return "7bit";
1115 case TransferEncoding.Base64:
1116 return "base64";
1117 }
1118 return "unknown";
1119 }
1120
1121 #if SECURITY_DEP
1122 RemoteCertificateValidationCallback callback = delegate (object sender,
1123 X509Certificate certificate,
1124 X509Chain chain,
1125 SslPolicyErrors sslPolicyErrors) {
1126 // honor any exciting callback defined on ServicePointManager
1127 if (ServicePointManager.ServerCertificateValidationCallback != null)
1128 return ServicePointManager.ServerCertificateValidationCallback (sender, certificate, chain, sslPolicyErrors);
1129 // otherwise provide our own
1130 if (sslPolicyErrors != SslPolicyErrors.None)
1131 throw new InvalidOperationException ("SSL authentication error: " + sslPolicyErrors);
1132 return true;
1133 };
1134 #endif
1135
1136 private void InitiateSecureConnection () {
1137 SmtpResponse response = SendCommand ("STARTTLS");
1138
1139 if (IsError (response)) {
1140 throw new SmtpException (SmtpStatusCode.GeneralFailure, "Server does not support secure connections.");
1141 }
1142
1143 #if TARGET_JVM
1144 ((NetworkStream) stream).ChangeToSSLSocket ();
1145 #elif SECURITY_DEP
1146 SslStream sslStream = new SslStream (stream, false, callback, null);
1147 CheckCancellation ();
1148 sslStream.AuthenticateAsClient (Host, this.ClientCertificates, SslProtocols.Default, false);
1149 stream = sslStream;
1150
1151 #else
1152 throw new SystemException ("You are using an incomplete System.dll build");
1153 #endif
1154 }
1155
1156 void Authenticate ()
1157 {
1158 string user = null, pass = null;
1159
1160 if (UseDefaultCredentials) {
1161 user = CredentialCache.DefaultCredentials.GetCredential (new System.Uri ("smtp://" + host), "basic").UserName;
1162 pass = CredentialCache.DefaultCredentials.GetCredential (new System.Uri ("smtp://" + host), "basic").Password;
1163 } else if (Credentials != null) {
1164 user = Credentials.GetCredential (host, port, "smtp").UserName;
1165 pass = Credentials.GetCredential (host, port, "smtp").Password;
1166 } else {
1167 return;
1168 }
1169
1170 Authenticate (user, pass);
1171 }
1172
1173 void Authenticate (string Username, string Password)
1174 {
1175 // FIXME: use the proper AuthMech
1176 SmtpResponse status = SendCommand ("AUTH LOGIN");
1177 if (((int) status.StatusCode) != 334) {
1178 throw new SmtpException (status.StatusCode, status.Description);
1179 }
1180
1181 status = SendCommand (Convert.ToBase64String (Encoding.ASCII.GetBytes (Username)));
1182 if (((int) status.StatusCode) != 334) {
1183 throw new SmtpException (status.StatusCode, status.Description);
1184 }
1185
1186 status = SendCommand (Convert.ToBase64String (Encoding.ASCII.GetBytes (Password)));
1187 if (IsError (status)) {
1188 throw new SmtpException (status.StatusCode, status.Description);
1189 }
1190 }
1191
1192 #endregion // Methods
1193
1194 // The HeaderName struct is used to store constant string values representing mail headers.
1195 private struct HeaderName {
1196 public const string ContentTransferEncoding = "Content-Transfer-Encoding";
1197 public const string ContentType = "Content-Type";
1198 public const string Bcc = "Bcc";
1199 public const string Cc = "Cc";
1200 public const string From = "From";
1201 public const string Subject = "Subject";
1202 public const string To = "To";
1203 public const string MimeVersion = "MIME-Version";
1204 public const string MessageId = "Message-ID";
1205 public const string Priority = "Priority";
1206 public const string Importance = "Importance";
1207 public const string XPriority = "X-Priority";
1208 public const string Date = "Date";
1209 }
1210
1211 // This object encapsulates the status code and description of an SMTP response.
1212 private struct SmtpResponse {
1213 public SmtpStatusCode StatusCode;
1214 public string Description;
1215
1216 public static SmtpResponse Parse (string line) {
1217 SmtpResponse response = new SmtpResponse ();
1218
1219 if (line.Length < 4)
1220 throw new SmtpException ("Response is to short " +
1221 line.Length + ".");
1222
1223 if ((line [3] != ' ') && (line [3] != '-'))
1224 throw new SmtpException ("Response format is wrong.(" +
1225 line + ")");
1226
1227 // parse the response code
1228 response.StatusCode = (SmtpStatusCode) Int32.Parse (line.Substring (0, 3));
1229
1230 // set the raw response
1231 response.Description = line;
1232
1233 return response;
1234 }
1235 }
1236 }
1237
1238 class CCredentialsByHost : ICredentialsByHost
1239 {
1240 public CCredentialsByHost (string userName, string password) {
1241 this.userName = userName;
1242 this.password = password;
1243 }
1244
1245 public NetworkCredential GetCredential (string host, int port, string authenticationType) {
1246 return new NetworkCredential (userName, password);
1247 }
1248
1249 private string userName;
1250 private string password;
1251 }
1252 }
1253
1254 #endif // NET_2_0
git-svn mirror of mcs