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

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

Email服务器

开发平台：

Visual C++

SMTPUtils.cpp：源码内容
  1. /*
  2.  *  XMail by Davide Libenzi ( Intranet and Internet mail server )
  3.  *  Copyright (C) 1999,..,2004  Davide Libenzi
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  *  Davide Libenzi <davidel@xmailserver.org>
  20.  *
  21.  */
  23. #include "SysInclude.h"
  24. #include "SysDep.h"
  25. #include "SvrDefines.h"
  26. #include "ShBlocks.h"
  27. #include "ResLocks.h"
  28. #include "StrUtils.h"
  29. #include "SList.h"
  30. #include "BuffSock.h"
  31. #include "MailConfig.h"
  32. #include "UsrUtils.h"
  33. #include "UsrAuth.h"
  34. #include "SvrUtils.h"
  35. #include "MiscUtils.h"
  36. #include "DNS.h"
  37. #include "DNSCache.h"
  38. #include "MessQueue.h"
  39. #include "SMAILUtils.h"
  40. #include "QueueUtils.h"
  41. #include "SMTPSvr.h"
  42. #include "SMTPUtils.h"
  43. #include "Base64Enc.h"
  44. #include "MD5.h"
  45. #include "MailSvr.h"
  47. #define STD_SMTP_TIMEOUT        STD_SERVER_TIMEOUT
  48. #define SMTPGW_LINE_MAX         1024
  49. #define SMTPGW_TABLE_FILE       "smtpgw.tab"
  50. #define SMTPFWD_LINE_MAX        1024
  51. #define SMTPFWD_TABLE_FILE      "smtpfwd.tab"
  52. #define SMTPRELAY_LINE_MAX      512
  53. #define SMTP_RELAY_FILE         "smtprelay.tab"
  54. #define MAX_MX_RECORDS          32
  55. #define SMTP_SPAMMERS_FILE      "spammers.tab"
  56. #define SMTP_SPAM_ADDRESS_FILE  "spam-address.tab"
  57. #define SPAMMERS_LINE_MAX       512
  58. #define SPAM_ADDRESS_LINE_MAX   512
  59. #define SMTPAUTH_LINE_MAX       512
  60. #define SMTP_EXTAUTH_TIMEOUT    60
  61. #define SMTP_EXTAUTH_PRIORITY   SYS_PRIORITY_NORMAL
  62. #define SMTP_EXTAUTH_SUCCESS    0
  63. #define RFC_SPECIALS            "()<>@,/\;:"[]*?"
  65. #define SMTPCH_SUPPORT_SIZE     (1 << 0)
  67. enum SmtpGwFileds {
  68. gwDomain = 0,
  69. gwGateway,
  71. gwMax
  72. };
  74. enum SmtpFwdFileds {
  75. fwdDomain = 0,
  76. fwdGateway,
  78. fwdMax
  79. };
  81. enum SmtpRelayFileds {
  82. rlyFromIP = 0,
  83. rlyFromMask,
  85. rlyMax
  86. };
  88. enum SpammerFileds {
  89. spmFromIP = 0,
  90. spmFromMask,
  92. spmMax
  93. };
  95. struct SmtpMXRecords {
  96. int iNumMXRecords;
  97. int iMXCost[MAX_MX_RECORDS];
  98. char *pszMXName[MAX_MX_RECORDS];
  99. int iCurrMxCost;
  100. };
  102. struct SmtpChannel {
  103. BSOCK_HANDLE hBSock;
  104. unsigned long ulFlags;
  105. unsigned long ulMaxMsgSize;
  106. SYS_INET_ADDR SvrAddr;
  107. char *pszServer;
  108. };
  110. static int USmtpWriteGateway(FILE * pGwFile, const char *pszDomain, const char *pszGateway);
  111. static char *USmtpGetGwTableFilePath(char *pszGwFilePath, int iMaxPath);
  112. static char *USmtpGetFwdTableFilePath(char *pszFwdFilePath, int iMaxPath);
  113. static char *USmtpGetRelayFilePath(char *pszRelayFilePath, int iMaxPath);
  114. static int USmtpSetError(SMTPError * pSMTPE, int iSTMPResponse, char const *pszSTMPResponse,
  115.  char const *pszServer);
  116. static int USmtpSetErrorServer(SMTPError * pSMTPE, char const *pszServer);
  117. static int USmtpResponseClass(int iResponseCode, int iResponseClass);
  118. static int USmtpGetResultCode(const char *pszResult);
  119. static int USmtpIsPartialResponse(char const *pszResponse);
  120. static int USmtpGetResponse(BSOCK_HANDLE hBSock, char *pszResponse, int iMaxResponse,
  121.     int iTimeout = STD_SMTP_TIMEOUT);
  122. static int USmtpSendCommand(BSOCK_HANDLE hBSock, const char *pszCommand,
  123.     char *pszResponse, int iMaxResponse, int iTimeout = STD_SMTP_TIMEOUT);
  124. static int USmtpGetServerAuthFile(char const *pszServer, char *pszAuthFilePath);
  125. static int USmtpDoPlainAuth(SmtpChannel * pSmtpCh, char const *pszServer,
  126.     char const *const *ppszAuthTokens, SMTPError * pSMTPE);
  127. static int USmtpDoLoginAuth(SmtpChannel * pSmtpCh, char const *pszServer,
  128.     char const *const *ppszAuthTokens, SMTPError * pSMTPE);
  129. static int USmtpDoCramMD5Auth(SmtpChannel * pSmtpCh, char const *pszServer,
  130.       char const *const *ppszAuthTokens, SMTPError * pSMTPE);
  131. static int USmtpExternalAuthSubstitute(char **ppszAuthTokens, char const *pszChallenge,
  132.        char const *pszSecret, char const *pszRespFile);
  133. static int USmtpDoExternAuth(SmtpChannel * pSmtpCh, char const *pszServer,
  134.      char **ppszAuthTokens, SMTPError * pSMTPE);
  135. static int USmtpServerAuthenticate(SmtpChannel * pSmtpCh, char const *pszServer,
  136.    SMTPError * pSMTPE);
  137. static int USmtpParseEhloResponse(SmtpChannel * pSmtpCh, char const *pszResponse);
  138. static int USmtpGetDomainMX(SVRCFG_HANDLE hSvrConfig, const char *pszDomain, char *&pszMXDomains);
  139. static char *USmtpGetSpammersFilePath(char *pszSpamFilePath, int iMaxPath);
  140. static char *USmtpGetSpamAddrFilePath(char *pszSpamFilePath, int iMaxPath);
  142. static char *USmtpGetGwTableFilePath(char *pszGwFilePath, int iMaxPath)
  143. {
  145. CfgGetRootPath(pszGwFilePath, iMaxPath);
  147. StrNCat(pszGwFilePath, SMTPGW_TABLE_FILE, iMaxPath);
  149. return (pszGwFilePath);
  151. }
  153. static char *USmtpGetFwdTableFilePath(char *pszFwdFilePath, int iMaxPath)
  154. {
  156. CfgGetRootPath(pszFwdFilePath, iMaxPath);
  158. StrNCat(pszFwdFilePath, SMTPFWD_TABLE_FILE, iMaxPath);
  160. return (pszFwdFilePath);
  162. }
  164. char **USmtpGetFwdGateways(SVRCFG_HANDLE hSvrConfig, const char *pszDomain)
  165. {
  167. char szFwdFilePath[SYS_MAX_PATH] = "";
  169. USmtpGetFwdTableFilePath(szFwdFilePath, sizeof(szFwdFilePath));
  171. char szResLock[SYS_MAX_PATH] = "";
  172. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szFwdFilePath, szResLock,
  173.   sizeof(szResLock)));
  175. if (hResLock == INVALID_RLCK_HANDLE)
  176. return (NULL);
  178. FILE *pFwdFile = fopen(szFwdFilePath, "rt");
  180. if (pFwdFile == NULL) {
  181. RLckUnlockSH(hResLock);
  183. ErrSetErrorCode(ERR_SMTPFWD_FILE_NOT_FOUND);
  184. return (NULL);
  185. }
  187. char szFwdLine[SMTPFWD_LINE_MAX] = "";
  189. while (MscGetConfigLine(szFwdLine, sizeof(szFwdLine) - 1, pFwdFile) != NULL) {
  190. char **ppszStrings = StrGetTabLineStrings(szFwdLine);
  192. if (ppszStrings == NULL)
  193. continue;
  195. int iFieldsCount = StrStringsCount(ppszStrings);
  197. if ((iFieldsCount >= fwdMax) && StrIWildMatch(pszDomain, ppszStrings[fwdDomain])) {
  198. char **ppszFwdGws = NULL;
  200. if (ppszStrings[fwdGateway][0] == '#') {
  201. if ((ppszFwdGws =
  202.      StrTokenize(ppszStrings[fwdGateway] + 1, ",")) != NULL) {
  203. int iGwCount = StrStringsCount(ppszFwdGws);
  205. srand((unsigned int) time(NULL));
  207. for (int ii = 0; ii < (iGwCount / 2); ii++) {
  208. int iSwap1 = rand() % iGwCount;
  209. int iSwap2 = rand() % iGwCount;
  210. char *pszGw1 = ppszFwdGws[iSwap1];
  211. char *pszGw2 = ppszFwdGws[iSwap2];
  213. ppszFwdGws[iSwap1] = pszGw2;
  214. ppszFwdGws[iSwap2] = pszGw1;
  215. }
  216. }
  217. } else
  218. ppszFwdGws = StrTokenize(ppszStrings[fwdGateway], ",");
  220. StrFreeStrings(ppszStrings);
  221. fclose(pFwdFile);
  223. RLckUnlockSH(hResLock);
  225. return (ppszFwdGws);
  226. }
  228. StrFreeStrings(ppszStrings);
  229. }
  231. fclose(pFwdFile);
  233. RLckUnlockSH(hResLock);
  235. ErrSetErrorCode(ERR_SMTPFWD_NOT_FOUND);
  236. return (NULL);
  238. }
  240. static char *USmtpGetRelayFilePath(char *pszRelayFilePath, int iMaxPath)
  241. {
  243. CfgGetRootPath(pszRelayFilePath, iMaxPath);
  245. StrNCat(pszRelayFilePath, SMTP_RELAY_FILE, iMaxPath);
  247. return (pszRelayFilePath);
  249. }
  251. int USmtpGetGateway(SVRCFG_HANDLE hSvrConfig, const char *pszDomain, char *pszGateway)
  252. {
  254. char szGwFilePath[SYS_MAX_PATH] = "";
  256. USmtpGetGwTableFilePath(szGwFilePath, sizeof(szGwFilePath));
  258. char szResLock[SYS_MAX_PATH] = "";
  259. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szGwFilePath, szResLock,
  260.   sizeof(szResLock)));
  262. if (hResLock == INVALID_RLCK_HANDLE)
  263. return (ErrGetErrorCode());
  265. FILE *pGwFile = fopen(szGwFilePath, "rt");
  267. if (pGwFile == NULL) {
  268. RLckUnlockSH(hResLock);
  270. ErrSetErrorCode(ERR_SMTPGW_FILE_NOT_FOUND);
  271. return (ERR_SMTPGW_FILE_NOT_FOUND);
  272. }
  274. char szGwLine[SMTPGW_LINE_MAX] = "";
  276. while (MscGetConfigLine(szGwLine, sizeof(szGwLine) - 1, pGwFile) != NULL) {
  277. char **ppszStrings = StrGetTabLineStrings(szGwLine);
  279. if (ppszStrings == NULL)
  280. continue;
  282. int iFieldsCount = StrStringsCount(ppszStrings);
  284. if ((iFieldsCount >= gwMax) && StrIWildMatch(pszDomain, ppszStrings[gwDomain])) {
  285. strcpy(pszGateway, ppszStrings[gwGateway]);
  287. StrFreeStrings(ppszStrings);
  288. fclose(pGwFile);
  290. RLckUnlockSH(hResLock);
  292. return (0);
  293. }
  295. StrFreeStrings(ppszStrings);
  296. }
  298. fclose(pGwFile);
  300. RLckUnlockSH(hResLock);
  302. ErrSetErrorCode(ERR_SMTPGW_NOT_FOUND);
  303. return (ERR_SMTPGW_NOT_FOUND);
  305. }
  307. static int USmtpWriteGateway(FILE * pGwFile, const char *pszDomain, const char *pszGateway)
  308. {
  310. ///////////////////////////////////////////////////////////////////////////////
  311. //  Domain
  312. ///////////////////////////////////////////////////////////////////////////////
  313. char *pszQuoted = StrQuote(pszDomain, '"');
  315. if (pszQuoted == NULL)
  316. return (ErrGetErrorCode());
  318. fprintf(pGwFile, "%st", pszQuoted);
  320. SysFree(pszQuoted);
  322. ///////////////////////////////////////////////////////////////////////////////
  323. //  Gateway
  324. ///////////////////////////////////////////////////////////////////////////////
  325. pszQuoted = StrQuote(pszGateway, '"');
  327. if (pszQuoted == NULL)
  328. return (ErrGetErrorCode());
  330. fprintf(pGwFile, "%sn", pszQuoted);
  332. SysFree(pszQuoted);
  334. return (0);
  336. }
  338. int USmtpAddGateway(const char *pszDomain, const char *pszGateway)
  339. {
  341. char szGwFilePath[SYS_MAX_PATH] = "";
  343. USmtpGetGwTableFilePath(szGwFilePath, sizeof(szGwFilePath));
  345. char szResLock[SYS_MAX_PATH] = "";
  346. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szGwFilePath, szResLock,
  347.   sizeof(szResLock)));
  349. if (hResLock == INVALID_RLCK_HANDLE)
  350. return (ErrGetErrorCode());
  352. FILE *pGwFile = fopen(szGwFilePath, "r+t");
  354. if (pGwFile == NULL) {
  355. RLckUnlockEX(hResLock);
  357. ErrSetErrorCode(ERR_SMTPGW_FILE_NOT_FOUND);
  358. return (ERR_SMTPGW_FILE_NOT_FOUND);
  359. }
  361. char szGwLine[SMTPGW_LINE_MAX] = "";
  363. while (MscGetConfigLine(szGwLine, sizeof(szGwLine) - 1, pGwFile) != NULL) {
  364. char **ppszStrings = StrGetTabLineStrings(szGwLine);
  366. if (ppszStrings == NULL)
  367. continue;
  369. int iFieldsCount = StrStringsCount(ppszStrings);
  371. if ((iFieldsCount >= gwMax) && (stricmp(pszDomain, ppszStrings[gwDomain]) == 0) &&
  372.     (stricmp(pszGateway, ppszStrings[gwGateway]) == 0)) {
  373. StrFreeStrings(ppszStrings);
  374. fclose(pGwFile);
  375. RLckUnlockEX(hResLock);
  377. ErrSetErrorCode(ERR_GATEWAY_ALREADY_EXIST);
  378. return (ERR_GATEWAY_ALREADY_EXIST);
  379. }
  381. StrFreeStrings(ppszStrings);
  382. }
  384. fseek(pGwFile, 0, SEEK_END);
  386. if (USmtpWriteGateway(pGwFile, pszDomain, pszGateway) < 0) {
  387. fclose(pGwFile);
  388. RLckUnlockEX(hResLock);
  389. return (ErrGetErrorCode());
  390. }
  392. fclose(pGwFile);
  394. RLckUnlockEX(hResLock);
  396. return (0);
  398. }
  400. int USmtpRemoveGateway(const char *pszDomain)
  401. {
  403. char szGwFilePath[SYS_MAX_PATH] = "";
  405. USmtpGetGwTableFilePath(szGwFilePath, sizeof(szGwFilePath));
  407. char szTmpFile[SYS_MAX_PATH] = "";
  409. SysGetTmpFile(szTmpFile);
  411. char szResLock[SYS_MAX_PATH] = "";
  412. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szGwFilePath, szResLock,
  413.   sizeof(szResLock)));
  415. if (hResLock == INVALID_RLCK_HANDLE)
  416. return (ErrGetErrorCode());
  418. FILE *pGwFile = fopen(szGwFilePath, "rt");
  420. if (pGwFile == NULL) {
  421. RLckUnlockEX(hResLock);
  423. ErrSetErrorCode(ERR_SMTPGW_FILE_NOT_FOUND);
  424. return (ERR_SMTPGW_FILE_NOT_FOUND);
  425. }
  427. FILE *pTmpFile = fopen(szTmpFile, "wt");
  429. if (pTmpFile == NULL) {
  430. fclose(pGwFile);
  431. RLckUnlockEX(hResLock);
  433. ErrSetErrorCode(ERR_FILE_CREATE);
  434. return (ERR_FILE_CREATE);
  435. }
  437. int iGatewayFound = 0;
  438. char szGwLine[SMTPGW_LINE_MAX] = "";
  440. while (MscGetConfigLine(szGwLine, sizeof(szGwLine) - 1, pGwFile, false) != NULL) {
  441. if (szGwLine[0] == TAB_COMMENT_CHAR) {
  442. fprintf(pTmpFile, "%sn", szGwLine);
  443. continue;
  444. }
  446. char **ppszStrings = StrGetTabLineStrings(szGwLine);
  448. if (ppszStrings == NULL)
  449. continue;
  451. int iFieldsCount = StrStringsCount(ppszStrings);
  453. if ((iFieldsCount >= gwMax) && (stricmp(pszDomain, ppszStrings[gwDomain]) == 0)) {
  455. ++iGatewayFound;
  457. } else
  458. fprintf(pTmpFile, "%sn", szGwLine);
  460. StrFreeStrings(ppszStrings);
  461. }
  463. fclose(pGwFile);
  464. fclose(pTmpFile);
  466. if (iGatewayFound == 0) {
  467. SysRemove(szTmpFile);
  468. RLckUnlockEX(hResLock);
  470. ErrSetErrorCode(ERR_GATEWAY_NOT_FOUND);
  471. return (ERR_GATEWAY_NOT_FOUND);
  472. }
  474. char szTmpGwFilePath[SYS_MAX_PATH] = "";
  476. sprintf(szTmpGwFilePath, "%s.tmp", szGwFilePath);
  478. if (MscMoveFile(szGwFilePath, szTmpGwFilePath) < 0) {
  479. ErrorPush();
  480. RLckUnlockEX(hResLock);
  481. return (ErrorPop());
  482. }
  484. if (MscMoveFile(szTmpFile, szGwFilePath) < 0) {
  485. ErrorPush();
  486. MscMoveFile(szTmpGwFilePath, szGwFilePath);
  487. RLckUnlockEX(hResLock);
  488. return (ErrorPop());
  489. }
  491. SysRemove(szTmpGwFilePath);
  493. RLckUnlockEX(hResLock);
  495. return (0);
  497. }
  499. int USmtpIsAllowedRelay(const SYS_INET_ADDR & PeerInfo, SVRCFG_HANDLE hSvrConfig)
  500. {
  502. char szRelayFilePath[SYS_MAX_PATH] = "";
  504. USmtpGetRelayFilePath(szRelayFilePath, sizeof(szRelayFilePath));
  506. char szResLock[SYS_MAX_PATH] = "";
  507. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szRelayFilePath, szResLock,
  508.   sizeof(szResLock)));
  510. if (hResLock == INVALID_RLCK_HANDLE)
  511. return (ErrGetErrorCode());
  513. FILE *pRelayFile = fopen(szRelayFilePath, "rt");
  515. if (pRelayFile == NULL) {
  516. RLckUnlockSH(hResLock);
  518. ErrSetErrorCode(ERR_SMTPRELAY_FILE_NOT_FOUND);
  519. return (ERR_SMTPRELAY_FILE_NOT_FOUND);
  520. }
  522. NET_ADDRESS TestAddr;
  524. SysGetAddrAddress(PeerInfo, TestAddr);
  526. char szRelayLine[SMTPRELAY_LINE_MAX] = "";
  528. while (MscGetConfigLine(szRelayLine, sizeof(szRelayLine) - 1, pRelayFile) != NULL) {
  529. char **ppszStrings = StrGetTabLineStrings(szRelayLine);
  531. if (ppszStrings == NULL)
  532. continue;
  534. int iFieldsCount = StrStringsCount(ppszStrings);
  535. AddressFilter AF;
  537. if ((iFieldsCount > 0) &&
  538.     (MscLoadAddressFilter(ppszStrings, iFieldsCount, AF) == 0) &&
  539.     MscAddressMatch(AF, TestAddr)) {
  540. StrFreeStrings(ppszStrings);
  541. fclose(pRelayFile);
  542. RLckUnlockSH(hResLock);
  544. return (0);
  545. }
  547. StrFreeStrings(ppszStrings);
  548. }
  550. fclose(pRelayFile);
  552. RLckUnlockSH(hResLock);
  554. ErrSetErrorCode(ERR_RELAY_NOT_ALLOWED);
  556. return (ERR_RELAY_NOT_ALLOWED);
  558. }
  560. char **USmtpGetPathStrings(const char *pszMailCmd)
  561. {
  563. const char *pszOpen = strchr(pszMailCmd, '<');
  564. const char *pszClose = strchr(pszMailCmd, '>');
  566. if ((pszOpen == NULL) || (pszClose == NULL)) {
  567. ErrSetErrorCode(ERR_SMTP_PATH_PARSE_ERROR);
  568. return (NULL);
  569. }
  571. int iPathLength = (int) (pszClose - pszOpen) - 1;
  573. if ((iPathLength < 0) || (iPathLength >= MAX_SMTP_ADDRESS)) {
  574. ErrSetErrorCode(ERR_SMTP_PATH_PARSE_ERROR, pszMailCmd);
  575. return (NULL);
  576. }
  578. char *pszPath = (char *) SysAlloc(iPathLength + 1);
  580. if (pszPath == NULL)
  581. return (NULL);
  583. strncpy(pszPath, pszOpen + 1, iPathLength);
  584. pszPath[iPathLength] = '';
  586. char **ppszDomains = StrTokenize(pszPath, ",:");
  588. SysFree(pszPath);
  590. return (ppszDomains);
  592. }
  594. int USmtpSplitEmailAddr(const char *pszAddr, char *pszUser, char *pszDomain)
  595. {
  597. const char *pszAT = strchr(pszAddr, '@');
  599. if (pszAT == NULL) {
  600. ErrSetErrorCode(ERR_BAD_EMAIL_ADDR);
  601. return (ERR_BAD_EMAIL_ADDR);
  602. }
  604. int iUserLength = (int) (pszAT - pszAddr);
  605. int iDomainLength = strlen(pszAT + 1);
  607. if (pszUser != NULL) {
  608. if (iUserLength == 0) {
  609. ErrSetErrorCode(ERR_BAD_EMAIL_ADDR);
  610. return (ERR_BAD_EMAIL_ADDR);
  611. }
  613. iUserLength = Min(iUserLength, MAX_ADDR_NAME - 1);
  614. strncpy(pszUser, pszAddr, iUserLength);
  615. pszUser[iUserLength] = '';
  616. }
  618. if (pszDomain != NULL) {
  619. if (iDomainLength == 0) {
  620. ErrSetErrorCode(ERR_BAD_EMAIL_ADDR);
  621. return (ERR_BAD_EMAIL_ADDR);
  622. }
  624. StrNCpy(pszDomain, pszAT + 1, MAX_ADDR_NAME);
  625. }
  627. return (0);
  629. }
  631. int USmtpCheckAddressPart(char const *pszName)
  632. {
  634. for (; *pszName; pszName++)
  635. if ((*pszName <= ' ') || (*pszName == 127) ||
  636.     (strchr(RFC_SPECIALS, *pszName) != NULL)) {
  637. ErrSetErrorCode(ERR_BAD_RFCNAME);
  638. return (ERR_BAD_RFCNAME);
  639. }
  641. return (0);
  643. }
  645. int USmtpCheckAddress(char const *pszAddress)
  646. {
  647. char szUser[MAX_ADDR_NAME] = "";
  648. char szDomain[MAX_ADDR_NAME] = "";
  650. if ((USmtpSplitEmailAddr(pszAddress, szUser, szDomain) < 0) ||
  651.     (USmtpCheckAddressPart(szUser) < 0) || (USmtpCheckAddressPart(szDomain) < 0))
  652. return (ErrGetErrorCode());
  654. return (0);
  656. }
  658. int USmtpInitError(SMTPError * pSMTPE)
  659. {
  661. ZeroData(*pSMTPE);
  662. pSMTPE->iSTMPResponse = 0;
  663. pSMTPE->pszSTMPResponse = NULL;
  664. pSMTPE->pszServer = NULL;
  666. return (0);
  668. }
  670. static int USmtpSetError(SMTPError * pSMTPE, int iSTMPResponse, char const *pszSTMPResponse,
  671.  char const *pszServer)
  672. {
  674. pSMTPE->iSTMPResponse = iSTMPResponse;
  676. if (pSMTPE->pszSTMPResponse != NULL)
  677. SysFree(pSMTPE->pszSTMPResponse);
  679. if (pSMTPE->pszServer != NULL)
  680. SysFree(pSMTPE->pszServer);
  682. pSMTPE->pszSTMPResponse = SysStrDup(pszSTMPResponse);
  683. pSMTPE->pszServer = SysStrDup(pszServer);
  685. return (0);
  687. }
  689. static int USmtpSetErrorServer(SMTPError * pSMTPE, char const *pszServer)
  690. {
  692. if (pSMTPE->pszServer != NULL)
  693. SysFree(pSMTPE->pszServer);
  695. pSMTPE->pszServer = SysStrDup(pszServer);
  697. return (0);
  699. }
  701. bool USmtpIsFatalError(SMTPError const *pSMTPE)
  702. {
  704. return ((pSMTPE->iSTMPResponse == SMTP_FATAL_ERROR) ||
  705. ((pSMTPE->iSTMPResponse >= 500) && (pSMTPE->iSTMPResponse < 600)));
  707. }
  709. char const *USmtpGetErrorMessage(SMTPError const *pSMTPE)
  710. {
  712. return ((pSMTPE->pszSTMPResponse != NULL) ? pSMTPE->pszSTMPResponse : "");
  714. }
  716. int USmtpCleanupError(SMTPError * pSMTPE)
  717. {
  719. if (pSMTPE->pszSTMPResponse != NULL)
  720. SysFree(pSMTPE->pszSTMPResponse);
  722. if (pSMTPE->pszServer != NULL)
  723. SysFree(pSMTPE->pszServer);
  725. USmtpInitError(pSMTPE);
  727. return (0);
  729. }
  731. char *USmtpGetSMTPError(SMTPError * pSMTPE, char *pszError, int iMaxError)
  732. {
  734. char const *pszSmtpErr =
  735.     (pSMTPE != NULL) ? USmtpGetErrorMessage(pSMTPE) : DEFAULT_SMTP_ERR;
  737. if (IsEmptyString(pszSmtpErr))
  738. pszSmtpErr = DEFAULT_SMTP_ERR;
  740. StrNCpy(pszError, pszSmtpErr, iMaxError);
  742. return (pszError);
  744. }
  746. char const *USmtpGetErrorServer(SMTPError const *pSMTPE)
  747. {
  749. return ((pSMTPE->pszServer != NULL) ? pSMTPE->pszServer : "");
  751. }
  753. static int USmtpResponseClass(int iResponseCode, int iResponseClass)
  754. {
  756. return (((iResponseCode >= iResponseClass) &&
  757.  (iResponseCode < (iResponseClass + 100))) ? 1 : 0);
  759. }
  761. static int USmtpGetResultCode(const char *pszResult)
  762. {
  764. int ii;
  765. char szResCode[64] = "";
  767. for (ii = 0; (ii < sizeof(szResCode)) && isdigit(pszResult[ii]); ii++)
  768. szResCode[ii] = pszResult[ii];
  770. if ((ii == 0) || (ii == sizeof(szResCode))) {
  771. ErrSetErrorCode(ERR_BAD_SMTP_RESPONSE);
  772. return (ERR_BAD_SMTP_RESPONSE);
  773. }
  774. szResCode[ii] = '';
  776. return (atoi(szResCode));
  778. }
  780. static int USmtpIsPartialResponse(char const *pszResponse)
  781. {
  783. return (((strlen(pszResponse) >= 4) && (pszResponse[3] == '-')) ? 1 : 0);
  785. }
  787. static int USmtpGetResponse(BSOCK_HANDLE hBSock, char *pszResponse, int iMaxResponse,
  788.     int iTimeout)
  789. {
  791. int iResultCode = -1;
  792. int iResponseLenght = 0;
  793. char szPartial[1024] = "";
  795. SetEmptyString(pszResponse);
  796. do {
  797. int iLineLength = 0;
  799. if (BSckGetString(hBSock, szPartial, sizeof(szPartial) - 1, iTimeout,
  800.   &iLineLength) == NULL)
  801. return (ErrGetErrorCode());
  803. if ((iResponseLenght + 2) < iMaxResponse) {
  804. if (iResponseLenght > 0)
  805. strcat(pszResponse, "rn"), iResponseLenght += 2;
  807. int iCopyLenght = Min(iMaxResponse - 1 - iResponseLenght, iLineLength);
  809. if (iCopyLenght > 0) {
  810. strncpy(pszResponse + iResponseLenght, szPartial, iCopyLenght);
  812. iResponseLenght += iCopyLenght;
  814. pszResponse[iResponseLenght] = '';
  815. }
  816. }
  818. if ((iResultCode = USmtpGetResultCode(szPartial)) < 0)
  819. return (ErrGetErrorCode());
  821. } while (USmtpIsPartialResponse(szPartial));
  823. return (iResultCode);
  825. }
  827. static int USmtpSendCommand(BSOCK_HANDLE hBSock, const char *pszCommand,
  828.     char *pszResponse, int iMaxResponse, int iTimeout)
  829. {
  831. if (BSckSendString(hBSock, pszCommand, iTimeout) <= 0)
  832. return (ErrGetErrorCode());
  834. return (USmtpGetResponse(hBSock, pszResponse, iMaxResponse, iTimeout));
  836. }
  838. static int USmtpGetServerAuthFile(char const *pszServer, char *pszAuthFilePath)
  839. {
  841. int iRootedName = MscRootedName(pszServer);
  842. char szAuthPath[SYS_MAX_PATH] = "";
  844. UAthGetRootPath(AUTH_SERVICE_SMTP, szAuthPath, sizeof(szAuthPath));
  846. char const *pszDot = pszServer;
  848. while ((pszDot != NULL) && (strlen(pszDot) > 0)) {
  849. if (iRootedName)
  850. sprintf(pszAuthFilePath, "%s%stab", szAuthPath, pszDot);
  851. else
  852. sprintf(pszAuthFilePath, "%s%s.tab", szAuthPath, pszDot);
  854. if (SysExistFile(pszAuthFilePath))
  855. return (0);
  857. if ((pszDot = strchr(pszDot, '.')) != NULL)
  858. ++pszDot;
  859. }
  861. ErrSetErrorCode(ERR_NO_SMTP_AUTH_CONFIG);
  862. return (ERR_NO_SMTP_AUTH_CONFIG);
  864. }
  866. static int USmtpDoPlainAuth(SmtpChannel * pSmtpCh, char const *pszServer,
  867.     char const *const *ppszAuthTokens, SMTPError * pSMTPE)
  868. {
  870. if (StrStringsCount(ppszAuthTokens) < 3) {
  871. ErrSetErrorCode(ERR_BAD_SMTP_AUTH_CONFIG);
  872. return (ERR_BAD_SMTP_AUTH_CONFIG);
  873. }
  874. ///////////////////////////////////////////////////////////////////////////////
  875. //  Build plain text authentication token ( "" Username "" Password "" )
  876. ///////////////////////////////////////////////////////////////////////////////
  877. int iAuthLength = 1;
  878. char szAuthBuffer[2048] = "";
  880. strcpy(szAuthBuffer + iAuthLength, ppszAuthTokens[1]);
  881. iAuthLength += strlen(ppszAuthTokens[1]) + 1;
  883. strcpy(szAuthBuffer + iAuthLength, ppszAuthTokens[2]);
  884. iAuthLength += strlen(ppszAuthTokens[2]);
  886. unsigned int uEnc64Length = 0;
  887. char szEnc64Token[1024] = "";
  889. encode64(szAuthBuffer, iAuthLength, szEnc64Token, sizeof(szEnc64Token), &uEnc64Length);
  891. ///////////////////////////////////////////////////////////////////////////////
  892. //  Send AUTH command
  893. ///////////////////////////////////////////////////////////////////////////////
  894. int iSvrReponse;
  896. SysSNPrintf(szAuthBuffer, sizeof(szAuthBuffer) - 1, "AUTH PLAIN %s", szEnc64Token);
  898. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szAuthBuffer,
  899.        szAuthBuffer,
  900.        sizeof(szAuthBuffer) - 1), 200)) {
  901. if (iSvrReponse > 0) {
  902. if (pSMTPE != NULL)
  903. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer,
  904.       pSmtpCh->pszServer);
  906. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  907. }
  909. return (ErrGetErrorCode());
  910. }
  912. return (0);
  914. }
  916. static int USmtpDoLoginAuth(SmtpChannel * pSmtpCh, char const *pszServer,
  917.     char const *const *ppszAuthTokens, SMTPError * pSMTPE)
  918. {
  920. if (StrStringsCount(ppszAuthTokens) < 3) {
  921. ErrSetErrorCode(ERR_BAD_SMTP_AUTH_CONFIG);
  922. return (ERR_BAD_SMTP_AUTH_CONFIG);
  923. }
  924. ///////////////////////////////////////////////////////////////////////////////
  925. //  Send AUTH command
  926. ///////////////////////////////////////////////////////////////////////////////
  927. int iSvrReponse;
  928. char szAuthBuffer[1024] = "";
  930. sprintf(szAuthBuffer, "AUTH LOGIN");
  932. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szAuthBuffer,
  933.        szAuthBuffer,
  934.        sizeof(szAuthBuffer) - 1), 300)) {
  935. if (iSvrReponse > 0) {
  936. if (pSMTPE != NULL)
  937. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer,
  938.       pSmtpCh->pszServer);
  940. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  941. }
  943. return (ErrGetErrorCode());
  944. }
  945. ///////////////////////////////////////////////////////////////////////////////
  946. //  Send username
  947. ///////////////////////////////////////////////////////////////////////////////
  948. unsigned int uEnc64Length = 0;
  950. encode64(ppszAuthTokens[1], strlen(ppszAuthTokens[1]), szAuthBuffer,
  951.  sizeof(szAuthBuffer), &uEnc64Length);
  953. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szAuthBuffer,
  954.        szAuthBuffer,
  955.        sizeof(szAuthBuffer) - 1), 300)) {
  956. if (iSvrReponse > 0) {
  957. if (pSMTPE != NULL)
  958. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer,
  959.       pSmtpCh->pszServer);
  961. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  962. }
  964. return (ErrGetErrorCode());
  965. }
  966. ///////////////////////////////////////////////////////////////////////////////
  967. //  Send password
  968. ///////////////////////////////////////////////////////////////////////////////
  969. encode64(ppszAuthTokens[2], strlen(ppszAuthTokens[2]), szAuthBuffer,
  970.  sizeof(szAuthBuffer), &uEnc64Length);
  972. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szAuthBuffer,
  973.        szAuthBuffer,
  974.        sizeof(szAuthBuffer) - 1), 200)) {
  975. if (iSvrReponse > 0) {
  976. if (pSMTPE != NULL)
  977. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer,
  978.       pSmtpCh->pszServer);
  980. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  981. }
  983. return (ErrGetErrorCode());
  984. }
  986. return (0);
  988. }
  990. static int USmtpDoCramMD5Auth(SmtpChannel * pSmtpCh, char const *pszServer,
  991.       char const *const *ppszAuthTokens, SMTPError * pSMTPE)
  992. {
  994. if (StrStringsCount(ppszAuthTokens) < 3) {
  995. ErrSetErrorCode(ERR_BAD_SMTP_AUTH_CONFIG);
  996. return (ERR_BAD_SMTP_AUTH_CONFIG);
  997. }
  998. ///////////////////////////////////////////////////////////////////////////////
  999. //  Send AUTH command
  1000. ///////////////////////////////////////////////////////////////////////////////
  1001. int iSvrReponse;
  1002. char szAuthBuffer[1024] = "";
  1004. sprintf(szAuthBuffer, "AUTH CRAM-MD5");
  1006. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szAuthBuffer,
  1007.        szAuthBuffer,
  1008.        sizeof(szAuthBuffer) - 1), 300) ||
  1009.     (strlen(szAuthBuffer) < 4)) {
  1010. if (iSvrReponse > 0) {
  1011. if (pSMTPE != NULL)
  1012. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer,
  1013.       pSmtpCh->pszServer);
  1015. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  1016. }
  1018. return (ErrGetErrorCode());
  1019. }
  1020. ///////////////////////////////////////////////////////////////////////////////
  1021. //  Retrieve server challenge
  1022. ///////////////////////////////////////////////////////////////////////////////
  1023. unsigned int uDec64Length = 0;
  1024. char *pszAuth = szAuthBuffer + 4;
  1025. char szChallenge[1024] = "";
  1027. if (decode64(pszAuth, strlen(pszAuth), szChallenge, &uDec64Length) != 0) {
  1028. if (pSMTPE != NULL)
  1029. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer, pSmtpCh->pszServer);
  1031. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  1032. return (ERR_BAD_SERVER_RESPONSE);
  1033. }
  1034. ///////////////////////////////////////////////////////////////////////////////
  1035. //  Compute MD5 response ( secret , challenge , digest )
  1036. ///////////////////////////////////////////////////////////////////////////////
  1037. if (MscCramMD5(ppszAuthTokens[2], szChallenge, szChallenge) < 0)
  1038. return (ErrGetErrorCode());
  1040. ///////////////////////////////////////////////////////////////////////////////
  1041. //  Send response
  1042. ///////////////////////////////////////////////////////////////////////////////
  1043. unsigned int uEnc64Length = 0;
  1044. char szResponse[1024] = "";
  1046. SysSNPrintf(szResponse, sizeof(szResponse) - 1, "%s %s", ppszAuthTokens[1], szChallenge);
  1048. encode64(szResponse, strlen(szResponse), szAuthBuffer,
  1049.  sizeof(szAuthBuffer), &uEnc64Length);
  1051. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szAuthBuffer,
  1052.        szAuthBuffer,
  1053.        sizeof(szAuthBuffer) - 1), 200)) {
  1054. if (iSvrReponse > 0) {
  1055. if (pSMTPE != NULL)
  1056. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer,
  1057.       pSmtpCh->pszServer);
  1059. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  1060. }
  1062. return (ErrGetErrorCode());
  1063. }
  1065. return (0);
  1067. }
  1069. static int USmtpExternalAuthSubstitute(char **ppszAuthTokens, char const *pszChallenge,
  1070.        char const *pszSecret, char const *pszRespFile)
  1071. {
  1073. for (int ii = 0; ppszAuthTokens[ii] != NULL; ii++) {
  1074. if (strcmp(ppszAuthTokens[ii], "@@CHALL") == 0) {
  1075. char *pszNewValue = SysStrDup(pszChallenge);
  1077. if (pszNewValue == NULL)
  1078. return (ErrGetErrorCode());
  1080. SysFree(ppszAuthTokens[ii]);
  1082. ppszAuthTokens[ii] = pszNewValue;
  1083. } else if (strcmp(ppszAuthTokens[ii], "@@SECRT") == 0) {
  1084. char *pszNewValue = SysStrDup(pszSecret);
  1086. if (pszNewValue == NULL)
  1087. return (ErrGetErrorCode());
  1089. SysFree(ppszAuthTokens[ii]);
  1091. ppszAuthTokens[ii] = pszNewValue;
  1092. } else if (strcmp(ppszAuthTokens[ii], "@@RFILE") == 0) {
  1093. char *pszNewValue = SysStrDup(pszRespFile);
  1095. if (pszNewValue == NULL)
  1096. return (ErrGetErrorCode());
  1098. SysFree(ppszAuthTokens[ii]);
  1100. ppszAuthTokens[ii] = pszNewValue;
  1101. }
  1102. }
  1104. return (0);
  1106. }
  1108. static int USmtpDoExternAuth(SmtpChannel * pSmtpCh, char const *pszServer,
  1109.      char **ppszAuthTokens, SMTPError * pSMTPE)
  1110. {
  1112. if (StrStringsCount(ppszAuthTokens) < 4) {
  1113. ErrSetErrorCode(ERR_BAD_SMTP_AUTH_CONFIG);
  1114. return (ERR_BAD_SMTP_AUTH_CONFIG);
  1115. }
  1116. ///////////////////////////////////////////////////////////////////////////////
  1117. //  Send AUTH command
  1118. ///////////////////////////////////////////////////////////////////////////////
  1119. int iSvrReponse;
  1120. char szAuthBuffer[1024] = "";
  1122. SysSNPrintf(szAuthBuffer, sizeof(szAuthBuffer) - 1, "AUTH %s", ppszAuthTokens[1]);
  1124. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szAuthBuffer,
  1125.        szAuthBuffer,
  1126.        sizeof(szAuthBuffer) - 1), 300)) {
  1127. if (iSvrReponse > 0) {
  1128. if (pSMTPE != NULL)
  1129. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer,
  1130.       pSmtpCh->pszServer);
  1132. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  1133. }
  1135. return (ErrGetErrorCode());
  1136. }
  1137. ///////////////////////////////////////////////////////////////////////////////
  1138. //  Retrieve server challenge
  1139. ///////////////////////////////////////////////////////////////////////////////
  1140. unsigned int uDec64Length = 0;
  1141. char *pszAuth = szAuthBuffer + 4;
  1142. char szChallenge[1024] = "";
  1144. if ((strlen(szAuthBuffer) < 4) ||
  1145.     (decode64(pszAuth, strlen(pszAuth), szChallenge, &uDec64Length) != 0)) {
  1146. if (pSMTPE != NULL)
  1147. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer, pSmtpCh->pszServer);
  1149. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  1150. return (ERR_BAD_SERVER_RESPONSE);
  1151. }
  1152. ///////////////////////////////////////////////////////////////////////////////
  1153. //  Create temp filename for module response and do macro substitution
  1154. ///////////////////////////////////////////////////////////////////////////////
  1155. char szRespFile[SYS_MAX_PATH] = "";
  1157. SysGetTmpFile(szRespFile);
  1159. USmtpExternalAuthSubstitute(ppszAuthTokens, szChallenge, ppszAuthTokens[2], szRespFile);
  1161. ///////////////////////////////////////////////////////////////////////////////
  1162. //  Call external program to compute the response
  1163. ///////////////////////////////////////////////////////////////////////////////
  1164. int iExitCode = -1;
  1166. if (SysExec(ppszAuthTokens[3], &ppszAuthTokens[3], SMTP_EXTAUTH_TIMEOUT,
  1167.     SMTP_EXTAUTH_PRIORITY, &iExitCode) < 0) {
  1168. ErrorPush();
  1169. CheckRemoveFile(szRespFile);
  1171. return (ErrorPop());
  1172. }
  1174. if (iExitCode != SMTP_EXTAUTH_SUCCESS) {
  1175. CheckRemoveFile(szRespFile);
  1177. ErrSetErrorCode(ERR_BAD_EXTRNPRG_EXITCODE);
  1178. return (ERR_BAD_EXTRNPRG_EXITCODE);
  1179. }
  1180. ///////////////////////////////////////////////////////////////////////////////
  1181. //  Load response file
  1182. ///////////////////////////////////////////////////////////////////////////////
  1183. unsigned int uRespSize = 0;
  1184. char *pAuthResp = (char *) MscLoadFile(szRespFile, uRespSize);
  1186. CheckRemoveFile(szRespFile);
  1188. if (pAuthResp == NULL)
  1189. return (ErrGetErrorCode());
  1191. while ((uRespSize > 0) &&
  1192.        ((pAuthResp[uRespSize - 1] == 'r') || (pAuthResp[uRespSize - 1] == 'n')))
  1193. --uRespSize;
  1195. ///////////////////////////////////////////////////////////////////////////////
  1196. //  Send response
  1197. ///////////////////////////////////////////////////////////////////////////////
  1198. unsigned int uEnc64Length = 0;
  1200. encode64(pAuthResp, uRespSize, szAuthBuffer, sizeof(szAuthBuffer), &uEnc64Length);
  1202. SysFree(pAuthResp);
  1204. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szAuthBuffer,
  1205.        szAuthBuffer,
  1206.        sizeof(szAuthBuffer) - 1), 200)) {
  1207. if (iSvrReponse > 0) {
  1208. if (pSMTPE != NULL)
  1209. USmtpSetError(pSMTPE, iSvrReponse, szAuthBuffer,
  1210.       pSmtpCh->pszServer);
  1212. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szAuthBuffer);
  1213. }
  1215. return (ErrGetErrorCode());
  1216. }
  1218. return (0);
  1220. }
  1222. static int USmtpServerAuthenticate(SmtpChannel * pSmtpCh, char const *pszServer,
  1223.    SMTPError * pSMTPE)
  1224. {
  1225. ///////////////////////////////////////////////////////////////////////////////
  1226. //  Try to retrieve SMTP authentication config for  "pszServer"
  1227. ///////////////////////////////////////////////////////////////////////////////
  1228. char szAuthFilePath[SYS_MAX_PATH] = "";
  1230. if (USmtpGetServerAuthFile(pszServer, szAuthFilePath) < 0)
  1231. return (0);
  1233. FILE *pAuthFile = fopen(szAuthFilePath, "rt");
  1235. if (pAuthFile == NULL) {
  1236. ErrSetErrorCode(ERR_FILE_OPEN, szAuthFilePath);
  1237. return (ERR_FILE_OPEN);
  1238. }
  1240. char szAuthLine[SMTPAUTH_LINE_MAX] = "";
  1242. while (MscGetConfigLine(szAuthLine, sizeof(szAuthLine) - 1, pAuthFile) != NULL) {
  1243. char **ppszTokens = StrGetTabLineStrings(szAuthLine);
  1245. if (ppszTokens == NULL)
  1246. continue;
  1248. int iFieldsCount = StrStringsCount(ppszTokens);
  1250. if (iFieldsCount > 0) {
  1251. int iAuthResult = 0;
  1253. if (stricmp(ppszTokens[0], "plain") == 0)
  1254. iAuthResult =
  1255.     USmtpDoPlainAuth(pSmtpCh, pszServer, ppszTokens, pSMTPE);
  1256. else if (stricmp(ppszTokens[0], "login") == 0)
  1257. iAuthResult =
  1258.     USmtpDoLoginAuth(pSmtpCh, pszServer, ppszTokens, pSMTPE);
  1259. else if (stricmp(ppszTokens[0], "cram-md5") == 0)
  1260. iAuthResult =
  1261.     USmtpDoCramMD5Auth(pSmtpCh, pszServer, ppszTokens, pSMTPE);
  1262. else if (stricmp(ppszTokens[0], "external") == 0)
  1263. iAuthResult =
  1264.     USmtpDoExternAuth(pSmtpCh, pszServer, ppszTokens, pSMTPE);
  1265. else
  1266. ErrSetErrorCode(iAuthResult =
  1267. ERR_UNKNOWN_SMTP_AUTH, ppszTokens[0]);
  1269. StrFreeStrings(ppszTokens);
  1270. fclose(pAuthFile);
  1272. return (iAuthResult);
  1273. }
  1275. StrFreeStrings(ppszTokens);
  1276. }
  1278. fclose(pAuthFile);
  1280. return (0);
  1282. }
  1284. static int USmtpParseEhloResponse(SmtpChannel * pSmtpCh, char const *pszResponse)
  1285. {
  1287. char const *pszLine = pszResponse;
  1289. for (; pszLine != NULL; pszLine = strchr(pszLine, 'n')) {
  1290. if (*pszLine == 'n')
  1291. ++pszLine;
  1293. ///////////////////////////////////////////////////////////////////////////////
  1294. //  Skip SMTP code and ' ' or '-'
  1295. ///////////////////////////////////////////////////////////////////////////////
  1296. if (strlen(pszLine) < 4)
  1297. continue;
  1299. pszLine += 4;
  1301. ///////////////////////////////////////////////////////////////////////////////
  1302. //  SIZE suport detection
  1303. ///////////////////////////////////////////////////////////////////////////////
  1304. if ((strnicmp(pszLine, "SIZE", CStringSize("SIZE")) == 0) &&
  1305.     (strchr(" rn", pszLine[CStringSize("SIZE")]) != NULL)) {
  1306. pSmtpCh->ulFlags |= SMTPCH_SUPPORT_SIZE;
  1308. if ((pszLine[CStringSize("SIZE")] == ' ') &&
  1309.     isdigit(pszLine[CStringSize("SIZE") + 1]))
  1310. pSmtpCh->ulMaxMsgSize =
  1311.     (unsigned long) atol(pszLine + CStringSize("SIZE") + 1);
  1313. continue;
  1314. }
  1316. }
  1318. return (0);
  1320. }
  1322. SMTPCH_HANDLE USmtpCreateChannel(const char *pszServer, const char *pszDomain, SMTPError * pSMTPE)
  1323. {
  1324. ///////////////////////////////////////////////////////////////////////////////
  1325. //  Decode server address
  1326. ///////////////////////////////////////////////////////////////////////////////
  1327. int iPortNo = STD_SMTP_PORT;
  1328. char szAddress[MAX_ADDR_NAME] = "";
  1330. if (MscSplitAddressPort(pszServer, szAddress, iPortNo, STD_SMTP_PORT) < 0)
  1331. return (INVALID_SMTPCH_HANDLE);
  1333. SYS_INET_ADDR SvrAddr;
  1335. if (MscGetServerAddress(szAddress, SvrAddr, iPortNo) < 0)
  1336. return (INVALID_SMTPCH_HANDLE);
  1338. SYS_SOCKET SockFD = SysCreateSocket(AF_INET, SOCK_STREAM, 0);
  1340. if (SockFD == SYS_INVALID_SOCKET)
  1341. return (INVALID_SMTPCH_HANDLE);
  1343. if (SysConnect(SockFD, &SvrAddr, sizeof(SvrAddr), STD_SMTP_TIMEOUT) < 0) {
  1344. SysCloseSocket(SockFD);
  1345. return (INVALID_SMTPCH_HANDLE);
  1346. }
  1347. ///////////////////////////////////////////////////////////////////////////////
  1348. //  Check if We need to supply an HELO host
  1349. ///////////////////////////////////////////////////////////////////////////////
  1350. char szHeloHost[MAX_HOST_NAME] = "";
  1352. if (pszDomain == NULL) {
  1353. ///////////////////////////////////////////////////////////////////////////////
  1354. //  Get the DNS name of the local interface
  1355. ///////////////////////////////////////////////////////////////////////////////
  1356. if (MscGetSockHost(SockFD, szHeloHost) < 0) {
  1357. SYS_INET_ADDR SockInfo;
  1359. if (SysGetSockInfo(SockFD, SockInfo) < 0) {
  1360. SysCloseSocket(SockFD);
  1361. return (INVALID_SMTPCH_HANDLE);
  1362. }
  1364. char szIP[128] = "???.???.???.???";
  1366. StrSNCpy(szHeloHost, SysInetNToA(SockInfo, szIP));
  1367. }
  1369. pszDomain = szHeloHost;
  1370. }
  1371. ///////////////////////////////////////////////////////////////////////////////
  1372. //  Attach socket to buffered reader
  1373. ///////////////////////////////////////////////////////////////////////////////
  1374. BSOCK_HANDLE hBSock = BSckAttach(SockFD);
  1376. if (hBSock == INVALID_BSOCK_HANDLE) {
  1377. SysCloseSocket(SockFD);
  1378. return (INVALID_SMTPCH_HANDLE);
  1379. }
  1380. ///////////////////////////////////////////////////////////////////////////////
  1381. //  Read welcome message
  1382. ///////////////////////////////////////////////////////////////////////////////
  1383. SmtpChannel *pSmtpCh = (SmtpChannel *) SysAlloc(sizeof(SmtpChannel));
  1385. if (pSmtpCh == NULL) {
  1386. BSckDetach(hBSock, 1);
  1387. return (INVALID_SMTPCH_HANDLE);
  1388. }
  1390. pSmtpCh->hBSock = hBSock;
  1391. pSmtpCh->ulFlags = 0;
  1392. pSmtpCh->ulMaxMsgSize = 0;
  1393. pSmtpCh->SvrAddr = SvrAddr;
  1394. pSmtpCh->pszServer = SysStrDup(pszServer);
  1396. ///////////////////////////////////////////////////////////////////////////////
  1397. //  Read welcome message
  1398. ///////////////////////////////////////////////////////////////////////////////
  1399. int iSvrReponse = -1;
  1400. char szRTXBuffer[2048] = "";
  1402. if (!USmtpResponseClass(iSvrReponse = USmtpGetResponse(pSmtpCh->hBSock, szRTXBuffer,
  1403.        sizeof(szRTXBuffer) - 1), 200)) {
  1404. BSckDetach(pSmtpCh->hBSock, 1);
  1406. if (iSvrReponse > 0) {
  1407. if (pSMTPE != NULL)
  1408. USmtpSetError(pSMTPE, iSvrReponse, szRTXBuffer,
  1409.       pSmtpCh->pszServer);
  1411. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szRTXBuffer);
  1412. }
  1414. SysFree(pSmtpCh->pszServer);
  1415. SysFree(pSmtpCh);
  1417. return (INVALID_SMTPCH_HANDLE);
  1418. }
  1419. ///////////////////////////////////////////////////////////////////////////////
  1420. //  Try the EHLO ESMTP command before
  1421. ///////////////////////////////////////////////////////////////////////////////
  1422. SysSNPrintf(szRTXBuffer, sizeof(szRTXBuffer) - 1, "EHLO %s", pszDomain);
  1424. if (USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szRTXBuffer,
  1425.       szRTXBuffer,
  1426.       sizeof(szRTXBuffer) - 1), 200)) {
  1427. ///////////////////////////////////////////////////////////////////////////////
  1428. //  Parse EHLO response
  1429. ///////////////////////////////////////////////////////////////////////////////
  1430. if (USmtpParseEhloResponse(pSmtpCh, szRTXBuffer) < 0) {
  1431. BSckDetach(pSmtpCh->hBSock, 1);
  1432. SysFree(pSmtpCh->pszServer);
  1433. SysFree(pSmtpCh);
  1434. return (INVALID_SMTPCH_HANDLE);
  1435. }
  1437. } else {
  1438. ///////////////////////////////////////////////////////////////////////////////
  1439. //  Send HELO and read result
  1440. ///////////////////////////////////////////////////////////////////////////////
  1441. SysSNPrintf(szRTXBuffer, sizeof(szRTXBuffer) - 1, "HELO %s", pszDomain);
  1443. if (!USmtpResponseClass
  1444.     (iSvrReponse =
  1445.      USmtpSendCommand(pSmtpCh->hBSock, szRTXBuffer, szRTXBuffer,
  1446.       sizeof(szRTXBuffer) - 1), 200)) {
  1447. BSckDetach(pSmtpCh->hBSock, 1);
  1449. if (iSvrReponse > 0) {
  1450. if (pSMTPE != NULL)
  1451. USmtpSetError(pSMTPE, iSvrReponse, szRTXBuffer,
  1452.       pSmtpCh->pszServer);
  1454. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szRTXBuffer);
  1455. }
  1457. SysFree(pSmtpCh->pszServer);
  1458. SysFree(pSmtpCh);
  1460. return (INVALID_SMTPCH_HANDLE);
  1461. }
  1462. }
  1464. ///////////////////////////////////////////////////////////////////////////////
  1465. //  Check if We need authentication
  1466. ///////////////////////////////////////////////////////////////////////////////
  1467. if (USmtpServerAuthenticate(pSmtpCh, szAddress, pSMTPE) < 0) {
  1468. USmtpCloseChannel((SMTPCH_HANDLE) pSmtpCh, 0, pSMTPE);
  1470. return (INVALID_SMTPCH_HANDLE);
  1471. }
  1473. return ((SMTPCH_HANDLE) pSmtpCh);
  1475. }
  1477. int USmtpCloseChannel(SMTPCH_HANDLE hSmtpCh, int iHardClose, SMTPError * pSMTPE)
  1478. {
  1480. SmtpChannel *pSmtpCh = (SmtpChannel *) hSmtpCh;
  1482. if (!iHardClose) {
  1483. ///////////////////////////////////////////////////////////////////////////////
  1484. //  Send QUIT and read result
  1485. ///////////////////////////////////////////////////////////////////////////////
  1486. int iSvrReponse = -1;
  1487. char szRTXBuffer[2048] = "";
  1489. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, "QUIT",
  1490.        szRTXBuffer,
  1491.        sizeof(szRTXBuffer) - 1),
  1492. 200)) {
  1493. BSckDetach(pSmtpCh->hBSock, 1);
  1495. if (iSvrReponse > 0) {
  1496. if (pSMTPE != NULL)
  1497. USmtpSetError(pSMTPE, iSvrReponse, szRTXBuffer,
  1498.       pSmtpCh->pszServer);
  1500. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szRTXBuffer);
  1501. }
  1503. SysFree(pSmtpCh->pszServer);
  1504. SysFree(pSmtpCh);
  1506. return (ErrGetErrorCode());
  1507. }
  1508. }
  1510. BSckDetach(pSmtpCh->hBSock, 1);
  1512. SysFree(pSmtpCh->pszServer);
  1514. SysFree(pSmtpCh);
  1516. return (0);
  1518. }
  1520. int USmtpChannelReset(SMTPCH_HANDLE hSmtpCh, SMTPError * pSMTPE)
  1521. {
  1523. SmtpChannel *pSmtpCh = (SmtpChannel *) hSmtpCh;
  1525. ///////////////////////////////////////////////////////////////////////////////
  1526. //  Send RSET and read result
  1527. ///////////////////////////////////////////////////////////////////////////////
  1528. int iSvrReponse = -1;
  1529. char szRTXBuffer[2048] = "";
  1531. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, "RSET",
  1532.        szRTXBuffer,
  1533.        sizeof(szRTXBuffer) - 1), 200)) {
  1534. if (iSvrReponse > 0) {
  1535. if (pSMTPE != NULL)
  1536. USmtpSetError(pSMTPE, iSvrReponse, szRTXBuffer,
  1537.       pSmtpCh->pszServer);
  1539. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szRTXBuffer);
  1540. }
  1542. return (ErrGetErrorCode());
  1543. }
  1545. return (0);
  1547. }
  1549. int USmtpSendMail(SMTPCH_HANDLE hSmtpCh, const char *pszFrom, const char *pszRcpt,
  1550.   FileSection const *pFS, SMTPError * pSMTPE)
  1551. {
  1553. SmtpChannel *pSmtpCh = (SmtpChannel *) hSmtpCh;
  1555. ///////////////////////////////////////////////////////////////////////////////
  1556. //  Check message size ( if the remote server support the SIZE extension )
  1557. ///////////////////////////////////////////////////////////////////////////////
  1558. unsigned long ulMessageSize = 0;
  1560. if (pSmtpCh->ulMaxMsgSize != 0) {
  1561. if (MscGetSectionSize(pFS, &ulMessageSize) < 0)
  1562. return (ErrGetErrorCode());
  1564. if (ulMessageSize >= pSmtpCh->ulMaxMsgSize) {
  1565. if (pSMTPE != NULL)
  1566. USmtpSetError(pSMTPE, SMTP_FATAL_ERROR,
  1567.       ErrGetErrorString(ERR_SMTPSRV_MSG_SIZE),
  1568.       pSmtpCh->pszServer);
  1570. ErrSetErrorCode(ERR_SMTPSRV_MSG_SIZE);
  1571. return (ERR_SMTPSRV_MSG_SIZE);
  1572. }
  1573. }
  1574. ///////////////////////////////////////////////////////////////////////////////
  1575. //  Send MAIL FROM: and read result
  1576. ///////////////////////////////////////////////////////////////////////////////
  1577. int iSvrReponse = -1;
  1578. char szRTXBuffer[2048] = "";
  1580. if (pSmtpCh->ulFlags & SMTPCH_SUPPORT_SIZE) {
  1581. if ((ulMessageSize == 0) && (MscGetSectionSize(pFS, &ulMessageSize) < 0))
  1582. return (ErrGetErrorCode());
  1584. SysSNPrintf(szRTXBuffer, sizeof(szRTXBuffer) - 1, "MAIL FROM:<%s> SIZE=%lu",
  1585.     pszFrom, ulMessageSize);
  1586. } else
  1587. SysSNPrintf(szRTXBuffer, sizeof(szRTXBuffer) - 1, "MAIL FROM:<%s>", pszFrom);
  1589. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szRTXBuffer,
  1590.        szRTXBuffer,
  1591.        sizeof(szRTXBuffer) - 1), 200)) {
  1592. if (iSvrReponse > 0) {
  1593. if (pSMTPE != NULL)
  1594. USmtpSetError(pSMTPE, iSvrReponse, szRTXBuffer,
  1595.       pSmtpCh->pszServer);
  1597. ErrSetErrorCode(ERR_SMTP_BAD_MAIL_FROM, szRTXBuffer);
  1598. }
  1600. return (ErrGetErrorCode());
  1601. }
  1602. ///////////////////////////////////////////////////////////////////////////////
  1603. //  Send RCPT TO: and read result
  1604. ///////////////////////////////////////////////////////////////////////////////
  1605. SysSNPrintf(szRTXBuffer, sizeof(szRTXBuffer) - 1, "RCPT TO:<%s>", pszRcpt);
  1607. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, szRTXBuffer,
  1608.        szRTXBuffer,
  1609.        sizeof(szRTXBuffer) - 1), 200)) {
  1610. if (iSvrReponse > 0) {
  1611. if (pSMTPE != NULL)
  1612. USmtpSetError(pSMTPE, iSvrReponse, szRTXBuffer,
  1613.       pSmtpCh->pszServer);
  1615. ErrSetErrorCode(ERR_SMTP_BAD_RCPT_TO, szRTXBuffer);
  1616. }
  1618. return (ErrGetErrorCode());
  1619. }
  1620. ///////////////////////////////////////////////////////////////////////////////
  1621. //  Send DATA and read the "ready to receive"
  1622. ///////////////////////////////////////////////////////////////////////////////
  1623. if (!USmtpResponseClass(iSvrReponse = USmtpSendCommand(pSmtpCh->hBSock, "DATA",
  1624.        szRTXBuffer,
  1625.        sizeof(szRTXBuffer) - 1), 300)) {
  1626. if (iSvrReponse > 0) {
  1627. if (pSMTPE != NULL)
  1628. USmtpSetError(pSMTPE, iSvrReponse, szRTXBuffer,
  1629.       pSmtpCh->pszServer);
  1631. ErrSetErrorCode(ERR_SMTP_BAD_DATA, szRTXBuffer);
  1632. }
  1634. return (ErrGetErrorCode());
  1635. }
  1636. ///////////////////////////////////////////////////////////////////////////////
  1637. //  Send file
  1638. ///////////////////////////////////////////////////////////////////////////////
  1639. if (SysSendFile
  1640.     (BSckGetAttachedSocket(pSmtpCh->hBSock), pFS->szFilePath, pFS->ulStartOffset,
  1641.      pFS->ulEndOffset, STD_SMTP_TIMEOUT) < 0)
  1642. return (ErrGetErrorCode());
  1644. ///////////////////////////////////////////////////////////////////////////////
  1645. //  Send END OF DATA and read transfer result
  1646. ///////////////////////////////////////////////////////////////////////////////
  1647. if (BSckSendString(pSmtpCh->hBSock, ".", STD_SMTP_TIMEOUT) <= 0)
  1648. return (ErrGetErrorCode());
  1650. if (!USmtpResponseClass(iSvrReponse = USmtpGetResponse(pSmtpCh->hBSock, szRTXBuffer,
  1651.        sizeof(szRTXBuffer) - 1), 200)) {
  1652. if (iSvrReponse > 0) {
  1653. if (pSMTPE != NULL)
  1654. USmtpSetError(pSMTPE, iSvrReponse, szRTXBuffer,
  1655.       pSmtpCh->pszServer);
  1657. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, szRTXBuffer);
  1658. }
  1660. return (ErrGetErrorCode());
  1661. }
  1663. return (0);
  1665. }
  1667. int USmtpSendMail(const char *pszServer, const char *pszDomain,
  1668.   const char *pszFrom, const char *pszRcpt, FileSection const *pFS,
  1669.   SMTPError * pSMTPE)
  1670. {
  1671. ///////////////////////////////////////////////////////////////////////////////
  1672. //  Set server host name inside the SMTP error structure
  1673. ///////////////////////////////////////////////////////////////////////////////
  1674. if (pSMTPE != NULL)
  1675. USmtpSetErrorServer(pSMTPE, pszServer);
  1677. ///////////////////////////////////////////////////////////////////////////////
  1678. //  Open STMP channel and try to send the message
  1679. ///////////////////////////////////////////////////////////////////////////////
  1680. SMTPCH_HANDLE hSmtpCh = USmtpCreateChannel(pszServer, pszDomain, pSMTPE);
  1682. if (hSmtpCh == INVALID_SMTPCH_HANDLE)
  1683. return (ErrGetErrorCode());
  1685. int iResultCode = USmtpSendMail(hSmtpCh, pszFrom, pszRcpt, pFS, pSMTPE);
  1687. USmtpCloseChannel(hSmtpCh, 0, pSMTPE);
  1689. return (iResultCode);
  1691. }
  1693. char *USmtpBuildRcptPath(char const *const *ppszRcptTo, SVRCFG_HANDLE hSvrConfig)
  1694. {
  1696. int iRcptCount = StrStringsCount(ppszRcptTo);
  1697. char szDestDomain[MAX_HOST_NAME] = "";
  1699. if (USmtpSplitEmailAddr(ppszRcptTo[0], NULL, szDestDomain) < 0)
  1700. return (NULL);
  1702. ///////////////////////////////////////////////////////////////////////////////
  1703. //  Try to get routing path, if not found simply return an address concat
  1704. //  of "ppszRcptTo"
  1705. ///////////////////////////////////////////////////////////////////////////////
  1706. char szSpecMXHost[1024] = "";
  1708. if (USmtpGetGateway(hSvrConfig, szDestDomain, szSpecMXHost) < 0)
  1709. return (USmlAddrConcat(ppszRcptTo));
  1711. char *pszSendRcpt = USmlAddrConcat(ppszRcptTo);
  1713. if (pszSendRcpt == NULL)
  1714. return (NULL);
  1716. char *pszRcptPath = (char *) SysAlloc(strlen(pszSendRcpt) + strlen(szSpecMXHost) + 2);
  1718. if (iRcptCount == 1)
  1719. sprintf(pszRcptPath, "%s:%s", szSpecMXHost, pszSendRcpt);
  1720. else
  1721. sprintf(pszRcptPath, "%s,%s", szSpecMXHost, pszSendRcpt);
  1723. SysFree(pszSendRcpt);
  1725. return (pszRcptPath);
  1727. }
  1729. char **USmtpGetMailExchangers(SVRCFG_HANDLE hSvrConfig, const char *pszDomain)
  1730. {
  1731. ///////////////////////////////////////////////////////////////////////////////
  1732. //  Try to get default gateways
  1733. ///////////////////////////////////////////////////////////////////////////////
  1734. char *pszDefaultGws = SvrGetConfigVar(hSvrConfig, "DefaultSMTPGateways");
  1736. if (pszDefaultGws == NULL) {
  1737. ErrSetErrorCode(ERR_NO_PREDEFINED_MX);
  1738. return (NULL);
  1739. }
  1741. char **ppszMXGWs = StrTokenize(pszDefaultGws, ",; trn");
  1743. SysFree(pszDefaultGws);
  1745. return (ppszMXGWs);
  1747. }
  1749. static int USmtpGetDomainMX(SVRCFG_HANDLE hSvrConfig, const char *pszDomain, char *&pszMXDomains)
  1750. {
  1751. ///////////////////////////////////////////////////////////////////////////////
  1752. //  Exist a configured list of smart DNS hosts ?
  1753. ///////////////////////////////////////////////////////////////////////////////
  1754. char *pszSmartDNS = SvrGetConfigVar(hSvrConfig, "SmartDNSHost");
  1756. int iQueryResult = CDNS_GetDomainMX(pszDomain, pszMXDomains, pszSmartDNS);
  1758. if (pszSmartDNS != NULL)
  1759. SysFree(pszSmartDNS);
  1761. return (iQueryResult);
  1763. }
  1765. int USmtpCheckMailDomain(SVRCFG_HANDLE hSvrConfig, char const *pszDomain)
  1766. {
  1768. char *pszMXDomains = NULL;
  1769. NET_ADDRESS NetAddr;
  1771. if (USmtpGetDomainMX(hSvrConfig, pszDomain, pszMXDomains) < 0) {
  1772. if (SysGetHostByName(pszDomain, NetAddr) < 0) {
  1773. ErrSetErrorCode(ERR_INVALID_MAIL_DOMAIN);
  1774. return (ERR_INVALID_MAIL_DOMAIN);
  1775. }
  1776. } else
  1777. SysFree(pszMXDomains);
  1779. return (0);
  1781. }
  1783. MXS_HANDLE USmtpGetMXFirst(SVRCFG_HANDLE hSvrConfig, const char *pszDomain, char *pszMXHost)
  1784. {
  1786. ///////////////////////////////////////////////////////////////////////////////
  1787. //  Make a DNS query for domain MXs
  1788. ///////////////////////////////////////////////////////////////////////////////
  1789. char *pszMXHosts = NULL;
  1791. if (USmtpGetDomainMX(hSvrConfig, pszDomain, pszMXHosts) < 0)
  1792. return (INVALID_MXS_HANDLE);
  1794. ///////////////////////////////////////////////////////////////////////////////
  1795. //  MX records structure allocation
  1796. ///////////////////////////////////////////////////////////////////////////////
  1797. SmtpMXRecords *pMXR = (SmtpMXRecords *) SysAlloc(sizeof(SmtpMXRecords));
  1799. if (pMXR == NULL) {
  1800. SysFree(pszMXHosts);
  1801. return (INVALID_MXS_HANDLE);
  1802. }
  1804. pMXR->iNumMXRecords = 0;
  1805. pMXR->iCurrMxCost = -1;
  1807. ///////////////////////////////////////////////////////////////////////////////
  1808. //  MX hosts string format = c:h[,c:h]  where "c = cost" and "h = hosts"
  1809. ///////////////////////////////////////////////////////////////////////////////
  1810. int iMXCost = INT_MAX;
  1811. int iCurrIndex = -1;
  1812. char *pszToken = NULL;
  1813. char *pszSavePtr = NULL;
  1815. pszToken = SysStrTok(pszMXHosts, ":, trn", &pszSavePtr);
  1817. while ((pMXR->iNumMXRecords < MAX_MX_RECORDS) && (pszToken != NULL)) {
  1818. ///////////////////////////////////////////////////////////////////////////////
  1819. //  Get MX cost
  1820. ///////////////////////////////////////////////////////////////////////////////
  1821. int iCost = atoi(pszToken);
  1823. if ((pszToken = SysStrTok(NULL, ":, trn", &pszSavePtr)) == NULL) {
  1824. for (--pMXR->iNumMXRecords; pMXR->iNumMXRecords >= 0;
  1825.      pMXR->iNumMXRecords--)
  1826. SysFree(pMXR->pszMXName[pMXR->iNumMXRecords]);
  1827. SysFree(pMXR);
  1829. SysFree(pszMXHosts);
  1831. ErrSetErrorCode(ERR_INVALID_MXRECS_STRING);
  1832. return (INVALID_MXS_HANDLE);
  1833. }
  1835. pMXR->iMXCost[pMXR->iNumMXRecords] = iCost;
  1836. pMXR->pszMXName[pMXR->iNumMXRecords] = SysStrDup(pszToken);
  1838. if ((iCost < iMXCost) && (iCost >= pMXR->iCurrMxCost)) {
  1839. iMXCost = iCost;
  1841. strcpy(pszMXHost, pMXR->pszMXName[pMXR->iNumMXRecords]);
  1843. iCurrIndex = pMXR->iNumMXRecords;
  1844. }
  1846. ++pMXR->iNumMXRecords;
  1848. pszToken = SysStrTok(NULL, ":, trn", &pszSavePtr);
  1849. }
  1851. SysFree(pszMXHosts);
  1853. if (iMXCost == INT_MAX) {
  1854. for (--pMXR->iNumMXRecords; pMXR->iNumMXRecords >= 0; pMXR->iNumMXRecords--)
  1855. SysFree(pMXR->pszMXName[pMXR->iNumMXRecords]);
  1856. SysFree(pMXR);
  1858. ErrSetErrorCode(ERR_INVALID_MXRECS_STRING);
  1859. return (INVALID_MXS_HANDLE);
  1860. }
  1862. pMXR->iCurrMxCost = iMXCost;
  1863. pMXR->iMXCost[iCurrIndex] = iMXCost - 1;
  1865. return ((MXS_HANDLE) pMXR);
  1867. }
  1869. int USmtpGetMXNext(MXS_HANDLE hMXSHandle, char *pszMXHost)
  1870. {
  1872. SmtpMXRecords *pMXR = (SmtpMXRecords *) hMXSHandle;
  1874. int iMXCost = INT_MAX;
  1875. int iCurrIndex = -1;
  1877. for (int ii = 0; ii < pMXR->iNumMXRecords; ii++) {
  1878. if ((pMXR->iMXCost[ii] < iMXCost) && (pMXR->iMXCost[ii] >= pMXR->iCurrMxCost)) {
  1879. iMXCost = pMXR->iMXCost[ii];
  1881. strcpy(pszMXHost, pMXR->pszMXName[ii]);
  1883. iCurrIndex = ii;
  1884. }
  1885. }
  1887. if (iMXCost == INT_MAX) {
  1888. ErrSetErrorCode(ERR_NO_MORE_MXRECORDS);
  1889. return (ERR_NO_MORE_MXRECORDS);
  1890. }
  1892. pMXR->iCurrMxCost = iMXCost;
  1893. pMXR->iMXCost[iCurrIndex] = iMXCost - 1;
  1895. return (0);
  1897. }
  1899. void USmtpMXSClose(MXS_HANDLE hMXSHandle)
  1900. {
  1902. SmtpMXRecords *pMXR = (SmtpMXRecords *) hMXSHandle;
  1904. for (--pMXR->iNumMXRecords; pMXR->iNumMXRecords >= 0; pMXR->iNumMXRecords--)
  1905. SysFree(pMXR->pszMXName[pMXR->iNumMXRecords]);
  1907. SysFree(pMXR);
  1909. }
  1911. bool USmtpDnsMapsContained(SYS_INET_ADDR const &PeerInfo, char const *pszMapsServer)
  1912. {
  1914. SYS_UINT8 AddrBytes[sizeof(NET_ADDRESS)];
  1916. SysGetAddrAddress(PeerInfo, *((NET_ADDRESS *) AddrBytes));
  1918. char szMapsQuery[256] = "";
  1920. sprintf(szMapsQuery, "%u.%u.%u.%u.%s",
  1921. (unsigned int) AddrBytes[3], (unsigned int) AddrBytes[2],
  1922. (unsigned int) AddrBytes[1], (unsigned int) AddrBytes[0], pszMapsServer);
  1924. NET_ADDRESS NetAddr;
  1926. return ((SysGetHostByName(szMapsQuery, NetAddr) < 0) ? false : true);
  1928. }
  1930. static char *USmtpGetSpammersFilePath(char *pszSpamFilePath, int iMaxPath)
  1931. {
  1933. CfgGetRootPath(pszSpamFilePath, iMaxPath);
  1935. StrNCat(pszSpamFilePath, SMTP_SPAMMERS_FILE, iMaxPath);
  1937. return (pszSpamFilePath);
  1939. }
  1941. int USmtpSpammerCheck(const SYS_INET_ADDR & PeerInfo, char *&pszInfo)
  1942. {
  1944. pszInfo = NULL;
  1946. char szSpammersFilePath[SYS_MAX_PATH] = "";
  1948. USmtpGetSpammersFilePath(szSpammersFilePath, sizeof(szSpammersFilePath));
  1950. char szResLock[SYS_MAX_PATH] = "";
  1951. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szSpammersFilePath, szResLock,
  1952.   sizeof(szResLock)));
  1954. if (hResLock == INVALID_RLCK_HANDLE)
  1955. return (ErrGetErrorCode());
  1957. FILE *pSpammersFile = fopen(szSpammersFilePath, "rt");
  1959. if (pSpammersFile == NULL) {
  1960. RLckUnlockSH(hResLock);
  1962. ErrSetErrorCode(ERR_FILE_OPEN);
  1963. return (ERR_FILE_OPEN);
  1964. }
  1966. NET_ADDRESS TestAddr;
  1968. SysGetAddrAddress(PeerInfo, TestAddr);
  1970. char szSpammerLine[SPAMMERS_LINE_MAX] = "";
  1972. while (MscGetConfigLine(szSpammerLine, sizeof(szSpammerLine) - 1, pSpammersFile) != NULL) {
  1973. char **ppszStrings = StrGetTabLineStrings(szSpammerLine);
  1975. if (ppszStrings == NULL)
  1976. continue;
  1978. int iFieldsCount = StrStringsCount(ppszStrings);
  1980. if (iFieldsCount < 1) {
  1981. StrFreeStrings(ppszStrings);
  1982. continue;
  1983. }
  1985. int iAddrFields = 1;
  1987. if ((iFieldsCount > 1) && isdigit(ppszStrings[1][0]))
  1988. iAddrFields = 2;
  1990. AddressFilter AF;
  1992. if ((MscLoadAddressFilter(ppszStrings, iAddrFields, AF) == 0) &&
  1993.     MscAddressMatch(AF, TestAddr)) {
  1994. if (iFieldsCount > iAddrFields)
  1995. pszInfo = SysStrDup(ppszStrings[iAddrFields]);
  1997. StrFreeStrings(ppszStrings);
  1998. fclose(pSpammersFile);
  1999. RLckUnlockSH(hResLock);
  2001. char szIP[128] = "???.???.???.???";
  2003. ErrSetErrorCode(ERR_SPAMMER_IP, SysInetNToA(PeerInfo, szIP));
  2004. return (ERR_SPAMMER_IP);
  2005. }
  2007. StrFreeStrings(ppszStrings);
  2008. }
  2010. fclose(pSpammersFile);
  2012. RLckUnlockSH(hResLock);
  2014. return (0);
  2016. }
  2018. static char *USmtpGetSpamAddrFilePath(char *pszSpamFilePath, int iMaxPath)
  2019. {
  2021. CfgGetRootPath(pszSpamFilePath, iMaxPath);
  2023. StrNCat(pszSpamFilePath, SMTP_SPAM_ADDRESS_FILE, iMaxPath);
  2025. return (pszSpamFilePath);
  2027. }
  2029. int USmtpSpamAddressCheck(char const *pszAddress)
  2030. {
  2032. char szSpammersFilePath[SYS_MAX_PATH] = "";
  2034. USmtpGetSpamAddrFilePath(szSpammersFilePath, sizeof(szSpammersFilePath));
  2036. char szResLock[SYS_MAX_PATH] = "";
  2037. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szSpammersFilePath, szResLock,
  2038.   sizeof(szResLock)));
  2040. if (hResLock == INVALID_RLCK_HANDLE)
  2041. return (ErrGetErrorCode());
  2043. FILE *pSpammersFile = fopen(szSpammersFilePath, "rt");
  2045. if (pSpammersFile == NULL) {
  2046. RLckUnlockSH(hResLock);
  2047. return (0);
  2048. }
  2050. char szSpammerLine[SPAM_ADDRESS_LINE_MAX] = "";
  2052. while (MscGetConfigLine(szSpammerLine, sizeof(szSpammerLine) - 1, pSpammersFile) != NULL) {
  2053. char **ppszStrings = StrGetTabLineStrings(szSpammerLine);
  2055. if (ppszStrings == NULL)
  2056. continue;
  2058. int iFieldsCount = StrStringsCount(ppszStrings);
  2060. if ((iFieldsCount > 0) && StrIWildMatch(pszAddress, ppszStrings[0])) {
  2061. StrFreeStrings(ppszStrings);
  2062. fclose(pSpammersFile);
  2063. RLckUnlockSH(hResLock);
  2065. ErrSetErrorCode(ERR_SPAM_ADDRESS, pszAddress);
  2066. return (ERR_SPAM_ADDRESS);
  2067. }
  2069. StrFreeStrings(ppszStrings);
  2070. }
  2072. fclose(pSpammersFile);
  2074. RLckUnlockSH(hResLock);
  2076. return (0);
  2078. }
  2080. int USmtpAddMessageInfo(FILE * pMsgFile, char const *pszClientDomain,
  2081. SYS_INET_ADDR const &PeerInfo, char const *pszServerDomain,
  2082. SYS_INET_ADDR const &SockInfo, char const *pszSmtpServerLogo)
  2083. {
  2085. char szTime[256] = "";
  2087. MscGetTimeStr(szTime, sizeof(szTime) - 1);
  2089. char szPeerIP[128] = "";
  2090. char szSockIP[128] = "";
  2092. SysInetNToA(PeerInfo, szPeerIP);
  2093. SysInetNToA(SockInfo, szSockIP);
  2095. ///////////////////////////////////////////////////////////////////////////////
  2096. //  Write message info. If You change the order ( or add new fields ) You must
  2097. //  arrange fields into the SmtpMsgInfo union defined in SMTPUtils.h
  2098. ///////////////////////////////////////////////////////////////////////////////
  2099. fprintf(pMsgFile, "%s;[%s]:%d;%s;[%s]:%d;%s;%srn",
  2100. pszClientDomain, szPeerIP, SysGetAddrPort(PeerInfo),
  2101. pszServerDomain, szSockIP, SysGetAddrPort(SockInfo), szTime, pszSmtpServerLogo);
  2103. return (0);
  2105. }
  2107. int USmtpWriteInfoLine(FILE * pSpoolFile, char const *pszClientAddr,
  2108.        char const *pszServerAddr, char const *pszTime)
  2109. {
  2111. fprintf(pSpoolFile, "%s;%s;%srn", pszClientAddr, pszServerAddr, pszTime);
  2113. return (0);
  2115. }
  2117. char *USmtpGetReceived(int iType, char const *pszAuth, char const *const *ppszMsgInfo,
  2118.        char const *pszMailFrom, char const *pszRcptTo, char const *pszMessageID)
  2119. {
  2121. char szFrom[MAX_SMTP_ADDRESS] = "";
  2122. char szRcpt[MAX_SMTP_ADDRESS] = "";
  2124. if ((USmlParseAddress(pszMailFrom, NULL, 0, szFrom, sizeof(szFrom) - 1) < 0) ||
  2125.     (USmlParseAddress(pszRcptTo, NULL, 0, szRcpt, sizeof(szRcpt) - 1) < 0))
  2126. return (NULL);
  2128. ///////////////////////////////////////////////////////////////////////////////
  2129. //  Parse special types to hide client info
  2130. ///////////////////////////////////////////////////////////////////////////////
  2131. bool bHideClient = false;
  2133. if (iType == RECEIVED_TYPE_AUTHSTD) {
  2134. bHideClient = (pszAuth != NULL) && !IsEmptyString(pszAuth);
  2135. iType = RECEIVED_TYPE_STD;
  2136. } else if (iType == RECEIVED_TYPE_AUTHVERBOSE) {
  2137. bHideClient = (pszAuth != NULL) && !IsEmptyString(pszAuth);
  2138. iType = RECEIVED_TYPE_VERBOSE;
  2139. }
  2140. ///////////////////////////////////////////////////////////////////////////////
  2141. //  Return "Received:" tag
  2142. ///////////////////////////////////////////////////////////////////////////////
  2143. char *pszReceived = NULL;
  2145. switch (iType) {
  2146. case (RECEIVED_TYPE_STRICT):
  2147. pszReceived = StrSprint("Received: from %srn"
  2148. "tby %s with %srn"
  2149. "tid <%s> for <%s> from <%s>;rn"
  2150. "t%srn", ppszMsgInfo[smsgiClientDomain],
  2151. ppszMsgInfo[smsgiServerDomain],
  2152. ppszMsgInfo[smsgiSeverName], pszMessageID, szRcpt, szFrom,
  2153. ppszMsgInfo[smsgiTime]);
  2154. break;
  2156. case (RECEIVED_TYPE_VERBOSE):
  2157. if (!bHideClient)
  2158. pszReceived = StrSprint("Received: from %s (%s)rn"
  2159. "tby %s (%s) with %srn"
  2160. "tid <%s> for <%s> from <%s>;rn"
  2161. "t%srn", ppszMsgInfo[smsgiClientDomain],
  2162. ppszMsgInfo[smsgiClientAddr],
  2163. ppszMsgInfo[smsgiServerDomain],
  2164. ppszMsgInfo[smsgiServerAddr],
  2165. ppszMsgInfo[smsgiSeverName], pszMessageID, szRcpt,
  2166. szFrom, ppszMsgInfo[smsgiTime]);
  2167. else
  2168. pszReceived = StrSprint("Received: from %srn"
  2169. "tby %s (%s) with %srn"
  2170. "tid <%s> for <%s> from <%s>;rn"
  2171. "t%srn", ppszMsgInfo[smsgiClientDomain],
  2172. ppszMsgInfo[smsgiServerDomain],
  2173. ppszMsgInfo[smsgiServerAddr],
  2174. ppszMsgInfo[smsgiSeverName], pszMessageID, szRcpt,
  2175. szFrom, ppszMsgInfo[smsgiTime]);
  2176. break;
  2178. case (RECEIVED_TYPE_STD):
  2179. default:
  2180. if (!bHideClient)
  2181. pszReceived = StrSprint("Received: from %s (%s)rn"
  2182. "tby %s with %srn"
  2183. "tid <%s> for <%s> from <%s>;rn"
  2184. "t%srn", ppszMsgInfo[smsgiClientDomain],
  2185. ppszMsgInfo[smsgiClientAddr],
  2186. ppszMsgInfo[smsgiServerDomain],
  2187. ppszMsgInfo[smsgiSeverName], pszMessageID, szRcpt,
  2188. szFrom, ppszMsgInfo[smsgiTime]);
  2189. else
  2190. pszReceived = StrSprint("Received: from %srn"
  2191. "tby %s with %srn"
  2192. "tid <%s> for <%s> from <%s>;rn"
  2193. "t%srn", ppszMsgInfo[smsgiClientDomain],
  2194. ppszMsgInfo[smsgiServerDomain],
  2195. ppszMsgInfo[smsgiSeverName], pszMessageID, szRcpt,
  2196. szFrom, ppszMsgInfo[smsgiTime]);
  2197. break;
  2198. }
  2200. return (pszReceived);
  2202. }