# This script creates the backout package for a patch package
#
# directory format options.
#
# @(#) postinstall 1.13 01/01/12 SMI
#
# Copyright (c) 1995 by Sun Microsystems, Inc.
# All rights reserved
#

# Description:
#       Set the TYPE parameter for the remote file
#
# Parameters:
#       none
#
# Globals set:
#	TYPE

set_TYPE_parameter () {
	if [ ${PATCH_UNDO_ARCHIVE:?????} = "/dev" ]; then
		# handle device specific stuff
		TYPE="removable"
	else
		TYPE="filesystem"
	fi
}

#
# Description:
#       Build the remote file that points to the backout data
#
# Parameters:
#       $1:	the un/compressed undo archive
#
# Globals set:
#	UNDO, STATE

build_remote_file () {
	remote_path=$PKGSAV/$SUNW_PATCHID/remote
	set_TYPE_parameter
	STATE="active"

	if [ $1 = "undo" ]; then
		UNDO="undo"
	else
		UNDO="undo.Z"
	fi

	cat > $remote_path << EOF
# Backout data stored remotely
TYPE=$TYPE
FIND_AT=$ARCHIVE_DIR/$UNDO
STATE=$STATE
EOF
}

PATH=/usr/sadm/bin:$PATH

if [ "$PKG_INSTALL_ROOT" = "/" ]; then
	PKG_INSTALL_ROOT=""
fi

if [ -n "$PATCH_BUILD_DIR" -a -d "$PATCH_BUILD_DIR" ]; then
	BUILD_DIR="$PATCH_BUILD_DIR/$SUNW_PATCHID.$PKGINST"
else
	BUILD_DIR="$PKG_INSTALL_ROOT/var/tmp/$SUNW_PATCHID.$PKGINST"
fi

if [ ! -n "$PATCH_UNDO_ARCHIVE" ]; then
	PATCH_UNDO_ARCHIVE="none"
fi

FILE_DIR=$BUILD_DIR/files
RELOC_DIR=$FILE_DIR/reloc
ROOT_DIR=$FILE_DIR/root
BO_Deletes=$FILE_DIR/deletes
THIS_DIR=`dirname $0`
PROTO_FILE=$BUILD_DIR/prototype
TEMP_REMOTE=$PKGSAV/$SUNW_PATCHID/temp

if [ "$PATCH_PROGRESSIVE" = "true" ]; then
        # remove the scripts that are left behind
        install_scripts=`dirname $0`
        rm $install_scripts/checkinstall $install_scripts/patch_checkinstall $install_scripts/patch_postinstall

	# If this is being used in an old-style patch, insert
	# the old-style script commands here.

	#XXXOld_CommandsXXX#

	exit 0
fi

#
# At this point we either have a deletes file or we don't. If we do,
# we create a prototype entry.
#
if [ -f $BO_Deletes ]; then
	echo "i deletes=$BO_Deletes" >> $BUILD_DIR/prototype
fi

#
# Now delete everything in the deletes list after transferring
# the file to the backout package and the entry to the prototype
# file. Remember that the pkgmap will get the CLIENT_BASEDIR path
# but we have to actually get at it using the BASEDIR path. Also
# remember that removef will import our PKG_INSTALL_ROOT
#
Our_Deletes=$THIS_DIR/deletes
if [ -f $Our_Deletes ]; then
	cd $BASEDIR

	cat $Our_Deletes | while read path; do
		Reg_File=0

		if valpath -l $path; then
			Client_Path="$CLIENT_BASEDIR/$path"
			Build_Path="$RELOC_DIR/$path"
			Proto_Path=$BASEDIR/$path
		else	# It's an absolute path
			Client_Path=$path
			Build_Path="$ROOT_DIR$path"
			Proto_Path=$PKG_INSTALL_ROOT$path
		fi

		# If BASEDIR/CLIENTBASEDIR = "/", then the previous prepends
		# an extra / i.e. //. The sed command later can't find a
		# Proto_Path with // and therefore will not substitute the
		# correct build_Path resulting in the backout pkg not being
		# created.

		if [ "$CLIENT_BASEDIR" = "/" ]; then
			Client_Path=`echo $Client_Path | sed 's|^\/\/|\/|'`
			Proto_Path=`echo $Proto_Path | sed 's|^\/\/|\/|'`
		fi
			
		# Note: If the file isn't really there, pkgproto
		# doesn't write anything but displays an error
		# so check for the file before processing.

		if [ -f "$Proto_Path" ]; then
			LINE=`pkgproto $Proto_Path=$path`
		else
			continue
		fi

		ftype=`echo $LINE | nawk '{ print $1 }'`
		if [ "$ftype" = "f" ]; then
			Reg_File=1
		fi

		if [ $Reg_File = 1 ]; then
			# Add source file to the prototype entry
			if [ "$Proto_Path" = "$path" ]; then
				LINE=`echo $LINE | sed -e "s|$Proto_Path|$Build_Path|2"`
			else
				LINE=`echo $LINE | sed -e "s|$Proto_Path|$Build_Path|"`
			fi

			DirName=`dirname $Build_Path`
			# make room in the build tree
			mkdir -p $DirName
			cp -p $Proto_Path $Build_Path
		fi

		# Insert it into the prototype file
		echo $LINE 1>>$PROTO_FILE 2>/dev/null

		# Remove the file only if it's OK'd by removef
		rm `removef $PKGINST $Client_Path` 1>/dev/null 2>&1
	done
	removef -f $PKGINST

	rm $Our_Deletes
