mirror of https://github.com/AxioDL/metaforce.git
944 lines
28 KiB
C++
944 lines
28 KiB
C++
#include "hecl/hecl.hpp"
|
|
#include <thread>
|
|
#include <mutex>
|
|
#include <unordered_map>
|
|
|
|
#ifdef WIN32
|
|
#include <windows.h>
|
|
#ifndef _WIN32_IE
|
|
#define _WIN32_IE 0x0400
|
|
#endif
|
|
#include <shlobj.h>
|
|
#endif
|
|
|
|
#ifdef __APPLE__
|
|
#include <Carbon/Carbon.h>
|
|
#endif
|
|
|
|
#ifdef __linux__
|
|
#include <mntent.h>
|
|
#include <sys/wait.h>
|
|
#endif
|
|
|
|
namespace hecl
|
|
{
|
|
unsigned VerbosityLevel = 0;
|
|
bool GuiMode = false;
|
|
logvisor::Module LogModule("hecl");
|
|
static const std::string Illegals {"<>?\"|"};
|
|
|
|
#if __GNUC__
|
|
__attribute__((__format__ (__printf__, 1, 2)))
|
|
#endif
|
|
SystemString SysFormat(const SystemChar* format, ...)
|
|
{
|
|
SystemChar resultBuf[FORMAT_BUF_SZ];
|
|
va_list va;
|
|
va_start(va, format);
|
|
#if HECL_UCS2
|
|
int printSz = vswprintf(resultBuf, FORMAT_BUF_SZ, format, va);
|
|
#else
|
|
int printSz = vsnprintf(resultBuf, FORMAT_BUF_SZ, format, va);
|
|
#endif
|
|
va_end(va);
|
|
return SystemString(resultBuf, printSz);
|
|
}
|
|
|
|
#if __GNUC__
|
|
__attribute__((__format__ (__printf__, 1, 2)))
|
|
#endif
|
|
std::string Format(const char* format, ...)
|
|
{
|
|
char resultBuf[FORMAT_BUF_SZ];
|
|
va_list va;
|
|
va_start(va, format);
|
|
int printSz = vsnprintf(resultBuf, FORMAT_BUF_SZ, format, va);
|
|
va_end(va);
|
|
return std::string(resultBuf, printSz);
|
|
}
|
|
|
|
std::wstring WideFormat(const wchar_t* format, ...)
|
|
{
|
|
wchar_t resultBuf[FORMAT_BUF_SZ];
|
|
va_list va;
|
|
va_start(va, format);
|
|
int printSz = vswprintf(resultBuf, FORMAT_BUF_SZ, format, va);
|
|
va_end(va);
|
|
return std::wstring(resultBuf, printSz);
|
|
}
|
|
|
|
std::u16string Char16Format(const wchar_t* format, ...)
|
|
{
|
|
wchar_t resultBuf[FORMAT_BUF_SZ];
|
|
va_list va;
|
|
va_start(va, format);
|
|
int printSz = vswprintf(resultBuf, FORMAT_BUF_SZ, format, va);
|
|
va_end(va);
|
|
std::u16string res;
|
|
res.reserve(printSz);
|
|
for (size_t i=0 ; i<printSz ; ++i)
|
|
res.push_back(resultBuf[i]);
|
|
return res;
|
|
}
|
|
|
|
void SanitizePath(std::string& path)
|
|
{
|
|
if (path.empty())
|
|
return;
|
|
path.erase(std::remove(path.begin(), path.end(), '\n'), path.end());
|
|
path.erase(std::remove(path.begin(), path.end(), '\r'), path.end());
|
|
std::string::iterator p1 = path.begin();
|
|
bool ic = false;
|
|
std::transform(path.begin(), path.end(), path.begin(), [&](const char a) -> char {
|
|
++p1;
|
|
if (Illegals.find_first_of(a) != std::string::npos)
|
|
{
|
|
ic = false;
|
|
return '_';
|
|
}
|
|
|
|
if (ic)
|
|
{
|
|
ic = false;
|
|
return a;
|
|
}
|
|
if (a == '\\' && (p1 == path.end() || *p1 != '\\'))
|
|
{
|
|
ic = true;
|
|
return '/';
|
|
}
|
|
return a;
|
|
});
|
|
while (path.back() == '/')
|
|
path.pop_back();
|
|
}
|
|
|
|
static const std::wstring WIllegals {L"<>?\"|"};
|
|
|
|
void SanitizePath(std::wstring& path)
|
|
{
|
|
if (path.empty())
|
|
return;
|
|
path.erase(std::remove(path.begin(), path.end(), L'\n'), path.end());
|
|
path.erase(std::remove(path.begin(), path.end(), L'\r'), path.end());
|
|
std::wstring::iterator p1 = path.begin();
|
|
bool ic = false;
|
|
std::transform(path.begin(), path.end(), path.begin(), [&](const wchar_t a) -> wchar_t {
|
|
++p1;
|
|
if (WIllegals.find_first_of(a) != std::wstring::npos)
|
|
{
|
|
ic = false;
|
|
return L'_';
|
|
}
|
|
|
|
if (ic)
|
|
{
|
|
ic = false;
|
|
return a;
|
|
}
|
|
if (a == L'\\' && (p1 == path.end() || *p1 != L'\\'))
|
|
{
|
|
ic = true;
|
|
return L'/';
|
|
}
|
|
return a;
|
|
});
|
|
while (path.back() == L'/')
|
|
path.pop_back();
|
|
}
|
|
|
|
SystemString GetcwdStr()
|
|
{
|
|
/* http://stackoverflow.com/a/2869667 */
|
|
//const size_t ChunkSize=255;
|
|
//const int MaxChunks=10240; // 2550 KiBs of current path are more than enough
|
|
|
|
SystemChar stackBuffer[255]; // Stack buffer for the "normal" case
|
|
if (Getcwd(stackBuffer, 255) != nullptr)
|
|
return SystemString(stackBuffer);
|
|
if (errno != ERANGE)
|
|
{
|
|
// It's not ERANGE, so we don't know how to handle it
|
|
LogModule.report(logvisor::Fatal, "Cannot determine the current path.");
|
|
// Of course you may choose a different error reporting method
|
|
}
|
|
// Ok, the stack buffer isn't long enough; fallback to heap allocation
|
|
for (int chunks=2 ; chunks<10240 ; chunks++)
|
|
{
|
|
// With boost use scoped_ptr; in C++0x, use unique_ptr
|
|
// If you want to be less C++ but more efficient you may want to use realloc
|
|
std::unique_ptr<SystemChar[]> cwd(new SystemChar[255*chunks]);
|
|
if (Getcwd(cwd.get(), 255*chunks) != nullptr)
|
|
return SystemString(cwd.get());
|
|
if (errno != ERANGE)
|
|
{
|
|
// It's not ERANGE, so we don't know how to handle it
|
|
LogModule.report(logvisor::Fatal, "Cannot determine the current path.");
|
|
// Of course you may choose a different error reporting method
|
|
}
|
|
}
|
|
LogModule.report(logvisor::Fatal, "Cannot determine the current path; the path is apparently unreasonably long");
|
|
return SystemString();
|
|
}
|
|
|
|
static std::mutex PathsMutex;
|
|
static std::unordered_map<std::thread::id, ProjectPath> PathsInProgress;
|
|
|
|
bool ResourceLock::InProgress(const ProjectPath& path)
|
|
{
|
|
std::unique_lock<std::mutex> lk(PathsMutex);
|
|
for (const auto& p : PathsInProgress)
|
|
if (p.second == path)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool ResourceLock::SetThreadRes(const ProjectPath& path)
|
|
{
|
|
std::unique_lock<std::mutex> lk(PathsMutex);
|
|
if (PathsInProgress.find(std::this_thread::get_id()) != PathsInProgress.cend())
|
|
LogModule.report(logvisor::Fatal, "multiple resource locks on thread");
|
|
|
|
for (const auto& p : PathsInProgress)
|
|
if (p.second == path)
|
|
return false;
|
|
|
|
PathsInProgress[std::this_thread::get_id()] = path;
|
|
return true;
|
|
}
|
|
|
|
void ResourceLock::ClearThreadRes()
|
|
{
|
|
std::unique_lock<std::mutex> lk(PathsMutex);
|
|
PathsInProgress.erase(std::this_thread::get_id());
|
|
}
|
|
|
|
bool IsPathPNG(const hecl::ProjectPath& path)
|
|
{
|
|
FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _S("rb"));
|
|
if (!fp)
|
|
return false;
|
|
uint32_t buf = 0;
|
|
if (fread(&buf, 1, 4, fp) != 4)
|
|
{
|
|
fclose(fp);
|
|
return false;
|
|
}
|
|
fclose(fp);
|
|
buf = hecl::SBig(buf);
|
|
if (buf == 0x89504e47)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool IsPathBlend(const hecl::ProjectPath& path)
|
|
{
|
|
auto lastCompExt = path.getLastComponentExt();
|
|
if (lastCompExt.empty() || hecl::StrCmp(lastCompExt.data(), _S("blend")))
|
|
return false;
|
|
FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _S("rb"));
|
|
if (!fp)
|
|
return false;
|
|
uint32_t buf = 0;
|
|
if (fread(&buf, 1, 4, fp) != 4)
|
|
{
|
|
fclose(fp);
|
|
return false;
|
|
}
|
|
fclose(fp);
|
|
buf = hecl::SLittle(buf);
|
|
if (buf == 0x4e454c42 || buf == 0x88b1f)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool IsPathYAML(const hecl::ProjectPath& path)
|
|
{
|
|
if (!hecl::StrCmp(path.getLastComponent().data(), _S("!catalog.yaml")))
|
|
return false; /* !catalog.yaml is exempt from general use */
|
|
auto lastCompExt = path.getLastComponentExt();
|
|
if (lastCompExt.empty())
|
|
return false;
|
|
if (!hecl::StrCmp(lastCompExt.data(), _S("yaml")) ||
|
|
!hecl::StrCmp(lastCompExt.data(), _S("yml")))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
hecl::DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode,
|
|
bool sizeSort, bool reverse, bool noHidden)
|
|
{
|
|
hecl::Sstat theStat;
|
|
if (hecl::Stat(path.data(), &theStat) || !S_ISDIR(theStat.st_mode))
|
|
return;
|
|
|
|
#if _WIN32
|
|
hecl::SystemString wc(path);
|
|
wc += _S("/*");
|
|
WIN32_FIND_DATAW d;
|
|
HANDLE dir = FindFirstFileW(wc.c_str(), &d);
|
|
if (dir == INVALID_HANDLE_VALUE)
|
|
return;
|
|
switch (mode)
|
|
{
|
|
case Mode::Native:
|
|
do
|
|
{
|
|
if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S("..")))
|
|
continue;
|
|
if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
|
|
continue;
|
|
hecl::SystemString fp(path);
|
|
fp += _S('/');
|
|
fp += d.cFileName;
|
|
hecl::Sstat st;
|
|
if (hecl::Stat(fp.c_str(), &st))
|
|
continue;
|
|
|
|
size_t sz = 0;
|
|
bool isDir = false;
|
|
if (S_ISDIR(st.st_mode))
|
|
isDir = true;
|
|
else if (S_ISREG(st.st_mode))
|
|
sz = st.st_size;
|
|
else
|
|
continue;
|
|
|
|
m_entries.emplace_back(fp, d.cFileName, sz, isDir);
|
|
} while (FindNextFileW(dir, &d));
|
|
break;
|
|
case Mode::DirsThenFilesSorted:
|
|
case Mode::DirsSorted:
|
|
{
|
|
std::map<hecl::SystemString, Entry, CaseInsensitiveCompare> sort;
|
|
do
|
|
{
|
|
if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S("..")))
|
|
continue;
|
|
if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
|
|
continue;
|
|
hecl::SystemString fp(path);
|
|
fp +=_S('/');
|
|
fp += d.cFileName;
|
|
hecl::Sstat st;
|
|
if (hecl::Stat(fp.c_str(), &st) || !S_ISDIR(st.st_mode))
|
|
continue;
|
|
sort.emplace(std::make_pair(d.cFileName, Entry(std::move(fp), d.cFileName, 0, true)));
|
|
} while (FindNextFileW(dir, &d));
|
|
|
|
if (reverse)
|
|
for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
|
|
m_entries.push_back(std::move(it->second));
|
|
else
|
|
for (auto& e : sort)
|
|
m_entries.push_back(std::move(e.second));
|
|
|
|
if (mode == Mode::DirsSorted)
|
|
break;
|
|
FindClose(dir);
|
|
dir = FindFirstFileW(wc.c_str(), &d);
|
|
}
|
|
case Mode::FilesSorted:
|
|
{
|
|
if (mode == Mode::FilesSorted)
|
|
m_entries.clear();
|
|
|
|
if (sizeSort)
|
|
{
|
|
std::multimap<size_t, Entry> sort;
|
|
do
|
|
{
|
|
if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S("..")))
|
|
continue;
|
|
if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
|
|
continue;
|
|
hecl::SystemString fp(path);
|
|
fp += _S('/');
|
|
fp += d.cFileName;
|
|
hecl::Sstat st;
|
|
if (hecl::Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
|
|
continue;
|
|
sort.emplace(std::make_pair(st.st_size, Entry(std::move(fp), d.cFileName, st.st_size, false)));
|
|
} while (FindNextFileW(dir, &d));
|
|
|
|
if (reverse)
|
|
for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
|
|
m_entries.push_back(std::move(it->second));
|
|
else
|
|
for (auto& e : sort)
|
|
m_entries.push_back(std::move(e.second));
|
|
}
|
|
else
|
|
{
|
|
std::map<hecl::SystemString, Entry, CaseInsensitiveCompare> sort;
|
|
do
|
|
{
|
|
if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S("..")))
|
|
continue;
|
|
if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
|
|
continue;
|
|
hecl::SystemString fp(path);
|
|
fp += _S('/');
|
|
fp += d.cFileName;
|
|
hecl::Sstat st;
|
|
if (hecl::Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
|
|
continue;
|
|
sort.emplace(std::make_pair(d.cFileName, Entry(std::move(fp), d.cFileName, st.st_size, false)));
|
|
} while (FindNextFileW(dir, &d));
|
|
|
|
if (reverse)
|
|
for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
|
|
m_entries.push_back(std::move(it->second));
|
|
else
|
|
for (auto& e : sort)
|
|
m_entries.push_back(std::move(e.second));
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
FindClose(dir);
|
|
|
|
#else
|
|
|
|
DIR* dir = opendir(path.data());
|
|
if (!dir)
|
|
return;
|
|
const dirent* d;
|
|
switch (mode)
|
|
{
|
|
case Mode::Native:
|
|
while ((d = readdir(dir)))
|
|
{
|
|
if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
|
|
continue;
|
|
if (noHidden && d->d_name[0] == '.')
|
|
continue;
|
|
hecl::SystemString fp(path);
|
|
fp += '/';
|
|
fp += d->d_name;
|
|
hecl::Sstat st;
|
|
if (hecl::Stat(fp.c_str(), &st))
|
|
continue;
|
|
|
|
size_t sz = 0;
|
|
bool isDir = false;
|
|
if (S_ISDIR(st.st_mode))
|
|
isDir = true;
|
|
else if (S_ISREG(st.st_mode))
|
|
sz = st.st_size;
|
|
else
|
|
continue;
|
|
|
|
m_entries.push_back(Entry(std::move(fp), d->d_name, sz, isDir));
|
|
}
|
|
break;
|
|
case Mode::DirsThenFilesSorted:
|
|
case Mode::DirsSorted:
|
|
{
|
|
std::map<hecl::SystemString, Entry, CaseInsensitiveCompare> sort;
|
|
while ((d = readdir(dir)))
|
|
{
|
|
if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
|
|
continue;
|
|
if (noHidden && d->d_name[0] == '.')
|
|
continue;
|
|
hecl::SystemString fp(path);
|
|
fp += '/';
|
|
fp += d->d_name;
|
|
hecl::Sstat st;
|
|
if (hecl::Stat(fp.c_str(), &st) || !S_ISDIR(st.st_mode))
|
|
continue;
|
|
sort.emplace(std::make_pair(d->d_name, Entry(std::move(fp), d->d_name, 0, true)));
|
|
}
|
|
|
|
if (reverse)
|
|
for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
|
|
m_entries.push_back(std::move(it->second));
|
|
else
|
|
for (auto& e : sort)
|
|
m_entries.push_back(std::move(e.second));
|
|
|
|
if (mode == Mode::DirsSorted)
|
|
break;
|
|
rewinddir(dir);
|
|
}
|
|
case Mode::FilesSorted:
|
|
{
|
|
if (mode == Mode::FilesSorted)
|
|
m_entries.clear();
|
|
|
|
if (sizeSort)
|
|
{
|
|
std::multimap<size_t, Entry> sort;
|
|
while ((d = readdir(dir)))
|
|
{
|
|
if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
|
|
continue;
|
|
if (noHidden && d->d_name[0] == '.')
|
|
continue;
|
|
hecl::SystemString fp(path);
|
|
fp += '/';
|
|
fp += d->d_name;
|
|
hecl::Sstat st;
|
|
if (hecl::Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
|
|
continue;
|
|
sort.emplace(std::make_pair(st.st_size, Entry(std::move(fp), d->d_name, st.st_size, false)));
|
|
}
|
|
|
|
if (reverse)
|
|
for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
|
|
m_entries.push_back(std::move(it->second));
|
|
else
|
|
for (auto& e : sort)
|
|
m_entries.push_back(std::move(e.second));
|
|
}
|
|
else
|
|
{
|
|
std::map<hecl::SystemString, Entry, CaseInsensitiveCompare> sort;
|
|
while ((d = readdir(dir)))
|
|
{
|
|
if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
|
|
continue;
|
|
if (noHidden && d->d_name[0] == '.')
|
|
continue;
|
|
hecl::SystemString fp(path);
|
|
fp += '/';
|
|
fp += d->d_name;
|
|
hecl::Sstat st;
|
|
if (hecl::Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
|
|
continue;
|
|
sort.emplace(std::make_pair(d->d_name, Entry(std::move(fp), d->d_name, st.st_size, false)));
|
|
}
|
|
|
|
if (reverse)
|
|
for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
|
|
m_entries.push_back(std::move(it->second));
|
|
else
|
|
for (auto& e : sort)
|
|
m_entries.push_back(std::move(e.second));
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
closedir(dir);
|
|
|
|
#endif
|
|
}
|
|
|
|
#define FILE_MAXDIR 768
|
|
|
|
static std::pair<hecl::SystemString, std::string>
|
|
NameFromPath(hecl::SystemStringView path)
|
|
{
|
|
hecl::SystemUTF8Conv utf8(path);
|
|
if (utf8.str().size() == 1 && utf8.str()[0] == '/')
|
|
return {hecl::SystemString(path), "/"};
|
|
size_t lastSlash = utf8.str().rfind('/');
|
|
if (lastSlash != std::string::npos)
|
|
return {hecl::SystemString(path), std::string(utf8.str().cbegin() + lastSlash + 1, utf8.str().cend())};
|
|
else
|
|
return {hecl::SystemString(path), std::string(utf8.str())};
|
|
}
|
|
|
|
std::vector<std::pair<hecl::SystemString, std::string>> GetSystemLocations()
|
|
{
|
|
std::vector<std::pair<hecl::SystemString, std::string>> ret;
|
|
#ifdef WIN32
|
|
#if !WINDOWS_STORE
|
|
/* Add the drive names to the listing (as queried by blender) */
|
|
{
|
|
wchar_t wline[FILE_MAXDIR];
|
|
wchar_t* name;
|
|
__int64 tmp;
|
|
int i;
|
|
|
|
tmp = GetLogicalDrives();
|
|
|
|
for (i = 0; i < 26; i++)
|
|
{
|
|
if ((tmp >> i) & 1)
|
|
{
|
|
wline[0] = L'A' + i;
|
|
wline[1] = L':';
|
|
wline[2] = L'/';
|
|
wline[3] = L'\0';
|
|
name = nullptr;
|
|
|
|
/* Flee from horrible win querying hover floppy drives! */
|
|
if (i > 1)
|
|
{
|
|
/* Try to get volume label as well... */
|
|
if (GetVolumeInformationW(wline, wline + 4, FILE_MAXDIR - 4, nullptr, nullptr, nullptr, nullptr, 0))
|
|
{
|
|
size_t labelLen = wcslen(wline + 4);
|
|
_snwprintf(wline + 4 + labelLen, FILE_MAXDIR - 4 - labelLen, L" (%.2s)", wline);
|
|
name = wline + 4;
|
|
}
|
|
}
|
|
|
|
wline[2] = L'\0';
|
|
if (name)
|
|
ret.emplace_back(wline, hecl::WideToUTF8(name));
|
|
else
|
|
ret.push_back(NameFromPath(wline));
|
|
}
|
|
}
|
|
|
|
/* Adding Desktop and My Documents */
|
|
SystemString wpath;
|
|
SHGetSpecialFolderPathW(0, wline, CSIDL_PERSONAL, 0);
|
|
wpath.assign(wline);
|
|
SanitizePath(wpath);
|
|
ret.push_back(NameFromPath(wpath));
|
|
SHGetSpecialFolderPathW(0, wline, CSIDL_DESKTOPDIRECTORY, 0);
|
|
wpath.assign(wline);
|
|
SanitizePath(wpath);
|
|
ret.push_back(NameFromPath(wpath));
|
|
}
|
|
#endif
|
|
#else
|
|
#ifdef __APPLE__
|
|
{
|
|
hecl::Sstat theStat;
|
|
const char* home = getenv("HOME");
|
|
|
|
if (home)
|
|
{
|
|
ret.push_back(NameFromPath(home));
|
|
std::string desktop(home);
|
|
desktop += "/Desktop";
|
|
if (!hecl::Stat(desktop.c_str(), &theStat))
|
|
ret.push_back(NameFromPath(desktop));
|
|
}
|
|
|
|
/* Get mounted volumes better method OSX 10.6 and higher, see: */
|
|
/*https://developer.apple.com/library/mac/#documentation/CoreFOundation/Reference/CFURLRef/Reference/reference.html*/
|
|
/* we get all volumes sorted including network and do not relay on user-defined finder visibility, less confusing */
|
|
|
|
CFURLRef cfURL = NULL;
|
|
CFURLEnumeratorResult result = kCFURLEnumeratorSuccess;
|
|
CFURLEnumeratorRef volEnum = CFURLEnumeratorCreateForMountedVolumes(NULL, kCFURLEnumeratorSkipInvisibles, NULL);
|
|
|
|
while (result != kCFURLEnumeratorEnd)
|
|
{
|
|
char defPath[1024];
|
|
|
|
result = CFURLEnumeratorGetNextURL(volEnum, &cfURL, NULL);
|
|
if (result != kCFURLEnumeratorSuccess)
|
|
continue;
|
|
|
|
CFURLGetFileSystemRepresentation(cfURL, false, (UInt8 *)defPath, 1024);
|
|
ret.push_back(NameFromPath(defPath));
|
|
}
|
|
|
|
CFRelease(volEnum);
|
|
}
|
|
#else
|
|
/* unix */
|
|
{
|
|
hecl::Sstat theStat;
|
|
const char* home = getenv("HOME");
|
|
|
|
if (home)
|
|
{
|
|
ret.push_back(NameFromPath(home));
|
|
std::string desktop(home);
|
|
desktop += "/Desktop";
|
|
if (!hecl::Stat(desktop.c_str(), &theStat))
|
|
ret.push_back(NameFromPath(desktop));
|
|
}
|
|
|
|
{
|
|
bool found = false;
|
|
#ifdef __linux__
|
|
/* Loop over mount points */
|
|
struct mntent *mnt;
|
|
|
|
FILE* fp = setmntent(MOUNTED, "r");
|
|
if (fp)
|
|
{
|
|
while ((mnt = getmntent(fp)))
|
|
{
|
|
if (strlen(mnt->mnt_fsname) < 4 || strncmp(mnt->mnt_fsname, "/dev", 4))
|
|
continue;
|
|
|
|
std::string mntStr(mnt->mnt_dir);
|
|
if (mntStr.size() > 1 && mntStr.back() == '/')
|
|
mntStr.pop_back();
|
|
ret.push_back(NameFromPath(mntStr));
|
|
|
|
found = true;
|
|
}
|
|
endmntent(fp);
|
|
}
|
|
#endif
|
|
/* Fallback */
|
|
if (!found)
|
|
ret.push_back(NameFromPath("/"));
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
std::wstring Char16ToWide(std::u16string_view src)
|
|
{
|
|
return std::wstring(src.begin(), src.end());
|
|
}
|
|
|
|
/* recursive mkdir */
|
|
#if _WIN32
|
|
int RecursiveMakeDir(const SystemChar* dir) {
|
|
SystemChar tmp[1024];
|
|
SystemChar *p = nullptr;
|
|
Sstat sb;
|
|
size_t len;
|
|
|
|
/* copy path */
|
|
wcsncpy(tmp, dir, 1024);
|
|
len = wcslen(tmp);
|
|
if (len >= 1024) {
|
|
return -1;
|
|
}
|
|
|
|
/* remove trailing slash */
|
|
if(tmp[len - 1] == '/' || tmp[len - 1] == '\\') {
|
|
tmp[len - 1] = 0;
|
|
}
|
|
|
|
/* recursive mkdir */
|
|
for(p = tmp + 1; *p; p++) {
|
|
if(*p == '/' || *p == '\\') {
|
|
*p = 0;
|
|
/* test path */
|
|
if (Stat(tmp, &sb) != 0) {
|
|
/* path does not exist - create directory */
|
|
if (!CreateDirectoryW(tmp, nullptr)) {
|
|
return -1;
|
|
}
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
/* not a directory */
|
|
return -1;
|
|
}
|
|
*p = '/';
|
|
}
|
|
}
|
|
/* test path */
|
|
if (Stat(tmp, &sb) != 0) {
|
|
/* path does not exist - create directory */
|
|
if (!CreateDirectoryW(tmp, nullptr)) {
|
|
return -1;
|
|
}
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
/* not a directory */
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
#else
|
|
int RecursiveMakeDir(const SystemChar* dir) {
|
|
SystemChar tmp[1024];
|
|
SystemChar *p = nullptr;
|
|
Sstat sb;
|
|
size_t len;
|
|
|
|
/* copy path */
|
|
strncpy(tmp, dir, 1024);
|
|
len = strlen(tmp);
|
|
if (len >= 1024) {
|
|
return -1;
|
|
}
|
|
|
|
/* remove trailing slash */
|
|
if(tmp[len - 1] == '/') {
|
|
tmp[len - 1] = 0;
|
|
}
|
|
|
|
/* recursive mkdir */
|
|
for(p = tmp + 1; *p; p++) {
|
|
if(*p == '/') {
|
|
*p = 0;
|
|
/* test path */
|
|
if (Stat(tmp, &sb) != 0) {
|
|
/* path does not exist - create directory */
|
|
if (mkdir(tmp, 0755) < 0) {
|
|
return -1;
|
|
}
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
/* not a directory */
|
|
return -1;
|
|
}
|
|
*p = '/';
|
|
}
|
|
}
|
|
/* test path */
|
|
if (Stat(tmp, &sb) != 0) {
|
|
/* path does not exist - create directory */
|
|
if (mkdir(tmp, 0755) < 0) {
|
|
return -1;
|
|
}
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
/* not a directory */
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
const SystemChar* GetTmpDir()
|
|
{
|
|
#ifdef _WIN32
|
|
#if WINDOWS_STORE
|
|
wchar_t* TMPDIR = nullptr;
|
|
#else
|
|
wchar_t* TMPDIR = _wgetenv(L"TEMP");
|
|
if (!TMPDIR)
|
|
TMPDIR = (wchar_t*)L"\\Temp";
|
|
#endif
|
|
#else
|
|
char* TMPDIR = getenv("TMPDIR");
|
|
if (!TMPDIR)
|
|
TMPDIR = (char*)"/tmp";
|
|
#endif
|
|
return TMPDIR;
|
|
}
|
|
|
|
#if !WINDOWS_STORE
|
|
int RunProcess(const SystemChar* path, const SystemChar* const args[])
|
|
{
|
|
#ifdef _WIN32
|
|
SECURITY_ATTRIBUTES sattrs = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
|
|
HANDLE consoleOutReadTmp, consoleOutWrite, consoleErrWrite, consoleOutRead;
|
|
if (!CreatePipe(&consoleOutReadTmp, &consoleOutWrite, &sattrs, 0))
|
|
{
|
|
LogModule.report(logvisor::Fatal, "Error with CreatePipe");
|
|
return -1;
|
|
}
|
|
|
|
if (!DuplicateHandle(GetCurrentProcess(), consoleOutWrite,
|
|
GetCurrentProcess(), &consoleErrWrite, 0,
|
|
TRUE,DUPLICATE_SAME_ACCESS))
|
|
{
|
|
LogModule.report(logvisor::Fatal, "Error with DuplicateHandle");
|
|
CloseHandle(consoleOutReadTmp);
|
|
CloseHandle(consoleOutWrite);
|
|
return -1;
|
|
}
|
|
|
|
if (!DuplicateHandle(GetCurrentProcess(), consoleOutReadTmp,
|
|
GetCurrentProcess(),
|
|
&consoleOutRead, // Address of new handle.
|
|
0, FALSE, // Make it uninheritable.
|
|
DUPLICATE_SAME_ACCESS))
|
|
{
|
|
LogModule.report(logvisor::Fatal, "Error with DupliateHandle");
|
|
CloseHandle(consoleOutReadTmp);
|
|
CloseHandle(consoleOutWrite);
|
|
CloseHandle(consoleErrWrite);
|
|
return -1;
|
|
}
|
|
|
|
CloseHandle(consoleOutReadTmp);
|
|
|
|
hecl::SystemString cmdLine;
|
|
const SystemChar* const* arg = &args[1];
|
|
while (*arg)
|
|
{
|
|
cmdLine += _S(" \"");
|
|
cmdLine += *arg++;
|
|
cmdLine += _S('"');
|
|
}
|
|
|
|
STARTUPINFO sinfo = {sizeof(STARTUPINFO)};
|
|
HANDLE nulHandle = CreateFileW(L"nul", GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
|
|
&sattrs, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
sinfo.dwFlags = STARTF_USESTDHANDLES;
|
|
sinfo.hStdInput = nulHandle;
|
|
sinfo.hStdError = consoleErrWrite;
|
|
sinfo.hStdOutput = consoleOutWrite;
|
|
|
|
PROCESS_INFORMATION pinfo = {};
|
|
if (!CreateProcessW(path, (LPWSTR)cmdLine.c_str(), NULL, NULL, TRUE, NORMAL_PRIORITY_CLASS, NULL, NULL, &sinfo, &pinfo))
|
|
{
|
|
LPWSTR messageBuffer = nullptr;
|
|
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&messageBuffer, 0, NULL);
|
|
LogModule.report(logvisor::Error, L"unable to launch process from %s: %s", path, messageBuffer);
|
|
LocalFree(messageBuffer);
|
|
|
|
CloseHandle(nulHandle);
|
|
CloseHandle(consoleErrWrite);
|
|
CloseHandle(consoleOutWrite);
|
|
CloseHandle(consoleOutRead);
|
|
return -1;
|
|
}
|
|
|
|
CloseHandle(nulHandle);
|
|
CloseHandle(consoleErrWrite);
|
|
CloseHandle(consoleOutWrite);
|
|
|
|
bool consoleThreadRunning = true;
|
|
auto consoleThread = std::thread([=, &consoleThreadRunning]()
|
|
{
|
|
CHAR lpBuffer[256];
|
|
DWORD nBytesRead;
|
|
DWORD nCharsWritten;
|
|
|
|
while (consoleThreadRunning)
|
|
{
|
|
if (!ReadFile(consoleOutRead, lpBuffer, sizeof(lpBuffer),
|
|
&nBytesRead, NULL) || !nBytesRead)
|
|
{
|
|
DWORD err = GetLastError();
|
|
if (err == ERROR_BROKEN_PIPE)
|
|
break; // pipe done - normal exit path.
|
|
else
|
|
LogModule.report(logvisor::Error, "Error with ReadFile: %08X", err); // Something bad happened.
|
|
}
|
|
|
|
// Display the character read on the screen.
|
|
auto lk = logvisor::LockLog();
|
|
if (!WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), lpBuffer,
|
|
nBytesRead, &nCharsWritten, NULL))
|
|
{
|
|
//LogModule.report(logvisor::Error, "Error with WriteConsole: %08X", GetLastError());
|
|
}
|
|
}
|
|
|
|
CloseHandle(consoleOutRead);
|
|
});
|
|
|
|
WaitForSingleObject(pinfo.hProcess, INFINITE);
|
|
DWORD ret;
|
|
if (!GetExitCodeProcess(pinfo.hProcess, &ret))
|
|
ret = -1;
|
|
consoleThreadRunning = false;
|
|
if (consoleThread.joinable())
|
|
consoleThread.join();
|
|
|
|
CloseHandle(pinfo.hProcess);
|
|
CloseHandle(pinfo.hThread);
|
|
|
|
return ret;
|
|
#else
|
|
pid_t pid = fork();
|
|
if (!pid)
|
|
{
|
|
execvp(path, (char * const *)args);
|
|
exit(1);
|
|
}
|
|
int ret;
|
|
if (waitpid(pid, &ret, 0) < 0)
|
|
return -1;
|
|
if (WIFEXITED(ret))
|
|
return WEXITSTATUS(ret);
|
|
return -1;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
}
|