#!/usr/bin/sh
# *****************************************************************
# *                                                               *
# *   Copyright 2006 Hewlett-Packard Development Company, L.P.    *
# *                                                               *
# *   The software contained on this media is proprietary to and  *
# *   embodies the  confidential  technology  of Hewlett-Packard  *
# *   Development   Company.  Possession,  use,  duplication  or  *
# *   dissemination of the software and media is authorized only  *
# *   pursuant to a valid written license  from  Hewlett-Packard  *
# *   Company.                                                    *
# *                                                               *
# *   RESTRICTED RIGHTS LEGEND   Use, duplication, or disclosure  *
# *   by the U.S. Government is subject to restrictions  as  set  *
# *   forth in Subparagraph (c)(1)(ii)  of  DFARS  252.227-7013,  *
# *   or  in  FAR 52.227-19, as applicable.                       *
# *                                                               *
# *****************************************************************
# @(#)$RCSfile: dupclone.sh,v $ $Revision: 1.1.2.5 $ (DEC) $Date: 2006/09/13 13:32:16 $

Clone_CopyDoc ()
{
	cd $_ALLDOC

	case "$1" in
	-c )
		[ -f $_SP -a "$_SVLOG" ] &&
		{	

			if [ "$_IS_CSP" = 1 ]; then
				mv $_SP $_SP.tmp
			else
			{
				SaveLogs $_SP
				SaveLogs $_SPDB
				echo "
					* Previous special instructions file saved in $_SP.[1-$_MAX_LOGS]"
			}
			fi
		}
	
		
		_SVLOG=


		[ -d "$2" ] && {
			(cd $2; tar cpf - .) | tar xf -
		}
		;;
	-f )
	
		for K in `ls -1 $2*.special_instruction 2>/dev/null`
		do
			cat $K >> $_SP.tmp 
			echo $K | awk -F. '{print $1}' >> $_SPDB 
		done
		;;
	esac

	cd $_HDIR
}

Clone_DisplaySI ()
{
    case "$1" in
    -s )
	SIPATH=`echo $2 | sed 's/kit$/doc\/txt/'`
	shift 2

	for K in $*
	do
		[ -s $SIPATH/$K.special_instruction ] && {

			[ "$SIFLG" ] || {
			    SIFLG=1
			    echo "\n\n\n"
			    echo "*** Start of Special Instructions ***\n"
			}

			cat $SIPATH/$K.special_instruction
		}
	done
	;;
    -e )
	if [ "$SIFLG" ]
	then
		SIFLG=
		echo "\n*** End of Special Instructions ***\n\n"
	else
		echo "\n*** There are no Special Instructions ***\n\n"
	fi
	;;
    esac
}


Clone_Exit ()
{
	exit
}


Clone_License ()
{
	if [ "$_LICENSE" ]
	then
		echo "\nYou have accepted the license agreement.\n"
	else
		echo "
Please read the license agreement (license.txt) in the top level directory
of the patch kit.  To accept the license agreement, include the -license
option in the command line.\n"
		exit
	fi
}


Clone_License1 ()
{
	_DISPLAY=$_ROOT/usr/lbin/updmore
	export _DISPLAY

        ISCSP=`head -1 $_KPATH/00-READ-ME-FIRST | \
		grep "Customer-Specific Patch Summary"`
        ISERP=`head -1 $_KPATH/00-READ-ME-FIRST | \
		grep "Early Release Patch Kit Summary"`

        if [ ! "$ISCSP" -a ! "$ISERP" -a ! "$NHDLICENSEFLAG" ]
        then
                [ -r $_KPATH/license.txt ] || {
                        echo "\n\nCannot locate license agreement."
                        echo "Please contact an HP representative."
                        exit
                }
                while :
                do
                        echo "\n\n"
                        $_DISPLAY $_KPATH/license.txt
                        echo "\nTo read the license again, type 'license'."
                        Dialog \
                        "Do you accept the license agreement? (y/n) " ANS
                        case $ANS in
                            [yY]*) return 0 ;;
                            [nN]*) exit 0 ;;
                        esac
                done
        fi
}


