Head

GCC Code Coverage Report

Directory:	src/		Exec	Total	Coverage
File:	src/dirs.cpp	Lines:	29	157	18.5 %
Date:	2021-03-17	Branches:	18	248	7.3 %


/*
 *  The ManaPlus Client
 *  Copyright (C) 2004-2009  The Mana World Development Team
 *  Copyright (C) 2009-2010  The Mana Developers
 *  Copyright (C) 2011-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 "dirs.h"

#include "client.h"
#include "configuration.h"
#include "logger.h"
#include "main.h"
#include "settings.h"

#include "fs/mkdir.h"
#include "fs/paths.h"

#include "fs/virtfs/fs.h"

#include "utils/base64.h"
#if defined(__native_client__) || (defined(ANDROID) && defined(USE_SDL2))
#include "fs/files.h"
#endif  // defined(__native_client__) || (defined(ANDROID) &&
        // defined(USE_SDL2))

#include "utils/cast.h"
#include "utils/gettext.h"

#ifdef ANDROID
#ifdef USE_SDL2
#include "main.h"

#include "render/graphics.h"
#endif  // USE_SDL2
#endif  // ANDROID

#ifdef __APPLE__
#include <CoreFoundation/CFBundle.h>
#endif  // __APPLE__

#ifdef WIN32
PRAGMA48(GCC diagnostic push)
PRAGMA48(GCC diagnostic ignored "-Wshadow")
#include <SDL_syswm.h>
PRAGMA48(GCC diagnostic pop)
#include "fs/specialfolder.h"
#undef ERROR
#endif  // WIN32

#include <sys/stat.h>

#include <sstream>

#include "debug.h"

#if defined __native_client__
#define _nacl_dir std::string("/persistent/manaplus")
#endif  // defined __native_client__

#ifdef ANDROID
#ifdef USE_SDL2

int loadingProgressCounter = 1;

static void updateProgress(int cnt)
{
    const int progress = cnt + loadingProgressCounter;
    const int h = mainGraphics->mHeight;
    mainGraphics->setColor(Color(255, 255, 255, 255));
    const int maxSize = mainGraphics->mWidth - 100;
    const int width = maxSize * progress / 50;
    mainGraphics->fillRectangle(Rect(50, h - 100, width, 50));
    mainGraphics->updateScreen();
}

void Dirs::setProgress()
{
    loadingProgressCounter++;
    updateProgress(loadingProgressCounter);
}

static void resetProgress()
{
    loadingProgressCounter = 0;
    updateProgress(loadingProgressCounter);
}

void extractAssets()
{
    if (!getenv("APPDIR"))
    {
        logger->log("error: APPDIR is not set!");
        return;
    }
    const std::string fileName = pathJoin(getenv("APPDIR"),
        "data.zip");
    logger->log("Extracting asset into: " + fileName);
    uint8_t *buf = new uint8_t[1000000];

    FILE *const file = fopen(fileName.c_str(), "w");
    for (int f = 0; f < 100; f ++)
    {
        std::string part = strprintf("manaplus-data.zip%u%u",
            CAST_U32(f / 10),
            CAST_U32(f % 10));
        logger->log("testing asset: " + part);
        SDL_RWops *const rw = SDL_RWFromFile(part.c_str(), "r");
        if (rw)
        {
            const int size = SDL_RWsize(rw);
            int size2 = SDL_RWread(rw, buf, 1, size);
            logger->log("asset size: %d", size2);
            fwrite(buf, 1, size2, file);
            SDL_RWclose(rw);
            Dirs::setProgress();
        }
        else
        {
            break;
        }
    }
    fclose(file);

    const std::string fileName2 = pathJoin(getenv("APPDIR"),
        "locale.zip");
    FILE *const file2 = fopen(fileName2.c_str(), "w");
    SDL_RWops *const rw = SDL_RWFromFile("manaplus-locale.zip", "r");
    if (rw)
    {
        const int size = SDL_RWsize(rw);
        int size2 = SDL_RWread(rw, buf, 1, size);
        fwrite(buf, 1, size2, file2);
        SDL_RWclose(rw);
        Dirs::setProgress();
    }
    fclose(file2);

    delete [] buf;
}

#endif  // USE_SDL2
#endif  // ANDROID

void Dirs::updateDataPath()
{
    if (settings.options.dataPath.empty()
        && !branding.getStringValue("dataPath").empty())
    {
        if (isRealPath(branding.getStringValue("dataPath")))
        {
            settings.options.dataPath = branding.getStringValue("dataPath");
        }
        else
        {
            settings.options.dataPath = pathJoin(branding.getDirectory(),
                branding.getStringValue("dataPath"));
        }
        settings.options.skipUpdate = true;
    }
}

void Dirs::extractDataDir()
{
#if defined(ANDROID) && defined(USE_SDL2)
    Files::setCopyCallBack(&updateProgress);
    resetProgress();
    extractAssets();

    const std::string zipName = pathJoin(getenv("APPDIR"), "data.zip");
    const std::string dirName = pathJoin(getenv("APPDIR"), "data");
    VirtFs::mountZip2(zipName,
        "data",
        Append_false);
    VirtFs::mountZip2(zipName,
        "data/perserver/default",
        Append_false);
    Files::extractLocale();
#endif  // defined(ANDROID) && defined(USE_SDL2)
}

void Dirs::mountDataDir()
{
    VirtFs::mountDirSilent(PKG_DATADIR "data/perserver/default",
        Append_false);
    VirtFs::mountDirSilent("data/perserver/default",
        Append_false);

#if defined __APPLE__
    CFBundleRef mainBundle = CFBundleGetMainBundle();
    CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
    char path[PATH_MAX];
    if (!CFURLGetFileSystemRepresentation(resourcesURL,
        TRUE,
        reinterpret_cast<uint8_t*>(path),
        PATH_MAX))
    {
        fprintf(stderr, "Can't find Resources directory\n");
    }
    CFRelease(resourcesURL);
    std::string path2 = pathJoin(path, "data");
    VirtFs::mountDir(pathJoin(path2, "perserver/default"), Append_false);
    VirtFs::mountDir(path2, Append_false);
// possible this need for support run client from dmg images.
//    mPackageDir = path;
#endif  // defined __APPLE__

    VirtFs::mountDirSilent(PKG_DATADIR "data", Append_false);
    setPackageDir(PKG_DATADIR "data");
    VirtFs::mountDirSilent("data", Append_false);

#ifdef ANDROID
#ifdef USE_SDL2
    if (getenv("APPDIR"))
    {
        const std::string appDir = getenv("APPDIR");
        VirtFs::mountDir(appDir + "/data", Append_false);
        VirtFs::mountDir(appDir + "/data/perserver/default",
            Append_false);
    }
#endif  // USE_SDL2
#endif  // ANDROID

#if defined __native_client__
    VirtFs::mountZip("/http/data.zip", Append_false);
    VirtFs::mountZip2("/http/data.zip",
        "perserver/default",
        Append_false);
#endif  // defined __native_client__

#ifndef WIN32
    // Add branding/data to VirtFS search path
    if (!settings.options.brandingPath.empty())
    {
        std::string path = settings.options.brandingPath;

        // Strip blah.manaplus from the path
        const int loc = CAST_S32(path.find_last_of('/'));

        if (loc > 0)
        {
            VirtFs::mountDir(path.substr(
                0, loc + 1).append("data"),
                Append_false);
        }
    }
#endif  // WIN32
}

void Dirs::initRootDir()
{
    settings.rootDir = VirtFs::getBaseDir();
    const std::string portableName = settings.rootDir + "portable.xml";
    struct stat statbuf;

    if (stat(portableName.c_str(), &statbuf) == 0 &&
        S_ISREG(statbuf.st_mode))
    {
        std::string dir;
        Configuration portable;
        portable.init(portableName,
            UseVirtFs_false,
            SkipError_false);

        if (settings.options.brandingPath.empty())
        {
            branding.init(portableName,
                UseVirtFs_false,
                SkipError_false);
            setBrandingDefaults(branding);
        }

        logger->log("Portable file: %s", portableName.c_str());

        if (settings.options.localDataDir.empty())
        {
            dir = portable.getValue("dataDir", "");
            if (!dir.empty())
            {
                settings.options.localDataDir = settings.rootDir + dir;
                logger->log("Portable data dir: %s",
                    settings.options.localDataDir.c_str());
            }
        }

        if (settings.options.configDir.empty())
        {
            dir = portable.getValue("configDir", "");
            if (!dir.empty())
            {
                settings.options.configDir = settings.rootDir + dir;
                logger->log("Portable config dir: %s",
                    settings.options.configDir.c_str());
            }
        }

        if (settings.options.screenshotDir.empty())
        {
            dir = portable.getValue("screenshotDir", "");
            if (!dir.empty())
            {
                settings.options.screenshotDir = settings.rootDir + dir;
                logger->log("Portable screenshot dir: %s",
                    settings.options.screenshotDir.c_str());
            }
        }
    }
}

/**
 * Initializes the home directory. On UNIX and FreeBSD, ~/.mana is used. On
 * Windows and other systems we use the current working directory.
 */
