Bonjour la communauté !  
 
Je demande votre aide car je n'arrive pas à faire un tri de mes adresses IPs qui s'affichent à l'écran. Mon script pour sortir les adresses IP de mon fichier fonctionne mais quand je veux les trier avant de les affichers, je n'y arrive pas, il ne me les trie pas ...
 
Voici mon code :
 

 
Donc j'ai choisi de faire une routine packed mais si vous avez une autre solution je suis preneur !
 
P.S : Je suis débutant en Perl depuis peu donc il se peut qu'il y est des erreurs.

Donne un exemple compilable/exécutable et précise comment tu veux trier tes adresses (avec des exemples).

C'est peut-être moi (débutant) qui ignore un truc mais ceci

@result = sort packed $formatted_output;

me paraît douteux. $formatted_output c'est un seul string, pas grand chose à trier donc. Ca serait pas plutôt sort packed @ip ou quelque chose comme ça?

Alors, j'ai un fichier venant de dhcpd.leases.
J'ouvre le fichier je le lis et je stock les adresses ip qui sont encore valide et les affiches ensuite.
Maintenant j'aimerai que les IPs afficher soit trier =).
 
J'ai essayé avec @ip en disant que mon @ip = $ip ou @ip = $_. Soit m'affiche les résultats mais non trier. Après je ne suis pas très bon en perl et j'ai encore du mal à tout comprendre :s.
 
Mes adresse je veux les trier par plage :
 
ex :  
 
172.17.112.0
172.17.111.1
172.17.110.0 ...
 
En ce moment j'ai les IP mais non trier.

 
sort ça prends un array et ça ressort un array, soit @result = sort @donnees.

Si j'ai bien compris ce que tu veux:

use strict;
use warnings FATAL => 'all';
 
my @addr=qw(172.17.110.0 172.17.110.1 172.17.111.0 172.16.255.243 172.16.255.244 172.17.112.0 172.17.111.1 );
 
sub packed {
   pack('C4', split(/\./, $a)) cmp pack('C4', split(/\./, $b));
}
 
my @result1 = sort packed @addr; #ordre croissant
my @result2 = reverse sort @addr; #ordre décroissant
 
print join("\n",@result1);
 
print "\n\n";
 
print join("\n",@result2);

A toi d'inclure ça dans ton script... En fait ton sub packed est bon, c'est juste l'appel de sort qui ne va pas.

edit: Si c'est pas clair, si il y a un autre soucis, ... je répète: donne un code compilable/exécutable, voire le script complet. Le script de ton premier post je ne peux pas l'exécuter parce qu'il manque des choses.

Ouais j'avais déjà vu un truc dans le genre mais dans my @addr = qw, je mets quoi dedans car j'ai pleins d'ip qui vient et ça peut être aléatoire.

Désolé, je crois que tu n'as pas compris. Le qw() tu en as pas besoin, toi tu vas lire tes adresses dans ton fichier ou ailleurs. Moi par contre j'ai utilisé le qw() pour insérer des adresses ip "bidons" pour avoir un script complet que je peux tester. J'aurais pu faire autrement mais qw() c'est le moins long à tapper...

Voilà le code complet :
 

#!/usr/bin/perl
 
my $VERSION=0.03;
 
my $leases_file = "/home/romain_bureau/Documents/synchro_docs/Test_DHCP/dhcpd.leases";
 
use strict;
use Date::Parse;
use Term::ANSIColor;
 
my $now = time;
my %seen;       # leases file has dupes (because logging failover stuff?). This hash will get rid of them.
 
