opentxs::OTPaths Class Reference

#include <OTPaths.hpp>

Public Member Functions
EXPORT	~OTPaths ()

Static Public Member Functions
static EXPORT const OTString &	AppBinaryFolder ()
static EXPORT void	SetAppBinaryFolder (OTString strLocation)
static EXPORT const OTString &	HomeFolder ()
static EXPORT void	SetHomeFolder (OTString strLocation)
static EXPORT const OTString &	AppDataFolder ()
static EXPORT const OTString &	GlobalConfigFile ()
static EXPORT const OTString &	PrefixFolder ()
static EXPORT const OTString &	ScriptsFolder ()
static EXPORT bool	LoadSetPrefixFolder (OTSettings &config=s_settings, const OTString &strPrefixFolder="")
static EXPORT bool	LoadSetScriptsFolder (OTSettings &config=s_settings, const OTString &strScriptsFolder="", const bool &bIsRelative=true)
static EXPORT bool	Get (OTSettings &config, const OTString &strSection, const OTString &strKey, OTString &out_strVar, bool &out_bIsRelative, bool &out_bKeyExist)
static EXPORT bool	Set (OTSettings &config, const OTString &strSection, const OTString &strKey, const OTString &strValue, const bool &bIsRelative, bool &out_bIsNewOrUpdated, const OTString &strComment="")
static EXPORT bool	FixPath (const OTString &strPath, OTString &out_strFixedPath, const bool &bIsFolder)
static EXPORT bool	PathExists (const OTString &strPath)
static EXPORT bool	FileExists (const OTString &strFilePath, int64_t &nFileLength)
static EXPORT bool	FolderExists (const OTString &strFolderPath)
static EXPORT bool	ConfirmCreateFolder (const OTString &strExactPath, bool &out_Exists, bool &out_IsNew)
static EXPORT bool	ToReal (const OTString &strExactPath, OTString &out_strCanonicalPath)
static EXPORT bool	GetExecutable (OTString &strExecutablePath)
static EXPORT bool	GetCurrentWorking (OTString &strCurrentWorkingPath)
static EXPORT bool	GetHomeFromSystem (OTString &out_strHomeFolder)
static EXPORT bool	AppendFolder (OTString &out_strPath, const OTString &strBasePath, const OTString &strFolderName)
static EXPORT bool	AppendFile (OTString &out_strPath, const OTString &strBasePath, const OTString &strFileName)
static EXPORT bool	RelativeToCanonical (OTString &out_strCanonicalPath, const OTString &strBasePath, const OTString &strRelativePath)
static EXPORT bool	BuildFolderPath (const OTString &strFolderPath, bool &out_bFolderCreated)
static EXPORT bool	BuildFilePath (const OTString &strFolderPath, bool &out_bFolderCreated)

Detailed Description

Definition at line 144 of file OTPaths.hpp.

Constructor & Destructor Documentation

opentxs::OTPaths::~OTPaths

(

)

Definition at line 226 of file OTPaths.cpp.

{
}

Member Function Documentation

const OTString & opentxs::OTPaths::AppBinaryFolder ( )

static

Definition at line 230 of file OTPaths.cpp.

{
    return OTPaths::s_strAppBinaryFolder;
}

const OTString & opentxs::OTPaths::AppDataFolder ( )

static

Definition at line 254 of file OTPaths.cpp.

{
    if (s_strAppDataFolder.Exists())
        return s_strAppDataFolder; // already got it, just return it.

    OTString strHomeDataFolder(OTPaths::HomeFolder()),
        strAppDataFolder(""); // eg. /home/user/  (the folder that the OT
                              // appdata folder will be in.)

    if (!strHomeDataFolder.Exists() && !GetHomeFromSystem(strHomeDataFolder)) {
        OT_FAIL;
    }

    // now lets change all the '\' into '/'
    // then check that the path /home/user indeed exists, and is a folder.

    FixPath(strHomeDataFolder, strHomeDataFolder, true);
    if (!PathExists(strHomeDataFolder)) OT_FAIL;

    // ok, we have the HomeData Folder, lets append our OT folder to it.

    if (!AppendFolder(strAppDataFolder, strHomeDataFolder, OT_APPDATA_DIR))
        OT_FAIL;

    bool bFolderCreated;
    if (!BuildFolderPath(strAppDataFolder, bFolderCreated)) OT_FAIL;

    s_strAppDataFolder = strAppDataFolder; // all good lets set it.

    return s_strAppDataFolder;
}

