#!/bin/bash

## To start/stop a parserd server without being root
## Warning: this script do not take every needed precaution to be safe
## It may also be dangerous to run a server as a normal user

######################################################################
## copied/adapted from /etc/rc.d/init.d/functions

TMP=/tmp
TMPDIR=/tmp/
VARDIR=/var

export TMP TMPDIR VARDIR

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

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

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

if [ -f /etc/sysconfig/i18n -a -z "$NOLOCALE" ]; then
  . /etc/sysconfig/i18n
  if [ "$CONSOLETYPE" != "pty" ]; then
      [ "$CONSOLE_NOT_LOCALIZED" = "yes" ] && GP_LANG=C
      [ "$CONSOLE_NOT_LOCALIZED" = "yes" ] && GP_LANGUAGE=C
  fi
  if [ -z "$GP_LANG" ]; then
      [ -n "$LC_CTYPE" ] && GP_LANG=$LC_CTYPE || GP_LANG=$LC_MESSAGES
  fi
  if [ -z "$GP_LANGUAGE" ]; then
      [ -n "$LANGUAGE" ] && GP_LANGUAGE=$LANGUAGE || GP_LANGUAGE=$GP_LANG
  fi
fi

# Read in our configuration
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"

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

        # Test syntax.
        if [ "$#" -eq 0 ] ; then
                gprintf "Usage: status {program}\n"
                return 1
        fi

        # First try "pidof"
        pid=`pidof -o $$ -o $PPID -o %PPID -x $1 || \
             pidof -o $$ -o $PPID -o %PPID -x ${base}`
        if [ -n "$pid" ] ; then
                gprintf "%s (pid %s) is running...\n" ${base} "$pid"
                return 0
        fi

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

gprintf() {
        if [ -x /bin/gettext -a -n "$1" ]; then
           if [ -n "$GP_LANG" ]; then
               local TEXT=`LC_ALL=$GP_LANG LANGUAGE=$GP_LANGUAGE gettext -e --domain=$TEXTDOMAIN -- "$1"`
           else
               local TEXT=`gettext -e --domain=$TEXTDOMAIN -- "$1"`
           fi
        else
           local TEXT=$1
        fi
        [ "${1#*\\n}" ] || TEXT="$TEXT\n"

        shift
        printf -- "$TEXT" "$@"
}

# Frontend to gprintf (support up to 4 %s in format string)
# returns the message transleted in GPRINTF_MSG and
# the resting parms in GPRINTF_REST
# This simplifies a lot the call of functions like action,
# now with i18n support
gprintf_msg_rest() {
case "$1" in
       *%s*%s*%s*%s*)
               GPRINTF_MSG=$(gprintf "$1" "$2" "$3" "$4" "$5")
               shift 5;;
       *%s*%s*%s*)
               GPRINTF_MSG=$(gprintf "$1" "$2" "$3" "$4")
               shift 4;;
       *%s*%s*)
               GPRINTF_MSG=$(gprintf "$1" "$2" "$3")
               shift 3;;
       *%s*)
               GPRINTF_MSG=$(gprintf "$1" "$2")
               shift 2;;
       *)
               GPRINTF_MSG=$(gprintf "$1")
               shift;;
esac
GPRINTF_REST="$@"
}

# Frontend to gprintf (support up to 4 %s in format string)
# returns the message transleted in GPRINTF_MSG and
# the resting parms in GPRINTF_REST
# This simplifies a lot the call of functions like action,
# now with i18n support
gprintf_msg_rest() {
case "$1" in
       *%s*%s*%s*%s*)
               GPRINTF_MSG=$(gprintf "$1" "$2" "$3" "$4" "$5")
               shift 5;;
       *%s*%s*%s*)
               GPRINTF_MSG=$(gprintf "$1" "$2" "$3" "$4")
               shift 4;;
       *%s*%s*)
               GPRINTF_MSG=$(gprintf "$1" "$2" "$3")
               shift 3;;
       *%s*)
               GPRINTF_MSG=$(gprintf "$1" "$2")
               shift 2;;
       *)
               GPRINTF_MSG=$(gprintf "$1")
               shift;;
esac
GPRINTF_REST="$@"
}

echo_success() {
  [ "$BOOTUP" = "color" ] && $MOVE_TO_COL
  echo -n "["
  [ "$BOOTUP" = "color" ] && $SETCOLOR_SUCCESS
  gprintf "  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
  gprintf "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
  gprintf "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
  gprintf "WARNING"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo -n "]"
  echo -ne "\r"
  return 1
}

# Log that something succeeded
success() {
  gprintf_msg_rest "$@"
  echo_success
  return 0
}

# Log that something failed
failure() {
  rc=$?
  gprintf_msg_rest "$@"
  echo_failure
  return $rc
}

# Log that something passed, but may have had errors. Useful for fsck
passed() {
  rc=$?
  gprintf_msg_rest "$@"
  echo_passed
  return $rc
}

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

######################################################################
# inspired from most service scripts

NAME=parserd
BINARY=/usr/sbin/$NAME
PROCESS=$NAME
LOCKFILE=${VARDIR}/lock/subsys/$NAME

test -x $BINARY || exit 0

RETVAL=0

#
# See how we were called.
#

start() {
	# Check if it is already running
	if [ ! -f $LOCKFILE ]; then
	    echo -n "Starting $NAME: "
	    mkdir -p ${VARDIR}
	    mkdir -p ${VARDIR}/log
	    mkdir -p ${VARDIR}/run
	    mkdir -p ${VARDIR}/lock/subsys
	    nice -n 19 $BINARY --config /etc/$NAME.conf
	    RETVAL=$?
	    [ $RETVAL -eq 0 ] && touch $LOCKFILE
	    [ $RETVAL = 0 ] && success "%s startup" $PROCESS || failure "%s startup" $PROCESS
	    echo
	fi
	return $RETVAL
}

stop() {
	echo -n "Stopping $NAME: "
	killproc $PROCESS
	RETVAL=$?
	[ $RETVAL -eq 0 ] && rm -f $LOCKFILE
	[ $RETVAL -eq 0 ] && success "%s shutdown" $PROCESS || failure "%s shutdown" $PROCESS
	echo
        return $RETVAL
}


reload() {
	echo -n "Reloading $NAME: "
	killproc $PROCESS
	RETVAL=$?
	echo
}	

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

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

killproc() {
    RC=0
    base=$1
    
        # Find pid.
    pid=
    if [ -f ${VARDIR}/run/${base}.pid ]; then
	local line p
	read line < ${VARDIR}/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
    
    if [ -n "${pid:-}" ] ; then
           # Kill it.
	if checkpid $pid 2>&1; then
	    kill -9 $pid
	    RC=$?
	fi
    else
	RC=1
    fi

    rm -f ${VARDIR}/run/${base}.pid

    return $RC
}

case "$1" in
start)
	start
	;;
stop)
	stop
	;;
reload)
	reload
	;;
restart)
	stop
	start
	;;
condrestart)
	if [ -f $LOCKFILE ]; then
	    start
	    stop
	fi
	;;
status)
	status $PROCESS
	;;
*)
	echo "Usage: $0 {start|stop|restart|condrestart|status}"
	exit 1
esac

exit $RETVAL

