Programmation Réseaux

2023/2024

Dr SALEK RIADI
[email protected]

Filiale : DUT Génie Informatique

Semestre : 4
 Plan [1/2]
Introduction
 Brève histoire d’Internet
 TCP/IP
 IP
 TCP et UDP
 Protocoles de couche applications

Architectures des applications distribuées

 L’architecture Client/Server
 L’architecture Peer-to-Peer
 Client/Server vers Peer-to-Peer

Socket
 Principe de base
 Type de sockets
 Socket TCP vers Socket UDP
 Plan [2/2]
Interface de programmation réseaux
 JAVA
 Le package java.net.*

Socket UDP
 Communication réseau avec le protocole UDP
 Architecture Client-Serveur en mode non connecté
 Serveur UDP
 Client UDP

Socket TCP
 Architecture Client-Serveur en mode connecté
 Serveur TCP Mono Client
 Client TCP
 Gestion de plusieurs clients
 Serveur TCP Multi Client
 Références

Bogdan Ciubotaru, Gabriel-Miro Muntean, Advanced Network

Programming - Principles and Techniques, Springer, 2013.
Elliotte Rusty Harold, Java Network Programming, 4th Edition,
O'Reilly Media, 2013.
Perry Xiao, Practical Java Programming for IoT, AI, and Blockchain,
Wiley, 2019.
Badr Benmammar, Programmation concurrente, temps réel et
distribuée en Java: Threads, RTSJ et RMI, Iste, 2018.
Claude Delannay, Programmer en Java, Eyrolles , 2008.
https://www.oracle.com/java/
 Introduction Brève histoire d’Internet

1962: Début de la recherche par DARPA (Defense Advanced

Research Projects Agency) sur un réseau global d'ordinateurs.
1969: Création d’Arpanet (Advanced Research Projects Agency
Network).
Arpanet en 1969 Arpanet en 1974
 Introduction TCP/IP : Le modèle Internet

Modèle OSI (Open Systems Interconnection): Modèle à 7 couches proposé par

l’ISO (International Standardization Organisation)

Modèle TCP/IP (Transmission Control Protocol/Internet Protocol): Modèle à 4

couches proposé par DARPA (Defense Advanced Research Projects Agency)
 Introduction TCP/IP : Couche accès réseau

La couche d’accès réseau a pour rôle de transmettre les données sur le
média physique utilisé.
 En fonction du type de réseau, des protocoles différents peuvent être utilisés
à ce niveau.
 Introduction TCP/IP : Couche internet

La couche internet permet d'envoyer les données sous forme de paquets vers
leurs destinations à travers une série de réseaux physiques différents.
 L'envoi de ces paquets est réalisé en fonction des adresses définies par le
protocole IP (Internet Protocol):
 IPv4  Adresses codées sur 4 octets en décimal, soit 4,3 Milliard de
possibilités. Exemple: 105.158.9.22
 IPv6  Adresses codées sur 16 octets en hexadécimal, soit 1 adresse par
millimètre carré… Exemple: fedc:6482:cafe:ba05:a200:e8ff:fe65:df9a
 Introduction TCP/IP: Couche Transport

 La couche transport permet de faire communiquer deux processus (applications et

programmes) qui s’exécutent sur deux machines quelconques de réseau.

 Deux grands protocoles de transport:

 UDP (User Datagram Protocol) offre un service de transmission de datagrammes
sans connexion.
 TCP (Transmission Control Protocol) assure un service de transmission de donnée
fiable avec une détection et une correction d’erreurs de bout en bout.

 millimètre carré… Exemple: fedc:6482:cafe:ba05:a200:e8ff:fe65:df9a

 Introduction TCP/IP: Couche Application (1/3)

 La couche application assure l'interface avec les applications. Il s'agit donc du

niveau le plus proche des utilisateurs, géré directement par les logiciels.
 Suivant la machine et son système d'exploitation, l'application pourra être un
programme, une tâche, un processus...
 La dénomination de l'application peut varier d'un système à un autre, c'est la
raison pour laquelle un système de numéro a été mis en place afin de pouvoir
associer un type d'application à un type de données, ces identifiants sont appelés
ports.
 Introduction TCP/IP: Couche Application (2/3)

 Les ports codées sur 16 bits en décimal, soit 216 – 1, soit 65535 port disponibles sur un