bool opentxs::OTPaths::AppendFile ( OTString &  out_strPath, const OTString &  strBasePath, const OTString &  strFileName  )

static

Definition at line 1245 of file OTPaths.cpp.

{
    if (!strBasePath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strBasePath"
              << " passed in!\n";
        OT_FAIL;
    }
    if (!strFileName.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strFileName"
              << " passed in!\n";
        OT_FAIL;
    }

    OTString l_strBasePath_fix(""), l_strFileName_fix("");

    if (!FixPath(strBasePath, l_strBasePath_fix, true)) return false;
    if (!FixPath(strFileName, l_strFileName_fix, false)) return false;

    std::string l_strBasePath(l_strBasePath_fix.Get()),
        l_strFileName(l_strFileName_fix.Get());

    l_strBasePath.append(l_strFileName);

    const OTString l_strPath(l_strBasePath);

    out_strPath = l_strPath;
    return true;
}

bool opentxs::OTPaths::AppendFolder ( OTString &  out_strPath, const OTString &  strBasePath, const OTString &  strFolderName  )

static

Definition at line 1212 of file OTPaths.cpp.

{
    if (!strBasePath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strBasePath"
              << " passed in!\n";
        OT_FAIL;
    }
    if (!strFolderName.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strFolderName"
              << " passed in!\n";
        OT_FAIL;
    }

    OTString l_strBasePath_fix(""), l_strFolderName_fix("");

    if (!FixPath(strBasePath, l_strBasePath_fix, true)) return false;
    if (!FixPath(strFolderName, l_strFolderName_fix, true)) return false;

    std::string l_strBasePath(l_strBasePath_fix.Get()),
        l_strFolderName(l_strFolderName_fix.Get());

    l_strBasePath.append(l_strFolderName);

    const OTString l_strPath(l_strBasePath);

    out_strPath = l_strPath;
    return true;
}

bool opentxs::OTPaths::BuildFilePath ( const OTString &  strFolderPath, bool &  out_bFolderCreated  )

static

Definition at line 1369 of file OTPaths.cpp.

{
    out_bFolderCreated = false;

    OTString l_strFilePath_fix(""), l_strFilePath_real("");

    if (!ToReal(strFolderPath, l_strFilePath_real))
        return false; // path to real

    if (!FixPath(l_strFilePath_real, l_strFilePath_fix, false))
        return false; // real to fixed real

    std::string l_strFilePath(l_strFilePath_fix.Get()); // fixed real path.

    std::vector<std::string> vFolders;

    split_byChar(vFolders, l_strFilePath, "/", split::no_empties);

    size_t nSize = vFolders.size();

    std::string l_strPathPart("");
    bool l_FolderExists(false), l_bBuiltFolder(false);

    const bool bLog(OTLog::IsInitialized());

    for (size_t i = 0; i < nSize; i++) {
#ifndef _WIN32                            // aka UNIX
        if (0 == i) l_strPathPart += "/"; // add annother / for root.
#endif

        l_strPathPart += vFolders[i];

        if ((i + 1) == nSize) continue; // file should be skipped

        l_strPathPart += "/"; // is a folder, so should append /

        if (0 == i) continue; // / or x:/ should be skiped.

        OTString strPathPart(l_strPathPart);
        if (!ConfirmCreateFolder(strPathPart, l_FolderExists, l_bBuiltFolder))
            return false;
        if (bLog && l_bBuiltFolder)
            otOut << __FUNCTION__ << ": Made new folder: " << l_strPathPart
                  << "";

        if (!out_bFolderCreated && l_bBuiltFolder) out_bFolderCreated = true;
    }
    return true;
}

bool opentxs::OTPaths::BuildFolderPath ( const OTString &  strFolderPath, bool &  out_bFolderCreated  )

static

Definition at line 1320 of file OTPaths.cpp.

