Réponse d'un serveur à tous les clients

**Super_carotte** · 21/12/2010, 11h53

Bonjour a tous.
Je suis actuellement en train de réaliser un code pour réaliser un chatt type IRC en PERL.

J’avais pensé a utilisé (pour mon exemple) 3 machines.
- 1 serveur
- 2 clients

Ce qui fonctionne pour l'instant:
- Mes 2 ou 3 ou X clients peuvent parler simultanément a mon serveur.
- Il n'y a jamais de cas ou un client doit attendre la fin d'exécution d'un tache d'un autre client pour parler (utilisation de fork)
- Les messages sont tous bien reçus par mon "serveur"
-les messages envoyé par un client (mettons le client A) sont bien reçus par le serveur, et le serveur arrive bien a renvoyer ce même message au client A.

Ce que je recherche:
- Actuellement, mon serveur reçois bien les messages, mais ce que je voudrai, c'est qu'il renvoi les messages reçus a tous les clients. (pour que les clients puissent voire et donc répondre aux messages des autres, comme dans un chat IRC)
Et mon probleme est la: je n'arrive pas a faire cet envoi des messages reçus par un client a touts les autres clients.

Si vous avez une idée, je vous en serai reconnaissant.

Merci,
Cordialement,
Benjamin

**Philou67430** · 21/12/2010, 13h15

Ton serveur à la connaissance de tous les clients connecté. Tu devrais pouvoir, à la réception d'un message d'un client, le renvoyer à toutes les autres connexions...

Sans voir comment est écrit ton serveur, il sera difficile de t'aider plus.

**Philou67430** · 21/12/2010, 13h18

Il y a une chose que je ne comprend pas : pourquoi as-tu besoin de fork ?
Tu veux dire que tes clients et ton serveur sont créés par fork à partir d'une unique application perl sur une seule machine ? Si c'est ça, ce n'est pas vraiment l'usage pour une application clients-serveur...

**Super_carotte** · 21/12/2010, 14h41

Merci de ton aide.
Étant débutant, j'imagine en effet que mes utilisations de fork, thread etc ne sont pas les meilleures.
Actuellement, j'essaie de résoudre mon problème grâce au threads.

Comme tu l'a dit, je pense qu'il te serai plus utile d'avoir mon code.

J'ai donc :
-1 fichier pour le serveur (chat1.pl)
-2 fichiers pour le premiers client (chat2.pl et chat2.pm)
-2 fichiers pour le deuxieme client (qui est identique au premier client chat3.pl et chat3.pm)
(je lance tout depuis la meme machine)
Il faut lancé chat1.pl puis ensuite les clients.

Voici les codes:
CHAT1.PL:

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#Ce code en PERL est un serveur chatt
#Pour utiliser ce code, ouvrez l invite de commande, placez vous dans le repertoire
#que vous voulez analyser et ecrivez la commande:
#"pearl EMPLACEMENT_DU_FICHIER_CALCUL_TAILLE_DOSSIER"
#exemple: "perl D:\Data\calcul_taille_dossier.pl"
#Commande detail:
#D:\BENJAMIN>"d:\Appli portable\Eclipse_3.5.1\Data\ActivePerl-5.12.2.1202-MSWin32-x86-293621\perl\bin\perl.exe" Calcul_taille_dossier.pl
 
#!/usr/bin/perl
use threads;
use threads::shared;
use warnings;
use strict;
use IO::Socket;
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
 
my $serveur = IO::Socket::INET->new(    #Connection
	LocalHost => '10.146.232.106',
	LocalPort => '7070',
	Proto     => 'tcp',
	Listen    => 1,
	Reuse     => 1,
  )
 
  or die "Impossible serveur tcp sur le port 10000 : $@\n";
 
my @res1                 = {};    #tableau qui recupere les messages du client
my $i                    = 0;     #compteur
my $j : shared           = -1;    #compteur
my $boolStopTransmission = 0;     #bollean de fin de transmission
my $mess_rep             = "";
my $client               = "";
my $tempClient           = "";
my @listecli : shared;            #tableau qui recupere la liste des clients
 
while ( $client = $serveur->accept() ) {    #pour chaque nouvele connection
	    #$tempClient = $client;
	    #print "Avant Threads TempClient=$tempClient\n";
	    #print "Avant Threads Client=$client\n";
	    #print "Avant Threads J=$j\n";
	my $thr2 = threads->new( \&recupClient, "$client" );
 
	next if my $pid = fork;
	close($serveur);
	print "*** Connexion d'un nouvel utilisateur ***\n";
 
	$mess_rep = "Bienvenue sur le Chatt100 !\n";
	print $client $mess_rep;
 
	while ( my $rep = <$client> ) {    #Pour chaque message du client
 
		my $rep = decode_base64($rep);    #dechifrage du code
 
		$i = $i + 1;
		$res1[$i] = $rep;
 
		my ( $finalPers, $finalMess, $md5, $boolStopTransmission ) =
		  ( $res1[$i] =~ /(.+) XyX (.+) XyX (.+) XyX (.+)/ )
		  ;                               #parsing du message
		my $md5Verif = md5_hex($finalMess);
 
		#Verification (CRC) grace a un MD5
		if ( $md5Verif eq $md5 ) {        #Verification CRC OK
 
			if ( $boolStopTransmission eq "1" ) {
				print "*** $finalPers a interrompu la communication ***\n";
				exit;
			}
			else {
 
			   my $thr1 =
			     threads->new( \&subEnvoiMessage, "$finalPers", "$finalMess" );
 
			    #subEnvoiMessage("$finalPers", "$finalMess");
 
				my $mess_rep2 = "$finalPers: $finalMess\n";
				print $client $mess_rep2;
 
				#print $client "\n$finalPers a envoyé : $finalMess\n";
				print "\n$finalPers vous envoi : $finalMess\n";
 
			}
		}
		else {    #Verification CRC KO
			print
"Le message suivant a été altéré lors du transfert sur le reseau.";
 
			if ( $boolStopTransmission eq "1" ) {
				print "$finalPers a interrompu la communication\n";
			}
			else {
				print "\n$finalPers vous envoi : $finalMess\n";
 
			}
		}
 
	}
	continu {
		close($client);
	}
}
$SIG{CHLD} = 'IGNORE';    #pour eviter les problemes de differents OS
 
######################  Mes Sub ####################
 
sub recupClient {
 
	my ( $tempClient, $client3 ) = @_;
	$j = $j + 1;
	#print "Pendant Threads tempClient=$tempClient\n";
	#print "Pendant Threads J=$j\n";
	$listecli[$j] = $tempClient;
	#print "Dans le thread1\n";
 
	#for ( my $k = 1 ; $k < @listecli ; $k++ ) {
	#	print "k=$k";
	#print "0=$listecli[0]\n";
	#print "1=$listecli[1]\n";
	#print "2=$listecli[2]\n";
 
	#}
 
}
 
