#!/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, Version 1.0 only

# (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 2005 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

# ident	"%Z%%M%	%I%	%E% SMI"

#

# 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);

use vars  qw($SkipUndefDirs $SkipUndefFiles $SkipUnusedDirs $SkipUnusedFiles);

use vars  qw($SkipStripDirs $SkipNoStripFiles $SkipStabFiles $SkipNoExStkFiles);

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

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

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

use strict;

# Define any directories we should skip completely.

$SkipDirs = qr{ 

	etc/lib |			# special - used for partial statics

	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{ ^(?:

	ld\.so\.1 |			# confusing but correct dependencies

	lddstub |			# lddstub has no dependencies

	libmakestate\.so\.1 |		# temporary; delivered by compiler group

	libm\.so\.1 |			# temporary; delivered by compiler group

	libm\.so\.2 |			# temporary; delivered by compiler group

	geniconvtbl\.so |		# 4384329

	libssagent\.so\.1 |		# 4328854

	libdmi\.so\.1 |			#  "  "

	libdmici\.so\.1 |		#  "  "

	libdmimi\.so\.1 |		#  "  "

	libpsvcplugin_psr\.so\.1 |	# 4385799

	libpsvcpolicy_psr\.so\.1 |	#  "  "

	libpsvcpolicy\.so\.1 |		#  "  "

	picl_slm\.so |			#  "  "

	libcrypto_extra\.so\.0\.9\.7 |	# OpenSSL SUNWcry filter lib

	libssl_extra\.so\.0\.9\.7 |	# OpenSSL SUNWcry filter lib

	fcpackage\.so |			# circular dependency on fcthread.so

	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 files that are allowed undefined references.

$SkipUndefDirs = qr{

	usr/lib/inet/ppp/ |		# pppd plugins have callbacks

	usr/lib/libp/ |			# libc.so.1 requires _mcount

	usr/lib/vold/ |			# vold dependencies have callbacks

	usr/lib/rmmount |		# rmmount actions have callbacks

	/lib/mdb/ |			# mdb modules have callbacks

	/lib/fm/fmd/plugins/ |		# fmd modules have callbacks

	/lib/fm/fmd/schemes/ 		# fmd schemes have callbacks

}x;

$SkipUndefFiles = qr{ ^(?:

	libthread_db\.so\.0 |		# callbacks to proc service interface

	libthread_db\.so\.1 |		#  "	"	"	"

	librtld_db\.so\.1 |		#  "	"	"	"

	libc_db\.so\.1 |		#  "	"	"	"

	libldstab\.so\.1 |		# link-edit support libraries have

	libld\.so\.3 |			# callback to the link-editors

	libld\.so\.2 |			#  "	"	"	"

	liblddbg\.so\.4 |		#  "	"	"	"

	librtld\.so\.1 |		#  "	"	"	"

	libnisdb\.so\.2 |		# C++

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

	libwanboot\.so\.1 |		# libcrypto.a and libssl.a

	libwrap\.so\.1\.0 |		# uses symbols provided by application

	fcthread\.so |			# uses symbols provided by application

	fn\.so\.2 |			# callback to automount

	preen_md\.so\.1 |		# callback to driver

	libike\.so\.1 |			# callbacks to in.iked for IKE policy

	devfsadmd_mod\.so |		# sysevent module callback to syseventd

	sysevent_conf_mod\.so |		# sysevent module callback to syseventd

	sysevent_reg_mod\.so		# sysevent module callback to syseventd

	)$

}x;

# Define any files that have unused dependencies.

$SkipUnusedDirs = qr{

	lib/picl/plugins/ |		# require devtree dependencies

	/lib/libp			# profile libc makes libm an unused

}x;					#	dependency of standard libc

$SkipUnusedFiles = qr{ ^(?:

	devfsadm |			# 4382889

	disks |				#  "  "

	tapes |				#  "  "

	ports |				#  "  "

	audlinks |			#  "  "

	devlinks |			#  "  "

	drvconfig |			#  "  "

	ntptrace |			# on intel doesn't need libmd5

	rmmount |			# 4418770, volmgt dependency is required

					#	to compensate for SunPCi.

	ocfserv |			# libsched unreference by libjvm,

	poold |				#	see 4952319. 

	libc\.so\.1\.9 |		# 4lib/libc versions have private

	libc\.so\.2\.9			#	copies of stuff from libc.

	)$

}x;

# Define any files that can be stripped.

$SkipStripDirs = qr{

	/abi/

}x;

# Define any files that must not be stripped.

$SkipNoStripFiles = qr{ ^(?:

	adb |

	mdb |

	unix

	)$

}x;

# Define any files that should contain debugging information.

$SkipStabFiles = qr{ ^(?:

	abi_.* |

	interceptors\.so\.1 |

	unix

	)$

}x;

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

$SkipNoExStkFiles = qr{ ^(?:

	forth |

	unix |

	multiboot

	)$

}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;

$UnusedFiles = qr{ ^(?:

	rpc\.nisd			# CCNEEDED makes pthread unreferenced

	)$

}x;

# Define unused dependencies we should ignore.

# libCrun has a unnecessary dependency on libw, and libmapmalloc is often

# defined to interpose on libc but isn't used by the application itself.

# Threads dependencies look unused if libc is bound first.

$UnusedNoise = qr{

	libw\.so\.1;\ unused |

	unused\ object=.*libw\.so\.1 |

	libthread\.so\.1;\ unused |

	libpthread\.so\.1;\ unused |

	unused\ object=.*libpthread\.so\.1 |

	libnsl\.so\.1;\ unused\ dependency\ of\ .*libxslt\.so\.1 |

	libdl\.so\.1;\ unused\ dependency\ of\ .*libspmicommon\.so\.1 |

	libdl\.so\.1;\ unused\ dependency\ of\ .*libCrun\.so\.1 |

	libfru\.so\.1;\ unused\ object=.*libdl\.so\.1 |

	libfrupicl\.so\.1;\ unused\ object=.*libdl\.so\.1 |

	libmapmalloc\.so\.1;\ unused

}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.

# Also, catch libdl, whose content was moved into libc as of on10 build 49.

$OldDeps = qr{ ^(?:

	libintl\.so\.1 |

	libw\.so\.1 |

	libthread\.so\.1 |

	libpthread\.so\.1 |

	libdl\.so\.1

	)$

}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);

}

# 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:imos', \%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";

	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";

	}

	# 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 and 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, $Uns, $Tex, $Stab, $Strip, $Lddopt);

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

	# 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 -epdic $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;

			}

		}

		if ($Line =~ /^ELF Header/) {

			$Header = 'Ehdr';

		} elsif ($Line =~ /^Program Header/) {

			$Header = 'Phdr';

			$RWX = 0;

		} elsif ($Line =~ /^Interpreter/) {

			$Header = 'Intp';

		} elsif ($Line =~ /^Dynamic Section/) {

			# A dynamic section indicates we're a dynamic object

			# (this makes sure we don't check static executables).

			$Dyn = 1;

		} elsif (($Header eq 'Ehdr') && ($Line =~ /e_type:/)) {

			# The e_type field indicates whether this file is a

			# shared object (ET_DYN) or an executable (ET_EXEC).

			if ($Line =~ /ET_DYN/) {

				$Dll = 1;

			} elsif ($Line !~ /ET_EXEC/) {

				return;

			}

		} elsif (($Header eq 'Ehdr') && ($Line =~ /ei_class:/)) {

			# If we encounter a 64-bit object, but we're not running

			# on a 64-bit system, suppress calling ldd(1).

			if (($Line =~ /ELFCLASS64/) && !$Ena64) {

				$SkipLdd = 1;

			}

		} elsif (($Header eq 'Ehdr') && ($Line =~ /e_machine:/)) {

			# If it's a X86 object, we need to enforce RW- data.

			if (($Line =~ /(EM_AMD64|EM_386)/)) {

				$IsX86 = 1;

			}

		} elsif (($Header eq 'Phdr') &&

		    ($Line =~ /\[ PF_X  PF_W  PF_R \]/)) {

			# RWX segment seen.

			$RWX = 1;

		} elsif (($Header eq 'Phdr') &&

		    ($Line =~ /\[ PT_LOAD \]/ && $RWX && $IsX86)) {

			# Seen an RWX PT_LOAD segment.

			if ($File !~ $SkipNoExStkFiles) {

				OutMsg($Ttl++, $RelPath,

				    "\tapplication requires non-executable " .

				    "data\t<no -Mmapfile_noexdata?>");

			}