{
    out_bFolderCreated = false;

    OTString l_strFolderPath_fix(""), l_strFolderPath_real("");

    if (!ToReal(strFolderPath, l_strFolderPath_real))
        return false; // path to real

    if (!FixPath(l_strFolderPath_real, l_strFolderPath_fix, true))
        return false; // real to fixed real

    std::string l_strFolderPath(l_strFolderPath_fix.Get()); // fixed real path.

    std::vector<std::string> vFolders;

    split_byChar(vFolders, l_strFolderPath, "/", split::no_empties);

    size_t nSize = vFolders.size();

    std::string l_strPathPart("");
    bool l_FolderExists(false), l_bBuiltFolder(false);

    const bool bLog(OTLog::IsInitialized());

    for (size_t i = 0; i < nSize; i++) {
#ifndef _WIN32                            // aka UNIX
        if (0 == i) l_strPathPart += "/"; // add annother / for root.
#endif
        l_strPathPart += vFolders[i];
        l_strPathPart += "/";

        if (0 == i) continue; // / or x:/ should be skiped.

        OTString strPathPart(l_strPathPart);

        if (!ConfirmCreateFolder(strPathPart, l_FolderExists, l_bBuiltFolder))
            return false;
        if (bLog && l_bBuiltFolder)
            otOut << __FUNCTION__ << ": Made new folder: " << l_strPathPart
                  << "\n";

        if (!out_bFolderCreated && l_bBuiltFolder) out_bFolderCreated = true;
    }
    return true;
}

bool opentxs::OTPaths::ConfirmCreateFolder ( const OTString &  strExactPath, bool &  out_Exists, bool &  out_IsNew  )

static

Definition at line 921 of file OTPaths.cpp.

{
    const bool bExists = (strExactPath.Exists() && !strExactPath.Compare(""));
    OT_ASSERT_MSG(
        bExists,
        "OTPaths::ConfirmCreateFolder: Assert failed: no strFolderName\n");

    std::string l_strExactPath(strExactPath.Get());

    if ('/' != *l_strExactPath.rbegin()) return false; // not a directory.

    // Confirm If Directory Exists Already
    out_Exists = PathExists(strExactPath);

    if (out_Exists) {
        out_IsNew = false;
        return true; // Already Have Folder, lets return true!
    }
    else {
// It dosn't exist: lets create it.

#ifdef _WIN32
        bool bCreateDirSuccess = (_mkdir(strExactPath.Get()) == 0);
#else
        bool bCreateDirSuccess = (mkdir(strExactPath.Get(), 0700) == 0);
#endif

        if (!bCreateDirSuccess) {
            otErr << "OTPaths::" << __FUNCTION__ << ": Unable To Confirm "
                                                    "Created Directory "
                  << strExactPath << ".\n";
            out_IsNew = false;
            out_Exists = false;
            return false;
        }

        // At this point if the folder still doesn't exist, nothing we can do.
        // We
        // already tried to create the folder, and SUCCEEDED, and then STILL
        // failed
        // to find it (if this is still false.)
        else {
            bool bCheckDirExist = PathExists(strExactPath);

            if (!bCheckDirExist) {
                otErr << "OTPaths::" << __FUNCTION__
                      << ": "
                         "Unable To Confirm Created Directory " << strExactPath
                      << ".\n";
                out_IsNew = false;
                out_Exists = false;
                return false;
            }
            else {
                out_IsNew = true;
                out_Exists = false;
                return true; // We have created and checked the Folder
            }
        }
    }
}

bool opentxs::OTPaths::FileExists ( const OTString &  strFilePath, int64_t &  nFileLength  )

static

Definition at line 842 of file OTPaths.cpp.

{
    if (!strFilePath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strFilePath"
              << " passed in!\n";
        OT_FAIL;
    }

    // remove trailing backslash for stat
    std::string l_strPath(strFilePath.Get());
    l_strPath = (OTString::replace_chars(l_strPath, "\\", '/')); // all \ to /

    if ('/' != *l_strPath.rbegin()) {
#ifdef _WIN32
        std::string l_strPath_stat = l_strPath;
        struct _stat st_buf;
        memset(&st_buf, 0, sizeof(st_buf));
        char filename[4086]; // not sure about this buffer,
        // on windows paths cannot be longer than 4086,
        // so it should be fine... needs more research.
        strcpy_s(filename, l_strPath_stat.c_str());
        _stat(filename, &st_buf);
#else
        struct stat st_buf;
        memset(&st_buf, 0, sizeof(st_buf));
        stat(l_strPath.c_str(), &st_buf);
#endif

        // check for file
        if (S_ISREG(st_buf.st_mode)) {
            // good we have a file.
            size_t lFileLength = st_buf.st_size;
            nFileLength = static_cast<int64_t>(lFileLength);
            return true;
        }
    }
    return false;
}

bool opentxs::OTPaths::FixPath ( const OTString &  strPath, OTString &  out_strFixedPath, const bool &  bIsFolder  )

static

Definition at line 759 of file OTPaths.cpp.

