#!/bin/bash
#Copyright 2001, William Stearns <wstearns@pobox.com>
#Released under the GPL.
#This script will free up space by hardlinking identical files together.
#From the yet-another-program-that-should-have-been-written-in-a-real-language series.

#Presettable parameters (place on command line before freedups):
#DEBUG=YES		#Debugging output if YES.
#ACTUALLYLINK=YES	#Just reports on potential savings if anything but YES.
#VERBOSE=YES		#Show directory listing and wait before linking if YES.
#CHECKDATE=YES		#Modified date and time must be equal to be considered for linking if YES.
#FILENAMESEQUAL=YES	#Files must have the same name (in different directories to be considered for linking if YES.
#MINSIZE=size		#Files must be larger than this size (in bytes) to be considered for linking.
#EXCLUDE=regex		#Egrep regex of files to ignore - not implemented yet.
#Command line holds just the dirs to look under.

#FIXME - remove the following before shipping
DEBUG=YES

SPACESAVED=0
SPACEWOULDHAVESAVED=0

if [ "$DEBUG" = "YES" ]; then
	debug () {
		echo $* >/dev/stderr
	}
else
	debug () {
		:
	}
fi
nodebug () {
	:
}

linkfiles () {
#Parameters: the 2 files that need to be hardlinked together.
	nodebug '++++' lf "$@"
	if [ $# -lt 2 ]; then
		return 1
	fi
	for AFILE in "$@" ; do
		if [ ! -f "$AFILE" ]; then
			debug $AFILE is not a file, aborting link.
			return 1
		fi
	done
	FILESIZE=`ls -al "$1" | awk '{print $5}'`
	if [ "$ACTUALLYLINK" = "YES" ]; then
#		FIRSTFILE="$1"
#		shift
#		for OTHERFILE in "$@" ; do
#To support more than 2 file parameters, revert the following "link to older file" logic to the preceding loop.
		if [ "$1" -nt "$2" ]; then
			FIRSTFILE="$2"
			OTHERFILE="$1"
		else
			FIRSTFILE="$1"
			OTHERFILE="$2"
		fi
		if [ "$VERBOSE" = "YES" ]; then
			ls -ali "$FIRSTFILE" "$OTHERFILE"
			read JUNK </dev/stderr
		fi
		#FIXME - askfirst if CLP requests it.
		#FIXME - invoke sudo if not root and either file or either parent dir not owned by this user
		if ln -f "$FIRSTFILE" "$OTHERFILE" ; then		#Hardlink takes care of time, owner, and rights.
			echo $FILESIZE Linked "$FIRSTFILE" and "$OTHERFILE"
			SPACESAVED=$[ $SPACESAVED + $FILESIZE ]
		else
			echo $FILESIZE: Failed to link "$FIRSTFILE" and "$OTHERFILE"
			SPACEWOULDHAVESAVED=$[ $SPACEWOULDHAVESAVED + $FILESIZE ]
		fi
#		done
	else
		echo $FILESIZE: Would have linked "$@"
		SPACEWOULDHAVESAVED=$[ $SPACEWOULDHAVESAVED + $FILESIZE ]
	fi
}

filesshouldbelinked () {
#Parameters - the two files to be compared.
#Returns 0 (True) if contents identical.
#If shoudln't be linked (different in any way, already share an inode, etc), 1 (False)
	if [ "$1" = "$2" ]; then
		nodebug $1 and $2 are the same file.		; return 1
	elif [ ! -f "$1" ]; then
		debug "$1" is not a file.			; return 2
	elif [ ! -f "$2" ]; then
		debug "$2" is not a file.			; return 2
	elif [ ! -s "$1" ]; then
		debug "$1" has zero length.			; return 3
	elif [ ! -s "$2" ]; then
		debug "$2" has zero length.			; return 3
	elif [ ! -r "$1" ]; then
		debug "$1" can\'t be read.			; return 4
	elif [ ! -r "$2" ]; then
		debug "$2" can\'t be read.			; return 4
	elif [ "$1" -ef "$2" ]; then
		nodebug "$1" and "$2" already share an inode.	; return 5
	elif [ "$CHECKDATE" = "YES" ] && [ "$1" -nt "$2" ]; then
		nodebug "$1" is newer than "$2"			; return 6
	elif [ "$CHECKDATE" = "YES" ] && [ "$1" -ot "$2" ]; then
		nodebug "$1" is older than "$2"			; return 6
	elif [ `ls -al "$1" | awk '{print $5 "/" $1 "/" $3 "/" $4 }'` != `ls -al "$2" | awk '{print $5 "/" $1 "/" $3 "/" $4 }'` ]; then
		nodebug "$1" and "$2" differ in size, rights, or ownership. ; return 7
	elif [ "$FILENAMESEQUAL" = "YES" ] && [ `basename "$1"` != `basename "$2"` ]; then
		nodebug "$1" and "$2" have different filenames.	; return 8
	elif ! diff -q "$1" "$2" >/dev/null ; then
		nodebug "$1" and "$2" have different contents.	; return 9
	else
		nodebug Identical.				; return 0
	fi
}

processsamesizefiles () {
	nodebug '----' pssf "$@"
	for ONEFILE in "$@" ; do
		#The following shift compares each file to each other once without comparing a file to itself.
		shift
		for TWOFILE in "$@" ; do
			if filesshouldbelinked "$ONEFILE" "$TWOFILE" ; then
				linkfiles "$ONEFILE" "$TWOFILE"
			fi
		done
	done
}

#FIXME - parse for parameters
if [ $# -gt 0 ]; then
	DIRS="$*"
	echo About to check for links in $DIRS >/dev/stderr
else
	echo Usage: >/dev/stderr
	echo $0 dirs >/dev/stderr
	echo Example: >/dev/stderr
	echo $0 '/usr/src/linux* /usr/src/pcmcia-cs*' >/dev/stderr
	exit 1
fi

#/tmpsizes will hold lines like: 
#1184 /tmp/bkwrap

#FIXME - stuff all info that needs to be equal (owner, size, rights, optionally basename) into the "size" field.
#Pipe find directly into while read; use exec kludge or manual looping; straight piping causes last file size block to be skipped from no GT1 var.
find $DIRS -xdev -type f `if [ -n "$MINSIZE" ]; then echo "-a -size +${MINSIZE}c" ; fi` -printf '%s %p\n' \
| grep -v '^0 ' | sort -nr | uniq >/tmp/sizes
#FIXME - use mktemp if using a file.
#FIXME - grep out exclude list if $EXCLUDE set
while read SIZE FILENAME ; do
	nodebug Z $SIZE Z $FILENAME Z
	if [ "$SIZE" = "$OLDSIZE" ]; then
		SAMESIZEFILES="$SAMESIZEFILES \"$FILENAME\""
		NUMFILES="GT1"
	else
		if [ "$NUMFILES" = "GT1" ]; then
			nodebug $SAMESIZEFILES have the same size.
			eval processsamesizefiles $SAMESIZEFILES
		fi
		SAMESIZEFILES="\"$FILENAME\""
		NUMFILES="1"
	fi
	OLDSIZE="$SIZE"
	OLDFILENAME="$FILENAME"
done </tmp/sizes
if [ "$NUMFILES" = "GT1" ]; then	#Handle last file size.
	nodebug $SAMESIZEFILES have the same size.
	eval processsamesizefiles $SAMESIZEFILES
fi

if [ $SPACESAVED -gt 0 ]; then
	echo Total space saved: $SPACESAVED \(Small risk of overcounting space saved if linked files have different times.\)
fi
if [ $SPACEWOULDHAVESAVED -gt 0 ]; then
	echo Total space would have saved: $SPACEWOULDHAVESAVED \(An overestimate if more than two files would have been linked together.\)
fi
exit

#Read kludge:
#Redirect stdin to work around an f^@&ing annoying limitation in the read command.
#CKPTSORTRULEFILE=" sortrulefile: split into equivalent sections." ; #ckpt $CKPTSORTRULEFILE
#exec 5<&0 < "$ONEFILE"
#while read ONELINE ; do
#	NEWRULETAG="`ruletag $ONELINE`"
#	if [ "$NEWRULETAG" != "$LASTRULETAG" ]; then
#		FILECOUNT=$[ $FILECOUNT + 1 ]
#		if [ -f $ONEFILE.$FILECOUNT ]; then rm -f $ONEFILE.$FILECOUNT || logfail $LINENO masonlib: YYYY 0118 ; fi
#	fi
#	echo "$ONELINE" >>$ONEFILE.$FILECOUNT
#	LASTRULETAG="$NEWRULETAG"
#done
#exec 0<&5 5<&-