Discussion :

[vodevil]

Sa fait un bon moment que je galère avec les socket pour transmettre un tableau du type @tableau;

J'ai testé plein de solutions mais aucune ne fontionne

[Jedai]

Ben si : il suffit d'utiliser le Dumper et eval() à la fin par exemple.

--
Jedaï

[vodevil]

aurais tu un exemple s'il te plait ?

voici mon 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
#!/usr/bin/perl -w
# client
use IO::Socket;
ecoute();
 
sub ecoute {
my $socket;
my $ligne = [];
while (!$socket) {
   $socket = creation_socket();
 }
 while (@$ligne = <$socket> ) {
  for (my $a = 0; $a <= $#$ligne; $a++) {
    print $ligne->[$a];
  }
 }
 ecoute();
}
 
sub creation_socket {
my $sock = IO::Socket::INET->new(
               PeerAddr => "localhost",
               Proto    => "tcp",
               PeerPort => 5004
   );
 return $sock;
}

mon array est du type $array = []; le probleme c'est que toutes les donnés ce trouve dans

Code :

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

$ligne->[0]

[Jedai]

Tu ne sembles pas bien comprendre comment fonctionnent les sockets... Tout ce qui peut-être transmis par des sockets c'est des strings, à charge pour le serveur de les envoyer dans un format tel que le client puisse les évaluer de la façon souhaitée.
Qu'est-ce qu'envoie ton serveur ?

--
Jedaï

[vodevil]

Voici mon 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
#!/usr/bin/perl -w
use IO::Socket;
 
$server = IO::Socket::INET->new(
    LocalPort => 5004,
    Type      => SOCK_STREAM,
    Reuse     => 1,
    Listen    => 5
) or die "Création du serveur impossible.\n";
print "Démarrage du serveur ..\n";
my $m = ["Le serveur dit 'bonjour' au client !","seconde"];
 
while ($client = $server->accept()) {
# print $client "Le serveur dit 'bonjour' au client !\n";
print $client "@$m";
 
 $pid = fork;
 die "Je ne peux pas forker !" if ! defined ($pid);
 
 if ($pid ==0) {
 # c'est le processus enfant, chargé de l'écoute des clients
 #############################################################
   while ($ligne = <$client> ) {
     print "client> $ligne";
 
   }
  } else {
  # c'est le père qui pendant ce temps répond au client #
  #######################################################
   while ($ligne = <>) {
     print $client $ligne;
  }
 }
}

il envoie aussi les données sous la forme

$array = [data];

[vodevil]

Je n'obtient pas des résultats très concluant avec le dumper

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
#!/usr/bin/perl -w
use IO::Socket;
use Data::Dumper;
ecoute();
 
sub ecoute {
my $socket;
my $ligne = [];
while (!$socket) {
   $socket = creation_socket();
 }
 while (@$ligne = <$socket> ) {
   my $d = Data::Dumper->new([$ligne]);
       print $d->Dump;
 }
 ecoute();
}
 
sub creation_socket {
my $sock = IO::Socket::INET->new(
               PeerAddr => "localhost",
               Proto    => "tcp",
               PeerPort => 5004
   );
 return $sock;
}

J'obtient en réponse

Code :

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