ordinateur. Ils sont divisés de la façon suivante :
 0 à 1023 pour les « well known ports »;
 1024 à 49151 pour les « registred ports »;
 49152 à 65535 pour les « private and/or dynamic ports ».
 Introduction TCP/IP: Couche Application (3/3)

 Exemples (voir C:\Windows\System32\drivers\etc\services)

Protocole / couche
Port réservé Protocole / couche transport
application
echo 7 TCP/UDP
discard 9 TCP/UDP
daytime 13 TCP/UDP
FTP data 20 TCP
FTP 21 TCP
SSH 22 TCP
telnet 23 TCP
smtp 25 TCP
time 37 TCP/UDP
whois 43 TCP
finger 79 TCP
HTTP 80 TCP
POP3 110 TCP
 Architectures
distribuées L’architecture Client/Server [1/4]

 Dans une architecture Client/Server «en français

Architecture Client/Serveur», un programme Serveur
attend des requêtes en provenance des programmes
clients, afin de les traiter
 Architectures
distribuées L’architecture Client/Server [2/4]

 Nombreux applications et services qui fonctionnent

selon une architecture client/server :
 Système de Gestion de base de données.
 Les systèmes transactionnels.
 Les systèmes de messagerie, web, Internet.
 Les systèmes de partages des données.
 Les calcules scientifique.
 Cloud computing
 Architectures L’architecture Client/Server [3/4]
distribuées Le programme Serveur

 Un programme serveur
 Tourne en permanence, attendant des requêtes
 Peut répondre à plusieurs clients en même temps
 Nécessite
 Une machine robuste et rapide, qui fonctionne 24h/24: Alimentation
redondante, téchnologie RAID…
 La présence d’administrateurs systèms et réseau pour gérer les serveurs
 windows server administrator
 linux server administrator
 Architectures L’architecture Client/Server [4/4]
distribuées Le programme Client

 Un programme client
 s'exécute sur un PC, un smartphone, une tablette ou sur un autre appareil
connecté.
 utilise le service offert par un serveur.
 Le client envoie une requête et reçoit la réponse.
 Requête : message transmis par un client à un serveur décrivant l’opération
à exécuter pour le compte du client.
 Réponse : message transmis par un serveur à un client suite à l’exécution
une opération, contenant le résultat de l’opération.
 Exemples
 Client FTP
 Client telnet
 Client mail
 Navigateur
 Architectures
distribuées L’architecture Peer-to-Peer [1/2]

 Architecture Peer-to-Peer po P2P «en français Architecture pair à

pair»: dans cette architecture, chaque programme/processus
connecté au réseau peut être un client ou un serveur selon le
programme/processus est-ce qu’il demande ou fournit le service.
 Architectures
distribuées L’architecture Peer-to-Peer [2/2]

 Nombreux applications et services qui fonctionnent

selon une architecture Peer-to-Peer :
 Workgroups in Microsoft Windows Network
 Gnutella v0.4
 Freenet
 Bitcoin
 Usenet
 Napster
 Gnutella v0.6
 eDonkey2000
 BitTorrent
Architectures
distribuées Client/Server vers Peer-to-Peer

Architecture Client/Server Peer-to-Peer

souffre si le nombre de pairs
Stabilité plus stable et évolutif
augmente dans le système

Coût coûteux à implémenter. moins chers à mettre en œuvre.

Lorsque plusieurs clients
Comme les services sont fournis
demandent les services
Coté Serveur simultanément, un serveur
par plusieurs serveurs répartis,
un serveur n’est pas encombré.
peut être encombré.
Les données sont stockées Chaque pair a ses propres
Données dans un serveur centralisé. données.
 Sockets Principe de base [1/2]

 Les Sockets sont considérés comme l’une des principales solutions

utilisées par la programmation réseau pour établir une
communication inter-processus.
 Une socket est un point de communication entre un processus et un
réseau
 Un processus client et un processus serveur, lorsqu’ils communiquent,
ouvrent donc chacun une socket. C’est le système d’exploitation qui alloue
ces sockets sur demande d’une application.
 A chaque socket est associé un port de connexion. Ces numéros de ports
sont uniques sur un système donné, une application pouvant en utiliser
plusieurs

Communication
Serveur Port Port Client
 Sockets Principe de base [2/2]

 Une connexion est identifiée par la donnée de deux couples, une

