![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to CatSearch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs / hfscommon / Catalog|
Return to CatSearch.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs / hfscommon / Catalog |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: File: CatSearch.c
27:
28: Contains: CatSearch (fast search of all files on a volume)
29:
30: Version: System 7.5.x (Tempo?)
31:
32: Copyright: � 1996-1997 by Apple Computer, Inc., all rights reserved.
33:
34: File Ownership:
35:
36: DRI: Mark Day
37:
38: Other Contact: Don Brady
39:
40: Technology: HFS+
41:
42: Writers:
43:
44: (JL) Jim Luther
45: (RNP) Roger Pantos
46: (DSH) Deric Horn
47: (djb) Don Brady
48: (msd) Mark Day
49:
50: Change History (most recent first):
51: <Rhap> 03/31/98 djb Sync up with final HFSVolumes.h header file.
52:
53: 4/14/98 DSH Now also compile some compare routines for Rhapsody for use in searchfs().
54: <CS18> 11/3/97 JL #2001483 - Return WDCBRecPtr from CatSearchC.
55: <CS17> 10/19/97 msd Bug 1684586. GetCatInfo and SetCatInfo use only contentModDate.
56: <CS16> 10/17/97 msd Conditionalize DebugStrs.
57: <CS15> 10/10/97 msd Bug 1683670. InitCatSearch was calling the wrong routine to
58: flush the volume; only the user files were getting flushed.
59: Added casts to Ptr for first parameter to UprText.
60: <CS14> 9/27/97 RNP Replace UprString() with UprText().
61: <CS13> 9/9/97 msd The PLstrcmp routine we link against has a bug with one
62: character strings, so just call our own PascalBinaryCompare
63: instead.
64: <CS12> 9/4/97 msd In CatalogNodeData, change attributeModDate to modifyDate.
65: <CS11> 7/28/97 msd Use fast new B-Tree scanner.
66: <CS10> 7/23/97 msd Radar #1668914. CatSearch should compare the file's backup date
67: with the search info's backup date range, not the create date
68: range. The mod date compare had the same problem.
69: <CS9> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name
70: collision
71: <CS8> 7/8/97 DSH Loading PrecompiledHeaders from define passed in on C line
72: <CS7> 6/24/97 djb Include "CatalogInternal.h"
73: <CS6> 6/20/97 msd Use contentModDate and attributeModDate fields instead of
74: modifyDate. Use CatalogNodeData as common record format. Got rid
75: of NEW_CATSEARCH define by removing old code.
76: <CS5> 6/17/97 msd Bug #1661443. Initialize cat position to parent dirID =
77: fsRtParID. When restoring a cat position, special case that
78: parent ID since there is no such thread record. If ioSearchTime
79: is -1, assume they meant infinite, and use 0 instead. The call
80: to ConvertUnicodeToHFSName in CheckCriteria was getting
81: parameters from the wrong places.
82: <4> 6/13/97 djb Change PrepareOutputName calls to ConvertUnicodeToHFSName calls.
83: <CS3> 6/9/97 msd Convert HFS Plus dates from UTC to local time in MakeCatDirRec
84: and MakeCatFilRec.
85: <CS2> 5/16/97 msd Fix some string type conversion problems in InsertMatch().
86: <CS1> 4/24/97 djb first checked in
87: <HFS22> 4/16/97 djb Always use new B-tree code.
88: <HFS21> 4/11/97 DSH use extended VCB fields catalogRefNum, and extentsRefNum.
89: <HFS20> 3/27/97 djb Unicode string lengths are now passed as a byte count.
90: <HFS19> 2/19/97 djb Get in sync with new B-tree definitions...
91: <HFS18> 2/6/97 msd When instrumentation is active, log a complete FSSpec when a
92: match is inserted into the buffer.
93: <HFS17> 2/5/97 msd On HFS+ disks, CheckCriteria needs to test against the HFS-style
94: copy of the catalog record rather than the HFS variants of the
95: CatalogRecord of the actual catalog data.
96: <HFS16> 1/29/97 msd InitCatSearch needs to preset the BTree position by searching
97: for a node before the directory record of the root so that the
98: root will be searched, too.
99: <HFS15> 1/29/97 msd CheckCriteria was ignoring the fsSBNegate bit when testing the
100: ioDirMask bit in the file attributes. Made sure that thread
101: records never match.
102: <HFS14> 1/17/97 msd Add trivial instrumentation.
103: <HFS13> 1/16/97 msd When using the new BTree manager, the old btcWCount field is
104: always zero, so use numUpdateNodes instead. However,
105: numUpdateNodes can be zero so use numUpdateNodes+1 instead; this
106: still allows the caller to set the writeCount in the
107: CatPositionRec to zero to indicate a new search.
108: <HFS12> 1/9/97 djb Get in sync with new HFSVolumesPriv.i..
109: <HFS11> 1/9/97 msd The CatPosition was not being updated during or after the call.
110: Also, InitCatSearch was going back to the root directory instead
111: of the parent directory specified in the CatPosition.
112: InitCatSearch should not use GetCatalogNode; it should use
113: SearchBTreeRecord instead since we want to be able to find
114: thread records and move relative to them.
115: <HFS10> 1/3/97 djb Integrated latest HFSVolumesPriv.h changes.
116: <HFS9> 12/23/96 msd Oops. Re-enable timers.
117: <HFS8> 12/23/96 msd Update to use new BTree interfaces. Conditionalized the code via
118: the NEW_CATSEARCH symbol. The code should compile both ways, but
119: should be cleaned up later. There is a DebugStr in case the
120: BTree returns an unexpected error. Performance is noticably
121: worse than the prior implementation.
122: <HFS7> 12/19/96 DSH All refs to VCB are now refs to ExtendedVCB
123: <HFS6> 12/18/96 msd Use PrepareOutputName when copying a found item's name into
124: FSSpec array.
125: <HFS5> 12/12/96 msd Use the Unicode wrapper functions.
126: <HFS4> 12/10/96 msd First version of HFS+ changes complete. The HFS+ catalog data is
127: converted to a CatalogRecord before comparison. Copied code from
128: Catalog.c for dealing with the Unicode names.
129: <HFS3> 12/10/96 msd Begin HFS+ changes. Check PRAGMA_LOAD_SUPPORTED before loading
130: precompiled headers.
131: <HFS2> 12/10/96 msd Add support for precompiled headers.
132: <HFS1> 12/9/96 msd first checked in
133:
134: */
135:
136: /*
137: Public routines:
138: CatSearchC
139: Searches the entire volume for files/folders matching given
140: criteria. It does this by reading every record in the Catalog
141: BTree; all non-index records are compared to the given criteria.
142: And files/folders that match have their FSSpec's returned
143: in a caller-supplied buffer. The caller may also provide a
144: buffer to use when reading the BTree; otherwise, a default
145: buffer within the File Manager is used.
146:
147: VerifyCatSearchPB
148: Validates the parameters in a CatSearch parameter block to
149: make sure the values are mutually consistent and in range.
150:
151: Internal routines:
152: ExtOffLineCheck
153: Make sure the given volume is both online and HFS (or HFS+).
154: If not, an appropriate error is returned.
155:
156: StartScan Initialize state for scan and return first record.
157: EndScan Cleanup state and return hint
158: ScanNextRecord Get the next record in the scan.
159: */
160:
161: #if ( PRAGMA_LOAD_SUPPORTED )
162: #pragma load PrecompiledHeaders
163: #else
164: #if TARGET_OS_MAC
165: #include <Timer.h>
166: #include <TextUtils.h>
167: #include <LowMemPriv.h>
168: #include <PLStringFuncs.h>
169: #else
170: #include "../headers/system/MacOSStubs.h"
171: #endif /* TARGET_OS_MAC */
172: #endif /* PRAGMA_LOAD_SUPPORTED */
173:
174:
175:
176: #include "../headers/HFSBtreesPriv.h"
177: #include "../headers/HFSVolumes.h"
178: #include "../headers/FileMgrInternal.h"
179: #include "../headers/system/HFSUnicodeWrappers.h"
180: #include "../headers/BTreesInternal.h"
181: #include "../headers/BTreesPrivate.h"
182: #include "../headers/BTreeScanner.h"
183: #include "../headers/CatalogPrivate.h"
184:
185: #if HFSInstrumentation
186: #include "../headers/system/Instrumentation.h"
187: #endif
188:
189:
190: #ifndef CATSEARCH_DEBUG
191: #define CATSEARCH_DEBUG 1
192: #endif
193:
194: #define BTREE_CB_TYPE BTreeControlBlock
195: #define BTREE_WRITE_COUNT(btcb) (btcb->numUpdateNodes+1)
196:
197: extern OSErr VerifyCatSearchPB( const CSParam *pb, UInt8 *outAttributes, UInt8 *outFlags );
198: extern OSErr CatSearchC( CSParam *pb, WDCBRecPtr *wdcb );
199: extern OSErr ExtOffLineCheck( ExtendedVCB *vcb );
200:
201: extern OSErr CheckExternalFileSystem( ExtendedVCB *vcb );
202: extern OSErr DeturmineVolume3( VolumeParam *iopb, short *nameLength, Boolean *nameSpecified, ExtendedVCB **vcb, WDCBRec **wdcb, unsigned char **pathName );
203: extern OSErr FlushVolume( ExtendedVCB *vcb );
204: extern OSErr FlushVolumeBuffers( ExtendedVCB *vcb );
205: extern OSErr ChkNode_glue( BTNodeDescriptor *node, BTREE_CB_TYPE *btcb );
206: extern void LocRec_glue( BTNodeDescriptor *node, BTREE_CB_TYPE *btcb, UInt32 recordNumber,
207: Ptr *key, Ptr *data, UInt32 *recordSize );
208:
209: //
210: //�� These need to be moved to an interface file
211: //
212: enum {
213: kBTreePrevious = -1,
214: kBTreeCurrent = 0,
215: kBTreeNext = 1
216:
217: };
218:
219: enum {
220: //
221: // Masks for bits in the file attributes
222: //
223: // kFileLockedMask = 1,
224: kMaskBatAttributes = ~(ioDirMask | kHFSFileLockedMask),
225:
226: //
227: // Masks for search bits
228: //
229: kMaskNotSearchInfo2 = ~(fsSBPartialName | fsSBFullName | fsSBNegate),
230: kMaskLengthBits = (fsSBFlLgLen | fsSBFlPyLen | fsSBFlRLgLen | fsSBFlRPyLen),
231:
232: //
233: // Masks for flags
234: //
235: kIncludeDirs = 1,
236: kIncludeFiles = 2,
237: kIncludeNames = 4,
238:
239: kMinimumBufferSize = 512
240: };
241:
242:
243: struct CatPosition {
244: UInt32 writeCount; // The BTree's write count (to see if the catalogwriteCount
245: // changed since the last search). If 0, the rest
246: // of the record is invalid, start from beginning.
247: UInt32 nextNode; // node number to resume search
248: UInt32 nextRecord; // record number to resume search
249: UInt32 recordsFound; // number of leaf records seen so far
250: };
251: typedef struct CatPosition CatPosition;
252:
253:
254: typedef BTScanState ScanState;
255:
256:
257: struct CatSearchState {
258: TMTask timer; // MUST be first field!
259: CSParam *pb;
260: Str31 targetName; // Upper case version of name being matched against
261: FSSpec *nextMatch;
262: long searchBits;
263: CatalogKey *currentKey; // Pointer to key within current record
264: CatalogRecord *currentData; // Pointer to data within current record
265: #if HFSInstrumentation
266: InstTraceClassRef trace;
267: InstEventTag eventTag;
268: InstDataDescriptorRef traceDescriptor;
269: #endif
270: short vRefNum; // Volume reference of volume being searched
271: Boolean isHFS; // True if volume is HFS
272: UInt8 attributes; // desired file attributes to match against
273: UInt8 flags;
274: Boolean timerCompleted; // Set to true by timer's completion routine
275: };
276: typedef struct CatSearchState CatSearchState;
277:
278: #if TARGET_OS_MAC
279: static OSErr InitCatSearch( ExtendedVCB *volume, CSParam *pb, ScanState *scanState );
280: static void UpdateCatPosition( const ExtendedVCB *volume, CatPosition *endingPosition, const ScanState *scanState );
281: static void InsertMatch(CatSearchState *searchState);
282: static Boolean CheckCriteria(ExtendedVCB *vcb, const CatSearchState *searchState);
283: Boolean CompareMasked(const UInt32 *thisValue, const UInt32 *compareData,
284: const UInt32 *compareMask, UInt32 count);
285: Boolean ComparePartialName(ConstStr31Param thisName, ConstStr31Param substring);
286: Boolean CompareFullName(ConstStr31Param thisName, ConstStr31Param testName);
287: #endif /* TARGET_OS_MAC */
288: Boolean CompareRange(UInt32 val, UInt32 low, UInt32 high);
289: #define CompareRange(val, low, high) (val >= low && val <= high)
290:
291: extern void CSTimerGlue(void);
292: extern void CatSearchTimerComplete(CatSearchState *state);
293:
294: UInt32 Low32BitsPinned(UInt64 x);
295: #define Low32BitsPinned(x) (x.hi ? 0xFFFFFFFF : x.lo)
296:
297:
298:
299: /*
300: ;__________________________________________________________________________________
301: ;
302: ; Routine: CMCatSearch
303: ;
304: ; Function: Locates files by search criteria
305: ;
306: ; Input: A0.L - parameter block pointer
307: ;
308: ; Register Usage (during call):
309: ; A0.L - scratch D0.L - scratch
310: ; A1.L - scratch D1.L - scratch
311: ; A2.L - scratch D2.L - scratch
312: ; A3.L - pointer to CatSearch State Record (CSSR) D3.L - scratch
313: ; A4.L - pointer to PScan State Record (PSR) D4.L - scratch
314: ; A5.L - pointer to user's param block D5.L - ioSearchBits
315: ; sp - standard file system stack
316: ; D7.L - ioActMatchCount
317: ;
318: ; Output: D0.W - result code (noErr, extFSErr, ioErr, nsvErr, catChanged, paramErr)
319: ; A0.L, A1.L - trash
320: ; D0.L, D1.L, D2.L - trash
321: ;__________________________________________________________________________________
322: */
323: #if TARGET_OS_MAC
324: OSErr CatSearchC( CSParam *pb, WDCBRecPtr *wdcb )
325: {
326: OSErr err;
327: ExtendedVCB *vcb;
328: short volNameLength;
329: Boolean volNameSpecified;
330: unsigned char *pathname;
331: UInt32 catalogRecordSize;
332: ScanState scanState;
333: CatSearchState searchState;
334: Boolean timerInstalled = false;
335: #if HFSInstrumentation
336: FSVarsRec *fsVars = (FSVarsRec *) LMGetFSMVars();
337: #endif
338:
339:
340: #if HFSInstrumentation
341: searchState.trace = (InstTraceClassRef) fsVars->later[0];
342: searchState.traceDescriptor = (InstDataDescriptorRef) fsVars->later[1];
343: searchState.eventTag = InstCreateEventTag();
344: InstLogTraceEvent( searchState.trace, searchState.eventTag, kInstStartEvent);
345: #endif
346:
347: //
348: // Start a timer for the call
349: //
350: searchState.timerCompleted = false;
351:
352: if (pb->ioSearchTime != 0 && pb->ioSearchTime != -1) {
353: searchState.timer.tmAddr = (TimerUPP) CSTimerGlue;
354: InsTime((QElem *) &searchState.timer);
355: PrimeTime((QElem *) &searchState.timer, pb->ioSearchTime);
356: timerInstalled = true;
357: }
358:
359: //
360: // Find the volume specified
361: //
362: err = DeturmineVolume3((VolumeParam *) pb, &volNameLength, &volNameSpecified, &vcb, wdcb, &pathname);
363: if (err != noErr) goto ErrorExit;
364:
365: //
366: // Make sure the volume is ours, and online.
367: //
368: err = ExtOffLineCheck(vcb);
369: if (err != noErr) goto ErrorExit;
370:
371: //
372: // Set up some information about the volume
373: //
374: searchState.vRefNum = vcb->vcbVRefNum;
375: if (vcb->vcbSigWord == kHFSSigWord)
376: searchState.isHFS = true;
377: else
378: searchState.isHFS = false;
379:
380: //
381: // Clear ioActMatchCount
382: //
383: pb->ioActMatchCount = 0;
384:
385: //
386: // Verify the parameter block
387: //
388: err = VerifyCatSearchPB(pb, &searchState.attributes, &searchState.flags);
389: if (err != noErr) goto ErrorExit;
390:
391: //
392: // If no matches requested, exit early
393: //
394: if (pb->ioReqMatchCount == 0) {
395: err = noErr;
396: goto ErrorExit;
397: }
398:
399: searchState.pb = pb;
400: searchState.searchBits = pb->ioSearchBits;
401: searchState.nextMatch = pb->ioMatchPtr;
402:
403: //
404: // If a name is part of the criteria, prepare it for matching. (We make it upper
405: // case and remove diacriticals.)
406: //
407: if (searchState.flags & kIncludeNames) {
408: StringPtr name;
409: name = pb->ioSearchInfo1->hFileInfo.ioNamePtr;
410: // If caller's name is longer than HFS names can be, then
411: // we can optimize.
412: if (name[0] > 31) {
413: // Nothing can possibly match the given name. If the caller asked
414: // us to negate the search, then we need to return everything.
415: if (searchState.searchBits & fsSBNegate) {
416: searchState.searchBits = 0; // causes everything to match
417: }
418: else {
419: err = eofErr; // nothing left to match
420: goto ErrorExit;
421: }
422: }
423: else {
424: //
425: // Make a copy of the supplied name and convert it to upper case
426: // for later comparison.
427: //
428: //�� There is a bug in the assembly CatSearch: it calls _FSUprString which
429: //�� is really just _UpperString. It passes the length of the string in D0.
430: //�� According to the interfaces, the second parameter (in D0) is a boolean
431: //�� to determine whether it should be diacritical sensitive (i.e. whether it
432: //���should leave diacriticals vs. stripping them). Apparently, this always
433: //�� evaluates to false (testing the high bit of the word?).
434: //
435: //�� I disagree with the above analysis. The $A054 trap, which _FSUprString is
436: //�� aliased to, is actually UprStringTrap(), implemented in :SuperMario:OS:SysUtil.a.
437: //�� It does in fact take a ptr to text in A0 and len in D0. UpperString(),
438: //���on the other hand, is glue in OSTrapsGlue.a which munges
439: //�� the input parameters (including the diac boolean) and then turns around and calls
440: //�� _UprString, with A0 pointing to text and D0 holding length. Same as assembly CatSearch.
441: //�� So _UprString (or _UpperString) != UpperString(), sadly enough.
442: //�� - RNP.
443: //
444: // Note: we still do this even for HFS+, since we want to compare the names that
445: // would actually be returned in the same way as HFS. That is name comparisons
446: // for HFS and HFS+ should behave identically if they returned the same name via
447: // GetCatInfo, even though HFS+ may be truncating or otherwise mangling the name
448: // to fit in 31 characters; we want to compare against the mangled name.
449: //
450: BlockMoveData(name, searchState.targetName, sizeof(Str31));
451: UprText( (Ptr)(searchState.targetName + 1), searchState.targetName[ 0]);
452: }
453: }
454:
455: //
456: // Set up for the search.
457: //
458: err = InitCatSearch(vcb, pb, &scanState);
459: #if DEBUG_BUILD
460: if (err > 0) DebugStr("\pCatSearch: Internal Error");
461: #endif
462:
463: //
464: // Now loop over the records
465: //
466: while (err == noErr) {
467: err = BTScanNextRecord(&scanState, searchState.timerCompleted, (void**)&searchState.currentKey, (void**)&searchState.currentData, &catalogRecordSize);
468: if (err == noErr) {
469: // Check for a match
470: if (CheckCriteria(vcb, &searchState)) { // Found a match?
471: err = BTScanCacheNode(&scanState); // Make sure current node is cached
472: InsertMatch(&searchState); // Return in to caller
473: if (++pb->ioActMatchCount == pb->ioReqMatchCount) // Got enough matches yet?
474: break;
475: }
476: }
477: }
478:
479: //
480: // See if we've scanned the entire Catalog BTree. If so, return eofErr.
481: // If we exited because of a timeout, then it's not an error.
482: //
483: if (err == btNotFound || err == fsBTEndOfIterationErr)
484: err = eofErr;
485: if (err == fsBTTimeOutErr)
486: err = noErr;
487: #if DEBUG_BUILD
488: if (err > 0) DebugStr("\pCatSearch: Internal Error");
489: #endif
490: //
491: // Update caller's CatPosition so they can resume the search
492: //
493: UpdateCatPosition(vcb, (CatPosition *) &pb->ioCatPosition, &scanState);
494:
495: //
496: // If we get here, we never actually started a scan, so all we have left
497: // is to remove the timer (if we installed one) and return the error code.
498: //
499: ErrorExit:
500: //
501: // Stop timer
502: //
503: if (timerInstalled)
504: RmvTime((QElem *) &searchState.timer);
505:
506: #if HFSInstrumentation
507: InstLogTraceEvent( searchState.trace, searchState.eventTag, kInstEndEvent);
508: #endif
509:
510: return err;
511: }
512:
513: #endif
514:
515: /*
516: ;__________________________________________________________________________________
517: ;
518: ; Routine: VerifyCSPB
519: ;
520: ; Function: Verify that a param block contains legal values
521: ;
522: ; Input: A0.L - parameter block pointer
523: ;
524: ; Register Usage (during call):
525: ; A0.L - pointer to user's param block D0.L - scratch
526: ; A1.L - pointer to ioSearchInfo1 D1.L - scratch
527: ; D2.B - copy of user's ioFlAttrib mask
528: ; D3.L - cssr.flags byte
529: ; A4.L - pointer to ioSearchInfo2
530: ; A5.L - pointer to user's param block D5.L - ioSearchBits
531: ;
532: ; Output:
533: ; d0.W - result code (noErr, paramErr)
534: ; d2.b - copy of user's ioFlAttrib mask, ioDirFlg masked
535: ; d3.b - cssr.flags with inclFiles, inclDirs and inclNames set correctly
536: ;
537: ; Here are the parameter checking rules for PBCatSearch: <1.3>
538: ; The labels at the left also appear in the code which checks that rule.
539: ;
540: ; You get a paramErr if
541: ; P1 ioMBufPtr is nil
542: ; P2 ioSearchInfo1 is nil
543: ; P3 (ioSearchBits includes not(fsSBPartialName or fsSBFullName or fsSBNegate)) and ioSearchInfo2 is nil;
544: ; i.e. A selected search bit requires the presence of ioSearchInfo2
545: ;
546: ; Then these,
547: ; ioSearchBits rules: You get a paramErr if
548: ; P4 fsSBPartialName
549: ; and (ioSearchInfo1->ioNamePtr = (nil or empty string))
550: ; P5 fsSBFullName (same as above)
551: ; P6 fsSBFlAttrib and some bit other than 0 (locked) or 4 (directory) returns paramErr
552: ; P7 search includes directories and
553: ; (ioSearchBits includes fsSBFlAttrib) and (ioSearchInfo2^.ioFlAttrib bit 0 = 1)
554: ; return paramErr
555: ; (i.e. "locked directory" makes no sense)
556: ; P8 fsSBDrNmFls and files returns paramErr
557: ; P9 fsSBFlLgLen and directories returns paramErr
558: ; P10 fsSBFlPyLen (same as above)
559: ; P11 fsSBFlRLgLen (same as above)
560: ; P12 fsSBFlRPyLen (same as above)
561: ;
562: ; A search includes (files only) if
563: ; ioSearchBits includes fsSBFlAttrib
564: ; - and -
565: ; ioSearchInfo1^.ioFlAttrib bit 4 = 0 i.e. explicitly looking for non-directories
566: ; - and -
567: ; ioSearchInfo2^.ioFlAttrib bit 4 = 1
568: ;
569: ; A search includes (directories only) if
570: ; ioSearchBits includes fsSBFlAttrib
571: ; - and -
572: ; ioSearchInfo1^.ioFlAttrib bit 4 = 1 i.e. explicitly looking for directories
573: ; - and -
574: ; ioSearchInfo2^.ioFlAttrib bit 4 = 1
575: ;
576: ; A search includes both if
577: ; ioSearchBits includes fsSBFlAttrib
578: ; - and -
579: ; ioSearchInfo2^.ioFlAttrib bit 4 = 0 i.e. don't care about the directory bit
580: ;
581: ; - OR -
582: ; ioSearchBits doesn't include fsSBFlAttrib i.e. don't care about attributes at all
583: ;__________________________________________________________________________________
584: */
585:
586: OSErr VerifyCatSearchPB(
587: const CSParam *pb, // user's parameter block
588: UInt8 *outAttributes, // ioFlAttrib, with ioDirFlg cleared
589: UInt8 *outFlags) // cssr.flags with inclFiles, inclDirs and inclNames set correctly
590: {
591: SInt8 attributes = 0; // local copy of output outAttributes
592: UInt8 flags; // local copy of output outFlags
593: long searchBits; // copy of pb->ioSearchBits
594: CInfoPBPtr searchInfo1; // copy of pb->ioSearchInfo1
595: CInfoPBPtr searchInfo2; // copy of pb->ioSearchInfo2
596:
597: //
598: // P1: User must supply a buffer to return the found FSSpec's
599: //
600: if (pb->ioMatchPtr == NULL)
601: goto ParamErrExit;
602:
603: //
604: // P2: Must supply values to compare against (ioSearchInfo1)
605: //
606: searchInfo1 = pb->ioSearchInfo1;
607: searchInfo2 = pb->ioSearchInfo2;
608: if (searchInfo1 == NULL)
609: goto ParamErrExit;
610:
611: searchBits = pb->ioSearchBits;
612:
613: //
614: // P3: See if we need any end-of-range or mask values (in ioSearchInfo2).
615: // If so, the pointer must be non-NULL.
616: //
617: if (((searchBits & kMaskNotSearchInfo2) != 0) && (searchInfo2 == NULL))
618: goto ParamErrExit;
619:
620: flags = 0;
621:
622: //
623: // P4-5: If we're searching by name (partial or full), then check the name passed.
624: //
625: if (searchBits & (fsSBPartialName | fsSBFullName)) {
626: StringPtr name = searchInfo1->hFileInfo.ioNamePtr;
627: if (name == NULL || name[0] == 0)
628: goto ParamErrExit;
629: flags |= kIncludeNames;
630: }
631:
632: //
633: // Determine whether we're looking for files, folders, or both.
634: //
635: if (searchBits & fsSBFlAttrib) {
636: attributes = searchInfo2->hFileInfo.ioFlAttrib; // get mask for attributes
637: if (attributes & kMaskBatAttributes) // P6: only locked and directory bits are allowed
638: goto ParamErrExit;
639: if (attributes & ioDirMask) // do they care whether object is a file or folder?
640: if (searchInfo1->hFileInfo.ioFlAttrib & ioDirMask)
641: flags |= kIncludeDirs; // wanted folders only
642: else
643: flags |= kIncludeFiles; // wanted files only
644: else
645: flags |= (kIncludeDirs | kIncludeFiles); // caller didn't care about files vs. folders
646: }
647: else
648: flags |= (kIncludeDirs | kIncludeFiles);
649:
650: attributes &= ~ioDirMask; // clear ioDirMask since it isn't actually on disk
651:
652: //
653: // P7: If they cared about file attributes, and search includes folders, then
654: // ioLockFlag must not be set (since it is meaningless for folders).
655: //
656: if ((flags & kIncludeDirs) && (searchBits & fsSBFlAttrib) && (attributes & kHFSFileLockedMask))
657: goto ParamErrExit;
658:
659: //
660: // P8: If search includes files, then # of files per folder must not be set.
661: //
662: if ((searchBits & fsSBDrNmFls) && (flags & kIncludeFiles))
663: goto ParamErrExit;
664:
665: //
666: // P9-P12: If search includes directories, then none of the fork length bits
667: // must be set.
668: //
669: if ((flags & kIncludeDirs) && (searchBits & kMaskLengthBits))
670: goto ParamErrExit;
671:
672: //
673: // When we get here, all the checks have passed. Return the output flags
674: // and file attributes.
675: //
676: *outAttributes = attributes;
677: *outFlags = flags;
678: return noErr;
679:
680: //
681: // If we get here, there was a problem with one of the parameters.
682: //
683: ParamErrExit:
684: return paramErr;
685: }
686:
687:
688:
689: //
690: // Copy the FSSpec for the current catalog node into the caller's match buffer
691: //
692: #if TARGET_OS_MAC
693: static void InsertMatch(CatSearchState *searchState)
694: {
695: CatalogKey *current;
696: FSSpec *match;
697:
698: // Get the key for the item we just found, and the place where we should
699: // store the item's FSSpec
700: current = searchState->currentKey;
701: match = searchState->nextMatch;
702:
703: // Copy vRefNum
704: match->vRefNum = searchState->vRefNum;
705:
706: if (searchState->isHFS) {
707: // Copy parentDirID
708: match->parID = current->hfs.parentID;
709:
710: // Copy the name as a PString
711: BlockMoveData(current->hfs.nodeName, &match->name[0], StrLength(current->hfs.nodeName) + 1);
712: }
713: else {
714: TextEncoding encoding;
715: HFSCatalogNodeID cnid;
716:
717: cnid = searchState->currentData->hfsPlusFile.fileID; // note: cnid at same offset for folders
718: encoding = searchState->currentData->hfsPlusFile.textEncoding; // note: textEncoding at same offset for folders
719:
720: // Copy parentDirID
721: match->parID = current->hfsPlus.parentID;
722:
723: // Copy the name as a PString
724: (void) ConvertUnicodeToHFSName( ¤t->hfsPlus.nodeName, encoding, cnid, &match->name[0]);
725: }
726:
727: #if HFSInstrumentation
728: // InstLogTraceEvent( searchState->trace, searchState->eventTag, kInstMiddleEvent);
729: {
730: struct {
731: long vRefNum;
732: long parID;
733: char name[32];
734: } x;
735: unsigned len;
736:
737: x.vRefNum = match->vRefNum;
738: x.parID = match->parID;
739:
740: len = match->name[0];
741: BlockMoveData(&match->name[1], &x.name[0], len);
742: x.name[len] = 0;
743:
744: InstLogTraceEventWithDataStructure( searchState->trace, searchState->eventTag, kInstMiddleEvent,
745: searchState->traceDescriptor, (UInt8 *) &x, sizeof(x));
746: }
747: #endif
748:
749: // Point to next FSSpec in caller's buffer
750: searchState->nextMatch++;
751: }
752: #endif /* TARGET_OS_MAC */
753:
754:
755:
756: //
757: // Determine whether the current catalog node matches the caller's criteria. Return
758: // true if the object matches.
759: //
760: #if TARGET_OS_MAC
761: static Boolean CheckCriteria(ExtendedVCB *vcb, const CatSearchState *searchState)
762: {
763: CatalogKey *key;
764: Boolean matched;
765: long searchBits;
766: CInfoPBRec *searchInfo1;
767: CInfoPBRec *searchInfo2;
768: CatalogNodeData catData;
769:
770: key = searchState->currentKey;
771:
772: // Change the catalog record data into a single common form
773: catData.nodeType = 0; // mark this record as not in use
774: CopyCatalogNodeData(vcb, searchState->currentData, &catData);
775:
776: switch (searchState->currentData->recordType) {
777: case kHFSFolderThreadRecord:
778: return false; // Never match a thread record!
779: break;
780: case kHFSPlusFolderThreadRecord:
781: return false; // Never match a thread record!
782: break;
783:
784: case kHFSFolderRecord:
785: case kHFSFileRecord:
786: case kHFSPlusFolderRecord:
787: case kHFSPlusFileRecord:
788: break;
789:
790: default:
791: return false; // Not a file or folder record, so can't search it
792: }
793:
794: searchBits = searchState->searchBits;
795: matched = true; // Assume we got a match
796:
797: // See if this type of object (file vs. folder) is one of the types they're trying
798: // to match.
799: if (catData.nodeType == kCatalogFolderNode && (searchState->flags & kIncludeDirs) == 0 ) {
800: // Found a folder, but they don't want folders.
801: matched = false;
802: goto TestDone;
803: }
804: if (catData.nodeType == kCatalogFileNode && (searchState->flags & kIncludeFiles) == 0 ) {
805: // Found a file, but they don't want files.
806: matched = false;
807: goto TestDone;
808: }
809:
810: searchInfo1 = searchState->pb->ioSearchInfo1;
811: searchInfo2 = searchState->pb->ioSearchInfo2;
812:
813: //
814: // First, attempt to match the name -- either partial or complete.
815: // If the volume is HFS+, then we need to make a Str31 version of the name
816: // to use for comparison.
817: //
818: if (searchBits & (fsSBPartialName | fsSBFullName)) {
819: Str31 keyName;
820: ConstStr31Param namePtr;
821:
822: // Make a pointer to a PString version of the name
823: if (searchState->isHFS)
824: namePtr = &key->hfs.nodeName[0];
825: else {
826: TextEncoding encoding;
827:
828: encoding = searchState->currentData->hfsPlusFile.textEncoding; // same offset for folders
829:
830: (void) ConvertUnicodeToHFSName(&key->hfsPlus.nodeName, encoding, catData.nodeID, keyName);
831: namePtr = keyName;
832: }
833:
834: // Check for a partial name match
835: if (searchBits & fsSBPartialName) {
836: matched = ComparePartialName(namePtr, searchState->targetName);
837: // Exit if no match, or we no there's nothing more to compare
838: if (matched == false || searchBits == fsSBPartialName)
839: goto TestDone;
840: }
841:
842: // Check for a full name match
843: if (searchBits & fsSBFullName) {
844: matched = CompareFullName(namePtr, searchState->targetName);
845: // Exit if no match, or we no there's nothing more to compare
846: if (matched == false || searchBits == fsSBFullName)
847: goto TestDone;
848: }
849: }
850:
851: //
852: // parent ID
853: //
854: if (searchBits & fsSBFlParID) {
855: HFSCatalogNodeID parentID;
856:
857: // Note: ioFlParID and ioDrParID have the same offset in search info, so no
858: // need to test the object type here. However, we do need to test for HFS
859: // vs. HFSPlus, since their key structures are different.
860:
861: if (searchState->isHFS)
862: parentID = key->hfs.parentID;
863: else
864: parentID = key->hfsPlus.parentID;
865:
866: matched = CompareRange(parentID, searchInfo1->hFileInfo.ioFlParID,
867: searchInfo2->hFileInfo.ioFlParID);
868: if (matched == false) goto TestDone;
869: }
870:
871: //
872: // File attributes
873: //
874: if (searchBits & fsSBFlAttrib) {
875: UInt32 temp;
876:
877: temp = (catData.nodeFlags ^ searchInfo1->hFileInfo.ioFlAttrib) & searchState->attributes;
878: if (temp != 0) {
879: matched = false;
880: goto TestDone;
881: }
882: }
883:
884: //
885: // Number of files in a directory
886: //
887: if (searchBits & fsSBDrNmFls) {
888: matched = CompareRange(catData.valence, searchInfo1->dirInfo.ioDrNmFls,
889: searchInfo2->dirInfo.ioDrNmFls);
890: if (matched == false) goto TestDone;
891: }
892:
893: //
894: // Finder Info
895: //
896: if (searchBits & fsSBFlFndrInfo) {
897: UInt32 *thisValue;
898:
899: thisValue = (UInt32 *) &catData.finderInfo[0];
900:
901: // Note: ioFlFndrInfo and ioDrUsrWds have the same offset in search info, so
902: // no need to test the object type here.
903: matched = CompareMasked(thisValue, (UInt32 *) &searchInfo1->hFileInfo.ioFlFndrInfo,
904: (UInt32 *) &searchInfo2->hFileInfo.ioFlFndrInfo,
905: sizeof(FInfo)/sizeof(UInt32));
906:
907: if (matched == false) goto TestDone;
908: }
909:
910: //
911: // Extended Finder Info
912: //
913: if (searchBits & fsSBFlXFndrInfo) {
914: UInt32 *thisValue;
915:
916: thisValue = (UInt32 *) &catData.extFinderInfo[0];
917:
918: // Note: ioFlXFndrInfo and ioDrFndrInfo have the same offset in search info, so
919: // no need to test the object type here.
920: matched = CompareMasked(thisValue, (UInt32 *) &searchInfo1->hFileInfo.ioFlXFndrInfo,
921: (UInt32 *) &searchInfo2->hFileInfo.ioFlXFndrInfo,
922: sizeof(FXInfo)/sizeof(UInt32));
923:
924: if (matched == false) goto TestDone;
925: }
926:
927: //
928: // File logical length (data fork)
929: //
930: if (searchBits & fsSBFlLgLen) {
931: matched = CompareRange(catData.dataLogicalSize, searchInfo1->hFileInfo.ioFlLgLen,
932: searchInfo2->hFileInfo.ioFlLgLen);
933: if (matched == false) goto TestDone;
934: }
935:
936: //
937: // File physical length (data fork)
938: //
939: if (searchBits & fsSBFlPyLen) {
940: matched = CompareRange(catData.dataPhysicalSize, searchInfo1->hFileInfo.ioFlPyLen,
941: searchInfo2->hFileInfo.ioFlPyLen);
942: if (matched == false) goto TestDone;
943: }
944:
945: //
946: // File logical length (resource fork)
947: //
948: if (searchBits & fsSBFlRLgLen) {
949: matched = CompareRange(catData.rsrcLogicalSize, searchInfo1->hFileInfo.ioFlRLgLen,
950: searchInfo2->hFileInfo.ioFlRLgLen);
951: if (matched == false) goto TestDone;
952: }
953:
954: //
955: // File physical length (resource fork)
956: //
957: if (searchBits & fsSBFlRPyLen) {
958: matched = CompareRange(catData.rsrcPhysicalSize, searchInfo1->hFileInfo.ioFlRPyLen,
959: searchInfo2->hFileInfo.ioFlRPyLen);
960: if (matched == false) goto TestDone;
961: }
962:
963: //
964: // Create date
965: //
966: if (searchBits & fsSBFlCrDat) {
967: matched = CompareRange(catData.createDate, searchInfo1->hFileInfo.ioFlCrDat,
968: searchInfo2->hFileInfo.ioFlCrDat);
969: if (matched == false) goto TestDone;
970: }
971:
972: //
973: // Mod date
974: //
975: if (searchBits & fsSBFlMdDat) {
976: matched = CompareRange(catData.contentModDate, searchInfo1->hFileInfo.ioFlMdDat,
977: searchInfo2->hFileInfo.ioFlMdDat);
978: if (matched == false) goto TestDone;
979: }
980:
981: //
982: // Backup date
983: //
984: if (searchBits & fsSBFlBkDat) {
985: matched = CompareRange(catData.backupDate, searchInfo1->hFileInfo.ioFlBkDat,
986: searchInfo2->hFileInfo.ioFlBkDat);
987: }
988:
989: TestDone:
990: //
991: // Finally, determine whether we need to negate the sense of the match (i.e. find
992: // all objects that DON'T match).
993: //
994: if (searchBits & fsSBNegate) {
995: matched = !matched;
996: }
997:
998: return matched;
999: }
1000: #endif /* TARGET_OS_MAC */
1001:
1002:
1003:
1004: Boolean CompareMasked(const UInt32 *thisValue, const UInt32 *compareData,
1005: const UInt32 *compareMask, UInt32 count)
1006: {
1007: Boolean matched;
1008: UInt32 i;
1009:
1010: matched = true; // Assume it will all match
1011:
1012: for (i=0; i<count; i++) {
1013: if (((*thisValue++ ^ *compareData++) & *compareMask++) != 0) {
1014: matched = false;
1015: break;
1016: }
1017: }
1018:
1019: return matched;
1020: }
1021:
1022:
1023: #if TARGET_OS_MAC
1024: Boolean CompareFullName(ConstStr31Param thisName, ConstStr31Param testName)
1025: {
1026: Str31 tempName;
1027:
1028: //
1029: // Make a quick check first. If the lengths differ, they can't possibly match.
1030: //
1031: if (thisName[0] != testName[0])
1032: return false;
1033:
1034: //
1035: // Now make an upper case copy of thisName.
1036: //
1037: //�� Would it be better to skip making upper case versions of the names
1038: //�� and just call EqualString(thisName, testName, false, false)? I think it
1039: //�� should give the same result.
1040: //
1041: BlockMoveData(thisName, tempName, sizeof(Str31));
1042: UprText( (Ptr)(tempName + 1), tempName[0]);
1043:
1044: //
1045: // Compare tempName and testName; they must be identical PStrings to match.
1046: //
1047: return PascalBinaryCompare(tempName, testName);
1048: }
1049: #endif /* TARGET_OS_MAC */
1050:
1051:
1052:
1053: #if TARGET_OS_MAC
1054: Boolean ComparePartialName(ConstStr31Param thisName, ConstStr31Param substring)
1055: {
1056: Boolean matched;
1057: Str31 tempName;
1058:
1059: //
1060: // Make a quick check first. If the substring is longer than this object's name,
1061: // it can't possibly match.
1062: //
1063: if (substring[0] > thisName[0])
1064: return false;
1065:
1066: //
1067: // Now make an upper case copy of thisName.
1068: //
1069: //�� Would it be better to skip making upper case versions of the names
1070: //�� and just call EqualString(thisName, testName, false, false)? I think it
1071: //�� should give the same result.
1072: //
1073: BlockMoveData(thisName, tempName, sizeof(Str31));
1074: UprText( (Ptr)(tempName + 1), tempName[0]);
1075:
1076: //
1077: // Now see if substring is a substring of tempName.
1078: //
1079: matched = (PLstrstr(tempName, substring) != NULL);
1080:
1081: return matched;
1082: }
1083: #endif /* TARGET_OS_MAC */
1084:
1085:
1086:
1087: //�� Same function appears in Volumes.c as CheckVolumeOffLine(), but the code is slightly different
1088: //�� we should delete one copy.
1089: #if TARGET_OS_MAC
1090: OSErr ExtOffLineCheck( ExtendedVCB *vcb )
1091: {
1092: OSErr err;
1093:
1094: err = CheckExternalFileSystem(vcb);
1095: if (err == noErr) {
1096: if (vcb->vcbDrvNum != 0)
1097: LMSetReqstVol((Ptr) vcb);
1098: else
1099: err = volOffLinErr;
1100: }
1101:
1102: return err;
1103: }
1104: #endif
1105:
1106:
1107: void CatSearchTimerComplete(CatSearchState *state)
1108: {
1109: state->timerCompleted = true;
1110: }
1111:
1112: #if TARGET_OS_MAC
1113: static OSErr InitCatSearch( ExtendedVCB *volume, CSParam *pb, ScanState *scanState )
1114: {
1115: OSErr err;
1116: FCB *fcb;
1117: BTREE_CB_TYPE *btcb;
1118: CatPosition *startingPosition;
1119: void *buffer;
1120: UInt32 bufferSize;
1121: FSVarsRec *fsVars;
1122:
1123: //
1124: // Set up pointers to the catalog's FCB and BTCB
1125: //
1126: fcb = GetFileControlBlock(volume->catalogRefNum);
1127: btcb = (BTREE_CB_TYPE *) fcb->fcbBTCBPtr;
1128:
1129: //
1130: // Flush all files on this volume so the BTrees will be up-to-date (since we only
1131: // read the BTree on disk, not what might be in the control blocks).
1132: //
1133: LMSetFlushOnly(0xFF);
1134: err = FlushVolume(volume);
1135: if (err != noErr) goto ErrorExit;
1136:
1137: //
1138: // Make sure the volume control files (especially the Catalog B-tree) gets flushed,
1139: // too, or else we'll be reading stale catalog data.
1140: //
1141: err = FlushVolumeBuffers(volume);
1142: if (err != noErr) goto ErrorExit;
1143:
1144: //
1145: // Use our internal optimization buffer unless the caller supplied a suitable one.
1146: //
1147: fsVars = (FSVarsRec *) LMGetFSMVars();
1148: buffer = pb->ioOptBuffer;
1149: bufferSize = pb->ioOptBufSize;
1150: if (buffer == NULL || bufferSize < fsVars->gAttributesBufferSize) {
1151: buffer = fsVars->gAttributesBuffer;
1152: bufferSize = fsVars->gAttributesBufferSize;
1153: }
1154:
1155: //
1156: // Set up the scan state to start a new search, or resume a previous one.
1157: //
1158: startingPosition = (CatPosition *) &pb->ioCatPosition;
1159: if (startingPosition->writeCount == 0) {
1160: //
1161: // Starting a new search
1162: //
1163: err = BTScanInitialize(fcb, 0, 0, 0, buffer, bufferSize, scanState);
1164: }
1165: else {
1166: //
1167: // Resuming a previous search. Make sure the catalog hasn't changed
1168: // since the previous search.
1169: //
1170: if (startingPosition->writeCount != BTREE_WRITE_COUNT(btcb)) {
1171: startingPosition->writeCount = BTREE_WRITE_COUNT(btcb); // return the new write count
1172: err = catChangedErr;
1173: goto ErrorExit;
1174: }
1175:
1176: err = BTScanInitialize(fcb, startingPosition->nextNode, startingPosition->nextRecord, startingPosition->recordsFound,
1177: buffer, bufferSize, scanState);
1178: }
1179:
1180: ErrorExit:
1181: return err;
1182: }
1183: #endif /* TARGET_OS_MAC */
1184:
1185: #if TARGET_OS_MAC
1186: static void UpdateCatPosition( const ExtendedVCB *volume, CatPosition *endingPosition, const ScanState *scanState )
1187: {
1188: FCB *fcb;
1189: BTREE_CB_TYPE *btcb;
1190:
1191: //
1192: // Set up pointers to the catalog's FCB and BTCB
1193: //
1194: fcb = GetFileControlBlock(volume->catalogRefNum);
1195: btcb = (BTREE_CB_TYPE *) fcb->fcbBTCBPtr;
1196:
1197: //
1198: // Update the caller's CatPosition for the next time
1199: //
1200: endingPosition->writeCount = BTREE_WRITE_COUNT(btcb);
1201: BTScanTerminate(scanState, &endingPosition->nextNode, &endingPosition->nextRecord, &endingPosition->recordsFound);
1202: }
1203: #endif /* TARGET_OS_MAC */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.