path: root/CVSROOT/commit_prep.pl

#!/usr/bin/perl -w
#
# $FreeBSD$
#
#
# Perl filter to handle pre-commit checking of files.  This program
# records the last directory where commits will be taking place for
# use by the log_accumulate script.  For new file, it forcing the
# existence of a RCS "Id" keyword in the first ten lines of the file.
# For existing files, it checks version number in the "Id" line to
# prevent losing changes because an old version of a file was copied
# into the direcory.
#
# Possible future enhancements:
#
#
#    Check for cruft left by unresolved conflicts.  Search for
#    "^<<<<<<<$", "^-------$", and "^>>>>>>>$".
#
#    Look for a copyright and automagically update it to the
#    current year.
#
# Contributed by David Hampton <hampton@cisco.com>
#

require 5.003;  # to be sure.  log_accum needs perl5

use lib $ENV{CVSROOT};
use CVSROOT::cfg;

############################################################
#
# Configurable options
#
############################################################
#
# Check each file (except dot files) for our RCS header keyword.
# (defined in the constants section.)
#
$check_id = 0;

############################################################
#
# Constants
#
############################################################
$ENTRIES       = "CVS/Entries";


# The "Id" header to check for.
my $HEADER  = $cfg::IDHEADER;


############################################################
#
# Error messages
#
############################################################
my $NoId = "
%s - Does not contain a line with the keyword \"\$$HEADER:\".\n";

# Protect string from substitution by RCS.
my $NoName = "
%s - The ID line should contain only \$$HEADER\$ for a newly created file.\n";

#$DelPath = "
#%s - The old path and version has been deleted from \$$HEADER\$.\n";

my $BadId = "%s - The \$$HEADER\$ is mangled.\n";

my $BadName = "
%s - The pathname '%s'
    in the \$$HEADER\$ line does not match the actual filename.\n";

my $BadVersion = "
%s - GRRR!!  You spammed your copy of the file
    which was based upon version %s, with a different version based
    upon %s.  Please move your '%s' out of the way,
    perform an update to get the current version, and then
    CAREFULLY merge your changes into that file.\n";

############################################################
#
# Subroutines
#
############################################################

# Write a single line to a file.
sub write_line {
    my $filename = shift;   # File to write to.
    my $line = shift;   # Line to write to the file.

    open FILE, ">$filename" or die "Cannot open $filename, stopped\n";
    print FILE "$line\n";
    close FILE;
}

sub check_version {
    local($id, $rname, $version, $bareid, $exclude, $path);
    local($filename, $directory, $hastag, $cvsversion) = @_;

    if (! -f $filename) {
        return(0);  # not present - either removed or let
                # cvs deal with it.
    }

    open FILE, $filename or die "Cannot open $filename, stopped\n";
    # requiring the header within the first 'n' lines isn't useful.
    while (1) {
        $pos = -1;
        last if eof(FILE);
        $line = <FILE>;
        $pos = index($line, "\$$HEADER");
        last if ($pos >= 0);
    }

    if ($pos == -1) {
        $exclude = $cvsroot . "/CVSROOT/exclude";
        $path = $directory . "/" . $filename;
        open(EX, "<$exclude") || die("cannot open $exclude: $!");
        while (<EX>) {
            local($line);

            chop;
            $line = $_;

            if ($line =~ /^#/) {
                next;
            }
            if ($path =~ /$line/) {
                close(EX);
                return(0);
            }
        }
        close(EX);
    }
    if ($pos == -1) {
        printf($NoId, $filename);
        return(1);
    }
    $bareid = (index($line, "\$$HEADER: \$") >= 0 ||
       index($line, "\$$HEADER\$") >= 0);
    if (!$bareid && $line !~ /\$$HEADER: .* \$/) {
        printf($BadId, $filename);
        return(1);
    }
    # Ignore version mismatches (MFC spamming etc) on branches.
    if ($hastag) {
        return (0);
    }
    ($id, $rname, $version) = split(' ', substr($line, $pos));
    if ($cvsversion{$filename} eq '0') {
        if (!$bareid) {
            printf($NoName, $filename);
            return(1);
        }
        return(0);
    }
    if ($bareid) {
        return (0);
#       if ($directory =~ /^ports\//) {
#           return (0); # ok for ports
#       }
#       # Don't know whether to allow or trap this.  It means
#       # one could bypass the version spam checks by simply
#       # using a bare tag.
#       printf($DelPath, $filename);
#       return(1);
    }
    if ($rname ne "$directory/$filename,v") {
        # If ports and the pathname is just the basename
        # (eg: somebody sent in a port with $Id$ and the
        # committer changed Id -> $HEADER and the version
        # numbers otherwise match.
        if (!($directory =~ /^ports\// && $rname eq "$filename,v")) {
            printf($BadName, "$directory/$filename,v", $rname);
            return(1);
        }
    }
    if ($cvsversion{$filename} ne $version) {
        printf($BadVersion, $filename, $cvsversion{$filename},
            $version, $filename);
        return(1);
    }
    return(0);
}

#############################################################
#
# Main Body
#
############################################################

#print("ARGV - ", join(":", @ARGV), "\n");
#print("id   - ", $cfg::PID, "\n");

#
# Suck in the Entries file
#
open ENTRIES, $ENTRIES or die "Cannot open $ENTRIES.\n";
while (<ENTRIES>) {
    chomp;
    next if /^D/;

    my ($filename, $ver, $stamp, $opt, $tag) = split '/', substr($_, 1);
    $cvsversion{$filename} = $ver;
    $cvstag{$filename} = $tag;
    $stamp = $opt;  #silence -w
}
close ENTRIES;

$directory = $ARGV[0];
shift @ARGV;

$cvsroot=$ENV{'CVSROOT'} || "/home/ncvs";
$directory =~ s,^$cvsroot[/]+,,;

if ($directory =~ /^src/) {
    $check_id = 1;
}
if ($directory =~ /^ports/) {
    $check_id = 2;
}
if ($directory =~ /^src\/contrib/) {
    $check_id = 3;
}
if ($directory =~ /^src\/crypto/) {
    $check_id = 3;
}
if ($directory =~ /^src\/release/) {
    $check_id = 0;
}
if ($directory =~ /^src\/etc/) {
    $check_id = 0;
}
#
# Now check each file name passed in, except for dot files.  Dot files
# are considered to be administrative files by this script.
#
if ($check_id != 0) {
    $failed = 0;
    foreach $arg (@ARGV) {
        local($hastag) = ($cvstag{$arg} ne '');
        next if (index($arg, ".") == 0);
        next if ($check_id == 2 && $arg ne "Makefile");
        next if ($check_id == 3 && $hastag);
        $failed += &check_version($arg, $directory, $hastag,
            $cvsversion);
    }
    if ($failed) {
        print "\n";
        unlink($cfg::LAST_FILE);
        exit(1);
    }
}

#
# Record this directory as the last one checked.  This will be used
# by the log_accumulate script to determine when it is processing
# the final directory of a multi-directory commit.
#
&write_line($cfg::LAST_FILE, $directory);

exit(0);