✔ Funktions Rückgabewert ist adresse

[mrkorn]

Hallo zusammen

ich hab mir eine Funktion geschrieben, die mir Registry Einträge ausliest. Jedoch bekomme ich als Warnung:
warning C4172: returning address of local variable or temporary

Ich weiß leider nicht wo ich anfangen soll das Programm zu ändern damit ich auch sicher meinen Wert bekomme und nicht die Adresse. Ich hoffe mir kann einer auf die Sprünge helfen?

Funktionsaufruf:

char * DNS_Reg = RegistryLesen(HKEY_LOCAL_MACHINE, REG_MULTI_SZ, L"Comm\\DM90001\\Parms\\TcpIp", L"DNS");
char * DNS_String = DNS_Reg;
printf("UEBRGEBEN DNS: %s\r\n",DNS_String);

Funktion:

char * RegistryLesen(HKEY MainKey, DWORD Reg_Type, LPCWSTR Subkey, LPCWSTR Value)
{
	HKEY m_hkey = MainKey;	
	LPCWSTR lpstrKey = Subkey;	
	LPCWSTR lpstrKeyValue = Value;
	DWORD dwType = Reg_Type;	

	DWORD dwSize = MAX_PATH; 
	char value[MAX_PATH];
	RegOpenKeyEx(m_hkey,lpstrKey,0,KEY_READ, &m_hkey) ;
	
	int i=0; 
	int iLastError=0; 
	char DaValue[MAX_PATH]="";
	char DaValue2[MAX_PATH]="";
	char * DaValuePart;
	int NullCounter=0;
	int EntryCounter=0;

	do 
	{ 
		LPTSTR cValueName; 
		DWORD dwValueName = 256; 
		DWORD ValueType = 0; 
		BYTE cValueData[256] = "\0"; 
		DWORD dwValueData = 256; 
		iLastError = RegEnumValue(m_hkey,i,cValueName,&dwValueName,0,&ValueType,cValueData,&dwValueData); 

		//if(ValueType == REG_SZ)
		//	printf("CVALUE: %s\r\n",cValueName);
		++i; 
	}while(iLastError!=ERROR_NO_MORE_ITEMS); 

	if (RegQueryValueEx(m_hkey, lpstrKeyValue, 0, &dwType,(LPBYTE)value,&dwSize)== ERROR_SUCCESS) 
	{		
		for(int s=0; s<(int)dwSize; s=s+2)
		{
			if (value[s]=='\0')
			{
				NullCounter++;
				DaValuePart = "";
			}
			else
			{
				DaValuePart = value+s;
				NullCounter=0;				
			}

			if (EntryCounter==0)
			{
				strcat(DaValue, DaValuePart);
			}
			else if (EntryCounter==1)
			{
				strcat(DaValue2, DaValuePart);
			}
			
			if (NullCounter==1)
			{
				NullCounter=0;
				EntryCounter++;
			}
		}
	}
	
	RegCloseKey(m_hkey);
	
	if (strlen(DaValue2)>=7)
	{
		strcat(DaValue, "-");
		strcat(DaValue, DaValue2);		
	}
	return DaValue;
}

Gruß
mrkorn

 

[crazyonur]

Hi mrkorn !

Also ich benutze RegQueryValueEx, zum Auslesen der Einträge, finde ich auch sehr unkompliziert.

hier ein Beispiel:

#include <windows.h> 
#include <iostream>
using namespace std;

int main()
{    
    DWORD dwData = 256;
    
    BYTE cDaten[256] = "";
    
    HKEY hKey;

    //hier kannst du den Pfad, der ausgelesen werden soll eingeben
    RegOpenKeyEx(HKEY_LOCAL_MACHINE,"REGISTRY Pfad", 0, KEY_READ, &hKey );
    //hier kannst du dann den Eintrag hineinschreiben, der ausgelesen werden soll :D
    RegQueryValueEx(hKey,"EINTRAG",0,0,cDaten,&dwData);

    //hier erfolgt die Ausgabe über cout
    cout<<cDaten<<"\n";
    system("pause");
 
 
}

