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.
368 lines
10 KiB
368 lines
10 KiB
#include "PreComp.h"
|
|
#undef POLARITY
|
|
#include <windows.h>
|
|
#include <objbase.h>
|
|
#include "os.h"
|
|
#include <autoptr.h>
|
|
|
|
namespace OS
|
|
{
|
|
int sysVersion();
|
|
const bool unicodeOS_ = unicodeOS();
|
|
const bool secureOS_ = unicodeOS();
|
|
const int osVer_ = sysVersion();
|
|
|
|
DWORD convert2ansi(const wchar_t* unicode, wmilib::auto_buffer<char>& ansi)
|
|
{
|
|
if (unicode)
|
|
{
|
|
size_t class_len = wcslen(unicode);
|
|
ansi = wmilib::auto_buffer<char>(new char[2*class_len+1],2*class_len+1);
|
|
if (ansi.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
if (wcstombs(ansi.get(),unicode, 2*class_len+1)==-1)
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
}
|
|
return ERROR_SUCCESS;
|
|
};
|
|
|
|
bool unicodeOS()
|
|
{
|
|
OSVERSIONINFOA OsVersionInfoA;
|
|
OsVersionInfoA.dwOSVersionInfoSize = sizeof (OSVERSIONINFOA) ;
|
|
GetVersionExA(&OsVersionInfoA);
|
|
return (OsVersionInfoA.dwPlatformId == VER_PLATFORM_WIN32_NT);
|
|
};
|
|
|
|
int sysVersion()
|
|
{
|
|
OSVERSIONINFOA OsVersionInfoA;
|
|
OsVersionInfoA.dwOSVersionInfoSize = sizeof (OSVERSIONINFOA) ;
|
|
GetVersionExA(&OsVersionInfoA);
|
|
//return (OsVersionInfoA.dwMajorVersion);
|
|
return 4;
|
|
};
|
|
|
|
HRESULT
|
|
CoImpersonateClient()
|
|
{
|
|
if (secureOS_) return ::CoImpersonateClient();
|
|
else return S_OK;
|
|
}
|
|
|
|
LONG RegOpenKeyExW (HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
|
|
{
|
|
if (unicodeOS_)
|
|
return ::RegOpenKeyExW(hKey, lpSubKey, ulOptions, samDesired, phkResult);
|
|
size_t key_len = wcslen(lpSubKey);
|
|
wmilib::auto_buffer<char> ansi_key (new char[2*key_len+1]);
|
|
if (ansi_key.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
if (wcstombs(ansi_key.get(),lpSubKey, 2*key_len+1)==-1)
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
return ::RegOpenKeyExA(hKey, ansi_key.get(), ulOptions, samDesired, phkResult);
|
|
};
|
|
|
|
LONG RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey,DWORD Reserved, LPWSTR lpClass,DWORD dwOptions,REGSAM samDesired,LPSECURITY_ATTRIBUTES lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition)
|
|
{
|
|
if (unicodeOS_)
|
|
return ::RegCreateKeyExW(hKey, lpSubKey, Reserved, lpClass, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition);
|
|
|
|
wmilib::auto_buffer<char> ansi_class;
|
|
if (lpClass)
|
|
{
|
|
size_t class_len = wcslen(lpClass);
|
|
ansi_class = wmilib::auto_buffer<char>(new char[2*class_len+1]);
|
|
if (ansi_class.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
if (wcstombs(ansi_class.get(),lpClass, 2*class_len+1)==-1)
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
};
|
|
|
|
size_t key_len = wcslen(lpSubKey);
|
|
wmilib::auto_buffer<char> ansi_key (new char[2*key_len+1]);
|
|
|
|
if (ansi_key.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
if (wcstombs(ansi_key.get(),lpSubKey, 2*key_len+1)==-1)
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
return ::RegCreateKeyExA(hKey, ansi_key.get(), Reserved, ansi_class.get(), dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition);
|
|
};
|
|
|
|
LONG RegEnumKeyExW (HKEY hKey,DWORD dwIndex,LPWSTR lpName,LPDWORD lpcName,LPDWORD lpReserved,LPWSTR lpClass,LPDWORD lpcClass,PFILETIME lpftLastWriteTime)
|
|
{
|
|
if (unicodeOS_)
|
|
return ::RegEnumKeyExW(hKey,dwIndex,lpName,lpcName,lpReserved,lpClass,lpcClass,lpftLastWriteTime);
|
|
|
|
DWORD nameLength = *lpcName ;
|
|
wmilib::auto_buffer<char> ansi_name(new char[(*lpcName)*2]);
|
|
if (ansi_name.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
LONG return_code = ::RegEnumKeyExA(hKey,dwIndex,ansi_name.get(),&nameLength,0, 0, 0,lpftLastWriteTime);
|
|
|
|
if (return_code == ERROR_SUCCESS)
|
|
{
|
|
mbstowcs(lpName, ansi_name.get(), *lpcName);
|
|
*lpcName = nameLength;
|
|
}
|
|
return return_code;
|
|
};
|
|
|
|
LONG RegDeleteKeyW (HKEY hKey, LPCWSTR lpSubKey)
|
|
{
|
|
if (unicodeOS_)
|
|
return ::RegDeleteKeyW(hKey, lpSubKey);
|
|
|
|
size_t key_len = wcslen(lpSubKey);
|
|
wmilib::auto_buffer<char> ansi_key (new char[2*key_len+1]);
|
|
if (ansi_key.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
if (wcstombs(ansi_key.get(),lpSubKey, 2*key_len+1)==-1)
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
return ::RegDeleteKeyA(hKey, ansi_key.get());
|
|
};
|
|
|
|
|
|
|
|
LONG RegQueryValueExW( HKEY hKey, LPCWSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData )
|
|
{
|
|
if (unicodeOS_)
|
|
return ::RegQueryValueExW(hKey, lpValueName, lpReserved, lpType, lpData, lpcbData);
|
|
|
|
size_t key_len = wcslen(lpValueName);
|
|
wmilib::auto_buffer<char> ansi_key (new char[2*key_len+1]);
|
|
if (ansi_key.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
if (wcstombs(ansi_key.get(),lpValueName, 2*key_len+1)==-1)
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
LONG available_size = *lpcbData;
|
|
LONG return_code = ::RegQueryValueExA(hKey, ansi_key.get(), lpReserved, lpType, lpData, lpcbData);
|
|
if (lpData==0)
|
|
{
|
|
*lpcbData *= 2;
|
|
return return_code;
|
|
}
|
|
|
|
if (return_code == ERROR_SUCCESS && (*lpType == REG_EXPAND_SZ || *lpType == REG_SZ))
|
|
{
|
|
wmilib::auto_buffer<BYTE> tempData(new BYTE[*lpcbData]);
|
|
if (tempData.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
memcpy(tempData.get(), lpData, *lpcbData);
|
|
const char * src = (char *)tempData.get();
|
|
wchar_t * dst = (wchar_t*)lpData;
|
|
|
|
if (*lpType==REG_SZ)
|
|
*lpcbData = (mbstowcs(dst, src, available_size)+1)*sizeof(wchar_t);
|
|
else
|
|
{
|
|
// Not Implemented
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
};
|
|
}
|
|
return return_code;
|
|
};
|
|
|
|
LONG RegSetValueExW(HKEY hKey, LPCWSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE *lpData, DWORD cbData)
|
|
{
|
|
if (unicodeOS_)
|
|
return ::RegSetValueExW(hKey, lpValueName, Reserved, dwType, lpData, cbData);
|
|
|
|
size_t key_len = wcslen(lpValueName);
|
|
wmilib::auto_buffer<char> ansi_key (new char[2*key_len+1]);
|
|
if (ansi_key.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
if (wcstombs(ansi_key.get(),lpValueName, 2*key_len+1)==-1)
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
if (dwType==REG_EXPAND_SZ || dwType==REG_SZ)
|
|
{
|
|
const wchar_t * src = reinterpret_cast<const wchar_t*>(lpData);
|
|
size_t value_len = cbData / sizeof(wchar_t) ;
|
|
wmilib::auto_buffer<char> ansi_value (new char[2*value_len+1]);
|
|
if (ansi_value.get() == 0)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
char * dest = ansi_value.get();
|
|
|
|
if (dwType==REG_SZ)
|
|
{
|
|
if ((value_len = wcstombs(dest,src, value_len)+1)==-1)
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
}
|
|
else
|
|
{
|
|
// Not Implemented
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
};
|
|
return ::RegSetValueExA(hKey, ansi_key.get(), Reserved, dwType, (const BYTE*)ansi_value.get(), value_len);
|
|
}
|
|
return ::RegSetValueExA(hKey, ansi_key.get(), Reserved, dwType, lpData, cbData);
|
|
}
|
|
|
|
BOOL GetProcessTimes(
|
|
HANDLE hProcess, // handle to process
|
|
LPFILETIME lpCreationTime, // process creation time
|
|
LPFILETIME lpExitTime, // process exit time
|
|
LPFILETIME lpKernelTime, // process kernel-mode time
|
|
LPFILETIME lpUserTime // process user-mode time
|
|
)
|
|
{
|
|
if (unicodeOS_)
|
|
return ::GetProcessTimes(hProcess, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime);
|
|
FILETIME zero = {0, 0};
|
|
*lpCreationTime = zero;
|
|
*lpExitTime = zero;
|
|
*lpKernelTime = zero;
|
|
*lpUserTime = zero;
|
|
return 1;
|
|
};
|
|
|
|
HANDLE CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName )
|
|
{
|
|
if (unicodeOS_)
|
|
return ::CreateEventW(lpEventAttributes, bManualReset, bInitialState, lpName);
|
|
|
|
wmilib::auto_buffer<char> name;
|
|
DWORD res = convert2ansi(lpName, name);
|
|
if (res == ERROR_SUCCESS)
|
|
return ::CreateEventA(lpEventAttributes, bManualReset, bInitialState, name.get());
|
|
else
|
|
::SetLastError(res);
|
|
return NULL;
|
|
}
|
|
|
|
HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bInitialOwner, LPCWSTR lpName )
|
|
{
|
|
if (unicodeOS_)
|
|
return ::CreateMutexW(lpEventAttributes, bInitialOwner, lpName);
|
|
|
|
wmilib::auto_buffer<char> name;
|
|
DWORD res = convert2ansi(lpName, name);
|
|
if (res == ERROR_SUCCESS)
|
|
return ::CreateMutexA(lpEventAttributes, bInitialOwner, name.get());
|
|
else
|
|
::SetLastError(res);
|
|
return NULL;
|
|
}
|
|
|
|
wchar_t ToUpper(wchar_t c)
|
|
{
|
|
if (unicodeOS_)
|
|
{
|
|
wchar_t wideChar ;
|
|
if (LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, &c, 1, &wideChar, 1) ==0)
|
|
{
|
|
_DBG_BREAK;
|
|
return c;
|
|
}
|
|
return wideChar;
|
|
}
|
|
else
|
|
{
|
|
char ansiString[16];
|
|
char ansiUpper[16];
|
|
wchar_t wideChar = c;
|
|
if (WideCharToMultiByte(CP_ACP, 0, &c, 1, ansiString, 16, NULL, NULL))
|
|
{
|
|
if (LCMapStringA(LOCALE_INVARIANT, LCMAP_UPPERCASE, ansiString, -1, ansiUpper, 16) ==0)
|
|
{
|
|
_DBG_BREAK;
|
|
return c;
|
|
}
|
|
MultiByteToWideChar(CP_ACP, 0, ansiUpper, -1, &wideChar, 1);
|
|
return wideChar;
|
|
};
|
|
return c;
|
|
}
|
|
}
|
|
|
|
wchar_t ToLower(wchar_t c)
|
|
{
|
|
if (unicodeOS_)
|
|
{
|
|
wchar_t wideChar ;
|
|
|
|
if (LCMapStringW(LOCALE_INVARIANT, LCMAP_LOWERCASE, &c, 1, &wideChar, 1) ==0)
|
|
{
|
|
_DBG_BREAK;
|
|
return c;
|
|
}
|
|
return wideChar;
|
|
}
|
|
else
|
|
{
|
|
char ansiString[16];
|
|
char ansiUpper[16];
|
|
wchar_t wideChar = c;
|
|
if (WideCharToMultiByte(CP_ACP, 0, &c, 1, ansiString, 16, NULL, NULL))
|
|
{
|
|
if (LCMapStringA(LOCALE_INVARIANT, LCMAP_LOWERCASE, ansiString, -1, ansiUpper, 16) ==0)
|
|
{
|
|
_DBG_BREAK;
|
|
return c;
|
|
}
|
|
MultiByteToWideChar(CP_ACP, 0, ansiUpper, -1, &wideChar, 1);
|
|
return wideChar;
|
|
};
|
|
return c;
|
|
}
|
|
|
|
}
|
|
bool wbem_iswdigit(wchar_t c)
|
|
{
|
|
WORD result;
|
|
if (unicodeOS_)
|
|
{
|
|
if (GetStringTypeExW(LOCALE_INVARIANT, CT_CTYPE1, &c, 1, &result))
|
|
{
|
|
return (result & C1_DIGIT) != 0;
|
|
};
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
char ansiString[16];
|
|
if (WideCharToMultiByte(CP_ACP, 0, &c, 1, ansiString, 16, NULL, NULL))
|
|
{
|
|
if (GetStringTypeExA(LOCALE_INVARIANT, CT_CTYPE1, ansiString, 1, &result))
|
|
{
|
|
return (result & C1_DIGIT) != 0;
|
|
}
|
|
};
|
|
return false;
|
|
}
|
|
};
|
|
|
|
bool wbem_iswalnum (wchar_t c)
|
|
{
|
|
WORD result;
|
|
if (unicodeOS_)
|
|
{
|
|
if (GetStringTypeExW(LOCALE_INVARIANT, CT_CTYPE1, &c, 1, &result))
|
|
{
|
|
return (result & (C1_DIGIT | C1_ALPHA)) != 0;
|
|
};
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
char ansiString[16];
|
|
if (WideCharToMultiByte(CP_ACP, 0, &c, 1, ansiString, 16, NULL, NULL))
|
|
{
|
|
if (GetStringTypeExA(LOCALE_INVARIANT, CT_CTYPE1, ansiString, 1, &result))
|
|
{
|
|
return (result & (C1_DIGIT | C1_ALPHA)) != 0;
|
|
}
|
|
};
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
};
|
|
|