sub subEnvoiMessage {
	my ( $finalPers, $finalMess ) = @_;
	#print "Dans le thread2\n";
	my $tailletab = @listecli;
	for ( my $k = 0 ; $k < $tailletab ; $k++ ) {
		#print "k=$k\n";
		#print "taille=$tailletab\n";
		my $mess_rep2 = "$finalPers: $finalMess\n";
		my $client = $listecli[$k];
		#print "Pendant Threads client=$client\n";
		#print "Pendant Threads mess_rep2=$mess_rep2\n";
 
		print $client $mess_rep2;
 
	}
}

Chat2.pl:

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#Ce code en PERL est un client chatt.
#Pour utiliser ce code, ouvrez l invite de commande, placez vous dans le repertoire
#ou est le fichier et ecrivez la commande:
#"pearl Chat2.pl"
#exemple: "perl D:\Data\Chat2.pl"
#Commande detail: 
#D:\BENJAMIN>"d:\Appli portable\Eclipse_3.5.1\Data\ActivePerl-5.12.2.1202-MSWin32-x86-293621\perl\bin\perl.exe" Chat2.pl
 
#!/usr/bin/perl
 
 
use IO::Socket;
use Chat2;
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
 
 
 
 
my $sock = IO::Socket::INET->new(    #Connection
	PeerAddr => '10.146.232.106',
	PeerPort => '7070',
	Proto    => 'tcp',
) or die "Failed : $@\n";
 
print "*** Debut de connexion ***\n";
 
while ( my $reponse = <$sock> ) {
 
	print "Bonjour, $reponse";
	my $finalPers = personne();      #Renseigne nom et prenom de l'utilisateur
	my $stopvariable =
	  finCom(); #Renseigne le message qui indiquera au systeme la fin de la comm
	my $boolStopTransmission = 0;
 
	while ( $stopvariable ne my $finalMess )
	{           #Tant que le message fin de comm n'est pas saisi
		my ( $finalMess, $md5 ) = message();
 
		if ( $stopvariable eq $finalMess )
		{       #Dernier message envoyé+fin de comm
			$boolStopTransmission = 1;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
			print "Vous avez interrompu la communication\n";
			exit;
		}
		else {                                   #envoi du message
			$boolStopTransmission = 0;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
 
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
 
		}
		my $reponse2 = <$sock>;
			print "$reponse2";
	}
 
	close($sock);
	print $sock "Au revoir SERVEUR!!!\n";
}
print "*** Fin de connexion ***\n";
 
######################  Mes Sub ####################
 
sub personne {
	my $prenom;
	my $nom;
	print "\nVotre prenom : ";
	$prenom = <STDIN>;
	chop($prenom);
	print "Votre Nom : ";
	$nom = <STDIN>;
	chop($nom);
	my $this = Chat2->constPers( "$nom", "$prenom" );
	my $persTemp = "";
 
	foreach ( keys(%$this) ) {
 
		$persTemp = $persTemp . " $$this{$_}";
	}
	print "\n";
	return $persTemp;
}
 
sub message {
	my $finalMess = "";
 
	print "\nMessage : ";
	my $messageTemp = <STDIN>;
	chop($messageTemp);
 
	my ( $this, $md5 ) = Chat2->constMess("$messageTemp");
 
	#$this = substr($this, 1);
	$messageTemp = "";
	foreach ( keys(%$this) ) {
 
		$messageTemp = $messageTemp . " $$this{$_}";
	}
 
	return ( $messageTemp, $md5 );
}
 
sub finCom {
	print "Message de fin de communication: ";
	my $stopvariableTemp = <STDIN>;
	chop($stopvariableTemp);
	$stopvariableTemp = " " . $stopvariableTemp;
	return $stopvariableTemp;
}

Chat2.pm:

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
package Chat2;
use strict;
use Digest::MD5 qw(md5_hex);
 
sub constMess {
 
	my ( $classe, $message ) = @_;
	my $md5Temp = "";
 
	my $this = { "Message" => $message, };
 
	foreach ( keys(%$this) ) {
		my $md5Temp = $md5Temp = $md5Temp . " $$this{$_}";
	}
	$md5Temp = substr( $md5Temp, 1 );
 
	my $md5 = md5_hex("$md5Temp");
 
	bless( $this, $classe );
	return ( $this, $md5 );
}
 
sub constPers {
 
	my ( $classe, $nom, $prenom, ) = @_;
	my $this = {
		"nom"    => $nom,
		"prenom" => $prenom,
	};
 
	bless( $this, $classe );
	return $this;
}
 
1;

Chat3.pl:

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#Ce code en PERL est un client chatt.
#Pour utiliser ce code, ouvrez l invite de commande, placez vous dans le repertoire
#ou est le fichier et ecrivez la commande:
#"pearl Chat3.pl"
#exemple: "perl D:\Data\Chat3.pl"
#Commande detail: 
#D:\BENJAMIN>"d:\Appli portable\Eclipse_3.5.1\Data\ActivePerl-5.12.2.1202-MSWin32-x86-293621\perl\bin\perl.exe" Chat3.pl
 
#!/usr/bin/perl
use IO::Socket;
use Chat3;
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
 
my $sock = IO::Socket::INET->new(    #Connection
	PeerAddr => '10.146.232.106',
	PeerPort => '7070',
	Proto    => 'tcp',
) or die "Failed : $@\n";
 
print "*** Debut de connexion ***\n";
 
while ( my $reponse = <$sock> ) {
 
	print "Bonjour, $reponse";
	my $finalPers = personne();      #Renseigne nom et prenom de l'utilisateur
	my $stopvariable =
	  finCom(); #Renseigne le message qui indiquera au systeme la fin de la comm
	my $boolStopTransmission = 0;
 
	while ( $stopvariable ne my $finalMess )
	{           #Tant que le message fin de comm n'est pas saisi
		my ( $finalMess, $md5 ) = message();
 
		if ( $stopvariable eq $finalMess )
		{       #Dernier message envoyé+fin de comm
			$boolStopTransmission = 1;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
			print "Vous avez interrompu la communication\n";
			exit;
		}
		else {                                   #envoi du message
			$boolStopTransmission = 0;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
 
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
 
		}
		my $reponse2 = <$sock>;
			print "$reponse2";
	}
 
	close($sock);
	print $sock "Au revoir SERVEUR!!!\n";
}
print "*** Fin de connexion ***\n";
 
######################  Mes Sub ####################
 
