#!/usr/perl5/bin/perl -w

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

#

#

# Check ELF information.

#

# This script descends a directory hierarchy inspecting ELF dynamic executables

# and shared objects.  The general theme is to verify that common Makefile rules

# have been used to build these objects.  Typical failures occur when Makefile

# rules are re-invented rather than being inherited from "cmd/lib" Makefiles.

#

# As always, a number of components don't follow the rules, and these are

# excluded to reduce this scripts output.  Pathnames used for this exclusion

# assume this script is being run over a "proto" area.  The -a (all) option

# skips any exclusions.

#

# By default any file that has conditions that should be reported is first

# listed and then each condition follows.  The -o (one-line) option produces a

# more terse output which is better for sorting/diffing with "nightly".

#

# NOTE: missing dependencies, symbols or versions are reported by running the

# file through ldd(1).  As objects within a proto area are built to exist in a

# base system, standard use of ldd(1) will bind any objects to dependencies

# that exist in the base system.  It is frequently the case that newer objects

# exist in the proto area that are required to satisfy other objects

# dependencies, and without using these newer objects an ldd(1) will produce

# misleading error messages.  To compensate for this, the -d option (or the

# existence of the CODEMSG_WS/ROOT environment variables) cause the creation of

# alternative dependency mappings via crle(1) configuration files that establish

# any proto shared objects as alternatives to their base system location.  Thus

# ldd(1) can be executed against these configuration files so that objects in a

# proto area bind to their dependencies in the same proto area.

# Define all global variables (required for strict)

use vars  qw($SkipDirs $SkipFiles $SkipTextrelFiles $SkipDirectBindFiles);

use vars  qw($SkipUndefFiles $SkipUnusedDeps);

use vars  qw($SkipStabFiles $SkipNoExStkFiles $SkipCrleConf);

use vars  qw($SkipUnusedSearchPath $SkipUnrefObject $SkipUnusedObject);

use vars  qw($Prog $Mach $Isalist $Env $Ena64 $Tmpdir $Error $Gnuc);

use vars  qw($UnusedPaths $LddNoU $Crle32 $Crle64 $Conf32 $Conf64);

use vars  qw($SkipDirectBindDirs $SkipInterps $SkipSymSort $OldDeps %opt);

use strict;

# Define any directories we should skip completely.

$SkipDirs = qr{ 

	usr/lib/devfsadm |		# 4382889

	usr/lib/libc |			# optimized libc

	usr/lib/rcm |			# 4426119

	usr/perl5 |			# alan's taking care of these :-)

	usr/src				# no need to look at shipped source

}x;

# Define any files we should skip completely.

$SkipFiles = qr{ ^(?:

	lddstub |			# lddstub has no dependencies

	geniconvtbl\.so |		# 4384329

	libssagent\.so\.1 |		# 4328854

	libpsvcplugin_psr\.so\.1 |	# 4385799

	libpsvcpolicy_psr\.so\.1 |	#  "  "

	libpsvcpolicy\.so\.1 |		#  "  "

	picl_slm\.so |			#  "  "

	mod_ipp\.so |			# Apache loadable module

	fptest |	# USIII specific extns. cause ldd noise on USII bld. m/c

	grub

	)$

}x;

# Define any files that are allowed text relocations.

$SkipTextrelFiles = qr{ ^(?:

	unix |				# kernel models are non-pic

	mdb				# relocations against __RTC (dbx)

	)$

}x;

# Define any directories or files that are allowed to have no direct bound

# symbols

$SkipDirectBindDirs = qr{

	usr/ucb

}x;

$SkipDirectBindFiles = qr{ ^(?:

	unix |

	sbcp |

	libproc.so.1 |

	libnisdb.so.2

	)$

}x;

# Define any files that are allowed undefined references.

$SkipUndefFiles = qr{ ^(?:

	libsvm\.so\.1 |			# libspmicommon.so.1 lacking

	libnisdb\.so\.2			# C++

	)$

}x;

