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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB邮件程序 > 查看源码
CSmtp.cpp
资源名称：mysmtp2.rar　[点击查看]
上传用户：young001
上传日期：2007-07-04
资源大小：33k
文件大小：27k
源码类别：

WEB邮件程序

开发平台：

Visual C++

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