fs.cpp

Go to the documentation of this file.

/*
 * The ManaPlus Client
 * Copyright (C) 2013-2019 The ManaPlus Developers
 * Copyright (C) 2019-2021 Andrei Karas
 *
 * This file is part of The ManaPlus Client.
 *
 * 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
 * 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, see <http://www.gnu.org/licenses/>.
 */
 
#include "fs/virtfs/fs.h"
 
#include "fs/files.h"
#include "fs/paths.h"
 
#include "fs/virtfs/direntry.h"
#include "fs/virtfs/file.h"
#include "fs/virtfs/fsdir.h"
#include "fs/virtfs/fsfuncs.h"
#include "fs/virtfs/fszip.h"
#include "fs/virtfs/list.h"
#include "fs/virtfs/zipentry.h"
#include "fs/virtfs/zipreader.h"
 
#include "utils/checkutils.h"
#include "utils/foreach.h"
#include "utils/stdmove.h"
#include "utils/stringutils.h"
 
#include "debug.h"
 
const char *dirSeparator = nullptr;
 
#ifdef UNITTESTS
#define reportNonTests(a, b) logger->log(a, b);
#else // UNITTESTS
#define reportNonTests(a, b) reportAlways(a, b)
#endif // UNITTESTS
 
namespace VirtFs
{
 namespace
 {
 STD_VECTOR<FsEntry*> mEntries;
 } // namespace
 
 void init(const std::string &restrict name)
 {
 updateDirSeparator();
 FsDir::init(name);
 FsZip::init();
 }
 
 void updateDirSeparator()
 {
#ifdef WIN32
 dirSeparator = "\\";
#else // WIN32
 dirSeparator = "/";
#endif // WIN32
 }
 
 const char *getDirSeparator()
 {
 return dirSeparator;
 }
 
 const char *getBaseDir()
 {
 return FsDir::getBaseDir();
 }
 
 const char *getUserDir()
 {
 return FsDir::getUserDir();
 }
 
 STD_VECTOR<FsEntry*> &getEntries()
 {
 return mEntries;
 }
 
