Dirs Class Reference

#include <dirs.h>

Static Public Member Functions
static void	initUsersDir ()
static void	updateDataPath ()
static void	extractDataDir ()
static void	mountDataDir ()
static void	initRootDir ()
static void	initHomeDir ()
static void	initLocalDataDir ()
static void	initTempDir ()
static void	initConfigDir ()
static void	initUpdatesDir ()
static void	initScreenshotDir ()

Detailed Description

Definition at line 29 of file dirs.h.

Member Function Documentation

extractDataDir()

void Dirs::extractDataDir ( )

static

Definition at line 179 of file dirs.cpp.

{
#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)
}

References Append_false, VirtFs::mountZip2(), and pathJoin().

Referenced by Client::gameInit().

initConfigDir()

void Dirs::initConfigDir ( )

static

Definition at line 396 of file dirs.cpp.

{
    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()));
    }
}

References _, branding, Options::configDir, Settings::configDir, Logger::error(), VirtFs::getUserDir(), ConfigurationObject::getValue(), Settings::localDataDir, Logger::log(), logger, mkdir_r(), Settings::options, pathJoin(), settings, and strprintf().

Referenced by initHomeDir().

initHomeDir()

void Dirs::initHomeDir ( )

static

Initializes the home directory. On UNIX and FreeBSD, ~/.mana is used. On Windows and other systems we use the current working directory.

Definition at line 330 of file dirs.cpp.

{
    initLocalDataDir();
    initTempDir();
    initConfigDir();
}

References initConfigDir(), initLocalDataDir(), and initTempDir().

Referenced by Client::gameInit().

initLocalDataDir()

void Dirs::initLocalDataDir ( )

static

Definition at line 337 of file dirs.cpp.

{
    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
}

References _, branding, Logger::error(), VirtFs::getUserDir(), ConfigurationObject::getValue(), PlayerInfo::init(), Options::localDataDir, Settings::localDataDir, logger, mkdir_r(), Settings::options, pathJoin(), settings, and strprintf().

Referenced by initHomeDir().

initRootDir()

void Dirs::initRootDir ( )

static

Definition at line 266 of file dirs.cpp.

{
    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());
            }
        }
    }
}

References branding, Options::brandingPath, Options::configDir, VirtFs::getBaseDir(), ConfigurationObject::getValue(), Configuration::init(), Options::localDataDir, Logger::log(), logger, Settings::options, Settings::rootDir, Options::screenshotDir, setBrandingDefaults(), settings, SkipError_false, and UseVirtFs_false.

Referenced by Client::gameInit().

initScreenshotDir()

void Dirs::initScreenshotDir ( )

static

Definition at line 544 of file dirs.cpp.

{
    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);
}

References _, branding, config, decodeBase64String(), encodeBase64String(), Configuration::getBoolValue(), getPicturesDir(), Configuration::getStringValue(), ConfigurationObject::getValue(), Logger::log(), logger, mkdir_r(), Settings::options, pathJoin(), Options::screenshotDir, Settings::screenshotDir, settings, Configuration::setValue(), and strprintf().

Referenced by Client::gameInit().

initTempDir()

void Dirs::initTempDir ( )

static

Definition at line 383 of file dirs.cpp.

{
    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);
}

References _, Logger::error(), Settings::localDataDir, logger, mkdir_r(), pathJoin(), settings, strprintf(), and Settings::tempDir.

Referenced by initHomeDir().

initUpdatesDir()

void Dirs::initUpdatesDir ( )

static

Parse the update host and determine the updates directory Then verify that the directory exists (creating if needed).

Definition at line 451 of file dirs.cpp.

{
    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);
}

References _, checkPath(), client, config, State::ERROR, errorMessage, Configuration::getStringValue(), VirtFs::isDirectory(), Settings::localDataDir, Logger::log(), Logger::log1(), logger, VirtFs::mkdir(), pathJoin(), replaceAll(), Settings::serverName, Client::setState(), settings, strprintf(), Settings::updateHost, and Settings::updatesDir.

initUsersDir()

void Dirs::initUsersDir ( )

static

Definition at line 599 of file dirs.cpp.

{
    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()));
    }
}

References _, Logger::error(), logger, mkdir_r(), Settings::npcsDir, Settings::serverConfigDir, settings, strprintf(), Settings::usersDir, and Settings::usersIdDir.

Referenced by Client::stateConnectServer1().

mountDataDir()

void Dirs::mountDataDir ( )

static

Definition at line 198 of file dirs.cpp.

{
    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
}

References Append_false, Options::brandingPath, CAST_S32, VirtFs::mountDir(), VirtFs::mountDirSilent(), VirtFs::mountZip(), VirtFs::mountZip2(), Settings::options, pathJoin(), PKG_DATADIR, setPackageDir(), and settings.

Referenced by Client::gameInit().

updateDataPath()

void Dirs::updateDataPath ( )

static

Definition at line 161 of file dirs.cpp.

{
    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;
    }
}

References branding, Options::dataPath, Configuration::getDirectory(), Configuration::getStringValue(), isRealPath(), Settings::options, pathJoin(), settings, and Options::skipUpdate.

Referenced by Client::gameInit().

---

The documentation for this class was generated from the following files:

• src/dirs.h (986a3bf)
• src/dirs.cpp (986a3bf)