#!/bin/ksh

#

# Script for starting a postponed post-installation command in

# a Live-Upgrade-safe environment

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License, Version 1.0 only

# (the "License").  You may not use this file except in compliance

# with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright 2004-2005 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

export PATH=/usr/bin

LC_ALL=C

export LC_ALL

MYDIR=$(cd $(dirname $0); pwd)

SPOOLDIR="$MYDIR/../../spool/postrun"

LOCKFILE="/var/run/postrun.lock"

LOGFILE="$MYDIR/../../log/postrun.log"

SEQFILE="$SPOOLDIR/.seq"

id | grep " euid=" && \

    myuid=`id | sed -e 's/.* euid=\([0-9][0-9]*\).*$/\1/'` || \

    myuid=`id | sed -e 's/uid=\([0-9][0-9]*\).*/\1/'`

if [ "$myuid" != 0 ]; then

    echo "postrun: error: run this script as root"

    exit 1

fi

umask 0133

usage() {

    echo 'Usage: postrun [options]'

    echo

    echo 'Options:'

    echo '    -u, --uniq'

    echo '        If the same command is requested multiple times, the command'

    echo '        is only run once.  If it is safe to execute the command'

    echo '        immediately, it will be delayed by 5 minutes, or as set'

    echo '        using the --timeout option'

    echo

    echo '    -t <n>, --timeout <n>'

    echo '        Delay the execution of uniq commands by <n> minutes.'

    echo

    echo '    -b, --bg'

    echo '        Run the command in the background and return control'

    echo '        immediately'

    echo

    echo '    -f <file>'

    echo '        Read the commands from <file> instead of the standard'

    echo '        input.'

    echo

    echo '    -c <class>'

    echo '        Assign this job to class <class>.  Useful for querying'

    echo '        jobs with postrun-query'

    echo

    echo '    -i'

    echo '        Ignore this job if it cannot be executed immediately.'

    echo

    echo '    -h, -?, --help'

    echo '        Display this help'

    exit 1

}

# Solaris 9 doesn't have mktemp, need a substitute in order to be

# Live Upgrade compliant

# Note: only creating tmp files is implemented, directories are not

postrun_mktemp () {

    test -x /usr/bin/mktemp && {

	/usr/bin/mktemp $1

	return

    }

    tempname="$1.$$.`date +%H%M%S`"

    while [ -f $tempname ]; do

	tempname="$tempname.`date +%S`"

    done

    touch $tempname && chmod 700 $tempname || exit 1

    echo $tempname

}

#LOCK_UNLOCK_FUNCTIONS_START

postrun_debug() {

    if [ "x$POSTRUN_DEBUG" = xyes ]; then

	for msg in "${@}"; do

	    echo '<POSTRUN_DEBUG>' "[$$]" "$msg" 1>&2

	done    

    fi

}

is_number() {

    echo "$1" | egrep -vs '^[0-9]+$' && return 1

    echo "$1" | egrep -s '^[0-9]+$' || return 1

    return 0

}

# lock the postrun spool or log file

# if $1 is 'log' then lock the log file, otherwise log the spool

postrun_lock() {

    typeset this_lock=$LOCKFILE

    if [ "x$1" = xlog ]; then

	this_lock=${LOCKFILE}.log

    fi

    postrun_debug "Taking lock on $this_lock"

    while true ; do

	# Try to take the lock

    	ln -s $$ $this_lock 2>/dev/null

    	if [ $? = 0 ] ; then

	    postrun_debug "Lock on $this_lock taken"

	    return

    	fi

	# Read who has the lock.  If this process has the lock return

	typeset pid=$(ls -ld $this_lock \

		| nawk -F' -> ' '$1 ~ /^l/ && NF == 2 { print $NF }')

	if [ "$pid" = $$ ] ; then

	    postrun_debug "Lock on $this_lock already held by this pid ($$)"

	    return

	fi

	# check to be sure the process that holds the lock is still running

	# if so, wait for it to be freed.  If the lock is stale, remove it

	# so that the next iteration of the loop can take the lock.

	if is_number "$pid" && kill -0 "$pid" 2>/dev/null ; then

	    postrun_debug "Waiting for $pid to release $this_lock"

	    sleep 1

	else

	    postrun_debug "Stale lock $this_lock from $pid being released"

	    rm -f $this_lock

	fi

    done

    postrun_debug "postrun_lock escaped the loop - should not b here"

}

# release the lock

