src/Utils/HwSMTP.cpp

   1 // HwSMTP.cpp: implementation of the CHwSMTP class.
   2 //
   3 //////////////////////////////////////////////////////////////////////
   4
   5 #include "stdafx.h"
   6 #include "afxstr.h"
   7 #include "HwSMTP.h"
   8 #include "CBase64.h"
   9 #include "SpeedPostEmail.h"
  10 #include "Windns.h"
  11 #include <Afxmt.h>
  12
  13 #ifdef _DEBUG
  14 #undef THIS_FILE
  15 static char THIS_FILE[]=__FILE__;
  16 #define new DEBUG_NEW
  17 #endif
  18
  19 CPtrArray g_PtrAry_Threads;
  20 ::CCriticalSection m_CSFor__g_PtrAry_Threads;
  21
  22 class CEMailObject
  23 {
  24 public:
  25         CEMailObject (
  26                 LPCTSTR lpszSmtpSrvHost,
  27                 LPCTSTR lpszUserName,
  28                 LPCTSTR lpszPasswd,
  29                 BOOL bMustAuth,
  30                 LPCTSTR lpszAddrFrom,
  31                 LPCTSTR lpszAddrTo,
  32                 LPCTSTR lpszFromName,
  33                 LPCTSTR lpszReceiverName,
  34                 LPCTSTR lpszSubject,
  35                 LPCTSTR lpszBody,
  36                 LPCTSTR lpszCharSet,
  37                 CStringArray *pStrAryAttach,
  38                 LPCTSTR pStrAryCC,
  39                 UINT nSmtpSrvPort,
  40                 LPCTSTR pSender,
  41                 LPCTSTR pToList
  42                 )
  43         {
  44                 m_csSmtpSrvHost = GET_SAFE_STRING(lpszSmtpSrvHost);
  45                 m_csUserName = GET_SAFE_STRING(lpszUserName);
  46                 m_csPasswd = GET_SAFE_STRING(lpszPasswd);
  47                 m_bMustAuth = bMustAuth;
  48                 m_csAddrFrom = GET_SAFE_STRING(lpszAddrFrom);
  49                 m_csAddrTo = GET_SAFE_STRING(lpszAddrTo);
  50                 m_csFromName = GET_SAFE_STRING(lpszFromName);
  51                 m_csReceiverName = GET_SAFE_STRING(lpszReceiverName);
  52                 m_csSubject = GET_SAFE_STRING(lpszSubject);
  53                 m_csBody = GET_SAFE_STRING(lpszBody);
  54                 m_csCharSet = GET_SAFE_STRING(lpszCharSet);
  55                 m_StrCC = GET_SAFE_STRING(pStrAryCC);
  56                 m_csSender = GET_SAFE_STRING(pSender);
  57                 m_csToList = GET_SAFE_STRING(pToList);
  58
  59                 if ( pStrAryAttach )
  60                         m_StrAryAttach.Append ( *pStrAryAttach );
  61
  62                 m_nSmtpSrvPort = nSmtpSrvPort;
  63                 m_hThread = NULL;
  64         }
  65
  66 public:
  67         CString m_csSmtpSrvHost;
  68         CString m_csUserName;
  69         CString m_csPasswd;
  70         BOOL m_bMustAuth;
  71         CString m_csAddrFrom;
  72         CString m_csAddrTo;
  73         CString m_csFromName;
  74         CString m_csReceiverName;
  75         CString m_csSubject;
  76         CString m_csBody;
  77         CString m_csCharSet;
  78         CStringArray m_StrAryAttach;
  79         CString m_StrCC;
  80         UINT m_nSmtpSrvPort;
  81         CString m_csSender;
  82         CString m_csToList;
  83
  84         HANDLE m_hThread;
  85 };
  86
  87 //////////////////////////////////////////////////////////////////////
  88 // Construction/Destruction
  89 //////////////////////////////////////////////////////////////////////
  90
  91 CHwSMTP::CHwSMTP () :
  92         m_bConnected ( FALSE ),
  93         m_nSmtpSrvPort ( 25 ),
  94         m_bMustAuth ( TRUE )
  95 {
  96         m_csPartBoundary = _T( "WC_MAIL_PaRt_BoUnDaRy_05151998" );
  97         m_csMIMEContentType = FormatString ( _T( "multipart/mixed; boundary=%s" ), m_csPartBoundary);
  98         m_csNoMIMEText = _T( "This is a multi-part message in MIME format." );
  99         //m_csCharSet = _T("\r\n\tcharset=\"iso-8859-1\"\r\n");
 100
 101         AfxSocketInit();
 102 }
 103
 104 CHwSMTP::~CHwSMTP()
 105 {
 106 }
 107
 108 void CHwSMTP::GetNameAddress(CString &in, CString &name,CString &address)
 109 {
 110         int start,end;
 111         start=in.Find(_T('<'));
 112         end=in.Find(_T('>'));
 113
 114         if(start >=0 && end >=0)
 115         {
 116                 name=in.Left(start);
 117                 address=in.Mid(start+1,end-start-1);
 118         }
 119         else
 120                 address=in;
 121 }
 122
 123 CString CHwSMTP::GetServerAddress(CString &email)
 124 {
 125         CString str;
 126         int start,end;
 127
 128         start = email.Find(_T("<"));
 129         end = email.Find(_T(">"));
 130
 131         if(start>=0 && end >=0)
 132         {
 133                 str=email.Mid(start+1,end-start-1);
 134         }
 135         else
 136         {
 137                 str=email;
 138         }
 139
 140         start = str.Find(_T('@'));
 141         return str.Mid(start+1);
 142
 143 }
 144
 145 BOOL CHwSMTP::SendSpeedEmail
 146                 (
 147                         LPCTSTR lpszAddrFrom,
 148                         LPCTSTR lpszAddrTo,
 149                         LPCTSTR lpszSubject,
 150                         LPCTSTR lpszBody,
 151                         LPCTSTR lpszCharSet,
 152                         CStringArray *pStrAryAttach,
 153                         LPCTSTR pStrAryCC,
 154                         UINT    nSmtpSrvPort,
 155                         LPCTSTR pSend
 156                 )
 157 {
 158
 159         BOOL ret=true;
 160         CString To;
 161         To += GET_SAFE_STRING(lpszAddrTo);
 162         To += _T(";");
 163         To += GET_SAFE_STRING(pStrAryCC);
 164
 165         std::map<CString,std::vector<CString>> Address;
 166
 167         int start = 0;
 168         while( start >= 0 )
 169         {
 170                 CString one= To.Tokenize(_T(";"),start);
 171                 one=one.Trim();
 172                 if(one.IsEmpty())
 173                         continue;
 174
 175                 CString addr;
 176                 addr = GetServerAddress(one);
 177                 if(addr.IsEmpty())
 178                         continue;
 179
 180                 Address[addr].push_back(one);
 181
 182         }
 183
 184         std::map<CString,std::vector<CString>>::iterator itr1  =  Address.begin();
 185         for(  ;  itr1  !=  Address.end();  ++itr1 )
 186         {
 187                 PDNS_RECORD pDnsRecord;
 188                 PDNS_RECORD pNext;
 189
 190                 DnsQuery(itr1->first ,
 191                                                 DNS_TYPE_MX,DNS_QUERY_STANDARD,
 192                                                 NULL,                   //Contains DNS server IP address.
 193                                                 &pDnsRecord,    //Resource record that contains the response.
 194                                                 NULL
 195                                                 );
 196
 197                 CString to;
 198                 to.Empty();
 199                 for(int i=0;i<itr1->second.size();i++)
 200                 {
 201                         to+=itr1->second[i];
 202                         to+=_T(";");
 203                 }
 204                 if(to.IsEmpty())
 205                         continue;
 206
 207                 pNext=pDnsRecord;
 208                 while(pNext)
 209                 {
 210                         if(pNext->wType == DNS_TYPE_MX)
 211                                 if(SendEmail(pNext->Data.MX.pNameExchange,NULL,NULL,false,
 212                                         lpszAddrFrom,to,lpszSubject,lpszBody,lpszCharSet,pStrAryAttach,pStrAryCC,
 213                                         25,pSend,lpszAddrTo))
 214                                         break;
 215                         pNext=pNext->pNext;
 216                 }
 217                 if(pNext == NULL)
 218                         ret = false;
 219
 220                 //SendEmail(itr1.first,NULL,NULL,false,lpszAddrFrom,,lpszFromname);
 221                 DnsRecordListFree(pDnsRecord,DnsFreeRecordList);
 222         }
 223
 224         return ret;
 225 }
 226 BOOL CHwSMTP::SendEmail (
 227                 LPCTSTR lpszSmtpSrvHost,
 228                 LPCTSTR lpszUserName,
 229                 LPCTSTR lpszPasswd,
 230                 BOOL bMustAuth,
 231                 LPCTSTR lpszAddrFrom,
 232                 LPCTSTR lpszAddrTo,
 233                 LPCTSTR lpszSubject,
 234                 LPCTSTR lpszBody,
 235                 LPCTSTR lpszCharSet,                                            // ×Ö·û¼¯ÀàÐÍ£¬ÀýÈç£º·±ÌåÖÐÎÄÕâÀïÓ¦ÊäÈë"big5"£¬¼òÌåÖÐÎÄÊ±ÊäÈë"gb2312"
 236                 CStringArray *pStrAryAttach/*=NULL*/,
 237                 LPCTSTR pStrAryCC/*=NULL*/,
 238                 UINT nSmtpSrvPort,/*=25*/
 239                 LPCTSTR pSender,
 240                 LPCTSTR pToList
 241                 )
 242 {
 243         TRACE ( _T("·¢ËÍÓÊ¼þ£º%s,  %s\n"), lpszAddrTo, lpszBody );
 244         m_StrAryAttach.RemoveAll();
 245
 246         m_StrCC += GET_SAFE_STRING(pStrAryCC);
 247
 248         m_csSmtpSrvHost = GET_SAFE_STRING ( lpszSmtpSrvHost );
 249         if ( m_csSmtpSrvHost.GetLength() <= 0 )
 250         {
 251                 m_csLastError.Format ( _T("Parameter Error!") );
 252                 return FALSE;
 253         }
 254         m_csUserName = GET_SAFE_STRING ( lpszUserName );
 255         m_csPasswd = GET_SAFE_STRING ( lpszPasswd );
 256         m_bMustAuth = bMustAuth;
 257         if ( m_bMustAuth && m_csUserName.GetLength() <= 0 )
 258         {
 259                 m_csLastError.Format ( _T("Parameter Error!") );
 260                 return FALSE;
 261         }
 262
 263         m_csAddrFrom = GET_SAFE_STRING ( lpszAddrFrom );
 264         m_csAddrTo = GET_SAFE_STRING ( lpszAddrTo );
 265 //      m_csFromName = GET_SAFE_STRING ( lpszFromName );
 266 //      m_csReceiverName = GET_SAFE_STRING ( lpszReceiverName );
 267         m_csSubject = GET_SAFE_STRING ( lpszSubject );
 268         m_csBody = GET_SAFE_STRING ( lpszBody );
 269
 270         this->m_csSender = GET_SAFE_STRING(pSender);
 271         this->m_csToList = GET_SAFE_STRING(pToList);
 272
 273         m_nSmtpSrvPort = nSmtpSrvPort;
 274
 275         if ( lpszCharSet && lstrlen(lpszCharSet) > 0 )
 276                 m_csCharSet.Format ( _T("\r\n\tcharset=\"%s\"\r\n"), lpszCharSet );
 277
 278         if      (
 279                         m_csAddrFrom.GetLength() <= 0 || m_csAddrTo.GetLength() <= 0
 280                 )
 281         {
 282                 m_csLastError.Format ( _T("Parameter Error!") );
 283                 return FALSE;
 284         }
 285
 286         if ( pStrAryAttach )
 287         {
 288                 m_StrAryAttach.Append ( *pStrAryAttach );
 289         }
 290         if ( m_StrAryAttach.GetSize() < 1 )
 291                 m_csMIMEContentType = FormatString ( _T( "text/plain; %s" ), m_csCharSet);
 292
 293         // ´´½¨Socket
 294         m_SendSock.Close();
 295         if ( !m_SendSock.Create () )
 296         {
 297                 int nResult = GetLastError();
 298                 m_csLastError.Format ( _T("Create socket failed!") );
 299                 return FALSE;
 300         }
 301
 302         // Á¬½Óµ½·þÎñÆ÷
 303         if ( !m_SendSock.Connect ( m_csSmtpSrvHost, m_nSmtpSrvPort ) )
 304         {
 305                 m_csLastError.Format ( _T("Connect to [ %s ] failed"), m_csSmtpSrvHost );
 306                 TRACE ( _T("%d\n"), GetLastError() );
 307                 return FALSE;
 308         }
 309         if ( !GetResponse( _T("220") ) ) return FALSE;
 310
 311         m_bConnected = TRUE;
 312         BOOL ret= SendEmail();
 313
 314         m_SendSock.Close();
 315
 316         return ret;
 317 }
 318
 319
 320 BOOL CHwSMTP::GetResponse ( LPCTSTR lpszVerifyCode, int *pnCode/*=NULL*/)
 321 {
 322         if ( !lpszVerifyCode || lstrlen(lpszVerifyCode) < 1 )
 323                 return FALSE;
 324
 325         char szRecvBuf[1024] = {0};
 326         int nRet = 0;
 327         char szStatusCode[4] = {0};
 328         nRet = m_SendSock.Receive ( szRecvBuf, sizeof(szRecvBuf) );
 329         TRACE ( _T("Received : %s\r\n"), szRecvBuf );
 330         if ( nRet <= 0 )
 331         {
 332                 m_csLastError.Format ( _T("Receive TCP data failed") );
 333                 return FALSE;
 334         }
 335 //      TRACE ( _T("ÊÕµ½·þÎñÆ÷»ØÓ¦£º%s\n"), szRecvBuf );
 336
 337         memcpy ( szStatusCode, szRecvBuf, 3 );
 338         if ( pnCode ) (*pnCode) = atoi ( szStatusCode );
 339
 340         if ( strcmp ( szStatusCode, CMultiByteString(lpszVerifyCode).GetBuffer() ) != 0 )
 341         {
 342                 m_csLastError.Format ( _T("Received invalid response  : %s"), GetCompatibleString(szRecvBuf,FALSE) );
 343                 return FALSE;
 344         }
 345
 346         return TRUE;
 347 }
 348 BOOL CHwSMTP::SendBuffer(char *buff,int size)
 349 {
 350         if(size<0)
 351                 size=(int)strlen(buff);
 352         if ( !m_bConnected )
 353         {
 354                 m_csLastError.Format ( _T("Didn't connect") );
 355                 return FALSE;
 356         }
 357
 358         if ( m_SendSock.Send ( buff, size ) != size )
 359         {
 360                 m_csLastError.Format ( _T("Socket send data failed") );
 361                 return FALSE;
 362         }
 363
 364         return TRUE;
 365 }
 366 // ÀûÓÃsocket·¢ËÍÊý¾Ý£¬Êý¾Ý³¤¶È²»ÄÜ³¬¹ý10M
 367 BOOL CHwSMTP::Send(CString &str )
 368 {
 369         if ( !m_bConnected )
 370         {
 371                 m_csLastError.Format ( _T("Didn't connect") );
 372                 return FALSE;
 373         }
 374
 375         CMultiByteString cbsData ( str );
 376
 377         TRACE ( _T("Send : %s\r\n"), cbsData.GetBuffer() );
 378         if ( m_SendSock.Send ( cbsData.GetBuffer(), cbsData.GetLength() ) != cbsData.GetLength() )
 379         {
 380                 m_csLastError.Format ( _T("Socket send data failed") );
 381                 return FALSE;
 382         }
 383
 384         return TRUE;
 385 }
 386
 387 BOOL CHwSMTP::SendEmail()
 388 {
 389         BOOL bRet = TRUE;
 390         char szLocalHostName[64] = {0};
 391         gethostname ( (char*)szLocalHostName, sizeof(szLocalHostName) );
 392
 393         // hello£¬ÎÕÊÖ
 394         CString str;
 395         str.Format(_T("HELO %s\r\n"), GetCompatibleString(szLocalHostName,FALSE));
 396         if ( !Send (  str ))
 397         {
 398                 return FALSE;
 399         }
 400         if ( !GetResponse ( _T("250") ) )
 401         {
 402                 return FALSE;
 403         }
 404         // Éí·ÝÑéÖ¤
 405         if ( m_bMustAuth && !auth() )
 406         {
 407                 return FALSE;
 408         }
 409         // ·¢ËÍÓÊ¼þÍ·
 410         if ( !SendHead() )
 411         {
 412                 return FALSE;
 413         }
 414         // ·¢ËÍÓÊ¼þÖ÷Ìâ
 415         if ( !SendSubject() )
 416         {
 417                 return FALSE;
 418         }
 419         // ·¢ËÍÓÊ¼þÕýÎÄ
 420         if ( !SendBody() )
 421         {
 422                 return FALSE;
 423         }
 424         // ·¢ËÍ¸½¼þ
 425         if ( !SendAttach() )
 426         {
 427                 return FALSE;
 428         }
 429         // ½áÊøÓÊ¼þÕýÎÄ
 430         if ( !Send ( CString(_T(".\r\n") ) ) ) return FALSE;
 431         if ( !GetResponse ( _T("250") ) )
 432                 return FALSE;
 433
 434         // ÍË³ö·¢ËÍ
 435         if ( HANDLE_IS_VALID(m_SendSock.m_hSocket) )
 436                 Send ( CString(_T("QUIT\r\n")) );
 437         m_bConnected = FALSE;
 438
 439         return bRet;
 440 }
 441
 442 BOOL CHwSMTP::auth()
 443 {
 444         int nResponseCode = 0;
 445         if ( !Send ( CString(_T("auth login\r\n")) ) ) return FALSE;
 446         if ( !GetResponse ( _T("334"), &nResponseCode ) ) return FALSE;
 447         if ( nResponseCode != 334 )     // ²»ÐèÒªÑéÖ¤ÓÃ»§ÃûºÍÃÜÂë
 448                 return TRUE;
 449
 450         CBase64 Base64Encode;
 451         CMultiByteString cbsUserName ( m_csUserName ), cbsPasswd ( m_csPasswd );
 452         CString csBase64_UserName = GetCompatibleString ( Base64Encode.Encode ( cbsUserName.GetBuffer(), cbsUserName.GetLength() ).GetBuffer(0), FALSE );
 453         CString csBase64_Passwd = GetCompatibleString ( Base64Encode.Encode ( cbsPasswd.GetBuffer(), cbsPasswd.GetLength() ).GetBuffer(0), FALSE );
 454
 455         CString str;
 456         str.Format( _T("%s\r\n"), csBase64_UserName );
 457         if ( !Send ( str ) )
 458                 return FALSE;
 459
 460         if ( !GetResponse ( _T("334") ) )
 461         {
 462                 m_csLastError.Format ( _T("Authentication UserName failed") );
 463                 return FALSE;
 464         }
 465
 466         str.Format(_T("%s\r\n"), csBase64_Passwd );
 467         if ( !Send ( str ) )
 468                 return FALSE;
 469
 470         if ( !GetResponse ( _T("235") ) )
 471         {
 472                 m_csLastError.Format ( _T("Authentication Password failed") );
 473                 return FALSE;
 474         }
 475
 476         return TRUE;
 477 }
 478
 479 BOOL CHwSMTP::SendHead()
 480 {
 481         CString str;
 482         CString name,addr;
 483         GetNameAddress(m_csAddrFrom,name,addr);
 484
 485         str.Format( _T("MAIL From: <%s>\r\n"), addr );
 486         if ( !Send ( str  ) ) return FALSE;
 487
 488         if ( !GetResponse ( _T("250") ) ) return FALSE;
 489
 490         int start=0;
 491         while(start>=0)
 492         {
 493                 CString one=m_csAddrTo.Tokenize(_T(";"),start);
 494                 one=one.Trim();
 495                 if(one.IsEmpty())
 496                         continue;
 497
 498
 499                 GetNameAddress(one,name,addr);
 500
 501                 str.Format(_T("RCPT TO: <%s>\r\n"), addr );
 502                 if ( !Send ( str ) ) return FALSE;
 503                 if ( !GetResponse ( _T("250") ) ) return FALSE;
 504         }
 505
 506 #if 0
 507         for ( int i=0; i<m_StrAryCC.GetSize(); i++ )
 508         {
 509                 str.Format(_T("RCPT TO: <%s>\r\n"), m_StrAryCC.GetAt(i)  );
 510                 if ( !Send ( str ) ) return FALSE;
 511                 if ( !GetResponse ( _T("250") ) ) return FALSE;
 512         }
 513 #endif
 514
 515         if ( !Send ( CString(_T("DATA\r\n") ) ) ) return FALSE;
 516         if ( !GetResponse ( CString(_T("354") )) ) return FALSE;
 517
 518         return TRUE;
 519 }
 520
 521 BOOL CHwSMTP::SendSubject()
 522 {
 523         CString csSubject;
 524         csSubject += _T("Date: ");
 525         COleDateTime tNow = COleDateTime::GetCurrentTime();
 526         if ( tNow > 1 )
 527         {
 528                 csSubject += FormatDateTime (tNow, _T("%a, %d %b %y %H:%M:%S %Z"));
 529         }
 530         csSubject += _T("\r\n");
 531         csSubject += FormatString ( _T("From: %s\r\n"), this->m_csAddrFrom);
 532
 533         csSubject += FormatString ( _T("CC: %s\r\n"), this->m_StrCC);
 534
 535         if(m_csSender.IsEmpty())
 536                 m_csSender =  this->m_csAddrFrom;
 537
 538         csSubject += FormatString ( _T("Sender: %s\r\n"), this->m_csSender);
 539
 540         if(this->m_csToList.IsEmpty())
 541                 m_csToList = m_csReceiverName;
 542
 543         csSubject += FormatString ( _T("To: %s\r\n"), this->m_csToList);
 544
 545         CString m_csToList;
 546
 547         csSubject += FormatString ( _T("Subject: %s\r\n"), m_csSubject );
 548
 549         csSubject += FormatString ( _T("X-Mailer: TortoiseGit\r\nMIME-Version: 1.0\r\nContent-Type: %s\r\n\r\n"),
 550                 m_csMIMEContentType );
 551
 552         return Send ( csSubject );
 553 }
 554
 555 BOOL CHwSMTP::SendBody()
 556 {
 557         CString csBody, csTemp;
 558
 559         if ( m_StrAryAttach.GetSize() > 0 )
 560         {
 561                 csTemp.Format ( _T("%s\r\n\r\n"), m_csNoMIMEText );
 562                 csBody += csTemp;
 563
 564                 csTemp.Format ( _T("--%s\r\n"), m_csPartBoundary );
 565                 csBody += csTemp;
 566
 567                 csTemp.Format ( _T("Content-Type: text/plain\r\n%sContent-Transfer-Encoding: UTF-8\r\n\r\n"),
 568                         m_csCharSet );
 569                 csBody += csTemp;
 570         }
 571
 572         //csTemp.Format ( _T("%s\r\n"), m_csBody );
 573         csBody += m_csBody;
 574         csBody += _T("\r\n");
 575
 576         return Send ( csBody );
 577 }
 578
 579 BOOL CHwSMTP::SendAttach()
 580 {
 581         int nCountAttach = (int)m_StrAryAttach.GetSize();
 582         if ( nCountAttach < 1 ) return TRUE;
 583
 584         for ( int i=0; i<nCountAttach; i++ )
 585         {
 586                 if ( !SendOnAttach ( m_StrAryAttach.GetAt(i) ) )
 587                         return FALSE;
 588         }
 589
 590         return TRUE;
 591 }
 592
 593 BOOL CHwSMTP::SendOnAttach(LPCTSTR lpszFileName)
 594 {
 595         ASSERT ( lpszFileName );
 596         CString csAttach, csTemp;
 597
 598         csTemp = lpszFileName;
 599         CString csShortFileName = csTemp.GetBuffer(0) + csTemp.ReverseFind ( '\\' );
 600         csShortFileName.TrimLeft ( _T("\\") );
 601
 602         csTemp.Format ( _T("--%s\r\n"), m_csPartBoundary );
 603         csAttach += csTemp;
 604
 605         csTemp.Format ( _T("Content-Type: application/octet-stream; file=%s\r\n"), csShortFileName );
 606         csAttach += csTemp;
 607
 608         csTemp.Format ( _T("Content-Transfer-Encoding: base64\r\n") );
 609         csAttach += csTemp;
 610
 611         csTemp.Format ( _T("Content-Disposition: attachment; filename=%s\r\n\r\n"), csShortFileName );
 612         csAttach += csTemp;
 613
 614         DWORD dwFileSize =  hwGetFileAttr(lpszFileName);
 615         if ( dwFileSize > 5*1024*1024 )
 616         {
 617                 m_csLastError.Format ( _T("File [%s] too big. File size is : %s"), lpszFileName, FormatBytes(dwFileSize) );
 618                 return FALSE;
 619         }
 620         char *pBuf = new char[dwFileSize+1];
 621         if ( !pBuf )
 622         {
 623                 ::AfxThrowMemoryException ();
 624                 return FALSE;
 625         }
 626
 627         if(!Send ( csAttach ))
 628         {
 629                 delete[] pBuf;
 630                 return FALSE;
 631         }
 632
 633         CFile file;
 634         CStringA filedata;
 635         try
 636         {
 637                 if ( !file.Open ( lpszFileName, CFile::modeRead ) )
 638                 {
 639                         m_csLastError.Format ( _T("Open file [%s] failed"), lpszFileName );
 640                         delete[] pBuf;
 641                         return FALSE;
 642                 }
 643                 UINT nFileLen = file.Read ( pBuf, dwFileSize );
 644                 CBase64 Base64Encode;
 645                 filedata = Base64Encode.Encode ( pBuf, nFileLen );
 646                 filedata += _T("\r\n\r\n");
 647         }
 648         catch (CFileException *e)
 649         {
 650                 e->Delete();
 651                 m_csLastError.Format ( _T("Read file [%s] failed"), lpszFileName );
 652                 delete[] pBuf;
 653                 return FALSE;
 654         }
 655
 656         if(!SendBuffer( filedata.GetBuffer() ))
 657         {
 658                 delete[] pBuf;
 659                 return FALSE;
 660         }
 661
 662         delete[] pBuf;
 663
 664         return TRUE;
 665         //return Send ( csAttach );
 666 }
 667
 668 CString CHwSMTP::GetLastErrorText()
 669 {
 670         return m_csLastError;
 671 }
 672
 673
 674 DWORD WINAPI ThreadProc_SendEmail( LPVOID lpParameter )
 675 {
 676         CEMailObject *pEMailObject = (CEMailObject*)lpParameter;
 677         ASSERT ( pEMailObject );
 678
 679         CHwSMTP HwSMTP;
 680         BOOL bRet = HwSMTP.SendEmail (
 681                 pEMailObject->m_csSmtpSrvHost,
 682                 pEMailObject->m_csUserName,
 683                 pEMailObject->m_csPasswd,
 684                 pEMailObject->m_bMustAuth,
 685                 pEMailObject->m_csAddrFrom,
 686                 pEMailObject->m_csAddrTo,
 687                 pEMailObject->m_csSubject,
 688                 pEMailObject->m_csBody,
 689                 pEMailObject->m_csCharSet,
 690                 &pEMailObject->m_StrAryAttach,
 691                 pEMailObject->m_StrCC,
 692                 pEMailObject->m_nSmtpSrvPort,
 693                 pEMailObject->m_csSender
 694                 );
 695         if ( !bRet)
 696         {
 697 #ifdef _DEBUG
 698                 CString csError = HwSMTP.GetLastErrorText ();
 699                 csError = FormatString ( _T("Send a email to [%s] failed."), pEMailObject->m_csSmtpSrvHost );
 700                 AfxMessageBox ( csError );
 701 #endif
 702         }
 703
 704         m_CSFor__g_PtrAry_Threads.Lock ();
 705         int nFindPos = FindFromArray ( g_PtrAry_Threads, pEMailObject->m_hThread );
 706         if ( nFindPos >= 0 )
 707                 g_PtrAry_Threads.RemoveAt ( nFindPos );
 708         m_CSFor__g_PtrAry_Threads.Unlock ();
 709
 710         delete pEMailObject;
 711         return bRet;
 712 }
 713
 714 //
 715 // ÓÃ SMTP ·þÎñ·¢ËÍµç×ÓÓÊ¼þ£¬Èç¹ûÉèÖÃ²ÎÊý bViaThreadSend=TRUE£¬ÄÇÔÚ³ÌÐò½áÊøÊ±Ó¦¸ÃÔÚ ExitInstance() ÖÐµ÷ÓÃ EndOfSMTP() º¯Êý
 716 //
 717 BOOL SendEmail (
 718                                 BOOL bViaThreadSend,
 719                                 LPCTSTR lpszSmtpSrvHost,
 720                                 LPCTSTR lpszUserName,
 721                                 LPCTSTR lpszPasswd,
 722                                 BOOL bMustAuth,
 723                                 LPCTSTR lpszAddrFrom,
 724                                 LPCTSTR lpszAddrTo,
 725                                 LPCTSTR lpszFromName,
 726                                 LPCTSTR lpszReceiverName,
 727                                 LPCTSTR lpszSubject,
 728                                 LPCTSTR lpszBody,
 729                                 LPCTSTR lpszCharSet/*=NULL*/,
 730                                 CStringArray *pStrAryAttach/*=NULL*/,
 731                                 LPCTSTR pStrAryCC/*=NULL*/,
 732                                 UINT nSmtpSrvPort/*=25*/,
 733                                 LPCTSTR lpszSender,
 734                                 LPCTSTR lpszToList
 735                                 )
 736 {
 737         if ( !lpszSmtpSrvHost || lstrlen(lpszSmtpSrvHost) < 1 ||
 738                 !lpszSubject || lstrlen(lpszSubject) < 1 ||
 739                 !lpszBody || lstrlen(lpszBody) < 1 )
 740         {
 741                 AfxMessageBox ( _T("Parameter error !") );
 742                 return FALSE;
 743         }
 744
 745         CEMailObject *pEMailObject = new CEMailObject (
 746                 lpszSmtpSrvHost,
 747                 lpszUserName,
 748                 lpszPasswd,
 749                 bMustAuth,
 750                 lpszAddrFrom,
 751                 lpszAddrTo,
 752                 lpszFromName,
 753                 lpszReceiverName,
 754                 lpszSubject,
 755                 lpszBody,
 756                 lpszCharSet,
 757                 pStrAryAttach,
 758                 pStrAryCC,
 759                 nSmtpSrvPort,
 760                 lpszSender,
 761                 lpszToList
 762                 );
 763         if ( !pEMailObject ) return FALSE;
 764
 765         BOOL bRet = FALSE;
 766         if ( bViaThreadSend )
 767         {
 768                 DWORD dwThreadId = 0;
 769                 pEMailObject->m_hThread = ::CreateThread ( NULL, 0, ::ThreadProc_SendEmail, pEMailObject, CREATE_SUSPENDED, &dwThreadId );
 770                 bRet = HANDLE_IS_VALID(pEMailObject->m_hThread);
 771                 m_CSFor__g_PtrAry_Threads.Lock();
 772                 g_PtrAry_Threads.Add ( pEMailObject->m_hThread );
 773                 m_CSFor__g_PtrAry_Threads.Unlock();
 774                 ResumeThread ( pEMailObject->m_hThread );
 775         }
 776         else
 777         {
 778                 bRet = (BOOL)ThreadProc_SendEmail ( pEMailObject );
 779         }
 780
 781         return bRet;
 782 }
 783
 784 void EndOfSMTP ()
 785 {
 786         // µÈ´ýËùÓÐÏß³ÌÖ´ÐÐÍê±Ï
 787         for ( int i=0; i<g_PtrAry_Threads.GetSize(); i++ )
 788         {
 789                 HANDLE hThread = (HANDLE)g_PtrAry_Threads.GetAt(i);
 790                 if ( HANDLE_IS_VALID(hThread) )
 791                 {
 792                         WaitForThreadEnd ( &hThread, 30*1000 );
 793                 }
 794         }
 795         g_PtrAry_Threads.RemoveAll ();
 796 }
 797
 798
 799 //
 800 // ½«×Ö·û´® lpszOrg ×ª»»Îª¶à×Ö½ÚµÄ×Ö·û´®£¬Èç¹û»¹ÒªÊ¹ÓÃ¶à×Ö·û´®µÄ³¤¶È£¬¿ÉÒÔÓÃÒÔÏÂ·½Ê½À´Ê¹ÓÃÕâ¸öÀà£º
 801 // CMultiByteString MultiByteString(_T("UNICODE×Ö·û´®"));
 802 // printf ( "ANSI ×Ö·û´®Îª£º %s£¬ ×Ö·û¸öÊýÎª£º %d £¬ ³¤¶ÈÎª£º %d×Ö½Ú\n", MultiByteString.GetBuffer(), MultiByteString.GetLength(), MultiByteString.GetSize() );
 803 //
 804 CMultiByteString::CMultiByteString( LPCTSTR lpszOrg, int nOrgStringEncodeType/*=STRING_IS_SOFTCODE*/, OUT char *pOutBuf/*=NULL*/, int nOutBufSize/*=0*/ )
 805 {
 806         m_bNewBuffer = FALSE;
 807         m_pszData = NULL;
 808         m_nDataSize = 0;
 809         m_nCharactersNumber = 0;
 810         if ( !lpszOrg ) return;
 811
 812         BOOL bOrgIsUnicode = FALSE;
 813         if ( nOrgStringEncodeType == STRING_IS_MULTICHARS ) bOrgIsUnicode = FALSE;
 814         else if ( nOrgStringEncodeType == STRING_IS_UNICODE ) bOrgIsUnicode = TRUE;
 815         else
 816         {
 817 #ifdef UNICODE
 818                 bOrgIsUnicode = TRUE;
 819 #else
 820                 bOrgIsUnicode = FALSE;
 821 #endif
 822         }
 823
 824         if ( bOrgIsUnicode )
 825         {
 826                 m_nCharactersNumber = (int)wcslen((WCHAR*)lpszOrg);
 827                 m_nDataSize = (m_nCharactersNumber + 1) * sizeof(WCHAR);
 828         }
 829         else
 830         {
 831                 m_nCharactersNumber = (int)strlen((char*)lpszOrg);
 832                 m_nDataSize = (m_nCharactersNumber + 1) * sizeof(char);
 833         }
 834
 835         if ( pOutBuf && nOutBufSize > 0 )
 836         {
 837                 m_pszData = pOutBuf;
 838                 m_nDataSize = nOutBufSize;
 839         }
 840         else
 841         {
 842                 m_pszData = (char*)new BYTE[m_nDataSize];
 843                 if ( !m_pszData )
 844                 {
 845                         ::AfxThrowMemoryException ();
 846                         return;
 847                 }
 848                 m_bNewBuffer = TRUE;
 849         }
 850         memset ( m_pszData, 0, m_nDataSize );
 851
 852         if ( bOrgIsUnicode )
 853         {
 854                 m_nCharactersNumber = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)lpszOrg, m_nCharactersNumber, (LPSTR)m_pszData, m_nDataSize / sizeof(char) - 1, NULL, NULL);
 855                 if ( m_nCharactersNumber < 1 ) m_nCharactersNumber = (int)strlen ( m_pszData );
 856         }
 857         else
 858         {
 859                 m_nCharactersNumber = __min ( m_nCharactersNumber, (int)(m_nDataSize/sizeof(char)-1) );
 860                 strncpy ( m_pszData, (const char*)lpszOrg, m_nCharactersNumber );
 861                 m_nCharactersNumber = (int)strlen ( m_pszData );
 862         }
 863         m_nDataSize = ( m_nCharactersNumber + 1 ) * sizeof(char);
 864 }
 865
 866 CMultiByteString::~CMultiByteString ()
 867 {
 868         if ( m_bNewBuffer && m_pszData )
 869         {
 870                 delete[] m_pszData;
 871         }
 872 }
 873
 874 CString GetCompatibleString ( LPVOID lpszOrg, BOOL bOrgIsUnicode, int nOrgLength/*=-1*/ )
 875 {
 876         if ( !lpszOrg ) return _T("");
 877
 878         TRY
 879         {
 880 #ifdef UNICODE
 881                 if ( bOrgIsUnicode )
 882                 {
 883                         if ( nOrgLength > 0 )
 884                         {
 885                                 WCHAR *szRet = new WCHAR[nOrgLength+1];
 886                                 if ( !szRet ) return _T("");
 887                                 memset ( szRet, 0, (nOrgLength+1)*sizeof(WCHAR) );
 888                                 memcpy ( szRet, lpszOrg, nOrgLength*sizeof(WCHAR) );
 889                                 CString csRet = szRet;
 890                                 delete[] szRet;
 891                                 return csRet;
 892                         }
 893                         else if ( nOrgLength == 0 )
 894                                 return _T("");
 895                         else
 896                                 return (LPCTSTR)lpszOrg;
 897                 }
 898
 899                 if ( nOrgLength < 0 )
 900                         nOrgLength = (int)strlen((const char*)lpszOrg);
 901                 int nWideCount = nOrgLength + 1;
 902                 WCHAR *wchar = new WCHAR[nWideCount];
 903                 if ( !wchar ) return _T("");
 904                 memset ( wchar, 0, nWideCount*sizeof(WCHAR) );
 905                 ::MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)lpszOrg, nOrgLength, wchar, nWideCount);
 906                 CString csRet = wchar;
 907                 delete[] wchar;
 908                 return csRet;
 909 #else
 910                 if ( !bOrgIsUnicode )
 911                 {
 912                         if ( nOrgLength > 0 )
 913                         {
 914                                 char *szRet = new char[nOrgLength+1];
 915                                 if ( !szRet ) return _T("");
 916                                 memset ( szRet, 0, (nOrgLength+1)*sizeof(char) );
 917                                 memcpy ( szRet, lpszOrg, nOrgLength*sizeof(char) );
 918                                 CString csRet = szRet;
 919                                 delete[] szRet;
 920                                 return csRet;
 921                         }
 922                         else if ( nOrgLength == 0 )
 923                                 return _T("");
 924                         else
 925                                 return (LPCTSTR)lpszOrg;
 926                 }
 927
 928                 if ( nOrgLength < 0 )
 929                         nOrgLength = (int)wcslen((WCHAR*)lpszOrg);
 930                 int nMultiByteCount = nOrgLength + 1;
 931                 char *szMultiByte = new char[nMultiByteCount];
 932                 if ( !szMultiByte ) return _T("");
 933                 memset ( szMultiByte, 0, nMultiByteCount*sizeof(char) );
 934                 ::WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)lpszOrg, nOrgLength, (LPSTR)szMultiByte, nMultiByteCount, NULL, NULL);
 935                 CString csRet = szMultiByte;
 936                 delete[] szMultiByte;
 937                 return csRet;
 938 #endif
 939         }
 940         CATCH_ALL(e)
 941         {
 942                 THROW_LAST ();
 943         }
 944         END_CATCH_ALL
 945
 946         return _T("");
 947 }
 948
 949 CString FormatDateTime ( COleDateTime &DateTime, LPCTSTR pFormat )
 950 {
 951         // If null, return empty string
 952         if ( DateTime.GetStatus() == COleDateTime::null || DateTime.GetStatus() == COleDateTime::invalid )
 953                 return _T("");
 954
 955         UDATE ud;
 956         if (S_OK != VarUdateFromDate(DateTime.m_dt, 0, &ud))
 957         {
 958                 return _T("");
 959         }
 960
 961         TCHAR *weeks[]={_T("Sun"),_T("Mon"),_T("Tue"),_T("Wen"),_T("Thu"),_T("Fri"),_T("Sat")};
 962         TCHAR *month[]={_T("JAN"),_T("FEB"),_T("MAR"),_T("APR"),
 963                                         _T("MAY"),_T("JUN"),_T("JUL"),_T("AUG"),
 964                                         _T("SEP"),_T("OCT"),_T("NOV"),_T("DEC")};
 965
 966         TIME_ZONE_INFORMATION stTimeZone;
 967         GetTimeZoneInformation(&stTimeZone);
 968
 969         CString strDate;
 970         strDate.Format(_T("%s, %d %s %02d %d:%d:%d %c%04d")
 971                 ,weeks[ud.st.wDayOfWeek],
 972                 ud.st.wDay,month[ud.st.wMonth-1],ud.st.wYear%100,ud.st.wHour,
 973                 ud.st.wMinute,ud.st.wSecond,
 974                 stTimeZone.Bias>0?_T('-'):_T('+'),
 975                 abs(stTimeZone.Bias*10/6)
 976                 );
 977         return strDate;
 978 }
 979
 980 CString FormatString ( LPCTSTR lpszStr, ... )
 981 {
 982         TCHAR *buf = NULL;
 983         for ( int nBufCount = 1024; nBufCount<5*1024*1024; nBufCount += 1024 )
 984         {
 985                 buf = new TCHAR[nBufCount];
 986                 if ( !buf )
 987                 {
 988                         ::AfxThrowMemoryException ();
 989                         return _T("");
 990                 }
 991                 memset ( buf, 0, nBufCount*sizeof(TCHAR) );
 992
 993                 va_list  va;
 994                 va_start (va, lpszStr);
 995                 int nLen = _vsnprintf_hw ((TCHAR*)buf, nBufCount-sizeof(TCHAR), lpszStr, va);
 996                 va_end(va);
 997                 if ( nLen <= (int)(nBufCount-sizeof(TCHAR)) )
 998                         break;
 999                 delete[] buf; buf = NULL;
1000         }
1001         if ( !buf )
1002         {
1003                 return _T("");
1004         }
1005
1006         CString csMsg = buf;
1007         delete[] buf; buf = NULL;
1008         return csMsg;
1009 }
1010
1011 int hwGetFileAttr ( LPCTSTR lpFileName, OUT CFileStatus *pFileStatus/*=NULL*/ )
1012 {
1013         if ( !lpFileName || lstrlen(lpFileName) < 1 ) return -1;
1014
1015         CFileStatus fileStatus;
1016         fileStatus.m_attribute = 0;
1017         fileStatus.m_size = 0;
1018         memset ( fileStatus.m_szFullName, 0, sizeof(fileStatus.m_szFullName) );
1019         BOOL bRet = FALSE;
1020         TRY
1021         {
1022                 if ( CFile::GetStatus(lpFileName,fileStatus) )
1023                 {
1024                         bRet = TRUE;
1025                 }
1026         }
1027         CATCH (CFileException, e)
1028         {
1029                 ASSERT ( FALSE );
1030                 bRet = FALSE;
1031         }
1032         CATCH_ALL(e)
1033         {
1034                 ASSERT ( FALSE );
1035                 bRet = FALSE;
1036         }
1037         END_CATCH_ALL;
1038
1039         if ( pFileStatus )
1040         {
1041                 pFileStatus->m_ctime = fileStatus.m_ctime;
1042                 pFileStatus->m_mtime = fileStatus.m_mtime;
1043                 pFileStatus->m_atime = fileStatus.m_atime;
1044                 pFileStatus->m_size = fileStatus.m_size;
1045                 pFileStatus->m_attribute = fileStatus.m_attribute;
1046                 lstrcpy ( pFileStatus->m_szFullName, fileStatus.m_szFullName );
1047
1048         }
1049
1050         return (int)fileStatus.m_size;
1051 }
1052
1053 CString FormatBytes ( double fBytesNum, BOOL bShowUnit/*=TRUE*/, int nFlag/*=0*/ )
1054 {
1055         CString csRes;
1056         if ( nFlag == 0 )
1057         {
1058                 if ( fBytesNum >= 1024.0 && fBytesNum < 1024.0*1024.0 )
1059                         csRes.Format ( _T("%.2f%s"), fBytesNum / 1024.0, bShowUnit?_T(" K"):_T("") );
1060                 else if ( fBytesNum >= 1024.0*1024.0 && fBytesNum < 1024.0*1024.0*1024.0 )
1061                         csRes.Format ( _T("%.2f%s"), fBytesNum / (1024.0*1024.0), bShowUnit?_T(" M"):_T("") );
1062                 else if ( fBytesNum >= 1024.0*1024.0*1024.0 )
1063                         csRes.Format ( _T("%.2f%s"), fBytesNum / (1024.0*1024.0*1024.0), bShowUnit?_T(" G"):_T("") );
1064                 else
1065                         csRes.Format ( _T("%.2f%s"), fBytesNum, bShowUnit?_T(" B"):_T("") );
1066         }
1067         else if ( nFlag == 1 )
1068         {
1069                 csRes.Format ( _T("%.2f%s"), fBytesNum / 1024.0, bShowUnit?_T(" K"):_T("") );
1070         }
1071         else if ( nFlag == 2 )
1072         {
1073                 csRes.Format ( _T("%.2f%s"), fBytesNum / (1024.0*1024.0), bShowUnit?_T(" M"):_T("") );
1074         }
1075         else if ( nFlag == 3 )
1076         {
1077                 csRes.Format ( _T("%.2f%s"), fBytesNum / (1024.0*1024.0*1024.0), bShowUnit?_T(" G"):_T("") );
1078         }
1079
1080         return csRes;
1081 }
1082
1083 //
1084 // µÈ´ýÏß³ÌÍË³ö
1085 //
1086 BOOL WaitForThreadEnd ( HANDLE *phThread, DWORD dwWaitTime /*=10*1000*/ )
1087 {
1088         BOOL bRet = TRUE;
1089         ASSERT ( phThread );
1090         if ( !(*phThread) ) return TRUE;
1091         if ( ::WaitForSingleObject ( *phThread, dwWaitTime ) == WAIT_TIMEOUT )
1092         {
1093                 bRet = FALSE;
1094                 ::TerminateThread ( *phThread, 0 );
1095         }
1096         ::CloseHandle ( *phThread );
1097         (*phThread) = NULL;
1098         return bRet;
1099 }