# Define any files that have unused dependencies.

$SkipUnusedDeps = qr{

	lib/picl/plugins/ |		# require devtree dependencies

	/lib/libp			# profile libc makes libm an unused

}x;					#	dependency of standard libc

# Define any objects that always look unused.

$SkipUnusedObject = qr{

	/libm_hwcap[0-9]+\.so\.2	# libm.so.2 dependency

}x;

# Define any files that should contain debugging information.

$SkipStabFiles = qr{ ^(?:

	unix

	)$

}x;

# Define any files that don't require a non-executable stack definition.

$SkipNoExStkFiles = qr{ ^(?:

	forth |

	unix |

	multiboot

	)$

}x;

# Identify any files that should be skipped when building a crle(1)

# configuration file.  As the hwcap libraries can be loop-back mounted onto

# libc, these can confuse crle(1) because of their identical dev/inode.

$SkipCrleConf = qr{

	lib/libc/libc_hwcap

}x;

# Skip "unused search path=" ldd(1) diagnostics.

$SkipUnusedSearchPath = qr{

	/usr/lib/fs/autofs.*\ from\ .automountd |		# dlopen()

	/etc/ppp/plugins.*\ from\ .*pppd |			# dlopen()

	/usr/lib/inet/ppp.*\ from\ .*pppd |			# dlopen()

	/usr/sfw/lib.*\ from\ .*libipsecutil.so.1 |		# dlopen()

	/usr/platform/.*rsmlib.*\ from\ .*librsm.so.2 |		# dlopen()

	\$ORIGIN.*\ from\ .*fcode.so |				# dlopen()

	/opt/VRTSvxvm/lib.*\ from\ .*libdiskmgt\.so\.1 |	# dlopen()

	/usr/platform/.*\ from\ .*/usr/platform |		# picl

	/usr/lib/picl/.*\ from\ .*/usr/platform |		# picl

	/usr/platform/.*\ from\ .*/usr/lib/picl |		# picl

	/usr/lib/smbsrv.*\ from\ .*libsmb\.so\.1 |		# future needs

	/usr/lib/mps/secv1.*\ from\ .*libnss3\.so |		# non-OSNet

	/usr/lib/mps.*\ from\ .*libnss3\.so |			# non-OSNet

	/usr/sfw/lib.*\ from\ .*libdbus-1\.so\.3 |		# non-OSNet

	/usr/sfw/lib.*\ from\ .*libdbus-glib-1\.so\.2 |		# non-OSNet

	/usr/sfw/lib.*\ from\ .*libglib-2\.0\.so\.0 |		# non-OSNet

	/usr/X11/lib.*\ from\ .*libglib-2\.0\.so\.0 |		# non-OSNet

	/usr/sfw/lib.*\ from\ .*libgobject-2\.0\.so\.0 |	# non-OSNet

	/usr/X11/lib.*\ from\ .*libgobject-2\.0\.so\.0 |	# non-OSNet

	/usr/sfw/lib.*\ from\ .*libcrypto\.so\.0\.9\.8 |	# non-OSNet

	/usr/sfw/lib.*\ from\ .*libnetsnmp\.so\.5 |		# non-OSNet

	/usr/sfw/lib.*\ from\ .*libgcc_s\.so\.1 |		# non-OSNet

	/usr.*\ from\ .*tst\.gcc\.exe |				# gcc built

	/usr/postgres/8.3/lib.*\ from\ .*libpq\.so\.5 |		# non-OSNET

	/usr/sfw/lib.*\ from\ .*libpq\.so\.5			# non-OSNET

}x;

# Skip "unreferenced object=" ldd(1) diagnostics.