 FsEntry *searchByRootInternal(const std::string &restrict root,
 const std::string &restrict subDir)
 {
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 const FsEntry *const entry = *it;
 if (entry->root == root &&
 entry->subDir == subDir)
 {
 return *it;
 }
 }
 return nullptr;
 }
 
 FsEntry *searchByTypeInternal(const std::string &restrict root,
 const FsEntryTypeT type)
 {
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 const FsEntry *const entry = *it;
 if (entry->root == root &&
 entry->type == type)
 {
 return *it;
 }
 }
 return nullptr;
 }
 
 bool exists(std::string name)
 {
 prepareFsPath(name);
 if (checkPath(name) == false)
 {
 reportAlways("FsDir::exists invalid path: %s",
 name.c_str())
 return false;
 }
 
 std::string rootDir = name;
 if (findLast(rootDir, std::string(dirSeparator)) == false)
 rootDir += dirSeparator;
 
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 if (entry->funcs->exists(entry, name, rootDir) == true)
 return true;
 }
 return false;
 }
 
 List *enumerateFiles(std::string dirName)
 {
 List *const list = new List;
 prepareFsPath(dirName);
 if (checkPath(dirName) == false)
 {
 reportAlways("VirtFs::enumerateFiles invalid path: %s",
 dirName.c_str())
 return list;
 }
 
 std::string rootDir = STD_MOVE(dirName);
 if (findLast(rootDir, std::string(dirSeparator)) == false)
 rootDir += dirSeparator;
 StringVect &names = list->names;
 
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 entry->funcs->enumerate(entry, rootDir, names);
 }
 
 return list;
 }
 
 void getFiles(std::string dirName,
 StringVect &list)
 {
 prepareFsPath(dirName);
 if (checkPath(dirName) == false)
 {
 reportAlways("VirtFs::enumerateFiles invalid path: %s",
 dirName.c_str())
 return;
 }
 
 std::string rootDir = STD_MOVE(dirName);
 if (findLast(rootDir, std::string(dirSeparator)) == false)
 rootDir += dirSeparator;
 
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 entry->funcs->getFiles(entry, rootDir, list);
 }
 }
 
 void getFilesWithDir(std::string dirName,
 StringVect &list)
 {
 prepareFsPath(dirName);
 if (checkPath(dirName) == false)
 {
 reportAlways("VirtFs::enumerateFiles invalid path: %s",
 dirName.c_str())
 return;
 }
 
 std::string rootDir = STD_MOVE(dirName);
 if (findLast(rootDir, std::string(dirSeparator)) == false)
 rootDir += dirSeparator;
 
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 entry->funcs->getFilesWithDir(entry, rootDir, list);
 }
 }
 
 
 void getDirs(std::string dirName,
 StringVect &list)
 {
 prepareFsPath(dirName);
 if (checkPath(dirName) == false)
 {
 reportAlways("VirtFs::enumerateFiles invalid path: %s",
 dirName.c_str())
 return;
 }
 
 std::string rootDir = STD_MOVE(dirName);
 if (findLast(rootDir, std::string(dirSeparator)) == false)
 rootDir += dirSeparator;
 
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 entry->funcs->getDirs(entry, rootDir, list);
 }
 }
 
 bool isDirectory(std::string name)
 {
 prepareFsPath(name);
 if (checkPath(name) == false)
 {
 reportAlways("VirtFs::isDirectory invalid path: %s",
 name.c_str())
 return false;
 }
 std::string dirName = STD_MOVE(name);
 if (findLast(dirName, std::string(dirSeparator)) == false)
 dirName += dirSeparator;
 
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 bool isDirFlag(false);
 if (entry->funcs->isDirectory(entry, dirName, isDirFlag) == true)
 {
 return isDirFlag;
 }
 }
 return false;
 }
 
 bool isSymbolicLink(const std::string &restrict name)
 {
 return FsDir::isSymbolicLink(name);
 }
 
 void freeList(List *restrict const handle)
 {
 delete handle;
 }
 
 File *openRead(std::string filename)
 {
 prepareFsPath(filename);
 if (checkPath(filename) == false)
 {
 reportAlways("VirtFs::openRead invalid path: %s",
 filename.c_str())
 return nullptr;
 }
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 File *const file = entry->funcs->openRead(entry, filename);
 if (file != nullptr)
 return file;
 }
 return nullptr;
 }
 
 File *openWrite(std::string filename)
 {
 prepareFsPath(filename);
 if (checkPath(filename) == false)
 {
 reportAlways("VirtFs::openWrite invalid path: %s",
 filename.c_str())
 return nullptr;
 }
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 File *const file = entry->funcs->openWrite(entry, filename);
 if (file != nullptr)
 return file;
 }
 return nullptr;
 }
 
 File *openAppend(std::string filename)
 {
 prepareFsPath(filename);
 if (checkPath(filename) == false)
 {
 reportAlways("VirtFs::openAppend invalid path: %s",
 filename.c_str())
 return nullptr;
 }
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 File *const file = entry->funcs->openAppend(entry, filename);
 if (file != nullptr)
 return file;
 }
 return nullptr;
 }
 
 bool setWriteDir(const std::string &restrict newDir)
 {
 return FsDir::setWriteDir(newDir);
 }
 
 void addEntry(FsEntry *const entry,
 const Append append)
 {
 if (append == Append_true)
 mEntries.push_back(entry);
 else
 mEntries.insert(mEntries.begin(), entry);
 }
 
 bool mountDirInternal(const std::string &restrict newDir,
 std::string subDir,
 const Append append)
 {
 if (newDir.find(".zip") != std::string::npos)
 {
 reportAlways("Called FsDir::mount with zip archive")
 return false;
 }
 std::string rootDir = newDir;
 if (findLast(rootDir, std::string(dirSeparator)) == false)
 rootDir += dirSeparator;
 if (subDir == dirSeparator)
 {
 subDir.clear();
 }
 else if (!subDir.empty() &&
 findLast(subDir, std::string(dirSeparator)) == false)
 {
 subDir += dirSeparator;
 }
 const FsEntry *const entry = searchByRootInternal(rootDir, subDir);
 if (entry != nullptr)
 {
 reportAlways("VirtFs::mount already exists: %s",
 newDir.c_str())
 return false;
 }
 if (subDir.empty())
 {
 logger->log("Add virtual directory: " + newDir);
 }
 else
 {
 logger->log("Add virtual directory: %s with dir %s",
 newDir.c_str(),
 subDir.c_str());
 }
 
 addEntry(new DirEntry(newDir,
 rootDir,
 subDir,
 rootDir + subDir,
 FsDir::getFuncs()),
 append);
 return true;
 }
 
 bool mountDir(std::string newDir,
 const Append append)
 {
 prepareFsPath(newDir);
 if (Files::existsLocal(newDir) == false)
 {
 reportNonTests("VirtFs::mount directory not exists: %s",
 newDir.c_str())
 return false;
 }
 return mountDirInternal(newDir, dirSeparator, append);
 }
 
 bool mountDir2(std::string newDir,
 std::string subDir,
 const Append append)
 {
 prepareFsPath(newDir);
 prepareFsPath(subDir);
 if (Files::existsLocal(newDir) == false)
 {
 reportNonTests("VirtFs::mount directory not exists: %s",
 newDir.c_str())
 return false;
 }
 return mountDirInternal(newDir, subDir, append);
 }
 
 bool mountDirSilent(std::string newDir,
 const Append append)
 {
 prepareFsPath(newDir);
 if (Files::existsLocal(newDir) == false)
 {
 logger->log("VirtFs::mount directory not exists: %s",
 newDir.c_str());
 return false;
 }
 return mountDirInternal(newDir, std::string(), append);
 }
 
 bool mountDirSilent2(std::string newDir,
 std::string subDir,
 const Append append)
 {
 prepareFsPath(newDir);
 prepareFsPath(subDir);
 if (Files::existsLocal(newDir) == false)
 {
 logger->log("VirtFs::mount directory not exists: %s",
 newDir.c_str());
 return false;
 }
 return mountDirInternal(newDir, subDir, append);
 }
 
