contrib/vmap_extractor_v2/stormlib/SFileFindFile.cpp

   1 /*****************************************************************************/
   2 /* SFileFindFile.cpp                      Copyright (c) Ladislav Zezula 2003 */
   3 /*---------------------------------------------------------------------------*/
   4 /* A module for file searching within MPQs                                   */
   5 /*---------------------------------------------------------------------------*/
   6 /*   Date    Ver   Who  Comment                                              */
   7 /* --------  ----  ---  -------                                              */
   8 /* 25.03.03  1.00  Lad  The first version of SFileFindFile.cpp               */
   9 /*****************************************************************************/
  10
  11 #define __STORMLIB_SELF__
  12 #include "StormLib.h"
  13 #include "SCommon.h"
  14
  15 //-----------------------------------------------------------------------------
  16 // Defines
  17
  18 #define LISTFILE_CACHE_SIZE 0x1000
  19
  20 //-----------------------------------------------------------------------------
  21 // Local functions
  22
  23 static BOOL IsValidSearchHandle(TMPQSearch * hs)
  24 {
  25     if(hs == NULL || IsBadReadPtr(hs, sizeof(TMPQSearch)))
  26         return FALSE;
  27
  28     if(!IsValidMpqHandle(hs->ha))
  29         return FALSE;
  30
  31     return TRUE;
  32 }
  33
  34 // This function compares a string with a wildcard search string.
  35 // returns TRUE, when the string matches with the wildcard.
  36 BOOL CheckWildCard(const char * szString, const char * szWildCard)
  37 {
  38     char * szTemp;                      // Temporary helper pointer
  39     int nResult = 0;                    // For memcmp return values
  40     int nMustNotMatch = 0;              // Number of following chars int szString,
  41                                         // which must not match with szWildCard
  42     int nMustMatch = 0;                 // Number of the following characters,
  43                                         // which must match
  44
  45     // When the string is empty, it does not match with every wildcard
  46     if(*szString == 0)
  47         return FALSE;
  48
  49     // When the mask is empty, it matches to every wildcard
  50     if(szWildCard == NULL || *szWildCard == 0)
  51         return FALSE;
  52
  53     // Do normal test
  54     for(;;)
  55     {
  56         switch(*szWildCard)
  57         {
  58             case '*': // Means "every number of characters"
  59                 // Skip all asterisks
  60                 while(*szWildCard == '*')
  61                     szWildCard++;
  62
  63                 // When no more characters in wildcard, it means that the strings match
  64                 if(*szWildCard == 0)
  65                     return TRUE;
  66
  67                 // The next N characters must not agree
  68                 nMustNotMatch |= 0x70000000;
  69                 break;
  70
  71             case '?':  // Means "One or no character"
  72                 while(*szWildCard == '?')
  73                 {
  74                     nMustNotMatch++;
  75                     szWildCard++;
  76                 }
  77                 break;
  78
  79             default:
  80                 // If the two characters match
  81                 if(toupper(*szString) == toupper(*szWildCard))
  82                 {
  83                     // When end of string, they agree
  84                     if(*szString == 0)
  85                         return TRUE;
  86
  87                     nMustNotMatch = 0;
  88                     szWildCard++;
  89                     szString++;
  90                     break;
  91                 }
  92
  93                 // If the next character must match, the string does not match
  94                 if(nMustNotMatch == 0)
  95                     return FALSE;
  96
  97                 // Count the characters which must match after characters
  98                 // that must not match
  99                 szTemp = (char *)szWildCard;
 100                 nMustMatch = 0;
 101                 while(*szTemp != 0 && *szTemp != '*' && *szTemp != '?')
 102                 {
 103                     nMustMatch++;
 104                     szTemp++;
 105                 }
 106
 107                 // Now skip characters from szString up to number of chars
 108                 // that must not match
 109                 nResult = -1;
 110                 while(nMustNotMatch > 0 && *szString != 0)
 111                 {
 112                     if((nResult = _strnicmp(szString, szWildCard, nMustMatch)) == 0)
 113                         break;
 114
 115                     szString++;
 116                     nMustNotMatch--;
 117                 }
 118
 119                 // Make one more comparison
 120                 if(nMustNotMatch == 0)
 121                     nResult = _strnicmp(szString, szWildCard, nMustMatch);
 122
 123                 // If a match has been found, continue the search
 124                 if(nResult == 0)
 125                 {
 126                     nMustNotMatch = 0;
 127                     szWildCard += nMustMatch;
 128                     szString   += nMustMatch;
 129                     break;
 130                 }
 131                 return FALSE;
 132         }
 133     }
 134 }
 135
 136 // Performs one MPQ search
 137 // TODO: Test for archives > 4GB
 138 static int DoMPQSearch(TMPQSearch * hs, SFILE_FIND_DATA * lpFindFileData)
 139 {
 140     TMPQArchive * ha = hs->ha;
 141     TFileNode * pNode;
 142     TMPQHash * pHashEnd = ha->pHashTable + ha->pHeader->dwHashTableSize;
 143     TMPQHash * pHash = ha->pHashTable + hs->dwNextIndex;
 144
 145     // Do until some file found or no more files
 146     while(pHash < pHashEnd)
 147     {
 148         pNode = ha->pListFile[hs->dwNextIndex++];
 149
 150         // If this entry is free, do nothing
 151         if(pHash->dwBlockIndex < HASH_ENTRY_FREE && (DWORD_PTR)pNode < HASH_ENTRY_FREE)
 152         {
 153             // Check the file name.
 154             if(CheckWildCard(pNode->szFileName, hs->szSearchMask))
 155             {
 156                 TMPQBlock * pBlock = ha->pBlockTable + pHash->dwBlockIndex;
 157
 158                 lpFindFileData->lcLocale     = pHash->lcLocale;
 159                 lpFindFileData->dwFileSize   = pBlock->dwFSize;
 160                 lpFindFileData->dwFileFlags  = pBlock->dwFlags;
 161                 lpFindFileData->dwBlockIndex = pHash->dwBlockIndex;
 162                 lpFindFileData->dwCompSize   = pBlock->dwCSize;
 163
 164                 // Fill the file name and plain file name
 165                 strcpy(lpFindFileData->cFileName, pNode->szFileName);
 166                 lpFindFileData->szPlainName = strrchr(lpFindFileData->cFileName, '\\');
 167                 if(lpFindFileData->szPlainName == NULL)
 168                     lpFindFileData->szPlainName = lpFindFileData->cFileName;
 169                 else
 170                     lpFindFileData->szPlainName++;
 171
 172                 // Fill the next entry
 173                 return ERROR_SUCCESS;
 174             }
 175         }
 176
 177         pHash++;
 178     }
 179
 180     // No more files found, return error
 181     return ERROR_NO_MORE_FILES;
 182 }
 183
 184 // TODO: Test for archives > 4GB
 185 static void FreeMPQSearch(TMPQSearch *& hs)
 186 {
 187     if(hs != NULL)
 188     {
 189         FREEMEM(hs);
 190         hs = NULL;
 191     }
 192 }
 193
 194 //-----------------------------------------------------------------------------
 195 // Public functions
 196
 197 // TODO: Test for archives > 4GB
 198 HANDLE WINAPI SFileFindFirstFile(HANDLE hMPQ, const char * szMask, SFILE_FIND_DATA * lpFindFileData, const char * szListFile)
 199 {
 200     TMPQArchive * ha = (TMPQArchive *)hMPQ;
 201     TMPQSearch * hs = NULL;             // Search object handle
 202     size_t nSize  = 0;
 203     int nError = ERROR_SUCCESS;
 204
 205     // Check for the valid parameters
 206     if(nError == ERROR_SUCCESS)
 207     {
 208         if(!IsValidMpqHandle(ha))
 209             nError = ERROR_INVALID_PARAMETER;
 210
 211         if(szMask == NULL || lpFindFileData == NULL)
 212             nError = ERROR_INVALID_PARAMETER;
 213
 214         if(szListFile == NULL && !IsValidMpqHandle(ha))
 215             nError = ERROR_INVALID_PARAMETER;
 216     }
 217
 218     // Include the listfile into the MPQ's internal listfile
 219     // Note that if the listfile name is NULL, do nothing because the
 220     // internal listfile is always included.
 221     if(nError == ERROR_SUCCESS && szListFile != NULL)
 222         nError = SFileAddListFile((HANDLE)ha, szListFile);
 223
 224     // Allocate the structure for MPQ search
 225     if(nError == ERROR_SUCCESS)
 226     {
 227         nSize = sizeof(TMPQSearch) + strlen(szMask) + 1;
 228         if((hs = (TMPQSearch *)ALLOCMEM(char, nSize)) == NULL)
 229             nError = ERROR_NOT_ENOUGH_MEMORY;
 230     }
 231
 232     // Perform the first search
 233     if(nError == ERROR_SUCCESS)
 234     {
 235         memset(hs, 0, sizeof(TMPQSearch));
 236         hs->ha          = ha;
 237         hs->dwNextIndex = 0;
 238         strcpy(hs->szSearchMask, szMask);
 239         nError = DoMPQSearch(hs, lpFindFileData);
 240     }
 241
 242     // Cleanup
 243     if(nError != ERROR_SUCCESS)
 244     {
 245         FreeMPQSearch(hs);
 246         SetLastError(nError);
 247     }
 248
 249     // Return the result value
 250     return (HANDLE)hs;
 251 }
 252
 253 // TODO: Test for archives > 4GB
 254 BOOL WINAPI SFileFindNextFile(HANDLE hFind, SFILE_FIND_DATA * lpFindFileData)
 255 {
 256     TMPQSearch * hs = (TMPQSearch *)hFind;
 257     int nError = ERROR_SUCCESS;
 258
 259     // Check the parameters
 260     if(nError == ERROR_SUCCESS)
 261     {
 262         if(!IsValidSearchHandle(hs) || lpFindFileData == NULL)
 263             nError = ERROR_INVALID_PARAMETER;
 264     }
 265
 266     if(nError == ERROR_SUCCESS)
 267         nError = DoMPQSearch(hs, lpFindFileData);
 268
 269     if(nError != ERROR_SUCCESS)
 270     {
 271         SetLastError(nError);
 272         return FALSE;
 273     }
 274     return TRUE;
 275 }
 276
 277 // TODO: Test for archives > 4GB
 278 BOOL WINAPI SFileFindClose(HANDLE hFind)
 279 {
 280     TMPQSearch * hs = (TMPQSearch *)hFind;
 281
 282     // Check the parameters
 283     if(!IsValidSearchHandle(hs))
 284     {
 285         SetLastError(ERROR_INVALID_PARAMETER);
 286         return FALSE;
 287     }
 288
 289     FreeMPQSearch(hs);
 290     return TRUE;
 291 }