• merge latest version of rannotate code from corecode
[alioth/cvs.git] / contrib / validate_repo.in
1 #! @PERL@ -w
2 ########################################################################
3 #
4 #  Copyright (c) 2000, 2001 by Donald Sharp <sharpd@cisco.com>
5 #  All Rights Reserved
6 #
7 #  Some portions Copyright (c) 2002, 2003 by
8 #                Derek R. Price <mailto:derek@ximbiot.com>
9 #                & Ximbiot <http://ximbiot.com>.
10 #  All rights reserved.
11 #
12 #  Permission is granted to copy and/or distribute this file, with or
13 #  without modifications, provided this notice is preserved.
14 #
15 #  This program is free software; you can redistribute it and/or modify
16 #  it under the terms of the GNU General Public License as published by
17 #  the Free Software Foundation; either version 2, or (at your option)
18 #  any later version.
19 #
20 #  This program is distributed in the hope that it will be useful,
21 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
22 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23 #  GNU General Public License for more details.
24 #
25 ########################################################################
26
27 =head1 validate_repo.pl
28
29 Script to check the integrity of the Repository.
30
31 =head1 SYNOPSIS
32
33     perldoc validate_repo.pl
34     validate_repo.pl --help [--verbose!]
35     validate_repo.pl [--verbose!] [--cvsroot=CVSROOT] [--exec=SCRIPT]...
36                      [--all-revisions!] [module]...
37
38 =head1 DESCRIPTION
39
40 This script will search through a repository and determine if any of the
41 files in it are corrupted.
42
43 This is normally accomplished by checking out all I<important> revisions, where
44 I<important> revisions are defined as the smallest set which, when checked out,
45 will cause each and every revision's integrity to be verified.  This resolves
46 to the most recent revision on each branch and the first and last revisions on
47 the trunk.
48
49 Please do not run this script inside of the repository itself.  This will cause
50 it too fail.
51
52 =head1 OPTIONS
53
54 =over
55
56 =item C<--help>
57
58 Print this very help text (or, with C<--verbose>, act like
59 C<perldoc validate_repo.pl>).
60
61 =item C<-a> or C<--all-revisions>
62
63 Check out each and every revision rather than just the I<important> ones.
64 This flag is useful with C<--exec> to execute the C<SCRIPT> (from C<--exec>
65 below) on a checked out copy of each and every revision.
66
67 =item C<-d> or C<--cvsroot=CVSROOT>
68
69 Use repository specified by C<CVSROOT>.  Defaults to the contents of the
70 F<./CVS/Root> file when it exists and is readable, then to the contents of the
71 C<$CVSROOT> environment variable when it is set and non-empty.
72
73 =item C<-e> or C<--exec=SCRIPT>
74
75 Execute (as from command prompt) C<SCRIPT> if it exists as a file, is readable,
76 and is executable, or evaluate (as a perl script) C<SCRIPT> for a checked out
77 copy of each I<important> revision of each RCS archive in CVSROOT.  Executed
78 scripts are passed C<CVSROOT FILE REVISION FNO>, where C<CVSROOT> is what
79 you'd think, C<FILE> is the path to the file relative to C<CVSROOT> and
80 suitable for use as an argument to C<cvs co>, C<cvs rlog>, and so on,
81 C<REVISION> is the revision of the checked out file, and C<FNO> is the file
82 number of the open, read-only file descriptor containing the checked out
83 contents of revision C<REVISION> of C<FILE>.  An evaluated C<SCRIPT> will find
84 the same four arguments in the same order in C<@_>, except that C<FNO> will be
85 an open file handle.
86
87 With C<--all-revisions>, execute or evaluate C<SCRIPT> for a checked out
88 version of each revsion in the RCS archive.
89
90 =item C<-v> or C<--verbose>
91
92 Print verbose debugging information (or, when specified with C<--help>, act
93 like C<perldoc validate_repo.pl>).
94
95 =head1 ARGUMENTS
96
97 =over
98
99 =item C<modules>
100
101 The module in the repository to examine.  Defaults to the contents of the
102 F<./CVS/Repository> file when it exists and is readable, then to F<.>
103 (all modules).
104
105 =head1 EXAMPLES
106
107     setenv CVSROOT /release/111/cvs
108     validate_repo.pl
109
110
111     validate_repo.pl -d /another/cvsroot --verbose --exec '
112     system "grep \"This string means Im a bad, bad file!\" <&"
113            . fileno( $_[3] )
114            . ">/dev/null"
115         or die "Revision $_[2] of $_[0]/$_[1],v is bad, bad, bad!"'
116
117 =head1 SEE ALSO
118
119 None.
120
121 =cut
122
123 ######################################################################
124 #                    MODULES                                         #
125 ######################################################################
126 use strict;
127
128 use Fcntl qw( F_GETFD F_SETFD );
129 use File::Find;
130 use File::Basename;
131 use File::Path;
132 use File::Spec;
133 use Getopt::Long;
134 use IO::File;
135 use Pod::Usage;
136
137 ######################################################################
138 #                    GLOBALS                                         #
139 ######################################################################
140
141 use vars qw(
142              $all_revisions
143              $cvsroot
144              @extra_files
145              @ignore_files
146              $ignored_files
147              @invalid_revs
148              @list_of_broken_files
149              @scripts
150              $total_files
151              $total_interesting_revisions
152              $total_revisions
153              $verbose
154            );
155
156
157
158 ######################################################################
159 #                    SUBROUTINES                                     #
160 ######################################################################
161
162 ######################################################################
163 #
164 #    NAME :
165 #      main
166 #
167 #    PURPOSE :
168 #      To search the repository for broken files
169 #
170 #    PARAMETERS :
171 #      NONE
172 #
173 #    GLOBALS :
174 #      $cvsroot              - The CVS repository to search through.
175 #      $ENV{ CVSROOT }       - The default CVS repository to search through.
176 #      @list_of_broken_files - The list of files that need to
177 #                              be fixed.
178 #      $verbose              - is verbose mode on?
179 #      @scripts              - scripts to run on checked out files.
180 #      $total_revisions      - The number of revisions considered
181 #      $total_interesting_revisions - The number of revisions used
182 #      $total_files          - The total number of files looked at.
183 #
184 #    RETURNS :
185 #      A list of broken files
186 #
187 #    COMMENTS :
188 #      Do not run this script inside the repository.  Choose
189 #      a nice safe spot( like /tmp ) outside of the repository.
190 #
191 ######################################################################
192 sub main
193 {
194         my $help;
195
196         $ignored_files = 0;
197         $total_files = 0;
198         $total_interesting_revisions = 0;
199         $total_revisions = 0;
200
201         Getopt::Long::Configure( "bundling" );
202         unless( GetOptions(
203                             'all-revisions|a!' => \$all_revisions,
204                             'cvsroot|d=s' => \$cvsroot,
205                             'exec|e=s' => \@scripts,
206                             'help|h|?!' => \$help,
207                             'verbose|v!' => \$verbose
208                           )
209               )
210         {
211                 pod2usage( 2 );
212                 exit 2;
213         }
214
215         pod2usage( -exitval => 2,
216                    -verbose => $verbose ? 2 : 1,
217                    -output => \*STDOUT )
218                 if $help;
219
220         verbose( "Verbose Mode Turned On\n" );
221
222         if( !$cvsroot && -f "CVS/Root" && -r "CVS/Root" )
223         {
224                 my $file = new IO::File "< CVS/Root";
225                 $cvsroot = $file->getline;
226                 chomp $cvsroot;
227         }
228         $cvsroot = $ENV{'CVSROOT'} unless $cvsroot;
229         pod2usage( "error: Must set CVSROOT" ) unless $cvsroot;
230
231         if( $cvsroot =~ /^:\w+:/ && $cvsroot !~ /^:local:/
232             || $cvsroot =~ /@/ )
233         {
234                 print STDERR "CVSROOT must be :local:\n";
235                 exit 2;
236         }
237
238         for (@scripts)
239         {
240                 $_ = File::Spec->rel2abs( $_ ) unless /\n/ || !-x $_;
241         }
242
243
244         if( !scalar( @ARGV ) && -f "CVS/Repository" && -r "CVS/Repository" )
245         {
246                 my $file = new IO::File "< CVS/Repository";
247                 my $module = $file->getline;
248                 chomp $module;
249                 push @ARGV, $module;
250         }
251
252         push @ARGV, "." unless( scalar @ARGV );
253
254         foreach my $directory_to_look_at ( @ARGV )
255         {
256                 $directory_to_look_at = File::Spec->catfile( $cvsroot,
257                                                              $directory_to_look_at );
258
259                 my $sym_count = 0;
260                 while( -l $directory_to_look_at )
261                 {
262                         $directory_to_look_at = readlink( $directory_to_look_at );
263                         $sym_count += 1;
264                         die( "Encountered too many symlinks for CVSROOT ($cvsroot)\n" )
265                                 if( $sym_count > 5 );
266                 }
267
268                 # Remove indirections.
269                 $directory_to_look_at =~ s#(/+.)*$##o;
270
271                 verbose( "Processing: $directory_to_look_at\n" );
272                 @ignore_files = get_ignore_files_from_cvsroot( $directory_to_look_at );
273                 find( \&process_file, $directory_to_look_at );
274         }
275
276         print "List of corrupted files\n" if @list_of_broken_files;
277         foreach my $broken ( @list_of_broken_files )
278         {
279                 print( "**** File: $broken\n" );
280         }
281
282         print "List of Files containing invalid revisions:\n"
283                 if @invalid_revs;
284         foreach ( @invalid_revs )
285         {
286                 print( "**** File: ($_->{'rev'}) $_->{'file'}\n" );
287         }
288
289         print "List of Files That Don't belong in Repository:\n"
290                 if @extra_files;
291         foreach my $extra ( @extra_files )
292         {
293                 print( "**** File: $extra\n" );
294         }
295         print( "Total Files: $total_files  Corrupted files: "
296                    . scalar( @list_of_broken_files )
297                    . "  Invalid revs: "
298                    . scalar( @invalid_revs )
299                    . "  Extra files: "
300                    . scalar( @extra_files )
301                    . "  Ignored Files: $ignored_files\n" );
302         print( "Total Revisions: $total_revisions  Interesting Revisions: $total_interesting_revisions\n" );
303 }
304
305
306
307 sub verbose
308 {
309         print STDERR @_ if $verbose;
310 }
311
312
313
314 ######################################################################
315 #
316 #    NAME :
317 #      process_file
318 #
319 #    PURPOSE :
320 #      This function is called by the find function, its purpose
321 #      is to decide if it is important to look at a file or not.  When
322 #      a file is important, we log it or call &look_at_cvs_file on it.
323 #
324 #    ALGORITHM
325 #      1) If the file is an archive file, we call &look_at_cvs_file on
326 #         it.
327 #      2) Else, if the file is not in the ignore list, we store its name
328 #         for later.
329 #
330 #    PARAMETERS :
331 #      NONE
332 #
333 #    GLOBALS :
334 #      $cvsroot               - The CVS repository to search through
335 #      @ignore_files          - File patterns we can afford to ignore.
336 #      $File::Find::name      - The absolute path of the file being examined.
337 #
338 #    RETURNS :
339 #      NONE
340 #
341 #    COMMENTS :
342 #      NONE
343 #
344 ######################################################################
345 sub process_file
346 {
347     if( ! -d $File::Find::name )
348         {
349                 my $path = $File::Find::name;
350                 $path =~ s#^$cvsroot/(\./)*##;
351                 $total_files++;
352
353                 verbose( "Examining `$path'\n" );
354
355                 if( $path =~ s/,v$// )
356                 {
357                         look_at_cvs_file( $path );
358                 }
359                 elsif( !grep { $path =~ $_ } @ignore_files )
360                 {
361                         push @extra_files, $path;
362                         verbose( "Adding unrecognized file `$path' to corrupted list.\n" );
363                 }
364                 else
365                 {
366                         $ignored_files++;
367                         verbose( "Ignoring `$path'\n" );
368                 }
369         }
370 }
371
372 ######################################################################
373 #
374 #    NAME :
375 #      look_at_cvs_file
376 #
377 #    PURPOSE :
378 #      To decide if a file is broken or not.  The algorithm is:
379 #      a)  Get the revision history for the file.
380 #              - If that fails the file is broken, save the fact
381 #                and continue processing other files.
382 #              - If that succeeds we have a list of revisions.
383 #      b)  For each revision call &check_revision on the file.
384 #              - If that fails the file is broken, save the fact
385 #                and continue processing other files.
386 #      c)  Continue on 
387 #
388 #    PARAMETERS :
389 #      $file - The path of the file to look at, relative to $cvsroot and
390 #              suitable for use as an argument to `cvs co', `cvs rlog', and
391 #              the rest of CVS's r* commands.
392 #
393 #    GLOBALS :
394 #      NONE
395 #
396 #    RETURNS :
397 #      NONE
398 #
399 #    COMMENTS :
400 #      We have to handle Attic files in a special manner.
401 #      Basically remove the Attic from the string if it
402 #      exists at the end of the $path variable.
403 #
404 ######################################################################
405 sub look_at_cvs_file
406 {
407     my( $file ) = @_;
408     my( $name, $path ) = fileparse( $file );
409
410     $file = $path . $name if $path =~ s#Attic/$##;
411
412     my( $finfo, $rinfo ) = get_history( $file );
413
414     unless( defined $rinfo )
415     {
416         verbose( "\t`$file' is corrupted.  It was determined to contain no\n"
417                          . "\trevisions via a cvs rlog command\n" );
418         push( @list_of_broken_files, $file );
419         return();
420     }
421
422     my @int_revisions =
423                 $all_revisions ? keys %$rinfo
424                        : find_interesting_revisions( keys %$rinfo );
425
426     foreach my $revision ( @int_revisions )
427     {
428         verbose( "\t\tLooking at Revision: $revision\n" );
429         if( !check_revision( $file, $revision, $finfo, $rinfo ) )
430         {
431             verbose( "\t$file is corrupted in revision: $revision\n" );
432             push( @list_of_broken_files, $file );
433             return();
434         }
435     }
436 }
437
438 ######################################################################
439 #
440 #    NAME :
441 #      get_history
442 #
443 #    PURPOSE :
444 #      To retrieve an array of revision numbers.
445 #
446 #    PARAMETERS :
447 #      $file - The file to retrieve the revision numbers for
448 #
449 #    GLOBALS :
450 #      $cvsroot - the CVSROOT we are examining
451 #
452 #    RETURNS :
453 #      On Success - A hash of revision info, indexed by revision numbers.
454 #      On Failure - undef.
455 #
456 #    COMMENTS :
457 #      The $_ is saved off because The File::find functionality
458 #      expects the $_ to not have been changed.
459 #      The -N option for the rlog command means to spit out 
460 #      tags or branch names.
461 #
462 ######################################################################
463 sub get_history
464 {
465         my( $file ) = @_;
466         $file =~ s/(["\$`\\])/\\$1/g;
467         my %finfo;              # Info about the file.
468         my %rinfo;              # Info about revisions in the file.
469         my $revision;
470
471     my $fh = new IO::File( "cvs -d $cvsroot rlog -N \"$file\""
472                            . ($verbose ? "" : " 2>&1") . " |" )
473                 or die( "unable to run `cvs rlog', help" );
474
475         my $ignore = -1;
476     while( my $line = $fh->getline )
477     {
478                 if( $ignore == 1 ) 
479                 {
480                         if( ( $revision ) = $line =~ /^revision (.*?)(\tlocked by: \S+;)?$/ )
481                         {
482                                 unless($revision =~ m/^\d+\.\d+(?:\.\d+\.\d+)*$/)
483                                 {
484                                         push @invalid_revs, { 'file' => $file, 'rev' => $revision };
485                                         verbose( "Adding invalid revision `$revision' of file `$file' to invalid revs list.\n" );
486                                 }
487
488                                 $ignore++;
489                                 next;
490                         }
491
492                         # We require ---- before a ^revision tag, not a revision
493                         # after every ----.
494                         $ignore = 0;
495         }
496                 if( $ignore == 2 )
497                 {
498                     if( my ( $date, $author, $state ) =
499                              $line =~ /^date: (\S+ \S+);  author: ([^;]+);  state: (\S+);/ )
500                         {
501                                 $rinfo{$revision} =
502                                 {
503                                         'date' => $date,
504                                         'author' => $author,
505                                         'state' => $state
506                                 }
507                         }
508                         else
509                         {
510                                 die "Couldn't read date/author/state for revision $revision\n"
511                                     . "of $file from `cvs rlog'.\n"
512                                     . "line = $line";
513                         }
514                         $ignore = 0;
515                         next;
516                 }
517                 if( $ignore == -1 )
518                 {
519                         # Until we find the first ---- below, we can read general file info
520                     if( my ( $kwmode ) =
521                              $line =~ /^keyword substitution: (\S+)$/ )
522                         {
523                                 $finfo{'kwmode'} = $kwmode;
524                                 next;
525                         }
526                 }
527                 # rlog outputs a "----" line before the actual revision
528                 # without this we'll pick up peoples comments if they 
529                 # happen to start with revision
530                 if( $line =~ /^----------------------------$/ )
531                 {
532                         # Catch this case when $ignore == -1 or 0
533                         $ignore = 1;
534                         next;
535                 }
536     }
537         if( $verbose )
538         {
539                 for (keys %rinfo)
540                 {
541                         verbose( "Revision $_: " );
542                         verbose( join( ", ", %{$rinfo{$_}} ) );
543                         verbose( "\n" );
544                 }
545         }
546
547         die "Syserr closing pipe from `cvs co': $!"
548                 if !$fh->close && $!;
549         return if $?;
550
551     return( \%finfo, %rinfo ? \%rinfo : undef );
552 }
553
554 ######################################################################
555 #
556 #    NAME :
557 #      check_revision
558 #
559 #    PURPOSE :
560 #      Given a file and a revision number ensure that we can check out that
561 #      file.
562 #
563 #      If the user has specified any scripts (passed in as arguments to --exec
564 #      and stored in @scripts), run them on the checked out revision.  If
565 #      executable scripts exit with a non-zero status or evaluated scripts set
566 #      $@ (die), print $status or $@ as a warning.
567 #
568 #    PARAMETERS :
569 #      $file     - The file to look at.
570 #      $revision - The revision to look at.
571 #      $rinfo    - A reference to a hash containing information about the
572 #                  revisions in $file.
573 #                  For instance, $rinfo->{$revision}->{'date'} contains the
574 #                  date revision $revision was committed.
575 #
576 #    GLOBALS :
577 #      NONE
578 #
579 #    RETURNS :
580 #      If we can get the File - 1
581 #      If we can not get the File - 0
582 #
583 #    COMMENTS :
584 #      cvs command line options are as followed:
585 #        -n - Do not run any checkout program as specified by the -o
586 #             option in the modules file
587 #        -p - Put all output to standard out.
588 #        -r - The revision of the file that we would like to look at.
589 #        -ko - Get the revision exactly as checked in - do not allow
590 #              RCS keyword substitution.
591 #      Please note that cvs will return 0 for being able to successfully
592 #      read the file and 1 for failure to read the file.
593 #
594 ######################################################################
595 sub check_revision
596 {
597     my( $file, $revision, $finfo, $rinfo ) = @_;
598         $file =~ s/(["\$`\\])/\\$1/g;
599
600         # Allow binaries to be checked out as such.  Otherwise, use -ko to avoid
601         # replacing keywords in the files.
602         my $kwmode = $finfo->{'kwmode'} eq 'b' ? '' : ' -ko';
603     my $command = "cvs -d $cvsroot co$kwmode -npr $revision \"$file\"";
604         my $ret_code;
605         verbose( "Executing `$command'.\n" );
606         if( @scripts )
607         {
608         my $fh = new IO::File $command . ($verbose ? "" : " 2>&1") . " |";
609                 fcntl( $fh, F_SETFD, 0 )
610                         or die "Can't clear close-on-exec flag on filehandle: $!";
611                 my $count;
612                 foreach my $script (@scripts)
613                 {
614                         $count++;
615                         if( $script !~ /\n/ && -x $script )
616                         {
617                                 # exec external script
618                                 my $status = system $script, $cvsroot, $file, $revision,
619                                                     fileno( $fh );
620                                 warn "`$script $cvsroot $file $revision "
621                                      . fileno( $fh )
622                                      . "' exited with code $status"
623                                         if $status;
624                         }
625                         else
626                         {
627                                 # eval script
628                                 @_ = ($cvsroot, $file, $revision, $fh);
629                                 eval $script;
630                                 warn "script $count ($cvsroot, $file, $revision, $fh) exited abnormally: $@"
631                                         if $@;
632                         }
633                 }
634                 # Read any data left so the close will work even if our called script
635                 # didn't finish reading the data.
636                 () = $fh->getlines;             # force list context
637                 die "Syserr closing pipe from `cvs co': $!"
638                         if !$fh->close && $!;
639                 $ret_code = $?;
640         }
641         else
642         {
643         $ret_code = 0xffff & system "$command >/dev/null 2>&1";
644         }
645
646     return !$ret_code;
647 }
648
649 ######################################################################
650 #
651 #    NAME :
652 #      find_interesting_revisions
653 #
654 #    PURPOSE :
655 #      CVS stores information in a logical manner.  We only really
656 #      need to look at some interestin revisions.  These are:
657 #      The first version
658 #      And the last version on every branch.
659 #      This is because cvs stores changes descending from 
660 #      main line. ie suppose the last version on mainline is 1.6
661 #      version 1.6 of the file is stored in toto.  version 1.5
662 #      is stored as a diff between 1.5 and 1.6.  1.4 is stored 
663 #      as a diff between 1.5 and 1.4.
664 #      branches are stored a little differently.  They are 
665 #      stored in ascending order.  Suppose there is a branch
666 #      on 1.4 of the file.  The first branches revision number
667 #      would be 1.4.1.1.  This is stored as a diff between 
668 #      version 1.4 and 1.4.1.1.  The 1.4.1.2 version is stored
669 #      as a diff between 1.4.1.1 and 1.4.1.2.  Therefore
670 #      we are only interested in the earliest revision number
671 #      and the highest revision number on a branch.
672 #
673 #    PARAMETERS :
674 #      @revisions - The list of revisions to find interesting ones
675 #
676 #    GLOBALS :
677 #      NONE
678 #
679 #    RETURNS :
680 #      @new_revisions - The list of revisions that we find interesting
681 #
682 #    COMMENTS :
683 #
684 ######################################################################
685 sub find_interesting_revisions
686 {
687     my( @revisions ) = @_;
688     my @new_revisions;
689     my %max_branch_revision;
690     my $branch_number;
691     my $branch_rev;
692     my $key;
693     my $value;
694
695     foreach my $revision( @revisions )
696     {
697         ( $branch_number, $branch_rev ) = branch_split( $revision );
698                 $max_branch_revision{$branch_number} = $branch_rev
699                         if( !exists $max_branch_revision{$branch_number}
700                                 || $max_branch_revision{$branch_number} < $branch_rev );
701         }
702
703         push( @new_revisions, "1.1" ) unless (exists $max_branch_revision{1}
704                                               && $max_branch_revision{1} == 1);
705     while( ( $key, $value ) = each ( %max_branch_revision ) )
706     {
707         push( @new_revisions, $key . "." . $value );
708     }
709
710     my $nrc;
711     my $rc;
712
713     $rc = @revisions;
714     $nrc = @new_revisions;
715
716     $total_revisions += $rc;
717     $total_interesting_revisions += $nrc;
718
719     verbose( "\t\tTotal Revisions: $rc Interesting Revisions: $nrc\n" );
720
721     return( @new_revisions );
722 }
723
724
725
726 ######################################################################
727 #
728 #    NAME :
729 #      branch_split
730 #
731 #    PURPOSE :
732 #      To split up a revision number up into the branch part and
733 #      the number part.  For Instance:
734 #      1.1.1.1 - is split 1.1.1 and 1
735 #      2.1     - is split 2 and 1
736 #      1.3.4.5.7.8 - is split 1.3.4.5.7 and 8
737 #
738 #    PARAMETERS :
739 #      $revision - The revision to look at.
740 #
741 #    GLOBALS :
742 #      NONE
743 #
744 #    RETURNS :
745 #      ( $branch, $revision ) - 
746 #      $branch - The branch part of the revision number 
747 #      $revision - The revision part of the revision number
748 #
749 #    COMMENTS :
750 #      NONE
751 #
752 ######################################################################
753 sub branch_split
754 {
755     my( $revision ) = @_;
756     my $branch;
757     my $version;
758     my @split_rev;
759     my $count;
760
761     @split_rev = split /\./, $revision;
762
763     my $numbers = @split_rev;     
764     @split_rev = reverse( @split_rev );
765     $branch = pop( @split_rev );
766     for( $count = 0; $count < $numbers - 2 ; $count++ )
767     {
768         $branch .= "." . pop( @split_rev );
769     }
770
771     return( $branch, pop( @split_rev ) );
772 }
773
774 ######################################################################
775 #
776 #    NAME :
777 #      get_ignore_files_from_cvsroot
778 #
779 #    PURPOSE :
780 #      Retrieve the list of files from the CVSROOT/ directory
781 #      that should be ignored. 
782 #      These are the regular files (e.g., commitinfo, loginfo)
783 #      and those specified in the checkoutlist file.
784 #
785 #    PARAMETERS :
786 #      The CVSROOT
787 #
788 #    GLOBALS :
789 #      NONE
790 #
791 #    RETURNS :
792 #      @ignore - the list of files to ignore
793 #
794 #    COMMENTS :
795 #      NONE
796 #
797 ######################################################################
798 sub get_ignore_files_from_cvsroot {
799     my( $cvsroot ) = @_;
800     my @ignore = (
801                        qr{CVS/fileattr$}o,
802                    qr{^(./)?CVSROOT/.#[^/]*$}o,
803                    qr{^(./)?CVSROOT/checkoutlist$}o,
804                    qr{^(./)?CVSROOT/commitinfo$}o,
805                    qr{^(./)?CVSROOT/config$}o,
806                    qr{^(./)?CVSROOT/cvsignore$}o,
807                    qr{^(./)?CVSROOT/cvswrappers$}o,
808                    qr{^(./)?CVSROOT/editinfo$}o,
809                    qr{^(./)?CVSROOT/history$}o,
810                    qr{^(./)?CVSROOT/loginfo$}o,
811                    qr{^(./)?CVSROOT/modules$}o,
812                    qr{^(./)?CVSROOT/notify$}o,
813                    qr{^(./)?CVSROOT/passwd$}o,
814                    qr{^(./)?CVSROOT/postadmin$}o,
815                    qr{^(./)?CVSROOT/postproxy$}o,
816                    qr{^(./)?CVSROOT/posttag$}o,
817                    qr{^(./)?CVSROOT/postwatch$}o,
818                    qr{^(./)?CVSROOT/preproxy$}o,
819                    qr{^(./)?CVSROOT/rcsinfo$}o,
820                    qr{^(./)?CVSROOT/readers$}o,
821                    qr{^(./)?CVSROOT/taginfo$}o,
822                    qr{^(./)?CVSROOT/val-tags$}o,
823                    qr{^(./)?CVSROOT/verifymsg$}o,
824                    qr{^(./)?CVSROOT/writers$}o
825                      );
826
827     my $checkoutlist_file = "$cvsroot/CVSROOT/checkoutlist";
828         if( -f $checkoutlist_file && -r $checkoutlist_file )
829         {
830                 my $fh = new IO::File "<$checkoutlist_file"
831                         or die "Unable to read checkoutlist file ($checkoutlist_file): $!\n";
832
833                 my @list = $fh->getlines;
834                 chomp( @list );
835                 $fh->close or die( "Unable to close checkoutlist file: $!\n" );
836
837                 foreach my $line( @list )
838                 {
839                         next if( $line =~ /^#/ || $line =~ /^\s*$/ );
840                         $line =~ s/^\s*(\S+)(\s+.*)?$/$1/;
841                         push @ignore, qr{^(./)?CVSROOT/$line$};
842                 }
843         }       
844
845     return @ignore;
846 }
847
848
849
850 ######
851 ###### Go.
852 ######
853
854 exit main @ARGV;
855
856 # vim:tabstop=4:shiftwidth=4