hfs_endian.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
    3  *
    4  * @APPLE_LICENSE_HEADER_START@
    5  * 
    6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
    7  * 
    8  * This file contains Original Code and/or Modifications of Original Code
    9  * as defined in and that are subject to the Apple Public Source License
   10  * Version 2.0 (the 'License'). You may not use this file except in
   11  * compliance with the License. Please obtain a copy of the License at
   12  * http://www.opensource.apple.com/apsl/ and read it before using this
   13  * file.
   14  * 
   15  * The Original Code and all software distributed under the License are
   16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
   17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
   18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
   19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
   20  * Please see the License for the specific language governing rights and
   21  * limitations under the License.
   22  * 
   23  * @APPLE_LICENSE_HEADER_END@
   24  */
   25 
   26 /*
   27  * hfs_endian.c
   28  *
   29  * This file implements endian swapping routines for the HFS/HFS Plus
   30  * volume format.
   31  */
   32 
   33 #include <architecture/byte_order.h>
   34 
   35 #include "hfs_endian.h"
   36 #include "hfs_dbg.h"
   37 
   38 #undef ENDIAN_DEBUG
   39 
   40 /* Private swapping routines */
   41 int hfs_swap_HFSPlusBTInternalNode (BlockDescriptor *src, HFSCatalogNodeID fileID, int unswap);
   42 int hfs_swap_HFSBTInternalNode (BlockDescriptor *src, HFSCatalogNodeID fileID, int unswap);
   43 
   44 /*
   45  * hfs_swap_HFSPlusForkData
   46  *
   47  *  There's still a few spots where we still need to swap the fork data.
   48  */
   49 void
   50 hfs_swap_HFSPlusForkData (
   51     HFSPlusForkData *src
   52 )
   53 {
   54     int i;
   55 
   56         src->logicalSize                = SWAP_BE64 (src->logicalSize);
   57 
   58         src->clumpSize                  = SWAP_BE32 (src->clumpSize);
   59         src->totalBlocks                = SWAP_BE32 (src->totalBlocks);
   60 
   61     for (i = 0; i < kHFSPlusExtentDensity; i++) {
   62         src->extents[i].startBlock      = SWAP_BE32 (src->extents[i].startBlock);
   63         src->extents[i].blockCount      = SWAP_BE32 (src->extents[i].blockCount);
   64     }
   65 }
   66 
   67 /*
   68  * hfs_swap_BTNode
   69  *
   70  *  NOTE: This operation is not naturally symmetric.
   71  *        We have to determine which way we're swapping things.
   72  */
   73 int
   74 hfs_swap_BTNode (
   75     BlockDescriptor *src,
   76     int isHFSPlus,
   77     HFSCatalogNodeID fileID,
   78     int unswap
   79 )
   80 {
   81     BTNodeDescriptor *srcDesc = src->buffer;
   82     UInt16 *srcOffs = NULL;
   83 
   84     UInt32 i;
   85     int error = 0;
   86 
   87 
   88 #ifdef ENDIAN_DEBUG
   89     if (unswap == 0) {
   90         printf ("BE -> LE Swap\n");
   91     } else if (unswap == 1) {
   92         printf ("LE -> BE Swap\n");
   93     } else if (unswap == 3) {
   94         printf ("Not swapping descriptors\n");
   95     } else {
   96         panic ("%s This is impossible", "hfs_swap_BTNode:");
   97     }
   98 #endif
   99 
  100     /* If we are doing a swap */
  101     if (unswap == 0) {
  102         /* Swap the node descriptor */
  103         srcDesc->fLink          = SWAP_BE32 (srcDesc->fLink);
  104         srcDesc->bLink          = SWAP_BE32 (srcDesc->bLink);
  105     
  106         /* Don't swap srcDesc->kind */
  107         /* Don't swap srcDesc->height */
  108         /* Don't swap srcDesc->reserved */
  109     
  110         srcDesc->numRecords     = SWAP_BE16 (srcDesc->numRecords);
  111         
  112         /* Swap the node offsets (including the free space one!) */
  113         srcOffs = (UInt16 *)((char *)src->buffer + (src->blockSize - ((srcDesc->numRecords + 1) * sizeof (UInt16))));
  114 
  115         /* Sanity check */
  116         if ((char *)srcOffs > ((char *)src->buffer + src->blockSize)) {
  117             panic ("%s Too many records in the B-Tree node", "hfs_swap_BTNode:");
  118         }
  119 
  120         for (i = 0; i < srcDesc->numRecords + 1; i++) {
  121             srcOffs[i]  = SWAP_BE16 (srcOffs[i]);
  122 
  123             /* Sanity check */
  124             if (srcOffs[i] >= src->blockSize) {
  125                 panic ("%s B-Tree node offset out of range", "hfs_swap_BTNode:");
  126             }
  127         }
  128     }
  129     
  130     /* Swap the records (ordered by frequency of access) */
  131     /* Swap a B-Tree internal node */
  132     if ((srcDesc->kind == kBTIndexNode) ||
  133         (srcDesc-> kind == kBTLeafNode)) {
  134 
  135         if (isHFSPlus) {
  136             error = hfs_swap_HFSPlusBTInternalNode (src, fileID, unswap);
  137         } else {
  138             error = hfs_swap_HFSBTInternalNode (src, fileID, unswap);
  139         }
  140         
  141     /* Swap a B-Tree map node */
  142     } else if (srcDesc-> kind == kBTMapNode) {
  143         /* Don't swap the bitmaps, they'll be done in the bitmap routines */
  144     
  145     /* Swap a B-Tree header node */
  146     } else if (srcDesc-> kind == kBTHeaderNode) {
  147         /* The header's offset is hard-wired because we cannot trust the offset pointers */
  148         BTHeaderRec *srcHead = (BTHeaderRec *)((char *)src->buffer + 14);
  149         
  150         srcHead->treeDepth              =       SWAP_BE16 (srcHead->treeDepth);
  151         
  152         srcHead->rootNode               =       SWAP_BE32 (srcHead->rootNode);
  153         srcHead->leafRecords    =       SWAP_BE32 (srcHead->leafRecords);
  154         srcHead->firstLeafNode  =       SWAP_BE32 (srcHead->firstLeafNode);
  155         srcHead->lastLeafNode   =       SWAP_BE32 (srcHead->lastLeafNode);
  156         
  157         srcHead->nodeSize               =       SWAP_BE16 (srcHead->nodeSize);
  158         srcHead->maxKeyLength   =       SWAP_BE16 (srcHead->maxKeyLength);
  159         
  160         srcHead->totalNodes             =       SWAP_BE32 (srcHead->totalNodes);
  161         srcHead->freeNodes              =       SWAP_BE32 (srcHead->freeNodes);
  162         
  163         srcHead->clumpSize              =       SWAP_BE32 (srcHead->clumpSize);
  164         srcHead->attributes             =       SWAP_BE32 (srcHead->attributes);
  165 
  166         /* Don't swap srcHead->reserved1 */
  167         /* Don't swap srcHead->btreeType */
  168         /* Don't swap srcHead->reserved2 */
  169         /* Don't swap srcHead->reserved3 */
  170         /* Don't swap bitmap */
  171     }
  172     
  173     /* If we are doing an unswap */
  174     if (unswap == 1) {
  175         /* Swap the node descriptor */
  176         srcDesc->fLink          = SWAP_BE32 (srcDesc->fLink);
  177         srcDesc->bLink          = SWAP_BE32 (srcDesc->bLink);
  178     
  179         /* Don't swap srcDesc->kind */
  180         /* Don't swap srcDesc->height */
  181         /* Don't swap srcDesc->reserved */
  182     
  183         /* Swap the node offsets (including the free space one!) */
  184         srcOffs = (UInt16 *)((char *)src->buffer + (src->blockSize - ((srcDesc->numRecords + 1) * sizeof (UInt16))));
  185 
  186         /* Sanity check */
  187         if ((char *)srcOffs > ((char *)src->buffer + src->blockSize)) {
  188             panic ("%s Too many records in the B-Tree node", "hfs_swap_BTNode:");
  189         }
  190 
  191         for (i = 0; i < srcDesc->numRecords + 1; i++) {
  192             /* Sanity check */
  193             if (srcOffs[i] >= src->blockSize) {
  194                 panic ("%s B-Tree node offset out of range", "hfs_swap_BTNode:");
  195             }
  196 
  197             srcOffs[i]  = SWAP_BE16 (srcOffs[i]);
  198         }
  199         
  200         srcDesc->numRecords     = SWAP_BE16 (srcDesc->numRecords);
  201     }
  202     
  203     return (error);
  204 }
  205 
  206 int
  207 hfs_swap_HFSPlusBTInternalNode (
  208     BlockDescriptor *src,
  209     HFSCatalogNodeID fileID,
  210     int unswap
  211 )
  212 {
  213     BTNodeDescriptor *srcDesc = src->buffer;
  214     UInt16 *srcOffs = (UInt16 *)((char *)src->buffer + (src->blockSize - (srcDesc->numRecords * sizeof (UInt16))));
  215 
  216     UInt32 i;
  217     UInt32 j;
  218 
  219     if (fileID == kHFSExtentsFileID) {
  220         HFSPlusExtentKey *srcKey;
  221         HFSPlusExtentDescriptor *srcRec;
  222         
  223         for (i = 0; i < srcDesc->numRecords; i++) {
  224             srcKey = (HFSPlusExtentKey *)((char *)src->buffer + srcOffs[i]);
  225 
  226             if (!unswap) srcKey->keyLength              = SWAP_BE16 (srcKey->keyLength);
  227             srcRec = (HFSPlusExtentDescriptor *)((char *)srcKey + srcKey->keyLength + 2);
  228             if (unswap) srcKey->keyLength               = SWAP_BE16 (srcKey->keyLength);
  229 
  230             /* Don't swap srcKey->forkType */
  231             /* Don't swap srcKey->pad */
  232 
  233             srcKey->fileID                      = SWAP_BE32 (srcKey->fileID);
  234             srcKey->startBlock          = SWAP_BE32 (srcKey->startBlock);
  235             
  236             /* Stop if this is just an index node */
  237             if (srcDesc->kind == kBTIndexNode) {
  238                 *((UInt32 *)srcRec) = SWAP_BE32 (*((UInt32 *)srcRec));
  239                 continue;
  240             }
  241 
  242             /* Swap the extent data */
  243             
  244             /* Swap each extent */
  245             for (j = 0; j < kHFSPlusExtentDensity; j++) {
  246                 srcRec[j].startBlock    = SWAP_BE32 (srcRec[j].startBlock);
  247                 srcRec[j].blockCount    = SWAP_BE32 (srcRec[j].blockCount);
  248             }
  249         }
  250 
  251     } else if (fileID == kHFSCatalogFileID) {
  252         HFSPlusCatalogKey *srcKey;
  253         SInt16 *srcPtr;
  254         
  255         for (i = 0; i < srcDesc->numRecords; i++) {
  256             srcKey = (HFSPlusCatalogKey *)((char *)src->buffer + srcOffs[i]);
  257 
  258             if (!unswap) srcKey->keyLength                      = SWAP_BE16 (srcKey->keyLength);
  259             srcPtr = (SInt16 *)((char *)srcKey + srcKey->keyLength + 2);
  260             if (unswap) srcKey->keyLength                       = SWAP_BE16 (srcKey->keyLength);
  261             
  262             srcKey->parentID                                            = SWAP_BE32 (srcKey->parentID);
  263 
  264             if (!unswap) srcKey->nodeName.length        = SWAP_BE16 (srcKey->nodeName.length);
  265             for (j = 0; j < srcKey->nodeName.length; j++) {
  266                 srcKey->nodeName.unicode[j]     = SWAP_BE16 (srcKey->nodeName.unicode[j]);
  267             }
  268             if (unswap) srcKey->nodeName.length = SWAP_BE16 (srcKey->nodeName.length);
  269  
  270             /* Stop if this is just an index node */
  271             if (srcDesc->kind == kBTIndexNode) {
  272                 *((UInt32 *)srcPtr) = SWAP_BE32 (*((UInt32 *)srcPtr));
  273                 continue;
  274             }
  275             
  276             /* Swap the recordType field, if unswapping, leave to later */
  277             if (!unswap) srcPtr[0] = SWAP_BE16 (srcPtr[0]);
  278             
  279             if (srcPtr[0] == kHFSPlusFolderRecord) {
  280                 HFSPlusCatalogFolder *srcRec = (HFSPlusCatalogFolder *)srcPtr;
  281                 
  282                 srcRec->flags                           = SWAP_BE16 (srcRec->flags);
  283                 srcRec->valence                         = SWAP_BE32 (srcRec->valence);
  284                 srcRec->folderID                        = SWAP_BE32 (srcRec->folderID);
  285                 srcRec->createDate                      = SWAP_BE32 (srcRec->createDate);
  286                 srcRec->contentModDate          = SWAP_BE32 (srcRec->contentModDate);
  287                 srcRec->attributeModDate        = SWAP_BE32 (srcRec->attributeModDate);
  288                 srcRec->accessDate                      = SWAP_BE32 (srcRec->accessDate);
  289                 srcRec->backupDate                      = SWAP_BE32 (srcRec->backupDate);
  290                 
  291                 srcRec->bsdInfo.ownerID         = SWAP_BE32 (srcRec->bsdInfo.ownerID);
  292                 srcRec->bsdInfo.groupID         = SWAP_BE32 (srcRec->bsdInfo.groupID);
  293     
  294                 /* Don't swap srcRec->bsdInfo.adminFlags */
  295                 /* Don't swap srcRec->bsdInfo.ownerFlags */
  296     
  297                 srcRec->bsdInfo.fileMode                        = SWAP_BE16 (srcRec->bsdInfo.fileMode);
  298                 srcRec->bsdInfo.special.iNodeNum        = SWAP_BE32 (srcRec->bsdInfo.special.iNodeNum);
  299     
  300                 srcRec->textEncoding            = SWAP_BE32 (srcRec->textEncoding);
  301     
  302                 /* Don't swap srcRec->userInfo */
  303                 /* Don't swap srcRec->finderInfo */
  304                 /* Don't swap srcRec->reserved */
  305     
  306             } else if (srcPtr[0] == kHFSPlusFileRecord) {
  307                 HFSPlusCatalogFile *srcRec = (HFSPlusCatalogFile *)srcPtr;
  308                 
  309                 srcRec->flags                           = SWAP_BE16 (srcRec->flags);
  310     
  311                 srcRec->fileID                          = SWAP_BE32 (srcRec->fileID);
  312     
  313                 srcRec->createDate                      = SWAP_BE32 (srcRec->createDate);
  314                 srcRec->contentModDate          = SWAP_BE32 (srcRec->contentModDate);
  315                 srcRec->attributeModDate        = SWAP_BE32 (srcRec->attributeModDate);
  316                 srcRec->accessDate                      = SWAP_BE32 (srcRec->accessDate);
  317                 srcRec->backupDate                      = SWAP_BE32 (srcRec->backupDate);
  318     
  319                 srcRec->bsdInfo.ownerID         = SWAP_BE32 (srcRec->bsdInfo.ownerID);
  320                 srcRec->bsdInfo.groupID         = SWAP_BE32 (srcRec->bsdInfo.groupID);
  321     
  322                 /* Don't swap srcRec->bsdInfo.adminFlags */
  323                 /* Don't swap srcRec->bsdInfo.ownerFlags */
  324     
  325                 srcRec->bsdInfo.fileMode                        = SWAP_BE16 (srcRec->bsdInfo.fileMode);
  326                 srcRec->bsdInfo.special.iNodeNum        = SWAP_BE32 (srcRec->bsdInfo.special.iNodeNum);
  327     
  328                 srcRec->textEncoding            = SWAP_BE32 (srcRec->textEncoding);
  329     
  330                 /* Don't swap srcRec->reserved1 */
  331                 /* Don't swap srcRec->userInfo */
  332                 /* Don't swap srcRec->finderInfo */
  333                 /* Don't swap srcRec->reserved2 */
  334     
  335                 hfs_swap_HFSPlusForkData (&srcRec->dataFork);
  336                 hfs_swap_HFSPlusForkData (&srcRec->resourceFork);
  337             
  338             } else if ((srcPtr[0] == kHFSPlusFolderThreadRecord) ||
  339                        (srcPtr[0] == kHFSPlusFileThreadRecord)) {
  340     
  341                 HFSPlusCatalogThread *srcRec = (HFSPlusCatalogThread *)srcPtr;
  342     
  343                 /* Don't swap srcRec->reserved */
  344                 
  345                 srcRec->parentID                                                = SWAP_BE32 (srcRec->parentID);
  346                 
  347                 if (!unswap) srcRec->nodeName.length    = SWAP_BE16 (srcRec->nodeName.length);
  348                 for (j = 0; j < srcRec->nodeName.length; j++) {
  349                     srcRec->nodeName.unicode[j] = SWAP_BE16 (srcRec->nodeName.unicode[j]);
  350                 }
  351                 if (unswap) srcRec->nodeName.length             = SWAP_BE16 (srcRec->nodeName.length);
  352 
  353             } else {
  354                 panic ("%s unrecognized catalog record type", "hfs_swap_BTNode:");
  355             }
  356     
  357             /* If unswapping, we can safely unswap type field now */
  358             if (unswap) srcPtr[0] = SWAP_BE16 (srcPtr[0]);
  359         }
  360         
  361     } else if (fileID > kHFSFirstUserCatalogNodeID) {
  362                 HotFileKey *srcKey;
  363                 UInt32 *srcRec;
  364         
  365                 for (i = 0; i < srcDesc->numRecords; i++) {
  366                         srcKey = (HotFileKey *)((char *)src->buffer + srcOffs[i]);
  367 
  368                         if (!unswap)
  369                                 srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);
  370                         srcRec = (u_int32_t *)((char *)srcKey + srcKey->keyLength + 2);
  371                         if (unswap)
  372                                 srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);
  373 
  374                         /* Don't swap srcKey->forkType */
  375                         /* Don't swap srcKey->pad */
  376 
  377                         srcKey->temperature = SWAP_BE32 (srcKey->temperature);
  378                         srcKey->fileID = SWAP_BE32 (srcKey->fileID);
  379              
  380                         *((UInt32 *)srcRec) = SWAP_BE32 (*((UInt32 *)srcRec));
  381                 }
  382     } else {
  383         panic ("%s unrecognized B-Tree type", "hfs_swap_BTNode:");
  384     }
  385 
  386 
  387     return (0);
  388 }
  389 
  390 int
  391 hfs_swap_HFSBTInternalNode (
  392     BlockDescriptor *src,
  393     HFSCatalogNodeID fileID,
  394     int unswap
  395 )
  396 {
  397     BTNodeDescriptor *srcDesc = src->buffer;
  398     UInt16 *srcOffs = (UInt16 *)((char *)src->buffer + (src->blockSize - (srcDesc->numRecords * sizeof (UInt16))));
  399 
  400     UInt32 i;
  401     UInt32 j;
  402 
  403     if (fileID == kHFSExtentsFileID) {
  404         HFSExtentKey *srcKey;
  405         HFSExtentDescriptor *srcRec;
  406         
  407         for (i = 0; i < srcDesc->numRecords; i++) {
  408             srcKey = (HFSExtentKey *)((char *)src->buffer + srcOffs[i]);
  409 
  410             /* Don't swap srcKey->keyLength */
  411             /* Don't swap srcKey->forkType */
  412 
  413             srcKey->fileID                      = SWAP_BE32 (srcKey->fileID);
  414             srcKey->startBlock          = SWAP_BE16 (srcKey->startBlock);
  415 
  416             /* Point to record data (round up to even byte boundary) */
  417             srcRec = (HFSExtentDescriptor *)((char *)srcKey + ((srcKey->keyLength + 2) & ~1));
  418     
  419             /* Stop if this is just an index node */
  420             if (srcDesc->kind == kBTIndexNode) {
  421                 *((UInt32 *)srcRec) = SWAP_BE32 (*((UInt32 *)srcRec));
  422                 continue;
  423             }
  424             
  425             /* Swap each extent */
  426             for (j = 0; j < kHFSExtentDensity; j++) {
  427                 srcRec[j].startBlock    = SWAP_BE16 (srcRec[j].startBlock);
  428                 srcRec[j].blockCount    = SWAP_BE16 (srcRec[j].blockCount);
  429             }
  430         }
  431         
  432     } else if (fileID == kHFSCatalogFileID) {
  433         HFSCatalogKey *srcKey;
  434         SInt16 *srcPtr;
  435         
  436         for (i = 0; i < srcDesc->numRecords; i++) {
  437             srcKey = (HFSCatalogKey *)((char *)src->buffer + srcOffs[i]);
  438 
  439             /* Don't swap srcKey->keyLength */
  440             /* Don't swap srcKey->reserved */
  441 
  442             srcKey->parentID                    = SWAP_BE32 (srcKey->parentID);
  443 
  444             /* Don't swap srcKey->nodeName */
  445 
  446             /* Point to record data (round up to even byte boundary) */
  447             srcPtr = (SInt16 *)((char *)srcKey + ((srcKey->keyLength + 2) & ~1));
  448             
  449             /* Stop if this is just an index node */
  450             if (srcDesc->kind == kBTIndexNode) {
  451                 *((UInt32 *)srcPtr) = SWAP_BE32 (*((UInt32 *)srcPtr));
  452                 continue;
  453             }
  454     
  455             /* Swap the recordType field, if unswapping, leave to later */
  456             if (!unswap) srcPtr[0] = SWAP_BE16 (srcPtr[0]);
  457             
  458             if (srcPtr[0] == kHFSFolderRecord) {
  459                 HFSCatalogFolder *srcRec = (HFSCatalogFolder *)srcPtr;
  460                 
  461                 srcRec->flags                           = SWAP_BE16 (srcRec->flags);
  462                 srcRec->valence                         = SWAP_BE16 (srcRec->valence);
  463                 
  464                 srcRec->folderID                        = SWAP_BE32 (srcRec->folderID);
  465                 srcRec->createDate                      = SWAP_BE32 (srcRec->createDate);
  466                 srcRec->modifyDate                      = SWAP_BE32 (srcRec->modifyDate);
  467                 srcRec->backupDate                      = SWAP_BE32 (srcRec->backupDate);
  468     
  469                 /* Don't swap srcRec->userInfo */
  470                 /* Don't swap srcRec->finderInfo */
  471                 /* Don't swap resserved array */
  472     
  473             } else if (srcPtr[0] == kHFSFileRecord) {
  474                 HFSCatalogFile *srcRec = (HFSCatalogFile *)srcPtr;
  475                 
  476                 srcRec->flags                           = srcRec->flags;
  477                 srcRec->fileType                        = srcRec->fileType;
  478     
  479                 /* Don't swap srcRec->userInfo */
  480     
  481                 srcRec->fileID                          = SWAP_BE32 (srcRec->fileID);
  482                 
  483                 srcRec->dataStartBlock          = SWAP_BE16 (srcRec->dataStartBlock);
  484                 srcRec->dataLogicalSize         = SWAP_BE32 (srcRec->dataLogicalSize);
  485                 srcRec->dataPhysicalSize        = SWAP_BE32 (srcRec->dataPhysicalSize);
  486                 
  487                 srcRec->rsrcStartBlock          = SWAP_BE16 (srcRec->rsrcStartBlock);
  488                 srcRec->rsrcLogicalSize         = SWAP_BE32 (srcRec->rsrcLogicalSize);
  489                 srcRec->rsrcPhysicalSize        = SWAP_BE32 (srcRec->rsrcPhysicalSize);
  490                 
  491                 srcRec->createDate                      = SWAP_BE32 (srcRec->createDate);
  492                 srcRec->modifyDate                      = SWAP_BE32 (srcRec->modifyDate);
  493                 srcRec->backupDate                      = SWAP_BE32 (srcRec->backupDate);
  494     
  495                 /* Don't swap srcRec->finderInfo */
  496     
  497                 srcRec->clumpSize                       = SWAP_BE16 (srcRec->clumpSize);
  498                 
  499                 /* Swap the two sets of extents as an array of six (three each) UInt16 */
  500                 for (j = 0; j < kHFSExtentDensity * 2; j++) {
  501                     srcRec->dataExtents[j].startBlock   = SWAP_BE16 (srcRec->dataExtents[j].startBlock);
  502                     srcRec->dataExtents[j].blockCount   = SWAP_BE16 (srcRec->dataExtents[j].blockCount);
  503                 }
  504     
  505                 /* Don't swap srcRec->reserved */
  506                 
  507             } else if ((srcPtr[0] == kHFSFolderThreadRecord) ||
  508                     (srcPtr[0] == kHFSFileThreadRecord)) {
  509     
  510                 HFSCatalogThread *srcRec = (HFSCatalogThread *)srcPtr;
  511     
  512                 /* Don't swap srcRec->reserved array */
  513     
  514                 srcRec->parentID                        = SWAP_BE32 (srcRec->parentID);
  515     
  516                 /* Don't swap srcRec->nodeName */
  517     
  518             } else {
  519                 panic ("%s unrecognized catalog record type", "hfs_swap_BTNode:");
  520             }
  521     
  522             /* If unswapping, we can safely swap type now */
  523             if (unswap) srcPtr[0] = SWAP_BE16 (srcPtr[0]);
  524         }
  525         
  526     } else {
  527         panic ("%s unrecognized B-Tree type", "hfs_swap_BTNode:");
  528     }
  529 
  530     return (0);
  531 }
Cache object: 399fe50fc7da1d5b704b72b856b52602
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/bsd/hfs/hfs_endian.c

FreeBSD/Linux Kernel Cross Reference
sys/bsd/hfs/hfs_endian.c
