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

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

Email服务器

开发平台：

Visual C++

QueueUtils.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 "ShBlocks.h"
  27. #include "ResLocks.h"
  28. #include "StrUtils.h"
  29. #include "SList.h"
  30. #include "MD5.h"
  31. #include "Base64Enc.h"
  32. #include "BuffSock.h"
  33. #include "MessQueue.h"
  34. #include "MailConfig.h"
  35. #include "UsrUtils.h"
  36. #include "SvrUtils.h"
  37. #include "AppDefines.h"
  38. #include "MailSvr.h"
  39. #include "MiscUtils.h"
  40. #include "SMTPUtils.h"
  41. #include "SMAILUtils.h"
  42. #include "QueueUtils.h"
  44. #define QUE_SMTP_MAILER_ERROR_HDR   "X-MailerError"
  45. #define QUE_MAILER_HDR              "X-MailerServer"
  47. static int QueUtDumpFrozen(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, FILE * pListFile);
  48. static char *QueUtGetLogEntryVar(char const *pszLog, char const *pszVarName);
  49. static char *QueUtGetReplyAddress(SPLF_HANDLE hFSpool);
  50. static int QueUtTXErrorNotifySender(SPLF_HANDLE hFSpool, char const *pszAdminAddrVar,
  51.     char const *pszReason, char const *pszText,
  52.     char const *pszServer, char const *pszLogFile);
  53. static int QueUtTXErrorExNotifySender(SPLF_HANDLE hFSpool, char const *pszMessFilePath,
  54.       char const *pszAdminAddrVar, char const *pszReason,
  55.       char const *pszText, char const *pszServer,
  56.       char const *pszLogFile);
  57. static int QueUtTXErrorNotifyRoot(SPLF_HANDLE hFSpool, char const *pszReason,
  58.   char const *pszLogFile);
  59. static int QueUtTXErrorExNotifyRoot(SPLF_HANDLE hFSpool, char const *pszMessFilePath,
  60.     char const *pszReason, char const *pszLogFile);
  61. static int QueUtBuildErrorRespose(char const *pszSMTPDomain, SPLF_HANDLE hFSpool,
  62.   char const *pszFrom, char const *pszSmtpFrom, char const *pszTo,
  63.   char const *pszResponseFile, char const *pszReason,
  64.   char const *pszText, char const *pszServer, int iLinesExtra,
  65.   char const *pszLogFile);
  67. static int QueUtDumpFrozen(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, FILE * pListFile)
  68. {
  69. ///////////////////////////////////////////////////////////////////////////////
  70. //  Get message file path
  71. ///////////////////////////////////////////////////////////////////////////////
  72. char szQueueFilePath[SYS_MAX_PATH] = "";
  74. QueGetFilePath(hQueue, hMessage, szQueueFilePath);
  76. ///////////////////////////////////////////////////////////////////////////////
  77. //  Load spool file info and make a type check
  78. ///////////////////////////////////////////////////////////////////////////////
  79. SYS_FILE_INFO FI;
  81. if (SysGetFileInfo(szQueueFilePath, FI) < 0)
  82. return (ErrGetErrorCode());
  84. ///////////////////////////////////////////////////////////////////////////////
  85. //  Load the spool file header
  86. ///////////////////////////////////////////////////////////////////////////////
  87. SpoolFileHeader SFH;
  89. if (USmlLoadSpoolFileHeader(szQueueFilePath, SFH) < 0)
  90. return (ErrGetErrorCode());
  92. char *pszFrom = USmlAddrConcat(SFH.ppszFrom);
  94. if (pszFrom == NULL) {
  95. ErrorPush();
  96. USmlCleanupSpoolFileHeader(SFH);
  97. return (ErrorPop());
  98. }
  100. char *pszRcpt = USmlAddrConcat(SFH.ppszRcpt);
  102. if (pszRcpt == NULL) {
  103. ErrorPush();
  104. SysFree(pszFrom);
  105. USmlCleanupSpoolFileHeader(SFH);
  106. return (ErrorPop());
  107. }
  109. char szTime[128] = "";
  111. MscGetTimeNbrString(szTime, sizeof(szTime) - 1, FI.tMod);
  113. fprintf(pListFile,
  114. ""%s"t"
  115. ""%d"t"
  116. ""%d"t"
  117. ""<%s>"t"
  118. ""<%s>"t"
  119. ""%s"t"
  120. ""%lu"n",
  121. QueGetFileName(hMessage), QueGetLevel1(hMessage), QueGetLevel2(hMessage),
  122. pszFrom, pszRcpt, szTime, FI.ulSize);
  124. SysFree(pszRcpt);
  125. SysFree(pszFrom);
  127. USmlCleanupSpoolFileHeader(SFH);
  129. return (0);
  131. }
  133. int QueUtGetFrozenList(QUEUE_HANDLE hQueue, char const *pszListFile)
  134. {
  136. int iNumDirsLevel = QueGetDirsLevel(hQueue);
  137. char const *pszRootPath = QueGetRootPath(hQueue);
  139. ///////////////////////////////////////////////////////////////////////////////
  140. //  Creates the list file and start scanning the frozen queue
  141. ///////////////////////////////////////////////////////////////////////////////
  142. FILE *pListFile = fopen(pszListFile, "wt");
  144. if (pListFile == NULL) {
  145. ErrSetErrorCode(ERR_FILE_CREATE, pszListFile);
  146. return (ERR_FILE_CREATE);
  147. }
  149. for (int ii = 0; ii < iNumDirsLevel; ii++) {
  150. for (int jj = 0; jj < iNumDirsLevel; jj++) {
  151. char szCurrPath[SYS_MAX_PATH] = "";
  153. sprintf(szCurrPath, "%s%d%s%d%s%s",
  154. pszRootPath, ii, SYS_SLASH_STR, jj, SYS_SLASH_STR,
  155. QUEUE_FROZ_DIR);
  157. char szFrozFileName[SYS_MAX_PATH] = "";
  158. FSCAN_HANDLE hFileScan = MscFirstFile(szCurrPath, 0, szFrozFileName);
  160. if (hFileScan != INVALID_FSCAN_HANDLE) {
  161. do {
  162. if (!SYS_IS_VALID_FILENAME(szFrozFileName))
  163. continue;
  165. ///////////////////////////////////////////////////////////////////////////////
  166. //  Create queue file handle
  167. ///////////////////////////////////////////////////////////////////////////////
  168. QMSG_HANDLE hMessage =
  169.     QueGetHandle(hQueue, ii, jj, QUEUE_FROZ_DIR,
  170.  szFrozFileName);
  172. if (hMessage != INVALID_QMSG_HANDLE) {
  173. QueUtDumpFrozen(hQueue, hMessage, pListFile);
  175. QueCloseMessage(hQueue, hMessage);
  176. }
  178. } while (MscNextFile(hFileScan, szFrozFileName));
  180. MscCloseFindFile(hFileScan);
  181. }
  183. }
  184. }
  186. fclose(pListFile);
  188. return (0);
  190. }
  192. int QueUtUnFreezeMessage(QUEUE_HANDLE hQueue, int iLevel1, int iLevel2,
  193.  char const *pszMessageFile)
  194. {
  195. ///////////////////////////////////////////////////////////////////////////////
  196. //  Create queue file handle
  197. ///////////////////////////////////////////////////////////////////////////////
  198. QMSG_HANDLE hMessage = QueGetHandle(hQueue, iLevel1, iLevel2, QUEUE_FROZ_DIR,
  199.     pszMessageFile);
  201. if (hMessage == INVALID_QMSG_HANDLE)
  202. return (ErrGetErrorCode());
  204. ///////////////////////////////////////////////////////////////////////////////
  205. //  Init message statistics
  206. ///////////////////////////////////////////////////////////////////////////////
  207. QueInitMessageStats(hQueue, hMessage);
  209. ///////////////////////////////////////////////////////////////////////////////
  210. //  Try to re-commit the frozen message
  211. ///////////////////////////////////////////////////////////////////////////////
  212. if (QueCommitMessage(hQueue, hMessage) < 0) {
  213. ErrorPush();
  214. QueCloseMessage(hQueue, hMessage);
  215. return (ErrorPop());
  216. }
  218. return (0);
  220. }
  222. int QueUtDeleteFrozenMessage(QUEUE_HANDLE hQueue, int iLevel1, int iLevel2,
  223.      char const *pszMessageFile)
  224. {
  225. ///////////////////////////////////////////////////////////////////////////////
  226. //  Create queue file handle
  227. ///////////////////////////////////////////////////////////////////////////////
  228. QMSG_HANDLE hMessage = QueGetHandle(hQueue, iLevel1, iLevel2, QUEUE_FROZ_DIR,
  229.     pszMessageFile);
  231. if (hMessage == INVALID_QMSG_HANDLE)
  232. return (ErrGetErrorCode());
  234. QueCleanupMessage(hQueue, hMessage);
  236. QueCloseMessage(hQueue, hMessage);
  238. return (0);
  240. }
  242. int QueUtGetFrozenMsgFile(QUEUE_HANDLE hQueue, int iLevel1, int iLevel2,
  243.   char const *pszMessageFile, char const *pszOutFile)
  244. {
  245. ///////////////////////////////////////////////////////////////////////////////
  246. //  Create queue file handle
  247. ///////////////////////////////////////////////////////////////////////////////
  248. QMSG_HANDLE hMessage = QueGetHandle(hQueue, iLevel1, iLevel2, QUEUE_FROZ_DIR,
  249.     pszMessageFile);
  251. if (hMessage == INVALID_QMSG_HANDLE)
  252. return (ErrGetErrorCode());
  254. ///////////////////////////////////////////////////////////////////////////////
  255. //  Get slog file path
  256. ///////////////////////////////////////////////////////////////////////////////
  257. char szQueueFilePath[SYS_MAX_PATH] = "";
  259. QueGetFilePath(hQueue, hMessage, szQueueFilePath);
  261. ///////////////////////////////////////////////////////////////////////////////
  262. //  Copy the requested file
  263. ///////////////////////////////////////////////////////////////////////////////
  264. if (MscCopyFile(pszOutFile, szQueueFilePath) < 0) {
  265. ErrorPush();
  266. QueCloseMessage(hQueue, hMessage);
  267. return (ErrorPop());
  268. }
  270. QueCloseMessage(hQueue, hMessage);
  272. return (0);
  274. }
  276. int QueUtGetFrozenLogFile(QUEUE_HANDLE hQueue, int iLevel1, int iLevel2,
  277.   char const *pszMessageFile, char const *pszOutFile)
  278. {
  279. ///////////////////////////////////////////////////////////////////////////////
  280. //  Create queue file handle
  281. ///////////////////////////////////////////////////////////////////////////////
  282. QMSG_HANDLE hMessage = QueGetHandle(hQueue, iLevel1, iLevel2, QUEUE_FROZ_DIR,
  283.     pszMessageFile);
  285. if (hMessage == INVALID_QMSG_HANDLE)
  286. return (ErrGetErrorCode());
  288. ///////////////////////////////////////////////////////////////////////////////
  289. //  Get slog file path
  290. ///////////////////////////////////////////////////////////////////////////////
  291. char szQueueFilePath[SYS_MAX_PATH] = "";
  293. QueGetFilePath(hQueue, hMessage, szQueueFilePath, QUEUE_SLOG_DIR);
  295. ///////////////////////////////////////////////////////////////////////////////
  296. //  Copy the requested file
  297. ///////////////////////////////////////////////////////////////////////////////
  298. if (MscCopyFile(pszOutFile, szQueueFilePath) < 0) {
  299. ErrorPush();
  300. QueCloseMessage(hQueue, hMessage);
  301. return (ErrorPop());
  302. }
  304. QueCloseMessage(hQueue, hMessage);
  306. return (0);
  308. }
  310. int QueUtErrLogMessage(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, char const *pszFormat, ...)
  311. {
  312. ///////////////////////////////////////////////////////////////////////////////
  313. //  Get slog file path
  314. ///////////////////////////////////////////////////////////////////////////////
  315. char szSlogFilePath[SYS_MAX_PATH] = "";
  317. QueGetFilePath(hQueue, hMessage, szSlogFilePath, QUEUE_SLOG_DIR);
  319. char *pszMessage = NULL;
  321. STRSPRINTF(pszMessage, pszFormat, pszFormat);
  323. if (pszMessage == NULL)
  324. return (ErrGetErrorCode());
  326. if (ErrFileLogString(szSlogFilePath, pszMessage) < 0) {
  327. SysFree(pszMessage);
  328. return (ErrGetErrorCode());
  329. }
  331. SysFree(pszMessage);
  333. return (0);
  335. }
  337. static char *QueUtGetLogEntryVar(char const *pszLog, char const *pszVarName)
  338. {
  340. char const *pszEPos;
  341. char const *pszEnd;
  343. if (((pszEPos = strstr(pszLog, pszVarName)) == NULL) ||
  344.     ((pszEPos = strchr(pszEPos, '=')) == NULL))
  345. return (NULL);
  347. ++pszEPos;
  348. StrSkipSpaces(pszEPos);
  350. if (((pszEnd = strchr(pszEPos, 'r')) == NULL) &&
  351.     ((pszEnd = strchr(pszEPos, 'n')) == NULL))
  352. pszEnd = pszEPos + strlen(pszEPos);
  354. if (*pszEPos == '"') {
  355. ++pszEPos;
  356. if (pszEnd[-1] == '"')
  357. pszEnd--;
  358. }
  360. int iVarLength = (int) (pszEnd - pszEPos);
  362. if (iVarLength <= 0)
  363. return (NULL);
  365. char *pszVarValue = (char *) SysAlloc(iVarLength + 1);
  367. if (pszVarValue != NULL) {
  368. memcpy(pszVarValue, pszEPos, iVarLength);
  369. pszVarValue[iVarLength] = '';
  370. }
  372. return (pszVarValue);
  374. }
  376. int QueUtGetLastLogInfo(char const *pszLogFilePath, QueLogInfo * pQLI)
  377. {
  379. char *pszEntry = QueLoadLastLogEntry(pszLogFilePath);
  381. pQLI->pszReason = pQLI->pszServer = NULL;
  383. if (pszEntry == NULL)
  384. return (ErrGetErrorCode());
  386. pQLI->pszReason = QueUtGetLogEntryVar(pszEntry, SMTP_ERROR_VARNAME);
  387. pQLI->pszServer = QueUtGetLogEntryVar(pszEntry, SMTP_SERVER_VARNAME);
  389. SysFree(pszEntry);
  391. return (0);
  393. }
  395. void QueUtFreeLastLogInfo(QueLogInfo * pQLI)
  396. {
  398. if (pQLI->pszServer != NULL)
  399. SysFree(pQLI->pszServer);
  401. if (pQLI->pszReason != NULL)
  402. SysFree(pQLI->pszReason);
  404. }
  406. bool QueUtRemoveSpoolErrors(void)
  407. {
  409. return (SvrTestConfigFlag("RemoveSpoolErrors", false));
  411. }
  413. int QueUtNotifyPermErrDelivery(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage,
  414.        SPLF_HANDLE hFSpool, char const *pszReason,
  415.        char const *pszServer, bool bCleanup)
  416. {
  417. ///////////////////////////////////////////////////////////////////////////////
  418. //  Get message file path
  419. ///////////////////////////////////////////////////////////////////////////////
  420. char szQueueFilePath[SYS_MAX_PATH] = "";
  421. char szQueueLogFilePath[SYS_MAX_PATH] = "";
  423. QueGetFilePath(hQueue, hMessage, szQueueFilePath);
  424. QueGetFilePath(hQueue, hMessage, szQueueLogFilePath, QUEUE_SLOG_DIR);
  426. ///////////////////////////////////////////////////////////////////////////////
  427. //  Load log information from the slog file
  428. ///////////////////////////////////////////////////////////////////////////////
  429. bool bFreeLogInfo = false;
  430. QueLogInfo QLI;
  432. if ((pszReason == NULL) || (pszServer == NULL)) {
  433. QueUtGetLastLogInfo(szQueueLogFilePath, &QLI);
  435. if (pszReason == NULL)
  436. pszReason = QLI.pszReason;
  438. if (pszServer == NULL)
  439. pszServer = QLI.pszServer;
  441. bFreeLogInfo = true;
  442. }
  444. int iNotifyResult = QueUtTXErrorExNotifySender(hFSpool, szQueueFilePath,
  445.        "ErrorsAdmin", pszReason, NULL,
  446.        pszServer, szQueueLogFilePath);
  448. if (bCleanup)
  449. QueCleanupMessage(hQueue, hMessage, !QueUtRemoveSpoolErrors());
  451. if (bFreeLogInfo)
  452. QueUtFreeLastLogInfo(&QLI);
  454. return (0);
  456. }
  458. int QueUtNotifyTempErrDelivery(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage,
  459.        SPLF_HANDLE hFSpool, char const *pszReason,
  460.        char const *pszText, char const *pszServer)
  461. {
  462. ///////////////////////////////////////////////////////////////////////////////
  463. //  Get message file path
  464. ///////////////////////////////////////////////////////////////////////////////
  465. char szQueueLogFilePath[SYS_MAX_PATH] = "";
  467. QueGetFilePath(hQueue, hMessage, szQueueLogFilePath, QUEUE_SLOG_DIR);
  469. ///////////////////////////////////////////////////////////////////////////////
  470. //  Load log information from the slog file
  471. ///////////////////////////////////////////////////////////////////////////////
  472. bool bFreeLogInfo = false;
  473. QueLogInfo QLI;
  475. if ((pszReason == NULL) || (pszServer == NULL)) {
  476. QueUtGetLastLogInfo(szQueueLogFilePath, &QLI);
  478. if (pszReason == NULL)
  479. pszReason = QLI.pszReason;
  481. if (pszServer == NULL)
  482. pszServer = QLI.pszServer;
  484. bFreeLogInfo = true;
  485. }
  487. int iNotifyResult = QueUtTXErrorNotifySender(hFSpool, "TempErrorsAdmin",
  488.      pszReason, pszText, pszServer,
  489.      szQueueLogFilePath);
  491. if (bFreeLogInfo)
  492. QueUtFreeLastLogInfo(&QLI);
  494. return (iNotifyResult);
  496. }
  498. int QueUtCleanupNotifyRoot(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage,
  499.    SPLF_HANDLE hFSpool, char const *pszReason)
  500. {
  501. ///////////////////////////////////////////////////////////////////////////////
  502. //  Get message file path
  503. ///////////////////////////////////////////////////////////////////////////////
  504. char szQueueFilePath[SYS_MAX_PATH] = "";
  505. char szQueueLogFilePath[SYS_MAX_PATH] = "";
  507. QueGetFilePath(hQueue, hMessage, szQueueFilePath);
  508. QueGetFilePath(hQueue, hMessage, szQueueLogFilePath, QUEUE_SLOG_DIR);
  510. ///////////////////////////////////////////////////////////////////////////////
  511. //  Load log information from the slog file
  512. ///////////////////////////////////////////////////////////////////////////////
  513. bool bFreeLogInfo = false;
  514. QueLogInfo QLI;
  516. if (pszReason == NULL) {
  517. QueUtGetLastLogInfo(szQueueLogFilePath, &QLI);
  519. pszReason = QLI.pszReason;
  521. bFreeLogInfo = true;
  522. }
  524. int iNotifyResult = QueUtTXErrorExNotifyRoot(hFSpool, szQueueFilePath, pszReason,
  525.      szQueueLogFilePath);
  527. if (bFreeLogInfo)
  528. QueUtFreeLastLogInfo(&QLI);
  530. QueCleanupMessage(hQueue, hMessage, !QueUtRemoveSpoolErrors());
  532. return (0);
  534. }
  536. static char *QueUtGetReplyAddress(SPLF_HANDLE hFSpool)
  537. {
  538. ///////////////////////////////////////////////////////////////////////////////
  539. //  Extract the sender
  540. ///////////////////////////////////////////////////////////////////////////////
  541. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  542. int iFromDomains = StrStringsCount(ppszFrom);
  544. if (iFromDomains == 0) {
  545. ErrSetErrorCode(ERR_NULL_SENDER);
  546. return (NULL);
  547. }
  549. char const *pszSender = ppszFrom[iFromDomains - 1];
  550. char szSenderDomain[MAX_ADDR_NAME] = "";
  551. char szSenderName[MAX_ADDR_NAME] = "";
  553. if (USmtpSplitEmailAddr(pszSender, szSenderName, szSenderDomain) < 0)
  554. return (SysStrDup(pszSender));
  556. ///////////////////////////////////////////////////////////////////////////////
  557. //  Lookup special reply-to header tags
  558. ///////////////////////////////////////////////////////////////////////////////
  560. return (SysStrDup(pszSender));
  562. }
  564. static int QueUtTXErrorNotifySender(SPLF_HANDLE hFSpool, char const *pszAdminAddrVar,
  565.     char const *pszReason, char const *pszText,
  566.     char const *pszServer, char const *pszLogFile)
  567. {
  568. ///////////////////////////////////////////////////////////////////////////////
  569. //  Extract the sender
  570. ///////////////////////////////////////////////////////////////////////////////
  571. char *pszReplyTo = QueUtGetReplyAddress(hFSpool);
  573. if (pszReplyTo == NULL)
  574. return (ErrGetErrorCode());
  576. ///////////////////////////////////////////////////////////////////////////////
  577. //  Load configuration handle
  578. ///////////////////////////////////////////////////////////////////////////////
  579. SVRCFG_HANDLE hSvrConfig = SvrGetConfigHandle();
  581. if (hSvrConfig == INVALID_SVRCFG_HANDLE) {
  582. ErrorPush();
  583. SysFree(pszReplyTo);
  584. return (ErrorPop());
  585. }
  587. char szPMAddress[MAX_ADDR_NAME] = "";
  588. char szMailDomain[MAX_HOST_NAME] = "";
  590. if ((SvrConfigVar("PostMaster", szPMAddress, sizeof(szPMAddress) - 1, hSvrConfig) < 0) ||
  591.     (SvrConfigVar("RootDomain", szMailDomain, sizeof(szMailDomain) - 1, hSvrConfig) < 0))
  592. {
  593. SvrReleaseConfigHandle(hSvrConfig);
  594. SysFree(pszReplyTo);
  596. ErrSetErrorCode(ERR_INCOMPLETE_CONFIG);
  597. return (ERR_INCOMPLETE_CONFIG);
  598. }
  599. ///////////////////////////////////////////////////////////////////////////////
  600. //  Get message handle
  601. ///////////////////////////////////////////////////////////////////////////////
  602. int iMsgLinesExtra = SvrGetConfigInt("NotifyMsgLinesExtra", 0, hSvrConfig);
  603. bool bSenderLog = SvrTestConfigFlag("NotifySendLogToSender", false, hSvrConfig);
  604. bool bNoSenderBounce = SvrTestConfigFlag("NoSenderBounce", false, hSvrConfig);
  605. QMSG_HANDLE hMessage = QueCreateMessage(hSpoolQueue);
  607. if (hMessage == INVALID_QMSG_HANDLE) {
  608. ErrorPush();
  609. SvrReleaseConfigHandle(hSvrConfig);
  610. SysFree(pszReplyTo);
  611. return (ErrorPop());
  612. }
  614. char szQueueFilePath[SYS_MAX_PATH] = "";
  616. QueGetFilePath(hSpoolQueue, hMessage, szQueueFilePath);
  618. ///////////////////////////////////////////////////////////////////////////////
  619. //  Build error response mail file
  620. ///////////////////////////////////////////////////////////////////////////////
  621. if (QueUtBuildErrorRespose(szMailDomain, hFSpool, szPMAddress,
  622.    bNoSenderBounce ? "": szPMAddress, pszReplyTo,
  623.    szQueueFilePath, pszReason, pszText, pszServer,
  624.    iMsgLinesExtra, bSenderLog ? pszLogFile : NULL) < 0) {
  625. ErrorPush();
  626. QueCleanupMessage(hSpoolQueue, hMessage);
  627. QueCloseMessage(hSpoolQueue, hMessage);
  628. SvrReleaseConfigHandle(hSvrConfig);
  629. SysFree(pszReplyTo);
  630. return (ErrorPop());
  631. }
  633. SysFree(pszReplyTo);
  635. ///////////////////////////////////////////////////////////////////////////////
  636. //  Send error response mail file
  637. ///////////////////////////////////////////////////////////////////////////////
  638. if (QueCommitMessage(hSpoolQueue, hMessage) < 0) {
  639. ErrorPush();
  640. QueCleanupMessage(hSpoolQueue, hMessage);
  641. QueCloseMessage(hSpoolQueue, hMessage);
  642. SvrReleaseConfigHandle(hSvrConfig);
  643. return (ErrorPop());
  644. }
  646. ///////////////////////////////////////////////////////////////////////////////
  647. //  Notify "error-handler" admin
  648. ///////////////////////////////////////////////////////////////////////////////
  649. char szEHAdmin[MAX_ADDR_NAME] = "";
  651. if ((SvrConfigVar(pszAdminAddrVar, szEHAdmin, sizeof(szEHAdmin) - 1, hSvrConfig) == 0) &&
  652.     !IsEmptyString(szEHAdmin)) {
  653. ///////////////////////////////////////////////////////////////////////////////
  654. //  Get message handle
  655. ///////////////////////////////////////////////////////////////////////////////
  656. if ((hMessage = QueCreateMessage(hSpoolQueue)) == INVALID_QMSG_HANDLE) {
  657. ErrorPush();
  658. SvrReleaseConfigHandle(hSvrConfig);
  659. return (ErrorPop());
  660. }
  662. QueGetFilePath(hSpoolQueue, hMessage, szQueueFilePath);
  664. ///////////////////////////////////////////////////////////////////////////////
  665. //  Build error response mail file
  666. ///////////////////////////////////////////////////////////////////////////////
  667. if (QueUtBuildErrorRespose(szMailDomain, hFSpool, szPMAddress,
  668.    bNoSenderBounce ? "": szPMAddress, szEHAdmin,
  669.    szQueueFilePath, pszReason, pszText,
  670.    pszServer, iMsgLinesExtra, pszLogFile) < 0) {
  671. ErrorPush();
  672. QueCleanupMessage(hSpoolQueue, hMessage);
  673. QueCloseMessage(hSpoolQueue, hMessage);
  674. SvrReleaseConfigHandle(hSvrConfig);
  675. return (ErrorPop());
  676. }
  677. ///////////////////////////////////////////////////////////////////////////////
  678. //  Send error response mail file
  679. ///////////////////////////////////////////////////////////////////////////////
  680. if (QueCommitMessage(hSpoolQueue, hMessage) < 0) {
  681. ErrorPush();
  682. QueCleanupMessage(hSpoolQueue, hMessage);
  683. QueCloseMessage(hSpoolQueue, hMessage);
  684. SvrReleaseConfigHandle(hSvrConfig);
  685. return (ErrorPop());
  686. }
  688. }
  690. SvrReleaseConfigHandle(hSvrConfig);
  692. return (0);
  694. }
  696. static int QueUtTXErrorExNotifySender(SPLF_HANDLE hFSpool, char const *pszMessFilePath,
  697.       char const *pszAdminAddrVar, char const *pszReason,
  698.       char const *pszText, char const *pszServer,
  699.       char const *pszLogFile)
  700. {
  702. bool bCloseHSpool = false;
  704. if (hFSpool == INVALID_SPLF_HANDLE) {
  705. if ((hFSpool = USmlCreateHandle(pszMessFilePath)) == INVALID_SPLF_HANDLE)
  706. return (ErrGetErrorCode());
  708. bCloseHSpool = true;
  709. }
  711. int iNotifyResult = QueUtTXErrorNotifySender(hFSpool, pszAdminAddrVar, pszReason,
  712.      pszText, pszServer, pszLogFile);
  714. if (bCloseHSpool)
  715. USmlCloseHandle(hFSpool);
  717. return (iNotifyResult);
  719. }
  721. static int QueUtTXErrorNotifyRoot(SPLF_HANDLE hFSpool, char const *pszReason,
  722.   char const *pszLogFile)
  723. {
  724. ///////////////////////////////////////////////////////////////////////////////
  725. //  Load configuration handle
  726. ///////////////////////////////////////////////////////////////////////////////
  727. SVRCFG_HANDLE hSvrConfig = SvrGetConfigHandle();
  729. if (hSvrConfig == INVALID_SVRCFG_HANDLE)
  730. return (ErrGetErrorCode());
  732. char szPMAddress[MAX_ADDR_NAME] = "";
  733. char szMailDomain[MAX_HOST_NAME] = "";
  735. if ((SvrConfigVar("PostMaster", szPMAddress, sizeof(szPMAddress) - 1, hSvrConfig) < 0) ||
  736.     (SvrConfigVar("RootDomain", szMailDomain, sizeof(szMailDomain) - 1, hSvrConfig) < 0))
  737. {
  738. SvrReleaseConfigHandle(hSvrConfig);
  740. ErrSetErrorCode(ERR_INCOMPLETE_CONFIG);
  741. return (ERR_INCOMPLETE_CONFIG);
  742. }
  743. ///////////////////////////////////////////////////////////////////////////////
  744. //  Get message handle
  745. ///////////////////////////////////////////////////////////////////////////////
  746. int iMsgLinesExtra = SvrGetConfigInt("NotifyMsgLinesExtra", 0, hSvrConfig);
  747. QMSG_HANDLE hMessage = QueCreateMessage(hSpoolQueue);
  749. if (hMessage == INVALID_QMSG_HANDLE) {
  750. ErrorPush();
  751. SvrReleaseConfigHandle(hSvrConfig);
  752. return (ErrorPop());
  753. }
  755. char szQueueFilePath[SYS_MAX_PATH] = "";
  757. QueGetFilePath(hSpoolQueue, hMessage, szQueueFilePath);
  759. ///////////////////////////////////////////////////////////////////////////////
  760. //  Build error response mail file
  761. ///////////////////////////////////////////////////////////////////////////////
  762. if (QueUtBuildErrorRespose(szMailDomain, hFSpool, szPMAddress, szPMAddress,
  763.    szPMAddress, szQueueFilePath, pszReason, NULL, NULL,
  764.    iMsgLinesExtra, pszLogFile) < 0) {
  765. ErrorPush();
  766. QueCleanupMessage(hSpoolQueue, hMessage);
  767. QueCloseMessage(hSpoolQueue, hMessage);
  768. SvrReleaseConfigHandle(hSvrConfig);
  769. return (ErrorPop());
  770. }
  772. SvrReleaseConfigHandle(hSvrConfig);
  774. ///////////////////////////////////////////////////////////////////////////////
  775. //  Send error response mail file
  776. ///////////////////////////////////////////////////////////////////////////////
  777. if (QueCommitMessage(hSpoolQueue, hMessage) < 0) {
  778. ErrorPush();
  779. QueCleanupMessage(hSpoolQueue, hMessage);
  780. QueCloseMessage(hSpoolQueue, hMessage);
  781. return (ErrorPop());
  782. }
  784. return (0);
  786. }
  788. static int QueUtTXErrorExNotifyRoot(SPLF_HANDLE hFSpool, char const *pszMessFilePath,
  789.     char const *pszReason, char const *pszLogFile)
  790. {
  792. bool bCloseHSpool = false;
  794. if (hFSpool == INVALID_SPLF_HANDLE) {
  795. if ((hFSpool = USmlCreateHandle(pszMessFilePath)) == INVALID_SPLF_HANDLE)
  796. return (ErrGetErrorCode());
  798. bCloseHSpool = true;
  799. }
  801. int iNotifyResult = QueUtTXErrorNotifyRoot(hFSpool, pszReason, pszLogFile);
  803. if (bCloseHSpool)
  804. USmlCloseHandle(hFSpool);
  806. return (iNotifyResult);
  808. }
  810. static int QueUtBuildErrorRespose(char const *pszSMTPDomain, SPLF_HANDLE hFSpool,
  811.   char const *pszFrom, char const *pszSmtpFrom, char const *pszTo,
  812.   char const *pszResponseFile, char const *pszReason,
  813.   char const *pszText, char const *pszServer, int iLinesExtra,
  814.   char const *pszLogFile)
  815. {
  817. char const *pszSpoolFileName = USmlGetSpoolFile(hFSpool);
  818. char const *pszSmtpMsgID = USmlGetSmtpMessageID(hFSpool);
  820. ///////////////////////////////////////////////////////////////////////////////
  821. //  Retrieve a new message ID
  822. ///////////////////////////////////////////////////////////////////////////////
  823. SYS_UINT64 ullMessageID = 0;
  825. if (SvrGetMessageID(&ullMessageID) < 0)
  826. return (ErrGetErrorCode());
  828. FILE *pRespFile = fopen(pszResponseFile, "wb");
  830. if (pRespFile == NULL) {
  831. ErrSetErrorCode(ERR_FILE_CREATE);
  832. return (ERR_FILE_CREATE);
  833. }
  834. ///////////////////////////////////////////////////////////////////////////////
  835. //  Try to remap target user address
  836. ///////////////////////////////////////////////////////////////////////////////
  837. char szDomain[MAX_ADDR_NAME] = "";
  838. char szName[MAX_ADDR_NAME] = "";
  839. char szTo[MAX_ADDR_NAME] = "";
  841. if (USmlMapAddress(pszTo, szDomain, szName) < 0)
  842. StrSNCpy(szTo, pszTo);
  843. else
  844. SysSNPrintf(szTo, sizeof(szTo) - 1, "%s@%s", szName, szDomain);
  846. ///////////////////////////////////////////////////////////////////////////////
  847. //  Get the current time string
  848. ///////////////////////////////////////////////////////////////////////////////
  849. char szTime[128] = "";
  851. MscGetTimeStr(szTime, sizeof(szTime) - 1);
  853. ///////////////////////////////////////////////////////////////////////////////
  854. //  Write info line
  855. ///////////////////////////////////////////////////////////////////////////////
  856. USmtpWriteInfoLine(pRespFile, LOCAL_ADDRESS_SQB ":0",
  857.    LOCAL_ADDRESS_SQB ":0", szTime);
  859. ///////////////////////////////////////////////////////////////////////////////
  860. //  Write domain
  861. ///////////////////////////////////////////////////////////////////////////////
  862. fprintf(pRespFile, "%srn", pszSMTPDomain);
  864. ///////////////////////////////////////////////////////////////////////////////
  865. //  Write message ID
  866. ///////////////////////////////////////////////////////////////////////////////
  867. fprintf(pRespFile, "X" SYS_LLX_FMT "rn", ullMessageID);
  869. ///////////////////////////////////////////////////////////////////////////////
  870. //  Write MAIL FROM
  871. ///////////////////////////////////////////////////////////////////////////////
  872. fprintf(pRespFile, "MAIL FROM:<%s>rn", pszSmtpFrom);
  874. ///////////////////////////////////////////////////////////////////////////////
  875. //  Write RCPT TO
  876. ///////////////////////////////////////////////////////////////////////////////
  877. fprintf(pRespFile, "RCPT TO:<%s>rn", szTo);
  879. ///////////////////////////////////////////////////////////////////////////////
  880. //  Write SPOOL_FILE_DATA_START
  881. ///////////////////////////////////////////////////////////////////////////////
  882. fprintf(pRespFile, "%srn", SPOOL_FILE_DATA_START);
  884. ///////////////////////////////////////////////////////////////////////////////
  885. //  Write Date ( mail data )
  886. ///////////////////////////////////////////////////////////////////////////////
  887. fprintf(pRespFile, "Date:   %srn", szTime);
  889. ///////////////////////////////////////////////////////////////////////////////
  890. //  Write X-MessageId ( mail data )
  891. ///////////////////////////////////////////////////////////////////////////////
  892. fprintf(pRespFile, "X-MessageId: <%s>rn", pszSpoolFileName);
  894. ///////////////////////////////////////////////////////////////////////////////
  895. //  Write X-SmtpMessageId ( mail data )
  896. ///////////////////////////////////////////////////////////////////////////////
  897. fprintf(pRespFile, "X-SmtpMessageId: <%s>rn", pszSmtpMsgID);
  899. ///////////////////////////////////////////////////////////////////////////////
  900. //  Write From ( mail data )
  901. ///////////////////////////////////////////////////////////////////////////////
  902. fprintf(pRespFile, "From: %s PostMaster <%s>rn", pszSMTPDomain, pszFrom);
  904. ///////////////////////////////////////////////////////////////////////////////
  905. //  Write To ( mail data )
  906. ///////////////////////////////////////////////////////////////////////////////
  907. fprintf(pRespFile, "To: %srn", pszTo);
  909. ///////////////////////////////////////////////////////////////////////////////
  910. //  Write Subject ( mail data )
  911. ///////////////////////////////////////////////////////////////////////////////
  912. fprintf(pRespFile, "Subject: Error sending message [%s] from [%s]rn",
  913. pszSpoolFileName, pszSMTPDomain);
  915. ///////////////////////////////////////////////////////////////////////////////
  916. //  Write X-MailerServer ( mail data )
  917. ///////////////////////////////////////////////////////////////////////////////
  918. fprintf(pRespFile, "%s: %srn", QUE_MAILER_HDR, APP_NAME_VERSION_STR);
  920. ///////////////////////////////////////////////////////////////////////////////
  921. //  Write X-SMTP-Mailer-Error ( mail data )
  922. ///////////////////////////////////////////////////////////////////////////////
  923. fprintf(pRespFile, "%s: Message = [%s] Server = [%s]rn",
  924. QUE_SMTP_MAILER_ERROR_HDR, pszSpoolFileName, pszSMTPDomain);
  926. ///////////////////////////////////////////////////////////////////////////////
  927. //  Write blank line ( mail data )
  928. ///////////////////////////////////////////////////////////////////////////////
  929. fprintf(pRespFile, "rn");
  931. ///////////////////////////////////////////////////////////////////////////////
  932. //  Write XMail bounce identifier
  933. ///////////////////////////////////////////////////////////////////////////////
  934. char const *pszMailFrom = USmlMailFrom(hFSpool);
  935. char const *pszRcptTo = USmlRcptTo(hFSpool);
  937. fprintf(pRespFile, "[<00>] XMail bounce: Rcpt=[%s];Error=[%s]rnrnrn",
  938. pszRcptTo, (pszReason != NULL) ? pszReason : "");
  940. ///////////////////////////////////////////////////////////////////////////////
  941. //  Write error message ( mail data )
  942. ///////////////////////////////////////////////////////////////////////////////
  943. fprintf(pRespFile, "[<01>] Error sending message [%s] from [%s].rnrn"
  944. "ID:        <%s>rn"
  945. "Mail From: <%s>rn"
  946. "Rcpt To:   <%s>rn",
  947. pszSpoolFileName, pszSMTPDomain, pszSmtpMsgID, pszMailFrom, pszRcptTo);
  949. if (pszServer != NULL) {
  950. SYS_INET_ADDR SvrAddr;
  951. char szIP[128] = "???.???.???.???";
  952. char szServer[MAX_HOST_NAME] = "";
  954. if ((MscGetServerAddress(pszServer, SvrAddr) == 0) &&
  955.     (SysGetHostByAddr(SvrAddr, szServer) == 0)) {
  956. pszServer = szServer;
  957. SysInetNToA(SvrAddr, szIP);
  958. } else
  959. StrSNCpy(szIP, pszServer);
  961. fprintf(pRespFile, "Server:    <%s> [%s]rn", pszServer, szIP);
  962. }
  964. fprintf(pRespFile, "rnrn");
  966. ///////////////////////////////////////////////////////////////////////////////
  967. //  Emit the delivery failure reason
  968. ///////////////////////////////////////////////////////////////////////////////
  969. if (pszReason != NULL)
  970. fprintf(pRespFile, "[<02>] The reason of the delivery failure was:rnrn"
  971. "%srnrnrn", pszReason);
  973. ///////////////////////////////////////////////////////////////////////////////
  974. //  Emit extra text
  975. ///////////////////////////////////////////////////////////////////////////////
  976. if (pszText != NULL)
  977. fprintf(pRespFile, "[<03>] Note:rnrn" "%srnrnrn", pszText);
  979. ///////////////////////////////////////////////////////////////////////////////
  980. //  Dump the log file associated with the message
  981. ///////////////////////////////////////////////////////////////////////////////
  982. char szBuffer[1536] = "";
  984. if (pszLogFile != NULL) {
  985. FILE *pLogFile = fopen(pszLogFile, "rb");
  987. if (pLogFile != NULL) {
  988. fprintf(pRespFile, "[<04>] Here is listed the message log file:rnrn");
  990. while (MscGetString(pLogFile, szBuffer, sizeof(szBuffer) - 1) != NULL)
  991. fprintf(pRespFile, "%srn", szBuffer);
  993. fprintf(pRespFile, "rnrn");
  995. fclose(pLogFile);
  996. }
  997. }
  998. ///////////////////////////////////////////////////////////////////////////////
  999. //  This function retrieve the spool file message section and sync the content.
  1000. //  This is necessary before reading the file
  1001. ///////////////////////////////////////////////////////////////////////////////
  1002. FileSection FS;
  1004. if (USmlGetMsgFileSection(hFSpool, FS) < 0) {
  1005. ErrorPush();
  1006. fclose(pRespFile);
  1007. SysRemove(pszResponseFile);
  1008. return (ErrorPop());
  1009. }
  1010. ///////////////////////////////////////////////////////////////////////////////
  1011. //  Open spool file
  1012. ///////////////////////////////////////////////////////////////////////////////
  1013. FILE *pMsgFile = fopen(FS.szFilePath, "rb");
  1015. if (pMsgFile == NULL) {
  1016. fclose(pRespFile);
  1017. SysRemove(pszResponseFile);
  1019. ErrSetErrorCode(ERR_FILE_OPEN, FS.szFilePath);
  1020. return (ERR_FILE_OPEN);
  1021. }
  1022. ///////////////////////////////////////////////////////////////////////////////
  1023. //  Seek at the beginning of the message ( headers section )
  1024. ///////////////////////////////////////////////////////////////////////////////
  1025. fseek(pMsgFile, FS.ulStartOffset, SEEK_SET);
  1027. fprintf(pRespFile, "[<05>] Here is listed the initial part of the message:rnrn");
  1029. bool bInHeaders = true;
  1031. while (MscGetString(pMsgFile, szBuffer, sizeof(szBuffer) - 1) != NULL) {
  1032. char *pszXDomain, *pszTmp;
  1034. ///////////////////////////////////////////////////////////////////////////////
  1035. //  Mail error loop deteced
  1036. ///////////////////////////////////////////////////////////////////////////////
  1037. if ((StrNComp(szBuffer, QUE_SMTP_MAILER_ERROR_HDR) == 0) &&
  1038.     ((pszXDomain = strrchr(szBuffer, '[')) != NULL) &&
  1039.     ((pszTmp = strrchr(++pszXDomain, ']')) != NULL) &&
  1040.     (strnicmp(pszXDomain, pszSMTPDomain, pszTmp - pszXDomain) == 0)){
  1041. fclose(pMsgFile);
  1042. fclose(pRespFile);
  1043. SysRemove(pszResponseFile);
  1045. ErrSetErrorCode(ERR_MAIL_ERROR_LOOP);
  1046. return (ERR_MAIL_ERROR_LOOP);
  1047. }
  1049. if (bInHeaders && IsEmptyString(szBuffer))
  1050. bInHeaders = false;
  1052. if (!bInHeaders && (iLinesExtra-- < 0))
  1053. break;
  1055. fprintf(pRespFile, "%srn", szBuffer);
  1056. }
  1058. fclose(pMsgFile);
  1060. fclose(pRespFile);
  1062. return (0);
  1064. }
  1066. int QueUtResendMessage(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, SPLF_HANDLE hFSpool)
  1067. {
  1068. ///////////////////////////////////////////////////////////////////////////////
  1069. //  Try to resend the message
  1070. ///////////////////////////////////////////////////////////////////////////////
  1071. int iResendResult = QueResendMessage(hQueue, hMessage);
  1073. ///////////////////////////////////////////////////////////////////////////////
  1074. //  If the message is expired ...
  1075. ///////////////////////////////////////////////////////////////////////////////
  1076. if (iResendResult == ERR_SPOOL_FILE_EXPIRED) {
  1077. ///////////////////////////////////////////////////////////////////////////////
  1078. //  Handle notifications and cleanup the message
  1079. ///////////////////////////////////////////////////////////////////////////////
  1080. iResendResult = QueUtNotifyPermErrDelivery(hQueue, hMessage, hFSpool,
  1081.    "The maximum number of delivery attempts has been reached",
  1082.    NULL, true);
  1084. QueCloseMessage(hQueue, hMessage);
  1085. }
  1087. return (iResendResult);
  1089. }