mkxp/src/filesystem.cpp

874 lines
17 KiB
C++
Raw Normal View History

2013-09-01 14:27:21 +00:00
/*
** filesystem.cpp
**
** This file is part of mkxp.
**
** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
**
** mkxp is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 2 of the License, or
** (at your option) any later version.
**
** mkxp is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "filesystem.h"
#include "util.h"
#include "exception.h"
#include "physfs.h"
#include <QHash>
#include <QSet>
2013-09-01 14:27:21 +00:00
#include <QByteArray>
#include "stdio.h"
#include "string.h"
#include <QDebug>
struct RGSS_entryData
{
2013-09-04 11:30:14 +00:00
int64_t offset;
uint64_t size;
uint32_t startMagic;
2013-09-01 14:27:21 +00:00
};
struct RGSS_entryHandle
{
RGSS_entryData data;
2013-09-04 11:30:14 +00:00
uint32_t currentMagic;
uint64_t currentOffset;
2013-09-01 14:27:21 +00:00
PHYSFS_Io *io;
RGSS_entryHandle(const RGSS_entryData &data, PHYSFS_Io *archIo)
2013-09-01 14:27:21 +00:00
: data(data),
currentMagic(data.startMagic),
currentOffset(0)
{
io = archIo->duplicate(archIo);
}
2013-09-01 14:27:21 +00:00
~RGSS_entryHandle()
{
io->destroy(io);
}
2013-09-01 14:27:21 +00:00
};
typedef QList<QByteArray> QByteList;
struct RGSS_archiveData
{
PHYSFS_Io *archiveIo;
/* Maps: file path
* to: entry data */
2013-09-01 14:27:21 +00:00
QHash<QByteArray, RGSS_entryData> entryHash;
/* Maps: directory path,
* to: list of contained entries */
QHash<QByteArray, QSet<QByteArray> > dirHash;
2013-09-01 14:27:21 +00:00
};
static bool
2013-09-04 11:30:14 +00:00
readUint32(PHYSFS_Io *io, uint32_t &result)
2013-09-01 14:27:21 +00:00
{
char buff[4];
PHYSFS_sint64 count = io->read(io, buff, 4);
result = ((buff[0] << 0x00) & 0x000000FF) |
((buff[1] << 0x08) & 0x0000FF00) |
((buff[2] << 0x10) & 0x00FF0000) |
((buff[3] << 0x18) & 0xFF000000) ;
return (count == 4);
}
#define RGSS_HEADER_1 0x53534752
2013-09-04 15:03:00 +00:00
#define RGSS_HEADER_2 0x01004441
2013-09-01 14:27:21 +00:00
#define RGSS_MAGIC 0xDEADCAFE
#define PHYSFS_ALLOC(type) \
static_cast<type*>(PHYSFS_getAllocator()->Malloc(sizeof(type)))
2013-09-04 11:30:14 +00:00
static inline uint32_t
advanceMagic(uint32_t &magic)
2013-09-01 14:27:21 +00:00
{
2013-09-04 11:30:14 +00:00
uint32_t old = magic;
2013-09-01 14:27:21 +00:00
magic = magic * 7 + 3;
return old;
}
struct MagicState
{
2013-09-04 11:30:14 +00:00
uint32_t magic;
uint64_t offset;
2013-09-01 14:27:21 +00:00
2013-09-04 11:30:14 +00:00
MagicState(uint64_t offset = 0)
2013-09-01 14:27:21 +00:00
: offset(offset)
{
magic = RGSS_MAGIC;
for (uint i = 0; i < (offset/4); ++i)
advanceBlock();
}
2013-09-04 11:30:14 +00:00
uint8_t advancePath()
2013-09-01 14:27:21 +00:00
{
2013-09-04 11:30:14 +00:00
uint8_t ret = magic & 0xFF;
2013-09-01 14:27:21 +00:00
offset++;
advanceBlock();
return ret;
}
2013-09-04 11:30:14 +00:00
uint8_t advanceData()
2013-09-01 14:27:21 +00:00
{
2013-09-04 11:30:14 +00:00
uint8_t ret = magic & 0xFF;
2013-09-01 14:27:21 +00:00
if (offset++ % 4 == 0)
advanceBlock();
return ret;
}
private:
void advanceBlock()
{
magic = magic * 7 + 3;
}
};
static PHYSFS_sint64
RGSS_ioRead(PHYSFS_Io *self, void *buffer, PHYSFS_uint64 len)
{
RGSS_entryHandle *entry = static_cast<RGSS_entryHandle*>(self->opaque);
PHYSFS_Io *io = entry->io;
2013-09-04 11:30:14 +00:00
uint64_t toRead = min<uint64_t>(entry->data.size - entry->currentOffset, len);
uint64_t offs = entry->currentOffset;
2013-09-01 14:27:21 +00:00
io->seek(io, entry->data.offset + offs);
/* We divide up the bytes to be read in 3 categories:
*
* preAlign: If the current read address is not dword
* aligned, this is the number of bytes to read til
* we reach alignment again (therefore can only be
* 3 or less).
*
* align: The number of aligned dwords we can read
* times 4 (= number of bytes).
*
* postAlign: The number of bytes to read after the
* last aligned dword. Always 3 or less.
*
* Treating the pre- and post aligned reads specially,
* we can read all aligned dwords in one syscall directly
* into the write buffer and then run the xor chain on
* it afterwards. */
uint8_t preAlign = 4 - (offs % 4);
if (preAlign == 4)
preAlign = 0;
else
preAlign = min<uint64_t>(preAlign, len);
uint8_t postAlign = (len > preAlign) ? (offs + len) % 4 : 0;
uint64_t align = len - (preAlign + postAlign);
/* Byte buffer pointer */
uint8_t *bBufferP = static_cast<uint8_t*>(buffer);
if (preAlign > 0)
2013-09-01 14:27:21 +00:00
{
uint32_t dword;
io->read(io, &dword, preAlign);
2013-09-01 14:27:21 +00:00
/* Need to align the bytes with the
* magic before xoring */
dword <<= 8 * (offs % 4);
dword ^= entry->currentMagic;
2013-09-01 14:27:21 +00:00
/* Shift them back to normal */
dword >>= 8 * (offs % 4);
memcpy(bBufferP, &dword, preAlign);
2013-09-01 14:27:21 +00:00
bBufferP += preAlign;
/* Only advance the magic if we actually
* reached the next alignment */
if ((offs+preAlign) % 4 == 0)
2013-09-01 14:27:21 +00:00
advanceMagic(entry->currentMagic);
}
if (align > 0)
{
/* Double word buffer pointer */
uint32_t *dwBufferP = reinterpret_cast<uint32_t*>(bBufferP);
/* Read aligned dwords in one go */
io->read(io, bBufferP, align);
/* Then xor them */
for (uint64_t i = 0; i < (align / 4); ++i)
dwBufferP[i] ^= advanceMagic(entry->currentMagic);
bBufferP += align;
}
if (postAlign > 0)
{
uint32_t dword;
io->read(io, &dword, postAlign);
/* Bytes are already aligned with magic */
dword ^= entry->currentMagic;
memcpy(bBufferP, &dword, postAlign);
}
2013-09-01 14:27:21 +00:00
entry->currentOffset += toRead;
return toRead;
}
static int
RGSS_ioSeek(PHYSFS_Io *self, PHYSFS_uint64 offset)
{
RGSS_entryHandle *entry = static_cast<RGSS_entryHandle*>(self->opaque);
if (offset == entry->currentOffset)
return 1;
if (offset > entry->data.size-1)
return 0;
/* If rewinding, we need to rewind to begining */
if (offset < entry->currentOffset)
{
entry->currentOffset = 0;
entry->currentMagic = entry->data.startMagic;
}
/* For each overstepped alignment, advance magic */
uint64_t currentDword = entry->currentOffset / 4;
uint64_t targetDword = offset / 4;
uint64_t dwordsSought = targetDword - currentDword;
2013-09-04 11:30:14 +00:00
for (uint64_t i = 0; i < dwordsSought; ++i)
2013-09-01 14:27:21 +00:00
advanceMagic(entry->currentMagic);
entry->currentOffset = offset;
entry->io->seek(entry->io, entry->data.offset + entry->currentOffset);
return 1;
}
static PHYSFS_sint64
RGSS_ioTell(PHYSFS_Io *self)
{
RGSS_entryHandle *entry = static_cast<RGSS_entryHandle*>(self->opaque);
return entry->currentOffset;
}
static PHYSFS_sint64
RGSS_ioLength(PHYSFS_Io *self)
{
RGSS_entryHandle *entry = static_cast<RGSS_entryHandle*>(self->opaque);
return entry->data.size;
}
static PHYSFS_Io*
RGSS_ioDuplicate(PHYSFS_Io *self)
{
RGSS_entryHandle *entry = static_cast<RGSS_entryHandle*>(self->opaque);
RGSS_entryHandle *entryDup = new RGSS_entryHandle(*entry);
PHYSFS_Io *dup = PHYSFS_ALLOC(PHYSFS_Io);
*dup = *self;
dup->opaque = entryDup;
return dup;
}
static void
RGSS_ioDestroy(PHYSFS_Io *self)
{
RGSS_entryHandle *entry = static_cast<RGSS_entryHandle*>(self->opaque);
delete entry;
PHYSFS_getAllocator()->Free(self);
}
static const PHYSFS_Io RGSS_IoTemplate =
{
0, /* version */
0, /* opaque */
RGSS_ioRead,
0, /* write */
RGSS_ioSeek,
RGSS_ioTell,
RGSS_ioLength,
RGSS_ioDuplicate,
0, /* flush */
RGSS_ioDestroy
};
static void*
RGSS_openArchive(PHYSFS_Io *io, const char *, int forWrite)
{
if (forWrite)
return 0;
/* Check header */
2013-09-04 11:30:14 +00:00
uint32_t header1, header2;
2013-09-01 14:27:21 +00:00
readUint32(io, header1);
readUint32(io, header2);
if (header1 != RGSS_HEADER_1 || header2 != RGSS_HEADER_2)
return 0;
RGSS_archiveData *data = new RGSS_archiveData;
data->archiveIo = io;
2013-09-04 11:30:14 +00:00
uint32_t magic = RGSS_MAGIC;
2013-09-01 14:27:21 +00:00
/* Top level entry list */
QSet<QByteArray> &topLevel = data->dirHash["."];
2013-09-01 14:27:21 +00:00
while (true)
{
/* Read filename length,
* if nothing was read, no files remain */
2013-09-04 11:30:14 +00:00
uint32_t nameLen;
2013-09-01 14:27:21 +00:00
if (!readUint32(io, nameLen))
break;
nameLen ^= advanceMagic(magic);
static char nameBuf[512];
uint i;
for (i = 0; i < nameLen; ++i)
{
char c;
io->read(io, &c, 1);
nameBuf[i] = c ^ (advanceMagic(magic) & 0xFF);
if (nameBuf[i] == '\\')
nameBuf[i] = '/';
}
nameBuf[i] = 0;
2013-09-04 11:30:14 +00:00
uint32_t entrySize;
2013-09-01 14:27:21 +00:00
readUint32(io, entrySize);
entrySize ^= advanceMagic(magic);
RGSS_entryData entry;
entry.offset = io->tell(io);
entry.size = entrySize;
entry.startMagic = magic;
data->entryHash.insert(nameBuf, entry);
/* Check for top level entries */
for (i = 0; i < nameLen; ++i)
{
bool slash = nameBuf[i] == '/';
if (!slash && i+1 < nameLen)
continue;
if (slash)
nameBuf[i] = '\0';
topLevel.insert(nameBuf);
if (slash)
nameBuf[i] = '/';
}
/* Check for more entries */
2013-09-01 14:27:21 +00:00
for (i = nameLen; i > 0; i--)
if (nameBuf[i] == '/')
{
nameBuf[i] = '\0';
const char *dir = nameBuf;
const char *entry = &nameBuf[i+1];
QSet<QByteArray> &entryList = data->dirHash[dir];
entryList.insert(entry);
2013-09-01 14:27:21 +00:00
}
io->seek(io, entry.offset + entry.size);
}
return data;
}
static void
RGSS_enumerateFiles(void *opaque, const char *dirname,
PHYSFS_EnumFilesCallback cb,
const char *origdir, void *callbackdata)
{
RGSS_archiveData *data = static_cast<RGSS_archiveData*>(opaque);
QByteArray _dirname(dirname);
2013-09-01 14:27:21 +00:00
if (!data->dirHash.contains(_dirname))
return;
2013-09-01 14:27:21 +00:00
const QSet<QByteArray> &entries = data->dirHash.value(_dirname);
2013-09-01 14:27:21 +00:00
QSet<QByteArray>::const_iterator iter;
for (iter = entries.begin(); iter != entries.end(); ++iter)
cb(callbackdata, origdir, iter->constData());
2013-09-01 14:27:21 +00:00
}
static PHYSFS_Io*
RGSS_openRead(void *opaque, const char *filename)
{
RGSS_archiveData *data = static_cast<RGSS_archiveData*>(opaque);
if (!data->entryHash.contains(filename))
return 0;
RGSS_entryHandle *entry =
new RGSS_entryHandle(data->entryHash[filename], data->archiveIo);
2013-09-01 14:27:21 +00:00
PHYSFS_Io *io = PHYSFS_ALLOC(PHYSFS_Io);
*io = RGSS_IoTemplate;
io->opaque = entry;
return io;
}
static int
RGSS_stat(void *opaque, const char *filename, PHYSFS_Stat *stat)
{
RGSS_archiveData *data = static_cast<RGSS_archiveData*>(opaque);
bool hasFile = data->entryHash.contains(filename);
bool hasDir = data->dirHash.contains(filename);
if (!hasFile && !hasDir)
{
PHYSFS_setErrorCode(PHYSFS_ERR_NOT_FOUND);
return 0;
}
stat->modtime =
stat->createtime =
stat->accesstime = 0;
stat->readonly = 1;
if (hasFile)
{
RGSS_entryData &entry = data->entryHash[filename];
stat->filesize = entry.size;
stat->filetype = PHYSFS_FILETYPE_REGULAR;
}
else
{
stat->filesize = 0;
stat->filetype = PHYSFS_FILETYPE_DIRECTORY;
}
return 1;
}
static void
RGSS_closeArchive(void *opaque)
{
RGSS_archiveData *data = static_cast<RGSS_archiveData*>(opaque);
delete data;
}
static PHYSFS_Io*
RGSS_noop1(void*, const char*)
{
return 0;
}
static int
RGSS_noop2(void*, const char*)
{
return 0;
}
static const PHYSFS_Archiver RGSS_Archiver =
{
0,
{
"RGSSAD",
"RGSS encrypted archive format",
"Jonas Kulla <Nyocurio@gmail.com>",
"http://k-du.de/rgss/rgss.html",
0 /* symlinks not supported */
},
RGSS_openArchive,
RGSS_enumerateFiles,
RGSS_openRead,
RGSS_noop1, /* openWrite */
RGSS_noop1, /* openAppend */
RGSS_noop2, /* remove */
RGSS_noop2, /* mkdir */
RGSS_stat,
RGSS_closeArchive
};
FileStream::FileStream(PHYSFS_File *file)
{
p = file;
}
FileStream::~FileStream()
{
// if (p)
// PHYSFS_close(p);
}
void FileStream::operator=(const FileStream &o)
{
p = o.p;
}
sf::Int64 FileStream::read(void *data, sf::Int64 size)
{
if (!p)
return -1;
return PHYSFS_readBytes(p, data, size);
}
sf::Int64 FileStream::seek(sf::Int64 position)
{
if (!p)
return -1;
int success = PHYSFS_seek(p, (PHYSFS_uint64) position);
return success ? position : -1;
}
sf::Int64 FileStream::tell()
{
if (!p)
return -1;
return PHYSFS_tell(p);
}
sf::Int64 FileStream::getSize()
{
if (!p)
return -1;
return PHYSFS_fileLength(p);
}
sf::Int64 FileStream::write(const void *data, sf::Int64 size)
{
if (!p)
return -1;
return PHYSFS_writeBytes(p, data, size);
}
void FileStream::close()
{
if (p)
{
PHYSFS_close(p);
p = 0;
}
}
static const char *imgExt[] =
{
"jpg",
"png"
};
static const char *audExt[] =
{
// "mid",
// "midi",
2013-10-01 00:28:46 +00:00
// "mp3",
// "wma",
2013-09-01 14:27:21 +00:00
"ogg",
2013-10-01 00:28:46 +00:00
"wav"
2013-09-01 14:27:21 +00:00
};
static const char *fonExt[] =
{
"ttf"
};
struct FileExtensions
{
const char **ext;
int count;
} fileExtensions[] =
{
{ imgExt, ARRAY_SIZE(imgExt) },
{ audExt, ARRAY_SIZE(audExt) },
{ fonExt, ARRAY_SIZE(fonExt) }
};
struct FileSystemPrivate
2013-09-01 14:27:21 +00:00
{
/* All keys are lower case */
QHash<QByteArray, QByteArray> pathCache;
2013-09-01 14:27:21 +00:00
const char *completeFileName(const char *filename,
FileSystem::FileType type)
2013-09-01 14:27:21 +00:00
{
char buff[512];
size_t i;
for (i = 0; i < sizeof(buff) && filename[i]; ++i)
buff[i] = tolower(filename[i]);
buff[i] = '\0';
QByteArray key(buff);
if (pathCache.contains(key))
return pathCache[key].constData();
char buff2[512];
if (type != FileSystem::Undefined)
2013-09-01 14:27:21 +00:00
{
FileExtensions *extTest = &fileExtensions[type];
for (int i = 0; i < extTest->count; ++i)
{
snprintf(buff2, sizeof(buff2), "%s.%s", buff, extTest->ext[i]);
key = buff2;
if (pathCache.contains(key))
return pathCache[key].constData();
}
2013-09-01 14:27:21 +00:00
}
return 0;
2013-09-01 14:27:21 +00:00
}
PHYSFS_File *openReadInt(const char *filename,
FileSystem::FileType type)
{
const char *foundName = completeFileName(filename, type);
if (!foundName)
throw Exception(Exception::NoFileError,
"No such file or directory - %s", filename);
PHYSFS_File *handle = PHYSFS_openRead(foundName);
if (!handle)
throw Exception(Exception::PHYSFSError, "PhysFS: %s", PHYSFS_getLastError());
return handle;
}
};
2013-10-20 20:38:46 +00:00
FileSystem::FileSystem(const char *argv0,
bool allowSymlinks)
{
p = new FileSystemPrivate;
PHYSFS_init(argv0);
PHYSFS_registerArchiver(&RGSS_Archiver);
2013-10-20 20:38:46 +00:00
if (allowSymlinks)
PHYSFS_permitSymbolicLinks(1);
}
FileSystem::~FileSystem()
{
delete p;
if (PHYSFS_deinit() == 0)
qDebug() << "PhyFS failed to deinit.";
}
void FileSystem::addPath(const char *path)
{
PHYSFS_mount(path, 0, 1);
2013-09-01 14:27:21 +00:00
}
static void cacheEnumCB(void *d, const char *origdir,
const char *fname)
2013-09-01 14:27:21 +00:00
{
FileSystemPrivate *p = static_cast<FileSystemPrivate*>(d);
char buf[512];
if (*origdir != '.')
snprintf(buf, sizeof(buf), "%s/%s", origdir, fname);
else
strncpy(buf, fname, sizeof(buf));
QByteArray mixedCase(buf);
2013-09-01 14:27:21 +00:00
for (char *p = buf; *p; ++p)
*p = tolower(*p);
2013-09-01 14:27:21 +00:00
QByteArray lowerCase(buf);
p->pathCache.insert(lowerCase, mixedCase);
2013-09-01 14:27:21 +00:00
PHYSFS_enumerateFilesCallback(mixedCase.constData(), cacheEnumCB, p);
}
2013-09-01 14:27:21 +00:00
void FileSystem::createPathCache()
{
PHYSFS_enumerateFilesCallback(".", cacheEnumCB, p);
2013-09-01 14:27:21 +00:00
}
FileStream FileSystem::openRead(const char *filename,
FileType type)
{
PHYSFS_File *handle = p->openReadInt(filename, type);
2013-09-01 14:27:21 +00:00
return FileStream(handle);
}
static inline PHYSFS_File *sdlPHYS(SDL_RWops *ops)
{
return static_cast<PHYSFS_File*>(ops->hidden.unknown.data1);
}
static Sint64 SDL_RWopsSize(SDL_RWops *ops)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return -1;
return PHYSFS_fileLength(f);
}
static Sint64 SDL_RWopsSeek(SDL_RWops *ops, Sint64 offset, int whence)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return -1;
Sint64 base;
switch (whence)
{
default:
case RW_SEEK_SET :
base = 0;
break;
case RW_SEEK_CUR :
base = PHYSFS_tell(f);
break;
case RW_SEEK_END :
base = PHYSFS_fileLength(f);
break;
}
int result = PHYSFS_seek(f, base + offset);
return (result != 0) ? PHYSFS_tell(f) : -1;
}
static size_t SDL_RWopsRead(SDL_RWops *ops, void *buffer, size_t size, size_t maxnum)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return 0;
PHYSFS_sint64 result = PHYSFS_readBytes(f, buffer, size*maxnum);
return (result != -1) ? (result / size) : 0;
}
static size_t SDL_RWopsWrite(SDL_RWops *ops, const void *buffer, size_t size, size_t num)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return 0;
PHYSFS_sint64 result = PHYSFS_writeBytes(f, buffer, size*num);
return (result != -1) ? (result / size) : 0;
}
static int SDL_RWopsClose(SDL_RWops *ops)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return -1;
int result = PHYSFS_close(f);
2013-09-04 11:32:11 +00:00
f = 0;
2013-09-01 14:27:21 +00:00
return (result != 0) ? 0 : -1;
}
static int SDL_RWopsCloseFree(SDL_RWops *ops)
{
int result = SDL_RWopsClose(ops);
SDL_FreeRW(ops);
return result;
}
2013-09-01 14:27:21 +00:00
const Uint32 SDL_RWOPS_PHYSFS = SDL_RWOPS_UNKNOWN+10;
void FileSystem::openRead(SDL_RWops &ops,
const char *filename,
FileType type,
bool freeOnClose)
2013-09-01 14:27:21 +00:00
{
PHYSFS_File *handle = p->openReadInt(filename, type);
2013-09-01 14:27:21 +00:00
ops.size = SDL_RWopsSize;
ops.seek = SDL_RWopsSeek;
ops.read = SDL_RWopsRead;
ops.write = SDL_RWopsWrite;
if (freeOnClose)
ops.close = SDL_RWopsCloseFree;
else
ops.close = SDL_RWopsClose;
2013-09-01 14:27:21 +00:00
ops.type = SDL_RWOPS_PHYSFS;
ops.hidden.unknown.data1 = handle;
}
bool FileSystem::exists(const char *filename, FileType type)
{
const char *foundName = p->completeFileName(filename, type);
2013-09-01 14:27:21 +00:00
return (foundName != 0);
}