hoffe konnte dir auf die Sprunge helfen

Gruß Onur

 

[mrkorn]

Hi Onur

danke für deinen post! Du gehst zwar nicht ganz auf das Thema ein, da ich beim Rückgabewert der Funktion eine Adresse übergebe und nicht den Wert selber!
Aber trotzdem nett von dir.
Beim auslesen benutze ich doch auch RegQueryValueEx. Nur gehe ich dann Zeichenweise durch um festzustellen an welcher Stelle die zweite IP anfängt.
Da der DNS Eintrag, den Primary und Secondary DNS in einem Key speichert, ihn mit "\0" trennt und dann mit "\0\0" abschließt:

Beipiel DNS für die IPs "123.123.123.123" und "2.2.2.2"
"DNS"=hex(7):\
31,32,33,2e,31,32,33,2e,31,32,33,2e,31,32,33,00,32,2e,32,2e,32,2e,32,00,00

Grüße
mrkorn

 

[crazyonur]

hi mrkorn !

sry..ich glaube ich war ein bisschen zu faul deinen code vollständig durchzulesen.

bitte um dein verständniss

 

[MCoder]

Hallo,

du gibst einen Zeiger auf einen Speicherbereich zurück, der nur innerhalb der Funktion "RegistryLesen" gültig ist (wird nur auf dem Stack angelegt). Nach dem Verlassen der Funktion kannst du daher nicht mehr darauf zugreifen. Du müsstest daher den Speicher für den Rückgabstring außerhalb der Funktion reservieren und als Parameter übergeben:

// Definition
char * RegistryLesen( HKEY    MainKey,
                      DWORD   Reg_Type,
                      LPCWSTR Subkey,
                      LPCWSTR Value,
                      char    *DaValue )
{
  // ...
  return DaValue;
}

// Funktionsaufruf


char DaValue[MAX_PATH];

char *pResult =  RegistryLesen( MainKey,
                                Reg_Type,
                                Subkey,
                                Value,
                                DaValue );

Gruß
MCoder

 

[mrkorn]

hi zusammen

@MCoder:
So funktioniert es. Danke.


@Crazyonur:
Ist nicht schlimm, so kam der Thread weingstens ins rollen...

Ich hätte da aber noch ne Frage, und zwar kann ich keine DWORD Einträge lesen. Ich bekomme immer nur die Adresse meines Wertes:

	HKEY hKeyRead;

	DWORD DatenDHCP[MAX_PATH];
	DWORD dwType=REG_DWORD;

	DWORD dwSize=sizeof(DWORD);

	RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"Comm\\DM90001\\Parms\\TcpIp", 0, KEY_ALL_ACCESS, &hKeyRead );

	if (RegQueryValueEx(hKeyRead, L"EnableDHCP", NULL, &dwType,(LPBYTE)&DatenDHCP, &dwSize)== ERROR_SUCCESS)
	{
		printf("DHCP: %d\r\n",DatenDHCP);
	}

	RegCloseKey(hKeyRead);

Als Ausgabe bekomme ich nur sowas: "DHCP: 269738008"

Dann hab ich noch ein zweites Beispiel aus dem Netz versucht:

DWORD VarType = REG_DWORD; //the value's a REG_DWORD type
	DWORD BuffSize = 4;
	int *Buff = (int*)malloc(BuffSize);

	RegQueryValueEx(hKeyRead,L"EnableDHCP",NULL,&VarType,(LPBYTE)Buff,&BuffSize);

	printf("DHCP: %i\r\n",Buff);

Liefert aber auch nur: "DHCP: 276752".

Was mach ich falsch?

 

[mrkorn]

Tja hat sich erledigt, bin selbst drauf gekommen

Und zwar bei dem zweiten Beispiel fehlt noch ein &:

RegQueryValueEx(hKeyRead,L"EnableDHCP",NULL,&VarType,(LPBYTE)&Buff,&BuffSize);

Und dann klappt das wunderbar...