# unlock the log file if $1 == 'log', unlock the spool otherwise

postrun_unlock() {

    typeset this_lock=$LOCKFILE

    if [ "x$1" = xlog ]; then

	this_lock=${LOCKFILE}.log

    fi

    postrun_debug "Releasing lock on $this_lock"

    typeset pid=$(ls -ld $this_lock \

    	| nawk -F' -> ' '$1 ~ /^l/ && NF == 2 { print $NF }')

    if ! rm -f $this_lock; then

	echo "postrun: error: cannot remove lock file $this_lock" 1>&2

	exit 1

    fi

    postrun_debug "Released lock on $this_lock taken by pid $pid"

}

#LOCK_UNLOCK_FUNCTIONS_END

# get the next job id

postrun_get_seq() {

    postrun_lock

    seq=`cat $SEQFILE 2>/dev/null`

    next_seq=$(($seq + 1))

    echo $next_seq > $SEQFILE

    postrun_unlock

    echo $next_seq

}

postrun_spool_command() {

    if [ $postrun_no_spool = yes ]; then

	postrun_debug "Ignoring job, because -i was used and it's not possible to run it now"

	return 1

    fi

    cd $SPOOLDIR

    # check if there's already a spooled job for the same command

    new_job=0

    uniq_job_nr=

    job_seq=`postrun_get_seq`

    IFS=' '

    postrun_lock

    for f in *.cmd; do

	test -f "$f" || continue

	cmp -s $postrun_command_file $f && {

	    if [ $postrun_is_uniq = yes ]; then

		uniq_job_nr=`basename $f .cmd`

		break

	    fi

	    egrep -s '^uniq_command: yes' `basename $f .cmd`.ctrl && {

		uniq_job_nr=`basename $f .cmd`

		break

	    }

	}

    done

    if [ "x$uniq_job_nr" != x ]; then

	postrun_debug "matching spooled uniq job (#${uniq_job_nr}) found"

	# we found a matching spooled uniq job

	# we need to update the uniq time and make sure it's

	# flagged as a uniq job

	new_job=1

	#

	# FIXME: shouldn't use sed for this, safer to simply append

	#        and process the duplicate entries when reading the file

	#

	sed -e 's/^uniq_command: .*/uniq_command: yes/' \

	    -e 's/^\(pkginst: .*\)/\1, '$PKGINST'/' \

	    -e 's/^uniq_time: /resubmit_time: /' \

	    -e 's/^uniq_timeout: .*/uniq_timeout: '"$postrun_uniq_timeout"'/' \

	    $uniq_job_nr.ctrl > $uniq_job_nr.ctrl.new

	echo 'uniq_time: '`date +%Y.%m.%d.%H.%M.%S` >> $uniq_job_nr.ctrl.new

        grep "^class: $postrun_job_class$" $uniq_job_nr.ctrl.new \

	    >/dev/null || \

	    echo "class: $postrun_job_class" >> $uniq_job_nr.ctrl.new

	#

	# FIXME: add the user name to the control file

	#

	# Use a new job id so that the job moves to the end of the queue.

	# Need to do this such a whay that if this process is interrupted at

        # any stage, the job is not lost and is not in the queue twice:

	# Step 1: copy the job to the new id:

	cp $uniq_job_nr.cmd $job_seq.cmd

	# Step 2: move the original job ctrl file to the new id:

	mv $uniq_job_nr.ctrl $job_seq.ctrl

	# Step 3: replace the original job ctrl file with the updated one:

	mv $uniq_job_nr.ctrl.new $job_seq.ctrl

	# Step 4: delete the original cmd file

	rm -f $uniq_job_nr.cmd

    else

	postrun_debug "spooling command as job #${job_seq}"

	user_name=${EMAIL:-root}

	ctrl_file="$SPOOLDIR/$job_seq.ctrl"

	cmd_file="$SPOOLDIR/$job_seq.cmd"

	cat $postrun_command_file > $cmd_file

	cat /dev/null > $ctrl_file

	echo "pkginst: $PKGINST"                        >> $ctrl_file

	echo "submit_time: `date +%Y.%m.%d.%H.%M.%S`"   >> $ctrl_file

	echo "uniq_command: $postrun_is_uniq"           >> $ctrl_file

	echo "uniq_time: `date +%Y.%m.%d.%H.%M.%S`"     >> $ctrl_file

	echo "uniq_timeout: $postrun_uniq_timeout"      >> $ctrl_file

	echo "background: $postrun_bg_job"              >> $ctrl_file

	echo "user: $user_name"                         >> $ctrl_file

	echo "class: $postrun_job_class"                >> $ctrl_file

    fi

    postrun_unlock

    return $new_job

}

