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

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

Email服务器

开发平台：

Visual C++

LMAILSvr.cpp：源码内容
  1. /*
  2.  *  XMail by Davide Libenzi ( Intranet and Internet mail server )
  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. #include "SysInclude.h"
  24. #include "SysDep.h"
  25. #include "SvrDefines.h"
  26. #include "SList.h"
  27. #include "ShBlocks.h"
  28. #include "StrUtils.h"
  29. #include "BuffSock.h"
  30. #include "MiscUtils.h"
  31. #include "ResLocks.h"
  32. #include "BuffSock.h"
  33. #include "MessQueue.h"
  34. #include "SvrUtils.h"
  35. #include "UsrUtils.h"
  36. #include "SMTPUtils.h"
  37. #include "SMAILUtils.h"
  38. #include "ExtAliases.h"
  39. #include "UsrMailList.h"
  40. #include "MailConfig.h"
  41. #include "LMAILSvr.h"
  42. #include "AppDefines.h"
  43. #include "MailSvr.h"
  45. #define LMAIL_SERVER_NAME           "[" APP_NAME_VERSION_STR " LMAIL Server]"
  46. #define LOCAL_SPOOL_DIR             "local"
  47. #define LMAIL_LOG_FILE              "lmail"
  49. static LMAILConfig *LMAILGetConfigCopy(SHB_HANDLE hShbLMAIL);
  50. static int LMAILThreadCountAdd(long lCount, SHB_HANDLE hShbLMAIL, LMAILConfig * pLMAILCfg = NULL);
  51. static int LMAILLogEnabled(SHB_HANDLE hShbLMAIL, LMAILConfig * pLMAILCfg = NULL);
  52. static int LMAILProcessLocalSpool(SHB_HANDLE hShbLMAIL, long lThreadId);
  53. static int LMAILGetFilesSnapShot(LMAILConfig * pLMAILCfg, long lThreadId, char *pszSSFileName);
  54. static int LMAILRemoveProcessed(LMAILConfig * pLMAILCfg, char const *pszListFileName);
  55. static int LMAILProcessList(LMAILConfig * pLMAILCfg, long lThreadId, char const *pszSSFileName);
  56. static int LMAILSubmitLocalFile(LMAILConfig * pLMAILCfg, const char *pszMailFile,
  57. long lThreadId, char const *pszSMTPDomain);
  58. static int LMAILAddReceived(FILE * pSpoolFile, char const *pszSMTPDomain,
  59.     char const *pszMailFrom, char const *pszRcptTo, char const *pszTime);
  60. static int LMAILLogMessage(char const *pszMailFile, char const *pszSMTPDomain,
  61.    char const *pszMessageID);
  63. char *LMAILGetSpoolDir(char *pszSpoolPath, int iMaxPath)
  64. {
  66. SvrGetSpoolDir(pszSpoolPath, iMaxPath);
  68. AppendSlash(pszSpoolPath);
  70. StrNCat(pszSpoolPath, LOCAL_SPOOL_DIR, iMaxPath);
  72. return (pszSpoolPath);
  74. }
  76. static LMAILConfig *LMAILGetConfigCopy(SHB_HANDLE hShbLMAIL)
  77. {
  79. LMAILConfig *pLMAILCfg = (LMAILConfig *) ShbLock(hShbLMAIL);
  81. if (pLMAILCfg == NULL)
  82. return (NULL);
  84. LMAILConfig *pNewLMAILCfg = (LMAILConfig *) SysAlloc(sizeof(LMAILConfig));
  86. if (pNewLMAILCfg != NULL)
  87. memcpy(pNewLMAILCfg, pLMAILCfg, sizeof(LMAILConfig));
  89. ShbUnlock(hShbLMAIL);
  91. return (pNewLMAILCfg);
  93. }
  95. static int LMAILThreadCountAdd(long lCount, SHB_HANDLE hShbLMAIL, LMAILConfig * pLMAILCfg)
  96. {
  98. int iDoUnlock = 0;
  100. if (pLMAILCfg == NULL) {
  101. if ((pLMAILCfg = (LMAILConfig *) ShbLock(hShbLMAIL)) == NULL)
  102. return (ErrGetErrorCode());
  104. ++iDoUnlock;
  105. }
  107. pLMAILCfg->lThreadCount += lCount;
  109. if (iDoUnlock)
  110. ShbUnlock(hShbLMAIL);
  112. return (0);
  114. }
  116. static int LMAILLogEnabled(SHB_HANDLE hShbLMAIL, LMAILConfig * pLMAILCfg)
  117. {
  119. int iDoUnlock = 0;
  121. if (pLMAILCfg == NULL) {
  122. if ((pLMAILCfg = (LMAILConfig *) ShbLock(hShbLMAIL)) == NULL)
  123. return (ErrGetErrorCode());
  125. ++iDoUnlock;
  126. }
  128. unsigned long ulFlags = pLMAILCfg->ulFlags;
  130. if (iDoUnlock)
  131. ShbUnlock(hShbLMAIL);
  133. return ((ulFlags & LMAILF_LOG_ENABLED) ? 1 : 0);
  135. }
  137. unsigned int LMAILThreadProc(void *pThreadData)
  138. {
  140. LMAILConfig *pLMAILCfg = (LMAILConfig *) ShbLock(hShbLMAIL);
  142. if (pLMAILCfg == NULL) {
  143. ErrorPush();
  144. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  145. return (ErrorPop());
  146. }
  147. ///////////////////////////////////////////////////////////////////////////////
  148. //  Get thread id and sleep timeout
  149. ///////////////////////////////////////////////////////////////////////////////
  150. int iSleepTimeout = pLMAILCfg->iSleepTimeout;
  151. long lThreadId = pLMAILCfg->lThreadCount;
  153. ///////////////////////////////////////////////////////////////////////////////
  154. //  Increase thread count
  155. ///////////////////////////////////////////////////////////////////////////////
  156. LMAILThreadCountAdd(+1, hShbLMAIL, pLMAILCfg);
  158. ShbUnlock(hShbLMAIL);
  160. SysLogMessage(LOG_LEV_MESSAGE, "LMAIL thread [%02ld] startedn", lThreadId);
  162. for (;;) {
  163. ///////////////////////////////////////////////////////////////////////////////
  164. //  Check shutdown condition
  165. ///////////////////////////////////////////////////////////////////////////////
  166. pLMAILCfg = (LMAILConfig *) ShbLock(hShbLMAIL);
  168. if ((pLMAILCfg == NULL) || (pLMAILCfg->ulFlags & LMAILF_STOP_SERVER)) {
  169. SysLogMessage(LOG_LEV_MESSAGE, "LMAIL thread [%02ld] exitingn",
  170.       lThreadId);
  172. if (pLMAILCfg != NULL)
  173. ShbUnlock(hShbLMAIL);
  174. break;
  175. }
  177. ShbUnlock(hShbLMAIL);
  179. ///////////////////////////////////////////////////////////////////////////////
  180. //  Process local spool files
  181. ///////////////////////////////////////////////////////////////////////////////
  182. int iProcessResult = LMAILProcessLocalSpool(hShbLMAIL, lThreadId);
  184. if (iProcessResult == ERR_NO_LOCAL_SPOOL_FILES)
  185. SysSleep(iSleepTimeout);
  187. }
  189. ///////////////////////////////////////////////////////////////////////////////
  190. //  Decrease thread count
  191. ///////////////////////////////////////////////////////////////////////////////
  192. LMAILThreadCountAdd(-1, hShbLMAIL);
  194. SysLogMessage(LOG_LEV_MESSAGE, "LMAIL thread [%02ld] stoppedn", lThreadId);
  196. return (0);
  198. }
  200. static int LMAILProcessLocalSpool(SHB_HANDLE hShbLMAIL, long lThreadId)
  201. {
  203. LMAILConfig *pLMAILCfg = LMAILGetConfigCopy(hShbLMAIL);
  205. if (pLMAILCfg == NULL)
  206. return (ErrGetErrorCode());
  208. char szSSFileName[SYS_MAX_PATH] = "";
  210. if (LMAILGetFilesSnapShot(pLMAILCfg, lThreadId, szSSFileName) < 0) {
  211. ErrorPush();
  212. SysFree(pLMAILCfg);
  213. return (ErrorPop());
  214. }
  216. if (LMAILProcessList(pLMAILCfg, lThreadId, szSSFileName) < 0) {
  217. ErrorPush();
  218. SysRemove(szSSFileName);
  219. SysFree(pLMAILCfg);
  220. return (ErrorPop());
  221. }
  223. LMAILRemoveProcessed(pLMAILCfg, szSSFileName);
  225. SysRemove(szSSFileName);
  227. SysFree(pLMAILCfg);
  229. return (0);
  231. }
  233. static int LMAILGetFilesSnapShot(LMAILConfig * pLMAILCfg, long lThreadId, char *pszSSFileName)
  234. {
  236. char szSpoolDir[SYS_MAX_PATH] = "";
  238. LMAILGetSpoolDir(szSpoolDir, sizeof(szSpoolDir));
  240. ///////////////////////////////////////////////////////////////////////////////
  241. //  Share lock local spool directory
  242. ///////////////////////////////////////////////////////////////////////////////
  243. char szResLock[SYS_MAX_PATH] = "";
  244. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szSpoolDir, szResLock,
  245.   sizeof(szResLock)));
  247. if (hResLock == INVALID_RLCK_HANDLE)
  248. return (ErrGetErrorCode());
  250. SysGetTmpFile(pszSSFileName);
  252. FILE *pSSFile = fopen(pszSSFileName, "wb");
  254. if (pSSFile == NULL) {
  255. ErrorPush();
  256. RLckUnlockSH(hResLock);
  257. return (ErrorPop());
  258. }
  260. int iFileCount = 0;
  261. char szSpoolFileName[SYS_MAX_PATH] = "";
  262. FSCAN_HANDLE hFileScan = MscFirstFile(szSpoolDir, 0, szSpoolFileName);
  264. if (hFileScan != INVALID_FSCAN_HANDLE) {
  265. do {
  266. SYS_UINT32 uHashValue =
  267.     MscHashString(szSpoolFileName, strlen(szSpoolFileName));
  269. if ((uHashValue % (SYS_UINT32) pLMAILCfg->lNumThreads) ==
  270.     (SYS_UINT32) lThreadId) {
  271. fprintf(pSSFile, "%srn", szSpoolFileName);
  273. ++iFileCount;
  274. }
  276. } while (MscNextFile(hFileScan, szSpoolFileName));
  278. MscCloseFindFile(hFileScan);
  279. }
  281. fclose(pSSFile);
  283. RLckUnlockSH(hResLock);
  285. if (iFileCount == 0) {
  286. SysRemove(pszSSFileName);
  287. SetEmptyString(pszSSFileName);
  289. ErrSetErrorCode(ERR_NO_LOCAL_SPOOL_FILES);
  290. return (ERR_NO_LOCAL_SPOOL_FILES);
  291. }
  293. return (0);
  295. }
  297. static int LMAILRemoveProcessed(LMAILConfig * pLMAILCfg, char const *pszListFileName)
  298. {
  300. char szSpoolDir[SYS_MAX_PATH] = "";
  302. LMAILGetSpoolDir(szSpoolDir, sizeof(szSpoolDir));
  304. ///////////////////////////////////////////////////////////////////////////////
  305. //  Share lock local spool directory
  306. ///////////////////////////////////////////////////////////////////////////////
  307. char szResLock[SYS_MAX_PATH] = "";
  308. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szSpoolDir, szResLock,
  309.   sizeof(szResLock)));
  311. if (hResLock == INVALID_RLCK_HANDLE)
  312. return (ErrGetErrorCode());
  314. FILE *pSSFile = fopen(pszListFileName, "rb");
  316. if (pSSFile == NULL) {
  317. ErrorPush();
  318. RLckUnlockEX(hResLock);
  319. return (ErrorPop());
  320. }
  322. char szSpoolFileName[SYS_MAX_PATH] = "";
  324. while (MscGetString(pSSFile, szSpoolFileName, sizeof(szSpoolFileName) - 1) != NULL) {
  325. char szSpoolFilePath[SYS_MAX_PATH] = "";
  327. sprintf(szSpoolFilePath, "%s%s%s", szSpoolDir, SYS_SLASH_STR, szSpoolFileName);
  329. CheckRemoveFile(szSpoolFilePath);
  330. }
  332. fclose(pSSFile);
  334. RLckUnlockEX(hResLock);
  336. return (0);
  338. }
  340. static int LMAILProcessList(LMAILConfig * pLMAILCfg, long lThreadId, char const *pszSSFileName)
  341. {
  343. char szSpoolDir[SYS_MAX_PATH] = "";
  345. LMAILGetSpoolDir(szSpoolDir, sizeof(szSpoolDir));
  347. ///////////////////////////////////////////////////////////////////////////////
  348. //  Retrieve SMTP domain
  349. ///////////////////////////////////////////////////////////////////////////////
  350. SVRCFG_HANDLE hSvrConfig = SvrGetConfigHandle();
  352. if (hSvrConfig == INVALID_SVRCFG_HANDLE)
  353. return (ErrGetErrorCode());
  355. char szSMTPDomain[MAX_HOST_NAME] = "localdomain";
  356. char *pszDefDomain = SvrGetConfigVar(hSvrConfig, "RootDomain");
  358. if (pszDefDomain != NULL) {
  359. StrSNCpy(szSMTPDomain, pszDefDomain);
  361. SysFree(pszDefDomain);
  362. }
  364. SvrReleaseConfigHandle(hSvrConfig);
  366. FILE *pSSFile = fopen(pszSSFileName, "rb");
  368. if (pSSFile == NULL)
  369. return (ErrGetErrorCode());
  371. char szSpoolFileName[SYS_MAX_PATH] = "";
  373. while (MscGetString(pSSFile, szSpoolFileName, sizeof(szSpoolFileName) - 1) != NULL) {
  374. char szSpoolFilePath[SYS_MAX_PATH] = "";
  376. sprintf(szSpoolFilePath, "%s%s%s", szSpoolDir, SYS_SLASH_STR, szSpoolFileName);
  378. if (LMAILSubmitLocalFile(pLMAILCfg, szSpoolFilePath, lThreadId, szSMTPDomain) < 0) {
  379. SysLogMessage(LOG_LEV_ERROR, "LMAIL [%02ld] error ( "%s" ): %sn",
  380.       lThreadId, ErrGetErrorString(), szSpoolFilePath);
  382. } else {
  383. SysLogMessage(LOG_LEV_MESSAGE, "LMAIL [%02ld] file processed: %sn",
  384.       lThreadId, szSpoolFilePath);
  386. }
  388. }
  390. fclose(pSSFile);
  392. return (0);
  394. }
  396. static int LMAILSubmitLocalFile(LMAILConfig * pLMAILCfg, const char *pszMailFile,
  397. long lThreadId, char const *pszSMTPDomain)
  398. {
  400. FILE *pMailFile = fopen(pszMailFile, "rb");
  402. if (pMailFile == NULL) {
  403. ErrSetErrorCode(ERR_FILE_OPEN);
  404. return (ERR_FILE_OPEN);
  405. }
  406. ///////////////////////////////////////////////////////////////////////////////
  407. //  Get a message ID
  408. ///////////////////////////////////////////////////////////////////////////////
  409. SYS_UINT64 uMessageID;
  410. char szMessageID[128] = "";
  412. if (SvrGetMessageID(&uMessageID) < 0) {
  413. ErrorPush();
  414. fclose(pMailFile);
  415. return (ErrorPop());
  416. }
  418. sprintf(szMessageID, "L" SYS_LLX_FMT, uMessageID);
  420. ///////////////////////////////////////////////////////////////////////////////
  421. //  Get current time
  422. ///////////////////////////////////////////////////////////////////////////////
  423. char szTime[256] = "";
  425. MscGetTimeStr(szTime, sizeof(szTime) - 1);
  427. ///////////////////////////////////////////////////////////////////////////////
  428. //  Log current opeartion
  429. ///////////////////////////////////////////////////////////////////////////////
  430. if (LMAILLogEnabled(SHB_INVALID_HANDLE, pLMAILCfg))
  431. LMAILLogMessage(pszMailFile, pszSMTPDomain, szMessageID);
  433. ///////////////////////////////////////////////////////////////////////////////
  434. //  Search mail data start
  435. ///////////////////////////////////////////////////////////////////////////////
  436. char szSpoolLine[MAX_SPOOL_LINE] = "";
  438. while (MscGetString(pMailFile, szSpoolLine, sizeof(szSpoolLine) - 1) != NULL)
  439. if (IsEmptyString(szSpoolLine))
  440. break;
  442. if (feof(pMailFile)) {
  443. fclose(pMailFile);
  444. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE, pszMailFile);
  445. return (ERR_INVALID_SPOOL_FILE);
  446. }
  447. ///////////////////////////////////////////////////////////////////////////////
  448. //  Get the offset at which the message data begin and rewind the file
  449. ///////////////////////////////////////////////////////////////////////////////
  450. unsigned long ulMsgOffset = (unsigned long) ftell(pMailFile);
  452. rewind(pMailFile);
  454. ///////////////////////////////////////////////////////////////////////////////
  455. //  Read "MAIL FROM:" ( 1th row of the smtp-mail file )
  456. ///////////////////////////////////////////////////////////////////////////////
  457. char szMailFrom[MAX_SPOOL_LINE] = "";
  459. if ((MscGetString(pMailFile, szMailFrom, sizeof(szMailFrom) - 1) == NULL) ||
  460.     (StrINComp(szMailFrom, MAIL_FROM_STR) != 0)) {
  461. fclose(pMailFile);
  462. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE, pszMailFile);
  463. return (ERR_INVALID_SPOOL_FILE);
  464. }
  466. ///////////////////////////////////////////////////////////////////////////////
  467. //  Read "RCPT TO:" ( 2nd[,...] row(s) of the local-mail file )
  468. ///////////////////////////////////////////////////////////////////////////////
  469. while ((MscGetString(pMailFile, szSpoolLine, sizeof(szSpoolLine) - 1) != NULL) &&
  470.        !IsEmptyString(szSpoolLine)) {
  471. ///////////////////////////////////////////////////////////////////////////////
  472. //  Get message handle
  473. ///////////////////////////////////////////////////////////////////////////////
  474. QMSG_HANDLE hMessage = QueCreateMessage(hSpoolQueue);
  476. if (hMessage == INVALID_QMSG_HANDLE) {
  477. ErrorPush();
  478. fclose(pMailFile);
  479. return (ErrorPop());
  480. }
  482. char szQueueFilePath[SYS_MAX_PATH] = "";
  484. QueGetFilePath(hSpoolQueue, hMessage, szQueueFilePath);
  486. FILE *pSpoolFile = fopen(szQueueFilePath, "wb");
  488. if (pSpoolFile == NULL) {
  489. QueCleanupMessage(hSpoolQueue, hMessage);
  490. QueCloseMessage(hSpoolQueue, hMessage);
  491. fclose(pMailFile);
  492. ErrSetErrorCode(ERR_FILE_CREATE);
  493. return (ERR_FILE_CREATE);
  494. }
  495. ///////////////////////////////////////////////////////////////////////////////
  496. //  Write info line
  497. ///////////////////////////////////////////////////////////////////////////////
  498. USmtpWriteInfoLine(pSpoolFile, LOCAL_ADDRESS_SQB ":0",
  499.    LOCAL_ADDRESS_SQB ":0", szTime);
  501. ///////////////////////////////////////////////////////////////////////////////
  502. //  Write SMTP domain
  503. ///////////////////////////////////////////////////////////////////////////////
  504. fprintf(pSpoolFile, "%srn", pszSMTPDomain);
  506. ///////////////////////////////////////////////////////////////////////////////
  507. //  Write message ID
  508. ///////////////////////////////////////////////////////////////////////////////
  509. fprintf(pSpoolFile, "%srn", szMessageID);
  511. ///////////////////////////////////////////////////////////////////////////////
  512. //  Write "MAIL FROM:"
  513. ///////////////////////////////////////////////////////////////////////////////
  514. fprintf(pSpoolFile, "%srn", szMailFrom);
  516. ///////////////////////////////////////////////////////////////////////////////
  517. //  Write "RCPT TO:"
  518. ///////////////////////////////////////////////////////////////////////////////
  519. fprintf(pSpoolFile, "%srn", szSpoolLine);
  521. ///////////////////////////////////////////////////////////////////////////////
  522. //  Write SPOOL_FILE_DATA_START
  523. ///////////////////////////////////////////////////////////////////////////////
  524. fprintf(pSpoolFile, "%srn", SPOOL_FILE_DATA_START);
  526. ///////////////////////////////////////////////////////////////////////////////
  527. //  Write "Received:" tag
  528. ///////////////////////////////////////////////////////////////////////////////
  529. LMAILAddReceived(pSpoolFile, pszSMTPDomain, szMailFrom, szSpoolLine, szTime);
  531. ///////////////////////////////////////////////////////////////////////////////
  532. //  Write mail data, saving and restoring the current file pointer
  533. ///////////////////////////////////////////////////////////////////////////////
  534. unsigned long ulCurrOffset = (unsigned long) ftell(pMailFile);
  536. if (MscCopyFile(pSpoolFile, pMailFile, ulMsgOffset, (unsigned long) -1) < 0) {
  537. ErrorPush();
  538. fclose(pSpoolFile);
  539. QueCleanupMessage(hSpoolQueue, hMessage);
  540. QueCloseMessage(hSpoolQueue, hMessage);
  541. fclose(pMailFile);
  542. return (ErrorPop());
  543. }
  545. if (SysFileSync(pSpoolFile) < 0) {
  546. ErrorPush();
  547. fclose(pSpoolFile);
  548. QueCleanupMessage(hSpoolQueue, hMessage);
  549. QueCloseMessage(hSpoolQueue, hMessage);
  550. fclose(pMailFile);
  551. return (ErrorPop());
  552. }
  554. if (fclose(pSpoolFile)) {
  555. QueCleanupMessage(hSpoolQueue, hMessage);
  556. QueCloseMessage(hSpoolQueue, hMessage);
  557. fclose(pMailFile);
  558. ErrSetErrorCode(ERR_FILE_WRITE, szQueueFilePath);
  559. return (ERR_FILE_WRITE);
  560. }
  562. fseek(pMailFile, ulCurrOffset, SEEK_SET);
  564. ///////////////////////////////////////////////////////////////////////////////
  565. //  Transfer file to the spool
  566. ///////////////////////////////////////////////////////////////////////////////
  567. if (QueCommitMessage(hSpoolQueue, hMessage) < 0) {
  568. ErrorPush();
  569. QueCleanupMessage(hSpoolQueue, hMessage);
  570. QueCloseMessage(hSpoolQueue, hMessage);
  571. fclose(pMailFile);
  572. return (ErrorPop());
  573. }
  574. }
  576. fclose(pMailFile);
  578. return (0);
  580. }
  582. static int LMAILAddReceived(FILE * pSpoolFile, char const *pszSMTPDomain,
  583.     char const *pszMailFrom, char const *pszRcptTo, char const *pszTime)
  584. {
  586. char szFrom[MAX_SMTP_ADDRESS] = "";
  587. char szRcpt[MAX_SMTP_ADDRESS] = "";
  589. if ((USmlParseAddress(pszMailFrom, NULL, 0, szFrom, sizeof(szFrom) - 1) < 0) ||
  590.     (USmlParseAddress(pszRcptTo, NULL, 0, szRcpt, sizeof(szRcpt) - 1) < 0))
  591. return (ErrGetErrorCode());
  593. ///////////////////////////////////////////////////////////////////////////////
  594. //  Add "Received:" tag
  595. ///////////////////////////////////////////////////////////////////////////////
  596. fprintf(pSpoolFile,
  597. "Received: from /spool/localrn"
  598. "tby %s with %srn"
  599. "tfor <%s> from <%s>;rn"
  600. "t%srn", pszSMTPDomain, LMAIL_SERVER_NAME, szRcpt, szFrom, pszTime);
  602. return (0);
  604. }
  606. static int LMAILLogMessage(char const *pszMailFile, char const *pszSMTPDomain,
  607.    char const *pszMessageID)
  608. {
  610. char szTime[256] = "";
  612. MscGetTimeNbrString(szTime, sizeof(szTime) - 1);
  614. char szLocalFile[SYS_MAX_PATH] = "";
  616. MscGetFileName(pszMailFile, szLocalFile);
  618. RLCK_HANDLE hResLock = RLckLockEX(SVR_LOGS_DIR SYS_SLASH_STR LMAIL_LOG_FILE);
  620. if (hResLock == INVALID_RLCK_HANDLE)
  621. return (ErrGetErrorCode());
  623. MscFileLog(LMAIL_LOG_FILE,
  624.    ""%s""
  625.    "t"%s""
  626.    "t"%s"" "t"%s"" "n", pszSMTPDomain, szLocalFile, pszMessageID, szTime);
  628. RLckUnlockEX(hResLock);
  630. return (0);
  632. }