352 lines
7.8 KiB
Perl
352 lines
7.8 KiB
Perl
#!/usr/bin/perl
|
|
#
|
|
#
|
|
# This will verify a *.dat script used in diskless installs
|
|
#
|
|
# $Revision: 1.4 $
|
|
#
|
|
#
|
|
|
|
require 5.003; #Needs perl 5.003 or recent
|
|
use Sys::Hostname;
|
|
local (*in);
|
|
local (*data);
|
|
$done=1;
|
|
|
|
sub atexit()
|
|
{
|
|
print STDERR "\a\nFix $filename and rerun verify\n";
|
|
exit 1;
|
|
}
|
|
|
|
sub usage()
|
|
{
|
|
$option=$ARGV[0];
|
|
$filename=$ARGV[1];
|
|
if ((!$filename)||(scalar@ARGV != 2))
|
|
{
|
|
print STDERR "Usage: verify -[cs] filename\n";
|
|
exit 1;
|
|
}
|
|
if (($option ne "-c") && ($option ne "-s"))
|
|
{
|
|
print STDERR "Unknown option: $option\n";
|
|
print STDERR "Usage: verify -[cs] filename\n";
|
|
print STDERR "\t-c to check a client file\n";
|
|
print STDERR "\t-s to check a share file\n";
|
|
exit 1;
|
|
}
|
|
return;
|
|
}
|
|
|
|
# Assert usage!
|
|
|
|
usage();
|
|
|
|
# Get variables and check sanity. Defined variables depend on the option
|
|
# (-c for client -s for share) The variables are stored in the associative
|
|
# array $in
|
|
|
|
open (INFILE, $filename) || die "verify: Can't open $filename - $!\n";
|
|
line:
|
|
while (<INFILE>)
|
|
{
|
|
chomp;
|
|
next line if /^#/;
|
|
next line if (!$_);
|
|
($key,$value)=split(/=/,$_,2);
|
|
|
|
# Anything that is undefined should be equal to "" if not, die
|
|
|
|
die "verify $option $filename: $key has no value " if (! $value);
|
|
$in{$key}=$value;
|
|
$in{$key}=~s/\"//g;
|
|
$in{$key}=~s/\s+//g;
|
|
}
|
|
close INFILE;
|
|
|
|
if ($option eq "-s")
|
|
{
|
|
|
|
# This means we are checking a share file!
|
|
|
|
#check hostname
|
|
$host=hostname();
|
|
if ($in{HOSTNAME} ne $host)
|
|
{
|
|
print STDERR "HOSTNAME is not valid. Should be $host not $in{HOSTNAME}\n";
|
|
atexit();
|
|
}
|
|
if ($in{SHAREHOST} ne "\$HOSTNAME")
|
|
{
|
|
print STDERR "SHAREHOST should always be \"\$HOSTNAME\"\n";
|
|
atexit();
|
|
}
|
|
if (($in{SERVER_NIS} ne "yes") && ($in{SERVER_NIS} ne "no"))
|
|
{
|
|
print STDERR "SERVER_NIS should either be \"yes\" or \"no\"\n";
|
|
atexit();
|
|
}
|
|
if ((!(-e $in{DISKLESS}))||(!(-d $in{DISKLESS})))
|
|
{
|
|
print STDERR "$in{DISKLESS} is not a directory or doesn't already exist\n";
|
|
atexit();
|
|
}
|
|
|
|
if ((!defined $in{CPUBOARD}) && (!defined $in{GFXBOARD}) &&
|
|
(!defined $in{CPUARCH}) && (!defined $in{VIDEO}))
|
|
{
|
|
#This means that we are installing for all platforms
|
|
#but mode must be defined as 32bit or 64bit
|
|
|
|
if (($in{MODE} ne "32bit") && ($in{MODE} ne "64bit"))
|
|
{
|
|
print STDERR "If you are trying to install for every\n";
|
|
print STDERR "platform you must specify mode to be 32bit\n";
|
|
print STDERR "or 64bit. Otherwise, CPUBOARD, CPUARCH,\n";
|
|
print STDERR "GFXBOARD, VIDEO, and MODE must be specified.\n";
|
|
atexit();
|
|
}
|
|
exit 0;
|
|
}
|
|
|
|
#Now here comes the hard part. From now on things can be multiple.
|
|
#Lets grab all of the cpu options first and concentrate on the rest
|
|
#later
|
|
|
|
($key,$value)=split(/-m/,$in{CPUBOARD},2);
|
|
if ($key eq "")
|
|
{
|
|
print STDERR "There is no value for CPUBOARD\n";
|
|
atexit();
|
|
}
|
|
$i=0;
|
|
while ($key)
|
|
{
|
|
open (IN, ".dl_classes") || die "Can't open .dl_classes: $!\n";
|
|
line1:while (<IN>)
|
|
{
|
|
chomp;
|
|
next line1 if /^#/;
|
|
next line1 if (!$_);
|
|
if (index($_,$key)>=0)
|
|
{
|
|
$_=~s/\s+/:/g;
|
|
($data[$i]{CPUBOARD}, $data[$i]{CPUARCH}, $data[$i]{GFXBOARD}, $data[$i]{SUBGR},
|
|
$data[$i]{VIDEO},
|
|
$data[$i]{MODE}) = split(/:/,$_,6);
|
|
if ($data[$i]{VIDEO} eq "NULL")
|
|
{
|
|
$data[$i]{VIDEO} = "";
|
|
}
|
|
$i++;
|
|
$done=0;
|
|
}
|
|
}
|
|
close IN;
|
|
if ($done==1)
|
|
{
|
|
print STDERR "verify $filename: $key not supported";
|
|
print STDERR " in diskless environment\n";
|
|
atexit();
|
|
}
|
|
($key,$key1)=split(/=/,$value,2);
|
|
if ($key ne "CPUBOARD")
|
|
{
|
|
if ($key ne "")
|
|
{
|
|
print "There is an improper entry for CPUBOARD\n";
|
|
open (INFILE,$filename) || die "verify: Can't open $filename - $!\n";
|
|
grepline:while (<INFILE>)
|
|
{
|
|
chomp;
|
|
next grepline if (! (/$key/));
|
|
print ">>>$_\n";
|
|
}
|
|
close INFILE;
|
|
atexit();
|
|
}
|
|
}
|
|
($key,$value)=split(/-m/,$key1,2);
|
|
}
|
|
|
|
# Now that the CPUBOARD is ok, lets get everything else
|
|
|
|
foreach $item ("CPUARCH", "GFXBOARD", "VIDEO", "MODE")
|
|
{
|
|
$done=1;
|
|
|
|
#Split the variable like you split everything else!!!
|
|
#But remember,GFXBOARD and SUBGR are on the same line
|
|
|
|
($key,$value)=split(/-m/,$in{$item},2);
|
|
if ($key eq "")
|
|
{
|
|
print STDERR "There is no value for $item\n";
|
|
atexit();
|
|
}
|
|
if ($item eq "GFXBOARD")
|
|
{
|
|
#Then we need to get subgr too
|
|
|
|
($key2,$x)=split(/=/,$value,2);
|
|
if ($key2 ne "SUBGR")
|
|
{
|
|
$key=$key2;
|
|
goto errorlabel;
|
|
}
|
|
($key2,$value)=split(/-m/,$x,2);
|
|
}
|
|
$i=0;
|
|
while ($key)
|
|
{
|
|
var:while ($i<scalar@data)
|
|
{
|
|
if ($key ne $data[$i]{$item})
|
|
{
|
|
$i++;
|
|
next var;
|
|
}
|
|
if ($item eq "GFXBOARD")
|
|
{
|
|
if ($key2 ne $data[$i]{SUBGR})
|
|
{
|
|
$i++;
|
|
next var;
|
|
}
|
|
}
|
|
$done=0;
|
|
last var;
|
|
}
|
|
if ($done==1)
|
|
{
|
|
if ($item ne "GFXBOARD")
|
|
{
|
|
print STDERR "verify $filename: $item = $key not";
|
|
print STDERR " supported for the specified CPU(s)\n";
|
|
}
|
|
else
|
|
{
|
|
print STDERR "verify $filename: $item = $key , SUBGR = $key2 not";
|
|
print STDERR " supported for the specified CPU(s)\n";
|
|
}
|
|
atexit();
|
|
}
|
|
($key,$key1)=split(/=/,$value,2);
|
|
if ($key ne $item)
|
|
{
|
|
if ($key ne "")
|
|
{
|
|
errorlabel:
|
|
print "$key!\n";
|
|
print STDERR "There is an improper entry for the specified CPU(s)\n";
|
|
open (INFILE,$filename) || die "verify: Can't open $filename - $!\n";
|
|
$i=0;
|
|
grepline2:while (<INFILE>)
|
|
{
|
|
chomp;
|
|
$i++;
|
|
next grepline2 if (! (/$key/));
|
|
print STDERR "$i:$_\n";
|
|
}
|
|
close INFILE;
|
|
atexit();
|
|
}
|
|
}
|
|
($key,$value)=split(/-m/,$key1,2);
|
|
$i=0;
|
|
$done=1;
|
|
if ($item eq "GFXBOARD" && $key) #Then we need to get subgr too
|
|
{
|
|
($key2,$x)=split(/=/,$value,2);
|
|
if ($key2 ne "SUBGR")
|
|
{
|
|
$key=$key2;
|
|
goto errorlabel;
|
|
}
|
|
($key2,$value)=split(/-m/,$x,2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Now handle the -c option!
|
|
|
|
if ($option eq "-c")
|
|
{
|
|
# This means we are checking a client file!
|
|
|
|
if ($in{CLROOT} ne "\$DISKLESS\/client\/\$HOST")
|
|
{
|
|
print STDERR "\$CLROOT should always be \"\$DISKLESS\/client\/\$HOST\"\n";
|
|
atexit();
|
|
}
|
|
if ($in{SWAP} ne "\$DISKLESS\/swap\/\$HOST")
|
|
{
|
|
print STDERR "\$SWAP should always be \$DISKLESS\/swap\/\$HOST\n";
|
|
atexit();
|
|
}
|
|
($key,$value)=split(/\d+m/,$in{SWAPSIZE},2);
|
|
if ($key ne "" || $value ne "")
|
|
{
|
|
print STDERR "Incorrect value for \$SWAPSIZE\n";
|
|
atexit();
|
|
}
|
|
open (IN, ".dl_classes") || die "Can't open .dl_classes: $!\n";
|
|
$i=0;
|
|
line2:while (<IN>)
|
|
{
|
|
chomp;
|
|
next line2 if /^#/;
|
|
next line2 if (!$_);
|
|
if (index($_,$in{CPUBOARD})>=0)
|
|
{
|
|
$_=~s/\s+/:/g;
|
|
($data[$i]{CPUBOARD}, $data[$i]{CPUARCH},
|
|
$data[$i]{GFXBOARD}, $data[$i]{SUBGR},
|
|
$data[$i]{VIDEO}, $data[$i]{MODE})=split(/:/,$_,6);
|
|
if ($data[$i]{VIDEO} eq "NULL")
|
|
{
|
|
$data[$i]{VIDEO}="";
|
|
}
|
|
$i++;
|
|
$done=0;
|
|
}
|
|
}
|
|
close IN;
|
|
$i=0;
|
|
if ($done==1)
|
|
{
|
|
print STDERR "verify $filename: $in{CPUBOARD} not supported in diskless environment\n";
|
|
atexit();
|
|
}
|
|
$done=1;
|
|
|
|
# We know the CPUBOARD is fine. Now let's check everything else....
|
|
|
|
($key,$value)=split(/-m/,$in{GFXBOARD},2);
|
|
$in{GFXBOARD}=$key;
|
|
($x,$in{SUBGR})=split(/=/,$value,2);
|
|
foreach $item ("CPUARCH", "GFXBOARD", "SUBGR", "VIDEO", "MODE")
|
|
{
|
|
var:while ($i<scalar@data)
|
|
{
|
|
if ($in{$item} ne $data[$i]{$item})
|
|
{
|
|
splice(@data,$i,1);
|
|
next var;
|
|
}
|
|
$i++;
|
|
$done=0;
|
|
}
|
|
if ($done==1)
|
|
{
|
|
print STDERR "verify $filename: $item = $in{$item} not";
|
|
print STDERR " supported for $in{CPUBOARD}\n";
|
|
atexit();
|
|
}
|
|
$i=0;
|
|
$done=1;
|
|
}
|
|
}
|