| Current Path : /usr/local/lib/rpm/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //usr/local/lib/rpm/rpmdiff |
#!/usr/bin/perl
# RPM (and it's source code) is covered under two separate licenses.
# The entire code base may be distributed under the terms of the GNU
# General Public License (GPL), which appears immediately below.
# Alternatively, all of the source code in the lib subdirectory of the
# RPM source code distribution as well as any code derived from that
# code may instead be distributed under the GNU Library General Public
# License (LGPL), at the choice of the distributor. The complete text
# of the LGPL appears at the bottom of this file.
# This alternatively is allowed to enable applications to be linked
# against the RPM library (commonly called librpm) without forcing
# such applications to be distributed under the GPL.
# Any questions regarding the licensing of RPM should be addressed to
# Erik Troan <ewt@redhat.com>.
# rpmdiff - a program for comparing two rpm files for differences.
# Written by Ken Estes, Mail.com.
use Getopt::Long;
# much of this code comes from reading the book
# "Maximum RPM" by Edward C. Bailey
sub usage {
my $args = "[--".join("] [--", @ARGS)."]";
my @default_args = map $RPMTAG->{$_}->{'arg'}, @DEFAULT_CMP;
my $default_args = "--".join(" --", @default_args)."";
my $usage =<<EOF;
$0 [--version] [--help] [--cmpmode] [--all]
$args
old_rpm_file new_rpm_file
Arguments
--version Print version information for this program
--help Show this usage page
--cmpmode Do not send any information to stdout, instead
exit with zero if the rpm files are identical and
exit with 1 if there are differences.
--all Ensure that all possible comparisons will be performed.
This argument should not be used with any CMP arguments.
CMP Arguments
Many of the options are designed to select which comparisons the user
is interested in so that spurious differences can be ignored. If no
CMP arguments are chosen then the default arguments are picked.
The CMP arguments are:
$args
The default arguments are:
$default_args
There are two methods of picking which comparisions will be performed.
Any differences between the two files which are not in the list of
performed comparisons will be ignored.
First arguments may be specified on the command line preceeded with a
'--' as in '--md5' these arguments specify which comparisons will be
performed. If a comparison is not mentioned on the command line it will
not be performed.
Second arguments may be specified on the command line preceeded with a
'--no' as in '--nomd5' these arguments specify which comparisons will
not be performed. If a comparison is not mentioned on the command line
it will be prefomed.
You can not mix the two types of arguments.
Synopsis
This script will compare old_rpm_file and new_rpm_file and print to
standard out the differences between the two files. The output is
designed to help isolate the changes which will occur when upgrading
an installed package. The output looks like the output of 'rpm -V'.
It is assumed that you have installed oldpackage and are thinking of
upgrading to newpackage. The output is as if you ran 'rpm -Va' after
installing the new package with cpio so that the rpm database was not
up todate. Thus 'rpm -Va' will pick up the differences between the
two pacakges.
Additionally the RPM scripts (prein, postin, triggers, verify, etc)
are compared and their results are displayed as if the scripts ended
up as files in the filesystem.
Exit Code
The if not run in cmpmode the program exists with the number of files
which are different between the two packages, the exitcode will get no
bigger than $MAX_EXIT.
If run in cmpmode then the program will exit with zero if the rpm
files are identical and exit with 1 if there are differences.
BUGS
This program only parses the RPM file headers not the cpio payload
inside the RPM file. In the rare case where an tag is defined in one
RPM and not in another we charitably assume that the RPMs match on
this tag. An example of this may be file uid/gid\'s. Currently rpm
does not store this information in the header, it appears only in the
cpio payload. If you were to compare two rpm files and one of them
does not have the uid/gid\'s in the header then no difference in
uid/gid will ever appear in the output regardless of what the RPMs
actually contain.
The program only checks differences between files and scripts, any
changes to dependencies, prefixes, or spec file header information are
not checked.
There is no method provided to check changes in a files flags, this
includes changes to the files documentation, MISSINGOK, NOREPLACE, or
configuration status.
Output Format
The differences are sent to stdout. There is one line for each file
which is different. The differences are encoded in a string using the
following letters to represent the differerences and the following
order to encode the information:
S is the file size
M is the file\'s mode
5 is the MD5 checksum of the file
D is the files major and monor numbers
L is the files symbolic link contents.
U is the owner of the file
G is the file\'s group
T is the modification time of the file
added indicates the file was added to the old version
missing indicates the file was deleted from the old version
Any attributes which match are denoted with a '.'.
Output Example
S.5..... PREIN
.....UG. /bin/echo
..5....T /usr/bin/grep
S.5....T /etc/info-dir
missing /usr/doc/dhcpcd-0.70/README
.M...... /usr/lib/libpanel.so.4
added /usr/lib/libmenu.so.4
SM5....T /usr/info/dir
Usage Example
$0 --help
$0 --version
$0 java-jdk-1.1.7-2.rpm java-jdk-1.1.7-3.rpm
$0 --md5 java-jdk-1.1.7-2.rpm java-jdk-1.1.7-3.rpm
$0 --nomd5 java-jdk-1.1.7-2.rpm java-jdk-1.1.7-3.rpm
$0 --md5 --link --mtime java-jdk-1.1.7-2.rpm java-jdk-1.1.7-3.rpm
$0 --all java-jdk-1.1.7-2.rpm java-jdk-1.1.7-3.rpm
$0 --cmpmode java-jdk-1.1.7-2.rpm java-jdk-1.1.7-3.rpm
$0 --cmpmode --md5 java-jdk-1.1.7-2.rpm java-jdk-1.1.7-3.rpm
EOF
print $usage;
exit 0;
}
sub set_static_vars {
# This functions sets all the static variables which are often
# configuration parameters. Since it only sets variables to static
# quantites it can not fail at run time. Some of these variables are
# adjusted by parse_args() but asside from that none of these
# variables are ever written to. All global variables are defined here
# so we have a list of them and a comment of what they are for.
# The numerical indicies to the hash comes from ~rpm/lib/rpmlib.h
# the index is the number of the tag as it appears in the rpmfile.
# tag_name: the name of the tag as it appears in rpmlib.h.
# all entries have a tag_name if an entry has one of the next three
# fields it must have the rest. If a tag does not have the next three
# fields we we will still gather data for it. This is for future
# functionality as these fields look important, and for debugging.
# diff_order: if the tag is used in the different output then this is
# the order of the character differences.
# diff_char: if the tag is used in the different output then this is
# the character which will appear when there is a
# difference.
# arg: the name of the command line option to specify whether this tag
# is used in the difference or not
# The scripts contained in the rpm (preinstall, postinstall) do not
# have the comparison information that files have. Some of the
# comparisons (md5, size) can be performed on scripts, using regular
# perl functions, others (uid, modes, link) can not. We use
# script_cmp to link the perl comparison function to the comparison
# arguments and to the diff_char.
# script_cmp: the perl comparion function to perform if this
# difference can be performed on the rpm scripts
# is_script: if defined this indicates that the datatype is a script
# and we can use script_cmp on it. The data is stored as an array
# containing a single string.
# note: that although we may need to denote differences in the flags
# this table may not be appropriate for that task.
# The data from the RPM files is stored in $RPM0, $RPM1 they are HoL.
# The hash is indexed with the same index as appears in $RPMTAG, the
# other data is what ever comes out of the file. Most of the data we
# want is stored as arrays of values (occasionally it is a scalar
# value). We keep a hash to allow us to find the index number to use
# in all arrays given the filename. Some information like the package
# name and the posinstall script are stored, in the hash table as an
# array which contains a single string.
$RPMTAG = {
1000 => {
'tag_name' => 'NAME',
},
1001 => {
'tag_name' => 'VERSION',
},
1002 => {
'tag_name' => 'RELEASE',
},
1006 => {
'tag_name' => 'BUILDTIME',
},
1027 => {
'tag_name' => 'FILENAMES',
},
1028 => {
'tag_name' => 'FILESIZES',
'diff_order' => 0,
'diff_char' => 'S',
'arg' => 'size',
'script_cmp' => sub { return (length($_[0]) ne
length($_[1])); },
},
1029 => {
'tag_name' => 'FILESTATES',
},
1030 => {
'tag_name' => 'FILEMODES',
'diff_order' => 1,
'diff_char' => 'M',
'arg' => 'mode',
},
1033 => {
'tag_name' => 'FILERDEVS',
'diff_order' => 3,
'diff_char' => 'D',
'arg' => 'dev',
},
1034 => {
'tag_name' => 'FILEMTIMES',
'diff_order' => 7,
'diff_char' => 'T',
'arg' => 'mtime',
},
1035 => {
'tag_name' => 'FILEMD5S',
'diff_order' => 2,
'diff_char' => '5',
'arg' => 'md5',
'script_cmp' => sub{ return ($_[0] ne
$_[1]); },
},
1036 => {
'tag_name' => 'FILELINKTOS',
'diff_order' => 4,
'diff_char' => 'L',
'arg' => 'link',
},
1037 => {
'tag_name' => 'FILEFLAGS',
},
1038 => {
'tag_name' => 'ROOT',
},
1039 => {
'tag_name' => 'FILEUSERNAME',
'diff_order' => 5,
'diff_char' => 'U',
'arg' => 'user',
},
1040 => {
'tag_name' => 'FILEGROUPNAME',
'diff_order' => 6,
'diff_char' => 'G',
'arg' => 'group',
},
1098 => {
'tag_name' => 'PREFIXES',
},
1099 => {
'tag_name' => 'INSTPREFIXES',
},
# support for differences of scripts
1023 => {
'tag_name' => 'PREIN',
'is_script' => 1,
},
1024 => {
'tag_name' => 'POSTIN',
'is_script' => 1,
},
1025 => {
'tag_name' => 'PREUN',
'is_script' => 1,
},
1026 => {
'tag_name' => 'POSTUN',
'is_script' => 1,
},
1079 => {
'tag_name' => 'VERIFYSCRIPT',
'is_script' => 1,
},
1065 => {
'tag_name' => 'TRIGGERSCRIPTS',
'is_script' => 1,
},
1091 => {
'tag_name' => 'VERIFYSCRIPTPROG',
'is_script' => 1,
},
1092 => {
'tag_name' => 'TRIGGERSCRIPTPROG',
'is_script' => 1,
},
};
# by default check these options, which are the "contents" of the
# files.
@DEFAULT_CMP = ( 1028, 1035, 1036, );
$RPM_FILE_MAGIC = chr(0xed).chr(0xab).chr(0xee).chr(0xdb);
$RPM_HEADER_MAGIC = chr(0x8e).chr(0xad).chr(0xe8);
# we want the second header block, as the first header is the
# signature block.
$HEADER_BLOCK_NUM = 2;
# number of bytes in the file to skip when looking for the first
# header. Actually I think the lead is bigger then this like 96, but
# I am sure this minimum value is correct.
$LEAD_LENGTH = 66;
$HEADER_RECORD_SIZE = 16;
# largest exit code we allow.
$MAX_EXIT = 250;
$NUM_DIFFERENCES = 0;
$RCS_REVISION = ' $Revision: 1.4 $ ';
# set a known path.
$ENV{'PATH'}= (
'/opt/gnu/bin'.
':/usr/local/bin'.
':/usr/bin'.
':/bin'.
'');
# taint perl requires we clean up these bad environmental variables.
delete @ENV{'IFS', 'CDPATH', 'ENV', 'BASH_ENV'};
$VERSION = 'NONE';
if ( $RCS_REVISION =~ m/([.0-9]+)/ ) {
$VERSION = $1;
}
return ;
}
sub parse_args{
my $arg_include = '';
my $arg_exclude = '';
my %arg_tags= ();
my @args_with_bang = ();
my %arg2tag = ();
# find out what arguments are availible and build some
# data structures to work with them.
foreach $tag (keys %$RPMTAG ) {
my $arg = $RPMTAG->{$tag}->{'arg'};
($arg) || next;
push @ARGS, $arg;
push @ALL_CMP_TAGS, $tag;
push @args_with_bang, "$arg!";
$arg2tag{$arg}=$tag;
}
# sort the tags to determine the proper comparison order.
# use the order stored in the RPMTAG table.
# If this code is too confusing, look up
# 'Schwartzian Transform' in perlfaq4 or an advanced perl book.
@ALL_CMP_TAGS = map { $_->[0] }
sort{ $a->[1] <=> $b->[1] }
map { [ $_, $RPMTAG->{$_}->{'diff_order'} ] }
@ALL_CMP_TAGS;
$FILES_EQ_STRING = '.' x scalar(@ALL_CMP_TAGS);
if( !GetOptions("version", "help", "all", "cmpmode!", @args_with_bang) ) {
print("Illegal options in \@ARGV: '@ARGV'\n");
usage() ;
exit 1 ;
}
if($opt_version) {
print "$0: Version: $VERSION\n";
exit 0;
}
if ($opt_help) {
usage();
}
if ($opt_all) {
# all is just an exclude with nothing to exclude
$arg_exclude = 1;
}
# process each of the arguments derived from the $RPMTAG hash
foreach $arg (@ARGS) {
my $arg_var = "opt_$arg";
if (defined($$arg_var)) {
$arg_tags{$arg2tag{$arg}} = 1;
if ($$arg_var) {
$arg_include = 1;
} else {
$arg_exclude = 1;
}
}
}
($arg_include) && ($arg_exclude) &&
die("$0: Can not mix both include and exclude arguements ".
"on the command line.\n");
if ($arg_include) {
# check only the options listed
foreach $tag (keys %arg_tags) {
$CMP_TAGS{$tag} = 1;
}
} elsif ($arg_exclude) {
# check everything but the options listed
foreach $tag (@ALL_CMP_TAGS) {
$CMP_TAGS{$tag} = 1;
}
foreach $tag (keys %arg_tags) {
delete $CMP_TAGS{$tag};
}
} else {
# check the default options
foreach $tag (@DEFAULT_CMP) {
$CMP_TAGS{$tag} = 1;
}
}
($#ARGV == 1) ||
die("$0: Argument list must include two file names\n");
$RPMFILE0 = $ARGV[0];
$RPMFILE1 = $ARGV[1];
( !(-f $RPMFILE0) || !(-r $RPMFILE0) ) &&
die("$0: '$RPMFILE0' is not a readable file\n");
( !(-f $RPMFILE1) || !(-r $RPMFILE1) ) &&
die("$0: '$RPMFILE1' is not a readable file\n");
$CMP_MODE = ($opt_cmpmode == 1);
return ;
}
# read the rpmfile and extract the header information.
sub parse_rpm_headers {
my ($filename) = @_;
my $file = '';
my $out = {};
# read whole file into memory
{
open (RPMFILE, "<$filename")||
die("$0: Could not open: $filename for reading. $!\n");
# not needed on unix but lets be very clear
binmode (RPMFILE);
# slurp whole file
my $old_irs = $/;
undef $/;
$file = <RPMFILE>;
$/ = $old_irs;
close(RPMFILE)||
die("$0: Could not close: $filename. $!\n");
$file =~ m/^$RPM_FILE_MAGIC/ ||
die("$0: file: $filename is not an RPM file. ".
"No magic number found.\n");
}
# we want the second header block, as the first header is the
# signature block.
my ($header_start, $store_start) = ($LEAD_LENGTH,0);
my ($_version, $_reserved, $num_header_entries, $num_store_bytes) = ();
foreach $i (1 .. $HEADER_BLOCK_NUM) {
# find beginning of header,
$header_start = index($file, $RPM_HEADER_MAGIC, $header_start);
($header_start < 0) &&
die("$0: file: $filename is not an RPM file. ".
"No: $i, header found.\n");
$header_start += length($RPM_HEADER_MAGIC);
($_version, $_reserved, $num_header_entries, $num_store_bytes) =
unpack("CNNN", substr($file, $header_start, 1+(4*3)));
$header_start += 1+(4*3);
# find beginning of store
$store_start = $header_start +
($num_header_entries * $HEADER_RECORD_SIZE);
( ($store_start + $num_store_bytes) < length($file) ) ||
die("$0: File Parse Error, file: $filename, ".
"is not long enough to hold store.\n");
}
# the header is just a list of information about data.
# the data is stored in the store futher down the file.
my $header_position = $header_start;
foreach $i (0 .. $num_header_entries-1) {
my ($tag, $data_type, $offset, $data_count) =
unpack("N4", substr($file, $header_position, $HEADER_RECORD_SIZE));
$header_position += $HEADER_RECORD_SIZE;
(
( ($tag < 100) || ($tag > 1200) ) ||
( ($data_type < 0) || ($data_type > 10) ) ||
($offset < 0)
) && die("$0: Error parsing header in rpm file: $filename, ".
"record number: $i.\n");
# we are only interested in the tags which are defined
$RPMTAG->{$tag} || next;
foreach $j (0 .. $data_count-1) {
my $value ='';
if (0) {
# dummy for aliging the code like a case statement
} elsif ($data_type == 0) {
# null
$value = '';
} elsif ($data_type == 1) {
# char
$value = substr($file, $store_start+$offset, 1);
$offset += 1;
} elsif ($data_type == 2) {
# int8
$value = ord(substr($file, $store_start+$offset, 1));
$offset += 1;
} elsif ($data_type == 3) {
# int16
$value = unpack("n", substr($file, $store_start+$offset, 2));
$offset += 2;
} elsif ($data_type == 4) {
# int32
$value = unpack("N", substr($file, $store_start+$offset, 4));
$offset += 4;
} elsif ($data_type == 5) {
# int64
# ---- These aren't supported by RPM (yet) */
die("$0: int64 type found in rpm file: $filename, ".
"record number: $i.\n");
} elsif ($data_type == 6) {
# string
my $null_position = index ($file, "\0", $store_start+$offset);
my $length = $null_position - ($store_start+$offset);
$value = substr($file, $store_start+$offset, $length);
$offset += $length;
} elsif ($data_type == 7) {
# bin
# to properly support this I need to move it outside the $j
# loop. However I do not need it.
die("$0: Bin type found in rpm file: $filename, ".
"record number: $i.\n");
} elsif ($data_type == 8) {
# string_array
my $null_position = index ($file, "\0", $store_start+$offset);
my $length = $null_position - ($store_start+$offset);
$value = substr($file, $store_start+$offset, $length);
$offset += $length+1
} elsif ($data_type == 9) {
# this is listed as both RPM_I18NSTRING_TYPE and RPM_MAX_TYPE
# in file ~rpm/lib/header.h but I ignore it
die("$0: I18NSTRING type found in rpm file: $filename, ".
"record number: $i.\n");
}
push @{$out->{$tag}}, $value;
if ($RPMTAG->{$tag}->{"tag_name"} eq 'FILENAMES') {
$out->{'name2index'}->{$value} = $j;
}
} # foreach $j
} # foreach $i
return $out;
}
# traverse the datastructures to create a text representation of the
# critical differences between rpmscripts. If we are running in
# cmpmode and a difference is found exit early.
sub format_script_differences {
my ($rpm0, $rpm1) = @_;
my $out = '';;
my %seen = ();
foreach $script ( sort (keys %$RPMTAG) ) {
($RPMTAG->{$script}->{'is_script'}) || next;
($rpm0->{$script} || $rpm1->{$script}) || next;
my $prefix='';
if ( ($rpm0->{$script}) && (!($rpm1->{$script})) ) {
$prefix = 'missing ';
} elsif ( (!($rpm0->{$script})) && ($rpm1->{$script}) ) {
$prefix = 'added ';
} else {
my $diff_str = '';
foreach $cmp_tag (@ALL_CMP_TAGS) {
if ( !($CMP_TAGS{$cmp_tag}) ||
!($RPMTAG->{$cmp_tag}->{'script_cmp'}) ){
$diff_str .= '.';
next;
}
# In the rare case where an tag is defined in one RPM and not
# in another we charitably assume that the RPMs match on this
# tag. There is a warning in the stderr anyway.
if (
($rpm0->{$cmp_tag}) &&
($rpm1->{$cmp_tag}) &&
# use the anonymous comparison function (stored in the
# table) to compare the two scripts
(&{$RPMTAG->{$cmp_tag}->{'script_cmp'}}
($rpm0->{$script}->[0], $rpm1->{$script}->[0]))
) {
$diff_str .= $RPMTAG->{$cmp_tag}->{'diff_char'};
} else {
$diff_str .= '.';
}
} # foreach $tag
if ($diff_str ne $FILES_EQ_STRING) {
$prefix = $diff_str;
}
}
($prefix) || next;
if ($CMP_MODE) {
exit 1;
}
($NUM_DIFFERENCES < $MAX_EXIT) &&
$NUM_DIFFERENCES++;
$out .= "$prefix $RPMTAG->{$script}->{'tag_name'}\n";
} # foreach $filename
return $out;
}
# traverse the datastructures to create a text representation of the
# critical differences between file stored in the pacakge. If we are
# running in cmpmode and a difference is found exit early.
sub format_file_differences {
my ($rpm0, $rpm1) = @_;
my $out = '';;
my %seen = ();
foreach $filename ( sort (
(keys %{$rpm0->{'name2index'}}),
(keys %{$rpm1->{'name2index'}})
) ) {
$seen{$filename} && next;
$seen{$filename} = 1;
$index0 = $rpm0->{'name2index'}->{$filename};
$index1 = $rpm1->{'name2index'}->{$filename};
my $prefix='';
if ( ($index0) && (!($index1)) ) {
$prefix = 'missing ';
} elsif ( (!($index0)) && ($index1) ) {
$prefix = 'added ';
} else {
my $diff_str = '';
foreach $cmp_tag (@ALL_CMP_TAGS) {
if (!($CMP_TAGS{$cmp_tag})){
$diff_str .= '.';
next;
}
# In the rare case where an tag is defined in one RPM and not
# in another we charitably assume that the RPMs match on this
# tag. There is a warning in the stderr anyway.
if (
($rpm0->{$cmp_tag}->[$index0]) &&
($rpm1->{$cmp_tag}->[$index1]) &&
($rpm0->{$cmp_tag}->[$index0] ne
$rpm1->{$cmp_tag}->[$index1])
) {
$diff_str .= $RPMTAG->{$cmp_tag}->{'diff_char'};
} else {
$diff_str .= '.';
}
} # foreach $tag
if ($diff_str ne $FILES_EQ_STRING) {
$prefix = $diff_str;
}
}
($prefix) || next;
if ($CMP_MODE) {
die 1;
}
($NUM_DIFFERENCES < $MAX_EXIT) &&
$NUM_DIFFERENCES++;
# this set of blanks would contain information from the flags, if
# only I was not so lazy
$out .= "$prefix $filename\n";
} # foreach $filename
return $out;
}
# warn user of a cmp that was requested can not be carried out due to
# lack of data in the header of atleast one file.
sub data_missing_warnings {
my ($rpm0, $rpm1) = @_;
my $out = '';;
foreach $cmp_tag (@ALL_CMP_TAGS) {
if (!($CMP_TAGS{$cmp_tag})) {
next;
}
if ( ($CMP_TAGS{$cmp_tag}) &&
(!$rpm0->{$cmp_tag})
){
$out .= ("Comparison: '$RPMTAG->{$cmp_tag}->{'arg'}' ".
"specified, but data is not availible in ".
"rpm: $RPMFILE0.\n");
}
if ( ($CMP_TAGS{$cmp_tag}) &&
(!$rpm1->{$cmp_tag})
){
$out .= ("Comparison: '$RPMTAG->{$cmp_tag}->{'arg'}' ".
"specified, but data is not availible in ".
"rpm: $RPMFILE1.\n");
}
}
return $out;
}
# -------------- main --------------
{
set_static_vars();
parse_args();
$RPM0 = parse_rpm_headers($RPMFILE0);
$RPM1 = parse_rpm_headers($RPMFILE1);
my $warnings = data_missing_warnings($RPM0, $RPM1);
# we must print warnings before running diff as we may exit early.
($warnings) &&
warn($warnings);
my $header = "oldpkg $RPMFILE0\n"."newpkg $RPMFILE1\n"."\n\n";
my $script_diffs = format_script_differences($RPM0, $RPM1);
my $file_diffs = format_file_differences($RPM0, $RPM1);
($script_diffs || $file_diffs) &&
print $header, $script_diffs, $file_diffs;
exit $NUM_DIFFERENCES;
}