{
    if (!strPath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strPath"
              << " passed in!\n";
        OT_FAIL;
    }

    std::string l_strPath(strPath.Get());
    // first change all back-slashes to forward slashes:
    std::string l_strPath_noBackslash(
        OTString::replace_chars(l_strPath, "\\", '/'));

    // now we make sure we have the correct trailing "/".

    if ('/' == *l_strPath_noBackslash.rbegin()) {
        if (bIsFolder) {
            out_strFixedPath.Set(l_strPath_noBackslash.c_str());
            return true;
        }
        else {
            out_strFixedPath.Set(
                l_strPath_noBackslash.substr(0, l_strPath_noBackslash.size() -
                                                    1).c_str());
            return true;
        }
    }
    else {
        if (bIsFolder) {
            l_strPath_noBackslash += "/";
            out_strFixedPath.Set(l_strPath_noBackslash.c_str());
            return true;
        }
        else {
            out_strFixedPath.Set(l_strPath_noBackslash.c_str());
            return true;
        }
    }
}

bool opentxs::OTPaths::FolderExists ( const OTString &  strFolderPath )

static

Definition at line 883 of file OTPaths.cpp.

{
    if (!strFolderPath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strFolderPath"
              << " passed in!\n";
        OT_FAIL;
    }

    // remove trailing backslash for stat
    std::string l_strPath(strFolderPath.Get());
    l_strPath = (OTString::replace_chars(l_strPath, "\\", '/')); // all \ to /

    if ('/' == *l_strPath.rbegin()) {
#ifdef _WIN32
        std::string l_strPath_stat = l_strPath.substr(0, l_strPath.size() - 1);
        struct _stat st_buf;
        memset(&st_buf, 0, sizeof(st_buf));
        char filename[4086] = ""; // not sure about this buffer,
        // on windows paths cannot be longer than 4086,
        // so it should be fine... needs more research.
        strcpy_s(filename, l_strPath_stat.c_str());
        _stat(filename, &st_buf);
#else
        struct stat st_buf;
        memset(&st_buf, 0, sizeof(st_buf));
        stat(l_strPath.c_str(), &st_buf);
#endif

        if (S_ISDIR(st_buf.st_mode)) {
            // good we have a directory.
            return true;
        }
    }
    return false;
}

bool opentxs::OTPaths::Get ( OTSettings &  config, const OTString &  strSection, const OTString &  strKey, OTString &  out_strVar, bool &  out_bIsRelative, bool &  out_bKeyExist  )

static

Definition at line 625 of file OTPaths.cpp.

{
    if (!strSection.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strSection"
              << " passed in!\n";
        OT_FAIL;
    }
    if (!strKey.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strKey"
              << " passed in!\n";
        OT_FAIL;
    }

    out_strVar = "";
    out_bIsRelative = false;
    out_bKeyExist = false;

    const bool bPreLoaded(config.IsLoaded());

    if (!bPreLoaded) {
        config.Reset();
        if (!config.Load()) {
            OT_FAIL;
        }
    }

    bool bBoolExists(false), bIsRelative(false);
    OTString strRelativeKey(""), strOutFolder("");

    strRelativeKey.Format("%s%s", strKey.Get(), OT_CONFIG_ISRELATIVE);

    if (config.Check_bool(strSection, strRelativeKey, bIsRelative,
                          bBoolExists)) {
        bool bStringExists = false;
        if (config.Check_str(strSection, strKey, strOutFolder, bStringExists)) {
            if (bBoolExists && bStringExists) {
                if (!bIsRelative) // lets fix the path, so it dosn't matter how
                                  // people write it in the config.
                {
                    if (!ToReal(strOutFolder, strOutFolder)) {
                        OT_FAIL;
                    }

                    if (!FixPath(strOutFolder, strOutFolder, true)) {
                        OT_FAIL;
                    }
                }

                out_strVar = strOutFolder;
                out_bIsRelative = bIsRelative;
                out_bKeyExist = true;
            }
            else {
                out_strVar = "";
                out_bIsRelative = false;
                out_bKeyExist = false;
            }

            if (!bPreLoaded) {
                config.Reset();
            }

            return true;
        }
    }
    // if we get here, there has been a error!
    OT_FAIL;
}

static EXPORT bool opentxs::OTPaths::GetCurrentWorking ( OTString &  strCurrentWorkingPath )

static

static EXPORT bool opentxs::OTPaths::GetExecutable ( OTString &  strExecutablePath )

static

bool opentxs::OTPaths::GetHomeFromSystem ( OTString &  out_strHomeFolder )

static

Definition at line 1155 of file OTPaths.cpp.

