Benutzer:Kirmse/fip03: Unterschied zwischen den Versionen

Aus Delixs
Zur Navigation springen Zur Suche springen
(leases- und dhcpd.conf kann übergeben werden)
(Formatierung korrigiert)
Zeile 2: Zeile 2:


einfach mit der Maus runterkratzen :)
einfach mit der Maus runterkratzen :)




  <font color="#C0C0C0"><i>#!/usr/bin/perl -w</i></font>
  <font color="#C0C0C0"><i>#!/usr/bin/perl -w</i></font>
 
  use strict;                        <font color="#C0C0C0"><i># Variablen -> deklariert sein</i></font>
  use strict;                        <font color="#C0C0C0"><i># Variablen -> deklariert sein</i></font>
  use Getopt::Long;                  <font color="#C0C0C0"><i># fuer Kommandozeilenparameter</i></font>
  use Getopt::Long;                  <font color="#C0C0C0"><i># fuer Kommandozeilenparameter</i></font>
 
 
  <font color="#C0C0C0"><i># ------------------- Konfigurationsbereich ---------------------</i></font>
  <font color="#C0C0C0"><i># ------------------- Konfigurationsbereich ---------------------</i></font>
 
  <font color="#C0C0C0"><i># hier wird der Pfad zur Datei "dhcpd.leases" eingetragen. Diese</i></font>
  <font color="#C0C0C0"><i># hier wird der Pfad zur Datei "dhcpd.leases" eingetragen. Diese</i></font>
  <font color="#C0C0C0"><i># Voreinstellung gilt für Arktur 4, wird aber ueber schrieben,</i></font>
  <font color="#C0C0C0"><i># Voreinstellung gilt für Arktur 4, wird aber ueber schrieben,</i></font>
  <font color="#C0C0C0"><i># wenn man mit Kommandozeilenparameter -f eine Datei uebergibt</i></font>
  <font color="#C0C0C0"><i># wenn man mit Kommandozeilenparameter -f eine Datei uebergibt</i></font>
  my $leasedatei = "dhcpd.leases";
  my $leasedatei = "dhcpd.leases";
 
  <font color="#C0C0C0"><i># hier die Bildungsvorschrift fuer den Namen als Regex uebergeben</i></font>
  <font color="#C0C0C0"><i># hier die Bildungsvorschrift fuer den Namen als Regex uebergeben</i></font>
  <font color="#C0C0C0"><i># diese Voreinstellung bedeutet, dass am Ende die Rechnernummer</i></font>
  <font color="#C0C0C0"><i># diese Voreinstellung bedeutet, dass am Ende die Rechnernummer</i></font>
Zeile 22: Zeile 23:
  <font color="#C0C0C0"><i># muss der Raumname sein</i></font>
  <font color="#C0C0C0"><i># muss der Raumname sein</i></font>
  my $regex = '(.*\D)\d+';
  my $regex = '(.*\D)\d+';
 
  <font color="#C0C0C0"><i># hier wird die Standardbezeichnung für die Gruppierung festgelegt</i></font>
  <font color="#C0C0C0"><i># hier wird die Standardbezeichnung für die Gruppierung festgelegt</i></font>
  <font color="#C0C0C0"><i># dabei werden die Gruppierungen hochgezaehlt und an diesen Namen</i></font>
  <font color="#C0C0C0"><i># dabei werden die Gruppierungen hochgezaehlt und an diesen Namen</i></font>
Zeile 31: Zeile 32:
  <font color="#C0C0C0"><i># Parameter -n oder -name ueberschrieben werden.</i></font>
  <font color="#C0C0C0"><i># Parameter -n oder -name ueberschrieben werden.</i></font>
  my $name  = 'Raum:2';
  my $name  = 'Raum:2';
 
 
  <font color="#C0C0C0"><i># ------------------- Initialisierungsbereich -------------------</i></font>
  <font color="#C0C0C0"><i># ------------------- Initialisierungsbereich -------------------</i></font>
 
  <font color="#C0C0C0"><i># Deklaration der globalen Variablen</i></font>
  <font color="#C0C0C0"><i># Deklaration der globalen Variablen</i></font>
  my @daten = ();                    <font color="#C0C0C0"><i># Element = Zeile von 'computer'</i></font>
  my @daten = ();                    <font color="#C0C0C0"><i># Element = Zeile von 'computer'</i></font>
Zeile 44: Zeile 45:
  my $datei = "computer";            <font color="#C0C0C0"><i># Daten nicht ok, dann .= '.not_okay'</i></font>
  my $datei = "computer";            <font color="#C0C0C0"><i># Daten nicht ok, dann .= '.not_okay'</i></font>
  my $startwerte = 20;              <font color="#C0C0C0"><i># Initialisierung fuer IP</i></font>
  my $startwerte = 20;              <font color="#C0C0C0"><i># Initialisierung fuer IP</i></font>
 
  <font color="#C0C0C0"><i># Deklaration Variablen für Parameter, wenn kein Schalter: undef</i></font>
  <font color="#C0C0C0"><i># Deklaration Variablen für Parameter, wenn kein Schalter: undef</i></font>
  my $namen;                        <font color="#C0C0C0"><i># Namensliste als String (Komma)</i></font>
  my $namen;                        <font color="#C0C0C0"><i># Namensliste als String (Komma)</i></font>
Zeile 50: Zeile 51:
  my $conf;                          <font color="#C0C0C0"><i># alte dhcpd.conf</i></font>
  my $conf;                          <font color="#C0C0C0"><i># alte dhcpd.conf</i></font>
  my $leases;                        <font color="#C0C0C0"><i># alte dhcpd.leases</i></font>
  my $leases;                        <font color="#C0C0C0"><i># alte dhcpd.leases</i></font>
 
 
  <font color="#C0C0C0"><i># =================== Hauptprogramm =============================</i></font>
  <font color="#C0C0C0"><i># =================== Hauptprogramm =============================</i></font>
 
  <font color="#C0C0C0"><i># ------- 1. Schritt: Kommandozeilenparameter uebernehmen -------</i></font>
  <font color="#C0C0C0"><i># ------- 1. Schritt: Kommandozeilenparameter uebernehmen -------</i></font>
 
  <font color="#C0C0C0"><i># hier werden die Zuordnungen fuer die Parameter erstellt</i></font>
  <font color="#C0C0C0"><i># hier werden die Zuordnungen fuer die Parameter erstellt</i></font>
  <font color="#C0C0C0"><i># Bsp.: 'conf' bedeutet Aufruf mit "-c dhcpd_alt.conf"</i></font>
  <font color="#C0C0C0"><i># Bsp.: 'conf' bedeutet Aufruf mit "-c dhcpd_alt.conf"</i></font>
