ist mein erster beitrag und ich hoffe ich hab ihn an die richtige Stelle gepostet...

Ich programmiere eine ISAPI Erweiterung mit embedded Visual C++, und zwar für ein Windows CE Gerät.

Das schreiben des Registryeintrages funktioniert, jedoch sieht der Key nicht ganz so aus wie er von den Windows CE Einstellungen geschrieben wird.

Mein KEY:
"IpAddress"=hex(7):\
31,32,33,2e,31,32,33,2e,31,32,33,2e,31,32,33

Sollte aber so aussehen, geschrieben durch die Windows CE Einstellungen:
"IpAddress"=hex(7):\
31,32,33,2e,31,32,33,2e,31,32,33,2e,31,32,33,00,00

Wenn diese Nullen fehlen dann wird unter Windows CE in den Einstellungen auch eine falsche Ip angezeigt. Anstatt "123.123.123.123" steht da dann nur noch "0.123.123.123".

Wie bekomme ich diese Nullen in meinen Key?

Grüße
Thomas

LONG iSuccess = RegCreateKeyEx( HKEY_LOCAL_MACHINE, lpstrKey, 0L, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey,lpdwDisp); 

if(iSuccess == ERROR_SUCCESS)   { 
      lpstrSubkey = L"IpAddress"; 
      MultiByteToWideChar(CP_ACP, 0, NetValueArray[queryCounter], -1,  lpstrSubkeyValue, sizeof(lpstrSubkeyValue)); 
/****    WRITE A HEX VALUE IN REGISTRY    ****/ 
     DWORD dwDispHex = 0; 
     LPDWORD lpdwDispHex = &dwDispHex; 

      iSuccess = RegCreateKeyEx( HKEY_LOCAL_MACHINE, lpstrKey, 0L, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey,lpdwDispHex); 
      if(iSuccess == ERROR_SUCCESS) 
         { 
        RegSetValueEx(hKey, lpstrSubkey, 0, REG_MULTI_SZ, 
(LPBYTE)lpstrSubkeyValue, (strlen(NetValueArray[queryCounter])*2)+1); 
         } 
   }

Habe eben noch ein +1 an strlen von RegSetValueEx rangehaengt, dadurch sieht mein Key dann so aus:
"IpAddress"=hex(7):\
31,32,33,2e,31,32,33,2e,31,32,33,2e,31,32,33,00

Nun hat er diese 2 Nullen, und unter den WinCE Einstellungen wird es nun auch richtig angezeigt.
Aber es wird ja schon einen Grund geben warum da normal "00,00" steht, oder sollte mir das etwa egal sein?

Note that REG_MULTI_SZ strings should have two null-terminating characters !!

Ok einen habe ich schon!
Wie bekomme ich noch den zweiten, etwa einfach "\0" an meinen String ranhängen?

PSTR TestIt = "";
strcat(TestIt, NetValueArray[queryCounter]);
strcat(TestIt, "\0");

führt aber zum selben Ergebnis:

IpAddress"=hex(7):\
31,32,33,2e,31,32,33,2e,31,32,33,2e,31,32,33,00

genauso wie 2mal "strcat(TestIt, "\0");" ausführen!

Gibt es vielleicht Funktionen mit denen das gehen sollte?
Ich möchte ja keine 1zu1 Quellcode abtipperei, aber ein wink in die richtige Richtung wäre echt klasse...
Danke

Ich weis jetzt nicht genau "wie" der String in lpstrSubkeyValue formatiert ist. Aber vieleicht hilft ein einfaches

strcat(lpstrSubkeyValue , ",00,00\0\0");

ich weis aber nicht ob der Code so funktioniert.

Apropo WinCE:
Hast du schonmal mit LoadIntChainHandler() gearbeitet?

Wenn ich vor der Umwandlung mit MultiByteToWideChar, deinen Code ausführe, dann steht hinter meinem RegistryKey noch ein Komma, jedoch gibt es keinerlei "00,00"!

Nach der Umwandlung bekomme ich nen Fehler:

strcat( lpstrSubkeyValue, L",00,00\0\0");