sub personne {
	my $prenom;
	my $nom;
	print "\nVotre prenom : ";
	$prenom = <STDIN>;
	chop($prenom);
	print "Votre Nom : ";
	$nom = <STDIN>;
	chop($nom);
	my $this = Chat3->constPers( "$nom", "$prenom" );
	my $persTemp = "";
 
	foreach ( keys(%$this) ) {
 
		$persTemp = $persTemp . " $$this{$_}";
	}
	print "\n";
	return $persTemp;
}
 
sub message {
	my $finalMess = "";
 
	print "\nMessage : ";
	my $messageTemp = <STDIN>;
	chop($messageTemp);
 
	my ( $this, $md5 ) = Chat3->constMess("$messageTemp");
 
	#$this = substr($this, 1);
	$messageTemp = "";
	foreach ( keys(%$this) ) {
 
		$messageTemp = $messageTemp . " $$this{$_}";
	}
 
	return ( $messageTemp, $md5 );
}
 
sub finCom {
	print "Message de fin de communication: ";
	my $stopvariableTemp = <STDIN>;
	chop($stopvariableTemp);
	$stopvariableTemp = " " . $stopvariableTemp;
	return $stopvariableTemp;
}

Chat3.pm:

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
package Chat3;
use strict;
use Digest::MD5 qw(md5_hex);
 
sub constMess {
 
	my ( $classe, $message ) = @_;
	my $md5Temp = "";
 
	my $this = { "Message" => $message, };
 
	foreach ( keys(%$this) ) {
		my $md5Temp = $md5Temp = $md5Temp . " $$this{$_}";
	}
	$md5Temp = substr( $md5Temp, 1 );
 
	my $md5 = md5_hex("$md5Temp");
 
	bless( $this, $classe );
	return ( $this, $md5 );
}
 
sub constPers {
 
	my ( $classe, $nom, $prenom, ) = @_;
	my $this = {
		"nom"    => $nom,
		"prenom" => $prenom,
	};
 
	bless( $this, $classe );
	return $this;
}
 
1;

Je suis conscient que tu prends de ton temps pour m'aide, et je t'en remercie grandement.

Cordialement,
Benjamin

**Super_carotte** · 21/12/2010, 16h05

Je pense que le problème pourrait venir de ma deuxième thread dans chat1.pl

En effet, le message d'erreur suivant:
Thread 2 terminated abnormally: Can't use string ("IO::Socket::INET=GLOB(0x1a2f2
f4)") as a symbol ref while "strict refs" in use at chat1.pl line 138, <GEN1> li
ne 1.

Me fait penser que le système récupère bien un string "IO::Socket::INET=GLOB(0x1a2f2f4)" mais ne le considère plus comme étant un socket.

Pensez vous que ça puisse être le problème?

**Philou67430** · 21/12/2010, 16h48

Je ne sais pas si le problème vient de là, mais je pense que tu ne devrais avoir qu'une seule paire de script pour les clients, que tu lances plusieurs fois sur ta machine.
Je ne pense pas avoir de temps aujourd'hui pour me pencher sur ton code, mais j'essayerai de le lire tout de même.

**Philou67430** · 21/12/2010, 17h09

Une chose me choque dans chat1.pl : tu mélanges l'usage des threads et de fork... Pour moi, c'est l'un ou l'autre.

Ensuite, comme je crois l'avoir dit dans une autre discussion, il est possible d'utiliser la fonction select pour savoir si un File::Handle contient quelque chose à lire. Il doit alors être possible de l'utiliser pour identifier si un nouveau client vient se connecter, ou si un client déjà connecté a émis un message. Ainsi, le serveur peut être mono tâche (ce qui me semblerait logique puisqu'il doit partager dynamiquement des données avec tous ses clients connectés). Voir les exemples ici : http://search.cpan.org/~gbarr/IO-1.25/lib/IO/Select.pm

**djibril** · 22/12/2010, 08h47

Je n'ai pas beaucoup d'expérience dans le développement de programmes asynchrone nécessitant un dialogue client serveur, mais pour ton cas, l'idéal serait peut être de combiner POE et IRC non ?

**Super_carotte** · 22/12/2010, 09h22

Merci beaucoup pour vos réponses.
Donc dans un premier temps, je vais essayer de refaire complètement mon code de mon coté serveur en utilisant IO::Select;.

Pour ce qui est du POE::Component::IRC je ne comprend pas bien ce qu'il fait, alors je vais d'abord voire si dans l'état actuel, mon client chat2.pl peux fonctionner avec mon nouveau serveur (avec IO::select).

Je pars mettre les mains dans le cambouis!

Merci,
Cordialement,
Benjamin

**Super_carotte** · 22/12/2010, 10h39

J'ai essayé la solution en sortant les fork et en utilisant IO::selct mais je perd la capacité de mon code a pouvoir gérer plusieurs clients en même temps.
Êtes vous sur que le select permet de faire ça?

Peut être ais-je mal utilisé le select?

Voici mon nouveau code:
Chat1.pl:

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
use IO::Select;
use IO::Socket;
 
#use warnings;
use strict;
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
 
my $new;
my @ready;
my $lsn;
my $sel;
my $fh;
my $mess_rep;
my $rep;
my $i;
my @res1;
my $mess_rep2;
my $md5Verif;
 
$lsn = new IO::Socket::INET(    #Connection
	LocalHost => '10.146.232.106',
	LocalPort => '7070',
	Proto     => 'tcp',
	Listen    => 1,
	Reuse     => 1,
);
$sel = new IO::Select($lsn);
 
while ( @ready = $sel->can_read ) {
	print "111111111111111 \n";
	foreach $fh (@ready) {
		print "22222222222 \n";
		if ( $fh == $lsn ) {
 
			# Create a new socket
			print "3333333333 \n";
			$new = $lsn->accept;
			$sel->add($new);
		}
		else {
			print "44444444444 \n";
 
			# Process socket
			#ProcessMain();
 
			print "*** Connexion d'un nouvel utilisateur ***\n";
 
			$mess_rep = "Bienvenue sur le Chatt100 !\n";
			print $new $mess_rep;
 
while ( my $rep = <$fh> ) {
			 #$rep = <$fh>;
			$rep = decode_base64($rep);    #dechifrage du code
 
			$i = $i + 1;
			$res1[$i] = $rep;
 
			my ( $finalPers, $finalMess, $md5, $boolStopTransmission ) =
			  ( $res1[$i] =~ /(.+) XyX (.+) XyX (.+) XyX (.+)/ )
			  ;                            #parsing du message
			$md5Verif = md5_hex($finalMess);
 
 
print "md5=$md5";
print "md5Verif=$md5Verif";
			#Verification (CRC) grace a un MD5
			if ( $md5Verif eq $md5 ) {     #Verification CRC OK
 
				if ( $boolStopTransmission eq "1" ) {
					print "*** $finalPers a interrompu la communication ***\n";
					exit;
				}
				else {
 
					#subEnvoiMessage("$finalPers", "$finalMess");
 
					$mess_rep2 = "$finalPers: $finalMess\n";
					print $fh $mess_rep2;
 
					#print $client "\n$finalPers a envoyé : $finalMess\n";
					print "\n$finalPers vous envoi : $finalMess\n";
 
				}
			}
			else {    #Verification CRC KO
				print
"Le message suivant a été altéré lors du transfert sur le reseau.";
 
				if ( $boolStopTransmission eq "1" ) {
					print "$finalPers a interrompu la communication\n";
				}
				else {
					print "\n$finalPers vous envoi : $finalMess\n";
 
				}
			}
}
 
			# Maybe we have finished with the socket
			print "555555555 \n";
			$sel->remove($fh);
			$fh->close;
		}
	}
}

