#!/sbin/sh
# @DEC_COPYRIGHT@
# @(#)$RCSfile: dupatch.sh,v $ $Revision: 1.1.1.6 $ (DEC) $Date: 1997/05/15 16:38:28 $



Main ()
{
	_ARGS_DONE=

	_DPWD=`/bin/pwd`; export _DPWD
	_PROG=`basename $0`; export _PROG
  
	P_Args $0 $* || P_Exit 1

	P_SetRoot

	P_KitLocGet || P_Exit 1

	P_UpdateTools || exit $?


        exec $_ROOT/usr/sbin/$_PROG $*

	exit $?

}


# @DEC_COPYRIGHT@
# @(#)$RCSfile: common.sh,v $ $Revision: 1.1.1.19 $ (DEC) $Date: 1997/06/12 19:56:50 $

. /usr/share/lib/shell/Dialog
. /usr/share/lib/shell/Lists
. /usr/share/lib/shell/Strings
. /usr/share/lib/shell/libscp



P_AbsPath ()
{ 

	P=$1
	case $P in
	.)	# current directory
		P=$_DPWD
		;;
	/*)	# absolute path, do nothing
		;;
	./*)	# relative path, strip the ./
		P=$_DPWD/`echo $P | sed 's/\.\///'`
		;;
	*)	P=$_DPWD/$P
		;;
	esac

	echo $P
}



P_Args ()
{
	[ "$_ARGS_DONE" ] && return 0

	CMDPATH=$0; shift

	P_ArgsInit $*

	ERR=0

	[ $# -eq 0 ] && return 0

	while :
	do
		[ $# -eq 0 ] && break

		SW=$1
		USW=`ToUpper $SW`		

		S=`echo $SW | sed 's/^-//'`
		S=`ToUpper $S`

		case $USW in
		-DELETE	| \
		-HELP	| \
		-INSTALL| \
		-TRACK )
			[ "$_CMDLINE" ] && 
				P_Ferror 1 "
You can only specify ONE of the following operations in one command:
	$_OPS" 
			_CMDLINE=$S			
			_TYPE=$_CMDLINE
			_CMDLINE_TEXT="$CMDPATH $*"

			export _TYPE _CMDLINE _CMDLINE_TEXT

			shift
			;;

		-NOBACKUP| \
		-DATA	 | \
		-DATA_FILE| \
		-KIT	 | \
		-NAME	 | \
		-NOTE	 | \
		-PATCH_ID | \
		-PRECHECK_ONLY | \
		-PROCEED | \
		-REV	 | \
		-ROOT 	 | \
		-ROOT_PATH | \
		-TYPE    | \
		-VERSION_STRING)
			P_SetSwitch $* 
			shift $_SHIFT 
			;;

		-PATCH)
			P_SetSwitch $* 
			shift $_SHIFT 


			P_ArgsPatchParse $_ARG_PATCH || 
			{
				ERR=1 
				continue
			} 

			P_ArgsPatchAdd /dev/null
			;;

		-VERSION)
			P_SetSwitch $* 
			shift $_SHIFT 


			P_ArgsVersionParse $_ARG_VERSION ||
			{ 
				ERR=1 
				continue
			} 

			_VERSION_LIST="$_VERSION_LIST $_ARG_VERSION"
			;;

                *)      # bad switches
			P_Usage
                        P_Ferror 1 "\n$SW is not a valid switch" 
			;;
		esac
	done

	[ "$_TYPE" ] || 
	{
		P_Usage

		P_Ferror 1 "
For command line interface, you must specify one of the following operations:
	$_OPS
   <OR>
specify no operations on the command line to use the menu interface.
" 

	}

	[ "$PATCH_DEBUG" ] &&
		echo "\n=== operation = $_TYPE\n"


	[ "$_SW_DATA" ] &&
	{
		P_ArgsData || ERR=1
	}

	P_ArgsCheck || ERR=1

	[ "$ERR" = 1 ] && 
	{
		P_Usage $_TYPE
		return 1
	}

	[ "$_TYPE" = HELP ] &&
	{
		P_Usage HELP
		exit 0
	}


	P_ArgsPatchMap || 
	{
		P_Usage $_TYPE
		return 1
	}

	for S in $_ALLSW
	{
		export _SW_$S
		export _ARG_$S 
	}
	_ARGS_DONE=1; export _ARGS_DONE

	return 0

}



P_ArgsCheck () 
{ 
	[ "$PATCH_DEBUG" ] &&
		echo "\n=== final check stage in P_ArgsCheck ()"

	eval SWLIST=\$_${_TYPE}_SW

	ERROR=0
	for S in $_ALLSW
	{
		eval SW=\$_SW_$S
		[ "$SW" ] || continue

		LSW="-`ToLower $S`"	

		Member $S $SWLIST ||
		{
			P_Error "
\"$LSW\" is not a valid switch with operation \"-`ToLower $_TYPE`\"" 
			ERROR=1
			continue
		}

		eval ARG=\$_ARG_$S

		case $S in
		KIT | \
		ROOT)
			[ "$ARG" ] ||
			{
				P_Error "
The \"$LSW\" switch requires a directory path as its argument." 
				ERROR=1 
				continue
			}

			ARG=`P_AbsPath $ARG`

			[ -d "$ARG" ] ||
			{
				P_Error "
\"$ARG\" does not exist or is not a directory." 
				ERROR=1 
				continue
			} 

			case $S in
			KIT) 	P_KitLocCheck $ARG || ERROR=1
				;;
			ROOT)	[ -d $ARG/usr/.smdb. ] ||
				{
					P_Error "
\"$ARG\" is not a valid directory for alternate root." 
					ERROR=1 
				}

				;;
			esac
				
			;;
		
		NAME | \
		NOTE)
			[ "$ARG" ] ||
			{
				P_Error "
The \"$LSW\" switch requires a text string as its argument."
				ERROR=1
			}
			;;

		DATA_FILE | \
		NOBACKUP | \
		PATCH_ID | \
		PRECHECK_ONLY | \
		PROCEED | \
		REV	 | \
		ROOT_PATH | \
		VERSION_STRING)
			[ "$ARG" ] &&
			{
				P_Error "
The \"$LSW\" switch does not require any argument."
				ERROR=1
			}
			;;
 
		TYPE) 
			eval KEYLIST=\$_${S}_KEY 
			KER=
			if [ ! "$ARG" ]; then 
			{
				KER=1
			} 
			else
			{
				UA=`ToUpper $ARG`				
				eval _ARG_$S='$UA'		
				Member $UA $KEYLIST || KER=1
			}
			fi

			[ "$KER" ] &&
			{
				KEYLIST=`echo $KEYLIST | sed 's/ / | /g'`		
				P_Error "
The \"$LSW\" switch requires one of the following arguments:
		`ToLower $KEYLIST` "
				ERROR=1
			}
			;;

		VERSION)

			[ "$_SW_PATCH" ] ||
			{
				P_Error " 
The \"$LSW\" switch must be used in conjuction with the \"-patch\" switch." 
				ERROR=1 
			} 

			P_SetRoot
			P_ValidVer

			LIST=
			NOT_VALID=
			eval KEYLIST=\$_${S}_KEY 
			for V in $_VERSION_LIST
			{
				UA=`ToUpper $V`				

				Member $UA $KEYLIST || 
				{
					P_Error " 
\"$V\" is not a valid DIGITAL UNIX version string." 
					NOT_VALID=1
					continue
				} 

				Member $UA $_PVSTR ||
				{
					NOT_VALID=1
					continue
				}
				LIST="$LIST $UA"
			}

			[ "$NOT_VALID" ] &&
			{
				ERROR=1 
				P_Error " 
Valid version strings on your system for this operation are:

		$_PVSTR"
				continue
			}
	
			_ARG_VERSION=`echo $LIST`
			;;

		esac

		[ "$PATCH_DEBUG" ] &&
		{
			eval SS=\$_SW_$S
			eval AA=\$_ARG_$S
			echo "=== _SW_$S=$SS	_ARG_$S=$AA"
		}

	}


	return "$ERROR"

}




P_ArgsData ()
{
	if [ "$_ARG_DATA" ]; then
	{
		_ARG_DATA=`P_AbsPath $_ARG_DATA`

		[ -f $_ARG_DATA ] || 
		{
			P_Error "
\"$_ARG_DATA\" does not exist or is not a file." 
			return 1 
		} 
	} 
	else
	{
			P_Error "
The \"-data\" switch requires a file path as its argument." 
			return 1 
	}
	fi

	
	eval SWLIST=\$_${_TYPE}_SW

	TMP=/var/tmp/$_PROG.tmp
	> $TMP

	PATCH_SET=
	VERSION_SET=
	[ "$_SW_PATCH" ]   && PATCH_SET=1
	[ "$_SW_VERSION" ] && VERSION_SET=1

	cat $_ARG_DATA | while read LINE
	do
		[ "$LINE" ] || continue

		LINE=`echo $LINE`	
		case $LINE in
		\#*)	continue
			;;
		esac
		
		LINE=`echo $LINE | awk -F# '{print $1}'`

		LV=`echo $LINE | awk -F= '{print $1}'`
		RV=`echo $LINE | awk -F= '{print $2}'`

		LVAL=`ToUpper \`echo $LV\``	
		RVAL=`echo $RV`	

		[ ! "$LVAL" -a ! "$RVAL" ] && continue


		case "$LVAL" in
		PATCH)	
			[ "$PATCH_SET" ] || 
			{ 
				P_SetSwitch $LVAL $RVAL 
				P_ArgsPatchParse $RVAL || continue 

				P_ArgsPatchAdd $TMP 

				echo "_SW_$LVAL=$LVAL" >> $TMP 
				echo _ARG_$LVAL=\"`echo $RVAL|sed 's/\"//g'`\" >> $TMP 
			} 
			;; 

		VERSION)
			[ "$VERSION_SET" ] ||
			{
				P_SetSwitch $LVAL $RVAL

				P_ArgsVersionParse $RVAL || continue
				
				_VERSION_LIST="$_VERSION_LIST $_ARG_VERSION"

				echo _VERSION_LIST=\"$_VERSION_LIST\" >> $TMP

				echo "_SW_$LVAL=$LVAL" >> $TMP
				echo _ARG_$LVAL=\"`echo $RVAL|sed 's/\"//g'`\" >> $TMP
			}
			;;
		*)
			eval SW=\$_SW_$LVAL
			[ "$SW" ] ||
			{
				echo "_SW_$LVAL=$LVAL" >> $TMP
				echo _ARG_$LVAL=\"`echo $RVAL|sed 's/\"//g'`\" >> $TMP
			}
			;;
		esac

	done

	. $TMP

	[ "$PATCH_DEBUG" ] &&
	{
		echo "\n=== After processing data file"
		cat $TMP 
	}

	rm -f $TMP 
	return 0

}



P_ArgsInit ()
{
	_OPS="-install | -delete | -track | -help"

	_DUPATCH_REV=10; export _DUPATCH_REV

	_CMDLINE=

	_ALLARGS=$*

	_DELETE_SW="DATA NAME NOTE PATCH PROCEED ROOT VERSION"
	_HELP_SW="DATA_FILE PATCH_ID REV ROOT_PATH VERSION_STRING"
	_INSTALL_SW="DATA KIT NAME NOBACKUP NOTE PATCH PRECHECK_ONLY PROCEED ROOT"
	_TRACK_SW="DATA ROOT TYPE"

	_TYPE_KEY="PATCH FILE"
	_VERSION_KEY="`VerInfo ALLSTR`"

	_VERSION_LIST=
	_PATCH_LIST=


	_ALLSW="ROOT DATA DATA_FILE KIT NAME NOBACKUP NOTE PATCH_ID PRECHECK_ONLY PROCEED REV ROOT_PATH TYPE VERSION VERSION_STRING PATCH" 

	
	DELETE_USAGE="	$_PROG -delete 	
			 -name <user_name> 
			 -note <user_note>
			 -patch <all | patch_id [patch_id ...]>
	
			 [optional switches]:
				-data <data_file>
		       	   	-root <root_path>		
				-proceed	* proceed with patches that
						* passed pre-deletion check
			   	-version <version_string>"

	HELP_USAGE="	$_PROG -help
			 [optional switches]:
				-data_file	* specifies data_file usage 
				-patch_id	* specifies patch_id usage 
				-rev		* lists $_PROG revision
				-version_string * specifies version_string usage"
		

	INSTALL_USAGE="	$_PROG -install	
			 -kit <kit_location>
			 -name <user_name> 	*
			 -note <user_note> 	*
			 -patch <all | patch_id [patch_id ...]>

				* optional when -precheck_only is specified.

			 [optional switches]:
			   	-data <data_file>
			   	-nobackup
			   	-precheck_only
				-proceed	* proceed with patches that
						* passed pre-installation check
			   	-root <root_path>"

	TRACK_USAGE="	$_PROG -track 	
			 -type <patch | file>
			     	* use \"patch\" to list installed patches.
			     	* use \"file\"  to list all patched files.

			 [optional switches]:
				-data <data_file>
				-root <root_path>"


	ALL_USAGE="For an operation to be completely non-interactive, all mandatory
switches must be specified on the command line or in the data_file.

$DELETE_USAGE

$HELP_USAGE

$INSTALL_USAGE

$TRACK_USAGE"

	DATA_FILE_USAGE="
<data_file usage>:

	When using the \"-data\" switch, you must specify a data_file
	which is a file path and contains specifications with the 
	following format:

		switch1=value	
		switch2=value
			.
  			.
		switch3

	Example:

		kit	= /mnt
		name	= John Doe
		note	= install April patch kit
		patch	= all

		precheck_only
		nobackup

	- blank lines and comments (preceded with #) are allowed.

	- line continuation (\) is required if a specification spans 
   	  multiple lines.

	- When a switch is specified both on the command line and in 
	  the data_file, the value specified on the command line 
	  overrides that specified in the data_file.
"

	REV_USAGE="
DIGITAL UNIX Patch Utility (Rev. $_DUPATCH_REV)
"
	ROOT_PATH_USAGE="
<root_path usage>:

	- the \"-root\" switch is similar to the \"-D\" switch of setld (8),
	  which specifies an alternative root for the specified operation.
 	
	- root_path must be the root of a complete DIGITAL UNIX file system.

	- The default root_path is / for all operations.
"

	_TOOLSUB=00000; export _TOOLSUB

	export ALL_USAGE DATA_FILE_USAGE ROOT_PATH_USAGE REV_USAGE

}


P_ArgsPatchAdd ()
{
	FILE=$1

	[ "$_ARG_PATCH" ] || return 0

	for J in $_ARG_PATCH
	{
		J=`ToUpper $J`			
		P=`echo $_ARG_VERSION:$J`

		_PATCH_LIST="$_PATCH_LIST $P"

		[ -f $FILE ] &&
			echo _PATCH_LIST=\"$_PATCH_LIST\" >> $FILE
	}

	return 0
}



P_ArgsPatchMap ()
{
	[ "$_PATCH_LIST" ] || return 0

	
	P_SetRoot

	[ "$_TYPE" = INSTALL ] &&
	{
        	P_KitLocGet || return 1
	}
	
	PLIST=
	PSUB_ERROR=
	for J in $_PATCH_LIST
	{
		V=`echo $J | awk -F: '{print $1}'`
		P=`echo $J | awk -F: '{print $2}'`

		if [ "$V" ]; then 
		{
			V=`ToUpper $V`
			VER=`VerInfo GETNUM $V`
		}
		else
			VER=???
		fi
		
		case "$P" in 
		ALL)	ID=?????
			RV=??
			;;

		*)	# process patch id, separate patch id and rev number.
			ID=`echo $P| awk -F. '{print $1}'`
			RV=`echo $P | awk -F. '{print $2}'`
			if [ "$ID" ]; then 
				ID=`echo $ID | awk '{printf "%05d", $1}'`
			else
				ID=?????
			fi

			if [ "$RV" ]; then 
				RV=`echo $RV | awk '{printf "%02d", $1}'`
			else
				RV=??
			fi
			;;
		esac

		case "$_TYPE" in
		INSTALL)PSUB=`(cd $_DUPATCH_KIT; ls OSFPAT?${ID}${RV}${VER} 2>/dev/nul1)`	 
			[ "$PSUB" ] ||
			{
				P_Error "
Patch \"$P\" is not available on the specified patch kit."
				PSUB_ERROR=1
				continue
			}

			STL_DepInit

			LIST=
			for S in $PSUB
			{
				STL_DepEval $S &&
                        	{
                			case $S in
                			OSFPAT?$_TOOLSUB*)
                        			continue
                        			;;
                			esac

					SDESC=$S
					SDESC=`GetSubDesc $S $_DUPATCH_KIT/instctrl Y`
					P_Error "
\"$SDESC\" 
is already installed and will not be included in this operation."
					continue
                        	}
				LIST="$LIST $S"
			}

			PLIST="$PLIST $LIST" 
			;;

		DELETE) PSUB=`(cd $_SMDB; ls OSFPAT?${ID}${RV}${VER}.lk 2>/dev/nul1 | sed 's/\.lk//')`	 
			[ "$PSUB" ] ||
			{
				STR2=
				[ "$V" ] && 
				{
					STR2=" for DIGITAL UNIX $V"
				}

				case "$P" in 
				ALL) 
					STR1="No patches"
					STR3=are
					;;
				*)
					STR1="Patch \"$P\""
					STR3="is not"
					;;
				esac

				P_Error " 
$STR1 $STR2 $STR3 installed on your system."
	
				continue
			}

			[ `Length $PSUB` -gt 1 -a "$P" != ALL ] &&
			{
				STR=
				for S in $PSUB
				{
					VER=`expr "$S" : '.*\(...\)'`
					VER=`VerInfo GETSTR $VER`
					PID=`expr "$S" : '.*\(.....\).....'`
					REV=`expr "$S" : '.*\(..\)...'`
					STR="$STR\n\tversion $VER	- patch $PID.$REV"
				}

				P_Error "
There are more than one Patch \"$P\" installed on your system:  
	$STR

Please clarify your specification by tagging on the patch revision 
and/or adding a \"-version\" switch before the \"-patch\" switch to 
specify the exact one."
				PSUB_ERROR=1
				continue
			}

        		LIST=
			for S in $PSUB
        		{
                		case $S in
                		OSFPAT?$_TOOLSUB*)
                        		continue
                        		;;
                		esac
			
                		LIST="$LIST $S"
        		}

			PLIST="$PLIST $LIST" 
			;;
		esac


	}

	[ "$PSUB_ERROR" ] && return 1

	_ARG_PATCH=`echo $PLIST`

	[ "$PATCH_DEBUG" ] && 
		echo "\n=== _ARG_PATCH=$_ARG_PATCH."

	[ "$_ARG_PATCH" ] ||
	{
		case "$_TYPE" in
		INSTALL)STR=installable
			;;
		DELETE)	STR=deletable
			;;
		esac

		P_Error "
There are no $STR patches as specified on the command line.
"

		P_Exit 2
	}

	return 0
}



P_ArgsPatchMsg ()
{
	CASE=$1

	TAB=	
	PREFIX=
	[ "$_TYPE" = HELP ] && 
	{
		PREFIX="\n<patch_id usage>:\n"		
		TAB="\t- "
	}

	STR_NOARG="\nThe \"-patch\" switch requires a list of patch_id's or the keyword 'all'."

	STR_ALLMIX="\n${TAB}The keyword 'all' can not be combined with other patch_ids."

	STR_ID="\n${TAB}A valid patch_id specification is in the format of:\n\n\t\t'all' <or> xxxx[.yy]\n\n\t\tExamples:\n\n\t\t\t200.11\n\t\t\t10.2\n\t\t\t00111.02\n\n\t- where xxxx is the patch identifier and yy is the patch revision.\n\n\t- Both xxxx and yy are numeric values; leading zeros can be omitted.\n\n\t- Patch revision (yy), when left unspecified, maps to wildcarded \"??\".\n\n\t- Multiple patch_id specifications are separated by white space."

	STR_ALL="$PREFIX$STR_ID\n$STR_ALLMIX\n"

	eval STR=\$STR_$CASE

	if [ "$_TYPE" = HELP ]; then 
		echo $STR
	else
		P_Error $STR
	fi

	return 0
}



P_ArgsPatchParse ()
{(

	VAL=$*

	[ "$VAL" ] ||
	{
		P_ArgsPatchMsg NOARG 
		return 1 
	}

	ERR=0

	NUM=`Length $VAL` 

	ID_ERR=
	for P in $VAL
	{
		P=`ToUpper $P`	
		case $P in
		ALL)	[ "$NUM" -eq 1 ] && return 0
			
			P_ArgsPatchMsg ALLMIX 
			ERR=1
			continue 
			;; 
		esac

		P_ERR=

		ID=`echo $P| awk -F. '{print $1}'`
		RV=`echo $P | awk -F. '{print $2}'`

		[ "$ID" ] ||
		{
			ID_ERR=1
			P_Error "
\"$P\" is not a valid patch_id specification."
			continue 
		}

		case $ID in
		[0-9] | \
		[0-9][0-9] | \
		[0-9][0-9][0-9] | \
		[0-9][0-9][0-9][0-9] | \
		[0-9][0-9][0-9][0-9][0-9]) 	
			;;
		*)
			ID_ERR=1
			P_Error "
\"$P\" is not a valid patch_id specification."
			continue 
			;;
		esac

		[ "$RV" ] && 
		{
			case $RV in
			[0-9] | \
			[0-9][0-9]) 	
				;;
			*) 	
				ID_ERR=1
				P_Error "
\"$P\" is not a valid patch_id specification."
				continue	
				;;
			esac
		}
		
	}

	[ "$ID_ERR" ] &&
	{
		P_ArgsPatchMsg ID $P
		ERR=1
	}

	return $ERR 
)}



P_ArgsVersionParse ()
{
	VAL=$*

	[ "$VAL" ] ||
	{ 
		P_Error " 
The \"-version\" switch requires a DIGITAL UNIX version string."
		return 1
	} 

	[ `Length $VAL` -gt 1 ] &&
	{ 
		P_Error " 
You can only specify one version string at a time."
		return 1
	} 

	return 0

}



P_ArgsVersionMsg ()
{
	echo "
<version string usage>:

	Valid DIGITAL UNIX version strings are as follows: 
"

	for V in $_VERSION_KEY
	{
		echo "
		$V"
	}

	echo "
	- A version_string specification only applies to the following
	  patch_id specification(s) and ends when another version_string
	  is specified. 

	- A version_string specification is not necessary when there're
	  no ambiguities in the patch_id specification.

	  Since its purpose is to clarify the patch_id specification,
	  its specification must precede that of the patch_id(s).

	Example:

		-version V4.0 -patch 1.1 -version V4.0B -patch 1.1

		In a "delete" operation, if there's only one patch 1.1
		installed on your system, the \"-version\" switch is not
		required.
"

	return 0
}



P_Cleanup ()
{
        trap '' 0
	
	rm -rf $_DUPATCH_TMP

	[ "$PATCH_DEBUG" ] && 
		echo "\n=== $_DUPATCH_TMP removed."
}




P_Error ()
{
        1>&2 echo "$*"
}



P_Exit ()
{
        STAT=$1

        P_Cleanup

        exit $STAT 
} 



P_Ferror ()
{
        STAT=$1
        P_Error "$_PROG: $2"
        P_Exit $STAT
}



P_KitLocCheck ()
{

	P=`P_AbsPath $1`

	[ -d $P ] ||
	{
		P_Error "
	$P does not exist"
		return 1
	}
	[ -d $P/kit ] ||
	{
		P_Error "
	$P/kit does not exist.
	$P does not contain a complete patch kit.
"

		return 1 
	} 
	
	[ -d $P/kit/instctrl ] ||
	{
		P_Error "
	$P/kit does not contain a DIGITAL UNIX patch kit.
"

		return 1
	}

	[ -d $P/doc ] ||
	{
		P_Error "
	/$P/doc does not exist.
	$P does not contain a complete patch kit.
"

	}

	_DUPATCH_KIT=$P/kit
	_DUPATCH_DOC=$P/doc
	export _DUPATCH_KIT _DUPATCH_DOC
	 
	SUB=`ls -1 $_DUPATCH_KIT/instctrl/*.ctrl | head -1`	
	eval `grep NAME= $SUB`
	_KITNAME=$NAME; export _KITNAME

	[ "$PATCH_DEBUG" ] &&
	{
		echo "\n=== _DUPATCH_KIT=$_DUPATCH_KIT"
		echo "\n=== _DUPATCH_DOC=$_DUPATCH_DOC"
	}

	return 0
               
}



P_KitLocGet ()
{

        [ "$_DUPATCH_KIT" ]  ||
        {
		[ "$_ARG_KIT" ] && 
		{
			P_KitLocCheck $_ARG_KIT
			return $?
		}

		STR="get back to the menu"
		[ "$_CMDLINE" ] &&
			STR=quit

		while :
		do
			Dialog "
Enter path to the patch kit (the directory containing ./kit and ./doc),
or enter \"q\" to $STR" P

			case $P in
			q|Q)
				return 1
				;;
			*)	P_KitLocCheck $P 
				return $?
				;;
			esac
		done
        }

	return 0
}



P_KitMatch ()
{

	ALLBASE=`(cd $_SMDB; ls -r OSFBASE*.lk 2>/dev/null | sed 's/\.lk//g' | sed 's/OSFBASE.*[\?\*].*//g')`

	[ "$ALLBASE" ] || 
	{
		P_Error "
	This patch kit can not be applied on a system
	without the \"Base System\" subset installed. "
		return 1
	}
	
	SYSBASE=`Car $ALLBASE`
	_SYSVER=`expr "$SYSBASE" : 'OSFBASE\(...\)'`

	KITSUB=`ls -1 $_DUPATCH_KIT | fgrep OSFPAT | head -1`
	_KITVER=`expr "$KITSUB" : '.*\(...\)$'`

	[ $_SYSVER = $_KITVER ] && return 0

	P_Error "
	This patch kit can be applied to DIGITAL UNIX `VerInfo GETSTR $_KITVER` systems only.
