598 lines
14 KiB
C++
598 lines
14 KiB
C++
/*
|
|
* Disk.cpp
|
|
* ProFUSE
|
|
*
|
|
* Created by Kelvin Sherlock on 12/18/08.
|
|
*
|
|
*/
|
|
|
|
#include "Disk.h"
|
|
#include "DiskCopy42.h"
|
|
#include "UniversalDiskImage.h"
|
|
|
|
#include "common.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include <algorithm>
|
|
#include <set>
|
|
#include <vector>
|
|
|
|
struct ucmp
|
|
{
|
|
bool operator()(unsigned a, unsigned b) const
|
|
{
|
|
return a < b;
|
|
}
|
|
};
|
|
|
|
using std::set;
|
|
using std::vector;
|
|
|
|
typedef set<unsigned, ucmp> uset;
|
|
|
|
Disk::Disk()
|
|
{
|
|
_data = (uint8_t *)-1;
|
|
_blocks = 0;
|
|
_offset = 0;
|
|
_size = 0;
|
|
_flags = 0;
|
|
}
|
|
|
|
Disk::~Disk()
|
|
{
|
|
if (_data != (uint8_t *)-1)
|
|
munmap(_data, _size);
|
|
}
|
|
|
|
|
|
Disk *Disk::OpenFile(const char *file, unsigned flags)
|
|
{
|
|
int fd;
|
|
struct stat st;
|
|
size_t size;
|
|
unsigned blocks;
|
|
|
|
unsigned offset;
|
|
|
|
|
|
void *map;
|
|
Disk *d = NULL;
|
|
|
|
|
|
|
|
fd = open(file, O_RDONLY);
|
|
if (fd >= 0)
|
|
{
|
|
|
|
if (fstat(fd, &st) == 0)
|
|
{
|
|
size = st.st_size;
|
|
|
|
// raw disk images must be a blocksize multiple and <= 32 Meg.
|
|
|
|
if ( (size & 0x1ff) == 0
|
|
&& size > 0
|
|
&& size <= 32 * 1024 * 1024
|
|
)
|
|
{
|
|
blocks = size >> 9;
|
|
offset = 0;
|
|
}
|
|
else {
|
|
|
|
// check for disk copy4.2 / universal disk image.
|
|
uint8_t buffer[1024];
|
|
|
|
if (read(fd, buffer, 1024) != 1024)
|
|
{
|
|
close(fd);
|
|
return NULL;
|
|
}
|
|
|
|
bool ok = false;
|
|
do {
|
|
|
|
DiskCopy42 dc;
|
|
|
|
if (dc.Load(buffer)
|
|
&& size == 84 + dc.data_size + dc.tag_size
|
|
&& (dc.data_size & 0x1ff) == 0)
|
|
{
|
|
offset = 84;
|
|
blocks = dc.data_size >> 9;
|
|
ok = true;
|
|
flags |= P8_DC42;
|
|
break;
|
|
}
|
|
|
|
UniversalDiskImage udi;
|
|
|
|
if (udi.Load(buffer)
|
|
//&& udi.version == 1
|
|
&& udi.image_format == UDI_FORMAT_PRODOS_ORDER)
|
|
{
|
|
|
|
blocks = udi.data_blocks;
|
|
offset = udi.data_offset;
|
|
ok = true;
|
|
flags |= P8_2MG;
|
|
break;
|
|
}
|
|
|
|
} while (false);
|
|
|
|
if (!ok)
|
|
{
|
|
close(fd);
|
|
return NULL;
|
|
}
|
|
lseek(fd, 0, SEEK_SET);
|
|
}
|
|
|
|
|
|
map = mmap(NULL, size, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0);
|
|
if (map != (void *)-1)
|
|
{
|
|
d = new Disk();
|
|
d->_size = size;
|
|
d->_data = (uint8_t *)map;
|
|
d->_blocks = blocks;
|
|
d->_offset = offset;
|
|
d->_flags = flags;
|
|
}
|
|
|
|
}
|
|
close(fd);
|
|
}
|
|
|
|
return d;
|
|
}
|
|
|
|
|
|
// 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;
|
|
|
|
|
|
if (_flags & P8_DOS_ORDER)
|
|
{
|
|
static unsigned do_map[] = {0x00, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x0f };
|
|
|
|
unsigned track = (block & ~0x07) << 9;
|
|
unsigned sector = (block & 0x07) << 1;
|
|
|
|
for (unsigned i = 0; i < 2; i++)
|
|
{
|
|
unsigned offset = track | (do_map[sector+i] << 8);
|
|
|
|
memcpy(buffer, _data + _offset + offset, 256);
|
|
|
|
buffer = (char *)buffer + 256;
|
|
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
memcpy(buffer, _data + _offset + (block << 9), BLOCK_SIZE);
|
|
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;
|
|
}
|
|
|
|
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 = load16(&buffer[0x00]);
|
|
next = load16(&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 = load16(&buffer[0x00]);
|
|
next = load16(&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 = load16(&buffer[0x00]);
|
|
next = load16(&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 = load16(&buffer[0x00]);
|
|
next = load16(&buffer[0x02]);
|
|
|
|
index = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|