dtux__task-lalis/SOURCES/identMM.pl

#!/usr/bin/perl

use strict;
use warnings;
use Tk;

#********** INITIALISATION DE LA GENERATION FICHIER CHECKLIST *********
#my $CheckFile="/home/lalis/Documents/checklist.txt";
my $CheckFile="/usr/share/lalis/checklist.txt";
my $PathFicout="/usr/share/lalis/";

#************* INITIALISATION DES INFORMATIONS GENERALES (LSHW) ****************
#         copie de la commande dans un tableau pour lshw
my @LshwTab=`lshw`;
# Extraction des champs relatifs aux item
my @ChampsLshw=("description|produit|fabriquant|numéro", # champs Identification ORDINATEUR
                "description|produit|fabriquant|version",# champs Identification CARTE MERE
                "description|fabriquant|version",# champs Identification BIOS
                "description|produit|bits|configuration",# champs Identification CPU
                "description|produit|fabriquant",  # champs Identification CARTE GRAPHIQUE
                "description|produit|fabriquant|capacité",# champs Identification RESEAU
                "description|produit|fabriquant",# champs Identification RESEAU
                "produit|fabriquant|capacité|configuration"# champs Identification BATTERIE
               );
my @LshwTitres=("\n########## Identification ORDINATEUR ##########\n",
                "\n########## Identification CARTE MERE ##########\n",
                "\n########## Identification BIOS #########\n",
                "\n########## Identification CPU ##########\n",
                "\n########## Identification CARTE GRAPHIQUE ##########\n",
                "\n########## Identification RESEAU ##########\n",
                "\n########## Identification BATTERIE ##########\n");
# Descripteur de l'item ordinateur                
my @DescOrdi=("0",          # titre du chapitre general (@LshwTitres)
              "0",          # champs (@ChampsLshw) de donnees à extraire
              "localhost",  # debut du bloc a extraire
              "\\*\\-"        # fin du bloc a extraire
             );
# Descripteur de l'item carte mère                             
my @DescCM=("1",            # titre du chapitre general (@LshwTitres)
            "1",          # champs (@ChampsLshw) de donnees à extraire
            "\\*\\-core", # debut du bloc a extraire
            "\\*\\-"        # fin du bloc a extraire
           );
