AxioDL
/
kabufuda
mirror of https://github.com/AxioDL/kabufuda.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Better file handling

This commit is contained in:
Phillip Stephens 2016-06-26 13:37:50 -07:00
parent aa36b77af6
commit 98b10f9641
3 changed files with 275 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
include/Card.hpp
View File

@ -28,6 +28,13 @@ enum class EBannerFlags : uint8_t
{
};
enum class SeekOrigin
{
Begin,
Current,
End
};
/**
* @brief The EDeviceId enum
*/
@ -92,24 +99,16 @@ class File
void swapEndian();
public:
File() {}
File();
File(char data[0x40]);
File(const char* filename);
~File() {}
};
struct FileHandle
class IFileHandle
{
File* file = nullptr;
uint16_t curBlock = 0;
uint16_t blockOffset = 0;
uint32_t offset =0;
operator bool() const { return file != nullptr; }
FileHandle(File* file = nullptr)
: file(file),
curBlock(file ? file->m_firstBlock : 0)
{
}
public:
virtual ~IFileHandle() {}
};
class BlockAllocationTable
@ -132,6 +131,7 @@ class BlockAllocationTable
#pragma pop()
void swapEndian();
void updateChecksum();
public:
explicit BlockAllocationTable(uint32_t blockCount = (uint32_t(ECardSize::Card2043Mb) * MbitToBlocks));
@ -163,6 +163,7 @@ class Directory
#pragma pop()
void swapEndian();
void updateChecksum();
public:
Directory();
@ -171,9 +172,8 @@ public:
void operator=(const Directory& other);
~Directory() {}
File* getFirstFreeFile(char* game, char* maker, const char* filename);
File* getFile(char* game, char* maker, const char* filename);
File* getFirstFreeFile(const char* game, const char* maker, const char* filename);
File* getFile(const char* game, const char* maker, const char* filename);
};
class Card
@ -199,10 +199,10 @@ class Card
uint8_t __raw[BlockSize];
};
void swapEndian();
#pragma pop()
SystemString m_filename;
FILE* m_fileHandle = nullptr;
Directory m_dir;
Directory m_dirBackup;
Directory* m_currentDir;
@ -215,6 +215,9 @@ class Card
uint16_t m_maxBlock;
char m_game[5] = {'\0'};
char m_maker[3] = {'\0'};
void swapEndian();
void updateDirAndBat();
public:
Card();
Card(const SystemString& filepath, const char* game = nullptr, const char* maker=nullptr);
@ -224,14 +227,17 @@ public:
* @brief openFile
* @param filename
*/
FileHandle openFile(const char* filename);
std::unique_ptr<IFileHandle> openFile(const char* filename);
/**
* @brief createFile
* @param filename
* @return
*/
FileHandle createFile(const char* filename, size_t size);
void write(FileHandle* f, const void* buf, size_t size);
std::unique_ptr<IFileHandle> createFile(const char* filename, size_t size);
void deleteFile(const std::unique_ptr<IFileHandle>& fh);
void write(const std::unique_ptr<IFileHandle>& fh, const void* buf, size_t size);
void read(const std::unique_ptr<IFileHandle>& fh, void* dst, size_t size);
void seek(const std::unique_ptr<IFileHandle>& fh, uint32_t pos, SeekOrigin whence);
/**
* @brief Sets the current game, if not null any openFile requests will only return files that match this game
* @param game The target game id, e.g "GM8E"
@ -280,6 +286,8 @@ public:
static uint32_t getSizeMbitFromFile(const SystemString& filename);
void commit();
operator bool() const { return m_fileHandle != nullptr; }
};
/**

322
src/Card.cpp
View File

@ -7,6 +7,23 @@
namespace kabufuda
{
class FileHandle : public IFileHandle
{
friend class Card;
const char* game;
const char* maker;
const char* filename;
uint32_t offset =0;
public:
FileHandle() = default;
FileHandle(const char* game, const char* maker, const char* filename)
: game(game),
maker(maker),
filename(filename)
{}
};
void Card::swapEndian()
{
m_formatTime = SBig(m_formatTime);
@ -35,16 +52,16 @@ Card::Card(const SystemString& filename, const char* game, const char* maker)
if (maker && strlen(maker) == 2)
memcpy(m_maker, maker, 2);
FILE* file = Fopen(m_filename.c_str(), _S("rb"));
if (file)
m_fileHandle = Fopen(m_filename.c_str(), _S("rb"));
if (m_fileHandle)
{
fread(__raw, 1, BlockSize, file);
fread(__raw, 1, BlockSize, m_fileHandle);
m_maxBlock = m_sizeMb * MbitToBlocks;
swapEndian();
fread(m_dir.__raw, 1, BlockSize, file);
fread(m_dirBackup.__raw, 1, BlockSize, file);
fread(m_bat.__raw, 1, BlockSize, file);
fread(m_batBackup.__raw, 1, BlockSize, file);
fread(m_dir.__raw, 1, BlockSize, m_fileHandle);
fread(m_dirBackup.__raw, 1, BlockSize, m_fileHandle);
fread(m_bat.__raw, 1, BlockSize, m_fileHandle);
fread(m_batBackup.__raw, 1, BlockSize, m_fileHandle);
if (m_dir.m_updateCounter > m_dirBackup.m_updateCounter)
{
m_currentDir = &m_dir;
@ -70,19 +87,62 @@ Card::Card(const SystemString& filename, const char* game, const char* maker)
m_previousDir->swapEndian();
m_currentBat->swapEndian();
m_previousBat->swapEndian();
/* Close and reopen in read/write mode */
fclose(m_fileHandle);
m_fileHandle = Fopen(m_filename.c_str(), _S("r+"));
}
}
Card::~Card()
{
commit();
if (m_fileHandle)
fclose(m_fileHandle);
m_fileHandle = nullptr;
}
FileHandle Card::openFile(const char* filename)
std::unique_ptr<IFileHandle> Card::openFile(const char* filename)
{
return {m_currentDir->getFile(m_game, m_maker, filename)};
File* f = m_currentDir->getFile(m_game, m_maker, filename);
if (f)
return std::unique_ptr<IFileHandle>(new FileHandle(m_game, m_maker, filename));
return nullptr;
}
FileHandle Card::createFile(const char* filename, size_t size)
void Card::updateDirAndBat()
{
Directory updateDir = *m_currentDir;
updateDir.m_updateCounter++;
*m_previousDir = updateDir;
if (m_previousDir == &m_dir)
{
m_currentDir = &m_dir;
m_previousDir = &m_dirBackup;
}
else
{
m_currentDir = &m_dirBackup;
m_previousDir = &m_dir;
}
BlockAllocationTable updateBat = *m_currentBat;
updateBat.m_updateCounter++;
*m_previousBat = updateBat;
if (m_previousBat == &m_bat)
{
m_currentBat = &m_bat;
m_previousBat = &m_batBackup;
}
else
{
m_currentBat = &m_batBackup;
m_previousBat = &m_bat;
}
}
std::unique_ptr<IFileHandle> Card::createFile(const char* filename, size_t size)
{
File* f = m_currentDir->getFirstFreeFile(m_game, m_maker, filename);
uint16_t block = m_currentBat->allocateBlocks(size / BlockSize, m_maxBlock);
@ -91,32 +151,144 @@ FileHandle Card::createFile(const char* filename, size_t size)
f->m_modifiedTime = getGCTime();
f->m_firstBlock = block;
f->m_blockCount = size / BlockSize;
return {f};
updateDirAndBat();
return std::unique_ptr<FileHandle>(new FileHandle(m_game, m_maker, filename));
}
return {};
return nullptr;
}
void Card::write(FileHandle* f, const void* buf, size_t size)
void Card::deleteFile(const std::unique_ptr<IFileHandle> &fh)
{
FILE* mc = Fopen(m_filename.c_str(), _S("r+"));
rewind(mc);
if (mc)
{
f->file->m_modifiedTime = getGCTime();
if (f->blockOffset > BlockSize)
{
f->curBlock = m_currentBat->m_map[f->curBlock - FSTBlocks];
f->blockOffset = 0;
/* TODO: Add error */
if (f->curBlock == 0xFFFF)
if (!fh)
return;
FileHandle* f = dynamic_cast<FileHandle*>(fh.get());
uint16_t block = m_currentDir->getFile(f->game, f->maker, f->filename)->m_firstBlock;
while(block != 0xFFFF)
{
/* TODO: add a fragmentation check */
uint16_t nextBlock = m_currentBat->getNextBlock(block);
m_currentBat->clear(block, 1);
block = nextBlock;
}
*m_currentDir->getFile(f->game, f->maker, f->filename) = File();
updateDirAndBat();
}
void Card::write(const std::unique_ptr<IFileHandle>& fh, const void* buf, size_t size)
{
if (!fh)
return;
if (m_fileHandle)
{
FileHandle* f = dynamic_cast<FileHandle*>(fh.get());
File* file = m_currentDir->getFile(f->game, f->maker, f->filename);
/* Block handling is a little different from cache handling,
* since each block can be in an arbitrary location we must
* first find our starting block.
*/
const uint16_t blockId = (f->offset / BlockSize);
uint16_t block = file->m_firstBlock;
for (uint16_t i = 0; i < blockId; i++)
block = m_currentBat->getNextBlock(block);
const uint8_t* tmpBuf = reinterpret_cast<const uint8_t*>(buf);
uint16_t curBlock = block;
uint32_t blockOffset = f->offset % BlockSize;
uint32_t rem = size;
while (rem)
{
if (curBlock == 0xFFFF)
return;
uint32_t cacheSize = rem;
if (cacheSize + blockOffset > BlockSize)
cacheSize = BlockSize - blockOffset;
uint32_t offset = (curBlock * BlockSize) + blockOffset;
fseek(m_fileHandle, offset, SEEK_SET);
fwrite(tmpBuf, 1, cacheSize, m_fileHandle);
tmpBuf += cacheSize;
rem -= cacheSize;
blockOffset += cacheSize;
if (blockOffset >= BlockSize)
{
curBlock = m_currentBat->getNextBlock(curBlock);
blockOffset = 0;
}
}
size_t blockOffset = (f->curBlock * BlockSize) + f->offset;
fseek(mc, blockOffset, SEEK_SET);
fwrite(buf, 1, size, mc);
fclose(mc);
f->offset += size;
f->blockOffset += size;
}
}
void Card::read(const std::unique_ptr<IFileHandle> &fh, void *dst, size_t size)
{
if (!fh)
return;
if (m_fileHandle)
{
FileHandle* f = dynamic_cast<FileHandle*>(fh.get());
File* file = m_currentDir->getFile(f->game, f->maker, f->filename);
/* Block handling is a little different from cache handling,
* since each block can be in an arbitrary location we must
* first find our starting block.
*/
const uint16_t blockId = (f->offset / BlockSize);
uint16_t block = file->m_firstBlock;
for (uint16_t i = 0; i < blockId; i++)
block = m_currentBat->getNextBlock(block);
uint8_t* tmpBuf = reinterpret_cast<uint8_t*>(dst);
uint16_t curBlock = block;
uint32_t blockOffset = f->offset % BlockSize;
uint32_t rem = size;
while (rem)
{
if (curBlock == 0xFFFF)
return;
uint32_t cacheSize = rem;
if (cacheSize + blockOffset > BlockSize)
cacheSize = BlockSize - blockOffset;
uint32_t offset = (curBlock * BlockSize) + blockOffset;
fseek(m_fileHandle, offset, SEEK_SET);
fread(tmpBuf, 1, cacheSize, m_fileHandle);
tmpBuf += cacheSize;
rem -= cacheSize;
blockOffset += cacheSize;
if (blockOffset >= BlockSize)
{
curBlock = m_currentBat->getNextBlock(curBlock);
blockOffset = 0;
}
}
f->offset += size;
}
}
void Card::seek(const std::unique_ptr<IFileHandle> &fh, uint32_t pos, SeekOrigin whence)
{
if (!fh)
return;
FileHandle* f = dynamic_cast<FileHandle*>(fh.get());
File* file = m_currentDir->getFile(f->game, f->maker, f->filename);
uint32_t oldOff = f->offset;
switch(whence)
{
case SeekOrigin::Begin:
f->offset = pos;
break;
case SeekOrigin::Current:
f->offset += pos;
break;
case SeekOrigin::End:
f->offset = (file->m_blockCount * BlockSize) - pos;
break;
}
}
@ -204,29 +376,32 @@ void Card::format(EDeviceId id, ECardSize size, EEncoding encoding)
m_bat = BlockAllocationTable(uint32_t(size) * MbitToBlocks);
m_batBackup = m_bat;
FILE* f = Fopen(m_filename.c_str(), _S("wb"));
if (f)
if (!m_fileHandle)
m_fileHandle = Fopen(m_filename.c_str(), _S("wb"));
if (m_fileHandle)
{
swapEndian();
fwrite(__raw, 1, BlockSize, f);
fwrite(__raw, 1, BlockSize, m_fileHandle);
swapEndian();
Directory tmpDir = m_dir;
tmpDir.swapEndian();
fwrite(tmpDir.__raw, 1, BlockSize, f);
fwrite(tmpDir.__raw, 1, BlockSize, m_fileHandle);
tmpDir = m_dirBackup;
tmpDir.swapEndian();
fwrite(tmpDir.__raw, 1, BlockSize, f);
fwrite(tmpDir.__raw, 1, BlockSize, m_fileHandle);
BlockAllocationTable tmpBat = m_bat;
tmpBat.swapEndian();
fwrite(tmpBat.__raw, 1, BlockSize, f);
fwrite(tmpBat.__raw, 1, BlockSize, m_fileHandle);
tmpBat = m_batBackup;
tmpBat.swapEndian();
fwrite(tmpBat.__raw, 1, BlockSize, f);
fwrite(tmpBat.__raw, 1, BlockSize, m_fileHandle);
uint32_t dataLen = ((uint32_t(size) * MbitToBlocks) - 5) * BlockSize;
std::unique_ptr<uint8_t[]> data(new uint8_t[dataLen]);
memset(data.get(), 0xFF, dataLen);
fwrite(data.get(), 1, dataLen, f);
fclose(f);
fwrite(data.get(), 1, dataLen, m_fileHandle);
fclose(m_fileHandle);
m_fileHandle = Fopen(m_filename.c_str(), _S("r+"));
}
}
@ -239,55 +414,25 @@ uint32_t Card::getSizeMbitFromFile(const SystemString& filename)
void Card::commit()
{
FILE* f = Fopen(m_filename.c_str(), _S("r+"));
if (f)
if (m_fileHandle)
{
Directory updateDir = *m_currentDir;
updateDir.m_updateCounter++;
*m_previousDir = updateDir;
if (m_previousDir == &m_dir)
{
m_currentDir = &m_dir;
m_previousDir = &m_dirBackup;
}
else
{
m_currentDir = &m_dirBackup;
m_previousDir = &m_dir;
}
BlockAllocationTable updateBat = *m_currentBat;
updateBat.m_updateCounter++;
*m_previousBat = updateBat;
if (m_previousBat == &m_bat)
{
m_currentBat = &m_bat;
m_previousBat = &m_batBackup;
}
else
{
m_currentBat = &m_batBackup;
m_previousBat = &m_bat;
}
rewind(m_fileHandle);
swapEndian();
fwrite(__raw, 1, BlockSize, f);
fwrite(__raw, 1, BlockSize, m_fileHandle);
swapEndian();
Directory tmpDir = *m_currentDir;
tmpDir.swapEndian();
fwrite(tmpDir.__raw, 1, BlockSize, f);
fwrite(tmpDir.__raw, 1, BlockSize, m_fileHandle);
tmpDir = *m_previousDir;
tmpDir.swapEndian();
fwrite(tmpDir.__raw, 1, BlockSize, f);
fwrite(tmpDir.__raw, 1, BlockSize, m_fileHandle);
BlockAllocationTable tmpBat = *m_currentBat;
tmpBat.swapEndian();
fwrite(tmpBat.__raw, 1, BlockSize, f);
fwrite(tmpBat.__raw, 1, BlockSize, m_fileHandle);
tmpBat = *m_previousBat;
tmpBat.swapEndian();
fwrite(tmpBat.__raw, 1, BlockSize, f);
fclose(f);
fwrite(tmpBat.__raw, 1, BlockSize, m_fileHandle);
}
}
@ -316,6 +461,10 @@ void File::swapEndian()
m_commentAddr = SBig(m_commentAddr);
}
File::File()
{
memset(__raw, 0xFF, 0x40);
}
void BlockAllocationTable::swapEndian()
{
@ -329,17 +478,22 @@ void BlockAllocationTable::swapEndian()
});
}
void BlockAllocationTable::updateChecksum()
{
calculateChecksum(reinterpret_cast<uint16_t*>(__raw + 4), 0xFFE, &m_checksum, &m_checksumInv);
}
BlockAllocationTable::BlockAllocationTable(uint32_t blockCount)
{
memset(__raw, 0, BlockSize);
m_freeBlocks = blockCount - FSTBlocks;
m_lastAllocated = 4;
calculateChecksum((uint16_t*)(__raw + 4), 0xFFE, &m_checksum, &m_checksumInv);
updateChecksum();
}
uint16_t BlockAllocationTable::getNextBlock(uint16_t block) const
{
if ((block < FSTBlocks) || (block > 4091))
if ((block < FSTBlocks) || (block > (BATSize - FSTBlocks)))
return 0;
return m_map[block - FSTBlocks];
@ -418,11 +572,16 @@ void Directory::swapEndian()
m_checksumInv = SBig(m_checksumInv);
}
void Directory::updateChecksum()
{
calculateChecksum(reinterpret_cast<uint16_t*>(__raw), 0xFFE, &m_checksum, &m_checksumInv);
}
Directory::Directory()
{
memset(__raw, 0xFF, BlockSize);
m_updateCounter = 0;
calculateChecksum((uint16_t*)__raw, 0xFFE, &m_checksum, &m_checksumInv);
updateChecksum();
}
Directory::Directory(uint8_t data[])
@ -440,14 +599,13 @@ void Directory::operator=(const Directory& other)
memcpy(__raw, other.__raw, BlockSize);
}
File* Directory::getFirstFreeFile(char* game, char* maker, const char* filename)
File* Directory::getFirstFreeFile(const char* game, const char* maker, const char* filename)
{
for (uint16_t i = 0 ; i < 127 ; i++)
{
if (m_files[i].m_id[0] == 0xFF)
{
File* ret = &m_files[i];
memset(ret->__raw, 0xFF, sizeof(File));
*ret = File(filename);
if (game && strlen(game) == 4)
memcpy(ret->m_id, game, 4);
@ -460,7 +618,7 @@ File* Directory::getFirstFreeFile(char* game, char* maker, const char* filename)
return nullptr;
}
File* Directory::getFile(char* game, char* maker, const char* filename)
File* Directory::getFile(const char* game, const char* maker, const char* filename)
{
for (uint16_t i = 0 ; i < 127 ; i++)
{
@ -479,7 +637,7 @@ void calculateChecksum(uint16_t* data, size_t len, uint16_t* checksum, uint16_t*
{
*checksum = 0;
*checksumInv = 0;
for (size_t i = 0; i < len; i++)
for (size_t i = 0; i < len; ++i)
{
*checksum += data[i];
*checksumInv += data[i] ^ 0xFFFF;

16
test/main.cpp
View File

@ -4,19 +4,23 @@
int main()
{
kabufuda::Card mc{_S("test.USA.raw"), "GM8E", "01"};
//mc.format(kabufuda::EDeviceId::SlotA, kabufuda::ECardSize::Card2043Mb);
kabufuda::FileHandle f = mc.openFile("MetroidPrime B");
//if (!mc)
mc.format(kabufuda::EDeviceId::SlotA, kabufuda::ECardSize::Card2043Mb);
std::unique_ptr<kabufuda::IFileHandle> f = mc.openFile("MetroidPrime B");
if (!f)
f = mc.createFile("MetroidPrime B", kabufuda::BlockSize);
if (f)
{
const char* test = "Metroid Prime B is Cool";
const char* test = "Metroid Prime A is Cool";
size_t len = strlen(test);
mc.write(&f, test, len + 1);
mc.write(f, test, len + 1);
uint16_t derp = 1234;
mc.write(&f, &derp, 2);
mc.commit();
mc.write(f, &derp, 2);
mc.seek(f, -4, kabufuda::SeekOrigin::Current);
mc.read(f, &derp, 2);
std::cout << derp << std::endl;
mc.deleteFile(f);
}
return 0;
}