Zeile 63: Zeile 64:
   'conf=s'      => \$conf,        <font color="#C0C0C0"><i># Pfad fuer alte dhcpd.conf</i></font>
   'conf=s'      => \$conf,        <font color="#C0C0C0"><i># Pfad fuer alte dhcpd.conf</i></font>
   'leases=s'    => \$leases);    <font color="#C0C0C0"><i># Pfad fuer alte dhcpd.leases</i></font>
   'leases=s'    => \$leases);    <font color="#C0C0C0"><i># Pfad fuer alte dhcpd.leases</i></font>
 
  <font color="#C0C0C0"><i># wenn Regex uebergeben, dann wird Voreinstellung ueberschrieben</i></font>
  <font color="#C0C0C0"><i># wenn Regex uebergeben, dann wird Voreinstellung ueberschrieben</i></font>
  if (defined($reg)) { $regex = $reg }
  if (defined($reg)) { $regex = $reg }
 
  <font color="#C0C0C0"><i># wenn leases-Datei uebergeben, dann wird Voreinstellung ueberschrieben</i></font>
  <font color="#C0C0C0"><i># wenn leases-Datei uebergeben, dann wird Voreinstellung ueberschrieben</i></font>
  if (defined($leases)) { $leasedatei = $leases }
  if (defined($leases)) { $leasedatei = $leases }
 
 
  <font color="#C0C0C0"><i># ------- 2. Schritt: Einlesen der Daten ------------------------</i></font>
  <font color="#C0C0C0"><i># ------- 2. Schritt: Einlesen der Daten ------------------------</i></font>
 
  <font color="#C0C0C0"><i># wenn eine conf-Datei uebergeben wurde, dann wird diese genommen</i></font>
  <font color="#C0C0C0"><i># wenn eine conf-Datei uebergeben wurde, dann wird diese genommen</i></font>
  if (defined($conf)) {
  if (defined($conf)) {
Zeile 79: Zeile 80:
   @daten  = &einlesen_leases($leasedatei)
   @daten  = &einlesen_leases($leasedatei)
  }
  }
 
  <font color="#C0C0C0"><i># ------- 3. Schritt: Vernichten von Doubletten -----------------</i></font>
  <font color="#C0C0C0"><i># ------- 3. Schritt: Vernichten von Doubletten -----------------</i></font>
 
  <font color="#C0C0C0"><i># bei der dhcpd.leases ist es bei kurzer LEASE-Time normal,</i></font>
  <font color="#C0C0C0"><i># bei der dhcpd.leases ist es bei kurzer LEASE-Time normal,</i></font>
  <font color="#C0C0C0"><i># dass fuer einen Rechner mehrere Eintraege (Doubletten) stehen</i></font>
  <font color="#C0C0C0"><i># dass fuer einen Rechner mehrere Eintraege (Doubletten) stehen</i></font>
  <font color="#C0C0C0"><i># sicherheitshalber vernichten wir in Bezug auf die MAC und Namen</i></font>
  <font color="#C0C0C0"><i># sicherheitshalber vernichten wir in Bezug auf die MAC und Namen</i></font>
  @daten  = &vernichte_Doubletten(@daten);
  @daten  = &vernichte_Doubletten(@daten);
 
 
  <font color="#C0C0C0"><i># ------- 4. Schritt: Bestimmen der Gruppen ---------------------</i></font>
  <font color="#C0C0C0"><i># ------- 4. Schritt: Bestimmen der Gruppen ---------------------</i></font>
 
  <font color="#C0C0C0"><i># mit Hilfe der Regex versuchen wir die Gruppen zu bestimmen</i></font>
  <font color="#C0C0C0"><i># mit Hilfe der Regex versuchen wir die Gruppen zu bestimmen</i></font>
  <font color="#C0C0C0"><i># mit diesen (temporaeren) Namen ueberschreiben wir das 4. Feld</i></font>
  <font color="#C0C0C0"><i># mit diesen (temporaeren) Namen ueberschreiben wir das 4. Feld</i></font>
  @daten  = &bestimme_Gruppen($regex,@daten);
  @daten  = &bestimme_Gruppen($regex,@daten);
  $liste  = &bestimme_Gruppenliste(@daten);
  $liste  = &bestimme_Gruppenliste(@daten);
 
 
  <font color="#C0C0C0"><i># ------- 5. Schritt: Reihenfolge bestimmen ---------------------</i></font>
  <font color="#C0C0C0"><i># ------- 5. Schritt: Reihenfolge bestimmen ---------------------</i></font>
 
  <font color="#C0C0C0"><i># die Daten werden jetzt folgendermassen sortiert: die Gruppen</i></font>
  <font color="#C0C0C0"><i># die Daten werden jetzt folgendermassen sortiert: die Gruppen</i></font>
  <font color="#C0C0C0"><i># werden entsprechend der Anzahl der PCs sortiert und innerhalb</i></font>
  <font color="#C0C0C0"><i># werden entsprechend der Anzahl der PCs sortiert und innerhalb</i></font>
  <font color="#C0C0C0"><i># der Gruppe alphabetisch nach dem Rechnernamen</i></font>
  <font color="#C0C0C0"><i># der Gruppe alphabetisch nach dem Rechnernamen</i></font>
  ($liste,@daten) = &sortieren($liste,@daten);
  ($liste,@daten) = &sortieren($liste,@daten);
 
 
  <font color="#C0C0C0"><i># ------- 6. Schritt: Gruppennamem vergeben -------------------</i></font>
  <font color="#C0C0C0"><i># ------- 6. Schritt: Gruppennamem vergeben -------------------</i></font>
 
  <font color="#C0C0C0"><i># es wird in gleicher Reihenfolge der temp. Namen ein Name generiert</i></font>
  <font color="#C0C0C0"><i># es wird in gleicher Reihenfolge der temp. Namen ein Name generiert</i></font>
  $liste2  = &generiere_Gruppennamen($name,$liste);
  $liste2  = &generiere_Gruppennamen($name,$liste);
  <font color="#C0C0C0"><i># es wird das 4. Feld von @daten ueberschrieben</i></font>
  <font color="#C0C0C0"><i># es wird das 4. Feld von @daten ueberschrieben</i></font>
  @daten  = &setze_Gruppenname($liste,$liste2,$namen,@daten);
  @daten  = &setze_Gruppenname($liste,$liste2,$namen,@daten);
 
 
  <font color="#C0C0C0"><i># ------- 7. Schritt: IP vergeben -------------------------------</i></font>
  <font color="#C0C0C0"><i># ------- 7. Schritt: IP vergeben -------------------------------</i></font>
 
  <font color="#C0C0C0"><i># es wird das 1. Feld @daten ueberschrieben</i></font>
  <font color="#C0C0C0"><i># es wird das 1. Feld @daten ueberschrieben</i></font>
  unless (defined($conf) or defined($leases)) {
  unless (defined($conf) or defined($leases)) {
   @daten  = &setze_ip(@daten)
   @daten  = &setze_ip(@daten)
  }
  }
 
  <font color="#C0C0C0"><i># ------- 8. Schritt: Schreiben der Datei 'computer' ------------</i></font>
  <font color="#C0C0C0"><i># ------- 8. Schritt: Schreiben der Datei 'computer' ------------</i></font>
 
  &schreibe_datei($datei,@daten);
  &schreibe_datei($datei,@daten);
 
  print "\n";
  print "\n";
 
  unless (defined($namen)) {
  unless (defined($namen)) {
   print 'Es wurden die Namen Raum01, Raum02, ... vergeben'."\n";
   print 'Es wurden die Namen Raum01, Raum02, ... vergeben'."\n";
Zeile 132: Zeile 133:
   print "bin fertig! \n"
   print "bin fertig! \n"
  }
  }
 
 
 
  <font color="#C0C0C0"><i># =================== Funktionen ================================</i></font>
  <font color="#C0C0C0"><i># =================== Funktionen ================================</i></font>
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: Liest die dhcpd.leases ein und erstellt eine Datenliste</i></font>
  <font color="#C0C0C0"><i># Funktion: Liest die dhcpd.leases ein und erstellt eine Datenliste</i></font>