void Dirs::initHomeDir()
{
    initLocalDataDir();
    initTempDir();
    initConfigDir();
}

void Dirs::initLocalDataDir()
{
    settings.localDataDir = settings.options.localDataDir;

    if (settings.localDataDir.empty())
    {
#ifdef __APPLE__
        // Use Application Directory instead of .mana
        settings.localDataDir = pathJoin(VirtFs::getUserDir(),
            "Library/Application Support",
            branding.getValue("appName", "ManaPlus"));
#elif defined __HAIKU__
        settings.localDataDir = pathJoin(VirtFs::getUserDir(),
           "config/cache/Mana");
#elif defined WIN32
        settings.localDataDir = getSpecialFolderLocation(CSIDL_LOCAL_APPDATA);
        if (settings.localDataDir.empty())
            settings.localDataDir = VirtFs::getUserDir();
        settings.localDataDir = pathJoin(settings.localDataDir,
            "Mana");
#elif defined __ANDROID__
        settings.localDataDir = pathJoin(getSdStoragePath(),
            branding.getValue("appShort", "ManaPlus"),
            "local");
#elif defined __native_client__
        settings.localDataDir = pathJoin(_nacl_dir, "local");
#elif defined __SWITCH__
        settings.localDataDir = pathJoin(VirtFs::getUserDir(), "local");
#else  // __APPLE__

        settings.localDataDir = pathJoin(VirtFs::getUserDir(),
            ".local/share/mana");
#endif  // __APPLE__
    }

    if (mkdir_r(settings.localDataDir.c_str()) != 0)
    {
        // TRANSLATORS: directory creation error
        logger->error(strprintf(_("%s doesn't exist and can't be created! "
            "Exiting."), settings.localDataDir.c_str()));
    }
#ifdef USE_PROFILER
    Perfomance::init(pathJoin(settings.localDataDir, "profiler.log"));
#endif  // USE_PROFILER
}

