开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
Message.cs
资源名称：Email.rar　[点击查看]
上传用户：hncsjykj
上传日期：2022-08-09
资源大小：461k
文件大小：39k
源码类别：

Email客户端

开发平台：

C#

Message.cs：源码内容
  1. /******************************************************************************
  2. Copyright 2003-2004 Hamid Qureshi and Unruled Boy 
  3. OpenPOP.Net is free software; you can redistribute it and/or modify
  4. it under the terms of the Lesser GNU General Public License as published by
  5. the Free Software Foundation; either version 2 of the License, or
  6. (at your option) any later version.
  8. OpenPOP.Net is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. Lesser GNU General Public License for more details.
  13. You should have received a copy of the Lesser GNU General Public License
  14. along with this program; if not, write to the Free Software
  15. Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16. /*******************************************************************************/
  18. /*
  19. *Name: OpenPOP.MIMEParser.Message
  20. *Function: Message Parser
  21. *Author: Hamid Qureshi
  22. *Created: 2003/8
  23. *Modified: 2004/6/16 18:34 GMT+8 by Unruled Boy
  24. *Description:
  25. *Changes:
  26. * 2004/6/16 18:34 GMT+8 by Unruled Boy
  27. * 1.fixed a loop in message body decoding by .
  28. * 2004/5/17 14:20 GMT+8 by Unruled Boy
  29. * 1.Again, fixed something but do not remember :(
  30. * 2004/5/11 17:00 GMT+8 by Unruled Boy
  31. * 1.Fixed a bug in parsing ContentCharset
  32. * 2.Fixed a bug in ParseStreamLines
  33. * 2004/5/10 10:00 GMT+8 by Unruled Boy
  34. * 1.Well, fixed something but do not remember :(
  35. * 2004/5/8 17:00 GMT+8 by Unruled Boy
  36. * 1.Fixed a bug in parsing boundary
  37. * 2004/5/1 14:13 GMT+8 by Unruled Boy
  38. * 1.Adding three more constructors
  39. * 2.Adding descriptions to every public functions/property/void
  40. * 2004/4/29 19:05 GMT+8 by Unruled Boy
  41. * 1.Fixed the bug parsing headers/boundary
  42. * 2004/4/28 19:06 GMT+8 by Unruled Boy
  43. * 1.Adding DateTimeInfo property
  44. * 2.Maybe we correct the HTML content type bug
  45. * 2004/4/23 21:13 GMT+8 by Unruled Boy
  46. * 1.New Contructor
  47. * 2.Tidy up the codes to follow Hungarian Notation
  48. * 2004/3/29 10:38 GMT+8 by Unruled Boy
  49. * 1.removing bugs in decoding message
  50. * 2004/3/29 17:22 GMT+8 by Unruled Boy
  51. * 1.adding support for reply message using ms-tnef 
  52. * 2.adding support for all custom headers
  53. * 3.rewriting the header parser(adding 3 ParseStreamLines)
  54. * 4.adding detail description for every function
  55. * 5.cleaning up the codes
  56. * 2004/3/30 09:15 GMT+8 by Unruled Boy
  57. * 1.Adding ImportanceType
  58. */
  59. using System;
  60. using System.IO;
  61. using System.Collections;
  62. using System.Text;
  63. using System.Text.RegularExpressions;
  65. namespace OpenPOP.MIMEParser
  66. {
  67. /// <summary>
  68. /// Message Parser.
  69. /// </summary>
  70. public class Message
  71. {
  72. #region Member Variables
  73. private ArrayList _attachments=new ArrayList();
  74. private string _rawHeader=null;
  75. private string _rawMessage=null;
  76. private string _rawMessageBody=null;
  77. private int _attachmentCount=0;
  78.         private int _realAttachmentCount =0;
  79.         private bool _hasRealAttachment = false;
  80. private string _replyTo=null;
  81. private string _replyToEmail=null;
  82. private string _from=null;
  83. private string _fromEmail=null;
  84. private string _date=null;
  85. private string _dateTimeInfo=null;
  86. private string _subject=null;
  87. private string[] _to=new string[0];
  88. private string[] _cc=new string[0];
  89. private string[] _bcc=new string[0];
  90. private ArrayList _keywords=new ArrayList();
  91. private string _contentType=null;
  92. private string _contentCharset=null;
  93. private string _reportType=null;
  94. private string _contentTransferEncoding=null;
  95. private bool _html=false;
  96. private long _contentLength=0;
  97. private string _contentEncoding=null;
  98. private string _returnPath=null;
  99. private string _mimeVersion=null;
  100. private string _received=null;
  101. private string _importance=null;
  102. private string _messageID=null;
  103. private string _attachmentboundry=null;
  104. private string _attachmentboundry2=null;
  105. private bool _hasAttachment=false;
  106. private string _dispositionNotificationTo=null;
  107. private ArrayList _messageBody=new ArrayList();
  108. private string _basePath=null;
  109. private bool _autoDecodeMSTNEF=false;
  110. private Hashtable _customHeaders=new Hashtable();
  111. #endregion
  114. #region Properties
  115. /// <summary>
  116. /// custom headers
  117. /// </summary>
  118. public Hashtable CustomHeaders
  119. {
  120. get{return _customHeaders;}
  121. set{_customHeaders=value;}
  122. }
  124. /// <summary>
  125. /// whether auto decoding MS-TNEF attachment files
  126. /// </summary>
  127. public bool AutoDecodeMSTNEF
  128. {
  129. get{return _autoDecodeMSTNEF;}
  130. set{_autoDecodeMSTNEF=value;}
  131. }
  133. /// <summary>
  134. /// path to extract MS-TNEF attachment files
  135. /// </summary>
  136. public string BasePath
  137. {
  138. get{return _basePath;}
  139. set
  140. {
  141. try
  142. {
  143. if(value.EndsWith("\"))
  144. _basePath=value;
  145. else
  146. _basePath=value+"\";
  147. }
  148. catch
  149. {
  150. }
  151. }
  152. }
  154. /// <summary>
  155. /// message keywords
  156. /// </summary>
  157. public ArrayList Keywords
  158. {
  159. get{return _keywords;}
  160. }
  162. /// <summary>
  163. /// disposition notification
  164. /// </summary>
  165. public string DispositionNotificationTo
  166. {
  167. get{return _dispositionNotificationTo;}
  168. }
  170. /// <summary>
  171. /// received server
  172. /// </summary>
  173. public string Received
  174. {
  175. get{return _received;}
  176. }
  178. /// <summary>
  179. /// importance level
  180. /// </summary>
  181. public string Importance
  182. {
  183. get{return _importance;}
  184. }
  186. /// <summary>
  187. /// importance level type
  188. /// </summary>
  189. public MessageImportanceType ImportanceType
  190. {
  191. get
  192. {
  193. switch(_importance.ToUpper())
  194. {
  195. case "5":
  196. case "HIGH":
  197. return MessageImportanceType.HIGH;
  198. case "3":
  199. case "NORMAL":
  200. return MessageImportanceType.NORMAL;
  201. case "1":
  202. case "LOW":
  203. return MessageImportanceType.LOW;
  204. default:
  205. return MessageImportanceType.NORMAL;
  206. }
  207. }
  208. }
  210. /// <summary>
  211. /// Content Charset
  212. /// </summary>
  213. public string ContentCharset
  214. {
  215. get{return _contentCharset;}
  216. }
  218. /// <summary>
  219. /// Content Transfer Encoding
  220. /// </summary>
  221. public string ContentTransferEncoding
  222. {
  223. get{return _contentTransferEncoding;}
  224. }
  226. /// <summary>
  227. /// Message Bodies
  228. /// </summary>
  229. public ArrayList MessageBody
  230. {
  231. get{return _messageBody;}
  232. }
  234. /// <summary>
  235. /// Attachment Boundry
  236. /// </summary>
  237. public string AttachmentBoundry
  238. {
  239. get{return _attachmentboundry;}
  240. }
  242. /// <summary>
  243. /// Alternate Attachment Boundry
  244. /// </summary>
  245. public string AttachmentBoundry2
  246. {
  247. get{return _attachmentboundry2;}
  248. }
  250. /// <summary>
  251. /// Attachment Count
  252. /// </summary>
  253. public int AttachmentCount
  254. {
  255. get{return _attachmentCount;}
  256. }
  258.         public int RealAttachmentCount
  259.         {
  260.             get { return _realAttachmentCount; }
  261.         }
  263. /// <summary>
  264. /// Attachments
  265. /// </summary>
  266. public ArrayList Attachments
  267. {
  268. get{return _attachments;}
  269. }
  271. /// <summary>
  272. /// CC
  273. /// </summary>
  274. public string[] CC
  275. {
  276. get{return _cc;}
  277. }
  279. /// <summary>
  280. /// BCC
  281. /// </summary>
  282. public string[] BCC
  283. {
  284. get{return _bcc;}
  285. }
  287. /// <summary>
  288. /// TO
  289. /// </summary>
  290. public string[] TO
  291. {
  292. get{return _to;}
  293. }
  295. /// <summary>
  296. /// Content Encoding
  297. /// </summary>
  298. public string ContentEncoding
  299. {
  300. get{return _contentEncoding;}
  301. }
  303. /// <summary>
  304. /// Content Length
  305. /// </summary>
  306. public long ContentLength
  307. {
  308. get{return _contentLength;}
  309. }
  311. /// <summary>
  312. /// Content Type
  313. /// </summary>
  314. public string ContentType
  315. {
  316. get{return _contentType;}
  317. }
  319. /// <summary>
  320. /// Report Type
  321. /// </summary>
  322. public string ReportType
  323. {
  324. get{return _reportType;}
  325. }
  327. /// <summary>
  328. /// HTML
  329. /// </summary>
  330. public bool HTML
  331. {
  332. get{return _html;}
  333. }
  335. /// <summary>
  336. /// Date
  337. /// </summary>
  338. public string Date
  339. {
  340. get{return _date;}
  341. }
  343. /// <summary>
  344. /// DateTime Info
  345. /// </summary>
  346. public string DateTimeInfo
  347. {
  348. get{return _dateTimeInfo;}
  349. }
  351. /// <summary>
  352. /// From name
  353. /// </summary>
  354. public string From
  355. {
  356. get{return _from;}
  357. }
  359. /// <summary>
  360. /// From Email
  361. /// </summary>
  362. public string FromEmail
  363. {
  364. get{return _fromEmail;}
  365. }
  367. /// <summary>
  368. /// Reply to name
  369. /// </summary>
  370. public string ReplyTo
  371. {
  372. get{return _replyTo;}
  373. }
  375. /// <summary>
  376. /// Reply to email
  377. /// </summary>
  378. public string ReplyToEmail
  379. {
  380. get{return _replyToEmail;}
  381. }
  383. /// <summary>
  384. /// whether has attachment
  385. /// </summary>
  386. public bool HasAttachment
  387. {
  388. get{return _hasAttachment;}
  389. }
  391.         public bool HasRealAttachment
  392.         {
  393.             get { return _hasRealAttachment; }
  394.         }
  396. /// <summary>
  397. /// raw message body
  398. /// </summary>
  399. public string RawMessageBody
  400. {
  401. get{return _rawMessageBody;}
  402. }
  404. /// <summary>
  405. /// Message ID
  406. /// </summary>
  407. public string MessageID
  408. {
  409. get{return _messageID;}
  410. }
  412. /// <summary>
  413. /// MIME version
  414. /// </summary>
  415. public string MimeVersion
  416. {
  417. get{return _mimeVersion;}
  418. }
  420. /// <summary>
  421. /// raw header
  422. /// </summary>
  423. public string RawHeader
  424. {
  425. get{return _rawHeader;}
  426. }
  428. /// <summary>
  429. /// raw message
  430. /// </summary>
  431. public string RawMessage
  432. {
  433. get{return _rawMessage;}
  434. }
  436. /// <summary>
  437. /// return path
  438. /// </summary>
  439. public string ReturnPath
  440. {
  441. get{return _returnPath;}
  442. }
  444. /// <summary>
  445. /// subject
  446. /// </summary>
  447. public string Subject
  448. {
  449. get{return _subject;}
  450. }
  451. #endregion
  454. /// <summary>
  455. /// release all objects
  456. /// </summary>
  457. ~Message()
  458. {
  459. _attachments.Clear();
  460. _attachments=null;
  461. _keywords.Clear();
  462. _keywords=null;
  463. _messageBody.Clear();
  464. _messageBody=null;
  465. _customHeaders.Clear();
  466. _customHeaders=null;
  467. }
  469. /// <summary>
  470. /// New Message
  471. /// </summary>
  472. /// <param name="blnFinish">reference for the finishing state</param>
  473. /// <param name="strBasePath">path to extract MS-TNEF attachment files</param>
  474. /// <param name="blnAutoDecodeMSTNEF">whether auto decoding MS-TNEF attachments</param>
  475. /// <param name="blnOnlyHeader">whether only decode the header without body</param>
  476. /// <param name="strEMLFile">file of email content to load from</param>
  477. public Message(ref bool blnFinish, string strBasePath, bool blnAutoDecodeMSTNEF, bool blnOnlyHeader, string strEMLFile)
  478. {
  479. string strMessage=null;
  480. if(Utility.ReadPlainTextFromFile(strEMLFile,ref strMessage))
  481. {
  482. NewMessage(ref blnFinish,strBasePath,blnAutoDecodeMSTNEF,strMessage,blnOnlyHeader);
  483. }
  484. else
  485. blnFinish=true;
  486. }
  488. /// <summary>
  489. /// New Message
  490. /// </summary>
  491. /// <param name="blnFinish">reference for the finishing state</param>
  492. /// <param name="strBasePath">path to extract MS-TNEF attachment files</param>
  493. /// <param name="blnAutoDecodeMSTNEF">whether auto decoding MS-TNEF attachments</param>
  494. /// <param name="strMessage">raw message content</param>
  495. /// <param name="blnOnlyHeader">whether only decode the header without body</param>
  496. public Message(ref bool blnFinish, string strBasePath, bool blnAutoDecodeMSTNEF, string strMessage, bool blnOnlyHeader)
  497. {
  498. NewMessage(ref blnFinish,strBasePath,blnAutoDecodeMSTNEF,strMessage,blnOnlyHeader);
  499. }
  501. /// <summary>
  502. /// New Message
  503. /// </summary>
  504. /// <param name="blnFinish">reference for the finishing state</param>
  505. /// <param name="strMessage">raw message content</param>
  506. /// <param name="blnOnlyHeader">whether only decode the header without body</param>
  507. public Message(ref bool blnFinish, string strMessage, bool blnOnlyHeader)
  508. {
  509. NewMessage(ref blnFinish,"",false,strMessage,blnOnlyHeader);
  510. }
  512. /// <summary>
  513. /// New Message
  514. /// </summary>
  515. /// <param name="blnFinish">reference for the finishing state</param>
  516. /// <param name="strMessage">raw message content</param>
  517. public Message(ref bool blnFinish, string strMessage)
  518. {
  519. NewMessage(ref blnFinish,"",false,strMessage,false);
  520. }
  522. /// <summary>
  523. /// get valid attachment
  524. /// </summary>
  525. /// <param name="intAttachmentNumber">attachment index in the attachments collection</param>
  526. /// <returns>attachment</returns>
  527. public Attachment GetAttachment(int intAttachmentNumber)
  528. {
  529. if(intAttachmentNumber<0 || intAttachmentNumber>_attachmentCount || intAttachmentNumber>_attachments.Count)
  530. {
  531. Utility.LogError("GetAttachment():attachment not exist");
  532. throw new ArgumentOutOfRangeException("intAttachmentNumber");
  533. }
  534. return (Attachment)_attachments[intAttachmentNumber];
  535. }
  537. /// <summary>
  538. /// New Message
  539. /// </summary>
  540. /// <param name="blnFinish">reference for the finishing state</param>
  541. /// <param name="strBasePath">path to extract MS-TNEF attachment files</param>
  542. /// <param name="blnAutoDecodeMSTNEF">whether auto decoding MS-TNEF attachments</param>
  543. /// <param name="strMessage">raw message content</param>
  544. /// <param name="blnOnlyHeader">whether only decode the header without body</param>
  545. /// <returns>construction result whether successfully new a message</returns>
  546. private bool NewMessage(ref bool blnFinish, string strBasePath, bool blnAutoDecodeMSTNEF, string strMessage, bool blnOnlyHeader)
  547. {
  548. StringReader srdReader=new StringReader(strMessage);
  549. StringBuilder sbdBuilder=new StringBuilder();
  550. _basePath=strBasePath;
  551. _autoDecodeMSTNEF=blnAutoDecodeMSTNEF;
  553. _rawMessage=strMessage;
  555. string strLine=srdReader.ReadLine();
  556. while(Utility.IsNotNullTextEx(strLine))
  557. {
  558. sbdBuilder.Append(strLine + "rn");
  559. ParseHeader(sbdBuilder,srdReader,ref strLine);
  560. if(Utility.IsOrNullTextEx(strLine))
  561. break;
  562. else
  563. strLine=srdReader.ReadLine();
  564. }
  566. _rawHeader=sbdBuilder.ToString();
  568. SetAttachmentBoundry2(_rawHeader);
  570. if(_contentLength==0)
  571. _contentLength=strMessage.Length;//_rawMessageBody.Length;
  573. if(blnOnlyHeader==false)
  574. {
  575. _rawMessageBody=srdReader.ReadToEnd().Trim();
  577. //the auto reply mail by outlook uses ms-tnef format
  578. if((_hasAttachment==true && _attachmentboundry!=null)||MIMETypes.IsMSTNEF(_contentType))
  579. {
  580. set_attachments();
  582. if (this.Attachments.Count>0)
  583. {
  584. Attachment at=this.GetAttachment(0);
  585. if(at!=null&&at.NotAttachment)
  586. this.GetMessageBody(at.DecodeAsText());
  587. else
  588. {}
  589. //in case body parts as text[0] html[1]
  590. if(this.Attachments.Count>1&&!this.IsReport())
  591. {
  592. at=this.GetAttachment(1);
  593. if(at!=null&&at.NotAttachment)
  594. this.GetMessageBody(at.DecodeAsText());
  595. else
  596. {}
  597. }
  598. }
  599. else
  600. {}
  601. }
  602. else
  603. {
  604. GetMessageBody(_rawMessageBody);
  605. }
  606. }
  608. blnFinish=true;
  609. return true;
  610. }
  612. /// <summary>
  613. /// parse message body
  614. /// </summary>
  615. /// <param name="strBuffer">raw message body</param>
  616. /// <returns>message body</returns>
  617. public string GetTextBody(string strBuffer)
  618. {
  619. if(strBuffer.EndsWith("rn."))
  620. return strBuffer.Substring(0,strBuffer.Length-"rn.".Length);
  621. else
  622. return strBuffer;
  623. }
  625. /// <summary>
  626. /// parse message body
  627. /// </summary>
  628. /// <param name="strBuffer">raw message body</param>
  629. public void GetMessageBody(string strBuffer)
  630. {
  631. int end, begin;
  632. string body;
  633. string encoding="";
  635. begin = end = 0;
  636. _messageBody.Clear();
  638. try
  639. {
  640. if(Utility.IsOrNullTextEx(strBuffer))
  641. return;
  642. else if(Utility.IsOrNullTextEx(_contentType) && _contentTransferEncoding==null)
  643. {
  644. _messageBody.Add(GetTextBody(strBuffer));
  645. }
  646. else if(_contentType!=null && _contentType.IndexOf("digest") >= 0)
  647. {
  648. // this is a digest method
  649. //ParseDigestMessage(strBuffer);
  650. _messageBody.Add(GetTextBody(strBuffer));
  651. }
  652. else if(_attachmentboundry2==null)
  653. {
  654. body=GetTextBody(strBuffer);
  656. if(Utility.IsQuotedPrintable(_contentTransferEncoding))
  657. {
  658. body=DecodeQP.ConvertHexContent(body);
  659. }
  660. else if(Utility.IsBase64(_contentTransferEncoding))
  661. {
  662. body=Utility.deCodeB64s(Utility.RemoveNonB64(body));
  663. }
  664. else if(Utility.IsNotNullText(_contentCharset))
  665. {
  666. body=Encoding.GetEncoding(_contentCharset).GetString(Encoding.Default.GetBytes(body));
  667. }
  668. _messageBody.Add(Utility.RemoveNonB64(body));
  669. }
  670. else
  671. {
  672. begin =0;
  674. while(begin!=-1)
  675. {
  676. // find "rnrn" denoting end of header
  677. begin = strBuffer.IndexOf("--" + _attachmentboundry2,begin);
  678. if(begin!=-1)
  679. {
  680. encoding=MIMETypes.GetContentTransferEncoding(strBuffer,begin);
  682. begin = strBuffer.IndexOf("rnrn",begin+1);//strBuffer.LastIndexOfAny(ALPHABET.ToCharArray());
  684. // find end of text
  685. end = strBuffer.IndexOf("--" + _attachmentboundry2,begin+1);
  687. if(begin!=-1)
  688. {
  689. if(end!=-1)
  690. {
  691. begin += 4;
  692. if(begin>=end)
  693. continue;
  694. else if (this._contentEncoding!=null && this._contentEncoding.IndexOf("8bit")!=-1)
  695. body=Utility.Change(strBuffer.Substring(begin, end - begin-2 ),_contentCharset);
  696. else
  697. body=strBuffer.Substring(begin, end - begin-2);
  698. }
  699. else
  700. {
  701. body=strBuffer.Substring(begin);
  702. }
  704. if(Utility.IsQuotedPrintable(encoding))
  705. {
  706. string ret=body;
  707. ret=DecodeQP.ConvertHexContent(ret);
  708. _messageBody.Add(ret);
  709. }
  710. else if(Utility.IsBase64(encoding))
  711. {
  712. string ret=Utility.RemoveNonB64(body);
  713. ret=Utility.deCodeB64s(ret);
  714. if(ret!="")
  715. _messageBody.Add(ret);
  716. else
  717. _messageBody.Add(body);
  718. }
  719. else
  720. _messageBody.Add(body);
  722. if(end==-1)break;
  723. }
  724. else
  725. {
  726. break;
  727. }
  728. }
  729. else
  730. {
  731. if(_messageBody.Count==0)
  732. {
  733. _messageBody.Add(strBuffer);
  734. }
  735. break;
  736. }
  737. }
  738. }
  739. }
  740. catch(Exception e)
  741. {
  742. Utility.LogError("GetMessageBody():"+e.Message);
  743. _messageBody.Add(Utility.deCodeB64s(strBuffer));
  744. }
  746. if(_messageBody.Count>1)
  747. _html=true;
  748. }
  750. /// <summary>
  751. /// verify if the message is a report
  752. /// </summary>
  753. /// <returns>if it is a report message, return true, else, false</returns>
  754. public bool IsReport()
  755. {
  756. if(Utility.IsNotNullText(_contentType))
  757. return (_contentType.ToLower().IndexOf("report".ToLower())!=-1);
  758. else
  759. return false;
  760. }
  762. /// <summary>
  763. /// verify if the attachment is MIME Email file
  764. /// </summary>
  765. /// <param name="attItem">attachment</param>
  766. /// <returns>if MIME Email file, return true, else, false</returns>
  767. public bool IsMIMEMailFile(Attachment attItem)
  768. {
  769. try
  770. {
  771. return (attItem.ContentFileName.ToLower().EndsWith(".eml".ToLower()) || attItem.ContentType.ToLower()=="message/rfc822".ToLower());
  772. }
  773. catch(Exception e)
  774. {
  775. Utility.LogError("IsMIMEMailFile():"+e.Message);
  776. return false;
  777. }
  778. }
  780. /// <summary>
  781. /// translate pictures url within the body
  782. /// </summary>
  783. /// <param name="strBody">message body</param>
  784. /// <param name="hsbFiles">pictures collection</param>
  785. /// <returns>translated message body</returns>
  786. public string TranslateHTMLPictureFiles(string strBody, Hashtable hsbFiles)
  787. {
  788. try
  789. {
  790. for(int i=0;i<this.AttachmentCount;i++)
  791. {
  792.                     Attachment att = this.GetAttachment(i);
  793. if(Utility.IsPictureFile(att.ContentFileName)==true)
  794. {
  795. if(Utility.IsNotNullText(att.ContentID))
  796. //support for embedded pictures
  797. strBody=strBody.Replace("cid:"+att.ContentID,hsbFiles[att.ContentFileName].ToString());
  799. strBody=strBody.Replace(att.ContentFileName,hsbFiles[att.ContentFileName].ToString());
  800. }
  801. }
  802. }
  803. catch(Exception e)
  804. {
  805. Utility.LogError("TranslateHTMLPictureFiles():"+e.Message);
  806. }
  807. return strBody;
  808. }
  810. /// <summary>
  811. /// translate pictures url within the body
  812. /// </summary>
  813. /// <param name="strBody">message body</param>
  814. /// <param name="strPath">path of the pictures</param>
  815. /// <returns>translated message body</returns>
  816. public string TranslateHTMLPictureFiles(string strBody, string strPath)
  817. {
  818. try
  819. {
  820. if(!strPath.EndsWith("\"))
  821. {
  822. strPath+="\";
  823. }
  824. for(int i=0;i<this.AttachmentCount;i++)
  825. {
  826. Attachment att=this.GetAttachment(i);
  827. if(Utility.IsPictureFile(att.ContentFileName)==true)
  828. {
  829. if(Utility.IsNotNullText(att.ContentID))
  830. //support for embedded pictures
  831. strBody=strBody.Replace("cid:"+att.ContentID,strPath+att.ContentFileName);
  832. strBody=strBody.Replace(att.ContentFileName,strPath+att.ContentFileName);
  833. }
  834. }
  835. }
  836. catch(Exception e)
  837. {
  838. Utility.LogError("TranslateHTMLPictureFiles():"+e.Message);
  839. }
  840. return strBody;
  841. }
  843. /// <summary>
  844. /// Get the proper attachment file name
  845. /// </summary>
  846. /// <param name="attItem">attachment</param>
  847. /// <returns>propery attachment file name</returns>
  848. public string GetAttachmentFileName(Attachment attItem)
  849. {
  851. int items=0;
  853. //return unique body file names
  854. for(int i=0;i<_attachments.Count;i++)
  855. {
  856. if(attItem.ContentFileName==attItem.DefaultFileName)
  857. {
  858. items++;
  859. attItem.ContentFileName=attItem.DefaultFileName2.Replace("*",items.ToString());
  860. }
  861. }
  862. string name=attItem.ContentFileName;
  863.                 
  864. return (name==null||name==""?(IsReport()==true?(this.IsMIMEMailFile(attItem)==true?attItem.DefaultMIMEFileName:attItem.DefaultReportFileName):(attItem.ContentID!=null?attItem.ContentID:attItem.DefaultFileName)):name);
  865. }
  867. /// <summary>
  868. /// save attachments to a defined path
  869. /// </summary>
  870. /// <param name="strPath">path to have attachments to be saved to</param>
  871. /// <returns>true if save successfully, false if failed</returns>
  872. public bool SaveAttachments(string strPath)
  873. {
  874. if(Utility.IsNotNullText(strPath))
  875. {
  876. try
  877. {
  878. bool blnRet=true;
  880. if(!strPath.EndsWith("\"))
  881. {
  882. strPath+="\";
  883. }
  884. for(int i=0;i<this.Attachments.Count;i++)
  885. {
  886.                         
  887. Attachment att=GetAttachment(i);
  888.                         if (att.NotAttachment)
  889.                             continue;
  890. blnRet=SaveAttachment(att,strPath+GetAttachmentFileName(att));
  891. if(!blnRet)
  892. break;
  893. }
  894. return blnRet;
  895. }
  896. catch(Exception e)
  897. {
  898. Utility.LogError(e.Message);
  899. return false;
  900. }
  901. }
  902. else
  903. return false;
  904. }
  906. /// <summary>
  907. /// save attachment to file
  908. /// </summary>
  909. /// <param name="attItem">Attachment</param>
  910. /// <param name="strFileName">File to be saved to</param>
  911. /// <returns>true if save successfully, false if failed</returns>
  912. public bool SaveAttachment(Attachment attItem, string strFileName)
  913. {
  914. byte[] da;
  915. try
  916. {
  917. // FileStream fs=File.Create(strFileName);
  918. // byte[] da;
  919. // if(attItem.ContentFileName.Length>0)
  920. // {
  921. // da=attItem.DecodedAttachment;
  922. // }
  923. // else
  924. // {
  925. // this.GetMessageBody(attItem.DecodeAttachmentAsText());
  926. // da=Encoding.Default.GetBytes((string)this.MessageBody[this.MessageBody.Count-1]);
  927. // }
  928. // fs.Write(da,0,da.Length);
  929. // fs.Close();
  930. // return true;
  931. if(attItem.InBytes)
  932. {
  933. da=attItem.RawBytes;
  934. }
  935. else if(attItem.ContentFileName.Length>0)
  936. {
  937. da=attItem.DecodedAttachment;
  938. }
  939. else if(attItem.ContentType.ToLower()=="message/rfc822".ToLower())
  940. {
  941. da=Encoding.Default.GetBytes(attItem.RawAttachment);
  942. }
  943. else
  944. {
  945. this.GetMessageBody(attItem.DecodeAsText());
  946. da=Encoding.Default.GetBytes((string)this.MessageBody[this.MessageBody.Count-1]);
  947. }
  948. return Utility.SaveByteContentToFile(strFileName,da);
  949. }
  950. catch
  951. {
  952. /*Utility.LogError("SaveAttachment():"+e.Message);
  953. return false;*/
  954. da=Encoding.Default.GetBytes(attItem.RawAttachment);
  955. return Utility.SaveByteContentToFile(strFileName,da);
  956. }
  957. }
  959. /// <summary>
  960. /// set attachments
  961. /// </summary>
  962. private void set_attachments()
  963. {
  964. int indexOf_attachmentstart=0;
  965. int indexOfAttachmentEnd=0;
  966. bool processed=false;
  968. Attachment att=null;
  970. SetAttachmentBoundry2(_rawMessageBody);
  972. while(!processed)
  973. {
  974. if(Utility.IsNotNullText(_attachmentboundry))
  975. {
  976. indexOf_attachmentstart=_rawMessageBody.IndexOf(_attachmentboundry,indexOf_attachmentstart)+_attachmentboundry.Length;
  977. if(_rawMessageBody==""||indexOf_attachmentstart<0)return;
  979. indexOfAttachmentEnd=_rawMessageBody.IndexOf(_attachmentboundry,indexOf_attachmentstart+1);
  980. }
  981. else
  982. {
  983. indexOfAttachmentEnd=-1;
  984. }
  986. //if(indexOfAttachmentEnd<0)return;
  987. if(indexOfAttachmentEnd!=-1)
  988. {
  989. }
  990. else if(indexOfAttachmentEnd==-1&&!processed&&_attachmentCount==0) 
  991. {
  992. processed=true;
  993. indexOfAttachmentEnd=_rawMessageBody.Length;
  994. }
  995. else
  996. return;
  998. if(indexOf_attachmentstart==indexOfAttachmentEnd-9)
  999. {
  1000. indexOf_attachmentstart=0;
  1001. processed=true;
  1002. }
  1004. string strLine=_rawMessageBody.Substring(indexOf_attachmentstart,(indexOfAttachmentEnd-indexOf_attachmentstart-2));            
  1005. bool isMSTNEF;
  1006. isMSTNEF=MIMETypes.IsMSTNEF(_contentType);
  1007. att=new Attachment(strLine.Trim(),_contentType,!isMSTNEF);
  1010. //ms-tnef format might contain multiple attachments
  1011. if(MIMETypes.IsMSTNEF(att.ContentType) && AutoDecodeMSTNEF && !isMSTNEF) 
  1012. {
  1013. Utility.LogError("set_attachments():found ms-tnef file");
  1014. TNEFParser tnef=new TNEFParser();
  1015. TNEFAttachment tatt=new TNEFAttachment();
  1016. Attachment attNew=null;
  1017.                     tnef.Verbose = false;
  1018.                     tnef.BasePath = this.BasePath;
  1019.                     //tnef.LogFilePath=this.BasePath + "OpenPOP.TNEF.log";
  1020.                     if (tnef.OpenTNEFStream(att.DecodedAsBytes()))
  1021.                     {
  1022.                         if (tnef.Parse())
  1023.                         {
  1024.                             for (IDictionaryEnumerator i = tnef.Attachments().GetEnumerator(); i.MoveNext(); )
  1025.                             {
  1026.                                 tatt = (TNEFAttachment)i.Value;
  1027.                                 attNew = new Attachment(tatt.FileContent, tatt.FileLength, tatt.FileName, MIMETypes.GetMimeType(tatt.FileName));
  1028.                                 _attachmentCount++;
  1029.                                 _attachments.Add(attNew);
  1030.                             }
  1031.                         }
  1032.                         else
  1033.                             Utility.LogError("set_attachments():ms-tnef file parse failed");
  1034.                     }
  1035.                     else
  1036.                         Utility.LogError("set_attachments():ms-tnef file open failed");
  1037.                 }
  1038.                 else
  1039.                 {
  1040.                     _attachmentCount++;
  1042.                     if (!att.NotAttachment)
  1043.                     {
  1044.                         _hasRealAttachment = true;
  1045.                         _realAttachmentCount++;
  1046.                     }
  1048.                     _attachments.Add(att);
  1049.                 }
  1051. indexOf_attachmentstart++;
  1052. }
  1053. }
  1055. /// <summary>
  1056. /// Set alternative attachment boundry
  1057. /// </summary>
  1058. /// <param name="strBuffer">raw message</param>
  1059. private void SetAttachmentBoundry2(string strBuffer)
  1060. {
  1061. int indexOfAttachmentBoundry2Begin=0;
  1062. int indexOfAttachmentBoundry2End=0;
  1063. indexOfAttachmentBoundry2Begin=strBuffer.ToLower().IndexOf("Multipart/Alternative".ToLower());
  1064. if(indexOfAttachmentBoundry2Begin!=-1)
  1065. {
  1066. /* indexOfAttachmentBoundry2Begin=strBuffer.IndexOf("boundary="");
  1067. indexOfAttachmentBoundry2End=strBuffer.IndexOf(""",indexOfAttachmentBoundry2Begin+10);
  1068. if(indexOfAttachmentBoundry2Begin!=-1&&indexOfAttachmentBoundry2End!=-1)
  1069. _attachmentboundry2=strBuffer.Substring(indexOfAttachmentBoundry2Begin+10,indexOfAttachmentBoundry2End-indexOfAttachmentBoundry2Begin-10).Trim();
  1070. */
  1071. indexOfAttachmentBoundry2Begin=strBuffer.IndexOf("boundary=");
  1072. if(indexOfAttachmentBoundry2Begin!=-1)
  1073. {
  1074. int p=strBuffer.IndexOf("rn",indexOfAttachmentBoundry2Begin);
  1075. string s=strBuffer.Substring(indexOfAttachmentBoundry2Begin+29,4);
  1076. indexOfAttachmentBoundry2End=strBuffer.IndexOf("rn",indexOfAttachmentBoundry2Begin+9);
  1077. if(indexOfAttachmentBoundry2End==-1)
  1078. indexOfAttachmentBoundry2End=strBuffer.Length;
  1079. _attachmentboundry2=Utility.RemoveQuote(strBuffer.Substring(indexOfAttachmentBoundry2Begin+9,indexOfAttachmentBoundry2End-indexOfAttachmentBoundry2Begin-9));
  1080. }
  1081. }
  1082. else
  1083. {
  1084. _attachmentboundry2=_attachmentboundry;
  1085. }
  1086. }
  1088. /// <summary>
  1089. /// Save message content to eml file
  1090. /// </summary>
  1091. /// <param name="strFile"></param>
  1092. /// <returns></returns>
  1093. public bool SaveToMIMEEmailFile(string strFile,bool blnReplaceExists)
  1094. {
  1095. return Utility.SavePlainTextToFile(strFile,_rawMessage,blnReplaceExists);
  1096. }
  1098. /// <summary>
  1099. /// parse multi-line header
  1100. /// </summary>
  1101. /// <param name="sbdBuilder">string builder to hold header content</param>
  1102. /// <param name="srdReader">string reader to get each line of the header</param>
  1103. /// <param name="strValue">first line content</param>
  1104. /// <param name="strLine">reference header line</param>
  1105. /// <param name="alCollection">collection to hold every content line</param>
  1106. private void ParseStreamLines(StringBuilder sbdBuilder
  1107. ,StringReader srdReader
  1108. ,string strValue
  1109. ,ref string strLine
  1110. ,ArrayList alCollection)
  1111. {
  1112. string strFormmated;
  1113. int intLines=0;
  1114. alCollection.Add(strValue);
  1116. sbdBuilder.Append(strLine);
  1118. strLine=srdReader.ReadLine();
  1120. while(strLine.Trim()!="" && (strLine.StartsWith("t") || strLine.StartsWith(" ")))
  1121. {
  1122. strFormmated=strLine.Substring(1);
  1123. alCollection.Add(Utility.DecodeLine(strFormmated));
  1124. sbdBuilder.Append(strLine);
  1125. strLine=srdReader.ReadLine();
  1126. intLines++;
  1127. }
  1129. if(strLine!="")
  1130. {
  1131. sbdBuilder.Append(strLine);
  1132. }
  1133. else
  1134. if(intLines==0)
  1135. {
  1136. strLine=srdReader.ReadLine();
  1137. sbdBuilder.Append(strLine);
  1138. }
  1140. ParseHeader(sbdBuilder,srdReader,ref strLine);
  1141. }
  1143. /// <summary>
  1144. /// parse multi-line header
  1145. /// </summary>
  1146. /// <param name="sbdBuilder">string builder to hold header content</param>
  1147. /// <param name="srdReader">string reader to get each line of the header</param>
  1148. /// <param name="strName">collection key</param>
  1149. /// <param name="strValue">first line content</param>
  1150. /// <param name="strLine">reference header line</param>
  1151. /// <param name="hstCollection">collection to hold every content line</param>
  1152. private void ParseStreamLines(StringBuilder sbdBuilder
  1153. ,StringReader srdReader
  1154. ,string strName
  1155. ,string strValue
  1156. ,ref string strLine
  1157. ,Hashtable hstCollection)
  1158. {
  1159. string strFormmated;
  1160. string strReturn=strValue;
  1161. int intLines=0;
  1163. //sbdBuilder.Append(strLine);
  1165. strLine=srdReader.ReadLine();
  1166. while(strLine.Trim()!="" && (strLine.StartsWith("t") || strLine.StartsWith(" ")))
  1167. {
  1168. strFormmated=strLine.Substring(1);
  1169. strReturn+=Utility.DecodeLine(strFormmated);
  1170. sbdBuilder.Append(strLine + "rn");
  1171. strLine=srdReader.ReadLine();
  1172. intLines++;
  1173. }
  1174. if(!hstCollection.ContainsKey(strName))
  1175. hstCollection.Add(strName,strReturn);
  1177. if(strLine!="")
  1178. {
  1179. sbdBuilder.Append(strLine + "rn");
  1180. }
  1181. else
  1182. if(intLines==0)
  1183. {
  1184. // strLine=srdReader.ReadLine();
  1185. // sbdBuilder.Append(strLine + "rn");
  1186. }
  1188. ParseHeader(sbdBuilder,srdReader,ref strLine);
  1189. }
  1191. /// <summary>
  1192. /// parse multi-line header
  1193. /// </summary>
  1194. /// <param name="sbdBuilder">string builder to hold header content</param>
  1195. /// <param name="srdReader">string reader to get each line of the header</param>
  1196. /// <param name="strValue">first line content</param>
  1197. /// <param name="strLine">reference header line</param>
  1198. /// <param name="strReturn">return value</param>
  1199. /// <param name="blnLineDecode">decode each line</param>
  1200. private void ParseStreamLines(StringBuilder sbdBuilder
  1201. ,StringReader srdReader
  1202. ,string strValue
  1203. ,ref string strLine
  1204. ,ref string strReturn
  1205. ,bool blnLineDecode)
  1206. {
  1207. string strFormmated;
  1208. int intLines=0;
  1209. strReturn=strValue;
  1211. sbdBuilder.Append(strLine + "rn");
  1213. if(blnLineDecode==true)
  1214. strReturn=Utility.DecodeLine(strReturn);
  1216. strLine=srdReader.ReadLine();
  1217. while(strLine.Trim()!="" && (strLine.StartsWith("t") || strLine.StartsWith(" ")))
  1218. {
  1219. strFormmated=strLine.Substring(1);
  1220. strReturn+=(blnLineDecode==true?Utility.DecodeLine(strFormmated):"rn"+strFormmated);
  1221. sbdBuilder.Append(strLine + "rn");
  1222. strLine=srdReader.ReadLine();
  1223. intLines++;
  1224. }
  1226. if(strLine!="")
  1227. {
  1228. sbdBuilder.Append(strLine + "rn");
  1229. }
  1230. else
  1231. if(intLines==0)
  1232. {
  1233. strLine=srdReader.ReadLine();
  1234. sbdBuilder.Append(strLine + "rn");
  1235. }
  1237. if(!blnLineDecode)
  1238. {
  1239. strReturn=Utility.RemoveWhiteBlanks(Utility.DecodeText(strReturn));
  1240. }
  1242. ParseHeader(sbdBuilder,srdReader,ref strLine);
  1243. }
  1245. /// <summary>
  1246. /// Parse the headers populating respective member fields
  1247. /// </summary>
  1248. /// <param name="sbdBuilder">string builder to hold the header content</param>
  1249. /// <param name="srdReader">string reader to get each line of the header</param>
  1250. /// <param name="strLine">reference header line</param>
  1251. private void ParseHeader(StringBuilder sbdBuilder,StringReader srdReader,ref string strLine)
  1252. {
  1253. string []array=Utility.GetHeadersValue(strLine);//Regex.Split(strLine,":");
  1255. switch(array[0].ToUpper())
  1256. {
  1257. case "TO":
  1258. _to=array[1].Split(',');
  1259. for(int i=0;i<_to.Length;i++)
  1260. {
  1261. _to[i]=Utility.DecodeLine(_to[i].Trim());
  1262. }
  1263. break;
  1265. case "CC":
  1266. _cc=array[1].Split(',');
  1267. for(int i=0;i<_cc.Length;i++)
  1268. {
  1269. _cc[i]=Utility.DecodeLine(_cc[i].Trim());
  1270. }
  1271. break;
  1273. case "BCC":
  1274. _bcc=array[1].Split(',');
  1275. for(int i=0;i<_bcc.Length;i++)
  1276. {
  1277. _bcc[i]=Utility.DecodeLine(_bcc[i].Trim());
  1278. }
  1279. break;
  1281. case "FROM":
  1282. Utility.ParseEmailAddress(array[1],ref _from,ref _fromEmail);
  1283. break;
  1285. case "REPLY-TO":
  1286. Utility.ParseEmailAddress(array[1],ref _replyTo,ref _replyToEmail);
  1287. break;
  1289. case "KEYWORDS": //ms outlook keywords
  1290. ParseStreamLines(sbdBuilder,srdReader,array[1].Trim(),ref strLine,_keywords);
  1291. break;
  1293. case "RECEIVED":
  1294. ParseStreamLines(sbdBuilder,srdReader,array[1].Trim(),ref strLine,ref _received,true);
  1295. break;
  1297. case "IMPORTANCE":
  1298. _importance=array[1].Trim();
  1299. break;
  1301. case "DISPOSITION-NOTIFICATION-TO":
  1302. _dispositionNotificationTo=array[1].Trim();
  1303. break;
  1305. case "MIME-VERSION":
  1306. _mimeVersion=array[1].Trim();
  1307. break;
  1309. case "SUBJECT":
  1310. case "THREAD-TOPIC":
  1311. string strRet=null;
  1312. for(int i=1;i<array.Length;i++)
  1313. {
  1314. strRet+=array[i];
  1315. }
  1316. ParseStreamLines(sbdBuilder,srdReader,strRet,ref strLine,ref _subject,false);
  1317. break;
  1319. case "RETURN-PATH":
  1320. _returnPath=array[1].Trim().Trim('>').Trim('<');
  1321. break;
  1323. case "MESSAGE-ID":
  1324. _messageID=array[1].Trim().Trim('>').Trim('<');
  1325. break;
  1327. case "DATE":
  1328. for(int i=1;i<array.Length;i++)
  1329. {
  1330. _dateTimeInfo+=array[i];
  1331. }
  1332. _dateTimeInfo=_dateTimeInfo.Trim();
  1333. _date=Utility.ParseEmailDate(_dateTimeInfo);
  1334. break;
  1336. case "CONTENT-LENGTH":
  1337. _contentLength=Convert.ToInt32(array[1]);
  1338. break;
  1340. case "CONTENT-TRANSFER-ENCODING":
  1341. _contentTransferEncoding=array[1].Trim();
  1342. break;
  1344. case "CONTENT-TYPE":
  1345. //if already content type has been assigned
  1346. if(_contentType!=null)
  1347. return;
  1349. strLine=array[1];
  1351. _contentType=strLine.Split(';')[0];
  1352. _contentType=_contentType.Trim();
  1354. int intCharset=strLine.IndexOf("charset=");
  1355. if(intCharset!=-1)
  1356. {
  1357. int intBound2=strLine.ToLower().IndexOf(";",intCharset+8);
  1358. if(intBound2==-1)
  1359. intBound2=strLine.Length;
  1360. intBound2-=(intCharset+8);
  1361. _contentCharset=strLine.Substring(intCharset+8,intBound2);
  1362. _contentCharset=Utility.RemoveQuote(_contentCharset);
  1363. }
  1364. else 
  1365. {
  1366. intCharset=strLine.ToLower().IndexOf("report-type=".ToLower());
  1367. if(intCharset!=-1)
  1368. {
  1369. int intPos=strLine.IndexOf(";",intCharset+13);
  1370. _reportType=strLine.Substring(intCharset+12,intPos-intCharset-13);
  1371. }
  1372. else if(strLine.ToLower().IndexOf("boundary=".ToLower())==-1)
  1373. {
  1374. strLine=srdReader.ReadLine();
  1375. if (strLine=="")
  1376. return;
  1377. intCharset=strLine.ToLower().IndexOf("charset=".ToLower());
  1378. if(intCharset!=-1)
  1379. _contentCharset=strLine.Substring(intCharset+9,strLine.Length-intCharset-10);
  1380. else if(strLine.IndexOf(":")!=-1)
  1381. {
  1382. sbdBuilder.Append(strLine + "rn");
  1383. ParseHeader(sbdBuilder,srdReader,ref strLine);
  1384. return;
  1385. }
  1386. else
  1387. {
  1388. sbdBuilder.Append(strLine + "rn");
  1389. }
  1390. }
  1391. }
  1392. if(_contentType=="text/plain")
  1393. return;
  1394. else if(_contentType.ToLower()=="text/html"||_contentType.ToLower().IndexOf("multipart/")!=-1)
  1395. _html=true;
  1397. if(strLine.Trim().Length==_contentType.Length+1 || strLine.ToLower().IndexOf("boundary=".ToLower())==-1)
  1398. {
  1399. strLine=srdReader.ReadLine();
  1400. if(strLine==null||strLine==""||strLine.IndexOf(":")!=-1)
  1401. {
  1402. sbdBuilder.Append(strLine + "rn");
  1403. ParseHeader(sbdBuilder,srdReader,ref strLine);
  1404. return;
  1405. }
  1406. else
  1407. {
  1408. sbdBuilder.Append(strLine + "rn");
  1409. }
  1411. if(strLine.ToLower().IndexOf("boundary=".ToLower())==-1)
  1412. {
  1413. _attachmentboundry=srdReader.ReadLine();
  1414. sbdBuilder.Append(_attachmentboundry+"rn");
  1415. }
  1416. _attachmentboundry=strLine;
  1417. }
  1418. else
  1419. {
  1420. /*if(strLine.IndexOf(";")!=-1)
  1421. _attachmentboundry=strLine.Split(';')[1];
  1422. else*/
  1423. _attachmentboundry=strLine;
  1424. }
  1426. int intBound=_attachmentboundry.ToLower().IndexOf("boundary=");
  1427. if(intBound!=-1)
  1428. {
  1429. int intBound2=_attachmentboundry.ToLower().IndexOf(";",intBound+10);
  1430. if(intBound2==-1)
  1431. intBound2=_attachmentboundry.Length;
  1432. intBound2-=(intBound+9);
  1433. _attachmentboundry=_attachmentboundry.Substring(intBound+9,intBound2);
  1434. }
  1435. _attachmentboundry=Utility.RemoveQuote(_attachmentboundry);
  1436. _hasAttachment=true;
  1438. break;
  1440. default:
  1441. if(array.Length>1) //here we parse all custom headers
  1442. {
  1443. string headerName=array[0].Trim();
  1444. if(headerName.ToUpper().StartsWith("X")) //every custom header starts with "X"
  1445. {
  1446. ParseStreamLines(sbdBuilder,srdReader,headerName,array[1].Trim(),ref strLine,_customHeaders);
  1447. }
  1448. }
  1449. break;
  1450. }
  1451. }
  1454. }
  1455. }