Clone_RunLogger ()
{
	SETUP=1
	export SETUP

	_CLONELOG=${_CLONELOG:=$_ROOT/var/adm/patch/log/session.log}
	MakeDir `dirname $_CLONELOG`
	SaveLogs $_CLONELOG

	log $_CLONELOG $0
}


Clone_GetPatchSS ()
{
	> $CL_SSLIST

	[ -f $1/instctrl/*.ctrl ] || return

	for CF in $1/instctrl/*.ctrl
	do
		. $CF
		PSS=`basename $CF .ctrl`

		IF=`echo "$CF" | sed 's/ctrl$/inv/'`

		for DSS in $PATCH_DEPS
		do
		    for ISS in $INSTALLED_SSLIST
		    do
			case "$DSS" in
			\. | $ISS )
				echo $PSS >> $CL_SSLIST
				cat $IF >> $PATINV
				echo "$PSS $PATCH_DEPS" >> $PARENTLIST
				for E in $PATCH_DEPS $PATCH_SUPERSEDE $PATCH_DEPS_ALT
				do
					echo $E
				done >> $CTRLDATA
				[ "$PATCH_KERNEL_BUILD" = "Y" ] &&
					KBR=1
				[ "$PATCH_REQUIRES_VERSION_SWITCH" = "Y" ] &&
					VSR=1
				break 2
			esac
		    done
		done
	done
}


Clone_ClusterStatus ()
{
	TERR=
	CLUSTAT=$_DUPATCH_TMP/clustat

	clu_get_info -raw | while read LINE
	do
		IFS=:
		set $LINE
		case "$1" in
		C )
			echo "C:$2:$3" >> $CLUSTAT
			echo
			echo "Cluster Name: $2"
			;;
		M )
			MEMBERS="$MEMBERS $2"
			echo "M:$2:$3:$5:$6:$9" >> $CLUSTAT
			echo "    Member-$2: $3 $5"

			[ "$6" = "UP" ] || {
				echo "    Member-$2 is not \"UP\"."
				ERROR=1
			}

			[ "$9" = "INSTALLED" ] || {
				echo "    Member-$2 is not running the same kernel version as other members in the cluster."
				TERR=1
			}
			;;
		esac
		IFS=" "
	done

	[ "$TERR" ] && exit
}


Clone_GetCmdArgs ()
{
	while [ "$#" -gt 0 ]
	do
		case "$1" in
		-k )
			_KPATH=`cd $2; pwd`
			shift 2
			;;
		-license )
			_LICENSE=1
			shift
			;;
		-logfile )
			_CLONELOG="$2"
			shift 2
			;;
		-r )
			_ROOT=`cd $2; pwd`
			_R="$_ROOT"
			shift 2
			;;
		-t )
			echo "$1"
			echo "$2"
			shift 2
			;;
		* )
			shift
			;;
		esac
	done
}


Clone_Init1 ()
{
	export _R _ROOT _KPATH _LICENSE _CLONELOG _MAX_LOGS

	. $_KPATH/clone_tools/lib/libcommon

	_MAX_LOGS=30
}


Clone_Init2 ()
{
	[ "`whoami`" = root ] || {
		echo "$0: you must be root to run this program"
		exit
	}





	TV1="$_ROOT/usr/share/lib/shell"

	for K in libscp libpat Lists Dialog Strings libswdb Ticker
	do
		if [ -s $TV1/$K ]
		then
			. $TV1/$K
		else
			echo "$0: unrecoverable error"
			echo "Cannot find $TV1/$K"
			exit 1
		fi
	done

	. $_KPATH/clone_tools/lib/libclone
	. $_KPATH/clone_tools/lib/libcommon





	_DUPATCH_TMP="$_ROOT/var/tmp/patch$$"
	FDD=$_DUPATCH_TMP/FDD
	_PATCHDIR="$_ROOT/var/adm/patch"
	_ALLDOC="$_PATCHDIR/doc"
	_DUPATCH_BACKUP="$_PATCHDIR/backup"
	_LOGDIR=$_PATCHDIR/log

	_DUPATCH_ENABLE="$_PATCHDIR/.enable"

	DLIST="$_PATCHDIR $_ALLDOC $_DUPATCH_BACKUP $_LOGDIR"
	DLIST="$DLIST $_DUPATCH_TMP $FDD"

	for K in $DLIST
	do
		MakeDir $K || {
			echo "unrecoverable error: cannot create $K"
			exit 1
		}
	done

	export _DUPATCH_TMP 




	CDSL_ADMIN="$_ROOT/var/adm/cdsl_admin.inv"
	DOCONFIG=/usr/sbin/doconfig
	_SETLD_PATH="$_KPATH/clone_tools/setld.clone"
	SPCOL="./usr/lbin/collision"
	VID="$_ROOT/usr/sys/conf/version.id"

	for K in $CDSL_ADMIN $_SETLD_PATH $_ROOT/$SPCOL $VID
	do
		[ -f $K ] || {
			echo "$0: $K, is missing.  Cannot continue."
			exit 1
		}
	done

	[ -f "$_ROOT$DOCONFIG" ] || {
		echo "$0: $_ROOT$DOCONFIG, is missing.  Cannot continue."
		exit 1
	}



	_BACKUP_SED="\.\/var\/adm\/patch\/backup\/"
	_CLONE=$_ROOT
	_DUPATCH=Y
	_DUPATCH_REVERT=Y
	_DUPATCH_SELECTED=
	_PATCH_REVERT=Y
	_SMDB="./usr/.smdb."
	_SVLOG=1
	_TOOLSUB=00000
	_VERS_SW_SAVEFILE=$_PATCHDIR/versionswitch.txt
	
	export _DUPATCH _DUPATCH_SELECTED _TOOLSUB
	export _DUPATCH_REVERT _DUPATCH_BACKUP _PATCH_REVERT
	export _CLONE _SETLD_PATH

	_HDIR=`pwd`
	SSORDER="OSF TCR IOS"

	DUPATCH_INSTINV=$_DUPATCH_TMP/instinv
	CL_SSLIST=$_DUPATCH_TMP/cl_sslist
	FDDTMP=$FDD/tmp
	PATINV=$FDD/patinv
	COLLOUT=$FDD/collout

	COLLERR=$FDD/collerr
	CTRLDATA=$FDD/ctrldata
	FAILLIST=$FDD/faillist
	PARENTLIST=$FDD/parentlist
	TMPF1=$_DUPATCH_TMP/tmpf1


	_SP=$_ALLDOC/Special_Instructions.txt
	_SPDB=$_ALLDOC/Special_Instructions.db
	
	> $PATINV
	> $CTRLDATA
	> $PARENTLIST
}


Clone_TestArgs ()
{
	if [ "$_ROOT" ]
	then
		[ "$_ROOT" = "/" ] && {
			echo "Can not clone to root file system"
			exit
		}
	else
		echo "Usage: $0 -r <root-path> -k <kit-path>"
		exit
	fi

	[ "$_KPATH" ] || {
		echo "Usage: $0 -r <root-path> -k <kit-path>"
		exit
	}

}


Clone_VerifyPK ()
{
	TERR=
	TMP1="$_DUPATCH_TMP/x1"
	TMP2="$_DUPATCH_TMP/x2"
	TMP3="$_DUPATCH_TMP/x3"

	> $TMP3

	echo
	echo "Checking patch kit for transmission errors during download..."

	KITDIRS=`find $_KPATH -name "kit"`

	for K in $KITDIRS
	do
		> $TMP1
		cd $K

		PROD=`echo "$K" | sed 's#'$_KPATH'##' | awk -F/ '{print $2}'`

		IMGP=`ls instctrl/*.image`
		[ "$IMGP" ] || {
		    TERR=1
		    echo "    - Cannot locate $PROD image file." >> $TMP3
		    continue
		}


		cat $IMGP | while read LINE
		do
			set $LINE
			[ -f instctrl/"$3".inv ] || {
			    TERR=1
			    echo "    - Cannot find $3 inventory" >> $TMP3
			}

			[ -f instctrl/"$3".scp ] || {
			    TERR=1
			    echo "    - Cannot find $3 scp file" >> $TMP3
			}

			[ -f instctrl/"$3".ctrl ] || {
			    TERR=1
			    echo "    - Cannot find $3 control file" >> $TMP3
			}

			echo "$1" >> $TMP1
			set `sum $3`
			echo "$1"
		done > $TMP2

		diff $TMP1 $TMP2 >/dev/null || {
		    TERR=1
		    echo "    - Subsets in $PROD appear corrupted." >> $TMP3
		    continue
		}
	done

	[ "$TERR" ] && {
		echo "Could not verify integrity of the patch kit in $_KPATH"
		echo "Please download the patch kit again."
		cat $TMP3
		exit
	}

	cd $_HDIR
}


Clone_FindLoadedSS ()
{
	T1=$_DUPATCH_TMP/tmp1
	T2=$_DUPATCH_TMP/tmp2


	cd $_ROOT/$_SMDB
	ls -1 *.sts *.lk 2>/dev/null | \
		sed -e 's/\.sts//' -e 's/\.lk//' | sort -u > $T1

	INSTALLED_SSLIST=`cat $T1`

	for K in `grep "^M:" $CLUSTAT | awk -F: '{print $2}'`
	do
		echo
		echo "Verifying current software on member $K"
		cd $_ROOT/cluster/members/member$K/$_SMDB
		ls -1 *.sts 2>/dev/null | sed -e 's/\.sts//' -e 's/\.lk//' | \
			sort -u > $T2

		TMP1=`comm -23 $T1 $T2`
		[ "$TMP1" ] && {
			TERR=1
			echo "The following software is missing from Member #$K"
			for S in $TMP1
			do
				echo "$S"
			done
		}

		grep "_INSTALLED" *.sts 2>/dev/null | awk -F: '{print $1}' | \
			sed 's/\.sts//' | sort -u > $T2
		TMP1=`comm -23 $T1 $T2`
		[ "$TMP1" ] && {
			TERR=1
			echo "The following subsets are not properly installed on Member #$K"
			for S in $TMP1
			do
				echo "$S"
			done
		}
		

		TMP1=
	done

	[ "$TERR" ] && exit


	echo
	echo "Creating master inventory of current system..."
	> $DUPATCH_INSTINV
	for S in `cat $T1`
	do
		if [ -s "$_ROOT/$_SMDB/$S.inv" ]
		then
			cat $_ROOT/$_SMDB/$S.inv >> $DUPATCH_INSTINV
		else
			echo "Error: The inventory file for $S is missing \c"
			echo "or empty"
			TERR=1
		fi
	done


	[ "$TERR" ] && exit

	sort -k 10 $DUPATCH_INSTINV > $T2
	mv $T2 $DUPATCH_INSTINV

	cd $_HDIR
}


Clone_SCPCheck ()
{
	NSS=0
	for K in $OSF_SSLIST $TCR_SSLIST $IOS_SSLIST
	do
        	NSS=`expr $NSS + 1`
	done

	cd $_ROOT


	echo "Inspecting $NSS patches for possible system conflicts ..."
	$SPCOL $DUPATCH_INSTINV $PATINV $CTRLDATA $CDSL_ADMIN \
		$PARENTLIST > $COLLOUT

	case "$?" in
	0)


		CollisionExceptions
		CollisionOutput
		[ -s "$FAILLIST" ] && exit
		;;
	*)
		echo "The error listed above is unrecoverable \c"
		echo "and must be resolved."
		echo "Exiting dupatch..."
		exit
		;;
	esac

	echo
	echo "Checking subset dependencies ..."
	ARG="DEPS_ONLY"
	for S in $OSF_SSLIST $TCR_SSLIST $IOS_SSLIST
	do
		case "$S" in
		OSF* )	LOC="$OSFPATH/instctrl"	;;
		TCR* )	LOC="$TCRPATH/instctrl"	;;
		IOS* )	LOC="$IOSPATH/instctrl"	;;
		esac
		ACT=POST_M $LOC/$S.scp $ARG || _FAIL_LIST="$_FAIL_LIST $S"
	done

	cd $_HDIR
}


Clone_KernelRebuild ()
{
	KERNPATH=/sys
	CFGPATH=/sys/conf

	CFGNAME=`echo $2 | awk -F. '{print $1}' | dd conv=ucase 2>/dev/null`

	if [ -f $_ROOT/$CFGPATH/$CFGNAME ]
	then
		echo "Building kernel for member $1 ($CFGNAME)..."
		chroot $_ROOT $DOCONFIG -a -c $CFGNAME >/dev/null
	
		echo
		echo "Copying new kernel to member $1 ($CFGNAME) as"
		echo "$_ROOT/cluster/members/member$1/boot_partition/vmunix"
		cp $_ROOT/$KERNPATH/$CFGNAME/vmunix.$CFGNAME \
			$_ROOT/cluster/members/member$1/boot_partition/vmunix
		echo
	else
		echo "Cannot locate config file $_ROOT/$CFGPATH/$CFGNAME"
		exit
	fi
}


Clone_TCRmods ()
{
	MEMBERS=`grep "^M:" $CLUSTAT | awk -F: '{print $2}'`

	set x `cat $_CLONE/cluster/admin/install/special.list`
	shift

	while [ $# -ge 2 ]
	do
		cp $_CLONE/$1 $_CLONE/$2
		for N in $MEMBERS
		do
			TMPFN=`echo "$2" | sed 's/member0/member'$N'/'`
			cp $_CLONE/$1 $_CLONE/$TMPFN
		done
		shift 2
	done

	TCRSYS="$_ROOT/usr/opt/TruCluster/sys"
	TCRCFG="$TCRSYS/config.file"

	[ -d "$TCRSYS" ] && {
		for K in config.tcr config.other config.custom
		do
			[ -s $TCRSYS/$K ] && cat $TCRSYS/$K >> $TCRCFG.$$
		done

		[ -f $TCRCFG.$$ ] && mv $TCRCFG.$$ $TCRCFG
	}

}


Clone_VersionSwitch ()
{
    VIDATE=`date +"%j_%H_%M_%S"`

    if VIL=`grep BUILTIN_VERS_ID_HIGH $VID`
    then
	VIH=`echo "$VIL" | awk '{print $3}' | sed 's/0x//'`
	VIH=`echo "ibase=16; $VIH" | bc`
    else
	VIH=
    fi

    if VIL=`grep BUILTIN_VERS_ID_LOW $VID`
    then
	VIL=`echo "$VIL" | awk '{print $3}' | sed 's/0x//'`
	VIL=`echo "ibase=16; $VIL" | bc`
    else
	VIL=
    fi

    [ "$VIH" -a "$VIL" ] || {
	echo "$0: unrecoverable error"
	echo "Clone_VersionSwitch: missing version id values"
	echo "VIH=$VIH"
	echo "VIL=$VIL"
    }

    for K in `grep "^M:" $CLUSTAT | awk -F: '{print $2}'`
    do
	SCT="$_ROOT/cluster/members/member$K/boot_partition/etc/sysconfigtab"

	echo "    $SCT"

	[ -s "$SCT" ] || {
		echo "$0: unrecoverable error."
		echo "Clone_VersionSwitch: Cannot find $SCT."
		exit 1
	}

	AVHE=`grep "act_vers_high" $SCT`
	NVHE=`grep "new_vers_high" $SCT`
	OVHE=`grep "old_vers_high" $SCT`
	AVLE=`grep "act_vers_low" $SCT`
	NVLE=`grep "new_vers_low" $SCT`
	OVLE=`grep "old_vers_low" $SCT`

	AVHE=`echo $AVHE`
	NVHE=`echo $NVHE`
	OVHE=`echo $OVHE`
	AVLE=`echo $AVLE`
	NVLE=`echo $NVLE`
	OVLE=`echo $OVLE`

	OVHE=${OVHE:="old_vers_high"}
	OVLE=${OVLE:="old_vers_low"}
	OVH=`echo "$AVHE" | awk -F\= '{print $2}'`
	OVL=`echo "$AVLE" | awk -F\= '{print $2}'`
	OVH=`echo $OVH`
	OVL=`echo $OVL`

	sed -e 's/'"$AVHE"'/act_vers_high = '$VIH'/' \
	    -e 's/'"$NVHE"'/new_vers_high = '$VIH'/' \
	    -e 's/'"$OVHE"'/old_vers_high = '$OVH'/' \
	    -e 's/'"$AVLE"'/act_vers_low = '$VIL'/' \
	    -e 's/'"$NVLE"'/new_vers_low = '$VIL'/' \
	    -e 's/'"$OVLE"'/old_vers_low = '$OVL'/' $SCT > $TMPF1

	[ "$?" -eq 0 ] || {
		echo "$0: unrecoverable error"
		echo "Clone_VersionSwitch: Failure setting version id in:"
		echo "$SCT"
		exit 1
	}

	AVHE=; AVLE=; NVHE=; NVLE=; OVHE=; OVLE=;
	set x `grep -E "_vers_high|_vers_low" $TMPF1 | sed 's/=/ /g'`
	shift

	while [ "$#" -ge 2 ]
	do
		case "$1" in
		act_vers_high )	AVHE=$2 ;;
		act_vers_low  ) AVLE=$2 ;;
		new_vers_high ) NVHE=$2 ;;
		new_vers_low  ) NVLE=$2 ;;
		old_vers_high ) OVHE=$2 ;;
		old_vers_low  ) OVLE=$2 ;;
		esac

		shift 2
	done

	[ "$AVHE" -eq $VIH -a "$NVHE" -eq $VIH ] || {
		echo "$0: unrecoverable error"
		echo "Clone_VersionSwitch: Failure setting high version id in:"
		echo "$SCT"
		exit 1
	}
	
	[ "$AVLE" -eq $VIL -a "$NVLE" -eq $VIL ] || {
		echo "$0: unrecoverable error"
		echo "Clone_VersionSwitch: Failure setting low version id in:"
		echo "$SCT"
		exit 1
	}

	if [ "$OVLE" ]
	then
	    [ "$OVLE" -eq "$OVL" ] || {
		echo "$0: unrecoverable error"
		echo "Clone_VersionSwitch: Failure setting old_vers_low id in:"
		echo "$SCT"
		exit 1
	    }
	else
		ed - $TMPF1 << EOF >/dev/null
/act_vers_low
a
	old_vers_low = $OVL
.
w
q
EOF
	fi

	if [ "$OVHE" ]
	then
	    [ "$OVHE" -eq "$OVH" ] || {
		echo "$0: unrecoverable error"
		echo "Clone_VersionSwitch: Failure setting old_vers_high id in:"
		echo "$SCT"
		exit 1
	    }
	else
		ed - $TMPF1 << EOF >/dev/null
/act_vers_low
a
	old_vers_high = $OVH
.
w
q
EOF
	fi


	mv $TMPF1 $SCT

	cp $VID $VID.$VIDATE || {
		echo "$0: unrecoverable error"
		echo "Clone_VersionSwitch: cannot copy $VID"
		exit 1
	}


    done

    echo "# This file created by dupclone.  Do not edit or remove!" \
	> $_VERS_SW_SAVEFILE
    echo "$OVL" >> $_VERS_SW_SAVEFILE

}




[ "$SETUP" ] || {
	Clone_GetCmdArgs "$@"
	Clone_TestArgs
	Clone_Init1
	Clone_RunLogger
	exit
}

Clone_Init2
Clone_License
Clone_ClusterStatus


Clone_VerifyPK


Clone_FindLoadedSS


for K in $KITDIRS
do
	case "$K" in
	*I18N* )	IOSPATH=$K ;;
	*Tru64* )	OSFPATH=$K ;;
	*TruCluster* )	TCRPATH=$K ;;
	esac
done


echo
echo "Getting list of patch subsets to install..."
> $PATINV
> $CTRLDATA
> $PARENTLIST


Clone_GetPatchSS $OSFPATH
[ -s "$CL_SSLIST" ] && {

	OSF_SSLIST=`cat $CL_SSLIST`

	OSF_PRODID=`head -1 $CL_SSLIST`
	OSF_PRODID=`expr "$OSF_PRODID" : '\(.........\)'`

	Clone_DisplaySI -s $OSFPATH $OSF_SSLIST
}

Clone_GetPatchSS $TCRPATH
[ -s "$CL_SSLIST" ] && {

	TCR_SSLIST=`cat $CL_SSLIST`

	TCR_PRODID=`head -1 $CL_SSLIST`
	TCR_PRODID=`expr "$TCR_PRODID" : '\(.........\)'`

	Clone_DisplaySI -s $TCRPATH $TCR_SSLIST
}

Clone_GetPatchSS $IOSPATH
[ -s "$CL_SSLIST" ] && {

	IOS_SSLIST=`cat $CL_SSLIST`

	IOS_PRODID=`head -1 $CL_SSLIST`
	IOS_PRODID=`expr "$IOS_PRODID" : '\(.........\)'`

	Clone_DisplaySI -s $IOSPATH $IOS_SSLIST
}


Clone_DisplaySI -e


if [ "$OSF_SSLIST$TCR_SSLIST$IOS_SSLIST" ]
then
	_DUPATCH_SELECTED="$OSF_SSLIST $TCR_SSLIST $IOS_SSLIST"
else
	echo "\nDid not identify any subsets for installation."
	exit
fi


echo $_DUPATCH_SELECTED | grep -qs "PAT0" 
	if [ "$?" = 0 ]; then
		_IS_CSP=0
	else
		_IS_CSP=1
	fi


grep -v "\.mrg\.\." $PATINV > $TMPF1
grep -v "\.upd\.\." $TMPF1 | sort -k 10 > $PATINV

sort -u $CTRLDATA > $TMPF1
mv $TMPF1 $CTRLDATA

echo


Clone_SCPCheck

LC_CheckSpace || {
	echo "Not enough file system space is available to install \c"
	echo "the patch kit."
	exit
}


echo "\n\n*** Loading Software ***\n"


[ "$OSF_SSLIST" ] && {
	$_SETLD_PATH -D $_ROOT -O $_CLONE -l $OSFPATH $OSF_SSLIST
	DOCDIR="`dirname $OSFPATH`/doc/txt"
	Clone_CopyDoc -c $DOCDIR
}

[ "$TCR_SSLIST" ] && {
	$_SETLD_PATH -D $_ROOT -O $_CLONE -l $TCRPATH $TCR_SSLIST
	DOCDIR="`dirname $TCRPATH`/doc/txt/"
	Clone_CopyDoc -c $DOCDIR
}

[ "$IOS_SSLIST" ] && {
	$_SETLD_PATH -D $_ROOT -O $_CLONE -l $IOSPATH $IOS_SSLIST
	DOCDIR="`dirname $IOSPATH`/doc/txt/"
	Clone_CopyDoc -c $DOCDIR
}


Clone_TCRmods

for K in $OSF_PRODID $TCR_PRODID $IOS_PRODID
do
	Clone_CopyDoc -f $K
done


[ -f $_SP.tmp ] &&
	mv $_SP.tmp $_SP 

echo "

*** KERNEL CONFIGURATION/BUILD PHASE ***"


[ "$VSR" ] && {
	echo "\nSetting version id on cluster members..."
	Clone_VersionSwitch
	echo
}


[ "$KBR" ] && {
	set -- `grep "^M:" $CLUSTAT | awk -F: '{print $2 " " $3}'`
	while [ $# -ge 2 ]
	do
		Clone_KernelRebuild $1 $2
		shift 2
	done
}



rm -rf $_DUPATCH_TMP


echo "
*** Dupatch Cloning Procedure Finished ***"