# This used to be the main way we installed, by spamming the real root directory
# It will make backups of any files before overwriting them and then restore them
# before continuing to process the package content. It's a pretty complicated method
# but has proved to be quite dependable.

install_to_real_root() {
echo $BLUE"Installing to real root directory - "$NORMAL"Using: '$INSTALL_COMMAND $INSTALL_RULE'"$NORMAL
	
unset INSTW_ROOTPATH
unset INSTW_TRANSL
unset INSTW_BACKUP
unset INSTW_LOGFILE
unset INSTW_DBGFILE
unset INSTW_DBGLVL
unset INSTW_EXCLUDE

if [ $DEBUG_FILELISTS ] ; then
	INSTW_DBGFILE="${CWD}/libsentry.debug"
	INSTW_DBGLVL=2
	if cat /dev/null >"${INSTW_DBGFILE}" ; then
		true
	else
		echo $RED"FAILED! - "$NORMAL "Unable to prepare $INSTW_DBGFILE"
		exit 1
	fi
fi
export INSTW_DBGFILE
export INSTW_DBGLVL

# this doesn't seem to work any other way
INSTW_EXCLUDE="/dev,/proc,/tmp,/var/tmp,${INSTW_EXCLUDE}"
OIFS="$IFS"
IFS=','
INSTW_EXCLUDE=$(for name in $INSTW_EXCLUDE; do
	echo $name
	done | sort -u |
	while read elem; do
		echo -n "$elem,"
	done)
export INSTW_EXCLUDE
IFS="$OIFS"

INSTW_LOGFILE="${CWD}/FILELIST.tmp"
export INSTW_LOGFILE

# turn the translation feature off
INSTW_TRANSL=0
export INSTW_TRANSL

if [[ "$KEEP_BACKUPS" = "YES" ]] ; then
	! [[ $BACKUP_DIR ]] && BACKUP_DIR=/tmp
	! [[ $BACKUP_DIR_NAME ]] && BACKUP_DIR_NAME=$NAME-$VERSION-backup-$BUILD$SIG
	! [[ $BACKUP_DIRECTORY ]] && BACKUP_DIRECTORY=${BACKUP_DIR}/${BACKUP_DIR_NAME}
	export BACKUP_DIRECTORY
	# we need to call it this when removing since INSTW_ROOTPATH gets unset
	mkdir -p $BACKUP_DIRECTORY
	# set the INSTW_ROOTPATH to the backup directory
	INSTW_ROOTPATH="${BACKUP_DIRECTORY}"
	# turn the backup feature on
	INSTW_BACKUP=1
else
	INSTW_ROOTPATH=${CWD}
	INSTW_BACKUP=0
fi

export INSTW_ROOTPATH
export INSTW_BACKUP

if cat /dev/null >"${INSTW_LOGFILE}" ; then
	true
else
	echo $RED"FAILED! - "$NORMAL "Unable to prepare $INSTW_LOGFILE"
	exit 1
fi

LD_PRELOAD="/usr/libexec/src2pkg/lib/libsentry.so"
export LD_PRELOAD
trap trap_int 2

( cd $OBJ_DIR;
if [[ $QUIET = "YES" ]] ; then
	${INSTALL_COMMAND} ${INSTALL_RULE} &> /dev/null
else
	${INSTALL_COMMAND} ${INSTALL_RULE}
fi
)
	
## this routine ends at the end of the function. It checks the exit status of the INSTALL_LINE and
## acts accordingly. To assure maximum robustness, the first parts of this routine uses statically-compiled
## programs which don't need any installed libraries at all. If you just whacked something really bad, like glibc,
## this routine should get your system back right away. The bad(?) thing is that you may not even notice. Since all
## these programs are out of the normal path it makes it possible to safely compile and package tar and the other
## programs which are used in this routine.
if [[ $? -gt 0 ]] ; then
	# make install itself returned an error
	  
	  if [[ -x $OBJ_DIR/$NAME ]] || [[ -x $OBJ_DIR/$ORIG_NAME ]]; then
	   echo $CYAN"Notice - "$NORMAL"Running '$INSTALL_LINE' has failed."
	   echo "But, there seems to be a matching executable in the SRC_DIR."
	   echo $BLUE"Doing generic install - "$NORMAL
	   mkdir -p $PKG_DIR/$PRE_FIX/bin
	   [[ -x $OBJ_DIR/$NAME ]] && cp -a $OBJ_DIR/$NAME $PKG_DIR/$PRE_FIX/bin/$NAME
	   [[ -x $OBJ_DIR/$ORIG_NAME ]] && cp -a $OBJ_DIR/$ORIG_NAME $PKG_DIR/$PRE_FIX/bin/$ORIG_NAME 
		if [[ -e $OBJ_DIR/$NAME.1 ]] || [[ -e $OBJ_DIR/$NAME.man ]] ; then
		 echo $BLUE"Found man-page - "$NORMAL"Copying into PKG_DIR"
		 mkdir -p $PKG_DIR/usr/man/man1
		 [[ -e $OBJ_DIR/$NAME.1 ]] && cp -a $OBJ_DIR/$NAME.1 $PKG_DIR/usr/man/man1/$NAME.1
		 [[ -e $OBJ_DIR/$NAME.man ]] && cp -a $OBJ_DIR/$NAME.man $PKG_DIR/usr/man/man1/$NAME.man
		fi
	  else
	   echo $RED"FATAL! "$NORMAL"Running '$INSTALL_LINE' has failed with error: $? "
	   echo "Try using INSTALL_LINE 'make -i install'  "$RED"Exiting..."$NORMAL
	   FAILED="make_install"
	  fi
	  unset INSTW_ROOTPATH
	  unset LD_PRELOAD
	  ( cd $BACKUP_DIR && rm -rf $BACKUP_DIR_NAME )
	  rm -f $CWD/FILELIST.tmp
elif [[ $(cat $CWD/FILELIST.tmp |grep -v FILELIST.tmp 2> /dev/null) = "" ]] ; then
	# 'make install' produced no errors but also produced no output
	echo $RED"FATAL! "$NORMAL"Running '$INSTALL_LINE' with libsentry produced no files list. "
	echo "This may be the result of an empty or faulty install rule. "$RED"Exiting..."$NORMAL
	unset INSTW_ROOTPATH
	unset LD_PRELOAD
	( cd $BACKUP_DIR && rm -rf $BACKUP_DIR_NAME )
	rm -f $CWD/FILELIST.tmp
	FAILED="make_install NO FILES"
elif [[ $FAILED = "CANCELLED" ]] ; then
	unset INSTW_ROOTPATH
	unset LD_PRELOAD
	( cd $BACKUP_DIR && rm -rf $BACKUP_DIR_NAME )
	FAILED="CANCELLED"
else
	# Commands have succeeded and we have files.
	# remove the no-backup directory
	unset INSTW_ROOTPATH
	unset LD_PRELOAD
	
	rm -rf ${BACKUP_DIRECTORY}/BACKUP/no-backup &> /dev/null
	#rm -f ${BACKUP_DIRECTORY}/BACKUP/dbgfile &> /dev/null
	
	# used by SHELL_INSTALL
	[[ $RESTORE_QUIET ]] && QUIET="YES"
	[[ $DEBUG ]] && echo -n $BLUE"Processing installation FILELIST - "$NORMAL
	# Parse the full original libsentry log FILELIST.tmp
	# extract a list of the regular files
	#  cat ./FILELIST.orig | egrep -v '^3' |sort -u
	cat $CWD/FILELIST.tmp | cut -f 3 | egrep -v "^(/dev|$CWD|/tmp)" | sort -u > $CWD/FILELIST
	# extract a  list of symlinks 
	cat $CWD/FILELIST.tmp | cut -f 4 | egrep -v "^(/dev|$CWD|/tmp)" | egrep -v "#File exists" |sort -u >> $CWD/FILELIST
	# DIRLIST extract the directories to a separate DIRLIST  so they can be handled apart
	cat $CWD/FILELIST.tmp | egrep 'mkdir' | egrep -v '#File exists' | egrep '#success' | cut -f3 |sort -r -u >> $CWD/DIRLIST
	# DEBUG_FILELISTS
	if [[ $DEBUG_FILELISTS ]] ; then
	   # get a list of the links created
	   cat $CWD/FILELIST.tmp | egrep 'symlink' | egrep "#success" | cut-f4 |sort -u >> $CWD/LINKLIST
	   # copy the full libsentry log
	   cat $CWD/FILELIST.tmp > $CWD/FILELIST.orig
	   KEEP_FILELIST="YES"
	   KEEP_DIRLIST="YES"
	fi
	# Delete the original list so we can recycle the name
	rm -f $CWD/FILELIST.tmp
	# sort and remove duplicates
	cat /dev/null > $CWD/FILELIST.tmp
	 sort -u < $CWD/FILELIST | uniq | while read file; do
		! [[ -d "$file" ]] && [[ -f "$file" ]] && echo $file >> $CWD/FILELIST.tmp
	  done
	# remove more cruft
	cat $CWD/FILELIST.tmp | egrep -v "$CWD" | egrep -v "#success"> $CWD/FILELIST
	rm -f $CWD/FILELIST.tmp
	[[ $DEBUG ]] && echo $GREEN"Done"$NORMAL
	#  End parsed FILELIST creation
	
	# Create $PKG_DIR/$PRE_FIX -is only created if make install succeeds
	mkdir -p $PKG_DIR/$PRE_FIX
	
	[[ $DEBUG ]] && echo -n $BLUE"Copying installed files to PKG_DIR - "$NORMAL
	# copy files from root directory into PKG_DIR using the FILELIST
	cd / ;
	  cat $CWD/FILELIST | while read i; do 
		if ! [[ -d "$i" ]] && [[ -e "$i" ]] ; then 
		  if [ -x ${TAR_STATIC} ] ; then
		  (${TAR_STATIC} -cpf - "$i"| ${TAR_STATIC} -f - -xvpC $PKG_DIR) 2> /dev/null 1> /dev/null
		  else
		  (tar -cpf - "$i"| tar -f - -xvpC $PKG_DIR) 2> /dev/null 1> /dev/null
		  fi
		fi
	  done
	[[ $DEBUG ]] && echo $GREEN"Done"$NORMAL
	
	if [[ "$KEEP_BACKUPS" = "YES" ]] ; then
		# *Carefully* remove the shadow CWD from the BACKUP_DIRECTORY
		# strip the leading '/' off, cd into the BACKUP and then rm -rf
		SHADOW_CWD=${CWD:1}
		# SHADOW_CWD_BASE=$(echo $SHADOW_CWD |cut -f1 -d'/') 
		SHADOW_CWD_BASE=${SHADOW_CWD%%/*}
		
		( cd $BACKUP_DIRECTORY/BACKUP && rm -rf $SHADOW_CWD_BASE )
		# also remove the META directory
		( cd $BACKUP_DIRECTORY && rm -rf META )
		
		# Once we have the file list and have copied the installed files into PKG_DIR
		# immediately restore any files which were overwritten by the installation
		ls $BACKUP_DIRECTORY/BACKUP/* &> /dev/null
		if [[ $? -eq 0 ]] ; then
			if [[ $(find $BACKUP_DIRECTORY/BACKUP -type f) != "" ]] ; then
				cd $BACKUP_DIRECTORY/BACKUP
				[[ $DEBUG ]] && echo -n $BLUE"Restoring overwritten files - "$NORMAL
				# $TAR --no-overwrite-dirs --one-file-system -xzUpvf - 
				if [ "$( ${TAR_STATIC} --version )" = "1.13" ] ; then
					${TAR_STATIC} -cpf - . | ${TAR_STATIC} -f - -xlUvpC / &> /dev/null
				elif [ -x ${TAR_STATIC} ] ; then
					${TAR_STATIC} -cpf - . | ${TAR_STATIC} -f - -xvpC / &> /dev/null
				elif [ $( tar --version) >= 1.16 ] ; then
					tar -cpf - . | tar-f - -xvpC / &> /dev/null
				else
					echo $YELLOW"Warning!"$NORMAL"Unable to find a suitable tar version!"
					echo "Backups will not be done because your tar version makes a mess."
				fi
				
				[[ $DEBUG ]] && echo $GREEN"Done"$NORMAL
			fi
		fi
		# Now remove the new files and links installed to the system, unless they were just backed up above.
		# Compare the list of installed file and links with the contents of the backup directory
		[[ $DEBUG ]] && echo -n $BLUE"Removing other files installed by: "$NORMAL"'$INSTALL_COMMAND $INSTALL_RULE' - "
		cd / ;
		cat $CWD/FILELIST | while read i; do 
		if [ -e "$i" -o -L "$i" ] && ! [ -d "$i" ] ; then 
			if [[ $QUIET = "YES" ]] ; then
				if ! [[ -e "$BACKUP_DIRECTORY/BACKUP/$i" ]] ; then
					( rm -f $i ) 1> /dev/null
				fi
			else
				if ! [[ -e "$BACKUP_DIRECTORY/BACKUP/$i" ]] ; then
					( rm -f $i )
				fi
			fi
		fi
		done
		[[ $DEBUG ]] && echo $GREEN"Done "$NORMAL""
		
		# run ldconfig immediately after restoring backups and removing new files
		if [[ -x /sbin/ldconfig ]] ; then
			[[ $DEBUG ]] &&  echo -n $BLUE"Running ldconfig - "$NORMAL"Updating shared library links - "
			/sbin/ldconfig
			[[ $DEBUG ]] &&  echo $GREEN"Done"$NORMAL
		fi
		### After restoring overwritten files, removing new ones and running ldconfig the system should
		### be running just as before running 'make install', or whatever install command was run.
		### So we stop using the static programs and go back to running whatever binaries are in the path(except tar).
		
		# Now remove any new directories from the system that were created by the INSTALL_LINE .
		# Our DIRLIST only includes directories which didn't exist before and they should already be empty.
		cd / ;
		if [[ "$(cat $CWD/DIRLIST)" != "" ]] ; then
			[[ $DEBUG ]] && echo -n $BLUE"Removing empty directories installed "$NORMAL"by '$INSTALL_LINE' - "
			cat $CWD/DIRLIST | while read i; do 
			if [[ -d "$i" ]] ; then 
				( rm -rf $i )
			fi
			done
			[[ $DEBUG ]] && echo $GREEN"Done"$NORMAL""
		fi
		# create backup tarball if requested
		if [[ $KEEP_BACKUPS = "YES" ]] ; then
			! [[ $BACKUPS_SAVE_DIR ]] && BACKUPS_SAVE_DIR="$CWD"
			if [[ "$(find $BACKUP_DIR/$NAME-$VERSION-backup-$BUILD$SIG -type f)" != "" ]] ; then
				cd $BACKUP_DIR/$NAME-$VERSION-backup-$BUILD$SIG/BACKUP ;
				echo -n $BLUE"Creating backup package - "$NORMAL
				${TAR_STATIC} -cpf - . | gzip -9 > "${BACKUPS_SAVE_DIR}/backup-$(date +%m%d%Y%H%M)-pre-${SHORT_NAME}.tar.gz"
				rm -f $CWD/BACKUP.list
				echo $GREEN"Done"$NORMAL
			fi
		fi
		# remove the backup directory
		if [[ -d $BACKUP_DIR/$NAME-$VERSION-backup-$BUILD$SIG ]] ; then
			ls $BACKUP_DIR/$NAME-$VERSION-backup-$BUILD$SIG/* &> /dev/null
			if [[ $? -eq 0 ]] ; then
				cd $BACKUP_DIR ;
				if [[ "$(find $BACKUP_DIR/$NAME-$VERSION-backup-$BUILD$SIG -type f)" != "" ]] ; then
					[[ $DEBUG ]] &&  echo -n $BLUE"Removing backup files - "$NORMAL
					rm -rf $BACKUP_DIRECTORY 2> /dev/null 1> /dev/null
				else
					[[ $DEBUG ]] &&  echo -n $BLUE"Removing empty backup directories - "$NORMAL
					rm -rf $BACKUP_DIRECTORY 2> /dev/null 1> /dev/null
				fi
				[[ $DEBUG ]] &&  echo $GREEN"Done"$NORMAL
			else
				cd $BACKUP_DIR ;
				[[ $DEBUG ]] &&  echo $BLUE"Removing unused backup directory - "$NORMAL
				rm -rf $BACKUP_DIRECTORY 2> /dev/null 1> /dev/null
			fi
		fi
	# end of backups
	fi
	# remove filelists unless we are debugging
	! [[ $KEEP_FILELIST = "YES" ]] && rm -f $CWD/FILELIST
	! [[ $KEEP_DIRLIST = "YES" ]] && rm -f $CWD/DIRLIST
	! [[ $DEBUG_FILELISTS ]] && rm -f $CWD/libsentry.debug
	
	echo $BLUE"Safe installation - "$GREEN"Successful!"$NORMAL
	echo $BLUE"Processing package content:"$NORMAL
fi
}