{
#ifdef _WIN32
#ifdef _UNICODE
    TCHAR szPath[MAX_PATH] = L"";
#else
    TCHAR szPath[MAX_PATH] = "";
#endif

    if (SUCCEEDED(SHGetFolderPath(nullptr, CSIDL_APPDATA | CSIDL_FLAG_CREATE,
                                  nullptr, 0, szPath))) {
#ifdef UNICODE
        out_strHomeFolder.Set(utf8util::UTF8FromUTF16(szPath));
#else
        out_strHomeFolder.Set(szPath);
#endif
    }
    else {
        out_strHomeFolder.Set("");
        return false;
    }
#else
    out_strHomeFolder.Set(getenv("HOME"));
#endif
    return true;
}

const OTString & opentxs::OTPaths::GlobalConfigFile ( )

static

Definition at line 286 of file OTPaths.cpp.

{
    if (s_strGlobalConfigFile.Exists())
        return s_strGlobalConfigFile; // got it, lets return it.

    OTString strGlobalConfigFile("");

    if (!AppendFile(strGlobalConfigFile, AppDataFolder(),
                    OT_INIT_CONFIG_FILENAME))
        OT_FAIL;

    s_strGlobalConfigFile = strGlobalConfigFile;

    return s_strGlobalConfigFile;
}

const OTString & opentxs::OTPaths::HomeFolder ( )

static

Definition at line 240 of file OTPaths.cpp.

{
    return OTPaths::s_strHomeFolder;
}

bool opentxs::OTPaths::LoadSetPrefixFolder ( OTSettings &  config = s_settings, const OTString &  strPrefixFolder = ""  )

static

Definition at line 331 of file OTPaths.cpp.

{
    /*
    The prefix path is special.

    This path is tested if it is different to the
    one that would be automatically selected by this program
    (aka either compiled into, or from the registry, or the default user data
    directory).

    If the set path is different to what would be supplied and the override path
    value is set.
    Then we will use that path.

    Otherwise, we will update the path in the configuration to link against the
    updated path.

    Users will need to set the override path flag in the configuration,
    if they want to manually set the prefix path.
    */

    const bool bPreLoaded(config.IsLoaded());

    if (!bPreLoaded) {
        config.Reset();
        if (!config.Load()) {
            OT_FAIL;
        }
    }

    {
        // get default path
        OTString strDefaultPrefixPath(OT_PREFIX_PATH);
        {
            if (!strDefaultPrefixPath.Exists()) {
                otErr << __FUNCTION__ << ": Error: OT_PREFIX_PATH is not set!";
                OT_FAIL;
            }

#ifdef _WIN32
            OTString strTemp;
            if (OTPaths::Win_GetInstallFolderFromRegistry(strTemp)) {
                strDefaultPrefixPath = strTemp;
            }
#endif

            if (!ToReal(strDefaultPrefixPath, strDefaultPrefixPath)) {
                OT_FAIL;
            }
            if (!FixPath(strDefaultPrefixPath, strDefaultPrefixPath, true)) {
                OT_FAIL;
            }
        }

        OTString strLocalPrefixPath = "";
        bool bPrefixPathOverride = false;

        {
            // now check the configuration to see what values we have:
            OTString strConfigPath = "";

            bool bIsNew = false;
            OTString strPrefixPathOverride("prefix_path_override");

            if (!config.CheckSet_str("paths", "prefix_path",
                                     strDefaultPrefixPath, strConfigPath,
                                     bIsNew)) {
                return false;
            }
            if (!config.CheckSet_bool(
                    "paths", strPrefixPathOverride, false, bPrefixPathOverride,
                    bIsNew, "; This will force the prefix not to change")) {
                return false;
            }

            // if the config dosn't have a prefix path set. Lets set the
            // default.
            // if a prefix path was passed in, we will override with that later.
            if (!strConfigPath.Exists() || (3 > strConfigPath.GetLength())) {
                otErr << __FUNCTION__ << ": Error: Bad "
                      << "prefix_path"
                      << " in config, will reset!";

                strConfigPath = strDefaultPrefixPath; // set
                bPrefixPathOverride = false;

                // lets set the default path, and reset override
                bool bNewOrUpdate = false;
                if (!config.Set_str("paths", "prefix_path",
                                    strDefaultPrefixPath, bNewOrUpdate)) {
                    return false;
                }
                if (!config.Set_bool("paths", strPrefixPathOverride, false,
                                     bNewOrUpdate)) {
                    return false;
                }
            }

            strLocalPrefixPath = strConfigPath;
        }

        {
            if (!bPrefixPathOverride) {
                bool bUpdate = false;

                // default
                if (!strLocalPrefixPath.Compare(strDefaultPrefixPath)) {
                    strLocalPrefixPath = strDefaultPrefixPath;
                    bUpdate = true;
                }

                // passed in
                if (strPrefixFolder.Exists() &&
                    (3 < strPrefixFolder.GetLength())) {
                    // a prefix folder was passed in... lets use it, and update
                    // the config if the override isn't set
                    OTString strTmp = strPrefixFolder;

                    if (!ToReal(strTmp, strTmp)) {
                        OT_FAIL;
                    }

                    if (!FixPath(strTmp, strTmp, true)) {
                        OT_FAIL;
                    }

                    if (!strLocalPrefixPath.Compare(strTmp)) {
                        strLocalPrefixPath = strTmp;
                        bUpdate = true;
                    }
                }

                // we need to update the path in the config
                if (bUpdate) {
                    bool bNewOrUpdate = false;
                    if (!config.Set_str("paths", "prefix_path",
                                        strLocalPrefixPath, bNewOrUpdate)) {
                        return false;
                    }
                }
            }
        }

        {
            if (!strLocalPrefixPath.Exists()) {
                OT_FAIL;
            }

            if (!ToReal(strLocalPrefixPath, strLocalPrefixPath)) {
                OT_FAIL;
            }
            if (!FixPath(strLocalPrefixPath, strLocalPrefixPath, true)) {
                OT_FAIL;
            }
            s_strPrefixFolder = strLocalPrefixPath;
        }
    }

    if (!bPreLoaded) {
        if (!config.Save()) {
            OT_FAIL;
        }
        config.Reset();
    }
    return true;
}

