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

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

Email服务器

开发平台：

Visual C++

SMTPSvr.cpp：源码内容
  1. /*
  2.  *  XMail by Davide Libenzi ( Intranet and Internet mail server )
  3.  *  Copyright (C) 1999,..,2004  Davide Libenzi
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  *  Davide Libenzi <davidel@xmailserver.org>
  20.  *
  21.  */
  23. #include "SysInclude.h"
  24. #include "SysDep.h"
  25. #include "SvrDefines.h"
  26. #include "SList.h"
  27. #include "ShBlocks.h"
  28. #include "BuffSock.h"
  29. #include "ResLocks.h"
  30. #include "StrUtils.h"
  31. #include "UsrUtils.h"
  32. #include "SvrUtils.h"
  33. #include "MessQueue.h"
  34. #include "SMAILUtils.h"
  35. #include "QueueUtils.h"
  36. #include "MiscUtils.h"
  37. #include "Base64Enc.h"
  38. #include "MD5.h"
  39. #include "UsrMailList.h"
  40. #include "SMTPSvr.h"
  41. #include "SMTPUtils.h"
  42. #include "MailDomains.h"
  43. #include "POP3Utils.h"
  44. #include "Filter.h"
  45. #include "MailConfig.h"
  46. #include "AppDefines.h"
  47. #include "MailSvr.h"
  49. #define SMTP_MAX_LINE_SIZE      2048
  50. #define SMTPSRV_ACCEPT_TIMEOUT  4
  51. #define STD_SMTP_TIMEOUT        30
  52. #define SMTP_LISTEN_SIZE        64
  53. #define SMTP_WAIT_SLEEP         2
  54. #define MAX_CLIENTS_WAIT        300
  55. #define SMTP_IPMAP_FILE         "smtp.ipmap.tab"
  56. #define SMTP_IPPROP_FILE        "smtp.ipprop.tab"
  57. #define SMTP_LOG_FILE           "smtp"
  58. #define SMTP_SERVER_NAME        "[" APP_NAME_VERSION_STR " ESMTP Server]"
  59. #define SMTP_PRE_DATA_FILTER    "pre-data"
  60. #define SMTP_POST_DATA_FILTER   "post-data"
  61. #define SMTP_FILTER_REJECT_CODE 3
  62. #define PLAIN_AUTH_PARAM_SIZE   1024
  63. #define LOGIN_AUTH_USERNAME     "Username:"
  64. #define LOGIN_AUTH_PASSWORD     "Password:"
  65. #define SVR_SMTP_AUTH_FILE      "smtpauth.tab"
  66. #define SVR_SMTPAUTH_LINE_MAX   512
  67. #define SVR_SMTP_EXTAUTH_FILE   "smtpextauth.tab"
  68. #define SVR_SMTP_EXTAUTH_LINE_MAX   1024
  69. #define SVR_SMTP_EXTAUTH_TIMEOUT    60
  70. #define SVR_SMTP_EXTAUTH_PRIORITY   SYS_PRIORITY_NORMAL
  71. #define SVR_SMTP_EXTAUTH_SUCCESS    0
  73. #define SMTPF_RELAY_ENABLED     (1 << 0)
  74. #define SMTPF_MAIL_LOCKED       (1 << 1)
  75. #define SMTPF_MAIL_UNLOCKED     (1 << 2)
  76. #define SMTPF_AUTHENTICATED     (1 << 3)
  77. #define SMTPF_VRFY_ENABLED      (1 << 4)
  78. #define SMTPF_MAPPED_IP         (1 << 5)
  79. #define SMTPF_NORDNS_IP         (1 << 6)
  80. #define SMTPF_ETRN_ENABLED      (1 << 7)
  81. #define SMTPF_NOEMIT_AUTH       (1 << 8)
  82. #define SMTPF_WHITE_LISTED      (1 << 9)
  83. #define SMTPF_BLOCKED_IP        (1 << 10)
  85. #define SMTPF_STATIC_MASK       (SMTPF_MAPPED_IP | SMTPF_NORDNS_IP | SMTPF_WHITE_LISTED | SMTPF_BLOCKED_IP)
  86. #define SMTPF_AUTH_MASK         (SMTPF_RELAY_ENABLED | SMTPF_MAIL_UNLOCKED | SMTPF_AUTHENTICATED | 
  87.                                         SMTPF_VRFY_ENABLED | SMTPF_ETRN_ENABLED)
  88. #define SMTPF_RESET_MASK        (SMTPF_AUTH_MASK | SMTPF_STATIC_MASK | SMTPF_NOEMIT_AUTH)
  90. #define SMTP_FILTER_FL_BREAK    (1 << 4)
  91. #define SMTP_FILTER_FL_MASK     SMTP_FILTER_FL_BREAK
  93. enum SMTPStates {
  94. stateInit = 0,
  95. stateHelo,
  96. stateAuthenticated,
  97. stateMail,
  98. stateRcpt,
  100. stateExit
  101. };
  103. struct SMTPSession {
  104. int iSMTPState;
  105. SHB_HANDLE hShbSMTP;
  106. SMTPConfig *pSMTPCfg;
  107. SVRCFG_HANDLE hSvrConfig;
  108. SYS_INET_ADDR PeerInfo;
  109. SYS_INET_ADDR SockInfo;
  110. int iCmdDelay;
  111. unsigned long ulMaxMsgSize;
  112. char szSvrFQDN[MAX_ADDR_NAME];
  113. char szSvrDomain[MAX_ADDR_NAME];
  114. char szClientFQDN[MAX_ADDR_NAME];
  115. char szClientDomain[MAX_ADDR_NAME];
  116. char szDestDomain[MAX_ADDR_NAME];
  117. char szLogonUser[128];
  118. char szMsgFile[SYS_MAX_PATH];
  119. FILE *pMsgFile;
  120. char *pszFrom;
  121. char *pszRcpt;
  122. char *pszSendRcpt;
  123. int iRcptCount;
  124. int iErrorsCount;
  125. int iErrorsMax;
  126. SYS_UINT64 ullMessageID;
  127. char szMessageID[128];
  128. char szTimeStamp[256];
  129. unsigned long ulSetupFlags;
  130. unsigned long ulFlags;
  131. char *pszCustMsg;
  132. char szRejMapName[256];
  133. };
  135. enum SmtpAuthFields {
  136. smtpaUsername = 0,
  137. smtpaPassword,
  138. smtpaPerms,
  140. smtpaMax
  141. };
  143. static SMTPConfig *SMTPGetConfigCopy(SHB_HANDLE hShbSMTP);
  144. static int SMTPLogEnabled(SHB_HANDLE hShbSMTP, SMTPConfig * pSMTPCfg = NULL);
  145. static int SMTPCheckPeerIP(SYS_SOCKET SockFD);
  146. static int SMTPThreadCountAdd(long lCount, SHB_HANDLE hShbSMTP, SMTPConfig * pSMTPCfg = NULL);
  147. static unsigned int SMTPClientThread(void *pThreadData);
  148. static int SMTPCheckSysResources(SVRCFG_HANDLE hSvrConfig);
  149. static int SMTPCheckMapsList(SYS_INET_ADDR const &PeerInfo, char const *pszMapList,
  150.      char *pszMapName, int iMaxMapName, int &iMapCode);
  151. static int SMTPApplyIPProps(SMTPSession & SMTPS);
  152. static int SMTPDoIPBasedInit(SMTPSession & SMTPS, char *&pszSMTPError);
  153. static int SMTPInitSession(SHB_HANDLE hShbSMTP, BSOCK_HANDLE hBSock,
  154.    SMTPSession & SMTPS, char *&pszSMTPError);
  155. static int SMTPLoadConfig(SMTPSession & SMTPS, char const *pszSvrConfig);
  156. static int SMTPApplyPerms(SMTPSession & SMTPS, char const *pszPerms);
  157. static int SMTPApplyUserConfig(SMTPSession & SMTPS, UserInfo * pUI);
  158. static int SMTPLogSession(SMTPSession & SMTPS, char const *pszSender,
  159.   char const *pszRecipient, char const *pszStatus,
  160.   unsigned long ulMsgSize);
  161. static int SMTPSendError(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszFormat, ...);
  162. static int SMTPHandleSession(SHB_HANDLE hShbSMTP, BSOCK_HANDLE hBSock);
  163. static void SMTPClearSession(SMTPSession & SMTPS);
  164. static void SMTPResetSession(SMTPSession & SMTPS);
  165. static int SMTPHandleCommand(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  166. static int SMTPCheckReturnPath(const char *pszCommand, char **ppszRetDomains,
  167.        SMTPSession & SMTPS, char *&pszSMTPError);
  168. static int SMTPTryPopAuthIpCheck(SMTPSession & SMTPS, char const *pszUser, char const *pszDomain);
  169. static int SMTPAddMessageInfo(SMTPSession & SMTPS);
  170. static int SMTPCheckMailParams(const char *pszCommand, char **ppszRetDomains,
  171.        SMTPSession & SMTPS, char *&pszSMTPError);
  172. static int SMTPHandleCmd_MAIL(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  173. static int SMTPCheckRelayCapability(SMTPSession & SMTPS, char const *pszDestDomain);
  174. static int SMTPCheckForwardPath(char **ppszFwdDomains, SMTPSession & SMTPS,
  175. char *&pszRealRcpt, char *&pszSMTPError);
  176. static int SMTPHandleCmd_RCPT(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  177. static int SMTPGetFilterFile(const char *pszFiltID, char *pszFileName, int iMaxName);
  178. static int SMTPFilterMacroSubstitutes(char **ppszCmdTokens, SMTPSession & SMTPS);
  179. static char *SMTPGetFilterRejMessage(char const *pszMsgFilePath);
  180. static int SMTPLogFilter(SMTPSession & SMTPS, char const * const *ppszExec, int iExecResult,
  181.  int iExitCode, char const *pszType, char const *pszInfo);
  182. static int SMTPPreFilterExec(SMTPSession & SMTPS, FilterTokens *pToks, char **ppszPEError);
  183. static int SMTPRunFilters(SMTPSession & SMTPS, char const *pszFilterPath, char const *pszType,
  184.   char *&pszError);
  185. static int SMTPFilterMessage(SMTPSession & SMTPS, const char *pszFiltID, char *&pszError);
  186. static int SMTPHandleCmd_DATA(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  187. static int SMTPAddReceived(int iType, char const *pszAuth, char const *const *ppszMsgInfo,
  188.    char const *pszMailFrom, char const *pszRcptTo,
  189.    char const *pszMessageID, FILE * pMailFile);
  190. static char *SMTPTrimRcptLine(char *pszRcptLn);
  191. static int SMTPSubmitPackedFile(SMTPSession & SMTPS, const char *pszPkgFile);
  192. static int SMTPHandleCmd_HELO(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  193. static int SMTPHandleCmd_EHLO(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  194. static int SMTPListExtAuths(FILE * pRespFile, SMTPSession & SMTPS);
  195. static int SMTPExternalAuthSubstitute(char **ppszAuthTokens, char const *pszChallenge,
  196.       char const *pszDigest, char const *pszSecretsFile);
  197. static int SMTPCreateSecretsFile(char const *pszSecretsFile);
  198. static int SMTPExternalAuthenticate(BSOCK_HANDLE hBSock, SMTPSession & SMTPS,
  199.     char **ppszAuthTokens);
  200. static int SMTPDoAuthExternal(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszAuthType);
  201. static int SMTPDoAuthPlain(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszAuthParam);
  202. static int SMTPDoAuthLogin(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszAuthParam);
  203. static char *SMTPGetAuthFilePath(char *pszFilePath, int iMaxPath);
  204. static char *SMTPGetExtAuthFilePath(char *pszFilePath, int iMaxPath);
  205. static int SMTPTryApplyLocalAuth(SMTPSession & SMTPS, char const *pszUsername,
  206.  char const *pszPassword);
  207. static int SMTPGetUserSmtpPerms(UserInfo * pUI, SVRCFG_HANDLE hSvrConfig, char *pszPerms,
  208. int iMaxPerms);
  209. static int SMTPTryApplyLocalCMD5Auth(SMTPSession & SMTPS, char const *pszChallenge,
  210.      char const *pszUsername, char const *pszDigest);
  211. static int SMTPTryApplyUsrPwdAuth(SMTPSession & SMTPS, char const *pszUsername,
  212.   char const *pszPassword);
  213. static int SMTPTryApplyCMD5Auth(SMTPSession & SMTPS, char const *pszChallenge,
  214. char const *pszUsername, char const *pszDigest);
  215. static int SMTPDoAuthCramMD5(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszAuthParam);
  216. static int SMTPHandleCmd_AUTH(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  217. static int SMTPSendMultilineResponse(BSOCK_HANDLE hBSock, int iTimeout, FILE * pRespFile);
  218. static int SMTPHandleCmd_RSET(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  219. static int SMTPHandleCmd_NOOP(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  220. static int SMTPHandleCmd_HELP(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  221. static int SMTPHandleCmd_QUIT(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  222. static int SMTPHandleCmd_VRFY(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  223. static int SMTPHandleCmd_ETRN(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS);
  225. static SMTPConfig *SMTPGetConfigCopy(SHB_HANDLE hShbSMTP)
  226. {
  228. SMTPConfig *pSMTPCfg = (SMTPConfig *) ShbLock(hShbSMTP);
  230. if (pSMTPCfg == NULL)
  231. return (NULL);
  233. SMTPConfig *pSMTPCfgCopy = (SMTPConfig *) SysAlloc(sizeof(SMTPConfig));
  235. if (pSMTPCfgCopy != NULL)
  236. memcpy(pSMTPCfgCopy, pSMTPCfg, sizeof(SMTPConfig));
  238. ShbUnlock(hShbSMTP);
  240. return (pSMTPCfgCopy);
  242. }
  244. static int SMTPLogEnabled(SHB_HANDLE hShbSMTP, SMTPConfig * pSMTPCfg)
  245. {
  247. int iDoUnlock = 0;
  249. if (pSMTPCfg == NULL) {
  250. if ((pSMTPCfg = (SMTPConfig *) ShbLock(hShbSMTP)) == NULL)
  251. return (ErrGetErrorCode());
  253. ++iDoUnlock;
  254. }
  256. unsigned long ulFlags = pSMTPCfg->ulFlags;
  258. if (iDoUnlock)
  259. ShbUnlock(hShbSMTP);
  261. return ((ulFlags & SMTPF_LOG_ENABLED) ? 1 : 0);
  263. }
  265. static int SMTPCheckPeerIP(SYS_SOCKET SockFD)
  266. {
  268. char szIPMapFile[SYS_MAX_PATH] = "";
  270. CfgGetRootPath(szIPMapFile, sizeof(szIPMapFile));
  271. StrNCat(szIPMapFile, SMTP_IPMAP_FILE, sizeof(szIPMapFile));
  273. if (SysExistFile(szIPMapFile)) {
  274. SYS_INET_ADDR PeerInfo;
  276. if (SysGetPeerInfo(SockFD, PeerInfo) < 0)
  277. return (ErrGetErrorCode());
  279. if (MscCheckAllowedIP(szIPMapFile, PeerInfo, true) < 0)
  280. return (ErrGetErrorCode());
  281. }
  283. return (0);
  285. }
  287. static int SMTPThreadCountAdd(long lCount, SHB_HANDLE hShbSMTP, SMTPConfig * pSMTPCfg)
  288. {
  290. int iDoUnlock = 0;
  292. if (pSMTPCfg == NULL) {
  293. if ((pSMTPCfg = (SMTPConfig *) ShbLock(hShbSMTP)) == NULL)
  294. return (ErrGetErrorCode());
  296. ++iDoUnlock;
  297. }
  299. if ((pSMTPCfg->lThreadCount + lCount) > pSMTPCfg->lMaxThreads) {
  300. if (iDoUnlock)
  301. ShbUnlock(hShbSMTP);
  303. ErrSetErrorCode(ERR_SERVER_BUSY);
  304. return (ERR_SERVER_BUSY);
  305. }
  307. pSMTPCfg->lThreadCount += lCount;
  309. if (iDoUnlock)
  310. ShbUnlock(hShbSMTP);
  312. return (0);
  314. }
  316. static unsigned int SMTPClientThread(void *pThreadData)
  317. {
  319. SYS_SOCKET SockFD = (SYS_SOCKET) (unsigned long) pThreadData;
  321. ///////////////////////////////////////////////////////////////////////////////
  322. //  Link socket to the bufferer
  323. ///////////////////////////////////////////////////////////////////////////////
  324. BSOCK_HANDLE hBSock = BSckAttach(SockFD);
  326. if (hBSock == INVALID_BSOCK_HANDLE) {
  327. ErrorPush();
  328. SysCloseSocket(SockFD);
  329. return (ErrorPop());
  330. }
  331. ///////////////////////////////////////////////////////////////////////////////
  332. //  Check IP permission
  333. ///////////////////////////////////////////////////////////////////////////////
  334. if (SMTPCheckPeerIP(SockFD) < 0) {
  335. ErrorPush();
  337. BSckVSendString(hBSock, STD_SMTP_TIMEOUT, "421 %s - %s",
  338. SMTP_SERVER_NAME, ErrGetErrorString(ErrorFetch()));
  340. BSckDetach(hBSock, 1);
  341. return (ErrorPop());
  342. }
  343. ///////////////////////////////////////////////////////////////////////////////
  344. //  Increase threads count
  345. ///////////////////////////////////////////////////////////////////////////////
  346. if (SMTPThreadCountAdd(+1, hShbSMTP) < 0) {
  347. ErrorPush();
  349. BSckVSendString(hBSock, STD_SMTP_TIMEOUT, "421 %s - %s",
  350. SMTP_SERVER_NAME, ErrGetErrorString(ErrorFetch()));
  352. BSckDetach(hBSock, 1);
  353. return (ErrorPop());
  354. }
  356. ///////////////////////////////////////////////////////////////////////////////
  357. //  Handle client session
  358. ///////////////////////////////////////////////////////////////////////////////
  359. SMTPHandleSession(hShbSMTP, hBSock);
  361. ///////////////////////////////////////////////////////////////////////////////
  362. //  Decrease threads count
  363. ///////////////////////////////////////////////////////////////////////////////
  364. SMTPThreadCountAdd(-1, hShbSMTP);
  366. ///////////////////////////////////////////////////////////////////////////////
  367. //  Unlink socket from the bufferer and close it
  368. ///////////////////////////////////////////////////////////////////////////////
  369. BSckDetach(hBSock, 1);
  371. return (0);
  373. }
  375. unsigned int SMTPThreadProc(void *pThreadData)
  376. {
  378. SMTPConfig *pSMTPCfg = (SMTPConfig *) ShbLock(hShbSMTP);
  380. if (pSMTPCfg == NULL) {
  381. ErrorPush();
  382. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  383. return (ErrorPop());
  384. }
  386. int iNumSockFDs = 0;
  387. SYS_SOCKET SockFDs[MAX_SMTP_ACCEPT_ADDRESSES];
  389. if (MscCreateServerSockets(pSMTPCfg->iNumAddr, pSMTPCfg->SvrAddr, pSMTPCfg->iPort,
  390.    SMTP_LISTEN_SIZE, SockFDs, iNumSockFDs) < 0) {
  391. ErrorPush();
  392. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  393. ShbUnlock(hShbSMTP);
  394. return (ErrorPop());
  395. }
  397. ShbUnlock(hShbSMTP);
  399. SysLogMessage(LOG_LEV_MESSAGE, "%s startedn", SMTP_SERVER_NAME);
  401. for (;;) {
  402. int iNumConnSockFD = 0;
  403. SYS_SOCKET ConnSockFD[MAX_SMTP_ACCEPT_ADDRESSES];
  405. if (MscAcceptServerConnection(SockFDs, iNumSockFDs, ConnSockFD,
  406.       iNumConnSockFD, SMTPSRV_ACCEPT_TIMEOUT) < 0) {
  407. unsigned long ulFlags = SMTPF_STOP_SERVER;
  409. pSMTPCfg = (SMTPConfig *) ShbLock(hShbSMTP);
  411. if (pSMTPCfg != NULL)
  412. ulFlags = pSMTPCfg->ulFlags;
  414. ShbUnlock(hShbSMTP);
  416. if (ulFlags & SMTPF_STOP_SERVER)
  417. break;
  418. else
  419. continue;
  420. }
  422. for (int ss = 0; ss < iNumConnSockFD; ss++) {
  423. SYS_THREAD hClientThread =
  424.     SysCreateServiceThread(SMTPClientThread, ConnSockFD[ss]);
  426. if (hClientThread != SYS_INVALID_THREAD)
  427. SysCloseThread(hClientThread, 0);
  428. else
  429. SysCloseSocket(ConnSockFD[ss]);
  431. }
  432. }
  434. for (int ss = 0; ss < iNumSockFDs; ss++)
  435. SysCloseSocket(SockFDs[ss]);
  437. ///////////////////////////////////////////////////////////////////////////////
  438. //  Wait for client completion
  439. ///////////////////////////////////////////////////////////////////////////////
  440. for (int iTotalWait = 0; (iTotalWait < MAX_CLIENTS_WAIT); iTotalWait += SMTP_WAIT_SLEEP) {
  441. pSMTPCfg = (SMTPConfig *) ShbLock(hShbSMTP);
  443. if (pSMTPCfg == NULL)
  444. break;
  446. long lThreadCount = pSMTPCfg->lThreadCount;
  448. ShbUnlock(hShbSMTP);
  450. if (lThreadCount == 0)
  451. break;
  453. SysSleep(SMTP_WAIT_SLEEP);
  454. }
  456. SysLogMessage(LOG_LEV_MESSAGE, "%s stoppedn", SMTP_SERVER_NAME);
  458. return (0);
  460. }
  462. static int SMTPCheckSysResources(SVRCFG_HANDLE hSvrConfig)
  463. {
  464. ///////////////////////////////////////////////////////////////////////////////
  465. //  Check disk space
  466. ///////////////////////////////////////////////////////////////////////////////
  467. int iMinValue = SvrGetConfigInt("SmtpMinDiskSpace", -1, hSvrConfig);
  469. if ((iMinValue > 0) && (SvrCheckDiskSpace(1024 * (unsigned long) iMinValue) < 0))
  470. return (ErrGetErrorCode());
  472. ///////////////////////////////////////////////////////////////////////////////
  473. //  Check virtual memory
  474. ///////////////////////////////////////////////////////////////////////////////
  475. if (((iMinValue = SvrGetConfigInt("SmtpMinVirtMemSpace", -1, hSvrConfig)) > 0) &&
  476.     (SvrCheckVirtMemSpace(1024 * (unsigned long) iMinValue) < 0))
  477. return (ErrGetErrorCode());
  479. return (0);
  481. }
  483. static int SMTPCheckMapsList(SYS_INET_ADDR const &PeerInfo, char const *pszMapList,
  484.      char *pszMapName, int iMaxMapName, int &iMapCode)
  485. {
  487. for (;;) {
  488. char const *pszColon = strchr(pszMapList, ':');
  490. if (pszColon == NULL)
  491. break;
  493. int iRetCode = atoi(pszColon + 1);
  494. int iMapLength = Min((int) (pszColon - pszMapList), MAX_HOST_NAME - 1);
  495. char szMapName[MAX_HOST_NAME] = "";
  497. strncpy(szMapName, pszMapList, iMapLength);
  498. szMapName[iMapLength] = '';
  500. if (USmtpDnsMapsContained(PeerInfo, szMapName)) {
  501. if (pszMapName != NULL)
  502. StrNCpy(pszMapName, szMapName, iMaxMapName);
  504. iMapCode = iRetCode;
  506. char szIP[128] = "???.???.???.???";
  507. char szMapSpec[MAX_HOST_NAME + 128] = "";
  509. SysInetNToA(PeerInfo, szIP);
  510. SysSNPrintf(szMapSpec, sizeof(szMapSpec) - 1, "%s:%s", szMapName, szIP);
  512. ErrSetErrorCode(ERR_MAPS_CONTAINED, szMapSpec);
  513. return (ERR_MAPS_CONTAINED);
  514. }
  516. if ((pszMapList = strchr(pszColon, ',')) == NULL)
  517. break;
  519. ++pszMapList;
  520. }
  522. return (0);
  524. }
  526. static int SMTPApplyIPProps(SMTPSession & SMTPS)
  527. {
  529. char szIPPropFile[SYS_MAX_PATH] = "";
  531. CfgGetRootPath(szIPPropFile, sizeof(szIPPropFile));
  532. StrNCat(szIPPropFile, SMTP_IPPROP_FILE, sizeof(szIPPropFile));
  534. int ii;
  535. char **ppszProps;
  537. if ((ppszProps = MscGetIPProperties(szIPPropFile, SMTPS.PeerInfo)) == NULL)
  538. return (0);
  540. for (ii = 1; ppszProps[ii] != NULL; ii++) {
  541. int iNameLen;
  542. char *pszName = ppszProps[ii];
  543. char *pszVal = strchr(pszName, '=');
  545. if (pszVal == NULL)
  546. continue;
  548. iNameLen = pszVal - pszName;
  549. pszVal++;
  551. if (strncmp(pszName, "WhiteList", CStringSize("WhiteList")) == 0) {
  552. if (atoi(pszVal))
  553. SMTPS.ulFlags |= SMTPF_WHITE_LISTED;
  554. }
  555. }
  557. StrFreeStrings(ppszProps);
  559. return (0);
  561. }
  563. static int SMTPDoIPBasedInit(SMTPSession & SMTPS, char *&pszSMTPError)
  564. {
  566. ///////////////////////////////////////////////////////////////////////////////
  567. //  Check if SMTP client is in "spammers.tab" file
  568. ///////////////////////////////////////////////////////////////////////////////
  569. char *pszChkInfo = NULL;
  571. if (USmtpSpammerCheck(SMTPS.PeerInfo, pszChkInfo) < 0) {
  572. int iMapCode = 1, iErrorCode = ErrGetErrorCode();
  574. if (pszChkInfo != NULL) {
  575. char szMapCode[32] = "";
  577. if (StrParamGet(pszChkInfo, "code", szMapCode, sizeof(szMapCode) - 1))
  578. iMapCode = atoi(szMapCode);
  580. SysFree(pszChkInfo);
  581. }
  583. if (iMapCode > 0) {
  584. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  585. SMTPLogSession(SMTPS, "", "", "SNDRIP=EIPSPAM", 0);
  587. pszSMTPError = SvrGetConfigVar(SMTPS.hSvrConfig, "SmtpMsgIPBanSpammers");
  589. ErrSetErrorCode(iErrorCode);
  590. return (iErrorCode);
  591. } else if (iMapCode == 0)
  592. SMTPS.ulFlags |= SMTPF_BLOCKED_IP;
  593. else
  594. SMTPS.iCmdDelay = Max(SMTPS.iCmdDelay, Abs(iMapCode));
  595. }
  597. ///////////////////////////////////////////////////////////////////////////////
  598. //  Custom maps checking
  599. ///////////////////////////////////////////////////////////////////////////////
  600. char *pszMapsList = SvrGetConfigVar(SMTPS.hSvrConfig, "CustMapsList");
  602. if (pszMapsList != NULL) {
  603. int iMapCode = 0;
  604. char *pszCfgError = NULL;
  606. if (SMTPCheckMapsList(SMTPS.PeerInfo, pszMapsList, SMTPS.szRejMapName,
  607.       sizeof(SMTPS.szRejMapName) - 1, iMapCode) < 0) {
  608. if (iMapCode == 1) {
  609. ErrorPush();
  611. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg)) {
  612. char *pszError =
  613. StrSprint("SNDRIP=EIPMAP (%s)", SMTPS.szRejMapName);
  615. SMTPLogSession(SMTPS, "", "",
  616.        (pszError !=
  617. NULL) ? pszError : "SNDRIP=EIPMAP", 0);
  619. if (pszError != NULL)
  620. SysFree(pszError);
  621. }
  623. if ((pszCfgError =
  624.      SvrGetConfigVar(SMTPS.hSvrConfig,
  625.      "SmtpMsgIPBanMaps")) != NULL) {
  626. pszSMTPError =
  627. StrSprint("%s (%s)", pszCfgError, SMTPS.szRejMapName);
  629. SysFree(pszCfgError);
  630. } else
  631. pszSMTPError =
  632. StrSprint
  633. ("550 Denied due inclusion of your IP inside (%s)",
  634.  SMTPS.szRejMapName);
  636. SysFree(pszMapsList);
  637. return (ErrorPop());
  638. }
  640. if (iMapCode == 0)
  641. SMTPS.ulFlags |= SMTPF_MAPPED_IP;
  642. else
  643. SMTPS.iCmdDelay = Max(SMTPS.iCmdDelay, Abs(iMapCode));
  644. }
  646. SysFree(pszMapsList);
  647. }
  648. ///////////////////////////////////////////////////////////////////////////////
  649. //  RDNS client check
  650. ///////////////////////////////////////////////////////////////////////////////
  651. int iCheckValue = SvrGetConfigInt("SMTP-RDNSCheck", 0, SMTPS.hSvrConfig);
  653. if ((iCheckValue != 0) && (SysGetHostByAddr(SMTPS.PeerInfo, SMTPS.szClientFQDN) < 0)) {
  654. if (iCheckValue > 0)
  655. SMTPS.ulFlags |= SMTPF_NORDNS_IP;
  656. else
  657. SMTPS.iCmdDelay = Max(SMTPS.iCmdDelay, -iCheckValue);
  658. }
  660. return (0);
  662. }
  664. static int SMTPInitSession(SHB_HANDLE hShbSMTP, BSOCK_HANDLE hBSock,
  665.    SMTPSession & SMTPS, char *&pszSMTPError)
  666. {
  668. ZeroData(SMTPS);
  669. SMTPS.iSMTPState = stateInit;
  670. SMTPS.hShbSMTP = hShbSMTP;
  671. SMTPS.hSvrConfig = INVALID_SVRCFG_HANDLE;
  672. SMTPS.pSMTPCfg = NULL;
  673. SMTPS.pMsgFile = NULL;
  674. SMTPS.pszFrom = NULL;
  675. SMTPS.pszRcpt = NULL;
  676. SMTPS.pszSendRcpt = NULL;
  677. SMTPS.iRcptCount = 0;
  678. SMTPS.iErrorsCount = 0;
  679. SMTPS.iErrorsMax = 0;
  680. SMTPS.iCmdDelay = 0;
  681. SMTPS.ulMaxMsgSize = 0;
  682. SetEmptyString(SMTPS.szMessageID);
  683. SetEmptyString(SMTPS.szDestDomain);
  684. SetEmptyString(SMTPS.szClientFQDN);
  685. SetEmptyString(SMTPS.szClientDomain);
  686. SetEmptyString(SMTPS.szLogonUser);
  687. SetEmptyString(SMTPS.szRejMapName);
  688. SMTPS.ulFlags = 0;
  689. SMTPS.ulSetupFlags = 0;
  690. SMTPS.pszCustMsg = NULL;
  692. SysGetTmpFile(SMTPS.szMsgFile);
  694. if ((SMTPS.hSvrConfig = SvrGetConfigHandle()) == INVALID_SVRCFG_HANDLE)
  695. return (ErrGetErrorCode());
  697. if ((SMTPCheckSysResources(SMTPS.hSvrConfig) < 0) ||
  698.     (SysGetPeerInfo(BSckGetAttachedSocket(hBSock), SMTPS.PeerInfo) < 0) ||
  699.     (SysGetSockInfo(BSckGetAttachedSocket(hBSock), SMTPS.SockInfo) < 0) ||
  700.     (SMTPApplyIPProps(SMTPS) < 0)) {
  701. ErrorPush();
  702. SvrReleaseConfigHandle(SMTPS.hSvrConfig);
  703. return (ErrorPop());
  704. }
  705. ///////////////////////////////////////////////////////////////////////////////
  706. //  If the remote IP is not white-listed, do all IP based checks
  707. ///////////////////////////////////////////////////////////////////////////////
  708. if (((SMTPS.ulFlags & SMTPF_WHITE_LISTED) == 0) &&
  709.     (SMTPDoIPBasedInit(SMTPS, pszSMTPError) < 0)) {
  710. ErrorPush();
  711. SvrReleaseConfigHandle(SMTPS.hSvrConfig);
  712. return (ErrorPop());
  713. }
  715. ///////////////////////////////////////////////////////////////////////////////
  716. //  Get maximum errors count allowed in an SMTP session
  717. ///////////////////////////////////////////////////////////////////////////////
  718. SMTPS.iErrorsMax = SvrGetConfigInt("SMTP-MaxErrors", 0, SMTPS.hSvrConfig);
  720. ///////////////////////////////////////////////////////////////////////////////
  721. //  Setup SMTP domain
  722. ///////////////////////////////////////////////////////////////////////////////
  723. char *pszSvrDomain = SvrGetConfigVar(SMTPS.hSvrConfig, "SmtpServerDomain");
  724. char szIP[128] = "???.???.???.???";
  726. if (pszSvrDomain != NULL) {
  727. StrSNCpy(SMTPS.szSvrDomain, pszSvrDomain);
  728. StrSNCpy(SMTPS.szSvrFQDN, pszSvrDomain);
  730. SysFree(pszSvrDomain);
  731. } else {
  732. if (MscGetSockHost(BSckGetAttachedSocket(hBSock), SMTPS.szSvrFQDN) < 0)
  733. StrSNCpy(SMTPS.szSvrFQDN, SysInetNToA(SMTPS.SockInfo, szIP));
  734. else {
  735. ///////////////////////////////////////////////////////////////////////////////
  736. //  Try to get a valid domain from the FQDN
  737. ///////////////////////////////////////////////////////////////////////////////
  738. if (MDomGetClientDomain(SMTPS.szSvrFQDN, SMTPS.szSvrDomain,
  739. sizeof(SMTPS.szSvrDomain) - 1) < 0)
  740. StrSNCpy(SMTPS.szSvrDomain, SMTPS.szSvrFQDN);
  741. }
  743. ///////////////////////////////////////////////////////////////////////////////
  744. //  Last attempt, try fetch the "RootDomain" variable ...
  745. ///////////////////////////////////////////////////////////////////////////////
  746. if (IsEmptyString(SMTPS.szSvrDomain)) {
  747. if ((pszSvrDomain =
  748.      SvrGetConfigVar(SMTPS.hSvrConfig, "RootDomain")) == NULL) {
  749. SvrReleaseConfigHandle(SMTPS.hSvrConfig);
  750. ErrSetErrorCode(ERR_NO_DOMAIN);
  751. return (ERR_NO_DOMAIN);
  752. }
  754. StrSNCpy(SMTPS.szSvrDomain, pszSvrDomain);
  756. SysFree(pszSvrDomain);
  757. }
  758. }
  760. ///////////////////////////////////////////////////////////////////////////////
  761. //  Create timestamp
  762. ///////////////////////////////////////////////////////////////////////////////
  763. sprintf(SMTPS.szTimeStamp, "<%lu.%lu@%s>",
  764. (unsigned long) time(NULL), SysGetCurrentThreadId(), SMTPS.szSvrDomain);
  766. if ((SMTPS.pSMTPCfg = SMTPGetConfigCopy(hShbSMTP)) == NULL) {
  767. ErrorPush();
  768. SvrReleaseConfigHandle(SMTPS.hSvrConfig);
  769. return (ErrorPop());
  770. }
  771. ///////////////////////////////////////////////////////////////////////////////
  772. //  Get maximum accepted message size
  773. ///////////////////////////////////////////////////////////////////////////////
  774. SMTPS.ulMaxMsgSize = 1024 * (unsigned long) SvrGetConfigInt("MaxMessageSize",
  775.     0, SMTPS.hSvrConfig);
  777. ///////////////////////////////////////////////////////////////////////////////
  778. //  Check if the emission of "X-Auth-User:" is diabled
  779. ///////////////////////////////////////////////////////////////////////////////
  780. if (SvrGetConfigInt("DisableEmitAuthUser", 0, SMTPS.hSvrConfig))
  781. SMTPS.ulFlags |= SMTPF_NOEMIT_AUTH;
  783. ///////////////////////////////////////////////////////////////////////////////
  784. //  Try to load specific configuration
  785. ///////////////////////////////////////////////////////////////////////////////
  786. char szConfigName[128] = "";
  788. sprintf(szConfigName, "SmtpConfig-%s", SysInetNToA(SMTPS.SockInfo, szIP));
  790. char *pszSvrConfig = SvrGetConfigVar(SMTPS.hSvrConfig, szConfigName);
  792. if ((pszSvrConfig != NULL) ||
  793.     ((pszSvrConfig = SvrGetConfigVar(SMTPS.hSvrConfig, "SmtpConfig")) != NULL)) {
  794. SMTPLoadConfig(SMTPS, pszSvrConfig);
  796. SysFree(pszSvrConfig);
  797. }
  799. SMTPS.ulFlags |= SMTPS.ulSetupFlags;
  801. ///////////////////////////////////////////////////////////////////////////////
  802. //  Get custom message to append to the SMTP response
  803. ///////////////////////////////////////////////////////////////////////////////
  804. SMTPS.pszCustMsg = SvrGetConfigVar(SMTPS.hSvrConfig, "CustomSMTPMessage");
  806. return (0);
  808. }
  810. static int SMTPLoadConfig(SMTPSession & SMTPS, char const *pszSvrConfig)
  811. {
  813. char **ppszCfgTokens = StrTokenize(pszSvrConfig, ",");
  815. if (ppszCfgTokens == NULL)
  816. return (ErrGetErrorCode());
  818. for (int ii = 0; ppszCfgTokens[ii] != NULL; ii++) {
  820. if (stricmp(ppszCfgTokens[ii], "mail-auth") == 0)
  821. SMTPS.ulSetupFlags |= SMTPF_MAIL_LOCKED;
  823. }
  825. StrFreeStrings(ppszCfgTokens);
  827. return (0);
  829. }
  831. static int SMTPApplyPerms(SMTPSession & SMTPS, char const *pszPerms)
  832. {
  834. for (int ii = 0; pszPerms[ii] != ''; ii++) {
  836. switch (pszPerms[ii]) {
  837. case ('M'):
  838. SMTPS.ulFlags |= SMTPF_MAIL_UNLOCKED;
  839. break;
  841. case ('R'):
  842. SMTPS.ulFlags |= SMTPF_RELAY_ENABLED;
  843. break;
  845. case ('V'):
  846. SMTPS.ulFlags |= SMTPF_VRFY_ENABLED;
  847. break;
  849. case ('T'):
  850. SMTPS.ulFlags |= SMTPF_ETRN_ENABLED;
  851. break;
  853. case ('Z'):
  854. SMTPS.ulMaxMsgSize = 0;
  855. break;
  856. }
  858. }
  860. ///////////////////////////////////////////////////////////////////////////////
  861. //  Clear bad ip mask and command delay
  862. ///////////////////////////////////////////////////////////////////////////////
  863. SMTPS.ulFlags &= ~(SMTPF_MAPPED_IP | SMTPF_NORDNS_IP | SMTPF_BLOCKED_IP);
  865. SMTPS.iCmdDelay = 0;
  867. return (0);
  869. }
  871. static int SMTPApplyUserConfig(SMTPSession & SMTPS, UserInfo * pUI)
  872. {
  873. ///////////////////////////////////////////////////////////////////////////////
  874. //  Retrieve and apply permissions
  875. ///////////////////////////////////////////////////////////////////////////////
  876. char *pszValue = NULL;
  877. char szPerms[128] = "";
  879. if (SMTPGetUserSmtpPerms(pUI, SMTPS.hSvrConfig, szPerms, sizeof(szPerms) - 1) < 0)
  880. return (ErrGetErrorCode());
  882. SMTPApplyPerms(SMTPS, szPerms);
  884. ///////////////////////////////////////////////////////////////////////////////
  885. //  Check "MaxMessageSize" override
  886. ///////////////////////////////////////////////////////////////////////////////
  887. if ((pszValue = UsrGetUserInfoVar(pUI, "MaxMessageSize")) != NULL) {
  888. SMTPS.ulMaxMsgSize = 1024 * (unsigned long) atol(pszValue);
  890. SysFree(pszValue);
  891. }
  892. ///////////////////////////////////////////////////////////////////////////////
  893. //  Check if the emission of "X-Auth-User:" is diabled
  894. ///////////////////////////////////////////////////////////////////////////////
  895. if ((pszValue = UsrGetUserInfoVar(pUI, "DisableEmitAuthUser")) != NULL) {
  896. if (atoi(pszValue))
  897. SMTPS.ulFlags |= SMTPF_NOEMIT_AUTH;
  898. else
  899. SMTPS.ulFlags &= ~SMTPF_NOEMIT_AUTH;
  901. SysFree(pszValue);
  902. }
  904. return (0);
  906. }
  908. static int SMTPLogSession(SMTPSession & SMTPS, char const *pszSender,
  909.   char const *pszRecipient, char const *pszStatus,
  910.   unsigned long ulMsgSize)
  911. {
  913. char szTime[256] = "";
  915. MscGetTimeNbrString(szTime, sizeof(szTime) - 1);
  917. RLCK_HANDLE hResLock = RLckLockEX(SVR_LOGS_DIR SYS_SLASH_STR SMTP_LOG_FILE);
  919. if (hResLock == INVALID_RLCK_HANDLE)
  920. return (ErrGetErrorCode());
  922. char szIP[128] = "???.???.???.???";
  924. MscFileLog(SMTP_LOG_FILE, ""%s""
  925.    "t"%s""
  926.    "t"%s""
  927.    "t"%s""
  928.    "t"%s""
  929.    "t"%s""
  930.    "t"%s""
  931.    "t"%s""
  932.    "t"%s""
  933.    "t"%s""
  934.    "t"%s""
  935.    "t"%lu""
  936.    "t"%s""
  937.    "n", SMTPS.szSvrFQDN, SMTPS.szSvrDomain, SysInetNToA(SMTPS.PeerInfo, szIP),
  938.    szTime, SMTPS.szClientDomain, SMTPS.szDestDomain, pszSender, pszRecipient,
  939.    SMTPS.szMessageID, pszStatus, SMTPS.szLogonUser, ulMsgSize,
  940.    SMTPS.szClientFQDN);
  942. RLckUnlockEX(hResLock);
  944. return (0);
  946. }
  948. static int SMTPSendError(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszFormat, ...)
  949. {
  951. char *pszBuffer = NULL;
  953. STRSPRINTF(pszBuffer, pszFormat, pszFormat);
  955. if (pszBuffer == NULL)
  956. return (ErrGetErrorCode());
  958. if (SMTPS.pszCustMsg == NULL) {
  959. if (BSckSendString(hBSock, pszBuffer, SMTPS.pSMTPCfg->iTimeout) < 0) {
  960. ErrorPush();
  961. SysFree(pszBuffer);
  962. return (ErrorPop());
  963. }
  964. } else {
  965. if (BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout,
  966.     "%s - %s", pszBuffer, SMTPS.pszCustMsg) < 0) {
  967. ErrorPush();
  968. SysFree(pszBuffer);
  969. return (ErrorPop());
  970. }
  971. }
  973. SysFree(pszBuffer);
  975. ///////////////////////////////////////////////////////////////////////////////
  976. //  Increase the number of errors we encountered in this session. If the
  977. //  maximum number of allowed errors is not zero, and the current number of
  978. //  errors exceed the maximum number, we set the state to 'exit' so that the
  979. //  SMTP connection will be dropped
  980. ///////////////////////////////////////////////////////////////////////////////
  981. SMTPS.iErrorsCount++;
  982. if ((SMTPS.iErrorsMax > 0) && (SMTPS.iErrorsCount >= SMTPS.iErrorsMax)) {
  983. char szIP[128] = "";
  985. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  986. SMTPLogSession(SMTPS, SMTPS.pszFrom != NULL ? SMTPS.pszFrom: "",
  987.        "", "SMTP=EERRS", 0);
  989. SysLogMessage(LOG_LEV_MESSAGE, "SMTP forced exit (too many errors: %d) [%s]n",
  990.       SMTPS.iErrorsCount, SysInetNToA(SMTPS.PeerInfo, szIP));
  992. SMTPS.iSMTPState = stateExit;
  993. }
  995. return (0);
  997. }
  999. static int SMTPHandleSession(SHB_HANDLE hShbSMTP, BSOCK_HANDLE hBSock)
  1000. {
  1002. ///////////////////////////////////////////////////////////////////////////////
  1003. //  Session structure declaration and init
  1004. ///////////////////////////////////////////////////////////////////////////////
  1005. char *pszSMTPError = NULL;
  1006. SMTPSession SMTPS;
  1008. if (SMTPInitSession(hShbSMTP, hBSock, SMTPS, pszSMTPError) < 0) {
  1009. ErrorPush();
  1010. if (pszSMTPError != NULL) {
  1011. BSckSendString(hBSock, pszSMTPError, STD_SMTP_TIMEOUT);
  1013. SysFree(pszSMTPError);
  1014. } else
  1015. BSckVSendString(hBSock, STD_SMTP_TIMEOUT,
  1016. "421 %s service not available (%d), closing transmission channel",
  1017. SMTP_SERVER_NAME, ErrorFetch());
  1019. return (ErrorPop());
  1020. }
  1022. char szIP[128] = "???.???.???.???";
  1024. SysLogMessage(LOG_LEV_MESSAGE, "SMTP client connection from [%s]n",
  1025.       SysInetNToA(SMTPS.PeerInfo, szIP));
  1027. ///////////////////////////////////////////////////////////////////////////////
  1028. //  Send welcome message
  1029. ///////////////////////////////////////////////////////////////////////////////
  1030. char szTime[256] = "";
  1032. MscGetTimeStr(szTime, sizeof(szTime) - 1);
  1034. if (BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout,
  1035.     "220 %s %s service ready; %s", SMTPS.szTimeStamp,
  1036.     SMTP_SERVER_NAME, szTime) < 0) {
  1037. ErrorPush();
  1038. SMTPClearSession(SMTPS);
  1039. return (ErrorPop());
  1040. }
  1041. ///////////////////////////////////////////////////////////////////////////////
  1042. //  Command loop
  1043. ///////////////////////////////////////////////////////////////////////////////
  1044. char szCommand[1024] = "";
  1046. while (!SvrInShutdown() && (SMTPS.iSMTPState != stateExit) &&
  1047.        (BSckGetString(hBSock, szCommand, sizeof(szCommand) - 1,
  1048.       SMTPS.pSMTPCfg->iSessionTimeout) != NULL) &&
  1049.        (MscCmdStringCheck(szCommand) == 0)) {
  1050. ///////////////////////////////////////////////////////////////////////////////
  1051. //  Retrieve a fresh new configuration copy and test shutdown flag
  1052. ///////////////////////////////////////////////////////////////////////////////
  1053. SysFree(SMTPS.pSMTPCfg);
  1055. SMTPS.pSMTPCfg = SMTPGetConfigCopy(hShbSMTP);
  1057. if ((SMTPS.pSMTPCfg == NULL) || (SMTPS.pSMTPCfg->ulFlags & SMTPF_STOP_SERVER))
  1058. break;
  1060. ///////////////////////////////////////////////////////////////////////////////
  1061. //  Handle command
  1062. ///////////////////////////////////////////////////////////////////////////////
  1063. SMTPHandleCommand(szCommand, hBSock, SMTPS);
  1065. }
  1067. SysLogMessage(LOG_LEV_MESSAGE, "SMTP client exit [%s]n",
  1068.       SysInetNToA(SMTPS.PeerInfo, szIP));
  1070. SMTPClearSession(SMTPS);
  1072. return (0);
  1074. }
  1076. static void SMTPClearSession(SMTPSession & SMTPS)
  1077. {
  1079. if (SMTPS.pMsgFile != NULL)
  1080. fclose(SMTPS.pMsgFile), SMTPS.pMsgFile = NULL;
  1082. SysRemove(SMTPS.szMsgFile);
  1084. if (SMTPS.hSvrConfig != INVALID_SVRCFG_HANDLE)
  1085. SvrReleaseConfigHandle(SMTPS.hSvrConfig), SMTPS.hSvrConfig =
  1086.     INVALID_SVRCFG_HANDLE;
  1088. if (SMTPS.pSMTPCfg != NULL)
  1089. SysFree(SMTPS.pSMTPCfg), SMTPS.pSMTPCfg = NULL;
  1091. if (SMTPS.pszFrom != NULL)
  1092. SysFree(SMTPS.pszFrom), SMTPS.pszFrom = NULL;
  1094. if (SMTPS.pszRcpt != NULL)
  1095. SysFree(SMTPS.pszRcpt), SMTPS.pszRcpt = NULL;
  1097. if (SMTPS.pszSendRcpt != NULL)
  1098. SysFree(SMTPS.pszSendRcpt), SMTPS.pszSendRcpt = NULL;
  1100. if (SMTPS.pszCustMsg != NULL)
  1101. SysFree(SMTPS.pszCustMsg), SMTPS.pszCustMsg = NULL;
  1103. }
  1105. static void SMTPResetSession(SMTPSession & SMTPS)
  1106. {
  1108. SMTPS.ulFlags = SMTPS.ulSetupFlags | (SMTPS.ulFlags & SMTPF_RESET_MASK);
  1109. SMTPS.ullMessageID = 0;
  1110. SMTPS.iRcptCount = 0;
  1111. SetEmptyString(SMTPS.szMessageID);
  1113. if (SMTPS.pMsgFile != NULL)
  1114. fclose(SMTPS.pMsgFile), SMTPS.pMsgFile = NULL;
  1116. SysRemove(SMTPS.szMsgFile);
  1118. SetEmptyString(SMTPS.szDestDomain);
  1120. if (SMTPS.pszFrom != NULL)
  1121. SysFree(SMTPS.pszFrom), SMTPS.pszFrom = NULL;
  1123. if (SMTPS.pszRcpt != NULL)
  1124. SysFree(SMTPS.pszRcpt), SMTPS.pszRcpt = NULL;
  1126. if (SMTPS.pszSendRcpt != NULL)
  1127. SysFree(SMTPS.pszSendRcpt), SMTPS.pszSendRcpt = NULL;
  1129. SMTPS.iSMTPState = (SMTPS.ulFlags & SMTPF_AUTHENTICATED) ? stateAuthenticated :
  1130.     Min(SMTPS.iSMTPState, stateHelo);
  1132. }
  1134. static int SMTPHandleCommand(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  1135. {
  1137. ///////////////////////////////////////////////////////////////////////////////
  1138. //  Delay protection against massive spammers
  1139. ///////////////////////////////////////////////////////////////////////////////
  1140. if (SMTPS.iCmdDelay > 0)
  1141. SysSleep(SMTPS.iCmdDelay);
  1143. ///////////////////////////////////////////////////////////////////////////////
  1144. //  Command parsing and processing
  1145. ///////////////////////////////////////////////////////////////////////////////
  1146. int iCmdResult = -1;
  1148. if (StrINComp(pszCommand, MAIL_FROM_STR) == 0)
  1149. iCmdResult = SMTPHandleCmd_MAIL(pszCommand, hBSock, SMTPS);
  1150. else if (StrINComp(pszCommand, RCPT_TO_STR) == 0)
  1151. iCmdResult = SMTPHandleCmd_RCPT(pszCommand, hBSock, SMTPS);
  1152. else if (StrCmdMatch(pszCommand, "DATA"))
  1153. iCmdResult = SMTPHandleCmd_DATA(pszCommand, hBSock, SMTPS);
  1154. else if (StrCmdMatch(pszCommand, "HELO"))
  1155. iCmdResult = SMTPHandleCmd_HELO(pszCommand, hBSock, SMTPS);
  1156. else if (StrCmdMatch(pszCommand, "EHLO"))
  1157. iCmdResult = SMTPHandleCmd_EHLO(pszCommand, hBSock, SMTPS);
  1158. else if (StrCmdMatch(pszCommand, "AUTH"))
  1159. iCmdResult = SMTPHandleCmd_AUTH(pszCommand, hBSock, SMTPS);
  1160. else if (StrCmdMatch(pszCommand, "RSET"))
  1161. iCmdResult = SMTPHandleCmd_RSET(pszCommand, hBSock, SMTPS);
  1162. else if (StrCmdMatch(pszCommand, "VRFY"))
  1163. iCmdResult = SMTPHandleCmd_VRFY(pszCommand, hBSock, SMTPS);
  1164. else if (StrCmdMatch(pszCommand, "ETRN"))
  1165. iCmdResult = SMTPHandleCmd_ETRN(pszCommand, hBSock, SMTPS);
  1166. else if (StrCmdMatch(pszCommand, "NOOP"))
  1167. iCmdResult = SMTPHandleCmd_NOOP(pszCommand, hBSock, SMTPS);
  1168. else if (StrCmdMatch(pszCommand, "HELP"))
  1169. iCmdResult = SMTPHandleCmd_HELP(pszCommand, hBSock, SMTPS);
  1170. else if (StrCmdMatch(pszCommand, "QUIT"))
  1171. iCmdResult = SMTPHandleCmd_QUIT(pszCommand, hBSock, SMTPS);
  1172. else
  1173. SMTPSendError(hBSock, SMTPS, "500 Syntax error, command unrecognized");
  1175. return (iCmdResult);
  1177. }
  1179. static int SMTPTryPopAuthIpCheck(SMTPSession & SMTPS, char const *pszUser, char const *pszDomain)
  1180. {
  1181. ///////////////////////////////////////////////////////////////////////////////
  1182. //  Load user info
  1183. ///////////////////////////////////////////////////////////////////////////////
  1184. UserInfo *pUI = UsrGetUserByNameOrAlias(pszDomain, pszUser);
  1186. if (pUI == NULL)
  1187. return (ErrGetErrorCode());
  1189. ///////////////////////////////////////////////////////////////////////////////
  1190. //  Perform IP file checking
  1191. ///////////////////////////////////////////////////////////////////////////////
  1192. if (UPopUserIpCheck(pUI, &SMTPS.PeerInfo, SMTPS.pSMTPCfg->uPopAuthExpireTime) < 0) {
  1193. ErrorPush();
  1194. UsrFreeUserInfo(pUI);
  1195. return (ErrorPop());
  1196. }
  1197. ///////////////////////////////////////////////////////////////////////////////
  1198. //  Apply user configuration
  1199. ///////////////////////////////////////////////////////////////////////////////
  1200. if (SMTPApplyUserConfig(SMTPS, pUI) < 0) {
  1201. ErrorPush();
  1202. UsrFreeUserInfo(pUI);
  1203. return (ErrorPop());
  1204. }
  1205. ///////////////////////////////////////////////////////////////////////////////
  1206. //  If the user did not authenticate, set the logon user token
  1207. ///////////////////////////////////////////////////////////////////////////////
  1208. if (IsEmptyString(SMTPS.szLogonUser))
  1209. UsrGetAddress(pUI, SMTPS.szLogonUser);
  1211. UsrFreeUserInfo(pUI);
  1213. return (0);
  1215. }
  1217. static int SMTPCheckReturnPath(const char *pszCommand, char **ppszRetDomains,
  1218.        SMTPSession & SMTPS, char *&pszSMTPError)
  1219. {
  1221. int iDomainCount = StrStringsCount(ppszRetDomains);
  1223. if (iDomainCount == 0) {
  1224. if (!SvrTestConfigFlag("AllowNullSender", true, SMTPS.hSvrConfig)) {
  1225. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1226. SMTPLogSession(SMTPS, "", "", "SNDR=EEMPTY", 0);
  1228. pszSMTPError = SysStrDup("501 Syntax error in return path");
  1230. ErrSetErrorCode(ERR_BAD_RETURN_PATH);
  1231. return (ERR_BAD_RETURN_PATH);
  1232. }
  1234. if (SMTPS.pszFrom != NULL)
  1235. SysFree(SMTPS.pszFrom);
  1237. SMTPS.pszFrom = SysStrDup("");
  1239. return (0);
  1240. }
  1242. char szMailerUser[MAX_ADDR_NAME] = "";
  1243. char szMailerDomain[MAX_ADDR_NAME] = "";
  1245. if (USmtpSplitEmailAddr(ppszRetDomains[0], szMailerUser, szMailerDomain) < 0) {
  1246. ErrorPush();
  1248. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1249. SMTPLogSession(SMTPS, ppszRetDomains[0], "", "SNDR=ESYNTAX", 0);
  1251. pszSMTPError = SysStrDup("501 Syntax error in return path");
  1253. return (ErrorPop());
  1254. }
  1255. ///////////////////////////////////////////////////////////////////////////////
  1256. //  Check mailer domain for DNS/MX entries
  1257. ///////////////////////////////////////////////////////////////////////////////
  1258. if (SvrTestConfigFlag("CheckMailerDomain", false, SMTPS.hSvrConfig) &&
  1259.     (USmtpCheckMailDomain(SMTPS.hSvrConfig, szMailerDomain) < 0)) {
  1260. ErrorPush();
  1262. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1263. SMTPLogSession(SMTPS, ppszRetDomains[0], "", "SNDR=ENODNS", 0);
  1265. pszSMTPError = SysStrDup("505 Your domain has not DNS/MX entries");
  1267. return (ErrorPop());
  1268. }
  1269. ///////////////////////////////////////////////////////////////////////////////
  1270. //  Check if mail come from a spammer address ( spam-address.tab )
  1271. ///////////////////////////////////////////////////////////////////////////////
  1272. if (USmtpSpamAddressCheck(ppszRetDomains[0]) < 0) {
  1273. ErrorPush();
  1275. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1276. SMTPLogSession(SMTPS, ppszRetDomains[0], "", "SNDR=ESPAM", 0);
  1278. if ((pszSMTPError =
  1279.      SvrGetConfigVar(SMTPS.hSvrConfig, "SmtpMsgIPBanSpamAddress")) == NULL)
  1280. pszSMTPError = SysStrDup("504 You are registered as spammer");
  1282. return (ErrorPop());
  1283. }
  1284. ///////////////////////////////////////////////////////////////////////////////
  1285. //  Check SMTP after POP3 authentication
  1286. ///////////////////////////////////////////////////////////////////////////////
  1287. if (SvrTestConfigFlag("EnableAuthSMTP-POP3", true, SMTPS.hSvrConfig))
  1288. SMTPTryPopAuthIpCheck(SMTPS, szMailerUser, szMailerDomain);
  1290. ///////////////////////////////////////////////////////////////////////////////
  1291. //  Check extended mail from parameters
  1292. ///////////////////////////////////////////////////////////////////////////////
  1293. if (SMTPCheckMailParams(pszCommand, ppszRetDomains, SMTPS, pszSMTPError) < 0)
  1294. return (ErrGetErrorCode());
  1296. ///////////////////////////////////////////////////////////////////////////////
  1297. //  Setup From string
  1298. ///////////////////////////////////////////////////////////////////////////////
  1299. if (SMTPS.pszFrom != NULL)
  1300. SysFree(SMTPS.pszFrom);
  1302. SMTPS.pszFrom = SysStrDup(ppszRetDomains[0]);
  1304. return (0);
  1306. }
  1308. static int SMTPAddMessageInfo(SMTPSession & SMTPS)
  1309. {
  1311. return (USmtpAddMessageInfo(SMTPS.pMsgFile, SMTPS.szClientDomain, SMTPS.PeerInfo,
  1312.     SMTPS.szSvrDomain, SMTPS.SockInfo, SMTP_SERVER_NAME));
  1314. }
  1316. static int SMTPCheckMailParams(const char *pszCommand, char **ppszRetDomains,
  1317.        SMTPSession & SMTPS, char *&pszSMTPError)
  1318. {
  1320. char const *pszParams = strrchr(pszCommand, '>');
  1322. if (pszParams == NULL)
  1323. pszParams = pszCommand;
  1325. ///////////////////////////////////////////////////////////////////////////////
  1326. //  Check the SIZE parameter
  1327. ///////////////////////////////////////////////////////////////////////////////
  1328. if (SMTPS.ulMaxMsgSize != 0) {
  1329. char const *pszSize = pszParams;
  1331. while ((pszSize = StrIStr(pszSize, " SIZE=")) != NULL) {
  1332. pszSize += CStringSize(" SIZE=");
  1334. if (isdigit(*pszSize) &&
  1335.     (SMTPS.ulMaxMsgSize < (unsigned long) atol(pszSize))) {
  1336. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1337. SMTPLogSession(SMTPS,
  1338.        (ppszRetDomains[0] !=
  1339. NULL) ? ppszRetDomains[0] : "", "",
  1340.        "SIZE=EBIG",
  1341.        (unsigned long) atol(pszSize));
  1343. pszSMTPError =
  1344.     SysStrDup("552 Message exceeds fixed maximum message size");
  1346. ErrSetErrorCode(ERR_MESSAGE_SIZE);
  1347. return (ERR_MESSAGE_SIZE);
  1348. }
  1349. }
  1351. }
  1353. return (0);
  1355. }
  1357. static int SMTPHandleCmd_MAIL(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  1358. {
  1360. if ((SMTPS.iSMTPState != stateHelo) && (SMTPS.iSMTPState != stateAuthenticated)) {
  1361. SMTPResetSession(SMTPS);
  1363. SMTPSendError(hBSock, SMTPS, "503 Bad sequence of commands");
  1365. ErrSetErrorCode(ERR_SMTP_BAD_CMD_SEQUENCE);
  1366. return (ERR_SMTP_BAD_CMD_SEQUENCE);
  1367. }
  1368. ///////////////////////////////////////////////////////////////////////////////
  1369. //  Split the RETURN PATH
  1370. ///////////////////////////////////////////////////////////////////////////////
  1371. char **ppszRetDomains = USmtpGetPathStrings(pszCommand);
  1373. if (ppszRetDomains == NULL) {
  1374. ErrorPush();
  1375. SMTPResetSession(SMTPS);
  1377. SMTPSendError(hBSock, SMTPS,
  1378.       "501 Syntax error in parameters or arguments: (%d)",
  1379.       ErrorFetch());
  1380. return (ErrorPop());
  1381. }
  1382. ///////////////////////////////////////////////////////////////////////////////
  1383. //  Check RETURN PATH
  1384. ///////////////////////////////////////////////////////////////////////////////
  1385. char *pszSMTPError = NULL;
  1387. if (SMTPCheckReturnPath(pszCommand, ppszRetDomains, SMTPS, pszSMTPError) < 0) {
  1388. ErrorPush();
  1389. StrFreeStrings(ppszRetDomains);
  1390. SMTPResetSession(SMTPS);
  1392. SMTPSendError(hBSock, SMTPS, "%s", pszSMTPError);
  1393. SysFree(pszSMTPError);
  1394. return (ErrorPop());
  1395. }
  1397. StrFreeStrings(ppszRetDomains);
  1399. ///////////////////////////////////////////////////////////////////////////////
  1400. //  If the incoming IP is "mapped" stop here
  1401. ///////////////////////////////////////////////////////////////////////////////
  1402. if (SMTPS.ulFlags & (SMTPF_MAPPED_IP | SMTPF_NORDNS_IP | SMTPF_BLOCKED_IP)) {
  1403. char *pszSMTPError = NULL;
  1405. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg)) {
  1406. if (SMTPS.ulFlags & SMTPF_MAPPED_IP) {
  1407. char *pszError =
  1408. StrSprint("SNDRIP=EIPMAP (%s)", SMTPS.szRejMapName);
  1410. SMTPLogSession(SMTPS, SMTPS.pszFrom, "",
  1411.        (pszError != NULL) ? pszError : "SNDRIP=EIPMAP",
  1412.        0);
  1414. if (pszError != NULL)
  1415. SysFree(pszError);
  1416. } else if (SMTPS.ulFlags & SMTPF_NORDNS_IP)
  1417. SMTPLogSession(SMTPS, SMTPS.pszFrom, "", "SNDRIP=ERDNS", 0);
  1418. else
  1419. SMTPLogSession(SMTPS, SMTPS.pszFrom, "", "SNDRIP=EIPSPAM", 0);
  1420. }
  1421. if (SMTPS.ulFlags & SMTPF_BLOCKED_IP)
  1422. pszSMTPError = SvrGetConfigVar(SMTPS.hSvrConfig, "SmtpMsgIPBanSpammers");
  1424. SMTPResetSession(SMTPS);
  1426. if (pszSMTPError == NULL)
  1427. SMTPSendError(hBSock, SMTPS, "551 Server access forbidden by your IP");
  1428. else {
  1429. SMTPSendError(hBSock, SMTPS, "%s", pszSMTPError);
  1430. SysFree(pszSMTPError);
  1431. }
  1433. ErrSetErrorCode(ERR_SMTP_USE_FORBIDDEN);
  1434. return (ERR_SMTP_USE_FORBIDDEN);
  1435. }
  1436. ///////////////////////////////////////////////////////////////////////////////
  1437. //  If MAIL command is locked stop here
  1438. ///////////////////////////////////////////////////////////////////////////////
  1439. if ((SMTPS.ulFlags & SMTPF_MAIL_LOCKED) && !(SMTPS.ulFlags & SMTPF_MAIL_UNLOCKED)) {
  1440. SMTPResetSession(SMTPS);
  1442. SMTPSendError(hBSock, SMTPS, "551 Server use forbidden");
  1444. ErrSetErrorCode(ERR_SMTP_USE_FORBIDDEN);
  1445. return (ERR_SMTP_USE_FORBIDDEN);
  1446. }
  1447. ///////////////////////////////////////////////////////////////////////////////
  1448. //  Prepare mail file
  1449. ///////////////////////////////////////////////////////////////////////////////
  1450. if ((SMTPS.pMsgFile = fopen(SMTPS.szMsgFile, "w+b")) == NULL) {
  1451. SMTPResetSession(SMTPS);
  1453. SMTPSendError(hBSock, SMTPS,
  1454.       "451 Requested action aborted: (%d) local error in processing",
  1455.       ERR_FILE_CREATE);
  1457. ErrSetErrorCode(ERR_FILE_CREATE, SMTPS.szMsgFile);
  1458. return (ERR_FILE_CREATE);
  1459. }
  1460. ///////////////////////////////////////////////////////////////////////////////
  1461. //  Write message infos ( 1st row of the smtp-mail file )
  1462. ///////////////////////////////////////////////////////////////////////////////
  1463. if (SMTPAddMessageInfo(SMTPS) < 0) {
  1464. ErrorPush();
  1465. SMTPResetSession(SMTPS);
  1467. SMTPSendError(hBSock, SMTPS,
  1468.       "451 Requested action aborted: (%d) local error in processing",
  1469.       ErrorFetch());
  1470. return (ErrorPop());
  1471. }
  1472. ///////////////////////////////////////////////////////////////////////////////
  1473. //  Write domain ( 2nd row of the smtp-mail file )
  1474. ///////////////////////////////////////////////////////////////////////////////
  1475. if (StrWriteCRLFString(SMTPS.pMsgFile, SMTPS.szSvrDomain) < 0) {
  1476. ErrorPush();
  1477. SMTPResetSession(SMTPS);
  1479. SMTPSendError(hBSock, SMTPS,
  1480.       "451 Requested action aborted: (%d) local error in processing",
  1481.       ErrorFetch());
  1482. return (ErrorPop());
  1483. }
  1484. ///////////////////////////////////////////////////////////////////////////////
  1485. //  Get SMTP message ID and write it to file ( 3th row of the smtp-mail file )
  1486. ///////////////////////////////////////////////////////////////////////////////
  1487. if (SvrGetMessageID(&SMTPS.ullMessageID) < 0) {
  1488. ErrorPush();
  1489. SMTPResetSession(SMTPS);
  1491. SMTPSendError(hBSock, SMTPS,
  1492.       "451 Requested action aborted: (%d) local error in processing",
  1493.       ErrorFetch());
  1494. return (ErrorPop());
  1495. }
  1497. sprintf(SMTPS.szMessageID, "S" SYS_LLX_FMT, SMTPS.ullMessageID);
  1499. if (StrWriteCRLFString(SMTPS.pMsgFile, SMTPS.szMessageID) < 0) {
  1500. ErrorPush();
  1501. SMTPResetSession(SMTPS);
  1503. SMTPSendError(hBSock, SMTPS,
  1504.       "451 Requested action aborted: (%d) local error in processing",
  1505.       ErrorFetch());
  1506. return (ErrorPop());
  1507. }
  1508. ///////////////////////////////////////////////////////////////////////////////
  1509. //  Write MAIL FROM ( 4th row of the smtp-mail file )
  1510. ///////////////////////////////////////////////////////////////////////////////
  1511. if (StrWriteCRLFString(SMTPS.pMsgFile, pszCommand) < 0) {
  1512. ErrorPush();
  1513. SMTPResetSession(SMTPS);
  1515. SMTPSendError(hBSock, SMTPS,
  1516.       "451 Requested action aborted: (%d) local error in processing",
  1517.       ErrorFetch());
  1518. return (ErrorPop());
  1519. }
  1521. BSckSendString(hBSock, "250 OK", SMTPS.pSMTPCfg->iTimeout);
  1523. SMTPS.iSMTPState = stateMail;
  1525. return (0);
  1527. }
  1529. static int SMTPCheckRelayCapability(SMTPSession & SMTPS, char const *pszDestDomain)
  1530. {
  1531. ///////////////////////////////////////////////////////////////////////////////
  1532. //  OK if enabled ( authentication )
  1533. ///////////////////////////////////////////////////////////////////////////////
  1534. if (SMTPS.ulFlags & SMTPF_RELAY_ENABLED)
  1535. return (0);
  1537. ///////////////////////////////////////////////////////////////////////////////
  1538. //  OK if destination domain is a custom-handled domain
  1539. ///////////////////////////////////////////////////////////////////////////////
  1540. if (USmlCustomizedDomain(pszDestDomain) == 0)
  1541. return (0);
  1543. ///////////////////////////////////////////////////////////////////////////////
  1544. //  IP based relay check
  1545. ///////////////////////////////////////////////////////////////////////////////
  1546. return (USmtpIsAllowedRelay(SMTPS.PeerInfo, SMTPS.hSvrConfig));
  1548. }
  1550. static int SMTPCheckForwardPath(char **ppszFwdDomains, SMTPSession & SMTPS,
  1551. char *&pszRealRcpt, char *&pszSMTPError)
  1552. {
  1554. int iDomainCount = StrStringsCount(ppszFwdDomains);
  1556. if (iDomainCount == 0) {
  1557. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1558. SMTPLogSession(SMTPS, SMTPS.pszFrom, "", "RCPT=ESYNTAX", 0);
  1560. pszSMTPError = SysStrDup("501 Syntax error in forward path");
  1562. ErrSetErrorCode(ERR_BAD_FORWARD_PATH);
  1563. return (ERR_BAD_FORWARD_PATH);
  1564. }
  1566. char szDestUser[MAX_ADDR_NAME] = "";
  1567. char szDestDomain[MAX_ADDR_NAME] = "";
  1568. char szRealUser[MAX_ADDR_NAME] = "";
  1570. if (USmtpSplitEmailAddr(ppszFwdDomains[iDomainCount - 1], szDestUser, szDestDomain) < 0) {
  1571. ErrorPush();
  1573. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1574. SMTPLogSession(SMTPS, SMTPS.pszFrom, ppszFwdDomains[0], "RCPT=ESYNTAX",
  1575.        0);
  1577. pszSMTPError = SysStrDup("501 Syntax error in forward path");
  1579. return (ErrorPop());
  1580. }
  1582. if (iDomainCount == 1) {
  1583. if (USmlIsCmdAliasAccount(szDestDomain, szDestUser) == 0) {
  1584. ///////////////////////////////////////////////////////////////////////////////
  1585. //  The recipient is handled with cmdaliases
  1586. ///////////////////////////////////////////////////////////////////////////////
  1588. } else if (MDomIsHandledDomain(szDestDomain) == 0) {
  1589. ///////////////////////////////////////////////////////////////////////////////
  1590. //  Check user existance
  1591. ///////////////////////////////////////////////////////////////////////////////
  1592. UserInfo *pUI = UsrGetUserByNameOrAlias(szDestDomain, szDestUser);
  1594. if (pUI != NULL) {
  1595. ///////////////////////////////////////////////////////////////////////////////
  1596. //  Check if the account is enabled for receiving
  1597. ///////////////////////////////////////////////////////////////////////////////
  1598. if (!UsrGetUserInfoVarInt(pUI, "ReceiveEnable", 1)) {
  1599. UsrFreeUserInfo(pUI);
  1601. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1602. SMTPLogSession(SMTPS, SMTPS.pszFrom,
  1603.        ppszFwdDomains[0], "RCPT=EDSBL",
  1604.        0);
  1606. pszSMTPError = StrSprint("550 Account disabled <%s@%s>",
  1607.  szDestUser, szDestDomain);
  1609. ErrSetErrorCode(ERR_USER_DISABLED);
  1610. return (ERR_USER_DISABLED);
  1611. }
  1613. if (UsrGetUserType(pUI) == usrTypeUser) {
  1614. ///////////////////////////////////////////////////////////////////////////////
  1615. //  Target is a normal user
  1616. ///////////////////////////////////////////////////////////////////////////////
  1618. ///////////////////////////////////////////////////////////////////////////////
  1619. //  Check user mailbox size
  1620. ///////////////////////////////////////////////////////////////////////////////
  1621. if (UPopCheckMailboxSize(pUI) < 0) {
  1622. ErrorPush();
  1623. UsrFreeUserInfo(pUI);
  1625. if (SMTPLogEnabled
  1626.     (SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1627. SMTPLogSession(SMTPS, SMTPS.pszFrom,
  1628.        ppszFwdDomains[0],
  1629.        "RCPT=EFULL", 0);
  1631. pszSMTPError =
  1632. StrSprint
  1633. ("552 Requested mail action aborted: exceeded storage allocation - <%s@%s>",
  1634.  szDestUser, szDestDomain);
  1636. return (ErrorPop());
  1637. }
  1638. } else {
  1639. ///////////////////////////////////////////////////////////////////////////////
  1640. //  Target is a mailing list
  1641. ///////////////////////////////////////////////////////////////////////////////
  1643. ///////////////////////////////////////////////////////////////////////////////
  1644. //  Check if client can post to this mailing list
  1645. ///////////////////////////////////////////////////////////////////////////////
  1646. if (UsrMLCheckUserPost(pUI, SMTPS.pszFrom,
  1647.        IsEmptyString(SMTPS.
  1648.      szLogonUser) ? NULL :
  1649.        SMTPS.szLogonUser) < 0) {
  1650. ErrorPush();
  1651. UsrFreeUserInfo(pUI);
  1653. if (SMTPLogEnabled
  1654.     (SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1655. SMTPLogSession(SMTPS, SMTPS.pszFrom,
  1656.        ppszFwdDomains[0],
  1657.        "RCPT=EACCESS", 0);
  1659. pszSMTPError =
  1660. StrSprint
  1661. ("557 Access denied <%s@%s> for user <%s>",
  1662.  szDestUser, szDestDomain, SMTPS.pszFrom);
  1664. return (ErrorPop());
  1665. }
  1666. }
  1667. ///////////////////////////////////////////////////////////////////////////////
  1668. //  Extract the real user address
  1669. ///////////////////////////////////////////////////////////////////////////////
  1670. UsrGetAddress(pUI, szRealUser);
  1672. UsrFreeUserInfo(pUI);
  1673. } else {
  1674. ///////////////////////////////////////////////////////////////////////////////
  1675. //  Recipient domain is local but no account is found inside the standard
  1676. //  users/aliases database and the account is not handled with cmdaliases.
  1677. //  It's pretty much time to report a recipient error
  1678. ///////////////////////////////////////////////////////////////////////////////
  1679. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1680. SMTPLogSession(SMTPS, SMTPS.pszFrom, ppszFwdDomains[0],
  1681.        "RCPT=EAVAIL", 0);
  1683. pszSMTPError = StrSprint("550 Mailbox unavailable <%s@%s>",
  1684.  szDestUser, szDestDomain);
  1686. ErrSetErrorCode(ERR_USER_NOT_LOCAL);
  1687. return (ERR_USER_NOT_LOCAL);
  1688. }
  1689. } else {
  1690. ///////////////////////////////////////////////////////////////////////////////
  1691. //  Check relay permission
  1692. ///////////////////////////////////////////////////////////////////////////////
  1693. if (SMTPCheckRelayCapability(SMTPS, szDestDomain) < 0) {
  1694. ErrorPush();
  1696. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1697. SMTPLogSession(SMTPS, SMTPS.pszFrom, ppszFwdDomains[0],
  1698.        "RCPT=ERELAY", 0);
  1700. pszSMTPError = SysStrDup("550 Relay denied");
  1702. return (ErrorPop());
  1703. }
  1704. }
  1705. } else {
  1706. ///////////////////////////////////////////////////////////////////////////////
  1707. //  Check relay permission
  1708. ///////////////////////////////////////////////////////////////////////////////
  1709. if (SMTPCheckRelayCapability(SMTPS, szDestDomain) < 0) {
  1710. ErrorPush();
  1712. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1713. SMTPLogSession(SMTPS, SMTPS.pszFrom, ppszFwdDomains[0],
  1714.        "RCPT=ERELAY", 0);
  1716. pszSMTPError = SysStrDup("550 Relay denied");
  1718. return (ErrorPop());
  1719. }
  1720. }
  1722. ///////////////////////////////////////////////////////////////////////////////
  1723. //  Retrieve destination domain
  1724. ///////////////////////////////////////////////////////////////////////////////
  1725. if (USmtpSplitEmailAddr(ppszFwdDomains[0], NULL, SMTPS.szDestDomain) < 0) {
  1726. ErrorPush();
  1728. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1729. SMTPLogSession(SMTPS, SMTPS.pszFrom, ppszFwdDomains[0], "RCPT=ESYNTAX",
  1730.        0);
  1732. pszSMTPError = SysStrDup("501 Syntax error in forward path");
  1734. return (ErrorPop());
  1735. }
  1736. ///////////////////////////////////////////////////////////////////////////////
  1737. //  Setup SendRcpt string ( it'll be used to build "RCPT TO:<>" line into
  1738. //  the message file
  1739. ///////////////////////////////////////////////////////////////////////////////
  1740. if (SMTPS.pszSendRcpt != NULL)
  1741. SysFree(SMTPS.pszSendRcpt);
  1743. if ((SMTPS.pszSendRcpt = USmtpBuildRcptPath(ppszFwdDomains, SMTPS.hSvrConfig)) == NULL) {
  1744. ErrorPush();
  1746. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1747. SMTPLogSession(SMTPS, SMTPS.pszFrom, ppszFwdDomains[0], "RCPT=ESYNTAX",
  1748.        0);
  1750. pszSMTPError = SysStrDup("501 Syntax error in forward path");
  1752. return (ErrorPop());
  1753. }
  1754. ///////////////////////////////////////////////////////////////////////////////
  1755. //  Setup the Real Rcpt string
  1756. ///////////////////////////////////////////////////////////////////////////////
  1757. if (!IsEmptyString(szRealUser))
  1758. pszRealRcpt = SysStrDup(szRealUser);
  1759. ///////////////////////////////////////////////////////////////////////////////
  1760. //  Setup Rcpt string
  1761. ///////////////////////////////////////////////////////////////////////////////
  1762. if (SMTPS.pszRcpt != NULL)
  1763. SysFree(SMTPS.pszRcpt);
  1765. SMTPS.pszRcpt = SysStrDup(ppszFwdDomains[0]);
  1767. return (0);
  1769. }
  1771. static int SMTPHandleCmd_RCPT(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  1772. {
  1774. if ((SMTPS.iSMTPState != stateMail) && (SMTPS.iSMTPState != stateRcpt)) {
  1775. SMTPResetSession(SMTPS);
  1777. SMTPSendError(hBSock, SMTPS, "503 Bad sequence of commands");
  1779. ErrSetErrorCode(ERR_SMTP_BAD_CMD_SEQUENCE);
  1780. return (ERR_SMTP_BAD_CMD_SEQUENCE);
  1781. }
  1782. ///////////////////////////////////////////////////////////////////////////////
  1783. //  Check recipients count
  1784. ///////////////////////////////////////////////////////////////////////////////
  1785. if (SMTPS.iRcptCount >= SMTPS.pSMTPCfg->iMaxRcpts) {
  1786. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1787. SMTPLogSession(SMTPS, SMTPS.pszFrom, "", "RCPT=ENBR", 0);
  1789. SMTPSendError(hBSock, SMTPS, "552 Too many recipients");
  1791. ErrSetErrorCode(ERR_SMTP_TOO_MANY_RECIPIENTS);
  1792. return (ERR_SMTP_TOO_MANY_RECIPIENTS);
  1793. }
  1795. char **ppszFwdDomains = USmtpGetPathStrings(pszCommand);
  1797. if (ppszFwdDomains == NULL) {
  1798. ErrorPush();
  1800. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1801. SMTPLogSession(SMTPS, SMTPS.pszFrom, "", "RCPT=ESYNTAX", 0);
  1803. SMTPResetSession(SMTPS);
  1805. SMTPSendError(hBSock, SMTPS,
  1806.       "501 Syntax error in parameters or arguments: (%d)",
  1807.       ErrorFetch());
  1808. return (ErrorPop());
  1809. }
  1810. ///////////////////////////////////////////////////////////////////////////////
  1811. //  Check FORWARD PATH
  1812. ///////////////////////////////////////////////////////////////////////////////
  1813. char *pszRealRcpt = NULL;
  1814. char *pszSMTPError = NULL;
  1816. if (SMTPCheckForwardPath(ppszFwdDomains, SMTPS, pszRealRcpt,
  1817.  pszSMTPError) < 0) {
  1818. ErrorPush();
  1819. StrFreeStrings(ppszFwdDomains);
  1821. SMTPSendError(hBSock, SMTPS, "%s", pszSMTPError);
  1822. SysFree(pszSMTPError);
  1823. return (ErrorPop());
  1824. }
  1826. StrFreeStrings(ppszFwdDomains);
  1828. ///////////////////////////////////////////////////////////////////////////////
  1829. //  Log SMTP session
  1830. ///////////////////////////////////////////////////////////////////////////////
  1831. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  1832. SMTPLogSession(SMTPS, SMTPS.pszFrom, SMTPS.pszRcpt, "RCPT=OK", 0);
  1834. ///////////////////////////////////////////////////////////////////////////////
  1835. //  Write RCPT TO ( 5th[,...] row(s) of the smtp-mail file )
  1836. ///////////////////////////////////////////////////////////////////////////////
  1837. fprintf(SMTPS.pMsgFile, "RCPT TO:<%s> {ra=%s}rn", SMTPS.pszSendRcpt,
  1838. (pszRealRcpt != NULL) ? pszRealRcpt: SMTPS.pszSendRcpt);
  1840. if (pszRealRcpt != NULL)
  1841. SysFree(pszRealRcpt);
  1843. BSckSendString(hBSock, "250 OK", SMTPS.pSMTPCfg->iTimeout);
  1845. ++SMTPS.iRcptCount;
  1847. SMTPS.iSMTPState = stateRcpt;
  1849. return (0);
  1851. }
  1853. static int SMTPGetFilterFile(const char *pszFiltID, char *pszFileName, int iMaxName)
  1854. {
  1856. char szMailRoot[SYS_MAX_PATH] = "";
  1858. CfgGetRootPath(szMailRoot, sizeof(szMailRoot));
  1859. SysSNPrintf(pszFileName, iMaxName - 1, "%sfilters.%s.tab", szMailRoot, pszFiltID);
  1861. return (SysExistFile(pszFileName));
  1863. }
  1865. static int SMTPFilterMacroSubstitutes(char **ppszCmdTokens, SMTPSession & SMTPS)
  1866. {
  1868. for (int ii = 0; ppszCmdTokens[ii] != NULL; ii++) {
  1869. if (strcmp(ppszCmdTokens[ii], "@@FILE") == 0) {
  1870. char *pszNewValue = SysStrDup(SMTPS.szMsgFile);
  1872. if (pszNewValue == NULL)
  1873. return (ErrGetErrorCode());
  1875. SysFree(ppszCmdTokens[ii]);
  1877. ppszCmdTokens[ii] = pszNewValue;
  1878. } else if (strcmp(ppszCmdTokens[ii], "@@USERAUTH") == 0) {
  1879. char *pszNewValue = SysStrDup(IsEmptyString(SMTPS.szLogonUser) ?
  1880.       "-": SMTPS.szLogonUser);
  1882. if (pszNewValue == NULL)
  1883. return (ErrGetErrorCode());
  1885. SysFree(ppszCmdTokens[ii]);
  1887. ppszCmdTokens[ii] = pszNewValue;
  1888. } else if (strcmp(ppszCmdTokens[ii], "@@REMOTEADDR") == 0) {
  1889. char szIP[128] = "???.???.???.???";
  1890. char *pszNewValue = SysStrDup(SysInetNToA(SMTPS.PeerInfo, szIP));
  1892. if (pszNewValue == NULL)
  1893. return (ErrGetErrorCode());
  1895. SysFree(ppszCmdTokens[ii]);
  1897. ppszCmdTokens[ii] = pszNewValue;
  1898. } else if (strcmp(ppszCmdTokens[ii], "@@LOCALADDR") == 0) {
  1899. char szIP[128] = "???.???.???.???";
  1900. char *pszNewValue = SysStrDup(SysInetNToA(SMTPS.SockInfo, szIP));
  1902. if (pszNewValue == NULL)
  1903. return (ErrGetErrorCode());
  1905. SysFree(ppszCmdTokens[ii]);
  1907. ppszCmdTokens[ii] = pszNewValue;
  1908. }
  1909. }
  1911. return (0);
  1912. }
  1914. static char *SMTPGetFilterRejMessage(char const *pszMsgFilePath)
  1915. {
  1917. FILE *pFile;
  1918. char szRejFilePath[SYS_MAX_PATH] = "";
  1919. char szRejMsg[512] = "";
  1921. SysSNPrintf(szRejFilePath, sizeof(szRejFilePath) - 1, "%s.rej", pszMsgFilePath);
  1922. if ((pFile = fopen(szRejFilePath, "rb")) == NULL)
  1923. return NULL;
  1925. MscFGets(szRejMsg, sizeof(szRejMsg) - 1, pFile);
  1927. fclose(pFile);
  1928. SysRemove(szRejFilePath);
  1930. return (SysStrDup(szRejMsg));
  1932. }
  1934. static int SMTPLogFilter(SMTPSession & SMTPS, char const * const *ppszExec, int iExecResult,
  1935.  int iExitCode, char const *pszType, char const *pszInfo)
  1936. {
  1938. FilterLogInfo FLI;
  1940. FLI.pszSender = SMTPS.pszFrom != NULL ? SMTPS.pszFrom: "";
  1941. FLI.pszRecipient = SMTPS.pszRcpt != NULL ? (SMTPS.iRcptCount == 1 ? SMTPS.pszRcpt: "*"): "";
  1942. FLI.LocalAddr = SMTPS.SockInfo;
  1943. FLI.RemoteAddr = SMTPS.PeerInfo;
  1944. FLI.ppszExec = ppszExec;
  1945. FLI.iExecResult = iExecResult;
  1946. FLI.iExitCode = iExitCode;
  1947. FLI.pszType = pszType;
  1948. FLI.pszInfo = pszInfo != NULL ? pszInfo: "";
  1950. return (FilLogFilter(&FLI));
  1952. }
  1954. static int SMTPPreFilterExec(SMTPSession & SMTPS, FilterTokens *pToks, char **ppszPEError)
  1955. {
  1957. FilterExecCtx FCtx;
  1959. FCtx.pToks = pToks;
  1960. FCtx.pszAuthName = SMTPS.szLogonUser;
  1962. return (FilExecPreParse(&FCtx, ppszPEError));
  1964. }
  1966. static int SMTPRunFilters(SMTPSession & SMTPS, char const *pszFilterPath, char const *pszType,
  1967.   char *&pszError)
  1968. {
  1969. ///////////////////////////////////////////////////////////////////////////////
  1970. //  Share lock the filter file
  1971. ///////////////////////////////////////////////////////////////////////////////
  1972. char szResLock[SYS_MAX_PATH] = "";
  1973. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(pszFilterPath, szResLock,
  1974.   sizeof(szResLock)));
  1976. if (hResLock == INVALID_RLCK_HANDLE)
  1977. return (ErrGetErrorCode());
  1979. ///////////////////////////////////////////////////////////////////////////////
  1980. //  This should not happen but if it happens we let the message pass through
  1981. ///////////////////////////////////////////////////////////////////////////////
  1982. FILE *pFiltFile = fopen(pszFilterPath, "rt");
  1984. if (pFiltFile == NULL) {
  1985. RLckUnlockSH(hResLock);
  1986. return (0);
  1987. }
  1989. ///////////////////////////////////////////////////////////////////////////////
  1990. //  Filter this message
  1991. ///////////////////////////////////////////////////////////////////////////////
  1992. int iFieldsCount, iExitCode, iExitFlags, iExecResult;
  1993. char szFiltLine[1024] = "";
  1995. while (MscGetConfigLine(szFiltLine, sizeof(szFiltLine) - 1, pFiltFile) != NULL) {
  1996. char **ppszCmdTokens = StrGetTabLineStrings(szFiltLine);
  1998. if (ppszCmdTokens == NULL)
  1999. continue;
  2001. if ((iFieldsCount = StrStringsCount(ppszCmdTokens)) < 1) {
  2002. StrFreeStrings(ppszCmdTokens);
  2003. continue;
  2004. }
  2006. ///////////////////////////////////////////////////////////////////////////////
  2007. //  Perform pre-exec filtering (like exec exclude if authenticated, ...)
  2008. ///////////////////////////////////////////////////////////////////////////////
  2009. char *pszPEError = NULL;
  2010. FilterTokens Toks;
  2012. Toks.ppszCmdTokens = ppszCmdTokens;
  2013. Toks.iTokenCount = iFieldsCount;
  2015. if (SMTPPreFilterExec(SMTPS, &Toks, &pszPEError) < 0) {
  2016. if (bFilterLogEnabled)
  2017. SMTPLogFilter(SMTPS, Toks.ppszCmdTokens, -1,
  2018.       -1, pszType, pszPEError);
  2019. if (pszPEError != NULL)
  2020. SysFree(pszPEError);
  2021. StrFreeStrings(ppszCmdTokens);
  2022. continue;
  2023. }
  2025. ///////////////////////////////////////////////////////////////////////////////
  2026. //  Do filter line macro substitution
  2027. ///////////////////////////////////////////////////////////////////////////////
  2028. SMTPFilterMacroSubstitutes(Toks.ppszCmdTokens, SMTPS);
  2030. iExitCode = -1;
  2031. iExitFlags = 0;
  2032. iExecResult = SysExec(Toks.ppszCmdTokens[0], &Toks.ppszCmdTokens[0],
  2033.       iFilterTimeout, SYS_PRIORITY_NORMAL, &iExitCode);
  2035. ///////////////////////////////////////////////////////////////////////////////
  2036. //  Log filter execution, if enabled
  2037. ///////////////////////////////////////////////////////////////////////////////
  2038. if (bFilterLogEnabled)
  2039. SMTPLogFilter(SMTPS, Toks.ppszCmdTokens, iExecResult,
  2040.       iExitCode, pszType, NULL);
  2042. if (iExecResult == 0) {
  2043. SysLogMessage(LOG_LEV_MESSAGE,
  2044.       "SMTP filter run: Filter = "%s" Retcode = %dn",
  2045.       Toks.ppszCmdTokens[0], iExitCode);
  2047. iExitFlags = iExitCode & SMTP_FILTER_FL_MASK;
  2048. iExitCode &= ~SMTP_FILTER_FL_MASK;
  2050. if (iExitCode == SMTP_FILTER_REJECT_CODE) {
  2051. StrFreeStrings(ppszCmdTokens);
  2052. fclose(pFiltFile);
  2053. RLckUnlockSH(hResLock);
  2055. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  2056. SMTPLogSession(SMTPS, SMTPS.pszFrom, SMTPS.pszRcpt,
  2057.        "DATA=EFILTER", 0);
  2059. pszError = SMTPGetFilterRejMessage(SMTPS.szMsgFile);
  2061. ErrSetErrorCode(ERR_FILTERED_MESSAGE);
  2062. return (ERR_FILTERED_MESSAGE);
  2063. }
  2064. } else {
  2065. SysLogMessage(LOG_LEV_ERROR,
  2066.       "SMTP filter error (%d): Filter = "%s"n",
  2067.       iExecResult, Toks.ppszCmdTokens[0]);
  2068. }
  2070. StrFreeStrings(ppszCmdTokens);
  2072. if (iExitFlags & SMTP_FILTER_FL_BREAK)
  2073. break;
  2074. }
  2076. fclose(pFiltFile);
  2077. RLckUnlockSH(hResLock);
  2079. return (0);
  2080. }
  2082. static int SMTPFilterMessage(SMTPSession & SMTPS, const char *pszFiltID, char *&pszError)
  2083. {
  2085. int iReOpen = 0;
  2086. char szFilterFile[SYS_MAX_PATH] = "";
  2088. if (!SMTPGetFilterFile(pszFiltID, szFilterFile, sizeof(szFilterFile) - 1))
  2089. return (0);
  2091. if (SMTPS.pMsgFile != NULL) {
  2092. if (fflush(SMTPS.pMsgFile)) {
  2093. ErrSetErrorCode(ERR_FILE_WRITE, SMTPS.szMsgFile);
  2094. return (ERR_FILE_WRITE);
  2095. }
  2096. if (fclose(SMTPS.pMsgFile)) {
  2097. SMTPS.pMsgFile = NULL;
  2098. ErrSetErrorCode(ERR_FILE_WRITE, SMTPS.szMsgFile);
  2099. return (ERR_FILE_WRITE);
  2100. }
  2101. SMTPS.pMsgFile = NULL;
  2102. iReOpen++;
  2103. }
  2105. if (SMTPRunFilters(SMTPS, szFilterFile, pszFiltID, pszError) < 0)
  2106. return (ErrGetErrorCode());
  2108. if (iReOpen) {
  2109. if ((SMTPS.pMsgFile = fopen(SMTPS.szMsgFile, "r+b")) == NULL) {
  2110. ErrSetErrorCode(ERR_FILE_OPEN, SMTPS.szMsgFile);
  2111. return (ERR_FILE_OPEN);
  2112. }
  2113. fseek(SMTPS.pMsgFile, 0, SEEK_END);
  2114. }
  2116. return (0);
  2118. }
  2120. static int SMTPHandleCmd_DATA(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  2121. {
  2122. char *pszError;
  2124. if (SMTPS.iSMTPState != stateRcpt) {
  2125. SMTPResetSession(SMTPS);
  2127. SMTPSendError(hBSock, SMTPS, "503 Bad sequence of commands");
  2129. ErrSetErrorCode(ERR_SMTP_BAD_CMD_SEQUENCE);
  2130. return (ERR_SMTP_BAD_CMD_SEQUENCE);
  2131. }
  2133. ///////////////////////////////////////////////////////////////////////////////
  2134. //  Run the pre-DATA filter
  2135. ///////////////////////////////////////////////////////////////////////////////
  2136. pszError = NULL;
  2137. if (SMTPFilterMessage(SMTPS, SMTP_PRE_DATA_FILTER, pszError) < 0) {
  2138. ErrorPush();
  2139. SMTPResetSession(SMTPS);
  2141. if (pszError != NULL) {
  2142. SMTPSendError(hBSock, SMTPS, "%s", pszError);
  2143. SysFree(pszError);
  2144. } else
  2145. BSckSendString(hBSock, "554 Transaction failed",
  2146.        SMTPS.pSMTPCfg->iTimeout);
  2147. return (ErrorPop());
  2148. }
  2150. ///////////////////////////////////////////////////////////////////////////////
  2151. //  Write data begin marker
  2152. ///////////////////////////////////////////////////////////////////////////////
  2153. if (StrWriteCRLFString(SMTPS.pMsgFile, SPOOL_FILE_DATA_START) < 0) {
  2154. ErrorPush();
  2155. SMTPResetSession(SMTPS);
  2157. SMTPSendError(hBSock, SMTPS,
  2158.       "451 Requested action aborted: (%d) local error in processing",
  2159.       ErrorFetch());
  2160. return (ErrorPop());
  2161. }
  2163. BSckSendString(hBSock, "354 Start mail input; end with <CRLF>.<CRLF>",
  2164.        SMTPS.pSMTPCfg->iTimeout);
  2166. ///////////////////////////////////////////////////////////////////////////////
  2167. //  Write data
  2168. ///////////////////////////////////////////////////////////////////////////////
  2169. int iErrorCode = 0;
  2170. int iLineLength;
  2171. int iGotNL;
  2172. int iGotNLPrev = 1;
  2173. unsigned long ulMessageSize = 0;
  2174. unsigned long ulMaxMsgSize = SMTPS.ulMaxMsgSize;
  2175. char const *pszSmtpError = NULL;
  2176. char szBuffer[SMTP_MAX_LINE_SIZE + 4];
  2178. for (;;) {
  2179. if (BSckGetString
  2180.     (hBSock, szBuffer, sizeof(szBuffer) - 3, SMTPS.pSMTPCfg->iTimeout,
  2181.      &iLineLength, &iGotNL) == NULL) {
  2182. ErrorPush();
  2183. SMTPResetSession(SMTPS);
  2184. return (ErrorPop());
  2185. }
  2186. ///////////////////////////////////////////////////////////////////////////////
  2187. //  Check end of data condition
  2188. ///////////////////////////////////////////////////////////////////////////////
  2189. if (iGotNL && iGotNLPrev && (strcmp(szBuffer, ".") == 0))
  2190. break;
  2192. ///////////////////////////////////////////////////////////////////////////////
  2193. //  Correctly terminate the line
  2194. ///////////////////////////////////////////////////////////////////////////////
  2195. if (iGotNL)
  2196. memcpy(szBuffer + iLineLength, "rn", 3), iLineLength += 2;
  2198. if (iErrorCode == 0) {
  2199. ///////////////////////////////////////////////////////////////////////////////
  2200. //  Write data on disk
  2201. ///////////////////////////////////////////////////////////////////////////////
  2202. if (!fwrite(szBuffer, iLineLength, 1, SMTPS.pMsgFile)) {
  2203. ErrSetErrorCode(iErrorCode = ERR_FILE_WRITE, SMTPS.szMsgFile);
  2205. }
  2207. }
  2209. ulMessageSize += (unsigned long) iLineLength;
  2211. ///////////////////////////////////////////////////////////////////////////////
  2212. //  Check the message size
  2213. ///////////////////////////////////////////////////////////////////////////////
  2214. if ((ulMaxMsgSize != 0) && (ulMaxMsgSize < ulMessageSize)) {
  2215. pszSmtpError = "552 Message exceeds fixed maximum message size";
  2217. ErrSetErrorCode(iErrorCode = ERR_MESSAGE_SIZE);
  2218. }
  2220. if (SvrInShutdown()) {
  2221. SMTPResetSession(SMTPS);
  2223. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  2224. return (ERR_SERVER_SHUTDOWN);
  2225. }
  2227. iGotNLPrev = iGotNL;
  2228. }
  2230. ///////////////////////////////////////////////////////////////////////////////
  2231. //  Check fclose() return value coz data might be buffered and fail to flush
  2232. ///////////////////////////////////////////////////////////////////////////////
  2233. if (fclose(SMTPS.pMsgFile))
  2234. ErrSetErrorCode(iErrorCode = ERR_FILE_WRITE, SMTPS.szMsgFile);
  2236. SMTPS.pMsgFile = NULL;
  2238. if (iErrorCode == 0) {
  2239. ///////////////////////////////////////////////////////////////////////////////
  2240. //  Run the post-DATA filter
  2241. ///////////////////////////////////////////////////////////////////////////////
  2242. pszError = NULL;
  2243. if (SMTPFilterMessage(SMTPS, SMTP_POST_DATA_FILTER, pszError) < 0) {
  2244. ErrorPush();
  2245. SMTPResetSession(SMTPS);
  2247. if (pszError != NULL) {
  2248. SMTPSendError(hBSock, SMTPS, "%s", pszError);
  2249. SysFree(pszError);
  2250. } else
  2251. BSckSendString(hBSock, "554 Transaction failed",
  2252.        SMTPS.pSMTPCfg->iTimeout);
  2253. return (ErrorPop());
  2254. }
  2256. ///////////////////////////////////////////////////////////////////////////////
  2257. //  Transfer spool file
  2258. ///////////////////////////////////////////////////////////////////////////////
  2259. if (SMTPSubmitPackedFile(SMTPS, SMTPS.szMsgFile) < 0)
  2260. SMTPSendError(hBSock, SMTPS,
  2261.       "451 Requested action aborted: (%d) local error in processing",
  2262.       ErrGetErrorCode());
  2263. else {
  2264. ///////////////////////////////////////////////////////////////////////////////
  2265. //  Log the message receive
  2266. ///////////////////////////////////////////////////////////////////////////////
  2267. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  2268. SMTPLogSession(SMTPS, SMTPS.pszFrom, SMTPS.pszRcpt, "RECV=OK",
  2269.        ulMessageSize);
  2271. ///////////////////////////////////////////////////////////////////////////////
  2272. //  Send the ack only when everything is OK
  2273. ///////////////////////////////////////////////////////////////////////////////
  2274. BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout, "250 OK <%s>",
  2275. SMTPS.szMessageID);
  2277. }
  2278. } else {
  2279. ///////////////////////////////////////////////////////////////////////////////
  2280. //  Notify the client the error condition
  2281. ///////////////////////////////////////////////////////////////////////////////
  2282. if (pszSmtpError == NULL)
  2283. SMTPSendError(hBSock, SMTPS,
  2284.       "451 Requested action aborted: (%d) local error in processing",
  2285.       ErrGetErrorCode());
  2286. else
  2287. SMTPSendError(hBSock, SMTPS, "%s", pszSmtpError);
  2289. }
  2291. SMTPResetSession(SMTPS);
  2293. return (iErrorCode);
  2295. }
  2297. static int SMTPAddReceived(int iType, char const *pszAuth, char const *const *ppszMsgInfo,
  2298.    char const *pszMailFrom, char const *pszRcptTo,
  2299.    char const *pszMessageID, FILE * pMailFile)
  2300. {
  2302. char *pszReceived = USmtpGetReceived(iType, pszAuth, ppszMsgInfo, pszMailFrom, pszRcptTo,
  2303.      pszMessageID);
  2305. if (pszReceived == NULL)
  2306. return (ErrGetErrorCode());
  2308. ///////////////////////////////////////////////////////////////////////////////
  2309. //  Write "Received:" tag
  2310. ///////////////////////////////////////////////////////////////////////////////
  2311. fputs(pszReceived, pMailFile);
  2313. SysFree(pszReceived);
  2315. return (0);
  2317. }
  2319. static char *SMTPTrimRcptLine(char *pszRcptLn)
  2320. {
  2322. char *pszTrim = strchr(pszRcptLn, '>');
  2324. if (pszTrim != NULL)
  2325. pszTrim[1] = '';
  2327. return (pszRcptLn);
  2329. }
  2331. static int SMTPSubmitPackedFile(SMTPSession & SMTPS, const char *pszPkgFile)
  2332. {
  2334. FILE *pPkgFile = fopen(pszPkgFile, "rb");
  2336. if (pPkgFile == NULL) {
  2337. ErrSetErrorCode(ERR_FILE_OPEN);
  2338. return (ERR_FILE_OPEN);
  2339. }
  2341. char szSpoolLine[MAX_SPOOL_LINE] = "";
  2343. while ((MscGetString(pPkgFile, szSpoolLine, sizeof(szSpoolLine) - 1) != NULL) &&
  2344.        (strncmp(szSpoolLine, SPOOL_FILE_DATA_START, CStringSize(SPOOL_FILE_DATA_START)) !=
  2345. 0));
  2347. if (strncmp(szSpoolLine, SPOOL_FILE_DATA_START, CStringSize(SPOOL_FILE_DATA_START)) != 0) {
  2348. fclose(pPkgFile);
  2349. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  2350. return (ERR_INVALID_SPOOL_FILE);
  2351. }
  2352. ///////////////////////////////////////////////////////////////////////////////
  2353. //  Get the offset at which the message data begin and rewind the file
  2354. ///////////////////////////////////////////////////////////////////////////////
  2355. unsigned long ulMsgOffset = (unsigned long) ftell(pPkgFile);
  2357. rewind(pPkgFile);
  2359. ///////////////////////////////////////////////////////////////////////////////
  2360. //  Read SMTP message info ( 1st row of the smtp-mail file )
  2361. ///////////////////////////////////////////////////////////////////////////////
  2362. char **ppszMsgInfo = NULL;
  2364. if ((MscGetString(pPkgFile, szSpoolLine, sizeof(szSpoolLine) - 1) == NULL) ||
  2365.     ((ppszMsgInfo = StrTokenize(szSpoolLine, ";")) == NULL) ||
  2366.     (StrStringsCount(ppszMsgInfo) < smsgiMax)) {
  2367. if (ppszMsgInfo != NULL)
  2368. StrFreeStrings(ppszMsgInfo);
  2369. fclose(pPkgFile);
  2370. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  2371. return (ERR_INVALID_SPOOL_FILE);
  2372. }
  2373. ///////////////////////////////////////////////////////////////////////////////
  2374. //  Read SMTP domain ( 2nd row of the smtp-mail file )
  2375. ///////////////////////////////////////////////////////////////////////////////
  2376. char szSMTPDomain[256] = "";
  2378. if (MscGetString(pPkgFile, szSMTPDomain, sizeof(szSMTPDomain) - 1) == NULL) {
  2379. StrFreeStrings(ppszMsgInfo);
  2380. fclose(pPkgFile);
  2381. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  2382. return (ERR_INVALID_SPOOL_FILE);
  2383. }
  2384. ///////////////////////////////////////////////////////////////////////////////
  2385. //  Read message ID ( 3th row of the smtp-mail file )
  2386. ///////////////////////////////////////////////////////////////////////////////
  2387. char szMessageID[128] = "";
  2389. if (MscGetString(pPkgFile, szMessageID, sizeof(szMessageID) - 1) == NULL) {
  2390. StrFreeStrings(ppszMsgInfo);
  2391. fclose(pPkgFile);
  2392. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  2393. return (ERR_INVALID_SPOOL_FILE);
  2394. }
  2395. ///////////////////////////////////////////////////////////////////////////////
  2396. //  Read "MAIL FROM:" ( 4th row of the smtp-mail file )
  2397. ///////////////////////////////////////////////////////////////////////////////
  2398. char szMailFrom[MAX_SPOOL_LINE] = "";
  2400. if ((MscGetString(pPkgFile, szMailFrom, sizeof(szMailFrom) - 1) == NULL) ||
  2401.     (StrINComp(szMailFrom, MAIL_FROM_STR) != 0)) {
  2402. StrFreeStrings(ppszMsgInfo);
  2403. fclose(pPkgFile);
  2404. ErrSetErrorCode(ERR_INVALID_SPOOL_FILE);
  2405. return (ERR_INVALID_SPOOL_FILE);
  2406. }
  2407. ///////////////////////////////////////////////////////////////////////////////
  2408. //  Get the Received: header type to emit
  2409. ///////////////////////////////////////////////////////////////////////////////
  2410. int iReceivedType = SvrGetConfigInt("ReceivedHdrType", RECEIVED_TYPE_STD,
  2411.     SMTPS.hSvrConfig);
  2413. ///////////////////////////////////////////////////////////////////////////////
  2414. //  Read "RCPT TO:" ( 5th[,...] row(s) of the smtp-mail file )
  2415. ///////////////////////////////////////////////////////////////////////////////
  2416. while ((MscGetString(pPkgFile, szSpoolLine, sizeof(szSpoolLine) - 1) != NULL) &&
  2417.        (StrINComp(szSpoolLine, RCPT_TO_STR) == 0)) {
  2418. ///////////////////////////////////////////////////////////////////////////////
  2419. //  Cleanup the RCPT line from extra info
  2420. ///////////////////////////////////////////////////////////////////////////////
  2421. SMTPTrimRcptLine(szSpoolLine);
  2423. ///////////////////////////////////////////////////////////////////////////////
  2424. //  Get message handle
  2425. ///////////////////////////////////////////////////////////////////////////////
  2426. QMSG_HANDLE hMessage = QueCreateMessage(hSpoolQueue);
  2428. if (hMessage == INVALID_QMSG_HANDLE) {
  2429. ErrorPush();
  2430. StrFreeStrings(ppszMsgInfo);
  2431. fclose(pPkgFile);
  2432. return (ErrorPop());
  2433. }
  2435. char szQueueFilePath[SYS_MAX_PATH] = "";
  2437. QueGetFilePath(hSpoolQueue, hMessage, szQueueFilePath);
  2439. FILE *pSpoolFile = fopen(szQueueFilePath, "wb");
  2441. if (pSpoolFile == NULL) {
  2442. QueCleanupMessage(hSpoolQueue, hMessage);
  2443. QueCloseMessage(hSpoolQueue, hMessage);
  2444. StrFreeStrings(ppszMsgInfo);
  2445. fclose(pPkgFile);
  2446. ErrSetErrorCode(ERR_FILE_CREATE);
  2447. return (ERR_FILE_CREATE);
  2448. }
  2449. ///////////////////////////////////////////////////////////////////////////////
  2450. //  Write info line
  2451. ///////////////////////////////////////////////////////////////////////////////
  2452. USmtpWriteInfoLine(pSpoolFile, ppszMsgInfo[smsgiClientAddr],
  2453.    ppszMsgInfo[smsgiServerAddr], ppszMsgInfo[smsgiTime]);
  2455. ///////////////////////////////////////////////////////////////////////////////
  2456. //  Write SMTP domain
  2457. ///////////////////////////////////////////////////////////////////////////////
  2458. fprintf(pSpoolFile, "%srn", szSMTPDomain);
  2460. ///////////////////////////////////////////////////////////////////////////////
  2461. //  Write message ID
  2462. ///////////////////////////////////////////////////////////////////////////////
  2463. fprintf(pSpoolFile, "%srn", szMessageID);
  2465. ///////////////////////////////////////////////////////////////////////////////
  2466. //  Write "MAIL FROM:"
  2467. ///////////////////////////////////////////////////////////////////////////////
  2468. fprintf(pSpoolFile, "%srn", szMailFrom);
  2470. ///////////////////////////////////////////////////////////////////////////////
  2471. //  Write "RCPT TO:"
  2472. ///////////////////////////////////////////////////////////////////////////////
  2473. fprintf(pSpoolFile, "%srn", szSpoolLine);
  2475. ///////////////////////////////////////////////////////////////////////////////
  2476. //  Write SPOOL_FILE_DATA_START
  2477. ///////////////////////////////////////////////////////////////////////////////
  2478. fprintf(pSpoolFile, "%srn", SPOOL_FILE_DATA_START);
  2480. ///////////////////////////////////////////////////////////////////////////////
  2481. //  Write "X-AuthUser:" tag
  2482. ///////////////////////////////////////////////////////////////////////////////
  2483. if (!IsEmptyString(SMTPS.szLogonUser) && !(SMTPS.ulFlags & SMTPF_NOEMIT_AUTH))
  2484. fprintf(pSpoolFile, "X-AuthUser: %srn", SMTPS.szLogonUser);
  2486. ///////////////////////////////////////////////////////////////////////////////
  2487. //  Write "Received:" tag
  2488. ///////////////////////////////////////////////////////////////////////////////
  2489. SMTPAddReceived(iReceivedType,
  2490. IsEmptyString(SMTPS.szLogonUser) ? NULL : SMTPS.szLogonUser,
  2491. ppszMsgInfo, szMailFrom, szSpoolLine, szMessageID, pSpoolFile);
  2493. ///////////////////////////////////////////////////////////////////////////////
  2494. //  Write mail data, saving and restoring the current file pointer
  2495. ///////////////////////////////////////////////////////////////////////////////
  2496. unsigned long ulCurrOffset = (unsigned long) ftell(pPkgFile);
  2498. if (MscCopyFile(pSpoolFile, pPkgFile, ulMsgOffset, (unsigned long) -1) < 0) {
  2499. ErrorPush();
  2500. fclose(pSpoolFile);
  2501. QueCleanupMessage(hSpoolQueue, hMessage);
  2502. QueCloseMessage(hSpoolQueue, hMessage);
  2503. StrFreeStrings(ppszMsgInfo);
  2504. fclose(pPkgFile);
  2505. return (ErrorPop());
  2506. }
  2508. if (SysFileSync(pSpoolFile) < 0) {
  2509. ErrorPush();
  2510. fclose(pSpoolFile);
  2511. QueCleanupMessage(hSpoolQueue, hMessage);
  2512. QueCloseMessage(hSpoolQueue, hMessage);
  2513. StrFreeStrings(ppszMsgInfo);
  2514. fclose(pPkgFile);
  2515. return (ErrorPop());
  2516. }
  2518. if (fclose(pSpoolFile)) {
  2519. QueCleanupMessage(hSpoolQueue, hMessage);
  2520. QueCloseMessage(hSpoolQueue, hMessage);
  2521. StrFreeStrings(ppszMsgInfo);
  2522. fclose(pPkgFile);
  2523. ErrSetErrorCode(ERR_FILE_WRITE, szQueueFilePath);
  2524. return (ERR_FILE_WRITE);
  2525. }
  2527. fseek(pPkgFile, ulCurrOffset, SEEK_SET);
  2529. ///////////////////////////////////////////////////////////////////////////////
  2530. //  Transfer file to the spool
  2531. ///////////////////////////////////////////////////////////////////////////////
  2532. if (QueCommitMessage(hSpoolQueue, hMessage) < 0) {
  2533. ErrorPush();
  2534. QueCleanupMessage(hSpoolQueue, hMessage);
  2535. QueCloseMessage(hSpoolQueue, hMessage);
  2536. StrFreeStrings(ppszMsgInfo);
  2537. fclose(pPkgFile);
  2538. return (ErrorPop());
  2539. }
  2540. }
  2542. StrFreeStrings(ppszMsgInfo);
  2543. fclose(pPkgFile);
  2545. return (0);
  2547. }
  2549. static int SMTPHandleCmd_HELO(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  2550. {
  2552. if ((SMTPS.iSMTPState != stateInit) && (SMTPS.iSMTPState != stateHelo)) {
  2553. SMTPResetSession(SMTPS);
  2555. SMTPSendError(hBSock, SMTPS, "503 Bad sequence of commands");
  2557. ErrSetErrorCode(ERR_SMTP_BAD_CMD_SEQUENCE);
  2558. return (ERR_SMTP_BAD_CMD_SEQUENCE);
  2559. }
  2561. char **ppszTokens = StrTokenize(pszCommand, " ");
  2563. if ((ppszTokens == NULL) || (StrStringsCount(ppszTokens) != 2)) {
  2564. if (ppszTokens != NULL)
  2565. StrFreeStrings(ppszTokens);
  2567. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  2568. return (-1);
  2569. }
  2571. StrSNCpy(SMTPS.szClientDomain, ppszTokens[1]);
  2573. StrFreeStrings(ppszTokens);
  2575. char *pszDomain = SvrGetConfigVar(SMTPS.hSvrConfig, "RootDomain");
  2577. if (pszDomain == NULL) {
  2578. SMTPSendError(hBSock, SMTPS,
  2579.       "451 Requested action aborted: (%d) local error in processing",
  2580.       ERR_NO_ROOT_DOMAIN_VAR);
  2582. ErrSetErrorCode(ERR_NO_ROOT_DOMAIN_VAR);
  2583. return (ERR_NO_ROOT_DOMAIN_VAR);
  2584. }
  2586. BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout, "250 %s", pszDomain);
  2588. SysFree(pszDomain);
  2590. SMTPS.iSMTPState = stateHelo;
  2592. return (0);
  2594. }
  2596. static int SMTPHandleCmd_EHLO(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  2597. {
  2599. if ((SMTPS.iSMTPState != stateInit) && (SMTPS.iSMTPState != stateHelo)) {
  2600. SMTPResetSession(SMTPS);
  2602. SMTPSendError(hBSock, SMTPS, "503 Bad sequence of commands");
  2604. ErrSetErrorCode(ERR_SMTP_BAD_CMD_SEQUENCE);
  2605. return (ERR_SMTP_BAD_CMD_SEQUENCE);
  2606. }
  2608. char **ppszTokens = StrTokenize(pszCommand, " ");
  2610. if ((ppszTokens == NULL) || (StrStringsCount(ppszTokens) != 2)) {
  2611. if (ppszTokens != NULL)
  2612. StrFreeStrings(ppszTokens);
  2614. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  2615. return (-1);
  2616. }
  2618. StrSNCpy(SMTPS.szClientDomain, ppszTokens[1]);
  2620. StrFreeStrings(ppszTokens);
  2622. ///////////////////////////////////////////////////////////////////////////////
  2623. //  Create response file
  2624. ///////////////////////////////////////////////////////////////////////////////
  2625. char szRespFile[SYS_MAX_PATH] = "";
  2627. SysGetTmpFile(szRespFile);
  2629. FILE *pRespFile = fopen(szRespFile, "w+b");
  2631. if (pRespFile == NULL) {
  2632. CheckRemoveFile(szRespFile);
  2634. SMTPSendError(hBSock, SMTPS,
  2635.       "451 Requested action aborted: (%d) local error in processing",
  2636.       ERR_FILE_CREATE);
  2638. ErrSetErrorCode(ERR_FILE_CREATE);
  2639. return (ERR_FILE_CREATE);
  2640. }
  2641. ///////////////////////////////////////////////////////////////////////////////
  2642. //  Get root domain ( "RootDomain" )
  2643. ///////////////////////////////////////////////////////////////////////////////
  2644. char *pszDomain = SvrGetConfigVar(SMTPS.hSvrConfig, "RootDomain");
  2646. if (pszDomain == NULL) {
  2647. fclose(pRespFile);
  2648. SysRemove(szRespFile);
  2650. SMTPSendError(hBSock, SMTPS,
  2651.       "451 Requested action aborted: (%d) local error in processing",
  2652.       ERR_NO_ROOT_DOMAIN_VAR);
  2654. ErrSetErrorCode(ERR_NO_ROOT_DOMAIN_VAR);
  2655. return (ERR_NO_ROOT_DOMAIN_VAR);
  2656. }
  2657. ///////////////////////////////////////////////////////////////////////////////
  2658. //  Build EHLO response file ( domain + auths )
  2659. ///////////////////////////////////////////////////////////////////////////////
  2660. fprintf(pRespFile, "250 %srn", pszDomain);
  2662. SysFree(pszDomain);
  2664. ///////////////////////////////////////////////////////////////////////////////
  2665. //  Emit extended SMTP command and internal auths
  2666. ///////////////////////////////////////////////////////////////////////////////
  2667. fprintf(pRespFile,
  2668. "250 VRFYrn"
  2669. "250 ETRNrn"
  2670. "250 8BITMIMErn" "250 PIPELININGrn" "250 AUTH LOGIN PLAIN CRAM-MD5");
  2672. ///////////////////////////////////////////////////////////////////////////////
  2673. //  Emit external authentication methods
  2674. ///////////////////////////////////////////////////////////////////////////////
  2675. SMTPListExtAuths(pRespFile, SMTPS);
  2677. fprintf(pRespFile, "rn");
  2679. ///////////////////////////////////////////////////////////////////////////////
  2680. //  Emit maximum message size ( if set )
  2681. ///////////////////////////////////////////////////////////////////////////////
  2682. if (SMTPS.ulMaxMsgSize != 0)
  2683. fprintf(pRespFile, "250 SIZE %lurn", SMTPS.ulMaxMsgSize);
  2684. else
  2685. fprintf(pRespFile, "250 SIZErn");
  2687. ///////////////////////////////////////////////////////////////////////////////
  2688. //  Send EHLO response file
  2689. ///////////////////////////////////////////////////////////////////////////////
  2690. if (SMTPSendMultilineResponse(hBSock, SMTPS.pSMTPCfg->iTimeout, pRespFile) < 0) {
  2691. ErrorPush();
  2692. fclose(pRespFile);
  2693. SysRemove(szRespFile);
  2695. SMTPSendError(hBSock, SMTPS,
  2696.       "451 Requested action aborted: (%d) local error in processing",
  2697.       ErrorFetch());
  2699. return (ErrorPop());
  2700. }
  2702. fclose(pRespFile);
  2703. SysRemove(szRespFile);
  2705. SMTPS.iSMTPState = stateHelo;
  2707. return (0);
  2709. }
  2711. static int SMTPListExtAuths(FILE * pRespFile, SMTPSession & SMTPS)
  2712. {
  2714. char szExtAuthFilePath[SYS_MAX_PATH] = "";
  2716. SMTPGetExtAuthFilePath(szExtAuthFilePath, sizeof(szExtAuthFilePath));
  2718. FILE *pExtAuthFile = fopen(szExtAuthFilePath, "rt");
  2720. if (pExtAuthFile != NULL) {
  2721. char szExtAuthLine[SVR_SMTP_EXTAUTH_LINE_MAX] = "";
  2723. while (MscGetConfigLine(szExtAuthLine, sizeof(szExtAuthLine) - 1, pExtAuthFile) !=
  2724.        NULL) {
  2725. char **ppszStrings = StrGetTabLineStrings(szExtAuthLine);
  2727. if (ppszStrings == NULL)
  2728. continue;
  2730. if (StrStringsCount(ppszStrings) > 0)
  2731. fprintf(pRespFile, " %s", ppszStrings[0]);
  2733. StrFreeStrings(ppszStrings);
  2734. }
  2736. fclose(pExtAuthFile);
  2737. }
  2739. return (0);
  2741. }
  2743. static int SMTPExternalAuthSubstitute(char **ppszAuthTokens, char const *pszChallenge,
  2744.       char const *pszDigest, char const *pszSecretsFile)
  2745. {
  2747. for (int ii = 0; ppszAuthTokens[ii] != NULL; ii++) {
  2748. if (strcmp(ppszAuthTokens[ii], "@@FSECRT") == 0) {
  2749. char *pszNewValue = SysStrDup(pszSecretsFile);
  2751. if (pszNewValue == NULL)
  2752. return (ErrGetErrorCode());
  2754. SysFree(ppszAuthTokens[ii]);
  2756. ppszAuthTokens[ii] = pszNewValue;
  2757. } else if (strcmp(ppszAuthTokens[ii], "@@CHALL") == 0) {
  2758. char *pszNewValue = SysStrDup(pszChallenge);
  2760. if (pszNewValue == NULL)
  2761. return (ErrGetErrorCode());
  2763. SysFree(ppszAuthTokens[ii]);
  2765. ppszAuthTokens[ii] = pszNewValue;
  2766. } else if (strcmp(ppszAuthTokens[ii], "@@DGEST") == 0) {
  2767. char *pszNewValue = SysStrDup(pszDigest);
  2769. if (pszNewValue == NULL)
  2770. return (ErrGetErrorCode());
  2772. SysFree(ppszAuthTokens[ii]);
  2774. ppszAuthTokens[ii] = pszNewValue;
  2775. }
  2776. }
  2778. return (0);
  2780. }
  2782. static int SMTPCreateSecretsFile(char const *pszSecretsFile)
  2783. {
  2785. char szAuthFilePath[SYS_MAX_PATH] = "";
  2787. SMTPGetAuthFilePath(szAuthFilePath, sizeof(szAuthFilePath));
  2789. FILE *pAuthFile = fopen(szAuthFilePath, "rt");
  2791. if (pAuthFile == NULL) {
  2792. ErrSetErrorCode(ERR_FILE_OPEN, szAuthFilePath);
  2793. return (ERR_FILE_OPEN);
  2794. }
  2796. FILE *pSecretFile = fopen(pszSecretsFile, "wt");
  2798. if (pSecretFile == NULL) {
  2799. fclose(pAuthFile);
  2801. ErrSetErrorCode(ERR_FILE_CREATE, pszSecretsFile);
  2802. return (ERR_FILE_CREATE);
  2803. }
  2805. char szAuthLine[SVR_SMTPAUTH_LINE_MAX] = "";
  2807. while (MscGetConfigLine(szAuthLine, sizeof(szAuthLine) - 1, pAuthFile) != NULL) {
  2808. char **ppszStrings = StrGetTabLineStrings(szAuthLine);
  2810. if (ppszStrings == NULL)
  2811. continue;
  2813. int iFieldsCount = StrStringsCount(ppszStrings);
  2815. if (iFieldsCount >= smtpaMax)
  2816. fprintf(pSecretFile, "%s:%sn", ppszStrings[smtpaUsername],
  2817. ppszStrings[smtpaPassword]);
  2819. StrFreeStrings(ppszStrings);
  2820. }
  2822. fclose(pSecretFile);
  2823. fclose(pAuthFile);
  2825. return (0);
  2827. }
  2829. static int SMTPExternalAuthenticate(BSOCK_HANDLE hBSock, SMTPSession & SMTPS,
  2830.     char **ppszAuthTokens)
  2831. {
  2832. ///////////////////////////////////////////////////////////////////////////////
  2833. //  Emit encoded ( base64 ) challenge ( param1 + ':' + timestamp )
  2834. //  and get client response
  2835. ///////////////////////////////////////////////////////////////////////////////
  2836. unsigned int uEnc64Length = 0;
  2837. char szChallenge[1024] = "";
  2838. char szDigest[1024] = "";
  2840. SysSNPrintf(szDigest, sizeof(szDigest) - 1, "%s:%s", ppszAuthTokens[1],
  2841.     SMTPS.szTimeStamp);
  2842. encode64(szDigest, strlen(szDigest), szChallenge, sizeof(szChallenge) - 1, &uEnc64Length);
  2844. if ((BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout, "334 %s", szChallenge) < 0) ||
  2845.     (BSckGetString(hBSock, szChallenge, sizeof(szChallenge) - 1, SMTPS.pSMTPCfg->iTimeout)
  2846.      == NULL))
  2847. return (ErrGetErrorCode());
  2849. ///////////////////////////////////////////////////////////////////////////////
  2850. //  Decode ( base64 ) client response
  2851. ///////////////////////////////////////////////////////////////////////////////
  2852. unsigned int uDec64Length = 0;
  2854. if (decode64(szChallenge, strlen(szChallenge), szDigest, &uDec64Length) != 0) {
  2855. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  2857. ErrSetErrorCode(ERR_BAD_SMTP_CMD_SYNTAX);
  2858. return (ERR_BAD_SMTP_CMD_SYNTAX);
  2859. }
  2861. SysSNPrintf(szChallenge, sizeof(szChallenge) - 1, "%s:%s", ppszAuthTokens[1],
  2862.     SMTPS.szTimeStamp);
  2864. ///////////////////////////////////////////////////////////////////////////////
  2865. //  Create secrets file ( username + ':' + password )
  2866. ///////////////////////////////////////////////////////////////////////////////
  2867. char szSecretsFile[SYS_MAX_PATH] = "";
  2869. SysGetTmpFile(szSecretsFile);
  2871. if (SMTPCreateSecretsFile(szSecretsFile) < 0) {
  2872. ErrorPush();
  2873. CheckRemoveFile(szSecretsFile);
  2874. return (ErrorPop());
  2875. }
  2876. ///////////////////////////////////////////////////////////////////////////////
  2877. //  Do macro substitution
  2878. ///////////////////////////////////////////////////////////////////////////////
  2879. SMTPExternalAuthSubstitute(ppszAuthTokens, szChallenge, szDigest, szSecretsFile);
  2881. ///////////////////////////////////////////////////////////////////////////////
  2882. //  Call external program to compute the response
  2883. ///////////////////////////////////////////////////////////////////////////////
  2884. int iExitCode = -1;
  2886. if (SysExec(ppszAuthTokens[2], &ppszAuthTokens[2], SVR_SMTP_EXTAUTH_TIMEOUT,
  2887.     SVR_SMTP_EXTAUTH_PRIORITY, &iExitCode) < 0) {
  2888. ErrorPush();
  2889. SysRemove(szSecretsFile);
  2891. SMTPSendError(hBSock, SMTPS,
  2892.       "451 Requested action aborted: (%d) local error in processing",
  2893.       ErrorFetch());
  2895. return (ErrorPop());
  2896. }
  2898. if (iExitCode != SVR_SMTP_EXTAUTH_SUCCESS) {
  2899. SysRemove(szSecretsFile);
  2901. SMTPSendError(hBSock, SMTPS, "503 Authentication failed");
  2903. ErrSetErrorCode(ERR_BAD_EXTRNPRG_EXITCODE);
  2904. return (ERR_BAD_EXTRNPRG_EXITCODE);
  2905. }
  2906. ///////////////////////////////////////////////////////////////////////////////
  2907. //  Load response file containing the matching secret
  2908. ///////////////////////////////////////////////////////////////////////////////
  2909. unsigned int uRespSize = 0;
  2910. char *pMatchSecret = (char *) MscLoadFile(szSecretsFile, uRespSize);
  2912. CheckRemoveFile(szSecretsFile);
  2914. if (pMatchSecret == NULL) {
  2915. ErrorPush();
  2917. SMTPSendError(hBSock, SMTPS,
  2918.       "451 Requested action aborted: (%d) local error in processing",
  2919.       ErrorFetch());
  2921. return (ErrorPop());
  2922. }
  2924. while ((uRespSize > 0) &&
  2925.        ((pMatchSecret[uRespSize - 1] == 'r') || (pMatchSecret[uRespSize - 1] == 'n')))
  2926. --uRespSize;
  2928. pMatchSecret[uRespSize] = '';
  2930. ///////////////////////////////////////////////////////////////////////////////
  2931. //  Try to extract username and password tokens ( username + ':' + password )
  2932. ///////////////////////////////////////////////////////////////////////////////
  2933. char **ppszTokens = StrTokenize(pMatchSecret, ":");
  2935. SysFree(pMatchSecret);
  2937. if (StrStringsCount(ppszTokens) != 2) {
  2938. StrFreeStrings(ppszTokens);
  2940. SMTPSendError(hBSock, SMTPS,
  2941.       "451 Requested action aborted: (%d) local error in processing",
  2942.       ERR_BAD_SMTP_EXTAUTH_RESPONSE_FILE);
  2944. ErrSetErrorCode(ERR_BAD_SMTP_EXTAUTH_RESPONSE_FILE);
  2945. return (ERR_BAD_SMTP_EXTAUTH_RESPONSE_FILE);
  2946. }
  2947. ///////////////////////////////////////////////////////////////////////////////
  2948. //  Lookup smtp auth file
  2949. ///////////////////////////////////////////////////////////////////////////////
  2950. if (SMTPTryApplyUsrPwdAuth(SMTPS, ppszTokens[0], ppszTokens[1]) < 0) {
  2951. ErrorPush();
  2952. StrFreeStrings(ppszTokens);
  2954. SMTPSendError(hBSock, SMTPS, "503 Authentication failed");
  2956. return (ErrorPop());
  2957. }
  2958. ///////////////////////////////////////////////////////////////////////////////
  2959. //  Set the logon user
  2960. ///////////////////////////////////////////////////////////////////////////////
  2961. StrSNCpy(SMTPS.szLogonUser, ppszTokens[0]);
  2963. StrFreeStrings(ppszTokens);
  2965. SMTPS.ulFlags |= SMTPF_AUTHENTICATED;
  2966. SMTPS.iSMTPState = stateAuthenticated;
  2968. BSckSendString(hBSock, "235 Authentication successful", SMTPS.pSMTPCfg->iTimeout);
  2970. return (0);
  2972. }
  2974. static int SMTPDoAuthExternal(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszAuthType)
  2975. {
  2977. char szExtAuthFilePath[SYS_MAX_PATH] = "";
  2979. SMTPGetExtAuthFilePath(szExtAuthFilePath, sizeof(szExtAuthFilePath));
  2981. FILE *pExtAuthFile = fopen(szExtAuthFilePath, "rt");
  2983. if (pExtAuthFile == NULL) {
  2984. ErrSetErrorCode(ERR_FILE_OPEN, szExtAuthFilePath);
  2985. return (ERR_FILE_OPEN);
  2986. }
  2988. char szExtAuthLine[SVR_SMTP_EXTAUTH_LINE_MAX] = "";
  2990. while (MscGetConfigLine(szExtAuthLine, sizeof(szExtAuthLine) - 1, pExtAuthFile) != NULL) {
  2991. char **ppszStrings = StrGetTabLineStrings(szExtAuthLine);
  2993. if (ppszStrings == NULL)
  2994. continue;
  2996. int iFieldsCount = StrStringsCount(ppszStrings);
  2998. if ((iFieldsCount > 5) && (stricmp(ppszStrings[0], pszAuthType) == 0)) {
  2999. fclose(pExtAuthFile);
  3001. int iAuthResult = SMTPExternalAuthenticate(hBSock, SMTPS, ppszStrings);
  3003. StrFreeStrings(ppszStrings);
  3005. return (iAuthResult);
  3006. }
  3008. StrFreeStrings(ppszStrings);
  3009. }
  3011. fclose(pExtAuthFile);
  3013. SMTPSendError(hBSock, SMTPS, "504 Unknown authentication");
  3015. ErrSetErrorCode(ERR_UNKNOWN_SMTP_AUTH, pszAuthType);
  3016. return (ERR_UNKNOWN_SMTP_AUTH);
  3018. }
  3020. static int SMTPDoAuthPlain(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszAuthParam)
  3021. {
  3022. ///////////////////////////////////////////////////////////////////////////////
  3023. //  Parameter validation
  3024. ///////////////////////////////////////////////////////////////////////////////
  3025. if ((pszAuthParam == NULL) || (strlen(pszAuthParam) == 0)) {
  3026. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3028. ErrSetErrorCode(ERR_BAD_SMTP_CMD_SYNTAX);
  3029. return (ERR_BAD_SMTP_CMD_SYNTAX);
  3030. }
  3031. ///////////////////////////////////////////////////////////////////////////////
  3032. //  Decode ( base64 ) auth parameter
  3033. ///////////////////////////////////////////////////////////////////////////////
  3034. unsigned int uDec64Length = 0;
  3035. char szClientAuth[PLAIN_AUTH_PARAM_SIZE] = "";
  3037. ZeroData(szClientAuth);
  3039. if (decode64(pszAuthParam, strlen(pszAuthParam), szClientAuth, &uDec64Length) != 0) {
  3040. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3042. ErrSetErrorCode(ERR_BAD_SMTP_CMD_SYNTAX);
  3043. return (ERR_BAD_SMTP_CMD_SYNTAX);
  3044. }
  3045. ///////////////////////////////////////////////////////////////////////////////
  3046. //  Extract plain auth params ( unused + 0 + username + 0 + password )
  3047. ///////////////////////////////////////////////////////////////////////////////
  3048. char *pszUsername = szClientAuth + strlen(szClientAuth) + 1;
  3049. char *pszPassword = pszUsername + strlen(pszUsername) + 1;
  3051. ///////////////////////////////////////////////////////////////////////////////
  3052. //  Validate client response
  3053. ///////////////////////////////////////////////////////////////////////////////
  3054. if ((SMTPTryApplyLocalAuth(SMTPS, pszUsername, pszPassword) < 0) &&
  3055.     (SMTPTryApplyUsrPwdAuth(SMTPS, pszUsername, pszPassword) < 0)) {
  3056. ErrorPush();
  3058. SMTPSendError(hBSock, SMTPS, "503 Authentication failed");
  3060. return (ErrorPop());
  3061. }
  3062. ///////////////////////////////////////////////////////////////////////////////
  3063. //  Set the logon user
  3064. ///////////////////////////////////////////////////////////////////////////////
  3065. StrSNCpy(SMTPS.szLogonUser, pszUsername);
  3067. SMTPS.ulFlags |= SMTPF_AUTHENTICATED;
  3068. SMTPS.iSMTPState = stateAuthenticated;
  3070. BSckSendString(hBSock, "235 Authentication successful", SMTPS.pSMTPCfg->iTimeout);
  3072. return (0);
  3074. }
  3076. static int SMTPDoAuthLogin(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszAuthParam)
  3077. {
  3078. ///////////////////////////////////////////////////////////////////////////////
  3079. //  Emit encoded64 username request
  3080. ///////////////////////////////////////////////////////////////////////////////
  3081. unsigned int uEnc64Length = 0;
  3082. char szUsername[512] = "";
  3084. encode64(LOGIN_AUTH_USERNAME, strlen(LOGIN_AUTH_USERNAME), szUsername,
  3085.  sizeof(szUsername), &uEnc64Length);
  3087. if ((BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout, "334 %s", szUsername) < 0) ||
  3088.     (BSckGetString(hBSock, szUsername, sizeof(szUsername) - 1, SMTPS.pSMTPCfg->iTimeout)
  3089.      == NULL))
  3090. return (ErrGetErrorCode());
  3092. ///////////////////////////////////////////////////////////////////////////////
  3093. //  Emit encoded64 password request
  3094. ///////////////////////////////////////////////////////////////////////////////
  3095. char szPassword[512] = "";
  3097. encode64(LOGIN_AUTH_PASSWORD, strlen(LOGIN_AUTH_PASSWORD), szPassword,
  3098.  sizeof(szPassword), &uEnc64Length);
  3100. if ((BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout, "334 %s", szPassword) < 0) ||
  3101.     (BSckGetString(hBSock, szPassword, sizeof(szPassword) - 1, SMTPS.pSMTPCfg->iTimeout)
  3102.      == NULL))
  3103. return (ErrGetErrorCode());
  3105. ///////////////////////////////////////////////////////////////////////////////
  3106. //  Decode ( base64 ) username
  3107. ///////////////////////////////////////////////////////////////////////////////
  3108. unsigned int uDec64Length = 0;
  3109. char szDecodeBuffer[512] = "";
  3111. if (decode64(szUsername, strlen(szUsername), szDecodeBuffer, &uDec64Length) != 0) {
  3112. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3114. ErrSetErrorCode(ERR_BAD_SMTP_CMD_SYNTAX);
  3115. return (ERR_BAD_SMTP_CMD_SYNTAX);
  3116. }
  3118. StrSNCpy(szUsername, szDecodeBuffer);
  3120. ///////////////////////////////////////////////////////////////////////////////
  3121. //  Decode ( base64 ) password
  3122. ///////////////////////////////////////////////////////////////////////////////
  3123. if (decode64(szPassword, strlen(szPassword), szDecodeBuffer, &uDec64Length) != 0) {
  3124. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3126. ErrSetErrorCode(ERR_BAD_SMTP_CMD_SYNTAX);
  3127. return (ERR_BAD_SMTP_CMD_SYNTAX);
  3128. }
  3130. StrSNCpy(szPassword, szDecodeBuffer);
  3132. ///////////////////////////////////////////////////////////////////////////////
  3133. //  Validate client response
  3134. ///////////////////////////////////////////////////////////////////////////////
  3135. if ((SMTPTryApplyLocalAuth(SMTPS, szUsername, szPassword) < 0) &&
  3136.     (SMTPTryApplyUsrPwdAuth(SMTPS, szUsername, szPassword) < 0)) {
  3137. ErrorPush();
  3139. SMTPSendError(hBSock, SMTPS, "503 Authentication failed");
  3141. return (ErrorPop());
  3142. }
  3143. ///////////////////////////////////////////////////////////////////////////////
  3144. //  Set the logon user
  3145. ///////////////////////////////////////////////////////////////////////////////
  3146. StrSNCpy(SMTPS.szLogonUser, szUsername);
  3148. SMTPS.ulFlags |= SMTPF_AUTHENTICATED;
  3149. SMTPS.iSMTPState = stateAuthenticated;
  3151. BSckSendString(hBSock, "235 Authentication successful", SMTPS.pSMTPCfg->iTimeout);
  3153. return (0);
  3155. }
  3157. static char *SMTPGetAuthFilePath(char *pszFilePath, int iMaxPath)
  3158. {
  3160. CfgGetRootPath(pszFilePath, iMaxPath);
  3162. StrNCat(pszFilePath, SVR_SMTP_AUTH_FILE, iMaxPath);
  3164. return (pszFilePath);
  3166. }
  3168. static char *SMTPGetExtAuthFilePath(char *pszFilePath, int iMaxPath)
  3169. {
  3171. CfgGetRootPath(pszFilePath, iMaxPath);
  3173. StrNCat(pszFilePath, SVR_SMTP_EXTAUTH_FILE, iMaxPath);
  3175. return (pszFilePath);
  3177. }
  3179. static int SMTPTryApplyLocalAuth(SMTPSession & SMTPS, char const *pszUsername,
  3180.  char const *pszPassword)
  3181. {
  3182. ///////////////////////////////////////////////////////////////////////////////
  3183. //  First try to lookup  mailusers.tab
  3184. ///////////////////////////////////////////////////////////////////////////////
  3185. char szAccountUser[MAX_ADDR_NAME] = "";
  3186. char szAccountDomain[MAX_HOST_NAME] = "";
  3188. if (StrSplitString(pszUsername, POP3_USER_SPLITTERS, szAccountUser, sizeof(szAccountUser),
  3189.    szAccountDomain, sizeof(szAccountDomain)) < 0)
  3190. return (ErrGetErrorCode());
  3192. UserInfo *pUI = UsrGetUserByName(szAccountDomain, szAccountUser);
  3194. if (pUI != NULL) {
  3195. if (strcmp(pUI->pszPassword, pszPassword) == 0) {
  3196. ///////////////////////////////////////////////////////////////////////////////
  3197. //  Apply user configuration
  3198. ///////////////////////////////////////////////////////////////////////////////
  3199. if (SMTPApplyUserConfig(SMTPS, pUI) < 0) {
  3200. ErrorPush();
  3201. UsrFreeUserInfo(pUI);
  3202. return (ErrorPop());
  3203. }
  3205. UsrFreeUserInfo(pUI);
  3207. return (0);
  3208. }
  3210. UsrFreeUserInfo(pUI);
  3212. }
  3214. ErrSetErrorCode(ERR_SMTP_AUTH_FAILED);
  3215. return (ERR_SMTP_AUTH_FAILED);
  3217. }
  3219. static int SMTPGetUserSmtpPerms(UserInfo * pUI, SVRCFG_HANDLE hSvrConfig, char *pszPerms,
  3220. int iMaxPerms)
  3221. {
  3223. char *pszUserPerms = UsrGetUserInfoVar(pUI, "SmtpPerms");
  3225. if (pszUserPerms != NULL) {
  3226. StrNCpy(pszPerms, pszUserPerms, iMaxPerms);
  3228. SysFree(pszUserPerms);
  3229. } else {
  3230. ///////////////////////////////////////////////////////////////////////////////
  3231. //  Match found, get the default permissions
  3232. ///////////////////////////////////////////////////////////////////////////////
  3233. char *pszDefultPerms = SvrGetConfigVar(hSvrConfig,
  3234.        "DefaultSmtpPerms", "MR");
  3236. if (pszDefultPerms != NULL) {
  3237. StrNCpy(pszPerms, pszDefultPerms, iMaxPerms);
  3239. SysFree(pszDefultPerms);
  3240. } else
  3241. SetEmptyString(pszPerms);
  3243. }
  3245. return (0);
  3247. }
  3249. static int SMTPTryApplyLocalCMD5Auth(SMTPSession & SMTPS, char const *pszChallenge,
  3250.      char const *pszUsername, char const *pszDigest)
  3251. {
  3252. ///////////////////////////////////////////////////////////////////////////////
  3253. //  First try to lookup  mailusers.tab
  3254. ///////////////////////////////////////////////////////////////////////////////
  3255. char szAccountUser[MAX_ADDR_NAME] = "";
  3256. char szAccountDomain[MAX_HOST_NAME] = "";
  3258. if (StrSplitString(pszUsername, POP3_USER_SPLITTERS, szAccountUser, sizeof(szAccountUser),
  3259.    szAccountDomain, sizeof(szAccountDomain)) < 0)
  3260. return (ErrGetErrorCode());
  3262. UserInfo *pUI = UsrGetUserByName(szAccountDomain, szAccountUser);
  3264. if (pUI != NULL) {
  3265. ///////////////////////////////////////////////////////////////////////////////
  3266. //  Compute MD5 response ( secret , challenge , digest )
  3267. ///////////////////////////////////////////////////////////////////////////////
  3268. char szCurrDigest[512] = "";
  3270. if (MscCramMD5(pUI->pszPassword, pszChallenge, szCurrDigest) < 0) {
  3271. UsrFreeUserInfo(pUI);
  3273. return (ErrGetErrorCode());
  3274. }
  3276. if (stricmp(szCurrDigest, pszDigest) == 0) {
  3277. ///////////////////////////////////////////////////////////////////////////////
  3278. //  Apply user configuration
  3279. ///////////////////////////////////////////////////////////////////////////////
  3280. if (SMTPApplyUserConfig(SMTPS, pUI) < 0) {
  3281. ErrorPush();
  3282. UsrFreeUserInfo(pUI);
  3283. return (ErrorPop());
  3284. }
  3286. UsrFreeUserInfo(pUI);
  3288. return (0);
  3289. }
  3291. UsrFreeUserInfo(pUI);
  3293. }
  3295. ErrSetErrorCode(ERR_SMTP_AUTH_FAILED);
  3296. return (ERR_SMTP_AUTH_FAILED);
  3298. }
  3300. static int SMTPTryApplyUsrPwdAuth(SMTPSession & SMTPS, char const *pszUsername,
  3301.   char const *pszPassword)
  3302. {
  3304. char szAuthFilePath[SYS_MAX_PATH] = "";
  3306. SMTPGetAuthFilePath(szAuthFilePath, sizeof(szAuthFilePath));
  3308. char szResLock[SYS_MAX_PATH] = "";
  3309. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szAuthFilePath, szResLock,
  3310.   sizeof(szResLock)));
  3312. if (hResLock == INVALID_RLCK_HANDLE)
  3313. return (ErrGetErrorCode());
  3315. FILE *pAuthFile = fopen(szAuthFilePath, "rt");
  3317. if (pAuthFile == NULL) {
  3318. RLckUnlockSH(hResLock);
  3319. ErrSetErrorCode(ERR_FILE_OPEN, szAuthFilePath);
  3320. return (ERR_FILE_OPEN);
  3321. }
  3323. char szAuthLine[SVR_SMTPAUTH_LINE_MAX] = "";
  3325. while (MscGetConfigLine(szAuthLine, sizeof(szAuthLine) - 1, pAuthFile) != NULL) {
  3326. char **ppszStrings = StrGetTabLineStrings(szAuthLine);
  3328. if (ppszStrings == NULL)
  3329. continue;
  3331. int iFieldsCount = StrStringsCount(ppszStrings);
  3333. if ((iFieldsCount >= smtpaMax) &&
  3334.     (strcmp(ppszStrings[smtpaUsername], pszUsername) == 0) &&
  3335.     (strcmp(ppszStrings[smtpaPassword], pszPassword) == 0)) {
  3336. ///////////////////////////////////////////////////////////////////////////////
  3337. //  Apply user perms to SMTP config
  3338. ///////////////////////////////////////////////////////////////////////////////
  3339. SMTPApplyPerms(SMTPS, ppszStrings[smtpaPerms]);
  3341. StrFreeStrings(ppszStrings);
  3342. fclose(pAuthFile);
  3343. RLckUnlockSH(hResLock);
  3345. return (0);
  3346. }
  3348. StrFreeStrings(ppszStrings);
  3349. }
  3351. fclose(pAuthFile);
  3353. RLckUnlockSH(hResLock);
  3355. ErrSetErrorCode(ERR_SMTP_AUTH_FAILED);
  3356. return (ERR_SMTP_AUTH_FAILED);
  3358. }
  3360. static int SMTPTryApplyCMD5Auth(SMTPSession & SMTPS, char const *pszChallenge,
  3361. char const *pszUsername, char const *pszDigest)
  3362. {
  3364. char szAuthFilePath[SYS_MAX_PATH] = "";
  3366. SMTPGetAuthFilePath(szAuthFilePath, sizeof(szAuthFilePath));
  3368. FILE *pAuthFile = fopen(szAuthFilePath, "rt");
  3370. if (pAuthFile == NULL) {
  3371. ErrSetErrorCode(ERR_FILE_OPEN, szAuthFilePath);
  3372. return (ERR_FILE_OPEN);
  3373. }
  3375. char szAuthLine[SVR_SMTPAUTH_LINE_MAX] = "";
  3377. while (MscGetConfigLine(szAuthLine, sizeof(szAuthLine) - 1, pAuthFile) != NULL) {
  3378. char **ppszStrings = StrGetTabLineStrings(szAuthLine);
  3380. if (ppszStrings == NULL)
  3381. continue;
  3383. int iFieldsCount = StrStringsCount(ppszStrings);
  3385. if ((iFieldsCount >= smtpaMax) &&
  3386.     (strcmp(ppszStrings[smtpaUsername], pszUsername) == 0)) {
  3387. char szCurrDigest[512] = "";
  3389. ///////////////////////////////////////////////////////////////////////////////
  3390. //  Compute MD5 response ( secret , challenge , digest )
  3391. ///////////////////////////////////////////////////////////////////////////////
  3392. if (MscCramMD5(ppszStrings[smtpaPassword], pszChallenge, szCurrDigest) <
  3393.     0) {
  3394. StrFreeStrings(ppszStrings);
  3395. fclose(pAuthFile);
  3397. return (ErrGetErrorCode());
  3398. }
  3400. if (stricmp(szCurrDigest, pszDigest) == 0) {
  3401. ///////////////////////////////////////////////////////////////////////////////
  3402. //  Apply user perms to SMTP config
  3403. ///////////////////////////////////////////////////////////////////////////////
  3404. SMTPApplyPerms(SMTPS, ppszStrings[smtpaPerms]);
  3406. StrFreeStrings(ppszStrings);
  3407. fclose(pAuthFile);
  3409. return (0);
  3410. }
  3411. }
  3413. StrFreeStrings(ppszStrings);
  3414. }
  3416. fclose(pAuthFile);
  3418. ErrSetErrorCode(ERR_SMTP_AUTH_FAILED);
  3419. return (ERR_SMTP_AUTH_FAILED);
  3421. }
  3423. static int SMTPDoAuthCramMD5(BSOCK_HANDLE hBSock, SMTPSession & SMTPS, char const *pszAuthParam)
  3424. {
  3425. ///////////////////////////////////////////////////////////////////////////////
  3426. //  Emit encoded64 challenge and get client response
  3427. ///////////////////////////////////////////////////////////////////////////////
  3428. unsigned int uEnc64Length = 0;
  3429. char szChallenge[512] = "";
  3431. encode64(SMTPS.szTimeStamp, strlen(SMTPS.szTimeStamp), szChallenge,
  3432.  sizeof(szChallenge), &uEnc64Length);
  3434. if ((BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout, "334 %s", szChallenge) < 0) ||
  3435.     (BSckGetString(hBSock, szChallenge, sizeof(szChallenge) - 1, SMTPS.pSMTPCfg->iTimeout)
  3436.      == NULL))
  3437. return (ErrGetErrorCode());
  3439. ///////////////////////////////////////////////////////////////////////////////
  3440. //  Decode ( base64 ) client response
  3441. ///////////////////////////////////////////////////////////////////////////////
  3442. unsigned int uDec64Length = 0;
  3443. char szClientResp[512] = "";
  3445. if (decode64(szChallenge, strlen(szChallenge), szClientResp, &uDec64Length) != 0) {
  3446. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3448. ErrSetErrorCode(ERR_BAD_SMTP_CMD_SYNTAX);
  3449. return (ERR_BAD_SMTP_CMD_SYNTAX);
  3450. }
  3451. ///////////////////////////////////////////////////////////////////////////////
  3452. //  Extract the username and client digest
  3453. ///////////////////////////////////////////////////////////////////////////////
  3454. char *pszUsername = szClientResp;
  3455. char *pszDigest = strchr(szClientResp, ' ');
  3457. if (pszDigest == NULL) {
  3458. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3460. ErrSetErrorCode(ERR_BAD_SMTP_CMD_SYNTAX);
  3461. return (ERR_BAD_SMTP_CMD_SYNTAX);
  3462. }
  3464. *pszDigest++ = '';
  3466. ///////////////////////////////////////////////////////////////////////////////
  3467. //  Validate client response
  3468. ///////////////////////////////////////////////////////////////////////////////
  3469. if ((SMTPTryApplyLocalCMD5Auth(SMTPS, SMTPS.szTimeStamp, pszUsername,
  3470.        pszDigest) < 0) &&
  3471.     (SMTPTryApplyCMD5Auth(SMTPS, SMTPS.szTimeStamp, pszUsername, pszDigest) < 0)) {
  3472. ErrorPush();
  3474. SMTPSendError(hBSock, SMTPS, "503 Authentication failed");
  3476. return (ErrorPop());
  3477. }
  3478. ///////////////////////////////////////////////////////////////////////////////
  3479. //  Set the logon user
  3480. ///////////////////////////////////////////////////////////////////////////////
  3481. StrSNCpy(SMTPS.szLogonUser, pszUsername);
  3483. SMTPS.ulFlags |= SMTPF_AUTHENTICATED;
  3484. SMTPS.iSMTPState = stateAuthenticated;
  3486. BSckSendString(hBSock, "235 Authentication successful", SMTPS.pSMTPCfg->iTimeout);
  3488. return (0);
  3490. }
  3492. static int SMTPHandleCmd_AUTH(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  3493. {
  3495. if (SMTPS.iSMTPState != stateHelo) {
  3496. SMTPResetSession(SMTPS);
  3498. SMTPSendError(hBSock, SMTPS, "503 Bad sequence of commands");
  3500. ErrSetErrorCode(ERR_SMTP_BAD_CMD_SEQUENCE);
  3501. return (ERR_SMTP_BAD_CMD_SEQUENCE);
  3502. }
  3504. int iTokensCount;
  3505. char **ppszTokens = StrTokenize(pszCommand, " ");
  3507. if ((ppszTokens == NULL) || ((iTokensCount = StrStringsCount(ppszTokens)) < 2)) {
  3508. if (ppszTokens != NULL)
  3509. StrFreeStrings(ppszTokens);
  3511. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3512. return (-1);
  3513. }
  3514. ///////////////////////////////////////////////////////////////////////////////
  3515. //  Decode AUTH command params
  3516. ///////////////////////////////////////////////////////////////////////////////
  3517. char szAuthType[128] = "";
  3518. char szAuthParam[PLAIN_AUTH_PARAM_SIZE] = "";
  3520. StrSNCpy(szAuthType, ppszTokens[1]);
  3522. if (iTokensCount > 2)
  3523. StrSNCpy(szAuthParam, ppszTokens[2]);
  3525. StrFreeStrings(ppszTokens);
  3527. ///////////////////////////////////////////////////////////////////////////////
  3528. //  Handle authentication methods
  3529. ///////////////////////////////////////////////////////////////////////////////
  3530. if (stricmp(szAuthType, "plain") == 0) {
  3532. if (SMTPDoAuthPlain(hBSock, SMTPS, szAuthParam) < 0) {
  3533. ErrorPush();
  3535. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  3536. SMTPLogSession(SMTPS, "", "", "AUTH=EFAIL:TYPE=PLAIN", 0);
  3538. return (ErrorPop());
  3539. }
  3541. } else if (stricmp(szAuthType, "login") == 0) {
  3543. if (SMTPDoAuthLogin(hBSock, SMTPS, szAuthParam) < 0) {
  3544. ErrorPush();
  3546. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  3547. SMTPLogSession(SMTPS, "", "", "AUTH=EFAIL:TYPE=LOGIN", 0);
  3549. return (ErrorPop());
  3550. }
  3552. } else if (stricmp(szAuthType, "cram-md5") == 0) {
  3554. if (SMTPDoAuthCramMD5(hBSock, SMTPS, szAuthParam) < 0) {
  3555. ErrorPush();
  3557. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  3558. SMTPLogSession(SMTPS, "", "", "AUTH=EFAIL:TYPE=CRAM-MD5", 0);
  3560. return (ErrorPop());
  3561. }
  3563. } else {
  3564. ///////////////////////////////////////////////////////////////////////////////
  3565. //  Handle external authentication methods
  3566. ///////////////////////////////////////////////////////////////////////////////
  3567. if (SMTPDoAuthExternal(hBSock, SMTPS, szAuthType) < 0) {
  3568. ErrorPush();
  3570. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  3571. SMTPLogSession(SMTPS, "", "", "AUTH=EFAIL:TYPE=EXTRN", 0);
  3573. return (ErrorPop());
  3574. }
  3576. }
  3578. return (0);
  3580. }
  3582. static int SMTPSendMultilineResponse(BSOCK_HANDLE hBSock, int iTimeout, FILE * pRespFile)
  3583. {
  3585. rewind(pRespFile);
  3587. char szCurrLine[1024] = "";
  3588. char szPrevLine[1024] = "";
  3590. if (MscGetString(pRespFile, szPrevLine, sizeof(szPrevLine) - 1) != NULL) {
  3591. while (MscGetString(pRespFile, szCurrLine, sizeof(szCurrLine) - 1) != NULL) {
  3592. szPrevLine[3] = '-';
  3594. if (BSckSendString(hBSock, szPrevLine, iTimeout) < 0)
  3595. return (ErrGetErrorCode());
  3597. StrSNCpy(szPrevLine, szCurrLine);
  3598. }
  3600. if (BSckSendString(hBSock, szPrevLine, iTimeout) < 0)
  3601. return (ErrGetErrorCode());
  3602. }
  3604. return (0);
  3606. }
  3608. static int SMTPHandleCmd_RSET(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  3609. {
  3611. SMTPResetSession(SMTPS);
  3613. BSckSendString(hBSock, "250 OK", SMTPS.pSMTPCfg->iTimeout);
  3615. return (0);
  3617. }
  3619. static int SMTPHandleCmd_NOOP(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  3620. {
  3622. BSckSendString(hBSock, "250 OK", SMTPS.pSMTPCfg->iTimeout);
  3624. return (0);
  3626. }
  3628. static int SMTPHandleCmd_HELP(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  3629. {
  3631. BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout,
  3632. "250-HELO EHLO MAIL RCPT DATA AUTHrn"
  3633. "250-RSET VRFY ETRN NOOP HELP QUITrn"
  3634. "250 For more information please visit : %s", APP_URL);
  3636. return (0);
  3638. }
  3640. static int SMTPHandleCmd_QUIT(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  3641. {
  3643. SMTPS.iSMTPState = stateExit;
  3645. BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout,
  3646. "221 %s service closing transmission channel", SMTP_SERVER_NAME);
  3648. return (0);
  3650. }
  3652. static int SMTPHandleCmd_VRFY(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  3653. {
  3655. ///////////////////////////////////////////////////////////////////////////////
  3656. //  Check if VRFY is enabled
  3657. ///////////////////////////////////////////////////////////////////////////////
  3658. if (((SMTPS.ulFlags & SMTPF_VRFY_ENABLED) == 0) &&
  3659.     !SvrTestConfigFlag("AllowSmtpVRFY", false, SMTPS.hSvrConfig)) {
  3660. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  3661. SMTPLogSession(SMTPS, "", "", "VRFY=EACCESS", 0);
  3663. SMTPSendError(hBSock, SMTPS, "252 Argument not checked");
  3664. return (-1);
  3665. }
  3667. char **ppszTokens = StrTokenize(pszCommand, " ");
  3669. if ((ppszTokens == NULL) || (StrStringsCount(ppszTokens) != 2)) {
  3670. if (ppszTokens != NULL)
  3671. StrFreeStrings(ppszTokens);
  3673. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3674. return (-1);
  3675. }
  3677. char szVrfyUser[MAX_ADDR_NAME] = "";
  3678. char szVrfyDomain[MAX_ADDR_NAME] = "";
  3680. if (USmtpSplitEmailAddr(ppszTokens[1], szVrfyUser, szVrfyDomain) < 0) {
  3681. ErrorPush();
  3682. StrFreeStrings(ppszTokens);
  3684. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3685. return (ErrorPop());
  3686. }
  3688. StrFreeStrings(ppszTokens);
  3690. UserInfo *pUI = UsrGetUserByNameOrAlias(szVrfyDomain, szVrfyUser);
  3692. if (pUI != NULL) {
  3693. char *pszRealName = UsrGetUserInfoVar(pUI, "RealName", "Unknown");
  3695. BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout,
  3696. "250 %s <%s@%s>", pszRealName, pUI->pszName, pUI->pszDomain);
  3698. SysFree(pszRealName);
  3700. UsrFreeUserInfo(pUI);
  3701. } else {
  3702. if (USmlIsCmdAliasAccount(szVrfyDomain, szVrfyUser) < 0) {
  3703. SMTPSendError(hBSock, SMTPS, "550 String does not match anything");
  3705. ErrSetErrorCode(ERR_USER_NOT_LOCAL);
  3706. return (ERR_USER_NOT_LOCAL);
  3707. }
  3709. BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout,
  3710. "250 Local account <%s@%s>", szVrfyUser, szVrfyDomain);
  3712. }
  3714. return (0);
  3716. }
  3718. static int SMTPHandleCmd_ETRN(const char *pszCommand, BSOCK_HANDLE hBSock, SMTPSession & SMTPS)
  3719. {
  3721. ///////////////////////////////////////////////////////////////////////////////
  3722. //  Check if ETRN is enabled
  3723. ///////////////////////////////////////////////////////////////////////////////
  3724. if (((SMTPS.ulFlags & SMTPF_ETRN_ENABLED) == 0) &&
  3725.     !SvrTestConfigFlag("AllowSmtpETRN", false, SMTPS.hSvrConfig)) {
  3726. if (SMTPLogEnabled(SMTPS.hShbSMTP, SMTPS.pSMTPCfg))
  3727. SMTPLogSession(SMTPS, "", "", "ETRN=EACCESS", 0);
  3729. SMTPSendError(hBSock, SMTPS, "501 Command not accepted");
  3730. return (-1);
  3731. }
  3733. char **ppszTokens = StrTokenize(pszCommand, " ");
  3735. if ((ppszTokens == NULL) || (StrStringsCount(ppszTokens) != 2)) {
  3736. if (ppszTokens != NULL)
  3737. StrFreeStrings(ppszTokens);
  3739. SMTPSendError(hBSock, SMTPS, "501 Syntax error in parameters or arguments");
  3740. return (-1);
  3741. }
  3742. ///////////////////////////////////////////////////////////////////////////////
  3743. //  Do a matched flush of the rsnd arena
  3744. ///////////////////////////////////////////////////////////////////////////////
  3745. if (QueFlushRsndArena(hSpoolQueue, ppszTokens[1]) < 0) {
  3746. ErrorPush();
  3747. StrFreeStrings(ppszTokens);
  3749. SMTPSendError(hBSock, SMTPS,
  3750.       "451 Requested action aborted: (%d) local error in processing",
  3751.       ErrorFetch());
  3753. return (ErrorPop());
  3754. }
  3756. BSckVSendString(hBSock, SMTPS.pSMTPCfg->iTimeout,
  3757. "250 Queueing for '%s' has been started", ppszTokens[1]);
  3759. StrFreeStrings(ppszTokens);
  3761. return (0);
  3763. }