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

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

Email服务器

开发平台：

Visual C++

TabIndex.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 "StrUtils.h"
  28. #include "SList.h"
  29. #include "BuffSock.h"
  30. #include "MiscUtils.h"
  31. #include "TabIndex.h"
  33. ///////////////////////////////////////////////////////////////////////////////
  34. //  The index version MUST be incremented at every file format change
  35. ///////////////////////////////////////////////////////////////////////////////
  36. #define TAB_INDEX_CURR_VERSION      1
  38. #define TAB_SAMPLE_LINES            32
  39. #define TAB_MIN_HASH_SIZE           17
  40. #define TAB_INDEX_DIR               "tabindex"
  41. #define TAB_INDEX_MAGIC             (*(SYS_UINT32 *) "ABDL")
  42. #define KEY_BUFFER_SIZE             1024
  43. #define TAB_RECORD_BUFFER_SIZE      2048
  44. #define TOKEN_SEP_STR               "t"
  46. struct HashLink {
  47. SysListHead LLink;
  48. SYS_UINT32 uOffset;
  49. };
  51. struct HashNode {
  52. SysListHead NodeList;
  53. SYS_UINT32 uCount;
  54. };
  56. struct HashFileHeader {
  57. SYS_UINT32 uMagic;
  58. SYS_UINT32 uVersion;
  59. SYS_UINT32 uHashSize;
  60. };
  62. struct TabHashIndex {
  63. HashFileHeader HFH;
  64. FILE *pIndexFile;
  65. };
  67. struct IndexLookupData {
  68. FILE *pTabFile;
  69. SYS_UINT32 *pHashTable;
  70. };
  72. static int TbixCalcHashSize(FILE * pTabFile, char *pszLineBuffer, int iBufferSize);
  73. static int TbixFreeHash(HashNode * pHash, int iHashSize);
  74. static int TbixBuildKey(char *pszKey, va_list Args, bool bCaseSens);
  75. static int TbixBuildKey(char *pszKey, char const *const *ppszTabTokens,
  76. int const *piFieldsIdx, bool bCaseSens);
  77. static int TbixOpenIndex(char const *pszIndexFile, TabHashIndex & THI);
  78. static int TbixCloseIndex(TabHashIndex & THI);
  79. static int TbixCheckIndex(char const *pszIndexFile);
  80. static SYS_UINT32 *TbixReadTable(TabHashIndex & THI, SYS_UINT32 uHashVal);
  81. static char **TbixLoadRecord(FILE * pTabFile, SYS_UINT32 uOffset);
  83. static int TbixCalcHashSize(FILE * pTabFile, char *pszLineBuffer, int iBufferSize)
  84. {
  86. int iSampleLines = 0;
  87. unsigned long ulOrigOffset = (unsigned long) ftell(pTabFile);
  88. unsigned long ulCurrOffset = 0;
  89. unsigned long ulLineSize = 0;
  91. rewind(pTabFile);
  93. while (iSampleLines < TAB_SAMPLE_LINES) {
  94. if (MscGetString(pTabFile, pszLineBuffer, iBufferSize - 1) == NULL)
  95. break;
  97. unsigned long ulOffset = (unsigned long) ftell(pTabFile);
  99. if (!IsEmptyString(pszLineBuffer) && (pszLineBuffer[0] != TAB_COMMENT_CHAR)) {
  100. ulLineSize += ulOffset - ulCurrOffset;
  102. ++iSampleLines;
  103. }
  105. ulCurrOffset = ulOffset;
  106. }
  108. if (iSampleLines == 0) {
  109. fseek(pTabFile, ulOrigOffset, SEEK_SET);
  110. return (TAB_MIN_HASH_SIZE);
  111. }
  113. ulLineSize /= iSampleLines;
  115. fseek(pTabFile, 0, SEEK_END);
  117. unsigned long ulFileSize = (unsigned long) ftell(pTabFile);
  119. fseek(pTabFile, ulOrigOffset, SEEK_SET);
  121. int iHashSize = (int) (ulFileSize / ulLineSize) + TAB_MIN_HASH_SIZE;
  123. while (!IsPrimeNumber(iHashSize))
  124. ++iHashSize;
  126. return (iHashSize);
  128. }
  130. char *TbixGetIndexFile(char const *pszTabFilePath, int const *piFieldsIdx, char *pszIndexFile)
  131. {
  133. char szFileDir[SYS_MAX_PATH] = "";
  134. char szFileName[SYS_MAX_PATH] = "";
  136. MscSplitPath(pszTabFilePath, szFileDir, szFileName, NULL);
  138. sprintf(pszIndexFile, "%s%s%s%s-", szFileDir, TAB_INDEX_DIR, SYS_SLASH_STR, szFileName);
  140. for (int ii = 0; piFieldsIdx[ii] != INDEX_SEQUENCE_TERMINATOR; ii++) {
  141. char szIndex[64] = "";
  143. sprintf(szIndex, "%02d", piFieldsIdx[ii]);
  145. strcat(pszIndexFile, szIndex);
  146. }
  148. strcat(pszIndexFile, ".hdx");
  150. return (pszIndexFile);
  152. }
  154. static int TbixFreeHash(HashNode * pHash, int iHashSize)
  155. {
  157. for (int ii = 0; ii < iHashSize; ii++) {
  158. SysListHead *pHead = &pHash[ii].NodeList;
  159. SysListHead *pLLink;
  161. while ((pLLink = SYS_LIST_FIRST(pHead)) != NULL) {
  162. HashLink *pHL = SYS_LIST_ENTRY(pLLink, HashLink, LLink);
  164. SYS_LIST_DEL(&pHL->LLink);
  166. SysFree(pHL);
  167. }
  168. }
  170. SysFree(pHash);
  172. return (0);
  174. }
  176. int TbixCreateIndex(char const *pszTabFilePath, int const *piFieldsIdx, bool bCaseSens,
  177.     int (*pHashFunc) (char const *const *, int const *, SYS_UINT32 *, bool))
  178. {
  179. ///////////////////////////////////////////////////////////////////////////////
  180. //  Adjust hash function
  181. ///////////////////////////////////////////////////////////////////////////////
  182. if (pHashFunc == NULL)
  183. pHashFunc = TbixCalculateHash;
  185. ///////////////////////////////////////////////////////////////////////////////
  186. //  Build index file name
  187. ///////////////////////////////////////////////////////////////////////////////
  188. char szIndexFile[SYS_MAX_PATH] = "";
  190. if (TbixGetIndexFile(pszTabFilePath, piFieldsIdx, szIndexFile) < 0)
  191. return (ErrGetErrorCode());
  193. FILE *pTabFile = fopen(pszTabFilePath, "rb");
  195. if (pTabFile == NULL) {
  196. ErrSetErrorCode(ERR_FILE_OPEN, pszTabFilePath);
  197. return (ERR_FILE_OPEN);
  198. }
  199. ///////////////////////////////////////////////////////////////////////////////
  200. //  Calculate file lookup hash size
  201. ///////////////////////////////////////////////////////////////////////////////
  202. char szLineBuffer[TAB_RECORD_BUFFER_SIZE] = "";
  203. int iHashSize = TbixCalcHashSize(pTabFile, szLineBuffer, sizeof(szLineBuffer));
  205. ///////////////////////////////////////////////////////////////////////////////
  206. //  Alloc and init hash records
  207. ///////////////////////////////////////////////////////////////////////////////
  208. HashNode *pHash = (HashNode *) SysAlloc(iHashSize * sizeof(HashNode));
  210. if (pHash == NULL) {
  211. fclose(pTabFile);
  212. return (ErrGetErrorCode());
  213. }
  215. int ii;
  217. for (ii = 0; ii < iHashSize; ii++) {
  218. SYS_INIT_LIST_HEAD(&pHash[ii].NodeList);
  219. pHash[ii].uCount = 0;
  220. }
  222. ///////////////////////////////////////////////////////////////////////////////
  223. //  Setup indexes records
  224. ///////////////////////////////////////////////////////////////////////////////
  225. for (;;) {
  226. ///////////////////////////////////////////////////////////////////////////////
  227. //  Get current offset
  228. ///////////////////////////////////////////////////////////////////////////////
  229. SYS_UINT32 uFileOffset = (SYS_UINT32) ftell(pTabFile);
  231. if (MscGetString(pTabFile, szLineBuffer, sizeof(szLineBuffer) - 1) == NULL)
  232. break;
  234. if (szLineBuffer[0] == TAB_COMMENT_CHAR)
  235. continue;
  237. char **ppszTabTokens = StrGetTabLineStrings(szLineBuffer);
  239. if (ppszTabTokens == NULL)
  240. continue;
  242. ///////////////////////////////////////////////////////////////////////////////
  243. //  Calculate hash value
  244. ///////////////////////////////////////////////////////////////////////////////
  245. SYS_UINT32 uHashVal = 0;
  247. if (pHashFunc(ppszTabTokens, piFieldsIdx, &uHashVal, bCaseSens) == 0) {
  248. int iHashIndex = (int) (uHashVal % (SYS_UINT32) iHashSize);
  249. HashLink *pHL = (HashLink *) SysAlloc(sizeof(HashLink));
  251. if (pHL == NULL) {
  252. TbixFreeHash(pHash, iHashSize);
  253. fclose(pTabFile);
  254. return (ErrGetErrorCode());
  255. }
  257. pHL->uOffset = uFileOffset;
  259. SYS_LIST_ADDT(&pHL->LLink, &pHash[iHashIndex].NodeList);
  260. ++pHash[iHashIndex].uCount;
  261. }
  263. StrFreeStrings(ppszTabTokens);
  264. }
  266. fclose(pTabFile);
  268. ///////////////////////////////////////////////////////////////////////////////
  269. //  Write index file
  270. ///////////////////////////////////////////////////////////////////////////////
  271. FILE *pIndexFile = fopen(szIndexFile, "wb");
  273. if (pIndexFile == NULL) {
  274. TbixFreeHash(pHash, iHashSize);
  276. ErrSetErrorCode(ERR_FILE_CREATE, szIndexFile);
  277. return (ERR_FILE_CREATE);
  278. }
  279. ///////////////////////////////////////////////////////////////////////////////
  280. //  Write file header
  281. ///////////////////////////////////////////////////////////////////////////////
  282. HashFileHeader HFH;
  284. ZeroData(HFH);
  285. HFH.uMagic = TAB_INDEX_MAGIC;
  286. HFH.uVersion = TAB_INDEX_CURR_VERSION;
  287. HFH.uHashSize = (SYS_UINT32) iHashSize;
  289. if (!fwrite(&HFH, sizeof(HFH), 1, pIndexFile)) {
  290. fclose(pIndexFile);
  291. SysRemove(szIndexFile);
  292. TbixFreeHash(pHash, iHashSize);
  294. ErrSetErrorCode(ERR_FILE_WRITE);
  295. return (ERR_FILE_WRITE);
  296. }
  297. ///////////////////////////////////////////////////////////////////////////////
  298. //  Dump main table
  299. ///////////////////////////////////////////////////////////////////////////////
  300. SYS_UINT32 uCurrOffset = sizeof(HFH) + iHashSize * sizeof(SYS_UINT32);
  302. for (ii = 0; ii < iHashSize; ii++) {
  303. SYS_UINT32 uTableOffset = 0;
  305. if (pHash[ii].uCount != 0) {
  306. uTableOffset = uCurrOffset;
  308. uCurrOffset += (pHash[ii].uCount + 1) * sizeof(SYS_UINT32);
  309. }
  311. if (!fwrite(&uTableOffset, sizeof(uTableOffset), 1, pIndexFile)) {
  312. fclose(pIndexFile);
  313. SysRemove(szIndexFile);
  314. TbixFreeHash(pHash, iHashSize);
  316. ErrSetErrorCode(ERR_FILE_WRITE);
  317. return (ERR_FILE_WRITE);
  318. }
  319. }
  321. ///////////////////////////////////////////////////////////////////////////////
  322. //  Dump hash tables
  323. ///////////////////////////////////////////////////////////////////////////////
  324. for (ii = 0; ii < iHashSize; ii++) {
  325. SYS_UINT32 uRecCount = pHash[ii].uCount;
  327. if (uRecCount != 0) {
  328. if (!fwrite(&uRecCount, sizeof(uRecCount), 1, pIndexFile)) {
  329. fclose(pIndexFile);
  330. SysRemove(szIndexFile);
  331. TbixFreeHash(pHash, iHashSize);
  333. ErrSetErrorCode(ERR_FILE_WRITE);
  334. return (ERR_FILE_WRITE);
  335. }
  337. SysListHead *pHead = &pHash[ii].NodeList;
  338. SysListHead *pLLink;
  340. SYS_LIST_FOR_EACH(pLLink, pHead) {
  341. HashLink *pHL = SYS_LIST_ENTRY(pLLink, HashLink, LLink);
  342. SYS_UINT32 uRecordOffset = pHL->uOffset;
  344. if (!fwrite(&uRecordOffset, sizeof(uRecordOffset), 1, pIndexFile)) {
  345. fclose(pIndexFile);
  346. SysRemove(szIndexFile);
  347. TbixFreeHash(pHash, iHashSize);
  349. ErrSetErrorCode(ERR_FILE_WRITE);
  350. return (ERR_FILE_WRITE);
  351. }
  352. }
  353. }
  354. }
  356. fclose(pIndexFile);
  358. TbixFreeHash(pHash, iHashSize);
  360. return (0);
  362. }
  364. static int TbixBuildKey(char *pszKey, va_list Args, bool bCaseSens)
  365. {
  367. SetEmptyString(pszKey);
  369. char const *pszToken;
  371. for (int ii = 0; (pszToken = va_arg(Args, char *)) != NULL; ii++) {
  372. if (ii > 0)
  373. strcat(pszKey, TOKEN_SEP_STR);
  375. strcat(pszKey, pszToken);
  376. }
  378. if (!bCaseSens)
  379. StrLower(pszKey);
  381. return (0);
  383. }
  385. static int TbixBuildKey(char *pszKey, char const *const *ppszTabTokens,
  386. int const *piFieldsIdx, bool bCaseSens)
  387. {
  389. SetEmptyString(pszKey);
  391. int iFieldsCount = StrStringsCount(ppszTabTokens);
  393. for (int ii = 0; piFieldsIdx[ii] != INDEX_SEQUENCE_TERMINATOR; ii++) {
  394. if ((piFieldsIdx[ii] < 0) || (piFieldsIdx[ii] >= iFieldsCount)) {
  395. ErrSetErrorCode(ERR_BAD_TAB_INDEX_FIELD);
  396. return (ERR_BAD_TAB_INDEX_FIELD);
  397. }
  399. if (ii > 0)
  400. strcat(pszKey, TOKEN_SEP_STR);
  402. strcat(pszKey, ppszTabTokens[piFieldsIdx[ii]]);
  403. }
  405. if (!bCaseSens)
  406. StrLower(pszKey);
  408. return (0);
  410. }
  412. int TbixCalculateHash(char const *const *ppszTabTokens, int const *piFieldsIdx,
  413.       SYS_UINT32 * puHashVal, bool bCaseSens)
  414. {
  416. char szKey[KEY_BUFFER_SIZE] = "";
  418. if (TbixBuildKey(szKey, ppszTabTokens, piFieldsIdx, bCaseSens) < 0)
  419. return (ErrGetErrorCode());
  421. *puHashVal = MscHashString(szKey, strlen(szKey));
  423. return (0);
  425. }
  427. static int TbixOpenIndex(char const *pszIndexFile, TabHashIndex & THI)
  428. {
  430. FILE *pIndexFile = fopen(pszIndexFile, "rb");
  432. if (pIndexFile == NULL) {
  433. ErrSetErrorCode(ERR_FILE_OPEN, pszIndexFile);
  434. return (ERR_FILE_OPEN);
  435. }
  436. ///////////////////////////////////////////////////////////////////////////////
  437. //  Read header and check signature
  438. ///////////////////////////////////////////////////////////////////////////////
  439. ZeroData(THI);
  441. if (!fread(&THI.HFH, sizeof(THI.HFH), 1, pIndexFile)) {
  442. fclose(pIndexFile);
  444. ErrSetErrorCode(ERR_FILE_READ, pszIndexFile);
  445. return (ERR_FILE_READ);
  446. }
  448. if ((THI.HFH.uMagic != TAB_INDEX_MAGIC) || (THI.HFH.uVersion != TAB_INDEX_CURR_VERSION)) {
  449. fclose(pIndexFile);
  451. ErrSetErrorCode(ERR_BAD_INDEX_FILE, pszIndexFile);
  452. return (ERR_BAD_INDEX_FILE);
  453. }
  455. THI.pIndexFile = pIndexFile;
  457. return (0);
  459. }
  461. static int TbixCloseIndex(TabHashIndex & THI)
  462. {
  464. fclose(THI.pIndexFile);
  466. ZeroData(THI);
  468. return (0);
  470. }
  472. static int TbixCheckIndex(char const *pszIndexFile)
  473. {
  475. TabHashIndex THI;
  477. if (TbixOpenIndex(pszIndexFile, THI) < 0)
  478. return (ErrGetErrorCode());
  480. TbixCloseIndex(THI);
  482. return (0);
  484. }
  486. static SYS_UINT32 *TbixReadTable(TabHashIndex & THI, SYS_UINT32 uHashVal)
  487. {
  489. SYS_UINT32 uHashIndex = uHashVal % THI.HFH.uHashSize;
  490. unsigned long ulTableOffset = sizeof(HashFileHeader) + uHashIndex * sizeof(SYS_UINT32);
  492. if (fseek(THI.pIndexFile, ulTableOffset, SEEK_SET) != 0) {
  493. ErrSetErrorCode(ERR_BAD_INDEX_FILE);
  494. return (NULL);
  495. }
  497. SYS_UINT32 uTableOffset;
  499. if (!fread(&uTableOffset, sizeof(uTableOffset), 1, THI.pIndexFile)) {
  500. ErrSetErrorCode(ERR_FILE_READ);
  501. return (NULL);
  502. }
  504. if (uTableOffset == 0) {
  505. ErrSetErrorCode(ERR_RECORD_NOT_FOUND);
  506. return (NULL);
  507. }
  509. if (fseek(THI.pIndexFile, uTableOffset, SEEK_SET) != 0) {
  510. ErrSetErrorCode(ERR_BAD_INDEX_FILE);
  511. return (NULL);
  512. }
  514. SYS_UINT32 uTableSize;
  516. if (!fread(&uTableSize, sizeof(uTableSize), 1, THI.pIndexFile)) {
  517. ErrSetErrorCode(ERR_FILE_READ);
  518. return (NULL);
  519. }
  521. SYS_UINT32 *pOffTable = (SYS_UINT32 *) SysAlloc((uTableSize + 1) * sizeof(SYS_UINT32));
  523. if (pOffTable == NULL)
  524. return (NULL);
  526. pOffTable[0] = uTableSize;
  528. if (!fread(&pOffTable[1], uTableSize * sizeof(SYS_UINT32), 1, THI.pIndexFile)) {
  529. SysFree(pOffTable);
  530. ErrSetErrorCode(ERR_FILE_READ);
  531. return (NULL);
  532. }
  534. return (pOffTable);
  536. }
  538. char **TbixLookup(char const *pszTabFilePath, int const *piFieldsIdx, bool bCaseSens, ...)
  539. {
  540. ///////////////////////////////////////////////////////////////////////////////
  541. //  Build index file name
  542. ///////////////////////////////////////////////////////////////////////////////
  543. char szIndexFile[SYS_MAX_PATH] = "";
  545. if (TbixGetIndexFile(pszTabFilePath, piFieldsIdx, szIndexFile) < 0)
  546. return (NULL);
  548. ///////////////////////////////////////////////////////////////////////////////
  549. //  Calculate key & hash
  550. ///////////////////////////////////////////////////////////////////////////////
  551. va_list Args;
  553. va_start(Args, bCaseSens);
  555. char szRefKey[KEY_BUFFER_SIZE] = "";
  557. if (TbixBuildKey(szRefKey, Args, bCaseSens) < 0) {
  558. va_end(Args);
  559. return (NULL);
  560. }
  562. va_end(Args);
  564. SYS_UINT32 uHashVal = MscHashString(szRefKey, strlen(szRefKey));
  566. ///////////////////////////////////////////////////////////////////////////////
  567. //  Open index
  568. ///////////////////////////////////////////////////////////////////////////////
  569. TabHashIndex THI;
  571. if (TbixOpenIndex(szIndexFile, THI) < 0)
  572. return (NULL);
  574. ///////////////////////////////////////////////////////////////////////////////
  575. //  Try to lookup records
  576. ///////////////////////////////////////////////////////////////////////////////
  577. SYS_UINT32 *pHashTable = TbixReadTable(THI, uHashVal);
  579. TbixCloseIndex(THI);
  581. if (pHashTable == NULL)
  582. return (NULL);
  584. ///////////////////////////////////////////////////////////////////////////////
  585. //  Search for the matched one
  586. ///////////////////////////////////////////////////////////////////////////////
  587. FILE *pTabFile = fopen(pszTabFilePath, "rb");
  589. if (pTabFile == NULL) {
  590. SysFree(pHashTable);
  592. ErrSetErrorCode(ERR_FILE_OPEN, pszTabFilePath);
  593. return (NULL);
  594. }
  596. int iHashNodes = (int) pHashTable[0];
  598. for (int ii = 0; ii < iHashNodes; ii++) {
  599. char **ppszTabTokens = TbixLoadRecord(pTabFile, pHashTable[ii + 1]);
  601. if (ppszTabTokens != NULL) {
  602. char szKey[KEY_BUFFER_SIZE] = "";
  604. if (TbixBuildKey(szKey, ppszTabTokens, piFieldsIdx, bCaseSens) == 0) {
  605. if (bCaseSens) {
  606. if (strcmp(szKey, szRefKey) == 0) {
  607. fclose(pTabFile);
  608. SysFree(pHashTable);
  609. return (ppszTabTokens);
  610. }
  611. } else {
  612. if (stricmp(szKey, szRefKey) == 0) {
  613. fclose(pTabFile);
  614. SysFree(pHashTable);
  615. return (ppszTabTokens);
  616. }
  617. }
  618. }
  620. StrFreeStrings(ppszTabTokens);
  621. }
  622. }
  624. fclose(pTabFile);
  626. SysFree(pHashTable);
  628. ErrSetErrorCode(ERR_RECORD_NOT_FOUND);
  630. return (NULL);
  632. }
  634. static char **TbixLoadRecord(FILE * pTabFile, SYS_UINT32 uOffset)
  635. {
  637. if (fseek(pTabFile, uOffset, SEEK_SET) != 0) {
  638. ErrSetErrorCode(ERR_BAD_INDEX_FILE);
  639. return (NULL);
  640. }
  642. char szLineBuffer[TAB_RECORD_BUFFER_SIZE] = "";
  644. if (MscGetString(pTabFile, szLineBuffer, sizeof(szLineBuffer) - 1) == NULL) {
  645. ErrSetErrorCode(ERR_FILE_READ);
  646. return (NULL);
  647. }
  649. return (StrGetTabLineStrings(szLineBuffer));
  651. }
  653. int TbixCheckIndex(char const *pszTabFilePath, int const *piFieldsIdx, bool bCaseSens,
  654.    int (*pHashFunc) (char const *const *, int const *, SYS_UINT32 *, bool))
  655. {
  657. SYS_FILE_INFO FI_Tab;
  659. if (SysGetFileInfo(pszTabFilePath, FI_Tab) < 0)
  660. return (ErrGetErrorCode());
  662. ///////////////////////////////////////////////////////////////////////////////
  663. //  Build index file name
  664. ///////////////////////////////////////////////////////////////////////////////
  665. char szIndexFile[SYS_MAX_PATH] = "";
  667. if (TbixGetIndexFile(pszTabFilePath, piFieldsIdx, szIndexFile) < 0)
  668. return (ErrGetErrorCode());
  670. ///////////////////////////////////////////////////////////////////////////////
  671. //  Compare TAB <-> Index dates
  672. ///////////////////////////////////////////////////////////////////////////////
  673. SYS_FILE_INFO FI_Index;
  675. if ((SysGetFileInfo(szIndexFile, FI_Index) < 0) || (FI_Tab.tMod > FI_Index.tMod) ||
  676.     (TbixCheckIndex(szIndexFile) < 0)) {
  678. ///////////////////////////////////////////////////////////////////////////////
  679. //  Rebuild the index
  680. ///////////////////////////////////////////////////////////////////////////////
  681. if (TbixCreateIndex(pszTabFilePath, piFieldsIdx, bCaseSens, pHashFunc) < 0)
  682. return (ErrGetErrorCode());
  684. }
  686. return (0);
  688. }
  690. INDEX_HANDLE TbixOpenHandle(char const *pszTabFilePath, int const *piFieldsIdx,
  691.     SYS_UINT32 uHashVal)
  692. {
  693. ///////////////////////////////////////////////////////////////////////////////
  694. //  Build index file name
  695. ///////////////////////////////////////////////////////////////////////////////
  696. char szIndexFile[SYS_MAX_PATH] = "";
  698. if (TbixGetIndexFile(pszTabFilePath, piFieldsIdx, szIndexFile) < 0)
  699. return (INVALID_INDEX_HANDLE);
  701. ///////////////////////////////////////////////////////////////////////////////
  702. //  Open index
  703. ///////////////////////////////////////////////////////////////////////////////
  704. TabHashIndex THI;
  706. if (TbixOpenIndex(szIndexFile, THI) < 0)
  707. return (INVALID_INDEX_HANDLE);
  709. ///////////////////////////////////////////////////////////////////////////////
  710. //  Try to lookup records
  711. ///////////////////////////////////////////////////////////////////////////////
  712. SYS_UINT32 *pHashTable = TbixReadTable(THI, uHashVal);
  714. TbixCloseIndex(THI);
  716. if (pHashTable == NULL)
  717. return (INVALID_INDEX_HANDLE);
  719. ///////////////////////////////////////////////////////////////////////////////
  720. //  Open tab file
  721. ///////////////////////////////////////////////////////////////////////////////
  722. FILE *pTabFile = fopen(pszTabFilePath, "rb");
  724. if (pTabFile == NULL) {
  725. SysFree(pHashTable);
  727. ErrSetErrorCode(ERR_FILE_OPEN, pszTabFilePath);
  728. return (INVALID_INDEX_HANDLE);
  729. }
  730. ///////////////////////////////////////////////////////////////////////////////
  731. //  Setup lookup struct
  732. ///////////////////////////////////////////////////////////////////////////////
  733. IndexLookupData *pILD = (IndexLookupData *) SysAlloc(sizeof(IndexLookupData));
  735. if (pILD == NULL) {
  736. fclose(pTabFile);
  737. SysFree(pHashTable);
  738. return (INVALID_INDEX_HANDLE);
  739. }
  741. pILD->pTabFile = pTabFile;
  742. pILD->pHashTable = pHashTable;
  744. return ((INDEX_HANDLE) pILD);
  746. }
  748. int TbixCloseHandle(INDEX_HANDLE hIndexLookup)
  749. {
  751. IndexLookupData *pILD = (IndexLookupData *) hIndexLookup;
  753. fclose(pILD->pTabFile);
  755. SysFree(pILD->pHashTable);
  757. SysFree(pILD);
  759. return (0);
  761. }
  763. int TbixLookedUpRecords(INDEX_HANDLE hIndexLookup)
  764. {
  766. IndexLookupData *pILD = (IndexLookupData *) hIndexLookup;
  768. return ((int) pILD->pHashTable[0]);
  770. }
  772. char **TbixGetRecord(INDEX_HANDLE hIndexLookup, int iRecord)
  773. {
  775. IndexLookupData *pILD = (IndexLookupData *) hIndexLookup;
  777. if ((iRecord < 0) || (iRecord >= (int) pILD->pHashTable[0])) {
  778. ErrSetErrorCode(ERR_RECORD_NOT_FOUND);
  779. return (NULL);
  780. }
  782. return (TbixLoadRecord(pILD->pTabFile, pILD->pHashTable[iRecord + 1]));
  784. }