bsd/hfs/hfs_endian.c

   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 /*
  24  * hfs_endian.c
  25  *
  26  * This file implements endian swapping routines for the HFS/HFS Plus
  27  * volume format.
  28  */
  29
  30 #include <architecture/byte_order.h>
  31
  32 #include "hfs_endian.h"
  33 #include "hfs_dbg.h"
  34
  35 #undef ENDIAN_DEBUG
  36
  37 /* Private swapping routines */
  38 int hfs_swap_HFSPlusBTInternalNode (BlockDescriptor *src, HFSCatalogNodeID fileID, int unswap);
  39 int hfs_swap_HFSBTInternalNode (BlockDescriptor *src, HFSCatalogNodeID fileID, int unswap);
  40
  41 /*
  42  * hfs_swap_HFSPlusForkData
  43  *
  44  *  There's still a few spots where we still need to swap the fork data.
  45  */
  46 void
  47 hfs_swap_HFSPlusForkData (
  48     HFSPlusForkData *src
  49 )
  50 {
  51     int i;
  52
  53         src->logicalSize                = SWAP_BE64 (src->logicalSize);
  54
  55         src->clumpSize                  = SWAP_BE32 (src->clumpSize);
  56         src->totalBlocks                = SWAP_BE32 (src->totalBlocks);
  57
  58     for (i = 0; i < kHFSPlusExtentDensity; i++) {
  59         src->extents[i].startBlock      = SWAP_BE32 (src->extents[i].startBlock);
  60         src->extents[i].blockCount      = SWAP_BE32 (src->extents[i].blockCount);
  61     }
  62 }
  63
  64 /*
  65  * hfs_swap_BTNode
  66  *
  67  *  NOTE: This operation is not naturally symmetric.
  68  *        We have to determine which way we're swapping things.
  69  */
  70 int
  71 hfs_swap_BTNode (
  72     BlockDescriptor *src,
  73     int isHFSPlus,
  74     HFSCatalogNodeID fileID,
  75     int unswap
  76 )
  77 {
  78     BTNodeDescriptor *srcDesc = src->buffer;
  79     UInt16 *srcOffs = NULL;
  80
  81     UInt32 i;
  82     int error = 0;
  83
  84
  85 #ifdef ENDIAN_DEBUG
  86     if (unswap == 0) {
  87         printf ("BE -> LE Swap\n");
  88     } else if (unswap == 1) {
  89         printf ("LE -> BE Swap\n");
  90     } else if (unswap == 3) {
  91         printf ("Not swapping descriptors\n");
  92     } else {
  93         panic ("%s This is impossible", "hfs_swap_BTNode:");
  94     }
  95 #endif
  96
  97     /* If we are doing a swap */
  98     if (unswap == 0) {
  99         /* Swap the node descriptor */
 100         srcDesc->fLink          = SWAP_BE32 (srcDesc->fLink);
 101         srcDesc->bLink          = SWAP_BE32 (srcDesc->bLink);
 102
 103         /* Don't swap srcDesc->kind */
 104         /* Don't swap srcDesc->height */
 105         /* Don't swap srcDesc->reserved */
 106
 107         srcDesc->numRecords     = SWAP_BE16 (srcDesc->numRecords);
 108
 109         /* Swap the node offsets (including the free space one!) */
 110         srcOffs = (UInt16 *)((char *)src->buffer + (src->blockSize - ((srcDesc->numRecords + 1) * sizeof (UInt16))));
 111
 112         /* Sanity check */
 113         if ((char *)srcOffs > ((char *)src->buffer + src->blockSize)) {
 114             panic ("%s Too many records in the B-Tree node", "hfs_swap_BTNode:");
 115         }
 116
 117         for (i = 0; i < srcDesc->numRecords + 1; i++) {
 118             srcOffs[i]  = SWAP_BE16 (srcOffs[i]);
 119
 120             /* Sanity check */
 121             if (srcOffs[i] >= src->blockSize) {
 122                 panic ("%s B-Tree node offset out of range", "hfs_swap_BTNode:");
 123             }
 124         }
 125     }
 126
 127     /* Swap the records (ordered by frequency of access) */
 128     /* Swap a B-Tree internal node */
 129     if ((srcDesc->kind == kBTIndexNode) ||
 130         (srcDesc-> kind == kBTLeafNode)) {
 131
 132         if (isHFSPlus) {
 133             error = hfs_swap_HFSPlusBTInternalNode (src, fileID, unswap);
 134         } else {
 135             error = hfs_swap_HFSBTInternalNode (src, fileID, unswap);
 136         }
 137
 138     /* Swap a B-Tree map node */
 139     } else if (srcDesc-> kind == kBTMapNode) {
 140         /* Don't swap the bitmaps, they'll be done in the bitmap routines */
 141
 142     /* Swap a B-Tree header node */
 143     } else if (srcDesc-> kind == kBTHeaderNode) {
 144         /* The header's offset is hard-wired because we cannot trust the offset pointers */
 145         BTHeaderRec *srcHead = (BTHeaderRec *)((char *)src->buffer + 14);
 146
 147         srcHead->treeDepth              =       SWAP_BE16 (srcHead->treeDepth);
 148
 149         srcHead->rootNode               =       SWAP_BE32 (srcHead->rootNode);
 150         srcHead->leafRecords    =       SWAP_BE32 (srcHead->leafRecords);
 151         srcHead->firstLeafNode  =       SWAP_BE32 (srcHead->firstLeafNode);
 152         srcHead->lastLeafNode   =       SWAP_BE32 (srcHead->lastLeafNode);
 153
 154         srcHead->nodeSize               =       SWAP_BE16 (srcHead->nodeSize);
 155         srcHead->maxKeyLength   =       SWAP_BE16 (srcHead->maxKeyLength);
 156
 157         srcHead->totalNodes             =       SWAP_BE32 (srcHead->totalNodes);
 158         srcHead->freeNodes              =       SWAP_BE32 (srcHead->freeNodes);
 159
 160         srcHead->clumpSize              =       SWAP_BE32 (srcHead->clumpSize);
 161         srcHead->attributes             =       SWAP_BE32 (srcHead->attributes);
 162
 163         /* Don't swap srcHead->reserved1 */
 164         /* Don't swap srcHead->btreeType */
 165         /* Don't swap srcHead->reserved2 */
 166         /* Don't swap srcHead->reserved3 */
 167         /* Don't swap bitmap */
 168     }
 169
 170     /* If we are doing an unswap */
 171     if (unswap == 1) {
 172         /* Swap the node descriptor */
 173         srcDesc->fLink          = SWAP_BE32 (srcDesc->fLink);
 174         srcDesc->bLink          = SWAP_BE32 (srcDesc->bLink);
 175
 176         /* Don't swap srcDesc->kind */
 177         /* Don't swap srcDesc->height */
 178         /* Don't swap srcDesc->reserved */
 179
 180         /* Swap the node offsets (including the free space one!) */
 181         srcOffs = (UInt16 *)((char *)src->buffer + (src->blockSize - ((srcDesc->numRecords + 1) * sizeof (UInt16))));
 182
 183         /* Sanity check */
 184         if ((char *)srcOffs > ((char *)src->buffer + src->blockSize)) {
 185             panic ("%s Too many records in the B-Tree node", "hfs_swap_BTNode:");
 186         }
 187
 188         for (i = 0; i < srcDesc->numRecords + 1; i++) {
 189             /* Sanity check */
 190             if (srcOffs[i] >= src->blockSize) {
 191                 panic ("%s B-Tree node offset out of range", "hfs_swap_BTNode:");
 192             }
 193
 194             srcOffs[i]  = SWAP_BE16 (srcOffs[i]);
 195         }
 196
 197         srcDesc->numRecords     = SWAP_BE16 (srcDesc->numRecords);
 198     }
 199
 200     return (error);
 201 }
 202
 203 int
 204 hfs_swap_HFSPlusBTInternalNode (
 205     BlockDescriptor *src,
 206     HFSCatalogNodeID fileID,
 207     int unswap
 208 )
 209 {
 210     BTNodeDescriptor *srcDesc = src->buffer;
 211     UInt16 *srcOffs = (UInt16 *)((char *)src->buffer + (src->blockSize - (srcDesc->numRecords * sizeof (UInt16))));
 212
 213     UInt32 i;
 214     UInt32 j;
 215
 216     if (fileID == kHFSExtentsFileID) {
 217         HFSPlusExtentKey *srcKey;
 218         HFSPlusExtentDescriptor *srcRec;
 219
 220         for (i = 0; i < srcDesc->numRecords; i++) {
 221             srcKey = (HFSPlusExtentKey *)((char *)src->buffer + srcOffs[i]);
 222
 223             if (!unswap) srcKey->keyLength              = SWAP_BE16 (srcKey->keyLength);
 224             srcRec = (HFSPlusExtentDescriptor *)((char *)srcKey + srcKey->keyLength + 2);
 225             if (unswap) srcKey->keyLength               = SWAP_BE16 (srcKey->keyLength);
 226
 227             /* Don't swap srcKey->forkType */
 228             /* Don't swap srcKey->pad */
 229
 230             srcKey->fileID                      = SWAP_BE32 (srcKey->fileID);
 231             srcKey->startBlock          = SWAP_BE32 (srcKey->startBlock);
 232
 233             /* Stop if this is just an index node */
 234             if (srcDesc->kind == kBTIndexNode) {
 235                 *((UInt32 *)srcRec) = SWAP_BE32 (*((UInt32 *)srcRec));
 236                 continue;
 237             }
 238
 239             /* Swap the extent data */
 240
 241             /* Swap each extent */
 242             for (j = 0; j < kHFSPlusExtentDensity; j++) {
 243                 srcRec[j].startBlock    = SWAP_BE32 (srcRec[j].startBlock);
 244                 srcRec[j].blockCount    = SWAP_BE32 (srcRec[j].blockCount);
 245             }
 246         }
 247
 248     } else if (fileID == kHFSCatalogFileID) {
 249         HFSPlusCatalogKey *srcKey;
 250         SInt16 *srcPtr;
 251
 252         for (i = 0; i < srcDesc->numRecords; i++) {
 253             srcKey = (HFSPlusCatalogKey *)((char *)src->buffer + srcOffs[i]);
 254
 255             if (!unswap) srcKey->keyLength                      = SWAP_BE16 (srcKey->keyLength);
 256             srcPtr = (SInt16 *)((char *)srcKey + srcKey->keyLength + 2);
 257             if (unswap) srcKey->keyLength                       = SWAP_BE16 (srcKey->keyLength);
 258
 259             srcKey->parentID                                            = SWAP_BE32 (srcKey->parentID);
 260
 261             if (!unswap) srcKey->nodeName.length        = SWAP_BE16 (srcKey->nodeName.length);
 262             for (j = 0; j < srcKey->nodeName.length; j++) {
 263                 srcKey->nodeName.unicode[j]     = SWAP_BE16 (srcKey->nodeName.unicode[j]);
 264             }
 265             if (unswap) srcKey->nodeName.length = SWAP_BE16 (srcKey->nodeName.length);
 266
 267             /* Stop if this is just an index node */
 268             if (srcDesc->kind == kBTIndexNode) {
 269                 *((UInt32 *)srcPtr) = SWAP_BE32 (*((UInt32 *)srcPtr));
 270                 continue;
 271             }
 272
 273             /* Swap the recordType field, if unswapping, leave to later */
 274             if (!unswap) srcPtr[0] = SWAP_BE16 (srcPtr[0]);
 275
 276             if (srcPtr[0] == kHFSPlusFolderRecord) {
 277                 HFSPlusCatalogFolder *srcRec = (HFSPlusCatalogFolder *)srcPtr;
 278
 279                 srcRec->flags                           = SWAP_BE16 (srcRec->flags);
 280                 srcRec->valence                         = SWAP_BE32 (srcRec->valence);
 281                 srcRec->folderID                        = SWAP_BE32 (srcRec->folderID);
 282                 srcRec->createDate                      = SWAP_BE32 (srcRec->createDate);
 283                 srcRec->contentModDate          = SWAP_BE32 (srcRec->contentModDate);
 284                 srcRec->attributeModDate        = SWAP_BE32 (srcRec->attributeModDate);
 285                 srcRec->accessDate                      = SWAP_BE32 (srcRec->accessDate);
 286                 srcRec->backupDate                      = SWAP_BE32 (srcRec->backupDate);
 287
 288                 srcRec->bsdInfo.ownerID         = SWAP_BE32 (srcRec->bsdInfo.ownerID);
 289                 srcRec->bsdInfo.groupID         = SWAP_BE32 (srcRec->bsdInfo.groupID);
 290
 291                 /* Don't swap srcRec->bsdInfo.adminFlags */
 292                 /* Don't swap srcRec->bsdInfo.ownerFlags */
 293
 294                 srcRec->bsdInfo.fileMode                        = SWAP_BE16 (srcRec->bsdInfo.fileMode);
 295                 srcRec->bsdInfo.special.iNodeNum        = SWAP_BE32 (srcRec->bsdInfo.special.iNodeNum);
 296
 297                 srcRec->textEncoding            = SWAP_BE32 (srcRec->textEncoding);
 298
 299                 /* Don't swap srcRec->userInfo */
 300                 /* Don't swap srcRec->finderInfo */
 301                 /* Don't swap srcRec->reserved */
 302
 303             } else if (srcPtr[0] == kHFSPlusFileRecord) {
 304                 HFSPlusCatalogFile *srcRec = (HFSPlusCatalogFile *)srcPtr;
 305
 306                 srcRec->flags                           = SWAP_BE16 (srcRec->flags);
 307
 308                 srcRec->fileID                          = SWAP_BE32 (srcRec->fileID);
 309
 310                 srcRec->createDate                      = SWAP_BE32 (srcRec->createDate);
 311                 srcRec->contentModDate          = SWAP_BE32 (srcRec->contentModDate);
 312                 srcRec->attributeModDate        = SWAP_BE32 (srcRec->attributeModDate);
 313                 srcRec->accessDate                      = SWAP_BE32 (srcRec->accessDate);
 314                 srcRec->backupDate                      = SWAP_BE32 (srcRec->backupDate);
 315
 316                 srcRec->bsdInfo.ownerID         = SWAP_BE32 (srcRec->bsdInfo.ownerID);
 317                 srcRec->bsdInfo.groupID         = SWAP_BE32 (srcRec->bsdInfo.groupID);
 318
 319                 /* Don't swap srcRec->bsdInfo.adminFlags */
 320                 /* Don't swap srcRec->bsdInfo.ownerFlags */
 321
 322                 srcRec->bsdInfo.fileMode                        = SWAP_BE16 (srcRec->bsdInfo.fileMode);
 323                 srcRec->bsdInfo.special.iNodeNum        = SWAP_BE32 (srcRec->bsdInfo.special.iNodeNum);
 324
 325                 srcRec->textEncoding            = SWAP_BE32 (srcRec->textEncoding);
 326
 327                 /* Don't swap srcRec->reserved1 */
 328                 /* Don't swap srcRec->userInfo */
 329                 /* Don't swap srcRec->finderInfo */
 330                 /* Don't swap srcRec->reserved2 */
 331
 332                 hfs_swap_HFSPlusForkData (&srcRec->dataFork);
 333                 hfs_swap_HFSPlusForkData (&srcRec->resourceFork);
 334
 335             } else if ((srcPtr[0] == kHFSPlusFolderThreadRecord) ||
 336                        (srcPtr[0] == kHFSPlusFileThreadRecord)) {
 337
 338                 HFSPlusCatalogThread *srcRec = (HFSPlusCatalogThread *)srcPtr;
 339
 340                 /* Don't swap srcRec->reserved */
 341
 342                 srcRec->parentID                                                = SWAP_BE32 (srcRec->parentID);
 343
 344                 if (!unswap) srcRec->nodeName.length    = SWAP_BE16 (srcRec->nodeName.length);
 345                 for (j = 0; j < srcRec->nodeName.length; j++) {
 346                     srcRec->nodeName.unicode[j] = SWAP_BE16 (srcRec->nodeName.unicode[j]);
 347                 }
 348                 if (unswap) srcRec->nodeName.length             = SWAP_BE16 (srcRec->nodeName.length);
 349
 350             } else {
 351                 panic ("%s unrecognized catalog record type", "hfs_swap_BTNode:");
 352             }
 353
 354             /* If unswapping, we can safely unswap type field now */
 355             if (unswap) srcPtr[0] = SWAP_BE16 (srcPtr[0]);
 356         }
 357
 358     } else if (fileID == kHFSAttributesFileID) {
 359         HFSPlusAttrKey *srcKey;
 360         HFSPlusAttrRecord *srcRec;
 361
 362         for (i = 0; i < srcDesc->numRecords; i++) {
 363                 srcKey = (HFSPlusAttrKey *)((char *)src->buffer + srcOffs[i]);
 364
 365                 if (!unswap) srcKey->keyLength = SWAP_BE16(srcKey->keyLength);
 366                 srcRec = (HFSPlusAttrRecord *)((char *)srcKey + srcKey->keyLength + 2);
 367                 if (unswap) srcKey->keyLength = SWAP_BE16(srcKey->keyLength);
 368
 369                 srcKey->fileID = SWAP_BE32(srcKey->fileID);
 370                 srcKey->startBlock = SWAP_BE32(srcKey->startBlock);
 371
 372                 if (!unswap) srcKey->attrNameLen = SWAP_BE16(srcKey->attrNameLen);
 373                 for (j = 0; j < srcKey->attrNameLen; j++)
 374                         srcKey->attrName[j] = SWAP_BE16(srcKey->attrName[j]);
 375                 if (unswap) srcKey->attrNameLen = SWAP_BE16(srcKey->attrNameLen);
 376
 377                 /* If this is an index node, just swap the child node number */
 378             if (srcDesc->kind == kBTIndexNode) {
 379                 *((UInt32 *)srcRec) = SWAP_BE32 (*((UInt32 *)srcRec));
 380                 continue;
 381             }
 382
 383             /* Swap the data record */
 384             if (!unswap) srcRec->recordType = SWAP_BE32(srcRec->recordType);
 385             switch (srcRec->recordType) {
 386                 case kHFSPlusAttrInlineData:
 387                         /* We're not swapping the reserved fields */
 388                         srcRec->attrData.attrSize = SWAP_BE32(srcRec->attrData.attrSize);
 389                         /* Not swapping the attrData */
 390                         break;
 391                 case kHFSPlusAttrForkData:
 392                         /* We're not swapping the reserved field */
 393                         hfs_swap_HFSPlusForkData(&srcRec->forkData.theFork);
 394                         break;
 395                 case kHFSPlusAttrExtents:
 396                         /* We're not swapping the reserved field */
 397                         for (j = 0; j < kHFSPlusExtentDensity; j++) {
 398                                 srcRec->overflowExtents.extents[j].startBlock =
 399                                         SWAP_BE32(srcRec->overflowExtents.extents[j].startBlock);
 400                                 srcRec->overflowExtents.extents[j].blockCount =
 401                                         SWAP_BE32(srcRec->overflowExtents.extents[j].blockCount);
 402                         }
 403                         break;
 404             }
 405             if (unswap) srcRec->recordType = SWAP_BE32(srcRec->recordType);
 406         }
 407     } else if (fileID > kHFSFirstUserCatalogNodeID) {
 408                 HotFileKey *srcKey;
 409                 UInt32 *srcRec;
 410
 411                 for (i = 0; i < srcDesc->numRecords; i++) {
 412                         srcKey = (HotFileKey *)((char *)src->buffer + srcOffs[i]);
 413
 414                         if (!unswap)
 415                                 srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);
 416                         srcRec = (u_int32_t *)((char *)srcKey + srcKey->keyLength + 2);
 417                         if (unswap)
 418                                 srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);
 419
 420                         /* Don't swap srcKey->forkType */
 421                         /* Don't swap srcKey->pad */
 422
 423                         srcKey->temperature = SWAP_BE32 (srcKey->temperature);
 424                         srcKey->fileID = SWAP_BE32 (srcKey->fileID);
 425
 426                         *((UInt32 *)srcRec) = SWAP_BE32 (*((UInt32 *)srcRec));
 427                 }
 428     } else {
 429         panic ("%s unrecognized B-Tree type", "hfs_swap_BTNode:");
 430     }
 431
 432
 433     return (0);
 434 }
 435
 436 int
 437 hfs_swap_HFSBTInternalNode (
 438     BlockDescriptor *src,
 439     HFSCatalogNodeID fileID,
 440     int unswap
 441 )
 442 {
 443     BTNodeDescriptor *srcDesc = src->buffer;
 444     UInt16 *srcOffs = (UInt16 *)((char *)src->buffer + (src->blockSize - (srcDesc->numRecords * sizeof (UInt16))));
 445
 446     UInt32 i;
 447     UInt32 j;
 448
 449     if (fileID == kHFSExtentsFileID) {
 450         HFSExtentKey *srcKey;
 451         HFSExtentDescriptor *srcRec;
 452
 453         for (i = 0; i < srcDesc->numRecords; i++) {
 454             srcKey = (HFSExtentKey *)((char *)src->buffer + srcOffs[i]);
 455
 456             /* Don't swap srcKey->keyLength */
 457             /* Don't swap srcKey->forkType */
 458
 459             srcKey->fileID                      = SWAP_BE32 (srcKey->fileID);
 460             srcKey->startBlock          = SWAP_BE16 (srcKey->startBlock);
 461
 462             /* Point to record data (round up to even byte boundary) */
 463             srcRec = (HFSExtentDescriptor *)((char *)srcKey + ((srcKey->keyLength + 2) & ~1));
 464
 465             /* Stop if this is just an index node */
 466             if (srcDesc->kind == kBTIndexNode) {
 467                 *((UInt32 *)srcRec) = SWAP_BE32 (*((UInt32 *)srcRec));
 468                 continue;
 469             }
 470
 471             /* Swap each extent */
 472             for (j = 0; j < kHFSExtentDensity; j++) {
 473                 srcRec[j].startBlock    = SWAP_BE16 (srcRec[j].startBlock);
 474                 srcRec[j].blockCount    = SWAP_BE16 (srcRec[j].blockCount);
 475             }
 476         }
 477
 478     } else if (fileID == kHFSCatalogFileID) {
 479         HFSCatalogKey *srcKey;
 480         SInt16 *srcPtr;
 481
 482         for (i = 0; i < srcDesc->numRecords; i++) {
 483             srcKey = (HFSCatalogKey *)((char *)src->buffer + srcOffs[i]);
 484
 485             /* Don't swap srcKey->keyLength */
 486             /* Don't swap srcKey->reserved */
 487
 488             srcKey->parentID                    = SWAP_BE32 (srcKey->parentID);
 489
 490             /* Don't swap srcKey->nodeName */
 491
 492             /* Point to record data (round up to even byte boundary) */
 493             srcPtr = (SInt16 *)((char *)srcKey + ((srcKey->keyLength + 2) & ~1));
 494
 495             /* Stop if this is just an index node */
 496             if (srcDesc->kind == kBTIndexNode) {
 497                 *((UInt32 *)srcPtr) = SWAP_BE32 (*((UInt32 *)srcPtr));
 498                 continue;
 499             }
 500
 501             /* Swap the recordType field, if unswapping, leave to later */
 502             if (!unswap) srcPtr[0] = SWAP_BE16 (srcPtr[0]);
 503
 504             if (srcPtr[0] == kHFSFolderRecord) {
 505                 HFSCatalogFolder *srcRec = (HFSCatalogFolder *)srcPtr;
 506
 507                 srcRec->flags                           = SWAP_BE16 (srcRec->flags);
 508                 srcRec->valence                         = SWAP_BE16 (srcRec->valence);
 509
 510                 srcRec->folderID                        = SWAP_BE32 (srcRec->folderID);
 511                 srcRec->createDate                      = SWAP_BE32 (srcRec->createDate);
 512                 srcRec->modifyDate                      = SWAP_BE32 (srcRec->modifyDate);
 513                 srcRec->backupDate                      = SWAP_BE32 (srcRec->backupDate);
 514
 515                 /* Don't swap srcRec->userInfo */
 516                 /* Don't swap srcRec->finderInfo */
 517                 /* Don't swap resserved array */
 518
 519             } else if (srcPtr[0] == kHFSFileRecord) {
 520                 HFSCatalogFile *srcRec = (HFSCatalogFile *)srcPtr;
 521
 522                 srcRec->flags                           = srcRec->flags;
 523                 srcRec->fileType                        = srcRec->fileType;
 524
 525                 /* Don't swap srcRec->userInfo */
 526
 527                 srcRec->fileID                          = SWAP_BE32 (srcRec->fileID);
 528
 529                 srcRec->dataStartBlock          = SWAP_BE16 (srcRec->dataStartBlock);
 530                 srcRec->dataLogicalSize         = SWAP_BE32 (srcRec->dataLogicalSize);
 531                 srcRec->dataPhysicalSize        = SWAP_BE32 (srcRec->dataPhysicalSize);
 532
 533                 srcRec->rsrcStartBlock          = SWAP_BE16 (srcRec->rsrcStartBlock);
 534                 srcRec->rsrcLogicalSize         = SWAP_BE32 (srcRec->rsrcLogicalSize);
 535                 srcRec->rsrcPhysicalSize        = SWAP_BE32 (srcRec->rsrcPhysicalSize);
 536
 537                 srcRec->createDate                      = SWAP_BE32 (srcRec->createDate);
 538                 srcRec->modifyDate                      = SWAP_BE32 (srcRec->modifyDate);
 539                 srcRec->backupDate                      = SWAP_BE32 (srcRec->backupDate);
 540
 541                 /* Don't swap srcRec->finderInfo */
 542
 543                 srcRec->clumpSize                       = SWAP_BE16 (srcRec->clumpSize);
 544
 545                 /* Swap the two sets of extents as an array of six (three each) UInt16 */
 546                 for (j = 0; j < kHFSExtentDensity * 2; j++) {
 547                     srcRec->dataExtents[j].startBlock   = SWAP_BE16 (srcRec->dataExtents[j].startBlock);
 548                     srcRec->dataExtents[j].blockCount   = SWAP_BE16 (srcRec->dataExtents[j].blockCount);
 549                 }
 550
 551                 /* Don't swap srcRec->reserved */
 552
 553             } else if ((srcPtr[0] == kHFSFolderThreadRecord) ||
 554                     (srcPtr[0] == kHFSFileThreadRecord)) {
 555
 556                 HFSCatalogThread *srcRec = (HFSCatalogThread *)srcPtr;
 557
 558                 /* Don't swap srcRec->reserved array */
 559
 560                 srcRec->parentID                        = SWAP_BE32 (srcRec->parentID);
 561
 562                 /* Don't swap srcRec->nodeName */
 563
 564             } else {
 565                 panic ("%s unrecognized catalog record type", "hfs_swap_BTNode:");
 566             }
 567
 568             /* If unswapping, we can safely swap type now */
 569             if (unswap) srcPtr[0] = SWAP_BE16 (srcPtr[0]);
 570         }
 571
 572     } else {
 573         panic ("%s unrecognized B-Tree type", "hfs_swap_BTNode:");
 574     }
 575
 576     return (0);
 577 }