adresse IP et un numéro de port, un pour le client et un autre pour
le serveur
 Un dialogue Client/Server n’a pas forcément lieu via un réseau. Il
est en effet possible de faire communiquer un client et un serveur
sur une même machine, via ce qu’on appelle l’interface de loopback
(boucle locale), représentée par convention par l’adresse IP
127.0.0.1 .

Communication
Serveur Port Port Client
 Sockets Type de sockets

 Il existe deux types de sockets, qui fournissent chacun des

fonctionnalités spécifiques:
 Sockets de couche transport (Transport Layer Sockets): UDP sockets et TCP
sockets
 Sockets de couche application (Application Layer Sockets): utilisent les
protocols de couche application telques Hypertext Transfer Protocol (HTTP)
et Simple Mail Transfer Protocol (SMTP) …
 Sockets de Couche Transport [1/2]
Sockets
Socket TCP vers Socket UDP

 Il est important de savoir ce que peuvent faire les sockets TCP et UDP, et ce
qu'elles ne peuvent pas faire, de manière à pouvoir choisir le type qui correspond
aux besoins de votre application. :

Socket TCP Socket UDP

1 Connectée Non connectée

Transmission fiable: fiabilité Transmission non fiable: il n’y a

garantie dès lors que la liaison pas de garantie de bonne
2 physique existe livraison d’un datagramme à sa
destination

3 Un peu lent Plus rapide et plus léger

Communication par flots Communication par

4 d’octets: stream datagrammes: datagramme
Transmission ordonnée: ordre Transmission non ordonnée:
de réception identique à l’ordre d’arrivée des
5 l’ordre d’émission datagrammes peut différer de
l’ordre d’envoi
 Sockets de Couche Transport [2/2]
Sockets
Socket TCP vers Socket UDP

 Le protocole TCP est dit connecté et sécurisé, car il s’assure que toutes les
données arrivent à destination et qu’elles soient reconstituées en prenant en
compte leur ordre d’émission.
 Le mauvais côté de tout ceci est que TCP est beaucoup plus lent qu'UDP mais,
comme vous le savez, UDP n'est pas un protocole sûr.
 Le mode non connecté utilise le protocole UDP de l'Internet.
 Interface de
Le package java.net
Programmation Réseaux

 Java possède en standard une API permettant de programmer des

application réseau, en utilisant des sockets
 En Java toutes les classes relatives aux sockets sont dans le package
java.net

Object

ServerSocket
DatagramSocket
DatagramPacket

HttpAwareServerSocket Socket MulticastSocket

HttpSendSocket WrappedSocket
 Communication réseau avec le protocole
Sockets UDP
UDP

 Un processus envoie un paquet autonome d'information (datagramme) à destination

d'un autre en spécifiant son adresse (l’adresse IP de machine et numéro de port).
 Réciproquement, un processus peut recevoir des datagrammes sur un port. Le
datagramme contiendra les informations envoyées par l'émetteur, ainsi que son
adresse IP. Il n'est donc pas nécessaire de connaître à l'avance les adresses IP de
machine et de port de ses correspondants.
 Contrairement au mode connecté, aucune procédure de connexion n'est nécessaire.
Par contre, il n'y a aucune garantie que les datagrammes arrivent à destination. Si un
datagramme est perdu, par exemple parce que personne n'est là pour le recevoir,
l'émetteur n'est pas averti.
 Architecture Client-Server en mode non connecté
Sockets UDP [1/2]

Client Réseau Server

Envoi d’un
Attente d'un
message
message

Envoi d'une
réponse

Attente d'un
message
 Architecture Client-Serveur en mode non connecté
Sockets UDP [2/2]

Message
Serveur Port Client

Réponse
Serveur Port Client
 Sockets UDP Serveur UDP

import java.net.*;
class UDPServer{
public static void main(String[] args) throws Exception {
int port = Integer.parseInt(args[0]);
byte buffer[] = new byte[1024];
DatagramSocket socket = new DatagramSocket(port);
while(true) {
DatagramPacket dp = new DatagramPacket(buffer,buffer.length);
socket.receive(dp);
String str = new String(dp.getData(), 0, dp.getLength());
System.out.println("@IP : " + dp.getAddress() + "Port : " + dp.getPort()
+ " : " + str);
socket.send(dp);
}
}
}
 Sockets UDP Client UDP

