ScuroNeko
/
VMProtect
mirror of https://github.com/Obfuscator-Collections/VMProtect.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
VMProtect/core/osutils.cc

2205 lines
52 KiB
C++
Raw Blame History

#include "osutils.h"
#include <fstream>
#ifdef __APPLE__
#include <CoreServices/CoreServices.h>
#include <CoreFoundation/CoreFoundation.h>
#include <dlfcn.h>
#elif defined(__unix__)
#include <dlfcn.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <langinfo.h>
#include <pwd.h>
#else
#pragma warning( disable : 4091 )
#include <shlobj.h>
#pragma warning( default: 4091 )
#endif
#define FILE_OPEN_MODE(fm) ((fm) & 0xf)
#define FILE_SHARE_MODE(fm) ((fm) & 0xf0)
namespace os
{
static const uint8_t utf8_limits[5] = {0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
unicode_string FromUTF8(const std::string &src)
{
unicode_string dest;
size_t pos = 0;
size_t len = src.size();
while (pos < len) {
uint8_t c = src[pos++];
if (c < 0x80) {
dest += c;
continue;
}
size_t val_len;
for (val_len = 0; val_len < _countof(utf8_limits); val_len++) {
if (c < utf8_limits[val_len])
break;
}
if (val_len == 0)
continue;
uint32_t value = c - utf8_limits[val_len - 1];
while (val_len) {
if (pos == len)
break;
c = src[pos++];
if (c < 0x80 || c >= 0xC0)
break;
value <<= 6;
value |= (c - 0x80);
val_len--;
}
if (value < 0x10000) {
dest += static_cast<uint16_t>(value);
} else if (value <= 0x10FFFF) {
value -= 0x10000;
dest += static_cast<uint16_t>(0xD800 + (value >> 10));
dest += static_cast<uint16_t>(0xDC00 + (value & 0x3FF));
}
}
return dest;
}
#ifdef VMP_GNU
std::wstring UCS4FromUTF8(const std::string &src)
{
std::wstring dest;
size_t pos = 0;
size_t len = src.size();
while (pos < len) {
uint8_t c = src[pos++];
if (c < 0x80) {
dest += c;
continue;
}
size_t val_len;
for (val_len = 0; val_len < _countof(utf8_limits); val_len++) {
if (c < utf8_limits[val_len])
break;
}
if (val_len == 0)
continue;
uint32_t value = c - utf8_limits[val_len - 1];
while (val_len) {
if (pos == len)
break;
c = src[pos++];
if (c < 0x80 || c >= 0xC0)
break;
value <<= 6;
value |= (c - 0x80);
val_len--;
}
dest += static_cast<wchar_t>(value);
}
return dest;
}
#endif
std::string ToUTF8(const unicode_string &src)
{
std::string dest;
size_t pos = 0;
size_t len = src.size();
while (pos < len) {
uint16_t c = src[pos++];
if (c < 0x80) {
dest += static_cast<char>(c);
continue;
}
uint32_t value;
if (c >= 0xD800 && c < 0xE000) {
value = 0xFFFD;
if (c < 0xDC00 && pos + 1 < len) {
uint16_t c2 = src[pos++];
if (c2 >= 0xDC00 && c2 < 0xE000)
value = 0x10000 + ((c & 0x3FF) << 10) + (c2 & 0x3FF);
}
} else {
value = c;
}
size_t val_len;
for (val_len = 1; val_len < 5; val_len++) {
if (value < (static_cast<uint32_t>(1) << (val_len * 5 + 6)))
break;
}
dest += static_cast<char>(utf8_limits[val_len - 1] + (value >> (6 * val_len)));
while (val_len) {
val_len--;
dest += static_cast<char>(0x80 + ((value >> (6 * val_len)) & 0x3F));
}
}
return dest;
}
unicode_string StringToFileName(const char *name)
{
unicode_string res = FromUTF8(name);
for (size_t i = 0; i < res.size(); i++) {
if (res[i] == L'/')
res[i] = L'\\';
}
return res;
}
bool is_separator(char c)
{
return c == '/'
#ifndef VMP_GNU
|| c == '\\'
#endif
;
}
static const char *GetFileName(const char *name)
{
const char *res = name;
while (*name) {
if ((is_separator(name[0])
#ifndef VMP_GNU
|| name[0] == ':'
#endif
) && !is_separator(name[1]))
res = name + 1;
name++;
}
return res;
}
static const char *GetFileExt(const char *name)
{
name = GetFileName(name);
const char *res = NULL;
while (*name) {
if (*name == ' ')
res = NULL;
else if (*name == '.')
res = name;
name++;
}
return res ? res : name;
}
std::string ExtractFilePath(const char *name)
{
if (!name)
return std::string();
return std::string(name, static_cast<size_t>(GetFileName(name) - name));
}
std::string ExtractFileName(const char *name)
{
if (!name)
return std::string();
return std::string(GetFileName(name));
}
std::string ExtractFileExt(const char *name)
{
if (!name)
return std::string();
return std::string(GetFileExt(name));
}
std::string ChangeFileExt(const char *name, const char *ext)
{
if (!name)
return std::string();
std::string res = std::string(name, static_cast<size_t>(GetFileExt(name) - name));
if (ext)
res += ext;
return res;
}
static bool IsRelative(const char *name)
{
if (name && (is_separator(*name)
#ifndef VMP_GNU
|| (name[0] && name[1] == ':')
#endif
))
return false;
return true;
}
std::string CombinePaths(const char *path, const char *file_name)
{
if (!path || *path == 0 || !IsRelative(file_name))
return std::string(file_name ? file_name : "");
std::string res = path;
if (!res.empty()) {
#ifdef VMP_GNU
if (!is_separator(*(res.end() - 1)))
res += '/';
#else
if (!is_separator(res.back()))
res += '\\';
#endif
}
return res + file_name;
}
std::string SubtractPath(const char *path, const char *file_name)
{
if (!path || *path == 0 || !file_name || IsRelative(file_name))
return std::string(file_name ? file_name : "");
const char *name = file_name;
while (*name) {
char p = *path++;
char f = *name++;
if (p != f) {
if (is_separator(f) && is_separator(p))
continue;
if (p == 0)
return std::string(is_separator(f) ? name : name - 1);
break;
}
}
return std::string(file_name);
}
std::string GetCurrentPath()
{
#ifdef VMP_GNU
char buff[PATH_MAX];
if (!getcwd(buff, sizeof(buff)))
buff[0] = 0;
return std::string(buff);
#else
wchar_t buff[MAX_PATH];
DWORD size = GetCurrentDirectoryW(_countof(buff), buff);
return ToUTF8(std::wstring(buff, size));
#endif
}
std::string GetExecutablePath()
{
std::string res;
#ifdef __APPLE__
CFURLRef url = CFBundleCopyExecutableURL(CFBundleGetMainBundle());
if (url) {
CFStringRef path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
if (path) {
char buffer[PATH_MAX];
if (CFStringGetCString(path, buffer, sizeof(buffer), kCFStringEncodingUTF8))
res = ExtractFilePath(buffer);
CFRelease(path);
}
CFRelease(url);
}
#elif defined(__unix__)
char buff[PATH_MAX];
ssize_t len = ::readlink("/proc/self/exe", buff, sizeof(buff)-1);
if (len != -1) {
buff[len] = '\0';
res = ExtractFilePath(buff);
}
#else
wchar_t buff[MAX_PATH];
DWORD size = GetModuleFileNameW(NULL, buff, _countof(buff));
res = ExtractFilePath(ToUTF8(std::wstring(buff, size)).c_str());
#endif
return res;
}
bool FileExists(const char *name)
{
if (!name)
return false;
#ifdef VMP_GNU
struct stat s;
int res = stat(name, &s);
if (res == -1)
return false;
return true;
#else
return GetFileAttributesW(FromUTF8(name).c_str()) != INVALID_FILE_ATTRIBUTES;
#endif
}
bool FileDelete(const char *name, bool toRecycleBin /*= false*/)
{
#ifdef VMP_GNU
if(toRecycleBin)
{
#ifdef __APPLE__
if (0 == FSPathMoveObjectToTrashSync(name, NULL, kFSFileOperationDefaultOptions))
return true;
#elif defined(__unix__)
//using trash from apt-get install trash-cli
system((std::string("trash \"") + name + "\"").c_str());
if (!FileExists(name))
return true;
#endif
}
return (remove(name) == 0);
#else
unicode_string uname = FromUTF8(name);
if(toRecycleBin)
{
SHFILEOPSTRUCTW operation = SHFILEOPSTRUCTW();
operation.wFunc = FO_DELETE;
wchar_t full_path[MAX_PATH + 1];
DWORD lengNoTerm = GetFullPathNameW(uname.c_str(), MAX_PATH, full_path, NULL);
if(lengNoTerm < MAX_PATH)
{
full_path[lengNoTerm + 1] = 0; //double terminated
operation.pFrom = full_path;
operation.fFlags = FOF_ALLOWUNDO | FOF_NO_UI;
if(SHFileOperationW(&operation) == 0)
return true;
}
}
return (DeleteFileW(uname.c_str()) != FALSE);
#endif
}
bool FileCopy(const char *src, const char *dest)
{
#ifdef __APPLE__
return (copyfile(src, dest, NULL, COPYFILE_ALL) == 0);
#elif defined (__unix__)
try
{
std::ifstream source(src, std::ios::binary);
if (!source.is_open())
return false;
std::ofstream destination(dest, std::ios::binary);
if (!destination.is_open())
return false;
destination << source.rdbuf();
return true;
} catch(std::ios_base::failure &)
{
FileDelete(dest);
return false;
}
#else
return (CopyFileW(FromUTF8(src).c_str(), FromUTF8(dest).c_str(), false) != FALSE);
#endif
}
// fmCreate Create a file with the given name. If a file with the given name exists, open the file in write mode.
// fmOpenRead Open the file for reading only.
// fmOpenWrite Open the file for writing only. Writing to the file completely replaces the current contents.
// fmOpenReadWrite Open the file to modify the current contents rather than replace them.
HANDLE FileCreate(const char *name, uint32_t mode)
{
#ifdef VMP_GNU
int flags;
switch (FILE_OPEN_MODE(mode)) {
case fmOpenRead:
flags = O_RDONLY;
break;
case fmOpenWrite:
flags = O_WRONLY | O_TRUNC;
break;
case fmOpenReadWrite:
flags = O_RDWR;
break;
default:
return INVALID_HANDLE_VALUE;
}
if (mode & fmCreate)
flags |= (O_CREAT | O_TRUNC);
return reinterpret_cast<HANDLE>(open(name, flags, (flags & O_CREAT) ? S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH : 0));
#else
uint32_t desired_access, share_mode;
switch (FILE_OPEN_MODE(mode)) {
case fmOpenRead:
desired_access = GENERIC_READ;
break;
case fmOpenWrite:
desired_access = GENERIC_WRITE;
break;
case fmOpenReadWrite:
desired_access = GENERIC_WRITE | GENERIC_READ;
break;
default:
return INVALID_HANDLE_VALUE;
}
switch (FILE_SHARE_MODE(mode)) {
case fmShareExclusive:
share_mode = 0;
break;
case fmShareDenyWrite:
share_mode = FILE_SHARE_READ;
break;
case fmShareDenyRead:
share_mode = FILE_SHARE_WRITE;
break;
case fmShareDenyNone:
share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
break;
default:
return INVALID_HANDLE_VALUE;
}
return CreateFileW(FromUTF8(name).c_str(), desired_access, share_mode, NULL, (mode & fmCreate) ? CREATE_ALWAYS : OPEN_EXISTING, 0, NULL);
#endif
}
bool FileClose(HANDLE h)
{
#ifdef VMP_GNU
return (close(h) == 0);
#else
return (CloseHandle(h) != 0);
#endif
}
size_t FileRead(HANDLE h, void *buf, size_t size)
{
#ifdef VMP_GNU
size_t res;
res = read(h, buf, size);
#else
size_t res = 0;
DWORD portion;
while(size > 0) {
portion = (DWORD)-1;
if (portion > size)
portion = (DWORD)size;
if (ReadFile(h, (char *)buf + res, portion, &portion, NULL) == 0)
return (size_t)-1;
res += portion;
size -= portion;
if (portion == 0)
break;
}
#endif
return res;
}
size_t FileWrite(HANDLE h, const void *buf, size_t size)
{
#ifdef VMP_GNU
size_t res;
res = write(h, buf, size);
#else
size_t res = 0;
DWORD portion;
while(size > 0) {
portion = (DWORD)-1;
if (portion > size)
portion = (DWORD)size;
if (WriteFile(h, (const char *)buf + res, portion, &portion, NULL) == 0)
return (size_t)-1;
res += portion;
size -= portion;
if (portion == 0)
break;
}
#endif
return res;
}
uint64_t FileSeek(HANDLE h, uint64_t offset, SeekOrigin origin)
{
uint64_t res;
#ifdef VMP_GNU
int method;
switch (origin) {
case soBeginning:
method = SEEK_SET;
break;
case soCurrent:
method = SEEK_CUR;
break;
case soEnd:
method = SEEK_END;
break;
default:
return -1;
}
res = lseek(h, offset, method);
#else
uint32_t method;
switch (origin) {
case soBeginning:
method = FILE_BEGIN;
break;
case soCurrent:
method = FILE_CURRENT;
break;
case soEnd:
method = FILE_END;
break;
default:
return -1;
}
uint32_t pos_low = static_cast<uint32_t>(offset);
uint32_t pos_high = static_cast<uint32_t>(offset >> 32);
pos_low = SetFilePointer(h, pos_low, (PLONG)&pos_high, method);
if (pos_low == INVALID_SET_FILE_POINTER && GetLastError() != 0)
return -1;
res = (static_cast<uint64_t>(pos_high) << 32) | pos_low;
#endif
return res;
}
bool FileSetEnd(HANDLE h)
{
#ifdef VMP_GNU
uint64_t pos = lseek(h, 0, SEEK_CUR);
if (pos == (uint64_t)-1)
return false;
return (ftruncate(h, pos) == 0);
#else
return (SetEndOfFile(h) != 0);
#endif
}
bool FileGetCheckSum(const char *file_name, uint32_t *check_sum)
{
if (!file_name)
return false;
bool res = false;
HANDLE file_handle = FileCreate(file_name, fmOpenRead | fmShareDenyNone);
if (file_handle != INVALID_HANDLE_VALUE) {
#ifdef VMP_GNU
size_t file_size = lseek(file_handle, 0, SEEK_END);
#else
uint32_t file_size = GetFileSize(file_handle, NULL);
HANDLE file_map = CreateFileMappingW(file_handle, NULL, PAGE_READONLY, 0, 0, NULL);
if (file_map) {
#endif
#ifdef VMP_GNU
uint16_t *file_view = reinterpret_cast<uint16_t *>(mmap(0, file_size, PROT_READ, MAP_SHARED, file_handle, 0));
if (file_view != MAP_FAILED) {
#else
uint16_t *file_view = static_cast<uint16_t *>(MapViewOfFile(file_map, FILE_MAP_READ, 0, 0, 0));
if (file_view) {
#endif
bool is_valid_format = false;
uint32_t header_sum = 0;
IMAGE_DOS_HEADER *dos_header = reinterpret_cast<IMAGE_DOS_HEADER *>(file_view);
if (dos_header->e_magic == IMAGE_DOS_SIGNATURE) {
IMAGE_NT_HEADERS32 *header_32 = reinterpret_cast<IMAGE_NT_HEADERS32 *>(reinterpret_cast<uint8_t *>(file_view) + dos_header->e_lfanew);
if (header_32->Signature == IMAGE_NT_SIGNATURE) {
if (header_32->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
header_sum = header_32->OptionalHeader.CheckSum;
is_valid_format = true;
} else if (header_32->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
header_sum = reinterpret_cast<IMAGE_NT_HEADERS64 *>(header_32)->OptionalHeader.CheckSum;
is_valid_format = true;
}
}
}
if (is_valid_format) {
uint32_t sum = 0;
size_t c = (file_size + 1) / sizeof(uint16_t);
for (size_t i = 0; i < c; i++) {
sum += file_view[i];
if (HIWORD(sum))
sum = LOWORD(sum) + HIWORD(sum);
}
sum = static_cast<uint16_t>(LOWORD(sum) + HIWORD(sum));
if (LOWORD(sum) >= LOWORD(header_sum)) {
sum -= LOWORD(header_sum);
} else {
sum = ((LOWORD(sum) - LOWORD(header_sum)) & 0xFFFF) - 1;
}
if (LOWORD(sum) >= HIWORD(header_sum)) {
sum -= HIWORD(header_sum);
} else {
sum = ((LOWORD(sum) - HIWORD(header_sum)) & 0xFFFF) - 1;
}
sum += file_size;
*check_sum = sum;
res = true;
}
#ifdef VMP_GNU
munmap(file_view, file_size);
#else
UnmapViewOfFile(file_view);
#endif
#ifndef VMP_GNU
}
CloseHandle(file_map);
#endif
}
#ifdef VMP_GNU
close(file_handle);
#else
CloseHandle(file_handle);
#endif
}
return res;
}
#ifndef VMP_GNU
std::string ToOEM(const unicode_string &src)
{
std::string res;
if (!src.empty()) {
int size = WideCharToMultiByte(CP_OEMCP, 0, src.c_str(), (int)src.size(), NULL, 0, NULL, NULL);
if (size > 0) {
res.resize(size);
WideCharToMultiByte(CP_OEMCP, 0, src.c_str(), (int)src.size(), &res[0], (int)res.size(), NULL, NULL);
}
}
return res;
}
unicode_string FromACP(const std::string &src)
{
unicode_string res;
if (!src.empty()) {
int size = MultiByteToWideChar(CP_ACP, 0, src.c_str(), (int)src.size(), NULL, 0);
if (size > 0) {
res.resize(size);
MultiByteToWideChar(CP_ACP, 0, src.c_str(), (int)src.size(), &res[0], (int)res.size());
}
}
return res;
}
bool ValidateUTF8(const std::string &src)
{
bool ret = true;
if (!src.empty()) {
int res = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src.c_str(), -1, NULL, NULL);
if (res == 0 && GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
ret = false;
}
}
return ret;
}
#endif
void Print(const char *text)
{
#ifdef VMP_GNU
std::cout << text << std::flush;
#else
std::cout << ToOEM(FromUTF8(text)) << std::flush;
#endif
}
std::vector<std::string> CommandLine()
{
std::vector<std::string> res;
#ifdef __APPLE__
int num = *_NSGetArgc();
char **args = *_NSGetArgv();
for (int i = 0; i < num; i++) {
if (args[i])
res.push_back(std::string(args[i]));
}
#elif defined(__unix__)
FILE *cmdline = fopen("/proc/self/cmdline", "rb");
char *arg = 0;
size_t size = 0;
if (cmdline)
{
while (getdelim(&arg, &size, 0, cmdline) != -1)
{
res.push_back(std::string(arg));
}
}
free(arg);
fclose(cmdline);
#else
int num;
wchar_t **args = CommandLineToArgvW(GetCommandLineW(), &num);
for (int i = 0; i < num; i++) {
if (args[i])
res.push_back(ToUTF8(std::wstring(args[i])));
}
#endif
return res;
}
#ifdef VMP_GNU
#define TOUPPER(x) toupper(x)
static bool WildcardMatch(const char *name, const char *mask)
#else
#define TOUPPER(x) towupper(x)
static bool WildcardMatch(const wchar_t *name, const wchar_t *mask)
#endif
{
if (!name || !mask)
return false;
while (*name) {
if (*mask == '*') {
mask++;
if (*mask == '\0')
return true;
while (*name) {
if (WildcardMatch(name, mask))
return true;
name++;
}
return false;
}
if (*mask == '?' || TOUPPER(*name) == TOUPPER(*mask)) {
name++;
mask++;
} else {
return false;
}
}
while (*mask == '*')
mask++;
return (*mask == '\0');
}
std::vector<std::string> FindFiles(const char *name, const char *mask, bool only_directories)
{
std::vector<std::string> res;
if (!name || !mask)
return res;
#ifdef VMP_GNU
DIR *dir;
struct dirent *ent;
dir = opendir(name);
if (dir) {
while ((ent = readdir(dir))) {
if (WildcardMatch(ent->d_name, mask))
res.push_back(CombinePaths(name, ent->d_name));
}
closedir(dir);
}
#else
std::wstring unicode_mask = FromUTF8(mask);
WIN32_FIND_DATAW find_data;
HANDLE h = FindFirstFileW(FromUTF8(std::string(name) + "\\*").c_str(), &find_data);
if (h != INVALID_HANDLE_VALUE) {
do {
if (wcscmp(find_data.cFileName, L".") == 0 || wcscmp(find_data.cFileName, L"..") == 0)
continue;
if (only_directories && ((find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0))
continue;
if (!WildcardMatch(find_data.cFileName, unicode_mask.c_str()))
continue;
res.push_back(CombinePaths(name, ToUTF8(find_data.cFileName).c_str()));
} while (FindNextFileW(h, &find_data) != 0);
FindClose(h);
}
#endif
return res;
}
uint32_t GetTickCount()
{
#ifdef __APPLE__
const int64_t one_million = 1000 * 1000;
mach_timebase_info_data_t timebase_info;
mach_timebase_info(&timebase_info);
// mach_absolute_time() returns billionth of seconds,
// so divide by one million to get milliseconds
return static_cast<uint32_t>((mach_absolute_time() * timebase_info.numer) / (one_million * timebase_info.denom));
#elif defined (__unix__)
struct timeval tv;
gettimeofday(&tv, NULL);
return tv.tv_sec * 1000 + tv.tv_usec / 1000;
#else
return ::GetTickCount();
#endif
}
#ifdef VMP_GNU
static char* rstrip(char* s)
{
char* p = s + strlen(s);
while (p > s && isspace((unsigned char)(*--p)))
*p = '\0';
return s;
}
static char* lskip(const char* s)
{
while (*s && isspace((unsigned char)(*s)))
s++;
return (char*)s;
}
static char* find_char_or_comment(const char* s, char c)
{
int was_whitespace = 0;
while (*s && *s != c && !(was_whitespace && *s == ';')) {
was_whitespace = isspace((unsigned char)(*s));
s++;
}
return (char*)s;
}
static void SwapBuffer(unicode_char *buf, size_t size)
{
for (size_t i = 0; i < size; i++) {
unicode_char c = buf[i];
buf[i] = (c >> 8) | (c << 8);
}
}
bool ProfileString(const char *_section, const char *_key, const char *_value, char const *file_name, std::string *result)
{
static const uint8_t utf16_le_bom[] = {0xFF, 0xFE};
static const uint8_t utf16_be_bom[] = {0xFE, 0xFF};
static const uint8_t utf8_bom[] = {0xEF, 0xBB, 0xBF};
enum Encoding {
enNone,
enUTF16_le,
enUTF16_be,
enUTF8
};
char *start;
char *end;
char *section;
char *name;
char *value;
Encoding encoding = enNone;
std::stringstream stream;
HANDLE file = FileCreate(file_name, fmOpenRead | fmShareDenyNone);
if (file == INVALID_HANDLE_VALUE) {
if (result)
return false;
} else {
char bom[3] = {0};
FileRead(file, bom, sizeof(utf16_le_bom));
if (memcmp(bom, utf16_le_bom, sizeof(utf16_le_bom)) == 0) {
encoding = enUTF16_le;
} else if (memcmp(bom, utf16_be_bom, sizeof(utf16_be_bom)) == 0) {
encoding = enUTF16_be;
} else {
FileRead(file, &bom[2], 1);
if (memcmp(bom, utf8_bom, sizeof(utf8_bom)) == 0)
encoding = enUTF8;
}
uint64_t begin_pos = (encoding == enNone) ? 0 : FileSeek(file, 0, soCurrent);
uint64_t end_pos = FileSeek(file, 0, soEnd);
size_t size = static_cast<size_t>(end_pos - begin_pos);
if (size) {
FileSeek(file, begin_pos, soBeginning);
uint8_t *buff = new uint8_t[size];
FileRead(file, buff, size);
FileClose(file);
if (encoding == enUTF16_be)
SwapBuffer(reinterpret_cast<unicode_char *>(buff), size / sizeof(unicode_char));
stream.str((encoding == enUTF16_le || encoding == enUTF16_be) ? ToUTF8(unicode_string(reinterpret_cast<unicode_char *>(buff), size / sizeof(unicode_char))) : std::string(reinterpret_cast<char *>(buff), size));
delete [] buff;
}
FileClose(file);
}
bool section_found = false;
bool value_saved = false;
std::string line;
std::vector<std::string> lines;
while (std::getline(stream, line)) {
if (!line.empty() && *(line.end() - 1) == '\r')
line.erase(line.size() - 1);
if (!result)
lines.push_back(line);
start = &line[0];
start = lskip(rstrip(start));
if (*start == ';' || *start == '#') {
/* Per Python ConfigParser, allow '#' comments at start of line */
} else if (*start == '[') {
/* A "[section]" line */
end = find_char_or_comment(start + 1, ']');
if (*end == ']') {
*end = '\0';
if (section_found) {
if (_key) {
if (result) {
return false;
} else if (!value_saved) {
std::vector<std::string>::iterator it = lines.end() - 1;
if (_value)
lines.insert(it, std::string(_key) + std::string("=") + std::string(_value));
else
lines.erase(it);
value_saved = true;
}
} else {
if (result)
return true;
}
}
section = start + 1;
section_found = (_strcmpi(section, _section) == 0);
}
} else if (*start && *start != ';') {
/* Not a comment, must be a name[=:]value pair */
end = find_char_or_comment(start, '=');
if (*end != '=') {
end = find_char_or_comment(start, ':');
}
if (*end == '=' || *end == ':') {
*end = '\0';
name = rstrip(start);
value = lskip(end + 1);
end = find_char_or_comment(value, '\0');
if (*end == ';')
*end = '\0';
rstrip(value);
if (section_found) {
if (_key) {
if (_strcmpi(name, _key) == 0) {
if (result) {
*result = value;
return true;
} else if (!value_saved) {
std::vector<std::string>::iterator it = lines.end() - 1;
if (_value)
*it = std::string(name) + "=" + std::string(_value);
else
lines.erase(it);
value_saved = true;
}
}
} else {
if (result) {
*result += name;
*result += '\0';
}
}
}
}
}
}
if (result) {
return false;
} else {
file = FileCreate(file_name, fmCreate | fmOpenWrite | fmShareDenyNone);
if (file == INVALID_HANDLE_VALUE)
return false;
switch (encoding) {
case enUTF8:
FileWrite(file, utf8_bom, sizeof(utf8_bom));
break;
case enUTF16_le:
FileWrite(file, utf16_le_bom, sizeof(utf16_le_bom));
break;
case enUTF16_be:
FileWrite(file, utf16_be_bom, sizeof(utf16_be_bom));
break;
}
if (!value_saved) {
if (!section_found)
lines.push_back(std::string("[") + std::string(_section) + std::string("]"));
lines.push_back(std::string(_key) + std::string("=") + std::string(_value));
}
for (size_t i = 0; i < lines.size(); i++) {
std::string str = lines[i] + "\r\n";
if (encoding == enUTF16_le || encoding == enUTF16_be) {
unicode_string wstr = FromUTF8(str);
if (encoding == enUTF16_be)
SwapBuffer(const_cast<unicode_char *>(wstr.c_str()), wstr.size());
FileWrite(file, wstr.c_str(), wstr.size() * sizeof(unicode_char));
} else {
FileWrite(file, str.c_str(), str.size());
}
}
FileClose(file);
return true;
}
}
#endif
bool WriteIniString(const char *section, const char *key, const char *value, const char *file_name)
{
#ifdef VMP_GNU
return ProfileString(section, key, value, file_name, NULL);
#else
return WritePrivateProfileStringW(section ? FromUTF8(section).c_str() : NULL,
key ? os::FromUTF8(key).c_str() : NULL,
value ? os::FromUTF8(value).c_str() : NULL,
file_name ? os::FromUTF8(file_name).c_str() : NULL
) != FALSE;
#endif
}
std::string ReadIniString(const char *section, const char *key, const char *default_value, const char *file_name)
{
std::string res;
#ifdef VMP_GNU
if (!ProfileString(section, key, default_value, file_name, &res)) {
if (default_value)
res = std::string(default_value);
}
#else
size_t buffer_size = 1024;
os::unicode_char *buffer = NULL;
for (;;) {
delete [] buffer;
buffer = new os::unicode_char[buffer_size];
uint32_t len = GetPrivateProfileStringW(section ? FromUTF8(section).c_str() : NULL,
key ? FromUTF8(key).c_str() : NULL,
default_value ? FromUTF8(default_value).c_str() : NULL,
buffer, (DWORD)buffer_size,
file_name ? FromUTF8(file_name).c_str() : NULL);
if (len < buffer_size - sizeof(os::unicode_char)) {
res = os::ToUTF8(os::unicode_string(buffer, len));
break;
}
buffer_size *= 4;
}
delete [] buffer;
#endif
return res;
}
HPROCESS ProcessOpen(uint32_t id)
{
#ifdef __APPLE__
mach_port_t task;
if (task_for_pid(mach_task_self(), id, &task) != KERN_SUCCESS)
return 0;
return task;
#elif defined(__unix__)
return HPROCESS(id);
#else
return OpenProcess(PROCESS_ALL_ACCESS, FALSE, id);
#endif
}
bool ProcessClose(HPROCESS h)
{
#ifdef VMP_GNU
// do nothing
return true;
#else
return (CloseHandle(h) != 0);
#endif
}
size_t ProcessRead(HPROCESS h, void *base_address, void *buf, size_t size)
{
#ifdef __APPLE__
mach_vm_size_t res;
if (mach_vm_read_overwrite(h, (mach_vm_address_t)base_address, size, (mach_vm_address_t)buf, &res) != KERN_SUCCESS)
return -1;
return res;
#elif defined(__unix__)
struct iovec local, remote;
local.iov_base = buf;
local.iov_len = (int)size;
remote.iov_base = base_address;
local.iov_len = (int)size;
ssize_t nread = process_vm_readv(reinterpret_cast<pid_t>(h), &local, 1, &remote, 1, 0);
return (size_t)nread;
#else
SIZE_T res;
if (ReadProcessMemory(h, base_address, buf, size, &res) == 0)
return -1;
return res;
#endif
}
size_t ProcessWrite(HPROCESS h, void *base_address, const void *buf, size_t size)
{
#ifdef __APPLE__
if (mach_vm_write(h, (mach_vm_address_t)base_address, size, (mach_vm_address_t)buf) != KERN_SUCCESS)
return -1;
return size;
#elif defined(__unix__)
struct iovec local, remote;
local.iov_base = const_cast<void *>(buf);
local.iov_len = (int)size;
remote.iov_base = base_address;
local.iov_len = (int)size;
ssize_t nwrite = process_vm_writev(reinterpret_cast<pid_t>(h), &local, 1, &remote, 1, 0);
return (size_t)nwrite;
#else
SIZE_T res;
if (WriteProcessMemory(h, base_address, buf, size, &res) == 0)
return -1;
return res;
#endif
}
uint64_t GetLastWriteTime(const char *name)
{
uint64_t res = 0;
HANDLE h = FileCreate(name, fmOpenRead | fmShareDenyNone);
if (h != INVALID_HANDLE_VALUE) {
#ifdef VMP_GNU
struct stat stat_buf;
if (fstat(h, &stat_buf) == 0)
res = stat_buf.st_mtime;
#else
FILETIME file_time;
if (GetFileTime(h, NULL, NULL , &file_time))
res = (static_cast<uint64_t>(file_time.dwHighDateTime) << 32 | file_time.dwLowDateTime) / 10000000 - 11644473600;
#endif
FileClose(h);
}
return res;
}
std::vector<PROCESS_ITEM> EnumProcesses()
{
std::vector<PROCESS_ITEM> res;
#ifdef __APPLE__
int err;
static const int name[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0};
size_t length;
bool done = false;
kinfo_proc *processes = NULL;
do {
length = 0;
err = sysctl(const_cast<int *>(name), (sizeof(name) / sizeof(*name)) - 1, NULL, &length, NULL, 0);
if (err == -1)
err = errno;
if (err == 0) {
processes = new kinfo_proc[length];
if (processes == NULL)
err = ENOMEM;
}
if (err == 0) {
err = sysctl(const_cast<int *>(name), (sizeof(name) / sizeof(*name)) - 1, processes, &length, NULL, 0);
if (err == -1)
err = errno;
if (err == 0) {
done = true;
} else if (err == ENOMEM) {
delete [] processes;
processes = NULL;
err = 0;
}
}
} while (err == 0 && !done);
mach_port_t task;
if (err == 0 && processes) {
for (size_t i = 0; i < length / sizeof(kinfo_proc); i++) {
kinfo_proc *process = &processes[i];
if (task_for_pid(mach_task_self(), process->kp_proc.p_pid, &task) != KERN_SUCCESS)
continue;
PROCESS_ITEM item;
item.id = process->kp_proc.p_pid;
item.name = process->kp_proc.p_comm;
res.push_back(item);
}
}
delete [] processes;
#elif defined(__unix__)
struct dirent* dent;
DIR* srcdir = opendir("/proc");
if (srcdir != NULL)
{
while((dent = readdir(srcdir)) != NULL)
{
struct stat st;
if(strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0)
continue;
if (fstatat(dirfd(srcdir), dent->d_name, &st, 0) >= 0 && S_ISDIR(st.st_mode))
{
PROCESS_ITEM item;
item.id = atoi(dent->d_name);
if (item.id == 0)
continue;
char path[4096];
snprintf(path, sizeof(path), "/proc/%d/maps", item.id);
FILE *fmaps = fopen(path, "r");
if (fmaps)
{
char c;
size_t read = fread(&c, 1, 1, fmaps);
fclose(fmaps);
if (read == 1)
{
snprintf(path, sizeof(path), "/proc/%d/comm", item.id);
std::ifstream f(path);
std::stringstream buffer;
buffer << f.rdbuf();
item.name = buffer.str();
size_t endpos = item.name.find_last_not_of("\r\n");
if( std::string::npos != endpos )
item.name = item.name.substr( 0, endpos+1 );
res.push_back(item);
}
}
}
}
}
closedir(srcdir);
#else
DWORD processes[1024], needed;
if (::EnumProcesses(processes, sizeof(processes), &needed)) {
size_t count = needed / sizeof(DWORD);
for (size_t i = 0; i < count; i++) {
if (!processes[i])
continue;
wchar_t process_name[MAX_PATH] = {0};
HANDLE process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processes[i]);
if (process) {
if (GetModuleFileNameExW(process, 0, process_name, _countof(process_name))) {
PROCESS_ITEM item;
item.id = processes[i];
item.name = ExtractFileName(ToUTF8(process_name).c_str());
res.push_back(item);
}
CloseHandle(process);
}
}
}
#endif
return res;
}
#ifdef __unix__
/*
address perms offset dev inode pathname
00400000-00452000 r-xp 00000000 08:02 173521 /usr/bin/dbus-daemon
00651000-00652000 r--p 00051000 08:02 173521 /usr/bin/dbus-daemon
00652000-00655000 rw-p 00052000 08:02 173521 /usr/bin/dbus-daemon
00e03000-00e24000 rw-p 00000000 00:00 0 [heap]
00e24000-011f7000 rw-p 00000000 00:00 0 [heap]
...
35b1800000-35b1820000 r-xp 00000000 08:02 135522 /usr/lib64/ld-2.15.so
35b1a1f000-35b1a20000 r--p 0001f000 08:02 135522 /usr/lib64/ld-2.15.so
35b1a20000-35b1a21000 rw-p 00020000 08:02 135522 /usr/lib64/ld-2.15.so
35b1a21000-35b1a22000 rw-p 00000000 00:00 0
35b1c00000-35b1dac000 r-xp 00000000 08:02 135870 /usr/lib64/libc-2.15.so
35b1dac000-35b1fac000 ---p 001ac000 08:02 135870 /usr/lib64/libc-2.15.so
35b1fac000-35b1fb0000 r--p 001ac000 08:02 135870 /usr/lib64/libc-2.15.so
35b1fb0000-35b1fb2000 rw-p 001b0000 08:02 135870 /usr/lib64/libc-2.15.so
...
f2c6ff8c000-7f2c7078c000 rw-p 00000000 00:00 0 [stack:986]
...
7fffb2c0d000-7fffb2c2e000 rw-p 00000000 00:00 0 [stack]
7fffb2d48000-7fffb2d49000 r-xp 00000000 00:00 0 [vdso]
*/
static bool ParseMapsLine(const char *maps, int *inode, char *name, size_t cch_name, uint64_t *from, uint64_t *to, uint64_t *offset)
{
bool res = false;
*inode = 0;
*name = 0;
*from = *to = *offset = 0;
if ( strlen(maps) < cch_name &&
sscanf_s(maps, "%llx-%llx%*[ \trwxp-]%llx%*[ \t]%*d:%*d%*[ \t]%d%*[ \t]%s", from, to, offset, inode, name) == 5 &&
*inode != 0)
{
res = true;
}
return res;
}
#endif
std::vector<MODULE_ITEM> EnumModules(uint32_t process_id)
{
std::vector<MODULE_ITEM> res;
#ifdef __APPLE__
mach_port_t task;
if (task_for_pid(mach_task_self(), process_id, &task) == KERN_SUCCESS) {
struct task_dyld_info dyld_info;
mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
if (task_info(task, TASK_DYLD_INFO, (task_info_t)&dyld_info, &count) == KERN_SUCCESS) {
if (dyld_info.all_image_info_addr != 0 && dyld_info.all_image_info_size != 0) {
dyld_all_image_infos image_infos;
if (ProcessRead(task, (void *)dyld_info.all_image_info_addr, &image_infos, sizeof(image_infos)) != (size_t)-1 && image_infos.infoArrayCount) {
dyld_image_info *info_array = new dyld_image_info[image_infos.infoArrayCount];
if (ProcessRead(task, (void *)image_infos.infoArray, info_array, sizeof(dyld_image_info) * image_infos.infoArrayCount) != (size_t)-1) {
for (size_t i = 0; i < image_infos.infoArrayCount; i++) {
dyld_image_info *info = &info_array[i];
std::string name;
char c;
while (ProcessRead(task, (void *)(info->imageFilePath + name.size()), &c, sizeof(c)) != (size_t)-1) {
if (!c)
break;
name += c;
}
MODULE_ITEM item;
item.handle = (HMODULE)info->imageLoadAddress;
item.name = name;
res.push_back(item);
}
}
delete [] info_array;
}
}
}
}
#elif defined(__unix__)
char maps[2048], name[2048];
snprintf(maps, sizeof(maps), "/proc/%d/maps", process_id);
FILE *fmaps = fopen(maps, "r");
if (fmaps)
{
while (fgets(maps, sizeof(maps), fmaps))
{
MODULE_ITEM item;
int inode;
uint64_t from, to, offset;
if(ParseMapsLine(maps, &inode, name, sizeof(name), &from, &to, &offset))
{
item.handle = reinterpret_cast<HMODULE>(from);
item.name = name;
res.push_back(item);
}
}
fclose(fmaps);
}
#else
HANDLE process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, process_id);
if (process) {
HMODULE mods[1024];
DWORD needed;
if (EnumProcessModules(process, mods, sizeof(mods), &needed)) { //-V
size_t count = needed / sizeof(HMODULE);
for (size_t i = 0; i < count; i++) {
wchar_t module_name[MAX_PATH] = {0};
if (GetModuleFileNameExW(process, mods[i], module_name, _countof(module_name))) {
MODULE_ITEM item;
item.handle = mods[i];
item.name = ToUTF8(module_name);
res.push_back(item);
}
}
}
CloseHandle(process);
}
#endif
return res;
}
bool GetModuleInformation(HANDLE process, HMODULE module, MODULE_INFO *info, size_t size)
{
if (size < sizeof(MODULE_INFO))
return false;
#ifdef __APPLE__
uint8_t *address = static_cast<uint8_t *>(module);
mach_header header;
if (ProcessRead(process, address, &header, sizeof(header)) == (size_t)-1)
return false;
if (header.magic == MH_MAGIC) {
info->address = address;
address += sizeof(mach_header);
uint32_t min_address = 0;
uint32_t max_address = 0;
for (size_t i = 0; i < header.ncmds; i++) {
load_command command;
if (ProcessRead(process, address, &command, sizeof(command)) == (size_t)-1)
return false;
if (command.cmd == LC_SEGMENT) {
segment_command segment;
if (ProcessRead(process, address, &segment, sizeof(segment)) == (size_t)-1)
return false;
if (segment.vmaddr) {
if (!min_address)
min_address = segment.vmaddr;
if (max_address < segment.vmaddr + segment.vmsize)
max_address = segment.vmaddr + segment.vmsize;
}
}
address += command.cmdsize;
}
info->size = max_address - min_address;
} else if (header.magic == MH_MAGIC_64) {
info->address = address;
address += sizeof(mach_header_64);
uint64_t min_address = 0;
uint64_t max_address = 0;
for (size_t i = 0; i < header.ncmds; i++) {
load_command command;
if (ProcessRead(process, address, &command, sizeof(command)) == (size_t)-1)
return false;
if (command.cmd == LC_SEGMENT_64) {
segment_command_64 segment;
if (ProcessRead(process, address, &segment, sizeof(segment)) == (size_t)-1)
return false;
if (segment.vmaddr) {
if (!min_address)
min_address = segment.vmaddr;
if (max_address < segment.vmaddr + segment.vmsize)
max_address = segment.vmaddr + segment.vmsize;
}
}
address += command.cmdsize;
}
info->size = static_cast<size_t>(max_address - min_address);
} else {
return false;
}
return true;
#elif defined(__unix__)
bool ret = false;
char maps[1024], name[2048];
snprintf(maps, sizeof(maps), "/proc/%d/maps", (int)process);
FILE *fmaps = fopen(maps, "r");
if (fmaps)
{
while (fgets(maps, sizeof(maps), fmaps))
{
int inode;
uint64_t from, to, offset;
if(ParseMapsLine(maps, &inode, name, sizeof(name), &from, &to, &offset) &&
reinterpret_cast<HMODULE>(from) == module)
{
info->address = (void *)from;
info->size = to - from;
ret = true;
}
}
fclose(fmaps);
}
return ret;
#else
MODULEINFO moduleInfo;
if (!::GetModuleInformation(process, module, &moduleInfo, sizeof(moduleInfo)))
return false;
info->address = moduleInfo.lpBaseOfDll;
info->size = moduleInfo.SizeOfImage;
return true;
#endif
}
std::string GetSysAppDataDirectory()
{
std::string res;
#ifdef __APPLE__
FSRef ref;
if (FSFindFolder(kOnAppropriateDisk, kSharedUserDataFolderType, kDontCreateFolder, &ref) == 0) {
CFURLRef url_ref = CFURLCreateFromFSRef(NULL, &ref);
if (url_ref) {
char buffer[PATH_MAX];
if (CFURLGetFileSystemRepresentation(url_ref, true, (uint8_t*)buffer, sizeof(buffer)))
res = std::string(buffer);
CFRelease(url_ref);
}
}
#elif defined(__unix__)
const char *homedir;
if ((homedir = getenv("HOME")) == NULL) {
homedir = getpwuid(getuid())->pw_dir;
}
res = std::string(homedir) + "/.config"; //admin should use hard links to map this stuff to /usr/share etc
#else
os::unicode_char buffer[MAX_PATH];
if (SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA, NULL, 0, buffer) >= 0)
res = os::ToUTF8(buffer);
#endif
return res;
}
bool DirectoryCreate(const char *name)
{
if (!name)
return false;
#ifdef VMP_GNU
return (mkdir(name, S_IRWXU | S_IRWXG | S_IRWXO) == 0);
#else
return (CreateDirectoryW(FromUTF8(name).c_str(), NULL) != 0 || GetLastError() == ERROR_ALREADY_EXISTS);
#endif
}
bool PathCreate(const char *name)
{
if (!name)
return false;
bool res = DirectoryCreate(name);
if (!res) {
const char *prev = GetFileName(name);
if (prev != name && PathCreate(std::string(name, prev - name - 1).c_str()))
res = DirectoryCreate(name);
}
return res;
}
#ifndef VMP_GNU
struct LocaleInfo {
LCID id;
char iso_name[6];
};
static const LocaleInfo win_locale_info[] = {
{0x0436, "af"},
{0x3801, "ar_AE"},
{0x3c01, "ar_BH"},
{0x1401, "ar_DZ"},
{0x0c01, "ar_EG"},
{0x0801, "ar_IQ"},
{0x2c01, "ar_JO"},
{0x3401, "ar_KW"},
{0x3001, "ar_LB"},
{0x1001, "ar_LY"},
{0x1801, "ar_MA"},
{0x2001, "ar_OM"},
{0x4001, "ar_QA"},
{0x0401, "ar_SA"},
{0x2801, "ar_SY"},
{0x1c01, "ar_TN"},
{0x2401, "ar_YE"},
{0x0423, "be"},
{0x0402, "bg"},
{0x0403, "ca"},
{0x0405, "cs"},
{0x0406, "da"},
{0x0407, "de"},
{0x0c07, "de_AT"},
{0x0807, "de_CH"},
{0x1407, "de_LI"},
{0x1007, "de_LU"},
{0x0408, "el"},
{0x0409, "en"},
{0x0c09, "en_AU"},
{0x2809, "en_BZ"},
{0x1009, "en_CA"},
{0x0809, "en_GB"},
{0x1809, "en_IE"},
{0x2009, "en_JM"},
{0x1409, "en_NZ"},
{0x2c09, "en_TT"},
{0x0409, "en_US"},
{0x1c09, "en_ZA"},
{0x040a, "es"},
{0x2c0a, "es_AR"},
{0x400a, "es_BO"},
{0x340a, "es_CL"},
{0x240a, "es_CO"},
{0x140a, "es_CR"},
{0x1c0a, "es_DO"},
{0x300a, "es_EC"},
{0x100a, "es_GT"},
{0x480a, "es_HN"},
{0x080a, "es_MX"},
{0x4c0a, "es_NI"},
{0x180a, "es_PA"},
{0x280a, "es_PE"},
{0x500a, "es_PR"},
{0x3c0a, "es_PY"},
{0x440a, "es_SV"},
{0x380a, "es_UY"},
{0x200a, "es_VE"},
{0x0425, "et"},
{0x042d, "eu"},
{0x0429, "fa"},
{0x040b, "fi"},
{0x0438, "fo"},
{0x040c, "fr"},
{0x080c, "fr_BE"},
{0x0c0c, "fr_CA"},
{0x100c, "fr_CH"},
{0x140c, "fr_LU"},
{0x040d, "he"},
{0x0439, "hi"},
{0x041a, "hr"},
{0x040e, "hu"},
{0x0421, "in"},
{0x040f, "is"},
{0x0410, "it"},
{0x0810, "it_CH"},
{0x0411, "ja"},
{0x0812, "ko"},
{0x0412, "ko"},
{0x0427, "lt"},
{0x0426, "lv"},
{0x042f, "mk"},
{0x043e, "ms"},
{0x0458, "mt"},
{0x0413, "nl"},
{0x0813, "nl_BE"},
{0x0814, "no"},
{0x0414, "no"},
{0x0415, "pl"},
{0x0816, "pt"},
{0x0416, "pt_BR"},
{0x0418, "ro"},
{0x0419, "ru"},
{0x041c, "sq"},
{0x081a, "sr"},
{0x0c1a, "sr"},
{0x041d, "sv"},
{0x081d, "sv_FI"},
{0x041e, "th"},
{0x041f, "tr"},
{0x0422, "uk"},
{0x0420, "ur"},
{0x042a, "vi"},
{0x0804, "zh"},
{0x0804, "zh_CN"},
{0x0c04, "zh_HK"},
{0x1004, "zh_SG"},
{0x0404, "zh_TW"}
};
#endif
#ifdef __unix__
struct LocaleInfo {
char iso_name[3];
char int_name[32];
};
static const LocaleInfo lin_locale_info[] = {
{"af", "Afrikaans"},
{"ar", "Arabic"},
{"be", "Belarusian"},
{"bg", "Bulgarian"},
{"ca", "Catalan"},
{"cs", "Czech"},
{"da", "Danish"},
{"de", "German"},
{"el", "Greek"},
{"en", "English"},
{"es", "Spanish"},
{"et", "Estonian"},
{"eu", "Basque"},
{"fa", "Farsi"},
{"fi", "Finnish"},
{"fo", "Faroese"},
{"fr", "French"},
{"he", "Hebrew"},
{"hi", "Hindi"},
{"hr", "Croatian"},
{"hu", "Hungarian"},
{"is", "Icelandic"},
{"it", "Italian"},
{"ja", "Japanese"},
{"ko", "Korean"},
{"lt", "Lithuanian"},
{"lv", "Latvian"},
{"mk", "Macedonian"},
{"ms", "Malay"},
{"mt", "Maltese"},
{"nl", "Dutch"},
{"pl", "Polish"},
{"pt", "Portuguese"},
{"ro", "Romanian"},
{"ru", "Russian"},
{"sq", "Albanian"},
{"sr", "Serbian"},
{"sv", "Swedish"},
{"th", "Thai"},
{"tr", "Turkish"},
{"uk", "Ukrainian"},
{"ur", "Urdu"},
{"vi", "Vietnamese"},
{"zh", "Chinese"},
};
#endif
std::string GetLocaleName(const char *code)
{
if (!code)
return std::string();
std::string res;
#ifdef __APPLE__
CFStringRef id = CFStringCreateWithCString(NULL, code, kCFStringEncodingUTF8);
CFLocaleRef loc = CFLocaleCreate(NULL, id);
if (loc) {
CFStringRef name = CFLocaleCopyDisplayNameForPropertyValue(loc, kCFLocaleLanguageCode, id);
if (name) {
CFMutableStringRef mutable_name = CFStringCreateMutableCopy(NULL, 0, name);
CFStringCapitalize(mutable_name, loc);
char buffer[1024];
if (CFStringGetCString(mutable_name, buffer, sizeof(buffer), kCFStringEncodingUTF8))
res = buffer;
CFRelease(mutable_name);
CFRelease(name);
}
CFRelease(loc);
}
CFRelease(id);
#elif defined(__unix__)
int begin = 0;
int end = _countof(lin_locale_info);
while (end - begin > 1) {
int mid = (begin + end)/2;
const LocaleInfo *info = lin_locale_info + mid;
int cmp = strcmp(code, info->iso_name);
if (cmp < 0)
end = mid;
else if (cmp > 0)
begin = mid;
else {
res = info->int_name;
break;
}
}
#else
LCID id = 0;
int begin = 0;
int end = _countof(win_locale_info);
while (end - begin > 1) {
int mid = (begin + end)/2;
const LocaleInfo *info = win_locale_info + mid;
int cmp = strcmp(code, info->iso_name);
if (cmp < 0)
end = mid;
else if (cmp > 0)
begin = mid;
else {
id = info->id;
break;
}
}
if (id) {
os::unicode_char buffer[1024];
if (GetLocaleInfoW(id, LOCALE_SNATIVELANGNAME, buffer, sizeof(buffer))) {
LCMapStringW(id, LCMAP_UPPERCASE, buffer, 1, buffer, 1);
res = os::ToUTF8(os::unicode_string(buffer));
}
}
#endif
if (res.empty())
res = code;
return res;
}
std::string GetCurrentLocale()
{
std::string res;
#ifdef __APPLE__
CFLocaleRef loc = CFLocaleCopyCurrent();
if (loc) {
CFStringRef name = CFLocaleGetIdentifier(loc);
if (name) {
char buffer[1024];
if (CFStringGetCString(name, buffer, sizeof(buffer), kCFStringEncodingUTF8))
res = buffer;
}
CFRelease(loc);
}
#elif defined(__unix__)
const char *lang = ::getenv("LANG");
if (lang && *lang)
{
while (char sym = *lang++)
{
if (sym == '.' || sym == '_')
break;
res += sym;
}
} else
{
res = "en";
}
#else
LCID id = GetUserDefaultLCID();
for (size_t i = 0; i < _countof(win_locale_info); i++) {
if (win_locale_info[i].id == id) {
res = win_locale_info[i].iso_name;
break;
}
}
#endif
return res;
}
void GetLocalTime(SYSTEM_TIME *res)
{
#ifdef VMP_GNU
time_t rawtime;
time(&rawtime);
struct tm local_tm;
tm *timeinfo = localtime_r(&rawtime, &local_tm);
res->year = static_cast<uint16_t>(timeinfo->tm_year + 1900);
res->month = static_cast<uint8_t>(timeinfo->tm_mon);
res->day = static_cast<uint8_t>(timeinfo->tm_mday);
#else
SYSTEMTIME local_time;
::GetLocalTime(&local_time);
res->year = local_time.wYear;
res->month = static_cast<uint8_t>(local_time.wMonth);
res->day = static_cast<uint8_t>(local_time.wDay);
#endif
}
#ifndef VMP_GNU
#include <fcntl.h>
static const wchar_t letters[] =
L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
/* Generate a temporary file name based on TMPL. TMPL must match the
rules for mk[s]temp (i.e. end in "XXXXXX"). The name constructed
does not exist at the time of the call to mkstemp. TMPL is
overwritten with the result. */
int
mkstemp (wchar_t *tmpl)
{
size_t len;
wchar_t *XXXXXX;
static unsigned long long value;
unsigned long long random_time_bits;
unsigned int count;
int fd = -1;
int save_errno = errno;
/* A lower bound on the number of temporary files to attempt to
generate. The maximum total number of temporary file names that
can exist for a given template is 62**6. It should never be
necessary to try all these combinations. Instead if a reasonable
number of names is tried (we define reasonable as 62**3) fail to
give the system administrator the chance to remove the problems. */
#define ATTEMPTS_MIN (62 * 62 * 62)
/* The number of times to attempt to generate a temporary file. To
conform to POSIX, this must be no smaller than TMP_MAX. */
#if ATTEMPTS_MIN < TMP_MAX
unsigned int attempts = TMP_MAX;
#else
unsigned int attempts = ATTEMPTS_MIN;
#endif
len = wcsnlen_s (tmpl, MAX_PATH);
if (len < 6 || wcsncmp (&tmpl[len - 6], L"XXXXXX", MAX_PATH))
{
errno = EINVAL;
return -1;
}
/* This is where the Xs start. */
XXXXXX = &tmpl[len - 6];
/* Get some more or less random data. */
{
SYSTEMTIME stNow;
FILETIME ftNow;
// get system time
GetSystemTime(&stNow);
stNow.wMilliseconds = 500;
if (!SystemTimeToFileTime(&stNow, &ftNow))
{
errno = -1;
return -1;
}
random_time_bits = (((unsigned long long)ftNow.dwHighDateTime << 32)
| (unsigned long long)ftNow.dwLowDateTime);
}
value += random_time_bits ^ (unsigned long long)GetCurrentThreadId ();
for (count = 0; count < attempts; value += 7777, ++count)
{
unsigned long long v = value;
/* Fill in the random bits. */
XXXXXX[0] = letters[v % 62];
v /= 62;
XXXXXX[1] = letters[v % 62];
v /= 62;
XXXXXX[2] = letters[v % 62];
v /= 62;
XXXXXX[3] = letters[v % 62];
v /= 62;
XXXXXX[4] = letters[v % 62];
v /= 62;
XXXXXX[5] = letters[v % 62];
if (0 == _wsopen_s(&fd, tmpl, O_RDWR | O_CREAT | O_EXCL, _SH_DENYRW, _S_IREAD | _S_IWRITE) && fd >= 0)
{
errno = save_errno;
return fd;
} else if (errno != EEXIST)
{
return -1;
}
}
/* We got out of the loop because we ran out of combinations to try. */
errno = EEXIST;
return -1;
}
#endif
std::string GetTempFilePathName(const char *pathname_template /*=NULL*/)
{
std::string ret;
#ifdef VMP_GNU
char szTempFileName[PATH_MAX] = "/tmp/vmpXXXXXX";
if(pathname_template)
strcpy_s(szTempFileName, pathname_template);
int fd = mkstemp(szTempFileName);
if(fd >= 0)
{
fchmod(fd, S_IRUSR | S_IWUSR | S_IXUSR);
ret = szTempFileName;
close(fd);
}
#else
if(pathname_template)
{
os::unicode_string tempFileName = os::FromUTF8(pathname_template);
int fd = mkstemp(const_cast<wchar_t *>(tempFileName.data()));
if(fd >= 0)
{
ret = os::ToUTF8(tempFileName);
_close(fd);
}
} else
{
wchar_t lpTempPathBuffer[MAX_PATH], szTempFileName[MAX_PATH];
DWORD dwRetVal = GetTempPathW(MAX_PATH, lpTempPathBuffer);
if (dwRetVal <= MAX_PATH && (dwRetVal != 0))
{
UINT uRetVal = GetTempFileNameW(lpTempPathBuffer, L"vmp", 0, szTempFileName);
if (uRetVal > 0)
{
ret = os::ToUTF8(std::wstring(szTempFileName));
}
}
}
#endif
return ret;
}
std::string GetTempFilePathNameFor(const char *pathname)
{
std::string ret = os::GetTempFilePathName((std::string(pathname) + ".XXXXXX").c_str());
if(ret.empty())
{
return os::GetTempFilePathName();
}
return ret;
}
bool FileMove(const char *oldName, const char *newName)
{
#ifdef VMP_GNU
return rename(oldName, newName) == 0;
#else
return MoveFileExW(os::FromUTF8(oldName).c_str(), os::FromUTF8(newName).c_str(),
MOVEFILE_COPY_ALLOWED | // used only when different volumes
MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) == TRUE;
#endif
}
#ifdef __APPLE__
std::string GetMainExeFileName(const char *file_name)
{
std::string res;
CFStringRef cfPath = CFStringCreateWithCString(NULL, file_name, kCFStringEncodingUTF8);
if (cfPath) {
CFURLRef bundleURL = CFURLCreateWithFileSystemPath(NULL, cfPath, kCFURLPOSIXPathStyle, true);
if (bundleURL) {
CFBundleRef aBundle = CFBundleCreate(NULL, bundleURL);
if (aBundle) {
CFURLRef mainExecUrl = CFBundleCopyExecutableURL(aBundle);
if(mainExecUrl) {
CFURLRef mainExecAbsUrl = CFURLCopyAbsoluteURL(mainExecUrl);
if(mainExecAbsUrl) {
CFStringRef mainExec = CFURLCopyFileSystemPath(mainExecAbsUrl, kCFURLPOSIXPathStyle);
if (mainExec) {
char buffer[PATH_MAX];
if (CFStringGetCString(mainExec, buffer, sizeof(buffer), kCFStringEncodingUTF8))
res = buffer;
CFRelease(mainExec);
}
CFRelease(mainExecAbsUrl);
}
CFRelease(mainExecUrl);
}
CFRelease(aBundle);
}
CFRelease(bundleURL);
}
CFRelease(cfPath);
}
return res;
}
#endif
std::string CombineThisAppDataDirectory(const char *lastPathPart)
{
return os::CombinePaths(os::CombinePaths(os::GetSysAppDataDirectory().c_str(), "VMProtect Software/VMProtect").c_str(), lastPathPart);
}
HMODULE LibraryOpen(const std::string &name)
{
#ifdef VMP_GNU
return dlopen(name.c_str(), RTLD_NOW);
#else
return LoadLibraryW(FromUTF8(name).c_str());
#endif
}
bool LibraryClose(HMODULE h)
{
#ifdef VMP_GNU
return (dlclose(h) == 0);
#else
return (FreeLibrary(h) != 0);
#endif
}
void *GetFunction(HMODULE h, const std::string &name)
{
#ifdef VMP_GNU
return dlsym(h, name.c_str());
#else
return GetProcAddress(h, name.c_str());
#endif
}
std::string ExpandEnvironmentVariables(const char *path)
{
#ifdef VMP_GNU
std::string res;
for (const char *p = path; *p; ) {
const char *first = strchr(p, '%');
if (first) {
const char *next = strchr(first + 1, '%');
if (next) {
const char *var_value = getenv(std::string(first + 1, next - first - 1).c_str());
if (var_value) {
res.append(p, first - p);
res.append(var_value);
} else {
res.append(p, next + 1 - p);
}
p = next + 1;
continue;
}
}
res.append(p);
break;
}
return res;
#else
unicode_string src = FromUTF8(path);
unicode_string res;
for (const unicode_char *p = src.c_str(); *p; ) {
const unicode_char *first = wcschr(p, '%');
if (first) {
const unicode_char *next = wcschr(first + 1, '%');
if (next) {
size_t var_size;
unicode_string var = unicode_string(first + 1, next - first - 1);
_wgetenv_s(&var_size, NULL, 0, var.c_str()); //-V530
if (var_size) {
res.append(p, first - p);
unicode_char *var_value = new unicode_char[var_size];
_wgetenv_s(&var_size, var_value, var_size, var.c_str()); //-V530
res.append(var_value);
delete [] var_value;
} else {
res.append(p, next + 1 - p);
}
p = next + 1;
continue;
}
}
res.append(p);
break;
}
return ToUTF8(res);
#endif
}
std::string GetEnvironmentVariable(const char *name)
{
#ifdef VMP_GNU
if (const char *p = getenv(name))
return std::string(p);
return std::string();
#else
unicode_string var = FromUTF8(name);
unicode_string res;
size_t var_size;
_wgetenv_s(&var_size, NULL, 0, var.c_str());
if (var_size) {
unicode_char *var_value = new unicode_char[var_size];
_wgetenv_s(&var_size, var_value, var_size, var.c_str()); //-V530
res = var_value;
delete[] var_value;
}
return ToUTF8(res);
#endif
}
void SetEnvironmentVariable(const char *name, const char *value)
{
#ifdef VMP_GNU
setenv(name, value, 1);
#else
_wputenv_s(FromUTF8(name).c_str(), FromUTF8(value).c_str());
#endif
}
}
Reference in New Issue View Git Blame Copy Permalink