AnonymousFox

//etc/init.d/cpfunctions

# -*-Shell-script-*-
#
# cpfunctions	This file contains functions to be used by most or all
#		shell scripts in the /etc/init.d directory.
#

TEXTDOMAIN=initscripts

# Make sure umask is sane
umask 022

# Set up a default search path.
PATH="/sbin:/usr/sbin:/bin:/usr/bin:/usr/X11R6/bin"
export PATH

# Get a sane screen width
[ -z "${COLUMNS:-}" ] && COLUMNS=80

[ -z "${CONSOLETYPE:-}" ] && CONSOLETYPE="`/sbin/consoletype`"

if [ -f /etc/sysconfig/i18n -a -z "${NOLOCALE:-}" ] ; then
  . /etc/sysconfig/i18n
  if [ "$CONSOLETYPE" != "pty" ]; then
	case "${LANG:-}" in
		ja_JP*|ko_KR*|zh_CN*|zh_TW*|bn_*|bd_*|pa_*|hi_*|ta_*|gu_*)
			export LC_MESSAGES=en_US
			export LANG
			;;
		*)
			export LANG
			;;
	esac
  else
  	[ -n "$LC_MESSAGES" ] && export LC_MESSAGES
	export LANG
  fi
fi

# Read in our configuration
if [ -z "${BOOTUP:-}" ]; then
  if [ -f /etc/sysconfig/init ]; then
      . /etc/sysconfig/init
  else
    # This all seem confusing? Look in /etc/sysconfig/init,
    # or in /usr/doc/initscripts-*/sysconfig.txt
    BOOTUP=color
    RES_COL=60
    MOVE_TO_COL="echo -en \\033[${RES_COL}G"
    SETCOLOR_SUCCESS="echo -en \\033[1;32m"
    SETCOLOR_FAILURE="echo -en \\033[1;31m"
    SETCOLOR_WARNING="echo -en \\033[1;33m"
    SETCOLOR_NORMAL="echo -en \\033[0;39m"
    LOGLEVEL=1
  fi
  if [ "$CONSOLETYPE" = "serial" ]; then
      BOOTUP=serial
      MOVE_TO_COL=
      SETCOLOR_SUCCESS=
      SETCOLOR_FAILURE=
      SETCOLOR_WARNING=
      SETCOLOR_NORMAL=
  fi
fi

if [ "${BOOTUP:-}" != "verbose" ]; then
   INITLOG_ARGS="-q"
   LOGGER_ARGS=
else
   INITLOG_ARGS=
   LOGGER_ARGS="-s"
fi

LOGGER=$(which logger 2>/dev/null)

# Check if $pid (could be plural) are running
checkpid() {
	local i

for i in $* ; do
		[ -d "/proc/$i" ] && return 0
	done
	return 1
}

# A function to start a program.
daemon() {
	# Test syntax.
	local gotbase= force=
	local base= user= nice= bg= pid=
	nicelevel=0
	while [ "$1" != "${1##[-+]}" ]; do
	  case $1 in
	    '')    echo $"$0: Usage: daemon [+/-nicelevel] {program}"
	           return 1;;
	    --check)
		   base=$2
		   gotbase="yes"
		   shift 2
		   ;;
	    --check=?*)
	    	   base=${1#--check=}
		   gotbase="yes"
		   shift
		   ;;
	    --user)
		   user=$2
		   shift 2
		   ;;
	    --user=?*)
	           user=${1#--user=}
		   shift
		   ;;
	    --force)
	    	   force="force"
		   shift
		   ;;
	    [-+][0-9]*)
	    	   nice="nice -n $1"
	           shift
		   ;;
	    *)     echo $"$0: Usage: daemon [+/-nicelevel] {program}"
	           return 1;;
	  esac
	done

