487 lines
10 KiB
C++
487 lines
10 KiB
C++
/*
|
|
* Disk.cpp
|
|
* ProFUSE
|
|
*
|
|
* Created by Kelvin Sherlock on 12/18/08.
|
|
*
|
|
*/
|
|
|
|
#include "Disk.h"
|
|
|
|
|
|
#include "common.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
|
|
#include <algorithm>
|
|
#include <set>
|
|
#include <vector>
|
|
|
|
#include <Endian/Endian.h>
|
|
|
|
struct ucmp
|
|
{
|
|
bool operator()(unsigned a, unsigned b) const
|
|
{
|
|
return a < b;
|
|
}
|
|
};
|
|
|
|
using std::set;
|
|
using std::vector;
|
|
|
|
using namespace LittleEndian;
|
|
|
|
typedef set<unsigned, ucmp> uset;
|
|
|
|
Disk::Disk()
|
|
{
|
|
_blocks = 0;
|
|
|
|
}
|
|
|
|
Disk::~Disk()
|
|
{
|
|
}
|
|
|
|
Disk::Disk(Device::BlockDevicePointer device) :
|
|
_device(device)
|
|
{
|
|
_blocks = _device->blocks();
|
|
}
|
|
|
|
DiskPointer Disk::OpenFile(Device::BlockDevicePointer device)
|
|
{
|
|
DiskPointer disk(new Disk(device));
|
|
|
|
return disk;
|
|
}
|
|
|
|
// load the mini entry into the regular entry.
|
|
int Disk::Normalize(FileEntry &f, unsigned fork, ExtendedEntry *ee)
|
|
{
|
|
uint8_t buffer[BLOCK_SIZE];
|
|
int ok;
|
|
|
|
if (fork > 1) return -P8_INVALID_FORK;
|
|
|
|
if (f.storage_type != EXTENDED_FILE)
|
|
{
|
|
return fork == 0 ? 0 : -P8_INVALID_FORK;
|
|
}
|
|
|
|
ok = Read(f.key_pointer, buffer);
|
|
if (ok < 0) return ok;
|
|
|
|
ExtendedEntry e;
|
|
e.Load(buffer);
|
|
|
|
if (fork == 0)
|
|
{
|
|
f.storage_type = e.dataFork.storage_type;
|
|
f.key_pointer = e.dataFork.key_block;
|
|
f.eof = e.dataFork.eof;
|
|
f.blocks_used = e.dataFork.blocks_used;
|
|
}
|
|
else
|
|
{
|
|
f.storage_type = e.resourceFork.storage_type;
|
|
f.key_pointer = e.resourceFork.key_block;
|
|
f.eof = e.resourceFork.eof;
|
|
f.blocks_used = e.resourceFork.blocks_used;
|
|
}
|
|
|
|
if (ee) *ee = e;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
int Disk::Read(unsigned block, void *buffer)
|
|
{
|
|
|
|
if (block > _blocks) return -P8_INVALID_BLOCK;
|
|
|
|
_device->read(block, buffer);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
void *Disk::ReadFile(const FileEntry &f, unsigned fork, uint32_t *size, int *error)
|
|
{
|
|
|
|
#define SET_ERROR(x) if (error) *error = (x)
|
|
#define SET_SIZE(x) if (size) *size = (x)
|
|
|
|
|
|
SET_ERROR(0);
|
|
SET_SIZE(0);
|
|
|
|
if (fork != P8_DATA_FORK && fork != P8_RESOURCE_FORK)
|
|
{
|
|
SET_ERROR(-P8_INVALID_FORK);
|
|
return NULL;
|
|
}
|
|
|
|
uint8_t buffer[BLOCK_SIZE];
|
|
int ok;
|
|
uint32_t eof;
|
|
uint32_t alloc;
|
|
unsigned blocks;
|
|
unsigned storage_type;
|
|
unsigned key_block;
|
|
|
|
switch(f.storage_type)
|
|
{
|
|
case SEEDLING_FILE:
|
|
case SAPLING_FILE:
|
|
case TREE_FILE:
|
|
if (fork != P8_DATA_FORK)
|
|
{
|
|
SET_ERROR(1);
|
|
return NULL;
|
|
}
|
|
storage_type = f.storage_type;
|
|
eof = f.eof;
|
|
key_block = f.key_pointer;
|
|
break;
|
|
|
|
case EXTENDED_FILE:
|
|
{
|
|
ok = Read(f.key_pointer, buffer);
|
|
if (ok < 0)
|
|
{
|
|
SET_ERROR(ok);
|
|
return NULL;
|
|
}
|
|
|
|
ExtendedEntry entry;
|
|
entry.Load(buffer);
|
|
|
|
if (fork == P8_DATA_FORK)
|
|
{
|
|
storage_type = entry.dataFork.storage_type;
|
|
eof = entry.dataFork.eof;
|
|
key_block = entry.dataFork.key_block;
|
|
}
|
|
else
|
|
{
|
|
storage_type = entry.resourceFork.storage_type;
|
|
eof = entry.resourceFork.eof;
|
|
key_block = entry.resourceFork.key_block;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
SET_ERROR(-P8_INVALID_STORAGE_TYPE);
|
|
return NULL;
|
|
}
|
|
|
|
if (eof == 0)
|
|
{
|
|
SET_ERROR(1);
|
|
return NULL;
|
|
}
|
|
|
|
blocks = (eof + BLOCK_SIZE - 1) >> 9;
|
|
alloc = (eof + BLOCK_SIZE - 1) & (~BLOCK_SIZE);
|
|
uint8_t* data = new uint8_t[alloc];
|
|
|
|
|
|
switch (storage_type)
|
|
{
|
|
case SEEDLING_FILE:
|
|
ok = Read(key_block, data);
|
|
break;
|
|
case SAPLING_FILE:
|
|
ok = ReadIndex(f.key_pointer, buffer, 1, 0, blocks);
|
|
break;
|
|
case TREE_FILE:
|
|
ok = ReadIndex(f.key_pointer, buffer, 2, 0, blocks);
|
|
break;
|
|
|
|
default:
|
|
ok = false;
|
|
}
|
|
|
|
if (ok < 0)
|
|
{
|
|
SET_ERROR(ok);
|
|
delete[] data;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bzero(data + eof, alloc - eof);
|
|
SET_SIZE(eof);
|
|
|
|
return data;
|
|
}
|
|
|
|
|
|
int Disk::ReadFile(const FileEntry &f, void *buffer)
|
|
{
|
|
int blocks = (f.eof + BLOCK_SIZE - 1) >> 9;
|
|
int ok;
|
|
|
|
switch(f.storage_type)
|
|
{
|
|
case TREE_FILE:
|
|
ok = ReadIndex(f.key_pointer, buffer, 2, 0, blocks);
|
|
break;
|
|
case SAPLING_FILE:
|
|
ok = ReadIndex(f.key_pointer, buffer, 1, 0, blocks);
|
|
break;
|
|
case SEEDLING_FILE:
|
|
ok = Read(f.key_pointer, buffer);
|
|
break;
|
|
|
|
default:
|
|
return -P8_INVALID_STORAGE_TYPE;
|
|
}
|
|
|
|
if (ok >= 0)
|
|
{
|
|
bzero((uint8_t *)buffer + f.eof, (blocks << 9) - f.eof);
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
|
|
int Disk::ReadIndex(unsigned block, void *buffer, unsigned level, off_t offset, unsigned blocks)
|
|
{
|
|
if (level == 0)
|
|
{
|
|
// data level
|
|
if (block == 0) // sparse file
|
|
{
|
|
bzero(buffer, BLOCK_SIZE);
|
|
return 1;
|
|
}
|
|
return Read(block, buffer);
|
|
}
|
|
|
|
|
|
unsigned blockCount;
|
|
unsigned readSize;
|
|
unsigned first;
|
|
//unsigned last;
|
|
|
|
|
|
switch(level)
|
|
{
|
|
case 1:
|
|
first = (offset >> 9) & 0xff;
|
|
blockCount = 1;
|
|
readSize = BLOCK_SIZE;
|
|
offset = 0;
|
|
break;
|
|
case 2:
|
|
first = (offset >> 17) & 0xff;
|
|
blockCount = 256;
|
|
readSize = BLOCK_SIZE << 8;
|
|
offset &= 0x1ffff;
|
|
break;
|
|
default:
|
|
return -P8_INTERNAL_ERROR;
|
|
}
|
|
|
|
|
|
|
|
|
|
int ok;
|
|
uint8_t key[BLOCK_SIZE];
|
|
|
|
if (block) // not sparse.
|
|
{
|
|
ok = Read(block, key);
|
|
if (ok < 0 ) return ok;
|
|
}
|
|
else
|
|
{
|
|
// sparse -- zero it out so code below works w/o special cases.
|
|
bzero(key, BLOCK_SIZE);
|
|
}
|
|
|
|
for (unsigned i = first; blocks; i++)
|
|
{
|
|
// block pointers are split up since 8-bit indexing is limited to 256.
|
|
unsigned newBlock = (key[i]) | (key[256 + i] << 8);
|
|
|
|
unsigned b = std::min(blocks, blockCount);
|
|
|
|
ok = ReadIndex(newBlock, buffer, level - 1, offset, b);
|
|
if (ok < 0) return ok;
|
|
offset = 0;
|
|
buffer = ((char *)buffer) + readSize;
|
|
blocks -= b;
|
|
}
|
|
return blocks;
|
|
}
|
|
|
|
|
|
|
|
int Disk::ReadVolume(VolumeEntry *volume, std::vector<FileEntry> *files)
|
|
{
|
|
if (files) files->resize(0);
|
|
|
|
uint8_t buffer[BLOCK_SIZE];
|
|
int ok;
|
|
unsigned prev;
|
|
unsigned next;
|
|
|
|
uset blocks;
|
|
|
|
unsigned block = 2;
|
|
blocks.insert(block);
|
|
ok = Read(block, buffer);
|
|
|
|
if (ok < 0) return ok;
|
|
|
|
prev = Read16(&buffer[0x00]);
|
|
next = Read16(&buffer[0x02]);
|
|
|
|
VolumeEntry v;
|
|
v.Load(buffer + 0x04);
|
|
|
|
if (v.storage_type != VOLUME_HEADER) return -P8_INVALID_STORAGE_TYPE;
|
|
|
|
if (volume) *volume = v;
|
|
|
|
if (!files) return 1;
|
|
|
|
if (v.file_count)
|
|
{
|
|
files->reserve(v.file_count);
|
|
//files->resize(v.file_count);
|
|
|
|
//unsigned count = 0;
|
|
unsigned index = 1; // skip the header.
|
|
for(;;)
|
|
{
|
|
//
|
|
if ( (buffer[0x04 + v.entry_length * index] >> 4) != DELETED_FILE)
|
|
{
|
|
unsigned offset = v.entry_length * index + 0x4;
|
|
FileEntry f;
|
|
f.Load(buffer + offset);
|
|
f.address = (block << 9) + offset;
|
|
|
|
files->push_back(f);
|
|
//if (++count == v.file_count) break;
|
|
}
|
|
index++;
|
|
if (index >= v.entries_per_block)
|
|
{
|
|
if (!next) break; // all done!
|
|
|
|
|
|
if (blocks.insert(next).second == false)
|
|
{
|
|
return -P8_CYCLICAL_BLOCK;
|
|
}
|
|
|
|
ok = Read(next, buffer);
|
|
if (ok < 0) return ok;
|
|
block = next;
|
|
|
|
prev = Read16(&buffer[0x00]);
|
|
next = Read16(&buffer[0x02]);
|
|
|
|
index = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
int Disk::ReadDirectory(unsigned block, SubdirEntry *dir, std::vector<FileEntry> *files)
|
|
{
|
|
if (files) files->resize(0);
|
|
|
|
uint8_t buffer[BLOCK_SIZE];
|
|
int ok;
|
|
unsigned prev;
|
|
unsigned next;
|
|
|
|
// keep a list of blocks to prevent cyclical problems.
|
|
uset blocks;
|
|
|
|
blocks.insert(block);
|
|
|
|
ok = Read(block, buffer);
|
|
|
|
if (ok < 0) return ok;
|
|
|
|
prev = Read16(&buffer[0x00]);
|
|
next = Read16(&buffer[0x02]);
|
|
|
|
SubdirEntry v;
|
|
v.Load(buffer + 0x04);
|
|
|
|
if (v.storage_type != SUBDIR_HEADER) return -P8_INVALID_STORAGE_TYPE;
|
|
|
|
|
|
if (dir) *dir = v;
|
|
|
|
if (!files) return 1;
|
|
|
|
if (v.file_count)
|
|
{
|
|
files->reserve(v.file_count);
|
|
//files->resize(v.file_count);
|
|
|
|
//unsigned count = 0;
|
|
unsigned index = 1; // skip the header.
|
|
for(;;)
|
|
{
|
|
//
|
|
if ( (buffer[0x04 + v.entry_length * index] >> 4) != DELETED_FILE)
|
|
{
|
|
unsigned offset = v.entry_length * index + 0x4;
|
|
FileEntry f;
|
|
f.Load(buffer + offset);
|
|
f.address = (block << 9) + offset;
|
|
|
|
files->push_back(f);
|
|
|
|
//if (++count == v.file_count) break;
|
|
}
|
|
index++;
|
|
if (index >= v.entries_per_block)
|
|
{
|
|
if (!next) break; // all done!
|
|
|
|
|
|
if (blocks.insert(next).second == false)
|
|
{
|
|
return -P8_CYCLICAL_BLOCK;
|
|
}
|
|
|
|
ok = Read(next, buffer);
|
|
if (ok < 0) return ok;
|
|
block = next;
|
|
|
|
|
|
prev = Read16(&buffer[0x00]);
|
|
next = Read16(&buffer[0x02]);
|
|
|
|
index = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|