bool opentxs::OTPaths::LoadSetScriptsFolder ( OTSettings &  config = s_settings, const OTString &  strScriptsFolder = "", const bool &  bIsRelative = true  )

static

Definition at line 504 of file OTPaths.cpp.

{
    const bool bPreLoaded(config.IsLoaded());

    if (!bPreLoaded) {
        config.Reset();
        if (!config.Load()) {
            OT_FAIL;
        }
    }

    OTString strRelativeKey = "";
    strRelativeKey.Format("%s%s", "scripts", OT_CONFIG_ISRELATIVE);

    // local vairables.
    bool bConfigIsRelative = false;
    OTString strConfigFolder = "";

    // lets first check what we have in the configuration:
    {
        bool bKeyIsNew = false;

        if (!config.CheckSet_bool("paths", strRelativeKey, true,
                                  bConfigIsRelative, bKeyIsNew)) {
            return false;
        }
        if (!config.CheckSet_str("paths", "scripts", OT_SCRIPTS_DIR,
                                 strConfigFolder, bKeyIsNew)) {
            return false;
        }
    }

    // lets first test if there was a folder passed in

    if ((strScriptsFolder.Exists()) && (3 < strScriptsFolder.GetLength())) {

        // we have a folder passed in, lets now check if we need to update
        // anything:

        if (bConfigIsRelative != bIsRelative) {

            bConfigIsRelative = bIsRelative;
            bool bNewOrUpdated = false;

            if (!config.Set_bool("paths", strRelativeKey, bConfigIsRelative,
                                 bNewOrUpdated)) {
                return false;
            }
        }

        if (!strConfigFolder.Compare(strScriptsFolder)) {

            strConfigFolder = strScriptsFolder; // update folder
            bool bNewOrUpdated = false;

            if (!config.Set_str("paths", "scripts", strConfigFolder,
                                bNewOrUpdated)) {
                return false;
            }
        }
    }

    if (bConfigIsRelative) {
        if (!FixPath(strConfigFolder, strConfigFolder, true)) {
            OT_FAIL;
        }

        OTString strPrefixScriptPath = "";
        AppendFolder(strPrefixScriptPath, PrefixFolder(), strConfigFolder);

        OTString strAppBinaryScriptPath = "";

        // if the AppBinaryFolder is set, we will attempt to use this script
        // path instead.
        // however if the directory dosn't exist, we will default back to
        // appending to the prefix.

        // TODO:  Make the prefix path set to AppBinaryFolder. (da2ce7)

        if (AppBinaryFolder().Exists()) {
            AppendFolder(strAppBinaryScriptPath, AppBinaryFolder(),
                         strConfigFolder);
            if (!OTPaths::FolderExists(strAppBinaryScriptPath)) {
                otOut << __FUNCTION__
                      << ": Warning: Cannot Find: " << strAppBinaryScriptPath
                      << ", using default!";
                strAppBinaryScriptPath = ""; // don't have anything here.
            }
        }

        s_strScriptsFolder = strAppBinaryScriptPath.Exists()
                                 ? strAppBinaryScriptPath
                                 : strPrefixScriptPath;

        if (!s_strScriptsFolder.Exists()) OT_FAIL;

    }
    else {
        if (!ToReal(strConfigFolder, strConfigFolder)) {
            OT_FAIL;
        }

        if (!FixPath(strConfigFolder, strConfigFolder, true)) {
            OT_FAIL;
        }
        s_strScriptsFolder = strConfigFolder; // set
    }

    if (!bPreLoaded) {
        if (!config.Save()) {
            OT_FAIL;
        }
        config.Reset();
    }
    return true; // success
}