import java.net.*;
public class UDPClient{
public static void main(String args[]) throws Exception {
InetAddress serveur = InetAddress.getByName(args[0]);
int length = args[2].length();
byte buffer[] = args[2].getBytes();
int port = Integer.parseInt(args[1]);
DatagramPacket dataSent = new DatagramPacket(buffer,length,serveur,port);
DatagramSocket socket = new DatagramSocket();
socket.send(dataSent);
DatagramPacket dataRecieved = new DatagramPacket(new
byte[length],length);
socket.receive(dataRecieved);
System.out.println("Data recieved : " + new String(dataRecieved.getData()));
System.out.println("From : " + dataRecieved.getAddress() + ":" +
dataRecieved.getPort());
socket.close();
}
}
 Sockets UDP TD2 - Exercice 2 [1/3]

 Le programme serveur suivant (PrimeServer.java) permet de

déterminer si un nombre est premier :

import java.io.*;
import java.net.*;
class PrimeServer {
public static void main(String[] args) throws Exception {
int port = Integer.parseInt(args[0]);
DatagramSocket socket = new DatagramSocket(port);
int n;
Boolean b;
while (true) {
DatagramPacket dr = new DatagramPacket(new byte[32], 32);
socket.receive(dr);
String str = new String(dr.getData(), 0, dr.getLength());
System.out.println( str);
n = Integer.parseInt(str);
b = true;
 Sockets UDP TD2 - Exercice 2 [2/3]

for(int i = 2; i <= n/2; i++){

if(n % i == 0){
b = false;
}
}
if(b){
str = "Given number is Prime";
}
else{
str = "Given number is not Prime";
}
byte buffer[] = str.getBytes();
DatagramPacket ds = new DatagramPacket(buffer, buffer.length,
dr.getAddress(), dr.getPort());
socket.send(ds);
}
}
}
 Sockets UDP TD2 - Exercice 2 [3/3]

1. Quel est le protocole de couche transport utilisé par ce serveur ?

justifiez votre réponse.
2. Donnez la commande qui permet de lancer ce serveur sur le port
5000.
3. Ecrire un programme client «PrimeClient.java» qui peut
communiquer avec ce serveur.
4. Donnez la commande qui permet de connecter ce client au
serveur.
 Sockets UDP TD2 - Exercice 2 : Solution [1/3]

1. Quel est le protocole de couche transport utilisé par ce serveur ?

justifiez votre réponse.
- UDP ;
- Justification : le programme utilise les classes DatagramSocket et
DatagramPacket qui utilisent le protocole de couche transport
UDP.
2. Donnez la commande qui permet de lancer ce serveur sur le port
5000.
- java PrimeServer 5000
 Sockets UDP TD2 - Exercice 2 : Solution [2/3]

3. Ecrire un programme client «PrimeClient.java» qui peut

communiquer avec ce serveur.
import java.io.*;
import java.net.*;
public class PrimeClient {
public static void main(String args[]) throws Exception {
InetAddress serveur = InetAddress.getByName(args[0]);
int length = args[2].length();
byte buffer[] = args[2].getBytes();
int port = Integer.parseInt(args[1]);
DatagramPacket ds = new DatagramPacket(buffer, length, serveur, port);
DatagramSocket socket = new DatagramSocket();
socket.send(ds);
DatagramPacket dr = new DatagramPacket(new byte[100], 100);
socket.receive(dr);
System.out.println("Data recieved : " + new String(dr.getData()));
socket.close();
}
}
 Sockets UDP TD2 - Exercice 2 : Solution [3/3]

4. Donnez la commande qui permet de connecter ce client au

serveur.
- java PrimeClient 136.77.35.17 5000 66
 Sockets UDP TD2 – Exercice 4

 Ecrire un programme de chat Talkie-Walkie qui permet à deux utilisateurs

d'échanger des messages en utilisant le protocole UDP
 Le première utilisateur (Peer A) envoie un message texte puis se met
en attente.
 De son côté, le deuxième utilisateur (Peer B) reçoive le message et
renvoie à l'émetteur (Peer A) un autre message puis se met en
attente.
 Le premier utilisateur (Peer A) reste en attente jusqu’à ce qu'il
reçoive le message de deuxième utilisateur pour envoyer un
nouveau message et ainsi de suite…
 TD2 – Exercice 4
Sockets UDP
Peer-to-Peer Solution