open(L, $leases_file) or die "Cant open $leases_file : $!\n";
undef $/;
my @records = split /^lease\s+([\d\.]+)\s*\{/m, <L>;
shift @records; # remove stuff before first "lease" block
 
## process 2 array elements at a time: ip and data
 
# affichage du header
 
my $header=("\t\@IP\t||\tHOST NAME\t||\t\tMAC\t\t||\t\tSTATE\t\t||\t   DATE END\n" );
print color 'bold';
print "====================================================================================================================================\n";
print $header;
print "====================================================================================================================================\n\n";
print color 'reset';
 
# début processus
 
foreach my $i (0 .. $#records) {
    next if $i % 2;
    my ($ip, $_) = @records[$i, $i+1];
 
    s/^\n+//;     # && warn "leading spaces removed\n";
    s/[\s\}]+$//; # && warn "trailing junk removed\n";
 
    my ($s) = /^\s* starts \s+ \d+ \s+ (.*?);/xm;
    my ($e) = /^\s* ends   \s+ \d+ \s+ (.*?);/xm;
 
    my $start = str2time($s);
    my $end   = str2time($e);
 
    my %h; # to hold values we want
 
    foreach my $rx ('binding', 'hardware', 'client-hostname') {
        my ($val) = /^\s*$rx.*?(\S+);/sm;
        $h{$rx} = $val;
    }
 
    my $formatted_output;
 
    if ($end && $end < $now) {
        # we don't want the expired ip address
    }
    else {
        $formatted_output =
            sprintf "\033[32m%-15s : %-26s "              . "  %19s  "        ."%9s "        ."%24s  --  "             . "%24s\033[0m\n",
                             $ip,    $h{'client-hostname'}, "($h{'hardware'})", $h{'binding'}, scalar(localtime $start), scalar(localtime $end);
    }
    next if $seen{$formatted_output};
    $seen{$formatted_output}++; 
    print $formatted_output;
}

Et le fichier dhcpd.leases ça ressemble à quoi? J'y connais rien moi en réseaux...

Pleins de fois des trucs comme ça avec bien sur les ip qui changent etc ...
 
lease 172.17.97.241 {
 starts 5 2015/04/17 14:42:21 UTC;
 ends 6 2015/04/18 02:42:21 UTC;
 hardware ethernet 00:08:5d:44:64:e2;
 uid 01:00:08:5d:44:64:e2;
 client-hostname "6867i00085D4464E2";
}

Ok. Ton script tu l'as fait toi-même ou pris sur internet en entier ou pris sur internet par morceaux? Parce que là j'avoue que j'ai du mal à m'y retrouver... Bon, je vais voir ce que je peux faire.

La plupart fait par moi, quelques trucs prit sur le net, j'ai mit 3 semaines à faire ça  
Sans le tri des IP, mon script marche très bien, il fait exactement ce que je lui demande

Ok. Le truc c'est que (à mon avis) pour mettre un tri des adresses faut réorganiser le script autrement, il suffit pas de rajouter une ligne ou deux. En effet faut avoir un tableau de tout les adresses qu'on classe d'abord et ensuite on regarde pour l'affichage. Sauf que pour chaque adresse il y a d'autres infos qu'il faut mémoriser en même temps. C'est tout à fait faisable mais faut modifier le truc. Si tu me laisses un peu de temps je veux bien essayer de bricoler quelque chose (même si il y a des chances que gilou soit plus rapide...   ).

EDIT: Par contre je veux bien un exemple réel de fichier dhcp.leases, histoire d'être vraiment sûr du format.

Okay bah merci car là je suis un perdu ... Je peux attendre oui =).
L'exemple que je t'ai donné est un vrai . Ca ressemble exactement à ça =). Et tu as X adresses avec ce genre d'exemple. C'est un fichier .leases qui s'ouvre comme un fichier .txt

ligne 47: binding il sort d'où, j'en vois pas dans ton exemple de fichier dhcpd.leases... Et hardware c'est hardware ethernet je suppose?

Hardware c'est harware ethernet oui (adresse mac quoi).
Binding autant pour moi c'était des tests et j'ai oublié de le retirer . Donc tu  peux retirer binding ligne 47 et ligne 59 et 60.

Voici un truc fait à la va-vite mais qui fonctionne bien en tout cas avec les données que j'ai. À tester avant mise en prod...
À toi de faire la mise en page que tu veux (et que je ne connais pas) avec sprintf() et puis le print "HEADER.
Faut aussi rajouter les couleurs, chez moi sous Windows ça ne marche pas et j'y connais rien.

