#!/bin/bash
    #
    # sks-recon       This shell script takes care of starting and stopping
    #                 the SKS reconciliation server.
    #
    # chkconfig: - 89 11
    # description:    SKS is the OpenPGP Synchronizing Key Server.
    # processname:    sks-recon
    # config:         /srv/sks/sksconf
    # pidfile:        /var/run/sks-recon.pid
     
    # Source function library.
    . /etc/rc.d/init.d/functions
     
    # Source networking configuration.
    . /etc/sysconfig/network
     
    # Check that networking is up.
    [ ${NETWORKING} = "no" ] && exit 1
     
    # Defines
    DESC="the SKS Reconciliation Server"
    PROG="sks-recon"
    EXEC="/usr/sbin/${PROG}"
    LOCK="/var/lock/subsys/${PROG}"
    PIDF="/var/run/${PROG}.pid"
    CONF="/srv/sks/sksconf"
     
    # Include config
    if [ -s /etc/sysconfig/sks ]; then
      . /etc/sysconfig/sks
    fi
     
    # Further defines
    RUN_AS="${RUN_AS:-sks}"
    SKS_SHUT="${SKS_SHUT:-60}"
    SKS_CMD="`echo ${PROG} | cut -d'-' -f2`"

    # Check for binaries and configs
    [ -x ${EXEC} ] || exit 5
    [ -f ${CONF} ] || exit 6
     
     
    start() {
            # Start daemons.
            cd /srv/sks/
            echo -n $"Starting ${DESC}: "
    #       daemon --user=${RUN_AS} ${EXEC} ${SKS_CMD} -debuglevel 4 -hostname key-server.nausch.org -basedir /var/lib/sks -stat_hour 1 2\>/dev/null \&
            daemon --user=${RUN_AS} ${EXEC} ${SKS_CMD} 2\>/dev/null \&
    #       daemon --user=${RUN_AS} ${EXEC} ${SKS_CMD} ${OPTIONS} 2\>/dev/null \&
            RETVAL=${?}
     
            [ ${RETVAL} -eq 0 ] && {
              touch ${LOCK}
              sleep 3
     
              PID=`pidof -o %PPID ${PROG}`
              RETVAL=${?}
     
              [ ${RETVAL} -eq 0 ] && echo ${PID} >${PIDF}
            }
            echo
            return ${RETVAL}
    }
     
    stop() {
            # Stop daemons.
            echo -n $"Shutting down ${DESC}: "
            PID=`pidof -o %PPID ${PROG}`
            RETVAL=${?}
     
            [ ${RETVAL} -eq 0 ] && {
              kill -TERM ${PID}
     
              TIMEOUT=0
              while pidof -o %PPID ${PROG} >/dev/null; do
                if [ ${TIMEOUT} -ge ${SKS_SHUT} ]; then
                  RETVAL=1
                  break
                else
                  sleep 5 && echo -n "."
                  TIMEOUT=$((TIMEOUT+5))
                fi
              done
     
              [ ${RETVAL} -eq 0 ] && rm -f ${LOCK} ${PIDF}
            }
     
            [ ${RETVAL} -eq 0 ] && success $"${PROG} shutdown" || failure $"${PROG} shutdown"
            echo
            return ${RETVAL}
    }
     
    restart() {
            stop
            sleep 2
            start
    }
     
    force_reload() {
            restart
    }
     
    rh_status() {
            status ${PROG}
    }
     
    rh_status_q() {
            rh_status >/dev/null 2>&1
    }
     
     
    # See how we were called.
    case "${1}" in
        start)
            rh_status_q && exit 0
            ${1}
            ;;
        stop)
            rh_status_q || exit 0
            ${1}
            ;;
        restart)
            ${1}
            ;;
        force-reload)
            force_reload
            ;;
        status)
            rh_status
            ;;
        condrestart|try-restart)
            rh_status_q || exit 0
            restart
            ;;
        *)
            echo $"Usage: ${PROG} {start|stop|status|restart|try-restart|force-reload}"
            exit 2
    esac
    exit ${?}