postrun_run_command() {

    cmdout=`mktemp /tmp/postrun.out.XXXX`

    # create a background jobs script that executes the commands

    # then locks the spool/log file and appends the output to the

    # log file and finally unlocks

    cmdfile=`mktemp /tmp/postrun.job.XXXX`

    cat /dev/null > $cmdfile

    cat /dev/null > $cmdout

    echo '#!/bin/ksh'                                      >> $cmdfile

    # copy the postrun_lock and postrun_unlock commands from

    # this script to the background job script

    echo "LOCKFILE=$LOCKFILE"                              >> $cmdfile

    sed -e '1,/#LOCK_UNLOCK_FUNCTIONS_START/d' \

	-e '/#LOCK_UNLOCK_FUNCTIONS_END/,$d' $0            >> $cmdfile

    # save the stdout file description

    echo 'exec 3<&1'                                       >> $cmdfile

    echo "exec >> $cmdout 2>&1"                            >> $cmdfile

    echo 'PATH=/usr/bin; export PATH'                      >> $cmdfile

    echo 'echo Starting postrun job at `LC_ALL=C date`'    >> $cmdfile

    if [ "x$postrun_submit_time" != x ]; then

	if [ $postrun_bg_job = yes ]; then

	    echo "echo 'This is a spooled background job (#${postrun_job_number})'"    >> $cmdfile

	else

	    echo "echo 'This is a spooled foreground job (#${postrun_job_number})'"    >> $cmdfile

	fi

	echo "echo Job submitted by $postrun_pkginst at $postrun_submit_time" \

	    >> $cmdfile

    else

	if [ $postrun_bg_job = yes ]; then

	    echo 'echo This is an immediate background job' >> $cmdfile

	else

	    echo 'echo This is an immediate foreground job' >> $cmdfile

	fi

	echo "echo Job submitted by $postrun_pkginst"\

	    >> $cmdfile

    fi

    echo 'echo Running commands:'                          >> $cmdfile

    echo "echo '>>>' commands follow:"                     >> $cmdfile

    cat $postrun_command_file | \

	sed -e "s/'/'\"'\"'/g" | \

	sed -e "s/^/echo '/" \

	    -e "s/\$/'/" >> $cmdfile

    echo "echo '<<<' commands end"                         >> $cmdfile

    echo "echo '>>>' Command output follows:"              >> $cmdfile

    echo "chmod 700 $postrun_command_file"                  >> $cmdfile

    echo "$postrun_command_file"                           >> $cmdfile

    #

    # FIXME: send email to $postrun_user if the command failed

    #

    echo "echo '<<<' Command completed with exit status \$?" \

	>> $cmdfile

    echo 'echo Job finished at `LC_ALL=C date`'            >> $cmdfile

    echo 'echo --'                                         >> $cmdfile

    # restore PATH in case the command changed it

    echo 'PATH=/usr/bin; export PATH'                      >> $cmdfile

    # restore stdout

    echo 'exec 1<&3'                                       >> $cmdfile

    # close file descriptor 3

    echo 'exec 3<&-'                                       >> $cmdfile

    echo 'exec 2>&1'                                       >> $cmdfile

    # append the messages to the real log file

    # need to lock the log file to avoid 2 postrun commands

    # writing at the same time and messing up the log

    echo 'postrun_lock log'                                >> $cmdfile

    echo "cat $cmdout >> $LOGFILE"                         >> $cmdfile

    echo 'postrun_unlock log'                              >> $cmdfile

    echo "rm -f $cmdout"                                   >> $cmdfile

    echo "rm -f $cmdfile"                                  >> $cmdfile

    echo "rm -f $postrun_command_file"                     >> $cmdfile

    chmod 700 $cmdfile

    if [ $postrun_bg_job = yes ]; then

	$cmdfile &

    else

	$cmdfile

    fi

    exitval=$?

}

username=${EMAIL:-root}

postrun_defaults() {

    # default settings

    postrun_pkginst="$PKGINST"

    postrun_submit_time=''

    postrun_uniq_time=''

    postrun_is_uniq=no

    postrun_uniq_timeout=5

    postrun_bg_job=no

    postrun_command_file=''

    postrun_user=${username}

    postrun_job_number='???'

    postrun_alt_root_okay=no

    postrun_job_class=other

    postrun_no_spool=no

}

