scummvm/engines/zvision/zfs_archive.cpp

159 lines
4.9 KiB
C++

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program 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.
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include "common/scummsys.h"
#include "common/hashmap.h"
#include "common/memstream.h"
#include "common/debug.h"
#include "common/file.h"
#include "zvision/zfs_archive.h"
namespace ZVision {
ZfsArchive::ZfsArchive(const Common::String &fileName) : _fileName(fileName) {
Common::File zfsFile;
if (!zfsFile.open(_fileName)) {
warning("ZFSArchive::ZFSArchive(): Could not find the archive file");
return;
}
readHeaders(&zfsFile);
debug(0, "ArjArchive::ArjArchive(%s): Located %d files", _fileName.c_str(), _entryHeaders.size());
}
ZfsArchive::ZfsArchive(const Common::String &fileName, Common::SeekableReadStream *stream) : _fileName(fileName) {
readHeaders(stream);
debug(0, "ArjArchive::ArjArchive(%s): Located %d files", _fileName.c_str(), _entryHeaders.size());
}
ZfsArchive::~ZfsArchive() {
debug(0, "ZfsArchive Destructor Called");
ZfsEntryHeaderMap::iterator it = _entryHeaders.begin();
for ( ; it != _entryHeaders.end(); ++it) {
delete it->_value;
}
}
void ZfsArchive::readHeaders(Common::SeekableReadStream *stream) {
// Don't do a straight struct cast since we can't guarantee endianness
_header.magic = stream->readUint32LE();
_header.unknown1 = stream->readUint32LE();
_header.maxNameLength = stream->readUint32LE();
_header.filesPerBlock = stream->readUint32LE();
_header.fileCount = stream->readUint32LE();
_header.xorKey[0] = stream->readByte();
_header.xorKey[1] = stream->readByte();
_header.xorKey[2] = stream->readByte();
_header.xorKey[3] = stream->readByte();
_header.fileSectionOffset = stream->readUint32LE();
uint32 nextOffset;
do {
// Read the offset to the next block
nextOffset = stream->readUint32LE();
// Read in each entry header
for (uint32 i = 0; i < _header.filesPerBlock; i++) {
ZfsEntryHeader entryHeader;
entryHeader.name = readEntryName(stream);
entryHeader.offset = stream->readUint32LE();
entryHeader.id = stream->readUint32LE();
entryHeader.size = stream->readUint32LE();
entryHeader.time = stream->readUint32LE();
entryHeader.unknown = stream->readUint32LE();
if (entryHeader.size != 0)
_entryHeaders[entryHeader.name] = new ZfsEntryHeader(entryHeader);
}
// Seek to the next block of headers
stream->seek(nextOffset);
} while (nextOffset != 0);
}
Common::String ZfsArchive::readEntryName(Common::SeekableReadStream *stream) const {
// Entry Names are at most 16 bytes and are null padded
char buffer[16];
stream->read(buffer, 16);
return Common::String(buffer);
}
bool ZfsArchive::hasFile(const Common::String &name) const {
return _entryHeaders.contains(name);
}
int ZfsArchive::listMembers(Common::ArchiveMemberList &list) const {
int matches = 0;
for (ZfsEntryHeaderMap::const_iterator it = _entryHeaders.begin(); it != _entryHeaders.end(); ++it) {
list.push_back(Common::ArchiveMemberList::value_type(new Common::GenericArchiveMember(it->_value->name, this)));
matches++;
}
return matches;
}
const Common::ArchiveMemberPtr ZfsArchive::getMember(const Common::String &name) const {
if (!_entryHeaders.contains(name))
return Common::ArchiveMemberPtr();
return Common::ArchiveMemberPtr(new Common::GenericArchiveMember(name, this));
}
Common::SeekableReadStream *ZfsArchive::createReadStreamForMember(const Common::String &name) const {
if (!_entryHeaders.contains(name)) {
return 0;
}
ZfsEntryHeader *entryHeader = _entryHeaders[name];
Common::File zfsArchive;
zfsArchive.open(_fileName);
zfsArchive.seek(entryHeader->offset);
// This *HAS* to be malloc (not new[]) because MemoryReadStream uses free() to free the memory
byte* buffer = (byte *)malloc(entryHeader->size);
zfsArchive.read(buffer, entryHeader->size);
// Decrypt the data in place
if (_header.xorKey != 0)
unXor(buffer, entryHeader->size, _header.xorKey);
return new Common::MemoryReadStream(buffer, entryHeader->size, DisposeAfterUse::YES);
}
void ZfsArchive::unXor(byte *buffer, uint32 length, const byte *xorKey) const {
for (uint32 i = 0; i < length; i++)
buffer[i] ^= xorKey[i % 4];
}
} // End of namespace ZVision