![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to CatalogUtilities.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 CatalogUtilities.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: CatalogUtilities.c ! 27: ! 28: Contains: Private Catalog Manager support routines. ! 29: ! 30: Version: HFS Plus 1.0 ! 31: ! 32: Copyright: � 1997-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: (DSH) Deric Horn ! 45: (msd) Mark Day ! 46: (djb) Don Brady ! 47: ! 48: Change History (most recent first): ! 49: <Rhap> 1/8/99 djb Fixing LocateCatalogNodeByMangledName... ! 50: <Rhap> 1/7/99 djb In BuildCatalogKeyUTF8 check name length against NAME_MAX. ! 51: <Rhap> 12/7/98 djb Add ExtractTextEncoding routine to get text encodings. ! 52: <Rhap> 11/20/98 djb Add support for UTF-8 names. ! 53: <Rhap> 8/31/98 djb GetTimeLocal now takes an input. ! 54: <Rhap> 4/17/98 djb Add VCB locking. ! 55: <Rhap> 4/3/98 djb Removed last name conversion cache from LocateCatalogNodeWithRetry. ! 56: <Rhap> 4/2/98 djb InvalidateCatalogNodeCache and TrashCatalogNodeCache are not used in Rhapsody. ! 57: <Rhap> 03/31/98 djb Sync up with final HFSVolumes.h header file. ! 58: ! 59: <CS24> 1/29/98 DSH Add TrashCatalogNodeCache for TrashAllFSCaches API support. ! 60: <CS23> 12/15/97 djb Radar #2202860, In LocateCatalogNodeByMangledName remap ! 61: cmParentNotFound error code to cmNotFound. ! 62: <CS22> 12/10/97 DSH 2201501, Pin the leof and peof to multiple of allocation blocks ! 63: under 2 Gig. ! 64: <CS21> 12/9/97 DSH 2201501, Pin returned leof values to 2^31-1 (SInt32), instead of ! 65: 2^32-1 ! 66: <CS20> 11/26/97 djb Radar #2005688, 2005461 - need to handle kTextMalformedInputErr. ! 67: <CS19> 11/25/97 djb Radar #2002357 (again) fix new bug introduced in <CS18>. ! 68: <CS18> 11/17/97 djb PrepareInputName routine now returns an error. ! 69: <CS17> 10/19/97 msd Bug 1684586. GetCatInfo and SetCatInfo use only contentModDate. ! 70: <CS16> 10/17/97 djb Add ConvertInputNameToUnicode for Catalog Create/Rename. ! 71: <CS15> 10/14/97 djb Fix LocateCatalogNode's MakeFSSpec optimization (radar #1683166) ! 72: <CS14> 10/13/97 djb Copy text encoding in CopyCatalogNodeData. Fix cut/paste error ! 73: in VolumeHasEncodings macro. When accessing encoding bitmap use ! 74: the MapEncodingToIndex and MapIndexToEncoding macros. ! 75: <CS13> 10/1/97 djb Remove old Catalog Iterator code... ! 76: <CS12> 9/8/97 msd Make sure a folder's modifyDate is set whenever its ! 77: contentModDate is set. ! 78: <CS11> 9/4/97 djb Add MakeFSSpec optimization. ! 79: <CS10> 9/4/97 msd In CatalogNodeData, change attributeModDate to modifyDate. ! 80: <CS9> 8/26/97 djb Back out <CS4> (UpdateFolderCount must maintain vcbNmFls for HFS ! 81: Plus volumes too). ! 82: <CS8> 8/14/97 djb Remove hard link support. ! 83: <CS7> 7/18/97 msd Include LowMemPriv.h. ! 84: <CS6> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name ! 85: collision ! 86: <CS5> 7/8/97 DSH Loading PrecompiledHeaders from define passed in on C line ! 87: <CS4> 6/27/97 msd UpdateFolderCount should update number of root files/folders for ! 88: HFS volumes, not HFS Plus. ! 89: <CS3> 6/24/97 djb LocateCatalogNodeWithRetry did not always set result code. ! 90: <CS2> 6/24/97 djb Add LocateCatalogNodeByMangledName routine ! 91: <CS1> 6/24/97 djb first checked in ! 92: */ ! 93: ! 94: #if ( PRAGMA_LOAD_SUPPORTED ) ! 95: #pragma load PrecompiledHeaders ! 96: #else ! 97: #if TARGET_OS_MAC ! 98: #include <Errors.h> ! 99: #include <Files.h> ! 100: #include <FSM.h> ! 101: #include <Memory.h> ! 102: #include <TextUtils.h> ! 103: #include <Types.h> ! 104: #include <LowMemPriv.h> ! 105: #else ! 106: #include "../headers/system/MacOSStubs.h" ! 107: #include <sys/syslimits.h> ! 108: #endif /* TARGET_OS_MAC */ ! 109: #endif /* PRAGMA_LOAD_SUPPORTED */ ! 110: ! 111: ! 112: #include "../headers/FileMgrInternal.h" ! 113: #include "../headers/BTreesInternal.h" ! 114: #include "../headers/HFSVolumes.h" ! 115: #include "../headers/system/HFSUnicodeWrappers.h" ! 116: #include "../headers/CatalogPrivate.h" ! 117: #include <string.h> ! 118: ! 119: static void ExtractTextEncoding (ItemCount length, ConstUniCharArrayPtr string, UInt32 * textEncoding); ! 120: ! 121: //������������������������������������������������������������������������������� ! 122: // Routine: LocateCatalogNode ! 123: // ! 124: // Function: Locates the catalog record for an existing folder or file ! 125: // CNode and returns pointers to the key and data records. ! 126: // ! 127: //������������������������������������������������������������������������������� ! 128: ! 129: OSErr ! 130: LocateCatalogNode(const ExtendedVCB *volume, HFSCatalogNodeID folderID, const CatalogName *name, ! 131: UInt32 hint, CatalogKey *keyPtr, CatalogRecord *dataPtr, UInt32 *newHint) ! 132: { ! 133: OSErr result; ! 134: CatalogName *nodeName = NULL; /* To ward off uninitialized use warnings from compiler */ ! 135: HFSCatalogNodeID threadParentID; ! 136: ! 137: ! 138: result = LocateCatalogRecord(volume, folderID, name, hint, keyPtr, dataPtr, newHint); ! 139: ! 140: #if TARGET_OS_MAC ! 141: // ! 142: // MakeFSSpec Optimization...report a missing parent ! 143: // ! 144: if ( (result == cmNotFound) && (LMGetHFSFlags() & (1 << reportMissingParent)) ) ! 145: { ! 146: HFSCatalogNodeID parentID; ! 147: UInt16 dataSize; ! 148: OSErr err; ! 149: Boolean isHFSPlus = (volume->vcbSigWord == kHFSPlusSigWord); ! 150: ! 151: result = cmParentNotFound; // assume directory is missing ! 152: ! 153: if ( (name != NULL) && (CatalogNameLength(name, isHFSPlus) > 0) ) ! 154: { ! 155: // Look at the previous record's parent ID to determine if the ! 156: // parent of the CNode we were looking for actually exists ! 157: ! 158: err = GetBTreeRecord(volume->catalogRefNum, -1, keyPtr, dataPtr, &dataSize, newHint); ! 159: if (err == noErr) ! 160: { ! 161: if ( isHFSPlus ) ! 162: parentID = keyPtr->hfsPlus.parentID; ! 163: else ! 164: parentID = keyPtr->hfs.parentID; ! 165: ! 166: if ( folderID == parentID ) // did parent exists? ! 167: result = cmNotFound; // yes, so report a missing file to MakeFSSpec ! 168: } ! 169: } ! 170: } ! 171: #endif /* TARGET_OS_MAC */ ! 172: ! 173: ReturnIfError(result); ! 174: ! 175: // if we got a thread record, then go look up real record ! 176: switch ( dataPtr->recordType ) ! 177: { ! 178: case kHFSFileThreadRecord: ! 179: case kHFSFolderThreadRecord: ! 180: threadParentID = dataPtr->hfsThread.parentID; ! 181: nodeName = (CatalogName *) &dataPtr->hfsThread.nodeName; ! 182: break; ! 183: ! 184: case kHFSPlusFileThreadRecord: ! 185: case kHFSPlusFolderThreadRecord: ! 186: threadParentID = dataPtr->hfsPlusThread.parentID; ! 187: nodeName = (CatalogName *) &dataPtr->hfsPlusThread.nodeName; ! 188: break; ! 189: ! 190: default: ! 191: threadParentID = 0; ! 192: break; ! 193: } ! 194: ! 195: if ( threadParentID ) // found a thread ! 196: result = LocateCatalogRecord(volume, threadParentID, nodeName, kNoHint, keyPtr, dataPtr, newHint); ! 197: ! 198: return result; ! 199: } ! 200: ! 201: // ! 202: // Routine: LocateCatalogNodeByKey ! 203: // ! 204: // Function: Locates the catalog record for an existing folder or file ! 205: // CNode and returns the key and data records. ! 206: // ! 207: ! 208: OSErr ! 209: LocateCatalogNodeByKey(const ExtendedVCB *volume, UInt32 hint, CatalogKey *keyPtr, ! 210: CatalogRecord *dataPtr, UInt32 *newHint) ! 211: { ! 212: OSErr result; ! 213: CatalogName *nodeName = NULL; /* To ward off uninitialized use warnings from compiler */ ! 214: HFSCatalogNodeID threadParentID; ! 215: UInt16 tempSize; ! 216: ! 217: ! 218: result = SearchBTreeRecord(volume->catalogRefNum, keyPtr, hint, keyPtr, ! 219: dataPtr, &tempSize, newHint); ! 220: if (result == btNotFound) ! 221: result = cmNotFound; ! 222: ReturnIfError(result); ! 223: ! 224: // if we got a thread record, then go look up real record ! 225: switch ( dataPtr->recordType ) ! 226: { ! 227: case kHFSFileThreadRecord: ! 228: case kHFSFolderThreadRecord: ! 229: threadParentID = dataPtr->hfsThread.parentID; ! 230: nodeName = (CatalogName *) &dataPtr->hfsThread.nodeName; ! 231: break; ! 232: ! 233: case kHFSPlusFileThreadRecord: ! 234: case kHFSPlusFolderThreadRecord: ! 235: threadParentID = dataPtr->hfsPlusThread.parentID; ! 236: nodeName = (CatalogName *) &dataPtr->hfsPlusThread.nodeName; ! 237: break; ! 238: ! 239: default: ! 240: threadParentID = 0; ! 241: break; ! 242: } ! 243: ! 244: if ( threadParentID ) // found a thread ! 245: result = LocateCatalogRecord(volume, threadParentID, nodeName, kNoHint, keyPtr, dataPtr, newHint); ! 246: ! 247: return result; ! 248: } ! 249: ! 250: ! 251: #if 0 ! 252: //������������������������������������������������������������������������������� ! 253: // Routine: LocateCatalogNodeWithRetry ! 254: // ! 255: // Function: Locates the catalog record for an existing folder or file node. ! 256: // For HFS Plus volumes a retry is performed when a catalog node is ! 257: // not found and the volume contains more than one text encoding. ! 258: // ! 259: //������������������������������������������������������������������������������� ! 260: ! 261: #define VolumeHasEncodings(v) \ ! 262: ( ((v)->encodingsBitmap.lo | (v)->encodingsBitmap.hi) != 0 ) ! 263: ! 264: #define EncodingInstalled(i) \ ! 265: ( (fsVars)->gConversionContext[(i)].toUnicode != 0 ) ! 266: ! 267: #define EncodingUsedByVolume(v,i) \ ! 268: ( i < 32 ? ((v)->encodingsBitmap.lo & (1 << (i))) : ((v)->encodingsBitmap.hi & (1 << (i-32))) ) ! 269: ! 270: ! 271: OSErr ! 272: LocateCatalogNodeWithRetry (const ExtendedVCB *volume, HFSCatalogNodeID folderID, ConstStr31Param pascalName, CatalogName *unicodeName, ! 273: UInt32 hint, CatalogKey *keyPtr, CatalogRecord *dataPtr, UInt32 *newHint) ! 274: { ! 275: TextEncoding defaultEncoding; ! 276: TextEncoding encoding; ! 277: ItemCount encodingsToTry; ! 278: FSVarsRec *fsVars; ! 279: OSErr result = cmNotFound; ! 280: ! 281: fsVars = (FSVarsRec*) LMGetFSMVars(); // used by macros ! 282: ! 283: defaultEncoding = GetDefaultTextEncoding(); ! 284: encodingsToTry = CountInstalledEncodings(); ! 285: ! 286: // 1. Try finding file using default encoding (typical case) ! 287: ! 288: { ! 289: --encodingsToTry; ! 290: result = PrepareInputName(pascalName, true, defaultEncoding, unicodeName); ! 291: if (result == noErr) ! 292: result = LocateCatalogNode(volume, folderID, unicodeName, hint, keyPtr, dataPtr, newHint); ! 293: else ! 294: result = cmNotFound; ! 295: ! 296: if ( result != cmNotFound || encodingsToTry == 0) ! 297: return result; ! 298: } ! 299: ! 300: // ! 301: // XXX if the pascal string contains all 7-bit ascii then we don't need to do anymore retries ! 302: // ! 303: ! 304: // 2. Try finding file using Mac Roman (if not already tried above) ! 305: ! 306: if ( defaultEncoding != kTextEncodingMacRoman ) ! 307: { ! 308: --encodingsToTry; ! 309: result = PrepareInputName(pascalName, true, kTextEncodingMacRoman, unicodeName); ! 310: if (result == noErr) ! 311: result = LocateCatalogNode(volume, folderID, unicodeName, hint, keyPtr, dataPtr, newHint); ! 312: else ! 313: result = cmNotFound; ! 314: ! 315: if ( result != cmNotFound || encodingsToTry == 0 ) ! 316: return result; ! 317: } ! 318: ! 319: // 3. Try with encodings from disk (if any) ! 320: ! 321: if ( VolumeHasEncodings(volume) ) // any left to try? ! 322: { ! 323: UInt32 index; ! 324: ! 325: index = 0; // since we pre increment this will skip MacRoman (which was already tried above) ! 326: ! 327: while ( index < kMacBaseEncodingCount ) ! 328: { ! 329: ++index; ! 330: ! 331: encoding = MapIndexToEncoding(index); ! 332: ! 333: if ( encoding == defaultEncoding ) ! 334: continue; // we did this one already ! 335: ! 336: if ( EncodingInstalled(index) && EncodingUsedByVolume(volume, index) ) ! 337: { ! 338: --encodingsToTry; ! 339: result = PrepareInputName(pascalName, true, encoding, unicodeName); ! 340: if (result == noErr) ! 341: result = LocateCatalogNode(volume, folderID, unicodeName, hint, keyPtr, dataPtr, newHint); ! 342: else ! 343: result = cmNotFound; ! 344: ! 345: if ( result != cmNotFound || encodingsToTry == 0 ) ! 346: return result; ! 347: } ! 348: } ! 349: } ! 350: ! 351: // 4. Try any remaining encodings (if any) ! 352: ! 353: { ! 354: UInt32 index; ! 355: ! 356: index = 0; // since we pre increment this will skip MacRoman (which was already tried above) ! 357: ! 358: while ( (encodingsToTry > 0) && (index < kMacBaseEncodingCount) ) ! 359: { ! 360: ++index; ! 361: ! 362: encoding = MapIndexToEncoding(index); ! 363: ! 364: if ( encoding == defaultEncoding ) ! 365: continue; // we did this one already ! 366: ! 367: if ( EncodingInstalled(index) && EncodingUsedByVolume(volume, index) == false ) ! 368: { ! 369: --encodingsToTry; ! 370: result = PrepareInputName(pascalName, true, encoding, unicodeName); ! 371: if (result == noErr) ! 372: result = LocateCatalogNode(volume, folderID, unicodeName, hint, keyPtr, dataPtr, newHint); ! 373: else ! 374: result = cmNotFound; ! 375: ! 376: if ( result != cmNotFound || encodingsToTry == 0 ) ! 377: return result; ! 378: } ! 379: } ! 380: } ! 381: ! 382: return cmNotFound; ! 383: } ! 384: #endif ! 385: ! 386: //������������������������������������������������������������������������������� ! 387: // Routine: LocateCatalogNodeByMangledName ! 388: // ! 389: // Function: Locates the catalog record associated with a mangled name (if any) ! 390: // ! 391: //������������������������������������������������������������������������������� ! 392: ! 393: OSErr ! 394: LocateCatalogNodeByMangledName( const ExtendedVCB *volume, HFSCatalogNodeID folderID, ! 395: const unsigned char * name, CatalogKey *keyPtr, ! 396: CatalogRecord *dataPtr, UInt32 *hintPtr ) ! 397: { ! 398: HFSCatalogNodeID fileID; ! 399: unsigned char nodeName[64]; ! 400: OSErr result; ! 401: ByteCount actualDstLen; ! 402: ByteCount prefixlen; ! 403: ! 404: ! 405: if (name == NULL || name[0] == '\0') ! 406: return cmNotFound; ! 407: ! 408: fileID = GetEmbeddedFileID(name, &prefixlen); ! 409: ! 410: if ( fileID < kHFSFirstUserCatalogNodeID ) ! 411: return cmNotFound; ! 412: ! 413: result = LocateCatalogNode(volume, fileID, NULL, kNoHint, keyPtr, dataPtr, hintPtr); ! 414: if ( result == cmParentNotFound ) // GetCatalogNode already handled cmParentNotFound case <CS23> ! 415: result = cmNotFound; // so remap <CS23> ! 416: ReturnIfError(result); ! 417: ! 418: // first make sure that the parents match ! 419: if ( folderID != keyPtr->hfsPlus.parentID ) ! 420: return cmNotFound; // not the same folder so this is a false match ! 421: ! 422: result = ConvertUnicodeToUTF8( keyPtr->hfsPlus.nodeName.length * sizeof (UniChar), ! 423: keyPtr->hfsPlus.nodeName.unicode, ! 424: 64, ! 425: &actualDstLen, ! 426: nodeName); ! 427: ! 428: if ( (actualDstLen < prefixlen) || bcmp(nodeName, name, prefixlen) != 0) ! 429: return cmNotFound; // mangled names didn't match so this is a false match ! 430: ! 431: return noErr; // we found it ! 432: } ! 433: ! 434: ! 435: //������������������������������������������������������������������������������� ! 436: // Routine: LocateCatalogRecord ! 437: // ! 438: // Function: Locates the catalog record associated with folderID and name ! 439: // ! 440: //������������������������������������������������������������������������������� ! 441: ! 442: OSErr ! 443: LocateCatalogRecord(const ExtendedVCB *volume, HFSCatalogNodeID folderID, const CatalogName *name, ! 444: UInt32 hint, CatalogKey *keyPtr, CatalogRecord *dataPtr, UInt32 *newHint) ! 445: { ! 446: OSErr result; ! 447: CatalogKey tempKey; // 518 bytes ! 448: UInt16 tempSize; ! 449: ! 450: BuildCatalogKey(folderID, name, (volume->vcbSigWord == kHFSPlusSigWord), &tempKey); ! 451: ! 452: if ( name == NULL ) ! 453: hint = kNoHint; // no CName given so clear the hint ! 454: ! 455: result = SearchBTreeRecord(volume->catalogRefNum, &tempKey, hint, keyPtr, dataPtr, &tempSize, newHint); ! 456: ! 457: return (result == btNotFound ? cmNotFound : result); ! 458: } ! 459: ! 460: ! 461: //������������������������������������������������������������������������������� ! 462: // Routine: LocateCatalogThread ! 463: // ! 464: // Function: Locates a catalog thread record in the catalog BTree file and ! 465: // returns a pointer to the data record. ! 466: // ! 467: //������������������������������������������������������������������������������� ! 468: ! 469: OSErr ! 470: LocateCatalogThread(const ExtendedVCB *volume, HFSCatalogNodeID nodeID, CatalogRecord *threadData, UInt16 *threadSize, UInt32 *threadHint) ! 471: { ! 472: CatalogKey threadKey; // 518 bytes ! 473: OSErr result; ! 474: ! 475: //--- build key record ! 476: ! 477: BuildCatalogKey(nodeID, NULL, (volume->vcbSigWord == kHFSPlusSigWord), &threadKey); ! 478: ! 479: //--- locate thread record in BTree ! 480: ! 481: result = SearchBTreeRecord( volume->catalogRefNum, &threadKey, kNoHint, &threadKey, ! 482: threadData, threadSize, threadHint); ! 483: ! 484: return (result == btNotFound ? cmNotFound : result); ! 485: } ! 486: ! 487: ! 488: /* ! 489: * Routine: BuildCatalogKey ! 490: * ! 491: * Function: Constructs a catalog key record (ckr) given the parent ! 492: * folder ID and CName. Works for both classic and extended ! 493: * HFS volumes. ! 494: * ! 495: */ ! 496: ! 497: void ! 498: BuildCatalogKey(HFSCatalogNodeID parentID, const CatalogName *cName, Boolean isHFSPlus, CatalogKey *key) ! 499: { ! 500: if ( isHFSPlus ) ! 501: { ! 502: key->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength; // initial key length (4 + 2) ! 503: key->hfsPlus.parentID = parentID; // set parent ID ! 504: key->hfsPlus.nodeName.length = 0; // null CName length ! 505: if ( cName != NULL ) ! 506: { ! 507: CopyCatalogName(cName, (CatalogName *) &key->hfsPlus.nodeName, isHFSPlus); ! 508: key->hfsPlus.keyLength += sizeof(UniChar) * cName->ustr.length; // add CName size to key length ! 509: } ! 510: } ! 511: else ! 512: { ! 513: key->hfs.keyLength = kHFSCatalogKeyMinimumLength; // initial key length (1 + 4 + 1) ! 514: key->hfs.reserved = 0; // clear unused byte ! 515: key->hfs.parentID = parentID; // set parent ID ! 516: key->hfs.nodeName[0] = 0; // null CName length ! 517: if ( cName != NULL ) ! 518: { ! 519: UpdateCatalogName(cName->pstr, key->hfs.nodeName); ! 520: key->hfs.keyLength += key->hfs.nodeName[0]; // add CName size to key length ! 521: } ! 522: } ! 523: } ! 524: ! 525: /* ! 526: * for HFS, only MacRoman is supported. If a non-MacRoman character is found, an error is returned ! 527: */ ! 528: OSErr ! 529: BuildCatalogKeyUTF8(HFSCatalogNodeID parentID, const char *name, ! 530: Boolean isHFSPlus, CatalogKey *key, UInt32 *textEncoding) ! 531: { ! 532: OSErr err = 0; ! 533: UInt32 nameLength; ! 534: ! 535: if ( name != NULL ) ! 536: nameLength = strlen(name); ! 537: else ! 538: nameLength = 0; ! 539: ! 540: if (nameLength > NAME_MAX) ! 541: err = bdNamErr; /* name is too long */ ! 542: ! 543: if ( isHFSPlus ) { ! 544: ByteCount unicodeBytes = 0; ! 545: ! 546: key->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength; // initial key length (4 + 2) ! 547: key->hfsPlus.parentID = parentID; // set parent ID ! 548: key->hfsPlus.nodeName.length = 0; // null CName length ! 549: if ( nameLength > 0 ) { ! 550: err = ConvertUTF8ToUnicode(nameLength, name, sizeof(key->hfsPlus.nodeName.unicode), ! 551: &unicodeBytes, key->hfsPlus.nodeName.unicode); ! 552: key->hfsPlus.nodeName.length = unicodeBytes / sizeof(UniChar); ! 553: key->hfsPlus.keyLength += unicodeBytes; ! 554: } ! 555: ! 556: ExtractTextEncoding(key->hfsPlus.nodeName.length, key->hfsPlus.nodeName.unicode, textEncoding); ! 557: } ! 558: else { ! 559: key->hfs.keyLength = kHFSCatalogKeyMinimumLength; // initial key length (1 + 4 + 1) ! 560: key->hfs.reserved = 0; // clear unused byte ! 561: key->hfs.parentID = parentID; // set parent ID ! 562: key->hfs.nodeName[0] = 0; // null CName length ! 563: if ( nameLength > 0 ) { ! 564: err = ConvertUTF8ToMacRoman(nameLength, name, &key->hfs.nodeName[0]); ! 565: key->hfs.keyLength += key->hfs.nodeName[0]; // add CName size to key length ! 566: } ! 567: *textEncoding = 0; ! 568: } ! 569: ! 570: if (err) { ! 571: if (err == kTECOutputBufferFullStatus) ! 572: err = bdNamErr; /* name is too long */ ! 573: else ! 574: err = paramErr; /* name has invalid characters */ ! 575: } ! 576: ! 577: return err; ! 578: } ! 579: ! 580: ! 581: /* ! 582: * make a guess at the text encoding value that coresponds to the Unicode characters ! 583: */ ! 584: static void ! 585: ExtractTextEncoding(ItemCount length, ConstUniCharArrayPtr string, UInt32 * textEncoding) ! 586: { ! 587: int i; ! 588: UniChar ch; ! 589: ! 590: *textEncoding = 0; ! 591: ! 592: for (i = 0; i < length; ++i) { ! 593: ch = string[i]; ! 594: /* CJK codepoints are 0x3000 thru 0x9FFF */ ! 595: if (ch >= 0x3000) { ! 596: if (ch < 0xa000) { ! 597: *textEncoding = kTextEncodingMacJapanese; ! 598: break; ! 599: } ! 600: ! 601: /* fullwidth character codepoints are 0xFF00 thru 0xFFEF */ ! 602: if (ch >= 0xff00 && ch <= 0xffef) { ! 603: *textEncoding = kTextEncodingMacJapanese; ! 604: break; ! 605: } ! 606: } ! 607: } ! 608: } ! 609: ! 610: ! 611: //������������������������������������������������������������������������������� ! 612: // Routine: FlushCatalog ! 613: // ! 614: // Function: Flushes the catalog for a specified volume. ! 615: // ! 616: //������������������������������������������������������������������������������� ! 617: ! 618: OSErr ! 619: FlushCatalog(ExtendedVCB *volume) ! 620: { ! 621: FCB * fcb; ! 622: OSErr result; ! 623: ! 624: fcb = GetFileControlBlock(volume->catalogRefNum); ! 625: result = BTFlushPath(fcb); ! 626: ! 627: if (result == noErr) ! 628: { ! 629: //--- check if catalog's fcb is dirty... ! 630: ! 631: if ( fcb->fcbFlags & fcbModifiedMask ) ! 632: { ! 633: VCB_LOCK(volume); ! 634: volume->vcbFlags |= 0xFF00; // Mark the VCB dirty ! 635: volume->vcbLsMod = GetTimeLocal(volume->vcbSigWord == kHFSSigWord); // update last modified date ! 636: VCB_UNLOCK(volume); ! 637: ! 638: result = FlushVolumeControlBlock(volume); ! 639: } ! 640: } ! 641: ! 642: return result; ! 643: } ! 644: ! 645: ! 646: //������������������������������������������������������������������������������� ! 647: // Routine: InvalidateCatalogNodeCache ! 648: // ! 649: // Function: Invalidates the Catalog node cache if volume and folderID match ! 650: // ! 651: //������������������������������������������������������������������������������� ! 652: #if TARGET_OS_MAC ! 653: void ! 654: InvalidateCatalogNodeCache(ExtendedVCB *volume, HFSCatalogNodeID parentID) ! 655: { ! 656: FSVarsRec *fsVars; ! 657: ! 658: fsVars = (FSVarsRec*) LMGetFSMVars(); ! 659: ! 660: if ( (fsVars->gCatalogFSSpec.parID == parentID) && (volume->vcbVRefNum == fsVars->gCatalogFSSpec.vRefNum) ) ! 661: { ! 662: fsVars->gCatalogFSSpec.parID = 0; ! 663: fsVars->gCatalogFSSpec.vRefNum = 0; ! 664: } ! 665: } ! 666: #endif ! 667: ! 668: //������������������������������������������������������������������������������� ! 669: // Routine: TrashCatalogNodeCache ! 670: // ! 671: // Function: Invalidates the Catalog node cache. ! 672: // ! 673: //������������������������������������������������������������������������������� ! 674: #if TARGET_OS_MAC ! 675: void ! 676: TrashCatalogNodeCache( void ) ! 677: { ! 678: FSVarsRec *fsVars = (FSVarsRec*) LMGetFSMVars(); ! 679: ! 680: fsVars->gCatalogFSSpec.parID = 0; ! 681: fsVars->gCatalogFSSpec.vRefNum = 0; ! 682: } ! 683: #endif ! 684: ! 685: ! 686: //������������������������������������������������������������������������������� ! 687: // Routine: UpdateCatalogName ! 688: // ! 689: // Function: Updates a CName. ! 690: // ! 691: //������������������������������������������������������������������������������� ! 692: ! 693: void ! 694: UpdateCatalogName(ConstStr31Param srcName, Str31 destName) ! 695: { ! 696: Size length = srcName[0]; ! 697: ! 698: if (length > CMMaxCName) ! 699: length = CMMaxCName; // truncate to max ! 700: ! 701: destName[0] = length; // set length byte ! 702: ! 703: BlockMoveData(&srcName[1], &destName[1], length); ! 704: } ! 705: ! 706: ! 707: //������������������������������������������������������������������������������� ! 708: // Routine: AdjustVolumeCounts ! 709: // ! 710: // Function: Adjusts the folder and file counts in the VCB ! 711: // ! 712: //������������������������������������������������������������������������������� ! 713: ! 714: void ! 715: AdjustVolumeCounts(ExtendedVCB *volume, SInt16 type, SInt16 delta) ! 716: { ! 717: //�� also update extended VCB fields... ! 718: ! 719: VCB_LOCK(volume); ! 720: ! 721: if (type == kHFSFolderRecord || type == kHFSPlusFolderRecord) ! 722: volume->vcbDirCnt += delta; // adjust volume folder count, �� worry about overflow? ! 723: else ! 724: volume->vcbFilCnt += delta; // adjust volume file count ! 725: ! 726: volume->vcbFlags |= 0xFF00; // Mark the VCB dirty ! 727: volume->vcbLsMod = GetTimeLocal(volume->vcbSigWord == kHFSSigWord); // update last modified date ! 728: ! 729: VCB_UNLOCK(volume); ! 730: } ! 731: ! 732: ! 733: //������������������������������������������������������������������������������� ! 734: ! 735: void ! 736: UpdateVolumeEncodings(ExtendedVCB *volume, TextEncoding encoding) ! 737: { ! 738: UInt32 index; ! 739: ! 740: encoding &= 0x7F; ! 741: ! 742: index = MapEncodingToIndex(encoding); ! 743: ! 744: VCB_LOCK(volume); ! 745: ! 746: if ( index < 32 ) ! 747: volume->encodingsBitmap.lo |= (1 << index); ! 748: else ! 749: volume->encodingsBitmap.hi |= (1 << (index - 32)); ! 750: ! 751: VCB_UNLOCK(volume); ! 752: ! 753: // vcb should already be marked dirty ! 754: } ! 755: ! 756: ! 757: //������������������������������������������������������������������������������� ! 758: ! 759: OSErr ! 760: UpdateFolderCount( ExtendedVCB *volume, HFSCatalogNodeID parentID, const CatalogName *name, SInt16 newType, ! 761: UInt32 hint, SInt16 valenceDelta) ! 762: { ! 763: CatalogKey tempKey; // 518 bytes ! 764: CatalogRecord tempData; // 520 bytes ! 765: UInt32 tempHint; ! 766: HFSCatalogNodeID folderID; ! 767: UInt16 recordSize; ! 768: OSErr result; ! 769: ! 770: #if 0 ! 771: result = SearchBTreeRecord(volume->catalogRefNum, parentKey, hint, ! 772: &tempKey, &tempData, &recordSize, &tempHint); ! 773: if (result) ! 774: return (result == btNotFound ? cmNotFound : result); ! 775: #else ! 776: ! 777: result = LocateCatalogNode(volume, parentID, name, hint, &tempKey, &tempData, &tempHint); ! 778: ReturnIfError(result); ! 779: #endif ! 780: ! 781: if ( volume->vcbSigWord == kHFSPlusSigWord ) // HFS Plus ! 782: { ! 783: UInt32 timeStamp; ! 784: ! 785: if ( DEBUG_BUILD && tempData.recordType != kHFSPlusFolderRecord ) ! 786: DebugStr("\p UpdateFolder: found HFS folder on HFS+ volume!"); ! 787: ! 788: timeStamp = GetTimeUTC(); ! 789: tempData.hfsPlusFolder.valence += valenceDelta; // adjust valence ! 790: tempData.hfsPlusFolder.contentModDate = timeStamp; // set date/time last modified ! 791: folderID = tempData.hfsPlusFolder.folderID; ! 792: recordSize = sizeof(tempData.hfsPlusFolder); ! 793: } ! 794: else // classic HFS ! 795: { ! 796: if ( DEBUG_BUILD && tempData.recordType != kHFSFolderRecord ) ! 797: DebugStr("\p UpdateFolder: found HFS+ folder on HFS volume!"); ! 798: ! 799: tempData.hfsFolder.valence += valenceDelta; // adjust valence ! 800: tempData.hfsFolder.modifyDate = GetTimeLocal(true); // set date/time last modified ! 801: folderID = tempData.hfsFolder.folderID; ! 802: recordSize = sizeof(tempData.hfsFolder); ! 803: } ! 804: ! 805: result = ReplaceBTreeRecord(volume->catalogRefNum, &tempKey, tempHint, ! 806: &tempData, recordSize, &tempHint); ! 807: ReturnIfError(result); ! 808: ! 809: if ( folderID == kHFSRootFolderID ) ! 810: { ! 811: if (newType == kHFSFolderRecord || newType == kHFSPlusFolderRecord) ! 812: { ! 813: VCB_LOCK(volume); ! 814: volume->vcbNmRtDirs += valenceDelta; // adjust root folder count (undefined for HFS Plus) ! 815: VCB_UNLOCK(volume); ! 816: } ! 817: else ! 818: { ! 819: VCB_LOCK(volume); ! 820: volume->vcbNmFls += valenceDelta; // adjust root file count (used by GetVolInfo) ! 821: VCB_UNLOCK(volume); ! 822: } ! 823: } ! 824: ! 825: //XXX also update extended VCB fields... ! 826: ! 827: return result; ! 828: } ! 829: ! 830: ! 831: //������������������������������������������������������������������������������� ! 832: ! 833: UInt16 ! 834: GetCatalogRecordSize(const CatalogRecord *dataRecord) ! 835: { ! 836: switch (dataRecord->recordType) ! 837: { ! 838: case kHFSFileRecord: ! 839: return sizeof(HFSCatalogFile); ! 840: ! 841: case kHFSFolderRecord: ! 842: return sizeof(HFSCatalogFolder); ! 843: ! 844: case kHFSPlusFileRecord: ! 845: return sizeof(HFSPlusCatalogFile); ! 846: ! 847: case kHFSPlusFolderRecord: ! 848: return sizeof(HFSPlusCatalogFolder); ! 849: ! 850: case kHFSFolderThreadRecord: ! 851: case kHFSFileThreadRecord: ! 852: return sizeof(HFSCatalogThread); ! 853: ! 854: case kHFSPlusFolderThreadRecord: ! 855: case kHFSPlusFileThreadRecord: ! 856: return sizeof(HFSPlusCatalogThread); ! 857: ! 858: default: ! 859: return 0; ! 860: } ! 861: } ! 862: ! 863: ! 864: //������������������������������������������������������������������������������� ! 865: ! 866: void ! 867: CopyCatalogNodeData(const ExtendedVCB *volume, const CatalogRecord *dataPtr, CatalogNodeData *nodeData) ! 868: { ! 869: switch (dataPtr->recordType) ! 870: { ! 871: case kHFSFolderRecord: ! 872: { ! 873: nodeData->nodeType = kCatalogFolderNode; ! 874: nodeData->nodeFlags = dataPtr->hfsFolder.flags; ! 875: nodeData->nodeID = dataPtr->hfsFolder.folderID; ! 876: nodeData->createDate = dataPtr->hfsFolder.createDate; ! 877: nodeData->contentModDate = dataPtr->hfsFolder.modifyDate; ! 878: nodeData->backupDate = dataPtr->hfsFolder.backupDate; ! 879: nodeData->valence = dataPtr->hfsFolder.valence; ! 880: ! 881: BlockMoveData(&dataPtr->hfsFolder.userInfo, &nodeData->finderInfo, 32); // copy 32 bytes of finder data ! 882: break; ! 883: } ! 884: ! 885: case kHFSFileRecord: ! 886: { ! 887: UInt32 i; ! 888: ! 889: nodeData->nodeType = kCatalogFileNode; ! 890: nodeData->nodeFlags = dataPtr->hfsFile.flags; ! 891: nodeData->nodeID = dataPtr->hfsFile.fileID; ! 892: nodeData->createDate = dataPtr->hfsFile.createDate; ! 893: nodeData->contentModDate = dataPtr->hfsFile.modifyDate; ! 894: nodeData->backupDate = dataPtr->hfsFile.backupDate; ! 895: nodeData->valence = 0; ! 896: ! 897: BlockMoveData(&dataPtr->hfsFile.userInfo, &nodeData->finderInfo, 16); // copy finder data ! 898: BlockMoveData(&dataPtr->hfsFile.finderInfo, &nodeData->extFinderInfo, 16); // copy finder data ! 899: ! 900: nodeData->dataLogicalSize = dataPtr->hfsFile.dataLogicalSize; ! 901: nodeData->dataPhysicalSize = dataPtr->hfsFile.dataPhysicalSize; ! 902: nodeData->rsrcLogicalSize = dataPtr->hfsFile.rsrcLogicalSize; ! 903: nodeData->rsrcPhysicalSize = dataPtr->hfsFile.rsrcPhysicalSize; ! 904: ! 905: for (i = 0; i < kHFSExtentDensity; ++i) ! 906: { ! 907: nodeData->dataExtents[i].startBlock = (UInt32) (dataPtr->hfsFile.dataExtents[i].startBlock); ! 908: nodeData->dataExtents[i].blockCount = (UInt32) (dataPtr->hfsFile.dataExtents[i].blockCount); ! 909: ! 910: nodeData->rsrcExtents[i].startBlock = (UInt32) (dataPtr->hfsFile.rsrcExtents[i].startBlock); ! 911: nodeData->rsrcExtents[i].blockCount = (UInt32) (dataPtr->hfsFile.rsrcExtents[i].blockCount); ! 912: } ! 913: break; ! 914: } ! 915: ! 916: case kHFSPlusFolderRecord: ! 917: { ! 918: nodeData->nodeType = kCatalogFolderNode; ! 919: nodeData->nodeFlags = dataPtr->hfsPlusFolder.flags; ! 920: nodeData->nodeID = dataPtr->hfsPlusFolder.folderID; ! 921: nodeData->textEncoding = dataPtr->hfsPlusFolder.textEncoding; ! 922: nodeData->createDate = UTCToLocal(dataPtr->hfsPlusFolder.createDate); ! 923: nodeData->contentModDate = UTCToLocal(dataPtr->hfsPlusFolder.contentModDate); ! 924: nodeData->backupDate = UTCToLocal(dataPtr->hfsPlusFolder.backupDate); ! 925: if (dataPtr->hfsPlusFolder.valence > 0xffff) ! 926: nodeData->valence = 0xffff; // pass maximum 16-bit value ! 927: else ! 928: nodeData->valence = dataPtr->hfsPlusFolder.valence; ! 929: ! 930: BlockMoveData(&dataPtr->hfsPlusFolder.userInfo, &nodeData->finderInfo, 32); // copy finder data ! 931: #if TARGET_OS_RHAPSODY ! 932: nodeData->accessDate = UTCToLocal(dataPtr->hfsPlusFolder.accessDate); ! 933: nodeData->attributeModDate = UTCToLocal(dataPtr->hfsPlusFolder.attributeModDate); ! 934: nodeData->permissions = dataPtr->hfsPlusFolder.permissions; ! 935: #endif ! 936: break; ! 937: } ! 938: ! 939: case kHFSPlusFileRecord: ! 940: { ! 941: UInt32 largestFileSizeUnder2Gig; ! 942: ! 943: nodeData->nodeType = kCatalogFileNode; ! 944: nodeData->nodeFlags = dataPtr->hfsPlusFile.flags; ! 945: nodeData->nodeID = dataPtr->hfsPlusFile.fileID; ! 946: nodeData->textEncoding = dataPtr->hfsPlusFile.textEncoding; ! 947: nodeData->createDate = UTCToLocal(dataPtr->hfsPlusFile.createDate); ! 948: nodeData->contentModDate = UTCToLocal(dataPtr->hfsPlusFile.contentModDate); ! 949: nodeData->backupDate = UTCToLocal(dataPtr->hfsPlusFile.backupDate); ! 950: nodeData->valence = 0; ! 951: ! 952: BlockMoveData(&dataPtr->hfsPlusFile.userInfo, &nodeData->finderInfo, 32); // copy finder data ! 953: ! 954: // 2201501, Pin values to 2^31-1 (SInt32) ! 955: largestFileSizeUnder2Gig = (0x7FFFFFFF / volume->blockSize) * volume->blockSize; ! 956: ! 957: if ( (dataPtr->hfsPlusFile.dataFork.logicalSize.hi == 0) && (dataPtr->hfsPlusFile.dataFork.logicalSize.lo <= largestFileSizeUnder2Gig) ) ! 958: { ! 959: nodeData->dataLogicalSize = dataPtr->hfsPlusFile.dataFork.logicalSize.lo; ! 960: nodeData->dataPhysicalSize = (dataPtr->hfsPlusFile.dataFork.totalBlocks * volume->blockSize); ! 961: } ! 962: else ! 963: { ! 964: nodeData->dataPhysicalSize = largestFileSizeUnder2Gig; ! 965: nodeData->dataLogicalSize = nodeData->dataPhysicalSize; // signal to Open that this file is too big ! 966: nodeData->valence |= kLargeDataForkMask; // overload the valence for files over 2Gig ! 967: } ! 968: ! 969: if ( (dataPtr->hfsPlusFile.resourceFork.logicalSize.hi == 0) && (dataPtr->hfsPlusFile.resourceFork.logicalSize.lo <= largestFileSizeUnder2Gig) ) ! 970: { ! 971: nodeData->rsrcLogicalSize = dataPtr->hfsPlusFile.resourceFork.logicalSize.lo; ! 972: nodeData->rsrcPhysicalSize = (SInt32) ((SInt32)dataPtr->hfsPlusFile.resourceFork.totalBlocks * (SInt32)volume->blockSize); ! 973: } ! 974: else ! 975: { ! 976: nodeData->rsrcPhysicalSize = largestFileSizeUnder2Gig; ! 977: nodeData->rsrcLogicalSize = nodeData->rsrcPhysicalSize; // signal to Open that this file is too big ! 978: nodeData->valence |= kLargeRsrcForkMask; // overload the valence for files over 2Gig ! 979: } ! 980: ! 981: // copy data and rsrc extents ! 982: BlockMoveData(&dataPtr->hfsPlusFile.dataFork.extents, &nodeData->dataExtents, sizeof(HFSPlusExtentRecord)); ! 983: BlockMoveData(&dataPtr->hfsPlusFile.resourceFork.extents, &nodeData->rsrcExtents, sizeof(HFSPlusExtentRecord)); ! 984: #if TARGET_OS_RHAPSODY ! 985: nodeData->accessDate = UTCToLocal(dataPtr->hfsPlusFile.accessDate); ! 986: nodeData->attributeModDate = UTCToLocal(dataPtr->hfsPlusFile.attributeModDate); ! 987: nodeData->permissions = dataPtr->hfsPlusFile.permissions; ! 988: #endif ! 989: break; ! 990: } ! 991: ! 992: default: ! 993: nodeData->nodeType = '????'; // must have hit a thread record ! 994: } ! 995: } ! 996: ! 997: ! 998: //������������������������������������������������������������������������������� ! 999: #if 0 ! 1000: OSErr ! 1001: PrepareInputName(ConstStr31Param name, Boolean unicode, TextEncoding encoding, CatalogName *catalogName) ! 1002: { ! 1003: OSErr result = noErr; ! 1004: ! 1005: if (name == NULL) ! 1006: { ! 1007: catalogName->ustr.length = 0; // set length byte (works for both unicode and pascal) ! 1008: } ! 1009: else ! 1010: { ! 1011: Size length = name[0]; ! 1012: ! 1013: if (length > CMMaxCName) ! 1014: length = CMMaxCName; // truncate to max ! 1015: ! 1016: if ( length == 0 ) ! 1017: { ! 1018: catalogName->ustr.length = 0; ! 1019: } ! 1020: else if (unicode) ! 1021: { ! 1022: Str31 truncatedName; ! 1023: StringPtr pName; ! 1024: ! 1025: if (name[0] <= CMMaxCName) //�� should be CMMaxCName ! 1026: { ! 1027: pName = (StringPtr)name; ! 1028: } ! 1029: else ! 1030: { ! 1031: BlockMoveData(&name[1], &truncatedName[1], CMMaxCName); ! 1032: truncatedName[0] = CMMaxCName; ! 1033: pName = truncatedName; ! 1034: } ! 1035: ! 1036: //���need to pass pascal string length (could be clipped above) ! 1037: result = ConvertHFSNameToUnicode ( pName, encoding, &catalogName->ustr ); ! 1038: } ! 1039: else ! 1040: { ! 1041: BlockMoveData(&name[1], &catalogName->pstr[1], length); ! 1042: catalogName->pstr[0] = length; // set length byte (might be smaller than name[0] ! 1043: } ! 1044: } ! 1045: ! 1046: return result; ! 1047: } ! 1048: #endif ! 1049: ! 1050: //_______________________________________________________________________ ! 1051: ! 1052: #if 0 ! 1053: void ! 1054: ConvertInputNameToUnicode(ConstStr31Param name, TextEncoding encodingHint, TextEncoding *actualEncoding, CatalogName *catalogName) ! 1055: { ! 1056: Size length; ! 1057: OSErr result; ! 1058: ! 1059: catalogName->ustr.length = 0; // setup defaults... ! 1060: *actualEncoding = encodingHint; ! 1061: ! 1062: if (name == NULL) ! 1063: return; // catalogName is empty string ! 1064: ! 1065: length = name[0]; ! 1066: ! 1067: if (length == 0 || length > CMMaxCName) ! 1068: return; // catalogName is empty string ! 1069: ! 1070: result = ConvertHFSNameToUnicode ( name, encodingHint, &catalogName->ustr ); ! 1071: ! 1072: if (result != noErr) ! 1073: { ! 1074: // The converter didn't like our string, try again with roman encoding ! 1075: // This takes care of errors like: kTextMalformedInputErr ! 1076: // kTECPartialCharErr ! 1077: // kTECUnmappableElementErr ! 1078: // kTECIncompleteElementErr ! 1079: // ! 1080: if ( encodingHint != kTextEncodingMacRoman ) ! 1081: { ! 1082: *actualEncoding = kTextEncodingMacRoman; ! 1083: result = ConvertHFSNameToUnicode ( name, kTextEncodingMacRoman, &catalogName->ustr ); ! 1084: ! 1085: } ! 1086: ! 1087: if (DEBUG_BUILD && result != noErr) ! 1088: DebugStr("\p ConvertHFSNameToUnicode could not convert string!"); ! 1089: } ! 1090: } ! 1091: #endif ! 1092: ! 1093: //_______________________________________________________________________ ! 1094: ! 1095: void ! 1096: CopyCatalogName(const CatalogName *srcName, CatalogName *dstName, Boolean isHFSPLus) ! 1097: { ! 1098: UInt32 length; ! 1099: ! 1100: if ( srcName == NULL ) ! 1101: { ! 1102: if ( dstName != NULL ) ! 1103: dstName->ustr.length = 0; // set length byte to zero (works for both unicode and pascal) ! 1104: return; ! 1105: } ! 1106: ! 1107: if (isHFSPLus) ! 1108: length = sizeof(UniChar) * (srcName->ustr.length + 1); ! 1109: else ! 1110: length = sizeof(UInt8) + srcName->pstr[0]; ! 1111: ! 1112: if ( length > 1 ) ! 1113: BlockMoveData(srcName, dstName, length); ! 1114: else ! 1115: dstName->ustr.length = 0; // set length byte to zero (works for both unicode and pascal) ! 1116: } ! 1117: ! 1118: //_______________________________________________________________________ ! 1119: ! 1120: UInt32 ! 1121: CatalogNameLength(const CatalogName *name, Boolean isHFSPlus) ! 1122: { ! 1123: if (isHFSPlus) ! 1124: return name->ustr.length; ! 1125: else ! 1126: return name->pstr[0]; ! 1127: } ! 1128: ! 1129: ! 1130:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.