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.
 
 
 
 

475 lines
12 KiB

// This file is under GNU General Public License 3.0
// see LICENSE.txt
// Windows platform specification
#define WIN32_LEAN_AND_MEAN
#ifndef UNICODE
#define UNICODE
#endif
#define _WIN32_WINNT 0x0600
#include <windows.h>
#define _CRT_RAND_S
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <string>
#include <stdexcept>
#include "platform_windows.h"
#include "dynamic_api.h"
#include <fcntl.h>
#include <tchar.h>
#include <sys\stat.h>
#include "pEpEngine.h" // just for PEP_STATUS
#define LOCAL_DB_FILENAME "management.db"
#define SYSTEM_DB_FILENAME "system.db"
#define KEYS_DB "keys.db"
#define USER_FOLDER_PATH _per_user_directory()
#define SYSTEM_FOLDER_PATH _per_machine_directory()
#ifndef WC_ERR_INVALID_CHARS
#define WC_ERR_INVALID_CHARS 0x00000080 // error for invalid chars
#endif
using namespace std;
static string utf8_string(wstring wstr) {
string result;
if (wstr.length()) {
int size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS,
wstr.c_str(), -1, NULL, 0, NULL, NULL);
assert(size);
if (size) {
char *buf = new char[size];
WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, wstr.c_str(),
-1, buf, size, NULL, NULL);
result = buf;
delete[] buf;
} else
throw out_of_range("input wstring is not valid"
" while converting UTF-16 to UTF-8.");
}
return result;
}
static wstring utf16_string(string str) {
wstring result;
if (str.length()) {
int size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
str.c_str(), -1, NULL, 0);
assert(size);
if (size) {
wchar_t * buf = new wchar_t[size];
MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.c_str(), -1,
buf, size);
result = buf;
delete[] buf;
} else
throw out_of_range("input string is not valid"
" while converting UTF-8 to UTF-16.");
}
return result;
}
static bool readRegistryString(
HKEY hKey, LPCTSTR lpSubKey, LPCTSTR lpValueName, LPTSTR lpResult,
DWORD dwSize, LPCTSTR lpDefault
)
{
assert(lpResult);
HKEY theKey;
DWORD type;
DWORD bytesCopied = dwSize;
HRESULT result;
result = RegOpenKeyEx(hKey, lpSubKey, 0, KEY_READ, &theKey);
if (result != ERROR_SUCCESS) {
if (lpDefault) {
wcsncpy_s(lpResult, dwSize, lpDefault, _TRUNCATE);
return true;
}
else
return false;
}
result = RegQueryValueEx(theKey, lpValueName, NULL, &type,
(LPBYTE) lpResult, &bytesCopied);
if (result != ERROR_SUCCESS || (type != REG_EXPAND_SZ && type != REG_SZ)) {
if (lpDefault) {
wcsncpy_s(lpResult, dwSize, lpDefault, _TRUNCATE);
RegCloseKey(theKey);
return true;
}
else {
RegCloseKey(theKey);
return false;
}
}
RegCloseKey(theKey);
return true;
}
static const DWORD PATH_BUF_SIZE = 32768;
static inline string managementPath(const char *file_path, const char *file_name)
{
string path;
TCHAR tPath[PATH_BUF_SIZE];
DWORD length = ExpandEnvironmentStringsW(utf16_string(file_path).c_str(),
tPath, PATH_BUF_SIZE);
assert(length);
if (length == 0)
throw bad_alloc(); // BUG: there are other errors possible beside out of memory
CreateDirectory(tPath, NULL);
DWORD error = GetLastError();
path = utf8_string(tPath);
path += "\\";
path += file_name;
return path;
}
const char *_per_machine_directory(void)
{
static string path;
if (path.length())
return path.c_str();
TCHAR tPath[PATH_BUF_SIZE];
TCHAR tPath2[PATH_BUF_SIZE];
// Get SystemFolder Registry value and use if available
bool result = readRegistryString(HKEY_CURRENT_USER, TEXT("SOFTWARE\\pEp"),
TEXT("SystemFolder"), tPath2, PATH_BUF_SIZE, NULL);
DWORD length = 0;
// If no Registry value was found, use default
if (!result) {
length = ExpandEnvironmentStringsW(utf16_string(string(PER_MACHINE_DIRECTORY)).c_str(),
tPath, PATH_BUF_SIZE);
}
else {
length = ExpandEnvironmentStringsW(tPath2, tPath, PATH_BUF_SIZE);
}
assert(length);
if (length == 0)
throw bad_alloc(); // BUG: there are other errors possible beside out of memory
path = utf8_string(wstring(tPath, length));
return path.c_str();
}
const char *_per_user_directory(void)
{
static string path;
if (path.length())
return path.c_str();
TCHAR tPath[PATH_BUF_SIZE];
TCHAR tPath2[PATH_BUF_SIZE];
// Get UserFolder Registry value and use if available
bool result = readRegistryString(HKEY_CURRENT_USER, TEXT("SOFTWARE\\pEp"),
TEXT("UserFolder"), tPath2, PATH_BUF_SIZE, NULL);
DWORD length = 0;
// If no Registry value was found, use default
if (!result) {
length = ExpandEnvironmentStringsW(utf16_string(string(PER_USER_DIRECTORY)).c_str(),
tPath, PATH_BUF_SIZE);
}
else {
length = ExpandEnvironmentStringsW(tPath2, tPath, PATH_BUF_SIZE);
}
assert(length);
if (length == 0)
throw bad_alloc(); // BUG: there are other errors possible beside out of memory
path = utf8_string(wstring(tPath));
return path.c_str();
}
extern "C" {
DYNAMIC_API const char *per_user_directory(void)
{
return _per_user_directory();
}
DYNAMIC_API const char *per_machine_directory(void)
{
return _per_machine_directory();
}
void *dlopen(const char *filename, int flag) {
static TCHAR path[PATH_BUF_SIZE];
assert(filename);
assert(flag == RTLD_LAZY); // only lazy binding is implemented
// Look up GnuPG installation in current user scope
bool result = readRegistryString(HKEY_CURRENT_USER,
TEXT("SOFTWARE\\GnuPG"), TEXT("Install Directory"), path,
PATH_BUF_SIZE, NULL);
// If not found in current user, look up in local machine
if (!result)
result = readRegistryString(HKEY_LOCAL_MACHINE,
TEXT("SOFTWARE\\GnuPG"), TEXT("Install Directory"), path,
PATH_BUF_SIZE, NULL);
assert(result);
if (!result)
return NULL;
SetDllDirectory(TEXT(""));
BOOL _result = SetDllDirectory(path);
assert(_result != 0);
if (_result == 0)
return NULL;
HMODULE module = LoadLibrary(utf16_string(filename).c_str());
if (module == NULL) {
SetDllDirectory(NULL);
_tcscat_s(path, TEXT("\\bin"));
SetDllDirectory(TEXT(""));
_result = SetDllDirectory(path);
assert(_result != 0);
if (_result == 0)
return NULL;
module = LoadLibrary(utf16_string(filename).c_str());
}
SetDllDirectory(NULL);
if (module == NULL)
return NULL;
else
return (void *) module;
}
int dlclose(void *handle) {
if (FreeLibrary((HMODULE) handle))
return 0;
else
return 1;
}
void *dlsym(void *handle, const char *symbol) {
return (void *) (intptr_t) GetProcAddress((HMODULE) handle, symbol);
}
const char *windoze_keys_db(void) {
static string path;
if (path.length() == 0) {
path = managementPath(USER_FOLDER_PATH, KEYS_DB);
}
return path.c_str();
}
const char *windoze_local_db(void) {
static string path;
if (path.length() == 0)
path = managementPath(USER_FOLDER_PATH, LOCAL_DB_FILENAME);
return path.c_str();
}
const char *windoze_system_db(void) {
static string path;
if (path.length() == 0)
path = managementPath(PER_MACHINE_DIRECTORY, SYSTEM_DB_FILENAME);
return path.c_str();
}
long random(void)
{
unsigned int r;
errno_t e;
assert(sizeof(unsigned int) == sizeof(long)); // this is Windoze
do {
e = rand_s(&r);
} while (e);
return (long) (r & ((1U<<31)-1));
}
char *strndup(const char *s1, size_t n)
{
char *str = (char *) calloc(n + 1, 1);
if (str == NULL)
return NULL;
strncpy(str, s1, n);
return str;
}
char *stpcpy(char *dst, const char *src)
{
for (;; ++dst, ++src) {
*dst = *src;
if (*dst == 0)
break;
}
return dst;
}
size_t strlcpy(char* dst, const char* src, size_t size) {
size_t retval = strlen(src);
size_t size_to_copy = (retval < size ? retval : size - 1);
// strlcpy doc says src and dst not allowed to overlap, as
// it's undefined. So this is acceptable:
memcpy((void*)dst, (void*)src, size_to_copy); // no defined error return, but strcpy doesn't either
dst[size_to_copy] = '\0';
return retval;
}
size_t strlcat(char* dst, const char* src, size_t size) {
size_t start_len = strnlen(dst, size);
if (start_len == size)
return size; // no copy, no null termination in size bytes, according to spec
size_t add_len = strlen(src);
size_t retval = start_len + add_len;
size_t size_to_copy = (retval < size ? add_len : (size - start_len) - 1);
// strlcat doc says src and dst not allowed to overlap, as
// it's undefined. So this is acceptable:
memcpy((void*)(dst + start_len), (void*)src, size_to_copy); // no defined error return, but strcpy doesn't either
dst[start_len + size_to_copy] = '\0';
return retval;
}
char *strnstr(const char *big, const char *little, size_t len) {
if (big == NULL || little == NULL)
return NULL;
if (*little == '\0')
return (char*)big;
const char* curr_big = big;
size_t little_len = strlen(little);
size_t remaining = len;
const char* retval = NULL;
for (remaining = len; remaining >= little_len && *curr_big != '\0'; remaining--, curr_big++) {
// find first-char match
if (*curr_big != *little) {
continue;
}
retval = curr_big;
const char* inner_big = retval + 1;
const char* curr_little = little + 1;
size_t j;
for (j = 1; j < little_len; j++, inner_big++, curr_little++) {
if (*inner_big != *curr_little) {
retval = NULL;
break;
}
}
if (retval)
break;
}
return (char*)retval;
}
int mkstemp(char *templ)
{
char *pathname = _mktemp(templ);
if (!pathname)
return -1;
return _open(pathname, _O_RDWR | _O_CREAT | _O_EXCL, _S_IREAD | _S_IWRITE);
}
DYNAMIC_API time_t timegm(timestamp *timeptr)
{
assert(timeptr);
if (!timeptr)
return -1;
timeptr->tm_gmtoff = 0;
time_t result = _mkgmtime((struct tm *) timeptr);
if (result == -1)
return -1;
return result;
}
void uuid_generate_random(pEpUUID out)
{
RPC_STATUS rpc_status = UuidCreate(out);
assert(rpc_status == RPC_S_OK);
}
int uuid_parse(char *in, pEpUUID uu)
{
unsigned char *_in = (unsigned char *) in;
RPC_STATUS rpc_status = UuidFromStringA(_in, uu);
assert(rpc_status == RPC_S_OK);
if (rpc_status == RPC_S_INVALID_STRING_UUID)
return -1;
return 0;
}
void uuid_unparse_upper(pEpUUID uu, uuid_string_t out)
{
unsigned char *_out = (unsigned char*)out;
RPC_CSTR str;
RPC_STATUS rpc_status = UuidToStringA(uu, &str);
assert(rpc_status == RPC_S_OK);
if (rpc_status == RPC_S_OK) {
memcpy(out, str, 36);
out[36] = 0;
RpcStringFreeA(&str);
}
else { // if (rpc_status == RPC_S_OUT_OF_MEMORY)
memset(out, 0, 37);
}
}
void log_output_debug(const char *title,
const char *entity,
const char *description,
const char *comment)
{
const size_t size = 256;
char str[size];
snprintf(str, size, "*** %s %s %s %s\n", title, entity, description, comment);
OutputDebugStringA(str);
}
DYNAMIC_API PEP_STATUS reset_path_cache(void)
{
/* Do nothing and return success. This only exists for API compatibility
with the Unix version. */
return PEP_STATUS_OK;
}
DYNAMIC_API void clear_path_cache (void)
{
/* Like reset_path_cache, do nothing. */
}
} // "C"