Programmes Perl.

Quelques programmes Perl.
Clone avec dialogue Père <-> Fils.

# On commence par declarer deux tubes de communication.
# Le premier permet au pere d'ecrire et au fils de lire.
# Le second permet au fils d'ecrire et au pere de lire.

pipe(LIT_P,ECRIT_F);
pipe(LIT_F,ECRIT_P);

# Puis on purge des deux tubes afin de valider les echanges.

local($fh)=select ECRIT_F; $|=1;select $fh;
local($fh)=select ECRIT_P; $|=1;select $fh;
if ($pid = fork) {

	# Ici on est dans le pere.
	# Le pere ferme les tubes d'acces dont il n'a pas besoin
	# afin que son fils puisse les utiliser.

    close LIT_P;close ECRIT_P;

    @ Le pere transmet une valeur a son fils.
 
	$A = 10;
    print ECRIT_F "$A\n";

    # Puis il recupere ce que lui retourne son fils.

    chomp($A=);

    # Il ferme tous les tubes.

    close LIT_F;close ECRIT_F;

    # Et il attend la fin.

    waitpid($pid,0);
}
else {

	# La on est dans le fils.

    die "Pas moyen : $!" unless defined $pid;

    # Le fils ferme les tubes d'acces dont il n'a pas besoin
	# afin que son pere puisse les utiliser.

    close LIT_F;close ECRIT_F;

    # Le fils lit la valeur transmise par son pere.

    chomp($B=);

    # Il l'eleve au carre.

    $B**=2;

    # Et la retransmet a son pere.

    print ECRIT_P "$B\n";

    # Il ferme tous les tubes.

    close LIT_P;close ECRIT_P;

    # Et se termine.

    exit;
}

Recuperation du nom d'une machine dont on connait l'adresse IP,
ou de l'adresse IP d'une machine dont on connait le nom.

#!/usr/bin/perl
use IO::Socket;
print ("Donnez moi un nom de machine ou une adresse IP : ");
$valeur = ;

# test du type de la valeur entree.

if ($valeur =~ /\d+\.\d+\.\d+\.\d+/) {

  # On a l'adresse IP, on va chercher le nom.

  $valeur =~ s/^\s+|\s+$//g;
  @bytes = split (/\./, $valeur);
  $ad = pack ("C4", @bytes);
  unless ((($nom, $alias, $t_adr, $longueur, @l_adr) = gethostbyaddr ($ad, AF_INET))) {
                die ("Pas moyen de resoudre l'adresse $valeur.\n");
  }
  print ("Le nom principal de la machine est $nom\n");
  if ($alias ne "") {
    print ("Les alias de la machine sont :\n");
    @liste_d_alias = split (/\s+/, $alias);
    for ($i = 0; $i < @liste_d_alias; $i++) {
        print ("\t$liste_d_alias[$i]\n");
    }
  }
} else {

    # On a le nom, on va chercher l'adresse IP.

  chomp ($valeur);
  unless ((($nom,$alias,$typeadr,$longueur,@adrs) = gethostbyname ($valeur))) {
    die ("Pas moyen de resoudre le nom $adresse.\n");
  }
  @bytes = unpack ("C4", $adrs[0]);
  print "L'adresse ip est : ", (join(".",@bytes), "\n");
}

Un scanner qui teste les 255 machines d'une classe C.

#!/usr/bin/perl
use Net::Ping;
use IO::Socket::INET;

# Les trois premiers chiffres de la classe que l'on veut scanner.

my $classe = 'aaa.bbb.ccc';

# Preparation d'un ping() avec un delai d'attente de 0,1 seconde.

my $p = Net::Ping->new('icmp', 0.1);

# Exploration des 255 numeros de la classe C.

for my $n ( 0 .. 254 ) {
  my $ip = "$classe.$n";

  # Envoi du ping() pour verifier que la machine est en marche.

  if ( $p->ping($ip) ) {

  	#La machine est en marche.

    print "$ip: est en marche. ";

    # Tentative de connection ssh.

    my $s = IO::Socket::INET->new( PeerAddr => $ip,
                                   PeerPort => 22,
                                   Timeout  => 0.1);
    print " SSH ne repond pas.\n" unless ( $s );
    (print " " . <$s> and close $s) if ( $s );

  }
}

Dialogue Client / Serveur entre deux machines via Tcp/ip.

Le Serveur.

#!/usr/bin/perl
# Serveur.
use IO::Socket;

# Creation du socket.

$server = IO::Socket::INET->new(
  LocalPort => 3141, Type    => SOCK_STREAM,
  Reuse     => 1,    Listen  => 5)
          or die "Creation du serveur impossible.\n";
print "Demarrage du serveur..\n";

while ($client = $server->accept()) {
  print $client "Connection etablie !\n";
  $pid = fork;
  die "Clonage impossible !" unless defined ($pid);
  if ($pid ==0) {
  	
    # Le fils recoit les donnees du client.
    
    while ($ligne = <$client> ) {
      print "client > $ligne";
    }
  } else {
  	
    # Le pere envoie les donnees au client.
    
    while ($ligne = <>) {
      print $client $ligne;
    }
  }
}