void Dirs::initTempDir()
{
    settings.tempDir = pathJoin(settings.localDataDir, "temp");

    if (mkdir_r(settings.tempDir.c_str()) != 0)
    {
        // TRANSLATORS: directory creation error
        logger->error(strprintf(_("%s doesn't exist and can't be created! "
            "Exiting."), settings.tempDir.c_str()));
    }
//    ResourceManager::deleteFilesInDirectory(settings.tempDir);
}

void Dirs::initConfigDir()
{
    settings.configDir = settings.options.configDir;

    if (settings.configDir.empty())
    {
#ifdef __APPLE__
        settings.configDir = pathJoin(settings.localDataDir,
            branding.getValue("appShort", "mana"));
#elif defined __HAIKU__
        settings.configDir = pathJoin(VirtFs::getUserDir(),
           "config/settings/Mana",
           branding.getValue("appName", "ManaPlus"));
#elif defined WIN32
        settings.configDir = getSpecialFolderLocation(CSIDL_APPDATA);
        if (settings.configDir.empty())
        {
            settings.configDir = settings.localDataDir;
        }
        else
        {
            settings.configDir = pathJoin(settings.configDir,
                "mana",
                branding.getValue("appShort", "mana"));
        }
#elif defined __ANDROID__
        settings.configDir = pathJoin(getSdStoragePath(),
            branding.getValue("appShort", "ManaPlus"),
            "config");
#elif defined __native_client__
        settings.configDir = pathJoin(_nacl_dir, "config");
#elif defined __SWITCH__
        settings.configDir = pathJoin(VirtFs::getUserDir(), "config");
#else  // __APPLE__

        settings.configDir = pathJoin(VirtFs::getUserDir(),
            ".config/mana",
            branding.getValue("appShort", "mana"));
#endif  // __APPLE__

        logger->log("Generating config dir: " + settings.configDir);
    }

    if (mkdir_r(settings.configDir.c_str()) != 0)
    {
        // TRANSLATORS: directory creation error
        logger->error(strprintf(_("%s doesn't exist and can't be created! "
            "Exiting."), settings.configDir.c_str()));
    }
}

/**
 * Parse the update host and determine the updates directory
 * Then verify that the directory exists (creating if needed).
 */
void Dirs::initUpdatesDir()
{
    std::stringstream updates;

    // If updatesHost is currently empty, fill it from config file
    if (settings.updateHost.empty())
        settings.updateHost = config.getStringValue("updatehost");
    if (!checkPath(settings.updateHost))
        return;

    // Don't go out of range int he next check
    if (settings.updateHost.length() < 2)
    {
        if (settings.updatesDir.empty())
            settings.updatesDir = pathJoin("updates", settings.serverName);
        return;
    }

    const size_t sz = settings.updateHost.size();
    // Remove any trailing slash at the end of the update host
    if (settings.updateHost.at(sz - 1) == '/')
        settings.updateHost.resize(sz - 1);

    // Parse out any "http://" or "https://", and set the updates directory
    const size_t pos = settings.updateHost.find("://");
    if (pos != std::string::npos)
    {
        if (pos + 3 < settings.updateHost.length()
            && !settings.updateHost.empty())
        {
            updates << "updates/" << settings.updateHost.substr(pos + 3);
            settings.updatesDir = updates.str();
        }
        else
        {
            logger->log("Error: Invalid update host: %s",
                settings.updateHost.c_str());
            // TRANSLATORS: update server initialisation error
            errorMessage = strprintf(_("Invalid update host: %s."),
                settings.updateHost.c_str());
            client->setState(State::ERROR);
        }
    }
    else
    {
        logger->log1("Warning: no protocol was specified for the update host");
        updates << "updates/" << settings.updateHost;
        settings.updatesDir = updates.str();
    }

#ifdef WIN32
    if (settings.updatesDir.find(":") != std::string::npos)
        replaceAll(settings.updatesDir, ":", "_");
#endif  // WIN32

    const std::string updateDir("/" + settings.updatesDir);

    // Verify that the updates directory exists. Create if necessary.
    if (!VirtFs::isDirectory(updateDir))
    {
        if (!VirtFs::mkdir(updateDir))
        {
#if defined WIN32
            std::string newDir = pathJoin(settings.localDataDir,
                settings.updatesDir);
            if (!CreateDirectory(newDir.c_str(), nullptr) &&
                GetLastError() != ERROR_ALREADY_EXISTS)
            {
                logger->log("Error: %s can't be made, but doesn't exist!",
                            newDir.c_str());
                // TRANSLATORS: update server initialisation error
                errorMessage = _("Error creating updates directory!");
                client->setState(State::ERROR);
            }
#else  // defined WIN32

            logger->log("Error: %s/%s can't be made, but doesn't exist!",
                settings.localDataDir.c_str(),
                settings.updatesDir.c_str());
            // TRANSLATORS: update server initialisation error
            errorMessage = _("Error creating updates directory!");
            client->setState(State::ERROR);
#endif  // defined WIN32
        }
    }
    const std::string updateLocal = pathJoin(updateDir, "local");
    const std::string updateFix = pathJoin(updateDir, "fix");
    if (!VirtFs::isDirectory(updateLocal))
        VirtFs::mkdir(updateLocal);
    if (!VirtFs::isDirectory(updateFix))
        VirtFs::mkdir(updateFix);
}