Chat2.pl:

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#Ce code en PERL est un client chatt.
#Pour utiliser ce code, ouvrez l invite de commande, placez vous dans le repertoire
#ou est le fichier et ecrivez la commande:
#"pearl Chat2.pl"
#exemple: "perl D:\Data\Chat2.pl"
#Commande detail: 
#D:\BENJAMIN>"d:\Appli portable\Eclipse_3.5.1\Data\ActivePerl-5.12.2.1202-MSWin32-x86-293621\perl\bin\perl.exe" Chat2.pl
 
#!/usr/bin/perl
 
 
use IO::Socket;
use Chat2;
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
 
 
 
 
my $sock = IO::Socket::INET->new(    #Connection
	PeerAddr => '10.146.232.106',
	PeerPort => '7070',
	Proto    => 'tcp',
) or die "Failed : $@\n";
 
print "*** Debut de connexion ***\n";
$sock->send("IGIgcCBYeVggaW5pdGlhbGlzYXRpb24gWHlYIDNlNTIxMzFlNmIyNzJiZTUxMjQyZWUwMDMxMGI3MjUyIFh5WCAw");
printf $sock "\n";
while ( my $reponse = <$sock> ) {
 
	print "Bonjour, $reponse";
	my $finalPers = personne();      #Renseigne nom et prenom de l'utilisateur
	my $stopvariable =
	  finCom(); #Renseigne le message qui indiquera au systeme la fin de la comm
	my $boolStopTransmission = 0;
 
	while ( $stopvariable ne my $finalMess )
	{           #Tant que le message fin de comm n'est pas saisi
		my ( $finalMess, $md5 ) = message();
 
		if ( $stopvariable eq $finalMess )
		{       #Dernier message envoyé+fin de comm
			$boolStopTransmission = 1;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
			print "Vous avez interrompu la communication\n";
			exit;
		}
		else {                                   #envoi du message
			$boolStopTransmission = 0;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
 
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
 
		}
		my $reponse2 = <$sock>;
			print "$reponse2";
	}
 
	close($sock);
	print $sock "Au revoir SERVEUR!!!\n";
}
print "*** Fin de connexion ***\n";
 
######################  Mes Sub ####################
 
sub personne {
	my $prenom;
	my $nom;
	print "\nVotre prenom : ";
	$prenom = <STDIN>;
	chop($prenom);
	print "Votre Nom : ";
	$nom = <STDIN>;
	chop($nom);
	my $this = Chat2->constPers( "$nom", "$prenom" );
	my $persTemp = "";
 
	foreach ( keys(%$this) ) {
 
		$persTemp = $persTemp . " $$this{$_}";
	}
	print "\n";
	return $persTemp;
}
 
sub message {
	my $finalMess = "";
 
	print "\nMessage : ";
	my $messageTemp = <STDIN>;
	chop($messageTemp);
 
	my ( $this, $md5 ) = Chat2->constMess("$messageTemp");
 
	#$this = substr($this, 1);
	$messageTemp = "";
	foreach ( keys(%$this) ) {
 
		$messageTemp = $messageTemp . " $$this{$_}";
	}
 
	return ( $messageTemp, $md5 );
}
 
sub finCom {
	print "Message de fin de communication: ";
	my $stopvariableTemp = <STDIN>;
	chop($stopvariableTemp);
	$stopvariableTemp = " " . $stopvariableTemp;
	return $stopvariableTemp;
}

Chat2.pm:

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
package Chat2;
use strict;
use Digest::MD5 qw(md5_hex);
 
sub constMess {
 
	my ( $classe, $message ) = @_;
	my $md5Temp = "";
 
	my $this = { "Message" => $message, };
 
	foreach ( keys(%$this) ) {
		my $md5Temp = $md5Temp = $md5Temp . " $$this{$_}";
	}
	$md5Temp = substr( $md5Temp, 1 );
 
	my $md5 = md5_hex("$md5Temp");
 
	bless( $this, $classe );
	return ( $this, $md5 );
}
 
sub constPers {
 
	my ( $classe, $nom, $prenom, ) = @_;
	my $this = {
		"nom"    => $nom,
		"prenom" => $prenom,
	};
 
	bless( $this, $classe );
	return $this;
}
 
1;

Merci,
Cordialement,
Benjamin

**Philou67430** · 22/12/2010, 12h56

Voici un exemple très simplifié d'un serveur et d'un client qui semble fonctionner (test avec 2 clients et 1 serveur tournant tous sur "localhost", la machine locale).
Tu peux les adapter pour gérer ton tchat :

server.pl:

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
#!/usr/bin/perl
 
use warnings;
use strict;
use IO::Socket qw(:crlf inet_ntoa);
use IO::Select;
 
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
use feature qw(switch);
 
my $serveur = IO::Socket::INET->new(    #Connection
                                    LocalHost => 'localhost',
                                    LocalPort => '7070',
                                    Proto     => 'tcp',
                                    Listen    => 1,
                                    Reuse     => 1,
                                   )
  or die "Impossible serveur tcp sur le port 7070 : $@\n";
 
my $sockets = IO::Select->new($serveur);
my @clients;
my $client_nb = 0;
while ( ) {
  foreach my $socket ($sockets->can_read()) {
    if ($socket eq $serveur) {
      if (my ($client, $peer_ip) = $serveur->accept()) {
        $client = { socket => $client, name => $client_nb++ };
        print { $_->{socket} } "$client->{name} is coming$CRLF" foreach @clients;
        push @clients, $client;
        $sockets->add($client->{socket});
        print "New client connected from IP: ", (join "/", map inet_ntoa($_), $peer_ip =~ /(....)/g), " (", ref($client), ")\n";
      }
      else {
        die "Could not create a socket for a new client\n";
      }
    }
    else {
      my ($client) = grep $_->{socket} eq $socket, @clients;
      if (eof($socket)) {
        print "Client $client->{name} has left\n";
        $sockets->remove($socket);
        @clients = grep $_ ne $socket, @clients;
        print { $_->{socket} } "$client->{name} has left$CRLF" foreach @clients
      }
      else {
        if (chomp(my $text = <$socket>)) {
          print "Client $client->{name} has written $text\n";
          print { $_->{socket} } "$client->{name} said: $text$CRLF" foreach @clients;
        }
        else {
          warn "Client $client->{name} has nothing to say\n";
        }
      }
    }
  }
}

