profuse/DiskCopy42Image.cpp

203 lines
4.1 KiB
C++

#include "DiskCopy42Image.h"
#include "MappedFile.h"
#include "Buffer.h"
#include "Endian.h"
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace ProFUSE;
using namespace BigEndian;
DiskCopy42Image::DiskCopy42Image(MappedFile *f) :
DiskImage(f),
_changed(false)
{
}
DiskCopy42Image::DiskCopy42Image(const char *name, bool readOnly) :
DiskImage(name, readOnly),
_changed(false)
{
Validate(file());
}
DiskCopy42Image::~DiskCopy42Image()
{
if (_changed)
{
MappedFile *f = file();
void *data = f->fileData();
if (f)
{
uint32_t cs = Checksum(f->offset() + (uint8_t *)data,
f->blocks() * 512);
Write32(data, 72, cs);
f->sync();
}
// TODO -- checksum
}
}
uint32_t DiskCopy42Image::Checksum(void *data, size_t size)
{
uint32_t rv = 0;
uint8_t *dp = (uint8_t *)data;
if (size & 0x01) return rv;
for (size_t i = 0; i < size; i += 2)
{
rv += dp[i] << 8;
rv += dp[i+1];
rv = (rv >> 1) + (rv << 31);
}
return rv;
}
DiskCopy42Image *DiskCopy42Image::Open(MappedFile *f)
{
Validate(f);
return new DiskCopy42Image(f);
}
static uint8_t DiskFormat(size_t blocks)
{
switch (blocks)
{
case 800: return 0;
case 1600: return 1;
case 1440: return 2;
case 2880: return 3;
default: return 0xff;
}
}
static uint8_t FormatByte(size_t blocks)
{
switch(blocks)
{
case 800: return 0x12;
default: return 0x22;
}
}
DiskCopy42Image *DiskCopy42Image::Create(const char *name, size_t blocks)
{
return Create(name, blocks, "Untitled");
}
DiskCopy42Image *DiskCopy42Image::Create(const char *name, size_t blocks, const char *vname)
{
MappedFile *file = new MappedFile(name, blocks * 512 + 84);
file->setOffset(84);
file->setBlocks(blocks);
Buffer header(84);
// name -- 64byte pstring.
if (vname == NULL) vname = "Untitled";
unsigned l = std::strlen(vname);
header.push8(std::min(l, 63u));
header.pushBytes(vname, std::min(l, 63u));
header.resize(64);
// data size -- number of bytes
header.push32be(blocks * 512);
// tag size
header.push32be(0);
// data checksum
// if data is 0, will be 0.
//header.push32be(Checksum(file->fileData(), blocks * 512));
header.push32be(0);
// tag checksum
header.push32be(0);
// disk format.
/*
* 0 = 400k
* 1 = 800k
* 2 = 720k
* 3 = 1440k
* 0xff = other
*/
header.push8(DiskFormat(blocks));
// formatbyte
/*
* 0x12 = 400k
* 0x22 = >400k mac
* 0x24 = 800k appleII
*/
header.push8(FormatByte(blocks));
// private
header.push16be(0x100);
std::memcpy(file->fileData(), header.buffer(), 84);
file->sync();
return new DiskCopy42Image(file);
}
void DiskCopy42Image::Validate(MappedFile *file)
{
#undef __METHOD__
#define __METHOD__ "DiskCopy42Image::Validate"
size_t bytes = 0;
size_t size = file->fileSize();
const void *data = file->fileData();
bool ok = false;
uint32_t checksum = 0;
do {
if (size < 84) break;
// name must be < 64
if (Read8(data, 0) > 63) break;
if (Read32(data, 82) != 0x100)
break;
// bytes, not blocks.
bytes = Read32(data, 64);
if (bytes % 512) break;
if (size < 84 + bytes) break;
// todo -- checksum.
checksum = Read32(data, 72);
ok = true;
} while (false);
if (!ok)
throw Exception(__METHOD__ ": Invalid file format.");
uint32_t cs = Checksum(64 + (uint8_t *)data, bytes);
if (cs != checksum)
{
fprintf(stderr, "Warning: checksum invalid.\n");
}
file->reset();
file->setOffset(64);
file->setBlocks(bytes / 512);
}
void DiskCopy42Image::write(unsigned block, const void *bp)
{
DiskImage::write(block, bp);
_changed = true;
}