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