#!/usr/sfw/bin/python

#

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

# Use is subject to license terms.

#

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

#

# wsdiff(1) is a tool that can be used to determine which compiled objects

# have changed as a result of a given source change. Developers backporting

# new features, RFEs and bug fixes need to be able to identify the set of

# patch deliverables necessary for feature/fix realization on a patched system.

#

# The tool works by comparing objects in two trees/proto areas (one build with,

# and without the source changes.

#

# Using wsdiff(1) is fairly simple:

#	- Bringover to a fresh workspace

#	- Perform a full non-debug build (clobber if workspace isn't fresh)

#	- Move the proto area aside, call it proto.old, or something.

#	- Integrate your changes to the workspace

#	- Perform another full non-debug clobber build.

#	- Use wsdiff(1) to see what changed:

#		$ wsdiff proto.old proto

#

# By default, wsdiff will print the list of changed objects / deliverables to

# stdout. If a results file is specified via -r, the list of differing objects,

# and details about why wsdiff(1) thinks they are different will be logged to

# the results file.

#

# By invoking nightly(1) with the -w option to NIGHTLY_FLAGS, nightly(1) will use

# wsdiff(1) to report on what objects changed since the last build.

#

# For patch deliverable purposes, it's advised to have nightly do a clobber,

# non-debug build.

#

# Think about the results. Was something flagged that you don't expect? Go look

# at the results file to see details about the differences.

#

# Use the -i option in conjunction with -v and -V to dive deeper and have wsdiff(1)

# report with more verbosity.

#

# Usage: wsdiff [-vVt] [-r results ] [-i filelist ] old new

#

# Where "old" is the path to the proto area build without the changes, and

# "new" is the path to the proto area built with the changes. The following

# options are supported:

#

#        -v      Do not truncate observed diffs in results

#        -V      Log *all* ELF sect diffs vs. logging the first diff found

#        -t      Use onbld tools in $SRC/tools

#        -r      Log results and observed differences

#        -i      Tell wsdiff which objects to compare via an input file list

import datetime, fnmatch, getopt, profile, os, popen2, commands

import re, select, string, struct, sys, tempfile, time

from stat import *

# Human readable diffs truncated by default if longer than this

# Specifying -v on the command line will override

diffs_sz_thresh = 4096

# Default search path for wsdiff

wsdiff_path = [ "/usr/bin",

		"/usr/ccs/bin",

		"/lib/svc/bin",

		"/opt/onbld/bin" ]

# These are objects that wsdiff will notice look different, but will not report.

# Existence of an exceptions list, and adding things here is *dangerous*,

# and therefore the *only* reasons why anything would be listed here is because

# the objects do not build deterministically, yet we *cannot* fix this.

#

# These perl libraries use __DATE__ and therefore always look different.

# Ideally, we would purge use the use of __DATE__ from the source, but because

# this is source we wish to distribute with Solaris "unchanged", we cannot modify.

#

wsdiff_exceptions = [ "usr/perl5/5.8.4/lib/sun4-solaris-64int/CORE/libperl.so.1",

		      "usr/perl5/5.6.1/lib/sun4-solaris-64int/CORE/libperl.so.1",

		      "usr/perl5/5.8.4/lib/i86pc-solaris-64int/CORE/libperl.so.1",

		      "usr/perl5/5.6.1/lib/i86pc-solaris-64int/CORE/libperl.so.1"

		      ]

#####

# Logging routines

#

# Informational message to be printed to the screen, and the log file

def info(msg) :

	print >> sys.stdout, msg

	if logging :

		print >> log, msg

	sys.stdout.flush()

# Error message to be printed to the screen, and the log file

def error(msg) :

	print >> sys.stderr, "ERROR:", msg

	sys.stderr.flush()

	if logging :

		print >> log, "ERROR:", msg

		log.flush()

# Informational message to be printed only to the log, if there is one.

def v_info(msg) :

	if logging :

		print >> log, msg

		log.flush()

#

# Flag a detected file difference

# Display the fileName to stdout, and log the difference

#

def difference(f, dtype, diffs) :

	if f in wsdiff_exceptions :

		return

	print >> sys.stdout, f

	sys.stdout.flush()

	log_difference(f, dtype, diffs)

#

# Do the actual logging of the difference to the results file

#

def log_difference(f, dtype, diffs) :

	if logging :

		print >> log, f

		print >> log, "NOTE:", dtype, "difference detected."

		difflen = len(diffs)

		if difflen > 0 :				

			print >> log

			if not vdiffs and difflen > diffs_sz_thresh :

				print >> log, diffs[:diffs_sz_thresh]

				print >> log, \

				      "... truncated due to length: " \

				      "use -v to override ..."

			else :

				print >> log, diffs

			print >> log, "\n"

		log.flush()