1
2
3
$VAR1 = [
                `Le serveur dit \'bonjour\' au client ! booo'
             ];

:

[Jedai]

Le Dumper doit être utilisé au niveau de l'émetteur évidemment, ensuite on utilise eval() au niveau du récepteur pour récupérer les valeurs...
Par ailleurs Storable est sans doute plus adapté pour ce que tu veux faire mais c'est le même principe, que tu semble avoir du mal à comprendre : on encapsule du côté de l'émetteur sous une forme qu'on peut décapsuler du côté du récepteur.

--
Jedaï

[vodevil]

A vrai dire effectivement je comprend de moins en moins

[Jedai]

C'est pourtant pas bien compliqué : sur le réseau, toute information sur le type des données est perdu, on ne peut faire passer que des strings. Donc si on veut transmettre une structure de donnée, il faut l'émettre sous une forme qu'on peut facilement retransformer en la structure d'origine.
Tu pourrais réinventer une solution à ce problème, mais c'est beaucoup plus simple d'utiliser une solution fournie directement par Perl.

Code du 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
 
#!/usr/bin/perl -w
use IO::Socket;
use Storable qw/nfreeze/;
 
$server = IO::Socket::INET->new(
    LocalPort => 5004,
    Type      => SOCK_STREAM,
    Reuse     => 1,
    Listen    => 5
) or die "Création du serveur impossible.\n";
print "Démarrage du serveur ..\n";
my $m = ["Le serveur dit 'bonjour' au client !","seconde"];
 
while ($client = $server->accept()) {
  # print $client "Le serveur dit 'bonjour' au client !\n";
  print $client nfreeze($m);
  print $client "\nend of value\n";
 
 $pid = fork;
 die "Je ne peux pas forker !" if ! defined ($pid);
 
 if ($pid ==0) {
 # c'est le processus enfant, chargé de l'écoute des clients
 #############################################################
   while ($ligne = <$client> ) {
     print "client> $ligne";
 
   }
  } else {
  # c'est le père qui pendant ce temps répond au client #
  #######################################################
   while ($ligne = <>) {
     print $client $ligne;
  }
 }
}

Code du 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
#!/usr/bin/perl -w
use IO::Socket;
use Storable qw/thaw/;
ecoute();
 
sub ecoute {
my $socket;
my $ligne;
my ($value, $freezed);
 
 while (!$socket) {
   $socket = creation_socket();
 }
 while ($ligne = <$socket> ) {
   if( $ligne eq "end of value\n" ){
     $value = thaw($freezed);
     $freezed = "";
   } else {
     $freezed .= $ligne;
   }
 }
 ecoute();
}
 
sub creation_socket {
my $sock = IO::Socket::INET->new(
               PeerAddr => "localhost",
               Proto    => "tcp",
               PeerPort => 5004
   );
 return $sock;
}

C'est très cru comme solution, et ça ne sert pas à grand chose, mais comme je ne sais pas ce que tu veux vraiment faire...

[vodevil]

En fait je veut juste transmettre un tableau $array = [] mais la difficulté c'est que ce tableau contient du code html.

voila le tableau que je doit passer

Code :

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

my $donneweb = [$code , $poid, $url, $date];

$code contient tout le code de la page

J'ai testé ta solution mais j'ai des caractères bizarre sur la console (je suis sous winxp)

[Jedai]

Tu remarqueras qu'il y a aussi un code pour le client dans ma réponse, et qu'il ne se contente pas d'imprimer chaque ligne sur la sortie standard... Ce n'est qu'à partir du moment où l'on a effectué thaw() que $value va contenir une référence sur le tableau initial. Après c'est à toi de gérer cette donnée comme tu l'entend, peut-être devrais tu faire un last à cet endroit, et traiter $value.

--
Jedaï

[Jedai]

Tu ne dois pas toucher à ces caractères, ils font partie de l'information envoyée par freeze. A la place tu dois faire un thaw() sur la chaîne de caractères obtenue pour récupérer le tableau que tu avais envoyé.

Voici un dernier exemple de couple client-serveur où le serveur transmet des structures de données au(x) client(s) en utilisant des fonctions simples que j'ai écrites send_value() et receive_value() :
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
#!/usr/bin/perl -w
use IO::Socket;
use Storable qw/nfreeze/;
$| = 1;
 
$server = IO::Socket::INET->new(
    LocalPort => 5004,
    Type      => SOCK_STREAM,
    Reuse     => 1,
    Listen    => 5
) or die "Création du serveur impossible.\n";
print "Démarrage du serveur ..\n";
my $m = ["Le serveur dit 'bonjour' au client !","seconde"];
 
while ($client = $server->accept()) {
  print "Etablissement de la connexion\n";
 
  send_value( $client, $m );
  print "Valeur 1 transmise ! ";
 
  send_value( $client, ["Le serveur dit 'au revoir' au client !",
                        "troisième"]);
  print "Valeur 2 transmise ! ";
 
  send_value( $client, { Un => [ 'Dark Vador', 'Je suis ton père Luke' ],
      Deux => [ 'Luke Skywalker', "Nooonn\n" ]});
  print "Valeur 3 transmise !\n";
 
  send_value( $client, \"Fin de connexion" );
  print "Connexion terminée\n";
} 
 
sub send_value {
  my $client = shift;
  my $value = shift;
  print $client nfreeze($value);
  print $client "\neov\n";
}

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
#!/usr/bin/perl -w
use IO::Socket;
use Data::Dumper;
use Storable qw/thaw/;
 
$| = 1;
ecoute();
 
sub ecoute {
  my $socket;
  my $value;
 
  while (!$socket) {
    $socket = creation_socket();
  }
 
 while( $value = receive_value( $socket ) ){
   print Data::Dumper->Dump([$value]);
   last if( $value =~ /SCALAR/ and $$value eq "Fin de connexion" );
 }
}
 
sub creation_socket {
my $sock = IO::Socket::INET->new(
               PeerAddr => "localhost",
               Proto    => "tcp",
               PeerPort => 5004
   );
 return $sock;
}
 
 
sub receive_value {
  my $socket = shift;
  my ($ligne, $freezed);
  while ($ligne = <$socket> ) {
    if( $ligne eq "eov\n" ){
      return thaw($freezed);
    } else {
      $freezed .= $ligne;
    }
  }
}

--
Jedaï