bool opentxs::OTPaths::PathExists ( const OTString &  strPath )

static

Definition at line 802 of file OTPaths.cpp.

{
    if (!strPath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strPath"
              << " passed in!\n";
        OT_FAIL;
    }

    // remove trailing backslash for stat
    std::string l_strPath(strPath.Get());
    l_strPath = (OTString::replace_chars(l_strPath, "\\", '/')); // all \ to /

    // std::string l_strPath_stat = l_strPath;
    std::string l_strPath_stat("");

    // remove last / if it exists (for l_strPath_stat)
    if ('/' == *l_strPath.rbegin())
        l_strPath_stat = l_strPath.substr(0, l_strPath.size() - 1);
    else
        l_strPath_stat = l_strPath;

    struct stat st;
    memset(&st, 0, sizeof(st));

    if (0 ==
        stat(l_strPath_stat.c_str(), &st)) // good we have at-least on a node
    {
        if ('/' != *l_strPath.rbegin()) {
            int64_t temp_l = 0;
            return FileExists(strPath, temp_l);
        }
        else {
            return FolderExists(strPath);
        }
    }
    return false;
}

const OTString & opentxs::OTPaths::PrefixFolder ( )

static

Definition at line 302 of file OTPaths.cpp.

{
    if (s_strPrefixFolder.Exists())
        return s_strPrefixFolder; // got it, lets return it.

    // lets load from the statndard config, or create the entry.
    if (LoadSetPrefixFolder())
        return s_strPrefixFolder;
    else {
        OT_FAIL;
    }
}

bool opentxs::OTPaths::RelativeToCanonical ( OTString &  out_strCanonicalPath, const OTString &  strBasePath, const OTString &  strRelativePath  )

static

Definition at line 1280 of file OTPaths.cpp.

{
    if (!strBasePath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strBasePath"
              << " passed in!\n";
        OT_FAIL;
    }
    if (!strRelativePath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strRelativePath"
              << " passed in!\n";
        OT_FAIL;
    }

    OTString l_strBasePath_fix("");
    if (!FixPath(strBasePath, l_strBasePath_fix, true)) return false;

    if (strRelativePath.Compare(".")) {
        out_strCanonicalPath = strBasePath;
        return true;
    } // if ".", return base path.

    std::string l_strBasePath(l_strBasePath_fix.Get()),
        l_strRelativePath(strRelativePath.Get());

    l_strBasePath.append(l_strRelativePath);

    OTString l_strPath(l_strBasePath), l_strCanonicalPath("");

    if (!ToReal(l_strPath, l_strCanonicalPath)) return false;

    out_strCanonicalPath = l_strCanonicalPath;

    return true;
}

const OTString & opentxs::OTPaths::ScriptsFolder ( )

static

Definition at line 315 of file OTPaths.cpp.

{
    if (s_strScriptsFolder.Exists())
        return s_strScriptsFolder; // got it, lets return it.

    // load it from config (if we already have it set in the config).
    if (LoadSetScriptsFolder())
        return s_strScriptsFolder;
    else {
        OT_FAIL;
    }
}

bool opentxs::OTPaths::Set ( OTSettings &  config, const OTString &  strSection, const OTString &  strKey, const OTString &  strValue, const bool &  bIsRelative, bool &  out_bIsNewOrUpdated, const OTString &  strComment = ""  )

static

Definition at line 699 of file OTPaths.cpp.