#####

# diff generating routines

#

#

# Return human readable diffs from two temporary files

#

def diffFileData(tmpf1, tmpf2) :

	# Filter the data through od(1) if the data is detected

	# as being binary

	if isBinary(tmpf1) or isBinary(tmpf2) :

		tmp_od1 = tmpf1 + ".od"

		tmp_od2 = tmpf2 + ".od"

		cmd = od_cmd + " -c -t x4" + " " + tmpf1 + " > " + tmp_od1

		os.system(cmd)

		cmd = od_cmd + " -c -t x4" + " " + tmpf2 + " > " + tmp_od2

		os.system(cmd)

		tmpf1 = tmp_od1

		tmpf2 = tmp_od2

	data = commands.getoutput(diff_cmd + " " + tmpf1 + " " + tmpf2)

	return data

#

# Return human readable diffs betweeen two datasets

#

def diffData(d1, d2) :

	global tmpFile1

	global tmpFile2

	try:

		fd1 = open(tmpFile1, "w")

	except:

		error("failed to open: " + tmpFile1)

		cleanup(1)

	try:

		fd2 = open(tmpFile2, "w")

	except:

		error("failed to open: " + tmpFile2)

		cleanup(1)

	fd1.write(d1)

	fd2.write(d2)

	fd1.close()

	fd2.close()

	return diffFileData(tmpFile1, tmpFile2)

#####

# Misc utility functions

#

# Prune off the leading prefix from string s

def str_prefix_trunc(s, prefix) :

	snipLen = len(prefix)

	return s[snipLen:]

#

# Prune off leading proto path goo (if there is one) to yield

# the deliverable's eventual path relative to root

# e.g. proto.base/root_sparc/usr/src/cmd/prstat => usr/src/cmd/prstat

# 

def fnFormat(fn) :

	root_arch_str = "root_" + arch

	pos = fn.find(root_arch_str)

	if pos == -1 :

		return fn

	pos = fn.find("/", pos)

	if pos == -1 :

		return fn

	return fn[pos + 1:]

#####

# Usage / argument processing

#

#

# Display usage message

#

def usage() :

	sys.stdout.flush()

	print >> sys.stderr, """Usage: wsdiff [-vVt] [-r results ] [-i filelist ] old new

        -v      Do not truncate observed diffs in results

        -V      Log *all* ELF sect diffs vs. logging the first diff found

        -t      Use onbld tools in $SRC/tools

        -r      Log results and observed differences

        -i      Tell wsdiff which objects to compare via an input file list"""

	sys.exit(1)

#

# Process command line options

#

def args() :

	global logging

	global vdiffs

	global reportAllSects

	validOpts = 'i:r:vVt?'

	baseRoot = ""

	ptchRoot = ""

	fileNamesFile = ""

	results = ""

	localTools = False

	# getopt.getopt() returns:

	#	an option/value tuple

	#	a list of remaining non-option arguments

	#

	# A correct wsdiff invocation will have exactly two non option

	# arguments, the paths to the base (old), ptch (new) proto areas

	try:

		optlist, args = getopt.getopt(sys.argv[1:], validOpts)

	except getopt.error, val:

		usage()

	if len(args) != 2 :

		usage();

	for opt,val in optlist :

		if opt == '-i' :

			fileNamesFile = val

		elif opt == '-r' :

			results = val

			logging = True

		elif opt == '-v' :

			vdiffs = True

		elif opt == '-V' :

			reportAllSects = True

		elif opt == '-t':

			localTools = True

		else:

			usage()

	baseRoot = args[0]

	ptchRoot = args[1]

	if len(baseRoot) == 0 or len(ptchRoot) == 0 :

		usage()

	if logging and len(results) == 0 :

		usage()

	if vdiffs and not logging :

		error("The -v option requires a results file (-r)")

		sys.exit(1)

	if reportAllSects and not logging :

		error("The -V option requires a results file (-r)")

		sys.exit(1)

	# alphabetical order

	return	baseRoot, fileNamesFile, localTools, ptchRoot, results

#####

# File identification

#

#

# Identify the file type.

# If it's not ELF, use the file extension to identify

# certain file types that require special handling to

# compare. Otherwise just return a basic "ASCII" type.

#