client.pl:

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
#!/usr/bin/perl
 
use IO::Socket qw(:crlf);
use IO::Select;
 
my $sock = IO::Socket::INET->new(    #Connection
                                 PeerAddr => 'localhost',
               Am                  PeerPort => '7070',
                                 Proto    => 'tcp',
                                ) or die "Failed : $@\n";
 
print "*** Debut de connexion ***\n";
 
my $sockets = IO::Select->new(STDIN, $sock);
forever:
while () {
  foreach my $io ($sockets->can_read()) {
    if ($io eq STDIN) {
      chomp(my $msg = <STDIN>);
      last forever if $msg =~ /^exit/;
      print { $sock } $msg, $CRLF;
    }
    else {
      chomp(my $msg = <$io>);
      print "$msg\n";
    }
  }
}
 
close($sock);
print $sock "Au revoir SERVEUR!!!\n";
print "*** Fin de connexion ***\n";

On peut sortir du chat client en tapant "exit"

**Super_carotte** · 22/12/2010, 14h03

Merci pour cette proposition, elle m'a permis de découvrir de nouvelles fonctionnalités tel que "eof".
Toutefois, il me semble qu'elle ne fonctionne pas.

Mais elle m'a mis sur une piste:
J'ai recréer un serveur très simplifié que voici:

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
	use IO::Select;
	use IO::Socket;
	use Digest::MD5 qw(md5_hex);
	use MIME::Base64;
 
my $boolStopTransmission = 0;
 
 
	$lsn = new IO::Socket::INET( Listen => 1, LocalPort => 7070 );
	$sel = new IO::Select($lsn);
 
	while ( @ready = $sel->can_read ) {
		foreach $fh (@ready) {
			if ( $fh == $lsn ) {
 
				# Create a new socket
				$new = $lsn->accept;
				$sel->add($new);
				print "*** Connexion d'un nouvel utilisateur ***\n";
			}
			else {
 
				# Process socket
				#while ( $boolStopTransmission == 0 ) {
					my $rep = <$fh>;
					print $rep;						
				#}
 
				# Maybe we have finished with the socket
				$sel->remove($fh);
				$fh->close;
 
			}
		}
	}

Et il fonctionne très bien (les clients peuvent travailler en même temps) mis a part que vu qu'il n'y a pas de boucle, seul le premier message de mes clients est reçus par le serveur.