Le Client.

#!/usr/bin/perl
# Client.
use IO::Socket;

# Lecture du nom du serveur.

print "Nom du serveur.";
chomp($adresse = );

# Creation du socket.

$socket = IO::Socket::INET->new(
  PeerAddr => $adresse,
  Proto => "tcp",
  PeerPort => 3141)
         or die "Connexion au serveur impossible.\n";
$pid = fork;
die "Clonage impossible !" unless defined ($pid);
if ($pid == 0) {
	
  # Le fils envoie les donnees au serveur
  
  while ($ligne = <> ) {
    print $socket $ligne;
  }
} else {
	
  # Le pere recoit les donnees du serveur
  
  while ($ligne = <$socket>) {
    print "serveur> $ligne";
  }
}

Serveur de fichiert via Tcp/ip.

Le Serveur.

#!/usr/bin/perl
# Serveur.
use IO::Socket;

# Ouverture des tubes de communication.

pipe(LIT_P,ECRIT_F);
pipe(LIT_F,ECRIT_P);
local($fh)=select ECRIT_F; $|=1;select $fh;
local($fh)=select ECRIT_P; $|=1;select $fh;

# Ouverture du socket.

$socket = IO::Socket::INET->new(
  LocalPort => 3141, Type    => SOCK_STREAM,
  Reuse     => 1,    Listen  => 5)
or die "Creation du serveur impossible.\n";
$socket -> autoflush(1);
print "Demarrage du serveur..\n";

# Acceptation du client.

while ($client = $socket->accept()) {
	
  # Clonage du processus.
  
  $pid = fork;
  die "Clonage impossible !" unless defined ($pid);
  if ($pid) {
  	
    # Le pere recoit les donnees du client, le nom du fichier.
    
    $nom = <$client>;
    close LIT_P;close ECRIT_P;
    
    # Il transmet le nom a son fils.
    
    print ECRIT_F "$nom";
    close LIT_F;close ECRIT_F;
  } else {
  	
    # Le fils envoie les donnees au client.
    
    close LIT_F;close ECRIT_F;
    
    # Lecture du nom envoyé pas son pere.
    
    chomp($nom=);
    close LIT_P;close ECRIT_P;
    
    # Ouverture du fichier.
    
    die ("erreur ouverture $!") unless open (ENTREE, $nom);
    while ($ligne =  ) {
    	
      # Envoi du fichier au client.
      
      print "Envoi : $ligne";
      print $client $ligne;
    }
  }
  exit;
}

Le Client.

#!/usr/bin/perl
# Client.
use IO::Socket;

print "Nom du serveur.";

# Lecture du nom du serveur.

chomp($adresse = );

# Preparation de la connection.

$socket = IO::Socket::INET->new(
  PeerAddr => $adresse,
  Proto => "tcp",
  PeerPort => 3141)
or die "Connexion au serveur impossible.\n";
$socket -> autoflush(1);

# Clonage du processus.

$pid = fork;
die "Clonage impossible !" unless defined ($pid);
if ($pid == 0) {
	
  # Le fils envoie les donnees au serveur, le nom du fichier a lire.
  
  print "Nom du fichier a lire ? ";
  $nom = ;
  
  # Envoi du nom du fichier.
  
  print $socket "$nom";
} else {
	
  # Le pere recoit les donnees du serveur, les lignes du fichier.
  
  while ($ligne = <$socket>) {
    print "Recu : $ligne";
  }
}

Faire dialoguer deux programmes via un port de communication..

Serveur qui recoit le message.

#!/usr/bin/perl
# Serveur.
use IO::Socket::INET;
print ">> Programme Serveur <<\n";

# Creation d'une Socket.
$MySocket=new IO::Socket::INET->new(LocalPort=>1234,
                                    Proto=>'udp');

$def_msg="\nReception d'un message du client.....\n";
while(1)
{
	$MySocket->recv($text,128);
	if($text ne '')
	{
		print "\nMessage recu : '", $text,"'\n";
	}
	# Fin si le message est vide.
	else
	{
		print "Le client a termine son travail !\n";
		exit 1;
	}
}

Client qui envoie le message.

#!/usr/bin/perl
# Client.
use IO::Socket::INET;
print ">> Programme Client <<";

# Creation d'une Socket.
$MySocket=new IO::Socket::INET->new(PeerPort=>1234,
                                    Proto=>'udp',
                                    PeerAddr=>'localhost');

$def_msg="Quel est le message que je dois transmettre ? : ";
print "\n",$def_msg;
while($msg=)
{
	chomp $msg;
	if($msg ne '')
	{
		print "\nEnvoi du message : '",$msg,"'";
		if($MySocket->send($msg))
		{
			print ".....","\n";
			print $def_msg;
		}
	}
	else
	{
		
		# Message vide pour terminer.
		
		$MySocket->send('');
		exit 1;
	}
}