# usage: is_leap_year yyyy

is_leap_year() {

    cal 02 $1 | egrep -s 29 && return 0

    return 1

}

# get_abstime yy mm dd hh mm ss

#

# prints the elapsed time in seconds since 1970.01.01.00.00.00

#Length of the months:

#              JA FE MA AP MY JN JL AU SE OC NO DE

set -A MONTH 0 31 28 31 30 31 30 31 31 30 31 30 31

get_abstime() {

    # the absolute time since 1970...

    t=0

    # number of years

    t=$(($t + ($1 - 1970) * 31536000))

    # add 1 day for each leap year

    y=1972

    end_y=$1

    if [ $2 -lt 2 ]; then

	end_y=$(($1 - 1))

    fi

    while [ $y -le $end_y ]; do

	is_leap_year $y && t=$(($t + 86400))

	y=$(($y + 4))

    done

    # number of months

    m=1

    while [ $m -lt $2 ]; do

	t=$(($t + ${MONTH[$m]} * 86400))

	m=$(($m + 1))

    done

    # number of days, hours, minutes and seconds:

    echo $(($t + ($3 - 1) * 86400 + $4 * 3600 + $5 * 60 + $6))

}

# get_timediff: prints the difference in seconds between 2 time strings

#               the time strings should be of the following format:

#               YYYY.MM.DD.HH.MM.SS as printed by date +%Y.%m.%d.%H.%M.%S

#

#               Works for dates after 1970.01.01.00.00.00

#

get_timediff() {

    year1=$(expr "$1" : "^\([^.]*\)\..*")

    month1=$(expr "$1" : "^[^.]*\.\([^.]*\)\..*")

    day1=$(expr "$1" : "^[^.]*\.[^.]*\.\([^.]*\)\..*")

    hour1=$(expr "$1" : "^[^.]*\.[^.]*\.[^.]*\.\([^.]*\)\..*")

    min1=$(expr "$1" : "^[^.]*\.[^.]*\.[^.]*\.[^.]*\.\([^.]*\)\..*")

    sec1=$(expr "$1" : "^[^.]*\.[^.]*\.[^.]*\.[^.]*\.[^.]*\.\([^.]*\)")

    year2=$(expr "$2" : "^\([^.]*\)\..*")

    month2=$(expr "$2" : "^[^.]*\.\([^.]*\)\..*")

    day2=$(expr "$2" : "^[^.]*\.[^.]*\.\([^.]*\)\..*")

    hour2=$(expr "$2" : "^[^.]*\.[^.]*\.[^.]*\.\([^.]*\)\..*")

    min2=$(expr "$2" : "^[^.]*\.[^.]*\.[^.]*\.[^.]*\.\([^.]*\)\..*")

    sec2=$(expr "$2" : "^[^.]*\.[^.]*\.[^.]*\.[^.]*\.[^.]*\.\([^.]*\)")

    # calculate seconds since 1970.01.01.00.00.00

    t1=`get_abstime $year1 $month1 $day1 $hour1 $min1 $sec1`

    t2=`get_abstime $year2 $month2 $day2 $hour2 $min2 $sec2`

    # print difference

    expr $t1 - $t2

}

postrun_runq() {

    cd $SPOOLDIR

    IFS=' 

'

    timeleft=0

    postrun_lock

    all_jobs=`/bin/ls -1 *.ctrl | /bin/sort -n`

    for job in $all_jobs; do

	test -f "$job" || continue

	postrun_defaults

	while read var val; do

	    case "$var" in

		pkginst: )

                    postrun_pkginst="$val"

		    ;;

		submit_time: )

		    postrun_submit_time="$val"

		    ;;

		resubmit_time: )

		    ;;

	        uniq_command: )

		    postrun_is_uniq="$val"

		    ;;

		uniq_time: )

		    postrun_uniq_time="$val"

		    ;;

		uniq_timeout: )

		    postrun_uniq_timeout="$val"

		    ;;

		background: )

		    postrun_bg_job="$val"

		    ;;

		user: )

		    postrun_user="$val"

		    ;;

		class: )

		    postrun_job_class="$val"

		    ;;

		* )

		    echo "postrun: WARNING: invalid setting in $job: $var"

		    ;;

	    esac

	done < $job