fi

#
# Unless specifically denied, make the backout package.
#
if [ "$PATCH_NO_UNDO" != "true" ]; then
	cd $BUILD_DIR	# We have to build from here.

	if [ "$PATCH_UNDO_ARCHIVE" != "none" ]; then
		STAGE_DIR="$PATCH_UNDO_ARCHIVE"
		ARCHIVE_DIR="$PATCH_UNDO_ARCHIVE/$SUNW_PATCHID/$PKGINST"
		mkdir -p $ARCHIVE_DIR
		mkdir -p $PKGSAV/$SUNW_PATCHID
	else
		if [ -d $PKGSAV/$SUNW_PATCHID ]; then
			rm -r $PKGSAV/$SUNW_PATCHID
		fi
		STAGE_DIR=$PKGSAV
		ARCHIVE_DIR=$PKGSAV/$SUNW_PATCHID
		mkdir $ARCHIVE_DIR
	fi

	pkgmk -o -d $STAGE_DIR 1>/dev/null 2>&1
	pkgtrans -s $STAGE_DIR $ARCHIVE_DIR/undo $PKG 1>/dev/null 2>&1
	compress $ARCHIVE_DIR/undo
	retcode=$?
	if [ "$retcode" != 0 ]; then
		echo "compress(1) returned error code $retcode"
		echo "The $PKGINST backout package will not be compressed."
		echo "Continuing to process backout package."
	fi
	if [ "$PATCH_UNDO_ARCHIVE" != "none" ]; then
		if [ $retcode != 0 ]; then
			build_remote_file "undo"
		else
			build_remote_file "undo.Z"
		fi
	fi
	rm -r $STAGE_DIR/$PKG

	cd ..
	rm -r $BUILD_DIR
	# remove the scripts that are left behind
	install_scripts=`dirname $0`
	rm $install_scripts/checkinstall $install_scripts/patch_checkinstall $install_scripts/patch_postinstall
fi

#
# Since this apparently worked, we'll mark as obsoleted the prior
# versions of this patch - installpatch deals with explicit obsoletions.
#
cd ${PKG_INSTALL_ROOT:-/}
cd var/sadm/pkg

active_base=`echo $SUNW_PATCHID | nawk '
	{ print substr($0, 1, match($0, "-")-1) } '`

List=`ls -d $PKGINST/save/${active_base}* 2>/dev/null`
if [ $? -ne 0 ]; then
	List=""
fi

for savedir in $List; do
        patch=`basename $savedir` 
        if [ $patch = $SUNW_PATCHID ]; then
		break
	fi

        # If we get here then the previous patch gets deleted
	if [ -f $savedir/undo ]; then
		mv $savedir/undo $savedir/obsolete
		echo $SUNW_PATCHID >> $savedir/obsoleted_by
	elif [ -f $savedir/undo.Z ]; then
		mv $savedir/undo.Z $savedir/obsolete.Z
		echo $SUNW_PATCHID >> $savedir/obsoleted_by
        elif  [ -f $savedir/remote ]; then
                `grep . $PKGSAV/$patch/remote | sed 's|STATE=.*|STATE=obsolete|' > $TEMP_REMOTE` 
                rm -f $PKGSAV/$patch/remote 
                mv $TEMP_REMOTE $PKGSAV/$patch/remote  
                rm -f $TEMP_REMOTE 
                echo $SUNW_PATCHID >> $savedir/obsoleted_by
	elif  [ -f $savedir/obsolete -o -f $savedir/obsolete.Z ]; then
		echo $SUNW_PATCHID >> $savedir/obsoleted_by
	fi
done

# If additional operations are required for this package, place
# those package-specific commands here.

#XXXSpecial_CommandsXXX#

