scummvm/engines/cge/fileio.cpp

/* 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.
 *
 */

/*
 * This code is based on original Soltys source code
 * Copyright (c) 1994-1995 Janus B. Wisniewski and L.K. Avalon
 */

#include "common/system.h"
#include "common/str.h"
#include "common/debug.h"
#include "common/debug-channels.h"
#include "common/memstream.h"
#include "cge/cge.h"
#include "cge/fileio.h"

namespace CGE {

/*-----------------------------------------------------------------------
 * IOHand
 *-----------------------------------------------------------------------*/
IoHand::IoHand() : _error(0) {
	_file = new Common::File();
}

IoHand::IoHand(const char *name) : _error(0) {
	_file = new Common::File();
	_file->open(name);
}

IoHand::~IoHand() {
	_file->close();
	delete _file;
}

uint16 IoHand::read(void *buf, uint16 len) {
	if (!_file->isOpen())
		return 0;

	uint16 bytesRead = _file->read(buf, len);
	if (!bytesRead)
		error("Read %s - %d bytes", _file->getName(), len);
	XCrypt(buf, len);
	return bytesRead;
}

long IoHand::mark() {
	return _file->pos();
}

long IoHand::seek(long pos) {
	_file->seek(pos, SEEK_SET);
	return _file->pos();
}

long IoHand::size() {
	return _file->size();
}

/*-----------------------------------------------------------------------
 * BtPage
 *-----------------------------------------------------------------------*/
void BtPage::read(Common::ReadStream &s) {
	_header._count = s.readUint16LE();
	_header._down = s.readUint16LE();

	if (_header._down == kBtValNone) {
		// Leaf list
		for (int i = 0; i < kBtLeafCount; ++i) {
			s.read(_leaf[i]._key, kBtKeySize);
			_leaf[i]._mark = s.readUint32LE();
			_leaf[i]._size = s.readUint16LE();
		}
	} else {
		// Root index
		for (int i = 0; i < kBtInnerCount; ++i) {
			s.read(_inner[i]._key, kBtKeySize);
			_inner[i]._down = s.readUint16LE();
		}
	}
}

/*-----------------------------------------------------------------------
 * BtFile
 *-----------------------------------------------------------------------*/
BtFile::BtFile(const char *name) : IoHand(name) {
	debugC(1, kCGEDebugFile, "BtFile::BtFile(%s)", name);

	for (int i = 0; i < kBtLevel; i++) {
		_buff[i]._page = new BtPage;
		_buff[i]._pgNo = kBtValNone;
		_buff[i]._indx = -1;
		assert(_buff[i]._page != NULL);
	}
}

BtFile::~BtFile() {
	debugC(1, kCGEDebugFile, "BtFile::~BtFile()");
	for (int i = 0; i < kBtLevel; i++)
		delete _buff[i]._page;
}

BtPage *BtFile::getPage(int lev, uint16 pgn) {
	debugC(1, kCGEDebugFile, "BtFile::getPage(%d, %d)", lev, pgn);

	if (_buff[lev]._pgNo != pgn) {
		int32 pos = pgn * kBtSize;
		_buff[lev]._pgNo = pgn;
		assert(size() > pos);
		// In the original, there was a check verifying if the
		// purpose was to write a new file. This should only be
		// to create a new file, thus it was removed.
		seek((uint32) pgn * kBtSize);

		// Read in the page
		byte buffer[kBtSize];
		int bytesRead = read(buffer, kBtSize);

		// Unpack it into the page structure
		Common::MemoryReadStream stream(buffer, bytesRead, DisposeAfterUse::NO);
		_buff[lev]._page->read(stream);

		_buff[lev]._indx = -1;
	}
	return _buff[lev]._page;
}

BtKeypack *BtFile::find(const char *key) {
	debugC(1, kCGEDebugFile, "BtFile::find(%s)", key);

	int lev = 0;
	uint16 nxt = kBtValRoot;
	while (!_error) {
		BtPage *pg = getPage(lev, nxt);
		// search
		if (pg->_header._down != kBtValNone) {
			int i;
			for (i = 0; i < pg->_header._count; i++) {
				// Does this work, or does it have to compare the entire buffer?
				if (scumm_strnicmp((const char *)key, (const char*)pg->_inner[i]._key, kBtKeySize) < 0)
					break;
			}
			nxt = (i) ? pg->_inner[i - 1]._down : pg->_header._down;
			_buff[lev]._indx = i - 1;
			lev++;
		} else {
			int i;
			for (i = 0; i < pg->_header._count - 1; i++) {
				if (scumm_stricmp((const char *)key, (const char *)pg->_leaf[i]._key) <= 0)
					break;
			}
			_buff[lev]._indx = i;
			return &pg->_leaf[i];
		}
	}
	return NULL;
}

bool BtFile::exist(const char *name) {
	debugC(1, kCGEDebugFile, "BtFile::exist(%s)", name);

	return scumm_stricmp(find(name)->_key, name) == 0;
}

/*-----------------------------------------------------------------------
 * EncryptedStream
 *-----------------------------------------------------------------------*/
EncryptedStream::EncryptedStream(const char *name) {
	debugC(3, kCGEDebugFile, "EncryptedStream::EncryptedStream(%s)", name);

	_error = false;
	if (_dat->_error || _cat->_error)
		error("Bad volume data");
	BtKeypack *kp = _cat->find(name);
	if (scumm_stricmp(kp->_key, name) != 0)
		_error = true;

	_dat->_file->seek(kp->_mark);
	byte *dataBuffer = (byte *)malloc(kp->_size);
	_dat->_file->read(dataBuffer, kp->_size);
	XCrypt(dataBuffer, kp->_size);
	_readStream = new Common::MemoryReadStream(dataBuffer, kp->_size, DisposeAfterUse::YES);
}

uint32 EncryptedStream::read(void *dataPtr, uint32 dataSize) {
	return _readStream->read(dataPtr, dataSize);
}

bool EncryptedStream::err() {
	return (_error & _readStream->err());
}

bool EncryptedStream::eos() {
	return _readStream->eos();
}

bool EncryptedStream::seek(int32 offset) {
	return _readStream->seek(offset);
}

Common::String EncryptedStream::readLine() {
	return _readStream->readLine();
}

int32 EncryptedStream::size() {
	return _readStream->size();
}

int32 EncryptedStream::pos() {
	return _readStream->pos();
}

EncryptedStream::~EncryptedStream() {
}

} // End of namespace CGE