# Save basename.
        [ -z "$gotbase" ] && base=${1##*/}

# See if it's already running. Look *only* at the pid file.
	if [ -f /var/run/${base}.pid ]; then
		local line p
		read line < /var/run/${base}.pid
		for p in $line ; do
			[ -z "${p//[0-9]/}" -a -d "/proc/$p" ] && pid="$pid $p"
		done
	fi

[ -n "${pid:-}" -a -z "${force:-}" ] && return

# make sure it doesn't core dump anywhere unless requested
	ulimit -S -c ${DAEMON_COREFILE_LIMIT:-0} >/dev/null 2>&1

# if they set NICELEVEL in /etc/sysconfig/foo, honor it
	[ -n "$NICELEVEL" ] && nice="nice -n $NICELEVEL"

# Echo daemon
        [ "${BOOTUP:-}" = "verbose" -a -z "$LSB" ] && echo -n " $base"

# And start it up.
	if [ -z "$user" ]; then
        if [ -z $LOGGER ]; then
            $nice initlog $INITLOG_ARGS -c "$*"
        else
            $nice $* 2>&1 | grep -v '[^:]+: $|[=]+\|Setting filetype$' | grep -v '^[-\\\|\/]' | $LOGGER $LOGGER_ARGS -p local7.notice -t $1
        fi
	else
        if [ -z $LOGGER ]; then
            $nice initlog $INITLOG_ARGS -c "runuser -s /bin/bash - $user -c \"$*\""
        else
            $nice runuser -s /bin/bash - $user -c "$*" 2>&1 | grep -v '[^:]+: $|[=]+\|Setting filetype$' | grep -v '^[-\\\|\/]' | $LOGGER $LOGGER_ARGS -p local7.notice -t $1
        fi
	fi
	[ "$?" -eq 0 ] && success $"$base startup" || failure $"$base startup"
}

