diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/compress.c b/third_party/libdmg-hfsplus/src/dmg/compress.c index 172cf6f2d86d4..4331c2a623f3e 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/compress.c +++ b/third_party/libdmg-hfsplus/src/dmg/compress.c @@ -106,20 +106,20 @@ int getCompressor(Compressor* comp, char *name) { if (strcasecmp(name, "bzip2") == 0) { comp->block_type = BLOCK_BZIP2; - comp->compress = bz2Compress; + comp->compressFn = bz2Compress; comp->decompressBuffer = oldDecompressBuffer; return 0; } if (strcasecmp(name, "zlib") == 0) { comp->block_type = BLOCK_ZLIB; - comp->compress = zlibCompress; + comp->compressFn = zlibCompress; comp->decompressBuffer = oldDecompressBuffer; return 0; } #ifdef HAVE_LIBLZMA if (strcasecmp(name, "lzma") == 0) { comp->block_type = BLOCK_LZMA; - comp->compress = lzmaCompress; + comp->compressFn = lzmaCompress; comp->decompressBuffer = modernDecompressBuffer; return 0; } @@ -127,7 +127,7 @@ int getCompressor(Compressor* comp, char *name) #ifdef HAVE_LZFSE if (strcasecmp(name, "lzfse") == 0) { comp->block_type = BLOCK_LZFSE; - comp->compress = lzfseCompress; + comp->compressFn = lzfseCompress; comp->decompressBuffer = modernDecompressBuffer; return 0; } diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/io.c b/third_party/libdmg-hfsplus/src/dmg/io.c index 922612cf19d07..ec507cd4993ce 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/io.c +++ b/third_party/libdmg-hfsplus/src/dmg/io.c @@ -137,7 +137,7 @@ static block* blockRead(threadData* d) { static void blockCompress(block* b, Compressor* comp) { if (!b->keepRaw) { - ASSERT(comp->compress(b->inbuf, b->insize, b->outbuf, b->bufferSize, &b->outsize, comp->level) == 0, "compress"); + ASSERT(comp->compressFn(b->inbuf, b->insize, b->outbuf, b->bufferSize, &b->outsize, comp->level) == 0, "compress"); } if(b->keepRaw || ((b->outsize / SECTOR_SIZE) >= (b->run.sectorCount - 15))) { diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/partition.c b/third_party/libdmg-hfsplus/src/dmg/partition.c index ebab732f1e06e..aceb0f9782e0b 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/partition.c +++ b/third_party/libdmg-hfsplus/src/dmg/partition.c @@ -521,7 +521,7 @@ int writeDriverDescriptorMap(int pNum, AbstractFile* file, DriverDescriptorRecor char pName[100]; sprintf(pName, "Driver Descriptor Map (DDM : %d)", pNum + 1); *resources = insertData(*resources, "blkx", pNum, pName, 0, false, (const char*) blkx, sizeof(BLKXTable) + (blkx->blocksRunCount * sizeof(BLKXRun)), ATTRIBUTE_HDIUTIL); - + bufferFile->close(bufferFile); free(buffer); free(blkx); diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/hfs/btree.c b/third_party/libdmg-hfsplus/src/hfs/btree.c index 3aca4689dbb68..d31ff6d2bc5c9 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/hfs/btree.c +++ b/third_party/libdmg-hfsplus/src/hfs/btree.c @@ -3,44 +3,44 @@ BTNodeDescriptor* readBTNodeDescriptor(uint32_t num, BTree* tree) { BTNodeDescriptor* descriptor; - + descriptor = (BTNodeDescriptor*) malloc(sizeof(BTNodeDescriptor)); - + if(!READ(tree->io, num * tree->headerRec->nodeSize, sizeof(BTNodeDescriptor), descriptor)) return NULL; - + FLIPENDIAN(descriptor->fLink); FLIPENDIAN(descriptor->bLink); FLIPENDIAN(descriptor->numRecords); - + return descriptor; } static int writeBTNodeDescriptor(BTNodeDescriptor* descriptor, uint32_t num, BTree* tree) { BTNodeDescriptor myDescriptor; - + myDescriptor = *descriptor; FLIPENDIAN(myDescriptor.fLink); FLIPENDIAN(myDescriptor.bLink); FLIPENDIAN(myDescriptor.numRecords); - + if(!WRITE(tree->io, num * tree->headerRec->nodeSize, sizeof(BTNodeDescriptor), &myDescriptor)) return FALSE; - + return TRUE; } BTHeaderRec* readBTHeaderRec(io_func* io) { BTHeaderRec* headerRec; - + headerRec = (BTHeaderRec*) malloc(sizeof(BTHeaderRec)); - + if(!READ(io, sizeof(BTNodeDescriptor), sizeof(BTHeaderRec), headerRec)) { free(headerRec); return NULL; } - + FLIPENDIAN(headerRec->treeDepth); FLIPENDIAN(headerRec->rootNode); FLIPENDIAN(headerRec->leafRecords); @@ -52,7 +52,7 @@ BTHeaderRec* readBTHeaderRec(io_func* io) { FLIPENDIAN(headerRec->freeNodes); FLIPENDIAN(headerRec->clumpSize); FLIPENDIAN(headerRec->attributes); - + /*printf("treeDepth: %d\n", headerRec->treeDepth); printf("rootNode: %d\n", headerRec->rootNode); printf("leafRecords: %d\n", headerRec->leafRecords); @@ -67,15 +67,15 @@ BTHeaderRec* readBTHeaderRec(io_func* io) { printf("keyCompareType: 0x%x\n", headerRec->keyCompareType); printf("attributes: 0x%x\n", headerRec->attributes); fflush(stdout);*/ - + return headerRec; } static int writeBTHeaderRec(BTree* tree) { BTHeaderRec headerRec; - + headerRec = *tree->headerRec; - + FLIPENDIAN(headerRec.treeDepth); FLIPENDIAN(headerRec.rootNode); FLIPENDIAN(headerRec.leafRecords); @@ -87,32 +87,32 @@ static int writeBTHeaderRec(BTree* tree) { FLIPENDIAN(headerRec.freeNodes); FLIPENDIAN(headerRec.clumpSize); FLIPENDIAN(headerRec.attributes); - + if(!WRITE(tree->io, sizeof(BTNodeDescriptor), sizeof(BTHeaderRec), &headerRec)) return FALSE; - + return TRUE; } BTree* openBTree(io_func* io, compareFunc compare, dataReadFunc keyRead, keyWriteFunc keyWrite, keyPrintFunc keyPrint, dataReadFunc dataRead) { BTree* tree; - + tree = (BTree*) malloc(sizeof(BTree)); tree->io = io; tree->headerRec = readBTHeaderRec(tree->io); - + if(tree->headerRec == NULL) { free(tree); return NULL; } - + tree->compare = compare; tree->keyRead = keyRead; tree->keyWrite = keyWrite; tree->keyPrint = keyPrint; tree->dataRead = dataRead; - + return tree; } @@ -125,17 +125,17 @@ void closeBTree(BTree* tree) { off_t getRecordOffset(int num, uint32_t nodeNum, BTree* tree) { uint16_t offset; off_t nodeOffset; - + nodeOffset = nodeNum * tree->headerRec->nodeSize; - + if(!READ(tree->io, nodeOffset + tree->headerRec->nodeSize - (sizeof(uint16_t) * (num + 1)), sizeof(uint16_t), &offset)) { hfs_panic("cannot get record offset!"); } - + FLIPENDIAN(offset); - + //printf("%d: %d %d\n", nodeOffset + tree->headerRec->nodeSize - (sizeof(uint16_t) * (num + 1)), nodeOffset + offset, offset); - + return (nodeOffset + offset); } @@ -145,32 +145,32 @@ static off_t getFreeSpace(uint32_t nodeNum, BTNodeDescriptor* descriptor, BTree* off_t freespaceOffsetOffset; uint16_t offset; off_t freespaceOffset; - + num = descriptor->numRecords; - + nodeOffset = nodeNum * tree->headerRec->nodeSize; freespaceOffsetOffset = nodeOffset + tree->headerRec->nodeSize - (sizeof(uint16_t) * (num + 1)); - + if(!READ(tree->io, freespaceOffsetOffset, sizeof(uint16_t), &offset)) { hfs_panic("cannot get record offset!"); } - + FLIPENDIAN(offset); - + freespaceOffset = nodeOffset + offset; - + return (freespaceOffsetOffset - freespaceOffset); } off_t getNodeNumberFromPointerRecord(off_t offset, io_func* io) { uint32_t nodeNum; - + if(!READ(io, offset, sizeof(uint32_t), &nodeNum)) { hfs_panic("cannot get node number from pointer record!"); } - + FLIPENDIAN(nodeNum); - + return nodeNum; } @@ -180,39 +180,39 @@ static void* searchNode(BTree* tree, uint32_t root, BTKey* searchKey, int *exact off_t recordOffset; off_t recordDataOffset; off_t lastRecordDataOffset; - + int res; int i; - + descriptor = readBTNodeDescriptor(root, tree); - + if(descriptor == NULL) return NULL; - + lastRecordDataOffset = 0; - + for(i = 0; i < descriptor->numRecords; i++) { recordOffset = getRecordOffset(i, root, tree); key = READ_KEY(tree, recordOffset, tree->io); recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength); - + res = COMPARE(tree, key, searchKey); free(key); if(res == 0) { if(descriptor->kind == kBTLeafNode) { if(nodeNumber != NULL) *nodeNumber = root; - + if(recordNumber != NULL) *recordNumber = i; - + if(exact != NULL) *exact = TRUE; - + free(descriptor); return READ_DATA(tree, recordDataOffset, tree->io); - } else { + } else { free(descriptor); return searchNode(tree, getNodeNumberFromPointerRecord(recordDataOffset, tree->io), searchKey, exact, nodeNumber, recordNumber); } @@ -227,30 +227,30 @@ static void* searchNode(BTree* tree, uint32_t root, BTKey* searchKey, int *exact hfs_panic("BTree inconsistent!"); return NULL; } - - if(descriptor->kind == kBTLeafNode) { + + if(descriptor->kind == kBTLeafNode) { if(nodeNumber != NULL) *nodeNumber = root; - + if(recordNumber != NULL) *recordNumber = i; - + if(exact != NULL) *exact = FALSE; - + free(descriptor); return READ_DATA(tree, lastRecordDataOffset, tree->io); } else if(descriptor->kind == kBTIndexNode) { - + free(descriptor); return searchNode(tree, getNodeNumberFromPointerRecord(lastRecordDataOffset, tree->io), searchKey, exact, nodeNumber, recordNumber); } else { if(nodeNumber != NULL) *nodeNumber = root; - + if(recordNumber != NULL) *recordNumber = i; - + if(exact != NULL) *exact = FALSE; @@ -267,22 +267,22 @@ static uint32_t linearCheck(uint32_t* heightTable, unsigned char* map, BTree* tr uint8_t i; uint8_t j; uint32_t node; - + uint32_t count; uint32_t leafRecords; - + BTNodeDescriptor* descriptor; - + uint32_t prevNode; - + off_t recordOffset; BTKey* key; BTKey* previousKey; - + count = 0; - + leafRecords = 0; - + for(i = 0; i <= tree->headerRec->treeDepth; i++) { node = heightTable[i]; if(node != 0) { @@ -293,39 +293,39 @@ static uint32_t linearCheck(uint32_t* heightTable, unsigned char* map, BTree* tr descriptor = readBTNodeDescriptor(node, tree); } free(descriptor); - + prevNode = 0; previousKey = NULL; - + if(i == 1) { if(node != tree->headerRec->firstLeafNode) { printf("BTREE CONSISTENCY ERROR: First leaf node (%d) is not correct. Should be: %d\n", tree->headerRec->firstLeafNode, node); (*errCount)++; } } - + while(node != 0) { descriptor = readBTNodeDescriptor(node, tree); if(descriptor->bLink != prevNode) { printf("BTREE CONSISTENCY ERROR: Node %d is not properly linked with previous node %d\n", node, prevNode); (*errCount)++; } - + if(descriptor->height != i) { printf("BTREE CONSISTENCY ERROR: Node %d (%d) is not properly linked with nodes of the same height %d\n", node, descriptor->height, i); (*errCount)++; } - + if((map[node / 8] & (1 << (7 - (node % 8)))) == 0) { printf("BTREE CONSISTENCY ERROR: Node %d not marked allocated\n", node); (*errCount)++; } - + /*if(descriptor->kind == kBTIndexNode && descriptor->numRecords < 2) { printf("BTREE CONSISTENCY ERROR: Node %d does not have at least two children\n", node); (*errCount)++; }*/ - + for(j = 0; j < descriptor->numRecords; j++) { recordOffset = getRecordOffset(j, node, tree); key = READ_KEY(tree, recordOffset, tree->io); @@ -340,36 +340,36 @@ static uint32_t linearCheck(uint32_t* heightTable, unsigned char* map, BTree* tr } free(previousKey); } - + if(i == 1) { leafRecords++; } previousKey = key; } - + count++; - + prevNode = node; node = descriptor->fLink; free(descriptor); } - + if(i == 1) { if(prevNode != tree->headerRec->lastLeafNode) { printf("BTREE CONSISTENCY ERROR: Last leaf node (%d) is not correct. Should be: %d\n", tree->headerRec->lastLeafNode, node); (*errCount)++; } } - + free(previousKey); } } - + if(leafRecords != tree->headerRec->leafRecords) { printf("BTREE CONSISTENCY ERROR: leafRecords (%d) is not correct. Should be: %d\n", tree->headerRec->leafRecords, leafRecords); (*errCount)++; } - + return count; } @@ -381,36 +381,36 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map, BTKey* retFirstKey; BTKey* retLastKey; int i, j; - + int res; - + uint32_t count; - + off_t recordOffset; off_t recordDataOffset; - + off_t lastrecordDataOffset; - + descriptor = readBTNodeDescriptor(nodeNum, tree); - + previousKey = NULL; - + count = 1; - + if(displayTree) { for(i = 0; i < descriptor->height; i++) { printf(" "); } } - + if(descriptor->kind == kBTLeafNode) { if(displayTree) printf("Leaf %d: %d", nodeNum, descriptor->numRecords); - + if(descriptor->height != 1) { printf("BTREE CONSISTENCY ERROR: Leaf node %d does not have height 1\n", nodeNum); fflush(stdout); (*errCount)++; - } + } } else if(descriptor->kind == kBTIndexNode) { if(displayTree) printf("Index %d: %d", nodeNum, descriptor->numRecords); @@ -419,16 +419,16 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map, printf("BTREE CONSISTENCY ERROR: Unexpected node %d has kind %d\n", nodeNum, descriptor->kind); fflush(stdout); (*errCount)++; } - + if(displayTree) { printf("\n"); fflush(stdout); } - + if((map[nodeNum / 8] & (1 << (7 - (nodeNum % 8)))) == 0) { printf("BTREE CONSISTENCY ERROR: Node %d not marked allocated\n", nodeNum); fflush(stdout); (*errCount)++; } - + if(nodeNum == tree->headerRec->rootNode) { if(descriptor->height != tree->headerRec->treeDepth) { printf("BTREE CONSISTENCY ERROR: Root node %d (%d) does not have the proper height (%d)\n", nodeNum, @@ -441,20 +441,20 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map, (*errCount)++; } } - + /*if(descriptor->kind == kBTIndexNode && descriptor->numRecords < 2) { printf("BTREE CONSISTENCY ERROR: Node %d does not have at least two children\n", nodeNum); (*errCount)++; }*/ - + heightTable[descriptor->height] = nodeNum; lastrecordDataOffset = 0; - + for(i = 0; i < descriptor->numRecords; i++) { recordOffset = getRecordOffset(i, nodeNum, tree); key = READ_KEY(tree, recordOffset, tree->io); recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength); - + if((recordDataOffset - (nodeNum * tree->headerRec->nodeSize)) > (tree->headerRec->nodeSize - (sizeof(uint16_t) * (descriptor->numRecords + 1)))) { printf("BTREE CONSISTENCY ERROR: Record data extends past offsets in node %d record %d\n", nodeNum, i); fflush(stdout); (*errCount)++; @@ -463,11 +463,11 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map, if(i == 0) { *firstKey = READ_KEY(tree, recordOffset, tree->io); } - + if(i == (descriptor->numRecords - 1)) { *lastKey = READ_KEY(tree, recordOffset, tree->io); } - + if(previousKey != NULL) { res = COMPARE(tree, key, previousKey); if(res < 0) { @@ -481,7 +481,7 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map, free(previousKey); previousKey = NULL; } - + if(displayTree) { for(j = 0; j < (descriptor->height - 1); j++) { printf(" "); @@ -489,11 +489,11 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map, tree->keyPrint(key); printf("\n"); } - + if(descriptor->kind == kBTIndexNode) { count += traverseNode(getNodeNumberFromPointerRecord(recordDataOffset, tree->io), tree, map, descriptor->height, &retFirstKey, &retLastKey, heightTable, errCount, displayTree); - + if(COMPARE(tree, retFirstKey, key) != 0) { printf("BTREE CONSISTENCY ERROR: Index node key does not match first key in record %d node %d\n", i, nodeNum); fflush(stdout); (*errCount)++; @@ -508,41 +508,41 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map, } else { previousKey = key; } - + if(recordOffset < lastrecordDataOffset) { printf("BTREE CONSISTENCY ERROR: Record offsets are not in order in node %d starting at record %d\n", nodeNum, i); fflush(stdout); (*errCount)++; } - + lastrecordDataOffset = recordDataOffset; } - + if(previousKey != NULL) free(previousKey); free(descriptor); - + return count; - + } static unsigned char* mapNodes(BTree* tree, uint32_t* numMapNodes, uint32_t* errCount) { unsigned char *map; - + BTNodeDescriptor* descriptor; - + unsigned char byte; - + uint32_t totalNodes; uint32_t freeNodes; - + uint32_t byteNumber; uint32_t byteTracker; - + uint32_t mapNode; - + off_t mapRecordStart; off_t mapRecordLength; - + int i; map = (unsigned char *)malloc(tree->headerRec->totalNodes/8 + 1); @@ -550,14 +550,14 @@ static unsigned char* mapNodes(BTree* tree, uint32_t* numMapNodes, uint32_t* err byteTracker = 0; freeNodes = 0; totalNodes = 0; - + mapRecordStart = getRecordOffset(2, 0, tree); mapRecordLength = tree->headerRec->nodeSize - 256; byteNumber = 0; mapNode = 0; - + *numMapNodes = 0; - + while(TRUE) { while(byteNumber < mapRecordLength) { READ(tree->io, mapRecordStart + byteNumber, 1, &byte); @@ -569,36 +569,36 @@ static unsigned char* mapNodes(BTree* tree, uint32_t* numMapNodes, uint32_t* err freeNodes++; } totalNodes++; - + if(totalNodes == tree->headerRec->totalNodes) goto done; } } - + descriptor = readBTNodeDescriptor(mapNode, tree); mapNode = descriptor->fLink; free(descriptor); - + (*numMapNodes)++; - + if(mapNode == 0) { printf("BTREE CONSISTENCY ERROR: Not enough map nodes allocated! Allocated for: %d, needed: %d\n", totalNodes, tree->headerRec->totalNodes); (*errCount)++; break; } - + mapRecordStart = mapNode * tree->headerRec->nodeSize + 14; mapRecordLength = tree->headerRec->nodeSize - 20; byteNumber = 0; } - + done: - + if(freeNodes != tree->headerRec->freeNodes) { printf("BTREE CONSISTENCY ERROR: Free nodes %d differ from actually allocated %d\n", tree->headerRec->freeNodes, freeNodes); (*errCount)++; } - + return map; } @@ -607,21 +607,21 @@ int debugBTree(BTree* tree, int displayTree) { uint32_t *heightTable; BTKey* retFirstKey; BTKey* retLastKey; - + uint32_t numMapNodes; uint32_t traverseCount; uint32_t linearCount; uint32_t errorCount; - + uint8_t i; - + errorCount = 0; traverseCount = 0; linearCount = 0; - + printf("Mapping nodes...\n"); fflush(stdout); map = mapNodes(tree, &numMapNodes, &errorCount); - + printf("Initializing height table...\n"); fflush(stdout); heightTable = (uint32_t*) malloc(sizeof(uint32_t) * (tree->headerRec->treeDepth + 1)); for(i = 0; i <= tree->headerRec->treeDepth; i++) { @@ -632,13 +632,13 @@ int debugBTree(BTree* tree, int displayTree) { if(tree->headerRec->firstLeafNode || tree->headerRec->lastLeafNode) { printf("BTREE CONSISTENCY ERROR: First leaf node (%d) and last leaf node (%d) inconsistent with empty BTree\n", tree->headerRec->firstLeafNode, tree->headerRec->lastLeafNode); - + // Try to see if we can get a linear count if(tree->headerRec->firstLeafNode != 0) heightTable[1] = tree->headerRec->firstLeafNode; else heightTable[1] = tree->headerRec->lastLeafNode; - + linearCount = linearCheck(heightTable, map, tree, &errorCount); } } else { @@ -651,7 +651,7 @@ int debugBTree(BTree* tree, int displayTree) { printf("Performing linear traversal...\n"); fflush(stdout); linearCount = linearCheck(heightTable, map, tree, &errorCount); } - + printf("Total traverse nodes: %d\n", traverseCount); fflush(stdout); printf("Total linear nodes: %d\n", linearCount); fflush(stdout); printf("Error count: %d\n", errorCount); fflush(stdout); @@ -659,15 +659,15 @@ int debugBTree(BTree* tree, int displayTree) { if(traverseCount != linearCount) { printf("BTREE CONSISTENCY ERROR: Linear count and traverse count are inconsistent\n"); } - + if(traverseCount != (tree->headerRec->totalNodes - tree->headerRec->freeNodes - numMapNodes - 1)) { printf("BTREE CONSISTENCY ERROR: Free nodes and total nodes (%d) and traverse count are inconsistent\n", tree->headerRec->totalNodes - tree->headerRec->freeNodes); } free(heightTable); - free(map); - + free(map); + return errorCount; } @@ -675,19 +675,19 @@ static uint32_t findFree(BTree* tree) { unsigned char byte; uint32_t byteNumber; uint32_t mapNode; - + BTNodeDescriptor* descriptor; - + off_t mapRecordStart; off_t mapRecordLength; - + int i; mapRecordStart = getRecordOffset(2, 0, tree); mapRecordLength = tree->headerRec->nodeSize - 256; mapNode = 0; byteNumber = 0; - + while(TRUE) { while(byteNumber < mapRecordLength) { READ(tree->io, mapRecordStart + byteNumber, 1, &byte); @@ -704,15 +704,15 @@ static uint32_t findFree(BTree* tree) { } byteNumber++; } - + descriptor = readBTNodeDescriptor(mapNode, tree); mapNode = descriptor->fLink; free(descriptor); - + if(mapNode == 0) { return 0; } - + mapRecordStart = mapNode * tree->headerRec->nodeSize + 14; mapRecordLength = tree->headerRec->nodeSize - 20; byteNumber = 0; @@ -723,9 +723,9 @@ static int markUsed(uint32_t node, BTree* tree) { BTNodeDescriptor* descriptor; uint32_t mapNode; uint32_t byteNumber; - + unsigned char byte; - + mapNode = 0; byteNumber = node / 8; @@ -734,7 +734,7 @@ static int markUsed(uint32_t node, BTree* tree) { descriptor = readBTNodeDescriptor(mapNode, tree); mapNode = descriptor->fLink; free(descriptor); - + if(byteNumber > (tree->headerRec->nodeSize - 20)) { byteNumber -= tree->headerRec->nodeSize - 20; } else { @@ -742,11 +742,11 @@ static int markUsed(uint32_t node, BTree* tree) { } } } - + ASSERT(READ(tree->io, mapNode * tree->headerRec->nodeSize + 14 + byteNumber, 1, &byte), "READ"); byte |= (1 << (7 - (node % 8))); ASSERT(WRITE(tree->io, mapNode * tree->headerRec->nodeSize + 14 + byteNumber, 1, &byte), "WRITE"); - + return TRUE; } @@ -754,25 +754,25 @@ static int growBTree(BTree* tree) { int i; unsigned char* buffer; uint16_t offset; - + uint32_t byteNumber; uint32_t mapNode; int increasedNodes; - + off_t newNodeOffset; uint32_t newNodesStart; - + BTNodeDescriptor* descriptor; BTNodeDescriptor newDescriptor; - + allocate((RawFile*)(tree->io->data), ((RawFile*)(tree->io->data))->forkData->logicalSize + ((RawFile*)(tree->io->data))->forkData->clumpSize); increasedNodes = (((RawFile*)(tree->io->data))->forkData->logicalSize/tree->headerRec->nodeSize) - tree->headerRec->totalNodes; - + newNodesStart = tree->headerRec->totalNodes / tree->headerRec->nodeSize; - + tree->headerRec->freeNodes += increasedNodes; tree->headerRec->totalNodes += increasedNodes; - + byteNumber = tree->headerRec->totalNodes / 8; mapNode = 0; @@ -780,14 +780,14 @@ static int growBTree(BTree* tree) { for(i = 0; i < (tree->headerRec->nodeSize - 20); i++) { buffer[i] = 0; } - + if(byteNumber < (tree->headerRec->nodeSize - 256)) { ASSERT(writeBTHeaderRec(tree), "writeBTHeaderREc"); free(buffer); return TRUE; } else { byteNumber -= tree->headerRec->nodeSize - 256; - + while(TRUE) { descriptor = readBTNodeDescriptor(mapNode, tree); ASSERT(descriptor, "readBTNodeDescriptor failed in growBTree"); @@ -795,7 +795,7 @@ static int growBTree(BTree* tree) { if(descriptor->fLink == 0) { descriptor->fLink = newNodesStart; ASSERT(writeBTNodeDescriptor(descriptor, mapNode, tree), "growBTree failed to update existing descriptor"); - + newDescriptor.fLink = 0; newDescriptor.bLink = 0; newDescriptor.kind = kBTMapNode; @@ -803,9 +803,9 @@ static int growBTree(BTree* tree) { newDescriptor.numRecords = 1; newDescriptor.reserved = 0; ASSERT(writeBTNodeDescriptor(&newDescriptor, descriptor->fLink, tree), "growBTree failed to create a new descriptor"); - + newNodeOffset = descriptor->fLink * tree->headerRec->nodeSize; - + ASSERT(WRITE(tree->io, newNodeOffset + 14, tree->headerRec->nodeSize - 20, buffer), "WRITE"); offset = 14; FLIPENDIAN(offset); @@ -813,14 +813,14 @@ static int growBTree(BTree* tree) { offset = 14 + tree->headerRec->nodeSize - 20; FLIPENDIAN(offset); ASSERT(WRITE(tree->io, newNodeOffset + tree->headerRec->nodeSize - 4, sizeof(offset), &offset), "WRITE"); - + // mark the map node as being used ASSERT(markUsed(newNodesStart, tree), "markUsed"); tree->headerRec->freeNodes--; newNodesStart++; } mapNode = descriptor->fLink; - + if(byteNumber > (tree->headerRec->nodeSize - 20)) { byteNumber -= tree->headerRec->nodeSize - 20; } else { @@ -832,7 +832,7 @@ static int growBTree(BTree* tree) { free(descriptor); } } - + return FALSE; } @@ -840,7 +840,7 @@ static uint32_t getNewNode(BTree* tree) { if(tree->headerRec->freeNodes == 0) { growBTree(tree); } - + return findFree(tree); } @@ -851,114 +851,114 @@ static uint32_t removeNode(BTree* tree, uint32_t node) { size_t mapRecordLength; BTNodeDescriptor *descriptor; BTNodeDescriptor *oDescriptor; - + mapRecordStart = getRecordOffset(2, 0, tree); mapRecordLength = tree->headerRec->nodeSize - 256; mapNode = 0; - + while((node / 8) >= mapRecordLength) { descriptor = readBTNodeDescriptor(mapNode, tree); mapNode = descriptor->fLink; free(descriptor); - + if(mapNode == 0) { hfs_panic("Cannot remove node because I can't map it!"); return 0; } - + mapRecordStart = mapNode * tree->headerRec->nodeSize + 14; mapRecordLength = tree->headerRec->nodeSize - 20; node -= mapRecordLength * 8; } - + READ(tree->io, mapRecordStart + (node / 8), 1, &byte); - + byte &= ~(1 << (7 - (node % 8))); - + tree->headerRec->freeNodes++; - + descriptor = readBTNodeDescriptor(node, tree); - + if(tree->headerRec->firstLeafNode == node) { tree->headerRec->firstLeafNode = descriptor->fLink; } - + if(tree->headerRec->lastLeafNode == node) { tree->headerRec->lastLeafNode = descriptor->bLink; } - + if(node == tree->headerRec->rootNode) { tree->headerRec->rootNode = 0; } - + if(descriptor->bLink != 0) { oDescriptor = readBTNodeDescriptor(descriptor->bLink, tree); oDescriptor->fLink = descriptor->fLink; ASSERT(writeBTNodeDescriptor(oDescriptor, descriptor->bLink, tree), "writeBTNodeDescriptor"); free(oDescriptor); } - + if(descriptor->fLink != 0) { oDescriptor = readBTNodeDescriptor(descriptor->fLink, tree); oDescriptor->bLink = descriptor->bLink; ASSERT(writeBTNodeDescriptor(oDescriptor, descriptor->fLink, tree), "writeBTNodeDescriptor"); free(oDescriptor); } - + free(descriptor); - + ASSERT(WRITE(tree->io, mapRecordStart + (node / 8), 1, &byte), "WRITE"); ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec"); - + return TRUE; } static uint32_t splitNode(uint32_t node, BTNodeDescriptor* descriptor, BTree* tree) { int nodesToMove; - + int i; off_t internalOffset; - + BTNodeDescriptor* fDescriptor; - + BTNodeDescriptor newDescriptor; uint32_t newNodeNum; off_t newNodeOffset; - + off_t toMove; size_t toMoveLength; unsigned char *buffer; - + off_t offsetsToMove; size_t offsetsToMoveLength; uint16_t *offsetsBuffer; - + nodesToMove = descriptor->numRecords - (descriptor->numRecords/2); - + toMove = getRecordOffset(descriptor->numRecords/2, node, tree); toMoveLength = getRecordOffset(descriptor->numRecords, node, tree) - toMove; buffer = (unsigned char *)malloc(toMoveLength); ASSERT(READ(tree->io, toMove, toMoveLength, buffer), "READ"); - + offsetsToMove = (node * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * (descriptor->numRecords + 1)); offsetsToMoveLength = sizeof(uint16_t) * (nodesToMove + 1); offsetsBuffer = (uint16_t *)malloc(offsetsToMoveLength); ASSERT(READ(tree->io, offsetsToMove, offsetsToMoveLength, offsetsBuffer), "READ"); - + for(i = 0; i < (nodesToMove + 1); i++) { FLIPENDIAN(offsetsBuffer[i]); } - + internalOffset = offsetsBuffer[nodesToMove] - 14; - + for(i = 0; i < (nodesToMove + 1); i++) { offsetsBuffer[i] -= internalOffset; FLIPENDIAN(offsetsBuffer[i]); } - + newNodeNum = getNewNode(tree); newNodeOffset = newNodeNum * tree->headerRec->nodeSize; - + newDescriptor.fLink = descriptor->fLink; newDescriptor.bLink = node; newDescriptor.kind = descriptor->kind; @@ -966,32 +966,32 @@ static uint32_t splitNode(uint32_t node, BTNodeDescriptor* descriptor, BTree* tr newDescriptor.numRecords = nodesToMove; newDescriptor.reserved = 0; ASSERT(writeBTNodeDescriptor(&newDescriptor, newNodeNum, tree), "writeBTNodeDescriptor"); - - if(newDescriptor.fLink != 0) { + + if(newDescriptor.fLink != 0) { fDescriptor = readBTNodeDescriptor(newDescriptor.fLink, tree); fDescriptor->bLink = newNodeNum; ASSERT(writeBTNodeDescriptor(fDescriptor, newDescriptor.fLink, tree), "writeBTNodeDescriptor"); free(fDescriptor); } - + descriptor->fLink = newNodeNum; descriptor->numRecords = descriptor->numRecords/2; ASSERT(writeBTNodeDescriptor(descriptor, node, tree), "writeBTNodeDescriptor"); - + ASSERT(WRITE(tree->io, newNodeOffset + 14, toMoveLength, buffer), "WRITE"); ASSERT(WRITE(tree->io, newNodeOffset + tree->headerRec->nodeSize - (sizeof(uint16_t) * (nodesToMove + 1)), offsetsToMoveLength, offsetsBuffer), "WRITE"); - + // The offset for the existing descriptor's new numRecords will happen to be where the old data was, which is now where the free space starts // So we don't have to manually set the free space offset - + free(buffer); free(offsetsBuffer); - + if(descriptor->kind == kBTLeafNode && node == tree->headerRec->lastLeafNode) { tree->headerRec->lastLeafNode = newNodeNum; ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec"); } - + return newNodeNum; } @@ -999,33 +999,33 @@ static int moveRecordsDown(BTree* tree, BTNodeDescriptor* descriptor, int record off_t firstRecordStart; off_t lastRecordEnd; unsigned char* records; - + off_t firstOffsetStart; off_t lastOffsetEnd; uint16_t* offsets; - - int i; - + + int i; + firstRecordStart = getRecordOffset(record, node, tree); lastRecordEnd = getRecordOffset(descriptor->numRecords, node, tree); - + records = (unsigned char*)malloc(lastRecordEnd - firstRecordStart); - + ASSERT(READ(tree->io, firstRecordStart, lastRecordEnd - firstRecordStart, records), "READ"); firstOffsetStart = (node * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * (descriptor->numRecords + 1)); lastOffsetEnd = (node * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * record); - + offsets = (uint16_t*)malloc(lastOffsetEnd - firstOffsetStart); ASSERT(READ(tree->io, firstOffsetStart, lastOffsetEnd - firstOffsetStart, offsets), "READ"); - + for(i = 0; i < (lastOffsetEnd - firstOffsetStart)/sizeof(uint16_t); i++) { FLIPENDIAN(offsets[i]); offsets[i] += length; FLIPENDIAN(offsets[i]); } - + ASSERT(WRITE(tree->io, firstRecordStart + length, lastRecordEnd - firstRecordStart, records), "WRITE"); - + if(moveOffsets > 0) { ASSERT(WRITE(tree->io, firstOffsetStart - sizeof(uint16_t), lastOffsetEnd - firstOffsetStart, offsets), "WRITE"); } else if(moveOffsets < 0) { @@ -1033,10 +1033,10 @@ static int moveRecordsDown(BTree* tree, BTNodeDescriptor* descriptor, int record } else { ASSERT(WRITE(tree->io, firstOffsetStart, lastOffsetEnd - firstOffsetStart, offsets), "WRITE"); } - + free(records); free(offsets); - + return TRUE; } @@ -1051,45 +1051,45 @@ static int doAddRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t leng int res; int i; - + descriptor = readBTNodeDescriptor(root, tree); - + if(descriptor == NULL) return FALSE; - + lastRecordDataOffset = 0; - + for(i = 0; i < descriptor->numRecords; i++) { recordOffset = getRecordOffset(i, root, tree); key = READ_KEY(tree, recordOffset, tree->io); recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength); - + res = COMPARE(tree, key, searchKey); if(res == 0) { free(key); free(descriptor); - + return FALSE; } else if(res > 0) { free(key); - + break; } - + free(key); - + lastRecordDataOffset = recordDataOffset; } - + if(i != descriptor->numRecords) { // first, move everyone else down - + moveRecordsDown(tree, descriptor, i, root, sizeof(searchKey->keyLength) + searchKey->keyLength + length, 1); - + // then insert ourself ASSERT(WRITE_KEY(tree, recordOffset, searchKey, tree->io), "WRITE_KEY"); ASSERT(WRITE(tree->io, recordOffset + sizeof(searchKey->keyLength) + searchKey->keyLength, length, content), "WRITE"); - + offset = recordOffset - (root * tree->headerRec->nodeSize); FLIPENDIAN(offset); ASSERT(WRITE(tree->io, (root * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * (i + 1)), @@ -1099,23 +1099,23 @@ static int doAddRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t leng recordOffset = getRecordOffset(i, root, tree); ASSERT(WRITE_KEY(tree, recordOffset, searchKey, tree->io), "WRITE_KEY"); ASSERT(WRITE(tree->io, recordOffset + sizeof(uint16_t) + searchKey->keyLength, length, content), "WRITE"); - + // write the new free offset offset = (recordOffset + sizeof(searchKey->keyLength) + searchKey->keyLength + length) - (root * tree->headerRec->nodeSize); FLIPENDIAN(offset); ASSERT(WRITE(tree->io, (root * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * (descriptor->numRecords + 2)), sizeof(uint16_t), &offset), "WRITE"); } - + descriptor->numRecords++; - + if(descriptor->height == 1) { tree->headerRec->leafRecords++; } ASSERT(writeBTNodeDescriptor(descriptor, root, tree), "writeBTNodeDescriptor"); ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec"); - + free(descriptor); return TRUE; } @@ -1126,49 +1126,49 @@ static int addRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t length off_t recordOffset; off_t recordDataOffset; off_t lastRecordDataOffset; - + size_t freeSpace; - + int res; int i; - + uint32_t newNode; uint32_t newNodeBigEndian; - + uint32_t nodeBigEndian; - + descriptor = readBTNodeDescriptor(root, tree); - + if(descriptor == NULL) return 0; - + freeSpace = getFreeSpace(root, descriptor, tree); - + lastRecordDataOffset = 0; - + for(i = 0; i < descriptor->numRecords; i++) { recordOffset = getRecordOffset(i, root, tree); key = READ_KEY(tree, recordOffset, tree->io); recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength); - + res = COMPARE(tree, key, searchKey); if(res == 0) { free(key); free(descriptor); - + return 0; } else if(res > 0) { free(key); - + break; } - + free(key); - + lastRecordDataOffset = recordDataOffset; } - - if(descriptor->kind == kBTLeafNode) { + + if(descriptor->kind == kBTLeafNode) { if(freeSpace < (sizeof(searchKey->keyLength) + searchKey->keyLength + length + sizeof(uint16_t))) { newNode = splitNode(root, descriptor, tree); if(i < descriptor->numRecords) { @@ -1176,33 +1176,33 @@ static int addRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t length } else { doAddRecord(tree, newNode, searchKey, length, content); } - + free(descriptor); return newNode; } else { doAddRecord(tree, root, searchKey, length, content); - + free(descriptor); return 0; } - } else { + } else { if(lastRecordDataOffset == 0) { if(descriptor->numRecords == 0) { hfs_panic("empty index node in btree"); return 0; } - + key = READ_KEY(tree, (root * tree->headerRec->nodeSize) + 14, tree->io); - + recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength); nodeBigEndian = getNodeNumberFromPointerRecord(recordDataOffset, tree->io); - + FLIPENDIAN(nodeBigEndian); - + free(key); key = READ_KEY(tree, (root * tree->headerRec->nodeSize) + 14, tree->io); recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength); - + if(searchKey->keyLength != key->keyLength) { if(searchKey->keyLength > key->keyLength && freeSpace < (searchKey->keyLength - key->keyLength)) { // very unlikely. We need to split this node before we can resize the key of this index. Do that first, and tell them to call again. @@ -1212,19 +1212,19 @@ static int addRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t length moveRecordsDown(tree, descriptor, 1, root, searchKey->keyLength - key->keyLength, 0); } - + free(key); - + ASSERT(WRITE_KEY(tree, recordOffset, searchKey, tree->io), "WRITE_KEY"); ASSERT(WRITE(tree->io, recordOffset + sizeof(uint16_t) + searchKey->keyLength, sizeof(uint32_t), &nodeBigEndian), "WRITE"); - + FLIPENDIAN(nodeBigEndian); - + newNode = addRecord(tree, nodeBigEndian, searchKey, length, content, callAgain); } else { newNode = addRecord(tree, getNodeNumberFromPointerRecord(lastRecordDataOffset, tree->io), searchKey, length, content, callAgain); } - + if(newNode == 0) { free(descriptor); return 0; @@ -1232,22 +1232,22 @@ static int addRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t length newNodeBigEndian = newNode; key = READ_KEY(tree, newNode * tree->headerRec->nodeSize + 14, tree->io); FLIPENDIAN(newNodeBigEndian); - + if(freeSpace < (sizeof(key->keyLength) + key->keyLength + sizeof(newNodeBigEndian) + sizeof(uint16_t))) { newNode = splitNode(root, descriptor, tree); - + if(i < descriptor->numRecords) { doAddRecord(tree, root, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian)); } else { doAddRecord(tree, newNode, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian)); } - + free(key); free(descriptor); return newNode; } else { doAddRecord(tree, root, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian)); - + free(key); free(descriptor); return 0; @@ -1260,35 +1260,35 @@ static int increaseHeight(BTree* tree, uint32_t newNode) { uint32_t oldRoot; uint32_t newRoot; BTNodeDescriptor newDescriptor; - + BTKey* oldRootKey; BTKey* newNodeKey; - + uint16_t oldRootOffset; uint16_t newNodeOffset; uint16_t freeOffset; - + oldRoot = tree->headerRec->rootNode; - + oldRootKey = READ_KEY(tree, (oldRoot * tree->headerRec->nodeSize) + 14, tree->io); newNodeKey = READ_KEY(tree, (newNode * tree->headerRec->nodeSize) + 14, tree->io); - + newRoot = getNewNode(tree); - + newDescriptor.fLink = 0; newDescriptor.bLink = 0; newDescriptor.kind = kBTIndexNode; newDescriptor.height = tree->headerRec->treeDepth + 1; newDescriptor.numRecords = 2; newDescriptor.reserved = 0; - + oldRootOffset = 14; newNodeOffset = oldRootOffset + sizeof(oldRootKey->keyLength) + oldRootKey->keyLength + sizeof(uint32_t); freeOffset = newNodeOffset + sizeof(newNodeKey->keyLength) + newNodeKey->keyLength + sizeof(uint32_t); - + tree->headerRec->rootNode = newRoot; tree->headerRec->treeDepth = newDescriptor.height; - + ASSERT(WRITE_KEY(tree, newRoot * tree->headerRec->nodeSize + oldRootOffset, oldRootKey, tree->io), "WRITE_KEY"); FLIPENDIAN(oldRoot); ASSERT(WRITE(tree->io, newRoot * tree->headerRec->nodeSize + oldRootOffset + sizeof(oldRootKey->keyLength) + oldRootKey->keyLength, @@ -1298,15 +1298,15 @@ static int increaseHeight(BTree* tree, uint32_t newNode) { FLIPENDIAN(newNode); ASSERT(WRITE(tree->io, newRoot * tree->headerRec->nodeSize + newNodeOffset + sizeof(newNodeKey->keyLength) + newNodeKey->keyLength, sizeof(uint32_t), &newNode), "WRITE"); - + FLIPENDIAN(oldRootOffset); ASSERT(WRITE(tree->io, (newRoot * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 1), sizeof(uint16_t), &oldRootOffset), "WRITE"); - + FLIPENDIAN(newNodeOffset); ASSERT(WRITE(tree->io, (newRoot * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 2), sizeof(uint16_t), &newNodeOffset), "WRITE"); - + FLIPENDIAN(freeOffset); ASSERT(WRITE(tree->io, (newRoot * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 3), sizeof(uint16_t), &freeOffset), "WRITE"); @@ -1315,7 +1315,7 @@ static int increaseHeight(BTree* tree, uint32_t newNode) { ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec"); free(oldRootKey); - free(newNodeKey); + free(newNodeKey); return TRUE; } @@ -1325,7 +1325,7 @@ int addToBTree(BTree* tree, BTKey* searchKey, size_t length, unsigned char* cont uint16_t offset; uint16_t freeOffset; uint32_t newNode; - + if(tree->headerRec->rootNode != 0) { do { callAgain = FALSE; @@ -1341,25 +1341,25 @@ int addToBTree(BTree* tree, BTKey* searchKey, size_t length, unsigned char* cont tree->headerRec->lastLeafNode = tree->headerRec->rootNode; tree->headerRec->leafRecords = 1; tree->headerRec->treeDepth = 1; - + newDescriptor.fLink = 0; newDescriptor.bLink = 0; newDescriptor.kind = kBTLeafNode; newDescriptor.height = 1; newDescriptor.numRecords = 1; newDescriptor.reserved = 0; - + offset = 14; freeOffset = offset + sizeof(searchKey->keyLength) + searchKey->keyLength + length; - - ASSERT(WRITE_KEY(tree, tree->headerRec->rootNode * tree->headerRec->nodeSize + offset, searchKey, tree->io), "WRITE_KEY"); + + ASSERT(WRITE_KEY(tree, tree->headerRec->rootNode * tree->headerRec->nodeSize + offset, searchKey, tree->io), "WRITE_KEY"); ASSERT(WRITE(tree->io, tree->headerRec->rootNode * tree->headerRec->nodeSize + offset + sizeof(searchKey->keyLength) + searchKey->keyLength, length, content), "WRITE"); - + FLIPENDIAN(offset); ASSERT(WRITE(tree->io, (tree->headerRec->rootNode * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 1), sizeof(uint16_t), &offset), "WRITE"); - + FLIPENDIAN(freeOffset); ASSERT(WRITE(tree->io, (tree->headerRec->rootNode * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 2), sizeof(uint16_t), &freeOffset), "WRITE"); @@ -1367,7 +1367,7 @@ int addToBTree(BTree* tree, BTKey* searchKey, size_t length, unsigned char* cont ASSERT(writeBTNodeDescriptor(&newDescriptor, tree->headerRec->rootNode, tree), "writeBTNodeDescriptor"); ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec"); } - + return TRUE; } @@ -1376,52 +1376,52 @@ static uint32_t removeRecord(BTree* tree, uint32_t root, BTKey* searchKey, int* int length; int i; int res; - + uint32_t newNode; uint32_t nodeToTraverse; uint32_t newNodeBigEndian; - + BTKey* key; off_t recordOffset; off_t recordDataOffset; off_t lastRecordDataOffset; - + int childGone; int checkForChangedKey ; - + size_t freeSpace; - + descriptor = readBTNodeDescriptor(root, tree); - + freeSpace = getFreeSpace(root, descriptor, tree); - + nodeToTraverse = 0; lastRecordDataOffset = 0; newNode = 0; - + (*gone) = FALSE; checkForChangedKey = FALSE; - + for(i = 0; i < descriptor->numRecords; i++) { recordOffset = getRecordOffset(i, root, tree); key = READ_KEY(tree, recordOffset, tree->io); recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength); - + res = COMPARE(tree, key, searchKey); if(res == 0) { free(key); - + if(descriptor->kind == kBTLeafNode) { if(i != (descriptor->numRecords - 1)) { length = getRecordOffset(i + 1, root, tree) - recordOffset; moveRecordsDown(tree, descriptor, i + 1, root, -length, -1); } // don't need to do that if we're the last record, because our old offset pointer will be the new free space pointer - + descriptor->numRecords--; tree->headerRec->leafRecords--; ASSERT(writeBTNodeDescriptor(descriptor, root, tree), "writeBTNodeDescriptor"); ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec"); - + if(descriptor->numRecords >= 1) { free(descriptor); return 0; @@ -1438,7 +1438,7 @@ static uint32_t removeRecord(BTree* tree, uint32_t root, BTKey* searchKey, int* } } else if(res > 0) { free(key); - + if(lastRecordDataOffset == 0 || descriptor->kind == kBTLeafNode) { // not found; free(descriptor); @@ -1448,94 +1448,94 @@ static uint32_t removeRecord(BTree* tree, uint32_t root, BTKey* searchKey, int* break; } } - + lastRecordDataOffset = recordDataOffset; - + free(key); } - + if(nodeToTraverse == 0) { nodeToTraverse = getNodeNumberFromPointerRecord(lastRecordDataOffset, tree->io); } - + if(i == descriptor->numRecords) { i = descriptor->numRecords - 1; } - + newNode = removeRecord(tree, nodeToTraverse, searchKey, callAgain, &childGone); - + if(childGone) { if(i != (descriptor->numRecords - 1)) { length = getRecordOffset(i + 1, root, tree) - recordOffset; moveRecordsDown(tree, descriptor, i + 1, root, -length, -1); } // don't need to do that if we're the last record, because our old offset pointer will be the new free space pointer - + descriptor->numRecords--; ASSERT(writeBTNodeDescriptor(descriptor, root, tree), "writeBTNodeDescriptor"); } else { if(checkForChangedKey) { // we will remove the first item in the child node, so our index has to change - + key = READ_KEY(tree, getRecordOffset(0, nodeToTraverse, tree), tree->io); - + if(searchKey->keyLength != key->keyLength) { if(key->keyLength > searchKey->keyLength && freeSpace < (key->keyLength - searchKey->keyLength)) { // very unlikely. We need to split this node before we can resize the key of this index. Do that first, and tell them to call again. *callAgain = TRUE; return splitNode(root, descriptor, tree); } - + moveRecordsDown(tree, descriptor, i + 1, root, key->keyLength - searchKey->keyLength, 0); } - + ASSERT(WRITE_KEY(tree, recordOffset, key, tree->io), "WRITE_KEY"); FLIPENDIAN(nodeToTraverse); ASSERT(WRITE(tree->io, recordOffset + sizeof(uint16_t) + key->keyLength, sizeof(uint32_t), &nodeToTraverse), "WRITE"); FLIPENDIAN(nodeToTraverse); - + free(key); } } - + if(newNode == 0) { if(descriptor->numRecords == 0) { removeNode(tree, root); (*gone) = TRUE; } - + free(descriptor); return 0; } else { newNodeBigEndian = newNode; key = READ_KEY(tree, newNode * tree->headerRec->nodeSize + 14, tree->io); FLIPENDIAN(newNodeBigEndian); - + if(freeSpace < (sizeof(key->keyLength) + key->keyLength + sizeof(newNodeBigEndian) + sizeof(uint16_t))) { newNode = splitNode(root, descriptor, tree); - + if(i < descriptor->numRecords) { doAddRecord(tree, root, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian)); } else { doAddRecord(tree, newNode, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian)); } - + if(descriptor->numRecords == 0) { removeNode(tree, root); (*gone) = TRUE; } - + free(key); free(descriptor); return newNode; } else { doAddRecord(tree, root, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian)); - + free(key); free(descriptor); return 0; } } - + return FALSE; } @@ -1543,7 +1543,7 @@ int removeFromBTree(BTree* tree, BTKey* searchKey) { int callAgain; int gone; uint32_t newNode; - + do { callAgain = FALSE; newNode = removeRecord(tree, tree->headerRec->rootNode, searchKey, &callAgain, &gone); diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/hfs/fastunicodecompare.c b/third_party/libdmg-hfsplus/src/hfs/fastunicodecompare.c index 25793b3251dcd..454cb00da7a2f 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/hfs/fastunicodecompare.c +++ b/third_party/libdmg-hfsplus/src/hfs/fastunicodecompare.c @@ -401,10 +401,10 @@ int32_t FastUnicodeCompare ( register uint16_t str1[], register uint16_t length1 c2 = lowerCaseTable[temp + (c2 & 0x00FF)]; } if (c1 == ':') { - c1 = '/'; + c1 = '/'; } if (c2 == ':') { - c2 = '/'; + c2 = '/'; } if (c1 != c2) break; diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/common.h b/third_party/libdmg-hfsplus/src/includes/common.h index ec91b064c7016..4697c32d46ef2 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/common.h +++ b/third_party/libdmg-hfsplus/src/includes/common.h @@ -9,7 +9,7 @@ #include // strlcpy looks useful, but not part of POSIX libc. BSD-inspired libc may -// have it, but (as of 2025-Oct-2) Mozilla's build environment for +// have it, but (as of 2025-Oct-2) Mozilla's build environment for // libdmg-hfsplus doesn't. #ifdef strlcpy #undef strlcpy diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/dmg/attribution.h b/third_party/libdmg-hfsplus/src/includes/dmg/attribution.h index b13d1308dc84e..a84509cd8b869 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/dmg/attribution.h +++ b/third_party/libdmg-hfsplus/src/includes/dmg/attribution.h @@ -30,31 +30,31 @@ // part of a Base64 encoded struct. We can Base64 decode to bytes, // swizzle the 4 bytes of the checksum, and then Base64 encode back // to the same number of bytes. - /* */ - /* blkx */ - /* */ - /* */ - /* Attributes */ - /* 0x0050 */ - /* CFName */ - /* Driver Descriptor Map (DDM : 0) */ - /* Data */ - /* */ - /* bWlzaAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAA */ - /* AAII/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ - /* AAIAAAAgXDMYCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ - /* AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ - /* AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ - /* AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ - /* AAAAAAACgAAABgAAAAAAAAAAAAAAAAAAAAAAAAABAAAA */ - /* AAAAAAAAAAAAAAAANf////8AAAAAAAAAAAAAAAEAAAAA */ - /* AAAAAAAAAAAAAAA1AAAAAAAAAAA= */ - /* */ - /* ID */ - /* -1 */ - /* Name */ - /* Driver Descriptor Map (DDM : 0) */ - /* */ + /* */ + /* blkx */ + /* */ + /* */ + /* Attributes */ + /* 0x0050 */ + /* CFName */ + /* Driver Descriptor Map (DDM : 0) */ + /* Data */ + /* */ + /* bWlzaAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAA */ + /* AAII/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ + /* AAIAAAAgXDMYCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ + /* AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ + /* AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ + /* AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */ + /* AAAAAAACgAAABgAAAAAAAAAAAAAAAAAAAAAAAAABAAAA */ + /* AAAAAAAAAAAAAAAANf////8AAAAAAAAAAAAAAAEAAAAA */ + /* AAAAAAAAAAAAAAA1AAAAAAAAAAA= */ + /* */ + /* ID */ + /* -1 */ + /* Name */ + /* Driver Descriptor Map (DDM : 0) */ + /* */ /** * Binary representation of data needed to quickly "attribute" a DMG that is diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/dmg/compress.h b/third_party/libdmg-hfsplus/src/includes/dmg/compress.h index ef4126b7b8bf5..9647cb177c14d 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/dmg/compress.h +++ b/third_party/libdmg-hfsplus/src/includes/dmg/compress.h @@ -20,7 +20,7 @@ typedef int (*CompressFunc)(unsigned char *inBuffer, size_t inSize, typedef size_t (*DecompressBufferFunc)(size_t runSectors); typedef struct { - CompressFunc compress; + CompressFunc compressFn; DecompressBufferFunc decompressBuffer; int level; uint32_t block_type; diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/hfs/hfsplus.h b/third_party/libdmg-hfsplus/src/includes/hfs/hfsplus.h index e62bd3b8d2a50..a6f51caf37265 100644 --- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/hfs/hfsplus.h +++ b/third_party/libdmg-hfsplus/src/includes/hfs/hfsplus.h @@ -70,7 +70,7 @@ struct HFSPlusForkData { HFSPlusExtentRecord extents; } __attribute__((__packed__)); typedef struct HFSPlusForkData HFSPlusForkData; - + struct HFSPlusVolumeHeader { uint16_t signature; uint16_t version; @@ -178,7 +178,7 @@ struct Rect { } __attribute__((__packed__)); typedef struct Rect Rect; -/* OSType is a 32-bit value made by packing four 1-byte characters +/* OSType is a 32-bit value made by packing four 1-byte characters together. */ typedef uint32_t FourCharCode; typedef FourCharCode OSType; @@ -190,19 +190,19 @@ enum { kIsOnDesk = 0x0001, /* Files and folders (System 6) */ kColor = 0x000E, /* Files and folders */ kIsShared = 0x0040, /* Files only (Applications only) If */ - /* clear, the application needs */ - /* to write to its resource fork, */ - /* and therefore cannot be shared */ - /* on a server */ + /* clear, the application needs */ + /* to write to its resource fork, */ + /* and therefore cannot be shared */ + /* on a server */ kHasNoINITs = 0x0080, /* Files only (Extensions/Control */ - /* Panels only) */ - /* This file contains no INIT resource */ + /* Panels only) */ + /* This file contains no INIT resource */ kHasBeenInited = 0x0100, /* Files only. Clear if the file */ - /* contains desktop database resources */ - /* ('BNDL', 'FREF', 'open', 'kind'...) */ - /* that have not been added yet. Set */ - /* only by the Finder. */ - /* Reserved for folders */ + /* contains desktop database resources */ + /* ('BNDL', 'FREF', 'open', 'kind'...) */ + /* that have not been added yet. Set */ + /* only by the Finder. */ + /* Reserved for folders */ kHasCustomIcon = 0x0400, /* Files and folders */ kIsStationery = 0x0800, /* Files only */ kNameLocked = 0x1000, /* Files and folders */ @@ -214,11 +214,11 @@ enum { /* Extended flags (extendedFinderFlags, fdXFlags and frXFlags) */ enum { kExtendedFlagsAreInvalid = 0x8000, /* The other extended flags */ - /* should be ignored */ + /* should be ignored */ kExtendedFlagHasCustomBadge = 0x0100, /* The file or folder has a */ - /* badge resource */ + /* badge resource */ kExtendedFlagHasRoutingInfo = 0x0004 /* The file contains routing */ - /* info resource */ + /* info resource */ }; enum { @@ -245,11 +245,11 @@ typedef struct ExtendedFileInfo ExtendedFileInfo; struct FolderInfo { Rect windowBounds; /* The position and dimension of the */ - /* folder's window */ + /* folder's window */ uint16_t finderFlags; Point location; /* Folder's location in the parent */ - /* folder. If set to {0, 0}, the Finder */ - /* will place the item automatically */ + /* folder. If set to {0, 0}, the Finder */ + /* will place the item automatically */ uint16_t reservedField; } __attribute__((__packed__)); typedef struct FolderInfo FolderInfo; @@ -321,28 +321,25 @@ enum { kHFSPlusFileThreadRecord = 0x0004 /* HFSPlusCatalogThread */ }; -/* Flags enum for HFSPlusCatalogFolder and HFSPlusCatalogFile types. The - location that would contain these flags is reserved in HFSPlusCatalogThread. - Stored as `uint16_t flags` in the two types where it is specified. */ enum { kHFSFileLockedBit = 0x0000, /* file is locked and cannot be written to */ kHFSFileLockedMask = 0x0001, - + kHFSThreadExistsBit = 0x0001, /* a file thread record exists for this file */ kHFSThreadExistsMask = 0x0002, - + kHFSHasAttributesBit = 0x0002, /* object has extended attributes */ kHFSHasAttributesMask = 0x0004, - + kHFSHasSecurityBit = 0x0003, /* object has security data (ACLs) */ kHFSHasSecurityMask = 0x0008, - + kHFSHasFolderCountBit = 0x0004, /* only for HFSX, folder maintains a separate sub-folder count */ kHFSHasFolderCountMask = 0x0010, /* (sum of folder records and directory hard links) */ - + kHFSHasLinkChainBit = 0x0005, /* has hardlink chain (inode or link) */ kHFSHasLinkChainMask = 0x0020, - + kHFSHasChildLinkBit = 0x0006, /* folder has a child that's a dir link */ kHFSHasChildLinkMask = 0x0040 }; @@ -448,8 +445,8 @@ enum { /* HFSPlusCatalogRecord contains a record for some item inside an HFSPlus file system's catalog, of indefinite size. Use the recordType field to - determine how to interpret the record (generally by casting the pointer to - HFSPlusCatalogFolder, HFSPlusCatalogFile, or HFSPlusCatalogThread). **/ + determine how to interpret the record (generally by casting the pointer to + FSPlusCatalogFolder, HFSPlusCatalogFile, or HFSPlusCatalogThread). */ struct HFSPlusCatalogRecord { int16_t recordType; unsigned char data[0]; @@ -458,7 +455,7 @@ typedef struct HFSPlusCatalogRecord HFSPlusCatalogRecord; /* CatalogRecordList is a singly-linked list of HFSPlusCatalogRecord entries, each associated with a name. To recursively free CatalogRecordList, use - releaseCatalogRecordList(CatalogRecordList*). */ + releaseCatalogRecordList(CatalogRecordList*). */ struct CatalogRecordList { HFSUniStr255 name; HFSPlusCatalogRecord* record; @@ -467,9 +464,9 @@ struct CatalogRecordList { typedef struct CatalogRecordList CatalogRecordList; /* XAttrList is a singly-linked list of extended attribute names. Names are - * null-terminated Unicode strings uniquely owned by the XAttrList instance. - * The owner of the list is responsible for walking the list and recursively - * freeing all data in it when the list should be disposed. */ + null-terminated Unicode strings uniquely owned by the XAttrList instance. + The owner of the list is responsible for walking the list and recursively + freeing all data in it when the list should be disposed. */ struct XAttrList { char* name; struct XAttrList* next;