Zeile 149: Zeile 150:
  sub einlesen_leases {
  sub einlesen_leases {
   my $datei = shift;              <font color="#C0C0C0"><i># Pfad zur lease-Datei</i></font>
   my $datei = shift;              <font color="#C0C0C0"><i># Pfad zur lease-Datei</i></font>
 
   my ($hostname, $mac, $ip, @daten, @temp);
   my ($hostname, $mac, $ip, @daten, @temp);
 
   <font color="#C0C0C0"><i># die Datei einlesen</i></font>
   <font color="#C0C0C0"><i># die Datei einlesen</i></font>
   open (DATEI,'<'.$datei) or die "die Datei wurde nicht gefunden";
   open (DATEI,'<'.$datei) or die "die Datei wurde nicht gefunden";
   @daten = <DATEI>;
   @daten = <DATEI>;
   close DATEI;
   close DATEI;
 
   foreach my $zeile (@daten) {
   foreach my $zeile (@daten) {
     if ($zeile =~ /lease\s+(\d+\.\d+\.\d+\.\d+)/i) { $ip = $1 }
     if ($zeile =~ /lease\s+(\d+\.\d+\.\d+\.\d+)/i) { $ip = $1 }
Zeile 168: Zeile 169:
     }
     }
   }
   }
 
   return @temp;
   return @temp;
  }
  }
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: Liest alte(!) dhcpd.conf ein und erstellt eine Datenliste</i></font>
  <font color="#C0C0C0"><i># Funktion: Liest alte(!) dhcpd.conf ein und erstellt eine Datenliste</i></font>
Zeile 184: Zeile 185:
  sub einlesen_conf {
  sub einlesen_conf {
   my $datei = shift;              <font color="#C0C0C0"><i># Pfad zur lease-Datei</i></font>
   my $datei = shift;              <font color="#C0C0C0"><i># Pfad zur lease-Datei</i></font>
 
   my ($hostname, $mac, $ip, @daten, @temp, @tmp);
   my ($hostname, $mac, $ip, @daten, @temp, @tmp);
 
   <font color="#C0C0C0"><i># die Datei einlesen</i></font>
   <font color="#C0C0C0"><i># die Datei einlesen</i></font>
   open (DATEI,'<'.$datei) or die "die Datei $datei wurde nicht gefunden \n$!";
   open (DATEI,'<'.$datei) or die "die Datei $datei wurde nicht gefunden \n$!";
   @daten = <DATEI>;
   @daten = <DATEI>;
   close DATEI;
   close DATEI;
 
   <font color="#C0C0C0"><i># wir vernichten jetzt alle Kommentar</i></font>
   <font color="#C0C0C0"><i># wir vernichten jetzt alle Kommentar</i></font>
   @temp = @tmp = ();
   @temp = @tmp = ();
Zeile 203: Zeile 204:
   }
   }
   @daten = @temp;
   @daten = @temp;
 
   <font color="#C0C0C0"><i># jetzt holen wir uns die Daten</i></font>
   <font color="#C0C0C0"><i># jetzt holen wir uns die Daten</i></font>
   $hostname = $mac = $ip = "";
   $hostname = $mac = $ip = "";
Zeile 223: Zeile 224:
     }
     }
   }
   }
 
   return @temp;
   return @temp;
  }
  }
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: vernichtet die Doubletten bzgl. MAC und Name</i></font>
  <font color="#C0C0C0"><i># Funktion: vernichtet die Doubletten bzgl. MAC und Name</i></font>
Zeile 237: Zeile 238:
  sub vernichte_Doubletten {
  sub vernichte_Doubletten {
   my @daten = @_;
   my @daten = @_;
 
   my @temp = ();
   my @temp = ();
   my %h    = ();
   my %h    = ();
   my ($pc,$ip,$mac,$gruppe);
   my ($pc,$ip,$mac,$gruppe);
 
   <font color="#C0C0C0"><i># jeder Datensatz kommt in den Hash %h: $h{$mac} -> Datensatz</i></font>
   <font color="#C0C0C0"><i># jeder Datensatz kommt in den Hash %h: $h{$mac} -> Datensatz</i></font>
   foreach my $datensatz (@daten) {
   foreach my $datensatz (@daten) {
Zeile 251: Zeile 252:
     push @temp, $h{$ds}
     push @temp, $h{$ds}
   }
   }
 
   <font color="#C0C0C0"><i># jeder Datensatz kommt in den Hash %h: $h{$pc} -> Datensatz</i></font>
   <font color="#C0C0C0"><i># jeder Datensatz kommt in den Hash %h: $h{$pc} -> Datensatz</i></font>
   %h    = ();
   %h    = ();
Zeile 263: Zeile 264:
     push @daten, $h{$rechner}
     push @daten, $h{$rechner}
   }
   }
 
   return @daten
   return @daten
  }
  }
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: Ermittelt temporaeren Gruppennamen, schreibt ins 4. Feld</i></font>
  <font color="#C0C0C0"><i># Funktion: Ermittelt temporaeren Gruppennamen, schreibt ins 4. Feld</i></font>