Messages de A vers B
Peer A Port Port Peer B
Messages de B vers A
 TD2 – Exercice 4
Sockets UDP Peer-to-Peer Solution: Peer A [1/2]

class PeerA {
public static void main(String args[]) throws Exception {
InetAddress peerB = InetAddress.getByName(args[0]);
int length;
byte buffer[];
DatagramSocket socket = new DatagramSocket(10000);
DatagramPacket dataSent, dataRecieved;
Scanner sc = new Scanner(System.in);
String str;
 TD2 – Exercice 4
Sockets UDP Peer-to-Peer Solution: Peer A [2/2]

while (true) {
buffer = new byte[1024];
dataRecieved = new DatagramPacket(buffer, buffer.length);
socket.receive(dataRecieved);
str = new String(dataRecieved.getData(), 0,
dataRecieved.getLength());
System.out.println("Peer B : " + str);
str = sc.nextLine();
length = str.length();
buffer = str.getBytes();
dataSent = new DatagramPacket(buffer, length,
peerB,dataRecieved.getPort());
socket.send(dataSent);
}
}
}
 TD2 – Exercice 4
Sockets UDP Peer-to-Peer Solution: Peer B [1/2]

import java.io.*;
import java.net.*;
import java.util.Scanner;
public class PeerB {
public static void main(String args[]) throws Exception {
InetAddress peerA = InetAddress.getByName(args[0]);
int portA = Integer.parseInt(args[1]);
int length;
byte buffer[];
DatagramSocket socket = new DatagramSocket(20000);
DatagramPacket dataSent, dataRecieved;
Scanner sc = new Scanner(System.in);
String str;
 TD2 – Exercice 4
Sockets UDP Peer-to-Peer Solution: Peer B [2/2]

while (true) {
str = sc.nextLine();
length = str.length();
buffer = str.getBytes();
dataSent = new DatagramPacket(buffer, length, peerA, portA);
socket.send(dataSent);
buffer = new byte[1024];
dataRecieved = new DatagramPacket(buffer, buffer.length);
socket.receive(dataRecieved);
str = new String(dataRecieved.getData(), 0,
dataRecieved.getLength());
System.out.println("Peer A : " + str);
}
}
}
 TD2 – Exercice 4
Sockets UDP Client/Server Solution

Etape 2: Message de Server vers Client 2

Port Client 2
Etape 3: Message de Client 2 vers Server

Port

Serveur

Port

Etape 4: Message de Server vers Client 1

Port Client 1
Etape 1: Message de Client 1 vers Server
 Sockets UDP TD2 – Exercice 3

 Un nombre est parfait si il est égal à la somme de ses diviseurs

excepté lui même. Ecrire un programme serveur qui permet de
déterminer si un nombre est parfait en utilisant le protocole UDP.
Sockets TCP Architecture Client-Serveur en mode connecté
 Sockets TCP Serveur TCP Mono Client [1/2]

 Le Serveur Mono Client ne traite qu’un seul client

Demande de connexion
Serveur Port Client

Accepte
Serveur Port Client

Connexion
Serveur Port Port Client
 Sockets TCP Serveur TCP Mono Client [2/2]

import java.io.*;
import java.net.*;

class TCPServer {
public static void main(String argv[]) throws Exception {
int port = Integer.parseInt(argv[0]);
ServerSocket ss = new ServerSocket(port);
String str;
while (true) {
Socket connectionSocket = ss.accept();
InputStreamReader isr = new InputStreamReader(connectionSocket.getInputStream());
BufferedReader br = new BufferedReader(isr);
PrintWriter pw = new PrintWriter(connectionSocket.getOutputStream() , true);
str = br.readLine();
System.out.println("Received: " + str);
str = str.toUpperCase();
pw.println(str);
}
}
}
 Sockets TCP Client TCP

import java.io.*;
import java.net.*;
import java.util.Scanner;
class TCPClient {
public static void main(String argv[]) throws Exception {
InetAddress serveur = InetAddress.getByName(argv[0]);
int port = Integer.parseInt(argv[1]);
Socket clientSocket = new Socket(serveur, port);
Scanner sc = new Scanner(System.in);
BufferedReader br = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
PrintWriter pw = new PrintWriter(clientSocket.getOutputStream() , true);
String str;
System.out.println("Write your message here :");
str = sc.nextLine();
pw.println(str);
str = br.readLine();
System.out.println("Server response : " + str);
clientSocket.close();
}
}
 Sockets TCP Gestion de plusieurs clients [1/4]

 Contrainte de communication avec plusieurs clients

 Lecture sur une socket : opération bloquante tant que des données ne sont