"

	SYSSTR=`VerInfo GETSTR $_SYSVER`
	
	[ "$SYSSTR" ] &&
		P_Error "	Your system has DIGITAL UNIX $SYSSTR installed.
"

	return 1

}



P_SetRoot ()
{
	[ "$_ROOT" ] && return 0

	if [ "$_ARG_ROOT" ]; then 
	{
		_ROOT=$_ARG_ROOT

        	case "$_ROOT" in
		/*)     ;;
		*)      _ROOT=`(cd $_ROOT;Pwd)`
		esac

		_ALTROOT="-D $_ROOT"
	} 
	else
	{
		_ROOT=/
		_ALTROOT=
	}
	fi

	_SMDB=./usr/.smdb.
	export _ROOT _SMDB

	cd $_ROOT

	[ "$PATCH_DEBUG" ] &&
	{
		echo "\n=== _ROOT is $_ROOT"
		echo "\n=== _ALTROOT passed to setld is: $_ALTROOT"
	}

	return 0
}



P_SetSwitch ()
{

	SW=$1
	S=`echo $SW | sed 's/^-//'`
	S=`ToUpper $S`
	eval _SW_$S='$S'

	ARG_CNT=0
	eval _ARG_$S=

	shift
	ARGS=

	while :
	do
		[ $# -eq 0 ] && break

		case $1 in
		-*)	break
			;;
		*)	ARGS="$ARGS $1"
			ARG_CNT=`expr $ARG_CNT + 1`
			shift	
			;;
		esac
	done
	
	ARGS=`echo $ARGS`
	eval _ARG_$S='$ARGS' 

	[ "$PATCH_DEBUG" ] &&
		eval echo _ARG_$S=\$_ARG_$S
		
	_SHIFT=`expr $ARG_CNT + 1`
} 



P_UpdateTools ()
{
	[ "$_TOOLS_UPDATED" ] && return 0

	_TOOLS_UPDATED=

	P_KitMatch || return 1

	NEWSUB=`(cd $_DUPATCH_KIT; ls OSFPAT?${_TOOLSUB}* 2>/dev/null)`

	[ "$NEWSUB" ] || 
           	return 0


        CURSUB=`(cd $_SMDB; ls -1 OSFPAT?${_TOOLSUB}*${_KITVER}.lk 2>/dev/null |tail -1 | sed 's/\.lk//')`

	[ "$CURSUB" ] && 
	{

		NEWREV=`expr "$NEWSUB" : '.*\([0-9][0-9]\)...'`
		CURREV=`expr "$CURSUB" : '.*\([0-9][0-9]\)...'`
		
		[ $CURREV -gt $NEWREV ] && return 0

		[ $CURREV -eq $NEWREV -a ! "$UPDATE_DUPATCH" ] && return 0

     
		[ "$PATCH_DEBUG" ] &&
			echo "\n=== utility update NEW: $NEWREV  CUR: $CURREV"
	}


	STR1="."
 	STR2=""
	[ $_ROOT = / ] || 
	{
		STR1=" relative to $_ROOT."
		STR2="$_ROOT"
	}

        echo "
	* A new version of patch tools required for patch management 
	  is now being installed on your system$STR1"

	/usr/sbin/setld $_ALTROOT -l $_DUPATCH_KIT $NEWSUB > /dev/null || 
		P_Ferror 1 "\nFailed to update patch tools."

	echo "
	* Tools updated, invoking the updated Patch Utility...  "

	_TOOLS_UPDATED=1; export _TOOLS_UPDATED

	_DUPATCH_EXEC=Y; export _DUPATCH_EXEC
	exec $STR2/usr/sbin/$_PROG $_ALLARGS

	return $?
}



P_Usage ()
{
	case $1 in
	DELETE)
		echo "\n$DELETE_USAGE"
		;;
	HELP)
		[ "$_SW_DATA_FILE" ] &&
			echo "$DATA_FILE_USAGE"

		[ "$_SW_PATCH_ID" ] &&
			P_ArgsPatchMsg ALL

		[ "$_SW_REV" ] &&
			echo $_DUPATCH_REV

		[ "$_SW_ROOT_PATH" ] && 
			echo "$ROOT_PATH_USAGE"

		[ "$_SW_VERSION_STRING" ] &&
			P_ArgsVersionMsg

		[ ! "$_SW_DATA_FILE" -a \
		  ! "$_SW_PATCH_ID" -a \
		  ! "$_SW_REV" -a \
		  ! "$_SW_ROOT_PATH" -a \
		  ! "$_SW_VERSION_STRING"  ] &&	
		{

			TMP=/var/tmp/$_PROG.help
			> $TMP

			echo "$REV_USAGE" >> $TMP
			echo "$ALL_USAGE" >> $TMP
			echo "$DATA_FILE_USAGE" >> $TMP
			P_ArgsPatchMsg ALL >> $TMP
			echo "$ROOT_PATH_USAGE" >> $TMP
			P_ArgsVersionMsg >> $TMP

			if [ "$_DISPLAY" ]; then
				$_DISPLAY $TMP
			else
				cat $TMP
			fi

			rm -f $TMP
		}
		;;
	INSTALL)	
		echo "\n$INSTALL_USAGE"
		;;
	TRACK)	
		echo "\n$TRACK_USAGE"
		;;
	*)	echo "\n$ALL_USAGE"	
	esac
	
	return 0
}



P_ValidVer ()
{
	_PVNUM=`(cd $_SMDB; ls -1 OSFPAT*.lk 2>/dev/null | sed 's/\(.*\)\(...\)\(\.lk\)/\2/g' | sort -u)`

	_PVSTR=
	for J in $_PVNUM
	{
		STR=`VerInfo GETSTR $J`
		_PVSTR="$_PVSTR $STR"
	}

	export _PVSTR _PVNUM

	return 0
}

  
# @DEC_COPYRIGHT@
# @(#)$RCSfile: Subset.sh,v $ $Revision: 1.1.1.3 $ (DEC) $Date: 1997/05/20 20:09:20 $


GetSubDesc ()
{
	SUB=$1
	LOC=$2
	STRIP_CAT=$3

	SDESC=
	[ -f $LOC/$SUB.ctrl ] &&
	{ 
		eval `grep DESC= $LOC/$SUB.ctrl`

		SDESC=$DESC
		[ "$STRIP_CAT" = Y ] && 
			SDESC=`echo $DESC | sed 's/%.*//' | sed 's/ $//'`
	}

	case "$SUB" in
	???PAT?[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9])
		VCODE=`expr "$SUB" : '^.*\(...\)$'`	# version code 
		BASE=`expr "$SUB" : '^...\(.*\)...$'`	# w/o p/vcode

		PID=`echo $BASE | cut -b 6-9'`  	# id
		PREV=`echo $BASE | cut -b 10-11'`  	#  rev

		SDESC="`VerInfo GETSTR $VCODE` Patch $PID.$PREV - $SDESC" 
		;;
	esac

	echo $SDESC
	return 0
}

# @DEC_COPYRIGHT@
# @(#)$RCSfile: Ver.sh,v $ $Revision: 1.1.1.2 $ (DEC) $Date: 1997/04/29 13:19:40 $

VerInfo ()
{
        SWITCH=$1
        VAL=$2

	INFO=/var/tmp/verinfo$$

        cat >> $INFO <<PAIRS
V3.2C:350
V3.2D-1/E-1:360
V3.2D-2/E-2:365
V3.2F:370
V3.2G:375
V4.0:400
V4.0A:405
V4.0B:410
V4.0C:415
PAIRS

	case $SWITCH in
	ALLSTR)
		cat $INFO | while read PAIR
		do
			echo $PAIR | awk -F: '{print $1}'
		done
		;;
	ALLNUM)
		cat $INFO | while read PAIR
		do
			echo $PAIR | awk -F: '{print $2}'
		done
		;;
	GETSTR)
		egrep ":$VAL" $INFO | awk -F: '{print $1}'
		;;
	GETNUM)
		egrep "$VAL:" $INFO | awk -F: '{print $2}'
		;;
	esac


	rm -f $INFO
	return 0
}
  
[ "$SYNTAX" ] || Main $@