error C2664: 'strcat' : cannot convert parameter 1 from 'unsigned short [261]' to 'char *'

Hab das ganze auch schon mal mit sprintf versucht, führte aber auch nicht zum Erfolg. Was anderes fällt mir sonst nicht ein...

LoadIntChainHandler() hab ich noch nicht gebraucht! ist aber auch mein erstes Windows CE Projekt...

Lösung: Du kannst die "Länge" des einzutragenden Registry-Strings nicht mit strlen() ermitteln, sondern mußt dir selber merken, wie lang er ist.

Danke das mit wcscat bringt es nahezu. Also bei einer langen IP, 123.123.123.123, ist der RegKey immer richtig. Wenn die Ip jedoch von der länge gegen 1.1.1.1 geht dann steht meistens nicht "00,00" sondern "00,undnochetwasanderes"!? Kann auch schon bei 12.12.12.1 passieren.

WCHAR ZeroValue[MAX_PATH+1];
WCHAR WriteValue[MAX_PATH+1];
WCHAR lpstrSubkeyValue[MAX_PATH+1];
//  IP adresse setzen
lpstrSubkey = L"IpAddress";
MultiByteToWideChar(CP_ACP, 0, NetValueArray[queryCounter], -1, lpstrSubkeyValue, sizeof(lpstrSubkeyValue));
MultiByteToWideChar(CP_ACP, 0, "\0", -1, ZeroValue, sizeof(ZeroValue));

DWORD dwDispHex = 0;
LPDWORD lpdwDispHex = &dwDispHex;

iSuccess = RegCreateKeyExW( HKEY_LOCAL_MACHINE, lpstrKey, 0L,NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey,lpdwDispHex);
if(iSuccess == ERROR_SUCCESS)
{
   wcscpy(WriteValue, lpstrSubkeyValue);
   wcscat(WriteValue, ZeroValue);
   RegSetValueEx(hKey, lpstrSubkey, 0, REG_MULTI_SZ, (LPBYTE)WriteValue, (strlen(NetValueArray[queryCounter])*2)+3);
}

Ich denke mal das liegt irgendwie an meinen Längenangaben...
Bei RegSetValueEx übergeb ich ja die Länge des eigenlichen Ip-Strings vor der ganzen Umwandlung, und dann noch +3 dazu, 1 fürs erste "\0" und 2 fürs zweite "\0". Wenn ich nämlich ein +2 hinzufüge dann bekomme ich immer gute Werte aber nur mit einem "00", deshalb +3!
Seh ich das soweit richtig?

In das Array schreibe ich die IpAdressen die ich aus dem QueryString des Browsers auslese.

In das Array schreibe ich die IpAdressen die ich aus dem QueryString des Browsers auslese.

Das heißt, in Testform?

PS: Willst du immer genau drei 0-Werte am Ende des Eintrags haben? Oder hängt die Anzahl davon ab, wie lang die Adressangabe ist?

mrkorn schrieb:

In das Array schreibe ich die IpAdressen die ich aus dem QueryString des Browsers auslese.

Das heißt, in Testform?

PS: Willst du immer genau drei 0-Werte am Ende des Eintrags haben? Oder hängt die Anzahl davon ab, wie lang die Adressangabe ist?

In Testform? wie meinst du das?

Ein durch die Windows Ce Einstellungen geschriebener Key mit Ip=123.123.123.123 sieht so aus:

"IP"=hex(7):\
      31,32,33,2e,31,32,33,2e,31,32,33,2e,31,32,33,00,00

Ein durch die Windows Ce Einstellungen geschriebener Key mit Ip=1.1.1.1 sieht so aus:

"IP"=hex(7):\
      31,2e,31,2e,31,2e,31,00,00

Wenn ich jetzt nur meinen Wert nehme und schreibe habe ich nur:

"IP"=hex(7):\
      31,2e,31,2e,31,2e,31,00

Die MSDN Doku sagt aber das Keys als REG_MULTI_SZ geschrieben immer 00,00 am Ende brauchen!
Dies liegt daran das auch mehrere Ips, z.B. in DNS(primary,secondary) gespeichert werden können. Dies sieht dann so aus:

"DNS"=hex(7):\      31,32,33,2e,31,32,33,2e,31,32,33,2e,31,32,33,00,31,32,34,2e,31,32,34,2e,31,\
      32,34,2e,31,32,34,00,00

Getrennt werden die einzelnen Keys durch ein einfaches 00 und abgeschlossen wird mit 00,00.

Deshalb versuche ich hier noch ein zusätzliches "\0" an meinen Key der eine beliebige länge hat ranzuhängen und zu schreiben.

CStoll schrieb:

mrkorn schrieb:

In das Array schreibe ich die IpAdressen die ich aus dem QueryString des Browsers auslese.

Das heißt, in Testform?

PS: Willst du immer genau drei 0-Werte am Ende des Eintrags haben? Oder hängt die Anzahl davon ab, wie lang die Adressangabe ist?

In Testform? wie meinst du das?

Ja, auch mir passieren gelegentlich Tipfehler das sollte "Textform" heißen.

*schaut sich die Beispiele an* Und nach dem letzten Beitrag kann ich die Frage mit 'ja' beantworten.

Deshalb versuche ich hier noch ein zusätzliches "\0" an meinen Key der eine beliebige länge hat ranzuhängen und zu schreiben.

Da hast du dein Problem auch schon - '\0' wird von C als Stringende-Marke interpretiert, deshalb bekommst du Probleme, wenn du C-String-Funktionen (strcat(), strlen() etc) auf etwas loslässt, was Nullwerte als normalen Text enthält. Da mußt du vermutlich direkt in dein Ausgabe-Array schreiben und die fehlende(n) Nullen eintragen:

wcscpy(WriteValue, lpstrSubkeyValue);
int len=strlen(NetValueArray[queryCountertrlen]);
WriteValue[len]=WriteValue[len+1]=L'\0';
RegSetValueEx(hKey, lpstrSubkey, 0, REG_MULTI_SZ, (LPBYTE)WriteValue, 2*(len+2));

Hast du mir noch nen Tip wie ich das dann noch mit dem DNS(primary,secondary) Key zusammenfügen machen kann? Dürfte ja ähnlich gehen?

WCHAR lpstrSubkeyValueDNSPrimary[MAX_PATH+1];
WCHAR lpstrSubkeyValueDNSSecondary[MAX_PATH+1];

int len=strlen(NetValueArray[queryCounter]);
int len2=strlen(NetValueArray[queryCounter+1]);
int lenAll;

MultiByteToWideChar(CP_ACP, 0, NetValueArray[queryCounter], -1, lpstrSubkeyValueDNSPrimary, sizeof(lpstrSubkeyValue));
MultiByteToWideChar(CP_ACP, 0, NetValueArray[queryCounter+1], -1, lpstrSubkeyValueDNSSecondary, sizeof(lpstrSubkeyValue));

wcscpy(WriteValue, lpstrSubkeyValueDNSPrimary);
[b]// hier vermisse ich später mein "\0"[/b]
// muss hier "eigentlich" nicht hin da ja schon ein "\0" im String steht
// --> WriteValue[len]=WriteValue[len+1]=L'\0'; <-- //
wcscat(WriteValue, lpstrSubkeyValueDNSSecondary);
WriteValue[len+1+len2]=WriteValue[len+1+len2+1]=L'\0';
lenAll = (len+1+len2+1);

iSuccess = RegCreateKeyEx( HKEY_LOCAL_MACHINE, lpstrKey, 0L,NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey,lpdwDispHex);
if(iSuccess == ERROR_SUCCESS)
{
	RegSetValueEx(hKey, lpstrSubkey, 0, REG_MULTI_SZ, (LPBYTE)WriteValue, 2*(lenAll));
}

wcscpy(WriteValue, lpstrSubkeyValueDNSPrimary);
wcscpy(WriteValue+len+1, lpstrSubkeyValueDNSSecondary);
...

ich habs mit sowas probiert, und das geht nicht:

wcscpy(WriteValue[len+1], lpstrSubkeyValueDNSSecondary);

Danke vielmals, sollte jetzt alles sein, was das schreiben von Registry Einträgen anbelangt...