293 lines
8.8 KiB
C
293 lines
8.8 KiB
C
#include <zlib.h>
|
|
#include "common.h"
|
|
#include <hfs/hfsplus.h>
|
|
#include <hfs/hfscompress.h>
|
|
|
|
void flipHFSPlusDecmpfs(HFSPlusDecmpfs* compressData) {
|
|
FLIPENDIANLE(compressData->magic);
|
|
FLIPENDIANLE(compressData->flags);
|
|
FLIPENDIANLE(compressData->size);
|
|
}
|
|
|
|
void flipRsrcHead(HFSPlusCmpfRsrcHead* data) {
|
|
FLIPENDIAN(data->headerSize);
|
|
FLIPENDIAN(data->totalSize);
|
|
FLIPENDIAN(data->dataSize);
|
|
FLIPENDIAN(data->flags);
|
|
}
|
|
|
|
void flipRsrcBlockHead(HFSPlusCmpfRsrcBlockHead* data) {
|
|
FLIPENDIAN(data->dataSize);
|
|
FLIPENDIANLE(data->numBlocks);
|
|
}
|
|
|
|
void flipRsrcBlock(HFSPlusCmpfRsrcBlock* data) {
|
|
FLIPENDIANLE(data->offset);
|
|
FLIPENDIANLE(data->size);
|
|
}
|
|
|
|
void flipHFSPlusCmpfEnd(HFSPlusCmpfEnd* data) {
|
|
FLIPENDIAN(data->unk1);
|
|
FLIPENDIAN(data->unk2);
|
|
FLIPENDIAN(data->unk3);
|
|
FLIPENDIAN(data->magic);
|
|
FLIPENDIAN(data->flags);
|
|
FLIPENDIANLE(data->size);
|
|
FLIPENDIANLE(data->unk4);
|
|
}
|
|
|
|
static int compressedRead(io_func* io, off_t location, size_t size, void *buffer) {
|
|
HFSPlusCompressed* data = (HFSPlusCompressed*) io->data;
|
|
size_t toRead;
|
|
|
|
while(size > 0) {
|
|
if(data->cached && location >= data->cachedStart && location < data->cachedEnd) {
|
|
if((data->cachedEnd - location) < size)
|
|
toRead = data->cachedEnd - location;
|
|
else
|
|
toRead = size;
|
|
|
|
memcpy(buffer, data->cached + (location - data->cachedStart), toRead);
|
|
|
|
size -= toRead;
|
|
location += toRead;
|
|
buffer = ((uint8_t*) buffer) + toRead;
|
|
}
|
|
|
|
if(size == 0)
|
|
break;
|
|
|
|
// Try to cache
|
|
uLongf actualSize;
|
|
uint32_t block = location / 0x10000;
|
|
uint8_t* compressed = (uint8_t*) malloc(data->blocks->blocks[block].size);
|
|
if(!READ(data->io, data->rsrcHead.headerSize + sizeof(uint32_t) + data->blocks->blocks[block].offset, data->blocks->blocks[block].size, compressed)) {
|
|
hfs_panic("error reading");
|
|
}
|
|
|
|
if(data->cached)
|
|
free(data->cached);
|
|
|
|
data->cached = (uint8_t*) malloc(0x10000);
|
|
actualSize = 0x10000;
|
|
uncompress(data->cached, &actualSize, compressed, data->blocks->blocks[block].size);
|
|
data->cachedStart = block * 0x10000;
|
|
data->cachedEnd = data->cachedStart + actualSize;
|
|
free(compressed);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static int compressedWrite(io_func* io, off_t location, size_t size, void *buffer) {
|
|
HFSPlusCompressed* data = (HFSPlusCompressed*) io->data;
|
|
|
|
if(data->cachedStart != 0 || data->cachedEnd != data->decmpfs->size) {
|
|
// Cache entire file
|
|
uint8_t* newCache = (uint8_t*) malloc(data->decmpfs->size);
|
|
compressedRead(io, 0, data->decmpfs->size, newCache);
|
|
if(data->cached)
|
|
free(data->cached);
|
|
|
|
data->cached = newCache;
|
|
data->cachedStart = 0;
|
|
data->cachedEnd = data->decmpfs->size;
|
|
}
|
|
|
|
if((location + size) > data->decmpfs->size) {
|
|
data->decmpfs->size = location + size;
|
|
data->cached = (uint8_t*) realloc(data->cached, data->decmpfs->size);
|
|
data->cachedEnd = data->decmpfs->size;
|
|
}
|
|
|
|
memcpy(data->cached + location, buffer, size);
|
|
|
|
data->dirty = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
static void closeHFSPlusCompressed(io_func* io) {
|
|
HFSPlusCompressed* data = (HFSPlusCompressed*) io->data;
|
|
|
|
if(data->io)
|
|
CLOSE(data->io);
|
|
|
|
if(data->dirty) {
|
|
if(data->blocks)
|
|
free(data->blocks);
|
|
|
|
data->decmpfs->magic = CMPFS_MAGIC;
|
|
data->decmpfs->flags = 0x4;
|
|
data->decmpfsSize = sizeof(HFSPlusDecmpfs);
|
|
|
|
uint32_t numBlocks = (data->decmpfs->size + 0xFFFF) / 0x10000;
|
|
uint32_t blocksSize = sizeof(HFSPlusCmpfRsrcBlockHead) + (numBlocks * sizeof(HFSPlusCmpfRsrcBlock));
|
|
data->blocks = (HFSPlusCmpfRsrcBlockHead*) malloc(sizeof(HFSPlusCmpfRsrcBlockHead) + (numBlocks * sizeof(HFSPlusCmpfRsrcBlock)));
|
|
data->blocks->numBlocks = numBlocks;
|
|
data->blocks->dataSize = blocksSize - sizeof(uint32_t); // without the front dataSize in BlockHead.
|
|
|
|
data->rsrcHead.headerSize = 0x100;
|
|
data->rsrcHead.dataSize = blocksSize;
|
|
data->rsrcHead.totalSize = data->rsrcHead.headerSize + data->rsrcHead.dataSize;
|
|
data->rsrcHead.flags = 0x32;
|
|
|
|
uint8_t* buffer = (uint8_t*) malloc((0x10000 * 1.1) + 12);
|
|
uint32_t curFileOffset = data->blocks->dataSize;
|
|
uint32_t i;
|
|
for(i = 0; i < numBlocks; i++) {
|
|
data->blocks->blocks[i].offset = curFileOffset;
|
|
uLongf actualSize = (0x10000 * 1.1) + 12;
|
|
compress(buffer, &actualSize, data->cached + (0x10000 * i),
|
|
(data->decmpfs->size - (0x10000 * i)) > 0x10000 ? 0x10000 : (data->decmpfs->size - (0x10000 * i)));
|
|
data->blocks->blocks[i].size = actualSize;
|
|
|
|
// check if we can fit the whole thing into an inline extended attribute
|
|
// a little fudge factor here since sizeof(HFSPlusAttrKey) is bigger than it ought to be, since only 127 characters are strictly allowed
|
|
if(numBlocks <= 1 && (actualSize + sizeof(HFSPlusDecmpfs) + sizeof(HFSPlusAttrKey)) <= 0x1000) {
|
|
data->decmpfs->flags = 0x3;
|
|
memcpy(data->decmpfs->data, buffer, actualSize);
|
|
data->decmpfsSize = sizeof(HFSPlusDecmpfs) + actualSize;
|
|
printf("inline data\n");
|
|
break;
|
|
} else {
|
|
if(i == 0) {
|
|
data->io = openRawFile(data->file->fileID, &data->file->resourceFork, (HFSPlusCatalogRecord*)data->file, data->volume);
|
|
if(!data->io) {
|
|
hfs_panic("error opening resource fork");
|
|
}
|
|
}
|
|
|
|
WRITE(data->io, data->rsrcHead.headerSize + sizeof(uint32_t) + data->blocks->blocks[i].offset, data->blocks->blocks[i].size, buffer);
|
|
|
|
curFileOffset += data->blocks->blocks[i].size;
|
|
data->blocks->dataSize += data->blocks->blocks[i].size;
|
|
data->rsrcHead.dataSize += data->blocks->blocks[i].size;
|
|
data->rsrcHead.totalSize += data->blocks->blocks[i].size;
|
|
}
|
|
}
|
|
|
|
free(buffer);
|
|
|
|
if(data->decmpfs->flags == 0x4) {
|
|
flipRsrcHead(&data->rsrcHead);
|
|
WRITE(data->io, 0, sizeof(HFSPlusCmpfRsrcHead), &data->rsrcHead);
|
|
flipRsrcHead(&data->rsrcHead);
|
|
|
|
for(i = 0; i < data->blocks->numBlocks; i++) {
|
|
flipRsrcBlock(&data->blocks->blocks[i]);
|
|
}
|
|
flipRsrcBlockHead(data->blocks);
|
|
WRITE(data->io, data->rsrcHead.headerSize, blocksSize, data->blocks);
|
|
flipRsrcBlockHead(data->blocks);
|
|
for(i = 0; i < data->blocks->numBlocks; i++) {
|
|
flipRsrcBlock(&data->blocks->blocks[i]);
|
|
}
|
|
|
|
HFSPlusCmpfEnd end;
|
|
memset(&end, 0, sizeof(HFSPlusCmpfEnd));
|
|
end.unk1 = 0x1C;
|
|
end.unk2 = 0x32;
|
|
end.unk3 = 0x0;
|
|
end.magic = CMPFS_MAGIC;
|
|
end.flags = 0xA;
|
|
end.size = 0xFFFF01;
|
|
end.unk4 = 0x0;
|
|
|
|
flipHFSPlusCmpfEnd(&end);
|
|
WRITE(data->io, data->rsrcHead.totalSize, sizeof(HFSPlusCmpfEnd), &end);
|
|
flipHFSPlusCmpfEnd(&end);
|
|
|
|
CLOSE(data->io);
|
|
}
|
|
|
|
flipHFSPlusDecmpfs(data->decmpfs);
|
|
setAttribute(data->volume, data->file->fileID, "com.apple.decmpfs", (uint8_t*)(data->decmpfs), data->decmpfsSize);
|
|
flipHFSPlusDecmpfs(data->decmpfs);
|
|
}
|
|
|
|
if(data->cached)
|
|
free(data->cached);
|
|
|
|
if(data->blocks)
|
|
free(data->blocks);
|
|
|
|
free(data->decmpfs);
|
|
free(data);
|
|
free(io);
|
|
}
|
|
|
|
io_func* openHFSPlusCompressed(Volume* volume, HFSPlusCatalogFile* file) {
|
|
io_func* io;
|
|
HFSPlusCompressed* data;
|
|
uLongf actualSize;
|
|
|
|
io = (io_func*) malloc(sizeof(io_func));
|
|
data = (HFSPlusCompressed*) malloc(sizeof(HFSPlusCompressed));
|
|
|
|
data->volume = volume;
|
|
data->file = file;
|
|
|
|
io->data = data;
|
|
io->read = &compressedRead;
|
|
io->write = &compressedWrite;
|
|
io->close = &closeHFSPlusCompressed;
|
|
|
|
data->cached = NULL;
|
|
data->cachedStart = 0;
|
|
data->cachedEnd = 0;
|
|
data->io = NULL;
|
|
data->blocks = NULL;
|
|
data->dirty = FALSE;
|
|
|
|
data->decmpfsSize = getAttribute(volume, file->fileID, "com.apple.decmpfs", (uint8_t**)(&data->decmpfs));
|
|
if(data->decmpfsSize == 0) {
|
|
data->decmpfs = (HFSPlusDecmpfs*) malloc(0x1000);
|
|
data->decmpfs->size = 0;
|
|
return io; // previously not compressed file
|
|
}
|
|
|
|
flipHFSPlusDecmpfs(data->decmpfs);
|
|
|
|
if(data->decmpfs->flags == 0x3) {
|
|
data->cached = (uint8_t*) malloc(data->decmpfs->size);
|
|
actualSize = data->decmpfs->size;
|
|
uncompress(data->cached, &actualSize, data->decmpfs->data, data->decmpfsSize - sizeof(HFSPlusDecmpfs));
|
|
if(actualSize != data->decmpfs->size) {
|
|
fprintf(stderr, "decmpfs: size mismatch\n");
|
|
}
|
|
data->cachedStart = 0;
|
|
data->cachedEnd = actualSize;
|
|
} else {
|
|
data->io = openRawFile(file->fileID, &file->resourceFork, (HFSPlusCatalogRecord*)file, volume);
|
|
if(!data->io) {
|
|
hfs_panic("error opening resource fork");
|
|
}
|
|
|
|
if(!READ(data->io, 0, sizeof(HFSPlusCmpfRsrcHead), &data->rsrcHead)) {
|
|
hfs_panic("error reading");
|
|
}
|
|
|
|
flipRsrcHead(&data->rsrcHead);
|
|
|
|
data->blocks = (HFSPlusCmpfRsrcBlockHead*) malloc(sizeof(HFSPlusCmpfRsrcBlockHead));
|
|
if(!READ(data->io, data->rsrcHead.headerSize, sizeof(HFSPlusCmpfRsrcBlockHead), data->blocks)) {
|
|
hfs_panic("error reading");
|
|
}
|
|
|
|
flipRsrcBlockHead(data->blocks);
|
|
|
|
data->blocks = (HFSPlusCmpfRsrcBlockHead*) realloc(data->blocks, sizeof(HFSPlusCmpfRsrcBlockHead) + (sizeof(HFSPlusCmpfRsrcBlock) * data->blocks->numBlocks));
|
|
if(!READ(data->io, data->rsrcHead.headerSize + sizeof(HFSPlusCmpfRsrcBlockHead), sizeof(HFSPlusCmpfRsrcBlock) * data->blocks->numBlocks, data->blocks->blocks)) {
|
|
hfs_panic("error reading");
|
|
}
|
|
|
|
int i;
|
|
for(i = 0; i < data->blocks->numBlocks; i++) {
|
|
flipRsrcBlock(&data->blocks->blocks[i]);
|
|
}
|
|
}
|
|
|
|
return io;
|
|
}
|
|
|