Le code me paraît assez explicite, sinon n'hésite pas à poser des questions. On peut certainement faire autrement/plus élégant mais moi aussi je suis débutant et puis TMTOWTDI.

#!/usr/bin/perl
use strict;
use warnings FATAL => 'all';
no warnings 'experimental';
use Date::Parse;
use autodie;
 
#use Data::Dumper; #debug
 
my $leases_file='dhcpd.leases';
 
my $now=time;
 
open(L, $leases_file);
 
my ($ip, $start, $end, $hw_eth, $uid, $client_hostname);
 
my @res;
 
while(<L> )
{
    if(/^lease\s+([\d\.]+)\s*{/)
    {
        $ip=$1;
    }
    elsif(/^\s* starts \s+ \d+ \s+ (.*?);/x)
    {
        $start=str2time($1);
    }
    elsif(/^\s* ends \s+ \d+ \s+ (.*?);/x)
    {
        $end=str2time($1);
    }
    elsif(/^\s* hardware\sethernet \s+ (.*?);/x)
    {
        $hw_eth=$1;
    }
    elsif(/^\s* uid \s+ (.*?);/x)
    {
        $uid=$1;
    }
    elsif(/^\s* client-hostname \s+ (.*?);/x)
    {
        $client_hostname=$1;
    }
    elsif(/^\s*}\s*$/) #fin d'un bloc --> traitement
    {
        if($end > $now) #encore valide?
        {
            my  $formatted_output=sprintf "%s <-> %s <-> %s <-> %s <-> %s", 
$ip, $client_hostname, "($hw_eth)", scalar(localtime $start), scalar(localtime $end); #FORMAT À PRÉCISER
            
            if(!($formatted_output ~~ @res)) #pas encore dans le tableau? outil expérimental, à remplacer??
            {
                push @res, $formatted_output; #alors rajouter
            }
        }
    }
}
 
close(L);
 
sub sortsub
{
    $a=~/^([\d\.]+?)\s/; my $ip1=$1; #sortir adresse ip
    $b=~/^([\d\.]+?)\s/; my $ip2=$1; #de même
    
    return pack('C4', split(/\./, $ip1)) cmp pack('C4', split(/\./, $ip2));
}
 
@res=sort sortsub @res; #trier selon adresse ip
 
print "HEADER A FAIRE\n";
 
print "$_\n", foreach (@res); #affichage

edit: J'ai repris les regex de ton code, possible qu'il y ait des choses améliorables, j'ai pas analysé en détail.

Le fichier dhcpd.leases que j'avais bricolé et utilisé pour mes tests: 2 entrées encore valides (changé le 2015 en 2016...) et deux autres non.
 

Merci beaucoup ! Mais je viens de le tester et j'ai une erreur à la ligne 67 avec $ip1 :
"Use of uninitialized value $ip1 in split"

A oui, pour le truc avec expérimental, c'est le "~~" = "smartmatch operator" dont je parle. Au pire on modifie
 

...
if(!is_in_list($formatted_output, \@res))
...
 
sub is_in_list
{
    my ($el, $ref)=(shift, shift);
    foreach (@$ref)
    {
        if($_ eq $el)
        {
            return 1;
        }
    }
    return 0;
}

ou semblable...

Ca c'est ton fichier qui n'est pas bon ou pas comme je pensais, fait donc voir...

Tu peux aussi remettre un print Dumper(@res); et poster le résultat avant le truc avec le sort.

edit: Dumper doit sortir

avec mon fichier exemple.

Mon fichier ressemble exactement à ce que tu as mit haha.  
 
Voici 5 exemples qui se suivent :
 
