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

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

Email服务器

开发平台：

Visual C++

AliasDomain.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 "MessQueue.h"
  33. #include "MailSvr.h"
  34. #include "MiscUtils.h"
  35. #include "SvrUtils.h"
  36. #include "POP3GwLink.h"
  37. #include "ExtAliases.h"
  38. #include "UsrUtils.h"
  39. #include "UsrAuth.h"
  40. #include "TabIndex.h"
  41. #include "MailDomains.h"
  42. #include "AliasDomain.h"
  44. #define ADOMAIN_FILE                "aliasdomain.tab"
  45. #define WILD_ADOMAIN_HASH           0
  46. #define ADOMAIN_LINE_MAX            512
  48. struct ADomainScanData {
  49. char szTmpDBFile[SYS_MAX_PATH];
  50. FILE *pDBFile;
  51. char **ppszStrings;
  52. };
  54. static bool ADomIsWildAlias(char const *pszAlias);
  55. static int ADomCalcAliasHash(char const *const *ppszTabTokens, int const *piFieldsIdx,
  56.      SYS_UINT32 * puHashVal, bool bCaseSens);
  57. static int ADomRebuildADomainIndexes(char const *pszADomainFilePath);
  58. static char *ADomGetADomainFilePath(char *pszADomainFilePath, int iMaxPath);
  59. static int ADomLookupDomainLK(const char *pszADomainFilePath, const char *pszADomain,
  60.       char *pszDomain, bool bWildMatch);
  62. static int iIdxADomain_Alias[] = {
  63. adomADomain,
  65. INDEX_SEQUENCE_TERMINATOR
  66. };
  68. static bool ADomIsWildAlias(char const *pszAlias)
  69. {
  71. return ((strchr(pszAlias, '*') != NULL) || (strchr(pszAlias, '?') != NULL));
  73. }
  75. static int ADomCalcAliasHash(char const *const *ppszTabTokens, int const *piFieldsIdx,
  76.      SYS_UINT32 * puHashVal, bool bCaseSens)
  77. {
  78. ///////////////////////////////////////////////////////////////////////////////
  79. //  This will group wild alias ( * ? )
  80. ///////////////////////////////////////////////////////////////////////////////
  81. int iFieldsCount = StrStringsCount(ppszTabTokens);
  83. if ((iFieldsCount > adomADomain) && ADomIsWildAlias(ppszTabTokens[adomADomain])) {
  84. *puHashVal = WILD_ADOMAIN_HASH;
  86. return (0);
  87. }
  89. return (TbixCalculateHash(ppszTabTokens, piFieldsIdx, puHashVal, bCaseSens));
  91. }
  93. int ADomCheckDomainsIndexes(void)
  94. {
  96. char szADomainFilePath[SYS_MAX_PATH] = "";
  98. ADomGetADomainFilePath(szADomainFilePath, sizeof(szADomainFilePath));
  100. ///////////////////////////////////////////////////////////////////////////////
  101. //  Align RmtDomain-RmtName index
  102. ///////////////////////////////////////////////////////////////////////////////
  103. if (TbixCheckIndex(szADomainFilePath, iIdxADomain_Alias, false, ADomCalcAliasHash) < 0)
  104. return (ErrGetErrorCode());
  106. return (0);
  108. }
  110. static int ADomRebuildADomainIndexes(char const *pszADomainFilePath)
  111. {
  112. ///////////////////////////////////////////////////////////////////////////////
  113. //  Rebuild RmtDomain-RmtName index
  114. ///////////////////////////////////////////////////////////////////////////////
  115. if (TbixCreateIndex(pszADomainFilePath, iIdxADomain_Alias, false, ADomCalcAliasHash) < 0)
  116. return (ErrGetErrorCode());
  118. return (0);
  120. }
  122. static char *ADomGetADomainFilePath(char *pszADomainFilePath, int iMaxPath)
  123. {
  125. CfgGetRootPath(pszADomainFilePath, iMaxPath);
  127. StrNCat(pszADomainFilePath, ADOMAIN_FILE, iMaxPath);
  129. return (pszADomainFilePath);
  131. }
  133. static int ADomLookupDomainLK(const char *pszADomainFilePath, const char *pszADomain,
  134.       char *pszDomain, bool bWildMatch)
  135. {
  136. ///////////////////////////////////////////////////////////////////////////////
  137. //  Lookup record using the specified index ( lookup precise aliases )
  138. ///////////////////////////////////////////////////////////////////////////////
  139. char **ppszTabTokens = TbixLookup(pszADomainFilePath, iIdxADomain_Alias, false,
  140.   pszADomain,
  141.   NULL);
  143. if (ppszTabTokens != NULL) {
  144. if (pszDomain != NULL)
  145. StrNCpy(pszDomain, ppszTabTokens[adomDomain], MAX_HOST_NAME);
  147. StrFreeStrings(ppszTabTokens);
  149. return (1);
  150. }
  151. ///////////////////////////////////////////////////////////////////////////////
  152. //  We can stop here if wild alias matching is not required
  153. ///////////////////////////////////////////////////////////////////////////////
  154. if (!bWildMatch)
  155. return (0);
  157. ///////////////////////////////////////////////////////////////////////////////
  158. //  Lookup record using the specified index ( lookup wild aliases grouped
  159. //  under WILD_ADOMAIN_HASH hash key )
  160. ///////////////////////////////////////////////////////////////////////////////
  161. INDEX_HANDLE hIndexLookup = TbixOpenHandle(pszADomainFilePath, iIdxADomain_Alias,
  162.    WILD_ADOMAIN_HASH);
  164. if (hIndexLookup != INVALID_INDEX_HANDLE) {
  165. int iNumRecords = TbixLookedUpRecords(hIndexLookup);
  167. for (int ii = 0; ii < iNumRecords; ii++) {
  168. char **ppszTabTokens = TbixGetRecord(hIndexLookup, ii);
  170. if (ppszTabTokens == NULL)
  171. continue;
  173. int iFieldsCount = StrStringsCount(ppszTabTokens);
  175. if ((iFieldsCount >= adomMax) &&
  176.     StrIWildMatch(pszADomain, ppszTabTokens[adomADomain])) {
  177. if (pszDomain != NULL)
  178. StrNCpy(pszDomain, ppszTabTokens[adomDomain],
  179. MAX_HOST_NAME);
  181. StrFreeStrings(ppszTabTokens);
  182. TbixCloseHandle(hIndexLookup);
  184. return (1);
  185. }
  187. StrFreeStrings(ppszTabTokens);
  188. }
  190. TbixCloseHandle(hIndexLookup);
  191. }
  193. return (0);
  195. }
  197. int ADomLookupDomain(const char *pszADomain, char *pszDomain, bool bWildMatch)
  198. {
  200. char szADomainFilePath[SYS_MAX_PATH] = "";
  202. ADomGetADomainFilePath(szADomainFilePath, sizeof(szADomainFilePath));
  204. char szResLock[SYS_MAX_PATH] = "";
  205. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szADomainFilePath, szResLock,
  206.   sizeof(szResLock)));
  208. if (hResLock == INVALID_RLCK_HANDLE)
  209. return (0);
  211. int iLookupResult = ADomLookupDomainLK(szADomainFilePath, pszADomain,
  212.        pszDomain, bWildMatch);
  214. RLckUnlockSH(hResLock);
  216. return (iLookupResult);
  218. }
  220. int ADomAddADomain(char const *pszADomain, char const *pszDomain)
  221. {
  223. char szADomainFilePath[SYS_MAX_PATH] = "";
  225. ADomGetADomainFilePath(szADomainFilePath, sizeof(szADomainFilePath));
  227. char szResLock[SYS_MAX_PATH] = "";
  228. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szADomainFilePath, szResLock,
  229.   sizeof(szResLock)));
  231. if (hResLock == INVALID_RLCK_HANDLE)
  232. return (ErrGetErrorCode());
  234. FILE *pDomainsFile = fopen(szADomainFilePath, "r+t");
  236. if (pDomainsFile == NULL) {
  237. RLckUnlockEX(hResLock);
  239. ErrSetErrorCode(ERR_ADOMAIN_FILE_NOT_FOUND);
  240. return (ERR_ADOMAIN_FILE_NOT_FOUND);
  241. }
  243. char szADomainLine[ADOMAIN_LINE_MAX] = "";
  245. while (MscFGets(szADomainLine, sizeof(szADomainLine) - 1, pDomainsFile) != NULL) {
  246. char **ppszStrings = StrGetTabLineStrings(szADomainLine);
  248. if (ppszStrings == NULL)
  249. continue;
  251. int iFieldsCount = StrStringsCount(ppszStrings);
  253. if ((iFieldsCount >= adomMax) &&
  254.     (stricmp(pszADomain, ppszStrings[adomADomain]) == 0)) {
  255. StrFreeStrings(ppszStrings);
  256. fclose(pDomainsFile);
  257. RLckUnlockEX(hResLock);
  259. ErrSetErrorCode(ERR_ADOMAIN_EXIST);
  260. return (ERR_ADOMAIN_EXIST);
  261. }
  263. StrFreeStrings(ppszStrings);
  264. }
  266. fseek(pDomainsFile, 0, SEEK_END);
  268. fprintf(pDomainsFile, ""%s"t"%s"n", pszADomain, pszDomain);
  270. fclose(pDomainsFile);
  272. ///////////////////////////////////////////////////////////////////////////////
  273. //  Rebuild indexes
  274. ///////////////////////////////////////////////////////////////////////////////
  275. if (ADomRebuildADomainIndexes(szADomainFilePath) < 0) {
  276. ErrorPush();
  277. RLckUnlockEX(hResLock);
  278. return (ErrorPop());
  279. }
  281. RLckUnlockEX(hResLock);
  283. return (0);
  285. }
  287. int ADomRemoveADomain(char const *pszADomain)
  288. {
  290. char szADomainFilePath[SYS_MAX_PATH] = "";
  292. ADomGetADomainFilePath(szADomainFilePath, sizeof(szADomainFilePath));
  294. char szTmpFile[SYS_MAX_PATH] = "";
  296. SysGetTmpFile(szTmpFile);
  298. char szResLock[SYS_MAX_PATH] = "";
  299. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szADomainFilePath, szResLock,
  300.   sizeof(szResLock)));
  302. if (hResLock == INVALID_RLCK_HANDLE) {
  303. ErrorPush();
  304. CheckRemoveFile(szTmpFile);
  305. return (ErrorPop());
  306. }
  308. FILE *pDomainsFile = fopen(szADomainFilePath, "rt");
  310. if (pDomainsFile == NULL) {
  311. RLckUnlockEX(hResLock);
  312. CheckRemoveFile(szTmpFile);
  314. ErrSetErrorCode(ERR_ADOMAIN_FILE_NOT_FOUND);
  315. return (ERR_ADOMAIN_FILE_NOT_FOUND);
  316. }
  318. FILE *pTmpFile = fopen(szTmpFile, "wt");
  320. if (pTmpFile == NULL) {
  321. fclose(pDomainsFile);
  322. RLckUnlockEX(hResLock);
  323. CheckRemoveFile(szTmpFile);
  325. ErrSetErrorCode(ERR_FILE_CREATE, szTmpFile);
  326. return (ERR_FILE_CREATE);
  327. }
  329. int iADomainFound = 0;
  330. char szADomainLine[ADOMAIN_LINE_MAX] = "";
  332. while (MscFGets(szADomainLine, sizeof(szADomainLine) - 1, pDomainsFile) != NULL) {
  333. char **ppszStrings = StrGetTabLineStrings(szADomainLine);
  335. if (ppszStrings == NULL)
  336. continue;
  338. int iFieldsCount = StrStringsCount(ppszStrings);
  340. if ((iFieldsCount >= adomMax) &&
  341.     (stricmp(pszADomain, ppszStrings[adomADomain]) == 0)) {
  343. ++iADomainFound;
  345. } else
  346. fprintf(pTmpFile, "%sn", szADomainLine);
  348. StrFreeStrings(ppszStrings);
  349. }
  351. fclose(pDomainsFile);
  352. fclose(pTmpFile);
  354. if (iADomainFound == 0) {
  355. SysRemove(szTmpFile);
  356. RLckUnlockEX(hResLock);
  358. ErrSetErrorCode(ERR_ADOMAIN_NOT_FOUND);
  359. return (ERR_ADOMAIN_NOT_FOUND);
  360. }
  362. char szTmpADomainFilePath[SYS_MAX_PATH] = "";
  364. sprintf(szTmpADomainFilePath, "%s.tmp", szADomainFilePath);
  366. if (MscMoveFile(szADomainFilePath, szTmpADomainFilePath) < 0) {
  367. ErrorPush();
  368. RLckUnlockEX(hResLock);
  369. return (ErrorPop());
  370. }
  372. if (MscMoveFile(szTmpFile, szADomainFilePath) < 0) {
  373. ErrorPush();
  374. MscMoveFile(szTmpADomainFilePath, szADomainFilePath);
  375. RLckUnlockEX(hResLock);
  376. return (ErrorPop());
  377. }
  379. SysRemove(szTmpADomainFilePath);
  381. ///////////////////////////////////////////////////////////////////////////////
  382. //  Rebuild indexes
  383. ///////////////////////////////////////////////////////////////////////////////
  384. if (ADomRebuildADomainIndexes(szADomainFilePath) < 0) {
  385. ErrorPush();
  386. RLckUnlockEX(hResLock);
  387. return (ErrorPop());
  388. }
  390. RLckUnlockEX(hResLock);
  392. return (0);
  394. }
  396. int ADomRemoveLinkedDomains(char const *pszDomain)
  397. {
  399. char szADomainFilePath[SYS_MAX_PATH] = "";
  401. ADomGetADomainFilePath(szADomainFilePath, sizeof(szADomainFilePath));
  403. char szTmpFile[SYS_MAX_PATH] = "";
  405. SysGetTmpFile(szTmpFile);
  407. char szResLock[SYS_MAX_PATH] = "";
  408. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szADomainFilePath, szResLock,
  409.   sizeof(szResLock)));
  411. if (hResLock == INVALID_RLCK_HANDLE) {
  412. ErrorPush();
  413. CheckRemoveFile(szTmpFile);
  414. return (ErrorPop());
  415. }
  417. FILE *pDomainsFile = fopen(szADomainFilePath, "rt");
  419. if (pDomainsFile == NULL) {
  420. RLckUnlockEX(hResLock);
  421. CheckRemoveFile(szTmpFile);
  423. ErrSetErrorCode(ERR_ADOMAIN_FILE_NOT_FOUND);
  424. return (ERR_ADOMAIN_FILE_NOT_FOUND);
  425. }
  427. FILE *pTmpFile = fopen(szTmpFile, "wt");
  429. if (pTmpFile == NULL) {
  430. fclose(pDomainsFile);
  431. RLckUnlockEX(hResLock);
  432. CheckRemoveFile(szTmpFile);
  434. ErrSetErrorCode(ERR_FILE_CREATE, szTmpFile);
  435. return (ERR_FILE_CREATE);
  436. }
  438. int iDomainFound = 0;
  439. char szADomainLine[ADOMAIN_LINE_MAX] = "";
  441. while (MscFGets(szADomainLine, sizeof(szADomainLine) - 1, pDomainsFile) != NULL) {
  442. char **ppszStrings = StrGetTabLineStrings(szADomainLine);
  444. if (ppszStrings == NULL)
  445. continue;
  447. int iFieldsCount = StrStringsCount(ppszStrings);
  449. if ((iFieldsCount >= adomMax) &&
  450.     (stricmp(pszDomain, ppszStrings[adomDomain]) == 0)) {
  452. ++iDomainFound;
  454. } else
  455. fprintf(pTmpFile, "%sn", szADomainLine);
  457. StrFreeStrings(ppszStrings);
  458. }
  460. fclose(pDomainsFile);
  461. fclose(pTmpFile);
  463. if (iDomainFound == 0) {
  464. SysRemove(szTmpFile);
  465. RLckUnlockEX(hResLock);
  466. return (0);
  467. }
  469. char szTmpADomainFilePath[SYS_MAX_PATH] = "";
  471. sprintf(szTmpADomainFilePath, "%s.tmp", szADomainFilePath);
  473. if (MscMoveFile(szADomainFilePath, szTmpADomainFilePath) < 0) {
  474. ErrorPush();
  475. RLckUnlockEX(hResLock);
  476. return (ErrorPop());
  477. }
  479. if (MscMoveFile(szTmpFile, szADomainFilePath) < 0) {
  480. ErrorPush();
  481. MscMoveFile(szTmpADomainFilePath, szADomainFilePath);
  482. RLckUnlockEX(hResLock);
  483. return (ErrorPop());
  484. }
  486. SysRemove(szTmpADomainFilePath);
  488. ///////////////////////////////////////////////////////////////////////////////
  489. //  Rebuild indexes
  490. ///////////////////////////////////////////////////////////////////////////////
  491. if (ADomRebuildADomainIndexes(szADomainFilePath) < 0) {
  492. ErrorPush();
  493. RLckUnlockEX(hResLock);
  494. return (ErrorPop());
  495. }
  497. RLckUnlockEX(hResLock);
  499. return (0);
  501. }
  503. int ADomGetADomainFileSnapShot(const char *pszFileName)
  504. {
  506. char szADomainFilePath[SYS_MAX_PATH] = "";
  508. ADomGetADomainFilePath(szADomainFilePath, sizeof(szADomainFilePath));
  510. char szResLock[SYS_MAX_PATH] = "";
  511. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szADomainFilePath, szResLock,
  512.   sizeof(szResLock)));
  514. if (hResLock == INVALID_RLCK_HANDLE)
  515. return (ErrGetErrorCode());
  517. if (MscCopyFile(pszFileName, szADomainFilePath) < 0) {
  518. ErrorPush();
  519. RLckUnlockSH(hResLock);
  520. return (ErrorPop());
  521. }
  523. RLckUnlockSH(hResLock);
  525. return (0);
  527. }
  529. ADOMAIN_HANDLE ADomOpenDB(void)
  530. {
  532. ADomainScanData *pDSD = (ADomainScanData *) SysAlloc(sizeof(ADomainScanData));
  534. if (pDSD == NULL)
  535. return (INVALID_ADOMAIN_HANDLE);
  537. SysGetTmpFile(pDSD->szTmpDBFile);
  539. if (ADomGetADomainFileSnapShot(pDSD->szTmpDBFile) < 0) {
  540. CheckRemoveFile(pDSD->szTmpDBFile);
  541. SysFree(pDSD);
  542. return (INVALID_ADOMAIN_HANDLE);
  543. }
  545. if ((pDSD->pDBFile = fopen(pDSD->szTmpDBFile, "rt")) == NULL) {
  546. SysRemove(pDSD->szTmpDBFile);
  547. SysFree(pDSD);
  548. return (INVALID_ADOMAIN_HANDLE);
  549. }
  551. pDSD->ppszStrings = NULL;
  553. return ((ADOMAIN_HANDLE) pDSD);
  555. }
  557. void ADomCloseDB(ADOMAIN_HANDLE hDomainsDB)
  558. {
  560. ADomainScanData *pDSD = (ADomainScanData *) hDomainsDB;
  562. fclose(pDSD->pDBFile);
  564. SysRemove(pDSD->szTmpDBFile);
  566. if (pDSD->ppszStrings != NULL)
  567. StrFreeStrings(pDSD->ppszStrings);
  569. SysFree(pDSD);
  571. }
  573. char const *const *ADomGetFirstDomain(ADOMAIN_HANDLE hDomainsDB)
  574. {
  576. ADomainScanData *pDSD = (ADomainScanData *) hDomainsDB;
  578. rewind(pDSD->pDBFile);
  580. if (pDSD->ppszStrings != NULL)
  581. StrFreeStrings(pDSD->ppszStrings), pDSD->ppszStrings = NULL;
  583. char szADomainLine[ADOMAIN_LINE_MAX] = "";
  585. while (MscFGets(szADomainLine, sizeof(szADomainLine) - 1, pDSD->pDBFile) != NULL) {
  586. char **ppszStrings = StrGetTabLineStrings(szADomainLine);
  588. if (ppszStrings == NULL)
  589. continue;
  591. int iFieldsCount = StrStringsCount(ppszStrings);
  593. if (iFieldsCount >= adomMax)
  594. return (pDSD->ppszStrings = ppszStrings);
  596. StrFreeStrings(ppszStrings);
  597. }
  599. return (NULL);
  601. }
  603. char const *const *ADomGetNextDomain(ADOMAIN_HANDLE hDomainsDB)
  604. {
  606. ADomainScanData *pDSD = (ADomainScanData *) hDomainsDB;
  608. if (pDSD->ppszStrings != NULL)
  609. StrFreeStrings(pDSD->ppszStrings), pDSD->ppszStrings = NULL;
  611. char szADomainLine[ADOMAIN_LINE_MAX] = "";
  613. while (MscFGets(szADomainLine, sizeof(szADomainLine) - 1, pDSD->pDBFile) != NULL) {
  614. char **ppszStrings = StrGetTabLineStrings(szADomainLine);
  616. if (ppszStrings == NULL)
  617. continue;
  619. int iFieldsCount = StrStringsCount(ppszStrings);
  621. if (iFieldsCount >= adomMax)
  622. return (pDSD->ppszStrings = ppszStrings);
  624. StrFreeStrings(ppszStrings);
  625. }
  627. return (NULL);
  629. }