Zeile 280: Zeile 281:
   my $regex = shift;              <font color="#C0C0C0"><i># die Regex uebergeben</i></font>
   my $regex = shift;              <font color="#C0C0C0"><i># die Regex uebergeben</i></font>
   my @liste = @_;                  <font color="#C0C0C0"><i># es wird @daten uebergeben</i></font>
   my @liste = @_;                  <font color="#C0C0C0"><i># es wird @daten uebergeben</i></font>
 
   my ($pc,$ip,$mac,$gruppe,@temp);
   my ($pc,$ip,$mac,$gruppe,@temp);
 
   foreach my $datensatz (@liste) {
   foreach my $datensatz (@liste) {
     ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
     ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
Zeile 292: Zeile 293:
     push @temp, $ip.','.$pc.','.$mac.','.$gruppe
     push @temp, $ip.','.$pc.','.$mac.','.$gruppe
   }
   }
 
   return @temp
   return @temp
  }
  }
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: Ermittelt eine doublettenfreie Liste der Gruppennamen</i></font>
  <font color="#C0C0C0"><i># Funktion: Ermittelt eine doublettenfreie Liste der Gruppennamen</i></font>
Zeile 306: Zeile 307:
  sub bestimme_Gruppenliste {
  sub bestimme_Gruppenliste {
   my @daten = @_;
   my @daten = @_;
 
   my $liste = "";
   my $liste = "";
   my ($pc,$ip,$mac,$gruppe,%h);
   my ($pc,$ip,$mac,$gruppe,%h);
 
   foreach my $datensatz (@daten) {
   foreach my $datensatz (@daten) {
     ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
     ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
     $h{$gruppe} = 1;              <font color="#C0C0C0"><i># Gruppenname in den Hash</i></font>
     $h{$gruppe} = 1;              <font color="#C0C0C0"><i># Gruppenname in den Hash</i></font>
   }
   }
 
   foreach my $x (keys %h) {
   foreach my $x (keys %h) {
     $liste .= $x.',' ;
     $liste .= $x.',' ;
   }
   }
   chop($liste);                    <font color="#C0C0C0"><i># das letzte Komma weg</i></font>
   chop($liste);                    <font color="#C0C0C0"><i># das letzte Komma weg</i></font>
 
   return $liste
   return $liste
  }
  }
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: sortiert $liste und @daten (nach Anzahl der PCs)</i></font>
  <font color="#C0C0C0"><i># Funktion: sortiert $liste und @daten (nach Anzahl der PCs)</i></font>
Zeile 336: Zeile 337:
   my $liste = shift;
   my $liste = shift;
   my @daten = @_;
   my @daten = @_;
 
   my ($pc,$ip,$mac,$gruppe);      <font color="#C0C0C0"><i># zum Zerlegen des Datensatzes</i></font>
   my ($pc,$ip,$mac,$gruppe);      <font color="#C0C0C0"><i># zum Zerlegen des Datensatzes</i></font>
   my (@gruppen,%h,%anz);          <font color="#C0C0C0"><i># Gruppen, Hash auf DS und Anzahl</i></font>
   my (@gruppen,%h,%anz);          <font color="#C0C0C0"><i># Gruppen, Hash auf DS und Anzahl</i></font>
   my (@tmp,@tmp2,@tmp3,%namen);
   my (@tmp,@tmp2,@tmp3,%namen);
 
   <font color="#C0C0C0"><i># den String zerlegen, damit wir auf jede Gruppe zugreifen koennen</i></font>
   <font color="#C0C0C0"><i># den String zerlegen, damit wir auf jede Gruppe zugreifen koennen</i></font>
   @gruppen = split ',', $liste;
   @gruppen = split ',', $liste;
 
   <font color="#C0C0C0"><i># wir legen jetzt fuer jede Gruppe eine Liste an und erzeugen</i></font>
   <font color="#C0C0C0"><i># wir legen jetzt fuer jede Gruppe eine Liste an und erzeugen</i></font>
   <font color="#C0C0C0"><i># einen Hash %h mit $h{Gruppenname} -> Zeiger auf die Liste</i></font>
   <font color="#C0C0C0"><i># einen Hash %h mit $h{Gruppenname} -> Zeiger auf die Liste</i></font>
Zeile 356: Zeile 357:
     $h{$gr} = \@temp;
     $h{$gr} = \@temp;
   }
   }
 
   <font color="#C0C0C0"><i># wir holen uns von jeder Gruppe die Anzahl und erzeugen</i></font>
   <font color="#C0C0C0"><i># wir holen uns von jeder Gruppe die Anzahl und erzeugen</i></font>
   <font color="#C0C0C0"><i># einen Hash %anz mit $anz{Gruppenname} -> Anzahl</i></font>
   <font color="#C0C0C0"><i># einen Hash %anz mit $anz{Gruppenname} -> Anzahl</i></font>
Zeile 364: Zeile 365:
     $anz{$gr} = $anz
     $anz{$gr} = $anz
   }
   }
 
   <font color="#C0C0C0"><i># eine sortierte Liste der Gruppen erzeugen (groesste zuerst)</i></font>
   <font color="#C0C0C0"><i># eine sortierte Liste der Gruppen erzeugen (groesste zuerst)</i></font>
   @gruppen = sort {$anz{$b} <=> $anz{$a} or lc($a) cmp lc($b)} keys %anz;
   @gruppen = sort {$anz{$b} <=> $anz{$a} or lc($a) cmp lc($b)} keys %anz;
 
   <font color="#C0C0C0"><i># wir basteln aus der Liste einen String, Trennzeichen Komma</i></font>
   <font color="#C0C0C0"><i># wir basteln aus der Liste einen String, Trennzeichen Komma</i></font>
   $liste = "";                    <font color="#C0C0C0"><i># initialisieren</i></font>
   $liste = "";                    <font color="#C0C0C0"><i># initialisieren</i></font>
Zeile 374: Zeile 375:
   }                                <font color="#C0C0C0"><i># das letzte Komma wieder weg</i></font>
   }                                <font color="#C0C0C0"><i># das letzte Komma wieder weg</i></font>
   chop($liste);                    <font color="#C0C0C0"><i># -> unser erster Rueckgabewert</i></font>
   chop($liste);                    <font color="#C0C0C0"><i># -> unser erster Rueckgabewert</i></font>
 
   <font color="#C0C0C0"><i># wir sortieren jetzt jede Gruppe nach dem Rechnernamen</i></font>
   <font color="#C0C0C0"><i># wir sortieren jetzt jede Gruppe nach dem Rechnernamen</i></font>
   @tmp2 = ();
   @tmp2 = ();
Zeile 380: Zeile 381:
     my $ref = $h{$gr};
     my $ref = $h{$gr};
     @tmp = @$ref;
     @tmp = @$ref;
 
     <font color="#C0C0C0"><i># fuer jeden Datensatz dieser Gruppe</i></font>
     <font color="#C0C0C0"><i># fuer jeden Datensatz dieser Gruppe</i></font>
     %namen = ();
     %namen = ();
Zeile 389: Zeile 390:
       $namen{$pc} = $datensatz;
       $namen{$pc} = $datensatz;
     }
     }
 
     <font color="#C0C0C0"><i># fuer jeden Rechnernamen dieser Gruppe hole den Datensatz</i></font>
     <font color="#C0C0C0"><i># fuer jeden Rechnernamen dieser Gruppe hole den Datensatz</i></font>
     @tmp3 = ();
     @tmp3 = ();
Zeile 395: Zeile 396:
         push @tmp3, $namen{$pc}
         push @tmp3, $namen{$pc}
     }
     }
 
     push @tmp2, @tmp3
     push @tmp2, @tmp3
   }
   }
 
   return ($liste,@tmp2)
   return ($liste,@tmp2)
  }
  }
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: es wird der Gruppenname generiert (RaumXX)</i></font>
  <font color="#C0C0C0"><i># Funktion: es wird der Gruppenname generiert (RaumXX)</i></font>
Zeile 415: Zeile 416:
   my $name  = shift;
   my $name  = shift;
   my $liste = shift;
   my $liste = shift;
 
   my $liste2 = "";
   my $liste2 = "";
   my @gruppe = ();
   my @gruppe = ();
   my $zaehler = 1;
   my $zaehler = 1;
 
   <font color="#C0C0C0"><i># wir bauen den Formatstring</i></font>
   <font color="#C0C0C0"><i># wir bauen den Formatstring</i></font>
   my ($temp,$anz) = split ':', $name;
   my ($temp,$anz) = split ':', $name;
   my $string  = '%0'.$anz.'u';
   my $string  = '%0'.$anz.'u';
 
   <font color="#C0C0C0"><i># wir zerlegen den String $liste in eine echte Liste</i></font>
   <font color="#C0C0C0"><i># wir zerlegen den String $liste in eine echte Liste</i></font>
   @gruppe = split ',' , $liste;
   @gruppe = split ',' , $liste;
 
   <font color="#C0C0C0"><i># nun erzeugen wir die Namensliste</i></font>
   <font color="#C0C0C0"><i># nun erzeugen wir die Namensliste</i></font>
   foreach my $gruppe (@gruppe) {
   foreach my $gruppe (@gruppe) {
Zeile 434: Zeile 435:
   }
   }
   chop ($liste2);
   chop ($liste2);
 
   return $liste2
   return $liste2
  }
  }
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: # es wird das 4. Feld von @daten ueberschrieben</i></font>
  <font color="#C0C0C0"><i># Funktion: # es wird das 4. Feld von @daten ueberschrieben</i></font>
Zeile 451: Zeile 452:
   my $namen  = shift;
   my $namen  = shift;
   my @daten  = @_;
   my @daten  = @_;
 
   my ($ip,$pc,$mac,$gruppe);
   my ($ip,$pc,$mac,$gruppe);
 
   my @neu    = ();
   my @neu    = ();
   my %namen  = ();
   my %namen  = ();
Zeile 462: Zeile 463:
     @neuername = split ',', $namen
     @neuername = split ',', $namen
   }
   }
 
   my $help1 = "";
   my $help1 = "";
   my $help2 = "";
   my $help2 = "";
 
   foreach my $name (@tempnamen) {
   foreach my $name (@tempnamen) {
     $help1 = shift @gen_name;
     $help1 = shift @gen_name;
Zeile 475: Zeile 476:
     }
     }
   }
   }
 
   foreach my $datensatz (@daten) {
   foreach my $datensatz (@daten) {
     ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
     ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
Zeile 483: Zeile 484:
     push @neu, $ip.','.$pc.','.$mac.','.$gruppe;
     push @neu, $ip.','.$pc.','.$mac.','.$gruppe;
   }
   }
 
   return @neu;
   return @neu;
  }
  }
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: setzt die IP-Werte nach der Vorgabe im Wiki</i></font>
  <font color="#C0C0C0"><i># Funktion: setzt die IP-Werte nach der Vorgabe im Wiki</i></font>
Zeile 496: Zeile 497:
  sub setze_ip {
  sub setze_ip {
   my @daten = @_;
   my @daten = @_;
 
   my $gr = "";
   my $gr = "";
   my ($pc,$ip,$mac,$gruppe,@temp);
   my ($pc,$ip,$mac,$gruppe,@temp);
 
   my $start1 = undef;
   my $start1 = undef;
   my $start2 = 21;
   my $start2 = 21;
 
   my $ip1 = $start1;
   my $ip1 = $start1;
   my $ip2 = $start2;
   my $ip2 = $start2;
 
   <font color="#C0C0C0"><i># fuer jeden Datensatz tue</i></font>
   <font color="#C0C0C0"><i># fuer jeden Datensatz tue</i></font>
   foreach my $datensatz (@daten) {
   foreach my $datensatz (@daten) {
Zeile 521: Zeile 522:
       $ip2++
       $ip2++
     }
     }
 
     push @temp, '192.168.'.$ip1.'.'.$ip2.','.$pc.','.$mac.','.$gruppe;
     push @temp, '192.168.'.$ip1.'.'.$ip2.','.$pc.','.$mac.','.$gruppe;
   }
   }
 
   return @temp
   return @temp
  }
  }
 
 
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i>#--------------------------------------------------------------------</i></font>
  <font color="#C0C0C0"><i># Funktion: schreibt die gesuchte Datei (normalerweise 'computer')</i></font>
  <font color="#C0C0C0"><i># Funktion: schreibt die gesuchte Datei (normalerweise 'computer')</i></font>
Zeile 540: Zeile 541:
   my $datei = shift;
   my $datei = shift;
   my @daten = @_;
   my @daten = @_;
 
   open (DATEI, ">$datei") or die "konnte Datei $datei nicht oeffnen $!";
   open (DATEI, ">$datei") or die "konnte Datei $datei nicht oeffnen $!";
   foreach my $datensatz (@daten) {
   foreach my $datensatz (@daten) {
Zeile 547: Zeile 548:
   close DATEI
   close DATEI
  }
  }
 
 
   
   




