307 sub to_begin_ro {

   308     # gibt alle zonen mit abgelaufenen keycounter in die liste @begin_ro_list

   309     our @begin_ro_list;

   310     our $master_dir;

   311     our $key_counter_end;

   312     our @new_serial;

   313     my $zone;

   314 

   315     while (<$master_dir/*>) {

   316         chomp( $zone = $_ );

   317         my $key;

   318 

   319         unless (-f "$zone/.keycounter" ) {next;}

   320 

   321         open( KEY, "$zone/.keycounter" ) or die "$zone/.keycounter: $!\n";

   322         $key = <KEY>;

   323         close(KEY);

   324 

   325         # vergleicht den wert aus der keycount-datei mit dem wert aus der

   326         #dnstools.conf (key_counter_end)

   327         if ( $key_counter_end <= $key ) {

   328             $zone =~ s#($master_dir/)(.*)#$2#;

   329             push @begin_ro_list, $zone;

   330         }

   331     }

   332 }

   333 

   334 sub to_end_ro {

   335     # funktion ueberprueft ob ein keyrollover fertig ist

   336     # die bedingung dafuer ist das:

   337     # - eine datei .index.zsk vorhanden ist

   338     # - die datei .index.zsk vor mehr x stunden geaendert wurde

   339     # - die datei .index.zsk ueber mehr als zwei zeilen gross ist

   340     our $master_dir;

   341     our @end_ro_list;

   342     our $ablauf_zeit;

   343     chomp( my $now_time = `date +%s` );

   344 

   345     for (<$master_dir/*>) {

   346         my $zone = $_;

   347         $zone =~ s#($master_dir/)(.*)#$2#;

   348 

   349         my @index = ();

   350         my $index_wc;

   351         my @status;

   352 

   353         # prueft nach der ".index.zsk"-datei und erstellt den zeitpunkt

   354         # an dem das key-rollover endet. - $status[9]

   355         if ( -e "$master_dir/$zone/.index.zsk" ) {

   356             @status = stat("$master_dir/$zone/.index.zsk");

   357             $status[9] += ( 3600 * $ablauf_zeit );

   358         }

   359         else { next; }

   360 

   361         # $status[9] ist der zeitpunkt an dem der key-rollover endet

   362         # prueft ob das key-rollover-ende erreicht ist

   363         unless ( $status[9] < $now_time ) { next;}

   364 

   365         # prueft die anzahl der schluessel in der .index.zsk

   366         open( INDEX, "$master_dir/$zone/.index.zsk" )

   367             or die "$master_dir/$zone/.index.zsk: $!\n";

   368         @index    = <INDEX>;

   369         $index_wc = @index;

   370         close(INDEX);

   371         if ( $index_wc > 1 ) {push @end_ro_list, $zone;}

   372     }

   373 }

   374 

   375 sub begin_ro {

   376     # anfang des key-rollovers

   377     our @begin_ro_list;

   378     our $master_dir;

   379     our @new_serial;

   380 

   381     for ( &del_double( @begin_ro_list ) ) {

   382         #erzeugt zsks

   383         my $zone = $_;

   384         my $zpf   = "$master_dir/$zone";

   385         my @index;

   386 

   387         chdir "$zpf" or die "$zpf: $!\n";

   388         my $keyname = `dnssec-keygen -a RSASHA1 -b 512 -n ZONE $zone`;

   389 

   390         open( INDEX, ".index.zsk" ) or die "$zpf/.index.zsk: $!\n";

   391         @index = <INDEX>;

   392         close(INDEX);

   393 

   394         push @index, $keyname;

   395         if ( @index > 2 ) { shift(@index); }

   396 

   397         open( INDEX, ">.index.zsk" ) or die "$zpf/.index.zsk: $!\n";

   398         print INDEX @index;

   399         close(INDEX);

   400 

   401         chomp($keyname);

   402         print " * $zone: neuer ZSK $keyname erstellt\n";

   403 

   404         open( KC, ">.keycounter" ) or die "$zpf/keycounter: $!\n";

   405         print KC "0";

   406         close(KC);

   407 

   408         &kill_useless_keys($zone);

   409         &key_to_zonefile($zone);

   410         push @new_serial, $zone;

   411     }

   412 }

   413 

   414 sub key_to_zonefile {

   415     our $master_dir;

   416     my $zone = $_[0];

   417     my $zpf = "$master_dir/$zone";

   418     my @old_content;

   419     my @new_content = ();

   420 

   421     open(ZONEFILE, "<$zpf/$zone");

   422     @old_content = <ZONEFILE>;

   423     close(ZONEFILE);

   424 

   425     for (@old_content) {

   426         unless (m#INCLUDE.*key#) { push @new_content, $_; }

   427     }

   428 

   429     for (<$zpf/*>) {

   430         if (m#(.*\/)(K.*\.key)#) {

   431             push @new_content, "\$INCLUDE \"$2\"\n";

   432         }

   433     }

   434     open( ZONEFILE, ">$zpf/$zone" ) or die "$zpf/$zone: $!\n";

   435     print ZONEFILE @new_content;

   436     close(ZONEFILE);

   437 }

   438 

   439 sub kill_useless_keys {

   440     # die funktion loescht alle schluessel die nicht in der index.zsk

   441     # der uebergebenen zone stehen

   442     our $master_dir;

   443     my $zone     = $_[0];

   444     my @keylist  = ();

   445     my $zpf      = "$master_dir/$zone";

   446 

   447     open (INDEX, "<$zpf/.index.zsk") or die "$zpf/.index.zsk: $!\n";

   448     @keylist = <INDEX>;

   449     close(INDEX);

   450     open (INDEX, "<$zpf/.index.ksk") or die "$zpf/.index.ksk: $!\n";

   451     push @keylist, <INDEX>;

   452 

   453     # kuerzt die schluessel-bezeichnung aus der indexdatei auf die id um sie

   454     # besser vergleichen zu koennen.

   455     for ( @keylist ) {

   456         chomp;

   457         s#K.*\+.*\+(.*)#$1#;

   458     }

   459 

   460     # prueft alle schluesseldateien (ksk, zsk) ob sie in der jeweiligen

   461     # indexdatei beschrieben sind. wenn nicht werden sie geloescht.

   462     for (`ls $master_dir/$zone/K*[key,private]`) {

   463         chomp;

   464         my $file = $_;

   465         my $rm_count = 1;

   466         my $keyname;

   467         for (@keylist) {

   468             if ( $file =~ /$_/ ) { $rm_count = 0;}

   469         }

   470         if ($rm_count == 1) {

   471             unlink "$file";

   472             if ($file =~ /$zpf\/(.*\.key)/ ) {

   473                 print " * $zone: Schluessel $1 entfernt \n";

   474             }

   475         }       

   476     }

   477 }

   478 

   479 sub end_ro {

   480     our @end_ro_list;

   481     our $master_dir;

   482     our @new_serial;

   483     my @content;

   484 

   485     for (@end_ro_list) {

   486         my $zone = $_;

   487         my $count = 0;

   488         my @content;

   489         my $last_key;

   490 

   491         open (INDEX, "<$master_dir/$zone/.index.zsk");

   492         @content = <INDEX>;

   493         close(INDEX);

   494 

   495         for (@content) {

   496             $count++;

   497             $last_key = $_;

   498         }

   499         if ($count > 1) {

   500             open (INDEX, ">$master_dir/$zone/.index.zsk");

   501             print INDEX $last_key;

   502             close (INDEX);

   503         }

   504         &kill_useless_keys($zone);

   505         &key_to_zonefile($zone);

   506         push @new_serial, $zone;

   507     }

   508 }

   509 

   515 our @begin_ro_list;  # liste mit zonen deren key-rollover beginnt

   516 our @end_ro_list;    # liste mit zonen deren key-rollover fertig ist

   522 our $key_counter_end = $config{key_counter_end};

   523 our $ablauf_zeit     = $config{abl_zeit};

   528 

   529 &to_begin_ro; # prueft nach beginnenden rollover-verfahren

   530 &to_end_ro; # prueft nach endenden rollover-verfahren

   531 

   532 if (@begin_ro_list) {

   533     &begin_ro; # eine rollover-beginn-sequenz

   534 }

   535 

   536 if (@end_ro_list) {

   537     &end_ro; # eine rollover-end-squenz

   538 }