lease 172.17.99.167 {
 starts 1 2015/06/15 12:42:03 UTC;
 ends 2 2015/06/16 00:42:03 UTC;
 hardware ethernet 00:08:5d:43:48:8b;
 uid 01:00:08:5d:43:48:8b;
 client-hostname "6867i00085D43488B";
}
lease 172.17.110.46 {
 starts 1 2015/06/15 12:44:29 UTC;
 ends 2 2015/06/16 00:44:29 UTC;
 hardware ethernet 00:08:5d:44:61:77;
 uid 01:00:08:5d:44:61:77;
 client-hostname "6867i00085D446177";
}
lease 172.17.98.134 {
 starts 1 2015/06/15 12:45:51 UTC;
 ends 2 2015/06/16 00:45:51 UTC;
 hardware ethernet 00:08:5d:44:65:53;
 uid 01:00:08:5d:44:65:53;
 client-hostname "6867i00085D446553";
}
lease 172.17.97.2 {
 starts 1 2015/06/15 12:49:09 UTC;
 ends 2 2015/06/16 00:49:09 UTC;
 hardware ethernet 00:08:5d:44:64:e8;
 uid 01:00:08:5d:44:64:e8;
 client-hostname "6867i00085D4464E8";
}
lease 172.17.99.176 {
 starts 1 2015/06/15 12:50:51 UTC;
 ends 2 2015/06/16 00:50:51 UTC;
 hardware ethernet 00:08:5d:44:6b:6e;
 uid 01:00:08:5d:44:6b:6e;
 client-hostname "6867i00085D446B6E";
}

Chez moi ça marche très bien, il n'y a simplement rien dans le résultat car les entrées sont déjà invalides (ends au mois de juin).

-->

Le Dumper ça donne quoi?

EDIT: gestion d'erreurs dans le sortsub:

sub sortsub
{
    my ($ip1, $ip2);
    if($a=~/^([\d\.]+?)\s/)
    {
        $ip1=$1; #sortir adresse ip
    }
    else
    {
        die "sortsub: can't find ip in $a";
    }
    if($b=~/^([\d\.]+?)\s/)
    {
        $ip2=$1; #sortir adresse ip
    }
    else
    {
        die "sortsub: can't find ip in $b";
    }
    
    return pack('C4', split(/\./, $ip1)) cmp pack('C4', split(/\./, $ip2));
}

J'ai 5 ip que j'ai changé jusqu'au mois d'aout .
 
Le dumper si je mets :
 
print Dumper(@res);
 
Ca me met une erreur aussi haha

Avec la gestion d'erreur du sort sub j'ai ça dans mon terminal ubuntu
 
sortsub: can't find ip in 172.17.112.1    <-> "6867i00085D44D88E"        <->  (00:08:5d:44:d8:8e) <-> Wed May 13 10:27:07 2015  --  <-> Thu Aug 13 22:27:07 2015

   
 
L'erreur c'est "Undefined subroutine"? Evidemment faut remettre le use Data::Dumper;...

Okay désolé ...
Effectivement j'ai bien les @IP qui s'affichent avec le Dumper :
 

Là je ne comprends pas... Le regex dans le sort fonctionne bien ici...
Remets donc le script complet et exactement le fichier dhcpd que tu utilises, je testerai chez moi.

edit: Au pif, si tu modifies les deux(!) regex (dans sortsub) ainsi

ça donne quoi?

Tu as déjà essayé pour mettre des couleurs? Parce que dans ce cas il y a peut-être des trucs en début de $a et $b et du coup le regex ne marche plus. Par contre dans ton Dumper je ne vois rien, alors je sais pas... Comme je disais, sois très précis en donnant exactement ce que tu utilises actuellement.

Ok c'était bien les couleurs merci rat de combat. Mais j'aimerai y rajouter des couleurs maintenant

Alors faut simplement modifier le regex dans sortsub.

Voyons,

