Socket envoi pas tous les data

Version imprimable

Bonjour à tous,

alors j'ai fait pour commencer un socket serveur et client,
le client envoi "e04fd020ea3a6910a2d808002b30309d"
mais le serveur reçois qu'une partie à savoir "4f203a10d80309d".

Dois-je mettre un Thread.sleep() quelque part ? :?

Serveur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
public class SocketServer extends Thread
{
   private ServerSocket serverSocket;
   private String bitS = "";
 
   public SocketServer(int port) throws IOException
   {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(1000000);
   }
 
   @Override
   public void run()
   {
      while(true)
      {
         try
         {
            System.out.println("écoute sur le port : " +
            serverSocket.getLocalPort() + "...");
             try (Socket server = serverSocket.accept()) {
                 System.out.println("connecté à : " + server.getRemoteSocketAddress());
                 DataInputStream in = new DataInputStream(server.getInputStream());
                 //System.out.println(in.readUTF());
                 while(in.readBoolean())
                 {
                    bitS = bitS + Integer.toHexString(in.read()); 
 
                 } 
                 System.out.println(bitS);
                 DataOutputStream out = new DataOutputStream(server.getOutputStream());
                 out.writeUTF("connexion réussie " + server.getLocalSocketAddress() + "\nfin");
                 in.close();
                 out.close();
             }
         }catch(SocketTimeoutException s)
         {
            System.out.println("temps écoulé");
            break;
         }catch(IOException e)
         {
             System.out.println("erreur : " + e);
            break;
         }
      }
   }
   public static void main(String [] args)
   {
      int port = 12654;
      try
      {
         Thread t = new SocketServer(port);
         t.start();
      }catch(IOException e)
      {
      }
   }
}

Client :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
public class Client2 {
 
    public static byte[] hexStringToByte(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;
}
 
    public static void main(String[] args) throws InterruptedException {
          String serverName = "localhost";
      int port = 12654;
      byte[] b = hexStringToByte("e04fd020ea3a6910a2d808002b30309d");
      try
      {
         System.out.println("Connexion à " + serverName + " sur le port " + port);
            try (Socket client = new Socket(serverName, port)) {
                System.out.println("connecté à : " + client.getRemoteSocketAddress());
                OutputStream outToServer = client.getOutputStream();
             try (DataOutputStream out = new DataOutputStream(outToServer)) {
                 out.write(b);
                 out.writeUTF("Salut c'est : " + client.getLocalSocketAddress()+ " le 2e client "
                         + "\n attention j'envoi en byte ^^");
                 InputStream inFromServer = client.getInputStream();
                    try (DataInputStream in = new DataInputStream(inFromServer)) {
                        System.out.println("Réponse du serveur : " + in.readUTF());
                    }
             }
            }
      }catch(IOException e)
      {
          System.out.println("erreur : " + e);
      }
    }
}

24/01/2014, 17h52
thelvin

Ben tu perds grosso-modo la moitié des données...
Ce qui est un peu normal puisque tu oscilles entre lire un octet comme booléen et lire un octet comme int, mais que tu ne gardes que le int.
Garder un octet sur deux => perdre la moitié des données. Logique.

Ce n'est pas comme ça qu'on boucle sur un DataInputStream. Il faut savoir combien il y a de données à lire et s'arrêter quand on les a toutes lues.

Mais vu que là tu essaies de lire tous les octets et de les afficher en hexadécimal, pourquoi utiliser DataInputStream et pas simplement InputStream ?

Citation:

Envoyé par toufik135

Dois-je mettre un Thread.sleep() quelque part ? :?

Je vois pas le rapport -_-°.
C'est du TCP, les données sont convoyées correctement ou une IOException est lancée. Pas d'alternative.
24/01/2014, 18h02
BugFactory

Pour apporter une précision, readBoolean ne permet pas de savoir si il reste des données. C'est une méthode qui lit un octet et l'interprète sous forme de booléen.

d'accord mais comment je peux faire alors pour lire les données jusqu'à ce qu'il y en ait plus sans savoir la taille ?
Code:

1 2 3 4 5 6 while(????) { bitS = bitS + Integer.toHexString(in.read()); }

Comme je te l'ai déjà dit, avec un DataInputStream tu dois te débrouiller pour le savoir.

Exemples :
- le client et le serveur savent tous les deux qu'exactement 40 octets seront envoyés, parce que ça a été décidé comme ça.
- le message commence par 4 octets qui indiquent la longueur du reste.

Donc comme je te l'ai déjà dit, pour ce que tu essaies d'en faire, il faut un InputStream et pas un DataInputStream.

Edit : je constate que la FAQ ne dit pas vraiment comment faire avec un InputStream.

Voici la méthode naïve mais pas très efficace :
Code:

1 2 3 4 5 int b = in.read(); while(b >= 0) { bitS = bitS + String.format("%02x", (byte)b); b = in.read(); }
Et la méthode bufferisée :
Code:

1 2 3 4 5 6 7 8 byte[] buffer = new byte[1024]; int nbRead = in.read(buffer); while(nbRead >= 0) { for(int i = 0; i < nbRead; i++) { bitS = bitS + String.format("%02x", buffer[i]); } nbRead = in.read(buffer); }

Désolé, j'ai peut-être mal compris mais j'ai testé la solution de cette manière :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
public void run()
   {
      while(true)
      {
         try
         {
             System.out.println("écoute sur le port : " +
             serverSocket.getLocalPort() + "...");
             Socket server = serverSocket.accept();
             System.out.println("connecté à : " + server.getRemoteSocketAddress());
             DataOutputStream out;
             InputStream in = server.getInputStream();
             byte[] buffer = new byte[1024];
             int nbRead = in.read(buffer);
             while(nbRead >= 0) {
               for(int i = 0; i < nbRead; i++) {
                  bitS = bitS + String.format("%02x", buffer[i]); 
               }
               nbRead = in.read(buffer);
            }
            System.out.println(bitS);
            out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("connexion réussie " + server.getLocalSocketAddress() + "\nfin");
 
            out.close();
         }catch(SocketTimeoutException s)
         {
            System.out.println("temps écoulé");
            break;
         }catch(IOException e)
         {
             System.out.println("erreur : " + e);
            break;
         }
      }
   }

mais il se connecte et reste en boucle sans rien recevoir.

Effectivement, je vois que le serveur est censé donner une réponse quand il a fini de lire tous les octets... C'est-à-dire quand la socket est fermée et qu'il n'est plus possible d'envoyer une réponse -_-° ! Cela n'arrive donc bien sûr jamais.

C'est la quadrature du cercle. Si tu veux que le serveur envoie une réponse après avoir lu le message, il est obligatoire qu'il sache quelle est la taille du message.
Si tu veux lire jusqu'à ce qu'il n'y ait plus rien à lire sans t'occuper de taille, alors tu ne peux pas envoyer de réponse.

Le plus simple est de revenir sur un DataInputStream et d'indiquer juste la taille du premier message avant de l'envoyer :

Code:

out.writeInt(b.length);

Et de l'autre côté, lire cette taille; et s'en servir pour la boucle de lecture d'octets, puis lire la String qui était envoyée avec writeUTF :
Code:

1 2 3 4 5 6 7 8 9 10 // lire les octets int messageSize = in.readInt(); byte[] message = new byte[messageSize]; in.readFully(message); for(int i = 0; i < messageSize; i++) { bitS = bitS + String.format("%02x", message[i]); } // lire la String String string = in.readUTF();

27/01/2014, 02h36
toufik135

merci :ccool: