Comment transmettre un tableau par socket

Version imprimable

06/04/2006, 21h53
vodevil

Comment transmettre un tableau par socket

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 :twisted:
07/04/2006, 03h24
Jedai

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

--
Jedaï

8O aurais tu un exemple s'il te plait ? :oops:

voici mon client

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/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:

$ligne->[0]

07/04/2006, 08h57
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ï

Voici mon serveur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/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

Citation:

$array = [data];

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

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/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:

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

:roll: :twisted: :?: :!: :arrow:

07/04/2006, 19h57
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ï
07/04/2006, 21h01
vodevil

A vrai dire effectivement je comprend de moins en moins :arf:

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:

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:

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

08/04/2006, 00h32
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:

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) 8O

http://dirthangel.free.fr/dos.bmp
08/04/2006, 02h13
Jedai

A

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ï

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:

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:

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ï