Achja, ich programmiere nicht auf Arktur 4, deshalb im Konfigurationsteil die Pfade anpassen
Achja, ich programmiere nicht auf Arktur 4, deshalb im Konfigurationsteil die Pfade anpassen
--[[Benutzer:Kirmse|Kirmse]] 22:20, 25. Okt 2005 (CEST)

Version vom 25. Oktober 2005, 20:30 Uhr

Quelltext

einfach mit der Maus runterkratzen :)


#!/usr/bin/perl -w

use strict;                        # Variablen -> deklariert sein
use Getopt::Long;                  # fuer Kommandozeilenparameter


# ------------------- Konfigurationsbereich ---------------------

# hier wird der Pfad zur Datei "dhcpd.leases" eingetragen. Diese
# Voreinstellung gilt für Arktur 4, wird aber ueber schrieben,
# wenn man mit Kommandozeilenparameter -f eine Datei uebergibt
my $leasedatei = "dhcpd.leases";

# hier die Bildungsvorschrift fuer den Namen als Regex uebergeben
# diese Voreinstellung bedeutet, dass am Ende die Rechnernummer
# erwartet wird und davor der Raumname. Hinweis: die erste Klammer
# muss der Raumname sein
my $regex = '(.*\D)\d+';

# hier wird die Standardbezeichnung für die Gruppierung festgelegt
# dabei werden die Gruppierungen hochgezaehlt und an diesen Namen
# die Nummer standardmaessig als zweistellige Zahl angehangen.
# die Stelligkeit muss durch eine nachgestellte Zahl hinter dem
# Doppelpunkt angegeben werden z.B. Raum:3 bedeutet Raum007
# diese Standardbezeichnung kann durch eine Liste hinter dem
# Parameter -n oder -name ueberschrieben werden.
my $name   = 'Raum:2';


# ------------------- Initialisierungsbereich -------------------

# Deklaration der globalen Variablen
my @daten = ();                    # Element = Zeile von 'computer'
my @temp1 = ();                    # Daten vom 1. File
my @temp2 = ();                    # Daten vom 2. File
my $liste = "";                    # String mit temp.Gruppennamen
my $liste2 = "";                   # String mit gener. Gruppennamen
my %gruppen = ();                  # Gruppenname => \@Gruppe
my $datei = "computer";            # Daten nicht ok, dann .= '.not_okay'
my $startwerte = 20;               # Initialisierung fuer IP

# Deklaration Variablen für Parameter, wenn kein Schalter: undef
my $namen;                         # Namensliste als String (Komma)
my $reg;                           # Regex fuer Bildungsvorschrift
my $conf;                          # alte dhcpd.conf
my $leases;                        # alte dhcpd.leases


# =================== Hauptprogramm =============================

# ------- 1. Schritt: Kommandozeilenparameter uebernehmen -------

# hier werden die Zuordnungen fuer die Parameter erstellt
# Bsp.: 'conf' bedeutet Aufruf mit "-c dhcpd_alt.conf"
GetOptions (                       # Parameter fuer:
  'namen=s'      => \$namen,       # Namensliste
  'regex=s'      => \$reg,         # Regex
  'conf=s'       => \$conf,        # Pfad fuer alte dhcpd.conf
  'leases=s'     => \$leases);     # Pfad fuer alte dhcpd.leases

# wenn Regex uebergeben, dann wird Voreinstellung ueberschrieben
if (defined($reg)) { $regex = $reg }

# wenn leases-Datei uebergeben, dann wird Voreinstellung ueberschrieben
if (defined($leases)) { $leasedatei = $leases }


# ------- 2. Schritt: Einlesen der Daten ------------------------

# wenn eine conf-Datei uebergeben wurde, dann wird diese genommen
if (defined($conf)) {
  @daten   = &einlesen_conf($conf)
} else {
  @daten   = &einlesen_leases($leasedatei)
}

# ------- 3. Schritt: Vernichten von Doubletten -----------------

# bei der dhcpd.leases ist es bei kurzer LEASE-Time normal,
# dass fuer einen Rechner mehrere Eintraege (Doubletten) stehen
# sicherheitshalber vernichten wir in Bezug auf die MAC und Namen
@daten   = &vernichte_Doubletten(@daten);


# ------- 4. Schritt: Bestimmen der Gruppen ---------------------

# mit Hilfe der Regex versuchen wir die Gruppen zu bestimmen
# mit diesen (temporaeren) Namen ueberschreiben wir das 4. Feld
@daten   = &bestimme_Gruppen($regex,@daten);
$liste   = &bestimme_Gruppenliste(@daten);


# ------- 5. Schritt: Reihenfolge bestimmen ---------------------

# die Daten werden jetzt folgendermassen sortiert: die Gruppen
# werden entsprechend der Anzahl der PCs sortiert und innerhalb
# der Gruppe alphabetisch nach dem Rechnernamen
($liste,@daten) = &sortieren($liste,@daten);


# ------- 6. Schritt: Gruppennamem vergeben -------------------

# es wird in gleicher Reihenfolge der temp. Namen ein Name generiert
$liste2  = &generiere_Gruppennamen($name,$liste);
# es wird das 4. Feld von @daten ueberschrieben
@daten  = &setze_Gruppenname($liste,$liste2,$namen,@daten);


# ------- 7. Schritt: IP vergeben -------------------------------

# es wird das 1. Feld @daten ueberschrieben
unless (defined($conf) or defined($leases)) {
  @daten  = &setze_ip(@daten)
}

# ------- 8. Schritt: Schreiben der Datei 'computer' ------------

&schreibe_datei($datei,@daten);

print "\n";

unless (defined($namen)) {
  print 'Es wurden die Namen Raum01, Raum02, ... vergeben'."\n";
  print 'Als temporaere Namen wurden in dieser Reihenfolge ermittelt:'."\n\n";
  print $liste."\n"
} else {
  print "bin fertig! \n"
}



# =================== Funktionen ================================


#--------------------------------------------------------------------
# Funktion: Liest die dhcpd.leases ein und erstellt eine Datenliste
# Aufruf:   @daten = &einlesen_leases($pfad);
# Input:    Pfad zur Datei dhcpd.leases
# Output:   Liste von Strings: IP, Rechnername, MAC, Gruppe
# Bemerk.:  Es wird dieses File (siehe bei Input) eingelesen
# Bemerk.:  die Gruppe ist einfach der String 'Raum'
# Update:   24.10.2005
#--------------------------------------------------------------------
sub einlesen_leases {
  my $datei = shift;               # Pfad zur lease-Datei

  my ($hostname, $mac, $ip, @daten, @temp);

  # die Datei einlesen
  open (DATEI,'<'.$datei) or die "die Datei wurde nicht gefunden";
  @daten = <DATEI>;
  close DATEI;

  foreach my $zeile (@daten) {
    if ($zeile =~ /lease\s+(\d+\.\d+\.\d+\.\d+)/i) { $ip = $1 }
    if ($zeile =~ /client-hostname\s*"?(\S*)";?/i) { $hostname = $1 }
    if ($zeile =~ /ethernet\s+(\w+:\w+:\w+:\w+:\w+:\w+)/) { $mac = $1 }
    if ($zeile =~ /}/ and defined($ip)) {
      # sichern die Werte in die Liste @pcs
      push @temp, $ip.','.$hostname.','.$mac.',Raum';
      # wir initialisieren die Variablen neu
      $hostname = $mac = $ip = "";
    }
  }

  return @temp;
}