$SkipUnrefObject = qr{

	/libmapmalloc\.so\.1;\ unused\ dependency\ of |		# interposer

	/libstdc\+\+\.so\.6;\ unused\ dependency\ of |		# gcc build

	/libm\.so\.2.*\ of\ .*libstdc\+\+\.so\.6 |		# gcc build

	/lib.*\ of\ .*/lib/picl/plugins/ |			# picl

	/lib.*\ of\ .*libcimapi\.so |				# non-OSNET

	/lib.*\ of\ .*libjvm\.so |				# non-OSNET

	/lib.*\ of\ .*libnetsnmp\.so\.5 |			# non-OSNET

	/lib.*\ of\ .*libnetsnmpagent\.so\.5 |			# non-OSNET

	/lib.*\ of\ .*libnetsnmpmibs\.so\.5 |			# non-OSNET

	/lib.*\ of\ .*libnetsnmphelpers\.so\.5 |		# non-OSNET

	/lib.*\ of\ .*libnspr4\.so |				# non-OSNET

	/lib.*\ of\ .*libsoftokn3\.so |				# non-OSNET

	/lib.*\ of\ .*libspmicommon\.so\.1 |			# non-OSNET

	/lib.*\ of\ .*libspmocommon\.so\.1 |			# non-OSNET

	/lib.*\ of\ .*libssl3\.so |				# non-OSNET

	/lib.*\ of\ .*libxml2\.so\.2 |				# non-OSNET

	/lib.*\ of\ .*libxslt\.so\.1 |				# non-OSNET

}x;

# Define any files that should only have unused (ldd -u) processing.

$UnusedPaths = qr{

	ucb/shutdown			# libucb interposes on libc and makes

					# dependencies on libc seem unnecessary

}x;

# Define interpreters we should ignore.

$SkipInterps = qr{

	misc/krtld |

	misc/amd64/krtld |

	misc/sparcv9/krtld

}x;

# Catch libintl and libw, although ld(1) will bind to these and thus determine

# they're needed, their content was moved into libc as of on297 build 7.

# libthread and libpthread were completely moved into libc as of on10 build 53.

# libdl was moved into libc as of on10 build 49.  librt and libaio were moved

# into libc as of Nevada build 44.

$OldDeps = qr{ ^(?:

	libintl\.so\.1 |

	libw\.so\.1 |

	libthread\.so\.1 |

	libpthread\.so\.1 |

	libdl\.so\.1 |

	librt\.so\.1 |

	libaio\.so\.1

	)$

}x;

# Files for which we skip checking of duplicate addresses in the

# symbol sort sections. Such exceptions should be rare --- most code will

# not have duplicate addresses, since it takes assember or a "#pragma weak"

# to do such aliasing in C. C++ is different: The compiler generates aliases

# for implementation reasons, and the mangled names used to encode argument

# and return value types are difficult to handle well in mapfiles.

# Furthermore, the Sun compiler and gcc use different and incompatible

# name mangling conventions. Since ON must be buildable by either, we

# would have to maintain two sets of mapfiles for each such object.

# C++ use is rare in ON, so this is not worth pursuing.

#

$SkipSymSort = qr{ ^.*(?:

	opt/SUNWdtrt/tst/common/pid/tst.weak2.exe |	# DTrace test

	lib/amd64/libnsl\.so\.1 |			# C++

	lib/sparcv9/libnsl\.so\.1 |			# C++

	lib/sparcv9/libfru\.so\.1 |			# C++

	usr/lib/sgml/nsgmls |				# C++

	usr/lib/lms |					# C++

	ld\.so\.1 |					# libc_pic.a user

	lib/libsun_fc\.so\.1 |				# C++

	lib/amd64/libsun_fc\.so\.1 |			# C++

	lib/sparcv9/libsun_fc\.so\.1 			# C++

	)$

}x;

use Getopt::Std;

# -----------------------------------------------------------------------------

# Reliably compare two OS revisions.  Arguments are <ver1> <op> <ver2>.

# <op> is the string form of a normal numeric comparison operator.