void Dirs::initScreenshotDir()
{
    if (!settings.options.screenshotDir.empty())
    {
        settings.screenshotDir = settings.options.screenshotDir;
        if (mkdir_r(settings.screenshotDir.c_str()) != 0)
        {
            logger->log(strprintf(
                // TRANSLATORS: directory creation error
                _("Error: %s doesn't exist and can't be created! "
                "Exiting."), settings.screenshotDir.c_str()));
        }
    }
    else if (settings.screenshotDir.empty())
    {
#ifdef __native_client__
        settings.screenshotDir = pathJoin(_nacl_dir, "screenshots/");
#else  // __native_client__
        settings.screenshotDir = decodeBase64String(
            config.getStringValue("screenshotDirectory3"));
        if (settings.screenshotDir.empty())
        {
#ifdef __ANDROID__
            settings.screenshotDir = getSdStoragePath()
                + std::string("/images");

            if (mkdir_r(settings.screenshotDir.c_str()))
            {
                logger->log(strprintf(
                    // TRANSLATORS: directory creation error
                    _("Error: %s doesn't exist and can't be created! "
                    "Exiting."), settings.screenshotDir.c_str()));
            }
#else  // ANDROID
            settings.screenshotDir = getPicturesDir();
#endif  // ANDROID
            if (config.getBoolValue("useScreenshotDirectorySuffix"))
            {
                const std::string configScreenshotSuffix =
                    branding.getValue("screenshots", "ManaPlus");

                if (!configScreenshotSuffix.empty())
                {
                    settings.screenshotDir = pathJoin(settings.screenshotDir,
                        configScreenshotSuffix);
                }
            }
            config.setValue("screenshotDirectory3",
                encodeBase64String(settings.screenshotDir));
        }
#endif  // __native_client__
    }
    logger->log("screenshotDirectory: " + settings.screenshotDir);
}

