Discussion :

[toufik135]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
      }
    }
}

[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 ?

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.

[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.

[toufik135]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[thelvin]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
}

[toufik135]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[thelvin]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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();

[toufik135]

merci