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

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

Email服务器

开发平台：

Visual C++

SMAILSvr.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 "SMAILSvr.h"
  45. #include "AppDefines.h"
  46. #include "MailSvr.h"
  48. #define SMAIL_WAITMSG_TIMEOUT       2
  49. #define CUSTOM_PROC_LINE_MAX        1024
  50. #define SMAIL_EXTERNAL_EXIT_BREAK   16
  51. #define SMAIL_STOP_PROCESSING       3111965L
  53. static SMAILConfig *SMAILGetConfigCopy(SHB_HANDLE hShbSMAIL);
  54. static int SMAILThreadCountAdd(long lCount, SHB_HANDLE hShbSMAIL, SMAILConfig * pSMAILCfg = NULL);
  55. static int SMAILLogEnabled(SHB_HANDLE hShbSMAIL, SMAILConfig * pSMAILCfg = NULL);
  56. static int SMAILHandleResendNotify(SVRCFG_HANDLE hSvrConfig, QUEUE_HANDLE hQueue,
  57.    QMSG_HANDLE hMessage, SPLF_HANDLE hFSpool);
  58. static int SMAILTryProcessMessage(SVRCFG_HANDLE hSvrConfig, QUEUE_HANDLE hQueue,
  59.   QMSG_HANDLE hMessage, SHB_HANDLE hShbSMAIL,
  60.   SMAILConfig * pSMAILCfg);
  61. static int SMAILTryProcessSpool(SHB_HANDLE hShbSMAIL);
  62. static int SMAILProcessFile(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  63.     SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage);
  64. static int SMAILMailingListExplode(UserInfo * pUI, SPLF_HANDLE hFSpool);
  65. static int SMAILRemoteMsgSMTPSend(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  66.   SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage,
  67.   char const *pszDestDomain, SMTPError * pSMTPE = NULL);
  68. static int SMAILHandleRemoteUserMessage(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  69. SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  70. QMSG_HANDLE hMessage, char const *pszDestDomain,
  71. char const *pszDestUser);
  72. static int SMAILCustomProcessMessage(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  73.      SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  74.      QMSG_HANDLE hMessage, char const *pszDestDomain,
  75.      char const *pszDestUser, char const *pszCustFilePath);
  76. static int SMAILCmdMacroSubstitutes(char **ppszCmdTokens, SPLF_HANDLE hFSpool);
  77. static int SMAILCmd_external(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  78.      char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  79.      SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage);
  80. static int SMAILCmd_filter(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  81.    char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  82.    SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage);
  83. static int SMAILCmd_smtp(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  84.  char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  85.  SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage);
  86. static int SMAILCmd_smtprelay(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  87.       char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  88.       SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage);
  89. static int SMAILCmd_redirect(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  90.      char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  91.      SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage);
  92. static int SMAILCmd_lredirect(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  93.       char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  94.       SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage);
  96. static SMAILConfig *SMAILGetConfigCopy(SHB_HANDLE hShbSMAIL)
  97. {
  99. SMAILConfig *pLMAILCfg = (SMAILConfig *) ShbLock(hShbSMAIL);
  101. if (pLMAILCfg == NULL)
  102. return (NULL);
  104. SMAILConfig *pNewLMAILCfg = (SMAILConfig *) SysAlloc(sizeof(SMAILConfig));
  106. if (pNewLMAILCfg != NULL)
  107. memcpy(pNewLMAILCfg, pLMAILCfg, sizeof(SMAILConfig));
  109. ShbUnlock(hShbSMAIL);
  111. return (pNewLMAILCfg);
  113. }
  115. static int SMAILThreadCountAdd(long lCount, SHB_HANDLE hShbSMAIL, SMAILConfig * pSMAILCfg)
  116. {
  118. int iDoUnlock = 0;
  120. if (pSMAILCfg == NULL) {
  121. if ((pSMAILCfg = (SMAILConfig *) ShbLock(hShbSMAIL)) == NULL)
  122. return (ErrGetErrorCode());
  124. ++iDoUnlock;
  125. }
  127. pSMAILCfg->lThreadCount += lCount;
  129. if (iDoUnlock)
  130. ShbUnlock(hShbSMAIL);
  132. return (0);
  134. }
  136. static int SMAILLogEnabled(SHB_HANDLE hShbSMAIL, SMAILConfig * pSMAILCfg)
  137. {
  139. int iDoUnlock = 0;
  141. if (pSMAILCfg == NULL) {
  142. if ((pSMAILCfg = (SMAILConfig *) ShbLock(hShbSMAIL)) == NULL)
  143. return (ErrGetErrorCode());
  145. ++iDoUnlock;
  146. }
  148. unsigned long ulFlags = pSMAILCfg->ulFlags;
  150. if (iDoUnlock)
  151. ShbUnlock(hShbSMAIL);
  153. return ((ulFlags & SMAILF_LOG_ENABLED) ? 1 : 0);
  155. }
  157. unsigned int SMAILThreadProc(void *pThreadData)
  158. {
  160. SMAILConfig *pSMAILCfg = (SMAILConfig *) ShbLock(hShbSMAIL);
  162. if (pSMAILCfg == NULL) {
  163. ErrorPush();
  164. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  165. return (ErrorPop());
  166. }
  167. ///////////////////////////////////////////////////////////////////////////////
  168. //  Get thread id
  169. ///////////////////////////////////////////////////////////////////////////////
  170. long lThreadId = pSMAILCfg->lThreadCount;
  172. ///////////////////////////////////////////////////////////////////////////////
  173. //  Increase thread count
  174. ///////////////////////////////////////////////////////////////////////////////
  175. SMAILThreadCountAdd(+1, hShbSMAIL, pSMAILCfg);
  177. ShbUnlock(hShbSMAIL);
  179. SysLogMessage(LOG_LEV_MESSAGE, "SMAIL thread [%02ld] startedn", lThreadId);
  181. for (;;) {
  182. ///////////////////////////////////////////////////////////////////////////////
  183. //  Check shutdown condition
  184. ///////////////////////////////////////////////////////////////////////////////
  185. pSMAILCfg = (SMAILConfig *) ShbLock(hShbSMAIL);
  187. if ((pSMAILCfg == NULL) || (pSMAILCfg->ulFlags & SMAILF_STOP_SERVER)) {
  188. SysLogMessage(LOG_LEV_MESSAGE, "SMAIL thread [%02ld] exitingn",
  189.       lThreadId);
  191. if (pSMAILCfg != NULL)
  192. ShbUnlock(hShbSMAIL);
  193. break;
  194. }
  196. ShbUnlock(hShbSMAIL);
  198. ///////////////////////////////////////////////////////////////////////////////
  199. //  Process spool files
  200. ///////////////////////////////////////////////////////////////////////////////
  201. SMAILTryProcessSpool(hShbSMAIL);
  203. }
  205. ///////////////////////////////////////////////////////////////////////////////
  206. //  Decrease thread count
  207. ///////////////////////////////////////////////////////////////////////////////
  208. SMAILThreadCountAdd(-1, hShbSMAIL);
  210. SysLogMessage(LOG_LEV_MESSAGE, "SMAIL thread [%02ld] stoppedn", lThreadId);
  212. return (0);
  214. }
  216. static int SMAILHandleResendNotify(SVRCFG_HANDLE hSvrConfig, QUEUE_HANDLE hQueue,
  217.    QMSG_HANDLE hMessage, SPLF_HANDLE hFSpool)
  218. {
  219. ///////////////////////////////////////////////////////////////////////////////
  220. //  Check if it's time to notify about a failed delivery attempt
  221. ///////////////////////////////////////////////////////////////////////////////
  222. int iRetryCount = QueGetTryCount(hMessage);
  223. char szNotifyPattern[128] = "";
  225. SvrConfigVar("NotifyTryPattern", szNotifyPattern, sizeof(szNotifyPattern) - 1, hSvrConfig,
  226.      "");
  228. for (char *pszTry = szNotifyPattern; pszTry != NULL; ++pszTry) {
  229. if (isdigit(*pszTry) && (atoi(pszTry) == iRetryCount))
  230. break;
  232. if ((pszTry = strchr(pszTry, ',')) == NULL)
  233. return (0);
  234. }
  236. ///////////////////////////////////////////////////////////////////////////////
  237. //  Build the notification text and send the message
  238. ///////////////////////////////////////////////////////////////////////////////
  239. time_t tLastTry = QueGetLastTryTime(hMessage);
  240. time_t tNextTry = QueGetMessageNextOp(hQueue, hMessage);
  241. char szTimeLast[128] = "";
  242. char szTimeNext[128] = "";
  244. MscGetTimeStr(szTimeLast, sizeof(szTimeLast) - 1, tLastTry);
  245. MscGetTimeStr(szTimeNext, sizeof(szTimeNext) - 1, tNextTry);
  247. char *pszText =
  248.     StrSprint("** This is a temporary error and you do not have to resend the messagern"
  249.       "** The system tried to send the message at      : %srn"
  250.       "** The current number of delivery attempts is   : %drn"
  251.       "** The system will try to resend the message at : %srn",
  252.       szTimeLast, iRetryCount, szTimeNext);
  254. if (pszText == NULL)
  255. return (ErrGetErrorCode());
  257. int iNotifyResult = QueUtNotifyTempErrDelivery(hQueue, hMessage, hFSpool,
  258.        NULL, pszText, NULL);
  260. SysFree(pszText);
  262. return (iNotifyResult);
  264. }
  266. static int SMAILTryProcessMessage(SVRCFG_HANDLE hSvrConfig, QUEUE_HANDLE hQueue,
  267.   QMSG_HANDLE hMessage, SHB_HANDLE hShbSMAIL,
  268.   SMAILConfig * pSMAILCfg)
  269. {
  270. ///////////////////////////////////////////////////////////////////////////////
  271. //  Create the handle to manage the queue file
  272. ///////////////////////////////////////////////////////////////////////////////
  273. char szMessFilePath[SYS_MAX_PATH] = "";
  275. QueGetFilePath(hQueue, hMessage, szMessFilePath);
  277. SPLF_HANDLE hFSpool = USmlCreateHandle(szMessFilePath);
  279. if (hFSpool == INVALID_SPLF_HANDLE) {
  280. ErrorPush();
  281. ErrLogMessage(LOG_LEV_ERROR,
  282.       "Unable to load spool file "%s"n"
  283.       "%s = "%s"n",
  284.       szMessFilePath, SMTP_ERROR_VARNAME, "554 Error loading spool file");
  285. QueUtErrLogMessage(hQueue, hMessage,
  286.    "Unable to load spool file "%s"n"
  287.    "%s = "%s"n",
  288.    szMessFilePath, SMTP_ERROR_VARNAME,
  289.    "554 Error loading spool file");
  291. QueUtCleanupNotifyRoot(hQueue, hMessage, INVALID_SPLF_HANDLE,
  292.        ErrGetErrorString(ErrorFetch()));
  293. QueCloseMessage(hQueue, hMessage);
  295. return (ErrorPop());
  296. }
  297. ///////////////////////////////////////////////////////////////////////////////
  298. //  Check for mail loops
  299. ///////////////////////////////////////////////////////////////////////////////
  300. if (USmlMailLoopCheck(hFSpool, hSvrConfig) < 0) {
  301. ErrorPush();
  303. ///////////////////////////////////////////////////////////////////////////////
  304. //  Notify root and remove the message
  305. ///////////////////////////////////////////////////////////////////////////////
  306. char const *pszSmtpMessageID = USmlGetSmtpMessageID(hFSpool);
  308. ErrLogMessage(LOG_LEV_ERROR,
  309.       "Message <%s> blocked by mail loop check !n"
  310.       "%s = "%s"n",
  311.       pszSmtpMessageID, SMTP_ERROR_VARNAME,
  312.       "554 Message blocked by mail loop check");
  313. QueUtErrLogMessage(hQueue, hMessage,
  314.    "Message <%s> blocked by mail loop check !n"
  315.    "%s = "%s"n",
  316.    pszSmtpMessageID, SMTP_ERROR_VARNAME,
  317.    "554 Message blocked by mail loop check");
  319. QueUtCleanupNotifyRoot(hQueue, hMessage, hFSpool,
  320.        ErrGetErrorString(ErrorFetch()));
  321. USmlCloseHandle(hFSpool);
  322. QueCloseMessage(hQueue, hMessage);
  324. return (ErrorPop());
  325. }
  326. ///////////////////////////////////////////////////////////////////////////////
  327. //  Process queue file
  328. ///////////////////////////////////////////////////////////////////////////////
  329. if (SMAILProcessFile(hSvrConfig, hShbSMAIL, hFSpool, hQueue, hMessage) < 0) {
  330. ErrorPush();
  332. ///////////////////////////////////////////////////////////////////////////////
  333. //  Resend the message if it's not been cleaned up
  334. ///////////////////////////////////////////////////////////////////////////////
  335. if (QueCheckMessage(hQueue, hMessage) == 0) {
  336. USmlSyncChanges(hFSpool);
  338. ///////////////////////////////////////////////////////////////////////////////
  339. //  Handle resend notifications
  340. ///////////////////////////////////////////////////////////////////////////////
  341. SMAILHandleResendNotify(hSvrConfig, hQueue, hMessage, hFSpool);
  343. ///////////////////////////////////////////////////////////////////////////////
  344. //  Resend the message
  345. ///////////////////////////////////////////////////////////////////////////////
  346. QueUtResendMessage(hQueue, hMessage, hFSpool);
  348. } else
  349. QueCloseMessage(hQueue, hMessage);
  351. USmlCloseHandle(hFSpool);
  353. return (ErrorPop());
  354. }
  356. USmlCloseHandle(hFSpool);
  358. ///////////////////////////////////////////////////////////////////////////////
  359. //  Cleanup message
  360. ///////////////////////////////////////////////////////////////////////////////
  361. QueCleanupMessage(hQueue, hMessage);
  363. QueCloseMessage(hQueue, hMessage);
  365. return (0);
  367. }
  369. static int SMAILTryProcessSpool(SHB_HANDLE hShbSMAIL)
  370. {
  372. SMAILConfig *pSMAILCfg = SMAILGetConfigCopy(hShbSMAIL);
  374. if (pSMAILCfg == NULL) {
  375. ErrorPush();
  376. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  377. return (ErrorPop());
  378. }
  379. ///////////////////////////////////////////////////////////////////////////////
  380. //  Get queue file to process
  381. ///////////////////////////////////////////////////////////////////////////////
  382. QMSG_HANDLE hMessage = QueExtractMessage(hSpoolQueue, SMAIL_WAITMSG_TIMEOUT);
  384. if (hMessage != INVALID_QMSG_HANDLE) {
  385. ///////////////////////////////////////////////////////////////////////////////
  386. //  Get configuration handle
  387. ///////////////////////////////////////////////////////////////////////////////
  388. SVRCFG_HANDLE hSvrConfig = SvrGetConfigHandle();
  390. if (hSvrConfig == INVALID_SVRCFG_HANDLE) {
  391. ErrorPush();
  392. ErrLogMessage(LOG_LEV_ERROR,
  393.       "Unable to load server configuration filen"
  394.       "%s = "%s"n", SMTP_ERROR_VARNAME,
  395.       "417 Unable to load server configuration file");
  396. QueUtErrLogMessage(hSpoolQueue, hMessage,
  397.    "Unable to load server configuration filen"
  398.    "%s = "%s"n", SMTP_ERROR_VARNAME,
  399.    "417 Unable to load server configuration file");
  401. QueUtResendMessage(hSpoolQueue, hMessage, NULL);
  403. SysFree(pSMAILCfg);
  404. return (ErrorPop());
  405. }
  406. ///////////////////////////////////////////////////////////////////////////////
  407. //  Process queue file
  408. ///////////////////////////////////////////////////////////////////////////////
  409. SMAILTryProcessMessage(hSvrConfig, hSpoolQueue, hMessage, hShbSMAIL, pSMAILCfg);
  411. SvrReleaseConfigHandle(hSvrConfig);
  412. }
  414. SysFree(pSMAILCfg);
  416. return (0);
  418. }
  420. static int SMAILProcessFile(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  421.     SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage)
  422. {
  424. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  425. int iRcptDomains = StrStringsCount(ppszRcpt);
  427. char szDestUser[MAX_ADDR_NAME] = "";
  428. char szDestDomain[MAX_ADDR_NAME] = "";
  429. char szAliasFilePath[SYS_MAX_PATH] = "";
  431. if (iRcptDomains < 1) {
  432. ErrSetErrorCode(ERR_BAD_EMAIL_ADDR);
  433. return (ERR_BAD_EMAIL_ADDR);
  434. }
  435. ///////////////////////////////////////////////////////////////////////////////
  436. //  We can have two cases here. The recipient is a simple one, or it has an
  437. //  explicit routing (@dom1,@dom2:usr@dom).
  438. ///////////////////////////////////////////////////////////////////////////////
  439. if (iRcptDomains == 1) {
  440. if (USmtpSplitEmailAddr(ppszRcpt[0], szDestUser, szDestDomain) < 0)
  441. return (ErrGetErrorCode());
  442. } else if (USmtpSplitEmailAddr(ppszRcpt[0], NULL, szDestDomain) < 0)
  443. return (ErrGetErrorCode());
  445. ///////////////////////////////////////////////////////////////////////////////
  446. //  Is the target handled with cmdalias ?
  447. ///////////////////////////////////////////////////////////////////////////////
  448. if (USmlGetCmdAliasCustomFile(hFSpool, hQueue, hMessage, szDestDomain,
  449.       szDestUser, szAliasFilePath) == 0) {
  450. ///////////////////////////////////////////////////////////////////////////////
  451. //  Do cmd alias processing
  452. ///////////////////////////////////////////////////////////////////////////////
  453. if (SMAILCustomProcessMessage(hSvrConfig, hShbSMAIL, hFSpool, hQueue, hMessage,
  454.       szDestDomain, szDestUser, szAliasFilePath) < 0)
  455. return (ErrGetErrorCode());
  457. }
  458. ///////////////////////////////////////////////////////////////////////////////
  459. //  Check if we are at home
  460. ///////////////////////////////////////////////////////////////////////////////
  461. else if (MDomIsHandledDomain(szDestDomain) == 0) {
  462. UserInfo *pUI = UsrGetUserByNameOrAlias(szDestDomain, szDestUser);
  464. if (pUI != NULL) {
  465. SysLogMessage(LOG_LEV_MESSAGE,
  466.       "SMAIL local SMTP = "%s" From = <%s> To = <%s>n",
  467.       USmlGetSMTPDomain(hFSpool), USmlMailFrom(hFSpool),
  468.       ppszRcpt[0]);
  470. if (UsrGetUserType(pUI) == usrTypeUser) {
  471. ///////////////////////////////////////////////////////////////////////////////
  472. //  Local user case
  473. ///////////////////////////////////////////////////////////////////////////////
  474. LocalMailProcConfig LMPC;
  476. ZeroData(LMPC);
  477. LMPC.ulFlags =
  478. (SMAILLogEnabled(hShbSMAIL)) ? LMPCF_LOG_ENABLED : 0;
  480. if (USmlProcessLocalUserMessage
  481.     (hSvrConfig, pUI, hFSpool, hQueue, hMessage, LMPC) < 0) {
  482. ErrorPush();
  483. UsrFreeUserInfo(pUI);
  484. return (ErrorPop());
  485. }
  486. } else {
  487. ///////////////////////////////////////////////////////////////////////////////
  488. //  Apply filters ...
  489. ///////////////////////////////////////////////////////////////////////////////
  490. if (FilFilterMessage
  491.     (hFSpool, hQueue, hMessage, FILTER_MODE_INBOUND) < 0) {
  492. ErrorPush();
  493. UsrFreeUserInfo(pUI);
  494. return (ErrorPop());
  495. }
  496. ///////////////////////////////////////////////////////////////////////////////
  497. //  Local mailing list case
  498. ///////////////////////////////////////////////////////////////////////////////
  499. if (SMAILMailingListExplode(pUI, hFSpool) < 0) {
  500. ErrorPush();
  501. UsrFreeUserInfo(pUI);
  502. return (ErrorPop());
  503. }
  504. }
  506. UsrFreeUserInfo(pUI);
  507. } else {
  508. ErrorPush();
  509. ///////////////////////////////////////////////////////////////////////////////
  510. //  No account inside the handled domain
  511. ///////////////////////////////////////////////////////////////////////////////
  512. char szBounceMsg[512] = "";
  514. SysSNPrintf(szBounceMsg, sizeof(szBounceMsg) - 1,
  515.     "Unknown user "%s" in domain "%s"", szDestUser,
  516.     szDestDomain);
  518. QueUtErrLogMessage(hQueue, hMessage, "%sn", szBounceMsg);
  520. QueUtNotifyPermErrDelivery(hQueue, hMessage, hFSpool, szBounceMsg, NULL,
  521.    true);
  523. return (ErrorPop());
  524. }
  525. } else {
  526. ///////////////////////////////////////////////////////////////////////////////
  527. //  Remote user case ( or custom domain user )
  528. ///////////////////////////////////////////////////////////////////////////////
  529. if (SMAILHandleRemoteUserMessage(hSvrConfig, hShbSMAIL, hFSpool,
  530.  hQueue, hMessage, szDestDomain, szDestUser) < 0)
  531. return (ErrGetErrorCode());
  533. }
  535. return (0);
  537. }
  539. static int SMAILMailingListExplode(UserInfo * pUI, SPLF_HANDLE hFSpool)
  540. {
  542. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  543. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  545. char szDestUser[MAX_ADDR_NAME] = "";
  546. char szDestDomain[MAX_ADDR_NAME] = "";
  548. if (USmtpSplitEmailAddr(ppszRcpt[0], szDestUser, szDestDomain) < 0)
  549. return (ErrGetErrorCode());
  551. ///////////////////////////////////////////////////////////////////////////////
  552. //  Get Mailing List Sender address. If this account variable does not exist
  553. //  the sender will be the "real" message sender
  554. ///////////////////////////////////////////////////////////////////////////////
  555. char *pszMLSender = UsrGetUserInfoVar(pUI, "ListSender");
  557. ///////////////////////////////////////////////////////////////////////////////
  558. //  Check if the use of the Reply-To: is requested
  559. ///////////////////////////////////////////////////////////////////////////////
  560. int iUseReplyTo = UsrGetUserInfoVarInt(pUI, "UseReplyTo", 1);
  562. USRML_HANDLE hUsersDB = UsrMLOpenDB(pUI);
  564. if (hUsersDB == INVALID_USRML_HANDLE) {
  565. ErrorPush();
  566. SysFreeCheck(pszMLSender);
  567. return (ErrorPop());
  568. }
  569. ///////////////////////////////////////////////////////////////////////////////
  570. //  Mailing list scan
  571. ///////////////////////////////////////////////////////////////////////////////
  572. MLUserInfo *pMLUI = UsrMLGetFirstUser(hUsersDB);
  574. for (; pMLUI != NULL; pMLUI = UsrMLGetNextUser(hUsersDB)) {
  575. if (strchr(pMLUI->pszPerms, 'R') != NULL) {
  576. ///////////////////////////////////////////////////////////////////////////////
  577. //  Get message handle
  578. ///////////////////////////////////////////////////////////////////////////////
  579. QMSG_HANDLE hMessage = QueCreateMessage(hSpoolQueue);
  581. if (hMessage == INVALID_QMSG_HANDLE) {
  582. ErrorPush();
  583. SysFreeCheck(pszMLSender);
  584. UsrMLFreeUser(pMLUI);
  585. UsrMLCloseDB(hUsersDB);
  586. return (ErrorPop());
  587. }
  589. char szQueueFilePath[SYS_MAX_PATH] = "";
  591. QueGetFilePath(hSpoolQueue, hMessage, szQueueFilePath);
  593. ///////////////////////////////////////////////////////////////////////////////
  594. //  Create spool file. If "pszMLSender" is NULL the original sender is kept
  595. ///////////////////////////////////////////////////////////////////////////////
  596. if (USmlCreateSpoolFile
  597.     (hFSpool, pszMLSender, pMLUI->pszAddress, szQueueFilePath,
  598.      (iUseReplyTo != 0) ? "Reply-To" : "", ppszRcpt[0], NULL) < 0) {
  599. ErrorPush();
  600. QueCleanupMessage(hSpoolQueue, hMessage);
  601. QueCloseMessage(hSpoolQueue, hMessage);
  602. SysFreeCheck(pszMLSender);
  603. UsrMLFreeUser(pMLUI);
  604. UsrMLCloseDB(hUsersDB);
  605. return (ErrorPop());
  606. }
  607. ///////////////////////////////////////////////////////////////////////////////
  608. //  Transfer file to the spool
  609. ///////////////////////////////////////////////////////////////////////////////
  610. if (QueCommitMessage(hSpoolQueue, hMessage) < 0) {
  611. ErrorPush();
  612. QueCleanupMessage(hSpoolQueue, hMessage);
  613. QueCloseMessage(hSpoolQueue, hMessage);
  614. SysFreeCheck(pszMLSender);
  615. UsrMLFreeUser(pMLUI);
  616. UsrMLCloseDB(hUsersDB);
  617. return (ErrorPop());
  618. }
  619. }
  621. UsrMLFreeUser(pMLUI);
  622. }
  624. UsrMLCloseDB(hUsersDB);
  626. SysFreeCheck(pszMLSender);
  628. return (0);
  630. }
  632. static int SMAILRemoteMsgSMTPSend(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  633.   SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage,
  634.   char const *pszDestDomain, SMTPError * pSMTPE)
  635. {
  636. ///////////////////////////////////////////////////////////////////////////////
  637. //  Apply filters ...
  638. ///////////////////////////////////////////////////////////////////////////////
  639. if (FilFilterMessage(hFSpool, hQueue, hMessage, FILTER_MODE_OUTBOUND) < 0)
  640. return (ErrGetErrorCode());
  642. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  643. char const *pszSmtpMessageID = USmlGetSmtpMessageID(hFSpool);
  644. char const *pszSpoolFile = USmlGetSpoolFile(hFSpool);
  645. char const *pszSpoolFilePath = USmlGetSpoolFilePath(hFSpool);
  646. char const *pszMailFrom = USmlMailFrom(hFSpool);
  647. char const *pszSendMailFrom = USmlSendMailFrom(hFSpool);
  648. char const *pszRcptTo = USmlRcptTo(hFSpool);
  649. char const *pszSendRcptTo = USmlSendRcptTo(hFSpool);
  650. char const *pszRelayDomain = USmlGetRelayDomain(hFSpool);
  651. FileSection FS;
  653. ///////////////////////////////////////////////////////////////////////////////
  654. //  This function retrieve the spool file message section and sync the content.
  655. //  This is necessary before sending the file
  656. ///////////////////////////////////////////////////////////////////////////////
  657. if (USmlGetMsgFileSection(hFSpool, FS) < 0)
  658. return (ErrGetErrorCode());
  660. ///////////////////////////////////////////////////////////////////////////////
  661. //  Get HELO domain
  662. ///////////////////////////////////////////////////////////////////////////////
  663. char szHeloDomain[MAX_HOST_NAME] = "";
  665. SvrConfigVar("HeloDomain", szHeloDomain, sizeof(szHeloDomain) - 1, hSvrConfig, "");
  667. char const *pszHeloDomain = IsEmptyString(szHeloDomain) ? NULL : szHeloDomain;
  669. ///////////////////////////////////////////////////////////////////////////////
  670. //  If it's a relayed message use the associated relay
  671. ///////////////////////////////////////////////////////////////////////////////
  672. if (pszRelayDomain != NULL) {
  673. SysLogMessage(LOG_LEV_MESSAGE,
  674.       "SMAIL SMTP-Send CMX = "%s" SMTP = "%s" From = "%s" To = "%s"n",
  675.       pszRelayDomain, pszSMTPDomain, pszMailFrom, pszRcptTo);
  677. if (pSMTPE != NULL)
  678. USmtpCleanupError(pSMTPE);
  680. if (USmtpSendMail(pszRelayDomain, pszHeloDomain, pszSendMailFrom, pszSendRcptTo,
  681.   &FS, pSMTPE) < 0) {
  682. ErrorPush();
  684. char szSmtpError[512] = "";
  686. USmtpGetSMTPError(pSMTPE, szSmtpError, sizeof(szSmtpError));
  688. ErrLogMessage(LOG_LEV_MESSAGE,
  689.       "SMAIL SMTP-Send CMX = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  690.       "%s = "%s"n"
  691.       "%s = "%s"n", pszRelayDomain, pszSMTPDomain, pszMailFrom,
  692.       pszRcptTo, SMTP_ERROR_VARNAME, szSmtpError,
  693.       SMTP_SERVER_VARNAME, USmtpGetErrorServer(pSMTPE));
  695. QueUtErrLogMessage(hQueue, hMessage,
  696.    "SMAIL SMTP-Send CMX = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  697.    "%s = "%s"n"
  698.    "%s = "%s"n", pszRelayDomain, pszSMTPDomain,
  699.    pszMailFrom, pszRcptTo, SMTP_ERROR_VARNAME,
  700.    szSmtpError, SMTP_SERVER_VARNAME,
  701.    USmtpGetErrorServer(pSMTPE));
  703. return (ErrorPop());
  704. }
  706. if (SMAILLogEnabled(hShbSMAIL))
  707. USmlLogMessage(hFSpool, "SMTP", pszRelayDomain);
  709. return (0);
  710. }
  711. ///////////////////////////////////////////////////////////////////////////////
  712. //  Check the existance of direct SMTP forwarders
  713. ///////////////////////////////////////////////////////////////////////////////
  714. char **ppszFwdGws = USmtpGetFwdGateways(hSvrConfig, pszDestDomain);
  716. if (ppszFwdGws != NULL) {
  717. ///////////////////////////////////////////////////////////////////////////////
  718. //  By initializing this to zero makes XMail to discharge all mail for domains
  719. //  that have an empty forwarders list
  720. ///////////////////////////////////////////////////////////////////////////////
  721. int iSendErrorCode = 0;
  723. for (int ss = 0; ppszFwdGws[ss] != NULL; ss++) {
  724. SysLogMessage(LOG_LEV_MESSAGE,
  725.       "SMAIL SMTP-Send FWD = "%s" SMTP = "%s" From = "%s" To = "%s"n",
  726.       ppszFwdGws[ss], pszSMTPDomain, pszMailFrom, pszRcptTo);
  728. if (pSMTPE != NULL)
  729. USmtpCleanupError(pSMTPE);
  731. if ((iSendErrorCode = USmtpSendMail(ppszFwdGws[ss], pszHeloDomain,
  732.     pszSendMailFrom, pszSendRcptTo, &FS,
  733.     pSMTPE)) == 0) {
  734. ///////////////////////////////////////////////////////////////////////////////
  735. //  Log Mailer operation
  736. ///////////////////////////////////////////////////////////////////////////////
  737. if (SMAILLogEnabled(hShbSMAIL))
  738. USmlLogMessage(hFSpool, "FWD", ppszFwdGws[ss]);
  740. break;
  741. }
  743. char szSmtpError[512] = "";
  745. USmtpGetSMTPError(pSMTPE, szSmtpError, sizeof(szSmtpError));
  747. ErrLogMessage(LOG_LEV_MESSAGE,
  748.       "SMAIL SMTP-Send FWD = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  749.       "%s = "%s"n"
  750.       "%s = "%s"n", ppszFwdGws[ss], pszSMTPDomain, pszMailFrom,
  751.       pszRcptTo, SMTP_ERROR_VARNAME, szSmtpError,
  752.       SMTP_SERVER_VARNAME, USmtpGetErrorServer(pSMTPE));
  754. QueUtErrLogMessage(hQueue, hMessage,
  755.    "SMAIL SMTP-Send FWD = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  756.    "%s = "%s"n"
  757.    "%s = "%s"n", ppszFwdGws[ss], pszSMTPDomain,
  758.    pszMailFrom, pszRcptTo, SMTP_ERROR_VARNAME,
  759.    szSmtpError, SMTP_SERVER_VARNAME,
  760.    USmtpGetErrorServer(pSMTPE));
  762. if ((pSMTPE != NULL) && USmtpIsFatalError(pSMTPE))
  763. break;
  764. }
  766. StrFreeStrings(ppszFwdGws);
  768. return (iSendErrorCode);
  769. }
  770. ///////////////////////////////////////////////////////////////////////////////
  771. //  Try to get custom mail exchangers or DNS mail exchangers and if both tests
  772. //  fails try direct
  773. ///////////////////////////////////////////////////////////////////////////////
  774. char **ppszMXGWs = USmtpGetMailExchangers(hSvrConfig, pszDestDomain);
  776. if (ppszMXGWs == NULL) {
  777. char szDomainMXHost[256] = "";
  778. MXS_HANDLE hMXSHandle = USmtpGetMXFirst(hSvrConfig, pszDestDomain,
  779. szDomainMXHost);
  781. if (hMXSHandle != INVALID_MXS_HANDLE) {
  782. int iSendErrorCode = 0;
  784. do {
  785. SysLogMessage(LOG_LEV_MESSAGE,
  786.       "SMAIL SMTP-Send MX = "%s" SMTP = "%s" From = "%s" To = "%s"n",
  787.       szDomainMXHost, pszSMTPDomain, pszMailFrom,
  788.       pszRcptTo);
  790. if (pSMTPE != NULL)
  791. USmtpCleanupError(pSMTPE);
  793. if ((iSendErrorCode = USmtpSendMail(szDomainMXHost, pszHeloDomain,
  794.     pszSendMailFrom,
  795.     pszSendRcptTo, &FS,
  796.     pSMTPE)) == 0) {
  797. ///////////////////////////////////////////////////////////////////////////////
  798. //  Log Mailer operation
  799. ///////////////////////////////////////////////////////////////////////////////
  800. if (SMAILLogEnabled(hShbSMAIL))
  801. USmlLogMessage(hFSpool, "SMTP", szDomainMXHost);
  803. break;
  804. }
  806. char szSmtpError[512] = "";
  808. USmtpGetSMTPError(pSMTPE, szSmtpError, sizeof(szSmtpError));
  810. ErrLogMessage(LOG_LEV_MESSAGE,
  811.       "SMAIL SMTP-Send MX = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  812.       "%s = "%s"n"
  813.       "%s = "%s"n", szDomainMXHost, pszSMTPDomain,
  814.       pszMailFrom, pszRcptTo, SMTP_ERROR_VARNAME,
  815.       szSmtpError, SMTP_SERVER_VARNAME,
  816.       USmtpGetErrorServer(pSMTPE));
  818. QueUtErrLogMessage(hQueue, hMessage,
  819.    "SMAIL SMTP-Send MX = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  820.    "%s = "%s"n"
  821.    "%s = "%s"n", szDomainMXHost, pszSMTPDomain,
  822.    pszMailFrom, pszRcptTo, SMTP_ERROR_VARNAME,
  823.    szSmtpError, SMTP_SERVER_VARNAME,
  824.    USmtpGetErrorServer(pSMTPE));
  826. if ((pSMTPE != NULL) && USmtpIsFatalError(pSMTPE))
  827. break;
  829. } while (USmtpGetMXNext(hMXSHandle, szDomainMXHost) == 0);
  831. USmtpMXSClose(hMXSHandle);
  833. if (iSendErrorCode < 0)
  834. return (iSendErrorCode);
  836. } else {
  837. ///////////////////////////////////////////////////////////////////////////////
  838. //  MX records for destination domain not found, try direct !
  839. ///////////////////////////////////////////////////////////////////////////////
  840. SysLogMessage(LOG_LEV_MESSAGE,
  841.       "MX records for domain "%s" not found, trying direct.n",
  842.       pszDestDomain);
  844. SysLogMessage(LOG_LEV_MESSAGE,
  845.       "SMAIL SMTP-Send FF = "%s" SMTP = "%s" From = "%s" To = "%s"n",
  846.       pszDestDomain, pszSMTPDomain, pszMailFrom, pszRcptTo);
  848. if (pSMTPE != NULL)
  849. USmtpCleanupError(pSMTPE);
  851. if (USmtpSendMail
  852.     (pszDestDomain, pszHeloDomain, pszSendMailFrom, pszSendRcptTo, &FS,
  853.      pSMTPE) < 0) {
  854. ErrorPush();
  856. char szSmtpError[512] = "";
  858. USmtpGetSMTPError(pSMTPE, szSmtpError, sizeof(szSmtpError));
  860. ErrLogMessage(LOG_LEV_MESSAGE,
  861.       "SMAIL SMTP-Send FF = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  862.       "%s = "%s"n"
  863.       "%s = "%s"n", pszDestDomain, pszSMTPDomain,
  864.       pszMailFrom, pszRcptTo, SMTP_ERROR_VARNAME,
  865.       szSmtpError, SMTP_SERVER_VARNAME,
  866.       USmtpGetErrorServer(pSMTPE));
  868. QueUtErrLogMessage(hQueue, hMessage,
  869.    "SMAIL SMTP-Send FF = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  870.    "%s = "%s"n"
  871.    "%s = "%s"n", pszDestDomain, pszSMTPDomain,
  872.    pszMailFrom, pszRcptTo, SMTP_ERROR_VARNAME,
  873.    szSmtpError, SMTP_SERVER_VARNAME,
  874.    USmtpGetErrorServer(pSMTPE));
  876. return (ErrorPop());
  877. }
  878. ///////////////////////////////////////////////////////////////////////////////
  879. //  Log Mailer operation
  880. ///////////////////////////////////////////////////////////////////////////////
  881. if (SMAILLogEnabled(hShbSMAIL))
  882. USmlLogMessage(hFSpool, "SMTP", pszDestDomain);
  883. }
  884. } else {
  885. int iSendErrorCode = 0;
  887. for (int ss = 0; ppszMXGWs[ss] != NULL; ss++) {
  888. SysLogMessage(LOG_LEV_MESSAGE,
  889.       "SMAIL SMTP-Send MX = "%s" SMTP = "%s" From = "%s" To = "%s"n",
  890.       ppszMXGWs[ss], pszSMTPDomain, pszMailFrom, pszRcptTo);
  892. if (pSMTPE != NULL)
  893. USmtpCleanupError(pSMTPE);
  895. if ((iSendErrorCode = USmtpSendMail(ppszMXGWs[ss], pszHeloDomain,
  896.     pszSendMailFrom, pszSendRcptTo, &FS,
  897.     pSMTPE)) == 0) {
  898. ///////////////////////////////////////////////////////////////////////////////
  899. //  Log Mailer operation
  900. ///////////////////////////////////////////////////////////////////////////////
  901. if (SMAILLogEnabled(hShbSMAIL))
  902. USmlLogMessage(hFSpool, "SMTP", ppszMXGWs[ss]);
  904. break;
  905. }
  907. char szSmtpError[512] = "";
  909. USmtpGetSMTPError(pSMTPE, szSmtpError, sizeof(szSmtpError));
  911. ErrLogMessage(LOG_LEV_MESSAGE,
  912.       "SMAIL SMTP-Send MX = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  913.       "%s = "%s"n"
  914.       "%s = "%s"n", ppszMXGWs[ss], pszSMTPDomain, pszMailFrom,
  915.       pszRcptTo, SMTP_ERROR_VARNAME, szSmtpError,
  916.       SMTP_SERVER_VARNAME, USmtpGetErrorServer(pSMTPE));
  918. QueUtErrLogMessage(hQueue, hMessage,
  919.    "SMAIL SMTP-Send MX = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  920.    "%s = "%s"n"
  921.    "%s = "%s"n", ppszMXGWs[ss], pszSMTPDomain,
  922.    pszMailFrom, pszRcptTo, SMTP_ERROR_VARNAME,
  923.    szSmtpError, SMTP_SERVER_VARNAME,
  924.    USmtpGetErrorServer(pSMTPE));
  926. if ((pSMTPE != NULL) && USmtpIsFatalError(pSMTPE))
  927. break;
  928. }
  930. StrFreeStrings(ppszMXGWs);
  932. if (iSendErrorCode < 0)
  933. return (iSendErrorCode);
  934. }
  936. return (0);
  938. }
  940. static int SMAILHandleRemoteUserMessage(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  941. SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  942. QMSG_HANDLE hMessage, char const *pszDestDomain,
  943. char const *pszDestUser)
  944. {
  946. ///////////////////////////////////////////////////////////////////////////////
  947. //  Try domain custom processing
  948. ///////////////////////////////////////////////////////////////////////////////
  949. char szCustFilePath[SYS_MAX_PATH] = "";
  951. if (USmlGetDomainMsgCustomFile(hFSpool, hQueue, hMessage, pszDestDomain,
  952.        szCustFilePath) == 0)
  953. return (SMAILCustomProcessMessage
  954. (hSvrConfig, hShbSMAIL, hFSpool, hQueue, hMessage, pszDestDomain,
  955.  pszDestUser, szCustFilePath));
  957. ///////////////////////////////////////////////////////////////////////////////
  958. //  Fall down to use standard SMTP delivery
  959. ///////////////////////////////////////////////////////////////////////////////
  960. SMTPError SMTPE;
  962. USmtpInitError(&SMTPE);
  964. if (SMAILRemoteMsgSMTPSend(hSvrConfig, hShbSMAIL, hFSpool, hQueue, hMessage,
  965.    pszDestDomain, &SMTPE) < 0) {
  966. ErrorPush();
  967. ///////////////////////////////////////////////////////////////////////////////
  968. //  If a permanent SMTP error has been detected, then notify the message
  969. //  sender and remove the spool file
  970. ///////////////////////////////////////////////////////////////////////////////
  971. if (USmtpIsFatalError(&SMTPE))
  972. QueUtNotifyPermErrDelivery(hQueue, hMessage, hFSpool,
  973.    USmtpGetErrorMessage(&SMTPE),
  974.    USmtpGetErrorServer(&SMTPE), true);
  976. USmtpCleanupError(&SMTPE);
  978. return (ErrorPop());
  979. }
  981. USmtpCleanupError(&SMTPE);
  983. return (0);
  985. }
  987. static int SMAILCustomProcessMessage(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  988.      SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  989.      QMSG_HANDLE hMessage, char const *pszDestDomain,
  990.      char const *pszDestUser, char const *pszCustFilePath)
  991. {
  993. FILE *pCPFile = fopen(pszCustFilePath, "rt");
  995. if (pCPFile == NULL) {
  996. ErrSetErrorCode(ERR_FILE_OPEN, pszCustFilePath);
  997. return (ERR_FILE_OPEN);
  998. }
  999. ///////////////////////////////////////////////////////////////////////////////
  1000. //  Create pushback command file
  1001. ///////////////////////////////////////////////////////////////////////////////
  1002. char szTmpFile[SYS_MAX_PATH] = "";
  1004. SysGetTmpFile(szTmpFile);
  1006. FILE *pPushBFile = fopen(szTmpFile, "wt");
  1008. if (pPushBFile == NULL) {
  1009. fclose(pCPFile);
  1011. ErrSetErrorCode(ERR_FILE_CREATE, szTmpFile);
  1012. return (ERR_FILE_CREATE);
  1013. }
  1015. int iPushBackCmds = 0;
  1016. char szCmdLine[CUSTOM_PROC_LINE_MAX] = "";
  1018. while (MscGetConfigLine(szCmdLine, sizeof(szCmdLine) - 1, pCPFile) != NULL) {
  1019. char **ppszCmdTokens = StrGetTabLineStrings(szCmdLine);
  1021. if (ppszCmdTokens == NULL)
  1022. continue;
  1024. int iFieldsCount = StrStringsCount(ppszCmdTokens);
  1026. if (iFieldsCount > 0) {
  1027. ///////////////////////////////////////////////////////////////////////////////
  1028. //  Do command line macro substitution
  1029. ///////////////////////////////////////////////////////////////////////////////
  1030. SMAILCmdMacroSubstitutes(ppszCmdTokens, hFSpool);
  1032. int iCmdResult = 0;
  1034. if (stricmp(ppszCmdTokens[0], "external") == 0)
  1035. iCmdResult =
  1036. SMAILCmd_external(hSvrConfig, hShbSMAIL, pszDestDomain,
  1037.   ppszCmdTokens, iFieldsCount, hFSpool,
  1038.   hQueue, hMessage);
  1039. else if (stricmp(ppszCmdTokens[0], "filter") == 0)
  1040. iCmdResult = SMAILCmd_filter(hSvrConfig, hShbSMAIL, pszDestDomain,
  1041.      ppszCmdTokens, iFieldsCount, hFSpool,
  1042.      hQueue, hMessage);
  1043. else if (stricmp(ppszCmdTokens[0], "smtp") == 0)
  1044. iCmdResult = SMAILCmd_smtp(hSvrConfig, hShbSMAIL, pszDestDomain,
  1045.    ppszCmdTokens, iFieldsCount, hFSpool,
  1046.    hQueue, hMessage);
  1047. else if (stricmp(ppszCmdTokens[0], "smtprelay") == 0)
  1048. iCmdResult =
  1049. SMAILCmd_smtprelay(hSvrConfig, hShbSMAIL, pszDestDomain,
  1050.    ppszCmdTokens, iFieldsCount, hFSpool,
  1051.    hQueue, hMessage);
  1052. else if (stricmp(ppszCmdTokens[0], "redirect") == 0)
  1053. iCmdResult =
  1054. SMAILCmd_redirect(hSvrConfig, hShbSMAIL, pszDestDomain,
  1055.   ppszCmdTokens, iFieldsCount, hFSpool,
  1056.   hQueue, hMessage);
  1057. else if (stricmp(ppszCmdTokens[0], "lredirect") == 0)
  1058. iCmdResult =
  1059. SMAILCmd_lredirect(hSvrConfig, hShbSMAIL, pszDestDomain,
  1060.    ppszCmdTokens, iFieldsCount, hFSpool,
  1061.    hQueue, hMessage);
  1062. else {
  1063. SysLogMessage(LOG_LEV_ERROR,
  1064.       "Invalid command "%s" in file "%s"n",
  1065.       ppszCmdTokens[0], pszCustFilePath);
  1067. }
  1069. ///////////////////////////////////////////////////////////////////////////////
  1070. //  Check for the stop-processing error code
  1071. ///////////////////////////////////////////////////////////////////////////////
  1072. if (iCmdResult == SMAIL_STOP_PROCESSING) {
  1073. StrFreeStrings(ppszCmdTokens);
  1074. break;
  1075. }
  1076. ///////////////////////////////////////////////////////////////////////////////
  1077. //  Test if we must save a failed command
  1078. //  <0 = Error ; ==0 = Success ; >0 = Transient error ( save the command )
  1079. ///////////////////////////////////////////////////////////////////////////////
  1080. if (iCmdResult > 0) {
  1081. fprintf(pPushBFile, "%sn", szCmdLine);
  1083. ++iPushBackCmds;
  1084. }
  1085. ///////////////////////////////////////////////////////////////////////////////
  1086. //  An error code might result if filters blocked the message. If this is the
  1087. //  case QueCheckMessage() will return error and we MUST stop processing
  1088. ///////////////////////////////////////////////////////////////////////////////
  1089. if ((iCmdResult < 0) && (QueCheckMessage(hQueue, hMessage) < 0)) {
  1090. ErrorPush();
  1091. StrFreeStrings(ppszCmdTokens);
  1092. fclose(pPushBFile);
  1093. fclose(pCPFile);
  1094. SysRemove(szTmpFile);
  1095. return (ErrorPop());
  1096. }
  1097. }
  1099. StrFreeStrings(ppszCmdTokens);
  1100. }
  1102. fclose(pPushBFile);
  1103. fclose(pCPFile);
  1105. SysRemove(pszCustFilePath);
  1107. if (iPushBackCmds > 0) {
  1108. ///////////////////////////////////////////////////////////////////////////////
  1109. //  If commands left out of processing, push them into the custom file
  1110. ///////////////////////////////////////////////////////////////////////////////
  1111. if (MscMoveFile(szTmpFile, pszCustFilePath) < 0)
  1112. return (ErrGetErrorCode());
  1114. ErrSetErrorCode(ERR_INCOMPLETE_PROCESSING);
  1115. return (ERR_INCOMPLETE_PROCESSING);
  1116. }
  1118. SysRemove(szTmpFile);
  1120. return (0);
  1122. }
  1124. static int SMAILCmdMacroSubstitutes(char **ppszCmdTokens, SPLF_HANDLE hFSpool)
  1125. {
  1127. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  1128. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  1129. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  1130. char const *pszSmtpMessageID = USmlGetSmtpMessageID(hFSpool);
  1131. char const *pszMessageID = USmlGetSpoolFile(hFSpool);
  1132. int iFromDomains = StrStringsCount(ppszFrom);
  1133. int iRcptDomains = StrStringsCount(ppszRcpt);
  1134. FileSection FS;
  1136. ///////////////////////////////////////////////////////////////////////////////
  1137. //  This function retrieve the spool file message section and sync the content.
  1138. //  This is necessary before passing the file name to external programs
  1139. ///////////////////////////////////////////////////////////////////////////////
  1140. if (USmlGetMsgFileSection(hFSpool, FS) < 0)
  1141. return (ErrGetErrorCode());
  1143. for (int ii = 0; ppszCmdTokens[ii] != NULL; ii++) {
  1144. if (strcmp(ppszCmdTokens[ii], "@@FROM") == 0) {
  1145. char *pszNewValue =
  1146. SysStrDup((iFromDomains > 0) ? ppszFrom[iFromDomains - 1] : "");
  1148. if (pszNewValue == NULL)
  1149. return (ErrGetErrorCode());
  1151. SysFree(ppszCmdTokens[ii]);
  1153. ppszCmdTokens[ii] = pszNewValue;
  1154. } else if (strcmp(ppszCmdTokens[ii], "@@RCPT") == 0) {
  1155. char *pszNewValue =
  1156. SysStrDup((iRcptDomains > 0) ? ppszRcpt[iRcptDomains - 1] : "");
  1158. if (pszNewValue == NULL)
  1159. return (ErrGetErrorCode());
  1161. SysFree(ppszCmdTokens[ii]);
  1163. ppszCmdTokens[ii] = pszNewValue;
  1164. } else if (strcmp(ppszCmdTokens[ii], "@@FILE") == 0) {
  1165. char *pszNewValue = SysStrDup(FS.szFilePath);
  1167. if (pszNewValue == NULL)
  1168. return (ErrGetErrorCode());
  1170. SysFree(ppszCmdTokens[ii]);
  1172. ppszCmdTokens[ii] = pszNewValue;
  1173. } else if (strcmp(ppszCmdTokens[ii], "@@MSGID") == 0) {
  1174. char *pszNewValue = SysStrDup(pszMessageID);
  1176. if (pszNewValue == NULL)
  1177. return (ErrGetErrorCode());
  1179. SysFree(ppszCmdTokens[ii]);
  1181. ppszCmdTokens[ii] = pszNewValue;
  1182. } else if (strcmp(ppszCmdTokens[ii], "@@MSGREF") == 0) {
  1183. char *pszNewValue = SysStrDup(pszSmtpMessageID);
  1185. if (pszNewValue == NULL)
  1186. return (ErrGetErrorCode());
  1188. SysFree(ppszCmdTokens[ii]);
  1190. ppszCmdTokens[ii] = pszNewValue;
  1191. } else if (strcmp(ppszCmdTokens[ii], "@@TMPFILE") == 0) {
  1192. char szTmpFile[SYS_MAX_PATH] = "";
  1194. SysGetTmpFile(szTmpFile);
  1196. if (MscCopyFile(szTmpFile, FS.szFilePath) < 0) {
  1197. ErrorPush();
  1198. CheckRemoveFile(szTmpFile);
  1199. return (ErrorPop());
  1200. }
  1202. char *pszNewValue = SysStrDup(szTmpFile);
  1204. if (pszNewValue == NULL)
  1205. return (ErrGetErrorCode());
  1207. SysFree(ppszCmdTokens[ii]);
  1209. ppszCmdTokens[ii] = pszNewValue;
  1210. } else if (strcmp(ppszCmdTokens[ii], "@@USERAUTH") == 0) {
  1211. char szAuthName[MAX_ADDR_NAME] = "-";
  1213. USmlMessageAuth(hFSpool, szAuthName, sizeof(szAuthName) - 1);
  1215. char *pszNewValue = SysStrDup(szAuthName);
  1217. if (pszNewValue == NULL)
  1218. return (ErrGetErrorCode());
  1220. SysFree(ppszCmdTokens[ii]);
  1222. ppszCmdTokens[ii] = pszNewValue;
  1223. }
  1225. }
  1227. return (0);
  1229. }
  1231. static int SMAILCmd_external(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  1232.      char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  1233.      SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage)
  1234. {
  1235. ///////////////////////////////////////////////////////////////////////////////
  1236. //  Apply filters ...
  1237. ///////////////////////////////////////////////////////////////////////////////
  1238. if (FilFilterMessage(hFSpool, hQueue, hMessage, FILTER_MODE_INBOUND) < 0)
  1239. return (ErrGetErrorCode());
  1241. if (iNumTokens < 5) {
  1242. ErrSetErrorCode(ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1243. return (ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1244. }
  1246. int iPriority = atoi(ppszCmdTokens[1]);
  1247. int iWaitTimeout = atoi(ppszCmdTokens[2]);
  1248. int iExitStatus = 0;
  1250. if (SysExec(ppszCmdTokens[3], &ppszCmdTokens[3], iWaitTimeout, iPriority,
  1251.     &iExitStatus) < 0) {
  1252. ErrorPush();
  1254. char const *pszMailFrom = USmlMailFrom(hFSpool);
  1255. char const *pszRcptTo = USmlRcptTo(hFSpool);
  1257. ErrLogMessage(LOG_LEV_MESSAGE,
  1258.       "SMAIL EXTRN-Send Prg = "%s" Domain = "%s" From = "%s" To = "%s" Failed !n",
  1259.       ppszCmdTokens[3], pszDestDomain, pszMailFrom, pszRcptTo);
  1261. QueUtErrLogMessage(hQueue, hMessage,
  1262.    "SMAIL EXTRN-Send Prg = "%s" Domain = "%s" From = "%s" To = "%s" Failed !n",
  1263.    ppszCmdTokens[3], pszDestDomain, pszMailFrom, pszRcptTo);
  1265. return (ErrorPop());
  1266. }
  1267. ///////////////////////////////////////////////////////////////////////////////
  1268. //  Log Mailer operation
  1269. ///////////////////////////////////////////////////////////////////////////////
  1270. if (SMAILLogEnabled(hShbSMAIL))
  1271. USmlLogMessage(hFSpool, "EXTRN", ppszCmdTokens[3]);
  1273. return ((iExitStatus == SMAIL_EXTERNAL_EXIT_BREAK) ? SMAIL_STOP_PROCESSING: 0);
  1275. }
  1277. static int SMAILCmd_filter(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  1278.    char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  1279.    SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage)
  1280. {
  1282. if (iNumTokens < 5) {
  1283. ErrSetErrorCode(ERR_BAD_MAILPROC_CMD_SYNTAX);
  1284. return (ERR_BAD_MAILPROC_CMD_SYNTAX);
  1285. }
  1287. int iPriority = atoi(ppszCmdTokens[1]);
  1288. int iWaitTimeout = atoi(ppszCmdTokens[2]);
  1289. int iExitStatus = 0;
  1291. if (SysExec(ppszCmdTokens[3], &ppszCmdTokens[3], iWaitTimeout, iPriority,
  1292.     &iExitStatus) < 0) {
  1293. ErrorPush();
  1295. char const *pszMailFrom = USmlMailFrom(hFSpool);
  1296. char const *pszRcptTo = USmlRcptTo(hFSpool);
  1298. ErrLogMessage(LOG_LEV_MESSAGE,
  1299.       "USMAIL FILTER Prg = "%s" From = "%s" To = "%s" Failed !n",
  1300.       ppszCmdTokens[3], pszMailFrom, pszRcptTo);
  1302. QueUtErrLogMessage(hQueue, hMessage,
  1303.    "USMAIL FILTER Prg = "%s" From = "%s" To = "%s" Failed !n",
  1304.    ppszCmdTokens[3], pszMailFrom, pszRcptTo);
  1306. return (ErrorPop());
  1307. }
  1309. ///////////////////////////////////////////////////////////////////////////////
  1310. //  Log Mailer operation
  1311. ///////////////////////////////////////////////////////////////////////////////
  1312. if (SMAILLogEnabled(hShbSMAIL))
  1313. USmlLogMessage(hFSpool, "FILTER", ppszCmdTokens[3]);
  1315. ///////////////////////////////////////////////////////////////////////////////
  1316. //  Separate code from flags
  1317. ///////////////////////////////////////////////////////////////////////////////
  1318. int iExitFlags = iExitStatus & FILTER_FLAGS_MASK;
  1320. iExitStatus &= ~FILTER_FLAGS_MASK;
  1322. if ((iExitStatus == FILTER_OUT_EXITCODE) ||
  1323.     (iExitStatus == FILTER_OUT_NN_EXITCODE) ||
  1324.     (iExitStatus == FILTER_OUT_NNF_EXITCODE)) {
  1325. ///////////////////////////////////////////////////////////////////////////////
  1326. //  Filter out message
  1327. ///////////////////////////////////////////////////////////////////////////////
  1328. char *pszRejMsg = FilGetFilterRejMessage(USmlGetSpoolFilePath(hFSpool));
  1330. if (iExitStatus == FILTER_OUT_EXITCODE)
  1331. QueUtNotifyPermErrDelivery(hQueue, hMessage, NULL,
  1332.    (pszRejMsg != NULL) ? pszRejMsg :
  1333.    ErrGetErrorString(ERR_FILTERED_MESSAGE),
  1334.    NULL, true);
  1335. else if (iExitStatus == FILTER_OUT_NN_EXITCODE)
  1336. QueCleanupMessage(hQueue, hMessage,
  1337.   !QueUtRemoveSpoolErrors());
  1338. else
  1339. QueCleanupMessage(hQueue, hMessage, false);
  1341. if (pszRejMsg != NULL)
  1342. SysFree(pszRejMsg);
  1344. ErrSetErrorCode(ERR_FILTERED_MESSAGE);
  1345. return (ERR_FILTERED_MESSAGE);
  1346. } else if (iExitStatus == FILTER_MODIFY_EXITCODE) {
  1347. ///////////////////////////////////////////////////////////////////////////////
  1348. //  Filter modified the message, we need to reload the spool handle
  1349. ///////////////////////////////////////////////////////////////////////////////
  1350. if (USmlReloadHandle(hFSpool) < 0) {
  1351. ErrorPush();
  1353. char const *pszMailFrom = USmlMailFrom(hFSpool);
  1354. char const *pszRcptTo = USmlRcptTo(hFSpool);
  1356. SysLogMessage(LOG_LEV_MESSAGE,
  1357.       "Filter error [ Modified message corrupted ]: Sender = "%s" Recipient = "%s" (%s)n",
  1358.       pszMailFrom, pszRcptTo,
  1359.       ppszCmdTokens[3]);
  1361. QueUtErrLogMessage(hQueue, hMessage,
  1362.    "Filter error [ Modified message corrupted ]: Sender = "%s" Recipient = "%s" (%s)n",
  1363.    pszMailFrom, pszRcptTo,
  1364.    ppszCmdTokens[3]);
  1366. QueCleanupMessage(hQueue, hMessage, true);
  1368. return (ErrorPop());
  1369. }
  1370. }
  1372. return ((iExitFlags & FILTER_FLAGS_BREAK) ? SMAIL_STOP_PROCESSING: 0);
  1374. }
  1376. static int SMAILCmd_smtp(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  1377.  char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  1378.  SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage)
  1379. {
  1381. if (iNumTokens != 1) {
  1382. ErrSetErrorCode(ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1383. return (ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1384. }
  1386. SMTPError SMTPE;
  1388. USmtpInitError(&SMTPE);
  1390. if (SMAILRemoteMsgSMTPSend(hSvrConfig, hShbSMAIL, hFSpool, hQueue, hMessage,
  1391.    pszDestDomain, &SMTPE) < 0) {
  1392. ///////////////////////////////////////////////////////////////////////////////
  1393. //  If we get an SMTP fatal error We must return <0 , otherwise >0 to give
  1394. //  XMail to ability to resume the command
  1395. ///////////////////////////////////////////////////////////////////////////////
  1396. int iReturnCode = USmtpIsFatalError(&SMTPE) ? ErrGetErrorCode() :
  1397.     -ErrGetErrorCode();
  1399. ///////////////////////////////////////////////////////////////////////////////
  1400. //  If a permanent SMTP error has been detected, then notify the message sender
  1401. ///////////////////////////////////////////////////////////////////////////////
  1402. if (USmtpIsFatalError(&SMTPE))
  1403. QueUtNotifyPermErrDelivery(hQueue, hMessage, hFSpool,
  1404.    USmtpGetErrorMessage(&SMTPE),
  1405.    USmtpGetErrorServer(&SMTPE), false);
  1407. USmtpCleanupError(&SMTPE);
  1409. return (iReturnCode);
  1410. }
  1412. USmtpCleanupError(&SMTPE);
  1414. return (0);
  1416. }
  1418. static int SMAILCmd_smtprelay(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  1419.       char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  1420.       SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage)
  1421. {
  1422. ///////////////////////////////////////////////////////////////////////////////
  1423. //  Apply filters ...
  1424. ///////////////////////////////////////////////////////////////////////////////
  1425. if (FilFilterMessage(hFSpool, hQueue, hMessage, FILTER_MODE_OUTBOUND) < 0)
  1426. return (ErrGetErrorCode());
  1428. if (iNumTokens != 2) {
  1429. ErrSetErrorCode(ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1430. return (ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1431. }
  1433. char **ppszRelays = NULL;
  1435. if (ppszCmdTokens[1][0] == '#') {
  1436. if ((ppszRelays = StrTokenize(ppszCmdTokens[1] + 1, ",")) != NULL) {
  1437. int iRelayCount = StrStringsCount(ppszRelays);
  1439. srand((unsigned int) time(NULL));
  1441. for (int ii = 0; ii < (iRelayCount / 2); ii++) {
  1442. int iSwap1 = rand() % iRelayCount;
  1443. int iSwap2 = rand() % iRelayCount;
  1444. char *pszRly1 = ppszRelays[iSwap1];
  1445. char *pszRly2 = ppszRelays[iSwap2];
  1447. ppszRelays[iSwap1] = pszRly2;
  1448. ppszRelays[iSwap2] = pszRly1;
  1449. }
  1450. }
  1451. } else
  1452. ppszRelays = StrTokenize(ppszCmdTokens[1], ",");
  1454. if (ppszRelays == NULL)
  1455. return (ErrGetErrorCode());
  1457. ///////////////////////////////////////////////////////////////////////////////
  1458. //  This function retrieve the spool file message section and sync the content.
  1459. //  This is necessary before sending the file
  1460. ///////////////////////////////////////////////////////////////////////////////
  1461. FileSection FS;
  1463. if (USmlGetMsgFileSection(hFSpool, FS) < 0) {
  1464. ErrorPush();
  1465. StrFreeStrings(ppszRelays);
  1466. return (ErrorPop());
  1467. }
  1468. ///////////////////////////////////////////////////////////////////////////////
  1469. //  Get spool file infos
  1470. ///////////////////////////////////////////////////////////////////////////////
  1471. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  1472. char const *pszMailFrom = USmlMailFrom(hFSpool);
  1473. char const *pszRcptTo = USmlRcptTo(hFSpool);
  1474. char const *pszSendMailFrom = USmlSendMailFrom(hFSpool);
  1475. char const *pszSendRcptTo = USmlSendRcptTo(hFSpool);
  1476. char const *pszSpoolFilePath = USmlGetSpoolFilePath(hFSpool);
  1478. ///////////////////////////////////////////////////////////////////////////////
  1479. //  Get HELO domain
  1480. ///////////////////////////////////////////////////////////////////////////////
  1481. char szHeloDomain[MAX_HOST_NAME] = "";
  1483. SvrConfigVar("HeloDomain", szHeloDomain, sizeof(szHeloDomain) - 1, hSvrConfig, "");
  1485. char const *pszHeloDomain = IsEmptyString(szHeloDomain) ? NULL : szHeloDomain;
  1487. SMTPError SMTPE;
  1489. USmtpInitError(&SMTPE);
  1491. ///////////////////////////////////////////////////////////////////////////////
  1492. //  By initializing this to zero makes XMail to discharge all mail for domains
  1493. //  that have an empty relay list
  1494. ///////////////////////////////////////////////////////////////////////////////
  1495. int iReturnCode = 0;
  1497. for (int ss = 0; ppszRelays[ss] != NULL; ss++) {
  1498. SysLogMessage(LOG_LEV_MESSAGE,
  1499.       "SMAIL SMTP-Send RLYS = "%s" SMTP = "%s" From = "%s" To = "%s"n",
  1500.       ppszRelays[ss], pszSMTPDomain, pszMailFrom, pszRcptTo);
  1502. USmtpCleanupError(&SMTPE);
  1504. if (USmtpSendMail(ppszRelays[ss], pszHeloDomain, pszSendMailFrom, pszSendRcptTo,
  1505.   &FS, &SMTPE) == 0) {
  1506. ///////////////////////////////////////////////////////////////////////////////
  1507. //  Log Mailer operation
  1508. ///////////////////////////////////////////////////////////////////////////////
  1509. if (SMAILLogEnabled(hShbSMAIL))
  1510. USmlLogMessage(hFSpool, "RLYS", ppszRelays[ss]);
  1512. USmtpCleanupError(&SMTPE);
  1514. StrFreeStrings(ppszRelays);
  1516. return (0);
  1517. }
  1519. int iErrorCode = ErrGetErrorCode();
  1520. char szSmtpError[512] = "";
  1522. USmtpGetSMTPError(&SMTPE, szSmtpError, sizeof(szSmtpError));
  1524. ErrLogMessage(LOG_LEV_MESSAGE,
  1525.       "SMAIL SMTP-Send RLYS = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  1526.       "%s = "%s"n"
  1527.       "%s = "%s"n", ppszRelays[ss], pszSMTPDomain, pszMailFrom,
  1528.       pszRcptTo, SMTP_ERROR_VARNAME, szSmtpError, SMTP_SERVER_VARNAME,
  1529.       USmtpGetErrorServer(&SMTPE));
  1531. QueUtErrLogMessage(hQueue, hMessage,
  1532.    "SMAIL SMTP-Send RLYS = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  1533.    "%s = "%s"n"
  1534.    "%s = "%s"n", ppszRelays[ss], pszSMTPDomain, pszMailFrom,
  1535.    pszRcptTo, SMTP_ERROR_VARNAME, szSmtpError,
  1536.    SMTP_SERVER_VARNAME, USmtpGetErrorServer(&SMTPE));
  1538. ///////////////////////////////////////////////////////////////////////////////
  1539. //  If a permanent SMTP error has been detected, then notify the message sender
  1540. ///////////////////////////////////////////////////////////////////////////////
  1541. if (USmtpIsFatalError(&SMTPE))
  1542. QueUtNotifyPermErrDelivery(hQueue, hMessage, hFSpool,
  1543.    USmtpGetErrorMessage(&SMTPE),
  1544.    USmtpGetErrorServer(&SMTPE), false);
  1546. iReturnCode = USmtpIsFatalError(&SMTPE) ? iErrorCode : -iErrorCode;
  1547. }
  1549. USmtpCleanupError(&SMTPE);
  1551. StrFreeStrings(ppszRelays);
  1553. return (iReturnCode);
  1555. }
  1557. static int SMAILCmd_redirect(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  1558.      char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  1559.      SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage)
  1560. {
  1562. if (iNumTokens < 2) {
  1563. ErrSetErrorCode(ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1564. return (ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1565. }
  1567. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  1568. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  1569. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  1571. int iFromDomains = StrStringsCount(ppszFrom);
  1572. int iRcptDomains = StrStringsCount(ppszRcpt);
  1574. char szLocalUser[MAX_ADDR_NAME] = "";
  1575. char szLocalDomain[MAX_ADDR_NAME] = "";
  1577. if ((iRcptDomains < 1) ||
  1578.     (USmtpSplitEmailAddr(ppszRcpt[iRcptDomains - 1], szLocalUser, szLocalDomain) < 0))
  1579. return (ErrGetErrorCode());
  1581. for (int ii = 1; ppszCmdTokens[ii] != NULL; ii++) {
  1582. ///////////////////////////////////////////////////////////////////////////////
  1583. //  Get message handle
  1584. ///////////////////////////////////////////////////////////////////////////////
  1585. QMSG_HANDLE hRedirMessage = QueCreateMessage(hSpoolQueue);
  1587. if (hRedirMessage == INVALID_QMSG_HANDLE)
  1588. return (ErrGetErrorCode());
  1590. char szQueueFilePath[SYS_MAX_PATH] = "";
  1592. QueGetFilePath(hSpoolQueue, hRedirMessage, szQueueFilePath);
  1594. char szAliasAddr[MAX_ADDR_NAME] = "";
  1596. if (strchr(ppszCmdTokens[ii], '@') == NULL)
  1597. SysSNPrintf(szAliasAddr, sizeof(szAliasAddr) - 1, "%s@%s",
  1598.     szLocalUser, ppszCmdTokens[ii]);
  1599. else
  1600. StrSNCpy(szAliasAddr, ppszCmdTokens[ii]);
  1602. if (USmlCreateSpoolFile(hFSpool, NULL, szAliasAddr, szQueueFilePath, NULL) < 0) {
  1603. ErrorPush();
  1604. QueCleanupMessage(hSpoolQueue, hRedirMessage);
  1605. QueCloseMessage(hSpoolQueue, hRedirMessage);
  1606. return (ErrorPop());
  1607. }
  1608. ///////////////////////////////////////////////////////////////////////////////
  1609. //  Transfer file to the spool
  1610. ///////////////////////////////////////////////////////////////////////////////
  1611. if (QueCommitMessage(hSpoolQueue, hRedirMessage) < 0) {
  1612. ErrorPush();
  1613. QueCleanupMessage(hSpoolQueue, hRedirMessage);
  1614. QueCloseMessage(hSpoolQueue, hRedirMessage);
  1615. return (ErrorPop());
  1616. }
  1617. }
  1619. return (0);
  1621. }
  1623. static int SMAILCmd_lredirect(SVRCFG_HANDLE hSvrConfig, SHB_HANDLE hShbSMAIL,
  1624.       char const *pszDestDomain, char **ppszCmdTokens, int iNumTokens,
  1625.       SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage)
  1626. {
  1628. if (iNumTokens < 2) {
  1629. ErrSetErrorCode(ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1630. return (ERR_BAD_DOMAIN_PROC_CMD_SYNTAX);
  1631. }
  1633. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  1634. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  1636. int iFromDomains = StrStringsCount(ppszFrom);
  1637. int iRcptDomains = StrStringsCount(ppszRcpt);
  1639. char szLocalUser[MAX_ADDR_NAME] = "";
  1640. char szLocalDomain[MAX_ADDR_NAME] = "";
  1642. if ((iRcptDomains < 1) ||
  1643.     (USmtpSplitEmailAddr(ppszRcpt[iRcptDomains - 1], szLocalUser, szLocalDomain) < 0))
  1644. return (ErrGetErrorCode());
  1646. for (int ii = 1; ppszCmdTokens[ii] != NULL; ii++) {
  1647. ///////////////////////////////////////////////////////////////////////////////
  1648. //  Get message handle
  1649. ///////////////////////////////////////////////////////////////////////////////
  1650. QMSG_HANDLE hRedirMessage = QueCreateMessage(hSpoolQueue);
  1652. if (hRedirMessage == INVALID_QMSG_HANDLE)
  1653. return (ErrGetErrorCode());
  1655. char szQueueFilePath[SYS_MAX_PATH] = "";
  1657. QueGetFilePath(hSpoolQueue, hRedirMessage, szQueueFilePath);
  1659. char szAliasAddr[MAX_ADDR_NAME] = "";
  1661. if (strchr(ppszCmdTokens[ii], '@') == NULL)
  1662. SysSNPrintf(szAliasAddr, sizeof(szAliasAddr) - 1, "%s@%s",
  1663.     szLocalUser, ppszCmdTokens[ii]);
  1664. else
  1665. StrSNCpy(szAliasAddr, ppszCmdTokens[ii]);
  1667. if (USmlCreateSpoolFile(hFSpool, ppszRcpt[iRcptDomains - 1], szAliasAddr,
  1668. szQueueFilePath, NULL) < 0) {
  1669. ErrorPush();
  1670. QueCleanupMessage(hSpoolQueue, hRedirMessage);
  1671. QueCloseMessage(hSpoolQueue, hRedirMessage);
  1672. return (ErrorPop());
  1673. }
  1674. ///////////////////////////////////////////////////////////////////////////////
  1675. //  Transfer file to the spool
  1676. ///////////////////////////////////////////////////////////////////////////////
  1677. if (QueCommitMessage(hSpoolQueue, hRedirMessage) < 0) {
  1678. ErrorPush();
  1679. QueCleanupMessage(hSpoolQueue, hRedirMessage);
  1680. QueCloseMessage(hSpoolQueue, hRedirMessage);
  1681. return (ErrorPop());
  1682. }
  1683. }
  1685. return (0);
  1687. }