pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Refactored Linux platform initialization directories

Browse source 
Signed-off-by: Alexander Borsuk <me@alex.bio>
This commit is contained in:
Alexander Borsuk 2022-02-27 11:37:49 +01:00 • committed by Viktor Govako
parent fc7e44033f
commit b591f17f1e
1 changed files with 82 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

164
platform/platform_linux.cpp
View file

@ -11,136 +11,136 @@
#include "base/scope_guard.hpp"
#include <algorithm>
#include <functional>
#include <functional> // bind
#include <initializer_list>
#include <optional>
#include <string>
#include <stdlib.h>
#include <unistd.h>
#include <string.h> // strrchr
#include <unistd.h> // access, readlink
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <linux/limits.h> // PATH_MAX
#include <netinet/in.h>
using namespace std;
namespace
{
// Web service ip to check internet connection. Now it's a mail.ru ip.
char constexpr kSomeWorkingWebServer[] = "217.69.139.202";
// Web service ip to check internet connection. Now it's a GitHub.com IP.
char constexpr kSomeWorkingWebServer[] = "140.82.121.4";
// Returns directory where binary resides, including slash at the end.
bool GetBinaryDir(string & outPath)
std::optional<std::string> GetExecutableDir()
{
char path[4096] = {};
char path[PATH_MAX] = {};
if (::readlink("/proc/self/exe", path, ARRAY_SIZE(path)) <= 0)
return false;
outPath = path;
outPath.erase(outPath.find_last_of('/') + 1);
return true;
return {};
*(strrchr(path, '/') + 1) = '\0';
return path;
}
// Returns true if EULA file exists in directory.
bool IsWelcomeExist(string const & directory)
// Returns true if EULA file exists in a directory.
bool IsWelcomeExist(std::string const & dir)
{
return Platform::IsFileExistsByFullPath(base::JoinPath(directory, "welcome.html"));
return Platform::IsFileExistsByFullPath(base::JoinPath(dir, "welcome.html"));
}
bool GetHomeDir(string & outPath)
// Returns string value of an environment variable.
std::optional<std::string> GetEnv(char const * var)
{
char const * homePath = ::getenv("HOME");
if (homePath == nullptr)
return false;
outPath = homePath;
return true;
char const * value = ::getenv(var);
if (value == nullptr)
return {};
return value;
}
bool IsDirWritable(std::string const & dir)
{
return ::access(dir.c_str(), W_OK) == 0;
}
} // namespace
namespace platform
{
unique_ptr<Socket> CreateSocket()
std::unique_ptr<Socket> CreateSocket()
{
return unique_ptr<Socket>();
return std::unique_ptr<Socket>();
}
} // namespace platform
Platform::Platform()
{
// Init directories.
string execPath, homePath;
CHECK(GetBinaryDir(execPath), ("Can't retrieve path to executable"));
CHECK(GetHomeDir(homePath), ("Can't retrieve home path"));
using base::JoinPath;
// Current executable's path with a trailing slash.
auto const execDir = GetExecutableDir();
CHECK(execDir, ("Can't retrieve the path to executable"));
// Home directory without a trailing slash.
auto const homeDir = GetEnv("HOME");
CHECK(homeDir, ("Can't retrieve home directory"));
m_settingsDir = base::JoinPath(homePath, ".config", "OMaps");
// ~/.config/OMaps/
m_settingsDir = JoinPath(*homeDir, ".config", "OMaps");
if (!IsFileExistsByFullPath(JoinPath(m_settingsDir, SETTINGS_FILE_NAME)) && !MkDirRecursively(m_settingsDir))
MYTHROW(FileSystemException, ("Can't create directory", m_settingsDir));
m_settingsDir += '/';
if (!IsFileExistsByFullPath(base::JoinPath(m_settingsDir, SETTINGS_FILE_NAME)))
{
if (!MkDirRecursively(m_settingsDir))
MYTHROW(FileSystemException, ("Can't create directory", m_settingsDir));
}
// Override dirs from the env.
if (auto const dir = GetEnv("MWM_WRITABLE_DIR"))
m_writableDir = *dir;
char const * resDir = ::getenv("MWM_RESOURCES_DIR");
char const * writableDir = ::getenv("MWM_WRITABLE_DIR");
if (resDir && writableDir)
{
m_resourcesDir = resDir;
m_writableDir = writableDir;
}
else if (resDir)
{
m_resourcesDir = resDir;
m_writableDir = base::JoinPath(homePath, ".local", "share", "OMaps");
if (!MkDirRecursively(m_writableDir))
MYTHROW(FileSystemException, ("Can't create directory:", m_writableDir));
}
if (auto const dir = GetEnv("MWM_RESOURCES_DIR"))
m_resourcesDir = *dir;
else
{
initializer_list<string> dirs = {
"./data", // check symlink in the current folder
"../data", // check if we are in the 'build' folder inside repo
base::JoinPath(execPath, "..", "..", "data"), // check symlink from bundle?
base::JoinPath(execPath, "..", "share"), // installed version with packages
base::JoinPath(execPath, "..", "OMaps") // installed version without packages
{ // Guess the existing resources directory.
std::string const dirsToScan[] = {
"./data", // symlink in the current folder
"../data", // 'build' folder inside the repo
JoinPath(*execDir, "..", "organicmaps", "data"), // build-omim-{debug,release}
JoinPath(*execDir, "..", "share"), // installed version with packages
JoinPath(*execDir, "..", "OMaps"), // installed version without packages
};
for (auto const & dir : dirs)
for (auto const & dir : dirsToScan)
{
if (IsWelcomeExist(dir))
{
m_resourcesDir = dir;
m_writableDir = (writableDir != nullptr) ? writableDir : m_resourcesDir;
if (m_writableDir.empty() && IsDirWritable(dir))
m_writableDir = m_resourcesDir;
break;
}
}
}
// Actually, m_resourcesDir and m_writableDir maybe empty here and
// will be set later by tests infrustructure.
m_resourcesDir += '/';
m_settingsDir += '/';
m_writableDir += '/';
char const * tmpDir = ::getenv("TMPDIR");
if (tmpDir)
// Use ~/.local/share/OMaps if resources directory was not writable.
if (!m_resourcesDir.empty() && m_writableDir.empty())
{
m_tmpDir = tmpDir;
m_writableDir = JoinPath(*homeDir, ".local", "share", "OMaps");
if (!MkDirRecursively(m_writableDir))
MYTHROW(FileSystemException, ("Can't create writable directory:", m_writableDir));
}
else
{
/// @todo Don't have other good ideas here ..
m_tmpDir = base::JoinPath(homePath, "tmp");
if (!MkDirRecursively(m_tmpDir))
MYTHROW(FileSystemException, ("Can't create tmp directory:", m_tmpDir));
}
m_tmpDir += '/';
// Here one or both m_resourcesDir and m_writableDir still may be empty.
// Tests or binary may initialize them later.
using base::AddSlashIfNeeded;
if (!m_writableDir.empty())
m_writableDir = AddSlashIfNeeded(m_writableDir);
if (!m_resourcesDir.empty())
m_resourcesDir = AddSlashIfNeeded(m_resourcesDir);
m_guiThread = make_unique<platform::GuiThread>();
// Select directory for temporary files.
for (auto const & dir : { GetEnv("TMPDIR"), GetEnv("TMP"), GetEnv("TEMP"), {"/tmp"}})
{
if (dir && IsFileExistsByFullPath(*dir) && IsDirWritable(*dir))
{
m_tmpDir = AddSlashIfNeeded(*dir);
break;
}
}
m_guiThread = std::make_unique<platform::GuiThread>();
LOG(LDEBUG, ("Resources directory:", m_resourcesDir));
LOG(LDEBUG, ("Writable directory:", m_writableDir));
@ -148,12 +148,12 @@ Platform::Platform()
LOG(LDEBUG, ("Settings directory:", m_settingsDir));
}
string Platform::DeviceName() const
std::string Platform::DeviceName() const
{
return OMIM_OS_NAME;
}
string Platform::DeviceModel() const
std::string Platform::DeviceModel() const
{
return {};
}
@ -161,7 +161,7 @@ string Platform::DeviceModel() const
Platform::EConnectionType Platform::ConnectionStatus()
{
int socketFd = socket(AF_INET, SOCK_STREAM, 0);
SCOPE_GUARD(closeSocket, bind(&close, socketFd));
SCOPE_GUARD(closeSocket, std::bind(&close, socketFd));
if (socketFd < 0)
return EConnectionType::CONNECTION_NONE;
@ -225,7 +225,7 @@ void Platform::GetSystemFontNames(FilesList & res) const
"AbyssinicaSIL-R.ttf",
};
string systemFontsPath[] = {
std::string const systemFontsPath[] = {
"/usr/share/fonts/truetype/roboto/",
"/usr/share/fonts/truetype/droid/",
"/usr/share/fonts/truetype/dejavu/",
@ -244,7 +244,7 @@ void Platform::GetSystemFontNames(FilesList & res) const
{
for (auto sysPath : systemFontsPath)
{
string path = sysPath + font;
std::string path = sysPath + font;
if (IsFileExistsByFullPath(path))
{
LOG(LINFO, ("Found usable system font", path));