Im PHP-Code wird
IP : PORT wie folgt per "echo" ausgegeben:
Code:
$addy = "$a1.$a2.$a3.$a4";
$key = $addy.":".$a5;
echo $key."\n";
Einige Zeilen zuvor werden $a2 - $a5 gefüllt:
Code:
$a2 = ord(fread($socket,1));
$a3 = ord(fread($socket,1));
$a4 = ord(fread($socket,1));
$a5 = ord(fread($socket,1))*256 + ord(fread($socket,1));
$a1 wird vorher schon auf die selbe Weise gefüllt und es wird überprüft ob "$a1 = 0" bzw. in diesem Fall "$a1 != 0" ist.
Wenn ich jetzt den OBEREN Code richtig deute, dann ist "$a5" der Port.
Also betrachte ich mir folgende Zeile genauer:
Code:
$a5 = ord(fread($socket,1))*256 + ord(fread($socket,1));
Ich versuche den Code jetzt einfach mal zu übersetzen:
Variable "a5" ist gleich der
ASCII-Wert des Binärwertes der empfangenen Daten multipliziert mit 256. Zu diesem wird dann nochmal der
ASCII-Wert des Binärwertes von eben addiert.
Quellen:
http://php.net/manual/de/function.ord.php
http://php.net/manual/de/function.fread.php
Wenn ich jetzt nachschaue, was "Ord" in Delphi bedeutet:
http://www.delphibasics.co.uk/RTL.asp?Name=Ord
Dort lese ich heraus, dass ich mit "Ord" in Delphi einen "Integer"-Wert aus folgenden Typen bekomme: " AnsiChar | Char | WideChar | Enumeration | Integer "
Dann schaue ich mir mal meine Typ-Definition für den Port an:
Delphi-Quellcode:
TServerListResponse = record
ResponseHeader: Integer;
PacketHeader: Word;
First: Byte; // Byte
Second: Byte; // Byte
Third: Byte; // Byte
Fourth: Byte; // Byte
Port: Word; // unsigned Short
ServerAdresses: TserverAddresses;
end;
Laut diesen Tabellen ist der Typ "Word" in C gleich der Typ "unsigned int".
ganz unten:
http://edn.embarcadero.com/article/10156#H15
ca. in der mitte:
http://stackoverflow.com/questions/1...void-parameter
Ein Blick in die Protokol Doku von Valve:
https://developer.valvesoftware.com/...Query_Protocol
Port ist in C Typ "unsigned short" und das Equivalent in Delphi dazu ist ein Typ "Char".
Eigener Code abgeändert:
Delphi-Quellcode:
TServerListResponse = record
ResponseHeader: Integer;
PacketHeader: Word;
First: Byte; // Byte
Second: Byte; // Byte
Third: Byte; // Byte
Fourth: Byte; // Byte
Port: Char; // unsigned Short
ServerAdresses: TserverAddresses;
end;
Wenn ich jetzt den Serverquery ausführe:
Delphi-Quellcode:
if chr(response.PacketHeader) = 'f' then
begin
for y := 0 to 10 do
begin
Move(buffer[i], response.First, SizeOf(response.First)); inc(i, SizeOf(response.First));
Move(buffer[i], response.Second, SizeOf(response.Second)); inc(i, SizeOf(response.Second));
Move(buffer[i], response.Third, SizeOf(response.Third)); inc(i, SizeOf(response.Third));
Move(buffer[i], response.Fourth, SizeOf(response.Fourth)); inc(i, SizeOf(response.Fourth));
Move(buffer[i], response.Port, SizeOf(response.Port)); inc(i, SizeOf(response.Port));
Form1.ListBox1.Items.Add((IntToStr(response.First)) + '.' +
(IntToStr(response.Second)) + '.' +
(IntToStr(response.Third)) + '.' +
(IntToStr(response.Fourth)) + ':' +
response.Port );
Application.ProcessMessages;
end;
end;
end;
Das Ergebnis ist weniger befriedigend:
Oh da ist ja das "ÿ" !! Das kenne ich doch vom vorherigen
Query!! "ÿ" war doch die von HEX zu Text umgewandelte "FF". Also würde mir eine Umwandlung zu HEX schonmal nichts bringen.
Ach... sind wir ma experimentierfreudig:
char(response.Port) );
Ergebnis:
Herrje !!
Okay warte mal wir hatten doch auch in den vorherigen Querys "Shorts", "Bytes", "Strings" und "Words". Ersetzen wir mal die anderen Typen durch die in den gerade gefundenen Listen.
Ergebnis ist, dass mit den Typ-Definitionen von den Quellen die Querys falsche Werte zurückliefern.
Sind die Quellen falsch ? Lese ich sie einfach nur falsch?
Das kann doch nicht so schwer sein die Typen aus einer Tabelle zu übertragen und dann die jeweiligen Funktionen zur Umwandlung in einen String zur Ausgabe in einer Listbox zu finden.