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

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

Email服务器

开发平台：

Visual C++

Filter.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 "SvrUtils.h"
  34. #include "UsrUtils.h"
  35. #include "MessQueue.h"
  36. #include "SMAILUtils.h"
  37. #include "QueueUtils.h"
  38. #include "MailDomains.h"
  39. #include "SMTPUtils.h"
  40. #include "ExtAliases.h"
  41. #include "UsrMailList.h"
  42. #include "Filter.h"
  43. #include "MailConfig.h"
  44. #include "AppDefines.h"
  45. #include "MailSvr.h"
  47. #define FILTER_LOG_FILE             "filters"
  48. #define FILTER_STORAGE_DIR          "filters"
  49. #define FILTER_SELECT_MAX           128
  50. #define FILTER_DB_LINE_MAX          512
  51. #define FILTER_LINE_MAX             1024
  53. struct FilterMsgInfo {
  54. char szSender[MAX_ADDR_NAME];
  55. char szRecipient[MAX_ADDR_NAME];
  56. SYS_INET_ADDR LocalAddr;
  57. SYS_INET_ADDR RemoteAddr;
  58. char szSpoolFile[SYS_MAX_PATH];
  59. char szAuthName[MAX_ADDR_NAME];
  60. };
  62. static int FilLogExec(FilterMsgInfo const &FMI, char const * const *ppszExec,
  63.       int iExecResult, int iExitCode, char const *pszType,
  64.       char const *pszInfo);
  65. static int FilLoadMsgInfo(SPLF_HANDLE hFSpool, FilterMsgInfo & FMI);
  66. static void FilFreeMsgInfo(FilterMsgInfo & FMI);
  67. static int FilGetFilePath(char const *pszMode, char *pszFilePath, int iMaxPath);
  68. static int FilAddFilter(char **ppszFilters, int &iNumFilters, char const *pszFilterName);
  69. static int FilSelectFilters(char const *pszFilterFilePath, char const *pszMode,
  70.     FilterMsgInfo const &FMI, char **ppszFilters, int iMaxFilters);
  71. static void FilFreeFilters(char **ppszFilters, int iNumFilters);
  72. static int FilGetFilterPath(char const *pszFileName, char *pszFilePath, int iMaxPath);
  73. static int FilPreExec(FilterMsgInfo const &FMI, FilterTokens *pToks, char **ppszPEError);
  74. static int FilApplyFilter(char const *pszFilterPath, SPLF_HANDLE hFSpool,
  75.   QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, FilterMsgInfo const &FMI,
  76.   char const *pszType);
  77. static int FilFilterMacroSubstitutes(char **ppszCmdTokens, SPLF_HANDLE hFSpool,
  78.      FilterMsgInfo const &FMI);
  81. int FilLogFilter(FilterLogInfo const *pFLI)
  82. {
  84. char szTime[256] = "";
  86. MscGetTimeNbrString(szTime, sizeof(szTime) - 1);
  88. RLCK_HANDLE hResLock = RLckLockEX(SVR_LOGS_DIR SYS_SLASH_STR FILTER_LOG_FILE);
  90. if (hResLock == INVALID_RLCK_HANDLE)
  91. return (ErrGetErrorCode());
  93. char szLocIP[128] = "???.???.???.???";
  94. char szRmtIP[128] = "???.???.???.???";
  96. MscFileLog(FILTER_LOG_FILE, ""%s""
  97.    "t"%s""
  98.    "t"%s""
  99.    "t"%s""
  100.    "t"%s""
  101.    "t"%s""
  102.    "t"%s""
  103.    "t"%d""
  104.    "t"%d""
  105.    "t"%s""
  106.    "n", pFLI->pszSender, pFLI->pszRecipient, SysInetNToA(pFLI->LocalAddr, szLocIP),
  107.    SysInetNToA(pFLI->RemoteAddr, szRmtIP), szTime, pFLI->pszType, pFLI->pszInfo,
  108.    pFLI->iExecResult, pFLI->iExitCode, pFLI->ppszExec[0]);
  110. RLckUnlockEX(hResLock);
  112. return (0);
  114. }
  116. static int FilLogExec(FilterMsgInfo const &FMI, char const * const *ppszExec,
  117.       int iExecResult, int iExitCode, char const *pszType,
  118.       char const *pszInfo)
  119. {
  121. FilterLogInfo FLI;
  123. FLI.pszSender = FMI.szSender;
  124. FLI.pszRecipient = FMI.szRecipient;
  125. FLI.LocalAddr = FMI.LocalAddr;
  126. FLI.RemoteAddr = FMI.RemoteAddr;
  127. FLI.ppszExec = ppszExec;
  128. FLI.iExecResult = iExecResult;
  129. FLI.iExitCode = iExitCode;
  130. FLI.pszType = pszType;
  131. FLI.pszInfo = pszInfo != NULL ? pszInfo: "";
  133. return (FilLogFilter(&FLI));
  135. }
  137. static int FilLoadMsgInfo(SPLF_HANDLE hFSpool, FilterMsgInfo & FMI)
  138. {
  140. UserInfo *pUI;
  141. char const *const *ppszInfo = USmlGetInfo(hFSpool);
  142. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  143. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  144. char const *pszSpoolFile = USmlGetSpoolFilePath(hFSpool);
  145. int iFromDomains = StrStringsCount(ppszFrom);
  146. int iRcptDomains = StrStringsCount(ppszRcpt);
  147. char szUser[MAX_ADDR_NAME] = "";
  148. char szDomain[MAX_ADDR_NAME] = "";
  150. ZeroData(FMI);
  152. if ((iFromDomains > 0) &&
  153.     (USmtpSplitEmailAddr(ppszFrom[iFromDomains - 1], szUser, szDomain) == 0)) {
  154. if ((pUI = UsrGetUserByNameOrAlias(szDomain, szUser)) != NULL) {
  155. UsrGetAddress(pUI, FMI.szSender);
  157. UsrFreeUserInfo(pUI);
  158. } else
  159. StrSNCpy(FMI.szSender, ppszFrom[iFromDomains - 1]);
  160. } else
  161. SetEmptyString(FMI.szSender);
  163. if ((iRcptDomains > 0) &&
  164.     (USmtpSplitEmailAddr(ppszRcpt[iRcptDomains - 1], szUser, szDomain) == 0)) {
  165. if ((pUI = UsrGetUserByNameOrAlias(szDomain, szUser)) != NULL) {
  166. UsrGetAddress(pUI, FMI.szRecipient);
  168. UsrFreeUserInfo(pUI);
  169. } else
  170. StrSNCpy(FMI.szRecipient, ppszRcpt[iRcptDomains - 1]);
  171. } else
  172. SetEmptyString(FMI.szRecipient);
  174. if ((MscGetServerAddress(ppszInfo[smiServerAddr], FMI.LocalAddr) < 0) ||
  175.     (MscGetServerAddress(ppszInfo[smiClientAddr], FMI.RemoteAddr) < 0))
  176. return (ErrGetErrorCode());
  178. StrSNCpy(FMI.szSpoolFile, pszSpoolFile);
  180. if (USmlMessageAuth(hFSpool, FMI.szAuthName, sizeof(FMI.szAuthName) - 1) < 0)
  181. SetEmptyString(FMI.szAuthName);
  183. return (0);
  185. }
  187. static void FilFreeMsgInfo(FilterMsgInfo & FMI)
  188. {
  190. }
  192. char *FilGetFilterRejMessage(char const *pszSpoolFile)
  193. {
  195. FILE *pFile;
  196. char szRejFilePath[SYS_MAX_PATH] = "";
  197. char szRejMsg[512] = "";
  199. SysSNPrintf(szRejFilePath, sizeof(szRejFilePath) - 1, "%s.rej", pszSpoolFile);
  200. if ((pFile = fopen(szRejFilePath, "rb")) == NULL)
  201. return NULL;
  203. MscFGets(szRejMsg, sizeof(szRejMsg) - 1, pFile);
  205. fclose(pFile);
  206. SysRemove(szRejFilePath);
  208. return (SysStrDup(szRejMsg));
  210. }
  212. static int FilGetFilePath(char const *pszMode, char *pszFilePath, int iMaxPath)
  213. {
  215. char szMailRootPath[SYS_MAX_PATH] = "";
  217. CfgGetRootPath(szMailRootPath, sizeof(szMailRootPath));
  219. SysSNPrintf(pszFilePath, iMaxPath - 1, "%sfilters.%s.tab", szMailRootPath, pszMode);
  221. return (0);
  223. }
  225. static int FilAddFilter(char **ppszFilters, int &iNumFilters, char const *pszFilterName)
  226. {
  228. for (int ii = 0; ii < iNumFilters; ii++)
  229. if (strcmp(ppszFilters[ii], pszFilterName) == 0)
  230. return (0);
  232. if ((ppszFilters[iNumFilters] = SysStrDup(pszFilterName)) == NULL)
  233. return (ErrGetErrorCode());
  235. iNumFilters++;
  237. return (0);
  239. }
  241. static int FilSelectFilters(char const *pszFilterFilePath, char const *pszMode,
  242.     FilterMsgInfo const &FMI, char **ppszFilters, int iMaxFilters)
  243. {
  244. ///////////////////////////////////////////////////////////////////////////////
  245. //  Share lock the filter table file
  246. ///////////////////////////////////////////////////////////////////////////////
  247. char szResLock[SYS_MAX_PATH] = "";
  248. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(pszFilterFilePath, szResLock,
  249.   sizeof(szResLock)));
  251. if (hResLock == INVALID_RLCK_HANDLE)
  252. return (ErrGetErrorCode());
  254. ///////////////////////////////////////////////////////////////////////////////
  255. //  Get local and remote IP addresses
  256. ///////////////////////////////////////////////////////////////////////////////
  257. NET_ADDRESS LocalAddr;
  258. NET_ADDRESS RemoteAddr;
  260. SysGetAddrAddress(FMI.LocalAddr, LocalAddr);
  261. SysGetAddrAddress(FMI.RemoteAddr, RemoteAddr);
  263. ///////////////////////////////////////////////////////////////////////////////
  264. //  Open the filter database. Fail smootly if the file does not exist
  265. ///////////////////////////////////////////////////////////////////////////////
  266. FILE *pFile = fopen(pszFilterFilePath, "rt");
  268. if (pFile == NULL) {
  269. RLckUnlockSH(hResLock);
  270. return (0);
  271. }
  273. int iNumFilters = 0;
  274. char szLine[FILTER_DB_LINE_MAX] = "";
  276. while ((iNumFilters < iMaxFilters) &&
  277.        (MscGetConfigLine(szLine, sizeof(szLine) - 1, pFile) != NULL)) {
  278. char **ppszTokens = StrGetTabLineStrings(szLine);
  280. if (ppszTokens == NULL)
  281. continue;
  283. int iFieldsCount = StrStringsCount(ppszTokens);
  285. if ((iFieldsCount >= filMax) &&
  286.     StrIWildMatch(FMI.szSender, ppszTokens[filSender]) &&
  287.     StrIWildMatch(FMI.szRecipient, ppszTokens[filRecipient])) {
  288. AddressFilter AFRemote;
  289. AddressFilter AFLocal;
  291. if ((MscLoadAddressFilter(&ppszTokens[filRemoteAddr], 1, AFRemote) == 0)
  292.     && MscAddressMatch(AFRemote, RemoteAddr) &&
  293.     (MscLoadAddressFilter(&ppszTokens[filLocalAddr], 1, AFLocal) == 0) &&
  294.     MscAddressMatch(AFLocal, LocalAddr)) {
  296. FilAddFilter(ppszFilters, iNumFilters, ppszTokens[filFileName]);
  298. }
  299. }
  301. StrFreeStrings(ppszTokens);
  302. }
  304. fclose(pFile);
  306. RLckUnlockSH(hResLock);
  308. return (iNumFilters);
  310. }
  312. static void FilFreeFilters(char **ppszFilters, int iNumFilters)
  313. {
  315. for (iNumFilters--; iNumFilters >= 0; iNumFilters--)
  316. SysFree(ppszFilters[iNumFilters]);
  318. }
  320. static int FilGetFilterPath(char const *pszFileName, char *pszFilePath, int iMaxPath)
  321. {
  323. char szMailRootPath[SYS_MAX_PATH] = "";
  325. CfgGetRootPath(szMailRootPath, sizeof(szMailRootPath));
  327. SysSNPrintf(pszFilePath, iMaxPath - 1, "%s%s%s%s",
  328.     szMailRootPath, FILTER_STORAGE_DIR, SYS_SLASH_STR, pszFileName);
  330. return (0);
  332. }
  334. int FilExecPreParse(FilterExecCtx *pCtx, char **ppszPEError)
  335. {
  337. int i;
  338. char **ppszEToks;
  339. char const *pszEx = pCtx->pToks->ppszCmdTokens[0];
  341. if ((pCtx->pToks->iTokenCount < 1) || (*pszEx != '!'))
  342. return (0);
  344. pCtx->pToks->iTokenCount--;
  345. pCtx->pToks->ppszCmdTokens++;
  347. if ((ppszEToks = StrTokenize(pszEx + 1, ",")) == NULL)
  348. return (ErrGetErrorCode());
  349. for (i = 0; ppszEToks[i] != NULL; i++) {
  350. char *pszVar = ppszEToks[i], *pszVal;
  352. if ((pszVal = strchr(pszVar, '=')) != NULL)
  353. *pszVal++ = '';
  354. if (strcmp(pszVar, "aex") == 0) {
  355. if (!IsEmptyString(pCtx->pszAuthName)) {
  356. StrFreeStrings(ppszEToks);
  358. *ppszPEError = SysStrDup("EXCL");
  360. return (-1);
  361. }
  362. }
  363. }
  364. StrFreeStrings(ppszEToks);
  366. return (0);
  368. }
  370. static int FilPreExec(FilterMsgInfo const &FMI, FilterTokens *pToks, char **ppszPEError)
  371. {
  373. FilterExecCtx FCtx;
  375. FCtx.pToks = pToks;
  376. FCtx.pszAuthName = FMI.szAuthName;
  378. return (FilExecPreParse(&FCtx, ppszPEError));
  380. }
  382. static int FilApplyFilter(char const *pszFilterPath, SPLF_HANDLE hFSpool,
  383.   QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, FilterMsgInfo const &FMI,
  384.   char const *pszType)
  385. {
  386. ///////////////////////////////////////////////////////////////////////////////
  387. //  Share lock the filter file
  388. ///////////////////////////////////////////////////////////////////////////////
  389. char szResLock[SYS_MAX_PATH] = "";
  390. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(pszFilterPath, szResLock,
  391.   sizeof(szResLock)));
  393. if (hResLock == INVALID_RLCK_HANDLE)
  394. return (ErrGetErrorCode());
  396. ///////////////////////////////////////////////////////////////////////////////
  397. //  This should not happen but if it happens we let the message pass through
  398. ///////////////////////////////////////////////////////////////////////////////
  399. FILE *pFiltFile = fopen(pszFilterPath, "rt");
  401. if (pFiltFile == NULL) {
  402. RLckUnlockSH(hResLock);
  403. return (0);
  404. }
  405. ///////////////////////////////////////////////////////////////////////////////
  406. //  Filter this message
  407. ///////////////////////////////////////////////////////////////////////////////
  408. char szFiltLine[FILTER_LINE_MAX] = "";
  410. while (MscGetConfigLine(szFiltLine, sizeof(szFiltLine) - 1, pFiltFile) != NULL) {
  411. char **ppszCmdTokens = StrGetTabLineStrings(szFiltLine);
  413. if (ppszCmdTokens == NULL)
  414. continue;
  416. int iFieldsCount = StrStringsCount(ppszCmdTokens);
  418. if (iFieldsCount < 1) {
  419. StrFreeStrings(ppszCmdTokens);
  420. continue;
  421. }
  423. ///////////////////////////////////////////////////////////////////////////////
  424. //  Perform pre-exec filtering (like exec exclude if authenticated, ...)
  425. ///////////////////////////////////////////////////////////////////////////////
  426. char *pszPEError = NULL;
  427. FilterTokens Toks;
  429. Toks.ppszCmdTokens = ppszCmdTokens;
  430. Toks.iTokenCount = iFieldsCount;
  432. if (FilPreExec(FMI, &Toks, &pszPEError) < 0) {
  433. if (bFilterLogEnabled)
  434. FilLogExec(FMI, Toks.ppszCmdTokens, -1,
  435.    -1, pszType, pszPEError);
  436. if (pszPEError != NULL)
  437. SysFree(pszPEError);
  438. StrFreeStrings(ppszCmdTokens);
  439. continue;
  440. }
  442. ///////////////////////////////////////////////////////////////////////////////
  443. //  Do filter line macro substitution
  444. ///////////////////////////////////////////////////////////////////////////////
  445. FilFilterMacroSubstitutes(Toks.ppszCmdTokens, hFSpool, FMI);
  447. ///////////////////////////////////////////////////////////////////////////////
  448. //  Time to fire the external executable ...
  449. ///////////////////////////////////////////////////////////////////////////////
  450. int iExitCode = -1;
  451. int iExitFlags = 0;
  452. int iExecResult = SysExec(Toks.ppszCmdTokens[0], &Toks.ppszCmdTokens[0],
  453.   iFilterTimeout, FILTER_PRIORITY, &iExitCode);
  455. ///////////////////////////////////////////////////////////////////////////////
  456. //  Log the operation, if requested.
  457. ///////////////////////////////////////////////////////////////////////////////
  458. if (bFilterLogEnabled)
  459. FilLogExec(FMI, Toks.ppszCmdTokens, iExecResult,
  460.    iExitCode, pszType, NULL);
  462. if (iExecResult == 0) {
  463. SysLogMessage(LOG_LEV_MESSAGE,
  464.       "Filter run: Sender = "%s" Recipient = "%s" Filter = "%s" Retcode = %dn",
  465.       FMI.szSender, FMI.szRecipient, Toks.ppszCmdTokens[0],
  466.       iExitCode);
  468. ///////////////////////////////////////////////////////////////////////////////
  469. //  Separate code from flags
  470. ///////////////////////////////////////////////////////////////////////////////
  471. iExitFlags = iExitCode & FILTER_FLAGS_MASK;
  472. iExitCode &= ~FILTER_FLAGS_MASK;
  474. if ((iExitCode == FILTER_OUT_EXITCODE) ||
  475.     (iExitCode == FILTER_OUT_NN_EXITCODE) ||
  476.     (iExitCode == FILTER_OUT_NNF_EXITCODE)) {
  477. fclose(pFiltFile);
  478. RLckUnlockSH(hResLock);
  480. ///////////////////////////////////////////////////////////////////////////////
  481. //  Filter out message
  482. ///////////////////////////////////////////////////////////////////////////////
  483. char *pszRejMsg = FilGetFilterRejMessage(FMI.szSpoolFile);
  485. if (iExitCode == FILTER_OUT_EXITCODE)
  486. QueUtNotifyPermErrDelivery(hQueue, hMessage, NULL,
  487.    (pszRejMsg !=
  488.     NULL) ? pszRejMsg :
  489.    ErrGetErrorString
  490.    (ERR_FILTERED_MESSAGE),
  491.    NULL, true);
  492. else if (iExitCode == FILTER_OUT_NN_EXITCODE)
  493. QueCleanupMessage(hQueue, hMessage,
  494.   !QueUtRemoveSpoolErrors());
  495. else
  496. QueCleanupMessage(hQueue, hMessage, false);
  498. StrFreeStrings(ppszCmdTokens);
  499. if (pszRejMsg != NULL)
  500. SysFree(pszRejMsg);
  502. ErrSetErrorCode(ERR_FILTERED_MESSAGE);
  503. return (ERR_FILTERED_MESSAGE);
  504. } else if (iExitCode == FILTER_MODIFY_EXITCODE) {
  505. ///////////////////////////////////////////////////////////////////////////////
  506. //  Filter modified the message, we need to reload the spool handle
  507. ///////////////////////////////////////////////////////////////////////////////
  508. if (USmlReloadHandle(hFSpool) < 0) {
  509. ErrorPush();
  510. fclose(pFiltFile);
  511. RLckUnlockSH(hResLock);
  513. SysLogMessage(LOG_LEV_MESSAGE,
  514.       "Filter error [ Modified message corrupted ]: Sender = "%s" Recipient = "%s" (%s)n",
  515.       FMI.szSender, FMI.szRecipient,
  516.       Toks.ppszCmdTokens[0]);
  518. QueUtErrLogMessage(hQueue, hMessage,
  519.    "Filter error [ Modified message corrupted ]: Sender = "%s" Recipient = "%s" (%s)n",
  520.    FMI.szSender, FMI.szRecipient,
  521.    Toks.ppszCmdTokens[0]);
  523. QueCleanupMessage(hQueue, hMessage, true);
  524. StrFreeStrings(ppszCmdTokens);
  526. return (ErrorPop());
  527. }
  528. }
  529. } else {
  530. SysLogMessage(LOG_LEV_ERROR,
  531.       "Filter error (%d): Sender = "%s" Recipient = "%s" Filter = "%s"n",
  532.       iExecResult, FMI.szSender, FMI.szRecipient,
  533.       Toks.ppszCmdTokens[0]);
  535. QueUtErrLogMessage(hQueue, hMessage,
  536.    "Filter error (%d): Sender = "%s" Recipient = "%s" Filter = "%s"n",
  537.    iExecResult, FMI.szSender, FMI.szRecipient,
  538.    Toks.ppszCmdTokens[0]);
  539. }
  541. StrFreeStrings(ppszCmdTokens);
  543. ///////////////////////////////////////////////////////////////////////////////
  544. //  Filter list processing break required ?
  545. ///////////////////////////////////////////////////////////////////////////////
  546. if (iExitFlags & FILTER_FLAGS_BREAK) {
  547. fclose(pFiltFile);
  548. RLckUnlockSH(hResLock);
  549. return (1);
  550. }
  551. }
  553. fclose(pFiltFile);
  554. RLckUnlockSH(hResLock);
  556. return (0);
  558. }
  560. int FilFilterMessage(SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  561.      QMSG_HANDLE hMessage, char const *pszMode)
  562. {
  563. ///////////////////////////////////////////////////////////////////////////////
  564. //  Get filter file path and returns immediately if no file is defined
  565. ///////////////////////////////////////////////////////////////////////////////
  566. char szFilterFilePath[SYS_MAX_PATH] = "";
  568. FilGetFilePath(pszMode, szFilterFilePath, sizeof(szFilterFilePath));
  570. if (!SysExistFile(szFilterFilePath))
  571. return (0);
  573. ///////////////////////////////////////////////////////////////////////////////
  574. //  Load the message info
  575. ///////////////////////////////////////////////////////////////////////////////
  576. FilterMsgInfo FMI;
  578. if (FilLoadMsgInfo(hFSpool, FMI) < 0)
  579. return (ErrGetErrorCode());
  581. ///////////////////////////////////////////////////////////////////////////////
  582. //  Select applicable filters
  583. ///////////////////////////////////////////////////////////////////////////////
  584. int iNumFilters;
  585. char *pszFilters[FILTER_SELECT_MAX];
  587. if ((iNumFilters = FilSelectFilters(szFilterFilePath, pszMode, FMI, pszFilters,
  588.     CountOf(pszFilters))) < 0) {
  589. ErrorPush();
  590. FilFreeMsgInfo(FMI);
  591. return (ErrorPop());
  592. }
  593. ///////////////////////////////////////////////////////////////////////////////
  594. //  Sequentially apply each selected filter
  595. ///////////////////////////////////////////////////////////////////////////////
  596. for (int ii = 0; ii < iNumFilters; ii++) {
  597. int iFilterResult;
  598. char szFilterPath[SYS_MAX_PATH] = "";
  600. FilGetFilterPath(pszFilters[ii], szFilterPath, sizeof(szFilterPath));
  602. if ((iFilterResult =
  603.      FilApplyFilter(szFilterPath, hFSpool, hQueue, hMessage,
  604.     FMI, pszMode)) < 0) {
  605. ErrorPush();
  606. FilFreeFilters(pszFilters, iNumFilters);
  607. FilFreeMsgInfo(FMI);
  608. return (ErrorPop());
  609. }
  610. ///////////////////////////////////////////////////////////////////////////////
  611. //  A return code greater than zero means exit filter processing loop soon
  612. ///////////////////////////////////////////////////////////////////////////////
  613. if (iFilterResult > 0)
  614. break;
  615. }
  617. FilFreeFilters(pszFilters, iNumFilters);
  618. FilFreeMsgInfo(FMI);
  620. return (0);
  622. }
  624. static int FilFilterMacroSubstitutes(char **ppszCmdTokens, SPLF_HANDLE hFSpool,
  625.      FilterMsgInfo const &FMI)
  626. {
  628. char const *const *ppszInfo = USmlGetInfo(hFSpool);
  629. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  630. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  631. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  632. char const *pszSmtpMessageID = USmlGetSmtpMessageID(hFSpool);
  633. char const *pszMessageID = USmlGetSpoolFile(hFSpool);
  634. int iFromDomains = StrStringsCount(ppszFrom);
  635. int iRcptDomains = StrStringsCount(ppszRcpt);
  636. FileSection FS;
  638. ///////////////////////////////////////////////////////////////////////////////
  639. //  This function retrieve the spool file message section and sync the content.
  640. //  This is necessary before passing the file name to external programs
  641. ///////////////////////////////////////////////////////////////////////////////
  642. if (USmlGetMsgFileSection(hFSpool, FS) < 0)
  643. return (ErrGetErrorCode());
  645. for (int ii = 0; ppszCmdTokens[ii] != NULL; ii++) {
  646. if (strcmp(ppszCmdTokens[ii], "@@FROM") == 0) {
  647. char *pszNewValue =
  648. SysStrDup((iFromDomains > 0) ? ppszFrom[iFromDomains - 1] : "");
  650. if (pszNewValue == NULL)
  651. return (ErrGetErrorCode());
  653. SysFree(ppszCmdTokens[ii]);
  655. ppszCmdTokens[ii] = pszNewValue;
  656. } else if (strcmp(ppszCmdTokens[ii], "@@RCPT") == 0) {
  657. char *pszNewValue =
  658. SysStrDup((iRcptDomains > 0) ? ppszRcpt[iRcptDomains - 1] : "");
  660. if (pszNewValue == NULL)
  661. return (ErrGetErrorCode());
  663. SysFree(ppszCmdTokens[ii]);
  665. ppszCmdTokens[ii] = pszNewValue;
  666. } else if (strcmp(ppszCmdTokens[ii], "@@RFROM") == 0) {
  667. char *pszNewValue = SysStrDup(FMI.szSender);
  669. if (pszNewValue == NULL)
  670. return (ErrGetErrorCode());
  672. SysFree(ppszCmdTokens[ii]);
  674. ppszCmdTokens[ii] = pszNewValue;
  675. } else if (strcmp(ppszCmdTokens[ii], "@@RRCPT") == 0) {
  676. char *pszNewValue = SysStrDup(FMI.szRecipient);
  678. if (pszNewValue == NULL)
  679. return (ErrGetErrorCode());
  681. SysFree(ppszCmdTokens[ii]);
  683. ppszCmdTokens[ii] = pszNewValue;
  684. } else if (strcmp(ppszCmdTokens[ii], "@@FILE") == 0) {
  685. char *pszNewValue = SysStrDup(FS.szFilePath);
  687. if (pszNewValue == NULL)
  688. return (ErrGetErrorCode());
  690. SysFree(ppszCmdTokens[ii]);
  692. ppszCmdTokens[ii] = pszNewValue;
  693. } else if (strcmp(ppszCmdTokens[ii], "@@MSGID") == 0) {
  694. char *pszNewValue = SysStrDup(pszMessageID);
  696. if (pszNewValue == NULL)
  697. return (ErrGetErrorCode());
  699. SysFree(ppszCmdTokens[ii]);
  701. ppszCmdTokens[ii] = pszNewValue;
  702. } else if (strcmp(ppszCmdTokens[ii], "@@MSGREF") == 0) {
  703. char *pszNewValue = SysStrDup(pszSmtpMessageID);
  705. if (pszNewValue == NULL)
  706. return (ErrGetErrorCode());
  708. SysFree(ppszCmdTokens[ii]);
  710. ppszCmdTokens[ii] = pszNewValue;
  711. } else if (strcmp(ppszCmdTokens[ii], "@@LOCALADDR") == 0) {
  712. char *pszNewValue = SysStrDup(ppszInfo[smiServerAddr]);
  714. if (pszNewValue == NULL)
  715. return (ErrGetErrorCode());
  717. SysFree(ppszCmdTokens[ii]);
  719. ppszCmdTokens[ii] = pszNewValue;
  720. } else if (strcmp(ppszCmdTokens[ii], "@@REMOTEADDR") == 0) {
  721. char *pszNewValue = SysStrDup(ppszInfo[smiClientAddr]);
  723. if (pszNewValue == NULL)
  724. return (ErrGetErrorCode());
  726. SysFree(ppszCmdTokens[ii]);
  728. ppszCmdTokens[ii] = pszNewValue;
  729. } else if (strcmp(ppszCmdTokens[ii], "@@USERAUTH") == 0) {
  730. char *pszNewValue = SysStrDup(IsEmptyString(FMI.szAuthName) ? "-":
  731.       FMI.szAuthName);
  733. if (pszNewValue == NULL)
  734. return (ErrGetErrorCode());
  736. SysFree(ppszCmdTokens[ii]);
  738. ppszCmdTokens[ii] = pszNewValue;
  739. }
  741. }
  743. return (0);
  745. }