#--------------------------------------------------------------------
# Funktion: Liest alte(!) dhcpd.conf ein und erstellt eine Datenliste
# Aufruf:   @daten = &einlesen_conf($pfad);
# Input:    Pfad zu einer Datei dhcpd.conf
# Output:   Liste von Strings: IP, Rechnername, MAC, Gruppe
# Bemerk.:  Es wird dieses File (siehe bei Input) eingelesen
# Bemerk.:  die Gruppe ist einfach der String 'Raum'
# Update:   24.10.2005
#--------------------------------------------------------------------
sub einlesen_conf {
  my $datei = shift;               # Pfad zur lease-Datei

  my ($hostname, $mac, $ip, @daten, @temp, @tmp);

  # die Datei einlesen
  open (DATEI,'<'.$datei) or die "die Datei $datei wurde nicht gefunden \n$!";
  @daten = <DATEI>;
  close DATEI;

  # wir vernichten jetzt alle Kommentar
  @temp = @tmp = ();
  foreach my $zeile (@daten) {
    if ($zeile =~ /#/) {
      @tmp = split '#', $zeile;
      push @temp, $tmp[0]."\n"
    } else {
      push @temp, $zeile
    }
  }
  @daten = @temp;

  # jetzt holen wir uns die Daten
  $hostname = $mac = $ip = "";
  @temp = @tmp = ();
  foreach my $z (@daten) {
    if ($z =~ /host\s+(\S+)\s*{/) { $hostname = $1 };
    if ($z =~ /hardware ethernet\s+(\w+:\w+:\w+:\w+:\w+:\w+)/){$mac = $1}
    if ($z =~ /fixed-address\s/) {
      if ($z =~ /fixed-address\s+(\d+\.\d+\.\d+\.\d+);?/){
        $ip = $1
      } else {
        $ip = '192.168.X.XX'      # falls die IP im DNS steht
      }
    }
    if (($z =~ /}/) and ($mac ne "")) {
      push @temp, $ip.','.$hostname.','.$mac.',Raum';
      # wir initialisieren die Variablen neu
      $hostname = $mac = $ip = "";
    }
  }

  return @temp;
}


#--------------------------------------------------------------------
# Funktion: vernichtet die Doubletten bzgl. MAC und Name
# Aufruf:   @daten = &vernichte_Doubletten(@daten);
# Input:    die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Output:   die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Update:   24.10.2005
#--------------------------------------------------------------------
sub vernichte_Doubletten {
  my @daten = @_;

  my @temp = ();
  my %h    = ();
  my ($pc,$ip,$mac,$gruppe);

  # jeder Datensatz kommt in den Hash %h: $h{$mac} -> Datensatz
  foreach my $datensatz (@daten) {
    ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
    $h{$mac} = $datensatz;
  }
  # und dann wird daraus wieder eine Liste erstellt
  foreach my $ds (keys %h) {
    push @temp, $h{$ds}
  }

  # jeder Datensatz kommt in den Hash %h: $h{$pc} -> Datensatz
  %h    = ();
  foreach my $datensatz (@temp) {
    ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
    $h{$pc} = $datensatz;
  }
  # und dann wird daraus wieder eine Liste erstellt
  @daten = ();
  foreach my $rechner (keys %h) {
    push @daten, $h{$rechner}
  }

  return @daten
}


#--------------------------------------------------------------------
# Funktion: Ermittelt temporaeren Gruppennamen, schreibt ins 4. Feld
# Aufruf:   @daten = &bestimme_Gruppen($regex,@daten);
# Input:    Regex als Bildungsvorschrift fuer den Rechnernamen
# Input:    die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Output:   die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Update:   24.10.2005
#--------------------------------------------------------------------
sub bestimme_Gruppen
{
  my $regex = shift;               # die Regex uebergeben
  my @liste = @_;                  # es wird @daten uebergeben

  my ($pc,$ip,$mac,$gruppe,@temp);

  foreach my $datensatz (@liste) {
    ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
    if ($pc =~ /$regex/i) {        # wir suchen den Gruppenname
      $gruppe = $1
    } else {
      $gruppe = $pc                # sonst den ganzen Rechnername
    }
    push @temp, $ip.','.$pc.','.$mac.','.$gruppe
  }

  return @temp
}


#--------------------------------------------------------------------
# Funktion: Ermittelt eine doublettenfreie Liste der Gruppennamen
# Aufruf:   @liste = &bestimme_Gruppenliste(@daten);
# Input:    die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Output:   der String Gruppe1,Gruppe2,Gruppe3,Gruppe4,...
# Update:   24.10.2005
#--------------------------------------------------------------------
sub bestimme_Gruppenliste {
  my @daten = @_;

  my $liste = "";
  my ($pc,$ip,$mac,$gruppe,%h);

  foreach my $datensatz (@daten) {
    ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
    $h{$gruppe} = 1;               # Gruppenname in den Hash
  }

  foreach my $x (keys %h) {
    $liste .= $x.',' ;
  }
  chop($liste);                    # das letzte Komma weg

  return $liste
}


