+ my $devstr;
+ foreach $dev (sort {$a <=> $b} keys %devices) {
+ $devstr = sprintf ("0x%04x", $dev);
+ if ( $dev > 0xffffffff or $dev < 0 or hex($devstr) != $dev ) {
+ # sprintf "%x" will not return a useful value for device ids
+ # that are negative or which overflow the integer size on this
+ # instance of Perl, so we convert the hex string back to a
+ # number, and if it doesn't (numerically) equal the original
+ # device id value, we know the hex conversion hasn't worked.
+ #
+ # Unfortunately, since we're running in "-w" mode, Perl will
+ # also print a warning message if the hex() routine is called
+ # on anything larger than "0xffffffff", even in 64-bit Perl
+ # where such values are actually supported... so we have to
+ # avoid calling hex() at all if the device id is too large or
+ # negative. (If it's negative, the conversion to an unsigned
+ # integer for the "%x" specifier will mean the result will
+ # always trigger hex()'s warning on a 64-bit machine.)
+ #
+ # These situations don't seem to occur very often, so for now
+ # when they do occur, we simply print the original text value
+ # that was read from the snapshot file; it will look a bit
+ # funny next to the values that do print in hex, but that's
+ # preferable to printing values that aren't actually correct.
+ $devstr = $dev;
+ }
+ printf " Device %s occurs $devices{$dev} times.\n", $devstr;
+ }
+}
+
+## check field values
+
+# initializes the global %snapshot_field_ranges hash, based on the "-a"
+# command-line option if given, otherwise based on the "archname" of
+# the current system.
+#
+# Each value in the hash is a two-element array containing the minimum
+# and maximum allowed values, respectively, for that field in the snapshot
+# file. GNU tar's allowed values for each architecture are determined
+# in the incremen.c source file, where the TYPE_MIN and TYPE_MAX
+# pre-processor expressions are used to determine the range that can be
+# expressed by the C data type used for each field; the values in the
+# array defined below should match those calculations. (For tar v1.27
+# and later, the valid ranges for a particular tar binary can easily
+# be determined using the "tar --show-snapshot-field-ranges" command.)
+
+sub choose_architecture ($) {
+ my $opt_a = shift;
+
+ my $arch = $opt_a ? $opt_a : $Config{'archname'};
+
+ # These ranges apply to Linux 2.4/2.6 on iX86 systems, but are used
+ # by default on unrecognized/unsupported systems, too.
+ %iX86_linux_field_ranges = (
+ timestamp_sec => [ -2147483648, 2147483647 ], # min/max of time_t
+ timestamp_nsec => [ 0, 999999999 ], # 0 to BILLION-1
+ nfs => [ 0, 1 ],
+ dev => [ 0, 18446744073709551615 ], # min/max of dev_t
+ ino => [ 0, 4294967295 ], # min/max of ino_t
+ );
+
+
+ if ( $arch =~ m/^i[\dxX]86-linux/i ) {
+ %snapshot_field_ranges = %iX86_linux_field_ranges;
+ print "Checking snapshot field values using \"iX86-linux\" ranges.\n\n";
+ } elsif ( $arch =~ m/^x86_64-linux/i ) {
+ %snapshot_field_ranges = (
+ timestamp_sec => [ -9223372036854775808, 9223372036854775807 ],
+ timestamp_nsec => [ 0, 999999999 ],
+ nfs => [ 0, 1 ],
+ dev => [ 0, 18446744073709551615 ],
+ ino => [ 0, 18446744073709551615 ],
+ );
+ print "Checking snapshot field values using \"x86_64-linux\" ranges.\n\n";
+ } elsif ( $arch =~ m/^IA64.ARCHREV_0/i ) {
+ # HP/UX running on Itanium/ia64 architecture
+ %snapshot_field_ranges = (
+ timestamp_sec => [ -2147483648, 2147483647 ],
+ timestamp_nsec => [ 0, 999999999 ],
+ nfs => [ 0, 1 ],
+ dev => [ -2147483648, 2147483647 ],
+ ino => [ 0, 4294967295 ],
+ );
+ print "Checking snapshot field values using \"IA64.ARCHREV_0\" (HP/UX) ranges.\n\n";
+ } else {
+ %snapshot_field_ranges = %iX86_linux_field_ranges;
+ print "Unrecognized architecture \"$arch\"; defaulting to \"iX86-linux\".\n";
+ print "(Use -a option to override.)\n" unless $opt_a;
+ print "\n";
+ }
+
+ if ( ref(1) ne "" ) {
+ print "(\"bignum\" mode is in effect; skipping 64-bit-integer check.)\n\n"
+ } else {
+ # find the largest max value in the current set of ranges
+ my $maxmax = 0;
+ for $v (values %snapshot_field_ranges ) {
+ $maxmax = $v->[1] if ($v->[1] > $maxmax);
+ }
+
+ # "~0" translates into a platform-native integer with all bits turned
+ # on -- that is, the largest value that can be represented as
+ # an integer. We print a warning if our $maxmax value is greater
+ # than that largest integer, since in that case Perl will switch
+ # to using floats for those large max values. The wording of
+ # the message assumes that the only way this situation can exist
+ # is that the platform uses 32-bit integers but some of the
+ # snapshot-file fields have 64-bit values.
+ if ( ~0 < $maxmax ) {
+ print <<EOF
+Note: this version of Perl uses 32-bit integers, which means that it
+ will switch to using floating-point numbers when checking the ranges
+ for 64-bit snapshot-file fields. This normally will work fine, but
+ might fail to detect cases where the value in the input field value is
+ only slightly out of range. (For example, a "9223372036854775808"
+ might not be recognized as being larger than 9223372036854775807.)
+ If you suspect you are experiencing this problem, you can try running
+ the program using the "-Mbignum" option, as in
+ \$ perl $0 -Mbignum -c [FILES]
+ (but doing so will make the program run *much* slower).
+
+EOF
+ }
+ }
+
+
+}
+
+# returns a warning message if $field_value isn't a valid string
+# representation of an integer, or if the resulting integer is out of range
+# defined by the two-element array retrieved using up the $field_name key in
+# the global %snapshot_field_ranges hash.
+sub validate_integer_field ($$) {
+ my $field_value = shift;
+ my $field_name = shift;
+
+ my ($min, $max) = @{$snapshot_field_ranges{$field_name}};
+
+ my $msg = "";
+
+ if ( not $field_value =~ /^-?\d+$/ ) {
+ $msg = " $field_name value contains invalid characters: \"$field_value\"\n";
+ } else {
+ if ( $field_value < $min ) {
+ $msg = " $field_name value too low: \"$field_value\" < $min \n";
+ } elsif ( $field_value > $max ) {
+ $msg = " $field_name value too high: \"$field_value\" > $max \n";
+ }
+ }
+ return $msg;
+}
+
+
+# This routine loops through each directory entry in the $info data
+# structure and prints a warning message if tar would abort with an
+# "Unexpected field value in snapshot file", "Numerical result out of
+# range", or "Invalid argument" error upon reading this snapshot file.
+#
+# (Note that the "Unexpected field value in snapshot file" error message
+# was introduced along with the change to snapshot file format "2",
+# starting with tar v1.16 [or, more precisely, v1.15.91], while the
+# other two were introduced in v1.27.)
+#
+# The checks here are intended to match those found in the incremen.c
+# source file. See the choose_architecture() function (above) for more
+# information on how to configure the range of values considered valid
+# by this script.
+#
+# (Note: the checks here are taken from the code that processes
+# version 2 snapshot files, but to keep things simple we apply those
+# same checks to files having earlier versions -- but only for
+# the fields that actually exist in those input files.)
+
+sub check_field_values ($) {
+ my $info = shift;
+
+ my $msg;
+ my $error_found = 0;
+
+ print " Checking field values in snapshot file...\n";
+
+ $snapver = $info->[0];
+
+ $msg = "";
+ $msg .= validate_integer_field($info->[1], 'timestamp_sec');
+ if ($snapver >= 1) {
+ $msg .= validate_integer_field($info->[2], 'timestamp_nsec');