# Descripteur de l'item BIOS                           
my @DescBios=("2",               # titre du chapitre general (@LshwTitres)
              "2",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-firmware",  # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
# Descripteur de l'item CPU                
my @DescCPU=("3",               # titre du chapitre general (@LshwTitres)
             "3",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-cpu",      # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
# Descripteur de l'item Affichage                
my @DescDisp=("4",               # titre du chapitre general (@LshwTitres)
             "4",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-display",  # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
# Descripteur de l'item reseau                
my @DescNet=("5",               # titre du chapitre general (@LshwTitres)
             "5",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-network",  # debut du bloc a extraire
              "\\*\\-"             # fin du b loc a extraire
             );
# Descripteur de l'item battery                
my @DescBat=("6",               # titre du chapitre general (@LshwTitres)
             "7",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-battery",  # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
             
my @RefItems=("PC","CM","BIOS","CPU","DISP","NET","BAT");
#my @RefItems=("PC","CM","BIOS");
        
my @temp;
my @ident;
my $flag=0;

my $titre;
my $start;
my $end;
my $data;

#********** INITIALISATION DES INFORMATIONS USB (lsusb) *********


#********** INITIALISATION DES INFORMATIONS MEMOIRES (DMIDECODE) *********
#            copie de la commande dans un tableau pour dmidecode
my @tabdmidecode=`dmidecode -t memory`;
my @ChampsMem=("Data|Size|Bank Locator:|Type:|Speed:|Manufacturer");
my @MemTitres=("\n########## Identification MEMOIRE ##########\n");
my @DescMem=("0",      # titre du chapitre general (@SmartTitres)
             "0",      # champs (@ChampsMem) de donnees à extraire
             "Memory Device", # debut du bloc a extraire
             "Part"    # fin du bloc a extraire
              );


#*********** INITIALISATION DES INFORMATIONS DISK (SMARTCTL) **************
my @champsdisk=("Family|Model:|Serial|Capacity|Form|SATA");  
my @ListDisk=`ls /dev/sd?`;
my @DescDisk=("0",  # titre du chapitre general (@SmartTitres)
              "0"   # champs (@champsdisk) de donnees à extraire
              );
my @DiskTitres=("\n########## Identification DISK ##########\n");

my $D; 
my @tabsmart;              
my @temp2;
my $PathD;
my $nb=0;

#********** INITIALISATION DE LA GENERATION FICHIER RESULTAT *********
my @RefMachine=("PC", "CM"); 
my @ChampsRef=("numéro", # champs Identification ORDINATEUR
               "numéro"  # champs Identification CARTE MERE
              ); 

# Descripteur de l'item ordinateur                
my @DescOrdi2=("0",          # titre du chapitre general (@LshwTitres)
               "0",          # chamextraireps (@ChampsLshw) de donnees à extraire
               "localhost",  # debut du bloc a extraire
               "\\*\\-"        # fin du bloc a extraire
              );
# Descripteur de l'item carte mère                             
my @DescCM2=("1",            # titre du chapitre general (@LshwTitres)
             "1",          # champs (@ChampsLshw) de donnees à extraire
             "\\*\\-core", # debut du bloc a extraire
             "\\*\\-"        # fin du bloc a extraire
            );          
my @FicTab=@LshwTab;        
my $RefPC=undef;            
my $RefCM=undef;            
my $NomFic=undef;
my $A;
my $item;

#********** INITIALISATION TRAITEMENT CODE REOUR RSYNC *********
my %CodeRetourRsync = (0 => "Succes",
                       1 => "Erreur de syntaxe ou d'utilisation",
                       2 => "Incompatibilite de protocole",
                       3 => "Erreurs lors de la selection des fichiers et des repertoires d'entree/sortie",
                       4 => "Action non supportee",
                       5 => "Erreur lors du démarrage du protocole client-serveur",
                       6 => "Demon incapable d'ecrire dans le fichier de log",
                       10 => "Erreur dans la socket E/S",
                       11 => "Erreur d'E/S fichier",
                       12 => "Erreur dans le flux de donnée du protocole rsync",
                       13 => "Erreur avec les diagnostics du programme",
                       14 => "Erreur dans le code IPC",
                       20 => "SIGUSR1 ou SIGINT reçu ",
                       21 => "Une erreur retournee par waitpid() ",
                       22 => "Erreur lors de l'allocation des tampons de mémoire principaux",
                       23 => "Transfert partiel dut à une erreur",
                       24 => "Transfert partiel dut à la disparition d'un fichier source",
                       25 => "La limite --max-delete a été atteinte",
                       30 => "Dépassement du temps d'attente maximal lors d'envoi/reception de donnees");
                       
#********** INITIALISATION DE L'AFFICHAGE POPUP DE FIN DE TRAITEMENT *********
my @affich;

#########################################################################
#           PROGRAMME RENSEIGNEMENT DU FICHIER CHECKLIST     
######################################################################### 
# Renseignement du fichier checklist.txt de l'ordinateur par l'opérateur
system("su -c 'kwrite $CheckFile' lalis");

#########################################################################
#           PROGRAMME DES INFORMATIONS GENERALES (LSHW)     
#########################################################################              
foreach (@RefItems) {  # foreach @RefItems
   # Pour chaque item a afficher 
   if ($_ eq "PC"){($titre, $data, $start, $end)=@DescOrdi;}
   if ($_ eq "CM"){($titre, $data, $start, $end)=@DescCM;}
   if ($_ eq "BIOS"){($titre, $data, $start, $end)=@DescBios;}
   if ($_ eq "CPU"){($titre, $data, $start, $end)=@DescCPU;}
   if ($_ eq "DISP"){($titre, $data, $start, $end)=@DescDisp;}
   if ($_ eq "NET"){($titre, $data, $start, $end)=@DescNet;}
   if ($_ eq "BAT"){($titre, $data, $start, $end)=@DescBat;}
   #print("$end\n");
   
   $flag=0;
   foreach (@LshwTab) {  # foreach @LshwTab
      # vidage buffer temporaire
      @temp=();
      # extraction d'un bloc memoire dans @temp
      if ( $flag==0 ){   # attente debut du bloc vu
         if ( m/$start/ ){  # debut du bloc vu
            s/$_//;
            $flag=1;
            push(@ident,$LshwTitres[$titre]);
         }   
      }else{      # attente fin du bloc vu
         push(@temp,$_);
         if ( m/$end/ ){   # fin du bloc vu
            $flag=0;
         }
      }
      # Extraction des champs d'un bloc memoire contenu dans @temp
      foreach (@temp) {   # foreach temp
         if ( m/$ChampsLshw[$data]/ ){
            s/\s+/     /;
            push(@ident,$_);
         }
      }  # fin boucle foreach temp
   }  # fin boucle foreach @LshwTab
}  # fin boucle foreach @LshwTitres 


#########################################################################
#           PROGRAMME DES INFORMATIONS GENERALES (LSUSB)     
#########################################################################
   # vidage buffer temporaire
   @temp=();
   @temp=`lsusb`;
   push(@ident,"\n########## Identification USB ##########\n");
   # Extraction des champs d'un bloc memoire contenu dans @temp
   foreach (@temp) {   # foreach temp
         $_="     ".$_;
         push(@ident,$_);
   }
#########################################################################
#        PROGRAMME DES INFORMATIONS DES MEMOIRES (DMIDECODE)     
######################################################################### 
# titre Identification MEMOIRE
push(@ident,$MemTitres[$DescMem[0]]);
# initialisation des variables
$flag=0;
# vidage des tableaux temporaires 
@temp=();
# Pour chaque item a afficher
foreach (@tabdmidecode) {  # foreach @tabdmidecode
   #print"@tabdmidecode \n";
   # vidage des tableaux temporaires 
   @temp=();
   # extraction de la capacite maxi
   if ( m/Capacity/ ){
      s/\s+/     /;
      push(@ident,$_);
      #s/Capacity//;
   }
# extraction d'un bloc memoire dans @temp
   if ( $flag==0 ){   # attente debut du bloc vu
      if ( m/$DescMem[2]/ ){  # debut du bloc vu
         $flag=1;
         push(@ident,"\n************* BANK ***************\n");
      }   
   }else{      # attente fin du bloc vu
      push(@temp,$_);
      if ( m/$DescMem[3]/ ){   # fin du bloc vu
         $flag=0;
      }
   }

# Extraction des champs d'un bloc memoire contenu dans @temp
   foreach (@temp) {   # foreach temp
      if ( m/$ChampsMem[$DescMem[1]]/ ){
         s/\s+/     /;
         #print;

         push(@ident,$_);
      }
   }  # fin boucle foreach temp
} # fin boucle foreach @tabdmidecode
 

#########################################################################
#           PROGRAMME DES INFORMATIONS DISK (SMARTCTL)     
######################################################################### 
# titre Identification DISK
push(@ident,$DiskTitres[$DescDisk[0]]);
# pour chaque disque 
foreach (@ListDisk) { # foreach disk
# commande infos des disques
@tabsmart=`smartctl -i $_`;
# separation du chemin et nom du disque
(my $A, my $B, $D)=split /\//;
chop($D);
# memorisation chemin + nom du disque
$PathD =$_;
chop($PathD);

#@tabsmart=`smartctl -i /dev/$D`;
push(@ident,"\n*************** disk ".$D." *************\n");

# pour chaque disque extraction des champs description
   foreach (@tabsmart) {   # foreach tabsmart
      if ( m/$champsdisk[$DescDisk[1]]/ ){
         $_="     ".$_;
         #print;
         push(@ident,$_);
      }
   }  # fin boucle foreach tabsmart 
    # Sante du disque
    push(@ident,"\n--------------- Etat Disk ".$D." --------------\n");
    @temp=();
    @temp=`smartctl -H $PathD`;
    # pour chaque ligne de la commande smartctl
    foreach (@temp) {
       # recherche du resultat sante disk
       #$nb++;
       if ( m/result:/ ){
           #$nb++;
           #print "$nb\n";
           # Affichage de la ligne pour POPUP
           #push(@affich,"Partition"."sdisk".":"$_);
           push(@affich,"Partition ".$D.": ".$_);           
           # si le resultat est OK alors enregistrement
           if ( m/PASSED/ ){
               #$nb++;
               #print "$nb\n";
               push(@ident,$_);
           }
           else{
               # si le resultat est NOK alors enregistrement de la commande
               @temp2=`smartctl -a $PathD`;
               foreach (@temp2) {
                  push(@ident,$_);
               }  # fin foreach (@temp2)
           }
       }
   } # fin foreach (@temp)
} # fin foreach disk

#########################################################################
#           PROGRAMME DE LA GENERATION FICHIER RESULTAT  
######################################################################### 
# initialisation des variables
$flag=0;
foreach (@RefMachine) {  # foreach @RefMachine
   @temp=();
   # Pour chaque item a afficher
   if ($_ eq "PC"){($A, $data, $start, $end)=@DescOrdi2;}
   if ($_ eq "CM"){($A, $data, $start, $end)=@DescCM2;}
   $item=$_;
   #print "$A\n";
   #print "$data\n";
   #print "$start\n";
   #print "$fin\n";   
   foreach (@FicTab) {  # foreach @FicTab
      # extraction d'un bloc memoire dans @temp
      if ( $flag==0 ){   # attente debut du bloc vu
         if ( m/$start/ ){  # debut du bloc vu
            s/$_//;
            $flag=1;
         }   
      }else{      # attente fin du bloc vu
         push(@temp,$_);
         if ( m/$end/ ){   # fin du bloc vu
         $flag=0;
         }
      }

   # Extraction des champs d'un bloc memoire contenu dans @temp
   foreach (@temp) {   # foreach temp
      if ( m/$ChampsRef[$data]/ ){
         #s/\s+//;
         #print"$_";
         (my $E, my $Ref)=split(/:/,$_);
         $_=$Ref;
         s/\s+//;
         chop($_);
         #print"$_";
         if ($item eq "PC"){$RefPC=$_;}
         if ($item eq "CM"){$RefCM=$_;}
      }
   }  # fin boucle foreach temp
   }  # fin boucle foreach @FicTab

}   # fin boucle foreach @RefMachine
#print "$RefPC";
#print "$RefCM";

# patern pour test de la validite du test de la reference PC et CM
#$RefPC="CZC1194MME";
#$RefPC=undef;
#$RefPC="";

#$RefCM="CZC1194MMF";
#$RefCM=undef;
#$RefCM="";
# fin patern pour test de la validite du test de la reference PC et CM

# Test si $RefPC est: defini ET n'est pas une chaine vide ET ne contient pas d'espace
# Test si $RefCM est: defini ET n'est pas une chaine vide ET ne contient pas d'espace
if ((defined $RefPC) && ($RefPC ne "") && !($RefPC =~ m/\s+/))
{   $NomFic="PC_".$RefPC.".txt";
}elsif((defined $RefCM) && ($RefCM ne "") && !($RefCM =~ m/\s+/)){
       $NomFic="CM_".$RefCM.".txt";
   }else{ 
       $NomFic="ERROR.txt";
}


#########################################################################
# PROGRAMME DE CONCATENATION DES FICHIERS CHECKLIST PLUS CARACTERISTIQUES
#########################################################################
# La concatenation des fichiers checklist suivi de caractéristiques
# se trouve dans un fichier nommé avec la référence du PC ou de la carte
# Enregistrement du tableau @ident dans le fichier de nom $NomFic

open(my $FIN, "<",$CheckFile) or die "Ouverture du fichier $CheckFile impossible\n";
open(my $FOUT, ">",$PathFicout.$NomFic) or die "Ouverture du fichier $NomFic impossible\n";
# Recopie du fichier checklist dans le fichier ref PC ou carte $NomFic
while(<$FIN>){
print ($FOUT $_);  # ecrit la ligne dans le fichier $NomFic
#print("$_");
}
#print ($Fout "TOTO\n");
#print "\n";
# Recopie du tableau caracteristiques PC dans le fichier ref PC ou carte $NomFic
foreach(@ident){
print ($FOUT $_);
#print("$_");
}
close ($FIN);
close ($FOUT);

#########################################################################
#           PROGRAMME D'ENVOI DU FICHIER RESULTAT VERS LE SERVEUR  
#########################################################################
# Envoi du fichier concatené checklist plus caracteristiques PC sur le serveur 
my $ret=system("rsync --port 10073 -aP " . $PathFicout.$NomFic . " 'lalis69.ddns.net::lalis-ordis/'");
#my $ret=system("rsync --port 10073 -aP " . $PathFicout.$NomFic . " 'lalis68.ddns.net::lalis-ordis/'");
# sauvegarde du code retour
#my $ret=$?;
#print "******* $? ******\n";
#$ret=10;
#print "******* $ret ******\n";

# Libele et affichage du code retour de rsync
   if (exists ($CodeRetourRsync{$ret})){
      $_ = "Code retour rsync: ".$ret;
      push(@affich,$_);
      $_ = "Libellé code retour rsync: ".$CodeRetourRsync{$ret};
      push(@affich,$_);
   }
   else{
      push(@affich,"Code retour rsync Inconnu!!! ".$ret);
   }

#########################################################################
#          PROGRAMME DE L'AFFICHAGE POPUP DE FIN DE TRAITEMENT 
#########################################################################
my $mw = MainWindow->new();
$mw->title("Resultat test HDD");
$mw->geometry("700x100");
foreach (@affich) {
   # affichage dans la fenetre
   $mw->Label(-text => $_)->pack;
}
MainLoop;

print "\n########## Nom fichier resultat: $NomFic ##########\n";
print "\n################ Traitement terminé ################\n";
print "\n";
################################ FIN PROGRAMME ################################