# A function to stop a program.
killproc() {
	RC=0
	# Test syntax.
	if [ "$#" -eq 0 ]; then
		echo $"Usage: killproc {program} [signal]"
		return 1
	fi

notset=0
	# check for second arg to be kill level
	if [ -n "$2" ]; then
		killlevel=$2
	else
		notset=1
		killlevel="-9"
	fi

# Save basename.
        base=${1##*/}

# Find pid.
	pid=
	if [ -f /var/run/${base}.pid ]; then
		local line p
		read line < /var/run/${base}.pid
		for p in $line ; do
			[ -z "${p//[0-9]/}" -a -d "/proc/$p" ] && pid="$pid $p"
		done
	fi
	if [ -z "$pid" ]; then
		pid=`pidof -o $$ -o $PPID -o %PPID -x $1 || \
			pidof -o $$ -o $PPID -o %PPID -x $base`
	fi

# Kill it.
        if [ -n "${pid:-}" ] ; then
                [ "$BOOTUP" = "verbose" -a -z "$LSB" ] && echo -n "$base "
		if [ "$notset" -eq "1" ] ; then
		       if checkpid $pid 2>&1; then
			   # TERM first, then KILL if not dead
			   kill -TERM $pid >/dev/null 2>&1
			   usleep 100000
			   if checkpid $pid && sleep 1 &&
			      checkpid $pid && sleep 3 &&
			      checkpid $pid ; then
                                kill -KILL $pid >/dev/null 2>&1
				usleep 100000
			   fi
		        fi
			checkpid $pid
			RC=$?
			[ "$RC" -eq 0 ] && failure $"$base shutdown" || success $"$base shutdown"
			RC=$((! $RC))
		# use specified level only
		else
		        if checkpid $pid; then
	                	kill $killlevel $pid >/dev/null 2>&1
				RC=$?
				[ "$RC" -eq 0 ] && success $"$base $killlevel" || failure $"$base $killlevel"
			fi
		fi
	else
	    failure $"$base shutdown"
	    RC=1
	fi

# Remove pid file if any.
	if [ "$notset" = "1" ]; then
            rm -f /var/run/$base.pid
	fi
	return $RC
}

# A function to find the pid of a program. Looks *only* at the pidfile
pidfileofproc() {
	local base=${1##*/}

# Test syntax.
	if [ "$#" = 0 ] ; then
		echo $"Usage: pidfileofproc {program}"
		return 1
	fi

# First try "/var/run/*.pid" files
	if [ -f /var/run/$base.pid ] ; then
	        local line p pid=
		read line < /var/run/$base.pid
		for p in $line ; do
		       [ -z "${p//[0-9]/}" -a -d /proc/$p ] && pid="$pid $p"
		done
	        if [ -n "$pid" ]; then
	                echo $pid
	                return 0
	        fi
	fi
}

# A function to find the pid of a program.
pidofproc() {
	base=${1##*/}

# Test syntax.
	if [ "$#" = 0 ]; then
		echo $"Usage: pidofproc {program}"
		return 1
	fi

# First try "/var/run/*.pid" files
	if [ -f /var/run/$base.pid ]; then
	        local line p pid=
		read line < /var/run/$base.pid
		for p in $line ; do
		       [ -z "${p//[0-9]/}" -a -d /proc/$p ] && pid="$pid $p"
		done
	        if [ -n "$pid" ]; then
	                echo $pid
	                return 0
	        fi
	fi
	pidof -o $$ -o $PPID -o %PPID -x $1 || \
		pidof -o $$ -o $PPID -o %PPID -x $base
}

# Calls a script to determine if a service is running
# and if pid file is accurate
# Takes:
#    user
#    process
#    pid file
#    regex to distinguish process
# Returns:
#    0 - Process is running
#    1 - Invalid call
#    2 - Process not running
#    3 - Process running; pid file does not match
#    4 - Process running; no pid file
verify_pidfile() {
    local rc=
    /scripts/verify_pidfile $1 $2 $3 $4 >/dev/null 2>&1
    rc=$?

return $rc
}
already_running() {
    local rc=
    verify_pidfile $@; rc=$?
    if [ $rc = 0 -o $rc = 3 -o $rc = 4 ]; then
        return 1
    fi
    return 0
}

status() {
	local base=${1##*/}
	local pid

# Test syntax.
	if [ "$#" = 0 ] ; then
		echo $"Usage: status {program}"
		return 1
	fi

# First try "pidof"
	pid=`pidof -o $$ -o $PPID -o %PPID -x $1 || \
	     pidof -o $$ -o $PPID -o %PPID -x ${base}`
	pid=`echo $pid | sed 's/\n//'`

if [ -n "$pid" ]; then
	        echo $"${base} (pid $pid) is running..."
	        return 0
	fi

# Next try "/var/run/*.pid" files
	if [ -f /var/run/${base}.pid ] ; then
	        read pid < /var/run/${base}.pid
	        if [ -n "$pid" ]; then
	                echo $"${base} dead but pid file exists"
	                return 1
	        fi
	fi
	# See if /var/lock/subsys/${base} exists
	if [ -f /var/lock/subsys/${base} ]; then
		echo $"${base} dead but subsys locked"
		return 2
	fi
	echo $"${base} is stopped"
	return 3
}

echo_success() {
  [ "$BOOTUP" = "color" ] && $MOVE_TO_COL
  echo -n "[  "
  [ "$BOOTUP" = "color" ] && $SETCOLOR_SUCCESS
  echo -n $"OK"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo -n "  ]"
  echo -ne "\r"
  return 0
}

echo_failure() {
  [ "$BOOTUP" = "color" ] && $MOVE_TO_COL
  echo -n "["
  [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
  echo -n $"FAILED"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo -n "]"
  echo -ne "\r"
  return 1
}

echo_passed() {
  [ "$BOOTUP" = "color" ] && $MOVE_TO_COL
  echo -n "["
  [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
  echo -n $"PASSED"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo -n "]"
  echo -ne "\r"
  return 1
}

echo_warning() {
  [ "$BOOTUP" = "color" ] && $MOVE_TO_COL
  echo -n "["
  [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
  echo -n $"WARNING"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo -n "]"
  echo -ne "\r"
  return 1
}

# Inform the graphical boot of our current state
update_boot_stage() {
  if [ "$GRAPHICAL" = "yes" -a -x /usr/bin/rhgb-client ]; then
    /usr/bin/rhgb-client --update="$1"
  fi
  return 0
}

# Log that something succeeded
success() {
  if [ -z "${IN_INITLOG:-}" ]; then
     if [ -z $LOGGER ]; then
        initlog $INITLOG_ARGS -n $0 -s "$1" -e 1
     else
        $LOGGER $LOGGER_ARGS -t $0 -- "$1 succeeded"
     fi
  else
     # silly hack to avoid EPIPE killing rc.sysinit
     trap "" SIGPIPE
     if [ -z $LOGGER ]; then
        echo "$INITLOG_ARGS -n $0 -s \"$1\" -e 1" >&21
     else
        echo "$LOGGER $LOGGER_ARGS -t $0 -- \"$1 succeeded\"" >&21
     fi
     trap - SIGPIPE
  fi
  [ "$BOOTUP" != "verbose" -a -z "$LSB" ] && echo_success
  return 0
}

# Log that something failed
failure() {
  rc=$?
  if [ -z "${IN_INITLOG:-}" ]; then
     if [ -z $LOGGER ]; then
        initlog $INITLOG_ARGS -n $0 -s "$1" -e 2
     else
        $LOGGER $LOGGER_ARGS -t $0 -- "$1 failed"
     fi
  else
     trap "" SIGPIPE
     if [ -z $LOGGER ]; then
        echo "$INITLOG_ARGS -n $0 -s \"$1\" -e 2" >&21
     else
        echo "$LOGGER $LOGGER_ARGS -t $0 -- \"$1 failed\"" >&21
     fi
     trap - SIGPIPE
  fi
  [ "$BOOTUP" != "verbose" -a -z "$LSB" ] && echo_failure
  [ -x /usr/bin/rhgb-client ] && /usr/bin/rhgb-client --details=yes
  return $rc
}

# Log that something passed, but may have had errors. Useful for fsck
passed() {
  rc=$?
  if [ -z "${IN_INITLOG:-}" ]; then
     if [ -z $LOGGER ]; then
        initlog $INITLOG_ARGS -n $0 -s "$1" -e 1
     else
        $LOGGER $LOGGER_ARGS -t $0 -- "$1 succeeded"
     fi
  else
     trap "" SIGPIPE
     if [ -z $LOGGER ]; then
        echo "$INITLOG_ARGS -n $0 -s \"$1\" -e 1" >&21
     else
        echo "$LOGGER $LOGGER_ARGS -t $0 -- \"$1 succeeded\"" >&21
     fi
     trap - SIGPIPE
  fi
  [ "$BOOTUP" != "verbose" -a -z "$LSB" ] && echo_passed
  return $rc
}

# Log a warning
warning() {
  rc=$?
  if [ -z "${IN_INITLOG:-}" ]; then
     if [ -z $LOGGER ]; then
        initlog $INITLOG_ARGS -n $0 -s "$1" -e 1
     else
        $LOGGER $LOGGER_ARGS -t $0 -- "$1 succeeded"
     fi
  else
     trap "" SIGPIPE
     if [ -z $LOGGER ]; then
        echo "$INITLOG_ARGS -n $0 -s \"$1\" -e 1" >&21
     else
        echo "$LOGGER $LOGGER_ARGS -t $0 -- \"$1 succeeded\"" >&21
     fi
     trap - SIGPIPE
  fi
  [ "$BOOTUP" != "verbose" -a -z "$LSB" ] && echo_warning
  return $rc
}

# Run some action. Log its output.
action() {
  STRING=$1
  echo -n "$STRING "
  if [ "${RHGB_STARTED}" != "" -a -w /etc/rhgb/temp/rhgb-console ]; then
      echo -n "$STRING " > /etc/rhgb/temp/rhgb-console
  fi
  shift
  if [ -z $LOGGER ]; then
    initlog $INITLOG_ARGS -c "$*" && success $"$STRING" || failure $"$STRING"
  else
    $* 2>&1 | grep -v '[^:]+: $|[=]+\|Setting filetype$' | grep -v '^[-\\\|\/]' | $LOGGER $LOGGER_ARGS -p local7.notice -t $1 && success $"$STRING" || failure $"$STRING"
  fi
  rc=$?
  echo
  if [ "${RHGB_STARTED}" != "" -a -w /etc/rhgb/temp/rhgb-console ]; then
      if [ "$rc" = "0" ]; then
      	echo_success > /etc/rhgb/temp/rhgb-console
      else
        echo_failure > /etc/rhgb/temp/rhgb-console
	[ -x /usr/bin/rhgb-client ] && /usr/bin/rhgb-client --details=yes
      fi
      echo
  fi
  return $rc
}

# returns OK if $1 contains $2
strstr() {
  [ "${1#*$2*}" = "$1" ] && return 1
  return 0
}

# Confirm whether we really want to run this service
confirm() {
  [ -x /usr/bin/rhgb-client ] && /usr/bin/rhgb-client --details=yes
  while : ; do
      echo -n $"Start service $1 (Y)es/(N)o/(C)ontinue? [Y] "
      read answer
      if strstr $"yY" "$answer" || [ "$answer" = "" ] ; then
         return 0
      elif strstr $"cC" "$answer" ; then
	 rm -f /var/run/confirm
	 [ -x /usr/bin/rhgb-client ] && /usr/bin/rhgb-client --details=no
         return 2
      elif strstr $"nN" "$answer" ; then
         return 1
      fi
  done
}