Rename virtfs into fs.

1 files changed, 654 insertions, 0 deletions

diff --git a/src/fs/virtfs/fs.cpp b/src/fs/virtfs/fs.cpp
new file mode 100644
index 000000000..e96ad23b4
--- /dev/null
+++ b/src/fs/virtfs/fs.cpp
@@ -0,0 +1,654 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2013-2017  The ManaPlus Developers
+ *
+ *  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/virtfsdir.h"
+#include "fs/virtfs/fsfuncs.h"
+#include "fs/virtfs/virtfszip.h"
+#include "fs/virtfs/virtlist.h"
+#include "fs/virtfs/virtzipentry.h"
+#include "fs/virtfs/zipreader.h"
+
+#include "utils/checkutils.h"
+#include "utils/stringutils.h"
+
+#include "debug.h"
+
+const char *dirSeparator = nullptr;
+
+#ifdef UNITTESTS
+#define reportNonTests logger->log
+#else  // UNITTESTS
+#define reportNonTests reportAlways
+#endif  // UNITTESTS
+
+namespace VirtFs
+{
+    namespace
+    {
+        std::vector<FsEntry*> mEntries;
+    }  // namespace
+
+    void init(const std::string &restrict name)
+    {
+        updateDirSeparator();
+        VirtFsDir::init(name);
+        VirtFsZip::init();
+    }
+
+    void updateDirSeparator()
+    {
+#ifdef WIN32
+        dirSeparator = "\\";
+#else  // WIN32
+        dirSeparator = "/";
+#endif  // WIN32
+    }
+
+    const char *getDirSeparator()
+    {
+        return dirSeparator;
+    }
+
+    const char *getBaseDir()
+    {
+        return VirtFsDir::getBaseDir();
+    }
+
+    const char *getUserDir()
+    {
+        return VirtFsDir::getUserDir();
+    }
+
+    std::vector<FsEntry*> &getEntries()
+    {
+        return mEntries;
+    }
+
+    FsEntry *searchEntryByRootInternal(const std::string &restrict root)
+    {
+        FOR_EACH (std::vector<FsEntry*>::const_iterator, it, mEntries)
+        {
+            if ((*it)->root == root)
+                return *it;
+        }
+        return nullptr;
+    }
+
+    FsEntry *searchEntryInternal(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("VirtFsDir::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;
+    }
+
+    VirtList *enumerateFiles(std::string dirName)
+    {
+        VirtList *const list = new VirtList;
+        prepareFsPath(dirName);
+        if (checkPath(dirName) == false)
+        {
+            reportAlways("VirtFs::enumerateFiles invalid path: %s",
+                dirName.c_str());
+            return list;
+        }
+
+        std::string rootDir = 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 = 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 = 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 = 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 = 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 VirtFsDir::isSymbolicLink(name);
+    }
+
+    void freeList(VirtList *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 VirtFsDir::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,
+                          const Append append)
+    {
+        if (newDir.find(".zip") != std::string::npos)
+        {
+            reportAlways("Called VirtFsDir::addToSearchPath with zip archive");
+            return false;
+        }
+        std::string rootDir = newDir;
+        if (findLast(rootDir, std::string(dirSeparator)) == false)
+            rootDir += dirSeparator;
+        const FsEntry *const entry = searchEntryByRootInternal(rootDir);
+        if (entry != nullptr)
+        {
+            reportAlways("VirtFs::addToSearchPath already exists: %s",
+                newDir.c_str());
+            return false;
+        }
+        logger->log("Add virtual directory: " + newDir);
+        addEntry(new DirEntry(newDir, rootDir, VirtFsDir::getFuncs()),
+            append);
+        return true;
+    }
+
+    bool mountDir(std::string newDir,
+                  const Append append)
+    {
+        prepareFsPath(newDir);
+        if (Files::existsLocal(newDir) == false)
+        {
+            reportNonTests("VirtFs::addToSearchPath directory not exists: %s",
+                newDir.c_str());
+            return false;
+        }
+        return mountDirInternal(newDir, append);
+    }
+
+    bool mountDirSilent(std::string newDir,
+                        const Append append)
+    {
+        prepareFsPath(newDir);
+        if (Files::existsLocal(newDir) == false)
+        {
+            logger->log("VirtFs::addToSearchPath directory not exists: %s",
+                newDir.c_str());
+            return false;
+        }
+        return mountDirInternal(newDir, append);
+    }
+
+#ifdef UNITTESTS
+    bool mountDirSilent2(std::string newDir,
+                         const Append append)
+    {
+        prepareFsPath(newDir);
+        if (Files::existsLocal(newDir) == false)
+        {
+            logger->log("VirtFs::addToSearchPath directory not exists: %s",
+                newDir.c_str());
+        }
+        return mountDirInternal(newDir, append);
+    }
+#endif  // UNITTESTS
+
+    bool unmountDirInternal(std::string oldDir)
+    {
+        if (findLast(oldDir, std::string(dirSeparator)) == false)
+            oldDir += dirSeparator;
+        FOR_EACH (std::vector<FsEntry*>::iterator, it, mEntries)
+        {
+            FsEntry *const entry = *it;
+            if (entry->root == oldDir &&
+                entry->type == FsEntryType::Dir)
+            {
+                DirEntry *const dirEntry = static_cast<DirEntry*>(
+                    entry);
+                    logger->log("Remove virtual directory: " + oldDir);
+                    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 removeFromSearchPath with zip archive");
+            return false;
+        }
+        if (unmountDirInternal(oldDir) == 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 removeFromSearchPath with zip archive");
+            return false;
+        }
+        if (unmountDirInternal(oldDir) == 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("VirtFsZip::addToSearchPath file not exists: %s",
+                newDir.c_str());
+            return false;
+        }
+        if (findLast(newDir, ".zip") == false)
+        {
+            reportAlways("Called VirtFs::addToSearchPath without "
+                "zip archive");
+            return false;
+        }
+        if (searchEntryByRootInternal(newDir) != nullptr)
+        {
+            reportAlways("VirtFsZip::addToSearchPath already exists: %s",
+                newDir.c_str());
+            return false;
+        }
+        VirtZipEntry *const entry = new VirtZipEntry(newDir,
+            VirtFsZip::getFuncs());
+        if (ZipReader::readArchiveInfo(entry) == false)
+        {
+            delete entry;
+            return false;
+        }
+
+        logger->log("Add virtual zip: " + newDir);
+        addEntry(entry, append);
+        return true;
+    }
+
+    bool unmountZip(std::string oldDir)
+    {
+        prepareFsPath(oldDir);
+        if (findLast(oldDir, ".zip") == false)
+        {
+            reportAlways("Called removeFromSearchPath 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)
+            {
+                VirtZipEntry *const zipEntry = static_cast<VirtZipEntry*>(
+                    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;
+    }
+
+    std::string getRealDir(std::string fileName)
+    {
+        prepareFsPath(fileName);
+        if (checkPath(fileName) == false)
+        {
+            reportAlways("VirtFsDir::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 VirtFsDir::mkdir(dirname);
+    }
+
+    bool remove(const std::string &restrict filename)
+    {
+        return VirtFsDir::remove(filename);
+    }
+
+    bool deinit()
+    {
+        VirtFsDir::deinit();
+        VirtFsZip::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<VirtZipEntry*>(entry);
+            else
+                delete entry;
+        }
+        mEntries.clear();
+        return true;
+    }
+
+    void permitLinks(const bool val)
+    {
+        VirtFsDir::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