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

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

Email服务器

开发平台：

Visual C++

SMAILUtils.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 "StrUtils.h"
  27. #include "SList.h"
  28. #include "ShBlocks.h"
  29. #include "ResLocks.h"
  30. #include "BuffSock.h"
  31. #include "UsrUtils.h"
  32. #include "SvrUtils.h"
  33. #include "MailConfig.h"
  34. #include "MessQueue.h"
  35. #include "SMAILUtils.h"
  36. #include "QueueUtils.h"
  37. #include "ExtAliases.h"
  38. #include "MiscUtils.h"
  39. #include "MailDomains.h"
  40. #include "Filter.h"
  41. #include "SMTPSvr.h"
  42. #include "SMTPUtils.h"
  43. #include "AppDefines.h"
  44. #include "MailSvr.h"
  46. #define SFF_HEADER_MODIFIED             (1 << 0)
  48. #define STD_TAG_BUFFER_LENGTH           1024
  49. #define CUSTOM_CMD_LINE_MAX             512
  50. #define SMAIL_DOMAIN_PROC_DIR           "custdomains"
  51. #define SMAIL_CMDALIAS_DIR              "cmdaliases"
  52. #define SMAIL_DEFAULT_FILTER            ".tab"
  53. #define SMAIL_LOG_FILE                  "smail"
  54. #define MAX_MTA_OPS                     16
  55. #define ADDRESS_TOKENIZER               ","
  56. #define SMAIL_EXTERNAL_EXIT_BREAK       16
  57. #define SMAIL_STOP_PROCESSING           3111965L
  59. struct SpoolFileData {
  60. char **ppszInfo;
  61. char **ppszFrom;
  62. char *pszMailFrom;
  63. char *pszSendMailFrom;
  64. char **ppszRcpt;
  65. char *pszRcptTo;
  66. char *pszSendRcptTo;
  67. char *pszRelayDomain;
  68. char szSMTPDomain[MAX_ADDR_NAME];
  69. char szMessageID[128];
  70. char szMessFilePath[SYS_MAX_PATH];
  71. unsigned long ulMessageOffset;
  72. unsigned long ulMailDataOffset;
  73. char szSpoolFile[SYS_MAX_PATH];
  74. HSLIST hTagList;
  75. unsigned long ulFlags;
  76. };
  78. struct MessageTagData {
  79. LISTLINK LL;
  80. char *pszTagName;
  81. char *pszTagData;
  82. };
  84. static MessageTagData *USmlAllocTag(char const *pszTagName, char const *pszTagData);
  85. static void USmlFreeTag(MessageTagData * pMTD);
  86. static MessageTagData *USmlFindTag(HSLIST & hTagList, char const *pszTagName,
  87.    TAG_POSITION & TagPosition);
  88. static int USmlAddTag(HSLIST & hTagList, char const *pszTagName,
  89.       char const *pszTagData, int iUpdate = 0);
  90. static void USmlFreeTagsList(HSLIST & hTagList);
  91. static int USmlLoadTags(FILE * pSpoolFile, HSLIST & hTagList);
  92. static int USmlDumpHeaders(FILE * pMsgFile, HSLIST & hTagList);
  93. static void USmlFreeData(SpoolFileData * pSFD);
  94. static void USmlInitHandle(SpoolFileData * pSFD);
  95. static SpoolFileData *USmlAllocEmptyHandle(void);
  96. static int USmlLoadHandle(SpoolFileData * pSFD, const char *pszMessFilePath);
  97. static int USmlFlushMessageFile(SpoolFileData * pSFD);
  98. static int USmlGetMailProcessFile(UserInfo * pUI, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage,
  99.   char *pszMPFilePath);
  100. static int USmlProcessCustomMailingFile(SVRCFG_HANDLE hSvrConfig, UserInfo * pUI,
  101. SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  102. QMSG_HANDLE hMessage, char const *pszMPFile,
  103. LocalMailProcConfig & LMPC);
  104. static int USmlCmdMacroSubstitutes(char **ppszCmdTokens, UserInfo * pUI, SPLF_HANDLE hFSpool);
  105. static int USmlCmd_external(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  106.     UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  107.     QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC);
  108. static int USmlCmd_filter(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  109.   UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  110.   QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC);
  111. static int USmlCmd_mailbox(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  112.    UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  113.    QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC);
  114. static int USmlCmd_redirect(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  115.     UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  116.     QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC);
  117. static int USmlCmd_lredirect(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  118.      UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  119.      QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC);
  120. static int USmlCmd_smtprelay(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  121.      UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  122.      QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC);
  123. static int USmlLogMessage(char const *pszSMTPDomain, char const *pszMessageID,
  124.   char const *pszSmtpMessageID, char const *pszFrom, char const *pszRcpt,
  125.   char const *pszMedium, char const *pszParam);
  126. static int USmlExtractFromAddress(HSLIST & hTagList, char *pszFromAddr, int iMaxAddress);
  127. static char const *USmlAddressFromAtPtr(char const *pszAt, char const *pszBase,
  128. char *pszAddress, int iMaxAddress);
  129. static char const *USmlAddSingleAddress(char const *pszCurr, char const *pszBase,
  130. DynString * pAddrDS, char const *const *ppszMatchDomains,
  131. int *piAdded);
  132. static int USmlAddAddresses(char const *pszAddrList, DynString * pAddrDS,
  133.     char const *const *ppszMatchDomains);
  134. static char **USmlGetAddressList(HSLIST & hTagList, char const *const *ppszMatchDomains,
  135.  char const *const *ppszAddrTags);
  136. static int USmlExtractToAddress(HSLIST & hTagList, char *pszToAddr, int iMaxAddress);
  137. static char **USmlBuildTargetRcptList(char const *pszRcptTo, HSLIST & hTagList,
  138.       const char *pszFetchHdrTags);
  139. static int USmlCreateSpoolFile(FILE * pMailFile, char const *const *ppszInfo,
  140.        char const *pszMailFrom, char const *pszRcptTo,
  141.        char const *pszSpoolFile);
  143. int USmlLoadSpoolFileHeader(char const *pszSpoolFile, SpoolFileHeader & SFH)
  144. {
  146. ZeroData(SFH);
  148. FILE *pSpoolFile = fopen(pszSpoolFile, "rb");
  150. if (pSpoolFile == NULL) {
  151. ErrSetErrorCode(ERR_SPOOL_FILE_NOT_FOUND, pszSpoolFile);
  152. return (ERR_SPOOL_FILE_NOT_FOUND);
  153. }
  154. ///////////////////////////////////////////////////////////////////////////////
  155. //  Build spool file name
  156. ///////////////////////////////////////////////////////////////////////////////
  157. char szFName[SYS_MAX_PATH] = "";
  158. char szExt[SYS_MAX_PATH] = "";
  159. char szSpoolLine[MAX_SPOOL_LINE] = "";
  161. MscSplitPath(pszSpoolFile, NULL, szFName, szExt);
  163. SysSNPrintf(SFH.szSpoolFile, sizeof(SFH.szSpoolFile) - 1, "%s%s", szFName, szExt);
  165. ///////////////////////////////////////////////////////////////////////////////
  166. //  Read info ( 1st row of the spool file )
  167. ///////////////////////////////////////////////////////////////////////////////
  168. if ((MscGetString(pSpoolFile, szSpoolLine, sizeof(szSpoolLine) - 1) == NULL) ||
  169.     ((SFH.ppszInfo = StrTokenize(szSpoolLine, ";")) == NULL) ||
  170.     (StrStringsCount(SFH.ppszInfo) < smiMax)) {
  171. if (SFH.ppszInfo != NULL)
  172. StrFreeStrings(SFH.ppszInfo);
  173. fclose(pSpoolFile);
  174. ZeroData(SFH);
  176. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE, pszSpoolFile);
  177. return (ERR_SPOOL_FILE_NOT_FOUND);
  178. }
  179. ///////////////////////////////////////////////////////////////////////////////
  180. //  Read SMTP domain ( 2nd row of the spool file )
  181. ///////////////////////////////////////////////////////////////////////////////
  182. if (MscGetString(pSpoolFile, SFH.szSMTPDomain, sizeof(SFH.szSMTPDomain) - 1) == NULL) {
  183. StrFreeStrings(SFH.ppszInfo);
  184. fclose(pSpoolFile);
  185. ZeroData(SFH);
  187. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE, pszSpoolFile);
  188. return (ERR_SPOOL_FILE_NOT_FOUND);
  189. }
  190. ///////////////////////////////////////////////////////////////////////////////
  191. //  Read message ID ( 3rd row of the spool file )
  192. ///////////////////////////////////////////////////////////////////////////////
  193. if (MscGetString(pSpoolFile, SFH.szMessageID, sizeof(SFH.szMessageID) - 1) == NULL) {
  194. StrFreeStrings(SFH.ppszInfo);
  195. fclose(pSpoolFile);
  196. ZeroData(SFH);
  198. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE, pszSpoolFile);
  199. return (ERR_SPOOL_FILE_NOT_FOUND);
  200. }
  201. ///////////////////////////////////////////////////////////////////////////////
  202. //  Read "MAIL FROM:" ( 4th row of the spool file )
  203. ///////////////////////////////////////////////////////////////////////////////
  204. if ((MscGetString(pSpoolFile, szSpoolLine, sizeof(szSpoolLine) - 1) == NULL) ||
  205.     (StrINComp(szSpoolLine, MAIL_FROM_STR) != 0) ||
  206.     ((SFH.ppszFrom = USmtpGetPathStrings(szSpoolLine)) == NULL)) {
  207. StrFreeStrings(SFH.ppszInfo);
  208. fclose(pSpoolFile);
  209. ZeroData(SFH);
  211. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE, pszSpoolFile);
  212. return (ERR_INVALID_SPOOL_FILE);
  213. }
  214. ///////////////////////////////////////////////////////////////////////////////
  215. //  Read "RCPT TO:" ( 5th row of the spool file )
  216. ///////////////////////////////////////////////////////////////////////////////
  217. if ((MscGetString(pSpoolFile, szSpoolLine, sizeof(szSpoolLine) - 1) == NULL) ||
  218.     (StrINComp(szSpoolLine, RCPT_TO_STR) != 0) ||
  219.     ((SFH.ppszRcpt = USmtpGetPathStrings(szSpoolLine)) == NULL)) {
  220. StrFreeStrings(SFH.ppszFrom);
  221. StrFreeStrings(SFH.ppszInfo);
  222. fclose(pSpoolFile);
  223. ZeroData(SFH);
  225. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE, pszSpoolFile);
  226. return (ERR_INVALID_SPOOL_FILE);
  227. }
  229. fclose(pSpoolFile);
  231. return (0);
  233. }
  235. void USmlCleanupSpoolFileHeader(SpoolFileHeader & SFH)
  236. {
  238. if (SFH.ppszInfo != NULL)
  239. StrFreeStrings(SFH.ppszInfo);
  241. if (SFH.ppszRcpt != NULL)
  242. StrFreeStrings(SFH.ppszRcpt);
  244. if (SFH.ppszFrom != NULL)
  245. StrFreeStrings(SFH.ppszFrom);
  247. ZeroData(SFH);
  249. }
  251. static MessageTagData *USmlAllocTag(char const *pszTagName, char const *pszTagData)
  252. {
  254. MessageTagData *pMTD = (MessageTagData *) SysAlloc(sizeof(MessageTagData));
  256. if (pMTD == NULL)
  257. return (NULL);
  259. ListLinkInit(pMTD);
  260. pMTD->pszTagName = SysStrDup(pszTagName);
  261. pMTD->pszTagData = SysStrDup(pszTagData);
  263. return (pMTD);
  265. }
  267. static void USmlFreeTag(MessageTagData * pMTD)
  268. {
  270. SysFree(pMTD->pszTagName);
  272. SysFree(pMTD->pszTagData);
  274. SysFree(pMTD);
  276. }
  278. static MessageTagData *USmlFindTag(HSLIST & hTagList, char const *pszTagName,
  279.    TAG_POSITION & TagPosition)
  280. {
  282. MessageTagData *pMTD = (TagPosition == TAG_POSITION_INIT) ?
  283. (MessageTagData *) ListFirst(hTagList) : (MessageTagData *) TagPosition;
  285. for (; pMTD != INVALID_SLIST_PTR; pMTD = (MessageTagData *)
  286.      ListNext(hTagList, (PLISTLINK) pMTD)) {
  287. if ((pszTagName == NULL) || (stricmp(pMTD->pszTagName, pszTagName) == 0)) {
  288. TagPosition = (TAG_POSITION) ListNext(hTagList, (PLISTLINK) pMTD);
  289. return (pMTD);
  290. }
  291. }
  293. TagPosition = (TAG_POSITION) INVALID_SLIST_PTR;
  295. return (NULL);
  297. }
  299. static int USmlAddTag(HSLIST & hTagList, char const *pszTagName,
  300.       char const *pszTagData, int iUpdate)
  301. {
  303. if (!iUpdate) {
  304. MessageTagData *pMTD = USmlAllocTag(pszTagName, pszTagData);
  306. if (pMTD == NULL)
  307. return (ErrGetErrorCode());
  309. ListAddTail(hTagList, (PLISTLINK) pMTD);
  310. } else {
  311. TAG_POSITION TagPosition = TAG_POSITION_INIT;
  312. MessageTagData *pMTD = USmlFindTag(hTagList, pszTagName, TagPosition);
  314. if (pMTD != NULL) {
  315. SysFree(pMTD->pszTagData);
  317. pMTD->pszTagData = SysStrDup(pszTagData);
  318. } else {
  319. if ((pMTD = USmlAllocTag(pszTagName, pszTagData)) == NULL)
  320. return (ErrGetErrorCode());
  322. ListAddTail(hTagList, (PLISTLINK) pMTD);
  323. }
  324. }
  326. return (0);
  328. }
  330. static void USmlFreeTagsList(HSLIST & hTagList)
  331. {
  333. MessageTagData *pMTD;
  335. while ((pMTD = (MessageTagData *) ListRemove(hTagList)) != INVALID_SLIST_PTR)
  336. USmlFreeTag(pMTD);
  338. }
  340. static int USmlLoadTags(FILE * pSpoolFile, HSLIST & hTagList)
  341. {
  343. DynString TagDS;
  345. StrDynInit(&TagDS);
  347. unsigned long ulFilePos = (unsigned long) ftell(pSpoolFile);
  348. char szSpoolLine[MAX_SPOOL_LINE] = "";
  349. char szTagName[256] = "";
  351. while (MscGetString(pSpoolFile, szSpoolLine, sizeof(szSpoolLine) - 1) != NULL) {
  352. if (IsEmptyString(szSpoolLine)) {
  353. if (StrDynSize(&TagDS) > 0) {
  354. if (USmlAddTag(hTagList, szTagName, StrDynGet(&TagDS)) < 0) {
  355. ErrorPush();
  356. StrDynFree(&TagDS);
  357. fseek(pSpoolFile, ulFilePos, SEEK_SET);
  358. return (ErrorPop());
  359. }
  361. SetEmptyString(szTagName);
  362. StrDynTruncate(&TagDS);
  363. }
  365. break;
  366. }
  368. if ((szSpoolLine[0] == ' ') || (szSpoolLine[0] == 't')) {
  369. if (IsEmptyString(szTagName)) {
  370. StrDynFree(&TagDS);
  371. fseek(pSpoolFile, ulFilePos, SEEK_SET);
  373. ErrSetErrorCode(ERR_INVALID_MESSAGE_FORMAT);
  374. return (ERR_INVALID_MESSAGE_FORMAT);
  375. }
  377. if ((StrDynAdd(&TagDS, "rn") < 0) ||
  378.     (StrDynAdd(&TagDS, szSpoolLine) < 0)) {
  379. ErrorPush();
  380. StrDynFree(&TagDS);
  381. fseek(pSpoolFile, ulFilePos, SEEK_SET);
  382. return (ErrorPop());
  383. }
  384. } else {
  385. if (StrDynSize(&TagDS) > 0) {
  386. if (USmlAddTag(hTagList, szTagName, StrDynGet(&TagDS)) < 0) {
  387. ErrorPush();
  388. StrDynFree(&TagDS);
  389. fseek(pSpoolFile, ulFilePos, SEEK_SET);
  390. return (ErrorPop());
  391. }
  393. SetEmptyString(szTagName);
  394. StrDynTruncate(&TagDS);
  395. }
  397. char *pszEndTag = strchr(szSpoolLine, ':');
  399. if (pszEndTag == NULL) {
  400. StrDynFree(&TagDS);
  401. fseek(pSpoolFile, ulFilePos, SEEK_SET);
  403. ErrSetErrorCode(ERR_INVALID_MESSAGE_FORMAT);
  404. return (ERR_INVALID_MESSAGE_FORMAT);
  405. }
  407. int iNameLength = Min((int) (pszEndTag - szSpoolLine),
  408.       sizeof(szTagName) - 1);
  409. char *pszTagValue = pszEndTag + 1;
  411. strncpy(szTagName, szSpoolLine, iNameLength);
  412. szTagName[iNameLength] = '';
  414. StrSkipSpaces(pszTagValue);
  416. if (StrDynAdd(&TagDS, pszTagValue) < 0) {
  417. ErrorPush();
  418. StrDynFree(&TagDS);
  419. fseek(pSpoolFile, ulFilePos, SEEK_SET);
  420. return (ErrorPop());
  421. }
  422. }
  424. ulFilePos = (unsigned long) ftell(pSpoolFile);
  425. }
  427. StrDynFree(&TagDS);
  429. return (0);
  431. }
  433. static int USmlDumpHeaders(FILE * pMsgFile, HSLIST & hTagList)
  434. {
  436. MessageTagData *pMTD = (MessageTagData *) ListFirst(hTagList);
  438. for (; pMTD != INVALID_SLIST_PTR; pMTD = (MessageTagData *)
  439.      ListNext(hTagList, (PLISTLINK) pMTD)) {
  441. fprintf(pMsgFile, "%s: %srn", pMTD->pszTagName, pMTD->pszTagData);
  443. }
  445. return (0);
  447. }
  449. static void USmlFreeData(SpoolFileData * pSFD)
  450. {
  452. USmlFreeTagsList(pSFD->hTagList);
  454. if (pSFD->ppszInfo != NULL)
  455. StrFreeStrings(pSFD->ppszInfo);
  457. if (pSFD->ppszFrom != NULL)
  458. StrFreeStrings(pSFD->ppszFrom);
  460. if (pSFD->pszMailFrom != NULL)
  461. SysFree(pSFD->pszMailFrom);
  463. if (pSFD->pszSendMailFrom != NULL)
  464. SysFree(pSFD->pszSendMailFrom);
  466. if (pSFD->ppszRcpt != NULL)
  467. StrFreeStrings(pSFD->ppszRcpt);
  469. if (pSFD->pszRcptTo != NULL)
  470. SysFree(pSFD->pszRcptTo);
  472. if (pSFD->pszSendRcptTo != NULL)
  473. SysFree(pSFD->pszSendRcptTo);
  475. if (pSFD->pszRelayDomain != NULL)
  476. SysFree(pSFD->pszRelayDomain);
  478. }
  480. char *USmlAddrConcat(char const *const *ppszStrings)
  481. {
  483. int ii;
  484. int iStrCount = StrStringsCount(ppszStrings);
  485. int iSumLength = 0;
  487. for (ii = 0; ii < iStrCount; ii++)
  488. iSumLength += strlen(ppszStrings[ii]) + 1;
  490. char *pszConcat = (char *) SysAlloc(iSumLength + 1);
  492. if (pszConcat == NULL)
  493. return (NULL);
  495. SetEmptyString(pszConcat);
  497. for (ii = 0; ii < iStrCount; ii++) {
  498. if (ii > 0)
  499. strcat(pszConcat, (ii == (iStrCount - 1)) ? ":" : ",");
  501. strcat(pszConcat, ppszStrings[ii]);
  502. }
  504. return (pszConcat);
  506. }
  508. char *USmlBuildSendMailFrom(char const *const *ppszFrom, char const *const *ppszRcpt)
  509. {
  511. int iRcptCount = StrStringsCount(ppszRcpt);
  512. int iFromCount = StrStringsCount(ppszFrom);
  514. if (iRcptCount == 0) {
  515. ErrSetErrorCode(ERR_BAD_FORWARD_PATH);
  516. return (NULL);
  517. }
  519. if (iRcptCount == 1)
  520. return (USmlAddrConcat(ppszFrom));
  522. int ii, iSumLength = strlen(ppszRcpt[0]) + 1;
  524. for (ii = 0; ii < iFromCount; ii++)
  525. iSumLength += strlen(ppszFrom[ii]) + 1;
  527. char *pszConcat = (char *) SysAlloc(iSumLength + 1);
  529. if (pszConcat == NULL)
  530. return (NULL);
  532. strcpy(pszConcat, ppszRcpt[0]);
  534. for (ii = 0; ii < iFromCount; ii++) {
  535. strcat(pszConcat, (ii == (iFromCount - 1)) ? ":" : ",");
  537. strcat(pszConcat, ppszFrom[ii]);
  538. }
  540. return (pszConcat);
  542. }
  544. char *USmlBuildSendRcptTo(char const *const *ppszFrom, char const *const *ppszRcpt)
  545. {
  547. int iRcptCount = StrStringsCount(ppszRcpt);
  548. int iFromCount = StrStringsCount(ppszFrom);
  550. if (iRcptCount == 0) {
  551. ErrSetErrorCode(ERR_BAD_FORWARD_PATH);
  552. return (NULL);
  553. }
  555. if (iRcptCount == 1)
  556. return (USmlAddrConcat(ppszRcpt));
  558. int ii;
  559. int iSumLength = 0;
  561. for (ii = 1; ii < iRcptCount; ii++)
  562. iSumLength += strlen(ppszRcpt[ii]) + 1;
  564. char *pszConcat = (char *) SysAlloc(iSumLength + 1);
  566. if (pszConcat == NULL)
  567. return (NULL);
  569. SetEmptyString(pszConcat);
  571. for (ii = 1; ii < iRcptCount; ii++) {
  572. if (ii > 1)
  573. strcat(pszConcat, (ii == (iRcptCount - 1)) ? ":" : ",");
  575. strcat(pszConcat, ppszRcpt[ii]);
  576. }
  578. return (pszConcat);
  580. }
  582. static int USmlLoadHandle(SpoolFileData * pSFD, const char *pszMessFilePath)
  583. {
  585. char szFName[SYS_MAX_PATH] = "";
  586. char szExt[SYS_MAX_PATH] = "";
  588. StrSNCpy(pSFD->szMessFilePath, pszMessFilePath);
  590. MscSplitPath(pszMessFilePath, NULL, szFName, szExt);
  592. SysSNPrintf(pSFD->szSpoolFile, sizeof(pSFD->szSpoolFile) - 1, "%s%s", szFName, szExt);
  594. FILE *pSpoolFile = fopen(pszMessFilePath, "rb");
  596. if (pSpoolFile == NULL) {
  597. ErrSetErrorCode(ERR_SPOOL_FILE_NOT_FOUND);
  598. return (ERR_SPOOL_FILE_NOT_FOUND);
  599. }
  601. char szSpoolLine[MAX_SPOOL_LINE] = "";
  603. ///////////////////////////////////////////////////////////////////////////////
  604. //  Read info ( 1st row of the spool file )
  605. ///////////////////////////////////////////////////////////////////////////////
  606. if ((MscGetString(pSpoolFile, szSpoolLine, sizeof(szSpoolLine) - 1) == NULL) ||
  607.     ((pSFD->ppszInfo = StrTokenize(szSpoolLine, ";")) == NULL) ||
  608.     (StrStringsCount(pSFD->ppszInfo) < smiMax)) {
  609. fclose(pSpoolFile);
  610. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  611. return (ERR_INVALID_SPOOL_FILE);
  612. }
  613. ///////////////////////////////////////////////////////////////////////////////
  614. //  Read SMTP domain ( 2nd row of the spool file )
  615. ///////////////////////////////////////////////////////////////////////////////
  616. if (MscGetString(pSpoolFile, pSFD->szSMTPDomain, sizeof(pSFD->szSMTPDomain) - 1) == NULL) {
  617. fclose(pSpoolFile);
  618. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  619. return (ERR_INVALID_SPOOL_FILE);
  620. }
  621. ///////////////////////////////////////////////////////////////////////////////
  622. //  Read message ID ( 3rd row of the spool file )
  623. ///////////////////////////////////////////////////////////////////////////////
  624. if (MscGetString(pSpoolFile, pSFD->szMessageID, sizeof(pSFD->szMessageID) - 1) == NULL) {
  625. fclose(pSpoolFile);
  626. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  627. return (ERR_INVALID_SPOOL_FILE);
  628. }
  629. ///////////////////////////////////////////////////////////////////////////////
  630. //  Read "MAIL FROM:" ( 4th row of the spool file )
  631. ///////////////////////////////////////////////////////////////////////////////
  632. if ((MscGetString(pSpoolFile, szSpoolLine, sizeof(szSpoolLine) - 1) == NULL) ||
  633.     (StrINComp(szSpoolLine, MAIL_FROM_STR) != 0)) {
  634. fclose(pSpoolFile);
  635. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  636. return (ERR_INVALID_SPOOL_FILE);
  637. }
  639. if ((pSFD->ppszFrom = USmtpGetPathStrings(szSpoolLine)) == NULL) {
  640. fclose(pSpoolFile);
  641. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  642. return (ERR_INVALID_SPOOL_FILE);
  643. }
  644. ///////////////////////////////////////////////////////////////////////////////
  645. //  Read "RCPT TO:" ( 5th row of the spool file )
  646. ///////////////////////////////////////////////////////////////////////////////
  647. if ((MscGetString(pSpoolFile, szSpoolLine, sizeof(szSpoolLine) - 1) == NULL) ||
  648.     (StrINComp(szSpoolLine, RCPT_TO_STR) != 0)) {
  649. fclose(pSpoolFile);
  650. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  651. return (ERR_INVALID_SPOOL_FILE);
  652. }
  654. if ((pSFD->ppszRcpt = USmtpGetPathStrings(szSpoolLine)) == NULL) {
  655. fclose(pSpoolFile);
  656. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  657. return (ERR_INVALID_SPOOL_FILE);
  658. }
  659. ///////////////////////////////////////////////////////////////////////////////
  660. //  Check the presence of the init data mark ( 5th row of the spool file )
  661. ///////////////////////////////////////////////////////////////////////////////
  662. if ((MscGetString(pSpoolFile, szSpoolLine, sizeof(szSpoolLine) - 1) == NULL) ||
  663.     (strncmp(szSpoolLine, SPOOL_FILE_DATA_START, strlen(SPOOL_FILE_DATA_START)) != 0)) {
  664. fclose(pSpoolFile);
  665. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  666. return (ERR_INVALID_SPOOL_FILE);
  667. }
  668. ///////////////////////////////////////////////////////////////////////////////
  669. //  Get real message position
  670. ///////////////////////////////////////////////////////////////////////////////
  671. pSFD->ulMessageOffset = (unsigned long) ftell(pSpoolFile);
  673. ///////////////////////////////////////////////////////////////////////////////
  674. //  Build address strings
  675. ///////////////////////////////////////////////////////////////////////////////
  676. if (((pSFD->pszMailFrom = USmlAddrConcat(pSFD->ppszFrom)) == NULL) ||
  677.     ((pSFD->pszSendMailFrom =
  678.       USmlBuildSendMailFrom(pSFD->ppszFrom, pSFD->ppszRcpt)) == NULL) ||
  679.     ((pSFD->pszRcptTo = (char *) USmlAddrConcat(pSFD->ppszRcpt)) == NULL) ||
  680.     ((pSFD->pszSendRcptTo =
  681.       USmlBuildSendRcptTo(pSFD->ppszFrom, pSFD->ppszRcpt)) == NULL)) {
  682. fclose(pSpoolFile);
  683. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  684. return (ERR_INVALID_SPOOL_FILE);
  685. }
  686. ///////////////////////////////////////////////////////////////////////////////
  687. //  Check if it's a relay message
  688. ///////////////////////////////////////////////////////////////////////////////
  689. if (StrStringsCount(pSFD->ppszRcpt) > 1) {
  690. char szRelayDomain[MAX_ADDR_NAME] = "";
  692. if (USmtpSplitEmailAddr(pSFD->ppszRcpt[0], NULL, szRelayDomain) < 0) {
  693. fclose(pSpoolFile);
  694. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  695. return (ERR_INVALID_SPOOL_FILE);
  696. }
  698. pSFD->pszRelayDomain = SysStrDup(szRelayDomain);
  699. }
  700. ///////////////////////////////////////////////////////////////////////////////
  701. //  Load message tags
  702. ///////////////////////////////////////////////////////////////////////////////
  703. if (USmlLoadTags(pSpoolFile, pSFD->hTagList) < 0)
  704. SysLogMessage(LOG_LEV_MESSAGE, "Invalid headers section : %sn",
  705.       pSFD->szSpoolFile);
  707. ///////////////////////////////////////////////////////////////////////////////
  708. //  Get spool file position
  709. ///////////////////////////////////////////////////////////////////////////////
  710. pSFD->ulMailDataOffset = (unsigned long) ftell(pSpoolFile);
  712. fclose(pSpoolFile);
  714. return (0);
  716. }
  718. static void USmlInitHandle(SpoolFileData * pSFD)
  719. {
  721. pSFD->ppszInfo = NULL;
  722. pSFD->ppszFrom = NULL;
  723. pSFD->pszMailFrom = NULL;
  724. pSFD->pszSendMailFrom = NULL;
  725. pSFD->ppszRcpt = NULL;
  726. pSFD->pszRcptTo = NULL;
  727. pSFD->pszSendRcptTo = NULL;
  728. pSFD->pszRelayDomain = NULL;
  729. SetEmptyString(pSFD->szSMTPDomain);
  730. pSFD->ulFlags = 0;
  731. ListInit(pSFD->hTagList);
  733. }
  735. static SpoolFileData *USmlAllocEmptyHandle(void)
  736. {
  737. ///////////////////////////////////////////////////////////////////////////////
  738. //  Structure allocation and initialization
  739. ///////////////////////////////////////////////////////////////////////////////
  740. SpoolFileData *pSFD = (SpoolFileData *) SysAlloc(sizeof(SpoolFileData));
  742. if (pSFD != NULL)
  743. USmlInitHandle(pSFD);
  745. return (pSFD);
  747. }
  749. SPLF_HANDLE USmlCreateHandle(const char *pszMessFilePath)
  750. {
  751. ///////////////////////////////////////////////////////////////////////////////
  752. //  Structure allocation and initialization
  753. ///////////////////////////////////////////////////////////////////////////////
  754. SpoolFileData *pSFD = USmlAllocEmptyHandle();
  756. if (pSFD == NULL)
  757. return (INVALID_SPLF_HANDLE);
  759. if (USmlLoadHandle(pSFD, pszMessFilePath) < 0) {
  760. USmlFreeData(pSFD);
  761. SysFree(pSFD);
  762. return (INVALID_SPLF_HANDLE);
  763. }
  765. return ((SPLF_HANDLE) pSFD);
  767. }
  769. void USmlCloseHandle(SPLF_HANDLE hFSpool)
  770. {
  772. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  774. USmlFreeData(pSFD);
  776. SysFree(pSFD);
  777. }
  779. int USmlReloadHandle(SPLF_HANDLE hFSpool)
  780. {
  781. ///////////////////////////////////////////////////////////////////////////////
  782. //  Structure allocation and initialization
  783. ///////////////////////////////////////////////////////////////////////////////
  784. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  785. SpoolFileData *pNewSFD = USmlAllocEmptyHandle();
  787. if (pNewSFD == NULL)
  788. return (ErrGetErrorCode());
  790. ///////////////////////////////////////////////////////////////////////////////
  791. //  Load the new spool file data
  792. ///////////////////////////////////////////////////////////////////////////////
  793. if (USmlLoadHandle(pNewSFD, pSFD->szMessFilePath) < 0) {
  794. ErrorPush();
  795. USmlFreeData(pNewSFD);
  796. SysFree(pNewSFD);
  797. return (ErrorPop());
  798. }
  799. ///////////////////////////////////////////////////////////////////////////////
  800. //  Free the original structure data and load the new one
  801. ///////////////////////////////////////////////////////////////////////////////
  802. USmlFreeData(pSFD);
  804. *pSFD = *pNewSFD;
  806. ///////////////////////////////////////////////////////////////////////////////
  807. //  We don't have to call USmlFreeData() since its content has been tranfered
  808. //  to the original structure to replace the old information
  809. ///////////////////////////////////////////////////////////////////////////////
  810. SysFree(pNewSFD);
  812. return (0);
  814. }
  816. char const *USmlGetRelayDomain(SPLF_HANDLE hFSpool)
  817. {
  819. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  821. return (pSFD->pszRelayDomain);
  823. }
  825. char const *USmlGetSpoolFilePath(SPLF_HANDLE hFSpool)
  826. {
  828. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  830. return (pSFD->szMessFilePath);
  832. }
  834. char const *USmlGetSpoolFile(SPLF_HANDLE hFSpool)
  835. {
  837. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  839. return (pSFD->szSpoolFile);
  841. }
  843. char const *USmlGetSMTPDomain(SPLF_HANDLE hFSpool)
  844. {
  846. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  848. return (pSFD->szSMTPDomain);
  850. }
  852. char const *USmlGetSmtpMessageID(SPLF_HANDLE hFSpool)
  853. {
  855. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  857. return (pSFD->szMessageID);
  859. }
  861. char const *const *USmlGetInfo(SPLF_HANDLE hFSpool)
  862. {
  864. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  866. return (pSFD->ppszInfo);
  868. }
  870. char const *const *USmlGetMailFrom(SPLF_HANDLE hFSpool)
  871. {
  873. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  875. return (pSFD->ppszFrom);
  877. }
  879. char const *USmlMailFrom(SPLF_HANDLE hFSpool)
  880. {
  882. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  884. return (pSFD->pszMailFrom);
  886. }
  888. char const *USmlSendMailFrom(SPLF_HANDLE hFSpool)
  889. {
  891. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  893. return (pSFD->pszSendMailFrom);
  895. }
  897. char const *const *USmlGetRcptTo(SPLF_HANDLE hFSpool)
  898. {
  900. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  902. return (pSFD->ppszRcpt);
  904. }
  906. char const *USmlRcptTo(SPLF_HANDLE hFSpool)
  907. {
  909. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  911. return (pSFD->pszRcptTo);
  913. }
  915. char const *USmlSendRcptTo(SPLF_HANDLE hFSpool)
  916. {
  918. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  920. return (pSFD->pszSendRcptTo);
  922. }
  924. static int USmlFlushMessageFile(SpoolFileData * pSFD)
  925. {
  927. char szTmpMsgFile[SYS_MAX_PATH] = "";
  929. SysSNPrintf(szTmpMsgFile, sizeof(szTmpMsgFile) - 1, "%s.flush", pSFD->szMessFilePath);
  931. ///////////////////////////////////////////////////////////////////////////////
  932. //  Create temporary file
  933. ///////////////////////////////////////////////////////////////////////////////
  934. FILE *pMsgFile = fopen(szTmpMsgFile, "wb");
  936. if (pMsgFile == NULL) {
  937. ErrSetErrorCode(ERR_FILE_CREATE, szTmpMsgFile);
  938. return (ERR_FILE_CREATE);
  939. }
  940. ///////////////////////////////////////////////////////////////////////////////
  941. //  Open message file
  942. ///////////////////////////////////////////////////////////////////////////////
  943. FILE *pMessFile = fopen(pSFD->szMessFilePath, "rb");
  945. if (pMessFile == NULL) {
  946. fclose(pMsgFile);
  947. CheckRemoveFile(szTmpMsgFile);
  949. ErrSetErrorCode(ERR_FILE_OPEN, pSFD->szMessFilePath);
  950. return (ERR_FILE_OPEN);
  951. }
  952. ///////////////////////////////////////////////////////////////////////////////
  953. //  Dump info section ( start = 0 - bytes = ulMessageOffset )
  954. ///////////////////////////////////////////////////////////////////////////////
  955. if (MscCopyFile(pMsgFile, pMessFile, 0, pSFD->ulMessageOffset) < 0) {
  956. ErrorPush();
  957. fclose(pMessFile);
  958. fclose(pMsgFile);
  959. CheckRemoveFile(szTmpMsgFile);
  960. return (ErrorPop());
  961. }
  962. ///////////////////////////////////////////////////////////////////////////////
  963. //  Dump message headers
  964. ///////////////////////////////////////////////////////////////////////////////
  965. if (USmlDumpHeaders(pMsgFile, pSFD->hTagList) < 0) {
  966. ErrorPush();
  967. fclose(pMessFile);
  968. fclose(pMsgFile);
  969. CheckRemoveFile(szTmpMsgFile);
  970. return (ErrorPop());
  971. }
  973. fprintf(pMsgFile, "rn");
  975. ///////////////////////////////////////////////////////////////////////////////
  976. //  Get the new message body offset
  977. ///////////////////////////////////////////////////////////////////////////////
  978. unsigned long ulMailDataOffset = (unsigned long) ftell(pMsgFile);
  980. ///////////////////////////////////////////////////////////////////////////////
  981. //  Dump message data ( start = ulMailDataOffset - bytes = -1 [EOF] )
  982. ///////////////////////////////////////////////////////////////////////////////
  983. if (MscCopyFile(pMsgFile, pMessFile, pSFD->ulMailDataOffset, (unsigned long) -1) < 0) {
  984. ErrorPush();
  985. fclose(pMessFile);
  986. fclose(pMsgFile);
  987. CheckRemoveFile(szTmpMsgFile);
  988. return (ErrorPop());
  989. }
  991. fclose(pMessFile);
  993. if (SysFileSync(pMsgFile) < 0) {
  994. ErrorPush();
  995. fclose(pMsgFile);
  996. CheckRemoveFile(szTmpMsgFile);
  997. return (ErrorPop());
  998. }
  1000. if (fclose(pMsgFile)) {
  1001. CheckRemoveFile(szTmpMsgFile);
  1002. ErrSetErrorCode(ERR_FILE_WRITE, szTmpMsgFile);
  1003. return (ERR_FILE_WRITE);
  1004. }
  1005. ///////////////////////////////////////////////////////////////////////////////
  1006. //  Move the file
  1007. ///////////////////////////////////////////////////////////////////////////////
  1008. if ((SysRemove(pSFD->szMessFilePath) < 0) ||
  1009.     (SysMoveFile(szTmpMsgFile, pSFD->szMessFilePath) < 0)) {
  1010. ErrorPush();
  1011. CheckRemoveFile(szTmpMsgFile);
  1012. return (ErrorPop());
  1013. }
  1014. ///////////////////////////////////////////////////////////////////////////////
  1015. //  Set the new message body offset
  1016. ///////////////////////////////////////////////////////////////////////////////
  1017. pSFD->ulMailDataOffset = ulMailDataOffset;
  1019. return (0);
  1021. }
  1023. int USmlSyncChanges(SPLF_HANDLE hFSpool)
  1024. {
  1026. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  1028. if (pSFD->ulFlags & SFF_HEADER_MODIFIED) {
  1030. if (USmlFlushMessageFile(pSFD) == 0)
  1031. pSFD->ulFlags &= ~SFF_HEADER_MODIFIED;
  1033. }
  1035. return (0);
  1037. }
  1039. int USmlGetMsgFileSection(SPLF_HANDLE hFSpool, FileSection & FS)
  1040. {
  1042. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  1044. ///////////////////////////////////////////////////////////////////////////////
  1045. //  Sync message file
  1046. ///////////////////////////////////////////////////////////////////////////////
  1047. if (USmlSyncChanges(hFSpool) < 0)
  1048. return (ErrGetErrorCode());
  1050. ///////////////////////////////////////////////////////////////////////////////
  1051. //  Setup file section fields
  1052. ///////////////////////////////////////////////////////////////////////////////
  1053. ZeroData(FS);
  1055. StrSNCpy(FS.szFilePath, pSFD->szMessFilePath);
  1057. FS.ulStartOffset = pSFD->ulMessageOffset;
  1059. FS.ulEndOffset = (unsigned long) -1;
  1061. return (0);
  1063. }
  1065. int USmlWriteMailFile(SPLF_HANDLE hFSpool, FILE * pMsgFile)
  1066. {
  1068. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  1070. ///////////////////////////////////////////////////////////////////////////////
  1071. //  Dump message tags
  1072. ///////////////////////////////////////////////////////////////////////////////
  1073. if (USmlDumpHeaders(pMsgFile, pSFD->hTagList) < 0)
  1074. return (ErrGetErrorCode());
  1076. fprintf(pMsgFile, "rn");
  1078. ///////////////////////////////////////////////////////////////////////////////
  1079. //  Dump message data
  1080. ///////////////////////////////////////////////////////////////////////////////
  1081. FILE *pMessFile = fopen(pSFD->szMessFilePath, "rb");
  1083. if (pMessFile == NULL) {
  1084. ErrSetErrorCode(ERR_FILE_OPEN, pSFD->szMessFilePath);
  1085. return (ERR_FILE_OPEN);
  1086. }
  1088. if (MscCopyFile(pMsgFile, pMessFile, pSFD->ulMailDataOffset, (unsigned long) -1) < 0) {
  1089. ErrorPush();
  1090. fclose(pMessFile);
  1091. return (ErrorPop());
  1092. }
  1094. fclose(pMessFile);
  1096. return (0);
  1098. }
  1100. char *USmlGetTag(SPLF_HANDLE hFSpool, char const *pszTagName, TAG_POSITION & TagPosition)
  1101. {
  1103. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  1105. MessageTagData *pMTD = USmlFindTag(pSFD->hTagList, pszTagName, TagPosition);
  1107. return ((pMTD != NULL) ? SysStrDup(pMTD->pszTagData) : NULL);
  1109. }
  1111. int USmlAddTag(SPLF_HANDLE hFSpool, char const *pszTagName, char const *pszTagData, int iUpdate)
  1112. {
  1114. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  1116. if (USmlAddTag(pSFD->hTagList, pszTagName, pszTagData, iUpdate) < 0)
  1117. return (ErrGetErrorCode());
  1119. pSFD->ulFlags |= SFF_HEADER_MODIFIED;
  1121. return (0);
  1123. }
  1125. int USmlSetTagAddress(SPLF_HANDLE hFSpool, char const *pszTagName, char const *pszAddress)
  1126. {
  1128. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  1130. TAG_POSITION TagPosition = TAG_POSITION_INIT;
  1131. char *pszOldAddress = USmlGetTag(hFSpool, pszTagName, TagPosition);
  1133. if (pszOldAddress == NULL) {
  1134. char szTagData[512] = "";
  1136. SysSNPrintf(szTagData, sizeof(szTagData) - 1, "<%s>", pszAddress);
  1138. if (USmlAddTag(pSFD->hTagList, pszTagName, szTagData, 1) < 0)
  1139. return (ErrGetErrorCode());
  1141. } else {
  1142. char *pszOpen = strrchr(pszOldAddress, '<');
  1144. if (pszOpen != NULL) {
  1145. ///////////////////////////////////////////////////////////////////////////////
  1146. //  Case : NAME <ADDRESS>
  1147. ///////////////////////////////////////////////////////////////////////////////
  1148. char *pszClose = strrchr(pszOpen + 1, '>');
  1150. if (pszClose == NULL) {
  1151. SysFree(pszOldAddress);
  1153. ErrSetErrorCode(ERR_INVALID_MESSAGE_FORMAT);
  1154. return (ERR_INVALID_MESSAGE_FORMAT);
  1155. }
  1157. DynString DS;
  1159. StrDynInit(&DS);
  1161. StrDynAdd(&DS, pszOldAddress, (int) (pszOpen - pszOldAddress) + 1);
  1162. StrDynAdd(&DS, pszAddress);
  1163. StrDynAdd(&DS, pszClose);
  1165. SysFree(pszOldAddress);
  1167. if (USmlAddTag(pSFD->hTagList, pszTagName, StrDynGet(&DS), 1) < 0) {
  1168. ErrorPush();
  1169. StrDynFree(&DS);
  1170. return (ErrorPop());
  1171. }
  1173. StrDynFree(&DS);
  1175. } else {
  1176. ///////////////////////////////////////////////////////////////////////////////
  1177. //  Case : ADDRESS
  1178. ///////////////////////////////////////////////////////////////////////////////
  1179. SysFree(pszOldAddress);
  1181. if (USmlAddTag(pSFD->hTagList, pszTagName, pszAddress, 1) < 0)
  1182. return (ErrGetErrorCode());
  1184. }
  1186. }
  1188. return (0);
  1190. }
  1192. int USmlMapAddress(char const *pszAddress, char *pszDomain, char *pszName)
  1193. {
  1195. char szRmtDomain[MAX_ADDR_NAME] = "";
  1196. char szRmtName[MAX_ADDR_NAME] = "";
  1198. if (USmtpSplitEmailAddr(pszAddress, szRmtName, szRmtDomain) < 0)
  1199. return (ErrGetErrorCode());
  1201. ExtAlias *pExtAlias = ExAlGetAlias(szRmtDomain, szRmtName);
  1203. if (pExtAlias == NULL)
  1204. return (ErrGetErrorCode());
  1206. strcpy(pszDomain, pExtAlias->pszDomain);
  1207. strcpy(pszName, pExtAlias->pszName);
  1209. ExAlFreeAlias(pExtAlias);
  1211. return (0);
  1213. }
  1215. int USmlCreateMBFile(UserInfo * pUI, char const *pszFileName, SPLF_HANDLE hFSpool)
  1216. {
  1218. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  1220. FILE *pMBFile = fopen(pszFileName, "wb");
  1222. if (pMBFile == NULL) {
  1223. ErrSetErrorCode(ERR_FILE_CREATE, pszFileName);
  1224. return (ERR_FILE_CREATE);
  1225. }
  1226. ///////////////////////////////////////////////////////////////////////////////
  1227. //  Check the existence of the return path string ( PSYNC messages have )
  1228. ///////////////////////////////////////////////////////////////////////////////
  1229. TAG_POSITION TagPosition = TAG_POSITION_INIT;
  1230. char *pszReturnPath = USmlGetTag(hFSpool, "Return-Path", TagPosition);
  1232. if (pszReturnPath == NULL) {
  1233. ///////////////////////////////////////////////////////////////////////////////
  1234. //  Build return path string
  1235. ///////////////////////////////////////////////////////////////////////////////
  1236. int iFromDomains = StrStringsCount(ppszFrom);
  1237. char szDomain[MAX_ADDR_NAME] = "";
  1238. char szName[MAX_ADDR_NAME] = "";
  1239. char szReturnPath[1024] = "Return-Path: <>";
  1241. if ((iFromDomains == 0) ||
  1242.     (USmlMapAddress(ppszFrom[iFromDomains - 1], szDomain, szName) < 0)) {
  1243. char *pszRetPath = USmlAddrConcat(ppszFrom);
  1245. if (pszRetPath != NULL) {
  1246. int iRetLength = strlen(pszRetPath);
  1247. int iExtraLength = CStringSize("Return-Path: <>");
  1249. if (iRetLength > (int) (sizeof(szReturnPath) - iExtraLength - 2))
  1250. pszRetPath[sizeof(szReturnPath) - iExtraLength - 2] =
  1251.     '';
  1253. SysSNPrintf(szReturnPath, sizeof(szReturnPath) - 1,
  1254.     "Return-Path: <%s>", pszRetPath);
  1256. SysFree(pszRetPath);
  1257. }
  1258. } else {
  1259. SysSNPrintf(szReturnPath, sizeof(szReturnPath) - 1,
  1260.     "Return-Path: <%s@%s>", szName, szDomain);
  1262. char szAddress[MAX_ADDR_NAME] = "";
  1264. SysSNPrintf(szAddress, sizeof(szAddress) - 1, "%s@%s", szName, szDomain);
  1266. USmlSetTagAddress(hFSpool, "Reply-To", szAddress);
  1267. }
  1269. fprintf(pMBFile, "%srn", szReturnPath);
  1271. ///////////////////////////////////////////////////////////////////////////////
  1272. //  Add "Delivered-To:" tag
  1273. ///////////////////////////////////////////////////////////////////////////////
  1274. char szUserAddress[MAX_ADDR_NAME] = "";
  1276. UsrGetAddress(pUI, szUserAddress);
  1278. fprintf(pMBFile, "Delivered-To: %srn", szUserAddress);
  1279. } else
  1280. SysFree(pszReturnPath);
  1282. ///////////////////////////////////////////////////////////////////////////////
  1283. //  Write mail file
  1284. ///////////////////////////////////////////////////////////////////////////////
  1285. if (USmlWriteMailFile(hFSpool, pMBFile) < 0) {
  1286. ErrorPush();
  1287. fclose(pMBFile);
  1288. SysRemove(pszFileName);
  1289. return (ErrorPop());
  1290. }
  1292. fclose(pMBFile);
  1294. return (0);
  1296. }
  1298. int USmlVCreateSpoolFile(SPLF_HANDLE hFSpool, char const *pszFromUser,
  1299.  char const *pszRcptUser, char const *pszFileName, va_list Headers)
  1300. {
  1302. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  1303. char const *pszSmtpMessageID = USmlGetSmtpMessageID(hFSpool);
  1304. char const *const *ppszInfo = USmlGetInfo(hFSpool);
  1305. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  1306. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  1308. FILE *pSpoolFile = fopen(pszFileName, "wb");
  1310. if (pSpoolFile == NULL) {
  1311. ErrSetErrorCode(ERR_FILE_CREATE);
  1312. return (ERR_FILE_CREATE);
  1313. }
  1314. ///////////////////////////////////////////////////////////////////////////////
  1315. //  Write info line
  1316. ///////////////////////////////////////////////////////////////////////////////
  1317. USmtpWriteInfoLine(pSpoolFile, ppszInfo[smiClientAddr],
  1318.    ppszInfo[smiServerAddr], ppszInfo[smiTime]);
  1320. ///////////////////////////////////////////////////////////////////////////////
  1321. //  Write SMTP domain
  1322. ///////////////////////////////////////////////////////////////////////////////
  1323. fprintf(pSpoolFile, "%srn", pszSMTPDomain);
  1325. ///////////////////////////////////////////////////////////////////////////////
  1326. //  Write message ID
  1327. ///////////////////////////////////////////////////////////////////////////////
  1328. fprintf(pSpoolFile, "%srn", pszSmtpMessageID);
  1330. ///////////////////////////////////////////////////////////////////////////////
  1331. //  Write "MAIL FROM:"
  1332. ///////////////////////////////////////////////////////////////////////////////
  1333. char const *pszMailFrom = USmlMailFrom(hFSpool);
  1335. fprintf(pSpoolFile, "MAIL FROM: <%s>rn",
  1336. (pszFromUser != NULL) ? pszFromUser : pszMailFrom);
  1338. ///////////////////////////////////////////////////////////////////////////////
  1339. //  Write "RCPT TO:"
  1340. ///////////////////////////////////////////////////////////////////////////////
  1341. char const *pszRcptTo = USmlRcptTo(hFSpool);
  1343. fprintf(pSpoolFile, "RCPT TO: <%s>rn", (pszRcptUser != NULL) ? pszRcptUser : pszRcptTo);
  1345. ///////////////////////////////////////////////////////////////////////////////
  1346. //  Write SPOOL_FILE_DATA_START
  1347. ///////////////////////////////////////////////////////////////////////////////
  1348. fprintf(pSpoolFile, "%srn", SPOOL_FILE_DATA_START);
  1350. ///////////////////////////////////////////////////////////////////////////////
  1351. //  Write extra RFC822 headers
  1352. ///////////////////////////////////////////////////////////////////////////////
  1353. char const *pszHeader = NULL;
  1355. while ((pszHeader = va_arg(Headers, char *)) != NULL) {
  1356. char const *pszValue = va_arg(Headers, char *);
  1358. if (pszValue == NULL)
  1359. break;
  1361. if (!IsEmptyString(pszHeader))
  1362. fprintf(pSpoolFile, "%s: %srn", pszHeader, pszValue);
  1363. }
  1365. ///////////////////////////////////////////////////////////////////////////////
  1366. //  Than write mail data
  1367. ///////////////////////////////////////////////////////////////////////////////
  1368. if (USmlWriteMailFile(hFSpool, pSpoolFile) < 0) {
  1369. ErrorPush();
  1370. fclose(pSpoolFile);
  1371. SysRemove(pszFileName);
  1372. return (ErrorPop());
  1373. }
  1375. fclose(pSpoolFile);
  1377. return (0);
  1379. }
  1381. int USmlCreateSpoolFile(SPLF_HANDLE hFSpool, char const *pszFromUser,
  1382. char const *pszRcptUser, char const *pszFileName, ...)
  1383. {
  1385. va_list Headers;
  1387. va_start(Headers, pszFileName);
  1389. int iCreateResult = USmlVCreateSpoolFile(hFSpool, pszFromUser,
  1390.  pszRcptUser, pszFileName, Headers);
  1392. va_end(Headers);
  1394. return (iCreateResult);
  1396. }
  1398. static int USmlGetMailProcessFile(UserInfo * pUI, QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage,
  1399.   char *pszMPFilePath)
  1400. {
  1402. ///////////////////////////////////////////////////////////////////////////////
  1403. //  Get the custom spool file associated with this message
  1404. ///////////////////////////////////////////////////////////////////////////////
  1405. if (USmlGetUserCustomSpoolFile(hQueue, hMessage, pszMPFilePath) < 0)
  1406. return (ErrGetErrorCode());
  1408. ///////////////////////////////////////////////////////////////////////////////
  1409. //  If the file already exist inside the spool, just return the latest
  1410. ///////////////////////////////////////////////////////////////////////////////
  1411. if (SysExistFile(pszMPFilePath))
  1412. return (0);
  1414. ///////////////////////////////////////////////////////////////////////////////
  1415. //  Try to get a new copy from the user one. It'll fail if the account is not
  1416. //  handled with a custom mail processing
  1417. ///////////////////////////////////////////////////////////////////////////////
  1418. return (UsrGetMailProcessFile(pUI, pszMPFilePath));
  1420. }
  1422. int USmlProcessLocalUserMessage(SVRCFG_HANDLE hSvrConfig, UserInfo * pUI, SPLF_HANDLE hFSpool,
  1423. QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage,
  1424. LocalMailProcConfig & LMPC)
  1425. {
  1426. ///////////////////////////////////////////////////////////////////////////////
  1427. //  Exist user custom message processing ?
  1428. ///////////////////////////////////////////////////////////////////////////////
  1429. char szMPFile[SYS_MAX_PATH] = "";
  1431. if (USmlGetMailProcessFile(pUI, hQueue, hMessage, szMPFile) < 0) {
  1432. ///////////////////////////////////////////////////////////////////////////////
  1433. //  Apply filters ...
  1434. ///////////////////////////////////////////////////////////////////////////////
  1435. if (FilFilterMessage(hFSpool, hQueue, hMessage, FILTER_MODE_INBOUND) < 0)
  1436. return (ErrGetErrorCode());
  1438. ///////////////////////////////////////////////////////////////////////////////
  1439. //  Create mailbox file ...
  1440. ///////////////////////////////////////////////////////////////////////////////
  1441. char szMBFile[SYS_MAX_PATH] = "";
  1443. SysGetTmpFile(szMBFile);
  1445. if (USmlCreateMBFile(pUI, szMBFile, hFSpool) < 0)
  1446. return (ErrGetErrorCode());
  1448. ///////////////////////////////////////////////////////////////////////////////
  1449. //  and send it home
  1450. ///////////////////////////////////////////////////////////////////////////////
  1451. char const *pszMessageID = USmlGetSpoolFile(hFSpool);
  1453. if (UsrMoveToMailBox(pUI, szMBFile, pszMessageID) < 0) {
  1454. ErrorPush();
  1455. SysRemove(szMBFile);
  1456. return (ErrorPop());
  1457. }
  1458. ///////////////////////////////////////////////////////////////////////////////
  1459. //  Log operation
  1460. ///////////////////////////////////////////////////////////////////////////////
  1461. if (LMPC.ulFlags & LMPCF_LOG_ENABLED) {
  1462. char szLocalAddress[MAX_ADDR_NAME] = "";
  1464. USmlLogMessage(hFSpool, "LOCAL", UsrGetAddress(pUI, szLocalAddress));
  1465. }
  1466. } else {
  1467. ///////////////////////////////////////////////////////////////////////////////
  1468. //  Process custom mailings
  1469. ///////////////////////////////////////////////////////////////////////////////
  1470. if (USmlProcessCustomMailingFile(hSvrConfig, pUI, hFSpool, hQueue, hMessage,
  1471.  szMPFile, LMPC) < 0)
  1472. return (ErrGetErrorCode());
  1474. }
  1476. return (0);
  1478. }
  1480. static int USmlProcessCustomMailingFile(SVRCFG_HANDLE hSvrConfig, UserInfo * pUI,
  1481. SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  1482. QMSG_HANDLE hMessage, char const *pszMPFile,
  1483. LocalMailProcConfig & LMPC)
  1484. {
  1485. ///////////////////////////////////////////////////////////////////////////////
  1486. //  Open the mail processing file
  1487. ///////////////////////////////////////////////////////////////////////////////
  1488. FILE *pMPFile = fopen(pszMPFile, "rt");
  1490. if (pMPFile == NULL) {
  1491. ErrSetErrorCode(ERR_FILE_OPEN, pszMPFile);
  1492. return (ERR_FILE_OPEN);
  1493. }
  1494. ///////////////////////////////////////////////////////////////////////////////
  1495. //  Create pushback command file
  1496. ///////////////////////////////////////////////////////////////////////////////
  1497. char szTmpFile[SYS_MAX_PATH] = "";
  1499. SysGetTmpFile(szTmpFile);
  1501. FILE *pPushBFile = fopen(szTmpFile, "wt");
  1503. if (pPushBFile == NULL) {
  1504. fclose(pMPFile);
  1506. ErrSetErrorCode(ERR_FILE_CREATE, szTmpFile);
  1507. return (ERR_FILE_CREATE);
  1508. }
  1510. int iPushBackCmds = 0;
  1511. char szCmdLine[CUSTOM_CMD_LINE_MAX] = "";
  1513. while (MscGetConfigLine(szCmdLine, sizeof(szCmdLine) - 1, pMPFile) != NULL) {
  1514. char **ppszCmdTokens = StrGetTabLineStrings(szCmdLine);
  1516. if (ppszCmdTokens == NULL)
  1517. continue;
  1519. int iFieldsCount = StrStringsCount(ppszCmdTokens);
  1521. if (iFieldsCount > 0) {
  1522. ///////////////////////////////////////////////////////////////////////////////
  1523. //  Do command line macro substitution
  1524. ///////////////////////////////////////////////////////////////////////////////
  1525. USmlCmdMacroSubstitutes(ppszCmdTokens, pUI, hFSpool);
  1527. int iCmdResult = 0;
  1529. if (stricmp(ppszCmdTokens[0], "external") == 0)
  1530. iCmdResult =
  1531. USmlCmd_external(ppszCmdTokens, iFieldsCount, hSvrConfig, pUI,
  1532.  hFSpool, hQueue, hMessage, LMPC);
  1533. else if (stricmp(ppszCmdTokens[0], "filter") == 0)
  1534. iCmdResult =
  1535. USmlCmd_filter(ppszCmdTokens, iFieldsCount, hSvrConfig, pUI,
  1536.        hFSpool, hQueue, hMessage, LMPC);
  1537. else if (stricmp(ppszCmdTokens[0], "mailbox") == 0)
  1538. iCmdResult =
  1539. USmlCmd_mailbox(ppszCmdTokens, iFieldsCount, hSvrConfig, pUI,
  1540. hFSpool, hQueue, hMessage, LMPC);
  1541. else if (stricmp(ppszCmdTokens[0], "redirect") == 0)
  1542. iCmdResult =
  1543. USmlCmd_redirect(ppszCmdTokens, iFieldsCount, hSvrConfig, pUI,
  1544.  hFSpool, hQueue, hMessage, LMPC);
  1545. else if (stricmp(ppszCmdTokens[0], "lredirect") == 0)
  1546. iCmdResult =
  1547. USmlCmd_lredirect(ppszCmdTokens, iFieldsCount, hSvrConfig,
  1548.   pUI, hFSpool, hQueue, hMessage, LMPC);
  1549. else if (stricmp(ppszCmdTokens[0], "smtprelay") == 0)
  1550. iCmdResult =
  1551. USmlCmd_smtprelay(ppszCmdTokens, iFieldsCount, hSvrConfig,
  1552.   pUI, hFSpool, hQueue, hMessage, LMPC);
  1553. else {
  1554. SysLogMessage(LOG_LEV_ERROR,
  1555.       "Invalid command "%s" in file "%s"n",
  1556.       ppszCmdTokens[0], pszMPFile);
  1558. }
  1560. ///////////////////////////////////////////////////////////////////////////////
  1561. //  Check for the stop-processing error code
  1562. ///////////////////////////////////////////////////////////////////////////////
  1563. if (iCmdResult == SMAIL_STOP_PROCESSING) {
  1564. StrFreeStrings(ppszCmdTokens);
  1565. break;
  1566. }
  1567. ///////////////////////////////////////////////////////////////////////////////
  1568. //  Test if we must save a failed command
  1569. //  <0 = Error ; ==0 = Success ; >0 = Transient error ( save the command )
  1570. ///////////////////////////////////////////////////////////////////////////////
  1571. if (iCmdResult > 0) {
  1572. fprintf(pPushBFile, "%sn", szCmdLine);
  1574. ++iPushBackCmds;
  1575. }
  1576. ///////////////////////////////////////////////////////////////////////////////
  1577. //  An error code might result if filters blocked the message. If this is the
  1578. //  case QueCheckMessage() will return error and we MUST stop processing
  1579. ///////////////////////////////////////////////////////////////////////////////
  1580. if ((iCmdResult < 0) && (QueCheckMessage(hQueue, hMessage) < 0)) {
  1581. ErrorPush();
  1582. StrFreeStrings(ppszCmdTokens);
  1583. fclose(pPushBFile);
  1584. fclose(pMPFile);
  1585. SysRemove(szTmpFile);
  1586. return (ErrorPop());
  1587. }
  1588. }
  1590. StrFreeStrings(ppszCmdTokens);
  1592. }
  1594. fclose(pPushBFile);
  1595. fclose(pMPFile);
  1597. SysRemove(pszMPFile);
  1599. if (iPushBackCmds > 0) {
  1600. ///////////////////////////////////////////////////////////////////////////////
  1601. //  If commands left out of processing, push them into the custom file
  1602. ///////////////////////////////////////////////////////////////////////////////
  1603. if (MscMoveFile(szTmpFile, pszMPFile) < 0)
  1604. return (ErrGetErrorCode());
  1606. ErrSetErrorCode(ERR_INCOMPLETE_PROCESSING);
  1607. return (ERR_INCOMPLETE_PROCESSING);
  1608. }
  1610. SysRemove(szTmpFile);
  1612. return (0);
  1614. }
  1616. static int USmlCmdMacroSubstitutes(char **ppszCmdTokens, UserInfo * pUI, SPLF_HANDLE hFSpool)
  1617. {
  1619. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  1620. char const *const *ppszFrom = USmlGetMailFrom(hFSpool);
  1621. char const *const *ppszRcpt = USmlGetRcptTo(hFSpool);
  1622. char const *pszSmtpMessageID = USmlGetSmtpMessageID(hFSpool);
  1623. char const *pszMessageID = USmlGetSpoolFile(hFSpool);
  1624. int iFromDomains = StrStringsCount(ppszFrom);
  1625. int iRcptDomains = StrStringsCount(ppszRcpt);
  1626. FileSection FS;
  1628. ///////////////////////////////////////////////////////////////////////////////
  1629. //  This function retrieve the spool file message section and sync the content.
  1630. //  This is necessary before passing the file name to external commands.
  1631. ///////////////////////////////////////////////////////////////////////////////
  1632. if (USmlGetMsgFileSection(hFSpool, FS) < 0)
  1633. return (ErrGetErrorCode());
  1635. for (int ii = 0; ppszCmdTokens[ii] != NULL; ii++) {
  1636. if (strcmp(ppszCmdTokens[ii], "@@FROM") == 0) {
  1637. char *pszNewValue =
  1638. SysStrDup((iFromDomains > 0) ? ppszFrom[iFromDomains - 1] : "");
  1640. if (pszNewValue == NULL)
  1641. return (ErrGetErrorCode());
  1643. SysFree(ppszCmdTokens[ii]);
  1645. ppszCmdTokens[ii] = pszNewValue;
  1646. } else if (strcmp(ppszCmdTokens[ii], "@@RCPT") == 0) {
  1647. char *pszNewValue =
  1648. SysStrDup((iRcptDomains > 0) ? ppszRcpt[iRcptDomains - 1] : "");
  1650. if (pszNewValue == NULL)
  1651. return (ErrGetErrorCode());
  1653. SysFree(ppszCmdTokens[ii]);
  1655. ppszCmdTokens[ii] = pszNewValue;
  1656. } else if (strcmp(ppszCmdTokens[ii], "@@RRCPT") == 0) {
  1657. char szUserAddress[MAX_ADDR_NAME] = "";
  1659. UsrGetAddress(pUI, szUserAddress);
  1661. char *pszNewValue = SysStrDup(szUserAddress);
  1663. if (pszNewValue == NULL)
  1664. return (ErrGetErrorCode());
  1666. SysFree(ppszCmdTokens[ii]);
  1668. ppszCmdTokens[ii] = pszNewValue;
  1669. } else if (strcmp(ppszCmdTokens[ii], "@@FILE") == 0) {
  1670. char *pszNewValue = SysStrDup(FS.szFilePath);
  1672. if (pszNewValue == NULL)
  1673. return (ErrGetErrorCode());
  1675. SysFree(ppszCmdTokens[ii]);
  1677. ppszCmdTokens[ii] = pszNewValue;
  1678. } else if (strcmp(ppszCmdTokens[ii], "@@MSGID") == 0) {
  1679. char *pszNewValue = SysStrDup(pszMessageID);
  1681. if (pszNewValue == NULL)
  1682. return (ErrGetErrorCode());
  1684. SysFree(ppszCmdTokens[ii]);
  1686. ppszCmdTokens[ii] = pszNewValue;
  1687. } else if (strcmp(ppszCmdTokens[ii], "@@MSGREF") == 0) {
  1688. char *pszNewValue = SysStrDup(pszSmtpMessageID);
  1690. if (pszNewValue == NULL)
  1691. return (ErrGetErrorCode());
  1693. SysFree(ppszCmdTokens[ii]);
  1695. ppszCmdTokens[ii] = pszNewValue;
  1696. } else if (strcmp(ppszCmdTokens[ii], "@@TMPFILE") == 0) {
  1697. char szTmpFile[SYS_MAX_PATH] = "";
  1699. SysGetTmpFile(szTmpFile);
  1701. if (MscCopyFile(szTmpFile, FS.szFilePath) < 0) {
  1702. ErrorPush();
  1703. CheckRemoveFile(szTmpFile);
  1704. return (ErrorPop());
  1705. }
  1707. char *pszNewValue = SysStrDup(szTmpFile);
  1709. if (pszNewValue == NULL)
  1710. return (ErrGetErrorCode());
  1712. SysFree(ppszCmdTokens[ii]);
  1714. ppszCmdTokens[ii] = pszNewValue;
  1715. } else if (strcmp(ppszCmdTokens[ii], "@@USERAUTH") == 0) {
  1716. char szAuthName[MAX_ADDR_NAME] = "-";
  1718. USmlMessageAuth(hFSpool, szAuthName, sizeof(szAuthName) - 1);
  1720. char *pszNewValue = SysStrDup(szAuthName);
  1722. if (pszNewValue == NULL)
  1723. return (ErrGetErrorCode());
  1725. SysFree(ppszCmdTokens[ii]);
  1727. ppszCmdTokens[ii] = pszNewValue;
  1728. }
  1730. }
  1732. return (0);
  1734. }
  1736. static int USmlCmd_external(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  1737.     UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  1738.     QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC)
  1739. {
  1740. ///////////////////////////////////////////////////////////////////////////////
  1741. //  Apply filters ...
  1742. ///////////////////////////////////////////////////////////////////////////////
  1743. if (FilFilterMessage(hFSpool, hQueue, hMessage, FILTER_MODE_INBOUND) < 0)
  1744. return (ErrGetErrorCode());
  1746. if (iNumTokens < 5) {
  1747. ErrSetErrorCode(ERR_BAD_MAILPROC_CMD_SYNTAX);
  1748. return (ERR_BAD_MAILPROC_CMD_SYNTAX);
  1749. }
  1751. int iPriority = atoi(ppszCmdTokens[1]);
  1752. int iWaitTimeout = atoi(ppszCmdTokens[2]);
  1753. int iExitStatus = 0;
  1755. if (SysExec(ppszCmdTokens[3], &ppszCmdTokens[3], iWaitTimeout, iPriority,
  1756.     &iExitStatus) < 0) {
  1757. ErrorPush();
  1759. char const *pszMailFrom = USmlMailFrom(hFSpool);
  1760. char const *pszRcptTo = USmlRcptTo(hFSpool);
  1762. ErrLogMessage(LOG_LEV_MESSAGE,
  1763.       "USMAIL EXTRN-Send Prg = "%s" From = "%s" To = "%s" Failed !n",
  1764.       ppszCmdTokens[3], pszMailFrom, pszRcptTo);
  1766. QueUtErrLogMessage(hQueue, hMessage,
  1767.    "USMAIL EXTRN-Send Prg = "%s" From = "%s" To = "%s" Failed !n",
  1768.    ppszCmdTokens[3], pszMailFrom, pszRcptTo);
  1770. return (ErrorPop());
  1771. }
  1772. ///////////////////////////////////////////////////////////////////////////////
  1773. //  Log operation
  1774. ///////////////////////////////////////////////////////////////////////////////
  1775. if (LMPC.ulFlags & LMPCF_LOG_ENABLED)
  1776. USmlLogMessage(hFSpool, "EXTRN", ppszCmdTokens[3]);
  1778. return ((iExitStatus == SMAIL_EXTERNAL_EXIT_BREAK) ? SMAIL_STOP_PROCESSING: 0);
  1780. }
  1782. static int USmlCmd_filter(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  1783.   UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  1784.   QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC)
  1785. {
  1787. if (iNumTokens < 5) {
  1788. ErrSetErrorCode(ERR_BAD_MAILPROC_CMD_SYNTAX);
  1789. return (ERR_BAD_MAILPROC_CMD_SYNTAX);
  1790. }
  1792. int iPriority = atoi(ppszCmdTokens[1]);
  1793. int iWaitTimeout = atoi(ppszCmdTokens[2]);
  1794. int iExitStatus = 0;
  1796. if (SysExec(ppszCmdTokens[3], &ppszCmdTokens[3], iWaitTimeout, iPriority,
  1797.     &iExitStatus) < 0) {
  1798. ErrorPush();
  1800. char const *pszMailFrom = USmlMailFrom(hFSpool);
  1801. char const *pszRcptTo = USmlRcptTo(hFSpool);
  1803. ErrLogMessage(LOG_LEV_MESSAGE,
  1804.       "USMAIL FILTER Prg = "%s" From = "%s" To = "%s" Failed !n",
  1805.       ppszCmdTokens[3], pszMailFrom, pszRcptTo);
  1807. QueUtErrLogMessage(hQueue, hMessage,
  1808.    "USMAIL FILTER Prg = "%s" From = "%s" To = "%s" Failed !n",
  1809.    ppszCmdTokens[3], pszMailFrom, pszRcptTo);
  1811. return (ErrorPop());
  1812. }
  1814. ///////////////////////////////////////////////////////////////////////////////
  1815. //  Log operation
  1816. ///////////////////////////////////////////////////////////////////////////////
  1817. if (LMPC.ulFlags & LMPCF_LOG_ENABLED)
  1818. USmlLogMessage(hFSpool, "FILTER", ppszCmdTokens[3]);
  1820. ///////////////////////////////////////////////////////////////////////////////
  1821. //  Separate code from flags
  1822. ///////////////////////////////////////////////////////////////////////////////
  1823. int iExitFlags = iExitStatus & FILTER_FLAGS_MASK;
  1825. iExitStatus &= ~FILTER_FLAGS_MASK;
  1827. if ((iExitStatus == FILTER_OUT_EXITCODE) ||
  1828.     (iExitStatus == FILTER_OUT_NN_EXITCODE) ||
  1829.     (iExitStatus == FILTER_OUT_NNF_EXITCODE)) {
  1830. ///////////////////////////////////////////////////////////////////////////////
  1831. //  Filter out message
  1832. ///////////////////////////////////////////////////////////////////////////////
  1833. char *pszRejMsg = FilGetFilterRejMessage(USmlGetSpoolFilePath(hFSpool));
  1835. if (iExitStatus == FILTER_OUT_EXITCODE)
  1836. QueUtNotifyPermErrDelivery(hQueue, hMessage, NULL,
  1837.    (pszRejMsg != NULL) ? pszRejMsg :
  1838.    ErrGetErrorString(ERR_FILTERED_MESSAGE),
  1839.    NULL, true);
  1840. else if (iExitStatus == FILTER_OUT_NN_EXITCODE)
  1841. QueCleanupMessage(hQueue, hMessage,
  1842.   !QueUtRemoveSpoolErrors());
  1843. else
  1844. QueCleanupMessage(hQueue, hMessage, false);
  1846. if (pszRejMsg != NULL)
  1847. SysFree(pszRejMsg);
  1849. ErrSetErrorCode(ERR_FILTERED_MESSAGE);
  1850. return (ERR_FILTERED_MESSAGE);
  1851. } else if (iExitStatus == FILTER_MODIFY_EXITCODE) {
  1852. ///////////////////////////////////////////////////////////////////////////////
  1853. //  Filter modified the message, we need to reload the spool handle
  1854. ///////////////////////////////////////////////////////////////////////////////
  1855. if (USmlReloadHandle(hFSpool) < 0) {
  1856. ErrorPush();
  1858. char const *pszMailFrom = USmlMailFrom(hFSpool);
  1859. char const *pszRcptTo = USmlRcptTo(hFSpool);
  1861. SysLogMessage(LOG_LEV_MESSAGE,
  1862.       "Filter error [ Modified message corrupted ]: Sender = "%s" Recipient = "%s" (%s)n",
  1863.       pszMailFrom, pszRcptTo,
  1864.       ppszCmdTokens[3]);
  1866. QueUtErrLogMessage(hQueue, hMessage,
  1867.    "Filter error [ Modified message corrupted ]: Sender = "%s" Recipient = "%s" (%s)n",
  1868.    pszMailFrom, pszRcptTo,
  1869.    ppszCmdTokens[3]);
  1871. QueCleanupMessage(hQueue, hMessage, true);
  1873. return (ErrorPop());
  1874. }
  1875. }
  1877. return ((iExitFlags & FILTER_FLAGS_BREAK) ? SMAIL_STOP_PROCESSING: 0);
  1879. }
  1881. static int USmlCmd_mailbox(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  1882.    UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  1883.    QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC)
  1884. {
  1885. ///////////////////////////////////////////////////////////////////////////////
  1886. //  Apply filters ...
  1887. ///////////////////////////////////////////////////////////////////////////////
  1888. if (FilFilterMessage(hFSpool, hQueue, hMessage, FILTER_MODE_INBOUND) < 0)
  1889. return (ErrGetErrorCode());
  1891. if (iNumTokens != 1) {
  1892. ErrSetErrorCode(ERR_BAD_MAILPROC_CMD_SYNTAX);
  1893. return (ERR_BAD_MAILPROC_CMD_SYNTAX);
  1894. }
  1895. ///////////////////////////////////////////////////////////////////////////////
  1896. //  Create mailbox file ...
  1897. ///////////////////////////////////////////////////////////////////////////////
  1898. char szMBFile[SYS_MAX_PATH] = "";
  1900. SysGetTmpFile(szMBFile);
  1902. if (USmlCreateMBFile(pUI, szMBFile, hFSpool) < 0)
  1903. return (ErrGetErrorCode());
  1905. ///////////////////////////////////////////////////////////////////////////////
  1906. //  and send it home
  1907. ///////////////////////////////////////////////////////////////////////////////
  1908. char const *pszMessageID = USmlGetSpoolFile(hFSpool);
  1910. if (UsrMoveToMailBox(pUI, szMBFile, pszMessageID) < 0) {
  1911. ErrorPush();
  1912. SysRemove(szMBFile);
  1913. return (ErrorPop());
  1914. }
  1915. ///////////////////////////////////////////////////////////////////////////////
  1916. //  Log operation
  1917. ///////////////////////////////////////////////////////////////////////////////
  1918. if (LMPC.ulFlags & LMPCF_LOG_ENABLED) {
  1919. char szLocalAddress[MAX_ADDR_NAME] = "";
  1921. USmlLogMessage(hFSpool, "LOCAL", UsrGetAddress(pUI, szLocalAddress));
  1922. }
  1924. return (0);
  1926. }
  1928. static int USmlCmd_redirect(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  1929.     UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  1930.     QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC)
  1931. {
  1933. if (iNumTokens < 2) {
  1934. ErrSetErrorCode(ERR_BAD_MAILPROC_CMD_SYNTAX);
  1935. return (ERR_BAD_MAILPROC_CMD_SYNTAX);
  1936. }
  1938. char szUserAddress[MAX_ADDR_NAME] = "";
  1940. UsrGetAddress(pUI, szUserAddress);
  1942. ///////////////////////////////////////////////////////////////////////////////
  1943. //  Redirection loop
  1944. ///////////////////////////////////////////////////////////////////////////////
  1945. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  1947. for (int ii = 1; ppszCmdTokens[ii] != NULL; ii++) {
  1948. ///////////////////////////////////////////////////////////////////////////////
  1949. //  Get message handle
  1950. ///////////////////////////////////////////////////////////////////////////////
  1951. QMSG_HANDLE hRedirMessage = QueCreateMessage(hSpoolQueue);
  1953. if (hRedirMessage == INVALID_QMSG_HANDLE)
  1954. return (ErrGetErrorCode());
  1956. char szQueueFilePath[SYS_MAX_PATH] = "";
  1958. QueGetFilePath(hSpoolQueue, hRedirMessage, szQueueFilePath);
  1960. char szAliasAddr[MAX_ADDR_NAME] = "";
  1962. if (strchr(ppszCmdTokens[ii], '@') == NULL)
  1963. SysSNPrintf(szAliasAddr, sizeof(szAliasAddr) - 1, "%s@%s",
  1964.     pUI->pszName, ppszCmdTokens[ii]);
  1965. else
  1966. StrSNCpy(szAliasAddr, ppszCmdTokens[ii]);
  1968. if (USmlCreateSpoolFile(hFSpool, NULL, szAliasAddr, szQueueFilePath,
  1969. "X-Deliver-To", szUserAddress, NULL) < 0) {
  1970. ErrorPush();
  1971. QueCleanupMessage(hSpoolQueue, hRedirMessage);
  1972. QueCloseMessage(hSpoolQueue, hRedirMessage);
  1973. return (ErrorPop());
  1974. }
  1975. ///////////////////////////////////////////////////////////////////////////////
  1976. //  Transfer file to the spool
  1977. ///////////////////////////////////////////////////////////////////////////////
  1978. if (QueCommitMessage(hSpoolQueue, hRedirMessage) < 0) {
  1979. ErrorPush();
  1980. QueCleanupMessage(hSpoolQueue, hRedirMessage);
  1981. QueCloseMessage(hSpoolQueue, hRedirMessage);
  1982. return (ErrorPop());
  1983. }
  1984. ///////////////////////////////////////////////////////////////////////////////
  1985. //  Log the redir operation
  1986. ///////////////////////////////////////////////////////////////////////////////
  1987. if (LMPC.ulFlags & LMPCF_LOG_ENABLED)
  1988. USmlLogMessage(hFSpool, "REDIR", ppszCmdTokens[ii]);
  1989. }
  1991. return (0);
  1993. }
  1995. static int USmlCmd_lredirect(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  1996.      UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  1997.      QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC)
  1998. {
  2000. if (iNumTokens < 2) {
  2001. ErrSetErrorCode(ERR_BAD_MAILPROC_CMD_SYNTAX);
  2002. return (ERR_BAD_MAILPROC_CMD_SYNTAX);
  2003. }
  2005. char szUserAddress[MAX_ADDR_NAME] = "";
  2007. UsrGetAddress(pUI, szUserAddress);
  2009. ///////////////////////////////////////////////////////////////////////////////
  2010. //  Redirection loop
  2011. ///////////////////////////////////////////////////////////////////////////////
  2012. for (int ii = 1; ppszCmdTokens[ii] != NULL; ii++) {
  2013. ///////////////////////////////////////////////////////////////////////////////
  2014. //  Get message handle
  2015. ///////////////////////////////////////////////////////////////////////////////
  2016. QMSG_HANDLE hRedirMessage = QueCreateMessage(hSpoolQueue);
  2018. if (hRedirMessage == INVALID_QMSG_HANDLE)
  2019. return (ErrGetErrorCode());
  2021. char szQueueFilePath[SYS_MAX_PATH] = "";
  2023. QueGetFilePath(hSpoolQueue, hRedirMessage, szQueueFilePath);
  2025. char szAliasAddr[MAX_ADDR_NAME] = "";
  2027. if (strchr(ppszCmdTokens[ii], '@') == NULL)
  2028. SysSNPrintf(szAliasAddr, sizeof(szAliasAddr) - 1, "%s@%s",
  2029.     pUI->pszName, ppszCmdTokens[ii]);
  2030. else
  2031. StrSNCpy(szAliasAddr, ppszCmdTokens[ii]);
  2033. if (USmlCreateSpoolFile(hFSpool, szUserAddress, szAliasAddr, szQueueFilePath,
  2034. "X-Deliver-To", szUserAddress, NULL) < 0) {
  2035. ErrorPush();
  2036. QueCleanupMessage(hSpoolQueue, hRedirMessage);
  2037. QueCloseMessage(hSpoolQueue, hRedirMessage);
  2038. return (ErrorPop());
  2039. }
  2040. ///////////////////////////////////////////////////////////////////////////////
  2041. //  Transfer file to the spool
  2042. ///////////////////////////////////////////////////////////////////////////////
  2043. if (QueCommitMessage(hSpoolQueue, hRedirMessage) < 0) {
  2044. ErrorPush();
  2045. QueCleanupMessage(hSpoolQueue, hRedirMessage);
  2046. QueCloseMessage(hSpoolQueue, hRedirMessage);
  2047. return (ErrorPop());
  2048. }
  2049. ///////////////////////////////////////////////////////////////////////////////
  2050. //  Log the redir operation
  2051. ///////////////////////////////////////////////////////////////////////////////
  2052. if (LMPC.ulFlags & LMPCF_LOG_ENABLED)
  2053. USmlLogMessage(hFSpool, "LREDIR", ppszCmdTokens[ii]);
  2054. }
  2056. return (0);
  2058. }
  2060. static int USmlCmd_smtprelay(char **ppszCmdTokens, int iNumTokens, SVRCFG_HANDLE hSvrConfig,
  2061.      UserInfo * pUI, SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  2062.      QMSG_HANDLE hMessage, LocalMailProcConfig & LMPC)
  2063. {
  2064. ///////////////////////////////////////////////////////////////////////////////
  2065. //  Apply filters ...
  2066. ///////////////////////////////////////////////////////////////////////////////
  2067. if (FilFilterMessage(hFSpool, hQueue, hMessage, FILTER_MODE_OUTBOUND) < 0)
  2068. return (ErrGetErrorCode());
  2070. if (iNumTokens < 2) {
  2071. ErrSetErrorCode(ERR_BAD_MAILPROC_CMD_SYNTAX);
  2072. return (ERR_BAD_MAILPROC_CMD_SYNTAX);
  2073. }
  2075. char **ppszRelays = NULL;
  2077. if (ppszCmdTokens[1][0] == '#') {
  2078. if ((ppszRelays = StrTokenize(ppszCmdTokens[1] + 1, ",")) != NULL) {
  2079. int iRelayCount = StrStringsCount(ppszRelays);
  2081. srand((unsigned int) time(NULL));
  2083. for (int ii = 0; ii < (iRelayCount / 2); ii++) {
  2084. int iSwap1 = rand() % iRelayCount;
  2085. int iSwap2 = rand() % iRelayCount;
  2086. char *pszRly1 = ppszRelays[iSwap1];
  2087. char *pszRly2 = ppszRelays[iSwap2];
  2089. ppszRelays[iSwap1] = pszRly2;
  2090. ppszRelays[iSwap2] = pszRly1;
  2091. }
  2092. }
  2093. } else
  2094. ppszRelays = StrTokenize(ppszCmdTokens[1], ",");
  2096. if (ppszRelays == NULL)
  2097. return (ErrGetErrorCode());
  2099. ///////////////////////////////////////////////////////////////////////////////
  2100. //  This function retrieve the spool file message section and sync the content.
  2101. //  This is necessary before sending the file
  2102. ///////////////////////////////////////////////////////////////////////////////
  2103. FileSection FS;
  2105. if (USmlGetMsgFileSection(hFSpool, FS) < 0) {
  2106. ErrorPush();
  2107. StrFreeStrings(ppszRelays);
  2108. return (ErrorPop());
  2109. }
  2110. ///////////////////////////////////////////////////////////////////////////////
  2111. //  Get spool file infos
  2112. ///////////////////////////////////////////////////////////////////////////////
  2113. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  2114. char const *pszMailFrom = USmlMailFrom(hFSpool);
  2115. char const *pszRcptTo = USmlRcptTo(hFSpool);
  2116. char const *pszSendMailFrom = USmlSendMailFrom(hFSpool);
  2117. char const *pszSendRcptTo = USmlSendRcptTo(hFSpool);
  2118. char const *pszSpoolFilePath = USmlGetSpoolFilePath(hFSpool);
  2120. ///////////////////////////////////////////////////////////////////////////////
  2121. //  Get HELO domain
  2122. ///////////////////////////////////////////////////////////////////////////////
  2123. char szHeloDomain[MAX_HOST_NAME] = "";
  2125. SvrConfigVar("HeloDomain", szHeloDomain, sizeof(szHeloDomain) - 1, hSvrConfig, "");
  2127. char const *pszHeloDomain = IsEmptyString(szHeloDomain) ? NULL : szHeloDomain;
  2129. SMTPError SMTPE;
  2131. USmtpInitError(&SMTPE);
  2133. ///////////////////////////////////////////////////////////////////////////////
  2134. //  By initializing this to zero makes XMail to discharge all mail for domains
  2135. //  that have an empty relay list
  2136. ///////////////////////////////////////////////////////////////////////////////
  2137. int iReturnCode = 0;
  2139. for (int ss = 0; ppszRelays[ss] != NULL; ss++) {
  2140. SysLogMessage(LOG_LEV_MESSAGE,
  2141.       "USMAIL SMTP-Send RLYS = "%s" SMTP = "%s" From = "%s" To = "%s"n",
  2142.       ppszRelays[ss], pszSMTPDomain, pszMailFrom, pszRcptTo);
  2144. USmtpCleanupError(&SMTPE);
  2146. if (USmtpSendMail(ppszRelays[ss], pszHeloDomain, pszSendMailFrom, pszSendRcptTo,
  2147.   &FS, &SMTPE) == 0) {
  2148. ///////////////////////////////////////////////////////////////////////////////
  2149. //  Log Mailer operation
  2150. ///////////////////////////////////////////////////////////////////////////////
  2151. if (LMPC.ulFlags & LMPCF_LOG_ENABLED)
  2152. USmlLogMessage(hFSpool, "RLYS", ppszRelays[ss]);
  2154. USmtpCleanupError(&SMTPE);
  2156. StrFreeStrings(ppszRelays);
  2158. return (0);
  2159. }
  2161. int iErrorCode = ErrGetErrorCode();
  2162. char szSmtpError[512] = "";
  2164. USmtpGetSMTPError(&SMTPE, szSmtpError, sizeof(szSmtpError));
  2166. ErrLogMessage(LOG_LEV_MESSAGE,
  2167.       "USMAIL SMTP-Send RLYS = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  2168.       "%s = "%s"n", ppszRelays[ss], pszSMTPDomain, pszMailFrom,
  2169.       pszRcptTo, SMTP_ERROR_VARNAME, szSmtpError);
  2171. QueUtErrLogMessage(hQueue, hMessage,
  2172.    "USMAIL SMTP-Send RLYS = "%s" SMTP = "%s" From = "%s" To = "%s" Failed !n"
  2173.    "%s = "%s"n", ppszRelays[ss], pszSMTPDomain, pszMailFrom,
  2174.    pszRcptTo, SMTP_ERROR_VARNAME, szSmtpError);
  2176. ///////////////////////////////////////////////////////////////////////////////
  2177. //  If a permanent SMTP error has been detected, then notify the message sender
  2178. ///////////////////////////////////////////////////////////////////////////////
  2179. if (USmtpIsFatalError(&SMTPE))
  2180. QueUtNotifyPermErrDelivery(hQueue, hMessage, hFSpool,
  2181.    USmtpGetErrorMessage(&SMTPE),
  2182.    USmtpGetErrorServer(&SMTPE), false);
  2184. iReturnCode = USmtpIsFatalError(&SMTPE) ? iErrorCode : -iErrorCode;
  2185. }
  2187. USmtpCleanupError(&SMTPE);
  2189. StrFreeStrings(ppszRelays);
  2191. return (iReturnCode);
  2193. }
  2195. int USmlGetDomainCustomDir(char *pszCustomDir, int iMaxPath, int iFinalSlash)
  2196. {
  2198. CfgGetRootPath(pszCustomDir, iMaxPath);
  2200. StrNCat(pszCustomDir, SMAIL_DOMAIN_PROC_DIR, iMaxPath);
  2201. if (iFinalSlash)
  2202. AppendSlash(pszCustomDir);
  2204. return (0);
  2206. }
  2208. int USmlGetCmdAliasDir(char *pszAliasDir, int iMaxPath, int iFinalSlash)
  2209. {
  2211. CfgGetRootPath(pszAliasDir, iMaxPath);
  2213. StrNCat(pszAliasDir, SMAIL_CMDALIAS_DIR, iMaxPath);
  2214. if (iFinalSlash)
  2215. AppendSlash(pszAliasDir);
  2217. return (0);
  2219. }
  2221. int USmlGetCmdAliasFile(char const *pszDomain, char const *pszUser, char *pszAliasFile)
  2222. {
  2224. char szAliasDir[SYS_MAX_PATH] = "";
  2226. USmlGetCmdAliasDir(szAliasDir, sizeof(szAliasDir), 1);
  2228. SysSNPrintf(pszAliasFile, SYS_MAX_PATH - 1, "%s%s%s%s.tab",
  2229.     szAliasDir, pszDomain, SYS_SLASH_STR, pszUser);
  2231. StrLower(pszAliasFile + strlen(szAliasDir));
  2233. return (0);
  2235. }
  2237. int USmlIsCmdAliasAccount(char const *pszDomain, char const *pszUser, char *pszAliasFile)
  2238. {
  2240. char szAliasFile[SYS_MAX_PATH] = "";
  2242. if (pszAliasFile == NULL)
  2243. pszAliasFile = szAliasFile;
  2245. if (USmlGetCmdAliasFile(pszDomain, pszUser, pszAliasFile) < 0)
  2246. return (ErrGetErrorCode());
  2248. if (!SysExistFile(pszAliasFile)) {
  2249. ErrSetErrorCode(ERR_NOT_A_CMD_ALIAS);
  2250. return (ERR_NOT_A_CMD_ALIAS);
  2251. }
  2253. return (0);
  2255. }
  2257. int USmlCreateCmdAliasDomainDir(char const *pszDomain)
  2258. {
  2260. char szAliasDir[SYS_MAX_PATH] = "";
  2261. char szDomainAliasDir[SYS_MAX_PATH] = "";
  2263. USmlGetCmdAliasDir(szAliasDir, sizeof(szAliasDir), 1);
  2265. SysSNPrintf(szDomainAliasDir, sizeof(szDomainAliasDir) - 1, "%s%s",
  2266.     szAliasDir, pszDomain);
  2268. StrLower(szDomainAliasDir + strlen(szAliasDir));
  2270. if (SysMakeDir(szDomainAliasDir) < 0)
  2271. return (ErrGetErrorCode());
  2273. return (0);
  2275. }
  2277. int USmlDeleteCmdAliasDomainDir(char const *pszDomain)
  2278. {
  2280. char szAliasDir[SYS_MAX_PATH] = "";
  2281. char szDomainAliasDir[SYS_MAX_PATH] = "";
  2283. USmlGetCmdAliasDir(szAliasDir, sizeof(szAliasDir), 1);
  2285. SysSNPrintf(szDomainAliasDir, sizeof(szDomainAliasDir) - 1, "%s%s",
  2286.     szAliasDir, pszDomain);
  2288. StrLower(szDomainAliasDir + strlen(szAliasDir));
  2290. if (SysExistDir(szDomainAliasDir)) {
  2291. if (MscClearDirectory(szDomainAliasDir) < 0)
  2292. return (ErrGetErrorCode());
  2294. if (SysRemoveDir(szDomainAliasDir) < 0)
  2295. return (ErrGetErrorCode());
  2296. }
  2298. return (0);
  2300. }
  2302. int USmlGetCmdAliasSpoolFile(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, char *pszAliasFilePath)
  2303. {
  2305. return (QueGetFilePath(hQueue, hMessage, pszAliasFilePath, QUEUE_CUST_DIR));
  2307. }
  2309. int USmlGetCmdAliasCustomFile(SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  2310.       QMSG_HANDLE hMessage, char const *pszDomain, char const *pszUser,
  2311.       char *pszAliasFilePath)
  2312. {
  2313. ///////////////////////////////////////////////////////////////////////////////
  2314. //  Check if exist a spooled copy
  2315. ///////////////////////////////////////////////////////////////////////////////
  2316. char const *pszSpoolFilePath = USmlGetSpoolFilePath(hFSpool);
  2318. USmlGetCmdAliasSpoolFile(hQueue, hMessage, pszAliasFilePath);
  2320. if (SysExistFile(pszAliasFilePath))
  2321. return (0);
  2323. ///////////////////////////////////////////////////////////////////////////////
  2324. //  Check if this is a cmd alias
  2325. ///////////////////////////////////////////////////////////////////////////////
  2326. char szAliasFile[SYS_MAX_PATH] = "";
  2328. if (USmlIsCmdAliasAccount(pszDomain, pszUser, szAliasFile) < 0)
  2329. return (ErrGetErrorCode());
  2331. RLCK_HANDLE hResLock = RLckLockSH(szAliasFile);
  2333. if (hResLock == INVALID_RLCK_HANDLE)
  2334. return (ErrGetErrorCode());
  2336. ///////////////////////////////////////////////////////////////////////////////
  2337. //  Make a copy into the spool
  2338. ///////////////////////////////////////////////////////////////////////////////
  2339. if (MscCopyFile(pszAliasFilePath, szAliasFile) < 0) {
  2340. ErrorPush();
  2341. RLckUnlockSH(hResLock);
  2342. return (ErrorPop());
  2343. }
  2345. RLckUnlockSH(hResLock);
  2347. return (0);
  2349. }
  2351. int USmlDomainCustomFileName(char const *pszDestDomain, char *pszCustFilePath)
  2352. {
  2353. ///////////////////////////////////////////////////////////////////////////////
  2354. //  Make domain name lower case
  2355. ///////////////////////////////////////////////////////////////////////////////
  2356. char szDestDomain[MAX_HOST_NAME] = "";
  2358. StrSNCpy(szDestDomain, pszDestDomain);
  2359. StrLower(szDestDomain);
  2361. ///////////////////////////////////////////////////////////////////////////////
  2362. //  Build file name
  2363. ///////////////////////////////////////////////////////////////////////////////
  2364. char szCustomDir[SYS_MAX_PATH] = "";
  2366. USmlGetDomainCustomDir(szCustomDir, sizeof(szCustomDir), 1);
  2368. SysSNPrintf(pszCustFilePath, SYS_MAX_PATH - 1, "%s%s.tab", szCustomDir, szDestDomain);
  2370. return (0);
  2372. }
  2374. int USmlGetDomainCustomFile(char const *pszDestDomain, char *pszCustFilePath)
  2375. {
  2376. ///////////////////////////////////////////////////////////////////////////////
  2377. //  Make domain name lower case
  2378. ///////////////////////////////////////////////////////////////////////////////
  2379. char szDestDomain[MAX_HOST_NAME] = "";
  2381. StrSNCpy(szDestDomain, pszDestDomain);
  2382. StrLower(szDestDomain);
  2384. ///////////////////////////////////////////////////////////////////////////////
  2385. //  Lookup custom files
  2386. ///////////////////////////////////////////////////////////////////////////////
  2387. char szCustomDir[SYS_MAX_PATH] = "";
  2389. USmlGetDomainCustomDir(szCustomDir, sizeof(szCustomDir), 1);
  2391. for (char const *pszSubDom = szDestDomain; pszSubDom != NULL;
  2392.      pszSubDom = strchr(pszSubDom + 1, '.')) {
  2393. SysSNPrintf(pszCustFilePath, SYS_MAX_PATH - 1, "%s%s.tab", szCustomDir,
  2394.     pszSubDom);
  2396. if (SysExistFile(pszCustFilePath))
  2397. return (0);
  2399. }
  2401. SysSNPrintf(pszCustFilePath, SYS_MAX_PATH - 1, "%s.tab", szCustomDir);
  2403. if (SysExistFile(pszCustFilePath))
  2404. return (0);
  2406. ErrSetErrorCode(ERR_NOT_A_CUSTOM_DOMAIN);
  2407. return (ERR_NOT_A_CUSTOM_DOMAIN);
  2409. }
  2411. int USmlGetDomainCustomSpoolFile(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, char *pszCustFilePath)
  2412. {
  2414. return (QueGetFilePath(hQueue, hMessage, pszCustFilePath, QUEUE_CUST_DIR));
  2416. }
  2418. int USmlGetUserCustomSpoolFile(QUEUE_HANDLE hQueue, QMSG_HANDLE hMessage, char *pszCustFilePath)
  2419. {
  2421. return (QueGetFilePath(hQueue, hMessage, pszCustFilePath, QUEUE_MPRC_DIR));
  2423. }
  2425. int USmlGetDomainMsgCustomFile(SPLF_HANDLE hFSpool, QUEUE_HANDLE hQueue,
  2426.        QMSG_HANDLE hMessage, char const *pszDestDomain,
  2427.        char *pszCustFilePath)
  2428. {
  2429. ///////////////////////////////////////////////////////////////////////////////
  2430. //  Check if exist a spooled copy
  2431. ///////////////////////////////////////////////////////////////////////////////
  2432. char const *pszSpoolFilePath = USmlGetSpoolFilePath(hFSpool);
  2434. USmlGetDomainCustomSpoolFile(hQueue, hMessage, pszCustFilePath);
  2436. if (SysExistFile(pszCustFilePath))
  2437. return (0);
  2439. ///////////////////////////////////////////////////////////////////////////////
  2440. //  Check if this is a custom domain
  2441. ///////////////////////////////////////////////////////////////////////////////
  2442. char szCustDomainFile[SYS_MAX_PATH] = "";
  2444. if (USmlGetDomainCustomFile(pszDestDomain, szCustDomainFile) < 0)
  2445. return (ErrGetErrorCode());
  2447. RLCK_HANDLE hResLock = RLckLockSH(szCustDomainFile);
  2449. if (hResLock == INVALID_RLCK_HANDLE)
  2450. return (ErrGetErrorCode());
  2452. ///////////////////////////////////////////////////////////////////////////////
  2453. //  Make a copy into the spool
  2454. ///////////////////////////////////////////////////////////////////////////////
  2455. if (MscCopyFile(pszCustFilePath, szCustDomainFile) < 0) {
  2456. ErrorPush();
  2457. RLckUnlockSH(hResLock);
  2458. return (ErrorPop());
  2459. }
  2461. RLckUnlockSH(hResLock);
  2463. return (0);
  2465. }
  2467. int USmlGetCustomDomainFile(char const *pszDestDomain, char const *pszCustFilePath)
  2468. {
  2469. ///////////////////////////////////////////////////////////////////////////////
  2470. //  Check if this is a custom domain
  2471. ///////////////////////////////////////////////////////////////////////////////
  2472. char szCustDomainFile[SYS_MAX_PATH] = "";
  2474. if (USmlGetDomainCustomFile(pszDestDomain, szCustDomainFile) < 0)
  2475. return (ErrGetErrorCode());
  2477. char szResLock[SYS_MAX_PATH] = "";
  2478. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szCustDomainFile, szResLock,
  2479.   sizeof(szResLock)));
  2481. if (hResLock == INVALID_RLCK_HANDLE)
  2482. return (ErrGetErrorCode());
  2484. ///////////////////////////////////////////////////////////////////////////////
  2485. //  Make a copy onto user supplied file
  2486. ///////////////////////////////////////////////////////////////////////////////
  2487. if (MscCopyFile(pszCustFilePath, szCustDomainFile) < 0) {
  2488. ErrorPush();
  2489. RLckUnlockSH(hResLock);
  2490. return (ErrorPop());
  2491. }
  2493. RLckUnlockSH(hResLock);
  2495. return (0);
  2497. }
  2499. int USmlSetCustomDomainFile(char const *pszDestDomain, char const *pszCustFilePath)
  2500. {
  2501. ///////////////////////////////////////////////////////////////////////////////
  2502. //  Check if this is a custom domain
  2503. ///////////////////////////////////////////////////////////////////////////////
  2504. char szCustDomainFile[SYS_MAX_PATH] = "";
  2506. USmlDomainCustomFileName(pszDestDomain, szCustDomainFile);
  2508. char szResLock[SYS_MAX_PATH] = "";
  2509. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szCustDomainFile, szResLock,
  2510.   sizeof(szResLock)));
  2512. if (hResLock == INVALID_RLCK_HANDLE)
  2513. return (ErrGetErrorCode());
  2515. if (pszCustFilePath != NULL) {
  2516. ///////////////////////////////////////////////////////////////////////////////
  2517. //  Overwrite current file
  2518. ///////////////////////////////////////////////////////////////////////////////
  2519. if (MscCopyFile(szCustDomainFile, pszCustFilePath) < 0) {
  2520. ErrorPush();
  2521. RLckUnlockEX(hResLock);
  2522. return (ErrorPop());
  2523. }
  2524. } else
  2525. SysRemove(szCustDomainFile);
  2527. RLckUnlockEX(hResLock);
  2529. return (0);
  2531. }
  2533. int USmlCustomizedDomain(char const *pszDestDomain)
  2534. {
  2536. char szCustFilePath[SYS_MAX_PATH] = "";
  2538. return (USmlGetDomainCustomFile(pszDestDomain, szCustFilePath));
  2540. }
  2542. static int USmlLogMessage(char const *pszSMTPDomain, char const *pszMessageID,
  2543.   char const *pszSmtpMessageID, char const *pszFrom, char const *pszRcpt,
  2544.   char const *pszMedium, char const *pszParam)
  2545. {
  2547. char szTime[256] = "";
  2549. MscGetTimeNbrString(szTime, sizeof(szTime) - 1);
  2551. RLCK_HANDLE hResLock = RLckLockEX(SVR_LOGS_DIR SYS_SLASH_STR SMAIL_LOG_FILE);
  2553. if (hResLock == INVALID_RLCK_HANDLE)
  2554. return (ErrGetErrorCode());
  2556. MscFileLog(SMAIL_LOG_FILE, ""%s""
  2557.    "t"%s""
  2558.    "t"%s""
  2559.    "t"%s""
  2560.    "t"%s""
  2561.    "t"%s""
  2562.    "t"%s""
  2563.    "t"%s""
  2564.    "n", pszSMTPDomain, pszMessageID, pszSmtpMessageID, pszFrom, pszRcpt,
  2565.    pszMedium, pszParam, szTime);
  2567. RLckUnlockEX(hResLock);
  2569. return (0);
  2571. }
  2573. int USmlLogMessage(SPLF_HANDLE hFSpool, char const *pszMedium, char const *pszParam)
  2574. {
  2576. char const *pszSMTPDomain = USmlGetSMTPDomain(hFSpool);
  2577. char const *pszSmtpMessageID = USmlGetSmtpMessageID(hFSpool);
  2578. char const *pszMessageID = USmlGetSpoolFile(hFSpool);
  2579. char const *pszMailFrom = USmlMailFrom(hFSpool);
  2580. char const *pszRcptTo = USmlRcptTo(hFSpool);
  2582. USmlLogMessage(pszSMTPDomain, pszMessageID, pszSmtpMessageID, pszMailFrom, pszRcptTo,
  2583.        pszMedium, pszParam);
  2585. return (0);
  2587. }
  2589. int USmlParseAddress(char const *pszAddress, char *pszPreAddr,
  2590.      int iMaxPreAddress, char *pszEmailAddr, int iMaxAddress)
  2591. {
  2593. for (; (*pszAddress == ' ') || (*pszAddress == 't'); pszAddress++);
  2595. if (*pszAddress == '') {
  2596. ErrSetErrorCode(ERR_BAD_TAG_ADDRESS);
  2597. return (ERR_BAD_TAG_ADDRESS);
  2598. }
  2600. char const *pszOpen = strrchr(pszAddress, '<');
  2602. if (pszOpen != NULL) {
  2603. if (pszPreAddr != NULL) {
  2604. int iPreCount = Min((int) (pszOpen - pszAddress), iMaxPreAddress - 1);
  2606. strncpy(pszPreAddr, pszAddress, iPreCount);
  2607. pszPreAddr[iPreCount] = '';
  2609. StrTrim(pszPreAddr, " t");
  2610. }
  2612. if (pszEmailAddr != NULL) {
  2613. char const *pszClose = strrchr(pszAddress, '>');
  2615. if (pszClose == NULL) {
  2616. ErrSetErrorCode(ERR_BAD_TAG_ADDRESS);
  2617. return (ERR_BAD_TAG_ADDRESS);
  2618. }
  2620. int iEmailCount = (int) Min((pszClose - pszOpen) - 1, iMaxAddress - 1);
  2622. if (iEmailCount < 0) {
  2623. ErrSetErrorCode(ERR_BAD_TAG_ADDRESS);
  2624. return (ERR_BAD_TAG_ADDRESS);
  2625. }
  2627. strncpy(pszEmailAddr, pszOpen + 1, iEmailCount);
  2628. pszEmailAddr[iEmailCount] = '';
  2630. StrTrim(pszEmailAddr, " t");
  2631. }
  2632. } else {
  2633. if (pszPreAddr != NULL)
  2634. SetEmptyString(pszPreAddr);
  2636. if (pszEmailAddr != NULL) {
  2637. strncpy(pszEmailAddr, pszAddress, iMaxAddress - 1);
  2638. pszEmailAddr[iMaxAddress - 1] = '';
  2640. StrTrim(pszEmailAddr, " t");
  2641. }
  2642. }
  2644. return (0);
  2646. }
  2648. static int USmlExtractFromAddress(HSLIST & hTagList, char *pszFromAddr, int iMaxAddress)
  2649. {
  2650. ///////////////////////////////////////////////////////////////////////////////
  2651. //  Try to discover the "Return-Path" ( or eventually "From" ) tag to setup
  2652. //  the "MAIL FROM: <>" part of the spool message
  2653. ///////////////////////////////////////////////////////////////////////////////
  2654. TAG_POSITION TagPosition = TAG_POSITION_INIT;
  2655. MessageTagData *pMTD = USmlFindTag(hTagList, "Return-Path", TagPosition);
  2657. if ((pMTD != NULL) &&
  2658.     (USmlParseAddress(pMTD->pszTagData, NULL, 0, pszFromAddr, iMaxAddress) == 0))
  2659. return (0);
  2661. TagPosition = TAG_POSITION_INIT;
  2663. if (((pMTD = USmlFindTag(hTagList, "From", TagPosition)) != NULL) &&
  2664.     (USmlParseAddress(pMTD->pszTagData, NULL, 0, pszFromAddr, iMaxAddress) == 0))
  2665. return (0);
  2667. ErrSetErrorCode(ERR_MAILFROM_UNKNOWN);
  2668. return (ERR_MAILFROM_UNKNOWN);
  2670. }
  2672. static char const *USmlAddressFromAtPtr(char const *pszAt, char const *pszBase,
  2673. char *pszAddress, int iMaxAddress)
  2674. {
  2676. char const *pszStart = pszAt;
  2678. for (; (pszStart >= pszBase) && (strchr("<> t,":;'rn", *pszStart) == NULL);
  2679.      pszStart--);
  2681. ++pszStart;
  2683. char const *pszEnd = pszAt + 1;
  2685. for (; (*pszEnd != '') && (strchr("<> t,":;'rn", *pszEnd) == NULL); pszEnd++);
  2687. int iAddrLength = Min((int) (pszEnd - pszStart), iMaxAddress - 1);
  2689. strncpy(pszAddress, pszStart, iAddrLength);
  2690. pszAddress[iAddrLength] = '';
  2692. return (pszEnd);
  2694. }
  2696. static char const *USmlAddSingleAddress(char const *pszCurr, char const *pszBase,
  2697. DynString * pAddrDS, char const *const *ppszMatchDomains,
  2698. int *piAdded)
  2699. {
  2701. *piAdded = 0;
  2703. char const *pszAt = strchr(pszCurr, '@');
  2705. if (pszAt == NULL)
  2706. return (NULL);
  2708. char szAddress[MAX_SMTP_ADDRESS] = "";
  2709. char szDomain[MAX_ADDR_NAME] = "";
  2711. if (((pszCurr = USmlAddressFromAtPtr(pszAt, pszBase, szAddress,
  2712.      sizeof(szAddress) - 1)) != NULL) &&
  2713.     (USmtpSplitEmailAddr(szAddress, NULL, szDomain) == 0) &&
  2714.     ((ppszMatchDomains == NULL) || StrStringsIMatch(ppszMatchDomains, szDomain)) &&
  2715.     (StrIStr(StrDynGet(pAddrDS), szAddress) == NULL)) {
  2716. if (StrDynSize(pAddrDS) > 0)
  2717. StrDynAdd(pAddrDS, ADDRESS_TOKENIZER);
  2719. StrDynAdd(pAddrDS, szAddress);
  2721. ++(*piAdded);
  2722. }
  2724. return (pszCurr);
  2726. }
  2728. static int USmlAddAddresses(char const *pszAddrList, DynString * pAddrDS,
  2729.     char const *const *ppszMatchDomains)
  2730. {
  2732. int iAddrAdded = 0;
  2733. int iAdded;
  2734. char const *pszCurr = pszAddrList;
  2736. for (; (pszCurr != NULL) && (*pszCurr != '');) {
  2737. pszCurr =
  2738.     USmlAddSingleAddress(pszCurr, pszAddrList, pAddrDS, ppszMatchDomains,
  2739.  &iAdded);
  2741. if (iAdded)
  2742. ++iAddrAdded;
  2743. }
  2745. return (iAddrAdded);
  2747. }
  2749. static char **USmlGetAddressList(HSLIST & hTagList, char const *const *ppszMatchDomains,
  2750.  char const *const *ppszAddrTags)
  2751. {
  2753. DynString AddrDS;
  2755. StrDynInit(&AddrDS);
  2757. for (int ii = 0; ppszAddrTags[ii] != NULL; ii++) {
  2758. char const *pszHdrTag = (strchr("+", ppszAddrTags[ii][0]) != NULL) ?
  2759.     ppszAddrTags[ii] + 1 : ppszAddrTags[ii];
  2760. TAG_POSITION TagPosition = TAG_POSITION_INIT;
  2761. MessageTagData *pMTD = USmlFindTag(hTagList, pszHdrTag, TagPosition);
  2763. for (; pMTD != NULL; pMTD = USmlFindTag(hTagList, pszHdrTag, TagPosition)) {
  2764. int iAddrAdded = USmlAddAddresses(pMTD->pszTagData, &AddrDS,
  2765.   ppszMatchDomains);
  2767. ///////////////////////////////////////////////////////////////////////////////
  2768. //  Exclusive tag detected, stop the scan
  2769. ///////////////////////////////////////////////////////////////////////////////
  2770. if ((iAddrAdded > 0) && (ppszAddrTags[ii][0] == '+'))
  2771. goto BuildAddrList;
  2772. }
  2773. }
  2775. ///////////////////////////////////////////////////////////////////////////////
  2776. //  Yes, i know, goto's might be bad. Not in this case though ...
  2777. ///////////////////////////////////////////////////////////////////////////////
  2778.       BuildAddrList:
  2780. char **ppszAddresses = StrTokenize(StrDynGet(&AddrDS), ADDRESS_TOKENIZER);
  2782. StrDynFree(&AddrDS);
  2784. return (ppszAddresses);
  2786. }
  2788. static int USmlExtractToAddress(HSLIST & hTagList, char *pszToAddr, int iMaxAddress)
  2789. {
  2790. ///////////////////////////////////////////////////////////////////////////////
  2791. //  Try to extract the "To:" tag from the mail headers
  2792. ///////////////////////////////////////////////////////////////////////////////
  2793. TAG_POSITION TagPosition = TAG_POSITION_INIT;
  2794. MessageTagData *pMTD = USmlFindTag(hTagList, "To", TagPosition);
  2796. if ((pMTD == NULL) ||
  2797.     (USmlParseAddress(pMTD->pszTagData, NULL, 0, pszToAddr, iMaxAddress) < 0)) {
  2798. ErrSetErrorCode(ERR_RCPTTO_UNKNOWN);
  2799. return (ERR_RCPTTO_UNKNOWN);
  2800. }
  2802. return (0);
  2804. }
  2806. static char **USmlBuildTargetRcptList(char const *pszRcptTo, HSLIST & hTagList,
  2807.       const char *pszFetchHdrTags)
  2808. {
  2810. char **ppszRcptList = NULL;
  2811. char **ppszAddrTags = NULL;
  2813. if ((pszFetchHdrTags != NULL) &&
  2814.     ((ppszAddrTags = StrTokenize(pszFetchHdrTags, ",")) == NULL))
  2815. return (NULL);
  2817. if (pszRcptTo == NULL) {
  2818. if (ppszAddrTags == NULL) {
  2819. ErrSetErrorCode(ERR_NO_HDR_FETCH_TAGS);
  2820. return (NULL);
  2821. }
  2822. ///////////////////////////////////////////////////////////////////////////////
  2823. //  If the recipient is NULL try to extract addresses from the message using
  2824. //  the supplied tag string
  2825. ///////////////////////////////////////////////////////////////////////////////
  2826. if ((ppszRcptList = USmlGetAddressList(hTagList, NULL, ppszAddrTags)) == NULL) {
  2827. StrFreeStrings(ppszAddrTags);
  2828. return (NULL);
  2829. }
  2831. } else if (*pszRcptTo == '?') {
  2832. if (ppszAddrTags == NULL) {
  2833. ErrSetErrorCode(ERR_NO_HDR_FETCH_TAGS);
  2834. return (NULL);
  2835. }
  2836. ///////////////////////////////////////////////////////////////////////////////
  2837. //  Extract matching domains
  2838. ///////////////////////////////////////////////////////////////////////////////
  2839. char **ppszDomains = StrTokenize(pszRcptTo, ",");
  2841. if (ppszDomains == NULL) {
  2842. StrFreeStrings(ppszAddrTags);
  2843. return (NULL);
  2844. }
  2845. ///////////////////////////////////////////////////////////////////////////////
  2846. //  We need to masquerade incoming domain. In this case "pszRcptTo" is made by
  2847. //  "?" + masquerade-domain
  2848. ///////////////////////////////////////////////////////////////////////////////
  2849. if ((ppszRcptList =
  2850.      USmlGetAddressList(hTagList, &ppszDomains[1], ppszAddrTags)) == NULL) {
  2851. StrFreeStrings(ppszDomains);
  2852. StrFreeStrings(ppszAddrTags);
  2853. return (NULL);
  2854. }
  2856. int iAddrCount = StrStringsCount(ppszRcptList);
  2858. for (int ii = 0; ii < iAddrCount; ii++) {
  2859. char szToUser[MAX_ADDR_NAME] = "";
  2860. char szRecipient[MAX_ADDR_NAME] = "";
  2862. if (USmtpSplitEmailAddr(ppszRcptList[ii], szToUser, NULL) == 0) {
  2863. SysSNPrintf(szRecipient, sizeof(szRecipient) - 1, "%s@%s",
  2864.     szToUser, ppszDomains[0] + 1);
  2866. SysFree(ppszRcptList[ii]);
  2868. ppszRcptList[ii] = SysStrDup(szRecipient);
  2869. }
  2870. }
  2872. StrFreeStrings(ppszDomains);
  2873. } else if (*pszRcptTo == '&') {
  2874. if (ppszAddrTags == NULL) {
  2875. ErrSetErrorCode(ERR_NO_HDR_FETCH_TAGS);
  2876. return (NULL);
  2877. }
  2878. ///////////////////////////////////////////////////////////////////////////////
  2879. //  Extract matching domains
  2880. ///////////////////////////////////////////////////////////////////////////////
  2881. char **ppszDomains = StrTokenize(pszRcptTo, ",");
  2883. if (ppszDomains == NULL) {
  2884. StrFreeStrings(ppszAddrTags);
  2885. return (NULL);
  2886. }
  2887. ///////////////////////////////////////////////////////////////////////////////
  2888. //  We need to masquerade incoming domain. In this case "pszRcptTo" is made by
  2889. //  "&" + add-domain
  2890. ///////////////////////////////////////////////////////////////////////////////
  2891. if ((ppszRcptList =
  2892.      USmlGetAddressList(hTagList, &ppszDomains[1], ppszAddrTags)) == NULL) {
  2893. StrFreeStrings(ppszDomains);
  2894. StrFreeStrings(ppszAddrTags);
  2895. return (NULL);
  2896. }
  2898. int iAddrCount = StrStringsCount(ppszRcptList);
  2900. for (int ii = 0; ii < iAddrCount; ii++) {
  2901. char szRecipient[MAX_ADDR_NAME] = "";
  2903. SysSNPrintf(szRecipient, sizeof(szRecipient) - 1, "%s%s",
  2904.     ppszRcptList[ii], ppszDomains[0] + 1);
  2906. SysFree(ppszRcptList[ii]);
  2908. ppszRcptList[ii] = SysStrDup(szRecipient);
  2909. }
  2911. StrFreeStrings(ppszDomains);
  2912. } else
  2913. ppszRcptList = StrBuildList(pszRcptTo, NULL);
  2915. if (ppszAddrTags != NULL)
  2916. StrFreeStrings(ppszAddrTags);
  2918. return (ppszRcptList);
  2920. }
  2922. int USmlDeliverFetchedMsg(char const *pszSyncAddr, const char *pszFetchHdrTags,
  2923.   char const *pszMailFile)
  2924. {
  2926. FILE *pMailFile = fopen(pszMailFile, "rb");
  2928. if (pMailFile == NULL) {
  2929. ErrSetErrorCode(ERR_FILE_OPEN);
  2930. return (ERR_FILE_OPEN);
  2931. }
  2932. ///////////////////////////////////////////////////////////////////////////////
  2933. //  Load message tags
  2934. ///////////////////////////////////////////////////////////////////////////////
  2935. HSLIST hTagList;
  2937. ListInit(hTagList);
  2939. USmlLoadTags(pMailFile, hTagList);
  2941. ///////////////////////////////////////////////////////////////////////////////
  2942. //  Extract "MAIL FROM: <>" address
  2943. ///////////////////////////////////////////////////////////////////////////////
  2944. char szFromAddr[MAX_SMTP_ADDRESS] = "";
  2946. USmlExtractFromAddress(hTagList, szFromAddr, sizeof(szFromAddr) - 1);
  2948. ///////////////////////////////////////////////////////////////////////////////
  2949. //  Extract recipient list
  2950. ///////////////////////////////////////////////////////////////////////////////
  2951. char **ppszRcptList = USmlBuildTargetRcptList(pszSyncAddr, hTagList, pszFetchHdrTags);
  2953. if (ppszRcptList == NULL) {
  2954. ErrorPush();
  2955. USmlFreeTagsList(hTagList);
  2956. fclose(pMailFile);
  2957. return (ErrorPop());
  2958. }
  2960. USmlFreeTagsList(hTagList);
  2962. ///////////////////////////////////////////////////////////////////////////////
  2963. //  Loop through extracted recipients and deliver
  2964. ///////////////////////////////////////////////////////////////////////////////
  2965. int iDeliverCount = 0;
  2966. int iAddrCount = StrStringsCount(ppszRcptList);
  2968. for (int ii = 0; ii < iAddrCount; ii++) {
  2969. ///////////////////////////////////////////////////////////////////////////////
  2970. //  Check address validity and skip invalid ( or not handled ) ones
  2971. ///////////////////////////////////////////////////////////////////////////////
  2972. char szDestDomain[MAX_HOST_NAME] = "";
  2974. if ((USmtpSplitEmailAddr(ppszRcptList[ii], NULL, szDestDomain) < 0) ||
  2975.     ((MDomIsHandledDomain(szDestDomain) < 0) &&
  2976.      (USmlCustomizedDomain(szDestDomain) < 0)))
  2977. continue;
  2979. ///////////////////////////////////////////////////////////////////////////////
  2980. //  Get message handle
  2981. ///////////////////////////////////////////////////////////////////////////////
  2982. QMSG_HANDLE hMessage = QueCreateMessage(hSpoolQueue);
  2984. if (hMessage == INVALID_QMSG_HANDLE) {
  2985. ErrorPush();
  2986. StrFreeStrings(ppszRcptList);
  2987. fclose(pMailFile);
  2988. return (ErrorPop());
  2989. }
  2991. char szQueueFilePath[SYS_MAX_PATH] = "";
  2993. QueGetFilePath(hSpoolQueue, hMessage, szQueueFilePath);
  2995. if (USmlCreateSpoolFile(pMailFile, NULL, szFromAddr,
  2996. ppszRcptList[ii], szQueueFilePath) < 0) {
  2997. ErrorPush();
  2998. QueCleanupMessage(hSpoolQueue, hMessage);
  2999. QueCloseMessage(hSpoolQueue, hMessage);
  3000. StrFreeStrings(ppszRcptList);
  3001. fclose(pMailFile);
  3002. return (ErrorPop());
  3003. }
  3004. ///////////////////////////////////////////////////////////////////////////////
  3005. //  Transfer file to the spool
  3006. ///////////////////////////////////////////////////////////////////////////////
  3007. if (QueCommitMessage(hSpoolQueue, hMessage) < 0) {
  3008. ErrorPush();
  3009. QueCleanupMessage(hSpoolQueue, hMessage);
  3010. QueCloseMessage(hSpoolQueue, hMessage);
  3011. StrFreeStrings(ppszRcptList);
  3012. fclose(pMailFile);
  3013. return (ErrorPop());
  3014. }
  3016. ++iDeliverCount;
  3017. }
  3019. StrFreeStrings(ppszRcptList);
  3021. fclose(pMailFile);
  3023. ///////////////////////////////////////////////////////////////////////////////
  3024. //  Check if the message has been delivered at least one time
  3025. ///////////////////////////////////////////////////////////////////////////////
  3026. if (iDeliverCount == 0) {
  3027. ErrSetErrorCode(ERR_FETCHMSG_UNDELIVERED);
  3028. return (ERR_FETCHMSG_UNDELIVERED);
  3029. }
  3031. return (0);
  3033. }
  3035. static int USmlCreateSpoolFile(FILE * pMailFile, char const *const *ppszInfo,
  3036.        char const *pszMailFrom, char const *pszRcptTo,
  3037.        char const *pszSpoolFile)
  3038. {
  3040. FILE *pSpoolFile = fopen(pszSpoolFile, "wb");
  3042. if (pSpoolFile == NULL) {
  3043. ErrSetErrorCode(ERR_FILE_CREATE, pszSpoolFile);
  3044. return (ERR_FILE_CREATE);
  3045. }
  3046. ///////////////////////////////////////////////////////////////////////////////
  3047. //  Write info line
  3048. ///////////////////////////////////////////////////////////////////////////////
  3049. if (ppszInfo != NULL)
  3050. USmtpWriteInfoLine(pSpoolFile, ppszInfo[smsgiClientAddr],
  3051.    ppszInfo[smsgiServerAddr], ppszInfo[smsgiTime]);
  3052. else {
  3053. char szTime[256] = "";
  3055. MscGetTimeStr(szTime, sizeof(szTime) - 1);
  3057. USmtpWriteInfoLine(pSpoolFile, LOCAL_ADDRESS_SQB ":0",
  3058.    LOCAL_ADDRESS_SQB ":0", szTime);
  3059. }
  3061. ///////////////////////////////////////////////////////////////////////////////
  3062. //  Write SMTP domain
  3063. ///////////////////////////////////////////////////////////////////////////////
  3064. char szSmtpDomain[MAX_HOST_NAME] = "";
  3066. if (USmtpSplitEmailAddr(pszRcptTo, NULL, szSmtpDomain) < 0) {
  3067. ErrorPush();
  3068. fclose(pSpoolFile);
  3069. SysRemove(pszSpoolFile);
  3070. return (ErrorPop());
  3071. }
  3073. fprintf(pSpoolFile, "%srn", szSmtpDomain);
  3075. ///////////////////////////////////////////////////////////////////////////////
  3076. //  Write message ID
  3077. ///////////////////////////////////////////////////////////////////////////////
  3078. SYS_UINT64 ullMessageID = 0;
  3080. if (SvrGetMessageID(&ullMessageID) < 0) {
  3081. ErrorPush();
  3082. fclose(pSpoolFile);
  3083. SysRemove(pszSpoolFile);
  3084. return (ErrorPop());
  3085. }
  3087. fprintf(pSpoolFile, "P" SYS_LLX_FMT "rn", ullMessageID);
  3089. ///////////////////////////////////////////////////////////////////////////////
  3090. //  Write "MAIL FROM:"
  3091. ///////////////////////////////////////////////////////////////////////////////
  3092. fprintf(pSpoolFile, "MAIL FROM: <%s>rn", pszMailFrom);
  3094. ///////////////////////////////////////////////////////////////////////////////
  3095. //  Write "RCPT TO:"
  3096. ///////////////////////////////////////////////////////////////////////////////
  3097. fprintf(pSpoolFile, "RCPT TO: <%s>rn", pszRcptTo);
  3099. ///////////////////////////////////////////////////////////////////////////////
  3100. //  Write SPOOL_FILE_DATA_START
  3101. ///////////////////////////////////////////////////////////////////////////////
  3102. fprintf(pSpoolFile, "%srn", SPOOL_FILE_DATA_START);
  3104. ///////////////////////////////////////////////////////////////////////////////
  3105. //  Write message body
  3106. ///////////////////////////////////////////////////////////////////////////////
  3107. if (MscCopyFile(pSpoolFile, pMailFile, 0, (unsigned long) -1) < 0) {
  3108. ErrorPush();
  3109. fclose(pSpoolFile);
  3110. SysRemove(pszSpoolFile);
  3111. return (ErrorPop());
  3112. }
  3114. fclose(pSpoolFile);
  3116. return (0);
  3118. }
  3120. int USmlMailLoopCheck(SPLF_HANDLE hFSpool, SVRCFG_HANDLE hSvrConfig)
  3121. {
  3123. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  3125. ///////////////////////////////////////////////////////////////////////////////
  3126. //  Count MTA ops
  3127. ///////////////////////////////////////////////////////////////////////////////
  3128. int iLoopsCount = 0;
  3129. int iMaxMTAOps = SvrGetConfigInt("MaxMTAOps", MAX_MTA_OPS, hSvrConfig);
  3130. MessageTagData *pMTD = (MessageTagData *) ListFirst(pSFD->hTagList);
  3132. for (; pMTD != INVALID_SLIST_PTR; pMTD = (MessageTagData *)
  3133.      ListNext(pSFD->hTagList, (PLISTLINK) pMTD))
  3134. if ((stricmp(pMTD->pszTagName, "Received") == 0) ||
  3135.     (stricmp(pMTD->pszTagName, "X-Deliver-To") == 0))
  3136. ++iLoopsCount;
  3138. ///////////////////////////////////////////////////////////////////////////////
  3139. //  Check MTA count
  3140. ///////////////////////////////////////////////////////////////////////////////
  3141. if (iLoopsCount > iMaxMTAOps) {
  3142. ErrSetErrorCode(ERR_MAIL_LOOP_DETECTED);
  3143. return (ERR_MAIL_LOOP_DETECTED);
  3144. }
  3146. return (0);
  3148. }
  3150. int USmlMessageAuth(SPLF_HANDLE hFSpool, char *pszAuthName, int iSize)
  3151. {
  3153. SpoolFileData *pSFD = (SpoolFileData *) hFSpool;
  3155. ///////////////////////////////////////////////////////////////////////////////
  3156. //  Looks for the "X-AuthUser" tag, that has to happen *before* the first
  3157. //  "Received" tag (to prevent forging)
  3158. ///////////////////////////////////////////////////////////////////////////////
  3159. MessageTagData *pMTD = (MessageTagData *) ListFirst(pSFD->hTagList);
  3161. for (; pMTD != INVALID_SLIST_PTR; pMTD = (MessageTagData *)
  3162.      ListNext(pSFD->hTagList, (PLISTLINK) pMTD)) {
  3163. if (stricmp(pMTD->pszTagName, "Received") == 0)
  3164. break;
  3165. if (stricmp(pMTD->pszTagName, "X-AuthUser") == 0) {
  3166. if (pszAuthName != NULL) {
  3167. StrNCpy(pszAuthName, pMTD->pszTagData, iSize);
  3168. StrTrim(pszAuthName, " trn");
  3169. }
  3170. return (0);
  3171. }
  3172. }
  3174. ErrSetErrorCode(ERR_NO_MESSAGE_AUTH);
  3175. return (ERR_NO_MESSAGE_AUTH);
  3177. }