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

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

Email服务器

开发平台：

Visual C++

ExtAliases.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 "UsrUtils.h"
  37. #include "TabIndex.h"
  38. #include "ExtAliases.h"
  40. #define SVR_EXT_ALIAS_FILE          "extaliases.tab"
  41. #define ALIAS_TABLE_LINE_MAX        1024
  43. enum ExtAliasFields {
  44. ealRmtDomain = 0,
  45. ealRmtName,
  46. ealDomain,
  47. ealName,
  49. ealMax
  50. };
  52. struct ExAlDBScanData {
  53. char szTmpDBFile[SYS_MAX_PATH];
  54. FILE *pDBFile;
  55. };
  57. static int ExAlRebuildAliasIndexes(char const *pszAliasFilePath);
  58. static char *ExAlGetTableFilePath(char *pszLnkFilePath, int iMaxPath);
  59. static ExtAlias *ExAlGetAliasFromStrings(char **ppszStrings);
  60. static int ExAlWriteAlias(FILE * pAliasFile, ExtAlias * pExtAlias);
  62. static int iIdxExAlias_RmtDomain_RmtName[] = {
  63. ealRmtDomain,
  64. ealRmtName,
  66. INDEX_SEQUENCE_TERMINATOR
  67. };
  69. int ExAlCheckAliasIndexes(void)
  70. {
  72. char szAliasFilePath[SYS_MAX_PATH] = "";
  74. ExAlGetTableFilePath(szAliasFilePath, sizeof(szAliasFilePath));
  76. ///////////////////////////////////////////////////////////////////////////////
  77. //  Align RmtDomain-RmtName index
  78. ///////////////////////////////////////////////////////////////////////////////
  79. if (TbixCheckIndex(szAliasFilePath, iIdxExAlias_RmtDomain_RmtName, false) < 0)
  80. return (ErrGetErrorCode());
  82. return (0);
  84. }
  86. static int ExAlRebuildAliasIndexes(char const *pszAliasFilePath)
  87. {
  88. ///////////////////////////////////////////////////////////////////////////////
  89. //  Rebuild RmtDomain-RmtName index
  90. ///////////////////////////////////////////////////////////////////////////////
  91. if (TbixCreateIndex(pszAliasFilePath, iIdxExAlias_RmtDomain_RmtName, false) < 0)
  92. return (ErrGetErrorCode());
  94. return (0);
  96. }
  98. static char *ExAlGetTableFilePath(char *pszLnkFilePath, int iMaxPath)
  99. {
  101. CfgGetRootPath(pszLnkFilePath, iMaxPath);
  103. StrNCat(pszLnkFilePath, SVR_EXT_ALIAS_FILE, iMaxPath);
  105. return (pszLnkFilePath);
  107. }
  109. static ExtAlias *ExAlGetAliasFromStrings(char **ppszStrings)
  110. {
  112. int iFieldsCount = StrStringsCount(ppszStrings);
  114. if (iFieldsCount < ealMax)
  115. return (NULL);
  117. ExtAlias *pExtAlias = (ExtAlias *) SysAlloc(sizeof(ExtAlias));
  119. if (pExtAlias == NULL)
  120. return (NULL);
  122. pExtAlias->pszRmtDomain = SysStrDup(ppszStrings[ealRmtDomain]);
  123. pExtAlias->pszRmtName = SysStrDup(ppszStrings[ealRmtName]);
  124. pExtAlias->pszDomain = SysStrDup(ppszStrings[ealDomain]);
  125. pExtAlias->pszName = SysStrDup(ppszStrings[ealName]);
  127. return (pExtAlias);
  129. }
  131. ExtAlias *ExAlAllocAlias(void)
  132. {
  134. ExtAlias *pExtAlias = (ExtAlias *) SysAlloc(sizeof(ExtAlias));
  136. if (pExtAlias == NULL)
  137. return (NULL);
  139. pExtAlias->pszRmtDomain = NULL;
  140. pExtAlias->pszRmtName = NULL;
  141. pExtAlias->pszDomain = NULL;
  142. pExtAlias->pszName = NULL;
  144. return (pExtAlias);
  146. }
  148. void ExAlFreeAlias(ExtAlias * pExtAlias)
  149. {
  151. if (pExtAlias->pszDomain != NULL)
  152. SysFree(pExtAlias->pszDomain);
  154. if (pExtAlias->pszName != NULL)
  155. SysFree(pExtAlias->pszName);
  157. if (pExtAlias->pszRmtDomain != NULL)
  158. SysFree(pExtAlias->pszRmtDomain);
  160. if (pExtAlias->pszRmtName != NULL)
  161. SysFree(pExtAlias->pszRmtName);
  163. SysFree(pExtAlias);
  165. }
  167. static int ExAlWriteAlias(FILE * pAliasFile, ExtAlias * pExtAlias)
  168. {
  170. ///////////////////////////////////////////////////////////////////////////////
  171. //  Remote domain
  172. ///////////////////////////////////////////////////////////////////////////////
  173. char *pszQuoted = StrQuote(pExtAlias->pszRmtDomain, '"');
  175. if (pszQuoted == NULL)
  176. return (ErrGetErrorCode());
  178. fprintf(pAliasFile, "%st", pszQuoted);
  180. SysFree(pszQuoted);
  182. ///////////////////////////////////////////////////////////////////////////////
  183. //  Remote user
  184. ///////////////////////////////////////////////////////////////////////////////
  185. pszQuoted = StrQuote(pExtAlias->pszRmtName, '"');
  187. if (pszQuoted == NULL)
  188. return (ErrGetErrorCode());
  190. fprintf(pAliasFile, "%st", pszQuoted);
  192. SysFree(pszQuoted);
  194. ///////////////////////////////////////////////////////////////////////////////
  195. //  Domain
  196. ///////////////////////////////////////////////////////////////////////////////
  197. pszQuoted = StrQuote(pExtAlias->pszDomain, '"');
  199. if (pszQuoted == NULL)
  200. return (ErrGetErrorCode());
  202. fprintf(pAliasFile, "%st", pszQuoted);
  204. SysFree(pszQuoted);
  206. ///////////////////////////////////////////////////////////////////////////////
  207. //  Local user
  208. ///////////////////////////////////////////////////////////////////////////////
  209. pszQuoted = StrQuote(pExtAlias->pszName, '"');
  211. if (pszQuoted == NULL)
  212. return (ErrGetErrorCode());
  214. fprintf(pAliasFile, "%sn", pszQuoted);
  216. SysFree(pszQuoted);
  218. return (0);
  220. }
  222. int ExAlAddAlias(ExtAlias * pExtAlias)
  223. {
  225. char szAliasFilePath[SYS_MAX_PATH] = "";
  227. ExAlGetTableFilePath(szAliasFilePath, sizeof(szAliasFilePath));
  229. char szResLock[SYS_MAX_PATH] = "";
  230. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szAliasFilePath, szResLock,
  231.   sizeof(szResLock)));
  233. if (hResLock == INVALID_RLCK_HANDLE)
  234. return (ErrGetErrorCode());
  236. FILE *pAliasFile = fopen(szAliasFilePath, "r+t");
  238. if (pAliasFile == NULL) {
  239. RLckUnlockEX(hResLock);
  241. ErrSetErrorCode(ERR_EXTALIAS_FILE_NOT_FOUND);
  242. return (ERR_EXTALIAS_FILE_NOT_FOUND);
  243. }
  245. char szAliasLine[ALIAS_TABLE_LINE_MAX] = "";
  247. while (MscFGets(szAliasLine, sizeof(szAliasLine) - 1, pAliasFile) != NULL) {
  248. char **ppszStrings = StrGetTabLineStrings(szAliasLine);
  250. if (ppszStrings == NULL)
  251. continue;
  253. int iFieldsCount = StrStringsCount(ppszStrings);
  255. if ((iFieldsCount >= ealMax) &&
  256.     (stricmp(pExtAlias->pszRmtDomain, ppszStrings[ealRmtDomain]) == 0) &&
  257.     (stricmp(pExtAlias->pszRmtName, ppszStrings[ealRmtName]) == 0)) {
  258. StrFreeStrings(ppszStrings);
  259. fclose(pAliasFile);
  260. RLckUnlockEX(hResLock);
  262. ErrSetErrorCode(ERR_EXTALIAS_EXIST);
  263. return (ERR_EXTALIAS_EXIST);
  264. }
  266. StrFreeStrings(ppszStrings);
  267. }
  269. fseek(pAliasFile, 0, SEEK_END);
  271. if (ExAlWriteAlias(pAliasFile, pExtAlias) < 0) {
  272. fclose(pAliasFile);
  273. RLckUnlockEX(hResLock);
  275. ErrSetErrorCode(ERR_WRITE_EXTALIAS_FILE);
  276. return (ERR_WRITE_EXTALIAS_FILE);
  277. }
  279. fclose(pAliasFile);
  281. ///////////////////////////////////////////////////////////////////////////////
  282. //  Rebuild indexes
  283. ///////////////////////////////////////////////////////////////////////////////
  284. if (ExAlRebuildAliasIndexes(szAliasFilePath) < 0) {
  285. ErrorPush();
  286. RLckUnlockEX(hResLock);
  287. return (ErrorPop());
  288. }
  290. RLckUnlockEX(hResLock);
  292. return (0);
  294. }
  296. ExtAlias *ExAlGetAlias(char const *pszRmtDomain, char const *pszRmtName)
  297. {
  299. char szAliasFilePath[SYS_MAX_PATH] = "";
  301. ExAlGetTableFilePath(szAliasFilePath, sizeof(szAliasFilePath));
  303. char szResLock[SYS_MAX_PATH] = "";
  304. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szAliasFilePath, szResLock,
  305.   sizeof(szResLock)));
  307. if (hResLock == INVALID_RLCK_HANDLE)
  308. return (NULL);
  310. ///////////////////////////////////////////////////////////////////////////////
  311. //  Lookup record using the specified index
  312. ///////////////////////////////////////////////////////////////////////////////
  313. char **ppszTabTokens = TbixLookup(szAliasFilePath, iIdxExAlias_RmtDomain_RmtName, false,
  314.   pszRmtDomain,
  315.   pszRmtName,
  316.   NULL);
  318. if (ppszTabTokens == NULL) {
  319. RLckUnlockSH(hResLock);
  320. ErrSetErrorCode(ERR_EXTALIAS_NOT_FOUND);
  322. return (NULL);
  323. }
  325. ExtAlias *pExtAlias = ExAlGetAliasFromStrings(ppszTabTokens);
  327. StrFreeStrings(ppszTabTokens);
  329. RLckUnlockSH(hResLock);
  331. return (pExtAlias);
  333. }
  335. int ExAlRemoveAlias(ExtAlias * pExtAlias)
  336. {
  338. char szAliasFilePath[SYS_MAX_PATH] = "";
  340. ExAlGetTableFilePath(szAliasFilePath, sizeof(szAliasFilePath));
  342. char szTmpFile[SYS_MAX_PATH] = "";
  344. SysGetTmpFile(szTmpFile);
  346. char szResLock[SYS_MAX_PATH] = "";
  347. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szAliasFilePath, szResLock,
  348.   sizeof(szResLock)));
  350. if (hResLock == INVALID_RLCK_HANDLE)
  351. return (ErrGetErrorCode());
  353. FILE *pAliasFile = fopen(szAliasFilePath, "rt");
  355. if (pAliasFile == NULL) {
  356. RLckUnlockEX(hResLock);
  358. ErrSetErrorCode(ERR_EXTALIAS_FILE_NOT_FOUND);
  359. return (ERR_EXTALIAS_FILE_NOT_FOUND);
  360. }
  362. FILE *pTmpFile = fopen(szTmpFile, "wt");
  364. if (pTmpFile == NULL) {
  365. fclose(pAliasFile);
  366. RLckUnlockEX(hResLock);
  368. ErrSetErrorCode(ERR_FILE_CREATE);
  369. return (ERR_FILE_CREATE);
  370. }
  372. int iAliasFound = 0;
  373. char szAliasLine[ALIAS_TABLE_LINE_MAX] = "";
  375. while (MscFGets(szAliasLine, sizeof(szAliasLine) - 1, pAliasFile) != NULL) {
  376. char **ppszStrings = StrGetTabLineStrings(szAliasLine);
  378. if (ppszStrings == NULL)
  379. continue;
  381. int iFieldsCount = StrStringsCount(ppszStrings);
  383. if ((iFieldsCount >= ealMax) &&
  384.     (stricmp(pExtAlias->pszRmtDomain, ppszStrings[ealRmtDomain]) == 0) &&
  385.     (stricmp(pExtAlias->pszRmtName, ppszStrings[ealRmtName]) == 0)) {
  387. ++iAliasFound;
  389. } else
  390. fprintf(pTmpFile, "%sn", szAliasLine);
  392. StrFreeStrings(ppszStrings);
  393. }
  395. fclose(pAliasFile);
  396. fclose(pTmpFile);
  398. if (iAliasFound == 0) {
  399. SysRemove(szTmpFile);
  400. RLckUnlockEX(hResLock);
  402. ErrSetErrorCode(ERR_EXTALIAS_NOT_FOUND);
  403. return (ERR_EXTALIAS_NOT_FOUND);
  404. }
  406. char szTmpAliasFilePath[SYS_MAX_PATH] = "";
  408. SysSNPrintf(szTmpAliasFilePath, sizeof(szTmpAliasFilePath) - 1, "%s.tmp",
  409.     szAliasFilePath);
  411. if (MscMoveFile(szAliasFilePath, szTmpAliasFilePath) < 0) {
  412. RLckUnlockEX(hResLock);
  413. return (ErrGetErrorCode());
  414. }
  416. if (MscMoveFile(szTmpFile, szAliasFilePath) < 0) {
  417. MscMoveFile(szTmpAliasFilePath, szAliasFilePath);
  418. RLckUnlockEX(hResLock);
  419. return (ErrGetErrorCode());
  420. }
  422. SysRemove(szTmpAliasFilePath);
  424. ///////////////////////////////////////////////////////////////////////////////
  425. //  Rebuild indexes
  426. ///////////////////////////////////////////////////////////////////////////////
  427. if (ExAlRebuildAliasIndexes(szAliasFilePath) < 0) {
  428. ErrorPush();
  429. RLckUnlockEX(hResLock);
  430. return (ErrorPop());
  431. }
  433. RLckUnlockEX(hResLock);
  435. return (0);
  437. }
  439. int ExAlRemoveUserAliases(const char *pszDomain, const char *pszName)
  440. {
  442. char szAliasFilePath[SYS_MAX_PATH] = "";
  444. ExAlGetTableFilePath(szAliasFilePath, sizeof(szAliasFilePath));
  446. char szTmpFile[SYS_MAX_PATH] = "";
  448. SysGetTmpFile(szTmpFile);
  450. char szResLock[SYS_MAX_PATH] = "";
  451. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szAliasFilePath, szResLock,
  452.   sizeof(szResLock)));
  454. if (hResLock == INVALID_RLCK_HANDLE) {
  455. ErrorPush();
  456. CheckRemoveFile(szTmpFile);
  457. return (ErrorPop());
  458. }
  460. FILE *pAliasFile = fopen(szAliasFilePath, "rt");
  462. if (pAliasFile == NULL) {
  463. RLckUnlockEX(hResLock);
  464. CheckRemoveFile(szTmpFile);
  466. ErrSetErrorCode(ERR_EXTALIAS_FILE_NOT_FOUND);
  467. return (ERR_EXTALIAS_FILE_NOT_FOUND);
  468. }
  470. FILE *pTmpFile = fopen(szTmpFile, "wt");
  472. if (pTmpFile == NULL) {
  473. fclose(pAliasFile);
  474. RLckUnlockEX(hResLock);
  475. CheckRemoveFile(szTmpFile);
  477. ErrSetErrorCode(ERR_FILE_CREATE);
  478. return (ERR_FILE_CREATE);
  479. }
  481. int iAliasFound = 0;
  482. char szAliasLine[ALIAS_TABLE_LINE_MAX] = "";
  484. while (MscFGets(szAliasLine, sizeof(szAliasLine) - 1, pAliasFile) != NULL) {
  485. char **ppszStrings = StrGetTabLineStrings(szAliasLine);
  487. if (ppszStrings == NULL)
  488. continue;
  490. int iFieldsCount = StrStringsCount(ppszStrings);
  492. if ((iFieldsCount >= ealMax) && (stricmp(pszDomain, ppszStrings[ealDomain]) == 0)
  493.     && (stricmp(pszName, ppszStrings[ealName]) == 0)) {
  495. ++iAliasFound;
  497. } else
  498. fprintf(pTmpFile, "%sn", szAliasLine);
  500. StrFreeStrings(ppszStrings);
  501. }
  503. fclose(pAliasFile);
  504. fclose(pTmpFile);
  506. if (iAliasFound == 0) {
  507. SysRemove(szTmpFile);
  508. RLckUnlockEX(hResLock);
  509. return (0);
  510. }
  512. char szTmpAliasFilePath[SYS_MAX_PATH] = "";
  514. SysSNPrintf(szTmpAliasFilePath, sizeof(szTmpAliasFilePath) - 1, "%s.tmp",
  515.     szAliasFilePath);
  517. if (MscMoveFile(szAliasFilePath, szTmpAliasFilePath) < 0) {
  518. ErrorPush();
  519. RLckUnlockEX(hResLock);
  520. return (ErrorPop());
  521. }
  523. if (MscMoveFile(szTmpFile, szAliasFilePath) < 0) {
  524. ErrorPush();
  525. MscMoveFile(szTmpAliasFilePath, szAliasFilePath);
  526. RLckUnlockEX(hResLock);
  527. return (ErrorPop());
  528. }
  530. SysRemove(szTmpAliasFilePath);
  532. ///////////////////////////////////////////////////////////////////////////////
  533. //  Rebuild indexes
  534. ///////////////////////////////////////////////////////////////////////////////
  535. if (ExAlRebuildAliasIndexes(szAliasFilePath) < 0) {
  536. ErrorPush();
  537. RLckUnlockEX(hResLock);
  538. return (ErrorPop());
  539. }
  541. RLckUnlockEX(hResLock);
  543. return (0);
  545. }
  547. int ExAlRemoveDomainAliases(const char *pszDomain)
  548. {
  550. char szAliasFilePath[SYS_MAX_PATH] = "";
  552. ExAlGetTableFilePath(szAliasFilePath, sizeof(szAliasFilePath));
  554. char szTmpFile[SYS_MAX_PATH] = "";
  556. SysGetTmpFile(szTmpFile);
  558. char szResLock[SYS_MAX_PATH] = "";
  559. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szAliasFilePath, szResLock,
  560.   sizeof(szResLock)));
  562. if (hResLock == INVALID_RLCK_HANDLE) {
  563. ErrorPush();
  564. CheckRemoveFile(szTmpFile);
  565. return (ErrorPop());
  566. }
  568. FILE *pAliasFile = fopen(szAliasFilePath, "rt");
  570. if (pAliasFile == NULL) {
  571. RLckUnlockEX(hResLock);
  572. CheckRemoveFile(szTmpFile);
  574. ErrSetErrorCode(ERR_EXTALIAS_FILE_NOT_FOUND);
  575. return (ERR_EXTALIAS_FILE_NOT_FOUND);
  576. }
  578. FILE *pTmpFile = fopen(szTmpFile, "wt");
  580. if (pTmpFile == NULL) {
  581. fclose(pAliasFile);
  582. RLckUnlockEX(hResLock);
  583. CheckRemoveFile(szTmpFile);
  585. ErrSetErrorCode(ERR_FILE_CREATE);
  586. return (ERR_FILE_CREATE);
  587. }
  589. int iAliasFound = 0;
  590. char szAliasLine[ALIAS_TABLE_LINE_MAX] = "";
  592. while (MscFGets(szAliasLine, sizeof(szAliasLine) - 1, pAliasFile) != NULL) {
  593. char **ppszStrings = StrGetTabLineStrings(szAliasLine);
  595. if (ppszStrings == NULL)
  596. continue;
  598. int iFieldsCount = StrStringsCount(ppszStrings);
  600. if ((iFieldsCount >= ealMax) && (stricmp(pszDomain, ppszStrings[ealDomain]) == 0)) {
  602. ++iAliasFound;
  604. } else
  605. fprintf(pTmpFile, "%sn", szAliasLine);
  607. StrFreeStrings(ppszStrings);
  608. }
  610. fclose(pAliasFile);
  611. fclose(pTmpFile);
  613. if (iAliasFound == 0) {
  614. SysRemove(szTmpFile);
  615. RLckUnlockEX(hResLock);
  616. return (0);
  617. }
  619. char szTmpAliasFilePath[SYS_MAX_PATH] = "";
  621. SysSNPrintf(szTmpAliasFilePath, sizeof(szTmpAliasFilePath) - 1, "%s.tmp",
  622.     szAliasFilePath);
  624. if (MscMoveFile(szAliasFilePath, szTmpAliasFilePath) < 0) {
  625. ErrorPush();
  626. SysRemove(szTmpFile);
  627. RLckUnlockEX(hResLock);
  628. return (ErrorPop());
  629. }
  631. if (MscMoveFile(szTmpFile, szAliasFilePath) < 0) {
  632. ErrorPush();
  633. MscMoveFile(szTmpAliasFilePath, szAliasFilePath);
  634. SysRemove(szTmpFile);
  635. RLckUnlockEX(hResLock);
  636. return (ErrorPop());
  637. }
  639. SysRemove(szTmpAliasFilePath);
  641. ///////////////////////////////////////////////////////////////////////////////
  642. //  Rebuild indexes
  643. ///////////////////////////////////////////////////////////////////////////////
  644. if (ExAlRebuildAliasIndexes(szAliasFilePath) < 0) {
  645. ErrorPush();
  646. RLckUnlockEX(hResLock);
  647. return (ErrorPop());
  648. }
  650. RLckUnlockEX(hResLock);
  652. return (0);
  654. }
  656. int ExAlGetDBFileSnapShot(const char *pszFileName)
  657. {
  659. char szAliasFilePath[SYS_MAX_PATH] = "";
  661. ExAlGetTableFilePath(szAliasFilePath, sizeof(szAliasFilePath));
  663. char szResLock[SYS_MAX_PATH] = "";
  664. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szAliasFilePath, szResLock,
  665.   sizeof(szResLock)));
  667. if (hResLock == INVALID_RLCK_HANDLE)
  668. return (ErrGetErrorCode());
  670. if (MscCopyFile(pszFileName, szAliasFilePath) < 0) {
  671. RLckUnlockSH(hResLock);
  672. return (ErrGetErrorCode());
  673. }
  675. RLckUnlockSH(hResLock);
  677. return (0);
  679. }
  681. EXAL_HANDLE ExAlOpenDB(void)
  682. {
  684. ExAlDBScanData *pGLSD = (ExAlDBScanData *) SysAlloc(sizeof(ExAlDBScanData));
  686. if (pGLSD == NULL)
  687. return (INVALID_EXAL_HANDLE);
  689. SysGetTmpFile(pGLSD->szTmpDBFile);
  691. if (ExAlGetDBFileSnapShot(pGLSD->szTmpDBFile) < 0) {
  692. SysFree(pGLSD);
  693. return (INVALID_EXAL_HANDLE);
  694. }
  696. if ((pGLSD->pDBFile = fopen(pGLSD->szTmpDBFile, "rt")) == NULL) {
  697. SysRemove(pGLSD->szTmpDBFile);
  698. SysFree(pGLSD);
  699. return (INVALID_EXAL_HANDLE);
  700. }
  702. return ((EXAL_HANDLE) pGLSD);
  704. }
  706. void ExAlCloseDB(EXAL_HANDLE hLinksDB)
  707. {
  709. ExAlDBScanData *pGLSD = (ExAlDBScanData *) hLinksDB;
  711. fclose(pGLSD->pDBFile);
  713. SysRemove(pGLSD->szTmpDBFile);
  715. SysFree(pGLSD);
  717. }
  719. ExtAlias *ExAlGetFirstAlias(EXAL_HANDLE hLinksDB)
  720. {
  722. ExAlDBScanData *pGLSD = (ExAlDBScanData *) hLinksDB;
  724. rewind(pGLSD->pDBFile);
  726. ExtAlias *pExtAlias = NULL;
  727. char szAliasLine[ALIAS_TABLE_LINE_MAX] = "";
  729. while ((pExtAlias == NULL) &&
  730.        (MscFGets(szAliasLine, sizeof(szAliasLine) - 1, pGLSD->pDBFile) != NULL)) {
  731. char **ppszStrings = StrGetTabLineStrings(szAliasLine);
  733. if (ppszStrings == NULL)
  734. continue;
  736. int iFieldsCount = StrStringsCount(ppszStrings);
  738. if (iFieldsCount >= ealMax)
  739. pExtAlias = ExAlGetAliasFromStrings(ppszStrings);
  741. StrFreeStrings(ppszStrings);
  742. }
  744. return (pExtAlias);
  746. }
  748. ExtAlias *ExAlGetNextAlias(EXAL_HANDLE hLinksDB)
  749. {
  751. ExAlDBScanData *pGLSD = (ExAlDBScanData *) hLinksDB;
  753. ExtAlias *pExtAlias = NULL;
  754. char szAliasLine[ALIAS_TABLE_LINE_MAX] = "";
  756. while ((pExtAlias == NULL) &&
  757.        (MscFGets(szAliasLine, sizeof(szAliasLine) - 1, pGLSD->pDBFile) != NULL)) {
  758. char **ppszStrings = StrGetTabLineStrings(szAliasLine);
  760. if (ppszStrings == NULL)
  761. continue;
  763. int iFieldsCount = StrStringsCount(ppszStrings);
  765. if (iFieldsCount >= ealMax)
  766. pExtAlias = ExAlGetAliasFromStrings(ppszStrings);
  768. StrFreeStrings(ppszStrings);
  769. }
  771. return (pExtAlias);
  773. }