void Dirs::initUsersDir()
{
    settings.usersDir = settings.serverConfigDir + "/users/";
    if (mkdir_r(settings.usersDir.c_str()) != 0)
    {
        // TRANSLATORS: directory creation error
        logger->error(strprintf(_("%s doesn't exist and can't be created!"),
            settings.usersDir.c_str()));
    }

    settings.npcsDir = settings.serverConfigDir + "/npcs/";
    if (mkdir_r(settings.npcsDir.c_str()) != 0)
    {
        // TRANSLATORS: directory creation error
        logger->error(strprintf(_("%s doesn't exist and can't be created!"),
            settings.npcsDir.c_str()));
    }

    settings.usersIdDir = settings.serverConfigDir + "/usersid/";
    if (mkdir_r(settings.usersIdDir.c_str()) != 0)
    {
        // TRANSLATORS: directory creation error
        logger->error(strprintf(_("%s doesn't exist and can't be created!"),
            settings.usersIdDir.c_str()));
    }
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* The ManaPlus Client
3			* Copyright (C) 2004-2009 The Mana World Development Team
4			* Copyright (C) 2009-2010 The Mana Developers
5			* Copyright (C) 2011-2019 The ManaPlus Developers
6			* Copyright (C) 2019-2021 Andrei Karas
7			*
8			* This file is part of The ManaPlus Client.
9			*
10			* This program is free software; you can redistribute it and/or modify
11			* it under the terms of the GNU General Public License as published by
12			* the Free Software Foundation; either version 2 of the License, or
13			* any later version.
14			*
15			* This program is distributed in the hope that it will be useful,
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			* GNU General Public License for more details.
19			*
20			* You should have received a copy of the GNU General Public License
21			* along with this program. If not, see <http://www.gnu.org/licenses/>.
22			*/
23
24			#include "dirs.h"
25
26			#include "client.h"
27			#include "configuration.h"
28			#include "logger.h"
29			#include "main.h"
30			#include "settings.h"
31
32			#include "fs/mkdir.h"
33			#include "fs/paths.h"
34
35			#include "fs/virtfs/fs.h"
36
37			#include "utils/base64.h"
38			#if defined(__native_client__) \|\| (defined(ANDROID) && defined(USE_SDL2))
39			#include "fs/files.h"
40			#endif // defined(__native_client__) \|\| (defined(ANDROID) &&
41			// defined(USE_SDL2))
42
43			#include "utils/cast.h"
44			#include "utils/gettext.h"
45
46			#ifdef ANDROID
47			#ifdef USE_SDL2
48			#include "main.h"
49
50			#include "render/graphics.h"
51			#endif // USE_SDL2
52			#endif // ANDROID
53
54			#ifdef __APPLE__
55			#include <CoreFoundation/CFBundle.h>
56			#endif // __APPLE__
57
58			#ifdef WIN32
59			PRAGMA48(GCC diagnostic push)
60			PRAGMA48(GCC diagnostic ignored "-Wshadow")
61			#include <SDL_syswm.h>
62			PRAGMA48(GCC diagnostic pop)
63			#include "fs/specialfolder.h"
64			#undef ERROR
65			#endif // WIN32
66
67			#include <sys/stat.h>
68
69			#include <sstream>
70
71			#include "debug.h"
72
73			#if defined __native_client__
74			#define _nacl_dir std::string("/persistent/manaplus")
75			#endif // defined __native_client__
76
77			#ifdef ANDROID
78			#ifdef USE_SDL2
79
80			int loadingProgressCounter = 1;
81
82			static void updateProgress(int cnt)
83			{
84			const int progress = cnt + loadingProgressCounter;
85			const int h = mainGraphics->mHeight;
86			mainGraphics->setColor(Color(255, 255, 255, 255));
87			const int maxSize = mainGraphics->mWidth - 100;
88			const int width = maxSize * progress / 50;
89			mainGraphics->fillRectangle(Rect(50, h - 100, width, 50));
90			mainGraphics->updateScreen();
91			}
92
93			void Dirs::setProgress()
94			{
95			loadingProgressCounter++;
96			updateProgress(loadingProgressCounter);
97			}
98
99			static void resetProgress()
100			{
101			loadingProgressCounter = 0;
102			updateProgress(loadingProgressCounter);
103			}
104
105			void extractAssets()
106			{
107			if (!getenv("APPDIR"))
108			{
109			logger->log("error: APPDIR is not set!");
110			return;
111			}
112			const std::string fileName = pathJoin(getenv("APPDIR"),
113			"data.zip");
114			logger->log("Extracting asset into: " + fileName);
115			uint8_t *buf = new uint8_t[1000000];
116
117			FILE *const file = fopen(fileName.c_str(), "w");
118			for (int f = 0; f < 100; f ++)
119			{
120			std::string part = strprintf("manaplus-data.zip%u%u",
121			CAST_U32(f / 10),
122			CAST_U32(f % 10));
123			logger->log("testing asset: " + part);
124			SDL_RWops *const rw = SDL_RWFromFile(part.c_str(), "r");
125			if (rw)
126			{
127			const int size = SDL_RWsize(rw);
128			int size2 = SDL_RWread(rw, buf, 1, size);
129			logger->log("asset size: %d", size2);
130			fwrite(buf, 1, size2, file);
131			SDL_RWclose(rw);
132			Dirs::setProgress();
133			}
134			else
135			{
136			break;
137			}
138			}
139			fclose(file);
140
141			const std::string fileName2 = pathJoin(getenv("APPDIR"),
142			"locale.zip");
143			FILE *const file2 = fopen(fileName2.c_str(), "w");
144			SDL_RWops *const rw = SDL_RWFromFile("manaplus-locale.zip", "r");
145			if (rw)
146			{
147			const int size = SDL_RWsize(rw);
148			int size2 = SDL_RWread(rw, buf, 1, size);
149			fwrite(buf, 1, size2, file2);
150			SDL_RWclose(rw);
151			Dirs::setProgress();
152			}
153			fclose(file2);
154
155			delete [] buf;
156			}
157
158			#endif // USE_SDL2
159			#endif // ANDROID
160
161			void Dirs::updateDataPath()
162			{
163			if (settings.options.dataPath.empty()
164			&& !branding.getStringValue("dataPath").empty())
165			{
166			if (isRealPath(branding.getStringValue("dataPath")))
167			{
168			settings.options.dataPath = branding.getStringValue("dataPath");
169			}
170			else
171			{
172			settings.options.dataPath = pathJoin(branding.getDirectory(),
173			branding.getStringValue("dataPath"));
174			}
175			settings.options.skipUpdate = true;
176			}
177			}
178
179			void Dirs::extractDataDir()
180			{
181			#if defined(ANDROID) && defined(USE_SDL2)
182			Files::setCopyCallBack(&updateProgress);
183			resetProgress();
184			extractAssets();
185
186			const std::string zipName = pathJoin(getenv("APPDIR"), "data.zip");
187			const std::string dirName = pathJoin(getenv("APPDIR"), "data");
188			VirtFs::mountZip2(zipName,
189			"data",
190			Append_false);
191			VirtFs::mountZip2(zipName,
192			"data/perserver/default",
193			Append_false);
194			Files::extractLocale();
195			#endif // defined(ANDROID) && defined(USE_SDL2)
196			}
197
198			void Dirs::mountDataDir()
199			{
200			VirtFs::mountDirSilent(PKG_DATADIR "data/perserver/default",
201			Append_false);
202			VirtFs::mountDirSilent("data/perserver/default",
203			Append_false);
204
205			#if defined __APPLE__
206			CFBundleRef mainBundle = CFBundleGetMainBundle();
207			CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
208			char path[PATH_MAX];
209			if (!CFURLGetFileSystemRepresentation(resourcesURL,
210			TRUE,
211			reinterpret_cast<uint8_t*>(path),
212			PATH_MAX))
213			{
214			fprintf(stderr, "Can't find Resources directory\n");
215			}
216			CFRelease(resourcesURL);
217			std::string path2 = pathJoin(path, "data");
218			VirtFs::mountDir(pathJoin(path2, "perserver/default"), Append_false);
219			VirtFs::mountDir(path2, Append_false);
220			// possible this need for support run client from dmg images.
221			// mPackageDir = path;
222			#endif // defined __APPLE__
223
224			VirtFs::mountDirSilent(PKG_DATADIR "data", Append_false);
225			setPackageDir(PKG_DATADIR "data");
226			VirtFs::mountDirSilent("data", Append_false);
227
228			#ifdef ANDROID
229			#ifdef USE_SDL2
230			if (getenv("APPDIR"))
231			{
232			const std::string appDir = getenv("APPDIR");
233			VirtFs::mountDir(appDir + "/data", Append_false);
234			VirtFs::mountDir(appDir + "/data/perserver/default",
235			Append_false);
236			}
237			#endif // USE_SDL2
238			#endif // ANDROID
239
240			#if defined __native_client__
241			VirtFs::mountZip("/http/data.zip", Append_false);
242			VirtFs::mountZip2("/http/data.zip",
243			"perserver/default",
244			Append_false);
245			#endif // defined __native_client__
246
247			#ifndef WIN32
248			// Add branding/data to VirtFS search path
249			if (!settings.options.brandingPath.empty())
250			{
251			std::string path = settings.options.brandingPath;
252
253			// Strip blah.manaplus from the path
254			const int loc = CAST_S32(path.find_last_of('/'));
255
256			if (loc > 0)
257			{
258			VirtFs::mountDir(path.substr(
259			0, loc + 1).append("data"),
260			Append_false);
261			}
262			}
263			#endif // WIN32
264			}
265
266		291	void Dirs::initRootDir()
267			{
268		582	settings.rootDir = VirtFs::getBaseDir();
269		582	const std::string portableName = settings.rootDir + "portable.xml";
270			struct stat statbuf;
271
272	✗✓✗✗ ✗✓	582	if (stat(portableName.c_str(), &statbuf) == 0 &&
273			S_ISREG(statbuf.st_mode))
274			{
275			std::string dir;
276			Configuration portable;
277			portable.init(portableName,
278			UseVirtFs_false,
279			SkipError_false);
280
281			if (settings.options.brandingPath.empty())
282			{
283			branding.init(portableName,
284			UseVirtFs_false,
285			SkipError_false);
286			setBrandingDefaults(branding);
287			}
288
289			logger->log("Portable file: %s", portableName.c_str());
290
291			if (settings.options.localDataDir.empty())
292			{
293			dir = portable.getValue("dataDir", "");
294			if (!dir.empty())
295			{
296			settings.options.localDataDir = settings.rootDir + dir;
297			logger->log("Portable data dir: %s",
298			settings.options.localDataDir.c_str());
299			}
300			}
301
302			if (settings.options.configDir.empty())
303			{
304			dir = portable.getValue("configDir", "");
305			if (!dir.empty())
306			{
307			settings.options.configDir = settings.rootDir + dir;
308			logger->log("Portable config dir: %s",
309			settings.options.configDir.c_str());
310			}
311			}
312
313			if (settings.options.screenshotDir.empty())
314			{
315			dir = portable.getValue("screenshotDir", "");
316			if (!dir.empty())
317			{
318			settings.options.screenshotDir = settings.rootDir + dir;
319			logger->log("Portable screenshot dir: %s",
320			settings.options.screenshotDir.c_str());
321			}
322			}
323			}
324		291	}
325
326			/**
327			* Initializes the home directory. On UNIX and FreeBSD, ~/.mana is used. On
328			* Windows and other systems we use the current working directory.
329			*/
330		291	void Dirs::initHomeDir()
331			{
332		291	initLocalDataDir();
333		291	initTempDir();
334		291	initConfigDir();
335		291	}
336
337		291	void Dirs::initLocalDataDir()
338			{
339		291	settings.localDataDir = settings.options.localDataDir;
340
341	✓✗	291	if (settings.localDataDir.empty())
342			{
343			#ifdef __APPLE__
344			// Use Application Directory instead of .mana
345			settings.localDataDir = pathJoin(VirtFs::getUserDir(),
346			"Library/Application Support",
347			branding.getValue("appName", "ManaPlus"));
348			#elif defined __HAIKU__
349			settings.localDataDir = pathJoin(VirtFs::getUserDir(),
350			"config/cache/Mana");
351			#elif defined WIN32
352			settings.localDataDir = getSpecialFolderLocation(CSIDL_LOCAL_APPDATA);
353			if (settings.localDataDir.empty())
354			settings.localDataDir = VirtFs::getUserDir();
355			settings.localDataDir = pathJoin(settings.localDataDir,
356			"Mana");
357			#elif defined __ANDROID__
358			settings.localDataDir = pathJoin(getSdStoragePath(),
359			branding.getValue("appShort", "ManaPlus"),
360			"local");
361			#elif defined __native_client__
362			settings.localDataDir = pathJoin(_nacl_dir, "local");
363			#elif defined __SWITCH__
364			settings.localDataDir = pathJoin(VirtFs::getUserDir(), "local");
365			#else // __APPLE__
366
367	✓✗✓✗ ✓✗	2328	settings.localDataDir = pathJoin(VirtFs::getUserDir(),
368		291	".local/share/mana");
369			#endif // __APPLE__
370			}
371
372	✗✓	291	if (mkdir_r(settings.localDataDir.c_str()) != 0)
373			{
374			// TRANSLATORS: directory creation error
375			logger->error(strprintf(_("%s doesn't exist and can't be created! "
376			"Exiting."), settings.localDataDir.c_str()));
377			}
378			#ifdef USE_PROFILER
379			Perfomance::init(pathJoin(settings.localDataDir, "profiler.log"));
380			#endif // USE_PROFILER
381		291	}
382
383		291	void Dirs::initTempDir()
384			{
385	✓✗	2037	settings.tempDir = pathJoin(settings.localDataDir, "temp");
386
387	✗✓	291	if (mkdir_r(settings.tempDir.c_str()) != 0)
388			{
389			// TRANSLATORS: directory creation error
390			logger->error(strprintf(_("%s doesn't exist and can't be created! "
391			"Exiting."), settings.tempDir.c_str()));
392			}
393			// ResourceManager::deleteFilesInDirectory(settings.tempDir);
394		291	}
395
396		291	void Dirs::initConfigDir()
397			{
398		291	settings.configDir = settings.options.configDir;
399
400	✓✗	291	if (settings.configDir.empty())
401			{
402			#ifdef __APPLE__
403			settings.configDir = pathJoin(settings.localDataDir,
404			branding.getValue("appShort", "mana"));
405			#elif defined __HAIKU__
406			settings.configDir = pathJoin(VirtFs::getUserDir(),
407			"config/settings/Mana",
408			branding.getValue("appName", "ManaPlus"));
409			#elif defined WIN32
410			settings.configDir = getSpecialFolderLocation(CSIDL_APPDATA);
411			if (settings.configDir.empty())
412			{
413			settings.configDir = settings.localDataDir;
414			}
415			else
416			{
417			settings.configDir = pathJoin(settings.configDir,
418			"mana",
419			branding.getValue("appShort", "mana"));
420			}
421			#elif defined __ANDROID__
422			settings.configDir = pathJoin(getSdStoragePath(),
423			branding.getValue("appShort", "ManaPlus"),
424			"config");
425			#elif defined __native_client__
426			settings.configDir = pathJoin(_nacl_dir, "config");
427			#elif defined __SWITCH__
428			settings.configDir = pathJoin(VirtFs::getUserDir(), "config");
429			#else // __APPLE__
430
431	✓✗✓✗ ✓✗✓✗	2328	settings.configDir = pathJoin(VirtFs::getUserDir(),
432			".config/mana",
433	✓✗✓✗	2619	branding.getValue("appShort", "mana"));
434			#endif // __APPLE__
435
436	✓✗	582	logger->log("Generating config dir: " + settings.configDir);
437			}
438
439	✗✓	291	if (mkdir_r(settings.configDir.c_str()) != 0)
440			{
441			// TRANSLATORS: directory creation error
442			logger->error(strprintf(_("%s doesn't exist and can't be created! "
443			"Exiting."), settings.configDir.c_str()));
444			}
445		291	}
446
447			/**
448			* Parse the update host and determine the updates directory
449			* Then verify that the directory exists (creating if needed).
450			*/
451			void Dirs::initUpdatesDir()
452			{
453			std::stringstream updates;
454
455			// If updatesHost is currently empty, fill it from config file
456			if (settings.updateHost.empty())
457			settings.updateHost = config.getStringValue("updatehost");
458			if (!checkPath(settings.updateHost))
459			return;
460
461			// Don't go out of range int he next check
462			if (settings.updateHost.length() < 2)
463			{
464			if (settings.updatesDir.empty())
465			settings.updatesDir = pathJoin("updates", settings.serverName);
466			return;
467			}
468
469			const size_t sz = settings.updateHost.size();
470			// Remove any trailing slash at the end of the update host
471			if (settings.updateHost.at(sz - 1) == '/')
472			settings.updateHost.resize(sz - 1);
473
474			// Parse out any "http://" or "https://", and set the updates directory
475			const size_t pos = settings.updateHost.find("://");
476			if (pos != std::string::npos)
477			{
478			if (pos + 3 < settings.updateHost.length()
479			&& !settings.updateHost.empty())
480			{
481			updates << "updates/" << settings.updateHost.substr(pos + 3);
482			settings.updatesDir = updates.str();
483			}
484			else
485			{
486			logger->log("Error: Invalid update host: %s",
487			settings.updateHost.c_str());
488			// TRANSLATORS: update server initialisation error
489			errorMessage = strprintf(_("Invalid update host: %s."),
490			settings.updateHost.c_str());
491			client->setState(State::ERROR);
492			}
493			}
494			else
495			{
496			logger->log1("Warning: no protocol was specified for the update host");
497			updates << "updates/" << settings.updateHost;
498			settings.updatesDir = updates.str();
499			}
500
501			#ifdef WIN32
502			if (settings.updatesDir.find(":") != std::string::npos)
503			replaceAll(settings.updatesDir, ":", "_");
504			#endif // WIN32
505
506			const std::string updateDir("/" + settings.updatesDir);
507
508			// Verify that the updates directory exists. Create if necessary.
509			if (!VirtFs::isDirectory(updateDir))
510			{
511			if (!VirtFs::mkdir(updateDir))
512			{
513			#if defined WIN32
514			std::string newDir = pathJoin(settings.localDataDir,
515			settings.updatesDir);
516			if (!CreateDirectory(newDir.c_str(), nullptr) &&
517			GetLastError() != ERROR_ALREADY_EXISTS)
518			{
519			logger->log("Error: %s can't be made, but doesn't exist!",
520			newDir.c_str());
521			// TRANSLATORS: update server initialisation error
522			errorMessage = _("Error creating updates directory!");
523			client->setState(State::ERROR);
524			}
525			#else // defined WIN32
526
527			logger->log("Error: %s/%s can't be made, but doesn't exist!",
528			settings.localDataDir.c_str(),
529			settings.updatesDir.c_str());
530			// TRANSLATORS: update server initialisation error
531			errorMessage = _("Error creating updates directory!");
532			client->setState(State::ERROR);
533			#endif // defined WIN32
534			}
535			}
536			const std::string updateLocal = pathJoin(updateDir, "local");
537			const std::string updateFix = pathJoin(updateDir, "fix");
538			if (!VirtFs::isDirectory(updateLocal))
539			VirtFs::mkdir(updateLocal);
540			if (!VirtFs::isDirectory(updateFix))
541			VirtFs::mkdir(updateFix);
542			}
543
544			void Dirs::initScreenshotDir()
545			{
546			if (!settings.options.screenshotDir.empty())
547			{
548			settings.screenshotDir = settings.options.screenshotDir;
549			if (mkdir_r(settings.screenshotDir.c_str()) != 0)
550			{
551			logger->log(strprintf(
552			// TRANSLATORS: directory creation error
553			_("Error: %s doesn't exist and can't be created! "
554			"Exiting."), settings.screenshotDir.c_str()));
555			}
556			}
557			else if (settings.screenshotDir.empty())
558			{
559			#ifdef __native_client__
560			settings.screenshotDir = pathJoin(_nacl_dir, "screenshots/");
561			#else // __native_client__
562			settings.screenshotDir = decodeBase64String(
563			config.getStringValue("screenshotDirectory3"));
564			if (settings.screenshotDir.empty())
565			{
566			#ifdef __ANDROID__
567			settings.screenshotDir = getSdStoragePath()
568			+ std::string("/images");
569
570			if (mkdir_r(settings.screenshotDir.c_str()))
571			{
572			logger->log(strprintf(
573			// TRANSLATORS: directory creation error
574			_("Error: %s doesn't exist and can't be created! "
575			"Exiting."), settings.screenshotDir.c_str()));
576			}
577			#else // ANDROID
578			settings.screenshotDir = getPicturesDir();
579			#endif // ANDROID
580			if (config.getBoolValue("useScreenshotDirectorySuffix"))
581			{
582			const std::string configScreenshotSuffix =
583			branding.getValue("screenshots", "ManaPlus");
584
585			if (!configScreenshotSuffix.empty())
586			{
587			settings.screenshotDir = pathJoin(settings.screenshotDir,
588			configScreenshotSuffix);
589			}
590			}
591			config.setValue("screenshotDirectory3",
592			encodeBase64String(settings.screenshotDir));
593			}
594			#endif // __native_client__
595			}
596			logger->log("screenshotDirectory: " + settings.screenshotDir);
597			}
598
599			void Dirs::initUsersDir()
600			{
601			settings.usersDir = settings.serverConfigDir + "/users/";
602			if (mkdir_r(settings.usersDir.c_str()) != 0)
603			{
604			// TRANSLATORS: directory creation error
605			logger->error(strprintf(_("%s doesn't exist and can't be created!"),
606			settings.usersDir.c_str()));
607			}
608
609			settings.npcsDir = settings.serverConfigDir + "/npcs/";
610			if (mkdir_r(settings.npcsDir.c_str()) != 0)
611			{
612			// TRANSLATORS: directory creation error
613			logger->error(strprintf(_("%s doesn't exist and can't be created!"),
614			settings.npcsDir.c_str()));
615			}
616
617			settings.usersIdDir = settings.serverConfigDir + "/usersid/";
618			if (mkdir_r(settings.usersIdDir.c_str()) != 0)
619			{
620			// TRANSLATORS: directory creation error
621			logger->error(strprintf(_("%s doesn't exist and can't be created!"),
622			settings.usersIdDir.c_str()));
623			}
624			}