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); } }
// Explore the registry to find a suitable version of Java. // Returns an int which is the version of Java found (e.g. 1006 for 1.6) and the // matching path in outJavaPath. // Returns 0 if nothing suitable was found. static int exploreJavaRegistry(const char *entry, REGSAM access, CPath *outJavaPath) { // Let's visit HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment [CurrentVersion] CPath rootKey("SOFTWARE\\JavaSoft\\"); rootKey.addPath(entry); int versionInt = 0; CString currentVersion; CPath subKey(rootKey); if (getRegValue(subKey.cstr(), "CurrentVersion", access, ¤tVersion)) { // CurrentVersion should be something like "1.7". // We want to read HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment\1.7 [JavaHome] subKey.addPath(currentVersion); CPath javaHome; if (getRegValue(subKey.cstr(), "JavaHome", access, &javaHome)) { versionInt = checkBinPath(&javaHome); if (versionInt >= 0) { if (gIsDebug) { fprintf(stderr, "Java %d found via registry: %s\n", versionInt, javaHome.cstr()); } *outJavaPath = javaHome; } if (versionInt >= MIN_JAVA_VERSION) { // Heuristic: if the current version is good enough, stop here return versionInt; } } } // Try again, but this time look at all the versions available HKEY javaHomeKey; LSTATUS status = RegOpenKeyExA( HKEY_LOCAL_MACHINE, // hKey "SOFTWARE\\JavaSoft", // lpSubKey 0, // ulOptions KEY_READ | access, // samDesired &javaHomeKey); // phkResult if (status == ERROR_SUCCESS) { char name[256]; DWORD index = 0; CPath javaHome; for (LONG result = ERROR_SUCCESS; result == ERROR_SUCCESS; index++) { DWORD nameLen = 255; name[nameLen] = 0; result = RegEnumKeyExA( javaHomeKey, // hKey index, // dwIndex name, // lpName &nameLen, // lpcName NULL, // lpReserved NULL, // lpClass NULL, // lpcClass, NULL); // lpftLastWriteTime if (result == ERROR_SUCCESS && nameLen < 256) { name[nameLen] = 0; CPath subKey(rootKey); subKey.addPath(name); if (getRegValue(subKey.cstr(), "JavaHome", access, &javaHome)) { int v = checkBinPath(&javaHome); if (v > versionInt) { if (gIsDebug) { fprintf(stderr, "Java %d found via registry: %s\n", versionInt, javaHome.cstr()); } *outJavaPath = javaHome; versionInt = v; } } } } RegCloseKey(javaHomeKey); } return 0; }
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; }
/* 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; }
///////////////////////////////////////////////////////////////////////////// // DllUnregisterServer // ///////////////////////////////////////////////////////////////////////////// STDAPI DllUnregisterServer(void) { HKEY hRootKey = NULL; HKEY hModuleKey = NULL; HKEY hLTMKey = NULL; HKEY hLTMModuleKey = NULL; WCHAR* pwszCLSID = NULL; ULONG cBufferSize = MAX_NAME_LEN; GlobalModuleData* pModuleData = &g_pThisTestModule->m_gmd; CHAR szGuid[MAX_NAME_LEN]; CHAR szBuffer[MAX_NAME_LEN]; CHAR szBuffer2[MAX_NAME_LEN]; //{...Guid...} StringFromCLSID(*pModuleData->m_pguidModuleCLSID, &pwszCLSID); WideCharToMultiByte(CP_ACP, 0, pwszCLSID, -1, szGuid, MAX_NAME_LEN, NULL, NULL); // Step 1: Remove our CLSID as an OLE Server //HKEY_CLASSES_ROOT\CLSID if(ERROR_SUCCESS == RegOpenKeyExA(HKEY_CLASSES_ROOT, "CLSID", 0, KEY_WRITE, &hRootKey)) { //HKEY_CLASSES_ROOT\CLSID\{..Guid..} if(ERROR_SUCCESS == RegOpenKeyExA(hRootKey, szGuid, 0, KEY_WRITE, &hModuleKey)) { //HKEY_CLASSES_ROOT\CLSID\{..Guid..}\InprocServer32 RegDeleteKeyA(hModuleKey, "InprocServer32"); RegDeleteKeyA(hModuleKey, "ProgID"); } RegDeleteKeyA(hRootKey, szGuid); RegCloseKey(hRootKey); } //HKEY_CLASSES_ROOT\ProgID WideCharToMultiByte(CP_ACP, 0, pModuleData->m_wszModuleName, -1, szBuffer2, MAX_NAME_LEN, NULL, NULL); strcpy(szBuffer, "LTMTest."); strcat(szBuffer, szBuffer2); if(ERROR_SUCCESS == RegOpenKeyExA(HKEY_CLASSES_ROOT, szBuffer, 0, KEY_WRITE, &hRootKey)) { //HKEY_CLASSES_ROOT\ProgID\CLSID RegDeleteKeyA(hRootKey, "CLSID"); RegDeleteKey(hRootKey, NULL); } // Step 2: Remove LTM-specific registery entries //Obtain the Key for HKEY_LOCAL_MACHINE\"SOFTWARE\Microsoft\LTM\Test Modules" if(ERROR_SUCCESS == RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\LTM\\Test Modules", 0, KEY_WRITE, &hLTMKey)) { //Obtain the Key for "...\{Guid} if(ERROR_SUCCESS == RegOpenKeyExA(hLTMKey, szGuid, 0, KEY_WRITE | KEY_READ, &hLTMModuleKey)) { while(RegEnumKeyExA(hLTMModuleKey, 0, szBuffer, &cBufferSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { HKEY hLTMCase = NULL; if(ERROR_SUCCESS == RegOpenKeyExA(hLTMModuleKey, szBuffer, 0, KEY_WRITE | KEY_READ, &hLTMCase)) { cBufferSize = MAX_NAME_LEN; while(RegEnumKeyExA(hLTMCase, 0, szBuffer2, &cBufferSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { RegDeleteKeyA(hLTMCase, szBuffer2); cBufferSize = MAX_NAME_LEN; } RegCloseKey(hLTMCase); hLTMCase = NULL; RegDeleteKeyA(hLTMModuleKey, szBuffer); cBufferSize = MAX_NAME_LEN; } } RegDeleteKeyA(hLTMKey, szGuid); } } RegCloseKey(hLTMKey); RegCloseKey(hLTMModuleKey); RegCloseKey(hRootKey); RegCloseKey(hModuleKey); CoTaskMemFree(pwszCLSID); return S_OK; }
std::list<ADAPTER_INFO> KLOP_GetAdapterList() { std::list<ADAPTER_INFO> RetList; ADAPTER_INFO AI; HKEY hKey = NULL; FILETIME ftLastWriteTime; // last write time CHAR achKey[MAX_PATH]; wchar_t wchKey[MAX_PATH]; ULONG KeyLength; int i; DWORD retCode; if ( KLOP_isWinNT() ) { /* if ( ERROR_SUCCESS == RegOpenKey( HKEY_LOCAL_MACHINE, NT_ADAPTERS_KEY, &hKey ) ) { for (i = 0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++ ) { KeyLength = MAX_PATH; retCode = RegEnumKeyExW(hKey, i, wchKey, &KeyLength, NULL, NULL, NULL, &ftLastWriteTime ); if ( ERROR_SUCCESS == retCode ) { memset ( &AI , 0, sizeof ( AI ) ); wcscpy ( (wchar_t*)AI.AdapterBuffer, L"\\Device\\"); wcscat ( (wchar_t*)AI.AdapterBuffer, wchKey ); AI.AdapterNameSize = ( wcslen ( (wchar_t*)AI.AdapterBuffer ) + 1 ) << 1; AI.LocalIp = 0; RetList.push_back( AI ); } } } else */ { // Winnt4.0 if ( ERROR_SUCCESS == RegOpenKey( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards", &hKey ) ) { for ( i = 0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++ ) { HKEY hSubKey = NULL; KeyLength = MAX_PATH; retCode = RegEnumKeyExW(hKey, i, wchKey, &KeyLength, NULL, NULL, NULL, &ftLastWriteTime ); if ( retCode == ERROR_SUCCESS ) { retCode = RegOpenKeyW(hKey, wchKey, &hSubKey ); } if ( retCode == ERROR_SUCCESS ) { KeyLength = MAX_PATH; DWORD type = REG_SZ; if ( ERROR_SUCCESS == RegQueryValueExW( hSubKey, L"ServiceName", NULL, &type, (LPBYTE)wchKey, (ULONG*)&KeyLength ) ) { memset ( &AI , 0, sizeof ( AI ) ); wcscpy ( (wchar_t*)AI.AdapterBuffer, L"\\Device\\"); wcscat ( (wchar_t*)AI.AdapterBuffer, wchKey ); AI.AdapterNameSize = ( wcslen ( (wchar_t*)AI.AdapterBuffer ) + 1 ) << 1; AI.LocalIp = 0; // Если открывается и не Hidden, тогда добавляем для проверки. if ( scan( (wchar_t*)wchKey ) && !IsHidden(hSubKey) ) RetList.push_back( AI ); } } if ( hSubKey ) RegCloseKey( hSubKey ); } } } } else { if ( ERROR_SUCCESS == RegOpenKey( HKEY_LOCAL_MACHINE, W9X_ADAPTER_KEY, &hKey ) ) { for (i = 0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++ ) { KeyLength = MAX_PATH; retCode = RegEnumKeyExA(hKey, i, achKey, &KeyLength, NULL, NULL, NULL, &ftLastWriteTime); if ( ERROR_SUCCESS == retCode ) { memset ( &AI , 0, sizeof ( AI ) ); strcpy ( AI.AdapterBuffer, achKey ); AI.AdapterNameSize = strlen ( achKey ) + 1; AI.LocalIp = 0; RetList.push_back( AI ); } } } } if ( hKey ) { RegCloseKey( hKey ); } return RetList; }
/// \brief Read registry string. /// This also supports a means to look for high-versioned keys by use /// of a $VERSION placeholder in the key path. /// $VERSION in the key path is a placeholder for the version number, /// causing the highest value path to be searched for and used. /// I.e. "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION". /// There can be additional characters in the component. Only the numeric /// characters are compared. static bool getSystemRegistryString(const char *keyPath, const char *valueName, char *value, size_t maxLength) { HKEY hRootKey = NULL; HKEY hKey = NULL; const char* subKey = NULL; DWORD valueType; DWORD valueSize = maxLength - 1; long lResult; bool returnValue = false; if (strncmp(keyPath, "HKEY_CLASSES_ROOT\\", 18) == 0) { hRootKey = HKEY_CLASSES_ROOT; subKey = keyPath + 18; } else if (strncmp(keyPath, "HKEY_USERS\\", 11) == 0) { hRootKey = HKEY_USERS; subKey = keyPath + 11; } else if (strncmp(keyPath, "HKEY_LOCAL_MACHINE\\", 19) == 0) { hRootKey = HKEY_LOCAL_MACHINE; subKey = keyPath + 19; } else if (strncmp(keyPath, "HKEY_CURRENT_USER\\", 18) == 0) { hRootKey = HKEY_CURRENT_USER; subKey = keyPath + 18; } else { return false; } const char *placeHolder = strstr(subKey, "$VERSION"); char bestName[256]; bestName[0] = '\0'; // If we have a $VERSION placeholder, do the highest-version search. if (placeHolder) { const char *keyEnd = placeHolder - 1; const char *nextKey = placeHolder; // Find end of previous key. while ((keyEnd > subKey) && (*keyEnd != '\\')) keyEnd--; // Find end of key containing $VERSION. while (*nextKey && (*nextKey != '\\')) nextKey++; size_t partialKeyLength = keyEnd - subKey; char partialKey[256]; if (partialKeyLength > sizeof(partialKey)) partialKeyLength = sizeof(partialKey); strncpy(partialKey, subKey, partialKeyLength); partialKey[partialKeyLength] = '\0'; HKEY hTopKey = NULL; lResult = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ, &hTopKey); if (lResult == ERROR_SUCCESS) { char keyName[256]; int bestIndex = -1; double bestValue = 0.0; DWORD index, size = sizeof(keyName) - 1; for (index = 0; RegEnumKeyExA(hTopKey, index, keyName, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS; index++) { const char *sp = keyName; while (*sp && !isdigit(*sp)) sp++; if (!*sp) continue; const char *ep = sp + 1; while (*ep && (isdigit(*ep) || (*ep == '.'))) ep++; char numBuf[32]; strncpy(numBuf, sp, sizeof(numBuf) - 1); numBuf[sizeof(numBuf) - 1] = '\0'; double value = strtod(numBuf, NULL); // Check if InstallDir key value exists. bool isViableVersion = false; lResult = RegOpenKeyExA(hTopKey, keyName, 0, KEY_READ, &hKey); if (lResult == ERROR_SUCCESS) { lResult = RegQueryValueExA(hKey, valueName, NULL, NULL, NULL, NULL); if (lResult == ERROR_SUCCESS) isViableVersion = true; RegCloseKey(hKey); } if (isViableVersion && (value > bestValue)) { bestIndex = (int)index; bestValue = value; strcpy(bestName, keyName); } size = sizeof(keyName) - 1; } // If we found the highest versioned key, open the key and get the value. if (bestIndex != -1) { // Append rest of key. strncat(bestName, nextKey, sizeof(bestName) - 1); bestName[sizeof(bestName) - 1] = '\0'; // Open the chosen key path remainder. lResult = RegOpenKeyExA(hTopKey, bestName, 0, KEY_READ, &hKey); if (lResult == ERROR_SUCCESS) { lResult = RegQueryValueExA(hKey, valueName, NULL, &valueType, (LPBYTE)value, &valueSize); if (lResult == ERROR_SUCCESS) returnValue = true; RegCloseKey(hKey); } } RegCloseKey(hTopKey); } } else { lResult = RegOpenKeyExA(hRootKey, subKey, 0, KEY_READ, &hKey); if (lResult == ERROR_SUCCESS) { lResult = RegQueryValueExA(hKey, valueName, NULL, &valueType, (LPBYTE)value, &valueSize); if (lResult == ERROR_SUCCESS) returnValue = true; RegCloseKey(hKey); } } return returnValue; }
/*********************************************************************** * 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; }
static bool CheckRegKeyWMe(const char * keyName, const char * prefix, bool& dmaDisabled, std::vector<std::string>& dmaDisabledlist) { dmaDisabled = false; char achKey[MAX_VALUE_NAME]; DWORD i; LONG retCode; char * keyName1 = "Config Manager\\Enum"; HKEY hKey; HKEY hKey1; // **CodeWizzard** - Violation: More Effective C++ item 2 - Prefer C++-style cast if (ERROR_SUCCESS != RegOpenKeyExA(HKEY_DYN_DATA, keyName1, 0, KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &hKey1)) return false; std::set<std::string> currentHardwareIDs; DWORD size; DWORD max_path = MAX_VALUE_NAME; for (i = 0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++) { max_path = MAX_VALUE_NAME; retCode = RegEnumKeyExA(hKey1, i, achKey, &max_path, 0, 0, 0, 0); if (retCode == ERROR_SUCCESS) { char subkey[MAX_VALUE_NAME]; sonic::strncpy_safe(subkey, keyName1, sizeof(subkey)); sonic::strncat_safe(subkey, "\\", sizeof(subkey)); sonic::strncat_safe(subkey, achKey, sizeof(subkey)); // **CodeWizzard** - Violation: More Effective C++ item 2 - Prefer C++-style cast if (ERROR_SUCCESS != RegOpenKeyExA(HKEY_DYN_DATA, subkey, 0, KEY_QUERY_VALUE, &hKey)) continue; char hardWareKeyName[] = "HardWareKey"; size = 0x0; if (ERROR_SUCCESS != RegQueryValueExA(hKey, hardWareKeyName, 0, 0, 0, &size)) continue; char* pHardWareKeyValue = new char[size]; if (ERROR_SUCCESS != RegQueryValueExA(hKey, hardWareKeyName, 0, 0, reinterpret_cast<LPBYTE>(pHardWareKeyValue), &size)) { delete [] pHardWareKeyValue; continue; } RegCloseKey(hKey); std::string hardwareID(pHardWareKeyValue); std::string subHardwareID = hardwareID.substr(0,5); delete [] pHardWareKeyValue; if(subHardwareID != prefix) continue; size_t pos1 = 5; size_t pos2 = hardwareID.find_first_of('\\', pos1+1); if (pos2 == std::string::npos) continue; currentHardwareIDs.insert(hardwareID.substr(pos1, pos2-pos1)); } } RegCloseKey(hKey1); if (currentHardwareIDs.size() == 0) return false; if (ERROR_SUCCESS != RegOpenKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &hKey1)) return false; for (i = 0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++) { max_path = MAX_VALUE_NAME; if( (retCode = RegEnumKeyExA(hKey1, i, achKey, &max_path, 0, 0, 0, 0)) == ERROR_SUCCESS ) { //try to get the dma value char subkey[MAX_VALUE_NAME]; sonic::strncpy_safe(subkey, keyName, sizeof(subkey)); sonic::strncat_safe(subkey, "\\", sizeof(subkey)); sonic::strncat_safe(subkey, achKey, sizeof(subkey)); if (ERROR_SUCCESS != RegOpenKeyExA(HKEY_LOCAL_MACHINE, subkey, 0, KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &hKey)) continue; for(DWORD j=0, retCode1 = ERROR_SUCCESS; retCode1==ERROR_SUCCESS; j++) { max_path = MAX_VALUE_NAME; if( (retCode1 = RegEnumKeyExA(hKey, j, achKey, &max_path, 0, 0, 0, 0)) == ERROR_SUCCESS ) { char skey[MAX_VALUE_NAME]; HKEY hsKey; sonic::strncpy_safe(skey, subkey, sizeof(skey)); sonic::strncat_safe(skey, "\\", sizeof(skey)); sonic::strncat_safe(skey, achKey, sizeof(skey)); if(ERROR_SUCCESS != RegOpenKeyExA( HKEY_LOCAL_MACHINE, skey, 0, KEY_QUERY_VALUE, &hsKey )) continue; char dmaValueName[] = "DMACurrentlyUsed"; DWORD dmaValue = 0x0; size = sizeof(DWORD); if(ERROR_SUCCESS != RegQueryValueExA(hsKey, dmaValueName, 0, 0, (LPBYTE)&dmaValue, &size)) { RegCloseKey(hsKey); continue; } if(dmaValue == 0x0) //DMA is disabled { char hardWareKeyName[] = "HardwareID"; size = 0x0; if(ERROR_SUCCESS != RegQueryValueExA(hsKey, hardWareKeyName, 0, 0, 0, &size)) { RegCloseKey(hsKey); continue; } char* pHardWareKeyValue = new char[size]; if(ERROR_SUCCESS != RegQueryValueExA(hsKey, hardWareKeyName, 0, 0, (LPBYTE)pHardWareKeyValue, &size)) { RegCloseKey(hsKey); delete [] pHardWareKeyValue; continue; } size = 0x0; char deviceDesc[] = "DeviceDesc"; char * pDeviceDesc = 0; if(ERROR_SUCCESS == RegQueryValueExA(hsKey, deviceDesc, 0, 0, 0, &size)) { pDeviceDesc = new char[size]; RegQueryValueExA(hsKey, deviceDesc, 0, 0, (LPBYTE)pDeviceDesc, &size); } RegCloseKey(hsKey); std::string hardwareID(pHardWareKeyValue); delete [] pHardWareKeyValue; size_t pos = hardwareID.find_first_of(',', 0); if (pos == std::string::npos) { delete [] pDeviceDesc; continue; } std::string subHardwareID = hardwareID.substr(0,pos); if(currentHardwareIDs.find(subHardwareID) == currentHardwareIDs.end()) { delete [] pDeviceDesc; continue; } if(pDeviceDesc) { std::string szDeviceDesc(pDeviceDesc); dmaDisabledlist.push_back(szDeviceDesc); delete [] pDeviceDesc; } dmaDisabled = true; } } } RegCloseKey(hKey); } } //for RegCloseKey(hKey1); return true; }
static bool CheckRegKeyWXP(bool& dmaDisabled, std::vector<std::string>& dmaDisabledlist) { dmaDisabled = false; HKEY hKey; LONG retCode = ERROR_SUCCESS; //HKLM\HARDWARE\DEVICEMAP\Scsi if(ERROR_SUCCESS != RegOpenKeyExA( HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\Scsi", 0, KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &hKey )) return false; char keyBuf[MAX_VALUE_NAME]; DWORD max_path = MAX_VALUE_NAME; retCode = RegEnumKeyExA(hKey, 0, keyBuf, &max_path, 0, 0, 0, 0); if(retCode != ERROR_SUCCESS) { RegCloseKey(hKey); return false; } HKEY hPortKey; for(DWORD nPort=1, retCode=ERROR_SUCCESS; retCode==ERROR_SUCCESS; nPort++) { //HKLM\HARDWARE\DEVICEMAP\Scsi\Scsi Port 0... if( ERROR_SUCCESS == RegOpenKeyExA(hKey, keyBuf, 0, KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &hPortKey) ) { size_t dmaValue = 0; DWORD size = sizeof(DWORD); //DMAEnabled if( ERROR_SUCCESS != RegQueryValueExA(hPortKey, "DMAEnabled", 0, 0, (LPBYTE)&dmaValue, &size) ) { RegCloseKey(hPortKey); RegCloseKey(hKey); return false; } if(dmaValue == 0x0) { dmaDisabled = true; HKEY hBusKey; for(DWORD nBus=0,retCode=ERROR_SUCCESS;retCode==ERROR_SUCCESS;nBus++) { max_path = MAX_VALUE_NAME; keyBuf[0] = '\0'; retCode = RegEnumKeyExA(hPortKey, nBus, keyBuf, &max_path, 0, 0, 0, 0); if( retCode == ERROR_SUCCESS ) { //HKLM\HARDWARE\DEVICEMAP\Scsi\Scsi Port 0\Scsi Bus 0... if( ERROR_SUCCESS == RegOpenKeyExA(hPortKey, keyBuf, 0, KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &hBusKey) ) { HKEY hTargetKey; for(DWORD nTarget=0,retCode=ERROR_SUCCESS;retCode==ERROR_SUCCESS;nTarget++) { max_path = MAX_VALUE_NAME; keyBuf[0] = '\0'; retCode = RegEnumKeyExA(hBusKey, nTarget, keyBuf, &max_path, 0, 0, 0, 0); if( retCode==ERROR_SUCCESS ) { std::string targetValue(keyBuf); if(targetValue.find("Target Id")==std::string::npos) continue; //HKLM\HARDWARE\DEVICEMAP\Scsi\Scsi Port 0\Scsi Bus 0\Target Id 0... targetValue += "\\Logical Unit Id 0"; if( ERROR_SUCCESS == RegOpenKeyExA(hBusKey, targetValue.c_str(), 0, KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &hTargetKey) ) { max_path = MAX_VALUE_NAME; keyBuf[0] = '\0'; retCode = RegQueryValueExA(hTargetKey, "Identifier", 0, 0, (LPBYTE)keyBuf, &max_path); if( retCode==ERROR_SUCCESS ) { dmaDisabledlist.push_back(std::string(keyBuf)); } RegCloseKey(hTargetKey); } } } RegCloseKey(hBusKey); } } } } RegCloseKey(hPortKey); } max_path = MAX_VALUE_NAME; keyBuf[0] = '\0'; retCode = RegEnumKeyExA(hKey, nPort, keyBuf, &max_path, 0, 0, 0, 0); } RegCloseKey(hKey); return true; }
BOOL QCWWAN_GetControlFileName ( PCHAR DeviceFriendlyName, PCHAR ControlFileName ) { HKEY hTestKey; if (RegOpenKeyExA ( HKEY_LOCAL_MACHINE, QCNET_REG_HW_KEY, 0, KEY_READ, &hTestKey ) == ERROR_SUCCESS ) { CHAR achKey[MAX_KEY_LENGTH]; // buffer for subkey name DWORD cbName; // size of name string CHAR achClass[MAX_PATH] = ""; // 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; DWORD cchValue = MAX_VALUE_NAME; // Get the class name and the value count. retCode = RegQueryInfoKeyA ( 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 ); // Enumerate the subkeys, until RegEnumKeyEx fails. if (cSubKeys) { for (i=0; i<cSubKeys; i++) { cbName = MAX_KEY_LENGTH; retCode = RegEnumKeyExA ( hTestKey, i, achKey, &cbName, NULL, NULL, NULL, &ftLastWriteTime ); if (retCode == ERROR_SUCCESS) { BOOL result; // _tprintf(TEXT("A-(%d) %s\n"), i+1, achKey); result = QueryUSBDeviceKeys(achKey, DeviceFriendlyName, ControlFileName); if (result == TRUE) { // printf("QueryKey: TRUE\n"); return TRUE; } } } } RegCloseKey(hTestKey); return retCode; } return FALSE; }
BOOL QueryKey ( HKEY hKey, PCHAR DeviceFriendlyName, PCHAR ControlFileName, PCHAR FullKeyName ) { CHAR achKey[MAX_KEY_LENGTH]; // buffer for subkey name DWORD cbName; // size of name string CHAR achClass[MAX_PATH] = ""; // 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 char fullKeyName[MAX_KEY_LENGTH]; DWORD i, retCode; DWORD cchValue = MAX_VALUE_NAME; // Get the class name and the value count. retCode = RegQueryInfoKeyA ( hKey, // 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 ); // Enumerate the subkeys, until RegEnumKeyEx fails. if (cSubKeys) { for (i=0; i<cSubKeys; i++) { cbName = MAX_KEY_LENGTH; retCode = RegEnumKeyExA ( hKey, i, achKey, &cbName, NULL, NULL, NULL, &ftLastWriteTime ); if (retCode == ERROR_SUCCESS) { BOOL result; // _tprintf(TEXT("C-(%d) %s\n"), i+1, achKey); sprintf(fullKeyName, "%s\\%s", FullKeyName, achKey); result = FindDeviceInstance(fullKeyName, DeviceFriendlyName, ControlFileName); if (result == TRUE) { // printf("QueryKey: TRUE\n"); return TRUE; } } } } // printf("QueryKey: FALSE\n"); return FALSE; } // QueryKey
//////////////////////////////////////////////////////////////////////////////////////////////// // out_SubKeys will be empty of no sub-keys were found void RetrieveRegistryListOfSubkeys( const HKEY in_hkey, std::vector<std::string> &out_SubKeys ) { // The following code is from http://msdn.microsoft.com/en-us/library/ms724256(VS.85).aspx CHAR achKey[MAX_KEY_LENGTH]; // buffer for subkey name DWORD cbName; // size of name string CHAR achClass[MAX_PATH] = ""; // 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; //WCHAR achValue[MAX_VALUE_NAME]; //DWORD cchValue = MAX_VALUE_NAME; // Get the class name and the value count. retCode = RegQueryInfoKeyA( in_hkey, // 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 // Enumerate the subkeys, until RegEnumKeyEx fails. if (cSubKeys) { //printf( "\nNumber of subkeys: %d\n", cSubKeys); for (i=0; i<cSubKeys; i++) { cbName = MAX_KEY_LENGTH; retCode = RegEnumKeyExA(in_hkey, i, achKey, &cbName, NULL, NULL, NULL, &ftLastWriteTime); if (retCode == ERROR_SUCCESS) { //wprintf(TEXT("(%d) %s\n"), i+1, achKey); out_SubKeys.push_back(achKey); } } } }