sub cmp_os_ver {

	my @ver1 = split(/\./, $_[0]);

	my $op = $_[1];

	my @ver2 = split(/\./, $_[2]);

	push @ver2, ("0") x $#ver1 - $#ver2;

	push @ver1, ("0") x $#ver2 - $#ver1;

	my $diff = 0;

	while (@ver1 || @ver2) {

		if (($diff = shift(@ver1) - shift(@ver2)) != 0) {

			last;

		}

	}

	return (eval "$diff $op 0" ? 1 : 0);

}

# This script relies on ldd returning output reflecting only the binary 

# contents.  But if LD_PRELOAD* environment variables are present, libraries

# named by them will also appear in the output, disrupting our analysis.

# So, before we get too far, scrub the environment.

delete($ENV{LD_PRELOAD});

delete($ENV{LD_PRELOAD_32});

delete($ENV{LD_PRELOAD_64});

# Establish a program name for any error diagnostics.

chomp($Prog = `basename $0`);

# Determine what machinery is available.

$Mach = `uname -p`;

$Isalist = `isalist`;

$Env = "";

if ($Mach =~ /sparc/) {

	if ($Isalist =~ /sparcv9/) {

		$Ena64 = "ok";

	}

} elsif ($Mach =~ /i386/) {

	if ($Isalist =~ /amd64/) {

		$Ena64 = "ok";

	}

}

# Check that we have arguments.