#---------------------------------------------------------
# Takes INSTALL Directory as input.
# Return value results :
# 0 - successful upgrade. , 1 - error, unable to upgrade.
#---------------------------------------------------------
perform_post_upgrade () {

    installDir="$1"
    if [ ! -d "$installDir" ]; then
      echo "Installation Directory:$installDir does NOT exist."
      return 1;
    fi

    # Initialize the upgrade61 executable.
    if [ ! -f "$installDir/bin/https/bin/upgrade61" ]; then
      return 1
    fi

    $PERL $installDir/bin/https/bin/upgrade61 -r "$installDir"
    result=$?

    # Did upgrade go smoothly?
    if [ $result -ne 0 ]; then
      return 1
    fi

    return 0
}

#------------------------------------------------------------
###
# Start of Main program.
###
#------------------------------------------------------------

#############################################################
PRODUCT_NAME="Sun Java System Web Server"

# We should dynamically detect the SP VERSION.
COMPONENTS="webcore,snmp,cleanup"
JDK_SUPPORT="yes"
PERL_BINARY="$BASEDIR/bin/https/perl/perl"
PERL="$BASEDIR/bin/https/perl/perl -I$BASEDIR/bin/https/perl/perl/lib"
#############################################################

if [ -z "$PKG_INSTALL_ROOT" ]; then
  ROOTDIR="/"
else
  ROOTDIR="$PKG_INSTALL_ROOT"
fi

#------------------------------------------------------------
# Find location of a ksh or bash shell. We know one of them
# is here, since to get here we passed the test in checkinstall
#------------------------------------------------------------
if [ -x $PKG_INSTALL_ROOT/usr/bin/ksh ]; then
	SHELL_BIN="/usr/bin/ksh"
elif [ -x $PKG_INSTALL_ROOT/bin/ksh ]; then
	SHELL_BIN="/bin/ksh"
else
	SHELL_BIN="/bin/sh"
fi

#------------------------------------------------------------
# Validate perl location.
#------------------------------------------------------------
if [ ! -x "$PERL_BINARY" ]; then
	echo "Unable to find Perl program within $BASEDIR. "
	exit 1
fi

#------------------------------------------------------------
# Create default user/group of webservd/webservd. This came
# from the setup script.
#------------------------------------------------------------
# The following construct is used because some shell interpreters have
# problems with if ! <command>; then ...
#   if command; then
#     :
#   else
#     ... ! command ...
#   fi

# The following binaries will be searched for in the following search
# paths.  Once located, their full paths will be put in variables named
# s1_<binary>.  If any binaries are missing, report the missing
# binary and exit.
#------------------------------------------------------------
binaries='cut:roleadd:groupadd:getent:mv:rm:sed:awk:umask:chmod:ln'
search_dirs="/sbin:/usr/sbin:/bin:/usr/bin:/usr/ucb:/usr/local/bin:$PATH"

OLD_IFS=$IFS
IFS=:

for binary in $binaries; do
	binary_path=""
	for dir in $search_dirs; do
		if [ -x "$dir/$binary" ]; then
			binary_path="$dir/$binary"
			break
		fi
	done

	if [ -z "$binary_path" ]; then
		echo "Error: Unable to locate binary '$binary'."
		echo "       Please make certain this binary is on your path and try again."
		exit 1
	else
		eval "s1_$binary=$binary_path"
	fi
done

IFS=$OLD_IFS


# On Solaris, we have registered the webservd username / groupname to
# be associated with uid 80 / gid 80.  On other OS' we continue to
# use nobody / nobody as the default.

if $s1_getent group webservd > /dev/null 2>&1; then
	group_entry=`$s1_getent group webservd 2>&1`
	gid=`echo $group_entry | $s1_cut -f 3 -d':'`

	if [ "$gid" != "80" ]; then
		echo "Warning: Non-standard webservd group detected with gid=$gid."
		echo "         Expected webservd to have gid=80."
	fi
else
	if $s1_groupadd -g 80 webservd > /dev/null 2>&1; then
		:
	else
		echo "Warning: Unable to install the webservd group at gid 80." 1>&2
		echo "         This is a reserved gid that looks to be in use."
	fi
fi

if $s1_getent passwd webservd > /dev/null 2>&1; then
	passwd_entry=`$s1_getent passwd webservd 2>&1`
	uid=`echo $passwd_entry | $s1_cut -f 3 -d':'`
	gid=`echo $passwd_entry | $s1_cut -f 4 -d':'`

	if [ "$uid" != "80" ]; then
		echo "Warning: Non-standard webservd user detected with uid=$uid." 1>&2
		echo "         Expected webservd to have uid=80."
	fi
	if [ "$gid" != "80" ]; then
		echo "Warning: Non-standard webservd user detected with primary gid=$gid." 1>&2
		echo "         Expected webservd to have gid=80."
	fi
