поиск в реестре

[Arigato]

Переполнение возможно только из-за глубины рекурсии. Ну то, что локальные переменные тоже стек нагружают, это понятно, но там не должно быть сильно много переменных, по идеи.

[Человек_Борща]

Ну можно же и в RegShot'ские сырки окунуться =)

//------------------------------------------------------------
//Registry Shot Engine
//------------------------------------------------------------
VOID	GetRegistrySnap(HKEY hkey,LPKEYCONTENT lpFatherKeyContent)
{
    
	HKEY  Subhkey;
	DWORD i,NTr;
	DWORD TypeCode;
	DWORD LengthOfKeyName;
	DWORD LengthOfValueName;
	DWORD LengthOfValueData;
	DWORD LengthOfLongestValueName;
	DWORD LengthOfLongestValueData;
	DWORD LengthOfLongestSubkeyName;
	LPSTR lpValueName;
	LPSTR lpValueData;
	LPKEYCONTENT	lpKeyContent,lpKeyContentLast;
	LPVALUECONTENT	lpValueContent,lpValueContentLast;

	//To detemine MAX length
	if(RegQueryInfoKey(
		hkey,
		NULL,						//lpClassName_nouse,
		NULL,						//&nClassName_nouse_length,
		NULL,
		NULL,						//&NumberOfSubkeys,
		&LengthOfLongestSubkeyName, //chars
		NULL,						//&nClassName_nouse_longestlength,
		NULL,						//&NumberOfValue,
		&LengthOfLongestValueName,	//chars
		&LengthOfLongestValueData,	//bytes
		NULL,						//&nSecurity_length_nouse,
		NULL						//&ftLastWrite
		)!=ERROR_SUCCESS)
		return ;
	LengthOfLongestSubkeyName =LengthOfLongestSubkeyName*2+3;
	LengthOfLongestValueName  =LengthOfLongestValueName*2+3;
	LengthOfLongestValueData  =LengthOfLongestValueData+1;
	lpValueName=MYALLOC(LengthOfLongestValueName);
	lpValueData=MYALLOC(LengthOfLongestValueData);

	//Get Values
	for(i=0;;i++)
	{
		
		*(LPBYTE)lpValueName=(BYTE)0x00;
		*(LPBYTE)lpValueData=(BYTE)0x00;
		//DebugBreak();
		LengthOfValueName=LengthOfLongestValueName;
		LengthOfValueData=LengthOfLongestValueData;
		NTr=RegEnumValue(hkey,i,lpValueName,&LengthOfValueName,NULL,&TypeCode,lpValueData,&LengthOfValueData);
		if	(NTr==ERROR_NO_MORE_ITEMS)
			break;
		else 
		{
			if	(NTr!=ERROR_SUCCESS)
			{
				continue;
			}
		}

		lpValueContent=MYALLOC0(sizeof(VALUECONTENT));
		if(lpFatherKeyContent->lpfirstvalue==NULL)
			lpFatherKeyContent->lpfirstvalue=lpValueContent;
		else
			lpValueContentLast->lpnextvalue=lpValueContent;
		lpValueContentLast=lpValueContent;
		lpValueContent->typecode=TypeCode;
		lpValueContent->datasize=LengthOfValueData;
		lpValueContent->lpfatherkey=lpFatherKeyContent;
		lpValueContent->lpvaluename=MYALLOC(strlen(lpValueName)+1);
		strcpy(lpValueContent->lpvaluename,lpValueName);

		if(LengthOfValueData!=0)
		{
			lpValueContent->lpvaluedata=MYALLOC(LengthOfValueData);
			CopyMemory(lpValueContent->lpvaluedata,lpValueData,LengthOfValueData);
			//	*(lpValueContent->lpvaluedata+LengthOfValueData)=0x00;
		}
		nGettingValue++;
	}

	MYFREE(lpValueName);
	MYFREE(lpValueData);
	
	for(i=0;;i++)
	{
		LengthOfKeyName=LengthOfLongestSubkeyName;
		*(LPBYTE)lpKeyName=(BYTE)0x00;
		NTr=RegEnumKeyEx(hkey,i,lpKeyName,&LengthOfKeyName,NULL,NULL,NULL,&ftLastWrite);
		if	(NTr==ERROR_NO_MORE_ITEMS)
			break;
		else 
		{
			if	(NTr!=ERROR_SUCCESS)
			{
				continue;
			}
		}
		lpKeyContent=MYALLOC0(sizeof(KEYCONTENT));
		if	(lpFatherKeyContent->lpfirstsubkey==NULL)
			lpFatherKeyContent->lpfirstsubkey=lpKeyContent;
		else
			lpKeyContentLast->lpbrotherkey=lpKeyContent;
		lpKeyContentLast=lpKeyContent;
		lpKeyContent->lpkeyname=MYALLOC(strlen(lpKeyName)+1);
		strcpy(lpKeyContent->lpkeyname,lpKeyName);
		lpKeyContent->lpfatherkey=lpFatherKeyContent;
		
		nGettingKey++;

		if(RegOpenKeyEx(hkey,lpKeyName,0,KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS,&Subhkey)!=ERROR_SUCCESS)
			continue;
		if(IsInSkipList(lpKeyName,lpSnapRegs) )
		{ 
			RegCloseKey(Subhkey); 
			continue;
		}

		GetRegistrySnap(Subhkey,lpKeyContent);
		RegCloseKey(Subhkey);
	}
	
	nGettingTime=GetTickCount();
	if ((nGettingTime-nBASETIME1)>REFRESHINTERVAL)
	{
		UpdateCounters(lan_key,lan_value,nGettingKey,nGettingValue);
	}


	return ;
}

[WolF_123]

спасибо большое))))

[WolF_123]

а куда это все вставлять?

[Человек_Борща]

это код c++.
Ищем в msdn RegEnumKeyEx, RegEnumValue,RegQueryInfoKey
и пишем код на делфи ручками.