(tu notera l'absence du ^) semble fonctionner. Sinon faut me dire ce que tu as rajouté exactement pour les couleurs.

 
Voila sur la ligne ce que j'ai rajouté pour que ça apparaisse en vert

ok, regarde le regex de mon message Posté le 29-06-2015 à 16:48:14.

Je dois m'absenter là, désolé. Bon courage.

Okay merci beaucoup en tout cas !!! Tu m'as été d'une précieuse aide et j'ai bien compris ton script grâce au '#'

Okay j'ai trouvé ! Merci beaucoup en tout cas !! Je reviendrai vers toi si j'ai d'autre question sur ce script car j'aimerai peut être rajouter un compteur pour compter (*sans déconner*) le nombre d'ip active trouvé

Pour ton compteur suffit de regarder le nombre d'entrées dans @res:

print scalar(@res)," adresses actives!\n";

romyx1, tu es sur de ton format de dhcpd.leases?
Parce que les dates y sont toujours au format UTC, et dans toutes les descriptions de dhcpd.leases que j'ai trouvé, elles ne sont jamais accompagnées de UTC à la fin avant le ; (dans starts ou ends par exemple).
J'ai testé ton exemple sur un module Perl de CPAN qui parse les dhcpd.leases et les dates avec UTC ont été considérées comme incorrectes.

 
A+,

Un exemple de solution qui peut marcher au vu de vôtre jeu de données, que je donne comme exemple de méthode permettant de traiter des suites de records de structure fixe:

#!/usr/bin/perl
use strict;
use warnings;
use autodie;
use Date::Parse;
use Term::ANSIColor;
our $VERSION = 0.03;
 
my $DATE = '\d{4}\/\d{2}\/\d{2}\s\d{2}:\d{2}:\d{2}';
my $IPV4  = '\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}';
my $MAC  = '[0-9A-Fa-f]{2}(?::[0-9A-Fa-f]{2}){5}';
my $ETMAC  = '01(?::[0-9A-Fa-f]{2}){6}';  # 01 for ethernet followed by MAC address
 
my $leases_file = 'dhcpd.leases';
open(my $fh, "<", $leases_file);
undef $/;
$_ = <$fh>;
close($fh);
 
my $now = time;
my %leases;
# comment on parse un ensemble répétitif de structure fixe (ie un record)
while (m{
^lease \s+ ($IPV4) \s+ \{ \s* \n
\s* starts \s+ \d \s ($DATE) \s UTC ; \s* \n
\s* ends   \s+ \d \s ($DATE) \s UTC ; \s* \n
\s* hardware \s+ ethernet \s+ ($MAC); \s* \n
\s* uid \s+ ($ETMAC); \s* \n
\s* client-hostname \s+ "([^\"]+)"; \s* \n
\s* \} \s* \n
}xmg) {
  my $start = str2time($2);
  my $end = str2time($3);
  # commenté pour mon jeu de tests, à décommenter avec de vraies données
  # next if ($end && $end < $now);
  # clé unique pour virer les doublons, à la construction du hash
  my $key = $1.$start.$end.$4.$5.$6;
  $leases{$key}{"ip"} = $1;
  $leases{$key}{"start"} = scalar(localtime $start);
  $leases{$key}{"end"} = scalar(localtime $end);
  $leases{$key}{"hardware"} = $4;
  $leases{$key}{"binding"} = $5;
  $leases{$key}{"hostname"} = $6;
}
 
# on parcourt le hash en triant selon les IPs
foreach ( sort {my @a = split /\./, $leases{$a}{"ip"}; my @b = split /\./, $leases{$b}{"ip"};
        $a[0] <=> $b[0] or $a[1] <=> $b[1] or $a[2] <=> $b[2] or $a[3] <=> $b[3];} (keys %leases)) {
  print $leases{$_}{"ip"}, "\n"; # a remplacer par un truc plus complexe dans votre code
}

Un petit coup de Data::Dumper sur %leases vous permettra de visualiser la structure obtenue après parsing.
A adapter selon vos données.
 
A+,

Merci gilou et rat de combat, le compteur j'avais réussi aussi .
@gilou : Oui je suis sur que c'est comme ça . Je suis allé chercher le dhcpd.leases directement dans le switch . Merci pour le second script le 1er marche très bien mais je le prends quand même on ne sait jamais =).

Je voulais te montrer dans ma solution:
1) comment mettre toutes les infos utiles dans un hash
2) Trier les clés du hash en fonction d'un des champs du hash pour le parcourir dans l'ordre voulu et afficher les infos utiles.
 
Bon, je ne sais pas quel constructeur a fait ton switch, mais manifestement, il ne respecte pas les specs prévues pour ce fichier.
 
A+,