else
	$s1_roleadd -u 80 -g webservd webservd > /dev/null 2>&1
	err_code=$?
	if [ $err_code -eq 0 ]; then
		:
	elif [ $err_code -eq 9 ]; then
		# webservd user already exists at uid 80.
		:
	else
		echo "Warning: Unable to install the webservd user at uid 80." 1>&2
		echo "         This is a reserved uid that looks to be in use."
	fi
fi

# create a symbolic link to the shared copy of NSS utilities if not already
# created. Delete the private copy of the NSS utilities if they exist.

nss_shared_dir="/usr/sfw/bin"
nss_private_dir="$BASEDIR/bin/https/admin/bin"
nss_utils="modutil certutil pk12util"

for util in $nss_utils; do
	if [ ! -h $nss_private_dir/$util ]; then
		if [ ! -f $nss_shared_dir/$util ]; then
			echo "Warning: $nss_shared_dir/$util not found"
			echo "Please ensure that SUNWtlsu is installed"
		else
			if [ -f $nss_private_dir/$util ]; then
				$s1_rm -f $nss_private_dir/$util
			fi
			# create symlink using installf so that contents db is updated
			installf $PKG $nss_private_dir/$util=$nss_shared_dir/$util s
		fi
	fi
done

#------------------------------------------------------------
# Update the configure file
#------------------------------------------------------------
CONFIGURE_FILE="$BASEDIR/setup/configure"
CONFIGURE_TMP_FILE="$BASEDIR/setup/configure.tmp"
ERR_LOG="$BASEDIR/setup/configure.err.log"

installf $PKG $CONFIGURE_FILE

#############
### Handle install and upgrade mode separately.
############

is_upgrade=0

# This is upgrade mode and so handle this scenario accordingly
if [ -d "$BASEDIR/https-admserv" ]; then
  is_upgrade=1 
  perform_post_upgrade "$BASEDIR"
  echo "${PRODUCT_NAME} has been updated successfully."
fi

# This is fresh install mode and so handle this scenario accordingly
if [ $is_upgrade -eq 0 ]; then
  if [ ! -f "$CONFIGURE_FILE" ]; then
	  echo "WARNING: Unable to find the configure script in the $PRODUCT_NAME installation."
	  exit 1
  fi

  if [ -f "$CONFIGURE_FILE" ]; then
	  $s1_sed -e "s@<<_SHELL_>>@$SHELL_BIN@g" \
		-e "s@<<_SHELL_BINARY>>@$SHELL_BIN@g" \
		-e "s@<<_PACKAGE_NAME>>@$PKG@g" \
		-e "s@<<_PRODUCT_NAME>>@$PRODUCT_NAME@g" \
		-e "s@<<_INSTALL_DIR>>@$BASEDIR@g" \
		-e "s@<<_COMPONENTS>>@$COMPONENTS@g" \
		-e "s@<<_JDK_SUPPORT>>@$JDK_SUPPORT@g" \
		-e "s@<<_JDK_DIR>>@$JDK_DIR@g" \
		-e "s@<<_PERL_BINARY>>@$PERL_BINARY@g" \
		-e "s@<<_PERL_>>@$PERL@g" \
		$CONFIGURE_FILE > $CONFIGURE_TMP_FILE 2>$ERR_LOG
	  result=$?
	  if [ $result -eq 0 ]; then
		  $s1_mv -f $CONFIGURE_TMP_FILE $CONFIGURE_FILE
		  $s1_rm -f $ERR_LOG
	  else
		  echo "Internal Error: Unable to sucessfully generate the 'configure' script"
		  echo "in $BASEDIR/setup/. Without this script, you will NOT be able to configure"
		  echo "your installation succesfully. Please correct the errors mentioned in"
		  echo "'Error Log: $ERR_LOG' and try again."
		  exit 1
	  fi
  fi

  # Make sure configure script is executable by root
  if [ ! -x "$CONFIGURE_FILE" ]; then
	  $s1_umask 022;
	  $s1_chmod 744 $CONFIGURE_FILE
  fi

  #------------------------------------------------------------
  # Tell user how to proceed
  #------------------------------------------------------------
  echo " "
  echo "The $PKG package has been successfully added to the system."
  echo " "
  echo "NOTE: If you chose the 'Configure Now' option at the time of "
  echo "      installation, you can now start using ${PRODUCT_NAME} ."
  echo " "
  echo "NOTE: If you chose the 'Configure Later' option at the time of "
  echo "      of installation, now you will need run the below given script"
  echo "      to start configuring your ${PRODUCT_NAME} ."
  echo " "
  echo "      From the command line, please run the below given script: "
  echo "      '$BASEDIR/setup/configure'"
  echo " "
fi

# Update system files to reflect changes made to configure script
installf -f $PKGINST

exit 0
