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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
Smtp.cpp
资源名称：MiniCA2.rar　[点击查看]
上传用户：dengkfang
上传日期：2008-12-30
资源大小：5233k
文件大小：27k
源码类别：

CA认证

开发平台：

Visual C++

Smtp.cpp：源码内容
  1. // CSmtp.cpp: implementation of the CSmtp class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "smtp.h"
  8. #ifdef _DEBUG
  9. #undef THIS_FILE
  10. static char THIS_FILE[]=__FILE__;
  11. #define new DEBUG_NEW
  12. #endif
  14. //////////////////////////////////////////////////////////////////////
  15. // CMailMessage
  16. // Formats a message compliant with RFC 822.
  18. //////////////////////////////////////////////////////////////////////
  19. // Construction/Destruction
  20. //////////////////////////////////////////////////////////////////////
  22. CMailMessage::CMailMessage()
  23. {
  24. m_sMailerName = "MiniCA Reg";
  25. SetCharsPerLine(76);
  26. }
  28. CMailMessage::~CMailMessage()
  29. {
  30. }
  32. BOOL CMailMessage::AddRecipient(LPCTSTR szEmailAddress, LPCTSTR szFriendlyName)
  33. {
  34. ASSERT(szEmailAddress != NULL);
  35. ASSERT(szFriendlyName != NULL);
  36. CRecipient to;
  37. to.m_sEmailAddress = szEmailAddress;
  38. to.m_sFriendlyName = szFriendlyName;
  39. m_Recipients.Add(to);
  40. return TRUE;
  41. }
  43. // sEmailAddress and sFriendlyName are OUTPUT parameters.
  44. // If the function fails, it will return FALSE, and the OUTPUT
  45. // parameters will not be touched.
  46. BOOL CMailMessage::GetRecipient(CString & sEmailAddress, CString & sFriendlyName, int nIndex)
  47. {
  48. CRecipient to;
  49. if(nIndex < 0 || nIndex > m_Recipients.GetUpperBound())
  50. return FALSE;
  51. to = m_Recipients[nIndex];
  52. sEmailAddress = to.m_sEmailAddress;
  53. sFriendlyName = to.m_sFriendlyName;
  54. return TRUE;
  55. }
  57. int CMailMessage::GetNumRecipients()
  58. { return m_Recipients.GetSize(); }
  60. BOOL CMailMessage::AddMultipleRecipients(LPCTSTR szRecipients)
  61. {
  62. TCHAR* buf;
  63. UINT pos;
  64. UINT start;
  65. CString sTemp;
  66. CString sEmail;
  67. CString sFriendly;
  68. UINT length;
  69. int nMark;
  70. int nMark2;
  72. ASSERT(szRecipients != NULL);
  74. // Add Recipients
  75. length = strlen(szRecipients);
  76. buf = new TCHAR[length + 1]; // Allocate a work area (don't touch parameter itself)
  77. strcpy(buf, szRecipients);
  78. for(pos = 0, start = 0; pos <= length; pos++) {
  79. if(buf[pos] == ';' || buf[pos] == 0) {
  80. // First, pick apart the sub-strings (separated by ';')
  81. //  Store it in sTemp.
  82. buf[pos] = 0; // Redundant when at the end of string, but who cares.
  83. sTemp = &buf[start];
  84. // Now divide the substring into friendly names and e-mail addresses.
  85. nMark = sTemp.Find('<');
  86. if(nMark >= 0) {
  87. sFriendly = sTemp.Left(nMark);
  88. nMark2 = sTemp.Find('>');
  89. if(nMark2 < nMark) {
  90. delete[] buf;
  91. return FALSE;
  92. }
  93. // End of mark at closing bracket or end of string
  94. nMark2 > -1 ? nMark2 = nMark2 : nMark2 = sTemp.GetLength() - 1;
  95. sEmail = sTemp.Mid(nMark + 1, nMark2 - (nMark + 1));
  96. } else {
  97. sEmail = sTemp;
  98. sFriendly = _T("");
  99. }
  100. AddRecipient(sEmail, sFriendly);
  101. start = pos + 1;
  102. }
  103. }
  104. delete[] buf;
  105. return TRUE;
  106. }
  108. void CMailMessage::FormatMessage()
  109. {
  110. start_header();
  111. prepare_header();
  112. end_header();
  113. prepare_body();
  114. }
  116. void CMailMessage::SetCharsPerLine(UINT nCharsPerLine)
  117. { m_nCharsPerLine = nCharsPerLine; }
  119. UINT CMailMessage::GetCharsPerLine()
  120. {
  121. return m_nCharsPerLine;
  122. }
  124. // Create header as per RFC 822
  125. //
  126. void CMailMessage::prepare_header()
  127. {
  128. CString sTemp;
  129. sTemp = _T("");
  131. // From:
  132. sTemp = _T("From: ") + m_sFrom;
  133. add_header_line((LPCTSTR) sTemp);
  135. // To:
  136. sTemp = _T("To: ");
  137. CString sEmail = _T("");
  138. CString sFriendly = _T("");
  139. for(int i = 0; i < GetNumRecipients(); i++) {
  140. GetRecipient(sEmail, sFriendly, i);
  141. sTemp += (i > 0 ? _T(",") : _T(""));
  142. sTemp += sFriendly;
  143. sTemp += _T("<");
  144. sTemp += sEmail;
  145. sTemp += _T(">");
  146. }
  147. add_header_line((LPCTSTR) sTemp);
  149. // Date:
  150. m_tDateTime = m_tDateTime.GetCurrentTime();
  152. // Format: Mon, 01 Jun 98 01:10:30 GMT
  153. sTemp = _T("Date: ");
  154. sTemp += m_tDateTime.Format("%a, %d %b %y %H:%M:%S %Z");
  155. add_header_line((LPCTSTR) sTemp);
  157. // Subject:
  158. sTemp = _T("Subject: ") + m_sSubject;
  159. add_header_line((LPCTSTR) sTemp);
  161. // X-Mailer
  162. sTemp = _T("X-Mailer: ") + m_sMailerName;
  163. add_header_line((LPCTSTR) sTemp);
  164. }
  166. void CMailMessage::prepare_body()
  167. {
  168. // Append a CR/LF to body if necessary.
  169. if(m_sBody.Right(2) != _T("rn"))
  170. m_sBody += _T("rn");
  172. }
  174. void CMailMessage::start_header()
  175. { m_sHeader = _T(""); }
  177. void CMailMessage::end_header()
  178. { m_sHeader += _T("rn"); }
  180. void CMailMessage::add_header_line(LPCTSTR szHeaderLine)
  181. {
  182. CString sTemp;
  183. sTemp.Format(_T("%srn"), szHeaderLine);
  184. m_sHeader += sTemp;
  185. }
  187. //////////////////////////////////////////////////////////////////////
  188. // CMIMEContentAgent
  189. //////////////////////////////////////////////////////////////////////
  191. CMIMEContentAgent::CMIMEContentAgent(int nMIMEType)
  192. { m_nMIMETypeIHandle = nMIMEType; }
  194. CMIMEContentAgent::~CMIMEContentAgent()
  195. {}
  197. BOOL CMIMEContentAgent::QueryType(int nContentType)
  198. { return nContentType == m_nMIMETypeIHandle ? TRUE : FALSE; }
  201. //////////////////////////////////////////////////////////////////////
  202. // CMIMECode
  203. //////////////////////////////////////////////////////////////////////
  205. CMIMECode::CMIMECode()
  206. {
  207. }
  209. CMIMECode::~CMIMECode()
  210. {
  211. }
  213. //////////////////////////////////////////////////////////////////////
  214. // CBase64
  215. //////////////////////////////////////////////////////////////////////
  216. // Static Member Initializers
  217. //
  219. // The 7-bit alphabet used to encode binary information
  220. CString CBase64::m_sBase64Alphabet = 
  221. _T( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" );
  223. int CBase64::m_nMask[] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
  225. CBase64::CBase64()
  226. {
  227. }
  229. CBase64::~CBase64()
  230. {
  231. }
  233. CString CBase64::Encode(LPCTSTR szEncoding, int nSize)
  234. {
  235. CString sOutput = _T( "" );
  236. int nNumBits = 6;
  237. UINT nDigit;
  238. int lp = 0;
  240. ASSERT( szEncoding != NULL );
  241. if( szEncoding == NULL )
  242. return sOutput;
  243. m_szInput = szEncoding;
  244. m_nInputSize = nSize;
  246. m_nBitsRemaining = 0;
  247. nDigit = read_bits( nNumBits, &nNumBits, lp );
  248. while( nNumBits > 0 )
  249. {
  250. sOutput += m_sBase64Alphabet[ (int)nDigit ];
  251. nDigit = read_bits( nNumBits, &nNumBits, lp );
  252. }
  253. // Pad with '=' as per RFC 1521
  254. while( sOutput.GetLength() % 4 != 0 )
  255. {
  256. sOutput += '=';
  257. }
  258. return sOutput;
  259. }
  261. // The size of the output buffer must not be less than
  262. // 3/4 the size of the input buffer. For simplicity,
  263. // make them the same size.
  264. int CBase64::Decode(LPCTSTR szDecoding, LPTSTR szOutput)
  265. {
  266. CString sInput;
  267.     int c, lp =0;
  268. int nDigit;
  269.     int nDecode[ 256 ];
  271. ASSERT( szDecoding != NULL );
  272. ASSERT( szOutput != NULL );
  273. if( szOutput == NULL )
  274. return 0;
  275. if( szDecoding == NULL )
  276. return 0;
  277. sInput = szDecoding;
  278. if( sInput.GetLength() == 0 )
  279. return 0;
  281. // Build Decode Table
  282. //
  283. for( int i = 0; i < 256; i++ ) 
  284. nDecode[i] = -2; // Illegal digit
  285. for( i=0; i < 64; i++ )
  286. {
  287. nDecode[ m_sBase64Alphabet[ i ] ] = i;
  288. nDecode[ m_sBase64Alphabet[ i ] | 0x80 ] = i; // Ignore 8th bit
  289. nDecode[ '=' ] = -1; 
  290. nDecode[ '=' | 0x80 ] = -1; // Ignore MIME padding char
  291.     }
  293. // Clear the output buffer
  294. memset( szOutput, 0, sInput.GetLength() + 1 );
  296. // Decode the Input
  297. //
  298. for( lp = 0, i = 0; lp < sInput.GetLength(); lp++ )
  299. {
  300. c = sInput[ lp ];
  301. nDigit = nDecode[ c & 0x7F ];
  302. if( nDigit < -1 ) 
  303. {
  304. return 0;
  305. } 
  306. else if( nDigit >= 0 ) 
  307. // i (index into output) is incremented by write_bits()
  308. write_bits( nDigit & 0x3F, 6, szOutput, i );
  309.     }
  310. return i;
  311. }
  316. UINT CBase64::read_bits(int nNumBits, int * pBitsRead, int& lp)
  317. {
  318.     ULONG lScratch;
  319.     while( ( m_nBitsRemaining < nNumBits ) && 
  320.    ( lp < m_nInputSize ) ) 
  321. {
  322. int c = m_szInput[ lp++ ];
  323.         m_lBitStorage <<= 8;
  324.         m_lBitStorage |= (c & 0xff);
  325. m_nBitsRemaining += 8;
  326.     }
  327.     if( m_nBitsRemaining < nNumBits ) 
  328. {
  329. lScratch = m_lBitStorage << ( nNumBits - m_nBitsRemaining );
  330. *pBitsRead = m_nBitsRemaining;
  331. m_nBitsRemaining = 0;
  332.     } 
  333. else 
  334. {
  335. lScratch = m_lBitStorage >> ( m_nBitsRemaining - nNumBits );
  336. *pBitsRead = nNumBits;
  337. m_nBitsRemaining -= nNumBits;
  338.     }
  339.     return (UINT)lScratch & m_nMask[nNumBits];
  340. }
  343. void CBase64::write_bits(UINT nBits,
  344.  int nNumBits,
  345.  LPTSTR szOutput,
  346.  int& i)
  347. {
  348. UINT nScratch;
  350. m_lBitStorage = (m_lBitStorage << nNumBits) | nBits;
  351. m_nBitsRemaining += nNumBits;
  352. while( m_nBitsRemaining > 7 ) 
  353. {
  354. nScratch = m_lBitStorage >> (m_nBitsRemaining - 8);
  355. szOutput[ i++ ] = nScratch & 0xFF;
  356. m_nBitsRemaining -= 8;
  357. }
  358. }
  360. //////////////////////////////////////////////////////////////////////
  361. // CAppOctetStream
  362. //////////////////////////////////////////////////////////////////////
  364. // IMPORTANT: The number of bytes we read must be
  365. //  a multiple of 3 because CBase64's Encode()
  366. //  method will append padding characters ('=')
  367. //  to make the output's size a multiple of 4.
  368. //  (Base64 treats 3 8-bit bytes as 4 6-bit 'bytes').
  369. //  MIME decoders are free to treat '=' as a signal
  370. //  that there's no more data, so we don't want to pad
  371. //  until we're supposed to.
  372. // When at the end of the file, the # of bytes read
  373. //  may not be a multiple of 3, but that's okay
  374. //  because we DO want the padding chars then.
  376. #define BYTES_TO_READ 54 // This number guarantess output won't
  377.  // won't exceed line-length limit
  379. CAppOctetStream::CAppOctetStream(int nContentType)
  380. :CMIMEContentAgent(nContentType)
  381. {
  382. }
  384. CAppOctetStream::~CAppOctetStream()
  385. {
  386. }
  388. BOOL CAppOctetStream::AppendPart(LPCTSTR szContent, 
  389.  LPCTSTR szParameters, 
  390.  int nEncoding, 
  391.  BOOL bPath, 
  392.  CString & sDestination)
  393. {
  394. CStdioFile fAttachment;
  396. ASSERT(szContent != NULL);
  397. // This class handles only file attachments, so
  398. // it ignores the bPath parameter.
  399. if(szContent == NULL)
  400. return FALSE;
  401. if(!fAttachment.Open(szContent, (CFile::modeRead|CFile::shareDenyWrite|CFile::typeBinary)))
  402. return FALSE;
  403. sDestination += build_sub_header(szContent,
  404.       szParameters,
  405.   nEncoding,
  406.   TRUE);
  407. attach_file(&fAttachment, CMIMEMessage::BASE64, sDestination );
  408. fAttachment.Close();
  409. return TRUE;
  410. }
  413. CString CAppOctetStream::build_sub_header(LPCTSTR szContent, 
  414.   LPCTSTR szParameters, 
  415.   int nEncoding, 
  416.   BOOL bPath)
  417. {
  418. CString sSubHeader;
  419. CString sTemp;
  420. TCHAR szFName[ _MAX_FNAME ];
  421. TCHAR szExt[ _MAX_EXT ];
  423. _tsplitpath( szContent, NULL, NULL, szFName, szExt );
  425. // This class ignores szParameters and nEncoding.
  426. // It controls its own parameters and only handles
  427. // Base64 encoding.
  428. if( bPath )
  429. sTemp.Format( "; file=%s%s", szFName, szExt );
  430. else
  431. sTemp = _T( "" );
  432. sSubHeader.Format( _T( "Content-Type: %s%srn" ),
  433. (LPCTSTR)GetContentTypeString(),
  434. (LPCTSTR)sTemp );
  435. sSubHeader += _T( "Content-Transfer-Encoding: base64rn" );
  436. sTemp.Format( _T( "Content-Disposition: attachment; filename=%s%srn" ),
  437.   szFName, szExt );
  438. sSubHeader += sTemp;
  439. // Signal end of sub-header.
  440. sSubHeader += _T( "rn" ); // Warning: numerous concatenations
  441. // are inefficient.
  442. return sSubHeader;
  443. }
  445. CString CAppOctetStream::GetContentTypeString()
  446. {
  447. CString s;
  448. s = _T( "application/octet-stream" );
  449. return s;
  450. }
  452. // Caller is responsible for opening and closing the file
  453. void CAppOctetStream::attach_file(CStdioFile* pFileAtt, 
  454.   int nEncoding, 
  455.   CString & sDestination)
  456. {
  457. CMIMECode* pEncoder;
  458. int nBytesRead;
  459. TCHAR szBuffer[ BYTES_TO_READ + 1 ];
  461. ASSERT( pFileAtt != NULL );
  462. if( pFileAtt == NULL )
  463. return;
  464. switch( nEncoding )
  465. {
  466. // This class handles only Base64 encoding, but others
  467. //  may be added here.
  468. default:
  469. // Fall through to...
  470. case CMIMEMessage::BASE64:
  471. try 
  472. {
  473. pEncoder = new CBase64;
  474. }
  475. catch( CMemoryException* e )
  476. {
  477. delete e;
  478. return;
  479. }
  480. }
  481. if( pEncoder == NULL ) // Old habits are hard to break
  482. return;
  483. do
  484. {
  485. try
  486. {
  487. nBytesRead = pFileAtt->Read( szBuffer, BYTES_TO_READ );
  488. }
  489. catch( CFileException* e )
  490. {
  491. delete e;
  492. break;
  493. }
  494. szBuffer[ nBytesRead ] = 0; // Terminate the string
  495. sDestination += pEncoder->Encode( szBuffer, nBytesRead );
  496. sDestination += _T( "rn" );
  497. } while( nBytesRead == BYTES_TO_READ );
  498. sDestination += _T( "rn" );
  499. delete pEncoder;
  500. }
  502. //////////////////////////////////////////////////////////////////////
  503. // CTextPlain
  504. //////////////////////////////////////////////////////////////////////
  506. CTextPlain::CTextPlain( int nContentType, UINT nWrapPos )
  507. :CMIMEContentAgent( nContentType )
  508. {
  509. m_nWrapPos = nWrapPos;
  510. }
  512. CTextPlain::~CTextPlain()
  513. {
  515. }
  517. CString CTextPlain::GetContentTypeString()
  518. {
  519. CString s;
  520. s = _T( "text/plain" );
  521. return s;
  522. }
  524. BOOL CTextPlain::AppendPart(LPCTSTR szContent, 
  525. LPCTSTR szParameters, 
  526. int nEncoding, 
  527. BOOL bPath, 
  528. CString & sDestination)
  529. {
  530. CString sSubHeader;
  531. CString sWrapped;
  532. sSubHeader = build_sub_header( szContent,
  533.    szParameters,
  534.    nEncoding,
  535.    bPath );
  536. sWrapped = wrap_text( szContent );
  537. sDestination += (sSubHeader + sWrapped);
  538. return TRUE;
  539. }
  541. CString CTextPlain::build_sub_header(LPCTSTR szContent, 
  542.  LPCTSTR szParameters, 
  543.  int nEncoding, 
  544.  BOOL bPath)
  545. {
  546. CString sSubHeader;
  547. sSubHeader.Format( _T( "Content-Type: %s%srn" ),
  548.    (LPCTSTR)GetContentTypeString(),
  549.    szParameters );
  550. sSubHeader += _T( "Content-Transfer-Encoding: " );
  551. switch( nEncoding )
  552. {
  553. // This class handles only 7bit encoding, but others
  554. //  may be added here.
  555. default:
  556. //Fall through to...
  557. case CMIMEMessage::_7BIT:
  558. sSubHeader += _T( "7Bit" );
  559. }
  560. sSubHeader += _T( "rnrn" );
  561. return sSubHeader;
  562. }
  564. CString CTextPlain::wrap_text(LPCTSTR szText)
  565. {
  566. CString sTemp;
  567. CString sLeft;
  568. CString sRight;
  569. int lp = 0;
  570. UINT nCount = 0;
  571. int nSpacePos = 0;
  573. ASSERT( szText != NULL );
  574. if( szText == NULL )
  575. return sTemp;
  576. sTemp = szText;
  577. while( lp < sTemp.GetLength() )
  578. {
  579. if( sTemp[ lp ] == ' ' )
  580. nSpacePos = lp;
  581. // Reset counter on newline
  582. if( sTemp.Mid( lp, 2 ) == _T( "rn" ) )
  583. nCount = 0;
  584. // Wrap text at last found space
  585. if( nCount > m_nWrapPos )
  586. {
  587. sLeft = sTemp.Left( nSpacePos );
  588. sRight = sTemp.Right( sTemp.GetLength() - nSpacePos );
  589. sLeft.TrimRight();
  590. sRight.TrimLeft();
  591. sLeft += _T( "rn" );
  592. sTemp = sLeft + sRight;
  593. nCount = 0;
  594. }
  595. else
  596. nCount++;
  597. lp++;
  598. }
  599. return sTemp;
  600. }
  602. //////////////////////////////////////////////////////////////////////
  603. // CMIMEMessage
  604. //////////////////////////////////////////////////////////////////////
  606. // Static Member Initializers
  607. CMIMEMessage::CMIMETypeManager CMIMEMessage::m_MIMETypeManager;
  609. CMIMEMessage::CMIMEMessage()
  610. {
  611. m_sMIMEContentType = _T( "multipart/mixed");
  612. m_sPartBoundary = _T( "WC_MAIL_PaRt_BoUnDaRy_05151998" );
  613. m_sNoMIMEText = _T( "This is a multi-part message in MIME format." );
  615. // Register the MIME types handled by this class
  616. //
  617. CMIMEContentAgent* pType;
  618. // These objects are deleted by CMIMTypeManager's destructor
  619. pType = new CTextPlain( TEXT_PLAIN, GetCharsPerLine() );
  620. register_mime_type( pType );
  621. pType = new CAppOctetStream( APPLICATION_OCTETSTREAM );
  622. register_mime_type( pType );
  623. }
  625. CMIMEMessage::~CMIMEMessage()
  626. {
  627. }
  629. // This implementation adds the part to the part-list used
  630. //  to build the body.
  631. BOOL CMIMEMessage::AddMIMEPart(LPCTSTR szContent,
  632.    int nContentType, 
  633.    LPCTSTR szParameters, 
  634.    int nEncoding, 
  635.    BOOL bPath )
  636. {
  637. CMIMEPart part;
  638. part.m_nContentType = nContentType;
  639. part.m_sParameters = szParameters;
  640. part.m_nEncoding = nEncoding;
  641. part.m_bPath = bPath;
  642. part.m_sContent = szContent;
  643. part.m_sContent.TrimLeft();
  644. part.m_sContent.TrimRight();
  645. if( nContentType == TEXT_PLAIN )
  646. m_MIMEPartList.AddHead( part );
  647. else
  648. m_MIMEPartList.AddTail( part );
  649. return TRUE;
  650. }
  652. void CMIMEMessage::prepare_header()
  653. {
  654. CString sTemp;
  656. // Let the base class add its headers
  657. CMailMessage::prepare_header();
  659. add_header_line( _T( "MIME-Version: 1.0" ) );
  660. sTemp.Format( _T( "Content-Type: %s; boundary=%s" ),
  661.   (LPCTSTR)m_sMIMEContentType,
  662.   (LPCTSTR)m_sPartBoundary );
  663. add_header_line( (LPCTSTR)sTemp );
  664. }
  666. void CMIMEMessage::prepare_body()
  667. {
  668. // Class user may have assigned body text directly.
  669. // Convert it to just another MIME part to be processed.
  670. // If this default Content-Type isn't good enough for the
  671. // class user, he or she should have used AddMIMEPart() instead.
  672. if( m_sBody != _T( "" ) )
  673. AddMIMEPart( (LPCTSTR)m_sBody, TEXT_PLAIN, "", _7BIT, FALSE );
  675. // Initialize the body (replace current contents).
  676. m_sBody = m_sNoMIMEText;
  677. m_sBody += _T( "rnrn" );
  678. append_mime_parts();
  679. insert_message_end( m_sBody );
  681. // Let the base class take me to Funky Town
  682. CMailMessage::prepare_body();
  683. }
  685. void CMIMEMessage::insert_boundary( CString& sText )
  686. {
  687. CString sTemp;
  688. if( sText.Right( 2 ) != _T( "rn" ) )
  689. sText += _T( "rn" );
  690. sTemp.Format( _T( "--%srn" ), (LPCTSTR)m_sPartBoundary );
  691. sText += sTemp;
  692. }
  694. void CMIMEMessage::insert_message_end( CString& sText )
  695. {
  696. CString sTemp;
  697. if( sText.Right( 2 ) != _T( "rn" ) )
  698. sText += _T( "rn" );
  699. sTemp.Format( _T( "--%s--rn" ), (LPCTSTR)m_sPartBoundary );
  700. sText += sTemp;
  701. }
  703. void CMIMEMessage::register_mime_type(CMIMEContentAgent* pMIMEType)
  704. {
  705. ASSERT( pMIMEType != NULL );
  706. if( pMIMEType == NULL )
  707. return;
  708. m_MIMETypeManager.RegisterMIMEType( pMIMEType );
  709. }
  712. void CMIMEMessage::append_mime_parts()
  713. {
  714. POSITION part_position;
  715. CMIMEPart* pMIMEPart = NULL;
  716. CMIMEContentAgent* pMIMEType = NULL;
  718. part_position = m_MIMEPartList.GetHeadPosition();
  719. // Get each part from the list, retrieve a handler for it,
  720. //  and let the handler do its thing.
  721. while( part_position != NULL )
  722. {
  723. pMIMEPart = & m_MIMEPartList.GetNext( part_position );
  724. pMIMEType = m_MIMETypeManager.GetHandler( pMIMEPart->m_nContentType );
  725. if( pMIMEType != NULL )
  726. {
  727. insert_boundary( m_sBody );
  728. pMIMEType->AppendPart( pMIMEPart->m_sContent,
  729.    pMIMEPart->m_sParameters,
  730.    pMIMEPart->m_nEncoding,
  731.    pMIMEPart->m_bPath,
  732.    m_sBody );
  733. }
  734. }
  736. }
  738. //////////////////////////////////////////////////////////////////////
  739. // CMIMETypeManager Implementation
  740. //////////////////////////////////////////////////////////////////////
  742. CMIMEMessage::CMIMETypeManager::CMIMETypeManager()
  743. {
  744. }
  746. CMIMEMessage::CMIMETypeManager::~CMIMETypeManager()
  747. {
  748. POSITION pos;
  749. CMIMEContentAgent* p;
  750. m_csAccess.Lock();
  751. pos = m_MIMETypeList.GetHeadPosition();
  752. while( pos != NULL )
  753. {
  754. p = m_MIMETypeList.GetNext( pos );
  755. delete p;
  756. }
  757. }
  759. void CMIMEMessage::CMIMETypeManager::RegisterMIMEType(CMIMEContentAgent *pMIMEType)
  760. {
  761. ASSERT( pMIMEType != NULL );
  762. if( pMIMEType == NULL )
  763. return;
  764. m_csAccess.Lock();
  765. m_MIMETypeList.AddTail( pMIMEType );
  766. }
  768. CMIMEContentAgent* CMIMEMessage::CMIMETypeManager::GetHandler(int nContentType)
  769. {
  770. POSITION pos;
  771. CMIMEContentAgent* pType = NULL;
  773. m_csAccess.Lock();
  774. pos = m_MIMETypeList.GetHeadPosition();
  775. while( pos != NULL )
  776. {
  777. pType = m_MIMETypeList.GetNext( pos );
  778. if( pType->QueryType( nContentType ) == TRUE )
  779. break;
  780. }
  781. return pType;
  782. }
  784. //////////////////////////////////////////////////////////////////////
  785. // Construction/Destruction
  786. //////////////////////////////////////////////////////////////////////
  788. // Static member initializers
  789. //
  791. // Note: the order of the entries is important.
  792. //       They must be synchronized with eResponse entries. 
  793. CSmtp::response_code CSmtp::response_table[] = {
  794. // GENERIC_SUCCESS
  795. {250, _T("SMTP server error")},
  796. // CONNECT_SUCCESS
  797. {220, _T("SMTP server not available")},
  798. // AUTHQUE_SUCCESS
  799. {334, _T("SMTP server authentication error")},
  800. // AUTH_SUCCESS
  801. {235, _T("Error username or password")},
  802. // DATA_SUCCESS
  803. {354, _T("SMTP server not ready for data")},
  804. // QUIT_SUCCESS
  805. {221, _T("SMTP server didn't terminate session")}
  806. };
  808. //////////////////////////////////////////////////////////////////////
  809. // Construction/Destruction
  810. //////////////////////////////////////////////////////////////////////
  812. CSmtp::CSmtp(LPCTSTR szSMTPServerName, UINT nPort)
  813. {
  814. ASSERT(szSMTPServerName != NULL);
  815. AfxSocketInit();
  816. m_sSMTPServerHostName = szSMTPServerName;
  817. m_nPort = nPort;
  818. m_bConnected = FALSE;
  819. m_bAuthed = FALSE;
  820. m_sError = _T("OK");
  821. response_buf = NULL;
  822. }
  824. CSmtp::~CSmtp()
  825. { Disconnect(); }
  827. CString CSmtp::GetServerHostName()
  828. {
  829. return m_sSMTPServerHostName;
  830. }
  832. BOOL CSmtp::Connect()
  833. {
  834. CString sHello;
  835. TCHAR local_host[80]; // Warning: arbitrary size
  836. if(m_bConnected) return TRUE;
  838. try {
  839. // This will be deleted in Disconnect();
  840. response_buf = new TCHAR[RESPONSE_BUFFER_SIZE];
  841. // I can't count on all class users' applications
  842. // to have exception-throwing operator-new implementations,
  843. // so I'll soul-kiss the ones that don't.
  844. if(response_buf == NULL) {
  845. m_sError = _T("Not enough memory");
  846. return FALSE;
  847. }
  848. } catch(CException* e) {
  849. response_buf = NULL;
  850. m_sError = _T("Not enough memory");
  851. delete e;
  852. return FALSE;
  853. }
  855. if(!m_wsSMTPServer.Create()) {
  856. m_sError = _T("Unable to create the socket");
  857. delete response_buf;
  858. response_buf = NULL;
  859. return FALSE;
  860. }
  861. if( !m_wsSMTPServer.Connect(GetServerHostName(), GetPort())) {
  862. m_sError = _T("Unable to connect to server");
  863. m_wsSMTPServer.Close();
  864. delete response_buf;
  865. response_buf = NULL;
  866. return FALSE;
  867. }
  868. if(!get_response(CONNECT_SUCCESS)) {
  869. m_sError = _T( "Server didn't respond" );
  870. m_wsSMTPServer.Close();
  871. delete response_buf;
  872. response_buf = NULL;
  873. return FALSE;
  874. }
  875. gethostname(local_host, 80);
  876. sHello.Format(_T( "HELO %srn" ), local_host);
  877. m_wsSMTPServer.Send((LPCTSTR)sHello, sHello.GetLength());
  878. if(!get_response(GENERIC_SUCCESS)) {
  879. m_wsSMTPServer.Close();
  880. delete response_buf;
  881. response_buf = NULL;
  882. return FALSE;
  883. }
  884. m_bConnected = TRUE;
  885. return TRUE;
  886. }
  888. BOOL CSmtp::Disconnect()
  889. {
  890. BOOL ret;
  891. if(!m_bConnected) return TRUE;
  892. // Disconnect gracefully from the server and close the socket
  893. CString sQuit = _T("QUITrn");
  894. m_wsSMTPServer.Send((LPCTSTR)sQuit, sQuit.GetLength());
  896. // No need to check return value here.
  897. // If it fails, the message is available with GetLastError
  898. ret = get_response(QUIT_SUCCESS);
  899. m_wsSMTPServer.Close();
  901. if(response_buf != NULL) {
  902. delete[] response_buf;
  903. response_buf = NULL;
  904. }
  905. m_bConnected = FALSE;
  906. return ret;
  907. }
  909. UINT CSmtp::GetPort()
  910. { return m_nPort; }
  912. CString CSmtp::GetLastError()
  913. { return m_sError; }
  915. BOOL CSmtp::SendMessage(CMailMessage* msg)
  916. {
  917. ASSERT(msg != NULL);
  918. if(!m_bConnected) {
  919. m_sError = _T("Must be connected");
  920. return FALSE;
  921. }
  922. if(!m_bAuthed){
  923. m_sError = _T("Must be Authed");
  924. return FALSE;
  925. }
  926. if(FormatMailMessage(msg) == FALSE) {
  927. return FALSE;
  928. }
  929. if(transmit_message(msg) == FALSE) {
  930. return FALSE;
  931. }
  932. return TRUE;
  933. }
  935. BOOL CSmtp::FormatMailMessage(CMailMessage* msg)
  936. {
  937. ASSERT(msg != NULL);
  938. if(msg -> GetNumRecipients() == 0) {
  939. m_sError = _T("No Recipients");
  940. return FALSE;
  941. }
  942. msg -> FormatMessage();
  943. return TRUE;
  944. }
  946. void CSmtp::SetServerProperties(LPCTSTR szSMTPServerName, UINT nPort)
  947. {
  948. ASSERT(szSMTPServerName != NULL);
  949. // Needs to be safe in non-debug too
  950. if(szSMTPServerName == NULL) return;
  951. m_sSMTPServerHostName = szSMTPServerName;
  952. m_nPort = nPort;
  953. }
  956. CString CSmtp::cook_body(CMailMessage* msg)
  957. {
  958. ASSERT(msg != NULL);
  959. CString sTemp;
  960. CString sCooked = _T("");
  961. LPTSTR szBad = _T("rn.rn");
  962. LPTSTR szGood = _T("rn..rn");
  963. int nPos;
  964. int nStart = 0;
  965. int nBadLength = strlen(szBad);
  966. sTemp = msg -> m_sBody;
  967. if(sTemp.Left(3) == _T(".rn"))
  968. sTemp = _T(".") + sTemp;
  969. //
  970. // This is a little inefficient because it beings a search
  971. // at the beginning of the string each time. This was
  972. // the only thing I could think of that handled ALL variations.
  973. // In particular, the sequence "rn.rn.rn" is troublesome. 
  974. // (Even CStringEx's FindReplace wouldn't handle that situation
  975. // with the global flag set.)
  976. //
  977. while((nPos = sTemp.Find(szBad)) > -1) {
  978. sCooked = sTemp.Mid(nStart, nPos);
  979. sCooked += szGood;
  980. sTemp = sCooked + sTemp.Right(sTemp.GetLength() - (nPos + nBadLength));
  981. }
  982. return sTemp;
  983. }
  985. BOOL CSmtp::transmit_message(CMailMessage* msg)
  986. {
  987. CString sFrom;
  988. CString sTo;
  989. CString sTemp;
  990. CString sEmail;
  992. ASSERT(msg != NULL);
  993. if(!m_bConnected) {
  994. m_sError = _T("Must be connected");
  995. return FALSE;
  996. }
  998. if(!m_bAuthed){
  999. m_sError = _T("Must be Authed");
  1000. return FALSE;
  1001. }
  1003. // Send the MAIL command
  1004. sFrom.Format(_T( "MAIL From: <%s>rn" ), (LPCTSTR)msg->m_sFrom);
  1005. m_wsSMTPServer.Send((LPCTSTR)sFrom, sFrom.GetLength());
  1006. if(!get_response(GENERIC_SUCCESS)){
  1007. m_sError = _T("Error sender address");
  1008. return FALSE;
  1009. }
  1011. // Send RCPT commands (one for each recipient)
  1012. for(int i = 0; i < msg->GetNumRecipients(); i++) {
  1013. msg->GetRecipient(sEmail, sTemp, i);
  1014. sTo.Format(_T("RCPT TO: <%s>rn"), (LPCTSTR)sEmail);
  1015. m_wsSMTPServer.Send((LPCTSTR)sTo, sTo.GetLength());
  1016. get_response(GENERIC_SUCCESS);
  1017. }
  1019. // Send the DATA command
  1020. sTemp = _T("DATArn");
  1021. m_wsSMTPServer.Send((LPCTSTR)sTemp, sTemp.GetLength());
  1022. if( !get_response(DATA_SUCCESS)) {
  1023. return FALSE;
  1024. }
  1026. // Send the header
  1027. m_wsSMTPServer.Send((LPCTSTR)msg -> m_sHeader, msg -> m_sHeader.GetLength());
  1029. // Send the body
  1030. sTemp = cook_body(msg);
  1031. m_wsSMTPServer.Send((LPCTSTR)sTemp, sTemp.GetLength());
  1033. // Signal end of data
  1034. sTemp = _T("rn.rn");
  1035. m_wsSMTPServer.Send((LPCTSTR)sTemp, sTemp.GetLength());
  1036. if( !get_response(GENERIC_SUCCESS)) {
  1037. return FALSE;
  1038. }
  1039. return TRUE;
  1040. }
  1042. BOOL CSmtp::get_response(UINT response_expected)
  1043. {
  1044. ASSERT(response_expected >= GENERIC_SUCCESS);
  1045. ASSERT(response_expected < LAST_RESPONSE);
  1047. CString sResponse;
  1048. UINT response;
  1049. response_code* pResp; // Shorthand
  1051. if(m_wsSMTPServer.Receive(response_buf, RESPONSE_BUFFER_SIZE) == SOCKET_ERROR) {
  1052. m_sError = _T("Socket Error");
  1053. return FALSE;
  1054. }
  1055. sResponse = response_buf;
  1056. sscanf((LPCTSTR)sResponse.Left(3), _T("%d"), &response);
  1057. pResp = &response_table[response_expected];
  1058. if(response != pResp -> nResponse) {
  1059. m_sError.Format( _T("%d:%s"), response, (LPCTSTR)pResp -> sMessage);
  1060. return FALSE;
  1061. }
  1062. return TRUE;
  1063. }
  1065. BOOL CSmtp::Auth()
  1066. {
  1067. CString sAuth;
  1068. if(!m_bConnected) return FALSE;
  1070. sAuth.Format(_T( "auth loginrn" )); //construct auth quest
  1071. m_wsSMTPServer.Send((LPCTSTR)sAuth, sAuth.GetLength());
  1072. if(!get_response(AUTHQUE_SUCCESS)) {
  1073. m_sError="SMTP server with no auth";
  1074. m_bAuthed=TRUE;
  1075. return TRUE;
  1076. }
  1078. sAuth.Empty();
  1080. sAuth.Format(_T( "%srn" ), m_User); //m_User is an string encoded with CBASE64
  1081. m_wsSMTPServer.Send((LPCTSTR)sAuth, sAuth.GetLength());
  1082. if(!get_response(AUTHQUE_SUCCESS)) {
  1083. m_wsSMTPServer.Close();
  1084. delete response_buf;
  1085. response_buf = NULL;
  1086. return FALSE;
  1087. }
  1089. sAuth.Empty();
  1091. sAuth.Format(_T( "%srn" ), m_Pass); //m_sSMTPPass is an string encoded with CBASE64
  1092. m_wsSMTPServer.Send((LPCTSTR)sAuth, sAuth.GetLength());
  1093. if(!get_response(AUTH_SUCCESS)) {
  1094. m_wsSMTPServer.Close();
  1095. delete response_buf;
  1096. response_buf = NULL;
  1097. return FALSE;
  1098. }
  1100. m_bAuthed = TRUE;
  1101. return TRUE;
  1103. }