int CGlobalSettings::_GetUserValue(const char *product, const char *key, const char *value, char *buffer, int buffer_len)
{
HKEY hKey,hSubKey;
DWORD dwType,dwLen,dw;
cvs::string regkey;
if(!product || !strcmp(product,"cvsnt"))
regkey="Software\\Cvsnt";
else
cvs::sprintf(regkey,64,"Software\\March Hare Software Ltd\\%s",product);
if(RegOpenKeyExA(HKEY_CURRENT_USER,regkey.c_str(),0,KEY_READ,&hKey))
return -1; // Couldn't open or create key
if(key)
{
if(RegOpenKeyExA(hKey,key,0,KEY_READ,&hSubKey))
{
RegCloseKey(hKey);
return -1; // Couldn't open or create key
}
RegCloseKey(hKey);
hKey=hSubKey;
}
dwType=REG_SZ;
dwLen=buffer_len;
if((dw=RegQueryValueExA(hKey,value,NULL,&dwType,(LPBYTE)buffer,&dwLen))!=0)
{
RegCloseKey(hKey);
return -1;
}
RegCloseKey(hKey);
if(dwType==REG_DWORD && buffer)
sprintf(buffer,"%u",*(DWORD*)buffer);
return 0;
}
bool GetREGSZ(HKEY hKey, const std::string strLeafKeyName, std::string &strOutValue)
{
bool bResult = false;
int res = 0;
char buffer[257] = {0};
DWORD dwLen = 256;
DWORD dwType = 0;
do
{
res = RegQueryValueExA(hKey, strLeafKeyName.c_str(), 0, &dwType,
(BYTE *)buffer, &dwLen);
if(ERROR_SUCCESS != res)
break;
strOutValue = buffer;
bResult = true;
} while (false);
return bResult;
}
static int ReadRegistry(HKEY hroot,
char * p1, char * p2, char * p3,
char dest[1024])
{
HKEY h1, h2;
DWORD dwType;
unsigned long size;
LONG ret;
if (RegOpenKeyExA(hroot, p1, 0, KEY_QUERY_VALUE, &h1) != ERROR_SUCCESS)
return 0;
if (RegOpenKeyExA(h1, p2, 0, KEY_QUERY_VALUE, &h2) != ERROR_SUCCESS) {
RegCloseKey(h1);
return 0;
}
dwType = REG_SZ;
size = 1024;
ret = RegQueryValueExA(h2, p3, 0, &dwType, dest, &size);
RegCloseKey(h2);
RegCloseKey(h1);
return ret == ERROR_SUCCESS;
}
void UnregisterDriver() {
HKEY hReg;
if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32", &hReg)) {
MessageBoxA(NULL, "Cannot open registry key", "Registry error", MB_OK | MB_ICONEXCLAMATION);
return;
}
char str[255];
char drvName[] = "MIDI0";
DWORD len, res;
int mt32emuDriver = -1;
for (int i = 0; i < 10; i++) {
len = 255;
if (i) {
drvName[4] = '0' + i;
} else {
drvName[4] = 0;
}
res = RegQueryValueExA(hReg, drvName, NULL, NULL, (LPBYTE)str, &len);
if (res != ERROR_SUCCESS) {
continue;
}
if (!_stricmp(str, mt32emuDriverName)) {
mt32emuDriver = i;
res = RegDeleteValueA(hReg, drvName);
if (res != ERROR_SUCCESS) {
MessageBoxA(NULL, "Cannot uninstall MT32Emu MIDI driver", "Registry error", MB_OK | MB_ICONEXCLAMATION);
RegCloseKey(hReg);
return;
}
}
}
if (mt32emuDriver == -1) {
MessageBoxA(NULL, "Cannot uninstall MT32Emu MIDI driver. There is no driver found.", "Error", MB_OK | MB_ICONEXCLAMATION);
RegCloseKey(hReg);
return;
}
MessageBoxA(NULL, "MT32Emu MIDI Driver successfully uninstalled.", "Information", MB_OK | MB_ICONINFORMATION);
RegCloseKey(hReg);
}
static LONG getTZI(const char *winid, TZI *tzi)
{
DWORD cbData = sizeof(TZI);
LONG result;
HKEY hkey;
result = openTZRegKey(&hkey, winid);
if (result == ERROR_SUCCESS) {
result = RegQueryValueExA(hkey,
TZI_REGKEY,
NULL,
NULL,
(LPBYTE)tzi,
&cbData);
}
RegCloseKey(hkey);
return result;
}
static void RandAddSeedPerfmon()
{
RandAddSeed();
#ifdef WIN32
// Don't need this on Linux, OpenSSL automatically uses /dev/urandom
// Seed with the entire set of perfmon data
// This can take up to 2 seconds, so only do it every 10 minutes
static int64_t nLastPerfmon;
if (GetTime() < nLastPerfmon + 10 * 60)
return;
nLastPerfmon = GetTime();
std::vector<unsigned char> vData(250000, 0);
long ret = 0;
unsigned long nSize = 0;
const size_t nMaxSize = 10000000; // Bail out at more than 10MB of performance data
while (true) {
nSize = vData.size();
ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, begin_ptr(vData), &nSize);
if (ret != ERROR_MORE_DATA || vData.size() >= nMaxSize)
break;
vData.resize(std::max((vData.size() * 3) / 2, nMaxSize)); // Grow size of buffer exponentially
}
RegCloseKey(HKEY_PERFORMANCE_DATA);
if (ret == ERROR_SUCCESS) {
RAND_add(begin_ptr(vData), nSize, nSize / 100.0);
memory_cleanse(begin_ptr(vData), nSize);
LogPrint("rand", "%s: %lu bytes\n", __func__, nSize);
} else {
static bool warned = false; // Warn only once
if (!warned) {
LogPrintf("%s: Warning: RegQueryValueExA(HKEY_PERFORMANCE_DATA) failed with code %i\n", __func__, ret);
warned = true;
}
}
#endif
}
/*****************************************************************
* WNetGetCachedPassword [MPR.@] Retrieves password from cache
*
* NOTES
* the stub seems to be wrong:
* arg1: ptr 0x40xxxxxx -> (no string)
* arg2: len 36
* arg3: ptr 0x40xxxxxx -> (no string)
* arg4: ptr 0x40xxxxxx -> 0xc8
* arg5: type? 4
*
* ---- everything below this line might be wrong (js) -----
* RETURNS
* Success: WN_SUCCESS
* Failure: WN_ACCESS_DENIED, WN_BAD_PASSWORD, WN_BAD_VALUE,
* WN_NET_ERROR, WN_NOT_SUPPORTED, WN_OUT_OF_MEMORY
*/
DWORD WINAPI WNetGetCachedPassword(
LPSTR pbResource, /* [in] Name of workgroup, computer, or resource */
WORD cbResource, /* [in] Size of name */
LPSTR pbPassword, /* [out] Buffer to receive password */
LPWORD pcbPassword, /* [out] Receives size of password */
BYTE nType) /* [in] Type of password to retrieve */
{
HKEY hkey;
DWORD r, type = 0, sz;
LPSTR valname;
WARN( "(%p(%s), %d, %p, %p, %d): totally insecure\n",
pbResource, debugstr_a(pbResource), cbResource,
pbPassword, pcbPassword, nType );
memset( pbPassword, 0, *pcbPassword);
/* @@ Wine registry key: HKCU\Software\Wine\Wine\Mpr */
r = RegCreateKeyA( HKEY_CURRENT_USER, mpr_key, &hkey );
if( r )
return WN_ACCESS_DENIED;
valname = MPR_GetValueName( pbResource, cbResource, nType );
if( valname )
{
sz = *pcbPassword;
r = RegQueryValueExA( hkey, valname, 0, &type, (LPBYTE)pbPassword, &sz );
*pcbPassword = sz;
if( r )
r = WN_CANCEL;
else
r = WN_SUCCESS;
HeapFree( GetProcessHeap(), 0, valname );
}
else
r = WN_OUT_OF_MEMORY;
return r;
}
LONG winfrip_confstore_RegQueryValueEx(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData)
{
WINFRIPP_CONFSTORE_DEBUG_ASSERT(hKey);
WINFRIPP_CONFSTORE_DEBUG_ASSERT(lpValueName);
/*
* XXX document
*/
switch (winfrip_confstore_backend_get()) {
default:
WINFRIPP_CONFSTORE_DEBUG_FAIL();
return ERROR_INVALID_FUNCTION;
case WINFRIP_GENERAL_STORE_BACKEND_REGISTRY:
return RegQueryValueExA(hKey, lpValueName, lpReserved, lpType, lpData, lpcbData);
case WINFRIP_GENERAL_STORE_BACKEND_EPHEMERAL:
case WINFRIP_GENERAL_STORE_BACKEND_FILE:
/* TODO implement */
return ERROR_INVALID_FUNCTION;
}
}
// 20.11.15 - moved from interop class
bool spoutDirectX::ReadDwordFromRegistry(DWORD *pValue, const char *subkey, const char *valuename)
{
HKEY hRegKey;
LONG regres;
DWORD dwSize, dwKey;
dwSize = MAX_PATH;
// Does the key exist
regres = RegOpenKeyExA(HKEY_CURRENT_USER, subkey, NULL, KEY_READ, &hRegKey);
if(regres == ERROR_SUCCESS) {
// Read the key DWORD value
regres = RegQueryValueExA(hRegKey, valuename, NULL, &dwKey, (BYTE*)pValue, &dwSize);
RegCloseKey(hRegKey);
if(regres == ERROR_SUCCESS)
return true;
}
// Just quit if the key does not exist
return false;
}
UINT
mmGetProfileInt(LPCSTR appname, LPCSTR valuename, INT uDefault)
{
DWORD dwType;
INT value = uDefault;
DWORD dwData;
int cbData;
BOOL fCloseKey;
HKEY key = GetKeyA(appname, &fCloseKey, FALSE);
if (key) {
cbData = sizeof(dwData);
if (RegQueryValueExA(
key,
(LPSTR)valuename,
NULL,
&dwType,
(PBYTE) &dwData,
(LPDWORD)&cbData) == ERROR_SUCCESS) {
if (dwType == REG_DWORD || dwType == REG_BINARY) {
value = (INT)dwData;
#ifdef USESTRINGSALSO
} else if (dwType == REG_SZ) {
value = atoi((LPSTR) &dwData);
#endif
}
}
// close open key open if we did not cache it
if (fCloseKey) {
RegCloseKey(key);
}
}
return((UINT)value);
}
static BOOL HCR_RegGetIconA(HKEY hkey, LPSTR szDest, LPCSTR szName, DWORD len, int* picon_idx)
{
DWORD dwType;
char sTemp[MAX_PATH];
char sNum[5];
if (!RegQueryValueExA(hkey, szName, 0, &dwType, (LPBYTE)szDest, &len))
{
if (dwType == REG_EXPAND_SZ)
{
ExpandEnvironmentStringsA(szDest, sTemp, MAX_PATH);
lstrcpynA(szDest, sTemp, len);
}
if (ParseFieldA (szDest, 2, sNum, 5))
*picon_idx=atoi(sNum);
else
*picon_idx=0; /* sometimes the icon number is missing */
ParseFieldA (szDest, 1, szDest, len);
PathUnquoteSpacesA(szDest);
return TRUE;
}
return FALSE;
}
static BOOL full_title(void)
{
CABINETSTATE cs;
memset(&cs, 0, sizeof(cs));
if (pReadCabinetState)
{
pReadCabinetState(&cs, sizeof(cs));
}
else
{
HKEY key;
DWORD size;
win_skip("ReadCabinetState is not available, reading registry directly\n");
RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CabinetState", &key);
size = sizeof(cs);
RegQueryValueExA(key, "Settings", NULL, NULL, (LPBYTE)&cs, &size);
RegCloseKey(key);
}
return (cs.fFullPathTitle == -1);
}
CString getLucidRegValue(CString csSectionPath, CString csKey, CString csDefault)
{
HKEY myKey;
DWORD varType = REG_SZ; //the value's a REG_SZ type
DWORD buffSize = 1024;
LPBYTE pszBuf=NULL;
pszBuf = (LPBYTE)malloc(buffSize);
CString retStr = "";
pszBuf[0] = '\0';
RegOpenKeyEx(HKEY_CURRENT_USER,csSectionPath, 0, KEY_READ, &myKey);
RegQueryValueExA(myKey,csKey,NULL,&varType,pszBuf,&buffSize);
if (pszBuf[0] == '\0') {
retStr = csDefault;
}
else {
retStr = (LPCSTR(pszBuf));
}
free(pszBuf);
RegCloseKey(myKey);
return retStr;
}
static HRESULT WINAPI IDirectMusic8Impl_GetDefaultPort (LPDIRECTMUSIC8 iface, LPGUID pguidPort) {
IDirectMusic8Impl *This = (IDirectMusic8Impl *)iface;
HKEY hkGUID;
DWORD returnTypeGUID, sizeOfReturnBuffer = 50;
char returnBuffer[51];
GUID defaultPortGUID;
WCHAR buff[51];
TRACE("(%p, %p)\n", This, pguidPort);
if ((RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\DirectMusic\\Defaults" , 0, KEY_READ, &hkGUID) != ERROR_SUCCESS) ||
(RegQueryValueExA(hkGUID, "DefaultOutputPort", NULL, &returnTypeGUID, (LPBYTE)returnBuffer, &sizeOfReturnBuffer) != ERROR_SUCCESS))
{
WARN(": registry entry missing\n" );
*pguidPort = CLSID_DirectMusicSynth;
return S_OK;
}
/* FIXME: Check return types to ensure we're interpreting data right */
MultiByteToWideChar(CP_ACP, 0, returnBuffer, -1, buff, sizeof(buff) / sizeof(WCHAR));
CLSIDFromString(buff, &defaultPortGUID);
*pguidPort = defaultPortGUID;
return S_OK;
}
static LONG getTZKeyName(char* tzKeyName, int32_t length) {
HKEY hkey;
LONG result = FALSE;
DWORD cbData = length;
if(ERROR_SUCCESS == RegOpenKeyExA(
HKEY_LOCAL_MACHINE,
CURRENT_ZONE_REGKEY,
0,
KEY_QUERY_VALUE,
&hkey))
{
result = RegQueryValueExA(
hkey,
"TimeZoneKeyName",
NULL,
NULL,
(LPBYTE)tzKeyName,
&cbData);
}
return result;
}
bool WinRegistryKey::exists(const std::string& name)
{
bool exists = false;
HKEY hKey;
#if defined(POCO_WIN32_UTF8)
std::wstring usubKey;
Poco::UnicodeConverter::toUTF16(_subKey, usubKey);
if (RegOpenKeyExW(_hRootKey, usubKey.c_str(), 0, KEY_READ | _extraSam, &hKey) == ERROR_SUCCESS)
{
std::wstring uname;
Poco::UnicodeConverter::toUTF16(name, uname);
exists = RegQueryValueExW(hKey, uname.c_str(), NULL, NULL, NULL, NULL) == ERROR_SUCCESS;
RegCloseKey(hKey);
}
#else
if (RegOpenKeyExA(_hRootKey, _subKey.c_str(), 0, KEY_READ | _extraSam, &hKey) == ERROR_SUCCESS)
{
exists = RegQueryValueExA(hKey, name.c_str(), NULL, NULL, NULL, NULL) == ERROR_SUCCESS;
RegCloseKey(hKey);
}
#endif
return exists;
}
static unsigned dbg_load_internal_vars(void)
{
HKEY hkey;
DWORD type = REG_DWORD;
DWORD val;
DWORD count = sizeof(val);
int i;
struct dbg_internal_var* div = dbg_internal_vars;
/* initializes internal vars table */
#define INTERNAL_VAR(_var,_val,_ref,_tid) \
div->val = _val; div->name = #_var; div->pval = _ref; \
div->typeid = _tid; div++;
#include "intvar.h"
#undef INTERNAL_VAR
/* @@ Wine registry key: HKCU\Software\Wine\WineDbg */
if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey))
{
WINE_ERR("Cannot create WineDbg key in registry\n");
return FALSE;
}
for (i = 0; i < DBG_IV_LAST; i++)
{
if (!dbg_internal_vars[i].pval)
{
if (!RegQueryValueExA(hkey, dbg_internal_vars[i].name, 0,
&type, (LPBYTE)&val, &count))
dbg_internal_vars[i].val = val;
dbg_internal_vars[i].pval = &dbg_internal_vars[i].val;
}
}
RegCloseKey(hkey);
return TRUE;
}
static void warn_if_raster_font(void)
{
DWORD fontFamily = 0;
DECLARE_PROC_ADDR(kernel32.dll, BOOL, GetCurrentConsoleFontEx,
HANDLE, BOOL, PCONSOLE_FONT_INFOEX);
/* don't bother if output was ascii only */
if (!non_ascii_used)
return;
/* GetCurrentConsoleFontEx is available since Vista */
if (INIT_PROC_ADDR(GetCurrentConsoleFontEx)) {
CONSOLE_FONT_INFOEX cfi;
cfi.cbSize = sizeof(cfi);
if (GetCurrentConsoleFontEx(console, 0, &cfi))
fontFamily = cfi.FontFamily;
} else {
/* pre-Vista: check default console font in registry */
HKEY hkey;
if (ERROR_SUCCESS == RegOpenKeyExA(HKEY_CURRENT_USER, "Console",
0, KEY_READ, &hkey)) {
DWORD size = sizeof(fontFamily);
RegQueryValueExA(hkey, "FontFamily", NULL, NULL,
(LPVOID) &fontFamily, &size);
RegCloseKey(hkey);
}
}
if (!(fontFamily & TMPF_TRUETYPE)) {
const wchar_t *msg = L"\nWarning: Your console font probably "
L"doesn\'t support Unicode. If you experience strange "
L"characters in the output, consider switching to a "
L"TrueType font such as Consolas!\n";
DWORD dummy;
WriteConsoleW(console, msg, wcslen(msg), &dummy, NULL);
}
}
std::string raaUtilities::regReadEntry(std::string sKey, std::string sEntry)
{
std::string sStr;
HKEY hKey;
DWORD dwType=REG_SZ, dwSize=8192*sizeof(char);
if(RegOpenKeyExA(HKEY_LOCAL_MACHINE, sKey.c_str(),0,KEY_ALL_ACCESS,&hKey)==ERROR_SUCCESS)
{
if(hKey)
{
char c[8192];
int i=RegQueryValueExA(hKey, sEntry.c_str(), 0, &dwType, (PBYTE)c, &dwSize);
RegCloseKey(hKey);
if(!i)
{
sStr=c;
}
}
}
return sStr;
}
bool NTRegQuery::readValueData(LPSTR data)
{
return RegQueryValueExA(m_hKey, m_value, NULL, &m_dwType, (LPBYTE) data, &m_dwSize) == ERROR_SUCCESS;
}
char *netsnmp_getenv(const char *name)
{
#if !defined (WIN32) && !defined (cygwin)
return (getenv(name));
#else
char *temp = NULL;
HKEY hKey;
unsigned char * key_value = NULL;
DWORD key_value_size = 0;
DWORD key_value_type = 0;
DWORD getenv_worked = 0;
DEBUGMSGTL(("read_config", "netsnmp_getenv called with name: %s\n",name));
if (!(name))
return NULL;
/* Try environment variable first */
temp = getenv(name);
if (temp) {
getenv_worked = 1;
DEBUGMSGTL(("read_config", "netsnmp_getenv will return from ENV: %s\n",temp));
}
/* Next try HKCU */
if (temp == NULL)
{
if (getenv("SNMP_IGNORE_WINDOWS_REGISTRY"))
return NULL;
if (RegOpenKeyExA(
HKEY_CURRENT_USER,
"SOFTWARE\\Net-SNMP",
0,
KEY_QUERY_VALUE,
&hKey) == ERROR_SUCCESS) {
if (RegQueryValueExA(
hKey,
name,
NULL,
&key_value_type,
NULL, /* Just get the size */
&key_value_size) == ERROR_SUCCESS) {
SNMP_FREE(key_value);
/* Allocate memory needed +1 to allow RegQueryValueExA to NULL terminate the
* string data in registry is missing one (which is unlikely).
*/
key_value = malloc((sizeof(char) * key_value_size)+sizeof(char));
if (RegQueryValueExA(
hKey,
name,
NULL,
&key_value_type,
key_value,
&key_value_size) == ERROR_SUCCESS) {
}
temp = (char *) key_value;
}
RegCloseKey(hKey);
if (temp)
DEBUGMSGTL(("read_config", "netsnmp_getenv will return from HKCU: %s\n",temp));
}
}
/* Next try HKLM */
if (temp == NULL)
{
if (RegOpenKeyExA(
HKEY_LOCAL_MACHINE,
"SOFTWARE\\Net-SNMP",
0,
KEY_QUERY_VALUE,
&hKey) == ERROR_SUCCESS) {
if (RegQueryValueExA(
hKey,
name,
NULL,
&key_value_type,
NULL, /* Just get the size */
&key_value_size) == ERROR_SUCCESS) {
SNMP_FREE(key_value);
/* Allocate memory needed +1 to allow RegQueryValueExA to NULL terminate the
* string data in registry is missing one (which is unlikely).
*/
key_value = malloc((sizeof(char) * key_value_size)+sizeof(char));
if (RegQueryValueExA(
hKey,
name,
NULL,
&key_value_type,
key_value,
&key_value_size) == ERROR_SUCCESS) {
}
temp = (char *) key_value;
}
RegCloseKey(hKey);
if (temp)
DEBUGMSGTL(("read_config", "netsnmp_getenv will return from HKLM: %s\n",temp));
}
}
if (temp && !getenv_worked) {
setenv(name, temp, 1);
SNMP_FREE(temp);
}
DEBUGMSGTL(("read_config", "netsnmp_getenv returning: %s\n",getenv(name)));
return(getenv(name));
#endif
}
__declspec(dllexport) void download (HWND parent,
int string_size,
TCHAR *variables,
stack_t **stacktop)
{
char buf[1024];
char url[1024];
char filename[1024];
static char proxy[1024];
BOOL bSuccess=FALSE;
int timeout_ms=30000;
int getieproxy=1;
int manualproxy=0;
int translation_version;
const char *error=NULL;
// translation version 2 & 1
static char szDownloading[1024]; // "Downloading %s"
static char szConnecting[1024]; // "Connecting ..."
static char szSecond[1024]; // " (1 second remaining)" for v2
// "second" for v1
static char szMinute[1024]; // " (1 minute remaining)" for v2
// "minute" for v1
static char szHour[1024]; // " (1 hour remaining)" for v2
// "hour" for v1
static char szProgress[1024]; // "%skB (%d%%) of %skB at %u.%01ukB/s" for v2
// "%dkB (%d%%) of %dkB at %d.%01dkB/s" for v1
// translation version 2 only
static char szSeconds[1024]; // " (%u seconds remaining)"
static char szMinutes[1024]; // " (%u minutes remaining)"
static char szHours[1024]; // " (%u hours remaining)"
// translation version 1 only
static char szPlural[1024]; // "s";
static char szRemaining[1024]; // " (%d %s%s remaining)";
EXDLL_INIT();
PopStringA(url);
if (!lstrcmpiA(url, "/TRANSLATE2")) {
PopStringA(szDownloading);
PopStringA(szConnecting);
PopStringA(szSecond);
PopStringA(szMinute);
PopStringA(szHour);
PopStringA(szSeconds);
PopStringA(szMinutes);
PopStringA(szHours);
PopStringA(szProgress);
PopStringA(url);
translation_version=2;
} else if (!lstrcmpiA(url, "/TRANSLATE")) {
PopStringA(szDownloading);
PopStringA(szConnecting);
PopStringA(szSecond);
PopStringA(szMinute);
PopStringA(szHour);
PopStringA(szPlural);
PopStringA(szProgress);
PopStringA(szRemaining);
PopStringA(url);
translation_version=1;
} else {
lstrcpyA(szDownloading, "Downloading %s");
lstrcpyA(szConnecting, "Connecting ...");
lstrcpyA(szSecond, " (1 second remaining)");
lstrcpyA(szMinute, " (1 minute remaining)");
lstrcpyA(szHour, " (1 hour remaining)");
lstrcpyA(szSeconds, " (%u seconds remaining)");
lstrcpyA(szMinutes, " (%u minutes remaining)");
lstrcpyA(szHours, " (%u hours remaining)");
lstrcpyA(szProgress, "%skB (%d%%) of %skB at %u.%01ukB/s");
translation_version=2;
}
lstrcpynA(buf, url, 10);
if (!lstrcmpiA(buf, "/TIMEOUT=")) {
timeout_ms=my_atoi(url+9);
PopStringA(url);
}
if (!lstrcmpiA(url, "/PROXY")) {
getieproxy=0;
manualproxy=1;
PopStringA(proxy);
PopStringA(url);
}
if (!lstrcmpiA(url, "/NOIEPROXY")) {
getieproxy=0;
PopStringA(url);
}
PopStringA(filename);
HANDLE hFile = CreateFileA(filename,GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,0,NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
wsprintfA(buf, "Unable to open %s", filename);
error = buf;
}
else
{
if (parent)
{
uMsgCreate = RegisterWindowMessage(_T("nsisdl create"));
lpWndProcOld = (WNDPROC)SetWindowLongPtr(parent,GWLP_WNDPROC,(LONG_PTR)ParentWndProc);
SendMessage(parent, uMsgCreate, TRUE, (LPARAM) parent);
// set initial text
char *p = filename;
while (*p) p++;
while (*p !='\\' && p != filename) p = CharPrevA(filename, p);
wsprintfA(buf, szDownloading, p != filename ? p + 1 : p);
SetDlgItemTextA(childwnd, 1006, buf);
SetWindowTextA(g_hwndStatic, szConnecting);
}
{
WSADATA wsaData;
WSAStartup(MAKEWORD(1, 1), &wsaData);
JNL_HTTPGet *get = 0;
static char main_buf[8192];
char *buf=main_buf;
char *p=NULL;
HKEY hKey;
if (getieproxy && RegOpenKeyExA(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",0,KEY_READ,&hKey) == ERROR_SUCCESS)
{
DWORD l = 4;
DWORD t;
DWORD v;
if (RegQueryValueExA(hKey,"ProxyEnable",NULL,&t,(unsigned char*)&v,&l) == ERROR_SUCCESS && t == REG_DWORD && v)
{
l=8192;
if (RegQueryValueExA(hKey,"ProxyServer",NULL,&t,(unsigned char *)buf,&l ) == ERROR_SUCCESS && t == REG_SZ)
{
p=strstr(buf,"http=");
if (!p) p=buf;
else {
p+=5;
}
char *tp=strstr(p,";");
if (tp) *tp=0;
char *p2=strstr(p,"=");
if (p2) p=0; // we found the wrong proxy
}
}
buf[8192-1]=0;
RegCloseKey(hKey);
}
if (manualproxy == 1) {
p = proxy;
}
DWORD start_time=GetTickCount();
get=new JNL_HTTPGet(JNL_CONNECTION_AUTODNS,16384,(p&&p[0])?p:NULL);
int st;
int has_printed_headers = 0;
__int64 cl = 0;
int len;
__int64 sofar = 0;
DWORD last_recv_time=start_time;
get->addheader ("User-Agent: NSISDL/1.2 (Mozilla)");
get->addheader ("Accept: */*");
get->connect (url);
while (1) {
if (g_cancelled)
error = "cancel";
if (error)
{
if (parent)
{
SendMessage(parent, uMsgCreate, FALSE, (LPARAM) parent);
SetWindowLongPtr(parent, GWLP_WNDPROC, (LONG_PTR)lpWndProcOld);
}
break;
}
st = get->run ();
if (st == -1) {
lstrcpynA(url, get->geterrorstr(), sizeof(url));
error = url;
} else if (st == 1) {
if (sofar < cl || get->get_status () != 2)
error="download incomplete";
else
{
bSuccess=TRUE;
error = "success";
}
} else {
if (get->get_status () == 0) {
// progressFunc ("Connecting ...", 0);
if (last_recv_time+timeout_ms < GetTickCount())
error = "Timed out on connecting.";
else
Sleep(10); // don't busy-loop while connecting
} else if (get->get_status () == 1) {
progress_callback("Reading headers", 0);
if (last_recv_time+timeout_ms < GetTickCount())
error = "Timed out on getting headers.";
else
Sleep(10); // don't busy-loop while reading headers
} else if (get->get_status () == 2) {
if (! has_printed_headers) {
has_printed_headers = 1;
last_recv_time=GetTickCount();
cl = get->content_length ();
if (cl == 0)
error = "Server did not specify content length.";
else if (g_hwndProgressBar) {
SendMessage(g_hwndProgressBar, PBM_SETRANGE, 0, MAKELPARAM(0, 30000));
g_file_size = cl;
}
}
int data_downloaded = 0;
while ((len = get->bytes_available ()) > 0) {
data_downloaded++;
if (len > 8192)
len = 8192;
len = get->get_bytes (buf, len);
if (len > 0) {
last_recv_time=GetTickCount();
DWORD dw;
WriteFile(hFile,buf,len,&dw,NULL);
sofar += len;
int time_sofar=(GetTickCount()-start_time)/1000;
int bps = (int)(sofar/(time_sofar?time_sofar:1));
int remain = MulDiv64(time_sofar, cl, sofar) - time_sofar;
if (translation_version == 2) {
char *rtext=remain==1?szSecond:szSeconds;;
if (remain >= 60)
{
remain/=60;
rtext=remain==1?szMinute:szMinutes;
if (remain >= 60)
{
remain/=60;
rtext=remain==1?szHour:szHours;
}
}
char sofar_str[128];
char cl_str[128];
myitoa64(sofar/1024, sofar_str);
myitoa64(cl/1024, cl_str);
wsprintfA (buf,
szProgress, //%skB (%d%%) of %skB @ %u.%01ukB/s
sofar_str,
MulDiv64(100, sofar, cl),
cl_str,
bps/1024,((bps*10)/1024)%10
);
if (remain) wsprintfA(buf+lstrlenA(buf),rtext,
remain
);
} else if (translation_version == 1) {
char *rtext=szSecond;
if (remain >= 60)
{
remain/=60;
rtext=szMinute;
if (remain >= 60)
{
remain/=60;
rtext=szHour;
}
}
wsprintfA (buf,
szProgress, //%dkB (%d%%) of %dkB @ %d.%01dkB/s
int(sofar/1024),
MulDiv64(100, sofar, cl),
int(cl/1024),
bps/1024,((bps*10)/1024)%10
);
if (remain) wsprintfA(buf+lstrlenA(buf),szRemaining,
remain,
rtext,
remain==1?"":szPlural
);
}
progress_callback(buf, sofar);
} else {
if (sofar < cl)
error = "Server aborted.";
}
}
if (GetTickCount() > last_recv_time+timeout_ms)
{
if (sofar != cl)
{
error = "Downloading timed out.";
}
else
{
// workaround for bug #1713562
// buggy servers that wait for the client to close the connection.
// another solution would be manually stopping when cl == sofar,
// but then buggy servers that return wrong content-length will fail.
bSuccess = TRUE;
error = "success";
}
}
else if (!data_downloaded)
Sleep(10);
} else {
error = "Bad response status.";
}
}
}
// Clean up the connection then release winsock
if (get) delete get;
WSACleanup();
}
CloseHandle(hFile);
}
if (g_cancelled || !bSuccess) {
DeleteFileA(filename);
}
PushStringA(error);
}
static void test_ExitCode(void)
{
static const char* AeDebug="Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug";
char test_exe[MAX_PATH];
DWORD ret;
HKEY hkey;
DWORD disposition;
LPBYTE auto_val=NULL;
DWORD auto_size, auto_type;
LPBYTE debugger_val=NULL;
DWORD debugger_size, debugger_type;
GetModuleFileNameA(GetModuleHandle(NULL), test_exe, sizeof(test_exe));
if (GetFileAttributes(test_exe) == INVALID_FILE_ATTRIBUTES)
strcat(test_exe, ".so");
if (GetFileAttributesA(test_exe) == INVALID_FILE_ATTRIBUTES)
{
ok(0, "could not find the test executable '%s'\n", test_exe);
return;
}
ret=RegCreateKeyExA(HKEY_LOCAL_MACHINE, AeDebug, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &disposition);
if (ret == ERROR_SUCCESS)
{
auto_size=0;
ret=RegQueryValueExA(hkey, "auto", NULL, &auto_type, NULL, &auto_size);
if (ret == ERROR_SUCCESS)
{
auto_val=HeapAlloc(GetProcessHeap(), 0, auto_size);
RegQueryValueExA(hkey, "auto", NULL, &auto_type, auto_val, &auto_size);
}
debugger_size=0;
ret=RegQueryValueExA(hkey, "debugger", NULL, &debugger_type, NULL, &debugger_size);
if (ret == ERROR_SUCCESS)
{
debugger_val=HeapAlloc(GetProcessHeap(), 0, debugger_size);
RegQueryValueExA(hkey, "debugger", NULL, &debugger_type, debugger_val, &debugger_size);
}
}
else if (ret == ERROR_ACCESS_DENIED)
{
skip("not enough privileges to change the debugger\n");
return;
}
else if (ret != ERROR_FILE_NOT_FOUND)
{
ok(0, "could not open the AeDebug key: %d\n", ret);
return;
}
if (debugger_val && debugger_type == REG_SZ &&
strstr((char*)debugger_val, "winedbg --auto"))
crash_and_winedbg(hkey, test_exe);
crash_and_debug(hkey, test_exe, "dbg,none");
crash_and_debug(hkey, test_exe, "dbg,event,order");
crash_and_debug(hkey, test_exe, "dbg,attach,event,code2");
if (pDebugSetProcessKillOnExit)
crash_and_debug(hkey, test_exe, "dbg,attach,event,nokill");
if (pDebugActiveProcessStop)
crash_and_debug(hkey, test_exe, "dbg,attach,event,detach");
if (disposition == REG_CREATED_NEW_KEY)
{
RegCloseKey(hkey);
RegDeleteKeyA(HKEY_LOCAL_MACHINE, AeDebug);
}
else
{
if (auto_val)
{
RegSetValueExA(hkey, "auto", 0, auto_type, auto_val, auto_size);
HeapFree(GetProcessHeap(), 0, auto_val);
}
else
RegDeleteValueA(hkey, "auto");
if (debugger_val)
{
RegSetValueExA(hkey, "debugger", 0, debugger_type, debugger_val, debugger_size);
HeapFree(GetProcessHeap(), 0, debugger_val);
}
else
RegDeleteValueA(hkey, "debugger");
RegCloseKey(hkey);
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% N T A c q u i r e T y p e C a c h e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% NTAcquireTypeCache() loads a Windows TrueType fonts.
%
% The format of the NTAcquireTypeCache method is:
%
% MagickBooleanType NTAcquireTypeCache(SplayTreeInfo *type_cache)
%
% A description of each parameter follows:
%
% o type_cache: A linked list of fonts.
%
*/
MagickExport MagickBooleanType NTAcquireTypeCache(SplayTreeInfo *type_cache,
ExceptionInfo *exception)
{
HKEY
reg_key = (HKEY) INVALID_HANDLE_VALUE;
LONG
res;
int
list_entries = 0;
char
buffer[MaxTextExtent],
system_root[MaxTextExtent],
font_root[MaxTextExtent];
DWORD
type,
system_root_length;
MagickBooleanType
status;
/*
Try to find the right Windows*\CurrentVersion key, the SystemRoot and
then the Fonts key
*/
res = RegOpenKeyExA (HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0, KEY_READ, ®_key);
if (res == ERROR_SUCCESS) {
system_root_length=sizeof(system_root)-1;
res = RegQueryValueExA(reg_key,"SystemRoot",NULL, &type,
(BYTE*) system_root, &system_root_length);
}
if (res != ERROR_SUCCESS) {
res = RegOpenKeyExA (HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion", 0, KEY_READ, ®_key);
if (res == ERROR_SUCCESS) {
system_root_length=sizeof(system_root)-1;
res = RegQueryValueExA(reg_key,"SystemRoot",NULL, &type,
(BYTE*)system_root, &system_root_length);
}
}
if (res == ERROR_SUCCESS)
res = RegOpenKeyExA (reg_key, "Fonts",0, KEY_READ, ®_key);
if (res != ERROR_SUCCESS)
return(MagickFalse);
*font_root='\0';
(void) CopyMagickString(buffer,system_root,MaxTextExtent);
(void) ConcatenateMagickString(buffer,"\\fonts\\arial.ttf",MaxTextExtent);
if (IsPathAccessible(buffer) != MagickFalse)
{
(void) CopyMagickString(font_root,system_root,MaxTextExtent);
(void) ConcatenateMagickString(font_root,"\\fonts\\",MaxTextExtent);
}
else
{
(void) CopyMagickString(font_root,system_root,MaxTextExtent);
(void) ConcatenateMagickString(font_root,"\\",MaxTextExtent);
}
{
TypeInfo
*type_info;
DWORD
registry_index = 0,
type,
value_data_size,
value_name_length;
char
value_data[MaxTextExtent],
value_name[MaxTextExtent];
res = ERROR_SUCCESS;
while (res != ERROR_NO_MORE_ITEMS)
{
char
*family_extent,
token[MaxTextExtent],
*pos,
*q;
value_name_length = sizeof(value_name) - 1;
value_data_size = sizeof(value_data) - 1;
res=RegEnumValueA(reg_key,registry_index,value_name,&value_name_length,
0,&type,(BYTE *) value_data,&value_data_size);
registry_index++;
if (res != ERROR_SUCCESS)
continue;
if ((pos=strstr(value_name," (TrueType)")) == (char*) NULL)
continue;
*pos='\0'; /* Remove (TrueType) from string */
type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));
if (type_info == (TypeInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(type_info,0,sizeof(TypeInfo));
type_info->path=ConstantString("Windows Fonts");
type_info->signature=MagickSignature;
(void) CopyMagickString(buffer,value_name,MaxTextExtent); /* name */
for (pos=buffer; *pos != 0; pos++)
if (*pos == ' ')
*pos='-';
type_info->name=ConstantString(buffer);
type_info->description=ConstantString(value_name); /* fullname */
type_info->format=ConstantString("truetype"); /* format */
if (strchr(value_data,'\\') != (char *) NULL) /* glyphs */
(void) CopyMagickString(buffer,value_data,MaxTextExtent);
else
{
(void) CopyMagickString(buffer,font_root,MaxTextExtent);
(void) ConcatenateMagickString(buffer,value_data,MaxTextExtent);
}
LocaleLower(buffer);
type_info->glyphs=ConstantString(buffer);
type_info->stretch=NormalStretch;
type_info->style=NormalStyle;
type_info->weight=400;
/*
Some fonts are known to require special encodings.
*/
if ( (LocaleCompare(type_info->name, "Symbol") == 0 ) ||
(LocaleCompare(type_info->name, "Wingdings") == 0 ) ||
(LocaleCompare(type_info->name, "Wingdings-2") == 0 ) ||
(LocaleCompare(type_info->name, "Wingdings-3") == 0 ) )
type_info->encoding=ConstantString("AppleRoman");
family_extent=value_name;
for (q=value_name; *q != '\0'; )
{
GetMagickToken(q,(const char **) &q,token);
if (*token == '\0')
break;
if (LocaleCompare(token,"Italic") == 0)
{
type_info->style=ItalicStyle;
}
else if (LocaleCompare(token,"Oblique") == 0)
{
type_info->style=ObliqueStyle;
}
else if (LocaleCompare(token,"Bold") == 0)
{
type_info->weight=700;
}
else if (LocaleCompare(token,"Thin") == 0)
{
type_info->weight=100;
}
else if ( (LocaleCompare(token,"ExtraLight") == 0) ||
(LocaleCompare(token,"UltraLight") == 0) )
{
type_info->weight=200;
}
else if (LocaleCompare(token,"Light") == 0)
{
type_info->weight=300;
}
else if ( (LocaleCompare(token,"Normal") == 0) ||
(LocaleCompare(token,"Regular") == 0) )
{
type_info->weight=400;
}
else if (LocaleCompare(token,"Medium") == 0)
{
type_info->weight=500;
}
else if ( (LocaleCompare(token,"SemiBold") == 0) ||
(LocaleCompare(token,"DemiBold") == 0) )
{
type_info->weight=600;
}
else if ( (LocaleCompare(token,"ExtraBold") == 0) ||
(LocaleCompare(token,"UltraBold") == 0) )
{
type_info->weight=800;
}
else if ( (LocaleCompare(token,"Heavy") == 0) ||
(LocaleCompare(token,"Black") == 0) )
{
type_info->weight=900;
}
else if (LocaleCompare(token,"Condensed") == 0)
{
type_info->stretch = CondensedStretch;
}
else if (LocaleCompare(token,"Expanded") == 0)
{
type_info->stretch = ExpandedStretch;
}
else if (LocaleCompare(token,"ExtraCondensed") == 0)
{
type_info->stretch = ExtraCondensedStretch;
}
else if (LocaleCompare(token,"ExtraExpanded") == 0)
{
type_info->stretch = ExtraExpandedStretch;
}
else if (LocaleCompare(token,"SemiCondensed") == 0)
{
type_info->stretch = SemiCondensedStretch;
}
else if (LocaleCompare(token,"SemiExpanded") == 0)
{
type_info->stretch = SemiExpandedStretch;
}
else if (LocaleCompare(token,"UltraCondensed") == 0)
{
type_info->stretch = UltraCondensedStretch;
}
else if (LocaleCompare(token,"UltraExpanded") == 0)
{
type_info->stretch = UltraExpandedStretch;
}
else
{
family_extent=q;
}
}
(void) CopyMagickString(buffer,value_name,family_extent-value_name+1);
StripString(buffer);
type_info->family=ConstantString(buffer);
list_entries++;
status=AddValueToSplayTree(type_cache,ConstantString(type_info->name),
type_info);
if (status == MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",type_info->name);
}
}
RegCloseKey(reg_key);
return(MagickTrue);
}
bool cmtScanPorts(List<CmtPortInfo>& ports,uint32_t baudrate, uint32_t singleScanTimeout, uint32_t scanTries)
{
CmtPortInfo current = {0,0,0};
ports.clear(); // clear the list
#ifdef _WIN32
HDEVINFO hDevInfo;
SP_DEVINFO_DATA DeviceInfoData;
DWORD i;
// Create a HDEVINFO with all present devices.
// GUID for Ports: 4D36E978-E325-11CE-BFC1-08002BE10318
GUID portGuid =
{0x4D36E978,0xE325,0x11CE,{0xBF,0xC1,0x08,0x00,0x2B,0xE1,0x03,0x18}};
// "4D36E978-E325-11CE-BFC1-08002BE10318"
hDevInfo = SetupDiGetClassDevs(&portGuid, 0, 0, DIGCF_PRESENT | DIGCF_PROFILE);
if (hDevInfo == INVALID_HANDLE_VALUE)
return false;
// Enumerate through all devices in Set.
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
for (i=0;!abortScan && SetupDiEnumDeviceInfo(hDevInfo,i,&DeviceInfoData);++i)
{
DWORD DataT;
char buffer[256];
bool isBT = false;
//
// Call function with null to begin with,
// then use the returned buffer size
// to Alloc the buffer. Keep calling until
// success or an unknown failure.
//
#if 1
if (SetupDiGetDeviceRegistryProperty(hDevInfo,
&DeviceInfoData,
SPDRP_MFG,
&DataT,
(PBYTE)buffer,
256,
NULL))
{
// on failure, this is not an Xsens Device
// on success, we need to check if the device is an Xsens Device
//if (_strnicmp(buffer,"xsens",5))
// scan = true;
//else
if (!_strnicmp(buffer,"(Standard port types)",20))
continue;
if (_strnicmp(buffer,"xsens",5)) // if this is NOT an xsens device, treat it as a BT device
{
isBT = true;
if (_strnicmp(buffer,"WIDCOMM",7)) // if this is NOT a WIDCOMM (Ezureo / TDK stack), skip it
continue;
}
}
#endif
// we found an Xsens Device, add its port nr to the list
//Get the registry key which stores the ports settings
HKEY hDeviceKey = SetupDiOpenDevRegKey(hDevInfo, &DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
if (hDeviceKey != INVALID_HANDLE_VALUE)
{
//Read in the name of the port
char pszPortName[256];
DWORD dwSize = 256;
DWORD dwType = 0;
if ((RegQueryValueExA(hDeviceKey, "PortName", NULL, &dwType, (LPBYTE) pszPortName, &dwSize) == ERROR_SUCCESS) && (dwType == REG_SZ))
{
//If it looks like "COMX" then
//add it to the array which will be returned
int32_t nLen = (int32_t) strlen(pszPortName);
if (nLen > 3)
{
if (_strnicmp(pszPortName, "COM", 3))
continue;
int32_t nPort = atoi(&pszPortName[3]);
if (nPort)
{
current.m_portNr = (uint8_t) nPort;
if (isBT)
current.m_baudrate = CMT_BAUD_RATE_460K8;
else
current.m_baudrate = baudrate;
ports.append(current);
}
}
}
}
//Close the key now that we are finished with it
RegCloseKey(hDeviceKey);
}
// Cleanup
SetupDiDestroyDeviceInfoList(hDevInfo);
// Now sort the list by ascending port nr
ports.sortAscending();
// Add the standard com ports 1 and 2 unless they are already in the list
bool add1 = true,
add2 = true;
if ((ports.length() > 0) && (ports[0].m_portNr == 1))
add1 = false;
if (ports.length() > 0)
{
if (ports[0].m_portNr == 2)
add2 = false;
else
if (ports.length() > 1)
if (ports[1].m_portNr == 2)
add2 = false;
}
if (add1)
{
current.m_portNr = 1;
current.m_baudrate = baudrate;
ports.append(current);
}
if (add2)
{
current.m_portNr = 2;
current.m_baudrate = baudrate;
ports.append(current);
}
#else
DIR *dir;
struct dirent *entry;
if ((dir = opendir("/dev/")) == NULL)
return false;
while ((entry = readdir(dir)))
if (strncmp("ttyS", entry->d_name, 4) == 0 || strncmp("ttyUSB", entry->d_name, 6) == 0)
{
sprintf(current.m_portName, "/dev/%s", entry->d_name);
current.m_baudrate = baudrate;
ports.append(current);
}
closedir(dir);
ports.sortAscending();
#endif
// try to connect so we can detect if there really is an MT / XM attached
unsigned p = 0;
while (!abortScan && p < ports.length())
{
if (cmtScanPort(ports[p],ports[p].m_baudrate,singleScanTimeout,scanTries))
++p;
else
ports.remove(p);
}
if (abortScan)
return abortScan = false;
// Now sort the final list by ascending port nr
ports.sortAscending();
abortScan = false;
return true;
}
VOID LoadSetting(ModeInfo *mi)
{
HKEY hCompanyKey, hSoftwareKey;
LONG result;
INT i;
CHAR szValue[256];
DWORD cb;
result = RegOpenKeyExA(HKEY_CURRENT_USER, pszCompany, 0,
KEY_READ, &hCompanyKey);
if (result != ERROR_SUCCESS)
return;
result = RegOpenKeyExA(hCompanyKey, progname, 0,
KEY_READ, &hSoftwareKey);
if (result == ERROR_SUCCESS)
{
// load count
cb = 256 * sizeof(CHAR);
result = RegQueryValueExA(hSoftwareKey,
"count", NULL, NULL, szValue, &cb);
if (result == ERROR_SUCCESS)
mi->count = strtol(szValue, NULL, 10);
// load cycles
cb = 256 * sizeof(CHAR);
result = RegQueryValueExA(hSoftwareKey,
"cycles", NULL, NULL, szValue, &cb);
if (result == ERROR_SUCCESS)
mi->cycles = strtol(szValue, NULL, 10);
// load size
cb = 256 * sizeof(CHAR);
result = RegQueryValueExA(hSoftwareKey,
"size", NULL, NULL, szValue, &cb);
if (result == ERROR_SUCCESS)
mi->size = strtol(szValue, NULL, 10);
// load args
for (i = 0; i < hack_argcount; i++)
{
cb = 256 * sizeof(CHAR);
result = RegQueryValueExA(hSoftwareKey,
hack_arginfo[i].name, NULL, NULL, szValue, &cb);
if (result == ERROR_SUCCESS)
{
switch (hack_arginfo[i].type)
{
case t_Bool:
if (lstrcmpiA(szValue, "True") == 0 || lstrcmpiA(szValue, "1") == 0)
*(Bool *)hack_arginfo[i].data = True;
if (lstrcmpiA(szValue, "False") == 0 || lstrcmpiA(szValue, "0") == 0)
*(Bool *)hack_arginfo[i].data = False;
break;
case t_Int:
*(INT *)hack_arginfo[i].data = strtol(szValue, NULL, 10);
break;
case t_Float:
*(float *)hack_arginfo[i].data = strtod(szValue, NULL);
break;
case t_String:
*(char **)hack_arginfo[i].data = _strdup(szValue);
break;
}
}
}
RegCloseKey(hSoftwareKey);
}
RegCloseKey(hCompanyKey);
}
NTLM_CONTEXT* ntlm_ContextNew()
{
HKEY hKey;
LONG status;
DWORD dwType;
DWORD dwSize;
DWORD dwValue;
NTLM_CONTEXT* context;
context = (NTLM_CONTEXT*) calloc(1, sizeof(NTLM_CONTEXT));
if (!context)
return NULL;
context->NTLMv2 = TRUE;
context->UseMIC = FALSE;
context->SendVersionInfo = TRUE;
context->SendSingleHostData = FALSE;
context->SendWorkstationName = TRUE;
status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\WinPR\\NTLM"), 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
if (status == ERROR_SUCCESS)
{
if (RegQueryValueEx(hKey, _T("NTLMv2"), NULL, &dwType, (BYTE*) &dwValue, &dwSize) == ERROR_SUCCESS)
context->NTLMv2 = dwValue ? 1 : 0;
if (RegQueryValueEx(hKey, _T("UseMIC"), NULL, &dwType, (BYTE*) &dwValue, &dwSize) == ERROR_SUCCESS)
context->UseMIC = dwValue ? 1 : 0;
if (RegQueryValueEx(hKey, _T("SendVersionInfo"), NULL, &dwType, (BYTE*) &dwValue, &dwSize) == ERROR_SUCCESS)
context->SendVersionInfo = dwValue ? 1 : 0;
if (RegQueryValueEx(hKey, _T("SendSingleHostData"), NULL, &dwType, (BYTE*) &dwValue, &dwSize) == ERROR_SUCCESS)
context->SendSingleHostData = dwValue ? 1 : 0;
if (RegQueryValueEx(hKey, _T("SendWorkstationName"), NULL, &dwType, (BYTE*) &dwValue, &dwSize) == ERROR_SUCCESS)
context->SendWorkstationName = dwValue ? 1 : 0;
if (RegQueryValueEx(hKey, _T("WorkstationName"), NULL, &dwType, NULL, &dwSize) == ERROR_SUCCESS)
{
char* workstation = (char*) malloc(dwSize + 1);
if (!workstation)
return NULL;
status = RegQueryValueExA(hKey, "WorkstationName", NULL, &dwType, (BYTE*) workstation, &dwSize);
workstation[dwSize] = '\0';
if (ntlm_SetContextWorkstation(context, workstation) < 0)
return NULL;
free(workstation);
}
RegCloseKey(hKey);
}
/*
* Extended Protection is enabled by default in Windows 7,
* but enabling it in WinPR breaks TS Gateway at this point
*/
context->SuppressExtendedProtection = FALSE;
status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("System\\CurrentControlSet\\Control\\LSA"), 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
if (status == ERROR_SUCCESS)
{
if (RegQueryValueEx(hKey, _T("SuppressExtendedProtection"), NULL, &dwType, (BYTE*) &dwValue, &dwSize) == ERROR_SUCCESS)
context->SuppressExtendedProtection = dwValue ? 1 : 0;
RegCloseKey(hKey);
}
context->NegotiateFlags = 0;
context->LmCompatibilityLevel = 3;
context->state = NTLM_STATE_INITIAL;
FillMemory(context->MachineID, sizeof(context->MachineID), 0xAA);
if (context->NTLMv2)
context->UseMIC = TRUE;
return context;
}
bool NTRegQuery::readValueSize(const char* value)
{
m_value = value;
return RegQueryValueExA(m_hKey, value, NULL, &m_dwType, NULL, &m_dwSize) == ERROR_SUCCESS;
}
/***********************************************************************
* VideoCapDriverDescAndVer [MSVIDEO.22]
*/
DWORD WINAPI VideoCapDriverDescAndVer16(WORD nr, LPSTR buf1, WORD buf1len,
LPSTR buf2, WORD buf2len)
{
static const char version_info_spec[] = "\\StringFileInfo\\040904E4\\FileDescription";
DWORD verhandle;
DWORD infosize;
UINT subblocklen;
char *s, buf[2048], fn[260];
LPBYTE infobuf;
LPVOID subblock;
DWORD i, cnt = 0, lRet;
DWORD bufLen, fnLen;
FILETIME lastWrite;
HKEY hKey;
BOOL found = FALSE;
TRACE("(%d,%p,%d,%p,%d)\n", nr, buf1, buf1len, buf2, buf2len);
lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_DRIVERS32, 0, KEY_QUERY_VALUE, &hKey);
if (lRet == ERROR_SUCCESS)
{
RegQueryInfoKeyA( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
for (i = 0; i < cnt; i++)
{
bufLen = sizeof(buf) / sizeof(buf[0]);
lRet = RegEnumKeyExA(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite);
if (lRet != ERROR_SUCCESS) continue;
if (strncasecmp(buf, "vid", 3)) continue;
if (nr--) continue;
fnLen = sizeof(fn);
lRet = RegQueryValueExA(hKey, buf, 0, 0, (LPBYTE)fn, &fnLen);
if (lRet == ERROR_SUCCESS) found = TRUE;
break;
}
RegCloseKey( hKey );
}
/* search system.ini if not found in the registry */
if (!found && GetPrivateProfileStringA("drivers32", NULL, NULL, buf, sizeof(buf), "system.ini"))
{
for (s = buf; *s; s += strlen(s) + 1)
{
if (strncasecmp(s, "vid", 3)) continue;
if (nr--) continue;
if (GetPrivateProfileStringA("drivers32", s, NULL, fn, sizeof(fn), "system.ini"))
found = TRUE;
break;
}
}
if (!found)
{
TRACE("No more VID* entries found nr=%d\n", nr);
return 20;
}
infosize = GetFileVersionInfoSizeA(fn, &verhandle);
if (!infosize)
{
TRACE("%s has no fileversioninfo.\n", fn);
return 18;
}
infobuf = HeapAlloc(GetProcessHeap(), 0, infosize);
if (GetFileVersionInfoA(fn, verhandle, infosize, infobuf))
{
/* Yes, two space behind : */
/* FIXME: test for buflen */
snprintf(buf2, buf2len, "Version: %d.%d.%d.%d\n",
((WORD*)infobuf)[0x0f],
((WORD*)infobuf)[0x0e],
((WORD*)infobuf)[0x11],
((WORD*)infobuf)[0x10]
);
TRACE("version of %s is %s\n", fn, buf2);
}
else
{
TRACE("GetFileVersionInfoA failed for %s.\n", fn);
lstrcpynA(buf2, fn, buf2len); /* msvideo.dll appears to copy fn*/
}
/* FIXME: language problem? */
if (VerQueryValueA( infobuf,
version_info_spec,
&subblock,
&subblocklen
))
{
UINT copylen = min(subblocklen,buf1len-1);
memcpy(buf1, subblock, copylen);
buf1[copylen] = '\0';
TRACE("VQA returned %s\n", (LPCSTR)subblock);
}
else
{
TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n");
lstrcpynA(buf1, fn, buf1len); /* msvideo.dll appears to copy fn*/
}
HeapFree(GetProcessHeap(), 0, infobuf);
return 0;
}
/**************************************************************************
* SmoothScrollWindow [COMCTL32.382]
*
* Lots of magic for smooth scrolling windows.
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
* BUGS
* Currently only scrolls ONCE. The comctl32 implementation uses GetTickCount
* and what else to do smooth scrolling.
*/
BOOL WINAPI SmoothScrollWindow( const SMOOTHSCROLLSTRUCT *smooth ) {
LPRECT lpupdaterect = smooth->lpupdaterect;
HRGN hrgnupdate = smooth->hrgnupdate;
RECT tmprect;
DWORD flags = smooth->flags;
if (smooth->dwSize!=sizeof(SMOOTHSCROLLSTRUCT))
return FALSE;
if (!lpupdaterect)
lpupdaterect = &tmprect;
SetRectEmpty(lpupdaterect);
if (!(flags & 0x40000)) { /* no override, use system wide defaults */
if (smoothscroll == 2) {
HKEY hkey;
smoothscroll = 0;
if (!RegOpenKeyA(HKEY_CURRENT_USER,"Control Panel\\Desktop",&hkey)) {
DWORD len = 4;
RegQueryValueExA(hkey,"SmoothScroll",0,0,(LPBYTE)&smoothscroll,&len);
RegCloseKey(hkey);
}
}
if (!smoothscroll)
flags |= 0x20000;
}
if (flags & 0x20000) { /* are we doing jump scrolling? */
if ((smooth->x2 & 1) && smooth->scrollfun)
return smooth->scrollfun(
smooth->hwnd,smooth->dx,smooth->dy,smooth->lpscrollrect,
smooth->lpcliprect,hrgnupdate,lpupdaterect,
flags & 0xffff
);
else
return ScrollWindowEx(
smooth->hwnd,smooth->dx,smooth->dy,smooth->lpscrollrect,
smooth->lpcliprect,hrgnupdate,lpupdaterect,
flags & 0xffff
);
}
FIXME("(hwnd=%p,flags=%x,x2=%x): should smooth scroll here.\n",
smooth->hwnd,flags,smooth->x2
);
/* FIXME: do timer based smooth scrolling */
if ((smooth->x2 & 1) && smooth->scrollfun)
return smooth->scrollfun(
smooth->hwnd,smooth->dx,smooth->dy,smooth->lpscrollrect,
smooth->lpcliprect,hrgnupdate,lpupdaterect,
flags & 0xffff
);
else
return ScrollWindowEx(
smooth->hwnd,smooth->dx,smooth->dy,smooth->lpscrollrect,
smooth->lpcliprect,hrgnupdate,lpupdaterect,
flags & 0xffff
);
}