Le problème étant identifié, je décide donc d'appliquer une boucle.
Voici le nouveau code: (j'ai juste décommenté ma boucle)

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
	use IO::Select;
	use IO::Socket;
	use Digest::MD5 qw(md5_hex);
	use MIME::Base64;
 
my $boolStopTransmission = 0;
 
 
	$lsn = new IO::Socket::INET( Listen => 1, LocalPort => 7070 );
	$sel = new IO::Select($lsn);
 
	while ( @ready = $sel->can_read ) {
		foreach $fh (@ready) {
			if ( $fh == $lsn ) {
 
				# Create a new socket
				$new = $lsn->accept;
				$sel->add($new);
				print "*** Connexion d'un nouvel utilisateur ***\n";
			}
			else {
 
				# Process socket
				while ( $boolStopTransmission == 0 ) {
					my $rep = <$fh>;
					print $rep;						
				}
 
				# Maybe we have finished with the socket
				$sel->remove($fh);
				$fh->close;
 
			}
		}
	}

Et la, mon client arrive bien a transmettre autant de message qu'il veux mais par contre, mon deuxième client ne peux plus rien faire.
En effet, coté serveur, le système travail dans la boucle et du coup, il n'écoute plus les autres clients.

Voila donc ma question, comment faire une boucle qui soit non bloquante?

Merci,
Cordialement,
Benjamin

**Philou67430** · 22/12/2010, 14h12

Je ne pense pas que ton serveur soit bloqué dans la boucle. Pour aller plus loin, tu dois passer en mode débugger sur ton serveur, et lancer tes clients.

Je mets à jour le serveur avec quelques fonctions en + (notification sur le tchat des nouveaux arrivés, et des départs).

La fonction eof appliqué sur le socket client dans le serveur fonctionne très bien chez moi.

Je vais essayer de débugger ton serveur.

**Philou67430** · 22/12/2010, 14h17

Je crois que tu t'es trompé en donnant le code du client, qui est en fait celui du serveur (en double, du coup).

**Super_carotte** · 22/12/2010, 14h24

Oui, dans mon dernier post, j'ai mis 2 fois le code du serveur mais dans le second, j'ai mis une boucle pour montrer le problème auquel je faisais référence.

Si vous voulez le code de mon client, le voici:
(mais il subit de très nombreuses modif car j'essaie a chaque fois de l'adapter a mon serveur )
Mais voici son état actuel:
Chat2.pl:

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#Ce code en PERL est un client chatt.
#Pour utiliser ce code, ouvrez l invite de commande, placez vous dans le repertoire
#ou est le fichier et ecrivez la commande:
#"pearl Chat2.pl"
#exemple: "perl D:\Data\Chat2.pl"
#Commande detail: 
#D:\BENJAMIN>"d:\Appli portable\Eclipse_3.5.1\Data\ActivePerl-5.12.2.1202-MSWin32-x86-293621\perl\bin\perl.exe" Chat2.pl
 
#!/usr/bin/perl
 
 
use IO::Socket;
use Chat2;
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
 
 
 
 
my $sock = IO::Socket::INET->new(    #Connection
	PeerAddr => '10.146.232.106',
	PeerPort => '7070',
	Proto    => 'tcp',
) or die "Failed : $@\n";
 
print "*** Debut de connexion ***\n";
#$sock->send("IGIgcCBYeVggaW5pdGlhbGlzYXRpb24gWHlYIDNlNTIxMzFlNmIyNzJiZTUxMjQyZWUwMDMxMGI3MjUyIFh5WCAw");
#printf $sock "\n";
#while ( my $reponse = <$sock> ) {
 
	#print "Bonjour, $reponse";
	my $finalPers = personne();      #Renseigne nom et prenom de l'utilisateur
	my $stopvariable =
	  finCom(); #Renseigne le message qui indiquera au systeme la fin de la comm
	my $boolStopTransmission = 0;
 
	while ( $stopvariable ne my $finalMess )
 
	{           #Tant que le message fin de comm n'est pas saisi
		my ( $finalMess, $md5 ) = message();
 
		if ( $stopvariable eq $finalMess )
		{       #Dernier message envoyé+fin de comm
			$boolStopTransmission = 1;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
			print "Vous avez interrompu la communication\n";
			exit;
		}
		else {                                   #envoi du message
			$boolStopTransmission = 0;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
 
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
 
		}
		#my $reponse2 = <$sock>;
		#	print "$reponse2";
	}
 
	close($sock);
	#print $sock "Au revoir SERVEUR!!!\n";
#}
print "*** Fin de connexion ***\n";
 
######################  Mes Sub ####################
 
sub personne {
	my $prenom;
	my $nom;
	print "\nVotre prenom : ";
	$prenom = <STDIN>;
	chop($prenom);
	print "Votre Nom : ";
	$nom = <STDIN>;
	chop($nom);
	my $this = Chat2->constPers( "$nom", "$prenom" );
	my $persTemp = "";
 
	foreach ( keys(%$this) ) {
 
		$persTemp = $persTemp . " $$this{$_}";
	}
	print "\n";
	return $persTemp;
}
 
sub message {
	my $finalMess = "";
 
	print "\nMessage : ";
	my $messageTemp = <STDIN>;
	chop($messageTemp);
 
	my ( $this, $md5 ) = Chat2->constMess("$messageTemp");
 
	#$this = substr($this, 1);
	$messageTemp = "";
	foreach ( keys(%$this) ) {
 
		$messageTemp = $messageTemp . " $$this{$_}";
	}
 
	return ( $messageTemp, $md5 );
}
 
sub finCom {
	print "Message de fin de communication: ";
	my $stopvariableTemp = <STDIN>;
	chop($stopvariableTemp);
	$stopvariableTemp = " " . $stopvariableTemp;
	return $stopvariableTemp;
}

Chat2.pm:

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
package Chat2;
use strict;
use Digest::MD5 qw(md5_hex);
 
sub constMess {
 
	my ( $classe, $message ) = @_;
	my $md5Temp = "";
 
	my $this = { "Message" => $message, };
 
	foreach ( keys(%$this) ) {
		my $md5Temp = $md5Temp = $md5Temp . " $$this{$_}";
	}
	$md5Temp = substr( $md5Temp, 1 );
 
	my $md5 = md5_hex("$md5Temp");
 
	bless( $this, $classe );
	return ( $this, $md5 );
}
 
sub constPers {
 
	my ( $classe, $nom, $prenom, ) = @_;
	my $this = {
		"nom"    => $nom,
		"prenom" => $prenom,
	};
 
	bless( $this, $classe );
	return $this;
}
 
1;

**Philou67430** · 22/12/2010, 15h25

Le pb de ton serveur, c'est que tu fermes le socket d'un client (et le supprime de IO::Select) dès la réception d'un message.
Il faut laisser le socket ouvert, et au contraire, écrire le message reçu de ce socket sur tous les sockets clients (y compris le socket client émetteur).

Il faut donc au minimum supprimer les lignes

Code :

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

1
2
3
      # Maybe we have finished with the socket
      $sel->remove($fh);
      $fh->close;

et ajouter quelque chose qui ressemble à ce que j'avais écrit (attention, tu ne gères pas de liste de clients, ce qui ne conviendra pas pour ton serveur de tchat ; il faut adapter son serveur) :

Code :

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

          print { $_->{socket} } "$client->{name} said: $text$CRLF" foreach @clients;

**Super_carotte** · 22/12/2010, 16h38

Haha, en effet, ça marche maintenant si ce n'est que j'en reviens a ma première question: gérer l'envoi a tout les utilisateurs.
Je vais repartir étudier la question.

Mais mon code a bien changé, et ça m'a fait voire de nouvelles choses.
Merci beaucoup pour votre aide.

Cordialement,
Benjamin

Pour ceux qui seraient intéréssés, voici le code actuel:

Serveur.pl:

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
	use IO::Select;
	use IO::Socket;
	use Digest::MD5 qw(md5_hex);
	use MIME::Base64;
 
	my $boolStopTransmission = 0;
	my @tabCli;
	my $k=-1;
 
	$lsn = new IO::Socket::INET( Listen => 1, LocalPort => 7070 );
	$sel = new IO::Select($lsn);
 
	while ( @ready = $sel->can_read ) {
 
		foreach $fh (@ready) {
			if ( $fh == $lsn ) {
 
				# Create a new socket
				#$k=$k+1;
				#$tabCli[$k]=$sel->can_read;
				$new = $lsn->accept;
				$sel->add($new);
				print "*** Connexion d'un nouvel utilisateur ***\n";
			}
			else {
				print "4444444";
 
				# Process socket
 
				my $rep = <$fh>;
				print "5555555\n";
 
				#print "rep=$rep\n";
				$rep = decode_base64($rep);    #dechifrage du code
 
				$i = $i + 1;
				$res1[$i] = $rep;
 
				my ( $finalPers, $finalMess, $md5, $boolStopTransmission ) =
				  ( $res1[$i] =~ /(.+) XyX (.+) XyX (.+) XyX (.+)/ )
				  ;                            #parsing du message
				my $md5Verif = md5_hex($finalMess);
 
				#Verification (CRC) grace a un MD5
				if ( $md5Verif eq $md5 ) {     #Verification CRC OK
 
					if ( $boolStopTransmission eq "1" ) {
						print
						  "*** $finalPers a interrompu la communication ***\n";
						exit;
					}
					else {
 
						#subEnvoiMessage("$finalPers", "$finalMess");
 
						foreach $fh (@ready) {
							my $mess_rep2 =
							  "$finalPers a envoyé : $finalMess\n";
							  print "fh=$fh\n";
							print $fh $mess_rep2;
						}
 
						#print $client "\n$finalPers a envoyé : $finalMess\n";
						print "\n$finalPers vous envoi : $finalMess\n";
 
					}
				}
				else {    #Verification CRC KO
					print
"Le message suivant a été altéré lors du transfert sur le reseau.";
 
					if ( $boolStopTransmission eq "1" ) {
						print "$finalPers a interrompu la communication\n";
					}
					else {
						print "\n$finalPers vous envoi : $finalMess\n";
 
					}
				}
 
				#foreach $fh (@ready) {
				#	print "66666\n";
				#	#print { $_->{socket} } "TESSSSSSSSSSSSSSSSSTTTT";
				#	my $mess_rep2 = "$finalPers a envoyé : $finalMess\n";
				#	print $fh $mess_rep2;
				#}
 
				# Maybe we have finished with the socket
				#$sel->remove($fh);
				#$fh->close;
 
			}
		}
	}

chat2.pl (le 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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#Ce code en PERL est un client chatt.
#Pour utiliser ce code, ouvrez l invite de commande, placez vous dans le repertoire
#ou est le fichier et ecrivez la commande:
#"pearl Chat2.pl"
#exemple: "perl D:\Data\Chat2.pl"
#Commande detail: 
#D:\BENJAMIN>"d:\Appli portable\Eclipse_3.5.1\Data\ActivePerl-5.12.2.1202-MSWin32-x86-293621\perl\bin\perl.exe" Chat2.pl
 
#!/usr/bin/perl
 
 
use IO::Socket;
use Chat2;
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
 
 
 
 
my $sock = IO::Socket::INET->new(    #Connection
	PeerAddr => '10.146.232.106',
	PeerPort => '7070',
	Proto    => 'tcp',
) or die "Failed : $@\n";
 
print "*** Debut de connexion ***\n";
#$sock->send("IGIgcCBYeVggaW5pdGlhbGlzYXRpb24gWHlYIDNlNTIxMzFlNmIyNzJiZTUxMjQyZWUwMDMxMGI3MjUyIFh5WCAw");
#printf $sock "\n";
#while ( my $reponse = <$sock> ) {
 
	#print "Bonjour, $reponse";
	my $finalPers = personne();      #Renseigne nom et prenom de l'utilisateur
	my $stopvariable =
	  finCom(); #Renseigne le message qui indiquera au systeme la fin de la comm
	my $boolStopTransmission = 0;
 
	while ( $stopvariable ne my $finalMess )
 
 
	{           #Tant que le message fin de comm n'est pas saisi
 
		my ( $finalMess, $md5 ) = message();
 
		if ( $stopvariable eq $finalMess )
		{       #Dernier message envoyé+fin de comm
			$boolStopTransmission = 1;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
			print "Vous avez interrompu la communication\n";
			exit;
		}
		else {                                   #envoi du message
			$boolStopTransmission = 0;
			my $res =
			  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
 
 
			$res = encode_base64( $res, "" );    #chiffrement
			$sock->send("$res");
			printf $sock "\n";
			my $reponse = <$sock>;
			print "réponse=$reponse\n";
 
		}
		#my $reponse2 = <$sock>;
		#	print "$reponse2";
	}
 
	close($sock);
	#print $sock "Au revoir SERVEUR!!!\n";
#}
print "*** Fin de connexion ***\n";
 
######################  Mes Sub ####################
 
sub personne {
	my $prenom;
	my $nom;
	print "\nVotre prenom : ";
	$prenom = <STDIN>;
	chop($prenom);
	print "Votre Nom : ";
	$nom = <STDIN>;
	chop($nom);
	my $this = Chat2->constPers( "$nom", "$prenom" );
	my $persTemp = "";
 
	foreach ( keys(%$this) ) {
 
		$persTemp = $persTemp . " $$this{$_}";
	}
	print "\n";
	return $persTemp;
}
 
sub message {
	my $finalMess = "";
 
	print "\nMessage : ";
	my $messageTemp = <STDIN>;
	chop($messageTemp);
 
	my ( $this, $md5 ) = Chat2->constMess("$messageTemp");
 
	#$this = substr($this, 1);
	$messageTemp = "";
	foreach ( keys(%$this) ) {
 
		$messageTemp = $messageTemp . " $$this{$_}";
	}
 
	return ( $messageTemp, $md5 );
}
 
sub finCom {
	print "Message de fin de communication: ";
	my $stopvariableTemp = <STDIN>;
	chop($stopvariableTemp);
	$stopvariableTemp = " " . $stopvariableTemp;
	return $stopvariableTemp;
}

Chat2.pm:

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
package Chat2;
use strict;
use Digest::MD5 qw(md5_hex);
 
sub constMess {
 
	my ( $classe, $message ) = @_;
	my $md5Temp = "";
 
	my $this = { "Message" => $message, };
 
	foreach ( keys(%$this) ) {
		my $md5Temp = $md5Temp = $md5Temp . " $$this{$_}";
	}
	$md5Temp = substr( $md5Temp, 1 );
 
	my $md5 = md5_hex("$md5Temp");
 
	bless( $this, $classe );
	return ( $this, $md5 );
}
 
sub constPers {
 
	my ( $classe, $nom, $prenom, ) = @_;
	my $this = {
		"nom"    => $nom,
		"prenom" => $prenom,
	};
 
	bless( $this, $classe );
	return $this;
}
 
1;

**Philou67430** · 22/12/2010, 17h47

Envoyé par Super_carotte

maintenant si ce n'est que j'en reviens a ma première question: gérer l'envoi a tout les utilisateurs.
Je vais repartir étudier la question.

Pour ça aussi je t'ai donné une explication dans mon exemple ET dans mon message précédent

**Super_carotte** · 27/12/2010, 11h47

Merci Philou67430!
Et bonjour a tous et surtout...

!!!BONNE FÊTE!!!

Je viens vous voire car j'ai bien avancé sur ce petit code.
En effet, j'arrive a envoyer le message qu'un client envoi a tout les autres clients.
Ma seule (et j'espère dernière) difficultés est de faire en sorte que mes clients soient en écoute.

En effet, actuellement, je pense que tous reçoivent le message mais que seul l'émetteur le ré-affiche car il est le seul en écoute.

Les autres clients sont bloqués par leur prompt qui leur permet d'écrire leur message.

Avez vous une idée?

VOici le code actuel:

Servuer: (Test2.pl):

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
	use IO::Select;
	use IO::Socket;
	use Digest::MD5 qw(md5_hex);
	use MIME::Base64;
 
	my $boolStopTransmission = 0;
	my @tabCli;					#repertorie l'ensemble des socket de mes clients
	my $k = -1;
	my @ready;
	my $flag1 = 0;				#ce flag me ser lors d'un test qui verifie 
								#si un client n'est pas deja present dans @tabCli
 
	$lsn = new IO::Socket::INET( Listen => 1, LocalPort => 7070 );
	$sel = new IO::Select($lsn);
 
	$tabCli[0] =
	  "JemetUneValeurCarJaiUnForeachQuiNecessiteQueMonTableauNeSoitPasVide";
 
	while ( @ready = $sel->can_read ) {
 
		foreach $fh (@ready) {
 
			if ( $fh == $lsn ) {
				$new = $lsn->accept;
				$sel->add($new);
				print "*** Connexion d'un nouvel utilisateur ***\n";
			}
			else {    # Process socket
 
				foreach (@tabCli) {	#pour chaque client répertorié dans le tableau
 
					if ( $_ == $fh ) { #s'il est deja present, alors le flag passe a 1
						$flag1 = 1;
					}
				}
				if ( $flag1 == 0 ) { #si le flag est egale a 0 alors le client n'existe pas dans le tableau donc je le rajoute
					$k = $k + 1;
					$tabCli[$k] = $fh;
				}
 
				$flag1 = 0;
 
				my $rep = <$fh>;
 
				$rep = decode_base64($rep);    #dechifrage du code
 
				$i = $i + 1;
				$res1[$i] = $rep;
 
				my ( $finalPers, $finalMess, $md5, $boolStopTransmission ) =
				  ( $res1[$i] =~ /(.+) XyX (.+) XyX (.+) XyX (.+)/ )
				  ;                            #parsing du message
				my $md5Verif = md5_hex($finalMess);
 
				#Verification (CRC) grace a un MD5
				if ( $md5Verif eq $md5 ) {     #Verification CRC OK
 
					if ( $boolStopTransmission eq "1" ) {
						print
						  "*** $finalPers a interrompu la communication ***\n";
						exit;
					}
					else {
 
						foreach my $it (@tabCli) {	#pour chaque client de @tabCli, j'envoi le message
							my $mess_rep2 =
							  "$finalPers a envoyé : $finalMess\n";
							print "tabCli0=$tabCli[0]\n";
							print "tabCli1=$tabCli[1]\n";
							print "tabCli2=$tabCli[2]\n";
							print "tabCli3=$tabCli[3]\n";
							print $it $mess_rep2;
						}
						print "\n$finalPers vous envoi : $finalMess\n";
					}
				}
				else {    #Verification CRC KO
					print
"Le message suivant a été altéré lors du transfert sur le reseau.";
 
					if ( $boolStopTransmission eq "1" ) {
						print "$finalPers a interrompu la communication\n";
					}
					else {
						print "\n$finalPers vous envoi : $finalMess\n";
 
					}
				}
 
			}
		}
	}

Client: (Chat2.pl):

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#Ce code en PERL est un client chatt.
#Pour utiliser ce code, ouvrez l invite de commande, placez vous dans le repertoire
#ou est le fichier et ecrivez la commande:
#"pearl Chat2.pl"
#exemple: "perl D:\Data\Chat2.pl"
#Commande detail:
#D:\BENJAMIN>"d:\Appli portable\Eclipse_3.5.1\Data\ActivePerl-5.12.2.1202-MSWin32-x86-293621\perl\bin\perl.exe" Chat2.pl
 
#!/usr/bin/perl
use threads;
use threads::shared;
#use warnings;
use strict;
use IO::Socket;
use Chat2;
use Digest::MD5 qw(md5_hex);
use MIME::Base64;
 
my $sock = IO::Socket::INET->new(    #Connection
	PeerAddr => '10.146.232.106',
	PeerPort => '7070',
	Proto    => 'tcp',
) or die "Failed : $@\n";
 
print "*** Debut de connexion ***\n";
 
#$sock->send("IGIgcCBYeVggaW5pdGlhbGlzYXRpb24gWHlYIDNlNTIxMzFlNmIyNzJiZTUxMjQyZWUwMDMxMGI3MjUyIFh5WCAw");
#printf $sock "\n";
#while ( my $reponse = <$sock> ) {
 
#print "Bonjour, $reponse";
my $finalPers = personne();    #Renseigne nom et prenom de l'utilisateur
my $stopvariable =
  finCom();    #Renseigne le message qui indiquera au systeme la fin de la comm
my $boolStopTransmission = 0;
 
while ( $stopvariable ne my $finalMess )
 
{              #Tant que le message fin de comm n'est pas saisi
 
 
	my ( $finalMess, $md5 ) = message();
 
	if ( $stopvariable eq $finalMess ) {    #Dernier message envoyé+fin de comm
		$boolStopTransmission = 1;
		my $res =
		  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
		$res = encode_base64( $res, "" );    #chiffrement
		$sock->send("$res");
		printf $sock "\n";
		print "Vous avez interrompu la communication\n";
		exit;
	}
	else {                                   #envoi du message
		$boolStopTransmission = 0;
		my $res =
		  ("$finalPers XyX$finalMess XyX $md5 XyX $boolStopTransmission");
 
		$res = encode_base64( $res, "" );    #chiffrement
		$sock->send("$res");
		printf $sock "\n";
		my $reponse = <$sock>;
		print "réponse=$reponse\n";
 
	}
 
	#my $reponse2 = <$sock>;
	#	print "$reponse2";
}
 
close($sock);
 
#print $sock "Au revoir SERVEUR!!!\n";
#}
print "*** Fin de connexion ***\n";
 
######################  Mes Sub ####################
 
 
 
sub personne {
	my $prenom;
	my $nom;
	print "\nVotre prenom : ";
	$prenom = <STDIN>;
	chop($prenom);
	print "Votre Nom : ";
	$nom = <STDIN>;
	chop($nom);
	my $this = Chat2->constPers( "$nom", "$prenom" );
	my $persTemp = "";
 
	foreach ( keys(%$this) ) {
 
		$persTemp = $persTemp . " $$this{$_}";
	}
	print "\n";
	return $persTemp;
}
 
sub message {
	my $finalMess = "";
 
	print "\nMessage : ";
	my $messageTemp = <STDIN>;
	chop($messageTemp);
 
	my ( $this, $md5 ) = Chat2->constMess("$messageTemp");
 
	#$this = substr($this, 1);
	$messageTemp = "";
	foreach ( keys(%$this) ) {
 
		$messageTemp = $messageTemp . " $$this{$_}";
	}
 
	return ( $messageTemp, $md5 );
}
 
sub finCom {
	print "Message de fin de communication: ";
	my $stopvariableTemp = <STDIN>;
	chop($stopvariableTemp);
	$stopvariableTemp = " " . $stopvariableTemp;
	return $stopvariableTemp;
}

Suite client PM (chat2.pm)

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
package Chat2;
use strict;
use Digest::MD5 qw(md5_hex);
 
sub constMess {
 
	my ( $classe, $message ) = @_;
	my $md5Temp = "";
 
	my $this = { "Message" => $message, };
 
	foreach ( keys(%$this) ) {
		my $md5Temp = $md5Temp = $md5Temp . " $$this{$_}";
	}
	$md5Temp = substr( $md5Temp, 1 );
 
	my $md5 = md5_hex("$md5Temp");
 
	bless( $this, $classe );
	return ( $this, $md5 );
}
 
sub constPers {
 
	my ( $classe, $nom, $prenom, ) = @_;
	my $this = {
		"nom"    => $nom,
		"prenom" => $prenom,
	};
 
	bless( $this, $classe );
	return $this;
}
 
1;

Merci a vous tous et passez tous de bonnes fêtes!

**Philou67430** · 27/12/2010, 20h57

Le code que j'ai proposé au message #11 est à l'écoute à la fois du socket de tchat et de l'entrée clavier... tu as donc tous les éléments pour faire marcher ton application.

Réponse d'un serveur à tous les clients

Langage Perl

Discussions similaires

Partager

Partager