src/mac/morefile/mfsearch.cpp

   1 /*
   2 **      Apple Macintosh Developer Technical Support
   3 **
   4 **      IndexedSearch and the PBCatSearch compatibility function.
   5 **
   6 **      by Jim Luther, Apple Developer Technical Support Emeritus
   7 **
   8 **      File:           Search.c
   9 **
  10 **      Copyright © 1992-1998 Apple Computer, Inc.
  11 **      All rights reserved.
  12 **
  13 **      You may incorporate this sample code into your applications without
  14 **      restriction, though the sample code has been provided "AS IS" and the
  15 **      responsibility for its operation is 100% yours.  However, what you are
  16 **      not permitted to do is to redistribute the source as "DSC Sample Code"
  17 **      after having made changes. If you're going to re-distribute the source,
  18 **      we require that you make it clear in the source that the code was
  19 **      descended from Apple Sample Code, but that you've made changes.
  20 */
  21
  22 #include <Types.h>
  23 #include <Gestalt.h>
  24 #include <Timer.h>
  25 #include <Errors.h>
  26 #include <Memory.h>
  27 #include <Files.h>
  28 #include <TextUtils.h>
  29
  30 #define __COMPILINGMOREFILES
  31
  32 #include "morefile.h"
  33 #include "moreextr.h"
  34 #include "mfsearch.h"
  35
  36 /*****************************************************************************/
  37
  38 enum
  39 {
  40         /* Number of LevelRecs to add each time the searchStack is grown */
  41         /* 20 levels is probably more than reasonable for most volumes. */
  42         /* If more are needed, they are allocated 20 levels at a time. */
  43         kAdditionalLevelRecs = 20
  44 };
  45
  46 /*****************************************************************************/
  47
  48 /*
  49 **      LevelRecs are used to store the directory ID and index whenever
  50 **      IndexedSearch needs to either scan a sub-directory, or return control
  51 **      to the caller because the call has timed out or the number of
  52 **      matches requested has been found. LevelRecs are stored in an array
  53 **      used as a stack.
  54 */
  55 struct  LevelRec
  56 {
  57         long    dirModDate;     /* for detecting most (but not all) catalog changes */
  58         long    dirID;
  59         short   index;
  60 };
  61 typedef struct LevelRec LevelRec;
  62 typedef LevelRec *LevelRecPtr, **LevelRecHandle;
  63
  64
  65 /*
  66 **      SearchPositionRec is my version of a CatPositionRec. It holds the
  67 **      information I need to resuming searching.
  68 */
  69 #if PRAGMA_STRUCT_ALIGN
  70     #pragma options align=mac68k
  71 #elif PRAGMA_STRUCT_PACKPUSH
  72     #pragma pack(push, 2)
  73 #elif PRAGMA_STRUCT_PACK
  74     #pragma pack(2)
  75 #endif
  76 struct SearchPositionRec
  77 {
  78         long                    initialize;             /* Goofy checksum of volume information used to make */
  79                                                                         /* sure we're resuming a search on the same volume. */
  80         unsigned short  stackDepth;             /* Current depth on searchStack. */
  81         short                   priv[11];               /* For future use... */
  82 };
  83 #if PRAGMA_STRUCT_ALIGN
  84     #pragma options align=reset
  85 #elif PRAGMA_STRUCT_PACKPUSH
  86     #pragma pack(pop)
  87 #elif PRAGMA_STRUCT_PACK
  88     #pragma pack()
  89 #endif
  90 typedef struct SearchPositionRec SearchPositionRec;
  91 typedef SearchPositionRec *SearchPositionRecPtr;
  92
  93
  94 /*
  95 **      ExtendedTMTask is a TMTask record extended to hold the timer flag.
  96 */
  97 #if PRAGMA_STRUCT_ALIGN
  98     #pragma options align=mac68k
  99 #elif PRAGMA_STRUCT_PACKPUSH
 100     #pragma pack(push, 2)
 101 #elif PRAGMA_STRUCT_PACK
 102     #pragma pack(2)
 103 #endif
 104 struct ExtendedTMTask
 105 {
 106         TMTask                  theTask;
 107         Boolean                 stopSearch;             /* the Time Mgr task will set stopSearch to */
 108                                                                         /* true when the timer expires */
 109 };
 110 #if PRAGMA_STRUCT_ALIGN
 111     #pragma options align=reset
 112 #elif PRAGMA_STRUCT_PACKPUSH
 113     #pragma pack(pop)
 114 #elif PRAGMA_STRUCT_PACK
 115     #pragma pack()
 116 #endif
 117 typedef struct ExtendedTMTask ExtendedTMTask;
 118 typedef ExtendedTMTask *ExtendedTMTaskPtr;
 119
 120 /*****************************************************************************/
 121
 122 static  OSErr   CheckVol(ConstStr255Param pathname,
 123                                                  short vRefNum,
 124                                                  short *realVRefNum,
 125                                                  long *volID);
 126
 127 static  OSErr   CheckStack(unsigned short stackDepth,
 128                                                    LevelRecHandle searchStack,
 129                                                    Size *searchStackSize);
 130
 131 static  OSErr   VerifyUserPB(CSParamPtr userPB,
 132                                                          Boolean *includeFiles,
 133                                                          Boolean *includeDirs,
 134                                                          Boolean *includeNames);
 135
 136 static  Boolean IsSubString(ConstStr255Param aStringPtr,
 137                                                         ConstStr255Param subStringPtr);
 138
 139 static  Boolean CompareMasked(const long *data1,
 140                                                           const long *data2,
 141                                                           const long *mask,
 142                                                           short longsToCompare);
 143
 144 static  void    CheckForMatches(CInfoPBPtr cPB,
 145                                                                 CSParamPtr userPB,
 146                                                                 const Str63 matchName,
 147                                                                 Boolean includeFiles,
 148                                                                 Boolean includeDirs);
 149
 150 #if     __WANTPASCALELIMINATION
 151 #undef  pascal
 152 #endif
 153
 154 #if TARGET_CARBON
 155 static  pascal  void    TimeOutTask(TMTaskPtr tmTaskPtr);
 156
 157 #else
 158 #if GENERATINGCFM
 159
 160 static  pascal  void    TimeOutTask(TMTaskPtr tmTaskPtr);
 161
 162 #else
 163
 164 static  pascal  TMTaskPtr       GetTMTaskPtr(void);
 165
 166 static  void    TimeOutTask(void);
 167
 168 #endif
 169 #endif
 170
 171 #if     __WANTPASCALELIMINATION
 172 #define pascal
 173 #endif
 174
 175 static  long    GetDirModDate(short vRefNum,
 176                                                           long dirID);
 177
 178 /*****************************************************************************/
 179
 180 /*
 181 **      CheckVol gets the volume's real vRefNum and builds a volID. The volID
 182 **      is used to help insure that calls to resume searching with IndexedSearch
 183 **      are to the same volume as the last call to IndexedSearch.
 184 */
 185 static  OSErr   CheckVol(ConstStr255Param pathname,
 186                                                  short vRefNum,
 187                                                  short *realVRefNum,
 188                                                  long *volID)
 189 {
 190         HParamBlockRec pb;
 191         OSErr error;
 192
 193         error = GetVolumeInfoNoName(pathname, vRefNum, &pb);
 194         if ( error == noErr )
 195         {
 196                 /* Return the real vRefNum */
 197                 *realVRefNum = pb.volumeParam.ioVRefNum;
 198
 199                 /* Add together a bunch of things that aren't supposed to change on */
 200                 /* a mounted volume that's being searched and that should come up with */
 201                 /* a fairly unique number */
 202                 *volID = pb.volumeParam.ioVCrDate +
 203                                  pb.volumeParam.ioVRefNum +
 204                                  pb.volumeParam.ioVNmAlBlks +
 205                                  pb.volumeParam.ioVAlBlkSiz +
 206                                  pb.volumeParam.ioVFSID;
 207         }
 208         return ( error );
 209 }
 210
 211 /*****************************************************************************/
 212
 213 /*
 214 **      CheckStack checks the size of the search stack (array) to see if there's
 215 **      room to push another LevelRec. If not, CheckStack grows the stack by
 216 **      another kAdditionalLevelRecs elements.
 217 */
 218 static  OSErr   CheckStack(unsigned short stackDepth,
 219                                                    LevelRecHandle searchStack,
 220                                                    Size *searchStackSize)
 221 {
 222         OSErr   result;
 223
 224         if ( (*searchStackSize / sizeof(LevelRec)) == (stackDepth + 1) )
 225         {
 226                 /* Time to grow stack */
 227                 SetHandleSize((Handle)searchStack, *searchStackSize + (kAdditionalLevelRecs * sizeof(LevelRec)));
 228                 result = MemError();    /* should be noErr */
 229 #if TARGET_CARBON
 230                 *searchStackSize = GetHandleSize((Handle)searchStack);
 231 #else
 232                 *searchStackSize = InlineGetHandleSize((Handle)searchStack);
 233 #endif
 234         }
 235         else
 236         {
 237                 result = noErr;
 238         }
 239
 240         return ( result );
 241 }
 242
 243 /*****************************************************************************/
 244
 245 /*
 246 **      VerifyUserPB makes sure the parameter block passed to IndexedSearch has
 247 **      valid parameters. By making this check once, we don't have to worry about
 248 **      things like NULL pointers, strings being too long, etc.
 249 **      VerifyUserPB also determines if the search includes files and/or
 250 **      directories, and determines if a full or partial name search was requested.
 251 */
 252 static  OSErr   VerifyUserPB(CSParamPtr userPB,
 253                                                          Boolean *includeFiles,
 254                                                          Boolean *includeDirs,
 255                                                          Boolean *includeNames)
 256 {
 257         CInfoPBPtr      searchInfo1;
 258         CInfoPBPtr      searchInfo2;
 259
 260         searchInfo1 = userPB->ioSearchInfo1;
 261         searchInfo2 = userPB->ioSearchInfo2;
 262
 263         /* ioMatchPtr cannot be NULL */
 264         if ( userPB->ioMatchPtr == NULL )
 265         {
 266                 goto ParamErrExit;
 267         }
 268
 269         /* ioSearchInfo1 cannot be NULL */
 270         if ( searchInfo1 == NULL )
 271         {
 272                 goto ParamErrExit;
 273         }
 274
 275         /* If any bits except partialName, fullName, or negate are set, then */
 276         /* ioSearchInfo2 cannot be NULL because information in ioSearchInfo2 is required  */
 277         if ( ((userPB->ioSearchBits & ~(fsSBPartialName | fsSBFullName | fsSBNegate)) != 0) &&
 278                  ( searchInfo2 == NULL ))
 279         {
 280                 goto ParamErrExit;
 281         }
 282
 283         *includeFiles = false;
 284         *includeDirs = false;
 285         *includeNames = false;
 286
 287         if ( (userPB->ioSearchBits & (fsSBPartialName | fsSBFullName)) != 0 )
 288         {
 289                 /* If any kind of name matching is requested, then ioNamePtr in */
 290                 /* ioSearchInfo1 cannot be NULL or a zero-length string */
 291                 if ( (searchInfo1->hFileInfo.ioNamePtr == NULL) ||
 292                          (searchInfo1->hFileInfo.ioNamePtr[0] == 0) ||
 293                          (searchInfo1->hFileInfo.ioNamePtr[0] > (sizeof(Str63) - 1)) )
 294                 {
 295                         goto ParamErrExit;
 296                 }
 297
 298                 *includeNames = true;
 299         }
 300
 301         if ( (userPB->ioSearchBits & fsSBFlAttrib) != 0 )
 302         {
 303                 /* The only attributes you can search on are the directory flag */
 304                 /* and the locked flag. */
 305                 if ( (searchInfo2->hFileInfo.ioFlAttrib & ~(ioDirMask | 0x01)) != 0 )
 306                 {
 307                         goto ParamErrExit;
 308                 }
 309
 310                 /* interested in the directory bit? */
 311                 if ( (searchInfo2->hFileInfo.ioFlAttrib & ioDirMask) != 0 )
 312                 {
 313                         /* yes, so do they want just directories or just files? */
 314                         if ( (searchInfo1->hFileInfo.ioFlAttrib & ioDirMask) != 0 )
 315                         {
 316                                 *includeDirs = true;
 317                         }
 318                         else
 319                         {
 320                                 *includeFiles = true;
 321                         }
 322                 }
 323                 else
 324                 {
 325                         /* no interest in directory bit - get both files and directories */
 326                         *includeDirs = true;
 327                         *includeFiles = true;
 328                 }
 329         }
 330         else
 331         {
 332                 /* no attribute checking - get both files and directories */
 333                 *includeDirs = true;
 334                 *includeFiles = true;
 335         }
 336
 337         /* If directories are included in the search, */
 338         /* then the locked attribute cannot be requested. */
 339         if ( *includeDirs &&
 340                  ((userPB->ioSearchBits & fsSBFlAttrib) != 0) &&
 341                  ((searchInfo2->hFileInfo.ioFlAttrib & 0x01) != 0) )
 342         {
 343                 goto ParamErrExit;
 344         }
 345
 346         /* If files are included in the search, then there cannot be */
 347         /* a search on the number of files. */
 348         if ( *includeFiles &&
 349                  ((userPB->ioSearchBits & fsSBDrNmFls) != 0) )
 350         {
 351                 goto ParamErrExit;
 352         }
 353
 354         /* If directories are included in the search, then there cannot */
 355         /* be a search on file lengths. */
 356         if ( *includeDirs &&
 357                  ((userPB->ioSearchBits & (fsSBFlLgLen | fsSBFlPyLen | fsSBFlRLgLen | fsSBFlRPyLen)) != 0) )
 358         {
 359                 goto ParamErrExit;
 360         }
 361
 362         return ( noErr );
 363
 364 ParamErrExit:
 365         return ( paramErr );
 366 }
 367
 368 /*****************************************************************************/
 369
 370 /*
 371 **      IsSubString checks to see if a string is a substring of another string.
 372 **      Both input strings have already been converted to all uppercase using
 373 **      UprString (the same non-international call the File Manager uses).
 374 */
 375 static  Boolean IsSubString(ConstStr255Param aStringPtr,
 376                                                         ConstStr255Param subStringPtr)
 377 {
 378         short   strLength;              /* length of string */
 379         short   subStrLength;   /* length of subString */
 380         Boolean found;                  /* result of test */
 381         short   index;                  /* current index into string */
 382
 383         found = false;
 384         strLength = aStringPtr[0];
 385         subStrLength = subStringPtr[0];
 386
 387         if ( subStrLength <= strLength)
 388         {
 389                 register short  count;                  /* search counter */
 390                 register short  strIndex;               /* running index into string */
 391                 register short  subStrIndex;    /* running index into subString */
 392
 393                 /* start looking at first character */
 394                 index = 1;
 395
 396                 /* continue looking until remaining string is shorter than substring */
 397                 count = strLength - subStrLength + 1;
 398
 399                 do
 400                 {
 401                         strIndex = index;       /* start string index at index */
 402                         subStrIndex = 1;        /* start subString index at 1 */
 403
 404                         while ( !found && (aStringPtr[strIndex] == subStringPtr[subStrIndex]) )
 405                         {
 406                                 if ( subStrIndex == subStrLength )
 407                                 {
 408                                         /* all characters in subString were found */
 409                                         found = true;
 410                                 }
 411                                 else
 412                                 {
 413                                         /* check next character of substring against next character of string */
 414                                         ++subStrIndex;
 415                                         ++strIndex;
 416                                 }
 417                         }
 418
 419                         if ( !found )
 420                         {
 421                                 /* start substring search again at next string character */
 422                                 ++index;
 423                                 --count;
 424                         }
 425                 } while ( count != 0 && (!found) );
 426         }
 427
 428         return ( found );
 429 }
 430
 431 /*****************************************************************************/
 432
 433 /*
 434 **      CompareMasked does a bitwise comparison with mask on 1 or more longs.
 435 **      data1 and data2 are first exclusive-ORed together resulting with bits set
 436 **      where they are different. That value is then ANDed with the mask resulting
 437 **      with bits set if the test fails. true is returned if the tests pass.
 438 */
 439 static  Boolean CompareMasked(const long *data1,
 440                                                           const long *data2,
 441                                                           const long *mask,
 442                                                           short longsToCompare)
 443 {
 444         Boolean result = true;
 445
 446         while ( (longsToCompare != 0) && (result == true) )
 447         {
 448                 /* (*data1 ^ *data2) = bits that are different, so... */
 449                 /* ((*data1 ^ *data2) & *mask) = bits that are different that we're interested in */
 450
 451                 if ( ((*data1 ^ *data2) & *mask) != 0 )
 452                         result = false;
 453
 454                 ++data1;
 455                 ++data2;
 456                 ++mask;
 457                 --longsToCompare;
 458         }
 459
 460         return ( result );
 461 }
 462
 463 /*****************************************************************************/
 464
 465 /*
 466 **      Check for matches compares the search criteria in userPB to the file
 467 **      system object in cPB. If there's a match, then the information in cPB is
 468 **      is added to the match array and the actual match count is incremented.
 469 */
 470 static  void    CheckForMatches(CInfoPBPtr cPB,
 471                                                                 CSParamPtr userPB,
 472                                                                 const Str63 matchName,
 473                                                                 Boolean includeFiles,
 474                                                                 Boolean includeDirs)
 475 {
 476         long            searchBits;
 477         CInfoPBPtr      searchInfo1;
 478         CInfoPBPtr      searchInfo2;
 479         Str63           itemName;               /* copy of object's name for partial name matching */
 480         Boolean         foundMatch;
 481
 482         foundMatch = false;                     /* default to no match */
 483
 484         searchBits = userPB->ioSearchBits;
 485         searchInfo1 = userPB->ioSearchInfo1;
 486         searchInfo2 = userPB->ioSearchInfo2;
 487
 488         /* Into the if statements that go on forever... */
 489
 490         if ( (cPB->hFileInfo.ioFlAttrib & ioDirMask) == 0 )
 491         {
 492                 if (!includeFiles)
 493                 {
 494                         goto Failed;
 495                 }
 496         }
 497         else
 498         {
 499                 if (!includeDirs)
 500                 {
 501                         goto Failed;
 502                 }
 503         }
 504
 505         if ( (searchBits & fsSBPartialName) != 0 )
 506         {
 507                 if ( (cPB->hFileInfo.ioNamePtr[0] > 0) &&
 508                          (cPB->hFileInfo.ioNamePtr[0] <= (sizeof(Str63) - 1)) )
 509                 {
 510                         /* Make uppercase copy of object name */
 511                         BlockMoveData(cPB->hFileInfo.ioNamePtr,
 512                                                         itemName,
 513                                                         cPB->hFileInfo.ioNamePtr[0] + 1);
 514                         /* Use the same non-international call the File Manager uses */
 515                         UpperString(itemName, true);
 516                 }
 517                 else
 518                 {
 519                         goto Failed;
 520                 }
 521
 522                 {
 523                         if ( !IsSubString(itemName, matchName) )
 524                         {
 525                                 goto Failed;
 526                         }
 527                         else if ( searchBits == fsSBPartialName )
 528                         {
 529                                 /* optimize for name matching only since it is most common way to search */
 530                                 goto Hit;
 531                         }
 532                 }
 533         }
 534
 535         if ( (searchBits & fsSBFullName) != 0 )
 536         {
 537                 /* Use the same non-international call the File Manager uses */
 538                 if ( !EqualString(cPB->hFileInfo.ioNamePtr, matchName, false, true) )
 539                 {
 540                         goto Failed;
 541                 }
 542                 else if ( searchBits == fsSBFullName )
 543                 {
 544                         /* optimize for name matching only since it is most common way to search */
 545                         goto Hit;
 546                 }
 547         }
 548
 549         if ( (searchBits & fsSBFlParID) != 0 )
 550         {
 551                 if ( ((unsigned long)(cPB->hFileInfo.ioFlParID) < (unsigned long)(searchInfo1->hFileInfo.ioFlParID)) ||
 552                          ((unsigned long)(cPB->hFileInfo.ioFlParID) > (unsigned long)(searchInfo2->hFileInfo.ioFlParID)) )
 553                 {
 554                         goto Failed;
 555                 }
 556         }
 557
 558         if ( (searchBits & fsSBFlAttrib) != 0 )
 559         {
 560                 if ( ((cPB->hFileInfo.ioFlAttrib ^ searchInfo1->hFileInfo.ioFlAttrib) &
 561                           searchInfo2->hFileInfo.ioFlAttrib) != 0 )
 562                 {
 563                         goto Failed;
 564                 }
 565         }
 566
 567         if ( (searchBits & fsSBDrNmFls) != 0 )
 568         {
 569                 if ( ((unsigned long)(cPB->dirInfo.ioDrNmFls) < (unsigned long)(searchInfo1->dirInfo.ioDrNmFls)) ||
 570                          ((unsigned long)(cPB->dirInfo.ioDrNmFls) > (unsigned long)(searchInfo2->dirInfo.ioDrNmFls)) )
 571                 {
 572                         goto Failed;
 573                 }
 574         }
 575
 576         if ( (searchBits & fsSBFlFndrInfo) != 0 )       /* fsSBFlFndrInfo is same as fsSBDrUsrWds */
 577         {
 578                 if ( !CompareMasked((long *)&(cPB->hFileInfo.ioFlFndrInfo),
 579                                                         (long *)&(searchInfo1->hFileInfo.ioFlFndrInfo),
 580                                                         (long *)&(searchInfo2->hFileInfo.ioFlFndrInfo),
 581                                                         sizeof(FInfo) / sizeof(long)) )
 582                 {
 583                         goto Failed;
 584                 }
 585         }
 586
 587         if ( (searchBits & fsSBFlXFndrInfo) != 0 )      /* fsSBFlXFndrInfo is same as fsSBDrFndrInfo */
 588         {
 589                 if ( !CompareMasked((long *)&(cPB->hFileInfo.ioFlXFndrInfo),
 590                                                         (long *)&(searchInfo1->hFileInfo.ioFlXFndrInfo),
 591                                                         (long *)&(searchInfo2->hFileInfo.ioFlXFndrInfo),
 592                                                         sizeof(FXInfo) / sizeof(long)) )
 593                 {
 594                         goto Failed;
 595                 }
 596         }
 597
 598         if ( (searchBits & fsSBFlLgLen) != 0 )
 599         {
 600                 if ( ((unsigned long)(cPB->hFileInfo.ioFlLgLen) < (unsigned long)(searchInfo1->hFileInfo.ioFlLgLen)) ||
 601                          ((unsigned long)(cPB->hFileInfo.ioFlLgLen) > (unsigned long)(searchInfo2->hFileInfo.ioFlLgLen)) )
 602                 {
 603                         goto Failed;
 604                 }
 605         }
 606
 607         if ( (searchBits & fsSBFlPyLen) != 0 )
 608         {
 609                 if ( ((unsigned long)(cPB->hFileInfo.ioFlPyLen) < (unsigned long)(searchInfo1->hFileInfo.ioFlPyLen)) ||
 610                          ((unsigned long)(cPB->hFileInfo.ioFlPyLen) > (unsigned long)(searchInfo2->hFileInfo.ioFlPyLen)) )
 611                 {
 612                         goto Failed;
 613                 }
 614         }
 615
 616         if ( (searchBits & fsSBFlRLgLen) != 0 )
 617         {
 618                 if ( ((unsigned long)(cPB->hFileInfo.ioFlRLgLen) < (unsigned long)(searchInfo1->hFileInfo.ioFlRLgLen)) ||
 619                          ((unsigned long)(cPB->hFileInfo.ioFlRLgLen) > (unsigned long)(searchInfo2->hFileInfo.ioFlRLgLen)) )
 620                 {
 621                         goto Failed;
 622                 }
 623         }
 624
 625         if ( (searchBits & fsSBFlRPyLen) != 0 )
 626         {
 627                 if ( ((unsigned long)(cPB->hFileInfo.ioFlRPyLen) < (unsigned long)(searchInfo1->hFileInfo.ioFlRPyLen)) ||
 628                          ((unsigned long)(cPB->hFileInfo.ioFlRPyLen) > (unsigned long)(searchInfo2->hFileInfo.ioFlRPyLen)) )
 629                 {
 630                         goto Failed;
 631                 }
 632         }
 633
 634         if ( (searchBits & fsSBFlCrDat) != 0 )  /* fsSBFlCrDat is same as fsSBDrCrDat */
 635         {
 636                 if ( ((unsigned long)(cPB->hFileInfo.ioFlCrDat) < (unsigned long)(searchInfo1->hFileInfo.ioFlCrDat)) ||
 637                          ((unsigned long)(cPB->hFileInfo.ioFlCrDat) > (unsigned long)(searchInfo2->hFileInfo.ioFlCrDat)) )
 638                 {
 639                         goto Failed;
 640                 }
 641         }
 642
 643         if ( (searchBits & fsSBFlMdDat) != 0 )  /* fsSBFlMdDat is same as fsSBDrMdDat */
 644         {
 645                 if ( ((unsigned long)(cPB->hFileInfo.ioFlMdDat) < (unsigned long)(searchInfo1->hFileInfo.ioFlMdDat)) ||
 646                          ((unsigned long)(cPB->hFileInfo.ioFlMdDat) > (unsigned long)(searchInfo2->hFileInfo.ioFlMdDat)) )
 647                 {
 648                         goto Failed;
 649                 }
 650         }
 651
 652         if ( (searchBits & fsSBFlBkDat) != 0 )  /* fsSBFlBkDat is same as fsSBDrBkDat */
 653         {
 654                 if ( ((unsigned long)(cPB->hFileInfo.ioFlBkDat) < (unsigned long)(searchInfo1->hFileInfo.ioFlBkDat)) ||
 655                          ((unsigned long)(cPB->hFileInfo.ioFlBkDat) > (unsigned long)(searchInfo2->hFileInfo.ioFlBkDat)) )
 656                 {
 657                         goto Failed;
 658                 }
 659         }
 660
 661         /* Hey, we passed all of the tests! */
 662
 663 Hit:
 664         foundMatch = true;
 665
 666 /* foundMatch is false if code jumps to Failed */
 667 Failed:
 668         /* Do we reverse our findings? */
 669         if ( (searchBits & fsSBNegate) != 0 )
 670         {
 671                 foundMatch = !foundMatch;       /* matches are not, not matches are */
 672         }
 673
 674         if ( foundMatch )
 675         {
 676
 677                 /* Move the match into the match buffer */
 678                 userPB->ioMatchPtr[userPB->ioActMatchCount].vRefNum = cPB->hFileInfo.ioVRefNum;
 679                 userPB->ioMatchPtr[userPB->ioActMatchCount].parID = cPB->hFileInfo.ioFlParID;
 680                 if ( cPB->hFileInfo.ioNamePtr[0] > 63 )
 681                 {
 682                         cPB->hFileInfo.ioNamePtr[0] = 63;
 683                 }
 684                 BlockMoveData(cPB->hFileInfo.ioNamePtr,
 685                                           userPB->ioMatchPtr[userPB->ioActMatchCount].name,
 686                                           cPB->hFileInfo.ioNamePtr[0] + 1);
 687
 688                 /* increment the actual count */
 689                 ++(userPB->ioActMatchCount);
 690         }
 691 }
 692
 693 /*****************************************************************************/
 694
 695 /*
 696 **      TimeOutTask is executed when the timer goes off. It simply sets the
 697 **      stopSearch field to true. After each object is found and possibly added
 698 **      to the matches buffer, stopSearch is checked to see if the search should
 699 **      continue.
 700 */
 701
 702 #if     __WANTPASCALELIMINATION
 703 #undef  pascal
 704 #endif
 705 #if TARGET_CARBON
 706 static  pascal  void    TimeOutTask(TMTaskPtr tmTaskPtr)
 707 {
 708         ((ExtendedTMTaskPtr)tmTaskPtr)->stopSearch = true;
 709 }
 710 #else
 711 #if GENERATINGCFM
 712
 713 static  pascal  void    TimeOutTask(TMTaskPtr tmTaskPtr)
 714 {
 715         ((ExtendedTMTaskPtr)tmTaskPtr)->stopSearch = true;
 716 }
 717
 718 #else
 719
 720 static  pascal  TMTaskPtr       GetTMTaskPtr(void)
 721         ONEWORDINLINE(0x2e89);  /* MOVE.L A1,(SP) */
 722
 723 static  void    TimeOutTask(void)
 724 {
 725         ((ExtendedTMTaskPtr)GetTMTaskPtr())->stopSearch = true;
 726 }
 727 #endif
 728 #endif
 729
 730 #if     __WANTPASCALELIMINATION
 731 #define pascal
 732 #endif
 733
 734 /*****************************************************************************/
 735
 736 /*
 737 **      GetDirModDate returns the modification date of a directory. If there is
 738 **      an error getting the modification date, -1 is returned to indicate
 739 **      something went wrong.
 740 */
 741 static  long    GetDirModDate(short vRefNum,
 742                                                           long dirID)
 743 {
 744         CInfoPBRec pb;
 745         Str31 tempName;
 746         long modDate;
 747
 748         /* Protection against File Sharing problem */
 749         tempName[0] = 0;
 750         pb.dirInfo.ioNamePtr = tempName;
 751         pb.dirInfo.ioVRefNum = vRefNum;
 752         pb.dirInfo.ioDrDirID = dirID;
 753         pb.dirInfo.ioFDirIndex = -1;    /* use ioDrDirID */
 754
 755         if ( PBGetCatInfoSync(&pb) == noErr )
 756         {
 757                 modDate = pb.dirInfo.ioDrMdDat;
 758         }
 759         else
 760         {
 761                 modDate = -1;
 762         }
 763
 764         return ( modDate );
 765 }
 766
 767 /*****************************************************************************/
 768
 769 pascal  OSErr   IndexedSearch(CSParamPtr pb,
 770                                                           long dirID)
 771 {
 772         static LevelRecHandle   searchStack = NULL;             /* static handle to LevelRec stack */
 773         static Size                             searchStackSize = 0;    /* size of static handle */
 774         SearchPositionRecPtr    catPosition;
 775         long                                    modDate;
 776         short                                   index;
 777         ExtendedTMTask                  timerTask;
 778         OSErr                                   result;
 779         short                                   realVRefNum;
 780         Str63                                   itemName;
 781         CInfoPBRec                              cPB;
 782         long                                    tempLong;
 783         Boolean                                 includeFiles;
 784         Boolean                                 includeDirs;
 785         Boolean                                 includeNames;
 786         Str63                                   upperName;
 787
 788         timerTask.stopSearch = false;   /* don't stop yet! */
 789
 790         /* If request has a timeout, install a Time Manager task. */
 791         if ( pb->ioSearchTime != 0 )
 792         {
 793                 /* Start timer */
 794 #if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
 795                 timerTask.theTask.tmAddr = NewTimerUPP(TimeOutTask);
 796 #else
 797                 timerTask.theTask.tmAddr = NewTimerProc(TimeOutTask);
 798 #endif
 799                 InsTime((QElemPtr)&(timerTask.theTask));
 800                 PrimeTime((QElemPtr)&(timerTask.theTask), pb->ioSearchTime);
 801         }
 802
 803         /* Check the parameter block passed for things that we don't want to assume */
 804         /* are OK later in the code. For example, make sure pointers to data structures */
 805         /* and buffers are not NULL.  And while we're in there, see if the request */
 806         /* specified searching for files, directories, or both, and see if the search */
 807         /* was by full or partial name. */
 808         result = VerifyUserPB(pb, &includeFiles, &includeDirs, &includeNames);
 809         if ( result == noErr )
 810         {
 811                 pb->ioActMatchCount = 0;        /* no matches yet */
 812
 813                 if ( includeNames )
 814                 {
 815                         /* The search includes seach by full or partial name. */
 816                         /* Make an upper case copy of the match string to pass to */
 817                         /* CheckForMatches. */
 818                         BlockMoveData(pb->ioSearchInfo1->hFileInfo.ioNamePtr,
 819                                                         upperName,
 820                                                         pb->ioSearchInfo1->hFileInfo.ioNamePtr[0] + 1);
 821                         /* Use the same non-international call the File Manager uses */
 822                         UpperString(upperName, true);
 823                 }
 824
 825                 /* Prevent casting to my type throughout code */
 826                 catPosition = (SearchPositionRecPtr)&pb->ioCatPosition;
 827
 828                 /* Create searchStack first time called */
 829                 if ( searchStack == NULL )
 830                 {
 831                         searchStack = (LevelRecHandle)NewHandle(kAdditionalLevelRecs * sizeof(LevelRec));
 832                 }
 833
 834                 /* Make sure searchStack really exists */
 835                 if ( searchStack != NULL )
 836                 {
 837 #if TARGET_CARBON
 838                         searchStackSize = GetHandleSize((Handle)searchStack);
 839 #else
 840                         searchStackSize = InlineGetHandleSize((Handle)searchStack);
 841 #endif
 842
 843                         /* See if the search is a new search or a resumed search. */
 844                         if ( catPosition->initialize == 0 )
 845                         {
 846                                 /* New search. */
 847
 848                                 /* Get the real vRefNum and fill in catPosition->initialize. */
 849                                 result = CheckVol(pb->ioNamePtr, pb->ioVRefNum, &realVRefNum, &catPosition->initialize);
 850                                 if ( result == noErr )
 851                                 {
 852                                         /* clear searchStack */
 853                                         catPosition->stackDepth = 0;
 854
 855                                         /* use dirID parameter passed and... */
 856                                         index = -1;     /* start with the passed directory itself! */
 857                                 }
 858                         }
 859                         else
 860                         {
 861                                 /* We're resuming a search. */
 862
 863                                 /* Get the real vRefNum and make sure catPosition->initialize is valid. */
 864                                 result = CheckVol(pb->ioNamePtr, pb->ioVRefNum, &realVRefNum, &tempLong);
 865                                 if ( result == noErr )
 866                                 {
 867                                         /* Make sure the resumed search is to the same volume! */
 868                                         if ( catPosition->initialize == tempLong )
 869                                         {
 870                                                 /* For resume, catPosition->stackDepth > 0 */
 871                                                 if ( catPosition->stackDepth > 0 )
 872                                                 {
 873                                                         /* Position catPosition->stackDepth to access last saved level */
 874                                                         --(catPosition->stackDepth);
 875
 876                                                         /* Get the dirID and index for the next item */
 877                                                         dirID = (*searchStack)[catPosition->stackDepth].dirID;
 878                                                         index = (*searchStack)[catPosition->stackDepth].index;
 879
 880                                                         /* Check the dir's mod date against the saved mode date on our "stack" */
 881                                                         modDate = GetDirModDate(realVRefNum, dirID);
 882                                                         if ( modDate != (*searchStack)[catPosition->stackDepth].dirModDate )
 883                                                         {
 884                                                                 result = catChangedErr;
 885                                                         }
 886                                                 }
 887                                                 else
 888                                                 {
 889                                                         /* Invalid catPosition record was passed */
 890                                                         result = paramErr;
 891                                                 }
 892                                         }
 893                                         else
 894                                         {
 895                                                 /* The volume is not the same */
 896                                                 result = catChangedErr;
 897                                         }
 898                                 }
 899                         }
 900
 901                         if ( result == noErr )
 902                         {
 903                                 /* ioNamePtr and ioVRefNum only need to be set up once. */
 904                                 cPB.hFileInfo.ioNamePtr = itemName;
 905                                 cPB.hFileInfo.ioVRefNum = realVRefNum;
 906
 907                                 /*
 908                                 **      Here's the loop that:
 909                                 **              Finds the next item on the volume.
 910                                 **              If noErr, calls the code to check for matches and add matches
 911                                 **                      to the match buffer.
 912                                 **              Sets up dirID and index for to find the next item on the volume.
 913                                 **
 914                                 **      The looping ends when:
 915                                 **              (a) an unexpected error is returned by PBGetCatInfo. All that
 916                                 **                      is expected is noErr and fnfErr (after the last item in a
 917                                 **                      directory is found).
 918                                 **              (b) the caller specified a timeout and our Time Manager task
 919                                 **                      has fired.
 920                                 **              (c) the number of matches requested by the caller has been found.
 921                                 **              (d) the last item on the volume was found.
 922                                 */
 923                                 do
 924                                 {
 925                                         /* get the next item */
 926                                         cPB.hFileInfo.ioFDirIndex = index;
 927                                         cPB.hFileInfo.ioDirID = dirID;
 928                                         result = PBGetCatInfoSync(&cPB);
 929                                         if ( index != -1 )
 930                                         {
 931                                                 if ( result == noErr )
 932                                                 {
 933                                                         /* We found something */
 934
 935                                                         CheckForMatches(&cPB, pb, upperName, includeFiles, includeDirs);
 936
 937                                                         ++index;
 938                                                         if ( (cPB.dirInfo.ioFlAttrib & ioDirMask) != 0 )
 939                                                         {
 940                                                                 /* It's a directory */
 941
 942                                                                 result = CheckStack(catPosition->stackDepth, searchStack, &searchStackSize);
 943                                                                 if ( result == noErr )
 944                                                                 {
 945                                                                         /* Save the current state on the searchStack */
 946                                                                         /* when we come back, this is where we'll start */
 947                                                                         (*searchStack)[catPosition->stackDepth].dirID = dirID;
 948                                                                         (*searchStack)[catPosition->stackDepth].index = index;
 949                                                                         (*searchStack)[catPosition->stackDepth].dirModDate = GetDirModDate(realVRefNum, dirID);
 950
 951                                                                         /* position catPosition->stackDepth for next saved level */
 952                                                                         ++(catPosition->stackDepth);
 953
 954                                                                         /* The next item to get is the 1st item in the child directory */
 955                                                                         dirID = cPB.dirInfo.ioDrDirID;
 956                                                                         index = 1;
 957                                                                 }
 958                                                         }
 959                                                         /* else do nothing for files */
 960                                                 }
 961                                                 else
 962                                                 {
 963                                                         /* End of directory found (or we had some error and that */
 964                                                         /* means we have to drop out of this directory). */
 965                                                         /* Restore last thing put on stack and */
 966                                                         /* see if we need to continue or quit. */
 967                                                         if ( catPosition->stackDepth > 0 )
 968                                                         {
 969                                                                 /* position catPosition->stackDepth to access last saved level */
 970                                                                 --(catPosition->stackDepth);
 971
 972                                                                 dirID = (*searchStack)[catPosition->stackDepth].dirID;
 973                                                                 index = (*searchStack)[catPosition->stackDepth].index;
 974
 975                                                                 /* Check the dir's mod date against the saved mode date on our "stack" */
 976                                                                 modDate = GetDirModDate(realVRefNum, dirID);
 977                                                                 if ( modDate != (*searchStack)[catPosition->stackDepth].dirModDate )
 978                                                                 {
 979                                                                         result = catChangedErr;
 980                                                                 }
 981                                                                 else
 982                                                                 {
 983                                                                         /* Going back to ancestor directory. */
 984                                                                         /* Clear error so we can continue. */
 985                                                                         result = noErr;
 986                                                                 }
 987                                                         }
 988                                                         else
 989                                                         {
 990                                                                 /* We hit the bottom of the stack, so we'll let the */
 991                                                                 /* the eofErr drop us out of the loop. */
 992                                                                 result = eofErr;
 993                                                         }
 994                                                 }
 995                                         }
 996                                         else
 997                                         {
 998                                                 /* Special case for index == -1; that means that we're starting */
 999                                                 /* a new search and so the first item to check is the directory */
1000                                                 /* passed to us. */
1001                                                 if ( result == noErr )
1002                                                 {
1003                                                         /* We found something */
1004
1005                                                         CheckForMatches(&cPB, pb, upperName, includeFiles, includeDirs);
1006
1007                                                         /* Now, set the index to 1 and then we're ready to look inside */
1008                                                         /* the passed directory. */
1009                                                         index = 1;
1010                                                 }
1011                                         }
1012                                 } while ( (!timerTask.stopSearch) &&    /* timer hasn't fired */
1013                                                   (result == noErr) &&                  /* no unexpected errors */
1014                                                   (pb->ioReqMatchCount > pb->ioActMatchCount) ); /* we haven't found our limit */
1015
1016                                 /* Did we drop out of the loop because of timeout or */
1017                                 /* ioReqMatchCount was found? */
1018                                 if ( result == noErr )
1019                                 {
1020                                         result = CheckStack(catPosition->stackDepth, searchStack, &searchStackSize);
1021                                         if ( result == noErr )
1022                                         {
1023                                                 /* Either there was a timeout or ioReqMatchCount was reached. */
1024                                                 /* Save the dirID and index for the next time we're called. */
1025
1026                                                 (*searchStack)[catPosition->stackDepth].dirID = dirID;
1027                                                 (*searchStack)[catPosition->stackDepth].index = index;
1028                                                 (*searchStack)[catPosition->stackDepth].dirModDate = GetDirModDate(realVRefNum, dirID);
1029
1030                                                 /* position catPosition->stackDepth for next saved level */
1031
1032                                                 ++(catPosition->stackDepth);
1033                                         }
1034                                 }
1035                         }
1036                 }
1037                 else
1038                 {
1039                         /* searchStack Handle could not be allocated */
1040                         result = memFullErr;
1041                 }
1042         }
1043
1044         if ( pb->ioSearchTime != 0 )
1045         {
1046                 /* Stop Time Manager task here if it was installed */
1047                 RmvTime((QElemPtr)&(timerTask.theTask));
1048                 DisposeTimerUPP(timerTask.theTask.tmAddr);
1049         }
1050
1051         return ( result );
1052 }
1053
1054 /*****************************************************************************/
1055
1056 pascal OSErr PBCatSearchSyncCompat(CSParamPtr paramBlock)
1057 {
1058         static Boolean                  fullExtFSDispatchingtested = false;
1059         static Boolean                  hasFullExtFSDispatching = false;
1060         OSErr                                   result;
1061         Boolean                                 supportsCatSearch;
1062         long                                    response;
1063         GetVolParmsInfoBuffer   volParmsInfo;
1064         long                                    infoSize;
1065
1066         result = noErr;
1067
1068         /* See if File Manager will pass CatSearch requests to external file systems */
1069         /* we'll store the results in a static variable so we don't have to call Gestalt */
1070         /* everytime we're called. */
1071         if ( !fullExtFSDispatchingtested )
1072         {
1073                 fullExtFSDispatchingtested = true;
1074                 if ( Gestalt(gestaltFSAttr, &response) == noErr )
1075                 {
1076                         hasFullExtFSDispatching = ((response & (1L << gestaltFullExtFSDispatching)) != 0);
1077                 }
1078         }
1079
1080         /* CatSearch is a per volume attribute, so we have to check each time we're */
1081         /* called to see if it is available on the volume specified. */
1082         supportsCatSearch = false;
1083         if ( hasFullExtFSDispatching )
1084         {
1085                 infoSize = sizeof(GetVolParmsInfoBuffer);
1086                 result = HGetVolParms(paramBlock->ioNamePtr, paramBlock->ioVRefNum,
1087                                                         &volParmsInfo, &infoSize);
1088                 if ( result == noErr )
1089                 {
1090                         supportsCatSearch = hasCatSearch(volParmsInfo);
1091                 }
1092         }
1093
1094         /* noErr or paramErr is OK here. */
1095         /* paramErr just means that GetVolParms isn't supported by this volume */
1096         if ( (result == noErr) || (result == paramErr) )
1097         {
1098                 if ( supportsCatSearch )
1099                 {
1100                         /* Volume supports CatSearch so use it. */
1101                         /* CatSearch is faster than an indexed search. */
1102                         result = PBCatSearchSync(paramBlock);
1103                 }
1104                 else
1105                 {
1106                         /* Volume doesn't support CatSearch so */
1107                         /* search using IndexedSearch from root directory. */
1108                         result = IndexedSearch(paramBlock, fsRtDirID);
1109                 }
1110         }
1111
1112         return ( result );
1113 }
1114
1115 /*****************************************************************************/
1116
1117 pascal  OSErr   NameFileSearch(ConstStr255Param volName,
1118                                                            short vRefNum,
1119                                                            ConstStr255Param fileName,
1120                                                            FSSpecPtr matches,
1121                                                            long reqMatchCount,
1122                                                            long *actMatchCount,
1123                                                            Boolean newSearch,
1124                                                            Boolean partial)
1125 {
1126         CInfoPBRec              searchInfo1, searchInfo2;
1127         HParamBlockRec  pb;
1128         OSErr                   error;
1129         static CatPositionRec catPosition;
1130         static short    lastVRefNum = 0;
1131
1132         /* get the real volume reference number */
1133         error = DetermineVRefNum(volName, vRefNum, &vRefNum);
1134         if ( error != noErr )
1135                 return ( error );
1136
1137         pb.csParam.ioNamePtr = NULL;
1138         pb.csParam.ioVRefNum = vRefNum;
1139         pb.csParam.ioMatchPtr = matches;
1140         pb.csParam.ioReqMatchCount = reqMatchCount;
1141         if ( partial )  /* tell CatSearch what we're looking for: */
1142         {
1143                 pb.csParam.ioSearchBits = fsSBPartialName + fsSBFlAttrib;       /* partial name file matches or */
1144         }
1145         else
1146         {
1147                 pb.csParam.ioSearchBits =  fsSBFullName + fsSBFlAttrib;         /* full name file matches */
1148         }
1149         pb.csParam.ioSearchInfo1 = &searchInfo1;
1150         pb.csParam.ioSearchInfo2 = &searchInfo2;
1151         pb.csParam.ioSearchTime = 0;
1152         if ( (newSearch) ||                             /* If caller specified new search */
1153                  (lastVRefNum != vRefNum) )     /* or if last search was to another volume, */
1154         {
1155                 catPosition.initialize = 0;     /* then search from beginning of catalog */
1156         }
1157         pb.csParam.ioCatPosition = catPosition;
1158         pb.csParam.ioOptBuffer = GetTempBuffer(0x00004000, &pb.csParam.ioOptBufSize);
1159
1160         /* search for fileName */
1161         searchInfo1.hFileInfo.ioNamePtr = (StringPtr)fileName;
1162         searchInfo2.hFileInfo.ioNamePtr = NULL;
1163
1164         /* only match files (not directories) */
1165         searchInfo1.hFileInfo.ioFlAttrib = 0x00;
1166         searchInfo2.hFileInfo.ioFlAttrib = ioDirMask;
1167
1168         error = PBCatSearchSyncCompat((CSParamPtr)&pb);
1169
1170         if ( (error == noErr) ||                                                        /* If no errors or the end of catalog was */
1171                  (error == eofErr) )                                                    /* found, then the call was successful so */
1172         {
1173                 *actMatchCount = pb.csParam.ioActMatchCount;    /* return the match count */
1174         }
1175         else
1176         {
1177                 *actMatchCount = 0;                                                     /* else no matches found */
1178         }
1179
1180         if ( (error == noErr) ||                                                /* If no errors */
1181                  (error == catChangedErr) )                                     /* or there was a change in the catalog */
1182         {
1183                 catPosition = pb.csParam.ioCatPosition;
1184                 lastVRefNum = vRefNum;
1185                         /* we can probably start the next search where we stopped this time */
1186         }
1187         else
1188         {
1189                 catPosition.initialize = 0;
1190                         /* start the next search from beginning of catalog */
1191         }
1192
1193         if ( pb.csParam.ioOptBuffer != NULL )
1194         {
1195                 DisposePtr(pb.csParam.ioOptBuffer);
1196         }
1197
1198         return ( error );
1199 }
1200
1201 /*****************************************************************************/
1202
1203 pascal  OSErr   CreatorTypeFileSearch(ConstStr255Param volName,
1204                                                                           short vRefNum,
1205                                                                           OSType creator,
1206                                                                           OSType fileType,
1207                                                                           FSSpecPtr matches,
1208                                                                           long reqMatchCount,
1209                                                                           long *actMatchCount,
1210                                                                           Boolean newSearch)
1211 {
1212         CInfoPBRec              searchInfo1, searchInfo2;
1213         HParamBlockRec  pb;
1214         OSErr                   error;
1215         static CatPositionRec catPosition;
1216         static short    lastVRefNum = 0;
1217
1218         /* get the real volume reference number */
1219         error = DetermineVRefNum(volName, vRefNum, &vRefNum);
1220         if ( error != noErr )
1221                 return ( error );
1222
1223         pb.csParam.ioNamePtr = NULL;
1224         pb.csParam.ioVRefNum = vRefNum;
1225         pb.csParam.ioMatchPtr = matches;
1226         pb.csParam.ioReqMatchCount = reqMatchCount;
1227         pb.csParam.ioSearchBits = fsSBFlAttrib + fsSBFlFndrInfo;        /* Looking for finder info file matches */
1228         pb.csParam.ioSearchInfo1 = &searchInfo1;
1229         pb.csParam.ioSearchInfo2 = &searchInfo2;
1230         pb.csParam.ioSearchTime = 0;
1231         if ( (newSearch) ||                             /* If caller specified new search */
1232                  (lastVRefNum != vRefNum) )     /* or if last search was to another volume, */
1233         {
1234                 catPosition.initialize = 0;     /* then search from beginning of catalog */
1235         }
1236         pb.csParam.ioCatPosition = catPosition;
1237         pb.csParam.ioOptBuffer = GetTempBuffer(0x00004000, &pb.csParam.ioOptBufSize);
1238
1239         /* no fileName */
1240         searchInfo1.hFileInfo.ioNamePtr = NULL;
1241         searchInfo2.hFileInfo.ioNamePtr = NULL;
1242
1243         /* only match files (not directories) */
1244         searchInfo1.hFileInfo.ioFlAttrib = 0x00;
1245         searchInfo2.hFileInfo.ioFlAttrib = ioDirMask;
1246
1247         /* search for creator; if creator = 0x00000000, ignore creator */
1248         searchInfo1.hFileInfo.ioFlFndrInfo.fdCreator = creator;
1249         if ( creator == (OSType)0x00000000 )
1250         {
1251                 searchInfo2.hFileInfo.ioFlFndrInfo.fdCreator = (OSType)0x00000000;
1252         }
1253         else
1254         {
1255                 searchInfo2.hFileInfo.ioFlFndrInfo.fdCreator = (OSType)0xffffffff;
1256         }
1257
1258         /* search for fileType; if fileType = 0x00000000, ignore fileType */
1259         searchInfo1.hFileInfo.ioFlFndrInfo.fdType = fileType;
1260         if ( fileType == (OSType)0x00000000 )
1261         {
1262                 searchInfo2.hFileInfo.ioFlFndrInfo.fdType = (OSType)0x00000000;
1263         }
1264         else
1265         {
1266                 searchInfo2.hFileInfo.ioFlFndrInfo.fdType = (OSType)0xffffffff;
1267         }
1268
1269         /* zero all other FInfo fields */
1270         searchInfo1.hFileInfo.ioFlFndrInfo.fdFlags = 0;
1271         searchInfo1.hFileInfo.ioFlFndrInfo.fdLocation.v = 0;
1272         searchInfo1.hFileInfo.ioFlFndrInfo.fdLocation.h = 0;
1273         searchInfo1.hFileInfo.ioFlFndrInfo.fdFldr = 0;
1274
1275         searchInfo2.hFileInfo.ioFlFndrInfo.fdFlags = 0;
1276         searchInfo2.hFileInfo.ioFlFndrInfo.fdLocation.v = 0;
1277         searchInfo2.hFileInfo.ioFlFndrInfo.fdLocation.h = 0;
1278         searchInfo2.hFileInfo.ioFlFndrInfo.fdFldr = 0;
1279
1280         error = PBCatSearchSyncCompat((CSParamPtr)&pb);
1281
1282         if ( (error == noErr) ||                                                        /* If no errors or the end of catalog was */
1283                  (error == eofErr) )                                                    /* found, then the call was successful so */
1284         {
1285                 *actMatchCount = pb.csParam.ioActMatchCount;    /* return the match count */
1286         }
1287         else
1288         {
1289                 *actMatchCount = 0;                                                     /* else no matches found */
1290         }
1291
1292         if ( (error == noErr) ||                                                /* If no errors */
1293                  (error == catChangedErr) )                                     /* or there was a change in the catalog */
1294         {
1295                 catPosition = pb.csParam.ioCatPosition;
1296                 lastVRefNum = vRefNum;
1297                         /* we can probably start the next search where we stopped this time */
1298         }
1299         else
1300         {
1301                 catPosition.initialize = 0;
1302                         /* start the next search from beginning of catalog */
1303         }
1304
1305         if ( pb.csParam.ioOptBuffer != NULL )
1306         {
1307                 DisposePtr(pb.csParam.ioOptBuffer);
1308         }
1309
1310         return ( error );
1311 }
1312
1313 /*****************************************************************************/