int CControlPanelEnum::RegisterRegistryCPanelApps(HKEY hkey_root, LPCSTR szRepPath)
{
char name[MAX_PATH];
char value[MAX_PATH];
HKEY hkey;
int cnt = 0;
if (RegOpenKeyA(hkey_root, szRepPath, &hkey) == ERROR_SUCCESS)
{
int idx = 0;
for(; ; idx++)
{
DWORD nameLen = MAX_PATH;
DWORD valueLen = MAX_PATH;
if (RegEnumValueA(hkey, idx, name, &nameLen, NULL, NULL, (LPBYTE)&value, &valueLen) != ERROR_SUCCESS)
break;
if (RegisterCPanelApp(value))
++cnt;
}
RegCloseKey(hkey);
}
return cnt;
}
static int SHELL_RegisterRegistryCPanelApps(IEnumIDList* list, HKEY hkey_root, LPCSTR szRepPath)
{
char name[MAX_PATH];
char value[MAX_PATH];
HKEY hkey;
int cnt = 0;
if (RegOpenKeyA(hkey_root, szRepPath, &hkey) == ERROR_SUCCESS)
{
int idx = 0;
for(;; ++idx)
{
DWORD nameLen = MAX_PATH;
DWORD valueLen = MAX_PATH;
if (RegEnumValueA(hkey, idx, name, &nameLen, NULL, NULL, (LPBYTE)&value, &valueLen) != ERROR_SUCCESS)
break;
if (SHELL_RegisterCPanelApp(list, value))
++cnt;
}
RegCloseKey(hkey);
}
return cnt;
}
QStringList QSettingsPrivate::sysEntryList( const QString &key ) const
{
QString value;
QStringList list;
HKEY hkey = sysd->openKey( key + "\\", KEY_QUERY_VALUE, value, globalScope );
if ( hkey ) {
int idx = 0;
unsigned long count = QT_WA_INLINE( 16383, 260 );
QByteArray ba( ( count + 1 ) * sizeof( TCHAR ) );
while ( QT_WA_INLINE(
RegEnumValueW( hkey, idx, ( LPTSTR ) ba.data(),
&count, NULL, NULL, NULL, NULL ),
RegEnumValueA( hkey, idx, ( LPSTR ) ba.data(),
&count, NULL, NULL, NULL, NULL ) )
== ERROR_SUCCESS ) {
list.append ( QT_WA_INLINE( QString::fromUcs2( ( unsigned short * ) ba.data() ),
QString::fromLatin1( ( LPCSTR ) ba.data() ) ) );
idx++;
count = QT_WA_INLINE( 16383, 260 ); /* !! */
}
RegCloseKey( hkey );
}
return list;
}
/* CLSIDFromProgID is a bit too naive, so I wrote it myself */
HRESULT primCLSIDFromProgID( const char* progid, CLSID* clsid )
{
HRESULT hr;
char name[MAXSZ];
DWORD namesz = MAXSZ;
BYTE value[MAXSZ];
DWORD valuesz = MAXSZ;
WCHAR clsidName[MAXSZ];
DWORD type = REG_SZ;
HKEY key = 0;
HKEY subkey = 0;
if (!clsid) return E_POINTER;
if (!progid) return E_POINTER;
hr = HRESULT_FROM_WIN32(RegOpenKeyExA( HKEY_CLASSES_ROOT, progid, 0, KEY_READ, &key ));
if (FAILED(hr)) return CO_E_CLASSSTRING;
hr = HRESULT_FROM_WIN32(RegOpenKeyExA( key, "CurVer", 0, KEY_READ, &subkey ));
if (SUCCEEDED(hr))
{
hr = HRESULT_FROM_WIN32(RegEnumValueA( subkey, 0, name, &namesz, NULL, &type, value, &valuesz));
RegCloseKey( key );
RegCloseKey( subkey );
if (FAILED(hr)) return hr;
hr = HRESULT_FROM_WIN32(RegOpenKeyExA( HKEY_CLASSES_ROOT, (char*)value, 0, KEY_QUERY_VALUE, &key ));
if (FAILED(hr)) return CO_E_CLASSSTRING;
namesz = MAXSZ;
valuesz = MAXSZ;
}
hr = HRESULT_FROM_WIN32(RegOpenKeyExA( key, "CLSID", 0, KEY_READ, &subkey ));
if (FAILED(hr)) { RegCloseKey( key ); return CO_E_CLSREG_INCONSISTENT; };
hr = HRESULT_FROM_WIN32(RegEnumValueA( subkey, 0, name, &namesz, NULL, &type,value,&valuesz));
RegCloseKey( subkey );
RegCloseKey( key );
if (FAILED(hr)) return hr;
mbstowcs( clsidName, (char*)value, MAXSZ );
hr = CLSIDFromString( clsidName, clsid );
return hr;
}
void ZLWin32Config::collectValues(std::set<std::string> &valueSet, HKEY key) {
DWORD index = 0;
DWORD len = myBufferSize;
while (RegEnumValueA(key, index, myBuffer, &len, 0, 0, 0, 0) == ERROR_SUCCESS) {
valueSet.insert(myBuffer);
++index;
len = myBufferSize;
}
}
const char *VDRegistryValueIterator::Next() {
DWORD len = sizeof(mName)/sizeof(mName[0]);
LONG error = RegEnumValueA((HKEY)mpHandle, mIndex, mName, &len, NULL, NULL, NULL, NULL);
if (error)
return NULL;
++mIndex;
return mName;
}
BOOL My_RegEnumValueA()
{
HKEY hKey=NULL;
DWORD dwIndex=NULL;
LPSTR lpValueName=NULL;
LPDWORD lpcbValueName=NULL;
LPDWORD lpReserved=NULL;
LPDWORD lpType=NULL;
LPBYTE lpData=NULL;
LPDWORD lpcbData=NULL;
LONG returnVal_Real = NULL;
LONG returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
disableInterception();
returnVal_Real = RegEnumValueA (hKey,dwIndex,lpValueName,lpcbValueName,lpReserved,lpType,lpData,lpcbData);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = RegEnumValueA (hKey,dwIndex,lpValueName,lpcbValueName,lpReserved,lpType,lpData,lpcbData);
error_Intercepted = GetLastError();
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}
void WinRegistryKey::values(WinRegistryKey::Values& vals) {
Exception ex; // ignore here
if (!open(ex))
return;
DWORD valueCount = 0;
if (RegQueryInfoKey(_hKey, NULL, NULL, NULL, NULL, NULL, NULL, &valueCount, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
return;
char buf[256];
DWORD bufSize = sizeof(buf);
for (DWORD i = 0; i< valueCount; ++i)
{
if (RegEnumValueA(_hKey, i, buf, &bufSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
vals.emplace_back(buf);
bufSize = sizeof(buf);
}
}
static BOOL enum_drivers(DWORD fccType, enum_handler_t handler, void* param)
{
CHAR buf[2048], fccTypeStr[5], *s;
DWORD i, cnt = 0, lRet;
BOOL result = FALSE;
HKEY hKey;
fourcc_to_string(fccTypeStr, fccType);
fccTypeStr[4] = '.';
/* first, go through the registry entries */
lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_DRIVERS32, 0, KEY_QUERY_VALUE, &hKey);
if (lRet == ERROR_SUCCESS)
{
DWORD name, data, type;
i = 0;
for (;;)
{
name = 10;
data = sizeof buf - name;
lRet = RegEnumValueA(hKey, i++, buf, &name, 0, &type, (LPBYTE)(buf+name), &data);
if (lRet == ERROR_NO_MORE_ITEMS) break;
if (lRet != ERROR_SUCCESS) continue;
if (name != 9 || strncasecmp(buf, fccTypeStr, 5)) continue;
buf[name] = '=';
if ((result = handler(buf, cnt++, param))) break;
}
RegCloseKey( hKey );
}
if (result) return result;
/* if that didn't work, go through the values in system.ini */
if (GetPrivateProfileSectionA("drivers32", buf, sizeof(buf), "system.ini"))
{
for (s = buf; *s; s += strlen(s) + 1)
{
TRACE("got %s\n", s);
if (strncasecmp(s, fccTypeStr, 5) || s[9] != '=') continue;
if ((result = handler(s, cnt++, param))) break;
}
}
return result;
}
LONG WINAPI TTIsEmbeddingEnabledForFacename(LPCSTR facename, BOOL *enabled)
{
static const WCHAR exclusionlistW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
'S','h','a','r','e','d',' ','T','o','o','l','s','\\','t','2','e','m','b','e','d',0};
DWORD index;
HKEY hkey;
LONG ret;
TRACE("(%s %p)\n", debugstr_a(facename), enabled);
if (!facename)
return E_FACENAMEINVALID;
if (!enabled)
return E_PBENABLEDINVALID;
*enabled = TRUE;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, exclusionlistW, 0, GENERIC_READ, &hkey))
return E_NONE;
*enabled = TRUE;
ret = ERROR_SUCCESS;
index = 0;
while (ret != ERROR_NO_MORE_ITEMS)
{
DWORD name_len, value_len, value, type;
CHAR name[LF_FACESIZE];
name_len = sizeof(name)/sizeof(*name);
value_len = sizeof(value);
ret = RegEnumValueA(hkey, index++, name, &name_len, NULL, &type, (BYTE*)&value, &value_len);
if (ret || type != REG_DWORD)
continue;
if (!lstrcmpiA(name, facename))
{
*enabled = !!value;
break;
}
}
RegCloseKey(hkey);
return E_NONE;
}
static BOOL enum_drivers(DWORD fccType, enum_handler_t handler, void* param)
{
char fccTypeStr[4];
char name_buf[10];
char buf[2048];
DWORD i, cnt = 0, lRet;
BOOL result = FALSE;
HKEY hKey;
fourcc_to_string(fccTypeStr, fccType);
/* first, go through the registry entries */
lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_DRIVERS32, 0, KEY_QUERY_VALUE, &hKey);
if (lRet == ERROR_SUCCESS)
{
i = 0;
for (;;)
{
DWORD name_len = 10, driver_len = 128;
lRet = RegEnumValueA(hKey, i++, name_buf, &name_len, 0, 0, (BYTE *)buf, &driver_len);
if (lRet == ERROR_NO_MORE_ITEMS) break;
if (name_len != 9 || name_buf[4] != '.') continue;
if (fccType && strncasecmp(name_buf, fccTypeStr, 4)) continue;
if ((result = handler(name_buf, buf, cnt++, param))) break;
}
RegCloseKey( hKey );
}
if (result) return result;
/* if that didn't work, go through the values in system.ini */
if (GetPrivateProfileSectionA("drivers32", buf, sizeof(buf), "system.ini"))
{
char *s;
for (s = buf; *s; s += strlen(s) + 1)
{
if (s[4] != '.' || s[9] != '=') continue;
if (fccType && strncasecmp(s, fccTypeStr, 4)) continue;
if ((result = handler(s, s + 10, cnt++, param))) break;
}
}
return result;
}
int CGlobalSettings::EnumGlobalValues(const char *product, const char *key, int value_num, char *value, int value_len, char *buffer, int buffer_len)
{
HKEY hKey,hSubKey;
DWORD dwType,dwLen,dwValLen;
DWORD dwRes;
cvs::string regkey;
if(!product || !strcmp(product,"cvsnt"))
regkey="Software\\CVS";
else
cvs::sprintf(regkey,64,"Software\\March Hare Software Ltd\\%s",product);
if(RegOpenKeyExA(HKEY_LOCAL_MACHINE,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;
}
dwLen=buffer_len;
dwValLen=value_len;
if((dwRes=RegEnumValueA(hKey,value_num,value,&dwValLen,NULL,&dwType,(LPBYTE)buffer,&dwLen))!=0 && dwRes!=234)
{
RegCloseKey(hKey);
return -1;
}
RegCloseKey(hKey);
if(dwType==REG_DWORD && buffer)
sprintf(buffer,"%u",*(DWORD*)buffer);
return 0;
}
void WinRegistryKey::values(WinRegistryKey::Values& vals)
{
open();
DWORD valueCount = 0;
if (RegQueryInfoKey(_hKey, NULL, NULL, NULL, NULL, NULL, NULL, &valueCount, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
return ;
#if defined(POCO_WIN32_UTF8)
wchar_t buf[256];
DWORD bufSize = sizeof(buf)/sizeof(wchar_t);
for (DWORD i = 0; i< valueCount; ++i)
{
if (RegEnumValueW(_hKey, i, buf, &bufSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
std::wstring uname(buf);
std::string name;
Poco::UnicodeConverter::toUTF8(uname, name);
vals.push_back(name);
}
bufSize = sizeof(buf)/sizeof(wchar_t);
}
#else
char buf[256];
DWORD bufSize = sizeof(buf);
for (DWORD i = 0; i< valueCount; ++i)
{
if (RegEnumValueA(_hKey, i, buf, &bufSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
std::string name(buf);
vals.push_back(name);
}
bufSize = sizeof(buf);
}
#endif
}
UINT WINAPI WNetEnumCachedPasswords(
LPSTR pbPrefix, /* [in] prefix to filter cache entries */
WORD cbPrefix, /* [in] number of bytes in Prefix substring */
BYTE nType, /* [in] match the Type ID of the entry */
ENUMPASSWORDPROC enumPasswordProc, /* [in] callback function */
DWORD param) /* [in] parameter passed to enum function */
{
HKEY hkey;
DWORD r, type, val_sz, data_sz, i, j, size;
PASSWORD_CACHE_ENTRY *entry;
CHAR val[256], prefix[6];
WARN( "(%s, %d, %d, %p, 0x%08x) totally insecure\n",
debugstr_an(pbPrefix,cbPrefix), cbPrefix,
nType, enumPasswordProc, param );
/* @@ Wine registry key: HKCU\Software\Wine\Wine\Mpr */
r = RegCreateKeyA( HKEY_CURRENT_USER, mpr_key, &hkey );
if( r )
return WN_ACCESS_DENIED;
sprintf(prefix, "X-%02X-", nType );
for( i=0; ; i++ )
{
val_sz = sizeof val;
data_sz = 0;
type = 0;
val[0] = 0;
r = RegEnumValueA( hkey, i, val, &val_sz, NULL, &type, NULL, &data_sz );
if( r != ERROR_SUCCESS )
break;
if( type != REG_BINARY )
continue;
/* check the value is in the format we expect */
if( val_sz < sizeof prefix )
continue;
if( memcmp( prefix, val, 5 ) )
continue;
/* decode the value */
for(j=5; j<val_sz; j+=2 )
{
signed char hi = ctox( val[j] ), lo = ctox( val[j+1] );
if( ( hi < 0 ) || ( lo < 0 ) )
break;
val[(j-5)/2] = (hi<<4) | lo;
}
/* find the decoded length */
val_sz = (j - 5)/2;
val[val_sz]=0;
if( val_sz < cbPrefix )
continue;
/* check the prefix matches */
if( memcmp(val, pbPrefix, cbPrefix) )
continue;
/* read the value data */
size = sizeof *entry - sizeof entry->abResource[0] + val_sz + data_sz;
entry = HeapAlloc( GetProcessHeap(), 0, sizeof *entry + val_sz + data_sz );
memcpy( entry->abResource, val, val_sz );
entry->cbEntry = size;
entry->cbResource = val_sz;
entry->cbPassword = data_sz;
entry->iEntry = i;
entry->nType = nType;
r = RegEnumValueA( hkey, i, NULL, &val_sz, NULL, &type,
&entry->abResource[val_sz], &data_sz );
if( r == ERROR_SUCCESS )
enumPasswordProc( entry, param );
HeapFree( GetProcessHeap(), 0, entry );
}
RegCloseKey( hkey );
return WN_SUCCESS;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% 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);
}
int subsurface_fill_device_list(GtkListStore *store)
{
const int bufdef = 512;
const char *dlabels[] = {"UEMISSDA", NULL};
const char *devdef = "COM1";
GtkTreeIter iter;
int index = -1, nentries = 0, ret, i;
char bufname[bufdef], bufval[bufdef], *p;
DWORD nvalues, bufval_len, bufname_len;
HKEY key;
/* add serial ports */
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\SERIALCOMM",
0, KEY_READ, &key);
if (ret == ERROR_SUCCESS) {
ret = RegQueryInfoKeyA(key, NULL, NULL, NULL, NULL, NULL, NULL, &nvalues,
NULL, NULL, NULL, NULL);
if (ret == ERROR_SUCCESS)
for (i = 0; i < nvalues; i++) {
memset(bufval, 0, bufdef);
memset(bufname, 0, bufdef);
bufname_len = bufdef;
bufval_len = bufdef;
ret = RegEnumValueA(key, i, bufname, &bufname_len, NULL, NULL, bufval,
&bufval_len);
if (ret == ERROR_SUCCESS) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, bufval, -1);
if (is_default_dive_computer_device(bufval))
index = nentries;
nentries++;
}
}
}
/* add drive letters that match labels */
memset(bufname, 0, bufdef);
bufname_len = bufdef;
if (GetLogicalDriveStringsA(bufname_len, bufname)) {
p = bufname;
while (*p) {
memset(bufval, 0, bufdef);
if (GetVolumeInformationA(p, bufval, bufdef, NULL, NULL, NULL, NULL, 0)) {
for (i = 0; dlabels[i] != NULL; i++)
if (!strcmp(bufval, dlabels[i])) {
char name[80];
snprintf(name, sizeof(name), "%s (%s)", p, dlabels[i]);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, name, -1);
if (is_default_dive_computer_device(p))
index = nentries;
nentries++;
}
}
p = &p[strlen(p) + 1];
}
}
/* if we can't find anything, use the default */
if (!nentries) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
0, devdef, -1);
if (is_default_dive_computer_device(devdef))
index = 0;
}
return index;
}
int registry_walker(HKEY hkey, const char * section, struct a6o_conf * conf){
int ret = 0;
HKEY hSubKey = NULL;
char * subkey_name = NULL;
int subkey_maxlen = 0;
int subkey_len = 0;
char * class = NULL;
char * value_name = NULL;
int value_len = 0;
int value_maxlen = 0;
int value_type =0;
int data_len = 0;
char * data_str = NULL;
int data_int = 0;
char ** data_list = NULL;
char * tmp = NULL;
int list_len = 0;
int class_len = 0;
int class_maxlen = 0;
int res = 0;
int nb_index = 0, i =0,j=0;
int nbvalues = 0;
struct conf_reg_data data = {0};
if (hkey == NULL) {
printf("[-] Error :: registry_walker :: invalid parameter!\n");
return -1;
}
__try {
res = RegQueryInfoKeyA(hkey, NULL, &class_len, NULL, &nb_index, &subkey_maxlen, &class_maxlen, &nbvalues, &value_maxlen, NULL,NULL,NULL);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegEnumKeyExA failed! :: GLE= %d\n", res);
ret = -3;
__leave;
}
//printf("[+] Debug :: nbindex = %d :: nbvalues = %d\n",nb_index,nbvalues);
//printf("[+] Debug :: subkey_maxlen = %d :: index = %d :: class_maxlen = %d :: nbvalues = %d\n",subkey_maxlen ,nb_index, class_maxlen, nbvalues);
value_maxlen++;
value_name = (char *)calloc(value_maxlen + 1, sizeof(char));
// Get values.
for (i = 0; i < nbvalues; i++) {
value_len = value_maxlen;
if ((res = RegEnumValueA(hkey, i, value_name, &value_len, NULL, &value_type, NULL, &data_len)) != ERROR_SUCCESS) {
printf("[-] Error :: RegEnumValueA failed! :: GLE= %d\n", res);
ret = -3;
__leave;
}
// get data.
switch (value_type) {
case REG_DWORD:
if ((res = RegGetValueA(hkey,NULL,value_name,RRF_RT_ANY, NULL, &data_int,&data_len)) != ERROR_SUCCESS ) {
printf("[-] Error :: RegEnumValueA failed! :: GLE= %d\n", res);
break;
}
//printf("[+] Debug :: value_name = %s :: value_type = %d :: data_len = %d :: data_int = %d\n",value_name,value_type,data_len,data_int );
//printf("[+] Debug :: (%s) => %d\n",value_name,data_int );
// add value to conf struct
if (section != NULL)
a6o_conf_add_uint(conf, section, value_name, data_int);
break;
case REG_SZ:
//printf("[+] Debug :: value_name = %s :: value_type = %d :: data_len = %d\n",value_name,value_type,data_len );
data_str = (char *)calloc(data_len + 1, sizeof(char));
if ((res = RegGetValueA(hkey,NULL,value_name,RRF_RT_ANY, NULL,data_str,&data_len)) != ERROR_SUCCESS ) {
printf("[-] Error :: RegEnumValueA failed! :: GLE= %d\n", res);
break;
}
//printf("[+] Debug :: (%s) => %s\n",value_name,data_str);
if (section != NULL)
a6o_conf_add_string(conf, section, value_name, data_str);
break;
case REG_MULTI_SZ:
//data_string
//printf("[+] Debug :: value_name = %s :: value_type = %d :: data_len = %d\n",value_name,value_type,data_len );
data_str = (char *)calloc(data_len + 1, sizeof(char));
if ((res = RegGetValueA(hkey,NULL,value_name,RRF_RT_ANY, NULL,data_str,&data_len)) != ERROR_SUCCESS ) {
printf("[-] Error :: RegEnumValueA failed! :: GLE= %d\n", res);
break;
}
//printf("[+] Debug :: [%s] => %s\n",value_name,data_str);
//printf("[+] Debug :: (%s) =>\n",value_name);
list_len = 0;
tmp = data_str;
for (; *tmp != '\0'; tmp += strnlen(tmp,MAX_PATH)+1) {
//printf("\t\tvalue = %s\n",tmp);
list_len++;
}
///printf("\n");
data_list = (char**)calloc(list_len, sizeof(char*));
tmp = data_str;
j = 0;
//printf("list_len = %d\n",list_len);
for (; *tmp != '\0'; tmp += strnlen(tmp, MAX_PATH) + 1) {
data_list[j] = (char*)calloc(strnlen(tmp, MAX_PATH) + 1,sizeof(char));
memcpy(data_list[j],tmp,strnlen(tmp, MAX_PATH) + 1);
//printf("\tvalue = %s\n",data_list[j]);
j++;
}
if (section != NULL)
a6o_conf_add_list(conf, section, value_name, data_list, list_len);
if (data_list != NULL) {
for (j = 0; j < list_len; j++) {
free(data_list[j]);
data_list[j] = NULL;
}
free(data_list);
data_list = NULL;
}
if (data_str != NULL) {
free(data_str);
data_str = NULL;
}
break;
default:
//printf("[+] Debug :: value_name = %s :: value_type = %d :: data_len = %d\n",value_name,value_type,data_len );
break;
}
}
// Get subkeys
subkey_maxlen++; // add null terminating character.
subkey_name = (char *)calloc(subkey_maxlen + 1, sizeof(char));
for (i = 0; i < nb_index; i++) {
subkey_len = subkey_maxlen;
res = RegEnumKeyExA(hkey, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
if (res != ERROR_SUCCESS) {
printf("[-] Error :: RegEnumKeyExA failed! :: GLE= %d\n", res);
ret = -3;
__leave;
}
printf("[+] Debug :: section = [%s]\n",subkey_name);
//printf("[+] Debug :: sub_key_name = [%s] :: sub_key_len = %d :: class_len = %d\n",subkey_name, subkey_len,class_len);
if ((res = RegOpenKeyA(hkey,subkey_name, &hSubKey)) != ERROR_SUCCESS) {
printf("[-] Error :: RegOpenKeyA failed! :: GLE= %d\n", res);
ret = -2;
__leave;
}
registry_walker(hSubKey,subkey_name,conf);
//printf("\n\n");
}
}
__finally {
if (subkey_name != NULL) {
free(subkey_name);
subkey_name = NULL;
}
if (value_name != NULL) {
free(value_name);
value_name = NULL;
}
if (hSubKey != NULL) {
RegCloseKey(hSubKey);
hSubKey = NULL;
}
if (data_str != NULL) {
free(data_str);
data_str = NULL;
}
if (data_list != NULL) {
for (j = 0; j < list_len; j++) {
free(data_list[j]);
data_list[j] = NULL;
}
free(data_list);
data_list = NULL;
}
}
return ret;
}
std::vector<J2534Library> J2534_API::searchLibValuesRecursive(HKEY hKey, std::vector<J2534Library> PTlibs)
{
HKEY hKey2;
DWORD index = 0;
char KeyName[256] = "";
J2534Library PTlib;
PTlib.api = J2534_API_v0404;
char ValueName[256] = "";
unsigned long szValueName = 256;// variable that specifies the size (in characters, including the terminating null char) of the buffer pointed to by the "ValueName" parameter.
unsigned char Data[256] = ""; // buffer that receives the data for the value entry. This parameter can be NULL if the data is not required
unsigned long szData = 256; // variable that specifies the size, in bytes, of the buffer pointed to by the lpData parameter.
long ret = 0;
unsigned long ValueDataType = REG_NONE;
// Check values :
while ((RegEnumValueA(hKey, index, ValueName, &szValueName, NULL, &ValueDataType, Data, &szData)) != ERROR_NO_MORE_ITEMS)
{
if (ValueDataType == REG_SZ)
{
if (!strncmp(ValueName,"FunctionLibrary",15))
{
PTlib.path = (char*)(Data);
}
else if (!strncmp(ValueName,"Name",4))
{
PTlib.name = (char*)(Data);
}
else if (!strncmp(ValueName,"ProtocolsSupported",18)) // 02.02-API
{
std::string protocol_str = (char*)(Data);
if (protocol_str.find("J1850VPW") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_J1850VPW;
if (protocol_str.find("J1850PWM") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_J1850PWM;
if (protocol_str.find("ISO9141") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_ISO9141;
if (protocol_str.find("ISO14230") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_ISO14230;
if (protocol_str.find("ISO15765") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_ISO15765;
if (protocol_str.find("CAN") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_CAN;
if (protocol_str.find("SCI_A_ENGINE") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_SCI_A_ENGINE;
if (protocol_str.find("SCI_A_TRANS") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_SCI_A_TRANS;
if (protocol_str.find("SCI_B_ENGINE") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_SCI_B_ENGINE;
if (protocol_str.find("SCI_B_TRANS") != std::string::npos)
PTlib.protocols |= PROTOCOL_FLAG_SCI_B_TRANS;
PTlib.api = J2534_API_v0202;
}
}
else if (ValueDataType == REG_DWORD) // 04.04-API
{
DWORD key_value = *((DWORD*)(void*)(Data));
if (key_value)
{
if (!strncmp(ValueName,"J1850VPW",7))
{
PTlib.protocols |= PROTOCOL_FLAG_J1850VPW;;
}
else if (!strncmp(ValueName,"J1850PWM", 7))
{
PTlib.protocols |= PROTOCOL_FLAG_J1850PWM;
}
else if (!strncmp(ValueName,"ISO9141", 7))
{
PTlib.protocols |= PROTOCOL_FLAG_ISO9141;
}
else if (!strncmp(ValueName,"ISO14230", 8))
{
PTlib.protocols |= PROTOCOL_FLAG_ISO14230;
}
else if (!strncmp(ValueName,"ISO15765", 8))
{
PTlib.protocols |= PROTOCOL_FLAG_ISO15765;
}
else if (!strncmp(ValueName,"CAN", 3))
{
PTlib.protocols |= PROTOCOL_FLAG_CAN;
}
else if (!strncmp(ValueName,"SCI_A_ENGINE", 12))
{
PTlib.protocols |= PROTOCOL_FLAG_SCI_A_ENGINE;
}
else if (!strncmp(ValueName,"SCI_A_TRANS", 11))
{
PTlib.protocols |= PROTOCOL_FLAG_SCI_A_TRANS;
}
else if (!strncmp(ValueName,"SCI_B_ENGINE", 12))
{
PTlib.protocols |= PROTOCOL_FLAG_SCI_B_ENGINE;
}
else if (!strncmp(ValueName,"SCI_B_TRANS", 11))
{
PTlib.protocols |= PROTOCOL_FLAG_SCI_B_TRANS;
}
}
}
szValueName = 256; // because RegEnumValue has changed value !
szData = 256; // because RegEnumValue has changed value !
index++;
}
if (PTlib.path.size() > 0)
PTlibs.push_back( PTlib );
// Check sub-keys:
index = 0;
while (RegEnumKeyA(hKey, index, KeyName, 256) != ERROR_NO_MORE_ITEMS)
{
ret = RegOpenKeyExA(hKey, KeyName, 0, KEY_READ, &hKey2);
if (ret == ERROR_SUCCESS)
{
PTlibs = searchLibValuesRecursive(hKey2, PTlibs);
ret = RegCloseKey(hKey2);
#ifdef __J2534_API_DEBUG__
if (ret != ERROR_SUCCESS)
std::cout << "J2534interface::searchLibValuesRecursive(): RegCloseKey(...) failed with error " << ret << "\n";
#endif
}
#ifdef __J2534_API_DEBUG__
else
{
std::cout << "J2534interface::getAvailableJ2534Libs(): RegOpenKexEx(...) for key " << KeyName << " failed with error " << ret << "\n";
}
#endif
index++;
}
return PTlibs;
}
static void BackupRegTree_Worker(HKEY hKey,const char *pszSubKey,struct BackupRegTreeParam *param)
{
LONG res;
DWORD nMaxSubKeyLen,nMaxValNameLen,nMaxValSize;
DWORD index,cchName,dwType,cbData;
BYTE *pData;
char *pszName;
register TCHAR *ptszName;
DWORD nDbPrefixLen;
if ((res=RegOpenKeyExA(hKey,pszSubKey,0,KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS,&hKey))==ERROR_SUCCESS) {
if ((res=RegQueryInfoKey(hKey,NULL,NULL,NULL,NULL,&nMaxSubKeyLen,NULL,NULL,&nMaxValNameLen,&nMaxValSize,NULL,NULL))==ERROR_SUCCESS) {
if (nMaxSubKeyLen>nMaxValNameLen) nMaxValNameLen=nMaxSubKeyLen;
/* prepare buffer */
nDbPrefixLen = (DWORD)(mir_strlen(*param->ppszDbPrefix) + mir_strlen(pszSubKey) + 1);
cchName = nDbPrefixLen + nMaxValNameLen + 3;
if (cchName>*param->pdwDbPrefixSize) {
pszName=(char*)mir_realloc(*param->ppszDbPrefix,cchName);
if (pszName==NULL) return;
*param->ppszDbPrefix=pszName;
*param->pdwDbPrefixSize=cchName;
}
mir_strcat(mir_strcat(*param->ppszDbPrefix,pszSubKey),"\\"); /* buffer safe */
/* enum values */
pszName=(char*)mir_alloc(nMaxValNameLen+1);
if (nMaxValSize==0) nMaxValSize=1;
pData=(BYTE*)mir_alloc(nMaxValSize);
if (pszName!=NULL && pData!=NULL) {
index=0;
while(!res) {
cchName=nMaxValNameLen+1;
cbData=nMaxValSize;
if ((res=RegEnumValueA(hKey,index++,pszName,&cchName,NULL,NULL,NULL,NULL))==ERROR_SUCCESS) {
(*param->ppszDbPrefix)[nDbPrefixLen]=0;
mir_strcat(*param->ppszDbPrefix,pszName); /* buffer safe */
ptszName=a2t(pszName);
if (ptszName!=NULL) {
if (!RegQueryValueEx(hKey,ptszName,NULL,&dwType,pData,&cbData)) {
WriteDbBackupData(*param->ppszDbPrefix,dwType,pData,cbData);
}
mir_free(ptszName);
}
}
}
if (res==ERROR_NO_MORE_ITEMS) res=ERROR_SUCCESS;
}
mir_free(pData); /* does NULL check */
/* enum subkeys */
if (param->level<32 && pszName!=NULL) {
++param->level; /* can be max 32 levels deep (after prefix), restriction of RegCreateKeyEx() */
index=0;
while(!res) {
cchName=nMaxSubKeyLen+1;
if ((res=RegEnumKeyExA(hKey,index++,pszName,&cchName,NULL,NULL,NULL,NULL))==ERROR_SUCCESS) {
(*param->ppszDbPrefix)[nDbPrefixLen]=0;
BackupRegTree_Worker(hKey,pszName,param); /* recursion */
}
}
}
if (res==ERROR_NO_MORE_ITEMS) res=ERROR_SUCCESS;
mir_free(pszName); /* does NULL check */
}
RegCloseKey(hKey);
}
}
/***********************************************************************
* VxDCall_VMM
*/
static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
{
switch ( LOWORD(service) )
{
case 0x0011: /* RegOpenKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPHKEY retkey = (LPHKEY)stack32_pop( context );
return RegOpenKeyA( hkey, lpszSubKey, retkey );
}
case 0x0012: /* RegCreateKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPHKEY retkey = (LPHKEY)stack32_pop( context );
return RegCreateKeyA( hkey, lpszSubKey, retkey );
}
case 0x0013: /* RegCloseKey */
{
HKEY hkey = (HKEY)stack32_pop( context );
return RegCloseKey( hkey );
}
case 0x0014: /* RegDeleteKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
return RegDeleteKeyA( hkey, lpszSubKey );
}
case 0x0015: /* RegSetValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
DWORD dwType = (DWORD) stack32_pop( context );
LPCSTR lpszData = (LPCSTR)stack32_pop( context );
DWORD cbData = (DWORD) stack32_pop( context );
return RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
}
case 0x0016: /* RegDeleteValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR)stack32_pop( context );
return RegDeleteValueA( hkey, lpszValue );
}
case 0x0017: /* RegQueryValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszSubKey = (LPSTR) stack32_pop( context );
LPSTR lpszData = (LPSTR) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
}
case 0x0018: /* RegEnumKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
DWORD iSubkey = (DWORD)stack32_pop( context );
LPSTR lpszName = (LPSTR)stack32_pop( context );
DWORD lpcchName = (DWORD)stack32_pop( context );
return RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
}
case 0x0019: /* RegEnumValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
DWORD iValue = (DWORD) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
LPBYTE lpbData = (LPBYTE) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
lpReserved, lpdwType, lpbData, lpcbData );
}
case 0x001A: /* RegQueryValueEx */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
LPBYTE lpbData = (LPBYTE) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegQueryValueExA( hkey, lpszValue, lpReserved,
lpdwType, lpbData, lpcbData );
}
case 0x001B: /* RegSetValueEx */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
DWORD dwReserved = (DWORD) stack32_pop( context );
DWORD dwType = (DWORD) stack32_pop( context );
LPBYTE lpbData = (LPBYTE)stack32_pop( context );
DWORD cbData = (DWORD) stack32_pop( context );
return RegSetValueExA( hkey, lpszValue, dwReserved,
dwType, lpbData, cbData );
}
case 0x001C: /* RegFlushKey */
{
HKEY hkey = (HKEY)stack32_pop( context );
return RtlNtStatusToDosError (NtFlushKey (hkey));
}
case 0x001D: /* RegQueryInfoKey */
{
/* NOTE: This VxDCall takes only a subset of the parameters that the
corresponding Win32 API call does. The implementation in Win95
ADVAPI32 sets all output parameters not mentioned here to zero. */
HKEY hkey = (HKEY) stack32_pop( context );
LPDWORD lpcSubKeys = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxSubKey = (LPDWORD)stack32_pop( context );
LPDWORD lpcValues = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
return RegQueryInfoKeyA( hkey, NULL, NULL, NULL, lpcSubKeys, lpcchMaxSubKey,
NULL, lpcValues, lpcchMaxValueName, lpcchMaxValueData,
NULL, NULL );
}
case 0x0021: /* RegLoadKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
return RegLoadKeyA( hkey, lpszSubKey, lpszFile );
}
case 0x0022: /* RegUnLoadKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
FIXME ("(%p, %s): stub (should call NtUnloadKey)\n",
(void *)hkey, lpszSubKey);
return ERROR_SUCCESS;
}
case 0x0023: /* RegSaveKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
return RegSaveKeyA( hkey, lpszFile, sa );
}
#if 0 /* Functions are not yet implemented in misc/registry.c */
case 0x0024: /* RegRemapPreDefKey */
case 0x0026: /* RegQueryMultipleValues */
#endif
case 0x0027: /* RegReplaceKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPCSTR lpszNewFile= (LPCSTR)stack32_pop( context );
LPCSTR lpszOldFile= (LPCSTR)stack32_pop( context );
FIXME ("(%p, %s, %s, %s): stub (should call NtReplaceKey)\n",
(void *)hkey, lpszSubKey, lpszNewFile, lpszOldFile);
return ERROR_SUCCESS;
}
case 0x0000: /* PageReserve */
{
LPVOID address;
LPVOID ret;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
page, npages, flags );
if ( page == PR_SYSTEM ) {
ERR("Can't reserve ring 1 memory\n");
return -1;
}
/* FIXME: This has to be handled separately for the separate
address-spaces we now have */
if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
/* FIXME: Handle flags in some way */
address = (LPVOID )(page * psize);
ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
if ( ret == NULL )
return -1;
else
return (DWORD )ret;
}
case 0x0001: /* PageCommit */
{
LPVOID address;
LPVOID ret;
DWORD virt_perm;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG hpd = (ULONG) stack32_pop( context );
ULONG pagerdata = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
"%08lx, flags: %08lx partial stub\n",
page, npages, hpd, pagerdata, flags );
if ( flags & PC_USER )
if ( flags & PC_WRITEABLE )
virt_perm = PAGE_EXECUTE_READWRITE;
else
virt_perm = PAGE_EXECUTE_READ;
else
virt_perm = PAGE_NOACCESS;
address = (LPVOID )(page * psize);
ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
return (DWORD )ret;
}
case 0x0002: /* PageDecommit */
{
LPVOID address;
BOOL ret;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
page, npages, flags );
address = (LPVOID )( page * psize );
ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
return ret;
}
case 0x000d: /* PageModifyPermissions */
{
DWORD pg_old_perm;
DWORD pg_new_perm;
DWORD virt_old_perm;
DWORD virt_new_perm;
MEMORY_BASIC_INFORMATION mbi;
LPVOID address;
DWORD psize = getpagesize();
ULONG page = stack32_pop ( context );
ULONG npages = stack32_pop ( context );
ULONG permand = stack32_pop ( context );
ULONG permor = stack32_pop ( context );
TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
page, npages, permand, permor );
address = (LPVOID )( page * psize );
VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
virt_old_perm = mbi.Protect;
switch ( virt_old_perm & mbi.Protect ) {
case PAGE_READONLY:
case PAGE_EXECUTE:
case PAGE_EXECUTE_READ:
pg_old_perm = PC_USER;
break;
case PAGE_READWRITE:
case PAGE_WRITECOPY:
case PAGE_EXECUTE_READWRITE:
case PAGE_EXECUTE_WRITECOPY:
pg_old_perm = PC_USER | PC_WRITEABLE;
break;
case PAGE_NOACCESS:
default:
pg_old_perm = 0;
break;
}
pg_new_perm = pg_old_perm;
pg_new_perm &= permand & ~PC_STATIC;
pg_new_perm |= permor & ~PC_STATIC;
virt_new_perm = ( virt_old_perm ) & ~0xff;
if ( pg_new_perm & PC_USER )
{
if ( pg_new_perm & PC_WRITEABLE )
virt_new_perm |= PAGE_EXECUTE_READWRITE;
else
virt_new_perm |= PAGE_EXECUTE_READ;
}
if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
ERR("Can't change page permissions for %08lx\n", (DWORD )address );
return 0xffffffff;
}
TRACE("Returning: %08lx\n", pg_old_perm );
return pg_old_perm;
}
case 0x000a: /* PageFree */
{
BOOL ret;
LPVOID hmem = (LPVOID) stack32_pop( context );
DWORD flags = (DWORD ) stack32_pop( context );
TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
(DWORD )hmem, flags );
ret = VirtualFree ( hmem, 0, MEM_RELEASE );
context->Eax = ret;
TRACE("Returning: %d\n", ret );
return 0;
}
case 0x001e: /* GetDemandPageInfo */
{
DWORD dinfo = (DWORD)stack32_pop( context );
DWORD flags = (DWORD)stack32_pop( context );
/* GetDemandPageInfo is supposed to fill out the struct at
* "dinfo" with various low-level memory management information.
* Apps are certainly not supposed to call this, although it's
* demoed and documented by Pietrek on pages 441-443 of "Windows
* 95 System Programming Secrets" if any program needs a real
* implementation of this.
*/
FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
return 0;
}
default:
if (LOWORD(service) < N_VMM_SERVICE)
FIXME( "Unimplemented service %s (%08lx)\n",
VMM_Service_Name[LOWORD(service)], service);
else
FIXME( "Unknown service %08lx\n", service);
break;
}
return 0xffffffff; /* FIXME */
}
/* IO_pp_init
*
* Read the ppdev entries from wine.conf, open the device and check
* for nescessary IOCTRL
* Report verbose about possible errors
*/
char IO_pp_init(void)
{
char name[80];
char buffer[1024];
HKEY hkey;
char temp[256];
int i,idx=0,fd,res,userbase,nports=0;
char * timeout;
char ret=1;
int lasterror;
TRACE("\n");
if (RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\ppdev", &hkey ) != ERROR_SUCCESS)
return 1;
for (;;)
{
DWORD type, count = sizeof(buffer), name_len = sizeof(name);
if (RegEnumValueA( hkey, idx, name, &name_len, NULL, &type,
(LPBYTE)buffer, &count )!= ERROR_SUCCESS)
break;
idx++;
if(nports >4)
{
FIXME("Make the PPDeviceList larger then 5 elements\n");
break;
}
TRACE("Device '%s' at virtual userbase '%s'\n", buffer,name);
timeout = strchr(buffer,',');
if (timeout)
*timeout++=0;
fd=open(buffer,O_RDWR);
lasterror=errno;
if (fd == -1)
{
WARN("Configuration: No access to %s Cause: %s\n",buffer,strerror(lasterror));
WARN("Rejecting configuration item\n");
if (lasterror == ENODEV)
FIXME("Is the ppdev module loaded?\n");
continue;
}
userbase = strtol(name,(char **)NULL, 16);
if ( errno == ERANGE)
{
WARN("Configuration: Invalid base %s for %s\n",name,buffer);
WARN("Rejecting configuration item\n");
continue;
}
if (ioctl (fd,PPCLAIM,0))
{
ERR("PPCLAIM rejected %s\n",buffer);
ERR("Perhaps the device is already in use or non-existant\n");
continue;
}
if (nports > 0)
{
for (i=0; i<= nports; i++)
{
if (PPDeviceList[i].userbase == userbase)
{
WARN("Configuration: %s uses the same virtual ports as %s\n",
buffer,PPDeviceList[0].devicename);
WARN("Configuration: Rejecting configuration item");
userbase = 0;
break;
}
}
if (!userbase) continue;
}
/* Check for the minimum required IOCTLS */
if ((ioctl(fd,PPRDATA,&res))||
(ioctl(fd,PPRCONTROL,&res))||
(ioctl(fd,PPRCONTROL,&res)))
{
ERR("PPUSER IOCTL not available for parport device %s\n",temp);
continue;
}
if (ioctl (fd,PPRELEASE,0))
{
ERR("PPRELEASE rejected %s\n",buffer);
ERR("Perhaps the device is already in use or non-existant\n");
continue;
}
PPDeviceList[nports].devicename = malloc(sizeof(buffer)+1);
if (!PPDeviceList[nports].devicename)
{
ERR("No (more)space for devicename\n");
break;
}
strcpy(PPDeviceList[nports].devicename,buffer);
PPDeviceList[nports].fd = fd;
PPDeviceList[nports].userbase = userbase;
PPDeviceList[nports].lastaccess=NtGetTickCount();
if (timeout)
{
PPDeviceList[nports].timeout = strtol(timeout,(char **)NULL, 10);
if (errno == ERANGE)
{
WARN("Configuration:Invalid timeout %s in configuration for %s, Setting to 0\n",
timeout,buffer);
PPDeviceList[nports].timeout = 0;
}
}
else
PPDeviceList[nports].timeout = 0;
nports++;
}
TRACE("found %d ports\n",nports);
RegCloseKey( hkey );
PPDeviceNum= nports;
if (nports > 1)
/* sort in accending order for userbase for faster access*/
qsort (PPDeviceList,PPDeviceNum,sizeof(PPDeviceStruct),IO_pp_sort);
if (nports)
ret=0;
for (idx= 0;idx<PPDeviceNum; idx++)
TRACE("found device %s userbase %x fd %x timeout %d\n",
PPDeviceList[idx].devicename, PPDeviceList[idx].userbase,
PPDeviceList[idx].fd,PPDeviceList[idx].timeout);
/* FIXME:
register a timer callback perhaps every 30 second to release unused ports
Set lastaccess = 0 as indicator when port was released
*/
return ret;
}
/* Based on RegDeleteTreeW from dlls/advapi32/registry.c */
static LSTATUS mru_RegDeleteTreeA(HKEY hKey, LPCSTR lpszSubKey)
{
LONG ret;
DWORD dwMaxSubkeyLen, dwMaxValueLen;
DWORD dwMaxLen, dwSize;
CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
HKEY hSubKey = hKey;
if(lpszSubKey)
{
ret = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
if (ret) return ret;
}
/* Get highest length for keys, values */
ret = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, NULL,
&dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
if (ret) goto cleanup;
dwMaxSubkeyLen++;
dwMaxValueLen++;
dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
if (dwMaxLen > sizeof(szNameBuf)/sizeof(CHAR))
{
/* Name too big: alloc a buffer for it */
if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(CHAR))))
{
ret = ERROR_NOT_ENOUGH_MEMORY;
goto cleanup;
}
}
/* Recursively delete all the subkeys */
while (TRUE)
{
dwSize = dwMaxLen;
if (RegEnumKeyExA(hSubKey, 0, lpszName, &dwSize, NULL,
NULL, NULL, NULL)) break;
ret = mru_RegDeleteTreeA(hSubKey, lpszName);
if (ret) goto cleanup;
}
if (lpszSubKey)
ret = RegDeleteKeyA(hKey, lpszSubKey);
else
while (TRUE)
{
dwSize = dwMaxLen;
if (RegEnumValueA(hKey, 0, lpszName, &dwSize,
NULL, NULL, NULL, NULL)) break;
ret = RegDeleteValueA(hKey, lpszName);
if (ret) goto cleanup;
}
cleanup:
/* Free buffer if allocated */
if (lpszName != szNameBuf)
HeapFree( GetProcessHeap(), 0, lpszName);
if(lpszSubKey)
RegCloseKey(hSubKey);
return ret;
}
/* Obtain all the fontname -> filename mappings.
* This is called once and the results returned to Java code which can
* use it for lookups to reduce or avoid the need to search font files.
*/
JNIEXPORT void JNICALL
Java_sun_font_FontManager_populateFontFileNameMap
(JNIEnv *env, jclass obj, jobject fontToFileMap,
jobject fontToFamilyMap, jobject familyToFontListMap, jobject locale)
{
#define MAX_BUFFER (FILENAME_MAX+1)
const wchar_t wname[MAX_BUFFER];
const char cname[MAX_BUFFER];
const char data[MAX_BUFFER];
DWORD type;
LONG ret;
HKEY hkeyFonts;
DWORD dwNameSize;
DWORD dwDataValueSize;
DWORD nval;
LPCSTR fontKeyName;
DWORD dwNumValues, dwMaxValueNameLen, dwMaxValueDataLen;
DWORD numValues = 0;
jclass classID;
jmethodID putMID;
GdiFontMapInfo fmi;
/* Check we were passed all the maps we need, and do lookup of
* methods for JNI up-calls
*/
if (fontToFileMap == NULL ||
fontToFamilyMap == NULL ||
familyToFontListMap == NULL) {
return;
}
classID = (*env)->FindClass(env, "java/util/HashMap");
if (classID == NULL) {
return;
}
putMID = (*env)->GetMethodID(env, classID, "put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
if (putMID == NULL) {
return;
}
fmi.env = env;
fmi.fontToFamilyMap = fontToFamilyMap;
fmi.familyToFontListMap = familyToFontListMap;
fmi.putMID = putMID;
fmi.locale = locale;
fmi.containsKeyMID = (*env)->GetMethodID(env, classID, "containsKey",
"(Ljava/lang/Object;)Z");
if (fmi.containsKeyMID == NULL) {
return;
}
fmi.arrayListClass = (*env)->FindClass(env, "java/util/ArrayList");
if (fmi.arrayListClass == NULL) {
return;
}
fmi.arrayListCtr = (*env)->GetMethodID(env, fmi.arrayListClass,
"<init>", "(I)V");
if (fmi.arrayListCtr == NULL) {
return;
}
fmi.addMID = (*env)->GetMethodID(env, fmi.arrayListClass,
"add", "(Ljava/lang/Object;)Z");
if (fmi.addMID == NULL) {
return;
}
classID = (*env)->FindClass(env, "java/lang/String");
if (classID == NULL) {
return;
}
fmi.toLowerCaseMID =
(*env)->GetMethodID(env, classID, "toLowerCase",
"(Ljava/util/Locale;)Ljava/lang/String;");
if (fmi.toLowerCaseMID == NULL) {
return;
}
/* Enumerate fonts via GDI to build maps of fonts and families */
if (IS_NT) {
LOGFONTW lfw;
memset(&lfw, 0, sizeof(lfw));
lfw.lfCharSet = DEFAULT_CHARSET; /* all charsets */
wcscpy(lfw.lfFaceName, L""); /* one face per family (CHECK) */
EnumFontFamiliesExW(GetDC(NULL), &lfw,
(FONTENUMPROCW)EnumFamilyNamesW,
(LPARAM)(&fmi), 0L);
} else {
LOGFONT lfa;
memset(&lfa, 0, sizeof(lfa));
lfa.lfCharSet = DEFAULT_CHARSET; /* all charsets */
strcpy(lfa.lfFaceName, ""); /* one face per family */
ret = EnumFontFamiliesExA(GetDC(NULL), &lfa,
(FONTENUMPROCA)EnumFamilyNamesA,
(LPARAM)(&fmi), 0L);
}
/* Use the windows registry to map font names to files */
fontKeyName = (IS_NT) ? FONTKEY_NT : FONTKEY_WIN;
ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
fontKeyName, 0L, KEY_READ, &hkeyFonts);
if (ret != ERROR_SUCCESS) {
return;
}
if (IS_NT) {
ret = RegQueryInfoKeyW(hkeyFonts, NULL, NULL, NULL, NULL, NULL, NULL,
&dwNumValues, &dwMaxValueNameLen,
&dwMaxValueDataLen, NULL, NULL);
} else {
ret = RegQueryInfoKeyA(hkeyFonts, NULL, NULL, NULL, NULL, NULL, NULL,
&dwNumValues, &dwMaxValueNameLen,
&dwMaxValueDataLen, NULL, NULL);
}
if (ret != ERROR_SUCCESS ||
dwMaxValueNameLen >= MAX_BUFFER ||
dwMaxValueDataLen >= MAX_BUFFER) {
RegCloseKey(hkeyFonts);
return;
}
for (nval = 0; nval < dwNumValues; nval++ ) {
dwNameSize = MAX_BUFFER;
dwDataValueSize = MAX_BUFFER;
if (IS_NT) {
ret = RegEnumValueW(hkeyFonts, nval, (LPWSTR)wname, &dwNameSize,
NULL, &type, (LPBYTE)data, &dwDataValueSize);
} else {
ret = RegEnumValueA(hkeyFonts, nval, (LPSTR)cname, &dwNameSize,
NULL, &type, (LPBYTE)data, &dwDataValueSize);
}
if (ret != ERROR_SUCCESS) {
break;
}
if (type != REG_SZ) { /* REG_SZ means a null-terminated string */
continue;
}
if (IS_NT) {
if (!RegistryToBaseTTNameW((LPWSTR)wname) ) {
continue; /* not a TT font... */
}
registerFontW(&fmi, fontToFileMap, (LPWSTR)wname, (LPWSTR)data);
} else {
if (!RegistryToBaseTTNameA(cname) ) {
continue; /* not a TT font... */
}
registerFontA(&fmi, fontToFileMap, cname, (LPCSTR)data);
}
}
RegCloseKey(hkeyFonts);
}
bool get_fontfile(const char* font_name, gameswf::tu_string& file_name, bool is_bold, bool is_italic)
// gets font file name by font name
{
if (font_name == NULL)
{
return false;
}
#ifdef _WIN32
//Vitaly: I'm not sure that this code works on all versions of Windows
tu_stringi fontname = font_name;
if (is_bold)
{
fontname += " Bold";
}
if (is_italic)
{
fontname += " Italic";
}
fontname += " (TrueType)";
HKEY hKey;
// try WinNT
DWORD retCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
0,
KEY_ALL_ACCESS,
&hKey);
if (retCode != ERROR_SUCCESS)
{
// try Windows
retCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
"Software\\Microsoft\\Windows\\CurrentVersion\\Fonts",
0,
KEY_ALL_ACCESS,
&hKey);
if (retCode != ERROR_SUCCESS)
{
return false;
}
}
// Get the value of the 'windir' environment variable.
gameswf::tu_string windir(getenv("WINDIR"));
// Get value count.
DWORD cValues; // number of values for key
retCode = RegQueryInfoKey(
hKey, // key handle
NULL, // buffer for class name
NULL, // size of class string
NULL, // reserved
NULL, // number of subkeys
NULL, // longest subkey size
NULL, // longest class string
&cValues, // number of values for this key
NULL, // longest value name
NULL, // longest value data
NULL, // security descriptor
NULL); // last write time
// Enumerate the key values.
BYTE szValueData[MAX_PATH];
TCHAR achValue[MAX_PATH];
for (DWORD i = 0, retCode = ERROR_SUCCESS; i < cValues; i++)
{
DWORD cchValue = MAX_PATH;
DWORD dwValueDataSize = sizeof(szValueData) - 1;
achValue[0] = '\0';
retCode = RegEnumValueA(hKey, i,
achValue,
&cchValue,
NULL,
NULL,
szValueData,
&dwValueDataSize);
if (retCode == ERROR_SUCCESS)
{
if ((fontname == (char*) achValue) || ((strstr(achValue, font_name) != NULL) && !is_italic && !is_bold))
{
file_name = windir + gameswf::tu_string("\\Fonts\\") + (char*) szValueData;
RegCloseKey(hKey);
return true;
}
}
}
RegCloseKey(hKey);
return false;
#else
//TODO for Linux
// hack
if (strstr(font_name, "Times New Roman"))
{
file_name = "/usr/share/fonts/truetype/times";
}
else
if (strstr(font_name, "Arial"))
{
file_name = "/usr/share/fonts/truetype/arial";
}
else
{
return false;
}
if (is_bold && is_italic)
{
file_name += "bi";
}
else
if (is_bold)
{
file_name += "b";
}
else
if (is_italic)
{
file_name += "b";
}
file_name += ".ttf";
return true;
#endif
}
icd_loader::icd_loader()
{
#ifdef FREEOCL_ALWAYS_LOAD_FREEOCL
bool b_FreeOCL_loaded = false;
#endif
#ifdef FREEOCL_OS_WINDOWS
HKEY key;
RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Khronos\\OpenCL\\Vendors", 0, KEY_QUERY_VALUE | KEY_READ, &key);
for(int i = 0 ; true ; ++i)
{
char valueName[261];
memset(valueName, 0, sizeof(valueName));
DWORD valueNameSize = sizeof(valueName) - 1;
DWORD type;
DWORD data;
DWORD data_size = sizeof(data);
if (RegEnumValueA(key, i, valueName, &valueNameSize, NULL, &type, (LPBYTE)&data, &data_size) != 0)
break;
if (type == REG_DWORD && data == 0)
{
valueName[valueNameSize] = 0;
load(valueName);
#ifdef FREEOCL_ALWAYS_LOAD_FREEOCL
b_FreeOCL_loaded |= (std::string(valueName).find("libFreeOCL.dll") != std::string::npos);
#endif
}
}
RegCloseKey(key);
#ifdef FREEOCL_ALWAYS_LOAD_FREEOCL
if (!b_FreeOCL_loaded)
load("libFreeOCL.dll");
#endif
#else
// Get the list of all *.icd files in /etc/OpenCL/vendors/
const std::deque<std::string> &files = list_files("/etc/OpenCL/vendors/", ".icd");
// For each file
for(std::deque<std::string>::const_iterator i = files.begin() ; i != files.end() ; ++i)
{
std::ifstream file(i->c_str(), std::ios_base::in);
if (!file.is_open())
continue;
// Read the corresponding library name
std::string lib;
file >> lib;
// And load it
load(lib);
file.close();
#ifdef FREEOCL_ALWAYS_LOAD_FREEOCL
b_FreeOCL_loaded |= (lib.find("libFreeOCL.so") != std::string::npos);
#endif
}
#ifdef FREEOCL_ALWAYS_LOAD_FREEOCL
if (!b_FreeOCL_loaded)
load("libFreeOCL.so");
#endif
#endif
}
static bool MCRegistryListValues(HKEY p_root, const char *p_key, MCRegistryListValuesCallback p_callback, void *p_context)
{
bool t_success;
t_success = true;
// Attempt to open the given key.
HKEY t_handle;
t_handle = nil;
if (t_success)
if (RegOpenKeyExA(p_root, p_key, 0, KEY_QUERY_VALUE, &t_handle) != ERROR_SUCCESS)
t_success = false;
// Next determine the maximum length of the value names.
DWORD t_max_name_length;
if (t_success)
if (RegQueryInfoKeyA(t_handle, nil, nil, nil, nil, nil, nil, nil, &t_max_name_length, nil, nil, nil) != ERROR_SUCCESS)
t_success = false;
// Allocate a buffer big enough for the name
char *t_name_buffer;
t_name_buffer = nil;
if (t_success)
t_success = MCMemoryNewArray(t_max_name_length + 1, t_name_buffer);
if (t_success)
{
DWORD t_index;
t_index = 0;
while(t_success)
{
DWORD t_name_length, t_value_length;
t_name_length = t_max_name_length + 1;
t_value_length = 0;
LSTATUS t_result;
if (t_success)
{
t_result = RegEnumValueA(t_handle, t_index, t_name_buffer, &t_name_length, nil, nil, nil, &t_value_length);
if (t_result == ERROR_NO_MORE_ITEMS)
break;
if (t_result != ERROR_SUCCESS)
t_success = false;
}
void *t_value_buffer;
t_value_buffer = nil;
if (t_success)
t_success = MCMemoryAllocate(t_value_length, t_value_buffer);
DWORD t_type;
if (t_success)
{
t_name_length = t_max_name_length + 1;
if (RegEnumValueA(t_handle, t_index, t_name_buffer, &t_name_length, nil, &t_type, (LPBYTE)t_value_buffer, &t_value_length) != ERROR_SUCCESS)
t_success = false;
}
if (t_success && p_callback != nil)
p_callback(p_context, t_name_buffer, t_type, t_value_buffer, t_value_length);
MCMemoryDeallocate(t_value_buffer);
t_index++;
}
}
MCMemoryDeleteArray(t_name_buffer);
if (t_handle != nil)
RegCloseKey(t_handle);
return t_success;
}
HRESULT HostDnsServiceWin::updateInfo()
{
HostDnsInformation info;
LONG lrc;
int rc;
std::string strDomain;
std::string strSearchList; /* NB: comma separated, no spaces */
/*
* We ignore "DhcpDomain" key here since it's not stable. If
* there are two active interfaces that use DHCP (in particular
* when host uses OpenVPN) then DHCP ACKs will take turns updating
* that key. Instead we call GetAdaptersAddresses() below (which
* is what ipconfig.exe seems to do).
*/
for (DWORD regIndex = 0; /**/; ++regIndex) {
char keyName[256];
DWORD cbKeyName = sizeof(keyName);
DWORD keyType = 0;
char keyData[1024];
DWORD cbKeyData = sizeof(keyData);
lrc = RegEnumValueA(m->hKeyTcpipParameters, regIndex,
keyName, &cbKeyName, 0,
&keyType, (LPBYTE)keyData, &cbKeyData);
if (lrc == ERROR_NO_MORE_ITEMS)
break;
if (lrc == ERROR_MORE_DATA) /* buffer too small; handle? */
continue;
if (lrc != ERROR_SUCCESS)
{
LogRel2(("HostDnsServiceWin: RegEnumValue error %d\n", (int)lrc));
return E_FAIL;
}
if (keyType != REG_SZ)
continue;
if (cbKeyData > 0 && keyData[cbKeyData - 1] == '\0')
--cbKeyData; /* don't count trailing NUL if present */
if (RTStrICmp("Domain", keyName) == 0)
{
strDomain.assign(keyData, cbKeyData);
LogRel2(("HostDnsServiceWin: Domain=\"%s\"\n", strDomain.c_str()));
}
else if (RTStrICmp("DhcpDomain", keyName) == 0)
{
std::string strDhcpDomain(keyData, cbKeyData);
LogRel2(("HostDnsServiceWin: DhcpDomain=\"%s\"\n", strDhcpDomain.c_str()));
}
else if (RTStrICmp("SearchList", keyName) == 0)
{
strSearchList.assign(keyData, cbKeyData);
LogRel2(("HostDnsServiceWin: SearchList=\"%s\"\n", strSearchList.c_str()));
}
}
/* statically configured domain name */
if (!strDomain.empty())
{
info.domain = strDomain;
info.searchList.push_back(strDomain);
}
/* statically configured search list */
if (!strSearchList.empty())
{
vappend(info.searchList, strSearchList, ',');
}
/*
* When name servers are configured statically it seems that the
* value of Tcpip\Parameters\NameServer is NOT set, inly interface
* specific NameServer value is (which triggers notification for
* us to pick up the change). Fortunately, DnsApi seems to do the
* right thing there.
*/
DNS_STATUS status;
PIP4_ARRAY pIp4Array = NULL;
// NB: must be set on input it seems, despite docs' claim to the contrary.
DWORD cbBuffer = sizeof(&pIp4Array);
status = DnsQueryConfig(DnsConfigDnsServerList,
DNS_CONFIG_FLAG_ALLOC, NULL, NULL,
&pIp4Array, &cbBuffer);
if (status == NO_ERROR && pIp4Array != NULL)
{
for (DWORD i = 0; i < pIp4Array->AddrCount; ++i)
{
char szAddrStr[16] = "";
RTStrPrintf(szAddrStr, sizeof(szAddrStr), "%RTnaipv4", pIp4Array->AddrArray[i]);
LogRel2(("HostDnsServiceWin: server %d: %s\n", i+1, szAddrStr));
info.servers.push_back(szAddrStr);
}
LocalFree(pIp4Array);
}
/**
* DnsQueryConfig(DnsConfigSearchList, ...) is not implemented.
* Call GetAdaptersAddresses() that orders the returned list
* appropriately and collect IP_ADAPTER_ADDRESSES::DnsSuffix.
*/
do {
PIP_ADAPTER_ADDRESSES pAddrBuf = NULL;
ULONG cbAddrBuf = 8 * 1024;
bool fReallocated = false;
ULONG err;
pAddrBuf = (PIP_ADAPTER_ADDRESSES) malloc(cbAddrBuf);
if (pAddrBuf == NULL)
{
LogRel2(("HostDnsServiceWin: failed to allocate %zu bytes"
" of GetAdaptersAddresses buffer\n",
(size_t)cbAddrBuf));
break;
}
while (pAddrBuf != NULL)
{
ULONG cbAddrBufProvided = cbAddrBuf;
err = GetAdaptersAddresses(AF_UNSPEC,
GAA_FLAG_SKIP_ANYCAST
| GAA_FLAG_SKIP_MULTICAST,
NULL,
pAddrBuf, &cbAddrBuf);
if (err == NO_ERROR)
{
break;
}
else if (err == ERROR_BUFFER_OVERFLOW)
{
LogRel2(("HostDnsServiceWin: provided GetAdaptersAddresses with %zu"
" but asked again for %zu bytes\n",
(size_t)cbAddrBufProvided, (size_t)cbAddrBuf));
if (RT_UNLIKELY(fReallocated)) /* what? again?! */
{
LogRel2(("HostDnsServiceWin: ... not going to realloc again\n"));
free(pAddrBuf);
pAddrBuf = NULL;
break;
}
PIP_ADAPTER_ADDRESSES pNewBuf = (PIP_ADAPTER_ADDRESSES) realloc(pAddrBuf, cbAddrBuf);
if (pNewBuf == NULL)
{
LogRel2(("HostDnsServiceWin: failed to reallocate %zu bytes\n", (size_t)cbAddrBuf));
free(pAddrBuf);
pAddrBuf = NULL;
break;
}
/* try again */
pAddrBuf = pNewBuf; /* cbAddrBuf already updated */
fReallocated = true;
}
else
{
LogRel2(("HostDnsServiceWin: GetAdaptersAddresses error %d\n", err));
free(pAddrBuf);
pAddrBuf = NULL;
break;
}
}
if (pAddrBuf == NULL)
break;
for (PIP_ADAPTER_ADDRESSES pAdp = pAddrBuf; pAdp != NULL; pAdp = pAdp->Next)
{
LogRel2(("HostDnsServiceWin: %ls (status %u) ...\n",
pAdp->FriendlyName ? pAdp->FriendlyName : L"(null)",
pAdp->OperStatus));
if (pAdp->OperStatus != IfOperStatusUp)
continue;
if (pAdp->DnsSuffix == NULL || *pAdp->DnsSuffix == L'\0')
continue;
char *pszDnsSuffix = NULL;
rc = RTUtf16ToUtf8Ex(pAdp->DnsSuffix, RTSTR_MAX,
&pszDnsSuffix, 0, /* allocate */
NULL);
if (RT_FAILURE(rc))
{
LogRel2(("HostDnsServiceWin: failed to convert DNS suffix \"%ls\": %Rrc\n",
pAdp->DnsSuffix, rc));
continue;
}
AssertContinue(pszDnsSuffix != NULL);
AssertContinue(*pszDnsSuffix != '\0');
LogRel2(("HostDnsServiceWin: ... suffix = \"%s\"\n", pszDnsSuffix));
vappend(info.searchList, pszDnsSuffix);
RTStrFree(pszDnsSuffix);
}
free(pAddrBuf);
} while (0);
if (info.domain.empty() && !info.searchList.empty())
info.domain = info.searchList[0];
if (info.searchList.size() == 1)
info.searchList.clear();
HostDnsMonitor::setInfo(info);
return S_OK;
}
UINT16 CUARTApp::ScanSerialPort(UCHAR * numBuff)
{
#define MAX_KEY_LENGTH 255
#define MAX_VALUE_NAME 16383
HKEY hTestKey;
int nIndex = 0;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("HARDWARE\\DEVICEMAP\\SERIALCOMM"), 0, KEY_READ, &hTestKey))
{
TCHAR achClass[MAX_PATH] = TEXT(""); // buffer for class name
DWORD cchClassName = MAX_PATH; // size of class string
DWORD cSubKeys = 0; // number of subkeys
DWORD cbMaxSubKey; // longest subkey size
DWORD cchMaxClass; // longest class string
DWORD cValues; // number of values for key
DWORD cchMaxValue; // longest value name
DWORD cbMaxValueData; // longest value data
DWORD cbSecurityDescriptor; // size of security descriptor
FILETIME ftLastWriteTime; // last write time
DWORD i, retCode;
//TCHAR achValue[MAX_VALUE_NAME];
CHAR achValue[MAX_VALUE_NAME];
DWORD cchValue = MAX_VALUE_NAME;
LONG lResult;
// Get the class name and the value count.
retCode = RegQueryInfoKey(
hTestKey, // key handle
achClass, // buffer for class name
&cchClassName, // size of class string
NULL, // reserved
&cSubKeys, // number of subkeys
&cbMaxSubKey, // longest subkey size
&cchMaxClass, // longest class string
&cValues, // number of values for this key
&cchMaxValue, // longest value name
&cbMaxValueData, // longest value data
&cbSecurityDescriptor, // security descriptor
&ftLastWriteTime); // last write time
if (cValues > 0)
{
for (i = 0; i<cValues; i++)
{
cchValue = MAX_VALUE_NAME;
achValue[0] = '\0';
lResult = RegEnumValueA(hTestKey, i, achValue, &cchValue, NULL, NULL, NULL, NULL);
if (ERROR_SUCCESS == lResult)
{
BYTE strDSName[50];
//memset(strDSName, 0, 100);
strDSName[0] = '\n';
DWORD nBuffLen = 50;
//if (ERROR_SUCCESS == RegQueryValueEx(hTestKey, (LPCTSTR)achValue, NULL,&nValueType, strDSName, &nBuffLen))
if (ERROR_SUCCESS == RegQueryValueExA(hTestKey, achValue, NULL, NULL, strDSName, &nBuffLen))
{
// UCHAR num;
numBuff[nIndex++] = atoi((char*)(strDSName + 3));
//CString str(strDSName);
//combobox->AddString(str);
}
}
else
{
TRACE("error\r\n");
}
}
}
else
{
//AfxMessageBox(_T("PC机没有COM口....."));
}
}
RegCloseKey(hTestKey);
return nIndex;
}