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                 timerTask.theTask.tmAddr = NewTimerProc(TimeOutTask);
 795                 InsTime((QElemPtr)&(timerTask.theTask));
 796                 PrimeTime((QElemPtr)&(timerTask.theTask), pb->ioSearchTime);
 797         }
 798
 799         /* Check the parameter block passed for things that we don't want to assume */
 800         /* are OK later in the code. For example, make sure pointers to data structures */
 801         /* and buffers are not NULL.  And while we're in there, see if the request */
 802         /* specified searching for files, directories, or both, and see if the search */
 803         /* was by full or partial name. */
 804         result = VerifyUserPB(pb, &includeFiles, &includeDirs, &includeNames);
 805         if ( result == noErr )
 806         {
 807                 pb->ioActMatchCount = 0;        /* no matches yet */
 808
 809                 if ( includeNames )
 810                 {
 811                         /* The search includes seach by full or partial name. */
 812                         /* Make an upper case copy of the match string to pass to */
 813                         /* CheckForMatches. */
 814                         BlockMoveData(pb->ioSearchInfo1->hFileInfo.ioNamePtr,
 815                                                         upperName,
 816                                                         pb->ioSearchInfo1->hFileInfo.ioNamePtr[0] + 1);
 817                         /* Use the same non-international call the File Manager uses */
 818                         UpperString(upperName, true);
 819                 }
 820
 821                 /* Prevent casting to my type throughout code */
 822                 catPosition = (SearchPositionRecPtr)&pb->ioCatPosition;
 823
 824                 /* Create searchStack first time called */
 825                 if ( searchStack == NULL )
 826                 {
 827                         searchStack = (LevelRecHandle)NewHandle(kAdditionalLevelRecs * sizeof(LevelRec));
 828                 }
 829
 830                 /* Make sure searchStack really exists */
 831                 if ( searchStack != NULL )
 832                 {
 833 #if TARGET_CARBON
 834                         searchStackSize = GetHandleSize((Handle)searchStack);
 835 #else
 836                         searchStackSize = InlineGetHandleSize((Handle)searchStack);
 837 #endif
 838
 839                         /* See if the search is a new search or a resumed search. */
 840                         if ( catPosition->initialize == 0 )
 841                         {
 842                                 /* New search. */
 843
 844                                 /* Get the real vRefNum and fill in catPosition->initialize. */
 845                                 result = CheckVol(pb->ioNamePtr, pb->ioVRefNum, &realVRefNum, &catPosition->initialize);
 846                                 if ( result == noErr )
 847                                 {
 848                                         /* clear searchStack */
 849                                         catPosition->stackDepth = 0;
 850
 851                                         /* use dirID parameter passed and... */
 852                                         index = -1;     /* start with the passed directory itself! */
 853                                 }
 854                         }
 855                         else
 856                         {
 857                                 /* We're resuming a search. */
 858
 859                                 /* Get the real vRefNum and make sure catPosition->initialize is valid. */
 860                                 result = CheckVol(pb->ioNamePtr, pb->ioVRefNum, &realVRefNum, &tempLong);
 861                                 if ( result == noErr )
 862                                 {
 863                                         /* Make sure the resumed search is to the same volume! */
 864                                         if ( catPosition->initialize == tempLong )
 865                                         {
 866                                                 /* For resume, catPosition->stackDepth > 0 */
 867                                                 if ( catPosition->stackDepth > 0 )
 868                                                 {
 869                                                         /* Position catPosition->stackDepth to access last saved level */
 870                                                         --(catPosition->stackDepth);
 871
 872                                                         /* Get the dirID and index for the next item */
 873                                                         dirID = (*searchStack)[catPosition->stackDepth].dirID;
 874                                                         index = (*searchStack)[catPosition->stackDepth].index;
 875
 876                                                         /* Check the dir's mod date against the saved mode date on our "stack" */
 877                                                         modDate = GetDirModDate(realVRefNum, dirID);
 878                                                         if ( modDate != (*searchStack)[catPosition->stackDepth].dirModDate )
 879                                                         {
 880                                                                 result = catChangedErr;
 881                                                         }
 882                                                 }
 883                                                 else
 884                                                 {
 885                                                         /* Invalid catPosition record was passed */
 886                                                         result = paramErr;
 887                                                 }
 888                                         }
 889                                         else
 890                                         {
 891                                                 /* The volume is not the same */
 892                                                 result = catChangedErr;
 893                                         }
 894                                 }
 895                         }
 896
 897                         if ( result == noErr )
 898                         {
 899                                 /* ioNamePtr and ioVRefNum only need to be set up once. */
 900                                 cPB.hFileInfo.ioNamePtr = itemName;
 901                                 cPB.hFileInfo.ioVRefNum = realVRefNum;
 902
 903                                 /*
 904                                 **      Here's the loop that:
 905                                 **              Finds the next item on the volume.
 906                                 **              If noErr, calls the code to check for matches and add matches
 907                                 **                      to the match buffer.
 908                                 **              Sets up dirID and index for to find the next item on the volume.
 909                                 **
 910                                 **      The looping ends when:
 911                                 **              (a) an unexpected error is returned by PBGetCatInfo. All that
 912                                 **                      is expected is noErr and fnfErr (after the last item in a
 913                                 **                      directory is found).
 914                                 **              (b) the caller specified a timeout and our Time Manager task
 915                                 **                      has fired.
 916                                 **              (c) the number of matches requested by the caller has been found.
 917                                 **              (d) the last item on the volume was found.
 918                                 */
 919                                 do
 920                                 {
 921                                         /* get the next item */
 922                                         cPB.hFileInfo.ioFDirIndex = index;
 923                                         cPB.hFileInfo.ioDirID = dirID;
 924                                         result = PBGetCatInfoSync(&cPB);
 925                                         if ( index != -1 )
 926                                         {
 927                                                 if ( result == noErr )
 928                                                 {
 929                                                         /* We found something */
 930
 931                                                         CheckForMatches(&cPB, pb, upperName, includeFiles, includeDirs);
 932
 933                                                         ++index;
 934                                                         if ( (cPB.dirInfo.ioFlAttrib & ioDirMask) != 0 )
 935                                                         {
 936                                                                 /* It's a directory */
 937
 938                                                                 result = CheckStack(catPosition->stackDepth, searchStack, &searchStackSize);
 939                                                                 if ( result == noErr )
 940                                                                 {
 941                                                                         /* Save the current state on the searchStack */
 942                                                                         /* when we come back, this is where we'll start */
 943                                                                         (*searchStack)[catPosition->stackDepth].dirID = dirID;
 944                                                                         (*searchStack)[catPosition->stackDepth].index = index;
 945                                                                         (*searchStack)[catPosition->stackDepth].dirModDate = GetDirModDate(realVRefNum, dirID);
 946
 947                                                                         /* position catPosition->stackDepth for next saved level */
 948                                                                         ++(catPosition->stackDepth);
 949
 950                                                                         /* The next item to get is the 1st item in the child directory */
 951                                                                         dirID = cPB.dirInfo.ioDrDirID;
 952                                                                         index = 1;
 953                                                                 }
 954                                                         }
 955                                                         /* else do nothing for files */
 956                                                 }
 957                                                 else
 958                                                 {
 959                                                         /* End of directory found (or we had some error and that */
 960                                                         /* means we have to drop out of this directory). */
 961                                                         /* Restore last thing put on stack and */
 962                                                         /* see if we need to continue or quit. */
 963                                                         if ( catPosition->stackDepth > 0 )
 964                                                         {
 965                                                                 /* position catPosition->stackDepth to access last saved level */
 966                                                                 --(catPosition->stackDepth);
 967
 968                                                                 dirID = (*searchStack)[catPosition->stackDepth].dirID;
 969                                                                 index = (*searchStack)[catPosition->stackDepth].index;
 970
 971                                                                 /* Check the dir's mod date against the saved mode date on our "stack" */
 972                                                                 modDate = GetDirModDate(realVRefNum, dirID);
 973                                                                 if ( modDate != (*searchStack)[catPosition->stackDepth].dirModDate )
 974                                                                 {
 975                                                                         result = catChangedErr;
 976                                                                 }
 977                                                                 else
 978                                                                 {
 979                                                                         /* Going back to ancestor directory. */
 980                                                                         /* Clear error so we can continue. */
 981                                                                         result = noErr;
 982                                                                 }
 983                                                         }
 984                                                         else
 985                                                         {
 986                                                                 /* We hit the bottom of the stack, so we'll let the */
 987                                                                 /* the eofErr drop us out of the loop. */
 988                                                                 result = eofErr;
 989                                                         }
 990                                                 }
 991                                         }
 992                                         else
 993                                         {
 994                                                 /* Special case for index == -1; that means that we're starting */
 995                                                 /* a new search and so the first item to check is the directory */
 996                                                 /* passed to us. */
 997                                                 if ( result == noErr )
 998                                                 {
 999                                                         /* We found something */
1000
1001                                                         CheckForMatches(&cPB, pb, upperName, includeFiles, includeDirs);
1002
1003                                                         /* Now, set the index to 1 and then we're ready to look inside */
1004                                                         /* the passed directory. */
1005                                                         index = 1;
1006                                                 }
1007                                         }
1008                                 } while ( (!timerTask.stopSearch) &&    /* timer hasn't fired */
1009                                                   (result == noErr) &&                  /* no unexpected errors */
1010                                                   (pb->ioReqMatchCount > pb->ioActMatchCount) ); /* we haven't found our limit */
1011
1012                                 /* Did we drop out of the loop because of timeout or */
1013                                 /* ioReqMatchCount was found? */
1014                                 if ( result == noErr )
1015                                 {
1016                                         result = CheckStack(catPosition->stackDepth, searchStack, &searchStackSize);
1017                                         if ( result == noErr )
1018                                         {
1019                                                 /* Either there was a timeout or ioReqMatchCount was reached. */
1020                                                 /* Save the dirID and index for the next time we're called. */
1021
1022                                                 (*searchStack)[catPosition->stackDepth].dirID = dirID;
1023                                                 (*searchStack)[catPosition->stackDepth].index = index;
1024                                                 (*searchStack)[catPosition->stackDepth].dirModDate = GetDirModDate(realVRefNum, dirID);
1025
1026                                                 /* position catPosition->stackDepth for next saved level */
1027
1028                                                 ++(catPosition->stackDepth);
1029                                         }
1030                                 }
1031                         }
1032                 }
1033                 else
1034                 {
1035                         /* searchStack Handle could not be allocated */
1036                         result = memFullErr;
1037                 }
1038         }
1039
1040         if ( pb->ioSearchTime != 0 )
1041         {
1042                 /* Stop Time Manager task here if it was installed */
1043                 RmvTime((QElemPtr)&(timerTask.theTask));
1044                 DisposeTimerUPP(timerTask.theTask.tmAddr);
1045         }
1046
1047         return ( result );
1048 }
1049
1050 /*****************************************************************************/
1051
1052 pascal OSErr PBCatSearchSyncCompat(CSParamPtr paramBlock)
1053 {
1054         static Boolean                  fullExtFSDispatchingtested = false;
1055         static Boolean                  hasFullExtFSDispatching = false;
1056         OSErr                                   result;
1057         Boolean                                 supportsCatSearch;
1058         long                                    response;
1059         GetVolParmsInfoBuffer   volParmsInfo;
1060         long                                    infoSize;
1061
1062         result = noErr;
1063
1064         /* See if File Manager will pass CatSearch requests to external file systems */
1065         /* we'll store the results in a static variable so we don't have to call Gestalt */
1066         /* everytime we're called. */
1067         if ( !fullExtFSDispatchingtested )
1068         {
1069                 fullExtFSDispatchingtested = true;
1070                 if ( Gestalt(gestaltFSAttr, &response) == noErr )
1071                 {
1072                         hasFullExtFSDispatching = ((response & (1L << gestaltFullExtFSDispatching)) != 0);
1073                 }
1074         }
1075
1076         /* CatSearch is a per volume attribute, so we have to check each time we're */
1077         /* called to see if it is available on the volume specified. */
1078         supportsCatSearch = false;
1079         if ( hasFullExtFSDispatching )
1080         {
1081                 infoSize = sizeof(GetVolParmsInfoBuffer);
1082                 result = HGetVolParms(paramBlock->ioNamePtr, paramBlock->ioVRefNum,
1083                                                         &volParmsInfo, &infoSize);
1084                 if ( result == noErr )
1085                 {
1086                         supportsCatSearch = hasCatSearch(volParmsInfo);
1087                 }
1088         }
1089
1090         /* noErr or paramErr is OK here. */
1091         /* paramErr just means that GetVolParms isn't supported by this volume */
1092         if ( (result == noErr) || (result == paramErr) )
1093         {
1094                 if ( supportsCatSearch )
1095                 {
1096                         /* Volume supports CatSearch so use it. */
1097                         /* CatSearch is faster than an indexed search. */
1098                         result = PBCatSearchSync(paramBlock);
1099                 }
1100                 else
1101                 {
1102                         /* Volume doesn't support CatSearch so */
1103                         /* search using IndexedSearch from root directory. */
1104                         result = IndexedSearch(paramBlock, fsRtDirID);
1105                 }
1106         }
1107
1108         return ( result );
1109 }
1110
1111 /*****************************************************************************/
1112
1113 pascal  OSErr   NameFileSearch(ConstStr255Param volName,
1114                                                            short vRefNum,
1115                                                            ConstStr255Param fileName,
1116                                                            FSSpecPtr matches,
1117                                                            long reqMatchCount,
1118                                                            long *actMatchCount,
1119                                                            Boolean newSearch,
1120                                                            Boolean partial)
1121 {
1122         CInfoPBRec              searchInfo1, searchInfo2;
1123         HParamBlockRec  pb;
1124         OSErr                   error;
1125         static CatPositionRec catPosition;
1126         static short    lastVRefNum = 0;
1127
1128         /* get the real volume reference number */
1129         error = DetermineVRefNum(volName, vRefNum, &vRefNum);
1130         if ( error != noErr )
1131                 return ( error );
1132
1133         pb.csParam.ioNamePtr = NULL;
1134         pb.csParam.ioVRefNum = vRefNum;
1135         pb.csParam.ioMatchPtr = matches;
1136         pb.csParam.ioReqMatchCount = reqMatchCount;
1137         if ( partial )  /* tell CatSearch what we're looking for: */
1138         {
1139                 pb.csParam.ioSearchBits = fsSBPartialName + fsSBFlAttrib;       /* partial name file matches or */
1140         }
1141         else
1142         {
1143                 pb.csParam.ioSearchBits =  fsSBFullName + fsSBFlAttrib;         /* full name file matches */
1144         }
1145         pb.csParam.ioSearchInfo1 = &searchInfo1;
1146         pb.csParam.ioSearchInfo2 = &searchInfo2;
1147         pb.csParam.ioSearchTime = 0;
1148         if ( (newSearch) ||                             /* If caller specified new search */
1149                  (lastVRefNum != vRefNum) )     /* or if last search was to another volume, */
1150         {
1151                 catPosition.initialize = 0;     /* then search from beginning of catalog */
1152         }
1153         pb.csParam.ioCatPosition = catPosition;
1154         pb.csParam.ioOptBuffer = GetTempBuffer(0x00004000, &pb.csParam.ioOptBufSize);
1155
1156         /* search for fileName */
1157         searchInfo1.hFileInfo.ioNamePtr = (StringPtr)fileName;
1158         searchInfo2.hFileInfo.ioNamePtr = NULL;
1159
1160         /* only match files (not directories) */
1161         searchInfo1.hFileInfo.ioFlAttrib = 0x00;
1162         searchInfo2.hFileInfo.ioFlAttrib = ioDirMask;
1163
1164         error = PBCatSearchSyncCompat((CSParamPtr)&pb);
1165
1166         if ( (error == noErr) ||                                                        /* If no errors or the end of catalog was */
1167                  (error == eofErr) )                                                    /* found, then the call was successful so */
1168         {
1169                 *actMatchCount = pb.csParam.ioActMatchCount;    /* return the match count */
1170         }
1171         else
1172         {
1173                 *actMatchCount = 0;                                                     /* else no matches found */
1174         }
1175
1176         if ( (error == noErr) ||                                                /* If no errors */
1177                  (error == catChangedErr) )                                     /* or there was a change in the catalog */
1178         {
1179                 catPosition = pb.csParam.ioCatPosition;
1180                 lastVRefNum = vRefNum;
1181                         /* we can probably start the next search where we stopped this time */
1182         }
1183         else
1184         {
1185                 catPosition.initialize = 0;
1186                         /* start the next search from beginning of catalog */
1187         }
1188
1189         if ( pb.csParam.ioOptBuffer != NULL )
1190         {
1191                 DisposePtr(pb.csParam.ioOptBuffer);
1192         }
1193
1194         return ( error );
1195 }
1196
1197 /*****************************************************************************/
1198
1199 pascal  OSErr   CreatorTypeFileSearch(ConstStr255Param volName,
1200                                                                           short vRefNum,
1201                                                                           OSType creator,
1202                                                                           OSType fileType,
1203                                                                           FSSpecPtr matches,
1204                                                                           long reqMatchCount,
1205                                                                           long *actMatchCount,
1206                                                                           Boolean newSearch)
1207 {
1208         CInfoPBRec              searchInfo1, searchInfo2;
1209         HParamBlockRec  pb;
1210         OSErr                   error;
1211         static CatPositionRec catPosition;
1212         static short    lastVRefNum = 0;
1213
1214         /* get the real volume reference number */
1215         error = DetermineVRefNum(volName, vRefNum, &vRefNum);
1216         if ( error != noErr )
1217                 return ( error );
1218
1219         pb.csParam.ioNamePtr = NULL;
1220         pb.csParam.ioVRefNum = vRefNum;
1221         pb.csParam.ioMatchPtr = matches;
1222         pb.csParam.ioReqMatchCount = reqMatchCount;
1223         pb.csParam.ioSearchBits = fsSBFlAttrib + fsSBFlFndrInfo;        /* Looking for finder info file matches */
1224         pb.csParam.ioSearchInfo1 = &searchInfo1;
1225         pb.csParam.ioSearchInfo2 = &searchInfo2;
1226         pb.csParam.ioSearchTime = 0;
1227         if ( (newSearch) ||                             /* If caller specified new search */
1228                  (lastVRefNum != vRefNum) )     /* or if last search was to another volume, */
1229         {
1230                 catPosition.initialize = 0;     /* then search from beginning of catalog */
1231         }
1232         pb.csParam.ioCatPosition = catPosition;
1233         pb.csParam.ioOptBuffer = GetTempBuffer(0x00004000, &pb.csParam.ioOptBufSize);
1234
1235         /* no fileName */
1236         searchInfo1.hFileInfo.ioNamePtr = NULL;
1237         searchInfo2.hFileInfo.ioNamePtr = NULL;
1238
1239         /* only match files (not directories) */
1240         searchInfo1.hFileInfo.ioFlAttrib = 0x00;
1241         searchInfo2.hFileInfo.ioFlAttrib = ioDirMask;
1242
1243         /* search for creator; if creator = 0x00000000, ignore creator */
1244         searchInfo1.hFileInfo.ioFlFndrInfo.fdCreator = creator;
1245         if ( creator == (OSType)0x00000000 )
1246         {
1247                 searchInfo2.hFileInfo.ioFlFndrInfo.fdCreator = (OSType)0x00000000;
1248         }
1249         else
1250         {
1251                 searchInfo2.hFileInfo.ioFlFndrInfo.fdCreator = (OSType)0xffffffff;
1252         }
1253
1254         /* search for fileType; if fileType = 0x00000000, ignore fileType */
1255         searchInfo1.hFileInfo.ioFlFndrInfo.fdType = fileType;
1256         if ( fileType == (OSType)0x00000000 )
1257         {
1258                 searchInfo2.hFileInfo.ioFlFndrInfo.fdType = (OSType)0x00000000;
1259         }
1260         else
1261         {
1262                 searchInfo2.hFileInfo.ioFlFndrInfo.fdType = (OSType)0xffffffff;
1263         }
1264
1265         /* zero all other FInfo fields */
1266         searchInfo1.hFileInfo.ioFlFndrInfo.fdFlags = 0;
1267         searchInfo1.hFileInfo.ioFlFndrInfo.fdLocation.v = 0;
1268         searchInfo1.hFileInfo.ioFlFndrInfo.fdLocation.h = 0;
1269         searchInfo1.hFileInfo.ioFlFndrInfo.fdFldr = 0;
1270
1271         searchInfo2.hFileInfo.ioFlFndrInfo.fdFlags = 0;
1272         searchInfo2.hFileInfo.ioFlFndrInfo.fdLocation.v = 0;
1273         searchInfo2.hFileInfo.ioFlFndrInfo.fdLocation.h = 0;
1274         searchInfo2.hFileInfo.ioFlFndrInfo.fdFldr = 0;
1275
1276         error = PBCatSearchSyncCompat((CSParamPtr)&pb);
1277
1278         if ( (error == noErr) ||                                                        /* If no errors or the end of catalog was */
1279                  (error == eofErr) )                                                    /* found, then the call was successful so */
1280         {
1281                 *actMatchCount = pb.csParam.ioActMatchCount;    /* return the match count */
1282         }
1283         else
1284         {
1285                 *actMatchCount = 0;                                                     /* else no matches found */
1286         }
1287
1288         if ( (error == noErr) ||                                                /* If no errors */
1289                  (error == catChangedErr) )                                     /* or there was a change in the catalog */
1290         {
1291                 catPosition = pb.csParam.ioCatPosition;
1292                 lastVRefNum = vRefNum;
1293                         /* we can probably start the next search where we stopped this time */
1294         }
1295         else
1296         {
1297                 catPosition.initialize = 0;
1298                         /* start the next search from beginning of catalog */
1299         }
1300
1301         if ( pb.csParam.ioOptBuffer != NULL )
1302         {
1303                 DisposePtr(pb.csParam.ioOptBuffer);
1304         }
1305
1306         return ( error );
1307 }
1308
1309 /*****************************************************************************/