/* DirArchive::removeDir
* Deletes the directory matching [path], starting from [base]. If
* [base] is NULL, the root directory is used. Returns false if
* the directory does not exist, true otherwise
*
* For DirArchive also adds all subdirs and entries to the removed
* files list, so they are ignored when checking for changes on disk
*******************************************************************/
bool DirArchive::removeDir(string path, ArchiveTreeNode* base)
{
// Abort if read only
if (read_only)
return false;
// Get the dir to remove
ArchiveTreeNode* dir = getDir(path, base);
// Check it exists (and that it isn't the root dir)
if (!dir || dir == getRoot())
return false;
// Get all entries in the directory (and subdirectories)
vector<ArchiveEntry*> entries;
getEntryTreeAsList(entries, dir);
// Add to removed files list
for (unsigned a = 0; a < entries.size(); a++)
{
LOG_MESSAGE(2, entries[a]->exProp("filePath").getStringValue());
removed_files.push_back(entries[a]->exProp("filePath").getStringValue());
}
// Do normal dir remove
return Archive::removeDir(path, base);
}
/* Archive::getEntryTreeAsList
* Adds the directory structure starting from [start] to [list]
*******************************************************************/
void Archive::getEntryTreeAsList(vector<ArchiveEntry*>& list, ArchiveTreeNode* start)
{
// If no start dir is specified, use the root dir
if (!start)
start = dir_root;
// Add the directory entry to the list if it isn't the root dir
if (start != dir_root)
list.push_back(start->dir_entry);
// Add all entries to the list
for (unsigned a = 0; a < start->numEntries(); a++)
list.push_back(start->getEntry(a));
// Go through subdirectories and add them to the list
for (unsigned a = 0; a < start->nChildren(); a++)
getEntryTreeAsList(list, (ArchiveTreeNode*)start->getChild(a));
}
// -----------------------------------------------------------------------------
// Reads Chasm bin format data from a MemChunk
// Returns true if successful, false otherwise
// -----------------------------------------------------------------------------
bool ChasmBinArchive::open(MemChunk& mc)
{
// Check given data is valid
if (mc.getSize() < HEADER_SIZE)
{
return false;
}
// Read .bin header and check it
char magic[4] = {};
mc.read(magic, sizeof magic);
if (magic[0] != 'C' || magic[1] != 'S' || magic[2] != 'i' || magic[3] != 'd')
{
LOG_MESSAGE(1, "ChasmBinArchive::open: Opening failed, invalid header");
Global::error = "Invalid Chasm bin header";
return false;
}
// Stop announcements (don't want to be announcing modification due to entries being added etc)
setMuted(true);
uint16_t num_entries = 0;
mc.read(&num_entries, sizeof num_entries);
num_entries = wxUINT16_SWAP_ON_BE(num_entries);
// Read the directory
UI::setSplashProgressMessage("Reading Chasm bin archive data");
for (uint16_t i = 0; i < num_entries; ++i)
{
// Update splash window progress
UI::setSplashProgress(static_cast<float>(i) / num_entries);
// Read entry info
char name[NAME_SIZE] = {};
mc.read(name, sizeof name);
uint32_t size;
mc.read(&size, sizeof size);
size = wxUINT32_SWAP_ON_BE(size);
uint32_t offset;
mc.read(&offset, sizeof offset);
offset = wxUINT32_SWAP_ON_BE(offset);
// Check offset+size
if (offset + size > mc.getSize())
{
LOG_MESSAGE(1, "ChasmBinArchive::open: Bin archive is invalid or corrupt (entry goes past end of file)");
Global::error = "Archive is invalid and/or corrupt";
setMuted(false);
return false;
}
// Convert Pascal to zero-terminated string
memmove(name, name + 1, sizeof name - 1);
name[sizeof name - 1] = '\0';
// Create entry
ArchiveEntry* const entry = new ArchiveEntry(name, size);
entry->exProp("Offset") = static_cast<int>(offset);
entry->setLoaded(false);
entry->setState(0);
rootDir()->addEntry(entry);
}
// Detect all entry types
UI::setSplashProgressMessage("Detecting entry types");
vector<ArchiveEntry*> all_entries;
getEntryTreeAsList(all_entries);
MemChunk edata;
for (size_t i = 0; i < all_entries.size(); ++i)
{
// Update splash window progress
UI::setSplashProgress(static_cast<float>(i) / num_entries);
// Get entry
ArchiveEntry* const entry = all_entries[i];
// Read entry data if it isn't zero-sized
if (entry->getSize() > 0)
{
// Read the entry data
mc.exportMemChunk(edata, static_cast<int>(entry->exProp("Offset")), entry->getSize());
entry->importMemChunk(edata);
}
// Detect entry type
EntryType::detectEntryType(entry);
fixBrokenWave(entry);
// Unload entry data if needed
if (!archive_load_data)
{
entry->unloadData();
}
// Set entry to unchanged
entry->setState(0);
}
// Setup variables
setMuted(false);
setModified(false);
announce("opened");
UI::setSplashProgressMessage("");
return true;
}
// -----------------------------------------------------------------------------
// Writes Chasm bin archive to a MemChunk
// Returns true if successful, false otherwise
// -----------------------------------------------------------------------------
bool ChasmBinArchive::write(MemChunk& mc, bool update)
{
// Clear current data
mc.clear();
// Get archive tree as a list
vector<ArchiveEntry*> entries;
getEntryTreeAsList(entries);
// Check limit of entries count
const uint16_t num_entries = static_cast<uint16_t>(entries.size());
if (num_entries > MAX_ENTRY_COUNT)
{
LOG_MESSAGE(1, "ChasmBinArchive::write: Bin archive can contain no more than %u entries", MAX_ENTRY_COUNT);
Global::error = "Maximum number of entries exceeded for Chasm: The Rift bin archive";
return false;
}
// Init data size
static const uint32_t HEADER_TOC_SIZE = HEADER_SIZE + ENTRY_SIZE * MAX_ENTRY_COUNT;
mc.reSize(HEADER_TOC_SIZE, false);
mc.fillData(0);
// Write header
const char magic[4] = { 'C', 'S', 'i', 'd' };
mc.seek(0, SEEK_SET);
mc.write(magic, 4);
mc.write(&num_entries, sizeof num_entries);
// Write directory
uint32_t offset = HEADER_TOC_SIZE;
for (uint16_t i = 0; i < num_entries; ++i)
{
ArchiveEntry* const entry = entries[i];
// Update entry
if (update)
{
entry->setState(0);
entry->exProp("Offset") = static_cast<int>(offset);
}
// Check entry name
string name = entry->getName();
uint8_t name_length = static_cast<uint8_t>(name.Length());
if (name_length > NAME_SIZE - 1)
{
LOG_MESSAGE(1, "Warning: Entry %s name is too long, it will be truncated", name);
name.Truncate(NAME_SIZE - 1);
name_length = static_cast<uint8_t>(NAME_SIZE - 1);
}
// Write entry name
char name_data[NAME_SIZE] = {};
memcpy(name_data, &name_length, 1);
memcpy(name_data + 1, CHR(name), name_length);
mc.write(name_data, NAME_SIZE);
// Write entry size
const uint32_t size = entry->getSize();
mc.write(&size, sizeof size);
// Write entry offset
mc.write(&offset, sizeof offset);
// Increment/update offset
offset += size;
}
// Write entry data
mc.reSize(offset);
mc.seek(HEADER_TOC_SIZE, SEEK_SET);
for (uint16_t i = 0; i < num_entries; ++i)
{
ArchiveEntry* const entry = entries[i];
mc.write(entry->getData(), entry->getSize());
}
return true;
}
/* ADatArchive::open
* Reads dat format data from a MemChunk
* Returns true if successful, false otherwise
*******************************************************************/
bool ADatArchive::open(MemChunk& mc) {
// Check given data is valid
if (mc.getSize() < 16)
return false;
// Read dat header
char magic[4];
long dir_offset;
long dir_size;
mc.seek(0, SEEK_SET);
mc.read(magic, 4);
mc.read(&dir_offset, 4);
mc.read(&dir_size, 4);
// Check it
if (magic[0] != 'A' || magic[1] != 'D' || magic[2] != 'A' || magic[3] != 'T') {
wxLogMessage("ADatArchive::open: Opening failed, invalid header");
Global::error = "Invalid dat header";
return false;
}
// Stop announcements (don't want to be announcing modification due to entries being added etc)
setMuted(true);
// Read the directory
size_t num_entries = dir_size / DIRENTRY;
mc.seek(dir_offset, SEEK_SET);
theSplashWindow->setProgressMessage("Reading dat archive data");
for (uint32_t d = 0; d < num_entries; d++) {
// Update splash window progress
theSplashWindow->setProgress(((float)d / (float)num_entries));
// Read entry info
char name[128];
long offset;
long decsize;
long compsize;
long whatever; // No idea what this could be
mc.read(name, 128);
mc.read(&offset, 4);
mc.read(&decsize, 4);
mc.read(&compsize, 4);
mc.read(&whatever, 4);
// Byteswap if needed
offset = wxINT32_SWAP_ON_BE(offset);
decsize = wxINT32_SWAP_ON_BE(decsize);
compsize = wxINT32_SWAP_ON_BE(compsize);
// Check offset+size
if ((unsigned)(offset + compsize) > mc.getSize()) {
wxLogMessage("ADatArchive::open: dat archive is invalid or corrupt (entry goes past end of file)");
Global::error = "Archive is invalid and/or corrupt";
setMuted(false);
return false;
}
// Parse name
wxFileName fn(wxString::FromAscii(name, 128));
// Create directory if needed
ArchiveTreeNode* dir = createDir(fn.GetPath(true, wxPATH_UNIX));
// Create entry
ArchiveEntry* entry = new ArchiveEntry(fn.GetFullName(), compsize);
entry->exProp("Offset") = (int)offset;
entry->exProp("FullSize") = (int)decsize;
entry->setLoaded(false);
entry->setState(0);
// Add to directory
dir->addEntry(entry);
}
// Detect all entry types
MemChunk edata;
vector<ArchiveEntry*> all_entries;
getEntryTreeAsList(all_entries);
theSplashWindow->setProgressMessage("Detecting entry types");
for (size_t a = 0; a < all_entries.size(); a++) {
// Update splash window progress
theSplashWindow->setProgress((((float)a / (float)num_entries)));
// Get entry
ArchiveEntry* entry = all_entries[a];
// Read entry data if it isn't zero-sized
if (entry->getSize() > 0) {
// Read the entry data
mc.exportMemChunk(edata, (int)entry->exProp("Offset"), entry->getSize());
MemChunk xdata;
if (Compression::ZlibInflate(edata, xdata, (int)entry->exProp("FullSize")))
entry->importMemChunk(xdata);
else {
wxLogMessage("Entry %s couldn't be inflated", CHR(entry->getName()));
entry->importMemChunk(edata);
}
}
// Detect entry type
EntryType::detectEntryType(entry);
// Unload entry data if needed
if (!archive_load_data)
entry->unloadData();
// Set entry to unchanged
entry->setState(0);
}
// Setup variables
setMuted(false);
setModified(false);
announce("opened");
theSplashWindow->setProgressMessage("");
return true;
}
/* ADatArchive::write
* Writes the dat archive to a MemChunk
* Returns true if successful, false otherwise
*******************************************************************/
bool ADatArchive::write(MemChunk& mc, bool update) {
// Clear current data
mc.clear();
MemChunk directory;
MemChunk compressed;
// Get archive tree as a list
vector<ArchiveEntry*> entries;
getEntryTreeAsList(entries);
// Write header
long dir_offset = wxINT32_SWAP_ON_BE(16);
long dir_size = wxINT32_SWAP_ON_BE(0);
char pack[4] = { 'A', 'D', 'A', 'T' };
uint32_t version = wxINT32_SWAP_ON_BE(9);
mc.seek(0, SEEK_SET);
mc.write(pack, 4);
mc.write(&dir_offset, 4);
mc.write(&dir_size, 4);
mc.write(&version, 4);
// Write entry data
for (unsigned a = 0; a < entries.size(); a++) {
// Skip folders
if (entries[a]->getType() == EntryType::folderType())
continue;
// Create compressed version of the lump
MemChunk * entry = NULL;
if (Compression::ZlibDeflate(entries[a]->getMCData(), compressed, 9)) {
entry = &compressed;
} else {
entry = &(entries[a]->getMCData());
wxLogMessage("Entry %s couldn't be deflated", CHR(entries[a]->getName()));
}
// Update entry
int offset = mc.currentPos();
if (update) {
entries[a]->setState(0);
entries[a]->exProp("Offset") = (int)offset;
}
///////////////////////////////////
// Step 1: Write directory entry //
///////////////////////////////////
// Check entry name
string name = entries[a]->getPath(true);
name.Remove(0, 1); // Remove leading /
if (name.Len() > 128) {
wxLogMessage("Warning: Entry %s path is too long (> 128 characters), putting it in the root directory", CHR(name));
wxFileName fn(name);
name = fn.GetFullName();
if (name.Len() > 128)
name.Truncate(128);
}
// Write entry name
char name_data[128];
memset(name_data, 0, 128);
memcpy(name_data, CHR(name), name.Length());
directory.write(name_data, 128);
// Write entry offset
long myoffset = wxINT32_SWAP_ON_BE(offset);
directory.write(&myoffset, 4);
// Write full entry size
long decsize = wxINT32_SWAP_ON_BE(entries[a]->getSize());
directory.write(&decsize, 4);
// Write compressed entry size
long compsize = wxINT32_SWAP_ON_BE(entry->getSize());
directory.write(&compsize, 4);
// Write whatever it is that should be there
// TODO: Reverse engineer what exactly it is
// and implement something valid for the game.
long whatever = 0;
directory.write(&whatever, 4);
//////////////////////////////
// Step 2: Write entry data //
//////////////////////////////
mc.write(entry->getData(), entry->getSize());
}
// Write directory
dir_offset = wxINT32_SWAP_ON_BE(mc.currentPos());
dir_size = wxINT32_SWAP_ON_BE(directory.getSize());
mc.write(directory.getData(), directory.getSize());
// Update directory offset and size in header
mc.seek(4, SEEK_SET);
mc.write(&dir_offset, 4);
mc.write(&dir_size, 4);
// Yay! Finished!
return true;
}
/* ZipArchive::open
* Reads zip data from a file
* Returns true if successful, false otherwise
*******************************************************************/
bool ZipArchive::open(string filename)
{
// Open the file
wxFFileInputStream in(filename);
if (!in.IsOk())
{
Global::error = "Unable to open file";
return false;
}
// Create zip stream
wxZipInputStream zip(in);
if (!zip.IsOk())
{
Global::error = "Invalid zip file";
return false;
}
// Stop announcements (don't want to be announcing modification due to entries being added etc)
setMuted(true);
// Go through all zip entries
int entry_index = 0;
wxZipEntry* entry = zip.GetNextEntry();
theSplashWindow->setProgressMessage("Reading zip data");
while (entry)
{
theSplashWindow->setProgress(-1.0f);
if (entry->GetMethod() != wxZIP_METHOD_DEFLATE && entry->GetMethod() != wxZIP_METHOD_STORE)
{
Global::error = "Unsupported zip compression method";
setMuted(false);
return false;
}
if (!entry->IsDir())
{
// Get the entry name as a wxFileName (so we can break it up)
wxFileName fn(entry->GetName(wxPATH_UNIX), wxPATH_UNIX);
// Create entry
ArchiveEntry* new_entry = new ArchiveEntry(fn.GetFullName(), entry->GetSize());
// Setup entry info
new_entry->setLoaded(false);
new_entry->exProp("ZipIndex") = entry_index;
// Add entry and directory to directory tree
ArchiveTreeNode* ndir = createDir(fn.GetPath(true, wxPATH_UNIX));
ndir->addEntry(new_entry);
//zipdir_t* ndir = addDirectory(fn.GetPath(true, wxPATH_UNIX));
//ndir->entries.push_back(new_entry);
// Read the data, if possible
if (entry->GetSize() < 250 * 1024 * 1024)
{
uint8_t* data = new uint8_t[entry->GetSize()];
zip.Read(data, entry->GetSize()); // Note: this is where exceedingly large files cause an exception.
new_entry->importMem(data, entry->GetSize());
new_entry->setLoaded(true);
// Determine its type
EntryType::detectEntryType(new_entry);
// Unload data if needed
if (!archive_load_data)
new_entry->unloadData();
// Clean up
delete[] data;
}
else
{
Global::error = S_FMT("Entry too large: %s is %u mb",
entry->GetName(wxPATH_UNIX), entry->GetSize() / (1<<20));
setMuted(false);
return false;
}
}
else
{
// Zip entry is a directory, add it to the directory tree
wxFileName fn(entry->GetName(wxPATH_UNIX), wxPATH_UNIX);
createDir(fn.GetPath(true, wxPATH_UNIX));
//addDirectory(fn.GetPath(true, wxPATH_UNIX));
}
// Go to next entry in the zip file
delete entry;
entry = zip.GetNextEntry();
entry_index++;
}
theSplashWindow->forceRedraw();
// Set all entries/directories to unmodified
vector<ArchiveEntry*> entry_list;
getEntryTreeAsList(entry_list);
for (size_t a = 0; a < entry_list.size(); a++)
entry_list[a]->setState(0);
// Enable announcements
setMuted(false);
// Setup variables
this->filename = filename;
setModified(false);
on_disk = true;
theSplashWindow->setProgressMessage("");
return true;
}
/* ZipArchive::write
* Writes the zip archive to a file
* Returns true if successful, false otherwise
*******************************************************************/
bool ZipArchive::write(string filename, bool update)
{
// If we're overwriting the current file, rename it so that it can still be read while writing the 'new' file
string current = this->filename;
bool temp = false;
if (S_CMPNOCASE(filename, this->filename))
{
current = appPath("tempzip.zip", DIR_TEMP);
wxCopyFile(this->filename, current);
temp = true;
}
// Open the file
wxFFileOutputStream out(filename);
if (!out.IsOk())
{
Global::error = "Unable to open file for saving. Make sure it isn't in use by another program.";
return false;
}
// Open as zip for writing
wxZipOutputStream zip(out, 9);
if (!zip.IsOk())
{
Global::error = "Unable to create zip for saving";
return false;
}
// Open old zip for copying, if it exists. This is used to copy any entries
// that have been previously saved/compressed and are unmodified, to greatly
// speed up zip file saving by not having to recompress unchanged entries
wxFFileInputStream in(current);
wxZipInputStream inzip(in);
// Get a list of all entries in the old zip
wxZipEntry** c_entries = new wxZipEntry*[inzip.GetTotalEntries()];
for (int a = 0; a < inzip.GetTotalEntries(); a++)
c_entries[a] = inzip.GetNextEntry();
// Get a linear list of all entries in the archive
vector<ArchiveEntry*> entries;
getEntryTreeAsList(entries);
// Go through all entries
for (size_t a = 0; a < entries.size(); a++)
{
if (entries[a]->getType() == EntryType::folderType())
{
// If the current entry is a folder, just write a directory entry and continue
zip.PutNextDirEntry(entries[a]->getPath(true));
if (update) entries[a]->setState(0);
continue;
}
// Get entry zip index
int index = -1;
if (entries[a]->exProps().propertyExists("ZipIndex"))
index = entries[a]->exProp("ZipIndex");
if (!inzip.IsOk() || entries[a]->getState() > 0 || index < 0 || index >= inzip.GetTotalEntries())
{
// If the current entry has been changed, or doesn't exist in the old zip,
// (re)compress its data and write it to the zip
wxZipEntry* zipentry = new wxZipEntry(entries[a]->getPath() + entries[a]->getName());
zip.PutNextEntry(zipentry);
zip.Write(entries[a]->getData(), entries[a]->getSize());
}
else
{
// If the entry is unmodified and exists in the old zip, just copy it over
c_entries[index]->SetName(entries[a]->getPath() + entries[a]->getName());
zip.CopyEntry(c_entries[index], inzip);
inzip.Reset();
}
// Update entry info
if (update)
{
entries[a]->setState(0);
entries[a]->exProp("ZipIndex") = (int)a;
}
}
// Clean up
delete[] c_entries;
zip.Close();
return true;
}
/* PakArchive::open
* Reads pak format data from a MemChunk
* Returns true if successful, false otherwise
*******************************************************************/
bool PakArchive::open(MemChunk& mc)
{
// Check given data is valid
if (mc.getSize() < 12)
return false;
// Read pak header
char pack[4];
long dir_offset;
long dir_size;
mc.seek(0, SEEK_SET);
mc.read(pack, 4);
mc.read(&dir_offset, 4);
mc.read(&dir_size, 4);
// Check it
if (pack[0] != 'P' || pack[1] != 'A' || pack[2] != 'C' || pack[3] != 'K')
{
wxLogMessage("PakArchive::open: Opening failed, invalid header");
Global::error = "Invalid pak header";
return false;
}
// Stop announcements (don't want to be announcing modification due to entries being added etc)
setMuted(true);
// Read the directory
size_t num_entries = dir_size / 64;
mc.seek(dir_offset, SEEK_SET);
theSplashWindow->setProgressMessage("Reading pak archive data");
for (uint32_t d = 0; d < num_entries; d++)
{
// Update splash window progress
theSplashWindow->setProgress(((float)d / (float)num_entries));
// Read entry info
char name[56];
long offset;
long size;
mc.read(name, 56);
mc.read(&offset, 4);
mc.read(&size, 4);
// Byteswap if needed
offset = wxINT32_SWAP_ON_BE(offset);
size = wxINT32_SWAP_ON_BE(size);
// Check offset+size
if ((unsigned)(offset + size) > mc.getSize())
{
wxLogMessage("PakArchive::open: Pak archive is invalid or corrupt (entry goes past end of file)");
Global::error = "Archive is invalid and/or corrupt";
setMuted(false);
return false;
}
// Parse name
wxFileName fn(wxString::FromAscii(name, 56));
// Create directory if needed
ArchiveTreeNode* dir = createDir(fn.GetPath(true, wxPATH_UNIX));
// Create entry
ArchiveEntry* entry = new ArchiveEntry(fn.GetFullName(), size);
entry->exProp("Offset") = (int)offset;
entry->setLoaded(false);
entry->setState(0);
// Add to directory
dir->addEntry(entry);
}
// Detect all entry types
MemChunk edata;
vector<ArchiveEntry*> all_entries;
getEntryTreeAsList(all_entries);
theSplashWindow->setProgressMessage("Detecting entry types");
for (size_t a = 0; a < all_entries.size(); a++)
{
// Update splash window progress
theSplashWindow->setProgress((((float)a / (float)num_entries)));
// Get entry
ArchiveEntry* entry = all_entries[a];
// Read entry data if it isn't zero-sized
if (entry->getSize() > 0)
{
// Read the entry data
mc.exportMemChunk(edata, (int)entry->exProp("Offset"), entry->getSize());
entry->importMemChunk(edata);
}
// Detect entry type
EntryType::detectEntryType(entry);
// Unload entry data if needed
if (!archive_load_data)
entry->unloadData();
// Set entry to unchanged
entry->setState(0);
}
// Setup variables
setMuted(false);
setModified(false);
announce("opened");
theSplashWindow->setProgressMessage("");
return true;
}
/* PakArchive::write
* Writes the pak archive to a MemChunk
* Returns true if successful, false otherwise
*******************************************************************/
bool PakArchive::write(MemChunk& mc, bool update)
{
// Clear current data
mc.clear();
// Get archive tree as a list
vector<ArchiveEntry*> entries;
getEntryTreeAsList(entries);
// Process entry list
long dir_offset = 12;
long dir_size = 0;
for (unsigned a = 0; a < entries.size(); a++)
{
// Ignore folder entries
if (entries[a]->getType() == EntryType::folderType())
continue;
// Increment directory offset and size
dir_offset += entries[a]->getSize();
dir_size += 64;
}
// Init data size
mc.reSize(dir_offset + dir_size, false);
// Write header
char pack[4] = { 'P', 'A', 'C', 'K' };
mc.seek(0, SEEK_SET);
mc.write(pack, 4);
mc.write(&dir_offset, 4);
mc.write(&dir_size, 4);
// Write directory
mc.seek(dir_offset, SEEK_SET);
long offset = 12;
for (unsigned a = 0; a < entries.size(); a++)
{
// Skip folders
if (entries[a]->getType() == EntryType::folderType())
continue;
// Update entry
if (update)
{
entries[a]->setState(0);
entries[a]->exProp("Offset") = (int)offset;
}
// Check entry name
string name = entries[a]->getPath(true);
name.Remove(0, 1); // Remove leading /
if (name.Len() > 56)
{
wxLogMessage("Warning: Entry %s path is too long (> 56 characters), putting it in the root directory", name);
wxFileName fn(name);
name = fn.GetFullName();
if (name.Len() > 56)
name.Truncate(56);
}
// Write entry name
char name_data[56];
memset(name_data, 0, 56);
memcpy(name_data, CHR(name), name.Length());
mc.write(name_data, 56);
// Write entry offset
mc.write(&offset, 4);
// Write entry size
long size = entries[a]->getSize();
mc.write(&size, 4);
// Increment/update offset
offset += size;
}
// Write entry data
mc.seek(12, SEEK_SET);
for (unsigned a = 0; a < entries.size(); a++)
{
// Skip folders
if (entries[a]->getType() == EntryType::folderType())
continue;
// Write data
mc.write(entries[a]->getData(), entries[a]->getSize());
}
return true;
}
/* DirArchive::open
* Reads files from the directory [filename] into the archive
* Returns true if successful, false otherwise
*******************************************************************/
bool DirArchive::open(string filename)
{
theSplashWindow->setProgressMessage("Reading directory structure");
theSplashWindow->setProgress(0);
//wxArrayString files;
//wxDir::GetAllFiles(filename, &files, wxEmptyString, wxDIR_FILES|wxDIR_DIRS);
vector<string> files, dirs;
DirArchiveTraverser traverser(files, dirs);
wxDir dir(filename);
dir.Traverse(traverser, "", wxDIR_FILES | wxDIR_DIRS);
theSplashWindow->setProgressMessage("Reading files");
for (unsigned a = 0; a < files.size(); a++)
{
theSplashWindow->setProgress((float)a / (float)files.size());
// Cut off directory to get entry name + relative path
string name = files[a];
name.Remove(0, filename.Length());
if (name.StartsWith(separator))
name.Remove(0, 1);
//LOG_MESSAGE(3, fn.GetPath(true, wxPATH_UNIX));
// Create entry
wxFileName fn(name);
ArchiveEntry* new_entry = new ArchiveEntry(fn.GetFullName());
// Setup entry info
new_entry->setLoaded(false);
new_entry->exProp("filePath") = files[a];
// Add entry and directory to directory tree
ArchiveTreeNode* ndir = createDir(fn.GetPath(true, wxPATH_UNIX));
ndir->addEntry(new_entry);
ndir->getDirEntry()->exProp("filePath") = filename + fn.GetPath(true, wxPATH_UNIX);
// Read entry data
new_entry->importFile(files[a]);
new_entry->setLoaded(true);
time_t modtime = wxFileModificationTime(files[a]);
file_modification_times[new_entry] = modtime;
// Detect entry type
EntryType::detectEntryType(new_entry);
// Unload data if needed
if (!archive_load_data)
new_entry->unloadData();
}
// Add empty directories
for (unsigned a = 0; a < dirs.size(); a++)
{
string name = dirs[a];
name.Remove(0, filename.Length());
if (name.StartsWith(separator))
name.Remove(0, 1);
name.Replace("\\", "/");
ArchiveTreeNode* ndir = createDir(name);
ndir->getDirEntry()->exProp("filePath") = dirs[a];
}
// Set all entries/directories to unmodified
vector<ArchiveEntry*> entry_list;
getEntryTreeAsList(entry_list);
for (size_t a = 0; a < entry_list.size(); a++)
entry_list[a]->setState(0);
// Enable announcements
setMuted(false);
// Setup variables
this->filename = filename;
setModified(false);
on_disk = true;
theSplashWindow->setProgressMessage("");
return true;
}
/* DirArchive::save
* Saves any changes to the directory to the file system
*******************************************************************/
bool DirArchive::save(string filename)
{
// Get flat entry list
vector<ArchiveEntry*> entries;
getEntryTreeAsList(entries);
// Get entry path list
vector<string> entry_paths;
for (unsigned a = 0; a < entries.size(); a++)
{
entry_paths.push_back(this->filename + entries[a]->getPath(true));
if (separator != "/") entry_paths.back().Replace("/", separator);
}
// Get current directory structure
long time = theApp->runTimer();
vector<string> files, dirs;
DirArchiveTraverser traverser(files, dirs);
wxDir dir(this->filename);
dir.Traverse(traverser, "", wxDIR_FILES|wxDIR_DIRS);
//wxDir::GetAllFiles(this->filename, &files, wxEmptyString, wxDIR_FILES|wxDIR_DIRS);
LOG_MESSAGE(2, "GetAllFiles took %lums", theApp->runTimer() - time);
// Check for any files to remove
time = theApp->runTimer();
for (unsigned a = 0; a < removed_files.size(); a++)
{
if (wxFileExists(removed_files[a]))
{
LOG_MESSAGE(2, "Removing file %s", removed_files[a]);
wxRemoveFile(removed_files[a]);
}
}
// Check for any directories to remove
for (int a = dirs.size() - 1; a >= 0; a--)
{
// Check if dir path matches an existing dir
bool found = false;
for (unsigned e = 0; e < entry_paths.size(); e++)
{
if (dirs[a] == entry_paths[e])
{
found = true;
break;
}
}
// Dir on disk isn't part of the archive in memory
// (Note that this will fail if there are any untracked files in the
// directory)
if (!found && wxRmdir(dirs[a]))
LOG_MESSAGE(2, "Removing directory %s", dirs[a]);
}
LOG_MESSAGE(2, "Remove check took %lums", theApp->runTimer() - time);
// Go through entries
vector<string> files_written;
for (unsigned a = 0; a < entries.size(); a++)
{
// Check for folder
string path = entry_paths[a];
if (entries[a]->getType() == EntryType::folderType())
{
// Create if needed
if (!wxDirExists(path))
wxMkdir(path);
// Set unmodified
entries[a]->exProp("filePath") = path;
entries[a]->setState(0);
continue;
}
// Check if entry needs to be (re)written
if (entries[a]->getState() == 0 && path == entries[a]->exProp("filePath").getStringValue())
continue;
// Write entry to file
if (!entries[a]->exportFile(path))
{
LOG_MESSAGE(1, "Unable to save entry %s: %s", entries[a]->getName(), Global::error);
}
else
files_written.push_back(path);
// Set unmodified
entries[a]->setState(0);
entries[a]->exProp("filePath") = path;
file_modification_times[entries[a]] = wxFileModificationTime(path);
}
removed_files.clear();
setModified(false);
return true;
}
// -----------------------------------------------------------------------------
// Reads disk format data from a MemChunk.
// Returns true if successful, false otherwise
// -----------------------------------------------------------------------------
bool DiskArchive::open(MemChunk& mc)
{
size_t mcsize = mc.getSize();
// Check given data is valid
if (mcsize < 80)
return false;
// Read disk header
uint32_t num_entries;
mc.seek(0, SEEK_SET);
mc.read(&num_entries, 4);
num_entries = wxUINT32_SWAP_ON_LE(num_entries);
size_t start_offset = (72 * num_entries) + 8;
if (mcsize < start_offset)
return false;
// Stop announcements (don't want to be announcing modification due to entries being added etc)
setMuted(true);
// Read the directory
UI::setSplashProgressMessage("Reading disk archive data");
for (uint32_t d = 0; d < num_entries; d++)
{
// Update splash window progress
UI::setSplashProgress(((float)d / (float)num_entries));
// Read entry info
DiskEntry dent;
mc.read(&dent, 72);
// Byteswap if needed
dent.length = wxUINT32_SWAP_ON_LE(dent.length);
dent.offset = wxUINT32_SWAP_ON_LE(dent.offset);
// Increase offset to make it relative to start of archive
dent.offset += start_offset;
// Check offset+size
if (dent.offset + dent.length > mcsize)
{
LOG_MESSAGE(1, "DiskArchive::open: Disk archive is invalid or corrupt (entry goes past end of file)");
Global::error = "Archive is invalid and/or corrupt";
setMuted(false);
return false;
}
// Parse name
string name = wxString::FromAscii(dent.name, 64);
name.Replace("\\", "/");
name.Replace("GAME:/", "");
wxFileName fn(name);
// Create directory if needed
ArchiveTreeNode* dir = createDir(fn.GetPath(true, wxPATH_UNIX));
// Create entry
ArchiveEntry* entry = new ArchiveEntry(fn.GetFullName(), dent.length);
entry->exProp("Offset") = (int)dent.offset;
entry->setLoaded(false);
entry->setState(0);
// Add to directory
dir->addEntry(entry);
}
// Detect all entry types
MemChunk edata;
vector<ArchiveEntry*> all_entries;
getEntryTreeAsList(all_entries);
UI::setSplashProgressMessage("Detecting entry types");
for (size_t a = 0; a < all_entries.size(); a++)
{
// Update splash window progress
UI::setSplashProgress((((float)a / (float)num_entries)));
// Get entry
ArchiveEntry* entry = all_entries[a];
// Read entry data if it isn't zero-sized
if (entry->getSize() > 0)
{
// Read the entry data
mc.exportMemChunk(edata, (int)entry->exProp("Offset"), entry->getSize());
entry->importMemChunk(edata);
}
// Detect entry type
EntryType::detectEntryType(entry);
// Unload entry data if needed
if (!archive_load_data)
entry->unloadData();
// Set entry to unchanged
entry->setState(0);
}
// Setup variables
setMuted(false);
setModified(false);
announce("opened");
UI::setSplashProgressMessage("");
return true;
}
// -----------------------------------------------------------------------------
// Writes the disk archive to a MemChunk.
// Returns true if successful, false otherwise
// -----------------------------------------------------------------------------
bool DiskArchive::write(MemChunk& mc, bool update)
{
// Clear current data
mc.clear();
// Get archive tree as a list
vector<ArchiveEntry*> entries;
getEntryTreeAsList(entries);
// Process entry list
uint32_t num_entries = 0;
uint32_t size_entries = 0;
for (unsigned a = 0; a < entries.size(); a++)
{
// Ignore folder entries
if (entries[a]->getType() == EntryType::folderType())
continue;
// Increment directory offset and size
size_entries += entries[a]->getSize();
++num_entries;
}
// Init data size
uint32_t start_offset = 8 + (num_entries * 72);
uint32_t offset = start_offset;
mc.reSize(size_entries + start_offset, false);
// Write header
num_entries = wxUINT32_SWAP_ON_LE(num_entries);
mc.seek(0, SEEK_SET);
mc.write(&num_entries, 4);
// Write directory
for (unsigned a = 0; a < entries.size(); a++)
{
// Skip folders
if (entries[a]->getType() == EntryType::folderType())
continue;
// Update entry
if (update)
{
entries[a]->setState(0);
entries[a]->exProp("Offset") = (int)offset;
}
// Check entry name
string name = entries[a]->getPath(true);
name.Replace("/", "\\");
// The leading "GAME:\" part of the name means there is only 58 usable characters for path
if (name.Len() > 58)
{
LOG_MESSAGE(
1, "Warning: Entry %s path is too long (> 58 characters), putting it in the root directory", name);
wxFileName fn(name);
name = fn.GetFullName();
if (name.Len() > 57)
name.Truncate(57);
// Add leading "\"
name = "\\" + name;
}
name = "GAME:" + name;
DiskEntry dent;
// Write entry name
// The names field are padded with FD for doom.disk, FE for doom2.disk. No idea whether
// a non-null padding is actually required, though. It probably should work with anything.
memset(dent.name, 0xFE, 64);
memcpy(dent.name, CHR(name), name.Length());
dent.name[name.Length()] = 0;
// Write entry offset
dent.offset = wxUINT32_SWAP_ON_LE(offset - start_offset);
// Write entry size
dent.length = wxUINT32_SWAP_ON_LE(entries[a]->getSize());
// Actually write stuff
mc.write(&dent, 72);
// Increment/update offset
offset += wxUINT32_SWAP_ON_LE(dent.length);
}
// Finish writing header
size_entries = wxUINT32_SWAP_ON_LE(size_entries);
mc.write(&size_entries, 4);
// Write entry data
for (unsigned a = 0; a < entries.size(); a++)
{
// Skip folders
if (entries[a]->getType() == EntryType::folderType())
continue;
// Write data
mc.write(entries[a]->getData(), entries[a]->getSize());
}
return true;
}