#ifdef UNITTESTS
 bool mountDirSilentTest(std::string newDir,
 const Append append)
 {
 prepareFsPath(newDir);
 if (Files::existsLocal(newDir) == false)
 {
 logger->log("VirtFs::mount directory not exists: %s",
 newDir.c_str());
 }
 return mountDirInternal(newDir, std::string(), append);
 }
 
 bool mountDirSilentTest2(std::string newDir,
 std::string subDir,
 const Append append)
 {
 prepareFsPath(newDir);
 prepareFsPath(subDir);
 if (Files::existsLocal(newDir) == false)
 {
 logger->log("VirtFs::mount directory not exists: %s",
 newDir.c_str());
 }
 return mountDirInternal(newDir, subDir, append);
 }
#endif // UNITTESTS
 
 bool unmountDirInternal(std::string oldDir,
 std::string subDir)
 {
 if (findLast(oldDir, std::string(dirSeparator)) == false)
 oldDir += dirSeparator;
 if (subDir == dirSeparator)
 {
 subDir.clear();
 }
 else if (!subDir.empty() &&
 findLast(subDir, std::string(dirSeparator)) == false)
 {
 subDir += dirSeparator;
 }
 FOR_EACH (STD_VECTOR<FsEntry*>::iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 if (entry->root == oldDir &&
 entry->type == FsEntryType::Dir &&
 entry->subDir == subDir)
 {
 DirEntry *const dirEntry = static_cast<DirEntry*>(
 entry);
 if (subDir.empty())
 {
 logger->log("Remove virtual directory: " + oldDir);
 }
 else
 {
 logger->log("Remove virtual directory: %s with dir %s",
 oldDir.c_str(),
 subDir.c_str());
 }
 mEntries.erase(it);
 delete dirEntry;
 return true;
 }
 }
 return false;
 }
 
 bool unmountDir(std::string oldDir)
 {
 prepareFsPath(oldDir);
 if (oldDir.find(".zip") != std::string::npos)
 {
 reportAlways("Called unmount with zip archive")
 return false;
 }
 if (unmountDirInternal(oldDir, std::string()) == false)
 {
 reportAlways("VirtFs::unmountDir not exists: %s",
 oldDir.c_str())
 return false;
 }
 return true;
 }
 
 bool unmountDir2(std::string oldDir,
 std::string subDir)
 {
 prepareFsPath(oldDir);
 if (oldDir.find(".zip") != std::string::npos)
 {
 reportAlways("Called unmount with zip archive")
 return false;
 }
 prepareFsPath(subDir);
 if (unmountDirInternal(oldDir, subDir) == false)
 {
 reportAlways("VirtFs::unmountDir not exists: %s",
 oldDir.c_str())
 return false;
 }
 return true;
 }
 
 bool unmountDirSilent(std::string oldDir)
 {
 prepareFsPath(oldDir);
 if (oldDir.find(".zip") != std::string::npos)
 {
 reportAlways("Called unmount with zip archive")
 return false;
 }
 if (unmountDirInternal(oldDir, std::string()) == false)
 {
 logger->log("VirtFs::unmountDir not exists: %s",
 oldDir.c_str());
 return false;
 }
 return true;
 }
 
 bool unmountDirSilent2(std::string oldDir,
 std::string subDir)
 {
 prepareFsPath(oldDir);
 if (oldDir.find(".zip") != std::string::npos)
 {
 reportAlways("Called unmount with zip archive")
 return false;
 }
 prepareFsPath(subDir);
 if (unmountDirInternal(oldDir, subDir) == false)
 {
 logger->log("VirtFs::unmountDir not exists: %s",
 oldDir.c_str());
 return false;
 }
 return true;
 }
 
 bool mountZip(std::string newDir,
 const Append append)
 {
 prepareFsPath(newDir);
 if (Files::existsLocal(newDir) == false)
 {
 reportNonTests("FsZip::mount file not exists: %s",
 newDir.c_str())
 return false;
 }
 if (findLast(newDir, ".zip") == false)
 {
 reportAlways("Called VirtFs::mount without "
 "zip archive")
 return false;
 }
 if (searchByRootInternal(newDir, std::string()) != nullptr)
 {
 reportAlways("FsZip::mount already exists: %s",
 newDir.c_str())
 return false;
 }
 ZipEntry *const entry = new ZipEntry(newDir,
 std::string(),
 FsZip::getFuncs());
 if (ZipReader::readArchiveInfo(entry) == false)
 {
 delete entry;
 return false;
 }
 
 logger->log("Add virtual zip: " + newDir);
 addEntry(entry, append);
 return true;
 }
 
 bool mountZip2(std::string newDir,
 std::string subDir,
 const Append append)
 {
 prepareFsPath(newDir);
 if (Files::existsLocal(newDir) == false)
 {
 reportNonTests("FsZip::mount file not exists: %s",
 newDir.c_str())
 return false;
 }
 if (findLast(newDir, ".zip") == false)
 {
 reportAlways("Called VirtFs::mount without "
 "zip archive")
 return false;
 }
 prepareFsPath(subDir);
 if (subDir == dirSeparator)
 {
 subDir.clear();
 }
 else if (!subDir.empty() &&
 findLast(subDir, std::string(dirSeparator)) == false)
 {
 subDir += dirSeparator;
 }
 if (searchByRootInternal(newDir, subDir) != nullptr)
 {
 reportAlways("FsZip::mount already exists: %s",
 newDir.c_str())
 return false;
 }
 ZipEntry *const entry = new ZipEntry(newDir,
 subDir,
 FsZip::getFuncs());
 if (ZipReader::readArchiveInfo(entry) == false)
 {
 delete entry;
 return false;
 }
 
 logger->log("Add virtual zip: %s with dir %s",
 newDir.c_str(),
 subDir.c_str());
 addEntry(entry, append);
 return true;
 }
 
 bool unmountZip(std::string oldDir)
 {
 prepareFsPath(oldDir);
 if (findLast(oldDir, ".zip") == false)
 {
 reportAlways("Called unmount without zip archive")
 return false;
 }
 FOR_EACH (STD_VECTOR<FsEntry*>::iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 if (entry->root == oldDir &&
 entry->type == FsEntryType::Zip &&
 entry->subDir.empty())
 {
 ZipEntry *const zipEntry = static_cast<ZipEntry*>(
 entry);
 logger->log("Remove virtual zip: " + oldDir);
 mEntries.erase(it);
 delete zipEntry;
 return true;
 }
 }
 
 reportAlways("VirtFs::unmountZip not exists: %s",
 oldDir.c_str())
 return false;
 }
 
 bool unmountZip2(std::string oldDir,
 std::string subDir)
 {
 prepareFsPath(oldDir);
 if (findLast(oldDir, ".zip") == false)
 {
 reportAlways("Called unmount without zip archive")
 return false;
 }
 prepareFsPath(subDir);
 if (subDir == dirSeparator)
 {
 subDir.clear();
 }
 else if (!subDir.empty() &&
 findLast(subDir, std::string(dirSeparator)) == false)
 {
 subDir += dirSeparator;
 }
 FOR_EACH (STD_VECTOR<FsEntry*>::iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 if (entry->root == oldDir &&
 entry->type == FsEntryType::Zip &&
 entry->subDir == subDir)
 {
 ZipEntry *const zipEntry = static_cast<ZipEntry*>(
 entry);
 logger->log("Remove virtual zip: %s with dir %s",
 oldDir.c_str(),
 subDir.c_str());
 mEntries.erase(it);
 delete zipEntry;
 return true;
 }
 }
 
 reportAlways("VirtFs::unmountZip not exists: %s",
 oldDir.c_str())
 return false;
 }
 
 std::string getRealDir(std::string fileName)
 {
 prepareFsPath(fileName);
 if (checkPath(fileName) == false)
 {
 reportAlways("FsDir::getRealDir invalid path: %s",
 fileName.c_str())
 return std::string();
 }
 
 std::string rootDir = fileName;
 if (findLast(rootDir, std::string(dirSeparator)) == false)
 rootDir += dirSeparator;
 
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 std::string realDir;
 if (entry->funcs->getRealDir(entry,
 fileName,
 rootDir,
 realDir) == true)
 {
 return realDir;
 }
 }
 return std::string();
 }
 
 bool mkdir(const std::string &restrict dirname)
 {
 return FsDir::mkdir(dirname);
 }
 
 bool remove(const std::string &restrict filename)
 {
 return FsDir::remove(filename);
 }
 
 bool deinit()
 {
 FsDir::deinit();
 FsZip::deinit();
 FOR_EACH (STD_VECTOR<FsEntry*>::iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 if (entry->type == FsEntryType::Dir)
 delete static_cast<DirEntry*>(entry);
 else if (entry->type == FsEntryType::Zip)
 delete static_cast<ZipEntry*>(entry);
 else
 delete entry;
 }
 mEntries.clear();
 return true;
 }
 
 void permitLinks(const bool val)
 {
 FsDir::permitLinks(val);
 }
 
 int close(File *restrict const file)
 {
 if (file == nullptr)
 return 0;
 return file->funcs->close(file);
 }
 
 int64_t read(File *restrict const file,
 void *restrict const buffer,
 const uint32_t objSize,
 const uint32_t objCount)
 {
 return file->funcs->read(file,
 buffer,
 objSize,
 objCount);
 }
 
 int64_t write(File *restrict const file,
 const void *restrict const buffer,
 const uint32_t objSize,
 const uint32_t objCount)
 {
 return file->funcs->write(file,
 buffer,
 objSize,
 objCount);
 }
 
 int64_t fileLength(File *restrict const file)
 {
 return file->funcs->fileLength(file);
 }
 
 int64_t tell(File *restrict const file)
 {
 return file->funcs->tell(file);
 }
 
 int seek(File *restrict const file,
 const uint64_t pos)
 {
 return file->funcs->seek(file,
 pos);
 }
 
 int eof(File *restrict const file)
 {
 return file->funcs->eof(file);
 }
 
 const char *loadFile(std::string filename,
 int &restrict fileSize)
 {
 prepareFsPath(filename);
 if (checkPath(filename) == false)
 {
 reportAlways("VirtFs::loadFile invalid path: %s",
 filename.c_str())
 return nullptr;
 }
 FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
 {
 FsEntry *const entry = *it;
 const char *const buf = entry->funcs->loadFile(entry,
 filename,
 fileSize);
 if (buf != nullptr)
 return buf;
 }
 return nullptr;
 }
 
} // namespace VirtFs