#--------------------------------------------------------------------
# Funktion: sortiert $liste und @daten (nach Anzahl der PCs)
# Aufruf:   ($liste,@daten) = &sortieren($liste,@daten);
# Input:    der String Gruppe1,Gruppe2,Gruppe3,Gruppe4,...
# Input:    die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Output:   der sortierte String Gruppe1,Gruppe2,Gruppe3,...
# Output:   die sortierte Liste @daten "IP,Rechnername,MAC,Gruppe"
# Update:   24.10.2005
#--------------------------------------------------------------------
sub sortieren {
  my $liste = shift;
  my @daten = @_;

  my ($pc,$ip,$mac,$gruppe);       # zum Zerlegen des Datensatzes
  my (@gruppen,%h,%anz);           # Gruppen, Hash auf DS und Anzahl
  my (@tmp,@tmp2,@tmp3,%namen);

  # den String zerlegen, damit wir auf jede Gruppe zugreifen koennen
  @gruppen = split ',', $liste;

  # wir legen jetzt fuer jede Gruppe eine Liste an und erzeugen
  # einen Hash %h mit $h{Gruppenname} -> Zeiger auf die Liste
  foreach my $gr (@gruppen) {
    my @temp  = ();
    # fuer jeden Datensatz
    foreach my $datensatz (@daten) {
      # zerlege den Datensatz und hole die Gruppe
      ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
      if ($gr eq $gruppe) { push @temp, $datensatz };
    }
    $h{$gr} = \@temp;
  }

  # wir holen uns von jeder Gruppe die Anzahl und erzeugen
  # einen Hash %anz mit $anz{Gruppenname} -> Anzahl
  foreach my $gr (@gruppen) {
    my $ref = $h{$gr};
    my $anz = @$ref;
    $anz{$gr} = $anz
  }

  # eine sortierte Liste der Gruppen erzeugen (groesste zuerst)
  @gruppen = sort {$anz{$b} <=> $anz{$a} or lc($a) cmp lc($b)} keys %anz;

  # wir basteln aus der Liste einen String, Trennzeichen Komma
  $liste = "";                     # initialisieren
  foreach my $element (@gruppen) {
    $liste .= $element.','
  }                                # das letzte Komma wieder weg
  chop($liste);                    # -> unser erster Rueckgabewert

  # wir sortieren jetzt jede Gruppe nach dem Rechnernamen
  @tmp2 = ();
  foreach my $gr (@gruppen) {
    my $ref = $h{$gr};
    @tmp = @$ref;

    # fuer jeden Datensatz dieser Gruppe
    %namen = ();
    foreach my $datensatz (@tmp) {
      # zerlege den Datensatz und hole den Rechnername und erzeuge
      # einen Hash %namen mit $namen{Rechnername} -> Datensatz
      ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
      $namen{$pc} = $datensatz;
    }

    # fuer jeden Rechnernamen dieser Gruppe hole den Datensatz
    @tmp3 = ();
    foreach my $pc (sort keys %namen) {
       push @tmp3, $namen{$pc}
    }

    push @tmp2, @tmp3
  }

  return ($liste,@tmp2)
}


#--------------------------------------------------------------------
# Funktion: es wird der Gruppenname generiert (RaumXX)
# Aufruf:   $liste2  = &generiere_Gruppennamen($name,$liste);
# Input:    der String $name wird im Konfigurationsteil festgelegt
# Input:    die String $liste enthält die sortierten Gruppennamen
# Output:   der String mit Raum01,Raum02,Raum03,...
# Update:   25.10.2005
#--------------------------------------------------------------------
$liste2  = &generiere_Gruppennamen($name,$liste);
sub generiere_Gruppennamen {
  my $name  = shift;
  my $liste = shift;

  my $liste2 = "";
  my @gruppe = ();
  my $zaehler = 1;

  # wir bauen den Formatstring
  my ($temp,$anz) = split ':', $name;
  my $string  = '%0'.$anz.'u';

  # wir zerlegen den String $liste in eine echte Liste
  @gruppe = split ',' , $liste;

  # nun erzeugen wir die Namensliste
  foreach my $gruppe (@gruppe) {
    $temp    = sprintf($string,$zaehler);
    $liste2 .= 'Raum'.$temp.',';
    $zaehler++;
  }
  chop ($liste2);

  return $liste2
}


#--------------------------------------------------------------------
# Funktion: # es wird das 4. Feld von @daten ueberschrieben
# Aufruf:   @daten  = &setze_Gruppenname($liste,$liste2,$namen,@daten);
# Input:    die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Output:   die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Update:   25.10.2005
#--------------------------------------------------------------------
sub setze_Gruppenname {
  my $liste  = shift;
  my $liste2 = shift;
  my $namen  = shift;
  my @daten  = @_;

  my ($ip,$pc,$mac,$gruppe);

  my @neu    = ();
  my %namen  = ();
  my @neuername = ();
  my @tempnamen = split ',', $liste;
  my @gen_name  = split ',', $liste2;
  if (defined($namen)) {
    @neuername = split ',', $namen
  }

  my $help1 = "";
  my $help2 = "";

  foreach my $name (@tempnamen) {
    $help1 = shift @gen_name;
    $help2 = shift @neuername;
    if (defined($help2)) {
      $namen{$name} = $help2
    } else {
      $namen{$name} = $help1
    }
  }

  foreach my $datensatz (@daten) {
    ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
    if (defined($namen{$gruppe})) {
      $gruppe = $namen{$gruppe}
    }
    push @neu, $ip.','.$pc.','.$mac.','.$gruppe;
  }

  return @neu;
}

#--------------------------------------------------------------------
# Funktion: setzt die IP-Werte nach der Vorgabe im Wiki
# Aufruf:   @daten  = &setze_ip(@daten);
# Input:    die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Output:   die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Update:   25.10.2005
#--------------------------------------------------------------------
sub setze_ip {
  my @daten = @_;

  my $gr = "";
  my ($pc,$ip,$mac,$gruppe,@temp);

  my $start1 = undef;
  my $start2 = 21;

  my $ip1 = $start1;
  my $ip2 = $start2;

  # fuer jeden Datensatz tue
  foreach my $datensatz (@daten) {
    # zerlege den Datensatz und hole die Gruppe
    ($ip,$pc,$mac,$gruppe) = split ',', $datensatz;
    if ($gr ne $gruppe) {
      $gr = $gruppe;
      unless (defined($ip1)) {
        $ip1 = 0
      } else {
        $ip1++
      }
      $ip2 = $start2
    } else {
      $ip2++
    }

    push @temp, '192.168.'.$ip1.'.'.$ip2.','.$pc.','.$mac.','.$gruppe;
  }

  return @temp
}


#--------------------------------------------------------------------
# Funktion: schreibt die gesuchte Datei (normalerweise 'computer')
# Aufruf:   &schreibe_datei($datei,@daten);
# Input:    Pfad zur zur schreibenden Datei
# Input:    die Liste @daten aus "IP,Rechnername,MAC,Gruppe"
# Output:   die Datei 'computer' auf die Festpaltte
# Update:   25.10.2005
#--------------------------------------------------------------------
sub schreibe_datei {
  my $datei = shift;
  my @daten = @_;

  open (DATEI, ">$datei") or die "konnte Datei $datei nicht oeffnen $!";
  foreach my $datensatz (@daten) {
    print DATEI $datensatz."\n"
  }
  close DATEI
}




Achja, ich programmiere nicht auf Arktur 4, deshalb im Konfigurationsteil die Pfade anpassen