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

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

Email客户端

开发平台：

C#

Utility.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.Utility
  20. *Function: Utility
  21. *Author: Hamid Qureshi
  22. *Created: 2003/8
  23. *Modified: 2004/5/31 14:22 GMT+8 by Unruled Boy
  24. *Description:
  25. *Changes:
  26. * 2004/5/31 14:22 GMT+8 by Unruled Boy
  27. * 1.Fixed a bug in decoding Base64 text when using non-standard encoding
  28. * 2004/5/30 15:04 GMT+8 by Unruled Boy
  29. * 1.Added all description to all functions
  30. * 2004/5/25 13:55 GMT+8 by Unruled Boy
  31. * 1.Rewrote the DecodeText function using Regular Expression
  32. * 2004/5/17 14:20 GMT+8 by Unruled Boy
  33. * 1.Added ParseFileName
  34. * 2004/4/29 19:05 GMT+8 by Unruled Boy
  35. * 1.Adding ReadPlainTextFromFile function
  36. * 2004/4/28 19:06 GMT+8 by Unruled Boy
  37. * 1.Rewriting the Decode method
  38. * 2004/3/29 12:25 GMT+8 by Unruled Boy
  39. * 1.GetMimeType support for MONO
  40. * 2.cleaning up the names of variants
  41. */
  42. using System;
  43. using System.Text;
  44. using System.IO;
  45. using System.Threading;
  46. using System.Text.RegularExpressions;
  47. using System.Collections;
  49. namespace OpenPOP.MIMEParser
  50. {
  51. /// <summary>
  52. /// Summary description for Utility.
  53. /// </summary>
  54. public class Utility
  55. {
  56. private static bool m_blnLog=false;
  57. private static string m_strLogFile = "OpenPOP.log";
  59. public Utility()
  60. {
  61. }
  63. // public static string[] SplitText(string strText, string strSplitter)
  64. // {
  65. // string []segments=new string[0];
  66. // int indexOfstrSplitter=strText.IndexOf(strSplitter);
  67. // if(indexOfstrSplitter!=-1)
  68. // {
  69. //
  70. // }
  71. // return segments;
  72. // }
  73. //
  75. /// <summary>
  76. /// Verifies whether the file is of picture type or not
  77. /// </summary>
  78. /// <param name="strFile">File to be verified</param>
  79. /// <returns>True if picture file, false if not</returns>
  80. public static bool IsPictureFile(string strFile)
  81. {
  82. try
  83. {
  84. if(strFile!=null&&strFile!="")
  85. {
  86. strFile=strFile.ToLower();
  87. if(strFile.EndsWith(".jpg")||strFile.EndsWith(".bmp")||strFile.EndsWith(".ico")||strFile.EndsWith(".gif")||strFile.EndsWith(".png"))
  88. return true;
  89. else
  90. return false;
  91. }
  92. else
  93. return false;
  94. }
  95. catch
  96. {
  97. return false;
  98. }
  99. }
  101. /// <summary>
  102. /// Parse date time info from MIME header
  103. /// </summary>
  104. /// <param name="strDate">Encoded MIME date time</param>
  105. /// <returns>Decoded date time info</returns>
  106. public static string ParseEmailDate(string strDate)
  107. {
  108. string strRet=strDate.Trim();
  109. int indexOfTag=strRet.IndexOf(",");
  110. if(indexOfTag!=-1)
  111. {
  112. strRet=strRet.Substring(indexOfTag+1);
  113. }
  115. strRet=QuoteText(strRet,"+");
  116. strRet=QuoteText(strRet,"-");
  117. strRet=QuoteText(strRet,"GMT");
  118. strRet=QuoteText(strRet,"CST");
  119. return strRet.Trim();
  120. }
  122. /// <summary>
  123. /// Quote the text according to a tag
  124. /// </summary>
  125. /// <param name="strText">Text to be quoted</param>
  126. /// <param name="strTag">Quote tag</param>
  127. /// <returns>Quoted Text</returns>
  128. public static string QuoteText(string strText, string strTag)
  129. {
  130. int indexOfTag=strText.IndexOf(strTag);
  131. if(indexOfTag!=-1)
  132. return strText.Substring(0,indexOfTag-1);
  133. else
  134. return strText;
  135. }
  137. /// <summary>
  138. /// Parse file name from MIME header
  139. /// </summary>
  140. /// <param name="strHeader">MIME header</param>
  141. /// <returns>Decoded file name</returns>
  142. public static string ParseFileName(string strHeader)
  143. {
  144. string strTag;
  145. strTag="filename=";
  146. int intPos=strHeader.ToLower().IndexOf(strTag);
  147. if(intPos==-1)
  148. {
  149. strTag="name=";
  150. intPos=strHeader.ToLower().IndexOf(strTag);
  151. }
  152. string strRet;
  153. if(intPos!=-1)
  154. {
  155. strRet=strHeader.Substring(intPos+strTag.Length);
  156. intPos=strRet.ToLower().IndexOf(";");
  157. if(intPos!=-1)
  158. strRet=strRet.Substring(1,intPos-1);
  159. strRet=RemoveQuote(strRet);
  160. }
  161. else
  162. strRet="";
  164. return strRet;
  165. }
  167. /// <summary>
  168. /// Parse email address from MIME header
  169. /// </summary>
  170. /// <param name="strEmailAddress">MIME header</param>
  171. /// <param name="strUser">Decoded user name</param>
  172. /// <param name="strAddress">Decoded email address</param>
  173. /// <returns>True if decoding succeeded, false if failed</returns>
  174. public static bool ParseEmailAddress(string strEmailAddress,ref string strUser, ref string strAddress)
  175. {
  176. int indexOfAB=strEmailAddress.Trim().LastIndexOf("<");
  177. int indexOfEndAB=strEmailAddress.Trim().LastIndexOf(">");
  178. strUser=strEmailAddress;
  179. strAddress=strEmailAddress;
  180. if(indexOfAB>=0&&indexOfEndAB>=0)
  181. {
  182. if(indexOfAB>0)
  183. {
  184. strUser=strUser.Substring(0,indexOfAB-1);
  185. // strUser=strUser.Substring(0,indexOfAB-1).Trim('"');
  186. // if(strUser.IndexOf(""")>=0)
  187. // {
  188. // strUser=strUser.Substring(1,strUser.Length-1);
  189. // }
  190. }
  191. strUser=strUser.Trim();
  192. strUser=strUser.Trim('"');
  193. strAddress=strAddress.Substring(indexOfAB+1,indexOfEndAB-(indexOfAB+1));
  194. }
  195. strUser=strUser.Trim();
  196. strUser=DecodeText(strUser);
  197. strAddress=strAddress.Trim();
  199. return true;
  200. }
  202. /// <summary>
  203. /// Save byte content to a file
  204. /// </summary>
  205. /// <param name="strFile">File to be saved to</param>
  206. /// <param name="bytContent">Byte array content</param>
  207. /// <returns>True if saving succeeded, false if failed</returns>
  208. public static bool SaveByteContentToFile(string strFile,byte[] bytContent)
  209. {
  210. try
  211. {
  212. if(File.Exists(strFile))
  213. File.Delete(strFile);
  214. FileStream fs=File.Create(strFile);
  215. fs.Write(bytContent,0,bytContent.Length);
  216. fs.Close();
  217. return true;
  218. }
  219. catch(Exception e)
  220. {
  221. Utility.LogError("SaveByteContentToFile():"+e.Message);
  222. return false;
  223. }
  224. }
  226. /// <summary>
  227. /// Save text content to a file
  228. /// </summary>
  229. /// <param name="strFile">File to be saved to</param>
  230. /// <param name="strText">Text content</param>
  231. /// <param name="blnReplaceExists">Replace file if exists</param>
  232. /// <returns>True if saving succeeded, false if failed</returns>
  233. public static bool SavePlainTextToFile(string strFile, string strText, bool blnReplaceExists)
  234. {
  235. try
  236. {
  237. bool blnRet=true;
  239. if(File.Exists(strFile))
  240. {
  241. if(blnReplaceExists)
  242. File.Delete(strFile);
  243. else
  244. blnRet=false;
  245. }
  247. if(blnRet==true)
  248. {
  249. StreamWriter sw=File.CreateText(strFile);
  250. sw.Write(strText);
  251. sw.Close();
  252. }
  254. return blnRet;
  255. }
  256. catch(Exception e)
  257. {
  258. Utility.LogError("SavePlainTextToFile():"+e.Message);
  259. return false;
  260. }
  261. }
  263. /// <summary>
  264. /// Read text content from a file
  265. /// </summary>
  266. /// <param name="strFile">File to be read from</param>
  267. /// <param name="strText">Read text content</param>
  268. /// <returns>True if reading succeeded, false if failed</returns>
  269. public static bool ReadPlainTextFromFile(string strFile, ref string strText)
  270. {
  271. if(File.Exists(strFile))
  272. {
  273. StreamReader fs=new StreamReader(strFile);
  274. strText=fs.ReadToEnd();
  275. fs.Close();
  276. return true;
  277. }
  278. else
  279. return false;
  280. }
  282. /// <summary>
  283. /// Sepearte header name and header value
  284. /// </summary>
  285. /// <param name="strRawHeader"></param>
  286. /// <returns></returns>
  287. public static string[] GetHeadersValue(string strRawHeader)
  288. {
  289. if(strRawHeader==null)
  290. throw new ArgumentNullException("strRawHeader","Argument was null");
  292. string []array=new string[2]{"",""};
  293. int indexOfColon=strRawHeader.IndexOf(":");
  295. try
  296. {
  297. array[0]=strRawHeader.Substring(0,indexOfColon).Trim();
  298. array[1]=strRawHeader.Substring(indexOfColon+1).Trim();
  299. }
  300. catch(Exception){}
  302. return array;
  303. }
  305. /// <summary>
  306. /// Get quoted text
  307. /// </summary>
  308. /// <param name="strText">Text with quotes</param>
  309. /// <param name="strSplitter">Splitter</param>
  310. /// <param name="strTag">Target tag</param>
  311. /// <returns>Text without quote</returns>
  312. public static string GetQuotedValue(string strText, string strSplitter, string strTag)
  313. {
  314. if(strText==null)
  315. throw new ArgumentNullException("strText","Argument was null");
  317. string []array=new string[2]{"",""};
  318. int indexOfstrSplitter=strText.IndexOf(strSplitter);
  320. try
  321. {
  322. array[0]=strText.Substring(0,indexOfstrSplitter).Trim();
  323. array[1]=strText.Substring(indexOfstrSplitter+1).Trim();
  324. int pos=array[1].IndexOf(""");
  325. if(pos!=-1)
  326. {
  327. int pos2=array[1].IndexOf(""",pos+1);
  328. array[1]=array[1].Substring(pos+1,pos2-pos-1);
  329. }
  330. }
  331. catch(Exception){}
  333. //return array;
  334. if(array[0].ToLower()==strTag.ToLower())
  335. return array[1].Trim();
  336. else
  337. return null;
  339. /* string []array=null;
  340. try
  341. {
  342. array=Regex.Split(strText,strSplitter);
  343. //return array;
  344. if(array[0].ToLower()==strTag.ToLower())
  345. return RemoveQuote(array[1].Trim());
  346. else
  347. return null;
  348. }
  349. catch
  350. {return null;}*/
  351. }
  353. /// <summary>
  354. /// Change text encoding
  355. /// </summary>
  356. /// <param name="strText">Source encoded text</param>
  357. /// <param name="strCharset">New charset</param>
  358. /// <returns>Encoded text with new charset</returns>
  359. public static string Change(string strText,string strCharset)
  360. {
  361. if (strCharset==null || strCharset=="")
  362. return strText;
  363. byte[] b=Encoding.Default.GetBytes(strText);
  364. return new string(Encoding.GetEncoding(strCharset).GetChars(b));
  365. }
  367. /// <summary>
  368. /// Remove non-standard base 64 characters
  369. /// </summary>
  370. /// <param name="strText">Source text</param>
  371. /// <returns>standard base 64 text</returns>
  372. public static string RemoveNonB64(string strText)
  373. {
  374. return strText.Replace("","");
  375. }
  377. /// <summary>
  378. /// Remove white blank characters
  379. /// </summary>
  380. /// <param name="strText">Source text</param>
  381. /// <returns>Text with white blanks</returns>
  382. public static string RemoveWhiteBlanks(string strText)
  383. {
  384. return strText.Replace("","").Replace("rn","");
  385. }
  387. /// <summary>
  388. /// Remove quotes
  389. /// </summary>
  390. /// <param name="strText">Text with quotes</param>
  391. /// <returns>Text without quotes</returns>
  392. public static string RemoveQuote(string strText)
  393. {
  394. string strRet=strText;
  395.             //strText可能有空格，要去空格(还未修改)
  396. if(strRet.StartsWith("""))
  397. strRet=strRet.Substring(1);
  398. if(strRet.EndsWith("""))
  399. strRet=strRet.Substring(0,strRet.Length-1);
  400. return strRet;
  401. }
  403. /// <summary>
  404. /// Decode one line of text
  405. /// </summary>
  406. /// <param name="strText">Encoded text</param>
  407. /// <returns>Decoded text</returns>
  408. public static string DecodeLine(string strText)
  409. {
  410. return DecodeText(RemoveWhiteBlanks(strText));
  411. }
  413. /// <summary>
  414. /// Verifies wether the text is a valid MIME Text or not
  415. /// </summary>
  416. /// <param name="strText">Text to be verified</param>
  417. /// <returns>True if MIME text, false if not</returns>
  418. private static bool IsValidMIMEText(string strText)
  419. {
  420. int intPos=strText.IndexOf("=?");
  421. return (intPos!=-1&&strText.IndexOf("?=",intPos+6)!=-1&&strText.Length>7);
  422. }
  424. /// <summary>
  425. /// Decode text
  426. /// </summary>
  427. /// <param name="strText">Source text</param>
  428. /// <returns>Decoded text</returns>
  429. public static string DecodeText(string strText)
  430. {
  431.             /*try
  432.             {
  433.                 string strRet="";
  434.                 string strBody="";
  435.                 MatchCollection mc=Regex.Matches(strText,@"=?(?<Charset>S+)?(?<Encoding>w)?(?<Content>S+)?=");
  436.                                                          
  437.                 for(int i=0;i<mc.Count;i++)
  438.                 {
  439.                     if(mc[i].Success)
  440.                     {
  441.                         strBody=mc[i].Groups["Content"].Value;
  443.                         switch(mc[i].Groups["Encoding"].Value.ToUpper())
  444.                         {
  445.                             case "B":
  446.                                 strBody=deCodeB64s(strBody,mc[i].Groups["Charset"].Value);
  447.                                 break;
  448.                             case "Q":
  449.                                 strBody=DecodeQP.ConvertHexContent(strBody);//, m.Groups["Charset"].Value);
  450.                                 break;
  451.                             default:
  452.                                 break;
  453.                         }
  454.                         strRet+=strBody;
  455.                     }
  456.                     else
  457.                     {
  458.                         strRet+=mc[i].Value;
  459.                     }
  460.                 }
  461.                 return strRet;
  462.             }
  463.             catch
  464.             {return strText;}*/
  466.             try
  467. {
  468.                 
  469. string strRet="";
  470. string[] strParts=Regex.Split(strText,"rn");
  471. string strBody="";
  472. const string strRegEx=@"=?(?<Charset>S+)?(?<Encoding>w)?(?<Content>S+)?=";
  473. Match m=null;
  475. for(int i=0;i<strParts.Length;i++)
  476. {
  477.                     m = Regex.Match(strParts[i], strRegEx);
  478.                     //-------------start by shine---------------------------------//
  479.                     MatchCollection m1 = null;                    
  480.                     m1 = Regex.Matches(strParts[i], strRegEx);                    
  481. if(m.Success)
  482. {
  483.                         
  484.                         //strBody=m.Groups["Content"].Value;
  485.                        
  487.                         //switch (m.Groups["Encoding"].Value.ToUpper())
  488.                         //{
  489.                         //    case "B":
  490.                         //        strBody = deCodeB64s(strBody, m.Groups["Charset"].Value);
  491.                         //        break;
  492.                         //    case "Q":
  493.                         //        strBody = DecodeQP.ConvertHexContent(strBody);//, m.Groups["Charset"].Value);
  494.                         //        break;
  495.                         //    default:
  496.                         //        break;
  497.                         //}
  498.                         //strRet += strBody;
  499.                         IEnumerator ie = m1.GetEnumerator();
  500.                         string temp = string.Empty;
  501.                         while (ie.MoveNext())
  502.                         {
  503.                             
  504.                             string str = (string)ie.Current.ToString();
  505.                             m = Regex.Match(str, strRegEx);
  506.                             strBody = m.Groups["Content"].Value;
  507.                             switch (m.Groups["Encoding"].Value.ToUpper())
  508.                             {
  509.                                 case "B":
  510.                                     strBody = deCodeB64s(strBody, m.Groups["Charset"].Value);
  511.                                     break;
  512.                                 case "Q":
  513.                                     strBody = DecodeQP.ConvertHexContent(strBody);//, m.Groups["Charset"].Value);
  514.                                     break;
  515.                                 default:
  516.                                     break;
  517.                             }
  518.                             strRet += strBody;
  519.                         }
  520. }
  521.                     //---------------end by shine---------------------------------//
  522. else
  523. {
  524. if(!IsValidMIMEText(strParts[i]))
  525. strRet+=strParts[i];
  526. else
  527. {
  528. //blank text
  529. }
  530. }
  531. }
  532. return strRet;
  533. }
  534. catch
  535. {return strText;}
  537. /*
  538. {
  539. try
  540. {
  541. if(strText!=null&&strText!="")
  542. {
  543. if(IsValidMIMEText(strText))
  544. {
  545. //position at the end of charset
  546. int intPos=strText.IndexOf("=?");
  547. int intPos2=strText.IndexOf("?",intPos+2);
  548. if(intPos2>3)
  549. {
  550. string strCharset=strText.Substring(2,intPos2-2);
  551. string strEncoding=strText.Substring(intPos2+1,1);
  552. int intPos3=strText.IndexOf("?=",intPos2+3);
  553. string strBody=strText.Substring(intPos2+3,intPos3-intPos2-3);
  554. string strHead="";
  555. if(intPos>0)
  556. {
  557. strHead=strText.Substring(0,intPos-1);
  558. }
  559. string strEnd="";
  560. if(intPos3<strText.Length-2)
  561. {
  562. strEnd=strText.Substring(intPos3+2);
  563. }
  564. switch(strEncoding.ToUpper())
  565. {
  566. case "B":
  567. strBody=deCodeB64s(strBody);
  568. break;
  569. case "Q":
  570. strBody=DecodeQP.ConvertHexContent(strBody);
  571. break;
  572. default:
  573. break;
  574. }
  575. strText=strHead+strBody+strEnd;
  576. if(IsValidMIMEText(strText))
  577. return DecodeText(strText);
  578. else
  579. return strText;
  580. }
  581. else
  582. {return strText;}
  583. }
  584. else
  585. {return strText;}
  586. }
  587. else
  588. {return strText;}
  589. }
  590. catch
  591. {return strText;}*/
  592. }
  594. /// <summary>
  595. /// 
  596. /// </summary>
  597. /// <param name="strText"></param>
  598. /// <returns></returns>
  599. public static string deCodeB64s(string strText)
  600. {
  601. return Encoding.Default.GetString(deCodeB64(strText));
  602. }
  604. public static string deCodeB64s(string strText,string strEncoding)
  605. {
  606. try
  607. {
  608. if(strEncoding.ToLower()=="ISO-8859-1".ToLower())
  609. return deCodeB64s(strText);
  610. else
  611. return Encoding.GetEncoding(strEncoding).GetString(deCodeB64(strText));
  612. }
  613. catch
  614. {
  615. return deCodeB64s(strText);
  616. }
  617. }
  619. private static byte []deCodeB64(string strText)
  620. {
  621. byte[] by=null;
  622. try
  623. { 
  624. if(strText!="")
  625. {
  626. by=Convert.FromBase64String(strText); 
  627. //strText=Encoding.Default.GetString(by);
  628. }
  629. } 
  630. catch(Exception e) 
  631. {
  632.                 for (int i = 0; i < strText.Length; i++)
  633.                 {
  634.                     by[i] = Convert.ToByte(strText.Substring(i));
  635.                 }
  636. LogError("deCodeB64():"+e.Message);
  637. }
  638. return by;
  639. }
  641. /// <summary>
  642. /// Turns file logging on and off.
  643. /// </summary>
  644. /// <remarks>Comming soon.</remarks>
  645. public static bool Log
  646. {
  647. get
  648. {
  649. return m_blnLog;
  650. }
  651. set
  652. {
  653. m_blnLog = value;
  654. }
  655. }
  657. internal static void LogError(string strText) 
  658. {
  659. //Log=true;
  660. if(Log)
  661. {
  662. FileInfo file = null;
  663. FileStream fs = null;
  664. StreamWriter sw = null;
  665. try
  666. {
  667. file = new FileInfo(m_strLogFile);
  668. sw = file.AppendText();
  669. //fs = new FileStream(m_strLogFile, FileMode.OpenOrCreate, FileAccess.Write);
  670. //sw = new StreamWriter(fs);
  671. sw.WriteLine(DateTime.Now);
  672. sw.WriteLine(strText);
  673. sw.WriteLine("rn");
  674. sw.Flush();
  675. }
  676. finally
  677. {
  678. if(sw != null)
  679. {
  680. sw.Close();
  681. sw = null;
  682. }
  683. if(fs != null)
  684. {
  685. fs.Close();
  686. fs = null;
  687. }
  689. }
  690. }
  691. }
  693. public static bool IsQuotedPrintable(string strText)
  694. {
  695. if(strText!=null)
  696. return (strText.ToLower()=="quoted-printable".ToLower());
  697. else
  698. return false;
  699. }
  701. public static bool IsBase64(string strText)
  702. {
  703. if(strText!=null)
  704. return (strText.ToLower()=="base64".ToLower());
  705. else
  706. return false;
  707. }
  709. public static string[] SplitOnSemiColon(string strText)
  710. {
  711. if(strText==null)
  712. throw new ArgumentNullException("strText","Argument was null");
  714. string []array=null;
  715. int indexOfColon=strText.IndexOf(";");
  717. if(indexOfColon<0)
  718. {
  719. array=new string[1];
  720. array[0]=strText;
  721. return array;
  722. }
  723. else
  724. {
  725. array=new string[2];
  726. }
  728. try
  729. {
  730. array[0]=strText.Substring(0,indexOfColon).Trim();
  731. array[1]=strText.Substring(indexOfColon+1).Trim();
  732. }
  733. catch(Exception){}
  735. return array;
  736. }
  738. public static bool IsNotNullText(string strText)
  739. {
  740. try
  741. {
  742. return (strText!=null&&strText!="");
  743. }
  744. catch
  745. {
  746. return false;
  747. }
  748. }
  750. public static bool IsNotNullTextEx(string strText)
  751. {
  752. try
  753. {
  754. return (strText!=null&&strText.Trim()!="");
  755. }
  756. catch
  757. {
  758. return false;
  759. }
  760. }
  762. public static bool IsOrNullTextEx(string strText)
  763. {
  764. try
  765. {
  766. return (strText==null||strText.Trim()=="");
  767. }
  768. catch
  769. {
  770. return false;
  771. }
  772. }
  774. }
  775. }