Problemi di lettura pachetto UDP

[timeless]

sto cercando di leggere una serie di informazioni che mi arrivano in broadcasting sulla porta 1002 in udp ma avendo letto e creato un piccolo programma che legge il traffico UDP ho scoperto una cosa che non mi so spiegare.

codice mio programma

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPReceive {
  public static void main(String args[]) {
    try {
      int port = 1002;
      DatagramSocket socket = new DatagramSocket(port);
      //InetAddress server = InetAddress.getByName("10.0.0.251");
      byte[] buffer = new byte[4096];
      DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
      while (true) {
        socket.receive(packet);
        String msg = new String(buffer, 0, packet.getLength());
        System.out.println(packet.getAddress().getHostName());
        //System.out.println(" ");
        //System.out.println(msg);
        System.out.println(" ");
		System.out.println(stringToHex(msg));
	    stringHex(buffer,packet.getLength());
        packet.setLength(buffer.length); 
      }
    } catch (Exception e) {
      System.err.println(e);
    }
  }
public static String stringToHex(String base)
    {
     StringBuffer buffer = new StringBuffer();
     int intValue;
     for(int x = 0; x < base.length(); x++)
         {
         int cursor = 0;
         intValue = base.charAt(x);
         String binaryChar = new String(Integer.toBinaryString(base.charAt(x)));
         for(int i = 0; i < binaryChar.length(); i++)
             {
             if(binaryChar.charAt(i) == '1')
                 {
                 cursor += 1;
             }
         }
         if((cursor % 2) > 0)
             {
             intValue += 128;
         }
            if (intValue > 15) {
                buffer.append(Integer.toHexString(intValue)+".");
            } else {
                buffer.append("0"+Integer.toHexString(intValue)+".");
            }
     }
     return buffer.toString();
}
    public static Void stringHex(byte[] base, int leng) {
        StringBuffer buffer = new StringBuffer();
        for (int x = 0; x < leng; x++) {
            buffer.append(base[x] + ".");
        }  
        System.out.println(buffer.toString());
        return null;
       } 

}

la lettura che mi rende questo programmino in alcuni punti risulta errata:
00.0c.c6.f6.a9.d8.00.00.1d3.82.00.00.30.39.3a.35.3 6.3a.b2.39.00.00.
ma invece da uno sniffer vedo i dati reali:
00.0c.c6.76.29.58.08.00.45.00.02.54.bf.9f.00.b9.40 .11.a2.47.0a.00.00.fb.0a.00
ora non mi so spiegare perché vedo informazioni a oltre 8 bit es ( 1d3 ) che poi mi degradano tutto il parchetto.

quale potrebbe essere il problema ?

[ivenuti]

con che codifica vengono inviati i dati?
Alcune codifiche usano due byte per rappresentare certi caratteri...

[timeless]

i dati sono esadecimali ... per tanto hanno codifica classica a 8 bit.
basta vedere lo sniffer che legge i dati corretti ..

[timeless]

Semplificato , vado a leggere i valori presenti nell'array del buffer ma mi ci trovo dei valori negativi.. Come mai ?

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPReceive {
  public static void main(String args[]) {
    try {
      int port = 1002;
      DatagramSocket socket = new DatagramSocket(port);
      //InetAddress server = InetAddress.getByName("10.0.0.251");
      byte[] buffer = new byte[2048];
      DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
      while (true) {
        socket.receive(packet);
        System.out.println(packet.getLength());
        String msg = new String(buffer, 0, packet.getLength());
        System.out.println(packet.getAddress().getHostName());
        for (int x = 0; x < 2048; x++) {
            System.out.print(buffer[x] + ".");
        }
        System.out.println("");
        //packet.setLength(buffer.length);
      }
    } catch (Exception e) {
      System.err.println(e);
    }
  }
}

[andbin]

Originariamente inviato da timeless
i dati sono esadecimali ... per tanto hanno codifica classica a 8 bit.
basta vedere lo sniffer che legge i dati corretti ..

Lo sai che quando si converte un String in una sequenza di byte (o viceversa) bisogna sempre tenere a mente le questioni sui charset??

Originariamente inviato da timeless
Semplificato , vado a leggere i valori presenti nell'array del buffer ma mi ci trovo dei valori negativi.. Come mai ?

Lo sai che a parte il tipo char (che è unsigned), tutti gli altri tipi "primitivi" numerici interi sono signed (con segno)??

[timeless]

ok .. lo posso capire ma 0x088 in esadecimale non mi posso trovare -120...

Quale è la soluzione migliore perchè io mi possa andare a leggere i dati in esadecimale che mi arrivano dalla rete sul protocollo UDP ?

[andbin]

Originariamente inviato da timeless
ok .. lo posso capire ma 0x088 in esadecimale non mi posso trovare -120...

0x88 su 8 bit "segnati" vale proprio -120 in decimale!!!!
Almeno conoscere la numerazione binaria in complemento a due ..... dai ....

Originariamente inviato da timeless
Quale è la soluzione migliore perchè io mi possa andare a leggere i dati in esadecimale che mi arrivano dalla rete sul protocollo UDP ?

Guarda che non hai capito ..... la lettura dei byte che fai è certamente corretta .... la questione NON è lì.

Quello che può cambiare è il modo di "interpretare" il significato di quei 8 bit!!! 10001000 binario (0x88 appunto) lo puoi "vedere" come un valore 136 decimale senza segno, oppure come un valore -120 decimale se con segno oppure come 88 se in packet BCD (campi di 4 bit) ..... oppure se la tua casa ha 8 porte, ognuno dei bit potrebbe indicare se la porta è aperta o no ....

Dipende cosa rappresenta per te quel byte ....

[timeless]

bene ora ho capito .. grazie di cuore
ora pero che ho capito che mi servano in BCD non so come prendere i dati dal Buffer e farmeli portare in BCD

mi puoi dare una mano

[andbin]

Originariamente inviato da timeless
ora pero che ho capito che mi servano in BCD non so come prendere i dati dal Buffer e farmeli portare in BCD

Vuoi avere una rappresentazione in esadecimale di un byte??

String s = Integer.toHexString(tuoByte & 0xFF);

La stringa risultante non ha sempre 2 cifre hex ... se ne ha 1 devi aggiungere tu uno "0" davanti.

E il perché della AND con 0xFF te lo spiego pure subito. toHexString() di Integer si aspetta un int (non c'è un toHexString() in Byte). Quindi un byte viene convertito in int ma la conversione estende il segno, quindi es. un byte 0x88 che è negativo diventa un int 0xFFFFFF88 e quindi otterresti una stringa "ffffff88".

[timeless]

Grazie Mille .. ecco che ora funziona come volevo ...

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPReceive {

    public static void main(String args[]) {
        try {
            int port = 1002;
            DatagramSocket socket = new DatagramSocket(port);
            byte[] buffer = new byte[4096];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            while (true) {
                socket.receive(packet);
                System.out.println(packet.getAddress().getHostName());
                for (int x = 0; x < 2048; x++) {
                    if (Integer.toHexString(buffer[x] & 0xFF).length() < 2) {
                        System.out.print("0" + Integer.toHexString(buffer[x] & 0xFF));
                    } else {
                        System.out.print(Integer.toHexString(buffer[x] & 0xFF));
                    }
                    System.out.print(".");
                }
                System.out.println("");
            }
        } catch (Exception e) {
            System.err.println(e);
        }
    }
}