{
    if (!strSection.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strSection"
              << " passed in!\n";
        OT_FAIL;
    }
    if (!strKey.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strKey"
              << " passed in!\n";
        OT_FAIL;
    }

    out_bIsNewOrUpdated = false;

    const bool bPreLoaded(config.IsLoaded());

    if (!bPreLoaded) // we only need to load, if not already loaded.
    {
        config.Reset();
        if (!config.Load()) {
            OT_FAIL;
        }
    }

    bool bBoolIsNew(false);
    OTString strRelativeKey("");

    strRelativeKey.Format("%s%s", strKey.Get(), OT_CONFIG_ISRELATIVE);

    if (config.Set_bool(strSection, strRelativeKey, bIsRelative, bBoolIsNew,
                        strComment)) {
        bool bStringIsNew = false;
        if (config.Set_str(strSection, strKey, strValue, bStringIsNew)) {
            if (bBoolIsNew && bStringIsNew) // using existing key
            {
                out_bIsNewOrUpdated = true;
            }

            if (!bPreLoaded) {
                if (!config.Save()) {
                    OT_FAIL;
                }
                config.Reset();
            }

            return true;
        }
    }

    // if we get here, there has been a error!
    OT_FAIL;
}

void opentxs::OTPaths::SetAppBinaryFolder ( OTString  strLocation )

static

Definition at line 235 of file OTPaths.cpp.

{
    OTPaths::s_strAppBinaryFolder = strLocation;
}

void opentxs::OTPaths::SetHomeFolder ( OTString  strLocation )

static

Definition at line 245 of file OTPaths.cpp.

{
    OTPaths::s_strHomeFolder = strLocation;

#ifdef ANDROID
    OTPaths::s_settings.SetConfigFilePath(GlobalConfigFile());
#endif
}

bool opentxs::OTPaths::ToReal ( const OTString &  strExactPath, OTString &  out_strCanonicalPath  )

static

Definition at line 985 of file OTPaths.cpp.

{
    if (!strExactPath.Exists()) {
        otErr << __FUNCTION__ << ": Null: "
              << "strExactPath"
              << " passed in!\n";
        OT_FAIL;
    }

#ifdef _WIN32
#ifdef _UNICODE

    const char* szPath = strExactPath.Get();
    size_t newsize = strlen(szPath) + 1;
    wchar_t* wzPath = new wchar_t[newsize];

    size_t convertedChars = 0;
    mbstowcs_s(&convertedChars, wzPath, newsize, szPath, 4096);

    wchar_t szBuf[4096] = L"";

    if (GetFullPathName(wzPath, 4096, szBuf, nullptr)) {
        out_strCanonicalPath.Set(utf8util::UTF8FromUTF16(szBuf));
        return true;
    }
    else {
        out_strCanonicalPath.Set("");
        return false;
    }

#else
    char_t szBuf[4096] = "";
    char_t const* szPath = strRealPath.Get();

    if (GetFullPathName(szPath, 4096, szBuf, nullptr)) {
        out_strCanonicalPath.Set(szBuf);
        return true;
    }
    else {
        out_strCanonicalPath.Set("");
        return false;
    }

#endif
#else

    char* actualpath = realpath(strExactPath.Get(), NULL);
    if (actualpath == NULL) {

        if (errno == ENOTDIR) {
            otWarn << "Input value to RealPath is not a directory: (Realpath: "
                      "skipping)\n";
            out_strCanonicalPath.Set(strExactPath);
            return true;
        }

        if (errno == ENOENT) {
            otWarn << "File doesn't exist: (Realpath: skipping)\n";
            out_strCanonicalPath.Set(strExactPath);
            return true;
        }

        OT_ASSERT_MSG((errno != EACCES), "Error (Realpath: EACCES): Unable to "
                                         "build RealPath: access denied");
        OT_ASSERT_MSG(
            (errno != EINVAL),
            "Error (RealPath: EINVAL): Input value into RealPath was nullptr");
        OT_ASSERT_MSG(
            (errno != ELOOP),
            "Error (RealPath: ELOOP): Resloving links resulted in a loop.");
        OT_ASSERT_MSG((errno != ENAMETOOLONG),
                      "Error (RealPath: ENAMETOOLONG): Name too int64_t.");
        OT_ASSERT_MSG((errno != ERANGE), "Error (RealPath: ERANGE): Resulting "
                                         "path is too int64_t for the buffer");
        OT_ASSERT_MSG((errno != EIO),
                      "Error (RealPath: EIO): Unable to access path.");

        OT_ASSERT_MSG(
            (false),
            "Error (RealPath: OTHER): Something bad Happend with 'realpath'.");
    }
    out_strCanonicalPath.Set(actualpath);
    free(actualpath);
    return true;
#endif
}

---

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

• /usr/local/src/opentxs/include/opentxs/core/util/OTPaths.hpp
• /usr/local/src/opentxs/src/core/util/OTPaths.cpp