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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email服务器 > 查看源码
SendMail.cpp
资源名称：xmail-1.22.rar　[点击查看]
上传用户：woshihumen
上传日期：2013-07-18
资源大小：484k
文件大小：23k
源码类别：

Email服务器

开发平台：

Visual C++

SendMail.cpp：源码内容
  1. /*
  2.  *  SendMail by Davide Libenzi ( sendmail replacement for XMail )
  3.  *  Copyright (C) 1999,..,2004  Davide Libenzi
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  *  Davide Libenzi <davidel@xmailserver.org>
  20.  *
  21.  */
  23. #if defined(WIN32)
  25. #include <windows.h>
  26. #include <stdio.h>
  27. #include <io.h>
  28. #include <direct.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31. #include <ctype.h>
  32. #include <time.h>
  33. #include "AppDefines.h"
  35. #define SYS_SLASH_CHAR              '\'
  36. #define SYS_SLASH_STR               "\"
  37. #define SYS_MAX_PATH                256
  39. #define SysSNPrintf                 _snprintf
  41. #define Sign(v)                     (((v) < 0) ? -1: +1)
  42. #define Min(a, b)                   (((a) < (b)) ? (a): (b))
  43. #define Max(a, b)                   (((a) > (b)) ? (a): (b))
  44. #define Abs(v)                      (((v) > 0) ? (v): -(v))
  46. int SysFileSync(FILE * pFile)
  47. {
  49. if (fflush(pFile) || _commit(_fileno(pFile)))
  50. return (-1);
  52. return (0);
  54. }
  56. int SysPathExist(char const *pszPathName)
  57. {
  59. return ((_access(pszPathName, 0) == 0) ? 1 : 0);
  61. }
  63. int SysMakeDir(char const *pszPathName)
  64. {
  66. return ((_mkdir(pszPathName) == 0) ? 1 : 0);
  68. }
  70. int SysErrNo(void)
  71. {
  73. return (errno);
  75. }
  77. char const *SysErrStr(void)
  78. {
  80. return (strerror(errno));
  82. }
  84. unsigned long SysGetProcessId(void)
  85. {
  87. return ((unsigned long) GetCurrentThreadId());
  89. }
  91. int SysMoveFile(char const *pszOldName, char const *pszNewName)
  92. {
  94. if (!MoveFileEx
  95.     (pszOldName, pszNewName, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED))
  96. return (-1);
  98. return (0);
  100. }
  102. int SysGetHostName(char *pszHostName, int iNameSize)
  103. {
  105. DWORD dwSize = (DWORD) iNameSize;
  107. GetComputerName(pszHostName, &dwSize);
  109. return (0);
  111. }
  113. void SysMsSleep(int iMsTimeout)
  114. {
  116. Sleep(iMsTimeout);
  118. }
  120. char *SysGetEnv(const char *pszVarName)
  121. {
  123. char szRKeyPath[256] = "";
  125. sprintf(szRKeyPath, "SOFTWARE\%s\%s", APP_PRODUCER, APP_NAME_STR);
  127. HKEY hKey;
  129. if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szRKeyPath, 0, KEY_QUERY_VALUE,
  130.  &hKey) == ERROR_SUCCESS) {
  131. char szKeyValue[2048] = "";
  132. DWORD dwSize = sizeof(szKeyValue), dwKeyType;
  134. if (RegQueryValueEx(hKey, pszVarName, NULL, &dwKeyType, (u_char *) szKeyValue,
  135.     &dwSize) == ERROR_SUCCESS) {
  136. RegCloseKey(hKey);
  138. return (strdup(szKeyValue));
  139. }
  141. RegCloseKey(hKey);
  142. }
  144. const char *pszValue = getenv(pszVarName);
  146. return ((pszValue != NULL) ? strdup(pszValue) : NULL);
  148. }
  150. char *SysGetUserAddress(char *pszUser, int iSize, char const *pszEnvDomain)
  151. {
  153. DWORD dwSize;
  154. char const *pszDomain;
  155. char szUser[256] = "";
  156. char szDomain[256] = "";
  158. dwSize = sizeof(szUser);
  159. GetUserName(szUser, &dwSize);
  161. if ((pszDomain = SysGetEnv(pszEnvDomain)) == NULL) {
  162. dwSize = sizeof(szDomain);
  163. GetComputerName(szDomain, &dwSize);
  164. pszDomain = szDomain;
  165. }
  167. SysSNPrintf(pszUser, iSize, "%s@%s", szUser, pszDomain);
  169. return (pszUser);
  171. }
  173. #else // #if defined(WIN32)
  174. #if defined(__LINUX__) || defined(__SOLARIS__) || defined(__BSD__)
  176. #include <sys/stat.h>
  177. #include <stdio.h>
  178. #include <stdlib.h>
  179. #include <string.h>
  180. #include <ctype.h>
  181. #include <time.h>
  182. #include <fcntl.h>
  183. #include <unistd.h>
  184. #include <errno.h>
  185. #include <dirent.h>
  187. #define SYS_SLASH_CHAR              '/'
  188. #define SYS_SLASH_STR               "/"
  189. #define SYS_MAX_PATH                256
  191. #define SysSNPrintf                 snprintf
  192. #define stricmp                     strcasecmp
  193. #define strnicmp                    strncasecmp
  195. #define Sign(v)                     (((v) < 0) ? -1: +1)
  196. #define Min(a, b)                   (((a) < (b)) ? (a): (b))
  197. #define Max(a, b)                   (((a) > (b)) ? (a): (b))
  198. #define Abs(v)                      (((v) > 0) ? (v): -(v))
  200. int SysFileSync(FILE * pFile)
  201. {
  203. if (fflush(pFile) || fsync(fileno(pFile)))
  204. return (-1);
  206. return (0);
  208. }
  210. int SysPathExist(char const *pszPathName)
  211. {
  213. return ((access(pszPathName, 0) == 0) ? 1 : 0);
  215. }
  217. int SysMakeDir(char const *pszPathName)
  218. {
  220. return ((mkdir(pszPathName, 0700) == 0) ? 1 : 0);
  222. }
  224. int SysErrNo(void)
  225. {
  227. return (errno);
  229. }
  231. char const *SysErrStr(void)
  232. {
  234. return (strerror(errno));
  236. }
  238. unsigned long SysGetProcessId(void)
  239. {
  241. return ((unsigned long) getpid());
  243. }
  245. int SysMoveFile(char const *pszOldName, char const *pszNewName)
  246. {
  248. if (rename(pszOldName, pszNewName) != 0)
  249. return (-1);
  251. return (0);
  253. }
  255. int SysGetHostName(char *pszHostName, int iNameSize)
  256. {
  258. gethostname(pszHostName, iNameSize);
  260. return (0);
  262. }
  264. void SysMsSleep(int iMsTimeout)
  265. {
  267. usleep(iMsTimeout * 1000);
  269. }
  271. char *SysGetEnv(const char *pszVarName)
  272. {
  274. const char *pszValue = getenv(pszVarName);
  276. return ((pszValue != NULL) ? strdup(pszValue) : NULL);
  278. }
  280. char *SysGetUserAddress(char *pszUser, int iSize, char const *pszEnvDomain)
  281. {
  283. char const *pszEnv;
  284. char szUser[256] = "mail";
  285. char szDomain[256] = "localhost";
  287. if ((pszEnv = SysGetEnv("USER")) != NULL) {
  288. strncpy(szUser, pszEnv, sizeof(szUser) - 1);
  289. szUser[sizeof(szUser) - 1] = '';
  290. }
  291. if (((pszEnv = SysGetEnv(pszEnvDomain)) != NULL) ||
  292.     ((pszEnv = SysGetEnv("HOSTNAME")) != NULL)) {
  293. strncpy(szDomain, pszEnv, sizeof(szDomain) - 1);
  294. szDomain[sizeof(szDomain) - 1] = '';
  295. }
  297. SysSNPrintf(pszUser, iSize, "%s@%s", szUser, szDomain);
  299. return (pszUser);
  301. }
  304. #else // #if defined(__LINUX__) || defined(__SOLARIS__)
  306. #error system type not defined !
  308. #endif // #if defined(__LINUX__) || defined(__SOLARIS__)
  309. #endif // #if defined(WIN32)
  311. #define ENV_MAIL_ROOT           "MAIL_ROOT"
  312. #define LOCAL_TEMP_SUBPATH      "spool" SYS_SLASH_STR "temp" SYS_SLASH_STR
  313. #define LOCAL_SUBPATH           "spool" SYS_SLASH_STR "local" SYS_SLASH_STR
  314. #define MAIL_DATA_TAG           "<<MAIL-DATA>>"
  315. #define MAX_ADDR_NAME           256
  316. #define SAPE_OPEN_TENTATIVES    5
  317. #define SAPE_OPEN_DELAY         500
  318. #define ENV_DEFAULT_DOMAIN      "DEFAULT_DOMAIN"
  320. #define SetEmptyString(s)       (s)[0] = ''
  321. #define IsEmptyString(s)        (*(s) == '')
  322. #define StrNCpy(t, s, n)        do { strncpy(t, s, n); (t)[(n) - 1] = ''; } while (0)
  323. #define StrSNCpy(t, s)          StrNCpy(t, s, sizeof(t))
  325. static FILE *SafeOpenFile(char const *pszFilePath, char const *pszMode)
  326. {
  328. FILE *pFile;
  330. for (int ii = 0; ii < SAPE_OPEN_TENTATIVES; ii++) {
  331. if ((pFile = fopen(pszFilePath, pszMode)) != NULL)
  332. return (pFile);
  334. SysMsSleep(SAPE_OPEN_DELAY);
  335. }
  337. return (NULL);
  339. }
  341. static char const *AddressFromAtPtr(char const *pszAt, char const *pszBase, char *pszAddress,
  342.     int iSize)
  343. {
  345. char const *pszStart = pszAt;
  347. for (; (pszStart >= pszBase) && (strchr("<> t,":;'rn", *pszStart) == NULL);
  348.      pszStart--);
  350. ++pszStart;
  352. char const *pszEnd = pszAt + 1;
  354. for (; (*pszEnd != '') && (strchr("<> t,":;'rn", *pszEnd) == NULL); pszEnd++);
  356. int iAddrLength = Min((int) (pszEnd - pszStart), iSize - 1);
  358. strncpy(pszAddress, pszStart, iAddrLength);
  359. pszAddress[iAddrLength] = '';
  361. return (pszEnd);
  363. }
  365. static int EmitRecipients(FILE * pMailFile, char const *pszAddrList)
  366. {
  368. int iRcptCount = 0;
  369. char const *pszCurr = pszAddrList;
  371. for (; (pszCurr != NULL) && (*pszCurr != '');) {
  372. char const *pszAt = strchr(pszCurr, '@');
  374. if (pszAt == NULL)
  375. break;
  377. char szAddress[256] = "";
  379. if ((pszCurr = AddressFromAtPtr(pszAt, pszAddrList, szAddress,
  380. sizeof(szAddress))) != NULL) {
  381. fprintf(pMailFile, "rcpt to:<%s>rn", szAddress);
  383. ++iRcptCount;
  384. }
  386. }
  388. return (iRcptCount);
  390. }
  392. static int GetTime(struct tm &tmLocal, int &iDiffHours, int &iDiffMins, time_t tCurr)
  393. {
  395. if (tCurr == 0)
  396. time(&tCurr);
  398. tmLocal = *localtime(&tCurr);
  400. struct tm tmTimeLOC = tmLocal;
  401. struct tm tmTimeGM;
  403. tmTimeGM = *gmtime(&tCurr);
  405. tmTimeLOC.tm_isdst = 0;
  406. tmTimeGM.tm_isdst = 0;
  408. time_t tLocal = mktime(&tmTimeLOC);
  409. time_t tGM = mktime(&tmTimeGM);
  411. int iSecsDiff = (int) difftime(tLocal, tGM);
  412. int iSignDiff = Sign(iSecsDiff);
  413. int iMinutes = Abs(iSecsDiff) / 60;
  415. iDiffMins = iMinutes % 60;
  416. iDiffHours = iSignDiff * (iMinutes / 60);
  418. return (0);
  420. }
  422. char *MscStrftime(struct tm const *ptmTime, char *pszDateStr, int iSize)
  423. {
  425. const char *pszWDays[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
  426. const char *pszMonths[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  427. "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  428. };
  430. SysSNPrintf(pszDateStr, iSize, "%s, %d %s %d %02d:%02d:%02d",
  431.     pszWDays[ptmTime->tm_wday], ptmTime->tm_mday,
  432.     pszMonths[ptmTime->tm_mon], ptmTime->tm_year + 1900,
  433.     ptmTime->tm_hour, ptmTime->tm_min, ptmTime->tm_sec);
  435. return (pszDateStr);
  437. }
  439. static int GetTimeStr(char *pszTimeStr, int iStringSize, time_t tCurr)
  440. {
  442. int iDiffHours = 0;
  443. int iDiffMins = 0;
  444. struct tm tmTime;
  446. GetTime(tmTime, iDiffHours, iDiffMins, tCurr);
  448. char szDiffTime[128] = "";
  450. if (iDiffHours > 0)
  451. sprintf(szDiffTime, " +%02d%02d", iDiffHours, iDiffMins);
  452. else
  453. sprintf(szDiffTime, " -%02d%02d", -iDiffHours, iDiffMins);
  455. MscStrftime(&tmTime, pszTimeStr, iStringSize - strlen(szDiffTime) - 1);
  457. strcat(pszTimeStr, szDiffTime);
  459. return (0);
  461. }
  463. static char *CopyAddress(char *pszDest, char const *pszAddr, int iSize)
  464. {
  466. char *pszDomain;
  468. if (strchr(pszAddr, '@') || ((pszDomain = SysGetEnv(ENV_DEFAULT_DOMAIN)) == NULL))
  469. StrNCpy(pszDest, pszAddr, iSize);
  470. else
  471. SysSNPrintf(pszDest, iSize, "%s@%s", pszAddr, pszDomain);
  473. return (pszDest);
  475. }
  477. static bool IsRFC822HeaderLine(char const *pszLn)
  478. {
  480. char const *pszColon;
  482. if (!isalpha(*pszLn) || ((pszColon = strchr(pszLn, ':')) == NULL))
  483. return (false);
  484. for (pszLn++; pszLn < pszColon; pszLn++)
  485. if (!(isalpha(*pszLn) || isdigit(*pszLn) ||
  486.       strchr("_-", *pszLn) != NULL))
  487. return (false);
  489. return (true);
  491. }
  493. int main(int iArgCount, char *pszArgs[])
  494. {
  495. ///////////////////////////////////////////////////////////////////////////////
  496. //  Initialize time
  497. ///////////////////////////////////////////////////////////////////////////////
  498. tzset();
  500. ///////////////////////////////////////////////////////////////////////////////
  501. //  Get the mail root path
  502. ///////////////////////////////////////////////////////////////////////////////
  503. int iVarLength = 0;
  504. FILE *pInFile = stdin;
  505. char *pszMailRoot = SysGetEnv(ENV_MAIL_ROOT);
  506. char szMailRoot[SYS_MAX_PATH] = "";
  508. if ((pszMailRoot == NULL) || ((iVarLength = strlen(pszMailRoot)) == 0)) {
  509. if (pszMailRoot != NULL)
  510. free(pszMailRoot);
  511. fprintf(stderr, "cannot find environment variable: %sn", ENV_MAIL_ROOT);
  512. return (1);
  513. }
  515. StrSNCpy(szMailRoot, pszMailRoot);
  517. if (szMailRoot[iVarLength - 1] != SYS_SLASH_CHAR)
  518. strcat(szMailRoot, SYS_SLASH_STR);
  520. free(pszMailRoot);
  522. ///////////////////////////////////////////////////////////////////////////////
  523. //  Parse command line
  524. ///////////////////////////////////////////////////////////////////////////////
  525. int ii;
  526. bool bExtractRcpts = false;
  527. bool bXMailFormat = false;
  528. bool bDotMode = true;
  529. char szMailFrom[256] = "";
  530. char szExtMailFrom[256] = "";
  531. char szInputFile[SYS_MAX_PATH] = "";
  532. char szRcptFile[SYS_MAX_PATH] = "";
  534. SysGetUserAddress(szMailFrom, sizeof(szMailFrom) - 1, ENV_DEFAULT_DOMAIN);
  536. for (ii = 1; ii < iArgCount; ii++) {
  537. if (strcmp(pszArgs[ii], "--") == 0) {
  538. ++ii;
  539. break;
  540. }
  542. if (strcmp(pszArgs[ii], "--rcpt-file") == 0) {
  543. if (++ii < iArgCount)
  544. StrSNCpy(szRcptFile, pszArgs[ii]);
  545. } else if (strcmp(pszArgs[ii], "--xinput-file") == 0) {
  546. if (++ii < iArgCount) {
  547. StrSNCpy(szInputFile, pszArgs[ii]);
  549. bXMailFormat = true;
  550. }
  551. } else if (strcmp(pszArgs[ii], "--input-file") == 0) {
  552. if (++ii < iArgCount)
  553. StrSNCpy(szInputFile, pszArgs[ii]);
  554. } else if ((strcmp(pszArgs[ii], "-i") == 0) ||
  555.    (strcmp(pszArgs[ii], "-oi") == 0)){
  556. bDotMode = false;
  557. } else if (strcmp(pszArgs[ii], "-t") == 0) {
  558. bExtractRcpts = true;
  559. } else if (strncmp(pszArgs[ii], "-f", 2) == 0) {
  560. if (pszArgs[ii][2] != '')
  561. CopyAddress(szMailFrom, pszArgs[ii] + 2,
  562.     sizeof(szMailFrom) - 1);
  563. else if ((ii + 1) < iArgCount) {
  564. CopyAddress(szMailFrom, pszArgs[ii + 1],
  565.     sizeof(szMailFrom) - 1);
  566. ii++;
  567. }
  568. } else if (strncmp(pszArgs[ii], "-F", 2) == 0) {
  569. if (pszArgs[ii][2] != '')
  570. StrSNCpy(szExtMailFrom, pszArgs[ii] + 2);
  571. else if ((ii + 1) < iArgCount) {
  572. StrSNCpy(szExtMailFrom, pszArgs[ii + 1]);
  573. ii++;
  574. }
  576. char const *pszOpen = strchr(szExtMailFrom, '<');
  578. if (pszOpen == NULL)
  579. CopyAddress(szMailFrom, szExtMailFrom,
  580.     sizeof(szMailFrom) - 1);
  581. else {
  582. char szTmpMailFrom[256] = "";
  584. StrSNCpy(szTmpMailFrom, pszOpen + 1);
  586. char *pszClose =
  587. (char *) strchr(szTmpMailFrom, '>');
  589. if (pszClose != NULL)
  590. *pszClose = '';
  592. CopyAddress(szMailFrom, szTmpMailFrom,
  593.     sizeof(szMailFrom) - 1);
  594. }
  595. } else if (strncmp(pszArgs[ii], "-o", 2) == 0) {
  597. } else if ((strcmp(pszArgs[ii], "-L") == 0) ||
  598.    (strcmp(pszArgs[ii], "-O") == 0) ||
  599.    (strcmp(pszArgs[ii], "-R") == 0) ||
  600.    (strcmp(pszArgs[ii], "-X") == 0) ||
  601.    (strcmp(pszArgs[ii], "-V") == 0) ||
  602.    (strcmp(pszArgs[ii], "-N") == 0) ||
  603.    (strncmp(pszArgs[ii], "-qG", 3) == 0) ||
  604.    (strncmp(pszArgs[ii], "-q!", 3) == 0)) {
  605. if ((ii + 1) < iArgCount)
  606. ii++;
  607. } else
  608. break;
  609. }
  611. ///////////////////////////////////////////////////////////////////////////////
  612. //  Check if recipients are supplied
  613. ///////////////////////////////////////////////////////////////////////////////
  614. if (!bExtractRcpts && (ii >= iArgCount) && IsEmptyString(szRcptFile)) {
  615. fprintf(stderr, "empty recipient listn");
  616. return (2);
  617. }
  619. if (!IsEmptyString(szInputFile)) {
  620. if ((pInFile = fopen(szInputFile, "rb")) == NULL) {
  621. perror(szInputFile);
  622. return (3);
  623. }
  624. }
  625. ///////////////////////////////////////////////////////////////////////////////
  626. //  Save recipients index
  627. ///////////////////////////////////////////////////////////////////////////////
  628. int iRcptIndex = ii;
  629. int iRcptCount = iArgCount - iRcptIndex;
  631. ///////////////////////////////////////////////////////////////////////////////
  632. //  Create file name
  633. ///////////////////////////////////////////////////////////////////////////////
  634. char szHostName[256] = "";
  635. char szDataFile[SYS_MAX_PATH] = "";
  636. char szMailFile[SYS_MAX_PATH] = "";
  638. SysGetHostName(szHostName, sizeof(szHostName) - 1);
  640. sprintf(szDataFile, "%s%s%lu000.%lu.%s",
  641. szMailRoot,
  642. LOCAL_TEMP_SUBPATH, (unsigned long) time(NULL), SysGetProcessId(), szHostName);
  644. sprintf(szMailFile, "%s.mail", szDataFile);
  646. ///////////////////////////////////////////////////////////////////////////////
  647. //  Open raw data file
  648. ///////////////////////////////////////////////////////////////////////////////
  649. FILE *pDataFile = fopen(szDataFile, "w+b");
  651. if (pDataFile == NULL) {
  652. perror(szDataFile);
  653. if (pInFile != stdin)
  654. fclose(pInFile);
  655. return (4);
  656. }
  657. ///////////////////////////////////////////////////////////////////////////////
  658. //  Open maildrop file
  659. ///////////////////////////////////////////////////////////////////////////////
  660. FILE *pMailFile = fopen(szMailFile, "wb");
  662. if (pMailFile == NULL) {
  663. perror(szMailFile);
  664. fclose(pDataFile), remove(szDataFile);
  665. if (pInFile != stdin)
  666. fclose(pInFile);
  667. return (5);
  668. }
  669. ///////////////////////////////////////////////////////////////////////////////
  670. //  Emit sender
  671. ///////////////////////////////////////////////////////////////////////////////
  672. fprintf(pMailFile, "mail from:<%s>rn", szMailFrom);
  674. ///////////////////////////////////////////////////////////////////////////////
  675. //  Emit recipients
  676. ///////////////////////////////////////////////////////////////////////////////
  677. for (ii = iRcptIndex; ii < iArgCount; ii++) {
  678. char szAddr[256] = "";
  680. CopyAddress(szAddr, pszArgs[ii], sizeof(szAddr) - 1);
  682. fprintf(pMailFile, "rcpt to:<%s>rn", szAddr);
  683. }
  685. ///////////////////////////////////////////////////////////////////////////////
  686. //  Emit message by reading from stdin
  687. ///////////////////////////////////////////////////////////////////////////////
  688. int iLine;
  689. bool bInHeaders = true;
  690. bool bHasFrom = false;
  691. bool bHasDate = false;
  692. bool bRcptSource = false;
  693. bool bNoEmit = false;
  694. char szBuffer[1536] = "";
  696. for (iLine = 0; fgets(szBuffer, sizeof(szBuffer) - 1, pInFile) != NULL; iLine++) {
  697. int iLineLength = strlen(szBuffer);
  699. for (; (iLineLength > 0) &&
  700.      ((szBuffer[iLineLength - 1] == 'r') || (szBuffer[iLineLength - 1] == 'n'));
  701.      iLineLength--);
  703. szBuffer[iLineLength] = '';
  705. ///////////////////////////////////////////////////////////////////////////////
  706. //  Is it time to stop reading ?
  707. ///////////////////////////////////////////////////////////////////////////////
  708. if (bDotMode && (strcmp(szBuffer, ".") == 0))
  709. break;
  711. ///////////////////////////////////////////////////////////////////////////////
  712. //  Decode XMail spool file format
  713. ///////////////////////////////////////////////////////////////////////////////
  714. if (bXMailFormat) {
  715. if (strcmp(szBuffer, MAIL_DATA_TAG) == 0)
  716. bXMailFormat = false;
  718. continue;
  719. }
  720. ///////////////////////////////////////////////////////////////////////////////
  721. //  Extract mail from
  722. ///////////////////////////////////////////////////////////////////////////////
  723. if (bInHeaders) {
  724. bool bStraightFile = false;
  726. if ((iLine == 0) && !IsRFC822HeaderLine(szBuffer))
  727. bStraightFile = true;
  729. if (bStraightFile || (iLineLength == 0)) {
  730. bInHeaders = false;
  731. bNoEmit = false;
  733. ///////////////////////////////////////////////////////////////////////////////
  734. //  Add mail from ( if not present )
  735. ///////////////////////////////////////////////////////////////////////////////
  736. if (!bHasFrom) {
  737. if (strlen(szExtMailFrom) != 0)
  738. fprintf(pDataFile, "From: %srn", szExtMailFrom);
  739. else
  740. fprintf(pDataFile, "From: <%s>rn", szMailFrom);
  741. }
  742. ///////////////////////////////////////////////////////////////////////////////
  743. //  Add date ( if not present )
  744. ///////////////////////////////////////////////////////////////////////////////
  745. if (!bHasDate) {
  746. char szDate[128] = "";
  748. GetTimeStr(szDate, sizeof(szDate) - 1, time(NULL));
  750. fprintf(pDataFile, "Date: %srn", szDate);
  751. }
  753. if (bStraightFile)
  754. fprintf(pDataFile, "rn");
  755. }
  757. if ((szBuffer[0] == ' ') || (szBuffer[0] == 't')) {
  758. if (bExtractRcpts && bRcptSource) {
  759. int iRcptCurr = EmitRecipients(pMailFile, szBuffer);
  761. if (iRcptCurr > 0)
  762. iRcptCount += iRcptCurr;
  763. }
  764. } else if (iLineLength > 0) {
  765. bNoEmit = (strnicmp(szBuffer, "Bcc:", 4) == 0);
  766. bRcptSource = (strnicmp(szBuffer, "To:", 3) == 0) ||
  767. (strnicmp(szBuffer, "Cc:", 3) == 0) ||
  768. (strnicmp(szBuffer, "Bcc:", 4) == 0);
  770. if (bExtractRcpts && bRcptSource) {
  771. int iRcptCurr = EmitRecipients(pMailFile, szBuffer);
  773. if (iRcptCurr > 0)
  774. iRcptCount += iRcptCurr;
  775. }
  777. if (!bHasFrom && (strnicmp(szBuffer, "From:", 5) == 0))
  778. bHasFrom = true;
  780. if (!bHasDate && (strnicmp(szBuffer, "Date:", 5) == 0))
  781. bHasDate = true;
  782. }
  783. }
  784. ///////////////////////////////////////////////////////////////////////////////
  785. //  Emit mail line
  786. ///////////////////////////////////////////////////////////////////////////////
  787. if (!bNoEmit)
  788. fprintf(pDataFile, "%srn", szBuffer);
  790. }
  792. ///////////////////////////////////////////////////////////////////////////////
  793. //  Close input file if different from stdin
  794. ///////////////////////////////////////////////////////////////////////////////
  795. if (pInFile != stdin)
  796. fclose(pInFile);
  798. ///////////////////////////////////////////////////////////////////////////////
  799. //  Dump recipient file
  800. ///////////////////////////////////////////////////////////////////////////////
  801. if (!IsEmptyString(szRcptFile)) {
  802. FILE *pRcptFile = SafeOpenFile(szRcptFile, "rb");
  804. if (pRcptFile == NULL) {
  805. perror(szRcptFile);
  806. fclose(pDataFile), remove(szDataFile);
  807. fclose(pMailFile), remove(szMailFile);
  808. return (6);
  809. }
  811. while (fgets(szBuffer, sizeof(szBuffer) - 1, pRcptFile) != NULL) {
  812. int iLineLength = strlen(szBuffer);
  814. for (; (iLineLength > 0) &&
  815.      ((szBuffer[iLineLength - 1] == 'r') ||
  816.       (szBuffer[iLineLength - 1] == 'n')); iLineLength--);
  818. szBuffer[iLineLength] = '';
  820. if (iLineLength >= MAX_ADDR_NAME)
  821. continue;
  823. char *pszAt = strchr(szBuffer, '@');
  825. if (pszAt == NULL)
  826. continue;
  828. char szRecipient[MAX_ADDR_NAME] = "";
  830. if (AddressFromAtPtr(pszAt, szBuffer, szRecipient,
  831.      sizeof(szRecipient)) != NULL) {
  832. fprintf(pMailFile, "rcpt to:<%s>rn", szRecipient);
  834. ++iRcptCount;
  835. }
  836. }
  838. fclose(pRcptFile);
  839. }
  840. ///////////////////////////////////////////////////////////////////////////////
  841. //  Check the number of recipients
  842. ///////////////////////////////////////////////////////////////////////////////
  843. if (iRcptCount == 0) {
  844. fprintf(stderr, "empty recipient listn");
  845. fclose(pDataFile), remove(szDataFile);
  846. fclose(pMailFile), remove(szMailFile);
  847. return (7);
  848. }
  849. ///////////////////////////////////////////////////////////////////////////////
  850. //  Empty line separator between maildrop header and data
  851. ///////////////////////////////////////////////////////////////////////////////
  852. fprintf(pMailFile, "rn");
  854. ///////////////////////////////////////////////////////////////////////////////
  855. //  Append data file
  856. ///////////////////////////////////////////////////////////////////////////////
  857. rewind(pDataFile);
  859. unsigned int uReaded;
  861. do {
  862. if (((uReaded = fread(szBuffer, 1, sizeof(szBuffer), pDataFile)) != 0) &&
  863.     (fwrite(szBuffer, 1, uReaded, pMailFile) != uReaded)) {
  864. perror(szMailFile);
  865. fclose(pDataFile), remove(szDataFile);
  866. fclose(pMailFile), remove(szMailFile);
  867. return (8);
  868. }
  870. } while (uReaded == sizeof(szBuffer));
  872. fclose(pDataFile), remove(szDataFile);
  874. ///////////////////////////////////////////////////////////////////////////////
  875. //  Sync and close the mail file
  876. ///////////////////////////////////////////////////////////////////////////////
  877. if ((SysFileSync(pMailFile) < 0) || fclose(pMailFile)) {
  878. remove(szMailFile);
  879. fprintf(stderr, "cannot write file: %sn", szMailFile);
  880. return (9);
  881. }
  882. ///////////////////////////////////////////////////////////////////////////////
  883. //  Move the mail file
  884. ///////////////////////////////////////////////////////////////////////////////
  885. char szDropFile[SYS_MAX_PATH] = "";
  887. sprintf(szDropFile, "%s%s%lu000.%lu.%s",
  888. szMailRoot,
  889. LOCAL_SUBPATH, (unsigned long) time(NULL), SysGetProcessId(), szHostName);
  891. if (SysMoveFile(szMailFile, szDropFile) < 0) {
  892. remove(szMailFile);
  893. fprintf(stderr, "cannot move file: %sn", szMailFile);
  894. return (10);
  895. }
  897. return (0);
  899. }