pas reçues
 Attente de connexion : opération bloquante jusqu'à la prochaine connexion
d'un client distant
 Avec un seul flot d'exécution (processus/thread)
 Si ne sait pas quel est l'ordonnancement des arrivées des données des
clients ou de leur connexion au serveur: Impossible à gérer
 Donc nécessité de plusieurs processus ou threads
 Un processus en attente de connexion sur le port d'écoute
 Nouvelle connexion : un nouveau processus est créé pour gérer la
communication avec le nouveau client
 Sockets TCP Gestion de plusieurs clients [2/4]

 Java offre nativement un mécanisme permettant de gérer des flux

d'exécution parallèle: Les threads
 Rappel différence processus/thread
 Le processus est créé comme une copie d'un processus
existant
 Deux processus distincts avec leur mémoire propre
 Le thread s'exécute au sein d'un processus existant
 Nouveau flux d'exécution interne
 Partage des données du processus
 Pour créer et lancer un nouveau thread, 2 modes:
1. Etendre la classe java.lang.Thread
2. Implémenter l'interface java.lang.Runnable
 Sockets TCP Gestion de plusieurs clients [3/4]

1. Etendre la classe java.lang.Thread

 Redéfinir la méthode public void run() qui contient la
séquence de code qu'exécutera le thread
 Pour lancer le thread
 Instancier normalement la classe définie
 Appeler ensuiter la méthode start() sur l'objet créé

2. Implémenter l'interface java.lang.Runnable

 Définir la méthode public void run() de cette interface
 Qui contient la séquence de code qu'exécutera la thread
 Pour lancer le thread
 Instancier normalement la classe définie
 Créer une instance de la classe Thread en passant cet objet
en paramètre
 Lancer la méthode start() du thread instancié
Sockets TCP Gestion de plusieurs clients [4/4]
Sockets TCP Gestion de plusieurs clients [4/4]
Sockets TCP Serveur TCP Multi-Clients [1/8]

Demande de connexion
Serveur Port Client 1
Sockets TCP Serveur TCP Multi-Clients [2/8]

Accepte
Serveur Port Client 1
Sockets TCP Serveur TCP Multi-Clients [3/8]

Serveur Port

Port

connexion
Port Client 1
Sockets TCP Serveur TCP Multi-Clients [4/8]

Demande de connexion
Serveur Port Client 2

Port

Connexion
Port Client 1
Sockets TCP Serveur TCP Multi-Clients [5/8]

Accepte
Serveur Port Client 2

Port

Connexion
Port Client 1
Sockets TCP Serveur TCP Multi-Clients [6/8]

Connexion
Port Client 2

Port

Serveur Port

Port

Port Client 1
Connexion
 Sockets TCP Serveur TCP Multi Client [7/8]
/* ServeurMulti.java*/
/* Serveur multi clients */
import java.io.*;
import java.net.*;

public class ServerMulti {

public static void main(String[] args) {
if (args.length < 1) return;
int port = Integer.parseInt(args[0]);
try (ServerSocket serverSocket = new ServerSocket(port)) {
System.out.println("Server is listening on port " + port);
while (true) {
Socket socket = serverSocket.accept();
System.out.println("New client connected");
new ServerThread(socket).start();
}
}
catch (IOException ex) {
System.out.println("Server exception: " + ex.getMessage());
ex.printStackTrace();
}
}
}
 Sockets TCP Serveur TCP Multi Client [8/8]
class ServerThread extends Thread {
private Socket socket;
public ServerThread(Socket socket_) {socket = socket_;}
public void run() {
try {
int c_port = socket.getPort();
String c_ip = socket.getInetAddress().toString();
InputStream input = socket.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
OutputStream output = socket.getOutputStream();
PrintWriter writer = new PrintWriter(output, true);
String text;
do {
text = reader.readLine();
System.out.println("Client " + c_port + " : " + text);
writer.println("Server: " + "bien recu");
} while (!text.equals("bye"));
socket.close();
} catch (IOException ex) {
System.out.println("Server exception: " + ex.getMessage());
ex.printStackTrace();
}
}
}
MERCI DE VOTRE ATTENTION