if ((getopts('ad:imosv', \%opt) == 0) || ($#ARGV == -1)) {

	print "usage: $Prog [-a] [-d depdir] [-m] [-o] [-s] file | dir, ...\n";

	print "\t[-a]\t\tprocess all files (ignore any exception lists)\n";

	print "\t[-d dir]\testablish dependencies from under directory\n";

	print "\t[-i]\t\tproduce dynamic table entry information\n";

	print "\t[-m]\t\tprocess mcs(1) comments\n";

	print "\t[-o]\t\tproduce one-liner output (prefixed with pathname)\n";

	print "\t[-s]\t\tprocess .stab and .symtab entries\n";

	print "\t[-v]\t\tprocess version definition entries\n";

	exit 1;

} else {

	my($Proto);

	if ($opt{d}) {

		# User specified dependency directory - make sure it exists.

		if (! -d $opt{d}) {

			print "$Prog: $opt{d} is not a directory\n";

			exit 1;

		}

		$Proto = $opt{d};

	} elsif ($ENV{CODEMGR_WS}) {

		my($Root);

		# Without a user specified dependency directory see if we're

		# part of a codemanager workspace and if a proto area exists.

		if (($Root = $ENV{ROOT}) && (-d $Root)) {

			$Proto = $Root;

		}

	}

	if (!($Tmpdir = $ENV{TMPDIR}) || (! -d $Tmpdir)) {

		$Tmpdir = "/tmp";

	}

	# Determine whether this is a __GNUC build.  If so, unused search path

	# processing is disabled.

	if (defined $ENV{__GNUC}) {

		$Gnuc = 1;

	} else {

		$Gnuc = 0;

	}

	# Look for dependencies under $Proto.

	if ($Proto) {

		# To support alternative dependency mapping we'll need ldd(1)'s

		# -e option.  This is relatively new (s81_30), so make sure

		# ldd(1) is capable before gathering any dependency information.

		if (system('ldd -e /usr/lib/lddstub 2> /dev/null')) {

			print "ldd: does not support -e, unable to ";

			print "create alternative dependency mappingings.\n";

			print "ldd: option added under 4390308 (s81_30).\n\n";

		} else {

			# Gather dependencies and construct a alternative

			# dependency mapping via a crle(1) configuration file.

			GetDeps($Proto, "/");

			GenConf();

		}

	}

	# To support unreferenced dependency detection we'll need ldd(1)'s -U

	# option.  This is relatively new (4638070), and if not available we

	# can still fall back to -u.  Even with this option, don't use -U with

	# releases prior to 5.10 as the cleanup for -U use only got integrated

	# into 5.10 under 4642023.  Note, that nightly doesn't typically set a

	# RELEASE from the standard <env> files.  Users who wish to disable use

	# of ldd(1)'s -U should set (or uncomment) RELEASE in their <env> file

	# if using nightly, or otherwise establish it in their environment.

	if (system('ldd -U /usr/lib/lddstub 2> /dev/null')) {

		$LddNoU = 1;

	} else {

		my($Release);

		if (($Release = $ENV{RELEASE}) &&

		    (cmp_os_ver($Release, "<", "5.10"))) {

			$LddNoU = 1;

		} else {

			$LddNoU = 0;

		}

	}

	# For each argument determine if we're dealing with a file or directory.

	foreach my $Arg (@ARGV) {

		# Ignore symbolic links.

		if (-l $Arg) {

			next;

		}

		if (!stat($Arg)) {

			next;

		}

		# Process simple files.

		if (-f _) {

			my($RelPath) = $Arg;

			my($File) = $Arg;

			my($Secure) = 0;

			$RelPath =~ s!^.*/!./!;

			$File =~ s!^.*/!!;

			if (-u _ || -g _) {

				$Secure = 1;

			}

			ProcFile($Arg, $RelPath, $File, $Secure);

			next;

		}

		# Process directories.

		if (-d _) {

			ProcDir($Arg, ".");

			next;

		}

		print "$Arg is not a file or directory\n";

		$Error = 1;

	}

	# Cleanup

	CleanUp();

}

$Error = 0;

# Clean up any temporary files.

sub CleanUp {

	if ($Crle64) {

		unlink $Crle64;

	}

	if ($Conf64) {

		unlink $Conf64;

	}

	if ($Crle32) {

		unlink $Crle32;

	}

	if ($Conf32) {

		unlink $Conf32;

	}

}

# Create an output message, either a one-liner (under -o) or preceded by the

# files relative pathname as a title.

sub OutMsg {

	my($Ttl, $Path, $Msg) = @_;

	if ($opt{o}) {

		$Msg =~ s/^[ \t]*//;

		print "$Path: $Msg\n";

	} else {

		if ($Ttl eq 0) {

			print "==== $Path ====\n";

		}

		print "$Msg\n";

	}

}

# Determine whether this a ELF dynamic object and if so investigate its runtime

# attributes.

sub ProcFile {

	my($FullPath, $RelPath, $File, $Secure) = @_;

	my(@Elf, @Ldd, $Dyn, $Intp, $Dll, $Ttl, $Sym, $Interp, $Stack);

	my($Sun, $Relsz, $Pltsz, $Tex, $Stab, $Strip, $Lddopt, $SymSort);

	my($Val, $Header, $SkipLdd, $IsX86, $RWX, $UnDep);

	my($HasDirectBinding, $HasVerdef);

	# Ignore symbolic links.

	if (-l $FullPath) {

		return;

	}

	$Ttl = 0;

	@Ldd = 0;

	# Determine whether we have access to inspect the file.

	if (!(-r $FullPath)) {

		OutMsg($Ttl++, $RelPath,

		    "\tunable to inspect file: permission denied");

		return;

	}

	# Determine if this is a file we don't care about.

	if (!$opt{a}) {

		if ($File =~ $SkipFiles) {

			return;

		}

	}

	# Determine whether we have a executable (static or dynamic) or a

	# shared object.

	@Elf = split(/\n/, `elfdump -epdicyv $FullPath 2>&1`);

	$Dyn = $Intp = $Dll = $Stack = $IsX86 = $RWX = 0;

	$Interp = 1;

	$Header = 'None';

	foreach my $Line (@Elf) {

		# If we have an invalid file type (which we can tell from the

		# first line), or we're processing an archive, bail.

		if ($Header eq 'None') {

			if (($Line =~ /invalid file/) ||

			    ($Line =~ /$FullPath(.*):/)) {

				return;

			}