mirror of https://github.com/PurpleI2P/i2pd.git
I2P: End-to-End encrypted and anonymous Internet
https://i2pd.website/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
356 lines
8.6 KiB
356 lines
8.6 KiB
/* |
|
* Copyright (c) 2013-2024, The PurpleI2P Project |
|
* |
|
* This file is part of Purple i2pd project and licensed under BSD3 |
|
* |
|
* See full license text in LICENSE file at top of project tree |
|
*/ |
|
|
|
#include <algorithm> |
|
|
|
#if defined(MAC_OSX) |
|
#include <boost/system/system_error.hpp> |
|
#include <TargetConditionals.h> |
|
#endif |
|
|
|
#ifdef _WIN32 |
|
#include <shlobj.h> |
|
#include <windows.h> |
|
#include <codecvt> |
|
#endif |
|
|
|
#include "Base.h" |
|
#include "FS.h" |
|
#include "Log.h" |
|
#include "Garlic.h" |
|
|
|
#if STD_FILESYSTEM |
|
#include <filesystem> |
|
namespace fs_lib = std::filesystem; |
|
#else |
|
#include <boost/filesystem.hpp> |
|
namespace fs_lib = boost::filesystem; |
|
#endif |
|
|
|
namespace i2p { |
|
namespace fs { |
|
std::string appName = "i2pd"; |
|
std::string dataDir = ""; |
|
std::string certsDir = ""; |
|
#ifdef _WIN32 |
|
std::string dirSep = "\\"; |
|
#else |
|
std::string dirSep = "/"; |
|
#endif |
|
|
|
const std::string & GetAppName () { |
|
return appName; |
|
} |
|
|
|
void SetAppName (const std::string& name) { |
|
appName = name; |
|
} |
|
|
|
const std::string & GetDataDir () { |
|
return dataDir; |
|
} |
|
|
|
const std::string & GetCertsDir () { |
|
return certsDir; |
|
} |
|
|
|
const std::string GetUTF8DataDir () { |
|
#ifdef _WIN32 |
|
#if ((BOOST_VERSION >= 108500) || STD_FILESYSTEM) |
|
fs_lib::path path (dataDir); |
|
#else |
|
fs_lib::wpath path (dataDir); |
|
#endif |
|
auto loc = fs_lib::path::imbue(std::locale( std::locale(), new std::codecvt_utf8_utf16<wchar_t>() ) ); // convert path to UTF-8 |
|
auto dataDirUTF8 = path.string(); |
|
fs_lib::path::imbue(loc); // Return locale settings back |
|
return dataDirUTF8; |
|
#else |
|
return dataDir; // linux, osx, android uses UTF-8 by default |
|
#endif |
|
} |
|
|
|
void DetectDataDir(const std::string & cmdline_param, bool isService) { |
|
// with 'datadir' option |
|
if (cmdline_param != "") { |
|
dataDir = cmdline_param; |
|
return; |
|
} |
|
|
|
#if !defined(MAC_OSX) && !defined(ANDROID) |
|
// with 'service' option |
|
if (isService) { |
|
#ifdef _WIN32 |
|
wchar_t commonAppData[MAX_PATH]; |
|
if(SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA, NULL, 0, commonAppData) != S_OK) |
|
{ |
|
#ifdef WIN32_APP |
|
MessageBox(NULL, TEXT("Unable to get common AppData path!"), TEXT("I2Pd: error"), MB_ICONERROR | MB_OK); |
|
#else |
|
fprintf(stderr, "Error: Unable to get common AppData path!"); |
|
#endif |
|
exit(1); |
|
} |
|
else |
|
{ |
|
#if ((BOOST_VERSION >= 108500) || STD_FILESYSTEM) |
|
dataDir = fs_lib::path(commonAppData).string() + "\\" + appName; |
|
#else |
|
dataDir = fs_lib::wpath(commonAppData).string() + "\\" + appName; |
|
#endif |
|
} |
|
#else |
|
dataDir = "/var/lib/" + appName; |
|
#endif |
|
return; |
|
} |
|
#endif |
|
|
|
// detect directory as usual |
|
#ifdef _WIN32 |
|
wchar_t localAppData[MAX_PATH]; |
|
|
|
// check executable directory first |
|
if(!GetModuleFileNameW(NULL, localAppData, MAX_PATH)) |
|
{ |
|
#ifdef WIN32_APP |
|
MessageBox(NULL, TEXT("Unable to get application path!"), TEXT("I2Pd: error"), MB_ICONERROR | MB_OK); |
|
#else |
|
fprintf(stderr, "Error: Unable to get application path!"); |
|
#endif |
|
exit(1); |
|
} |
|
else |
|
{ |
|
#if ((BOOST_VERSION >= 108500) || STD_FILESYSTEM) |
|
auto execPath = fs_lib::path(localAppData).parent_path(); |
|
#else |
|
auto execPath = fs_lib::wpath(localAppData).parent_path(); |
|
#endif |
|
|
|
// if config file exists in .exe's folder use it |
|
if(fs_lib::exists(execPath/"i2pd.conf")) // TODO: magic string |
|
{ |
|
dataDir = execPath.string (); |
|
} else // otherwise %appdata% |
|
{ |
|
if(SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, 0, localAppData) != S_OK) |
|
{ |
|
#ifdef WIN32_APP |
|
MessageBox(NULL, TEXT("Unable to get AppData path!"), TEXT("I2Pd: error"), MB_ICONERROR | MB_OK); |
|
#else |
|
fprintf(stderr, "Error: Unable to get AppData path!"); |
|
#endif |
|
exit(1); |
|
} |
|
else |
|
{ |
|
#if ((BOOST_VERSION >= 108500) || STD_FILESYSTEM) |
|
dataDir = fs_lib::path(localAppData).string() + "\\" + appName; |
|
#else |
|
dataDir = fs_lib::wpath(localAppData).string() + "\\" + appName; |
|
#endif |
|
} |
|
} |
|
} |
|
return; |
|
#elif defined(MAC_OSX) |
|
char *home = getenv("HOME"); |
|
dataDir = (home != NULL && strlen(home) > 0) ? home : ""; |
|
dataDir += "/Library/Application Support/" + appName; |
|
return; |
|
#elif defined(__HAIKU__) |
|
char *home = getenv("HOME"); |
|
if (home != NULL && strlen(home) > 0) { |
|
dataDir = std::string(home) + "/config/settings/" + appName; |
|
} else { |
|
dataDir = "/tmp/" + appName; |
|
} |
|
return; |
|
#else /* other unix */ |
|
#if defined(ANDROID) |
|
const char * ext = getenv("EXTERNAL_STORAGE"); |
|
if (!ext) ext = "/sdcard"; |
|
if (fs_lib::exists(ext)) |
|
{ |
|
dataDir = std::string (ext) + "/" + appName; |
|
return; |
|
} |
|
#endif // ANDROID |
|
// use /home/user/.i2pd or /tmp/i2pd |
|
char *home = getenv("HOME"); |
|
if (home != NULL && strlen(home) > 0) { |
|
dataDir = std::string(home) + "/." + appName; |
|
} else { |
|
dataDir = "/tmp/" + appName; |
|
} |
|
return; |
|
#endif |
|
} |
|
|
|
void SetCertsDir(const std::string & cmdline_certsdir) { |
|
if (cmdline_certsdir != "") |
|
{ |
|
if (cmdline_certsdir[cmdline_certsdir.length()-1] == '/') |
|
certsDir = cmdline_certsdir.substr(0, cmdline_certsdir.size()-1); // strip trailing slash |
|
else |
|
certsDir = cmdline_certsdir; |
|
} |
|
else |
|
{ |
|
certsDir = i2p::fs::DataDirPath("certificates"); |
|
} |
|
return; |
|
} |
|
|
|
bool Init() { |
|
if (!fs_lib::exists(dataDir)) |
|
fs_lib::create_directory(dataDir); |
|
|
|
std::string destinations = DataDirPath("destinations"); |
|
if (!fs_lib::exists(destinations)) |
|
fs_lib::create_directory(destinations); |
|
|
|
std::string tags = DataDirPath("tags"); |
|
if (!fs_lib::exists(tags)) |
|
fs_lib::create_directory(tags); |
|
else |
|
i2p::garlic::CleanUpTagsFiles (); |
|
|
|
return true; |
|
} |
|
|
|
bool ReadDir(const std::string & path, std::vector<std::string> & files) { |
|
if (!fs_lib::exists(path)) |
|
return false; |
|
fs_lib::directory_iterator it(path); |
|
fs_lib::directory_iterator end; |
|
|
|
for ( ; it != end; it++) { |
|
if (!fs_lib::is_regular_file(it->status())) |
|
continue; |
|
files.push_back(it->path().string()); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
bool Exists(const std::string & path) { |
|
return fs_lib::exists(path); |
|
} |
|
|
|
uint32_t GetLastUpdateTime (const std::string & path) |
|
{ |
|
if (!fs_lib::exists(path)) |
|
return 0; |
|
#if STD_FILESYSTEM |
|
std::error_code ec; |
|
auto t = std::filesystem::last_write_time (path, ec); |
|
if (ec) return 0; |
|
#if __cplusplus >= 202002L // C++ 20 or higher |
|
const auto sctp = std::chrono::clock_cast<std::chrono::system_clock>(t); |
|
#else |
|
const auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>( |
|
t - decltype(t)::clock::now() + std::chrono::system_clock::now()); |
|
#endif |
|
return std::chrono::system_clock::to_time_t(sctp); |
|
#else |
|
boost::system::error_code ec; |
|
auto t = boost::filesystem::last_write_time (path, ec); |
|
return ec ? 0 : t; |
|
#endif |
|
} |
|
|
|
bool Remove(const std::string & path) { |
|
if (!fs_lib::exists(path)) |
|
return false; |
|
return fs_lib::remove(path); |
|
} |
|
|
|
bool CreateDirectory (const std::string& path) |
|
{ |
|
if (fs_lib::exists(path) && fs_lib::is_directory (fs_lib::status (path))) |
|
return true; |
|
return fs_lib::create_directory(path); |
|
} |
|
|
|
void HashedStorage::SetPlace(const std::string &path) { |
|
root = path + i2p::fs::dirSep + name; |
|
} |
|
|
|
bool HashedStorage::Init(const char * chars, size_t count) { |
|
if (!fs_lib::exists(root)) { |
|
fs_lib::create_directories(root); |
|
} |
|
|
|
for (size_t i = 0; i < count; i++) { |
|
auto p = root + i2p::fs::dirSep + prefix1 + chars[i]; |
|
if (fs_lib::exists(p)) |
|
continue; |
|
#if TARGET_OS_SIMULATOR |
|
// ios simulator fs says it is case sensitive, but it is not |
|
boost::system::error_code ec; |
|
if (fs_lib::create_directory(p, ec)) |
|
continue; |
|
switch (ec.value()) { |
|
case boost::system::errc::file_exists: |
|
case boost::system::errc::success: |
|
continue; |
|
default: |
|
throw boost::system::system_error( ec, __func__ ); |
|
} |
|
#else |
|
if (fs_lib::create_directory(p)) |
|
continue; /* ^ throws exception on failure */ |
|
#endif |
|
return false; |
|
} |
|
return true; |
|
} |
|
|
|
std::string HashedStorage::Path(const std::string & ident) const { |
|
std::string safe_ident = ident; |
|
std::replace(safe_ident.begin(), safe_ident.end(), '/', '-'); |
|
std::replace(safe_ident.begin(), safe_ident.end(), '\\', '-'); |
|
|
|
std::stringstream t(""); |
|
t << this->root << i2p::fs::dirSep; |
|
t << prefix1 << safe_ident[0] << i2p::fs::dirSep; |
|
t << prefix2 << safe_ident << "." << suffix; |
|
|
|
return t.str(); |
|
} |
|
|
|
void HashedStorage::Remove(const std::string & ident) { |
|
std::string path = Path(ident); |
|
if (!fs_lib::exists(path)) |
|
return; |
|
fs_lib::remove(path); |
|
} |
|
|
|
void HashedStorage::Traverse(std::vector<std::string> & files) { |
|
Iterate([&files] (const std::string & fname) { |
|
files.push_back(fname); |
|
}); |
|
} |
|
|
|
void HashedStorage::Iterate(FilenameVisitor v) |
|
{ |
|
fs_lib::path p(root); |
|
fs_lib::recursive_directory_iterator it(p); |
|
fs_lib::recursive_directory_iterator end; |
|
|
|
for ( ; it != end; it++) { |
|
if (!fs_lib::is_regular_file( it->status() )) |
|
continue; |
|
const std::string & t = it->path().string(); |
|
v(t); |
|
} |
|
} |
|
} // fs |
|
} // i2p
|
|
|