![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Catalog.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 Catalog.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: Catalog.c
27:
28: Contains: Catalog Manager Implementation
29:
30: Version: HFS Plus 1.0
31:
32: Copyright: � 1996-1999 by Apple Computer, Inc., all rights reserved.
33:
34: File Ownership:
35:
36: DRI: Don Brady
37:
38: Other Contact: Mark Day
39:
40: Technology: xxx put technology here xxx
41:
42: Writers:
43:
44: (msd) Mark Day
45: (DSH) Deric Horn
46: (djb) Don Brady
47:
48: Change History (most recent first):
49: <Rhap> 2/2/99 djb Fix CreateFileIDRef to copy entire name when creating thread record.
50: <Rhap> 1/7/99 djb Use a max bytes of 256 in calls to ConvertUnicodeToUTF8.
51: <Rhap> 12/9/98 djb UpdateCatalogNode only updates vcbLsMod if contentModDate changes.
52: <Rhap> 11/5/98 djb Add support for UTF-8 names.
53: <Rhap> 8/31/98 djb GetTimeLocal now takes an input.
54: <Rhap> 7/8/98 ser Added accessDate and AttributeModDate init. to create routine.
55: <Rhap> 6/5/98 djb Added CreateFileIDRef routine.
56: <Rhap> 6/3/98 djb Merge MoveCatalogRecord and RenameCatalogRecord into one routine.
57: <Rhap> 4/17/98 djb Add VCB locking.
58: <Rhap> 4/6/98 djb Catalog iterators now need to be released.
59: <Rhap> 4/6/98 djb Removed CreateVolumeCatalogCache and DisposeVolumeCatalogCache (obsolete).
60: <Rhap> 3/31/98 djb Make UpdateCatalogNode interface thread-safe.
61: <Rhap> 3/31/98 djb Sync up with final HFSVolumes.h header file.
62: <Rhap> 3/17/98 djb Fixed CreateCatalogNode interface to take kCatalogFolderNode and
63: kCatalogFileNode as type input.
64:
65: <CS36> 12/10/97 DSH 2201501, UpdateCatalogNode to only update CatalogRecords which
66: are under 2 Gig by checking the overloaded valence field.
67: <CS35> 11/20/97 djb Radar #2002357. Fixing retry mechanism.
68: <CS34> 11/17/97 djb PrepareInputName routine now returns an error.
69: <CS33> 11/13/97 djb Radar #1683572. Add new GetCatalogOffspringFile routine for
70: PBGetFileInfo calls (support used to be in HFSPathnameCalls.a).
71: <CS32> 11/7/97 msd Change calls to the wrapper routine CompareUnicodeNames() to use
72: the underlying routine FastUnicodeCompare() instead.
73: <CS31> 10/19/97 msd Bug 1684586. GetCatInfo and SetCatInfo use only contentModDate.
74: <CS30> 10/17/97 djb Change Catalog Create/Rename to use ConvertInputNameToUnicode.
75: <CS29> 10/13/97 djb Update volumeNameEncodingHint when changing volume name. Change
76: name of GetSystemTextEncoding to GetDefaultTextEncoding.
77: <CS28> 10/1/97 djb Add new catalog iterators and node cache to improve performance.
78: <CS27> 9/12/97 msd In CreateCatalogNode, make sure parent is a folder, not a file.
79: <CS26> 9/10/97 msd In RenameCatalogNodeUnicode, remove HFS-only code and make sure
80: the conversion context is set up and marked in the volume's
81: bitmap.
82: <CS25> 9/9/97 DSH Added RelString_Glue to avoid having to link DFAEngine with
83: Interface.o
84: <CS24> 9/8/97 msd Make sure a folder's modifyDate is set whenever its
85: contentModDate is set. In UpdateCatalogNode, make sure the
86: modifyDate is greater or equal to contentModDate; do a DebugStr
87: only for debug builds.
88: <CS23> 9/7/97 djb Make some DebuStrs DEBUG_BUILD only.
89: <CS22> 9/4/97 djb Add more Catalog Iterators, Instrument RelString.
90: <CS21> 9/4/97 msd Remove call to PropertyDeleteObject.
91: <CS20> 8/18/97 DSH Use RelString instead of FastRelString in DFA to avoid loading
92: branch island instead of table.
93: <CS19> 8/14/97 djb Remove hard link support. Switch over to FastRelString.
94: <CS18> 8/8/97 djb Fixed bugs in LinkCatalogNode.
95: <CS17> 8/5/97 djb Don't restore vcbNxtCNID if thread exists (radar #1670614).
96: <CS16> 7/25/97 DSH Pass heuristicHint to BTSearchRecord from GetCatalogOffspring.
97: <CS15> 7/18/97 msd Include LowMemPriv.h. In LinkCatalogNode, now sets the
98: kInsertedFileThread2 flag correctly; should only affect error
99: recovery code.
100: <CS14> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name
101: collision
102: <CS13> 7/8/97 DSH Loading PrecompiledHeaders from define passed in on C line
103: <CS12> 6/27/97 msd Add PBLongRename SPI. Added RenameCatalogNodeUnicode call, which
104: takes Unicode names for HFS Plus volumes. Removed calls to
105: Attributes module when creating, renaming or moving nodes.
106: <CS11> 6/24/97 djb Validate the mangled name matches in
107: LocateCatalogNodeByMangledName.
108: <CS10> 6/24/97 djb Add hard link support.
109: <CS9> 6/20/97 msd Use contentModDate and attributeModDate fields instead of
110: modifyDate. Made CopyCatalogNodeData public.
111: <CS8> 6/18/97 djb Add routines LocateCatalogNodeWithRetry & UpdateVolumeEncodings.
112: Add mangled name retry to DeleteCatalogNode, MoveCatalogNode and
113: RenameCatalogNode.
114: <CS7> 6/13/97 djb Major changes for longname support and multiple scripts.
115: <CS6> 6/9/97 msd Instead of calling GetDateTime, call GetTimeUTC or GetTimeLocal.
116: Dates on an HFS Plus volume need to be converted to/from UTC.
117: <CS5> 6/4/97 djb Set textEncoding hint in Rename and Create. TrashCatalogIterator
118: was not always called with the correct folder ID.
119: <CS4> 5/21/97 djb Turn off recursive iterators.
120: <CS3> 5/19/97 djb Add support for B-tree iterators to GetCatalogOffspring.
121: <CS2> 5/9/97 djb Get in sync with FilesInternal.i.
122: <CS1> 4/24/97 djb First checked into Common System Project.
123: <HFS26> 4/11/97 DSH Use extended VCB fields catalogRefNum, and extentsRefNum.
124: <HFS25> 4/4/97 djb Get in sync with volume format changes.
125: <HFS24> 3/31/97 djb Additional HFS Plus optimization added to GetCatalogNode.
126: <HFS23> 3/28/97 djb Add Optimization to GetCatalogNode.
127: <HFS22> 3/27/97 djb Unicode conversion routines now use byte counts.
128: <HFS21> 3/17/97 DSH Casting to compile with SC, GetRecordSize ->
129: GetCatalogRecordSize, moved some prototypes to extern.
130: <HFS20> 3/5/97 msd Add calls to Property Manager when catalog entries are created,
131: deleted, moved, renamed.
132: <HFS19> 2/19/97 djb HFS Plus catalog keys no longer have a pad word.
133: <HFS18> 1/24/97 DSH (djb) GetCatalogOffSpring() fix volume->vcbDirIDM = 0
134: <HFS17> 1/23/97 DSH Truncate name to CMMaxCName characters in PrepareInputName().
135: <HFS16> 1/14/97 djb Fixed RenameCatalogNode for case when just a cnid is passed.
136: <HFS15> 1/13/97 djb Added support for varaible sized thread records in HFS+.
137: <HFS14> 1/11/97 DSH Moving PrepareInputName() declaration fo FilesInternal.h
138: <HFS13> 1/10/97 djb CopyCatalogNodeData was trashing the resource extents on HFS+.
139: <HFS12> 1/10/97 djb CopyCatalogNodeData was trashing dataLogicalSize on HFS+ disks.
140: <HFS11> 1/9/97 djb Get in sync with new HFSVolumesPriv.i.
141: <HFS10> 1/6/97 djb Added name length checking to CompareExtendedCatalogKeys. Fixed
142: GetCatalogOffspring - it was not correctly passing the HFS+ flag
143: to PrepareOutputName. Fixed BuildKey for HFS+ keys.
144: <HFS9> 1/3/97 djb Fixed termination bug in GetCatalogOffspring. Added support for
145: large keys. Integrated latest HFSVolumesPriv.h changes.
146: <HFS8> 12/19/96 DSH Changed call from C_FlushMDB to HFS+ savy
147: FlushVolumeControlBlock()
148: <HFS7> 12/19/96 djb Add new B-tree manager...
149: <HFS6> 12/13/96 djb Fixing bugs for HFS+. Switch to HFSUnicodeWrappers routines.
150: <HFS5> 12/12/96 djb Changed the SPI for GetCatalogNode, GetCatalogOffspring, and
151: UpdateCatalogNode.
152: <HFS4> 12/12/96 DSH Removed static function declarations for functions used by
153: FileIDServices.c.
154: <HFS3> 11/11/96 djb Added support for HFS+ Unicode names. Major changes throughout.
155: <HFS2> 11/4/96 djb Added FSSpec output to GetCatalogNode and GetCatalogOffspring
156: routines.
157: <HFS1> 10/29/96 djb first checked in
158:
159: */
160:
161: #pragma segment Catalog
162:
163: #if ( PRAGMA_LOAD_SUPPORTED )
164: #pragma load PrecompiledHeaders
165: #else
166: #if TARGET_OS_MAC
167: #include <Errors.h>
168: #include <Files.h>
169: #include <FSM.h>
170: #include <Memory.h>
171: #include <TextUtils.h>
172: #include <Types.h>
173: #include <LowMemPriv.h>
174: #else
175: #include "../headers/system/MacOSTypes.h"
176: #include "../headers/system/MacOSStubs.h"
177: #endif /* TARGET_OS_MAC */
178: #endif /* PRAGMA_LOAD_SUPPORTED */
179:
180: #include "../headers/FileMgrInternal.h"
181: #include "../headers/BTreesInternal.h"
182: #include "../headers/HFSVolumes.h"
183: #include "../headers/system/HFSUnicodeWrappers.h"
184: #include "../headers/system/HFSInstrumentation.h"
185: #include "../headers/CatalogPrivate.h"
186:
187:
188: // External routines
189:
190: extern SInt32 FastRelString( ConstStr255Param str1, ConstStr255Param str2 );
191:
192: extern SInt16 RelString_Glue(StringPtr pStr1, StringPtr pStr2);
193:
194:
195: // Internal routines
196:
197: static OSErr IterateCatalogNode( ExtendedVCB *volume, CatalogIterator *catalogIterator, UInt16 index,
198: FSSpec *nodeSpec, CatalogNodeData *nodeData, UInt32 *hint );
199:
200: void InitCatalogThreadRecord(ExtendedVCB *volume, UInt32 nodeType, CatalogKey *nodeKey,
201: CatalogRecord *record, UInt32 *threadSize);
202:
203: void InitCatalogRecord(ExtendedVCB *volume, UInt32 nodeType, UInt32 textEncoding,
204: CatalogRecord *record, UInt32 *recordSize, HFSCatalogNodeID *catalogNodeID);
205:
206: #if TARGET_OS_RHAPSODY && DIAGNOSTIC
207: #include <sys/systm.h>
208: #define PRINTIT(A) kprintf A;
209: #else
210: #define PRINTIT(A)
211: #endif
212:
213: //_________________________________________________________________________________
214: // Exported Routines
215: //
216: // CreateCatalogNode - Creates a new folder or file CNode.
217: // DeleteCatalogNode - Deletes an existing folder or file CNode.
218: // GetCatalogNode - Locates an existing folder or file CNode.
219: // GetCatalogOffspringFile - Gets an offspring file record from a folder.
220: // GetCatalogOffspring - Gets an offspring record from a folder.
221: // MoveRenameCatalogNode - Moves/Renames an existing folder or file CNode.
222: // UpdateCatalogNode - Marks a Catalog BTree node as 'dirty'.
223: // CreateFileIDRef - Creates a file thread record for hfs file node
224: // CompareCatalogKeys - Compares two catalog keys.
225: //
226: //_________________________________________________________________________________
227:
228:
229: //_________________________________________________________________________________
230: //
231: // About date/time values:
232: //
233: // Date/time values stored in control blocks and generic structures (such as
234: // CatalogNodeData) are always stored in local time. Values stored in HFS volume
235: // format structures (such as B-tree records) are also stored in local time.
236: // Values stored in HFS Plus format structures are stored in UTC.
237: //_________________________________________________________________________________
238:
239:
240: // Implementation
241:
242:
243: //_________________________________________________________________________________
244: // Routine: CreateCatalogNode
245: //
246: // Function: Creates a new folder or file CNode. A new folder or file
247: // record is added to the catalog BTree. If a folder CNode is
248: // being created, a new thread record is also added.
249: //
250: //_________________________________________________________________________________
251:
252: OSErr
253: CreateCatalogNode ( ExtendedVCB *volume, HFSCatalogNodeID parentID, ConstUTF8Param name,
254: UInt32 nodeType, HFSCatalogNodeID *catalogNodeID, UInt32 *catalogHint)
255: {
256: CatalogKey nodeKey; // 518 bytes
257: CatalogRecord nodeData; // 520 bytes
258: UInt32 nodeDataSize;
259: CatalogRecord parentThreadData; // 520 bytes
260: HFSCatalogNodeID parentsParentID;
261: CatalogName *parentNamePtr;
262: UInt32 tempHint;
263: UInt32 textEncoding;
264: UInt16 tempSize;
265: OSErr result;
266: Boolean isHFSPlus = (volume->vcbSigWord == kHFSPlusSigWord);
267:
268: if (nodeType != kCatalogFolderNode && nodeType != kCatalogFileNode)
269: return paramErr;
270:
271: //--- make sure parent exists (by locating the parent's thread record)
272:
273: result = LocateCatalogThread(volume, parentID, &parentThreadData, &tempSize, &tempHint);
274: ReturnIfError(result);
275:
276: TrashCatalogIterator(volume, parentID); // invalidate any iterators for this parentID
277:
278: // save copy of parent's parentID and name.
279:
280: if (isHFSPlus)
281: {
282: if (parentThreadData.recordType != kHFSPlusFolderThreadRecord)
283: return dirNFErr;
284:
285: parentsParentID = parentThreadData.hfsPlusThread.parentID;
286: parentNamePtr = (CatalogName*) &parentThreadData.hfsPlusThread.nodeName;
287: }
288: else
289: {
290: if (parentThreadData.recordType != kHFSFolderThreadRecord)
291: return dirNFErr;
292:
293: parentsParentID = parentThreadData.hfsThread.parentID;
294: parentNamePtr = (CatalogName*) &parentThreadData.hfsThread.nodeName;
295: }
296:
297: // invalidate cache for parent since its about to change
298: InvalidateCatalogNodeCache(volume, parentsParentID);
299:
300: //--- build key for new catalog node
301: result = BuildCatalogKeyUTF8(parentID, name, isHFSPlus, &nodeKey, &textEncoding);
302: ReturnIfError(result);
303:
304: //--- initialize catalog data record (for folder or file)
305: InitCatalogRecord(volume, nodeType, textEncoding, &nodeData, &nodeDataSize, catalogNodeID);
306:
307: //--- add new folder/file record to catalog BTree
308: result = InsertBTreeRecord(volume->catalogRefNum, &nodeKey, &nodeData, nodeDataSize, catalogHint);
309: if (result)
310: {
311: if (result == btExists)
312: result = cmExists;
313: return result;
314: }
315:
316: //--- build thread record for new CNode
317: if (isHFSPlus || nodeType == kCatalogFolderNode)
318: {
319: HFSCatalogKey threadKey; // use the smaller key since name is null
320: CatalogRecord threadData; // 520 bytes
321: UInt32 threadSize;
322:
323: BuildCatalogKey(*catalogNodeID, NULL, isHFSPlus, (CatalogKey*) &threadKey);
324:
325: InitCatalogThreadRecord(volume, nodeType, &nodeKey, &threadData, &threadSize);
326:
327: //--- add thread record to catalog BTree
328:
329: result = InsertBTreeRecord(volume->catalogRefNum, &threadKey, &threadData, threadSize, &tempHint);
330:
331: //--- couldn't add thread record, delete newly created folder record and exit
332: if (result)
333: {
334: (void) DeleteBTreeRecord(volume->catalogRefNum, &nodeKey);
335:
336: if ( result == btExists ) // <CS17>
337: result = cmExists; // remap to a catalog error
338:
339: return result;
340: }
341: }
342:
343: //--- update counters...
344:
345: result = UpdateFolderCount( volume, parentsParentID, parentNamePtr, nodeData.recordType, kNoHint, +1);
346: ReturnIfError(result); /* XXX what about cleanup ??? */
347:
348: AdjustVolumeCounts(volume, nodeData.recordType, +1);
349:
350: result = FlushCatalog(volume);
351:
352: return result;
353:
354: } // end CreateCatalogNode
355:
356:
357: /*
358: * initialize catalog data record (for folder or file)
359: */
360: void InitCatalogRecord(ExtendedVCB *volume, UInt32 nodeType, UInt32 textEncoding, CatalogRecord *record, UInt32 *recordSize, HFSCatalogNodeID *catalogNodeID)
361: {
362: HFSCatalogNodeID nodeID;
363: UInt32 timeStamp;
364:
365: ClearMemory(record, sizeof(CatalogRecord)); // first clear the record
366:
367: VCB_LOCK(volume);
368: nodeID = volume->vcbNxtCNID++; // get CNID and bump next available CNode ID
369: VCB_UNLOCK(volume);
370: *catalogNodeID = nodeID; // make sure it gets passed back
371:
372: if (volume->vcbSigWord == kHFSPlusSigWord)
373: {
374: timeStamp = GetTimeUTC(); // get current date/time (universal)
375:
376: UpdateVolumeEncodings(volume, textEncoding);
377:
378: if (nodeType == kCatalogFolderNode )
379: {
380: record->recordType = kHFSPlusFolderRecord;
381: record->hfsPlusFolder.folderID = nodeID;
382: record->hfsPlusFolder.createDate = timeStamp;
383: record->hfsPlusFolder.contentModDate = timeStamp;
384: record->hfsPlusFolder.accessDate = timeStamp;
385: record->hfsPlusFolder.attributeModDate = timeStamp;
386: record->hfsPlusFolder.textEncoding = textEncoding;
387: *recordSize = sizeof(HFSPlusCatalogFolder);
388: // threadType = kHFSPlusFolderThreadRecord;
389: }
390: else if (nodeType == kCatalogFileNode )
391: {
392: record->recordType = kHFSPlusFileRecord;
393: record->hfsPlusFile.fileID = nodeID;
394: record->hfsPlusFile.createDate = timeStamp;
395: record->hfsPlusFile.contentModDate = timeStamp;
396: record->hfsPlusFile.accessDate = timeStamp;
397: record->hfsPlusFile.attributeModDate = timeStamp;
398: record->hfsPlusFile.flags |= kHFSThreadExistsMask;
399: record->hfsPlusFile.textEncoding = textEncoding;
400: *recordSize = sizeof(HFSPlusCatalogFile);
401: // threadType = kHFSPlusFileThreadRecord;
402: }
403: }
404: else /* standard hfs */
405: {
406: timeStamp = GetTimeLocal(true); // get current local date/time
407:
408: if (nodeType == kCatalogFolderNode )
409: {
410: record->recordType = kHFSFolderRecord;
411: record->hfsFolder.folderID = nodeID;
412: record->hfsFolder.createDate = timeStamp;
413: record->hfsFolder.modifyDate = timeStamp;
414: *recordSize = sizeof(HFSCatalogFolder);
415: // threadType = kHFSFolderThreadRecord;
416: }
417: else if (nodeType == kCatalogFileNode )
418: {
419: record->recordType = kHFSFileRecord;
420: record->hfsFile.fileID = nodeID;
421: record->hfsFile.createDate = timeStamp;
422: record->hfsFile.modifyDate = timeStamp;
423: *recordSize = sizeof(HFSCatalogFile);
424: }
425: }
426: }
427:
428:
429: void InitCatalogThreadRecord(ExtendedVCB *volume, UInt32 nodeType, CatalogKey *nodeKey,
430: CatalogRecord *record, UInt32 *threadSize)
431: {
432: ClearMemory(record, sizeof(CatalogRecord) ); // first clear the record
433:
434: if (volume->vcbSigWord == kHFSPlusSigWord)
435: {
436: if (nodeType == kCatalogFolderNode)
437: record->recordType = kHFSPlusFolderThreadRecord;
438: else
439: record->recordType = kHFSPlusFileThreadRecord;
440: record->hfsPlusThread.parentID = nodeKey->hfsPlus.parentID;
441: *threadSize = sizeof(record->hfsPlusThread);
442:
443: // HFS Plus has varaible sized threads so adjust to actual length
444: *threadSize -= ( sizeof(record->hfsPlusThread.nodeName.unicode) -
445: (nodeKey->hfsPlus.nodeName.length * sizeof(UniChar)) );
446: BlockMoveData(&nodeKey->hfsPlus.nodeName, &record->hfsPlusThread.nodeName,
447: sizeof(UniChar) * (nodeKey->hfsPlus.nodeName.length + 1));
448: }
449: else // classic HFS
450: {
451: if (nodeType == kCatalogFolderNode)
452: record->recordType = kHFSFolderThreadRecord;
453: else
454: record->recordType = kHFSFileThreadRecord;
455: record->hfsThread.parentID = nodeKey->hfs.parentID;
456: *threadSize = sizeof(record->hfsThread);
457: BlockMoveData(&nodeKey->hfs.nodeName, &record->hfsThread.nodeName,
458: nodeKey->hfs.nodeName[0] + 1);
459: }
460: }
461:
462:
463: //_________________________________________________________________________________
464: // Routine: DeleteCatalogNode
465: //
466: // Function: Deletes an existing folder or file CNode. The thread record
467: // is also deleted for directories and files that have thread
468: // records.
469: //
470: // The valence for a folder must be zero before it can be deleted.
471: // The rootfolder cannot be deleted.
472: //
473: //_________________________________________________________________________________
474:
475: OSErr
476: DeleteCatalogNode(ExtendedVCB *volume, HFSCatalogNodeID parentID, ConstUTF8Param name, UInt32 hint)
477: {
478: CatalogKey key; // 518 bytes
479: CatalogRecord data; // 520 bytes
480: UInt32 nodeHint;
481: HFSCatalogNodeID nodeID;
482: HFSCatalogNodeID nodeParentID;
483: UInt32 textEncoding;
484: UInt16 nodeType;
485: OSErr result;
486: Boolean isHFSPlus = (volume->vcbSigWord == kHFSPlusSigWord);
487:
488: //--- locate subject catalog node
489:
490: result = BuildCatalogKeyUTF8(parentID, name, isHFSPlus, &key, &textEncoding);
491: ReturnIfError(result);
492:
493: result = LocateCatalogNodeByKey(volume, hint, &key, &data, &nodeHint);
494:
495: // if we did not find it by name, then look for an embedded file ID in a mangled name
496: if ( (result == cmNotFound) && isHFSPlus )
497: result = LocateCatalogNodeByMangledName(volume, parentID, name, &key, &data, &nodeHint);
498: ReturnIfError(result);
499:
500: nodeParentID = isHFSPlus ? key.hfsPlus.parentID : key.hfs.parentID; // establish real parent cnid
501: nodeType = data.recordType; // establish cnode type
502: nodeID = 0;
503:
504: switch (nodeType)
505: {
506: case kHFSFolderRecord:
507: if (data.hfsFolder.valence != 0) // is it empty?
508: return cmNotEmpty;
509:
510: nodeID = data.hfsFolder.folderID;
511: break;
512:
513: case kHFSPlusFolderRecord:
514: if (data.hfsPlusFolder.valence != 0) // is it empty?
515: return cmNotEmpty;
516:
517: nodeID = data.hfsPlusFolder.folderID;
518: break;
519:
520: case kHFSFileRecord:
521: if (data.hfsFile.flags & kHFSThreadExistsMask)
522: nodeID = data.hfsFile.fileID;
523: break;
524:
525: case kHFSPlusFileRecord:
526: nodeID = data.hfsPlusFile.fileID; // note: HFS Plus files always have a thread
527: break;
528:
529: default:
530: return cmNotFound;
531: }
532:
533:
534: if (nodeID == fsRtDirID) // is this the root folder?
535: return cmRootCN; // sorry, you can't delete the root!
536:
537: TrashCatalogIterator(volume, nodeParentID); // invalidate any iterators for this parentID
538: InvalidateCatalogNodeCache(volume, nodeParentID); // and invalidate node cache
539:
540: //--- delete catalog records for CNode and file threads if they exist
541:
542: result = DeleteBTreeRecord(volume->catalogRefNum, &key);
543: ReturnIfError(result);
544:
545: if ( nodeID )
546: {
547: CatalogKey threadKey; // 518 bytes
548:
549: BuildCatalogKey(nodeID, NULL, isHFSPlus, &threadKey);
550:
551: (void) DeleteBTreeRecord(volume->catalogRefNum, &threadKey); // ignore errors for thread deletes
552: }
553:
554: //--- update counters...
555:
556: result = UpdateFolderCount(volume, nodeParentID, NULL, nodeType, kNoHint, -1);
557: ReturnIfError(result);
558:
559: AdjustVolumeCounts(volume, nodeType, -1); // all done with this file or folder
560:
561: result = FlushCatalog(volume);
562:
563: return result;
564:
565: } // end DeleteCatalogNode
566:
567:
568: //_________________________________________________________________________________
569: // Routine: GetCatalogNode
570: //
571: // Function: Locates an existing folder or file CNode and returns an FSSpec for
572: // the CNode and a pointer to the CNode data record.
573: //
574: //_________________________________________________________________________________
575:
576: OSErr
577: GetCatalogNode( ExtendedVCB *volume, HFSCatalogNodeID parentID, ConstUTF8Param name, UInt32 hint,
578: FSSpec *nodeSpec, CatalogNodeData *nodeData, UInt32 *newHint)
579: {
580: CatalogKey *key;
581: CatalogRecord *record;
582: OSErr result = noErr;
583: Boolean isHFSPlus = (volume->vcbSigWord == kHFSPlusSigWord);
584: UInt32 textEncoding;
585: CatalogRecord catalogRecord; // 520 bytes
586: CatalogKey catalogKey; // 518 bytes
587: ByteCount actualDstLen;
588:
589: record = &catalogRecord;
590: key = &catalogKey;
591:
592: //--- Locate folder/file BTree record for the CNode
593: result = BuildCatalogKeyUTF8(parentID, name, isHFSPlus, key, &textEncoding);
594: ReturnIfError(result);
595: result = LocateCatalogNodeByKey(volume, hint, key, record, newHint);
596:
597: // if we did not find it by name, then look for an embedded file ID in a mangled name
598: if ( result == cmNotFound && isHFSPlus)
599: result = LocateCatalogNodeByMangledName(volume, parentID, name, key, record, newHint);
600: ReturnIfError(result);
601:
602: //--- Fill out the FSSpec (output)
603:
604: nodeSpec->vRefNum = volume->vcbVRefNum;
605: nodeSpec->parID = isHFSPlus ? key->hfsPlus.parentID : key->hfs.parentID;
606:
607: if ( isHFSPlus )
608: {
609: // if ( UnicodeBinaryCompare(&key->hfsPlus.nodeName, &nodeName.ustr) )
610: // {
611: // // HFS Plus Optimization: since nodeName == key->ckrCName just copy the original name!
612: // // Omit _expensive_ conversion back to ascii
613: //
614: // BlockMoveData(name, nodeSpec->name, name[0] + 1);
615: // }
616: // else
617: {
618: result = ConvertUnicodeToUTF8(key->hfsPlus.nodeName.length * sizeof(UniChar),
619: key->hfsPlus.nodeName.unicode,
620: NAME_MAX + 1, /* 255 + termination byte */
621: &actualDstLen,
622: nodeSpec->name);
623: }
624: }
625: else // classic HFS
626: {
627: result = ConvertMacRomanToUTF8(key->hfs.nodeName, NAME_MAX + 1, &actualDstLen, nodeSpec->name);
628: }
629:
630: //--- Fill out universal data record...
631: CopyCatalogNodeData(volume, record, nodeData);
632:
633: #if DEBUG_BUILD
634: if ( nodeData->nodeType != '????' )
635: if ( nodeData->nodeID > volume->vcbNxtCNID || nodeData->nodeID == 0)
636: DebugStr("\pGetCatalogOffspring: bad file ID found!");
637: #endif
638:
639: return result;
640:
641: } // end GetCatalogNode
642:
643:
644:
645: //_________________________________________________________________________________
646: // Routine: GetCatalogOffspringFile
647: //
648: // Function: Gets an offspring file from a specified folder. The folder
649: // is identified by it's folderID. The desired offspring file is
650: // indicated by the value of the file index (1 = 1st file offspring,
651: // 2 = 2nd file offspring, etc.).
652: //
653: //_________________________________________________________________________________
654:
655: OSErr
656: GetCatalogOffspringFile( ExtendedVCB *volume, HFSCatalogNodeID folderID, UInt16 fileIndex,
657: FSSpec *nodeSpec, CatalogNodeData *nodeData, UInt32 *hint )
658: {
659: CatalogIterator * catalogIterator;
660: UInt16 index;
661: UInt16 fileCounter;
662: OSErr result = noErr;
663:
664:
665: if ( folderID == 0 )
666: return cmNotFound;
667:
668: // get the best catalog iterator...
669: catalogIterator = GetCatalogIterator(volume, folderID, fileIndex, kIterateFilesOnly);
670:
671: index = catalogIterator->currentIndex; // Get last search's folder offset
672:
673: // make sure we're not looking for a file beyond this one...
674: if ( index == 0 || catalogIterator->fileIndex > fileIndex )
675: {
676: index = 1; // Start with the first item in the folder
677: fileCounter = fileIndex; // Need to look at all files up to and including fileIndex
678: }
679: else
680: {
681: fileCounter = fileIndex - catalogIterator->fileIndex + 1;
682:
683: if (fileCounter == 2) // if difference is one then no need to read previous file
684: {
685: ++index; // go to next entry
686: fileCounter = 1; // were looking for 1 file (the next one we find)
687: }
688: }
689:
690: while ( fileCounter > 0 )
691: {
692: result = IterateCatalogNode(volume, catalogIterator, index++, nodeSpec, nodeData, hint);
693:
694: if (result != noErr)
695: break;
696:
697: if ( nodeData->nodeType == kCatalogFileNode )
698: --fileCounter; // one down
699: }
700:
701: if ( result == noErr )
702: catalogIterator->fileIndex = fileIndex; // update current file index for next time
703:
704: (void) ReleaseCatalogIterator(catalogIterator);
705:
706: return result;
707:
708: } // end GetCatalogOffspringFile
709:
710:
711: //_________________________________________________________________________________
712: // Routine: GetCatalogOffspring
713: //
714: // Function: Gets an offspring record from a specified folder. The folder
715: // is identified by it's folderID. The desired offspring CNode is
716: // indicated by the value of the offspring index (1 = 1st offspring
717: // CNode, 2 = 2nd offspring CNode, etc.).
718: //
719: //_________________________________________________________________________________
720:
721: OSErr
722: GetCatalogOffspring( ExtendedVCB *volume, HFSCatalogNodeID folderID, UInt16 index,
723: FSSpec *nodeSpec, CatalogNodeData *nodeData, UInt32 *hint )
724: {
725: CatalogIterator * catalogIterator;
726: OSErr result;
727:
728:
729: if ( folderID == 0 )
730: return cmNotFound;
731:
732: // get best catalog iterator...
733: catalogIterator = GetCatalogIterator(volume, folderID, index, kIterateAll);
734:
735: result = IterateCatalogNode(volume, catalogIterator, index, nodeSpec, nodeData, hint);
736:
737: (void) ReleaseCatalogIterator(catalogIterator);
738:
739: return result;
740:
741: } // end GetCatalogOffspring
742:
743:
744: //_________________________________________________________________________________
745: // Routine: IterateCatalogNode
746: //
747: // Function: Gets an offspring record from a specified folder. The folder
748: // is identified by it's folderID. The desired offspring CNode is
749: // indicated by the value of the offspring index (1 = 1st offspring
750: // CNode, 2 = 2nd offspring CNode, etc.).
751: //
752: //_________________________________________________________________________________
753:
754: static OSErr
755: IterateCatalogNode( ExtendedVCB *volume, CatalogIterator *catalogIterator, UInt16 index,
756: FSSpec *nodeSpec, CatalogNodeData *nodeData, UInt32 *hint )
757: {
758: HFSCatalogNodeID offspringParentID;
759: CatalogKey * offspringKey;
760: CatalogRecord * offspringData;
761: CatalogName * offspringName;
762: BTreeIterator btreeIterator;
763: FSBufferDescriptor btRecord;
764: FCB * fcb;
765: SInt16 selectionIndex;
766: UInt16 tempSize;
767: UInt16 operation;
768: OSErr result;
769: Boolean isHFSPlus;
770: CatalogRecord catalogRecord; // 520 bytes
771: ByteCount actualDstLen;
772:
773: offspringData = &catalogRecord;
774:
775: isHFSPlus = (volume->vcbSigWord == kHFSPlusSigWord);
776: fcb = GetFileControlBlock(volume->catalogRefNum);
777:
778: // make a btree iterator from catalog iterator
779: UpdateBtreeIterator(catalogIterator, &btreeIterator);
780:
781: btRecord.bufferAddress = offspringData;
782: btRecord.itemCount = 1;
783: btRecord.itemSize = sizeof(CatalogRecord);
784:
785: //--- if neccessary position the iterator at the thread record for the specified folder
786:
787: if ( catalogIterator->currentIndex == 0 ) // is this a new iterator?
788: {
789: UInt32 heuristicHint;
790: UInt32 *cachedHint;
791:
792: // We pass a 2nd hint/guess into BTSearchRecord. The heuristicHint is a mapping of
793: // dirID and nodeNumber, in hopes that the current search will be in the same node
794: // as the last search with the same parentID.
795: result = GetMRUCacheBlock( catalogIterator->folderID, volume->hintCachePtr, (Ptr *)&cachedHint );
796: heuristicHint = (result == noErr) ? *cachedHint : kInvalidMRUCacheKey;
797:
798: result = BTSearchRecord( fcb, &btreeIterator, heuristicHint, &btRecord, &tempSize, &btreeIterator );
799: ExitOnError(result);
800:
801: UpdateCatalogIterator(&btreeIterator, catalogIterator); // update btree hint and key
802:
803: InsertMRUCacheBlock( volume->hintCachePtr, catalogIterator->folderID, (Ptr) &btreeIterator.hint.nodeNum );
804: }
805:
806: //--- get offspring record (relative to catalogIterator's position)
807:
808: selectionIndex = index - catalogIterator->currentIndex;
809:
810: // now we have to map index into next/prev operations...
811: if (selectionIndex == 1)
812: {
813: operation = kBTreeNextRecord;
814: }
815: else if (selectionIndex == -1)
816: {
817: operation = kBTreePrevRecord;
818: }
819: else if (selectionIndex == 0)
820: {
821: operation = kBTreeCurrentRecord;
822: }
823: else if (selectionIndex > 1)
824: {
825: UInt32 i;
826:
827: for (i = 1; i < selectionIndex; ++i)
828: {
829: result = BTIterateRecord( fcb, kBTreeNextRecord, &btreeIterator, &btRecord, &tempSize );
830: ExitOnError(result);
831: }
832: operation = kBTreeNextRecord;
833: }
834: else // (selectionIndex < -1)
835: {
836: SInt32 i;
837:
838: for (i = -1; i > selectionIndex; --i)
839: {
840: result = BTIterateRecord( fcb, kBTreePrevRecord, &btreeIterator, &btRecord, &tempSize );
841: ExitOnError(result);
842: }
843: operation = kBTreePrevRecord;
844: }
845:
846: result = BTIterateRecord( fcb, operation, &btreeIterator, &btRecord, &tempSize );
847: ExitOnError(result);
848:
849: offspringKey = (CatalogKey*) &btreeIterator.key;
850:
851: if (isHFSPlus)
852: {
853: offspringParentID = offspringKey->hfsPlus.parentID;
854: offspringName = (CatalogName*) &offspringKey->hfsPlus.nodeName;
855: }
856: else
857: {
858: offspringParentID = offspringKey->hfs.parentID;
859: offspringName = (CatalogName*) offspringKey->hfs.nodeName;
860: }
861:
862: if (offspringParentID != catalogIterator->folderID) // different parent?
863: {
864: AgeCatalogIterator(catalogIterator); // we reached the end, so don't hog the cache!
865:
866: result = cmNotFound; // must be done with this folder
867: goto ErrorExit;
868: }
869:
870: UpdateCatalogIterator(&btreeIterator, catalogIterator); // update btree hint and key
871: catalogIterator->currentIndex = index; // update the offspring index marker
872:
873: *hint = btreeIterator.hint.nodeNum; // return an old-style hint
874:
875: //--- Fill out the FSSpec...
876:
877: nodeSpec->vRefNum = volume->vcbVRefNum;
878: nodeSpec->parID = offspringParentID;
879:
880: if (isHFSPlus)
881: {
882: result = ConvertUnicodeToUTF8(offspringName->ustr.length * sizeof(UniChar),
883: offspringName->ustr.unicode,
884: NAME_MAX + 1, /* 255 + termination byte */
885: &actualDstLen,
886: nodeSpec->name);
887: }
888: else /* hfs name */
889: {
890: result = ConvertMacRomanToUTF8(offspringName->pstr, NAME_MAX + 1, &actualDstLen, nodeSpec->name);
891: }
892:
893: //--- Fill out universal data record...
894: CopyCatalogNodeData(volume, offspringData, nodeData);
895:
896:
897: #if DEBUG_BUILD
898: if ( nodeData->nodeType != '????' )
899: if ( nodeData->nodeID > volume->vcbNxtCNID || nodeData->nodeID == 0)
900: DebugStr("\pGetCatalogOffspring: bad file ID found!");
901: #endif
902:
903: return result;
904:
905: ErrorExit:
906:
907: if ( result == btNotFound )
908: result = cmNotFound;
909:
910: return result;
911:
912: } // end IterateCatalogNode
913:
914:
915: //_________________________________________________________________________________
916: // Routine: MoveRenameCatalogNode
917: //
918: // Function: Moves and/or rename an existing folder or file CNode.
919: // Note that when moving a folder, all decendants (its offspring,
920: // their offspring, etc.) are also moved.
921: //
922: // Assumes srcHint contains a text encoding that was set by a GetCatalogNode call
923: //_________________________________________________________________________________
924:
925: OSErr
926: MoveRenameCatalogNode(ExtendedVCB *volume, HFSCatalogNodeID srcParentID, ConstUTF8Param srcName,
927: UInt32 srcHint, HFSCatalogNodeID dstParentID, ConstUTF8Param dstName, UInt32 *newHint)
928: {
929: CatalogKey srcKey; // 518 bytes
930: CatalogRecord srcRecord; // 520 bytes
931: CatalogKey dstKey; // 518 bytes
932: CatalogKey dstFolderKey; // 518 bytes
933: HFSCatalogNodeID dstFolderParentID = 0;
934: UInt32 dstFolderHint;
935: CatalogName *dstFolderNamePtr = NULL;
936: CatalogRecord tmpRecord; // 520 bytes
937: HFSCatalogNodeID threadID;
938: UInt32 textEncoding;
939: OSErr result;
940: Boolean isNewName;
941: Boolean isHFSPlus = (volume->vcbSigWord == kHFSPlusSigWord);
942: Boolean isOrigDeleted = false;
943: short srcNameLen;
944: short dstNameLen;
945:
946:
947: result = BuildCatalogKeyUTF8(srcParentID, srcName, isHFSPlus, &srcKey, &textEncoding);
948: ReturnIfError(result);
949:
950: /* XXX can strlen and bcmp handle NULL pointers? */
951:
952: srcNameLen = strlen(srcName);
953: dstNameLen = strlen(dstName);
954:
955: //--- check if names match
956:
957: if ((srcNameLen == dstNameLen) && (bcmp(srcName, dstName, srcNameLen) == 0))
958: {
959: isNewName = false;
960: dstKey = srcKey;
961: if ( isHFSPlus ) {
962: dstKey.hfsPlus.parentID = dstParentID; // set parent ID
963: }
964: else {
965: dstKey.hfs.parentID = dstParentID; // set parent ID
966: }
967: }
968: else /* names are different */
969: {
970: isNewName = true;
971: result = BuildCatalogKeyUTF8(dstParentID, dstName, isHFSPlus, &dstKey, &textEncoding);
972: ReturnIfError(result);
973: }
974:
975: //--- make sure source record exists
976:
977: result = LocateCatalogNodeByKey(volume, srcHint, &srcKey, &srcRecord, &srcHint);
978:
979: // if we did not find it by name, then look for an embedded file ID in a mangled name
980: if ( (result == cmNotFound) && isHFSPlus )
981: result = LocateCatalogNodeByMangledName(volume, srcParentID, srcName, &srcKey, &srcRecord, &srcHint);
982: ReturnIfError(result);
983:
984: srcParentID = (isHFSPlus ? srcKey.hfsPlus.parentID : srcKey.hfs.parentID);
985:
986: // if we're moving then do some additional preflighting...
987:
988: if (srcParentID != dstParentID)
989: {
990: //--- make sure destination folder exists
991:
992: result = LocateCatalogNode(volume, dstParentID, NULL, kNoHint, &dstFolderKey, &tmpRecord, &dstFolderHint);
993: ReturnIfError(result);
994:
995: if (tmpRecord.recordType == kHFSPlusFolderRecord)
996: {
997: dstParentID = tmpRecord.hfsPlusFolder.folderID;
998: dstFolderParentID = dstFolderKey.hfsPlus.parentID;
999: dstFolderNamePtr = (CatalogName*) &dstFolderKey.hfsPlus.nodeName;
1000: }
1001: else if (tmpRecord.recordType == kHFSFolderRecord)
1002: {
1003: dstParentID = tmpRecord.hfsFolder.folderID;
1004: dstFolderParentID = dstFolderKey.hfs.parentID;
1005: dstFolderNamePtr = (CatalogName*) &dstFolderKey.hfs.nodeName;
1006: }
1007: else
1008: {
1009: return badMovErr;
1010: }
1011:
1012: //--- if source is a folder, make sure its a proper move
1013:
1014: if (srcRecord.recordType == kHFSPlusFolderRecord || srcRecord.recordType == kHFSFolderRecord)
1015: {
1016: HFSCatalogNodeID srcFolderID;
1017: HFSCatalogNodeID ancestorParentID;
1018: CatalogKey tempKey; // 518 bytes
1019: UInt32 tempHint;
1020:
1021: if (isHFSPlus)
1022: {
1023: srcFolderID = srcRecord.hfsPlusFolder.folderID;
1024: ancestorParentID = dstFolderKey.hfsPlus.parentID;
1025: }
1026: else
1027: {
1028: srcFolderID = srcRecord.hfsFolder.folderID;
1029: ancestorParentID = dstFolderKey.hfs.parentID;
1030: }
1031:
1032: if ( srcFolderID == fsRtDirID || // source == root?
1033: srcFolderID == dstParentID || // source == destination?
1034: srcFolderID == ancestorParentID ) // source == destination's parent?
1035: {
1036: return badMovErr;
1037: }
1038:
1039: while (ancestorParentID > fsRtDirID) // loop until we reach the root folder
1040: {
1041: // locate next folder up the tree...
1042: result = LocateCatalogNode(volume, ancestorParentID, NULL, kNoHint, &tempKey, &tmpRecord, &tempHint);
1043: ReturnIfError(result);
1044:
1045: ancestorParentID = isHFSPlus ? tempKey.hfsPlus.parentID : tempKey.hfs.parentID;
1046:
1047: if (srcFolderID == ancestorParentID) // source = destination ancestor?
1048: return badMovErr;
1049: }
1050: }
1051:
1052: TrashCatalogIterator(volume, dstParentID); // invalidate any iterators for destination parentID
1053: }
1054: else /* (srcParentID == dstParentID) */
1055: {
1056: if ( !isNewName )
1057: {
1058: *newHint = srcHint; // they match, so we're all done!
1059: return noErr;
1060: }
1061: }
1062:
1063: TrashCatalogIterator(volume, srcParentID); // invalidate any iterators for source's parentID
1064: InvalidateCatalogNodeCache(volume, srcParentID); // invalidate node cache since parent changed
1065:
1066: if (isNewName && isHFSPlus)
1067: {
1068: // update textEncoding hint (works for folders and files)
1069: srcRecord.hfsPlusFolder.textEncoding = textEncoding;
1070:
1071: UpdateVolumeEncodings(volume, textEncoding);
1072: }
1073:
1074: //--- insert source CNode record in BTree with new key (a new parent id and/or new name)
1075:
1076: result = InsertBTreeRecord(volume->catalogRefNum, &dstKey, &srcRecord, GetCatalogRecordSize(&srcRecord), newHint);
1077:
1078: if (result == btExists)
1079: {
1080: UInt16 dataSize;
1081:
1082: /* XXX what about the case: move id1,foo to id2,FOO ?? */
1083: if (srcParentID != dstParentID || isNewName == false)
1084: return cmExists;
1085:
1086: //--- new CNode name already exists in the same folder, locate the existing one
1087: result = SearchBTreeRecord(volume->catalogRefNum, &dstKey, srcHint,
1088: &dstFolderKey, &tmpRecord, &dataSize, newHint);
1089:
1090: if (result == btNotFound)
1091: result = cmNotFound;
1092: ReturnIfError(result);
1093:
1094: //--- check if its the same CNode (same name but different upper/lower case)
1095:
1096: if (srcRecord.recordType != tmpRecord.recordType)
1097: return cmExists;
1098:
1099: switch (srcRecord.recordType)
1100: {
1101: case kHFSPlusFileRecord: /* HFS Plus records share same cnid location */
1102: case kHFSPlusFolderRecord:
1103: if (srcRecord.hfsPlusFolder.folderID != tmpRecord.hfsPlusFolder.folderID)
1104: return cmExists;
1105: break;
1106:
1107: case kHFSFolderRecord:
1108: if (srcRecord.hfsFolder.folderID != tmpRecord.hfsFolder.folderID)
1109: return cmExists;
1110: break;
1111:
1112: case kHFSFileRecord:
1113: if (srcRecord.hfsFile.fileID != tmpRecord.hfsFile.fileID)
1114: return cmExists;
1115: break;
1116:
1117: default:
1118: return cmExists;
1119: }
1120:
1121: //--- same name but different case, so delete old and insert with new name...
1122:
1123: result = DeleteBTreeRecord(volume->catalogRefNum, &srcKey);
1124: ReturnIfError(result);
1125: isOrigDeleted = true; // So we dont delete it again down below
1126:
1127: result = InsertBTreeRecord(volume->catalogRefNum, &dstKey, &srcRecord, dataSize, newHint);
1128: }
1129: ReturnIfError(result);
1130:
1131: //
1132: // from this point on we need to cleanup (ie delete the new record) if we encounter errors!
1133: //
1134:
1135: //--- update thread record for node (if it exists)
1136:
1137: switch (srcRecord.recordType)
1138: {
1139: case kHFSPlusFileRecord:
1140: case kHFSPlusFolderRecord:
1141: threadID = srcRecord.hfsPlusFolder.folderID;
1142: break;
1143:
1144: case kHFSFolderRecord:
1145: threadID = srcRecord.hfsFolder.folderID;
1146: break;
1147:
1148: case kHFSFileRecord:
1149: if (srcRecord.hfsFile.flags & kHFSThreadExistsMask)
1150: {
1151: threadID = srcRecord.hfsFile.fileID;
1152: break;
1153: }
1154: /* fall through if no thread... */
1155:
1156: default:
1157: threadID = 0;
1158: }
1159:
1160: if (threadID)
1161: {
1162: UInt32 threadHint;
1163: CatalogKey threadKey; // 518 bytes
1164: CatalogRecord threadRecord; // 520 bytes
1165: UInt16 threadSize;
1166:
1167: result = LocateCatalogRecord(volume, threadID, NULL, kNoHint, &threadKey, &threadRecord, &threadHint);
1168: if (result != noErr) goto Exit_Delete;
1169:
1170: if (isHFSPlus)
1171: {
1172: if (srcParentID != dstParentID)
1173: threadRecord.hfsPlusThread.parentID = dstParentID;
1174: if (isNewName)
1175: CopyCatalogName((CatalogName *)&dstKey.hfsPlus.nodeName, (CatalogName *) &threadRecord.hfsPlusThread.nodeName, isHFSPlus);
1176:
1177: threadSize = sizeof(threadRecord.hfsPlusThread);
1178: // HFS Plus has varaible sized threads so adjust to actual length
1179: threadSize -= ( sizeof(threadRecord.hfsPlusThread.nodeName.unicode) - (threadRecord.hfsPlusThread.nodeName.length * sizeof(UniChar)) );
1180: }
1181: else
1182: {
1183: if (srcParentID != dstParentID)
1184: threadRecord.hfsThread.parentID = dstParentID;
1185: if (isNewName)
1186: CopyCatalogName((CatalogName *)&dstKey.hfs.nodeName,(CatalogName *) threadRecord.hfsThread.nodeName, isHFSPlus);
1187:
1188: threadSize = sizeof(threadRecord.hfsThread);
1189: }
1190:
1191: result = DeleteBTreeRecord(volume->catalogRefNum, &threadKey);
1192: if (result != noErr) goto Exit_Delete;
1193:
1194: result = InsertBTreeRecord(volume->catalogRefNum, &threadKey, &threadRecord, threadSize, &threadHint);
1195: if (result != noErr) goto Exit_Delete; //XXX exiting with a missing thread!
1196: }
1197:
1198: //--- we successfully added the new node so delete the old source CNode record
1199:
1200: if (! isOrigDeleted) {
1201: result = DeleteBTreeRecord(volume->catalogRefNum, &srcKey);
1202: if (result)
1203: {
1204: // uh oh, we could not delete the original
1205: // so we better get rid of the new node...
1206:
1207: (void) DeleteBTreeRecord(volume->catalogRefNum, &dstKey);
1208:
1209: //XXX also need to fix up the thread...
1210:
1211: return result;
1212: }
1213: }
1214:
1215: if (srcParentID != dstParentID)
1216: {
1217: result = UpdateFolderCount(volume, srcParentID, NULL, srcRecord.recordType, kNoHint, -1);
1218: result = UpdateFolderCount(volume, dstFolderParentID, dstFolderNamePtr, srcRecord.recordType, dstFolderHint, +1);
1219: }
1220:
1221: //--- make sure changes get flushed out
1222: VCB_LOCK(volume);
1223: volume->vcbFlags |= 0xFF00; // Mark the VCB dirty
1224: volume->vcbLsMod = GetTimeLocal(!isHFSPlus); // update last modified date
1225: VCB_UNLOCK(volume);
1226:
1227: (void) FlushCatalog(volume);
1228:
1229: return result;
1230:
1231:
1232: Exit_Delete:
1233: (void) DeleteBTreeRecord(volume->catalogRefNum, &dstKey);
1234:
1235: return result;
1236:
1237: } // end MoveRenameCatalogNode
1238:
1239:
1240: //_________________________________________________________________________________
1241: // Routine: UpdateCatalogNode
1242: //
1243: // Function: Marks the Catalog BTree node identified by the given catalog hint
1244: // as 'dirty'.
1245: //
1246: //_________________________________________________________________________________
1247:
1248:
1249: OSErr
1250: UpdateCatalogNode(ExtendedVCB *volume, HFSCatalogNodeID parentID, ConstUTF8Param name,
1251: UInt32 catalogHint, const CatalogNodeData *nodeData)
1252: {
1253: CatalogKey *key;
1254: CatalogRecord *record;
1255: UInt32 hint;
1256: UInt16 recordSize;
1257: OSErr result;
1258: TextEncoding textEncoding;
1259: CatalogKey catalogKey; // 518 bytes
1260: CatalogRecord catalogRecord; // 520 bytes
1261: Boolean isHFSPlus = volume->vcbSigWord == kHFSPlusSigWord;
1262:
1263: /* XXX no reason to have ptrs to local variables... */
1264: key = &catalogKey;
1265: record = &catalogRecord;
1266:
1267: result = BuildCatalogKeyUTF8(parentID, name, isHFSPlus, key, &textEncoding);
1268: ReturnIfError(result);
1269:
1270: //--- locate subject catalog node
1271:
1272: result = LocateCatalogNodeByKey(volume, catalogHint, key, record, &hint);
1273:
1274: // if we did not find it by name, then look for an embedded file ID in a mangled name
1275: if ( (result == cmNotFound) && isHFSPlus )
1276: result = LocateCatalogNodeByMangledName(volume, parentID, name, key, record, &hint);
1277:
1278: if (result == btNotFound)
1279: result = cmNotFound;
1280:
1281: if (catalogHint != hint)
1282: PRINTIT(("UpdateCatalogNode: catalogHint does not match (in: %ld, out: %ld)\n", catalogHint, hint));
1283: ReturnIfError(result);
1284:
1285: // update user modifiable fields in the catalog node record...
1286:
1287: switch (record->recordType)
1288: {
1289: case kHFSFolderRecord:
1290: {
1291: #if DEBUG_BUILD
1292: if (nodeData->nodeType != kCatalogFolderNode)
1293: DebugStr("\p UpdateCatalogNode: folder/file mismatch!");
1294: #endif
1295:
1296: record->hfsFolder.createDate = nodeData->createDate;
1297: record->hfsFolder.modifyDate = nodeData->contentModDate;
1298: record->hfsFolder.backupDate = nodeData->backupDate;
1299:
1300: *(DInfo*) &record->hfsFolder.userInfo = *(DInfo*) &nodeData->finderInfo;
1301: *(DXInfo*) &record->hfsFolder.finderInfo = *(DXInfo*) &nodeData->extFinderInfo;
1302:
1303: recordSize = sizeof(HFSCatalogFolder);
1304: break;
1305: }
1306:
1307: case kHFSFileRecord:
1308: {
1309: UInt32 i;
1310:
1311: #if DEBUG_BUILD
1312: if (nodeData->nodeType != kCatalogFileNode)
1313: DebugStr("\p UpdateCatalogNode: folder/file mismatch!");
1314: #endif
1315:
1316: record->hfsFile.flags = (UInt8) nodeData->nodeFlags;
1317: record->hfsFile.createDate = nodeData->createDate;
1318: record->hfsFile.modifyDate = nodeData->contentModDate;
1319: record->hfsFile.backupDate = nodeData->backupDate;
1320:
1321: record->hfsFile.dataLogicalSize = nodeData->dataLogicalSize;
1322: record->hfsFile.dataPhysicalSize = nodeData->dataPhysicalSize;
1323: record->hfsFile.rsrcLogicalSize = nodeData->rsrcLogicalSize;
1324: record->hfsFile.rsrcPhysicalSize = nodeData->rsrcPhysicalSize;
1325:
1326: *(FInfo*) &record->hfsFile.userInfo = *(FInfo*) &nodeData->finderInfo;
1327: *(FXInfo*) &record->hfsFile.finderInfo = *(FXInfo*) &nodeData->extFinderInfo;
1328:
1329: // copy extent info
1330: for (i = 0; i < kHFSExtentDensity; ++i)
1331: {
1332: record->hfsFile.dataExtents[i].startBlock = (UInt16) nodeData->dataExtents[i].startBlock;
1333: record->hfsFile.dataExtents[i].blockCount = (UInt16) nodeData->dataExtents[i].blockCount;
1334:
1335: record->hfsFile.rsrcExtents[i].startBlock = (UInt16) nodeData->rsrcExtents[i].startBlock;
1336: record->hfsFile.rsrcExtents[i].blockCount = (UInt16) nodeData->rsrcExtents[i].blockCount;
1337: }
1338:
1339: recordSize = sizeof(HFSCatalogFile);
1340: break;
1341: }
1342:
1343: case kHFSPlusFolderRecord:
1344: {
1345: record->hfsPlusFolder.createDate = LocalToUTC(nodeData->createDate);
1346: record->hfsPlusFolder.contentModDate = LocalToUTC(nodeData->contentModDate);
1347: record->hfsPlusFolder.backupDate = LocalToUTC(nodeData->backupDate);
1348: #if TARGET_OS_RHAPSODY
1349: record->hfsPlusFolder.accessDate = LocalToUTC(nodeData->accessDate);
1350: record->hfsPlusFolder.attributeModDate = LocalToUTC(nodeData->attributeModDate);
1351: record->hfsPlusFolder.permissions = nodeData->permissions;
1352: #endif
1353:
1354: BlockMoveData(&nodeData->finderInfo, &record->hfsPlusFolder.userInfo, 32); // copy all of finder data
1355:
1356: recordSize = sizeof(HFSPlusCatalogFolder);
1357: break;
1358: }
1359:
1360: case kHFSPlusFileRecord:
1361: {
1362: record->hfsPlusFile.flags = nodeData->nodeFlags;
1363: record->hfsPlusFile.createDate = LocalToUTC(nodeData->createDate);
1364: record->hfsPlusFile.contentModDate = LocalToUTC(nodeData->contentModDate);
1365: record->hfsPlusFile.backupDate = LocalToUTC(nodeData->backupDate);
1366: #if TARGET_OS_RHAPSODY
1367: record->hfsPlusFile.accessDate = LocalToUTC(nodeData->accessDate);
1368: record->hfsPlusFile.attributeModDate = LocalToUTC(nodeData->attributeModDate);
1369: record->hfsPlusFile.permissions = nodeData->permissions;
1370: #endif
1371:
1372: record->hfsPlusFile.dataFork.logicalSize.lo = nodeData->dataLogicalSize;
1373: record->hfsPlusFile.dataFork.totalBlocks = nodeData->dataPhysicalSize / volume->blockSize;
1374: BlockMoveData(&nodeData->dataExtents, &record->hfsPlusFile.dataFork.extents, sizeof(HFSPlusExtentRecord));
1375:
1376: record->hfsPlusFile.resourceFork.logicalSize.lo = nodeData->rsrcLogicalSize;
1377: record->hfsPlusFile.resourceFork.totalBlocks = nodeData->rsrcPhysicalSize / volume->blockSize;
1378: BlockMoveData(&nodeData->rsrcExtents, &record->hfsPlusFile.resourceFork.extents, sizeof(HFSPlusExtentRecord));
1379:
1380: BlockMoveData(&nodeData->finderInfo, &record->hfsPlusFile.userInfo, 32); // copy all of 32 bytes of Finder data
1381:
1382: recordSize = sizeof(HFSPlusCatalogFile);
1383: break;
1384: }
1385:
1386: default:
1387: return cmNotFound;
1388: }
1389:
1390: result = ReplaceBTreeRecord(volume->catalogRefNum, key, catalogHint, record, recordSize, &hint);
1391:
1392: if ( result == btNotFound )
1393: {
1394: result = cmNotFound;
1395: }
1396: else if ( result == noErr )
1397: {
1398: /* if we're just updating the accessDate then no need to change volume mod date */
1399: if (nodeData->contentModDate > volume->vcbLsMod ||
1400: (isHFSPlus && nodeData->attributeModDate > volume->vcbLsMod))
1401: {
1402: VCB_LOCK(volume);
1403: volume->vcbFlags |= 0xFF00; // Mark the VCB dirty
1404: volume->vcbLsMod = GetTimeLocal(!isHFSPlus); // update last modified date
1405: VCB_UNLOCK(volume);
1406: }
1407:
1408: result = FlushCatalog(volume); // flush the catalog
1409: }
1410:
1411: return result;
1412: }
1413:
1414:
1415: //_________________________________________________________________________________
1416: // Routine: CreateFileIDRef
1417: //
1418: // Function: Creates a file thread record for hfs file node
1419: //
1420: //_________________________________________________________________________________
1421:
1422: OSErr
1423: CreateFileIDRef(ExtendedVCB *volume, HFSCatalogNodeID parentID, ConstUTF8Param name, UInt32 hint, HFSCatalogNodeID *threadID)
1424: {
1425: CatalogKey nodeKey; // 518 bytes
1426: CatalogRecord nodeData; // 520 bytes
1427: HFSCatalogKey threadKey;
1428: HFSCatalogThread threadData;
1429: UInt32 nodeHint;
1430: UInt32 tempHint;
1431: OSErr result;
1432: Boolean isHFSPlus = (volume->vcbSigWord == kHFSPlusSigWord);
1433: UInt32 textEncoding;
1434:
1435: *threadID = 0;
1436:
1437: result = BuildCatalogKeyUTF8(parentID, name, isHFSPlus, &nodeKey, &textEncoding);
1438: ReturnIfError(result);
1439:
1440: //--- locate subject catalog node
1441:
1442: result = LocateCatalogNodeByKey(volume, hint, &nodeKey, &nodeData, &nodeHint);
1443:
1444: // if we did not find it by name, then look for an embedded file ID in a mangled name
1445: if ( (result == cmNotFound) && isHFSPlus )
1446: result = LocateCatalogNodeByMangledName(volume, parentID, name, &nodeKey, &nodeData, &nodeHint);
1447: ReturnIfError(result);
1448:
1449: if (nodeData.recordType == kHFSPlusFileRecord)
1450: {
1451: *threadID = nodeData.hfsPlusFile.fileID;
1452: return noErr; // already have one
1453: }
1454:
1455: if (nodeData.recordType != kHFSFileRecord)
1456: {
1457: return notAFileErr;
1458: }
1459:
1460:
1461: if (nodeData.hfsFile.flags & kHFSThreadExistsMask)
1462: {
1463: *threadID = nodeData.hfsFile.fileID;
1464: return noErr; // already have one
1465: }
1466:
1467: result = VolumeWritable( volume );
1468: if ( result != noErr ) return result;
1469:
1470: //
1471: // need to insert a thread record
1472: //
1473: BuildCatalogKey(nodeData.hfsFile.fileID, NULL, false, (CatalogKey *)&threadKey);
1474:
1475: ClearMemory(&threadData, sizeof(HFSCatalogThread));
1476: threadData.recordType = kHFSFileThreadRecord;
1477: threadData.parentID = nodeKey.hfs.parentID;
1478: BlockMoveData(&nodeKey.hfs.nodeName, &threadData.nodeName, nodeKey.hfs.nodeName[0] + 1);
1479:
1480: result = InsertBTreeRecord(volume->catalogRefNum, &threadKey, &threadData, sizeof(HFSCatalogThread), &tempHint);
1481: if (result == btExists) result = noErr; //XXX could return cmExists or fidExists
1482: ReturnIfError(result);
1483:
1484: //
1485: // Finally, set the flag in the file record to say this file has a thread record.
1486: //
1487: nodeData.hfsFile.flags |= kHFSThreadExistsMask;
1488: result = ReplaceBTreeRecord(volume->catalogRefNum, &nodeKey, nodeHint, &nodeData, sizeof(HFSCatalogFile), &nodeHint );
1489:
1490: if (result == noErr) {
1491: (void) FlushCatalog(volume);
1492: *threadID = nodeData.hfsFile.fileID;
1493: }
1494:
1495: return result;
1496: }
1497:
1498:
1499: //_________________________________________________________________________________
1500: // Routine: CompareCatalogKeys
1501: //
1502: // Function: Compares two catalog keys (a search key and a trial key).
1503: //
1504: // Result: +n search key > trial key
1505: // 0 search key = trial key
1506: // -n search key < trial key
1507: //_________________________________________________________________________________
1508:
1509: SInt32
1510: CompareCatalogKeys(HFSCatalogKey *searchKey, HFSCatalogKey *trialKey)
1511: {
1512: HFSCatalogNodeID searchParentID, trialParentID;
1513: SInt32 result;
1514:
1515: searchParentID = searchKey->parentID;
1516: trialParentID = trialKey->parentID;
1517:
1518: if ( searchParentID > trialParentID ) // parent dirID is unsigned
1519: result = 1;
1520: else if ( searchParentID < trialParentID )
1521: result = -1;
1522: else // parent dirID's are equal, compare names
1523: {
1524: #if ( ! FORDISKFIRSTAID )
1525: LogStartTime(kTraceRelString);
1526:
1527: result = FastRelString(searchKey->nodeName, trialKey->nodeName);
1528:
1529: LogEndTime(kTraceRelString, noErr);
1530: #else
1531: result = (SInt32) RelString_Glue(searchKey->nodeName, trialKey->nodeName);
1532: #endif
1533: }
1534:
1535: return result;
1536: }
1537:
1538:
1539: //_________________________________________________________________________________
1540: // Routine: CompareExtendedCatalogKeys
1541: //
1542: // Function: Compares two large catalog keys (a search key and a trial key).
1543: //
1544: // Result: +n search key > trial key
1545: // 0 search key = trial key
1546: // -n search key < trial key
1547: //_________________________________________________________________________________
1548:
1549: SInt32
1550: CompareExtendedCatalogKeys(HFSPlusCatalogKey *searchKey, HFSPlusCatalogKey *trialKey)
1551: {
1552: SInt32 result;
1553: HFSCatalogNodeID searchParentID, trialParentID;
1554:
1555: searchParentID = searchKey->parentID;
1556: trialParentID = trialKey->parentID;
1557:
1558: if ( searchParentID > trialParentID ) // parent node IDs are unsigned
1559: {
1560: result = 1;
1561: }
1562: else if ( searchParentID < trialParentID )
1563: {
1564: result = -1;
1565: }
1566: else // parent node ID's are equal, compare names
1567: {
1568: if ( searchKey->nodeName.length == 0 || trialKey->nodeName.length == 0 )
1569: result = searchKey->nodeName.length - trialKey->nodeName.length;
1570: else
1571: result = FastUnicodeCompare(&searchKey->nodeName.unicode[0], searchKey->nodeName.length,
1572: &trialKey->nodeName.unicode[0], trialKey->nodeName.length);
1573: }
1574:
1575: return result;
1576: }
1577:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.