src/depends/directory.c

   1 #include <windows.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <assert.h>
   5 #include "directory.h"
   6
   7 #define MAX_WILDCARDS 10
   8
   9 // Internal functions only
  10 BOOL AddFileToSearchResult(PDIRECTORY_INFO pDirectory, char *BasePathName, char *Filename);
  11 BOOL MergeSearchResults(PDIRECTORY_INFO pBaseDir, PDIRECTORY_INFO pSubDir);
  12 BOOL MergeSearchResultsAndClose(PDIRECTORY_INFO pBaseDir, PDIRECTORY_INFO pSubDir);
  13 PSEARCH_RESULTS GetLastSearchResult(PSEARCH_RESULTS pSearchResult);
  14 DWORD GetSearchResultCount(PSEARCH_RESULTS pSearchResult);
  15 void DumpSearchResults(PSEARCH_RESULTS pSearchResults);
  16
  17 BOOL IsSameExtension(char *Extension1, char *Extension2)
  18 {
  19         if (_stricmp(Extension1, Extension2) == 0) return TRUE;
  20         else return FALSE;
  21 }
  22
  23 void PrintWildcardError()
  24 {
  25         fprintf(stderr, "Error: invalid wildcards for filename\n"
  26                 "Wildcards can be:\n"
  27                 "\tfilename      match \"filename\"\n"
  28                 "\tfilename.ext  match \"filename.ext\"\n"
  29                 "\t*             match all files (with or without extensions)\n"
  30                 "\t*.*           match all files with extensions\n"
  31                 "\t*.            match all files without extensions\n"
  32                 "\t*.ext         match all files ending in \".ext\"\n"
  33                 "\t*.ext1;*.ext2 match all files ending in \".ext1\" or \".ext2\"\n");
  34 }
  35
  36 PDIRECTORY_INFO DirectoryOpen(char *Directory, BOOL RecurseSubDirs)
  37 {
  38         PDIRECTORY_INFO pDirectory;
  39         char tmpdir[MAX_PATH+1];
  40
  41         if (!Directory) return NULL;
  42         //printf("Opening directory %s (RecurseSubDirs = %d)\n", Directory, RecurseSubDirs);
  43
  44         pDirectory = (PDIRECTORY_INFO)malloc(sizeof(DIRECTORY_INFO));
  45         if (!pDirectory)
  46         {
  47                 fprintf(stderr, "Unable to allocate %d bytes\n", sizeof(DIRECTORY_INFO));
  48                 return NULL;
  49         }
  50
  51         _snprintf(tmpdir, sizeof(tmpdir), "%s\\*", Directory);
  52         pDirectory->hFileList = FindFirstFile(tmpdir, &pDirectory->BasePath);
  53         if (pDirectory->hFileList == INVALID_HANDLE_VALUE)
  54         {
  55                 fprintf(stderr, "Invalid path \"%s\"\n", Directory);
  56                 return NULL;
  57         }
  58
  59         pDirectory->Initialized = TRUE;
  60         pDirectory->Finished = FALSE;
  61         pDirectory->RecurseSubDirs = RecurseSubDirs;
  62         pDirectory->pSearchResults = NULL;
  63
  64         _snprintf(pDirectory->BasePathName, sizeof(pDirectory->BasePathName), "%s", Directory);
  65         return pDirectory;
  66 }
  67
  68 void DirectoryClose(PDIRECTORY_INFO pDirectory)
  69 {
  70         PSEARCH_RESULTS pLast;
  71
  72         if (!pDirectory || !pDirectory->Initialized) return;
  73         //printf("Closing %s\n", pDirectory->BasePathName);
  74
  75         // Free the search results, if any
  76         if (pDirectory->pSearchResults)
  77         {
  78                 assert(pDirectory->pSearchResults->Previous == NULL);
  79
  80                 pLast = GetLastSearchResult(pDirectory->pSearchResults);
  81                 assert(pLast);
  82                 while (pLast->Previous)
  83                 {
  84                         assert(pLast->FilePath);
  85                         if (pLast->FilePath)
  86                         {
  87                                 //printf("Deallocating entry for %s\n", pLast->FilePath);
  88                                 free(pLast->FilePath);
  89                                 pLast->FilePath = NULL;
  90                         }
  91                         pLast = pLast->Previous;
  92                         free(pLast->Next);
  93                         pLast->Next = NULL;
  94                 }
  95
  96                 assert(pDirectory->pSearchResults == pLast);
  97                 assert(pDirectory->pSearchResults->FilePath);
  98
  99                 if (pDirectory->pSearchResults->FilePath)
 100                 {
 101                         //printf("Deallocating entry for %s\n", pDirectory->pSearchResults->FilePath);
 102                         free(pDirectory->pSearchResults->FilePath);
 103                         pDirectory->pSearchResults->FilePath = NULL;
 104                 }
 105
 106                 pDirectory->pSearchResults->Next = NULL;
 107                 free(pDirectory->pSearchResults);
 108                 pDirectory->pSearchResults = NULL;
 109         }
 110
 111         FindClose(pDirectory->hFileList);
 112         pDirectory->Initialized = FALSE;
 113         free(pDirectory);
 114 }
 115
 116 // This will match all files in a directory (or subdirectories if recursion is enabled)
 117 // Currently, this will not match any directories or specific filenames
 118 // Must use "*", "*.ext", or "*.ext1;*.ext2"
 119 // This is definitely not efficient and may crash when dealing with very deep levels
 120 BOOL DirectorySearch(PDIRECTORY_INFO pDirectory, char *FileWildcard)
 121 {
 122         int i, WildcardCount = 0;
 123     BOOL IsDirectory;
 124         BOOL RecurseSubDirs, MatchAllFiles = FALSE;
 125         char tmpSubDir[MAX_PATH+1];
 126         char *tmpWildcard, *Wildcard, *Wildcards[MAX_WILDCARDS];
 127         char *BasePathName, *Filename, *FileExtension, *tmpFileExtension;
 128         PDIRECTORY_INFO pNewDirectory;
 129
 130         if (!pDirectory || !pDirectory->Initialized || pDirectory->Finished) return FALSE;
 131
 132         //////////////////////////////////////////////////////////////
 133         // Setup wildcards
 134
 135         if (!FileWildcard)
 136         {
 137                 MatchAllFiles = TRUE;
 138         }
 139         else if (!FileWildcard[0] || strchr(FileWildcard, ','))
 140         {
 141                 PrintWildcardError();
 142                 return FALSE;
 143         }
 144         else
 145         {
 146                 if (!(tmpWildcard = Wildcard = strdup(FileWildcard)))
 147                 {
 148                         fprintf(stderr, "Error allocating %d bytes\n", strlen(FileWildcard)+1);
 149                         return FALSE;
 150                 }
 151
 152                 while (*tmpWildcard && (tmpFileExtension = strchr(tmpWildcard, ';')))
 153                 {
 154                         *tmpFileExtension++ = '\0';
 155                         if (WildcardCount == MAX_WILDCARDS - 1) return FALSE;
 156
 157                         if (tmpWildcard[0] == '*' && !tmpWildcard[1])
 158                         {
 159                                 MatchAllFiles = TRUE;
 160                                 break;
 161                         }
 162                         else
 163                         {
 164                                 if (tmpWildcard[0] == '*' && tmpWildcard[1] != '.')
 165                                 {
 166                                         PrintWildcardError();
 167                                         return FALSE;
 168                                 }
 169
 170                                 Wildcards[WildcardCount++] = strdup(tmpWildcard);
 171                                 tmpWildcard = tmpFileExtension;
 172                         }
 173                 }
 174
 175                 if (MatchAllFiles || (tmpWildcard[0] == '*' && !tmpWildcard[1]))
 176                 {
 177                         MatchAllFiles = TRUE;
 178                         for (i = 0; i < WildcardCount; i++) free(Wildcards[i]);
 179                         WildcardCount = 0;
 180                 }
 181                 else if (*tmpWildcard)
 182                 {
 183                         Wildcards[WildcardCount++] = strdup(tmpWildcard);
 184                         free(Wildcard);
 185                 }
 186         }
 187
 188         //////////////////////////////////////////////////////////////
 189         // Iterate through subdirectories
 190
 191         RecurseSubDirs = pDirectory->RecurseSubDirs;
 192         BasePathName = pDirectory->BasePathName;
 193         Filename = pDirectory->BasePath.cFileName;
 194
 195         //printf("=== Searching in %s (RecurseSubDirs = %d)\n", BasePathName, RecurseSubDirs);
 196         while (TRUE)
 197         {
 198                 IsDirectory = pDirectory->BasePath.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
 199                 FileExtension = strrchr(Filename, '.');
 200
 201                 // Match if the currently found item is a subdirectory and recursion is enabled
 202                 if (IsDirectory && RecurseSubDirs && *Filename != '.')
 203                 {
 204                         _snprintf(tmpSubDir, sizeof(tmpSubDir), "%s\\%s", BasePathName, Filename);
 205                         if (!(pNewDirectory = DirectoryOpen(tmpSubDir, TRUE))) return FALSE;
 206                         if (!(DirectorySearch(pNewDirectory, FileWildcard))) return FALSE;
 207                         if (!MergeSearchResults(pDirectory, pNewDirectory)) return FALSE;
 208                         DirectoryClose(pNewDirectory);
 209                 }
 210
 211                 // Try to match the current file to a wildcard or filename
 212                 else if (!IsDirectory)
 213                 {
 214                         //printf("Found %s\\%s\n", BasePathName, Filename);
 215
 216                         if (MatchAllFiles)
 217                         {
 218                                 if (!AddFileToSearchResult(pDirectory, BasePathName, Filename)) return FALSE;
 219                         }
 220                         else if (FileExtension)
 221                         {
 222                                 FileExtension++; // point to one byte past "." (the file extension)
 223                                 for (i = 0; i < WildcardCount; i++)
 224                                 {
 225                                         if (Wildcards[i][0] == '*')
 226                                         {
 227                                                 if (!Wildcards[i][1] || Wildcards[i][2] == '*')
 228                                                 {
 229                                                         if (!AddFileToSearchResult(pDirectory, BasePathName, Filename)) return FALSE;
 230                                                         break;
 231                                                 }
 232                                                 else if (Wildcards[i][2] && IsSameExtension(FileExtension, Wildcards[i] + 2))
 233                                                 {
 234                                                         if (!AddFileToSearchResult(pDirectory, BasePathName, Filename)) return FALSE;
 235                                                         break;
 236                                                 }
 237                                         }
 238                                         else if (IsSameExtension(Filename, Wildcards[i]))
 239                                         {
 240                                                 if (!AddFileToSearchResult(pDirectory, BasePathName, Filename)) return FALSE;
 241                                                 break;
 242                                         }
 243                                 }
 244                         }
 245                         else
 246                         {
 247                                 for (i = 0; i < WildcardCount; i++)
 248                                 {
 249                                         if (Wildcards[i][0] == '*' && Wildcards[i][1] == '.' && !Wildcards[i][2])
 250                                         {
 251                                                 if (!AddFileToSearchResult(pDirectory, BasePathName, Filename)) return FALSE;
 252                                                 break;
 253                                         }
 254                                         else if (IsSameExtension(Filename, Wildcards[i])) // match file
 255                                         {
 256                                                 if (!AddFileToSearchResult(pDirectory, BasePathName, Filename)) return FALSE;
 257                                                 break;
 258                                         }
 259
 260                                 }
 261                         }
 262                 }
 263
 264                 if (!FindNextFile(pDirectory->hFileList, &pDirectory->BasePath))
 265                 {
 266                         if (GetLastError() == ERROR_NO_MORE_FILES) break;
 267                         fprintf(stderr, "FindNextFile failed: error code 0x%08lx\n", GetLastError());
 268                         return FALSE;
 269                 }
 270     }
 271
 272         pDirectory->Finished = TRUE;
 273         return TRUE;
 274 }
 275
 276 PSEARCH_RESULTS GetLastSearchResult(PSEARCH_RESULTS pSearchResult)
 277 {
 278         while (pSearchResult && pSearchResult->Next) pSearchResult = pSearchResult->Next;
 279         return pSearchResult;
 280 }
 281
 282 BOOL AddFileToSearchResult(PDIRECTORY_INFO pDirectory, char *BasePathName, char *Filename)
 283 {
 284         DWORD PathLength;
 285         PSEARCH_RESULTS pSearchResults;
 286
 287         ////////////////////////////////////////////////////////////////
 288         // Allocate a new search result set or append to an existing one
 289
 290         if (!pDirectory->pSearchResults)
 291         {
 292                 pSearchResults = pDirectory->pSearchResults = malloc(sizeof(SEARCH_RESULTS));
 293                 if (!pSearchResults)
 294                 {
 295                         fprintf(stderr, "Error allocating %d bytes\n", sizeof(SEARCH_RESULTS));
 296                         return FALSE;
 297                 }
 298
 299                 pSearchResults->Previous = NULL;
 300         }
 301         else // an existing entry
 302         {
 303                 pSearchResults = GetLastSearchResult(pDirectory->pSearchResults);
 304                 if (!(pSearchResults->Next = malloc(sizeof(SEARCH_RESULTS))))
 305                 {
 306                         fprintf(stderr, "Error: unable to allocate %d bytes\n", sizeof(SEARCH_RESULTS));
 307                         return FALSE;
 308                 }
 309                 pSearchResults->Next->Previous = pSearchResults;
 310                 pSearchResults = pSearchResults->Next;
 311         }
 312
 313         pSearchResults->Next = NULL;
 314
 315         ////////////////////////////////////////////////////////////////
 316         // Save path to filename for the search result
 317
 318         PathLength = strlen(pDirectory->BasePathName) + strlen(Filename) + 2;
 319         if (PathLength > MAX_PATH)
 320         {
 321                 fprintf(stderr, "Error: File path is too large\n");
 322                 return FALSE;
 323         }
 324
 325         if (!(pSearchResults->FilePath = (char *)malloc(PathLength)))
 326         {
 327                 fprintf(stderr, "Error: unable to allocate %d bytes\n", PathLength);
 328                 return FALSE;
 329         }
 330
 331         sprintf(pSearchResults->FilePath, "%s\\%s", BasePathName, Filename);
 332         //printf("Added %s\n", pSearchResults->FilePath);
 333         return TRUE;
 334 }
 335
 336 BOOL MergeSearchResults(PDIRECTORY_INFO pBaseDir, PDIRECTORY_INFO pSubDir)
 337 {
 338         DWORD PathLength;
 339         PSEARCH_RESULTS pDestination, pSource;
 340
 341         if (!pBaseDir || !pSubDir) return FALSE;
 342         pSource = pSubDir->pSearchResults;
 343         if (!pSource) return TRUE; // subdirectory is empty (don't merge)
 344         assert(pSource->Previous == NULL);
 345
 346         if (!pBaseDir->pSearchResults) // merge subdirectory into empty result set
 347         {
 348                 pDestination = pBaseDir->pSearchResults = malloc(sizeof(SEARCH_RESULTS));
 349                 if (!pDestination)
 350                 {
 351                         fprintf(stderr, "Error allocating %d bytes\n", sizeof(SEARCH_RESULTS));
 352                         return FALSE;
 353                 }
 354
 355                 pDestination->Previous = NULL;
 356                 pDestination->Next = NULL;
 357         }
 358         else // merge subdirectory with an existing result set
 359         {
 360                 assert(pBaseDir->pSearchResults->Previous == NULL);
 361                 pDestination = GetLastSearchResult(pBaseDir->pSearchResults);
 362                 pDestination->Next = malloc(sizeof(SEARCH_RESULTS));
 363                 if (!pDestination->Next)
 364                 {
 365                         fprintf(stderr, "Error: unable to allocate %d bytes\n", sizeof(SEARCH_RESULTS));
 366                         return FALSE;
 367                 }
 368
 369                 pDestination->Next->Previous = pDestination;
 370                 pDestination = pDestination->Next;
 371                 pDestination->Next = NULL;
 372         }
 373
 374         while (TRUE)
 375         {
 376                 assert(pSource->FilePath != NULL);
 377                 PathLength = strlen(pSource->FilePath) + 1;
 378                 if (!(pDestination->FilePath = (char *)malloc(PathLength)))
 379                 {
 380                         fprintf(stderr, "Error: unable to allocate %d bytes\n", PathLength);
 381                         return FALSE;
 382                 }
 383
 384                 strcpy(pDestination->FilePath, pSource->FilePath);
 385                 //printf("Merged %s\n", pDestination->FilePath);
 386
 387                 pSource = pSource->Next;
 388                 if (!pSource) break;
 389
 390                 pDestination->Next = malloc(sizeof(SEARCH_RESULTS));
 391                 if (!pDestination->Next)
 392                 {
 393                         fprintf(stderr, "Error: unable to allocate %d bytes\n", sizeof(SEARCH_RESULTS));
 394                         return FALSE;
 395                 }
 396
 397                 pDestination->Next->Previous = pDestination;
 398                 pDestination = pDestination->Next;
 399                 pDestination->Next = NULL;
 400         }
 401
 402         //printf("New base directory contains:\n");
 403         //DumpSearchResults(pSubDir->pSearchResults);
 404         return TRUE;
 405 }
 406
 407 DWORD GetSearchResultCount(PSEARCH_RESULTS pSearchResult)
 408 {
 409         DWORD Count = 0;
 410
 411         if (!pSearchResult) return 0;
 412         while (pSearchResult && pSearchResult->Next)
 413         {
 414                 pSearchResult = pSearchResult->Next;
 415                 Count++;
 416         }
 417
 418         return Count + 1;
 419 }
 420
 421 void DumpSearchResults(PSEARCH_RESULTS pSearchResults)
 422 {
 423         PSEARCH_RESULTS tmpResult;
 424
 425         if (!pSearchResults) return;
 426
 427         printf("Total records: %d\n", GetSearchResultCount(pSearchResults));
 428         for (tmpResult = pSearchResults; tmpResult; tmpResult = tmpResult->Next)
 429         {
 430                 if (tmpResult->FilePath) printf("\t%s\n", tmpResult->FilePath);
 431         }
 432 }