Socket Socket schreib Effekt

[nitschchedu]

Hallo Hallo,

ich schreibe zur Zeit Plugins für mein Programm. Jetzt hab ich zurzeit ein Plugin das was über einen Socket zurück schreibt.
In der Entwicklungsumgebung funktioniert alles wunderbar. Doch in im Programm selber gibt es eine einzige stelle wo ein Byte nicht richtig geschrieben wird!

Also in der Entwicklungsumgebung der String:

093132372e302e302e31000000000000009623356130326165383432383363623662646334346137316664326232663564656500

Im Programm:

093132372e302e302e31000000000000003F23356130326165383432383363623662646334346137316664326232663564656500

Beide Strings sind im Wireshark mitgelesen!

Im Code schreibe ich hier auf den Socket:

protected void SendPacket(String packet) throws IOException
    {
        OutputStream out = this.client.getOutputStream();

        out.write(packet.getBytes());
        out.flush();
        
        //System.out.println(CHexString.toHexString(packet));
    }

Wandel ich den String dann noch um und geb ihn in der Console aus steht er auch richtig da.
Gibt es eine schönere Möglichkeit als mit getBytes das ganze zuschreiben oder gibt es da einen Punkt den ich übersehe?

 

[ModellbahnerTT]

anderes encoding in der IDE??

 

[nitschchedu]

Benutze immer Netbeans, desweiteren stammt das Hauptprogramm und das Plugin aus der selben IDE (Netbeans).
Auch in den Debugzeilen vom Hauptprogramm steht es richtig aber wird falsch an der einen Stelle gesendet!

Java ändert da wohl nach lust und Laune die Regeln ^^ !?

 

[oversoul]

Übergib mal der Funktion .getBytes() den Parameter "UTF-8" und guck ob sich was ändert

 

[fastjack]

Der erste String kann keine valide Bytefolge sein. Teile mal den String in eine Bytefolge auf. Also zwei Zeichen ergeben ein byte. An der Stelle 9623 hättest Du dann 0x96, 0x23.

0x96 = 150 > 127 --> kein Byte.

Der zweite String sieht bei mir so aus :

127.0.0.1XXXXXXX?#5a02ae84283cb6bdc44a71fd2b2f5deeX

wobei X bei mir als Kasten dargestellt wird.

Nachtrag :

        byte[] b = new byte[]{0x09, 0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x23, 0x35, 0x61, 0x30, 0x32, 0x61,
                0x65, 0x38, 0x34, 0x32, 0x38, 0x33, 0x63, 0x62, 0x36, 0x62, 0x64, 0x63, 0x34,
                0x34, 0x61, 0x37, 0x31, 0x66, 0x64, 0x32, 0x62, 0x32, 0x66, 0x35, 0x64, 0x65,
                0x65, 0x00};
        System.out.println(new String(b));

        b = new byte[]{0x09, 0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x96 /* > 127 ! */, 0x23, 0x35, 0x61, 0x30, 0x32, 0x61, 
                0x65, 0x38, 0x34, 0x32, 0x38, 0x33, 0x63, 0x62, 0x36, 0x62, 0x64, 0x63, 0x34,
                0x34, 0x61, 0x37, 0x31, 0x66, 0x64, 0x32, 0x62, 0x32, 0x66, 0x35, 0x64, 0x65,
                0x65, 0x00};
        System.out.println(new String(b));

 

[nitschchedu]

Mein Test:

byte[] b = new byte[10];

        String buff = CHexString.fromHexString("9623");

        String mchar = buff.substring(0, 0 + 1);
        b[0] = (byte) mchar.charAt(0);

        mchar = buff.substring(1, 1 + 1);
        b[1] = (byte) mchar.charAt(0);

        System.out.println(b[0]);
        System.out.println(b[1]);

Ausgabe:

-106
35

Hab ich das so richtig verstanden?

 

[fastjack]

Ich glaube nicht :

So muß das sein :

// 9623 -> 0x96, 0x23
System.out.println(Byte.decode("0x96")); // Value out of range. Value:"96" Radix:16
System.out.println(Byte.decode("0x23"));

P.S.: woher kommt den CHexString ?

 

[nitschchedu]

fastjack hab gerade gesehen das das nicht stimmen kann und hab auf deinen Hinweiß gegoogelt und das gefunden:
Quelle: hier

//Here's a solution that I think is better than any posted so far:

public static byte[] hexStringToByteArray(String s) {
    int len = s.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
        data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                             + Character.digit(s.charAt(i+1), 16));
    }
    return data;
}

/**Reasons why it is an improvement:

    *

      Safe with leading zeros (unlike BigInteger) and with negative byte values (unlike Byte.parseByte)
    *

      Doesn't convert the String into a char[], or create StringBuilder and String objects for every single byte.

Feel free to add argument checking via assert or exceptions if the argument is not known to be safe.**/

Und nun folgenden Test gemacht:

String buff = "9623";
        byte[] b = Main.hexStringToByteArray(buff);

        System.out.println(b[0]);
        //System.out.println(b[1]);
        System.out.println(new String(b));
        System.out.println(CHexString.byteArrToHexString(b));

Das so nun richtig in der Umwandlung?

Ausgabe:

-106
–#
9623

PS. CHexString ist meine Klasse da ich mit HexStrings Arbeiten muss

 

[fastjack]

Also ich bin davon das der String "9623" die Hexdarstellung der Bytes 0x96 und 0x23 ist.

Beispiel:

        String s = "hallo welt !";
        System.out.println(s);
        System.out.println("==>");
        byte[] b0 = s.getBytes();
        for (int i = 0; i < b0.length; i++) {
            System.out.print(Integer.toHexString(b0[i]));
            System.out.print(" ");
        }
        System.out.println();
        System.out.println("==>");
        b0 = new byte[]{0x68, 0x61, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x65, 0x6c, 0x74, 0x20, 0x21};
        System.out.println(new String(b0));
        System.out.println("==>");
        System.out.println("68616c6c6f2077656c742021");
        System.out.println("==>");
        b0 = hexStringToByteArray("68616c6c6f2077656c742021");
        System.out.println(new String(b0));

Ausgabe :

hallo welt !
==>
68 61 6c 6c 6f 20 77 65 6c 74 20 21 
==>
hallo welt !
==>
68616c6c6f2077656c742021
==>
hallo welt !

und eben der String

68 61 6c 6c 6f 20 77 65 6c 74 20 21

ist das, was Dir wireshark anzeigt.

--> Deine letzte Umwandlung ist richtig