src/Utils/HwSMTP.cpp

   1 // HwSMTP.cpp: implementation of the CHwSMTP class.
   2 //
   3 // Schannel/SSPI implementation based on http://www.coastrd.com/c-schannel-smtp
   4 //
   5 //////////////////////////////////////////////////////////////////////
   6
   7 #include "stdafx.h"
   8 #include "afxstr.h"
   9 #include "HwSMTP.h"
  10 #include "SpeedPostEmail.h"
  11 #include "Windns.h"
  12 #include <Afxmt.h>
  13 #include "FormatMessageWrapper.h"
  14 #include <atlenc.h>
  15 #include "AppUtils.h"
  16
  17 #define IO_BUFFER_SIZE 0x10000
  18
  19 #pragma comment(lib, "Secur32.lib")
  20
  21 DWORD dwProtocol = SP_PROT_TLS1; // SP_PROT_TLS1; // SP_PROT_PCT1; SP_PROT_SSL2; SP_PROT_SSL3; 0=default
  22 ALG_ID aiKeyExch = 0; // = default; CALG_DH_EPHEM; CALG_RSA_KEYX;
  23
  24 SCHANNEL_CRED SchannelCred;
  25 PSecurityFunctionTable g_pSSPI;
  26
  27 //////////////////////////////////////////////////////////////////////
  28 // Construction/Destruction
  29 //////////////////////////////////////////////////////////////////////
  30
  31 CHwSMTP::CHwSMTP () :
  32         m_bConnected ( FALSE ),
  33         m_nSmtpSrvPort ( 25 ),
  34         m_bMustAuth ( TRUE )
  35 {
  36         m_csPartBoundary = _T( "WC_MAIL_PaRt_BoUnDaRy_05151998" );
  37         m_csMIMEContentType = FormatString ( _T( "multipart/mixed; boundary=%s" ), m_csPartBoundary);
  38         m_csNoMIMEText = _T( "This is a multi-part message in MIME format." );
  39         //m_csCharSet = _T("\r\n\tcharset=\"iso-8859-1\"\r\n");
  40
  41         hContext = nullptr;
  42         hCreds = nullptr;
  43         pbIoBuffer = nullptr;
  44         cbIoBufferLength = 0;
  45
  46         m_iSecurityLevel = none;
  47
  48         SecureZeroMemory(&Sizes, sizeof(SecPkgContext_StreamSizes));
  49
  50         AfxSocketInit();
  51 }
  52
  53 CHwSMTP::~CHwSMTP()
  54 {
  55 }
  56
  57 void CHwSMTP::GetNameAddress(CString &in, CString &name,CString &address)
  58 {
  59         int start,end;
  60         start=in.Find(_T('<'));
  61         end=in.Find(_T('>'));
  62
  63         if(start >=0 && end >=0)
  64         {
  65                 name=in.Left(start);
  66                 address=in.Mid(start+1,end-start-1);
  67         }
  68         else
  69                 address=in;
  70 }
  71
  72 CString CHwSMTP::GetServerAddress(CString &email)
  73 {
  74         CString str;
  75         int start,end;
  76
  77         start = email.Find(_T("<"));
  78         end = email.Find(_T(">"));
  79
  80         if(start>=0 && end >=0)
  81         {
  82                 str=email.Mid(start+1,end-start-1);
  83         }
  84         else
  85         {
  86                 str=email;
  87         }
  88
  89         start = str.Find(_T('@'));
  90         return str.Mid(start+1);
  91
  92 }
  93
  94 BOOL CHwSMTP::SendSpeedEmail
  95                 (
  96                         LPCTSTR lpszAddrFrom,
  97                         LPCTSTR lpszAddrTo,
  98                         LPCTSTR lpszSubject,
  99                         LPCTSTR lpszBody,
 100                         LPCTSTR lpszCharSet,
 101                         CStringArray *pStrAryAttach,
 102                         LPCTSTR pStrAryCC,
 103                         LPCTSTR pSend
 104                 )
 105 {
 106
 107         BOOL ret=true;
 108         CString To;
 109         To += GET_SAFE_STRING(lpszAddrTo);
 110         To += _T(";");
 111         To += GET_SAFE_STRING(pStrAryCC);
 112
 113         std::map<CString,std::vector<CString>> Address;
 114
 115         int start = 0;
 116         while( start >= 0 )
 117         {
 118                 CString one= To.Tokenize(_T(";"),start);
 119                 one=one.Trim();
 120                 if(one.IsEmpty())
 121                         continue;
 122
 123                 CString addr;
 124                 addr = GetServerAddress(one);
 125                 if(addr.IsEmpty())
 126                         continue;
 127
 128                 Address[addr].push_back(one);
 129
 130         }
 131
 132         std::map<CString,std::vector<CString>>::iterator itr1  =  Address.begin();
 133         for(  ;  itr1  !=  Address.end();  ++itr1 )
 134         {
 135                 PDNS_RECORD pDnsRecord;
 136                 PDNS_RECORD pNext;
 137
 138                 DNS_STATUS status =
 139                 DnsQuery(itr1->first ,
 140                                                 DNS_TYPE_MX,DNS_QUERY_STANDARD,
 141                                                 NULL,                   //Contains DNS server IP address.
 142                                                 &pDnsRecord,    //Resource record that contains the response.
 143                                                 NULL
 144                                                 );
 145                 if (status)
 146                 {
 147                         m_csLastError.Format(_T("DNS query failed %d"), status);
 148                         ret = false;
 149                         continue;
 150                 }
 151
 152                 CString to;
 153                 to.Empty();
 154                 for (size_t i = 0; i < itr1->second.size(); ++i)
 155                 {
 156                         to+=itr1->second[i];
 157                         to+=_T(";");
 158                 }
 159                 if(to.IsEmpty())
 160                         continue;
 161
 162                 pNext=pDnsRecord;
 163                 while(pNext)
 164                 {
 165                         if(pNext->wType == DNS_TYPE_MX)
 166                                 if(SendEmail(pNext->Data.MX.pNameExchange,NULL,NULL,false,
 167                                         lpszAddrFrom,to,lpszSubject,lpszBody,lpszCharSet,pStrAryAttach,pStrAryCC,
 168                                         25,pSend,lpszAddrTo))
 169                                         break;
 170                         pNext=pNext->pNext;
 171                 }
 172                 if(pNext == NULL)
 173                         ret = false;
 174
 175                 if (pDnsRecord)
 176                         DnsRecordListFree(pDnsRecord,DnsFreeRecordList);
 177         }
 178
 179         return ret;
 180 }
 181
 182 static SECURITY_STATUS ClientHandshakeLoop(CSocket * Socket, PCredHandle phCreds, CtxtHandle * phContext, BOOL fDoInitialRead, SecBuffer * pExtraData)
 183 {
 184         SecBufferDesc OutBuffer, InBuffer;
 185         SecBuffer InBuffers[2], OutBuffers[1];
 186         DWORD dwSSPIFlags, dwSSPIOutFlags, cbData, cbIoBuffer;
 187         TimeStamp tsExpiry;
 188         SECURITY_STATUS scRet;
 189         PUCHAR IoBuffer;
 190         BOOL fDoRead;
 191
 192         dwSSPIFlags = ISC_REQ_SEQUENCE_DETECT   | ISC_REQ_REPLAY_DETECT         | ISC_REQ_CONFIDENTIALITY |
 193                                   ISC_RET_EXTENDED_ERROR        | ISC_REQ_ALLOCATE_MEMORY       | ISC_REQ_STREAM;
 194
 195         // Allocate data buffer.
 196         IoBuffer = new UCHAR[IO_BUFFER_SIZE];
 197         if (IoBuffer == nullptr)
 198         {
 199                 // printf("**** Out of memory (1)\n");
 200                 return SEC_E_INTERNAL_ERROR;
 201         }
 202         cbIoBuffer = 0;
 203         fDoRead = fDoInitialRead;
 204
 205         // Loop until the handshake is finished or an error occurs.
 206         scRet = SEC_I_CONTINUE_NEEDED;
 207
 208         while (scRet == SEC_I_CONTINUE_NEEDED || scRet == SEC_E_INCOMPLETE_MESSAGE || scRet == SEC_I_INCOMPLETE_CREDENTIALS)
 209         {
 210                 if (0 == cbIoBuffer || scRet == SEC_E_INCOMPLETE_MESSAGE) // Read data from server.
 211                 {
 212                         if (fDoRead)
 213                         {
 214                                 cbData = Socket->Receive(IoBuffer + cbIoBuffer, IO_BUFFER_SIZE - cbIoBuffer, 0);
 215                                 if (cbData == SOCKET_ERROR)
 216                                 {
 217                                         // printf("**** Error %d reading data from server\n", WSAGetLastError());
 218                                         scRet = SEC_E_INTERNAL_ERROR;
 219                                         break;
 220                                 }
 221                                 else if (cbData == 0)
 222                                 {
 223                                         // printf("**** Server unexpectedly disconnected\n");
 224                                         scRet = SEC_E_INTERNAL_ERROR;
 225                                         break;
 226                                 }
 227                                 // printf("%d bytes of handshake data received\n", cbData);
 228                                 cbIoBuffer += cbData;
 229                         }
 230                         else
 231                                 fDoRead = TRUE;
 232                 }
 233
 234                 // Set up the input buffers. Buffer 0 is used to pass in data
 235                 // received from the server. Schannel will consume some or all
 236                 // of this. Leftover data (if any) will be placed in buffer 1 and
 237                 // given a buffer type of SECBUFFER_EXTRA.
 238                 InBuffers[0].pvBuffer   = IoBuffer;
 239                 InBuffers[0].cbBuffer   = cbIoBuffer;
 240                 InBuffers[0].BufferType = SECBUFFER_TOKEN;
 241
 242                 InBuffers[1].pvBuffer   = nullptr;
 243                 InBuffers[1].cbBuffer   = 0;
 244                 InBuffers[1].BufferType = SECBUFFER_EMPTY;
 245
 246                 InBuffer.cBuffers               = 2;
 247                 InBuffer.pBuffers               = InBuffers;
 248                 InBuffer.ulVersion              = SECBUFFER_VERSION;
 249
 250                 // Set up the output buffers. These are initialized to NULL
 251                 // so as to make it less likely we'll attempt to free random
 252                 // garbage later.
 253                 OutBuffers[0].pvBuffer  = nullptr;
 254                 OutBuffers[0].BufferType= SECBUFFER_TOKEN;
 255                 OutBuffers[0].cbBuffer  = 0;
 256
 257                 OutBuffer.cBuffers              = 1;
 258                 OutBuffer.pBuffers              = OutBuffers;
 259                 OutBuffer.ulVersion             = SECBUFFER_VERSION;
 260
 261                 // Call InitializeSecurityContext.
 262                 scRet = g_pSSPI->InitializeSecurityContext(phCreds, phContext, nullptr, dwSSPIFlags, 0, SECURITY_NATIVE_DREP, &InBuffer, 0, nullptr, &OutBuffer, &dwSSPIOutFlags, &tsExpiry);
 263
 264                 // If InitializeSecurityContext was successful (or if the error was
 265                 // one of the special extended ones), send the contends of the output
 266                 // buffer to the server.
 267                 if (scRet == SEC_E_OK || scRet == SEC_I_CONTINUE_NEEDED || FAILED(scRet) && (dwSSPIOutFlags & ISC_RET_EXTENDED_ERROR))
 268                 {
 269                         if (OutBuffers[0].cbBuffer != 0 && OutBuffers[0].pvBuffer != nullptr)
 270                         {
 271                                 cbData = Socket->Send(OutBuffers[0].pvBuffer, OutBuffers[0].cbBuffer, 0 );
 272                                 if(cbData == SOCKET_ERROR || cbData == 0)
 273                                 {
 274                                         // printf( "**** Error %d sending data to server (2)\n",  WSAGetLastError() );
 275                                         g_pSSPI->FreeContextBuffer(OutBuffers[0].pvBuffer);
 276                                         g_pSSPI->DeleteSecurityContext(phContext);
 277                                         return SEC_E_INTERNAL_ERROR;
 278                                 }
 279                                 // printf("%d bytes of handshake data sent\n", cbData);
 280
 281                                 // Free output buffer.
 282                                 g_pSSPI->FreeContextBuffer(OutBuffers[0].pvBuffer);
 283                                 OutBuffers[0].pvBuffer = nullptr;
 284                         }
 285                 }
 286
 287                 // If InitializeSecurityContext returned SEC_E_INCOMPLETE_MESSAGE,
 288                 // then we need to read more data from the server and try again.
 289                 if (scRet == SEC_E_INCOMPLETE_MESSAGE) continue;
 290
 291                 // If InitializeSecurityContext returned SEC_E_OK, then the
 292                 // handshake completed successfully.
 293                 if (scRet == SEC_E_OK)
 294                 {
 295                         // If the "extra" buffer contains data, this is encrypted application
 296                         // protocol layer stuff. It needs to be saved. The application layer
 297                         // will later decrypt it with DecryptMessage.
 298                         // printf("Handshake was successful\n");
 299
 300                         if (InBuffers[1].BufferType == SECBUFFER_EXTRA)
 301                         {
 302                                 pExtraData->pvBuffer = LocalAlloc( LMEM_FIXED, InBuffers[1].cbBuffer );
 303                                 if (pExtraData->pvBuffer == nullptr)
 304                                 {
 305                                         // printf("**** Out of memory (2)\n");
 306                                         return SEC_E_INTERNAL_ERROR;
 307                                 }
 308
 309                                 MoveMemory(pExtraData->pvBuffer, IoBuffer + (cbIoBuffer - InBuffers[1].cbBuffer), InBuffers[1].cbBuffer);
 310
 311                                 pExtraData->cbBuffer    = InBuffers[1].cbBuffer;
 312                                 pExtraData->BufferType  = SECBUFFER_TOKEN;
 313
 314                                 // printf( "%d bytes of app data was bundled with handshake data\n", pExtraData->cbBuffer );
 315                         }
 316                         else
 317                         {
 318                                 pExtraData->pvBuffer    = nullptr;
 319                                 pExtraData->cbBuffer    = 0;
 320                                 pExtraData->BufferType  = SECBUFFER_EMPTY;
 321                         }
 322                         break; // Bail out to quit
 323                 }
 324
 325                 // Check for fatal error.
 326                 if (FAILED(scRet))
 327                 {
 328                         // printf("**** Error 0x%x returned by InitializeSecurityContext (2)\n", scRet);
 329                         break;
 330                 }
 331
 332                 // If InitializeSecurityContext returned SEC_I_INCOMPLETE_CREDENTIALS,
 333                 // then the server just requested client authentication.
 334                 if (scRet == SEC_I_INCOMPLETE_CREDENTIALS)
 335                 {
 336                         // Busted. The server has requested client authentication and
 337                         // the credential we supplied didn't contain a client certificate.
 338                         // This function will read the list of trusted certificate
 339                         // authorities ("issuers") that was received from the server
 340                         // and attempt to find a suitable client certificate that
 341                         // was issued by one of these. If this function is successful,
 342                         // then we will connect using the new certificate. Otherwise,
 343                         // we will attempt to connect anonymously (using our current credentials).
 344                         //GetNewClientCredentials(phCreds, phContext);
 345
 346                         // Go around again.
 347                         fDoRead = FALSE;
 348                         scRet = SEC_I_CONTINUE_NEEDED;
 349                         continue;
 350                 }
 351
 352                 // Copy any leftover data from the "extra" buffer, and go around again.
 353                 if ( InBuffers[1].BufferType == SECBUFFER_EXTRA )
 354                 {
 355                         MoveMemory(IoBuffer, IoBuffer + (cbIoBuffer - InBuffers[1].cbBuffer), InBuffers[1].cbBuffer);
 356                         cbIoBuffer = InBuffers[1].cbBuffer;
 357                 }
 358                 else
 359                         cbIoBuffer = 0;
 360         }
 361
 362         // Delete the security context in the case of a fatal error.
 363         if (FAILED(scRet))
 364                 g_pSSPI->DeleteSecurityContext(phContext);
 365         delete[] IoBuffer;
 366
 367         return scRet;
 368 }
 369
 370 static SECURITY_STATUS PerformClientHandshake( CSocket * Socket, PCredHandle phCreds, LPTSTR pszServerName, CtxtHandle * phContext, SecBuffer * pExtraData)
 371 {
 372         SecBufferDesc OutBuffer;
 373         SecBuffer OutBuffers[1];
 374         DWORD dwSSPIFlags, dwSSPIOutFlags, cbData;
 375         TimeStamp tsExpiry;
 376         SECURITY_STATUS scRet;
 377
 378         dwSSPIFlags = ISC_REQ_SEQUENCE_DETECT   | ISC_REQ_REPLAY_DETECT         | ISC_REQ_CONFIDENTIALITY |
 379                                   ISC_RET_EXTENDED_ERROR        | ISC_REQ_ALLOCATE_MEMORY       | ISC_REQ_STREAM;
 380
 381         //  Initiate a ClientHello message and generate a token.
 382         OutBuffers[0].pvBuffer = nullptr;
 383         OutBuffers[0].BufferType = SECBUFFER_TOKEN;
 384         OutBuffers[0].cbBuffer = 0;
 385
 386         OutBuffer.cBuffers = 1;
 387         OutBuffer.pBuffers = OutBuffers;
 388         OutBuffer.ulVersion = SECBUFFER_VERSION;
 389
 390         scRet = g_pSSPI->InitializeSecurityContext(phCreds, nullptr, pszServerName, dwSSPIFlags, 0, SECURITY_NATIVE_DREP, nullptr, 0, phContext, &OutBuffer, &dwSSPIOutFlags, &tsExpiry);
 391
 392         if (scRet != SEC_I_CONTINUE_NEEDED)
 393         {
 394                 // printf("**** Error %d returned by InitializeSecurityContext (1)\n", scRet);
 395                 return scRet;
 396         }
 397
 398         // Send response to server if there is one.
 399         if (OutBuffers[0].cbBuffer != 0 && OutBuffers[0].pvBuffer != nullptr)
 400         {
 401                 cbData = Socket->Send(OutBuffers[0].pvBuffer, OutBuffers[0].cbBuffer, 0);
 402                 if (cbData == SOCKET_ERROR || cbData == 0)
 403                 {
 404                         // printf("**** Error %d sending data to server (1)\n", WSAGetLastError());
 405                         g_pSSPI->FreeContextBuffer(OutBuffers[0].pvBuffer);
 406                         g_pSSPI->DeleteSecurityContext(phContext);
 407                         return SEC_E_INTERNAL_ERROR;
 408                 }
 409                 // printf("%d bytes of handshake data sent\n", cbData);
 410
 411                 g_pSSPI->FreeContextBuffer(OutBuffers[0].pvBuffer); // Free output buffer.
 412                 OutBuffers[0].pvBuffer = nullptr;
 413         }
 414
 415         return ClientHandshakeLoop(Socket, phCreds, phContext, TRUE, pExtraData);
 416 }
 417
 418 static SECURITY_STATUS CreateCredentials(PCredHandle phCreds)
 419 {
 420         TimeStamp tsExpiry;
 421         SECURITY_STATUS Status;
 422         DWORD cSupportedAlgs = 0;
 423         ALG_ID rgbSupportedAlgs[16];
 424
 425         // Build Schannel credential structure. Currently, this sample only
 426         // specifies the protocol to be used (and optionally the certificate,
 427         // of course). Real applications may wish to specify other parameters as well.
 428         SecureZeroMemory(&SchannelCred, sizeof(SchannelCred));
 429
 430         SchannelCred.dwVersion = SCHANNEL_CRED_VERSION;
 431         SchannelCred.grbitEnabledProtocols = dwProtocol;
 432
 433         if (aiKeyExch)
 434                 rgbSupportedAlgs[cSupportedAlgs++] = aiKeyExch;
 435
 436         if (cSupportedAlgs)
 437         {
 438                 SchannelCred.cSupportedAlgs = cSupportedAlgs;
 439                 SchannelCred.palgSupportedAlgs = rgbSupportedAlgs;
 440         }
 441
 442         SchannelCred.dwFlags |= SCH_CRED_NO_DEFAULT_CREDS;
 443
 444         // The SCH_CRED_MANUAL_CRED_VALIDATION flag is specified because
 445         // this sample verifies the server certificate manually.
 446         // Applications that expect to run on WinNT, Win9x, or WinME
 447         // should specify this flag and also manually verify the server
 448         // certificate. Applications running on newer versions of Windows can
 449         // leave off this flag, in which case the InitializeSecurityContext
 450         // function will validate the server certificate automatically.
 451         SchannelCred.dwFlags |= SCH_CRED_MANUAL_CRED_VALIDATION;
 452
 453         // Create an SSPI credential.
 454         Status = g_pSSPI->AcquireCredentialsHandle(nullptr,                // Name of principal
 455                                                                                                  UNISP_NAME,           // Name of package
 456                                                                                                  SECPKG_CRED_OUTBOUND, // Flags indicating use
 457                                                                                                  nullptr,              // Pointer to logon ID
 458                                                                                                  &SchannelCred,        // Package specific data
 459                                                                                                  nullptr,              // Pointer to GetKey() func
 460                                                                                                  nullptr,              // Value to pass to GetKey()
 461                                                                                                  phCreds,              // (out) Cred Handle
 462                                                                                                  &tsExpiry );          // (out) Lifetime (optional)
 463
 464         return Status;
 465 }
 466
 467 static DWORD EncryptSend(CSocket * Socket, CtxtHandle * phContext, PBYTE pbIoBuffer, SecPkgContext_StreamSizes Sizes)
 468 // http://msdn.microsoft.com/en-us/library/aa375378(VS.85).aspx
 469 // The encrypted message is encrypted in place, overwriting the original contents of its buffer.
 470 {
 471         SECURITY_STATUS scRet;
 472         SecBufferDesc Message;
 473         SecBuffer Buffers[4];
 474         DWORD cbMessage;
 475         PBYTE pbMessage;
 476
 477         pbMessage = pbIoBuffer + Sizes.cbHeader; // Offset by "header size"
 478         cbMessage = (DWORD)strlen((char *)pbMessage);
 479
 480         // Encrypt the HTTP request.
 481         Buffers[0].pvBuffer     = pbIoBuffer;                 // Pointer to buffer 1
 482         Buffers[0].cbBuffer     = Sizes.cbHeader;             // length of header
 483         Buffers[0].BufferType   = SECBUFFER_STREAM_HEADER;    // Type of the buffer
 484
 485         Buffers[1].pvBuffer     = pbMessage;                  // Pointer to buffer 2
 486         Buffers[1].cbBuffer     = cbMessage;                  // length of the message
 487         Buffers[1].BufferType   = SECBUFFER_DATA;             // Type of the buffer
 488
 489         Buffers[2].pvBuffer     = pbMessage + cbMessage;      // Pointer to buffer 3
 490         Buffers[2].cbBuffer     = Sizes.cbTrailer;            // length of the trailor
 491         Buffers[2].BufferType   = SECBUFFER_STREAM_TRAILER;   // Type of the buffer
 492
 493         Buffers[3].pvBuffer     = SECBUFFER_EMPTY;            // Pointer to buffer 4
 494         Buffers[3].cbBuffer     = SECBUFFER_EMPTY;            // length of buffer 4
 495         Buffers[3].BufferType   = SECBUFFER_EMPTY;            // Type of the buffer 4
 496
 497         Message.ulVersion       = SECBUFFER_VERSION;          // Version number
 498         Message.cBuffers        = 4;                          // Number of buffers - must contain four SecBuffer structures.
 499         Message.pBuffers        = Buffers;                    // Pointer to array of buffers
 500
 501         scRet = g_pSSPI->EncryptMessage(phContext, 0, &Message, 0); // must contain four SecBuffer structures.
 502         if (FAILED(scRet))
 503         {
 504                 // printf("**** Error 0x%x returned by EncryptMessage\n", scRet);
 505                 return scRet;
 506         }
 507
 508
 509         // Send the encrypted data to the server.
 510         return Socket->Send(pbIoBuffer, Buffers[0].cbBuffer + Buffers[1].cbBuffer + Buffers[2].cbBuffer, 0);
 511 }
 512
 513 static LONG DisconnectFromServer(CSocket * Socket, PCredHandle phCreds, CtxtHandle * phContext)
 514 {
 515         PBYTE pbMessage;
 516         DWORD dwType, dwSSPIFlags, dwSSPIOutFlags, cbMessage, cbData, Status;
 517         SecBufferDesc OutBuffer;
 518         SecBuffer OutBuffers[1];
 519         TimeStamp tsExpiry;
 520
 521         dwType = SCHANNEL_SHUTDOWN; // Notify schannel that we are about to close the connection.
 522
 523         OutBuffers[0].pvBuffer = &dwType;
 524         OutBuffers[0].BufferType = SECBUFFER_TOKEN;
 525         OutBuffers[0].cbBuffer = sizeof(dwType);
 526
 527         OutBuffer.cBuffers = 1;
 528         OutBuffer.pBuffers = OutBuffers;
 529         OutBuffer.ulVersion = SECBUFFER_VERSION;
 530
 531         Status = g_pSSPI->ApplyControlToken(phContext, &OutBuffer);
 532         if (FAILED(Status))
 533         {
 534                 // printf("**** Error 0x%x returned by ApplyControlToken\n", Status);
 535                 goto cleanup;
 536         }
 537
 538         // Build an SSL close notify message.
 539         dwSSPIFlags = ISC_REQ_SEQUENCE_DETECT | ISC_REQ_REPLAY_DETECT | ISC_REQ_CONFIDENTIALITY | ISC_RET_EXTENDED_ERROR | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_STREAM;
 540
 541         OutBuffers[0].pvBuffer = nullptr;
 542         OutBuffers[0].BufferType = SECBUFFER_TOKEN;
 543         OutBuffers[0].cbBuffer = 0;
 544
 545         OutBuffer.cBuffers = 1;
 546         OutBuffer.pBuffers = OutBuffers;
 547         OutBuffer.ulVersion = SECBUFFER_VERSION;
 548
 549         Status = g_pSSPI->InitializeSecurityContext(phCreds, phContext, nullptr, dwSSPIFlags, 0, SECURITY_NATIVE_DREP, nullptr, 0, phContext, &OutBuffer, &dwSSPIOutFlags, &tsExpiry);
 550
 551         if (FAILED(Status))
 552         {
 553                 // printf("**** Error 0x%x returned by InitializeSecurityContext\n", Status);
 554                 goto cleanup;
 555         }
 556
 557         pbMessage = (PBYTE)OutBuffers[0].pvBuffer;
 558         cbMessage = OutBuffers[0].cbBuffer;
 559
 560         // Send the close notify message to the server.
 561         if (pbMessage != nullptr && cbMessage != 0)
 562         {
 563                 cbData = Socket->Send(pbMessage, cbMessage, 0);
 564                 if (cbData == SOCKET_ERROR || cbData == 0)
 565                 {
 566                         Status = WSAGetLastError();
 567                         goto cleanup;
 568                 }
 569                 // printf("Sending Close Notify\n");
 570                 // printf("%d bytes of handshake data sent\n", cbData);
 571                 g_pSSPI->FreeContextBuffer(pbMessage); // Free output buffer.
 572         }
 573
 574 cleanup:
 575         g_pSSPI->DeleteSecurityContext(phContext); // Free the security context.
 576         Socket->Close();
 577
 578         return Status;
 579 }
 580
 581 static SECURITY_STATUS ReadDecrypt(CSocket * Socket, PCredHandle phCreds, CtxtHandle * phContext, PBYTE pbIoBuffer, DWORD cbIoBufferLength)
 582
 583 // calls recv() - blocking socket read
 584 // http://msdn.microsoft.com/en-us/library/ms740121(VS.85).aspx
 585
 586 // The encrypted message is decrypted in place, overwriting the original contents of its buffer.
 587 // http://msdn.microsoft.com/en-us/library/aa375211(VS.85).aspx
 588
 589 {
 590         SecBuffer ExtraBuffer;
 591         SecBuffer * pDataBuffer, * pExtraBuffer;
 592
 593         SECURITY_STATUS scRet;
 594         SecBufferDesc Message;
 595         SecBuffer Buffers[4];
 596
 597         DWORD cbIoBuffer, cbData, length;
 598         PBYTE buff;
 599
 600         // Read data from server until done.
 601         cbIoBuffer = 0;
 602         scRet = 0;
 603         while (TRUE) // Read some data.
 604         {
 605                 if (cbIoBuffer == 0 || scRet == SEC_E_INCOMPLETE_MESSAGE) // get the data
 606                 {
 607                         cbData = Socket->Receive(pbIoBuffer + cbIoBuffer, cbIoBufferLength - cbIoBuffer, 0);
 608                         if (cbData == SOCKET_ERROR)
 609                         {
 610                                 // printf("**** Error %d reading data from server\n", WSAGetLastError());
 611                                 scRet = SEC_E_INTERNAL_ERROR;
 612                                 break;
 613                         }
 614                         else if (cbData == 0) // Server disconnected.
 615                         {
 616                                 if (cbIoBuffer)
 617                                 {
 618                                         // printf("**** Server unexpectedly disconnected\n");
 619                                         scRet = SEC_E_INTERNAL_ERROR;
 620                                         return scRet;
 621                                 }
 622                                 else
 623                                         break; // All Done
 624                         }
 625                         else // success
 626                         {
 627                                 // printf("%d bytes of (encrypted) application data received\n", cbData);
 628                                 cbIoBuffer += cbData;
 629                         }
 630                 }
 631
 632                 // Decrypt the received data.
 633                 Buffers[0].pvBuffer     = pbIoBuffer;
 634                 Buffers[0].cbBuffer     = cbIoBuffer;
 635                 Buffers[0].BufferType   = SECBUFFER_DATA;  // Initial Type of the buffer 1
 636                 Buffers[1].BufferType   = SECBUFFER_EMPTY; // Initial Type of the buffer 2
 637                 Buffers[2].BufferType   = SECBUFFER_EMPTY; // Initial Type of the buffer 3
 638                 Buffers[3].BufferType   = SECBUFFER_EMPTY; // Initial Type of the buffer 4
 639
 640                 Message.ulVersion       = SECBUFFER_VERSION;    // Version number
 641                 Message.cBuffers        = 4;                    // Number of buffers - must contain four SecBuffer structures.
 642                 Message.pBuffers        = Buffers;              // Pointer to array of buffers
 643
 644                 scRet = g_pSSPI->DecryptMessage(phContext, &Message, 0, nullptr);
 645                 if (scRet == SEC_I_CONTEXT_EXPIRED)
 646                         break; // Server signalled end of session
 647 //              if (scRet == SEC_E_INCOMPLETE_MESSAGE - Input buffer has partial encrypted record, read more
 648                 if (scRet != SEC_E_OK && scRet != SEC_I_RENEGOTIATE && scRet != SEC_I_CONTEXT_EXPIRED)
 649                         return scRet;
 650
 651                 // Locate data and (optional) extra buffers.
 652                 pDataBuffer  = nullptr;
 653                 pExtraBuffer = nullptr;
 654                 for (int i = 1; i < 4; ++i)
 655                 {
 656                         if (pDataBuffer  == nullptr && Buffers[i].BufferType == SECBUFFER_DATA)
 657                                 pDataBuffer  = &Buffers[i];
 658                         if (pExtraBuffer == nullptr && Buffers[i].BufferType == SECBUFFER_EXTRA)
 659                                 pExtraBuffer = &Buffers[i];
 660                 }
 661
 662                 // Display the decrypted data.
 663                 if (pDataBuffer)
 664                 {
 665                         length = pDataBuffer->cbBuffer;
 666                         if (length) // check if last two chars are CR LF
 667                         {
 668                                 buff = (PBYTE)pDataBuffer->pvBuffer;
 669                                 if (buff[length-2] == 13 && buff[length-1] == 10) // Found CRLF
 670                                 {
 671                                         buff[length] = 0;
 672                                         break;
 673                                 }
 674                         }
 675                 }
 676
 677                 // Move any "extra" data to the input buffer.
 678                 if (pExtraBuffer)
 679                 {
 680                         MoveMemory(pbIoBuffer, pExtraBuffer->pvBuffer, pExtraBuffer->cbBuffer);
 681                         cbIoBuffer = pExtraBuffer->cbBuffer;
 682                 }
 683                 else
 684                         cbIoBuffer = 0;
 685
 686                 // The server wants to perform another handshake sequence.
 687                 if (scRet == SEC_I_RENEGOTIATE)
 688                 {
 689                         // printf("Server requested renegotiate!\n");
 690                         scRet = ClientHandshakeLoop( Socket, phCreds, phContext, FALSE, &ExtraBuffer);
 691                         if (scRet != SEC_E_OK)
 692                                 return scRet;
 693
 694                         if (ExtraBuffer.pvBuffer) // Move any "extra" data to the input buffer.
 695                         {
 696                                 MoveMemory(pbIoBuffer, ExtraBuffer.pvBuffer, ExtraBuffer.cbBuffer);
 697                                 cbIoBuffer = ExtraBuffer.cbBuffer;
 698                         }
 699                 }
 700         } // Loop till CRLF is found at the end of the data
 701
 702         return SEC_E_OK;
 703 }
 704
 705 BOOL CHwSMTP::SendEmail (
 706                 LPCTSTR lpszSmtpSrvHost,
 707                 LPCTSTR lpszUserName,
 708                 LPCTSTR lpszPasswd,
 709                 BOOL bMustAuth,
 710                 LPCTSTR lpszAddrFrom,
 711                 LPCTSTR lpszAddrTo,
 712                 LPCTSTR lpszSubject,
 713                 LPCTSTR lpszBody,
 714                 LPCTSTR lpszCharSet,                                            // ×Ö·û¼¯ÀàÐÍ£¬ÀýÈç£º·±ÌåÖÐÎÄÕâÀïÓ¦ÊäÈë"big5"£¬¼òÌåÖÐÎÄÊ±ÊäÈë"gb2312"
 715                 CStringArray *pStrAryAttach/*=NULL*/,
 716                 LPCTSTR pStrAryCC/*=NULL*/,
 717                 UINT nSmtpSrvPort,/*=25*/
 718                 LPCTSTR pSender,
 719                 LPCTSTR pToList,
 720                 DWORD secLevel
 721                 )
 722 {
 723         TRACE ( _T("·¢ËÍÓÊ¼þ£º%s,  %s\n"), lpszAddrTo, lpszBody );
 724         m_StrAryAttach.RemoveAll();
 725
 726         m_StrCC += GET_SAFE_STRING(pStrAryCC);
 727
 728         m_csSmtpSrvHost = GET_SAFE_STRING ( lpszSmtpSrvHost );
 729         if ( m_csSmtpSrvHost.GetLength() <= 0 )
 730         {
 731                 m_csLastError.Format ( _T("Parameter Error!") );
 732                 return FALSE;
 733         }
 734         m_csUserName = GET_SAFE_STRING ( lpszUserName );
 735         m_csPasswd = GET_SAFE_STRING ( lpszPasswd );
 736         m_bMustAuth = bMustAuth;
 737         if ( m_bMustAuth && m_csUserName.GetLength() <= 0 )
 738         {
 739                 m_csLastError.Format ( _T("Parameter Error!") );
 740                 return FALSE;
 741         }
 742
 743         m_csAddrFrom = GET_SAFE_STRING ( lpszAddrFrom );
 744         m_csAddrTo = GET_SAFE_STRING ( lpszAddrTo );
 745 //      m_csFromName = GET_SAFE_STRING ( lpszFromName );
 746 //      m_csReceiverName = GET_SAFE_STRING ( lpszReceiverName );
 747         m_csSubject = GET_SAFE_STRING ( lpszSubject );
 748         m_csBody = GET_SAFE_STRING ( lpszBody );
 749
 750         this->m_csSender = GET_SAFE_STRING(pSender);
 751         this->m_csToList = GET_SAFE_STRING(pToList);
 752
 753         m_nSmtpSrvPort = nSmtpSrvPort;
 754
 755         if ( lpszCharSet && lstrlen(lpszCharSet) > 0 )
 756                 m_csCharSet.Format ( _T("\r\n\tcharset=\"%s\"\r\n"), lpszCharSet );
 757
 758         if      (
 759                         m_csAddrFrom.GetLength() <= 0 || m_csAddrTo.GetLength() <= 0
 760                 )
 761         {
 762                 m_csLastError.Format ( _T("Parameter Error!") );
 763                 return FALSE;
 764         }
 765
 766         if ( pStrAryAttach )
 767         {
 768                 m_StrAryAttach.Append ( *pStrAryAttach );
 769         }
 770         if ( m_StrAryAttach.GetSize() < 1 )
 771                 m_csMIMEContentType = FormatString ( _T( "text/plain; %s" ), m_csCharSet);
 772
 773         // ´´½¨Socket
 774         m_SendSock.Close();
 775         if ( !m_SendSock.Create () )
 776         {
 777                 //int nResult = GetLastError();
 778                 m_csLastError.Format ( _T("Create socket failed!") );
 779                 return FALSE;
 780         }
 781
 782         switch (secLevel)
 783         {
 784         case 1:
 785                 m_iSecurityLevel = want_tls;
 786                 break;
 787         case 2:
 788                 m_iSecurityLevel = ssl;
 789                 break;
 790         default:
 791                 m_iSecurityLevel = none;
 792         }
 793
 794         // Á¬½Óµ½·þÎñÆ÷
 795         if ( !m_SendSock.Connect ( m_csSmtpSrvHost, m_nSmtpSrvPort ) )
 796         {
 797                 m_csLastError.Format ( _T("Connect to [ %s ] failed"), m_csSmtpSrvHost );
 798                 TRACE ( _T("%d\n"), GetLastError() );
 799                 return FALSE;
 800         }
 801
 802         if (m_iSecurityLevel == want_tls) {
 803                 if (!GetResponse(_T("220")))
 804                         return FALSE;
 805                 m_bConnected = TRUE;
 806                 Send(L"STARTTLS\n");
 807                 if (!GetResponse(_T("220")))
 808                         return FALSE;
 809                 m_iSecurityLevel = tls_established;
 810         }
 811
 812         BOOL ret = FALSE;
 813
 814         SecBuffer ExtraData;
 815         SECURITY_STATUS Status;
 816
 817         CtxtHandle contextStruct;
 818         CredHandle credentialsStruct;
 819
 820         if (m_iSecurityLevel >= ssl)
 821         {
 822                 g_pSSPI = InitSecurityInterface();
 823
 824                 contextStruct.dwLower = 0;
 825                 contextStruct.dwUpper = 0;
 826
 827                 hCreds = &credentialsStruct;
 828                 credentialsStruct.dwLower = 0;
 829                 credentialsStruct.dwUpper = 0;
 830                 Status = CreateCredentials(hCreds);
 831                 if (Status != SEC_E_OK)
 832                 {
 833                         m_csLastError = CFormatMessageWrapper(Status);
 834                         return FALSE;
 835                 }
 836
 837                 hContext = &contextStruct;
 838                 Status = PerformClientHandshake(&m_SendSock, hCreds, m_csSmtpSrvHost.GetBuffer(), hContext, &ExtraData);
 839                 if (Status != SEC_E_OK)
 840                 {
 841                         m_csLastError = CFormatMessageWrapper(Status);
 842                         return FALSE;
 843                 }
 844
 845                 PCCERT_CONTEXT pRemoteCertContext = nullptr;
 846                 // Authenticate server's credentials. Get server's certificate.
 847                 Status = g_pSSPI->QueryContextAttributes(hContext, SECPKG_ATTR_REMOTE_CERT_CONTEXT, (PVOID)&pRemoteCertContext);
 848                 if (Status)
 849                 {
 850                         m_csLastError = CFormatMessageWrapper(Status);
 851                         goto cleanup;
 852                 }
 853
 854                 git_cert_x509 cert;
 855                 cert.cert_type = GIT_CERT_X509;
 856                 cert.data = pRemoteCertContext->pbCertEncoded;
 857                 cert.len = pRemoteCertContext->cbCertEncoded;
 858                 if (CAppUtils::Git2CertificateCheck((git_cert*)&cert, 0, CUnicodeUtils::GetUTF8(m_csSmtpSrvHost), nullptr))
 859                 {
 860                         CertFreeCertificateContext(pRemoteCertContext);
 861                         m_csLastError = _T("Invalid certificate.");
 862                         goto cleanup;
 863                 }
 864
 865                 CertFreeCertificateContext(pRemoteCertContext);
 866
 867                 Status = g_pSSPI->QueryContextAttributes(hContext, SECPKG_ATTR_STREAM_SIZES, &Sizes);
 868                 if (Status)
 869                 {
 870                         m_csLastError = CFormatMessageWrapper(Status);
 871                         goto cleanup;
 872                 }
 873
 874                 // Create a buffer.
 875                 cbIoBufferLength = Sizes.cbHeader + Sizes.cbMaximumMessage + Sizes.cbTrailer;
 876                 pbIoBuffer = (PBYTE)LocalAlloc(LMEM_FIXED, cbIoBufferLength);
 877                 SecureZeroMemory(pbIoBuffer, cbIoBufferLength);
 878                 if (pbIoBuffer == nullptr)
 879                 {
 880                         m_csLastError = _T("Could not allocate memory");
 881                         goto cleanup;
 882                 }
 883         }
 884
 885         if (m_iSecurityLevel <= ssl)
 886         {
 887                 if (!GetResponse(_T("220")))
 888                         goto cleanup;
 889                 m_bConnected = TRUE;
 890         }
 891
 892         ret = SendEmail();
 893
 894 cleanup:
 895         if (m_iSecurityLevel >= ssl)
 896         {
 897                 if (hContext && hCreds)
 898                         DisconnectFromServer(&m_SendSock, hCreds, hContext);
 899                 if (pbIoBuffer)
 900                 {
 901                         LocalFree(pbIoBuffer);
 902                         pbIoBuffer = nullptr;
 903                         cbIoBufferLength = 0;
 904                 }
 905                 if (hContext)
 906                 {
 907                         g_pSSPI->DeleteSecurityContext(hContext);
 908                         hContext = nullptr;
 909                 }
 910                 if (hCreds)
 911                 {
 912                         g_pSSPI->FreeCredentialsHandle(hCreds);
 913                         hCreds = nullptr;
 914                 }
 915                 g_pSSPI = nullptr;
 916         }
 917         else
 918                 m_SendSock.Close();
 919
 920         return ret;
 921 }
 922
 923 BOOL CHwSMTP::GetResponse ( LPCTSTR lpszVerifyCode, int *pnCode/*=NULL*/)
 924 {
 925         if ( !lpszVerifyCode || lstrlen(lpszVerifyCode) < 1 )
 926                 return FALSE;
 927
 928         SECURITY_STATUS scRet = SEC_E_OK;
 929
 930         char szRecvBuf[1024] = {0};
 931         int nRet = 0;
 932         char szStatusCode[4] = {0};
 933
 934         if (m_iSecurityLevel >= ssl)
 935         {
 936                 scRet = ReadDecrypt(&m_SendSock, hCreds, hContext, pbIoBuffer, cbIoBufferLength);
 937                 SecureZeroMemory(szRecvBuf, 1024);
 938                 memcpy(szRecvBuf, pbIoBuffer+Sizes.cbHeader, 1024);
 939         }
 940         else
 941                 nRet = m_SendSock.Receive(szRecvBuf, sizeof(szRecvBuf));
 942         TRACE ( _T("Received : %s\r\n"), szRecvBuf );
 943         if (nRet == 0 && m_iSecurityLevel == none || m_iSecurityLevel >= ssl && scRet != SEC_E_OK)
 944         {
 945                 m_csLastError.Format ( _T("Receive TCP data failed") );
 946                 return FALSE;
 947         }
 948 //      TRACE ( _T("ÊÕµ½·þÎñÆ÷»ØÓ¦£º%s\n"), szRecvBuf );
 949
 950         memcpy ( szStatusCode, szRecvBuf, 3 );
 951         if ( pnCode ) (*pnCode) = atoi ( szStatusCode );
 952
 953         if ( strcmp ( szStatusCode, CMultiByteString(lpszVerifyCode).GetBuffer() ) != 0 )
 954         {
 955                 m_csLastError.Format ( _T("Received invalid response  : %s"), GetCompatibleString(szRecvBuf,FALSE) );
 956                 return FALSE;
 957         }
 958
 959         return TRUE;
 960 }
 961 BOOL CHwSMTP::SendBuffer(char *buff,int size)
 962 {
 963         if(size<0)
 964                 size=(int)strlen(buff);
 965         if ( !m_bConnected )
 966         {
 967                 m_csLastError.Format ( _T("Didn't connect") );
 968                 return FALSE;
 969         }
 970
 971         if (m_iSecurityLevel >= ssl)
 972         {
 973                 int sent = 0;
 974                 while (size - sent > 0)
 975                 {
 976                         int toSend = min(size - sent, (int)Sizes.cbMaximumMessage);
 977                         SecureZeroMemory(pbIoBuffer + Sizes.cbHeader, Sizes.cbMaximumMessage);
 978                         memcpy(pbIoBuffer + Sizes.cbHeader, buff + sent, toSend);
 979                         DWORD cbData = EncryptSend(&m_SendSock, hContext, pbIoBuffer, Sizes);
 980                         if (cbData == SOCKET_ERROR || cbData == 0)
 981                                 return FALSE;
 982                         sent += toSend;
 983                 }
 984         }
 985         else if (m_SendSock.Send ( buff, size ) != size)
 986         {
 987                 m_csLastError.Format ( _T("Socket send data failed") );
 988                 return FALSE;
 989         }
 990
 991         return TRUE;
 992 }
 993 // ÀûÓÃsocket·¢ËÍÊý¾Ý£¬Êý¾Ý³¤¶È²»ÄÜ³¬¹ý10M
 994 BOOL CHwSMTP::Send(const CString &str )
 995 {
 996         CMultiByteString cbsData ( str );
 997
 998         TRACE ( _T("Send : %s\r\n"), cbsData.GetBuffer() );
 999         return SendBuffer(cbsData.GetBuffer(), cbsData.GetLength());
1000 }
1001
1002 BOOL CHwSMTP::SendEmail()
1003 {
1004         BOOL bRet = TRUE;
1005         char szLocalHostName[64] = {0};
1006         gethostname ( (char*)szLocalHostName, sizeof(szLocalHostName) );
1007
1008         // make sure helo hostname can be interpreted as a FQDN
1009         CString hostname(GetCompatibleString(szLocalHostName, FALSE));
1010         if (hostname.Find(_T(".")) == -1)
1011                 hostname += _T(".local");
1012
1013         // hello£¬ÎÕÊÖ
1014         CString str;
1015         str.Format(_T("HELO %s\r\n"), hostname);
1016         if ( !Send (  str ))
1017         {
1018                 return FALSE;
1019         }
1020         if ( !GetResponse ( _T("250") ) )
1021         {
1022                 return FALSE;
1023         }
1024         // Éí·ÝÑéÖ¤
1025         if ( m_bMustAuth && !auth() )
1026         {
1027                 return FALSE;
1028         }
1029         // ·¢ËÍÓÊ¼þÍ·
1030         if ( !SendHead() )
1031         {
1032                 return FALSE;
1033         }
1034         // ·¢ËÍÓÊ¼þÖ÷Ìâ
1035         if (!SendSubject(hostname))
1036         {
1037                 return FALSE;
1038         }
1039         // ·¢ËÍÓÊ¼þÕýÎÄ
1040         if ( !SendBody() )
1041         {
1042                 return FALSE;
1043         }
1044         // ·¢ËÍ¸½¼þ
1045         if ( !SendAttach() )
1046         {
1047                 return FALSE;
1048         }
1049         // ½áÊøÓÊ¼þÕýÎÄ
1050         if ( !Send ( CString(_T(".\r\n") ) ) ) return FALSE;
1051         if ( !GetResponse ( _T("250") ) )
1052                 return FALSE;
1053
1054         // ÍË³ö·¢ËÍ
1055         if ( HANDLE_IS_VALID(m_SendSock.m_hSocket) )
1056                 Send ( CString(_T("QUIT\r\n")) );
1057         m_bConnected = FALSE;
1058
1059         return bRet;
1060 }
1061
1062 static CStringA EncodeBase64(const char * source, int len)
1063 {
1064         int neededLength = Base64EncodeGetRequiredLength(len);
1065         CStringA output;
1066         if (!Base64Encode((BYTE *)source, len, output.GetBufferSetLength(neededLength), &neededLength))
1067         {
1068                 output.ReleaseBuffer(0);
1069                 return output;
1070         }
1071         output.ReleaseBuffer(neededLength);
1072         return output;
1073 }
1074
1075 BOOL CHwSMTP::auth()
1076 {
1077         int nResponseCode = 0;
1078         if ( !Send ( CString(_T("auth login\r\n")) ) ) return FALSE;
1079         if ( !GetResponse ( _T("334"), &nResponseCode ) ) return FALSE;
1080         if ( nResponseCode != 334 )     // ²»ÐèÒªÑéÖ¤ÓÃ»§ÃûºÍÃÜÂë
1081                 return TRUE;
1082
1083         CMultiByteString cbsUserName ( m_csUserName ), cbsPasswd ( m_csPasswd );
1084         CString csBase64_UserName = GetCompatibleString(EncodeBase64(cbsUserName.GetBuffer(), cbsUserName.GetLength()).GetBuffer(0), FALSE);
1085         CString csBase64_Passwd = GetCompatibleString(EncodeBase64(cbsPasswd.GetBuffer(), cbsPasswd.GetLength()).GetBuffer(0), FALSE);
1086
1087         CString str;
1088         str.Format( _T("%s\r\n"), csBase64_UserName );
1089         if ( !Send ( str ) )
1090                 return FALSE;
1091
1092         if ( !GetResponse ( _T("334") ) )
1093         {
1094                 m_csLastError.Format ( _T("Authentication UserName failed") );
1095                 return FALSE;
1096         }
1097
1098         str.Format(_T("%s\r\n"), csBase64_Passwd );
1099         if ( !Send ( str ) )
1100                 return FALSE;
1101
1102         if ( !GetResponse ( _T("235") ) )
1103         {
1104                 m_csLastError.Format ( _T("Authentication Password failed") );
1105                 return FALSE;
1106         }
1107
1108         return TRUE;
1109 }
1110
1111 BOOL CHwSMTP::SendHead()
1112 {
1113         CString str;
1114         CString name,addr;
1115         GetNameAddress(m_csAddrFrom,name,addr);
1116
1117         str.Format( _T("MAIL From: <%s>\r\n"), addr );
1118         if ( !Send ( str  ) ) return FALSE;
1119
1120         if ( !GetResponse ( _T("250") ) ) return FALSE;
1121
1122         int start=0;
1123         while(start>=0)
1124         {
1125                 CString one=m_csAddrTo.Tokenize(_T(";"),start);
1126                 one=one.Trim();
1127                 if(one.IsEmpty())
1128                         continue;
1129
1130
1131                 GetNameAddress(one,name,addr);
1132
1133                 str.Format(_T("RCPT TO: <%s>\r\n"), addr );
1134                 if ( !Send ( str ) ) return FALSE;
1135                 if ( !GetResponse ( _T("250") ) ) return FALSE;
1136         }
1137
1138         if ( !Send ( CString(_T("DATA\r\n") ) ) ) return FALSE;
1139         if ( !GetResponse ( CString(_T("354") )) ) return FALSE;
1140
1141         return TRUE;
1142 }
1143
1144 BOOL CHwSMTP::SendSubject(const CString &hostname)
1145 {
1146         CString csSubject;
1147         csSubject += _T("Date: ");
1148         COleDateTime tNow = COleDateTime::GetCurrentTime();
1149         if ( tNow > 1 )
1150         {
1151                 csSubject += FormatDateTime (tNow, _T("%a, %d %b %y %H:%M:%S %Z"));
1152         }
1153         csSubject += _T("\r\n");
1154         csSubject += FormatString ( _T("From: %s\r\n"), this->m_csAddrFrom);
1155
1156         if (!m_StrCC.IsEmpty())
1157                 csSubject += FormatString ( _T("CC: %s\r\n"), this->m_StrCC);
1158
1159         if(m_csSender.IsEmpty())
1160                 m_csSender =  this->m_csAddrFrom;
1161
1162         csSubject += FormatString ( _T("Sender: %s\r\n"), this->m_csSender);
1163
1164         if(this->m_csToList.IsEmpty())
1165                 m_csToList = m_csReceiverName;
1166
1167         csSubject += FormatString ( _T("To: %s\r\n"), this->m_csToList);
1168
1169         CString m_csToList;
1170
1171         csSubject += FormatString ( _T("Subject: %s\r\n"), m_csSubject );
1172
1173         CString m_ListID;
1174         GUID guid;
1175         HRESULT hr = CoCreateGuid(&guid);
1176         if (hr == S_OK)
1177         {
1178                 RPC_WSTR guidStr;
1179                 if (UuidToString(&guid, &guidStr) == RPC_S_OK)
1180                 {
1181                         m_ListID = (LPTSTR)guidStr;
1182                         RpcStringFree(&guidStr);
1183                 }
1184         }
1185         if (m_ListID.IsEmpty())
1186         {
1187                 m_csLastError = _T("Could not generate Message-ID");
1188                 return FALSE;
1189         }
1190         csSubject += FormatString( _T("Message-ID: <%s@%s>\r\n"), m_ListID, hostname);
1191
1192         csSubject += FormatString ( _T("X-Mailer: TortoiseGit\r\nMIME-Version: 1.0\r\nContent-Type: %s\r\n\r\n"),
1193                 m_csMIMEContentType );
1194
1195         return Send ( csSubject );
1196 }
1197
1198 BOOL CHwSMTP::SendBody()
1199 {
1200         CString csBody, csTemp;
1201
1202         if ( m_StrAryAttach.GetSize() > 0 )
1203         {
1204                 csTemp.Format ( _T("%s\r\n\r\n"), m_csNoMIMEText );
1205                 csBody += csTemp;
1206
1207                 csTemp.Format ( _T("--%s\r\n"), m_csPartBoundary );
1208                 csBody += csTemp;
1209
1210                 csTemp.Format ( _T("Content-Type: text/plain\r\n%sContent-Transfer-Encoding: UTF-8\r\n\r\n"),
1211                         m_csCharSet );
1212                 csBody += csTemp;
1213         }
1214
1215         //csTemp.Format ( _T("%s\r\n"), m_csBody );
1216         csBody += m_csBody;
1217         csBody += _T("\r\n");
1218
1219         return Send ( csBody );
1220 }
1221
1222 BOOL CHwSMTP::SendAttach()
1223 {
1224         int nCountAttach = (int)m_StrAryAttach.GetSize();
1225         if ( nCountAttach < 1 ) return TRUE;
1226
1227         for ( int i=0; i<nCountAttach; i++ )
1228         {
1229                 if ( !SendOnAttach ( m_StrAryAttach.GetAt(i) ) )
1230                         return FALSE;
1231         }
1232
1233         Send(L"--" + m_csPartBoundary + L"--\r\n");
1234
1235         return TRUE;
1236 }
1237
1238 BOOL CHwSMTP::SendOnAttach(LPCTSTR lpszFileName)
1239 {
1240         ASSERT ( lpszFileName );
1241         CString csAttach, csTemp;
1242
1243         csTemp = lpszFileName;
1244         CString csShortFileName = csTemp.GetBuffer(0) + csTemp.ReverseFind ( '\\' );
1245         csShortFileName.TrimLeft ( _T("\\") );
1246
1247         csTemp.Format ( _T("--%s\r\n"), m_csPartBoundary );
1248         csAttach += csTemp;
1249
1250         csTemp.Format ( _T("Content-Type: application/octet-stream; file=%s\r\n"), csShortFileName );
1251         csAttach += csTemp;
1252
1253         csTemp.Format ( _T("Content-Transfer-Encoding: base64\r\n") );
1254         csAttach += csTemp;
1255
1256         csTemp.Format ( _T("Content-Disposition: attachment; filename=%s\r\n\r\n"), csShortFileName );
1257         csAttach += csTemp;
1258
1259         DWORD dwFileSize =  hwGetFileAttr(lpszFileName);
1260         if ( dwFileSize > 5*1024*1024 )
1261         {
1262                 m_csLastError.Format ( _T("File [%s] too big. File size is : %s"), lpszFileName, FormatBytes(dwFileSize) );
1263                 return FALSE;
1264         }
1265         char *pBuf = new char[dwFileSize+1];
1266         if ( !pBuf )
1267         {
1268                 ::AfxThrowMemoryException ();
1269                 return FALSE;
1270         }
1271
1272         if(!Send ( csAttach ))
1273         {
1274                 delete[] pBuf;
1275                 return FALSE;
1276         }
1277
1278         CFile file;
1279         CStringA filedata;
1280         try
1281         {
1282                 if ( !file.Open ( lpszFileName, CFile::modeRead ) )
1283                 {
1284                         m_csLastError.Format ( _T("Open file [%s] failed"), lpszFileName );
1285                         delete[] pBuf;
1286                         return FALSE;
1287                 }
1288                 UINT nFileLen = file.Read ( pBuf, dwFileSize );
1289                 filedata = EncodeBase64(pBuf, nFileLen);
1290                 filedata += _T("\r\n\r\n");
1291         }
1292         catch (CFileException *e)
1293         {
1294                 e->Delete();
1295                 m_csLastError.Format ( _T("Read file [%s] failed"), lpszFileName );
1296                 delete[] pBuf;
1297                 return FALSE;
1298         }
1299
1300         if(!SendBuffer( filedata.GetBuffer() ))
1301         {
1302                 delete[] pBuf;
1303                 return FALSE;
1304         }
1305
1306         delete[] pBuf;
1307
1308         return TRUE;
1309         //return Send ( csAttach );
1310 }
1311
1312 CString CHwSMTP::GetLastErrorText()
1313 {
1314         return m_csLastError;
1315 }
1316
1317 //
1318 // ½«×Ö·û´® lpszOrg ×ª»»Îª¶à×Ö½ÚµÄ×Ö·û´®£¬Èç¹û»¹ÒªÊ¹ÓÃ¶à×Ö·û´®µÄ³¤¶È£¬¿ÉÒÔÓÃÒÔÏÂ·½Ê½À´Ê¹ÓÃÕâ¸öÀà£º
1319 // CMultiByteString MultiByteString(_T("UNICODE×Ö·û´®"));
1320 // printf ( "ANSI ×Ö·û´®Îª£º %s£¬ ×Ö·û¸öÊýÎª£º %d £¬ ³¤¶ÈÎª£º %d×Ö½Ú\n", MultiByteString.GetBuffer(), MultiByteString.GetLength(), MultiByteString.GetSize() );
1321 //
1322 CMultiByteString::CMultiByteString( LPCTSTR lpszOrg, int nOrgStringEncodeType/*=STRING_IS_SOFTCODE*/, OUT char *pOutBuf/*=NULL*/, int nOutBufSize/*=0*/ )
1323 {
1324         m_bNewBuffer = FALSE;
1325         m_pszData = NULL;
1326         m_nDataSize = 0;
1327         m_nCharactersNumber = 0;
1328         if ( !lpszOrg ) return;
1329
1330         BOOL bOrgIsUnicode = FALSE;
1331         if ( nOrgStringEncodeType == STRING_IS_MULTICHARS ) bOrgIsUnicode = FALSE;
1332         else if ( nOrgStringEncodeType == STRING_IS_UNICODE ) bOrgIsUnicode = TRUE;
1333         else
1334         {
1335 #ifdef UNICODE
1336                 bOrgIsUnicode = TRUE;
1337 #else
1338                 bOrgIsUnicode = FALSE;
1339 #endif
1340         }
1341
1342         if ( bOrgIsUnicode )
1343         {
1344                 m_nCharactersNumber = (int)wcslen((WCHAR*)lpszOrg);
1345                 m_nDataSize = (m_nCharactersNumber + 1) * sizeof(WCHAR);
1346         }
1347         else
1348         {
1349                 m_nCharactersNumber = (int)strlen((char*)lpszOrg);
1350                 m_nDataSize = (m_nCharactersNumber + 1) * sizeof(char);
1351         }
1352
1353         if ( pOutBuf && nOutBufSize > 0 )
1354         {
1355                 m_pszData = pOutBuf;
1356                 m_nDataSize = nOutBufSize;
1357         }
1358         else
1359         {
1360                 m_pszData = (char*)new BYTE[m_nDataSize];
1361                 if ( !m_pszData )
1362                 {
1363                         ::AfxThrowMemoryException ();
1364                         return;
1365                 }
1366                 m_bNewBuffer = TRUE;
1367         }
1368         memset ( m_pszData, 0, m_nDataSize );
1369
1370         if ( bOrgIsUnicode )
1371         {
1372                 m_nCharactersNumber = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)lpszOrg, m_nCharactersNumber, (LPSTR)m_pszData, m_nDataSize / sizeof(char) - 1, NULL, NULL);
1373                 if ( m_nCharactersNumber < 1 ) m_nCharactersNumber = (int)strlen ( m_pszData );
1374         }
1375         else
1376         {
1377                 m_nCharactersNumber = __min ( m_nCharactersNumber, (int)(m_nDataSize/sizeof(char)-1) );
1378                 strncpy_s(m_pszData, m_nCharactersNumber, (const char*)lpszOrg, m_nCharactersNumber);
1379                 m_nCharactersNumber = (int)strlen ( m_pszData );
1380         }
1381         m_nDataSize = ( m_nCharactersNumber + 1 ) * sizeof(char);
1382 }
1383
1384 CMultiByteString::~CMultiByteString ()
1385 {
1386         if ( m_bNewBuffer && m_pszData )
1387         {
1388                 delete[] m_pszData;
1389         }
1390 }
1391
1392 CString GetCompatibleString ( LPVOID lpszOrg, BOOL bOrgIsUnicode, int nOrgLength/*=-1*/ )
1393 {
1394         if ( !lpszOrg ) return _T("");
1395
1396         TRY
1397         {
1398 #ifdef UNICODE
1399                 if ( bOrgIsUnicode )
1400                 {
1401                         if ( nOrgLength > 0 )
1402                         {
1403                                 WCHAR *szRet = new WCHAR[nOrgLength+1];
1404                                 if ( !szRet ) return _T("");
1405                                 memset ( szRet, 0, (nOrgLength+1)*sizeof(WCHAR) );
1406                                 memcpy ( szRet, lpszOrg, nOrgLength*sizeof(WCHAR) );
1407                                 CString csRet = szRet;
1408                                 delete[] szRet;
1409                                 return csRet;
1410                         }
1411                         else if ( nOrgLength == 0 )
1412                                 return _T("");
1413                         else
1414                                 return (LPCTSTR)lpszOrg;
1415                 }
1416
1417                 if ( nOrgLength < 0 )
1418                         nOrgLength = (int)strlen((const char*)lpszOrg);
1419                 int nWideCount = nOrgLength + 1;
1420                 WCHAR *wchar = new WCHAR[nWideCount];
1421                 if ( !wchar ) return _T("");
1422                 memset ( wchar, 0, nWideCount*sizeof(WCHAR) );
1423                 ::MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)lpszOrg, nOrgLength, wchar, nWideCount);
1424                 CString csRet = wchar;
1425                 delete[] wchar;
1426                 return csRet;
1427 #else
1428                 if ( !bOrgIsUnicode )
1429                 {
1430                         if ( nOrgLength > 0 )
1431                         {
1432                                 char *szRet = new char[nOrgLength+1];
1433                                 if ( !szRet ) return _T("");
1434                                 memset ( szRet, 0, (nOrgLength+1)*sizeof(char) );
1435                                 memcpy ( szRet, lpszOrg, nOrgLength*sizeof(char) );
1436                                 CString csRet = szRet;
1437                                 delete[] szRet;
1438                                 return csRet;
1439                         }
1440                         else if ( nOrgLength == 0 )
1441                                 return _T("");
1442                         else
1443                                 return (LPCTSTR)lpszOrg;
1444                 }
1445
1446                 if ( nOrgLength < 0 )
1447                         nOrgLength = (int)wcslen((WCHAR*)lpszOrg);
1448                 int nMultiByteCount = nOrgLength + 1;
1449                 char *szMultiByte = new char[nMultiByteCount];
1450                 if ( !szMultiByte ) return _T("");
1451                 memset ( szMultiByte, 0, nMultiByteCount*sizeof(char) );
1452                 ::WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)lpszOrg, nOrgLength, (LPSTR)szMultiByte, nMultiByteCount, NULL, NULL);
1453                 CString csRet = szMultiByte;
1454                 delete[] szMultiByte;
1455                 return csRet;
1456 #endif
1457         }
1458         CATCH_ALL(e)
1459         {
1460                 THROW_LAST ();
1461         }
1462         END_CATCH_ALL
1463
1464         return _T("");
1465 }
1466
1467 CString FormatDateTime (COleDateTime &DateTime, LPCTSTR /*pFormat*/)
1468 {
1469         // If null, return empty string
1470         if ( DateTime.GetStatus() == COleDateTime::null || DateTime.GetStatus() == COleDateTime::invalid )
1471                 return _T("");
1472
1473         UDATE ud;
1474         if (S_OK != VarUdateFromDate(DateTime.m_dt, 0, &ud))
1475         {
1476                 return _T("");
1477         }
1478
1479         TCHAR *weeks[]={_T("Sun"),_T("Mon"),_T("Tue"),_T("Wen"),_T("Thu"),_T("Fri"),_T("Sat")};
1480         TCHAR *month[]={_T("Jan"),_T("Feb"),_T("Mar"),_T("Apr"),
1481                                         _T("May"),_T("Jun"),_T("Jul"),_T("Aug"),
1482                                         _T("Sep"),_T("Oct"),_T("Nov"),_T("Dec")};
1483
1484         TIME_ZONE_INFORMATION stTimeZone;
1485         GetTimeZoneInformation(&stTimeZone);
1486
1487         CString strDate;
1488         strDate.Format(_T("%s, %d %s %d %02d:%02d:%02d %c%04d")
1489                 ,weeks[ud.st.wDayOfWeek],
1490                 ud.st.wDay,month[ud.st.wMonth-1],ud.st.wYear,ud.st.wHour,
1491                 ud.st.wMinute,ud.st.wSecond,
1492                 stTimeZone.Bias>0?_T('-'):_T('+'),
1493                 abs(stTimeZone.Bias*10/6)
1494                 );
1495         return strDate;
1496 }
1497
1498 CString FormatString ( LPCTSTR lpszStr, ... )
1499 {
1500         TCHAR *buf = NULL;
1501         for ( int nBufCount = 1024; nBufCount<5*1024*1024; nBufCount += 1024 )
1502         {
1503                 buf = new TCHAR[nBufCount];
1504                 if ( !buf )
1505                 {
1506                         ::AfxThrowMemoryException ();
1507                         return _T("");
1508                 }
1509                 memset ( buf, 0, nBufCount*sizeof(TCHAR) );
1510
1511                 va_list  va;
1512                 va_start (va, lpszStr);
1513                 int nLen = _vsnprintf_hw((TCHAR*)buf, nBufCount, _TRUNCATE, lpszStr, va);
1514                 va_end(va);
1515                 if ( nLen <= (int)(nBufCount-sizeof(TCHAR)) )
1516                         break;
1517                 delete[] buf; buf = NULL;
1518         }
1519         if ( !buf )
1520         {
1521                 return _T("");
1522         }
1523
1524         CString csMsg = buf;
1525         delete[] buf; buf = NULL;
1526         return csMsg;
1527 }
1528
1529 int hwGetFileAttr ( LPCTSTR lpFileName, OUT CFileStatus *pFileStatus/*=NULL*/ )
1530 {
1531         if ( !lpFileName || lstrlen(lpFileName) < 1 ) return -1;
1532
1533         CFileStatus fileStatus;
1534         fileStatus.m_attribute = 0;
1535         fileStatus.m_size = 0;
1536         memset ( fileStatus.m_szFullName, 0, sizeof(fileStatus.m_szFullName) );
1537         BOOL bRet = FALSE;
1538         TRY
1539         {
1540                 if ( CFile::GetStatus(lpFileName,fileStatus) )
1541                 {
1542                         bRet = TRUE;
1543                 }
1544         }
1545         CATCH (CFileException, e)
1546         {
1547                 ASSERT ( FALSE );
1548                 bRet = FALSE;
1549         }
1550         CATCH_ALL(e)
1551         {
1552                 ASSERT ( FALSE );
1553                 bRet = FALSE;
1554         }
1555         END_CATCH_ALL;
1556
1557         if ( pFileStatus )
1558         {
1559                 pFileStatus->m_ctime = fileStatus.m_ctime;
1560                 pFileStatus->m_mtime = fileStatus.m_mtime;
1561                 pFileStatus->m_atime = fileStatus.m_atime;
1562                 pFileStatus->m_size = fileStatus.m_size;
1563                 pFileStatus->m_attribute = fileStatus.m_attribute;
1564                 lstrcpy ( pFileStatus->m_szFullName, fileStatus.m_szFullName );
1565
1566         }
1567
1568         return (int)fileStatus.m_size;
1569 }
1570
1571 CString FormatBytes ( double fBytesNum, BOOL bShowUnit/*=TRUE*/, int nFlag/*=0*/ )
1572 {
1573         CString csRes;
1574         if ( nFlag == 0 )
1575         {
1576                 if ( fBytesNum >= 1024.0 && fBytesNum < 1024.0*1024.0 )
1577                         csRes.Format ( _T("%.2f%s"), fBytesNum / 1024.0, bShowUnit?_T(" K"):_T("") );
1578                 else if ( fBytesNum >= 1024.0*1024.0 && fBytesNum < 1024.0*1024.0*1024.0 )
1579                         csRes.Format ( _T("%.2f%s"), fBytesNum / (1024.0*1024.0), bShowUnit?_T(" M"):_T("") );
1580                 else if ( fBytesNum >= 1024.0*1024.0*1024.0 )
1581                         csRes.Format ( _T("%.2f%s"), fBytesNum / (1024.0*1024.0*1024.0), bShowUnit?_T(" G"):_T("") );
1582                 else
1583                         csRes.Format ( _T("%.2f%s"), fBytesNum, bShowUnit?_T(" B"):_T("") );
1584         }
1585         else if ( nFlag == 1 )
1586         {
1587                 csRes.Format ( _T("%.2f%s"), fBytesNum / 1024.0, bShowUnit?_T(" K"):_T("") );
1588         }
1589         else if ( nFlag == 2 )
1590         {
1591                 csRes.Format ( _T("%.2f%s"), fBytesNum / (1024.0*1024.0), bShowUnit?_T(" M"):_T("") );
1592         }
1593         else if ( nFlag == 3 )
1594         {
1595                 csRes.Format ( _T("%.2f%s"), fBytesNum / (1024.0*1024.0*1024.0), bShowUnit?_T(" G"):_T("") );
1596         }
1597
1598         return csRes;
1599 }