def getTheFileType(f) :

	extensions = { 'a'	:	'ELF Object Archive',

		       'jar'	:	'Java Archive',

		       'html'	:	'HTML',

		       'ln'	:	'Lint Library',

		       'db'	:	'Sqlite Database' }

	if os.stat(f)[ST_SIZE] == 0 :

		return 'ASCII'

	if isELF(f) == 1 :

		return 'ELF'

	fnamelist = f.split('.')

	if len(fnamelist) > 1 :	# Test the file extension

		extension = fnamelist[-1]

		if extension in extensions.keys():

			return extensions[extension]

	return 'ASCII'

#

# Return non-zero if "f" is an ELF file

#

elfmagic = '\177ELF'

def isELF(f) :

	try:

		fd = open(f)

	except:

		error("failed to open: " + f)

		return 0

	magic = fd.read(len(elfmagic))

	fd.close()

	if magic == elfmagic :

		return 1

	return 0

#

# Return non-zero is "f" is binary.

# Consider the file to be binary if it contains any null characters

# 

def isBinary(f) :

	try:

		fd = open(f)

	except:

		error("failed to open: " + f)

		return 0

	s = fd.read()

	fd.close()

	if s.find('\0') == -1 :

		return 0

	else :

		return 1

#####

# Directory traversal and file finding

# 

#

# Return a sorted list of files found under the specified directory

#

def findFiles(d) :

	for path, subdirs, files in os.walk(d) :

		files.sort()

		for name in files :

			yield os.path.join(path, name)

#

# Examine all files in base, ptch

#

# Return a list of files appearing in both proto areas,

# a list of new files (files found only in ptch) and

# a list of deleted files (files found only in base)

#

def protoCatalog(base, ptch) :

	compFiles = []		# List of files in both proto areas

	ptchList = []		# List of file in patch proto area

	newFiles = []		# New files detected

	deletedFiles = []	# Deleted files

	baseFilesList = list(findFiles(base))

	baseStringLength = len(base)

	ptchFilesList = list(findFiles(ptch))

	ptchStringLength = len(ptch)

	# Inventory files in the base proto area

	for fn in baseFilesList :

		if os.path.islink(fn) :

			continue

		fileName = fn[baseStringLength:]

		compFiles.append(fileName)

	# Inventory files in the patch proto area

	for fn in ptchFilesList :

		if os.path.islink(fn) :

			continue

		fileName = fn[ptchStringLength:]

		ptchList.append(fileName)

	# Deleted files appear in the base area, but not the patch area

	for fileName in compFiles :

		if not fileName in ptchList :

			deletedFiles.append(fileName)

	# Eliminate "deleted" files from the list of objects appearing

	# in both the base and patch proto areas

	for fileName in deletedFiles :

		try:

		       	compFiles.remove(fileName)

		except:

			error("filelist.remove() failed")

	# New files appear in the patch area, but not the base

	for fileName in ptchList :

		if not fileName in compFiles :

			newFiles.append(fileName)

	return compFiles, newFiles, deletedFiles

#

# Examine the files listed in the input file list

#

# Return a list of files appearing in both proto areas,

# a list of new files (files found only in ptch) and

# a list of deleted files (files found only in base)

#

def flistCatalog(base, ptch, flist) :

	compFiles = []		# List of files in both proto areas

	newFiles = []		# New files detected

	deletedFiles = []	# Deleted files

	try:

		fd = open(flist, "r")

	except:

		error("could not open: " + flist)

		cleanup(1)

	files = []

	files = fd.readlines()

	for f in files :

		ptch_present = True

		base_present = True

		if f == '\n' :

			continue

		# the fileNames have a trailing '\n'

		f = f.rstrip()

		# The objects in the file list have paths relative

		# to $ROOT or to the base/ptch directory specified on

		# the command line.

		# If it's relative to $ROOT, we'll need to add back the

		# root_`uname -p` goo we stripped off in fnFormat()

		if os.path.exists(base + f) :

			fn = f;

		elif os.path.exists(base + "root_" + arch + "/" + f) :

			fn = "root_" + arch + "/" + f

		else :

			base_present = False

		if base_present :

			if not os.path.exists(ptch + fn) :

				ptch_present = False

		else :

			if os.path.exists(ptch + f) :

				fn = f

			elif os.path.exists(ptch + "root_" + arch + "/" + f) :

				fn = "root_" + arch + "/" + f

			else :

				ptch_present = False

		if os.path.islink(base + fn) :	# ignore links

			base_present = False

		if os.path.islink(ptch + fn) :

			ptch_present = False

		if base_present and ptch_present :

			compFiles.append(fn)

		elif base_present :

			deletedFiles.append(fn)