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

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

Email客户端

开发平台：

C#

Attachment.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.Attachment
  20. *Function: Attachment
  21. *Author: Hamid Qureshi
  22. *Created: 2003/8
  23. *Last Modified: 2004/5/28 10:19 GMT+8 by Unruled Boy
  24. *Description:
  25. *Changes:
  26. * 2004/5/28 10:19 GMT+8 by grandepuffo via Unruled Boy
  27. * 1.Fixed a bug in parsing ContentFileName @ https://sourceforge.net/forum/message.php?msg_id=2589759
  28. * 2004/5/17 14:20 GMT+8 by Unruled Boy
  29. * 1.Fixed a bug in parsing FileName
  30. * 2004/5/8 17:00 GMT+8 by Unruled Boy
  31. * 1.Again, hopefully we have handled the NotAttachment property correctly
  32. * 2004/5/1 14:13 GMT+8 by Unruled Boy
  33. * 1.Adding three more constructors
  34. * 2.Adding descriptions to every public functions/property/void
  35. * 2004/4/29 19:05 GMT+8 by Unruled Boy
  36. * 1.Hopefully we have handled the NotAttachment property correctly
  37. * 2004/3/29 10:28 GMT+8 by Unruled Boy
  38. * 1.removing bugs in decoding attachment
  39. * 2004/3/29 17:32 GMT+8 by Unruled Boy
  40. * 1.support for reply message using ms-tnef 
  41. * 2.adding detail description for every function
  42. * 3.cleaning up the codes
  43. */
  44. using System;
  45. using System.IO;
  46. using System.Text;
  47. using System.Text.RegularExpressions;
  49. namespace OpenPOP.MIMEParser
  50. {
  51. /// <summary>
  52. /// Summary description for Attachment.
  53. /// </summary>
  54. public class Attachment : IComparable
  55. {
  56. #region Member Variables
  57. private string _contentType=null;
  58. private string _contentCharset=null;
  59. private string _contentFormat=null;
  60. private string _contentTransferEncoding=null;
  61. private string _contentDescription=null;
  62. private string _contentDisposition=null;
  63. private string _contentFileName="";
  64. private string _defaultFileName="body.htm";
  65. private string _defaultFileName2="body*.htm";
  66. private string _defaultReportFileName="report.htm";
  67. private string _defaultMIMEFileName="body.eml";
  68. private string _defaultMSTNEFFileName="winmail.dat";
  69. private string _contentID=null;
  70. private long _contentLength=0;
  71. private string _rawAttachment=null;
  72. private bool _inBytes=false;
  73. private byte[] _rawBytes=null;
  74. #endregion
  77. #region Properties
  78. /// <summary>
  79. /// raw attachment content bytes
  80. /// </summary>
  81. public byte[] RawBytes
  82. {
  83. get{return _rawBytes;}
  84. set{_rawBytes=value;}
  85. }
  87. /// <summary>
  88. /// whether attachment is in bytes
  89. /// </summary>
  90. public bool InBytes
  91. {
  92. get{return _inBytes;}
  93. set{_inBytes=value;}
  94. }
  96. /// <summary>
  97. /// Content length
  98. /// </summary>
  99. public long ContentLength
  100. {
  101. get{return _contentLength;}
  102. }
  104. /// <summary>
  105. /// verify the attachment whether it is a real attachment or not
  106. /// </summary>
  107. /// <remarks>this is so far not comprehensive and needs more work to finish</remarks>
  108. public bool NotAttachment
  109. {
  110. get
  111. {
  112. /* if (_contentDisposition==null||_contentType==null)
  113. return true;
  114. else
  115. return (_contentDisposition.IndexOf("attachment")==-1 && _contentType.IndexOf("text/plain")!=-1); */
  116. /* if (_contentType==null)
  117. return true;
  118. else
  119. return (_contentFileName!="");*/
  120. if ((_contentType==null||_contentFileName=="") && _contentID==null)//&&_contentType.ToLower().IndexOf("text/")!=-1)
  121. return true;
  122. else
  123. return false;
  125. }
  126. }
  128. /// <summary>
  129. /// Content format
  130. /// </summary>
  131. public string ContentFormat
  132. {
  133. get{return _contentFormat;}
  134. }
  136. /// <summary>
  137. /// Content charset
  138. /// </summary>
  139. public string ContentCharset
  140. {
  141. get{return _contentCharset;}
  142. }
  144. /// <summary>
  145. /// default file name
  146. /// </summary>
  147. public string DefaultFileName
  148. {
  149. get{return _defaultFileName;}
  150. set{_defaultFileName=value;}
  151. }
  153. /// <summary>
  154. /// default file name 2
  155. /// </summary>
  156. public string DefaultFileName2
  157. {
  158. get{return _defaultFileName2;}
  159. set{_defaultFileName2=value;}
  160. }
  162. /// <summary>
  163. /// default report file name
  164. /// </summary>
  165. public string DefaultReportFileName
  166. {
  167. get{return _defaultReportFileName;}
  168. set{_defaultReportFileName=value;}
  169. }
  171. /// <summary>
  172. /// default MIME File Name
  173. /// </summary>
  174. public string DefaultMIMEFileName
  175. {
  176. get{return _defaultMIMEFileName;}
  177. set{_defaultMIMEFileName=value;}
  178. }
  180. /// <summary>
  181. /// Content Type
  182. /// </summary>
  183. public string ContentType
  184. {
  185. get{return _contentType;}
  186. }
  188. /// <summary>
  189. /// Content Transfer Encoding
  190. /// </summary>
  191. public string ContentTransferEncoding
  192. {
  193. get{return _contentTransferEncoding;}
  194. }
  196. /// <summary>
  197. /// Content Description
  198. /// </summary>
  199. public string ContentDescription
  200. {
  201. get{return _contentDescription;}
  202. }
  204. /// <summary>
  205. /// Content File Name
  206. /// </summary>
  207. public string ContentFileName
  208. {
  209. get{return _contentFileName;}
  210. set{_contentFileName=value;}
  211. }
  213. /// <summary>
  214. /// Content Disposition
  215. /// </summary>
  216. public string ContentDisposition
  217. {
  218. get{return _contentDisposition;}
  219. }
  221. /// <summary>
  222. /// Content ID
  223. /// </summary>
  224. public string ContentID
  225. {
  226. get{return _contentID;}
  227. }
  229. /// <summary>
  230. /// Raw Attachment
  231. /// </summary>
  232. public string RawAttachment
  233. {
  234. get{return _rawAttachment;}
  235. }
  237. /// <summary>
  238. /// decoded attachment in bytes
  239. /// </summary>
  240. public byte[] DecodedAttachment
  241. {
  242. get
  243. {
  244. return DecodedAsBytes();
  245. }
  246. }
  247. #endregion
  250. /// <summary>
  251. /// release all objects
  252. /// </summary>
  253. ~Attachment()
  254. {
  255. _rawBytes=null;
  256. _rawAttachment=null;
  257. }
  259. /// <summary>
  260. /// New Attachment
  261. /// </summary>
  262. /// <param name="bytAttachment">attachment bytes content</param>
  263. /// <param name="lngFileLength">file length</param>
  264. /// <param name="strFileName">file name</param>
  265. /// <param name="strContentType">content type</param>
  266. public Attachment(byte[] bytAttachment, long lngFileLength, string strFileName, string strContentType)
  267. {
  268. _inBytes=true;
  269. _rawBytes=bytAttachment;
  270. _contentLength=lngFileLength;
  271. _contentFileName=strFileName;
  272. _contentType=strContentType;
  273. }
  275. /// <summary>
  276. /// New Attachment
  277. /// </summary>
  278. /// <param name="bytAttachment">attachment bytes content</param>
  279. /// <param name="strFileName">file name</param>
  280. /// <param name="strContentType">content type</param>
  281. public Attachment(byte[] bytAttachment, string strFileName, string strContentType)
  282. {
  283. _inBytes=true;
  284. _rawBytes=bytAttachment;
  285. _contentLength=bytAttachment.Length;
  286. _contentFileName=strFileName;
  287. _contentType=strContentType;
  288. }
  290. /// <summary>
  291. /// New Attachment
  292. /// </summary>
  293. /// <param name="strAttachment">attachment content</param>
  294. /// <param name="strContentType">content type</param>
  295. /// <param name="blnParseHeader">whether only parse the header or not</param>
  296. public Attachment(string strAttachment,string strContentType, bool blnParseHeader)
  297. {
  298. if(!blnParseHeader)
  299. {
  300. _contentFileName=_defaultMSTNEFFileName;
  301. _contentType=strContentType;
  302. }
  303. this.NewAttachment(strAttachment,blnParseHeader);
  304. }
  306. /// <summary>
  307. /// New Attachment
  308. /// </summary>
  309. /// <param name="strAttachment">attachment content</param>
  310. public Attachment(string strAttachment)
  311. {
  312. this.NewAttachment(strAttachment,true);
  313. }
  316. /// <summary>
  317. /// create attachment
  318. /// </summary>
  319. /// <param name="strAttachment">raw attachment text</param>
  320. /// <param name="blnParseHeader">parse header</param>
  321.         ///
  322.         private void NewAttachment(string strAttachment, bool blnParseHeader)
  323.         {
  324.             _inBytes = false;
  326.             if (strAttachment == null)
  327.                 throw new ArgumentNullException("strAttachment");
  329.             StringReader srReader = new StringReader(strAttachment);
  331.             
  332.             if (blnParseHeader)
  333.             { 
  334.                 string strLine = srReader.ReadLine();
  335.                 string strRead = "Begin";
  336.                 
  337.                 //if (strLine.Contains("name=") && !strLine.EndsWith("""))
  338.                 if(strLine.ToLower().Contains("content-type")&&!strLine.ToLower().Contains("text/plain"))
  339.                 {
  340.                     while (!strRead.EndsWith("""))
  341.                     {
  342.                         strRead = srReader.ReadLine();
  343.                         strLine = String.Concat(strLine, strRead);
  344.                         strLine=Regex.Replace(strLine, "\?= =\?gbk\?Q\?", "", RegexOptions.IgnoreCase);
  345.                         
  346.                     }
  347.                 }
  349.                 while (Utility.IsNotNullTextEx(strLine))
  350.                 {
  351.                     ParseHeader(srReader, ref strLine);
  352.                     if (Utility.IsOrNullTextEx(strLine))
  353.                         break;
  354.                     else
  355.                     {
  356.                         strLine = srReader.ReadLine();
  357.                         strRead = "Begin";
  358.                         if (Utility.IsOrNullTextEx(strLine))
  359.                             break;
  360.                         if (strLine.Contains("name=") && !strLine.EndsWith("""))
  361.                         {
  362.                             while (!strRead.EndsWith("""))
  363.                             {
  364.                                 strRead = srReader.ReadLine();
  365.                                 strLine = String.Concat(strLine, strRead);
  366.                                 strLine = Regex.Replace(strLine, "\?= =\?gbk\?Q\?", "", RegexOptions.IgnoreCase);
  367.                             }
  368.                         }
  370.                     }
  371.                 }
  372.             }
  374.             this._rawAttachment = srReader.ReadToEnd();
  375.             _contentLength = this._rawAttachment.Length;
  376.         }
  378.         /// <summary>
  379.         /// Parse header fields and set member variables
  380.         /// </summary>
  381.         /// <param name="srReader">string reader</param>
  382.         /// <param name="strLine">header line</param>
  383.         private void ParseHeader(StringReader srReader, ref string strLine)
  384.         {
  385.             string[] array = Utility.GetHeadersValue(strLine);
  386.             string[] values = Regex.Split(array[1], ";");
  387.             string strRet = null;
  388.             switch (array[0].ToUpper())
  389.             {
  390.                 case "CONTENT-TYPE":
  391.                     if (values.Length > 0)
  392.                         _contentType = values[0].Trim();
  393.                     if (values.Length > 1)
  394.                     {
  395.                         _contentCharset = Utility.GetQuotedValue(values[1], "=", "charset");
  396.                     }
  397.                     if (values.Length > 2)
  398.                     {
  399.                         _contentFormat = Utility.GetQuotedValue(values[2], "=", "format");
  400.                     }
  401.                     _contentFileName = Utility.ParseFileName(strLine);
  402.                     if (_contentFileName == "")
  403.                     {
  404.                         strRet = srReader.ReadLine();
  406.                         if (strRet == "")
  407.                         {
  408.                             strLine = "";
  409.                             break;
  410.                         }
  411.                         _contentFileName = Utility.ParseFileName(strLine);
  412.                         if (_contentFileName == "")
  413.                             ParseHeader(srReader, ref strRet);
  414.                     }
  415.                     break;
  416.                 case "CONTENT-TRANSFER-ENCODING":
  417.                     _contentTransferEncoding = Utility.SplitOnSemiColon(array[1])[0].Trim();
  418.                     break;
  419.                 case "CONTENT-DESCRIPTION":
  420.                     _contentDescription = Utility.DecodeText(Utility.SplitOnSemiColon(array[1])[0].Trim());
  421.                     break;
  422.                 case "CONTENT-DISPOSITION":
  423.                     if (values.Length > 0)
  424.                         _contentDisposition = values[0].Trim();
  426.                     ///<bug>reported by grandepuffo @ https://sourceforge.net/forum/message.php?msg_id=2589759
  427.                     //_contentFileName=values[1];
  428.                     if (values.Length > 1)
  429.                     {
  430.                         _contentFileName = values[1];
  431.                     }
  432.                     else
  433.                     {
  434.                         _contentFileName = "";
  435.                     }
  437.                     if (_contentFileName == "")
  438.                     {
  439.                         _contentFileName = srReader.ReadLine();
  440.                         //-------start by shine -----------------------------------//
  441.                         while(!_contentFileName.EndsWith("""))
  442.                         {
  443.                             _contentFileName += srReader.ReadLine();
  444.                         }
  445.                         //---------end by shine -----------------------------------//
  446.                     }
  447.                     _contentFileName = _contentFileName.Replace("t", "");
  448.                     _contentFileName = Utility.GetQuotedValue(_contentFileName, "=", "filename");
  449.                     _contentFileName = Utility.DecodeText(_contentFileName);
  450.                     break;
  451.                 case "CONTENT-ID":
  452.                     _contentID = Utility.SplitOnSemiColon(array[1])[0].Trim('<').Trim('>');
  453.                     break;
  454.             }
  455.         }
  457. /// <summary>
  458. /// verify the encoding
  459. /// </summary>
  460. /// <param name="encoding">encoding to verify</param>
  461. /// <returns>true if encoding</returns>
  462. private bool IsEncoding(string encoding)
  463. {
  464. return _contentTransferEncoding.ToLower().IndexOf(encoding.ToLower())!=-1;
  465. }
  467. /// <summary>
  468. /// Decode the attachment to text
  469. /// </summary>
  470. /// <returns>Decoded attachment text</returns>
  471. public string DecodeAsText()
  472. {
  473. string decodedAttachment=null;
  475. try
  476. {
  477. if(_contentType.ToLower()=="message/rfc822".ToLower())
  478. decodedAttachment=Utility.DecodeText(_rawAttachment);
  479. else if(_contentTransferEncoding!=null)
  480. {
  481. decodedAttachment=_rawAttachment;
  483. if(!IsEncoding("7bit"))
  484. {
  485. if(IsEncoding("8bit")&&_contentCharset!=null&_contentCharset!="")
  486. decodedAttachment=Utility.Change(decodedAttachment,_contentCharset);
  488. if(Utility.IsQuotedPrintable(_contentTransferEncoding))
  489. decodedAttachment=DecodeQP.ConvertHexContent(decodedAttachment);
  490. //else if(IsEncoding("8bit"))
  491. //decodedAttachment=decodedAttachment;
  492. else
  493. decodedAttachment=Utility.deCodeB64s(Utility.RemoveNonB64(decodedAttachment));
  494. }
  495. }
  496. else if(_contentCharset!=null)
  497. decodedAttachment=Utility.Change(_rawAttachment,_contentCharset);//Encoding.Default.GetString(Encoding.GetEncoding(_contentCharset).GetBytes(_rawAttachment));
  498. else
  499. decodedAttachment=_rawAttachment;
  500. }
  501. catch
  502. {
  503. decodedAttachment=_rawAttachment;
  504. }
  505. return decodedAttachment;
  506. }
  508. /// <summary>
  509. /// decode attachment to be a message object
  510. /// </summary>
  511. /// <returns>message</returns>
  512. public Message DecodeAsMessage()
  513. {
  514. bool blnRet=false;
  515. return new Message(ref blnRet,"",false ,_rawAttachment,false);
  516. }
  518. /// <summary>
  519. /// Decode the attachment to bytes
  520. /// </summary>
  521. /// <returns>Decoded attachment bytes</returns>
  522. public byte[] DecodedAsBytes()
  523. {
  524. if(_rawAttachment==null)
  525. return null;
  526. if(_contentFileName!="")
  527. {
  528. byte []decodedBytes=null;
  530. if(_contentType!=null && _contentType.ToLower()=="message/rfc822".ToLower())
  531. decodedBytes=Encoding.Default.GetBytes(Utility.DecodeText(_rawAttachment));
  532. else if(_contentTransferEncoding!=null)
  533. {
  534. string bytContent=_rawAttachment;
  536. if(!IsEncoding("7bit"))
  537. {
  538. if(IsEncoding("8bit")&&_contentCharset!=null&_contentCharset!="")
  539. bytContent=Utility.Change(bytContent,_contentCharset);
  541. if(Utility.IsQuotedPrintable(_contentTransferEncoding))
  542. decodedBytes=Encoding.Default.GetBytes(DecodeQP.ConvertHexContent(bytContent));
  543. else if(IsEncoding("8bit"))
  544. decodedBytes=Encoding.Default.GetBytes(bytContent);
  545. else
  546. decodedBytes=Convert.FromBase64String(Utility.RemoveNonB64(bytContent));
  547. }
  548. else
  549. decodedBytes=Encoding.Default.GetBytes(bytContent);
  550. }
  551. else if(_contentCharset!=null)
  552. decodedBytes=Encoding.Default.GetBytes(Utility.Change(_rawAttachment,_contentCharset));//Encoding.Default.GetString(Encoding.GetEncoding(_contentCharset).GetBytes(_rawAttachment));
  553. else
  554. decodedBytes=Encoding.Default.GetBytes(_rawAttachment);
  556. return decodedBytes;
  557. }
  558. else
  559. {
  560. return null;
  561. }
  562. }
  564. public int CompareTo(object attachment)
  565. {
  566. return (this.RawAttachment.CompareTo(((Attachment)(attachment)).RawAttachment));
  567. }
  568. }
  569. }