# Begin /lib/lsb/init-funtions # Provides initialization funtions as defined by the Linux Standard Base # specification, version 3.1.0 # Source rc configuration if not inherited from the environment if [ "${RC_BASE}" = "" ]; then . /etc/default/rc fi ############################################################################### # start_daemon() # # Usage: start_daemon [-f] [-n nicelevel] [-p pidfile] pathname [args...] # # # # Purpose: This runs the specified program as a daemon # # # # Inputs: -f: (force) run the program even if it is already running. # # -n nicelevel: specify a nice level. See 'man nice(1)'. # # -p pidfile: use the specified file to determine PIDs. # # pathname: the complete path to the specified program # # args: additional arguments passed to the program (pathname) # # # # Return values (as defined by LSB exit codes): # # 0 - program is running or service is OK # # 1 - generic or unspecified error # # 2 - invalid or excessive argument(s) # # 5 - program is not installed # ############################################################################### start_daemon() { local force="" local nice="0" local pidfile="" local pidlist="" local retval="" # Process arguments while true do case "${1}" in -f) force="1" shift 1 ;; -n) nice="${2}" shift 2 ;; -p) pidfile="${2}" shift 2 ;; -*) return 2 ;; *) program="${1}" break ;; esac done # Check for a valid program if [ ! -e "${program}" ] then return 5 fi # Execute if [ -z "${force}" ] then if [ -z "${pidfile}" ] then # determine the pid by discovery pidlist=`pidofproc "${1}"` retval="${?}" else # The PID file contains the needed PIDs # Note that by LSB requirement, the path must be given to pidofproc, # however, it is not used by the current implementation or standard. pidlist=`pidofproc -p "${pidfile}" "${1}"` retval="${?}" fi # return a value ONLY # It is the init script's (or distribution's functions) responsibilty # to log messages! case "${retval}" in 0) # program is already running correctly, this is a # succesful start. return 0 ;; 1) # program is not running, but an invalid pid file exists # remove the pid file and continue rm -f "${pidfile}" ;; 3) # program is not running and no pidfile exists # do nothing here, let start_deamon continue. ;; *) # Others as returned by status values shall not be interpreted # and returned as an unspecified error. return 1 ;; esac fi # do the start! nice -n "${nice}" "${@}" } ############################################################################### # killproc() # # Usage: killproc [-p pidfile] pathname [signal] # # # # Purpose: Send control signals to running processes # # # # Inputs: -p pidfile, uses the specified pidfile # # pathname, pathname to the specified program # # signal, send this signal to pathname # # # # Return values (as defined by LSB exit codes): # # 0 - program (pathname) has stopped/is already stopped or a # # running program has been sent specified signal and stopped # # successfully # # 1 - generic or unspecified error # # 2 - invalid or excessive argument(s) # # 5 - program is not installed # # 7 - program is not running and a signal was supplied # ############################################################################### killproc() { local pidfile local program local prefix local progname local signal="-TERM" local fallback="-KILL" local nosig local pidlist local retval local pid local delay="30" local piddead local dtime # Process arguments while true do case "${1}" in -p) pidfile="${2}" shift 2 ;; *) program="${1}" if [ -n "${2}" ] then signal="${2}" fallback="" else nosig=1 fi # error on additional arguments if [ -n "${3}" ] then return 2 else break fi ;; esac done # Check for a valid program if [ ! -e "${program}" ] then return 5 fi # Check for a valid signal check_signal "${signal}" if [ "${?}" -ne "0" ] then return 2 fi # Get a list of pids if [ -z "${pidfile}" ] then # determine the pid by discovery pidlist=`pidofproc "${1}"` retval="${?}" else # The PID file contains the needed PIDs # Note that by LSB requirement, the path must be given to pidofproc, # however, it is not used by the current implementation or standard. pidlist=`pidofproc -p "${pidfile}" "${1}"` retval="${?}" fi # return a value ONLY # It is the init script's (or distribution's functions) responsibilty # to log messages! case "${retval}" in 0) # program is running correctly # do nothing here, let killproc continue. ;; 1) # program is not running, but an invalid pid file exists # remove the pid file. rm -f "${pidfile}" # this is only a success if no signal was passed. if [ -n "${nosig}" ] then return 0 else return 7 fi ;; 3) # program is not running and no pidfile exists # this is only a success if no signal was passed. if [ -n "${nosig}" ] then return 0 else return 7 fi ;; *) # Others as returned by status values shall not be interpreted # and returned as an unspecified error. return 1 ;; esac # perform different actions for exit signals and control signals check_sig_type "${signal}" if [ "${?}" -eq "0" ] # signal is used to terminate the program then # account for empty pidlist (pid file still exists and nosignal was given) if [ "${pidlist}" != "" ]; then #kill the list of pids for pid in ${pidlist} do kill -0 "${pid}" 2> /dev/null if [ "${?}" -ne "0" ]; then # process is dead, continue to next and assume all is well continue else kill "${signal}" "${pid}" 2> /dev/null # Wait up to ${delay}/10 seconds to for "${pid}" to # terminate in 10ths of a second while [ "${delay}" -ne "0" ] do kill -0 "${pid}" 2> /dev/null || piddead="1" if [ "${piddead}" = "1" ] then break fi sleep 0.1 delay="$(( ${delay} - 1 ))" done # If a fallback is set, and program is still running, then # use the fallback if [ -n "${fallback}" -a "${piddead}" != "1" ] then kill "${fallback}" "${pid}" 2> /dev/null sleep 1 # Check again, and fail if still running kill -0 "${pid}" 2> /dev/null && return 1 else # just check one last time and if still alive, fail sleep 1 kill -0 "${pid}" 2> /dev/null && return 1 fi fi done fi # Check for and remove stale PID files. if [ -z "${pidfile}" ] then #find the basename of $program prefix=`echo "${program}" | sed 's/[^/]*$//'` progname=`echo "${program}" | sed "s@${prefix}@@"` if [ -e "/var/run/${progname}.pid" ] then rm -f "/var/run/${progname}.pid" 2> /dev/null fi else if [ -e "${pidfile}" ] then rm -f "${pidfile}" 2> /dev/null fi fi # For signals that do not expect a program to exit, simply # let kill do it's job, and evaluate kills return for value else # check_sig_type - signal is not used to terminate program for pid in ${pidlist} do kill "${signal}" "${pid}" if [ "${?}" -ne "0" ]; then return 1 fi done fi } ############################################################################### # pidofproc() # # Usage: pidofproc [-p pidfile] pathname # # # # Purpose: This function returns one or more pid(s) for a particular daemon # # # # Inputs: -p pidfile, use the specified pidfile instead of pidof # # pathname, path to the specified program # # # # Return values (as defined by LSB status codes): # # 0 - Success (PIDs to stdout) # # 1 - Program is dead, PID file still exists (remaining PIDs output) # # 3 - Program is not running (no output) # ############################################################################### pidofproc() { local pidfile local program local prefix local progname local pidlist local lpids local exitstatus="0" # Process arguments while true do case "${1}" in -p) pidfile="${2}" shift 2 ;; *) program="${1}" if [ -n "${2}" ] then # Too many arguments # Since this is status, return unknown return 4 else break fi ;; esac done # If a PID file is not specified, try and find one. if [ -z "${pidfile}" ] then # get the program's basename prefix=`echo "${program}" | sed 's/[^/]*$//'` progname=`echo "${program}" | sed "s@${prefix}@@"` # if a PID file exists with that name, assume that is it. if [ -e "/var/run/${progname}.pid" ] then pidfile="/var/run/${progname}.pid" fi fi # if a PID file is set and exists, use it. if [ -n "${pidfile}" -a -e "${pidfile}" ] then # use the value in the first line of the pidfile pidlist=`/bin/head -n1 "${pidfile}"` # This can optionally be written as 'sed 1q' to repalce 'head -n1' # should LFS move /bin/head to /usr/bin/head else # use pidof pidlist=`pidof "${program}"` fi # Figure out if all listed PIDs are running. for pid in ${pidlist} do kill -0 ${pid} 2> /dev/null if [ "${?}" -eq "0" ]; then lpids="${pids}${pid} " else exitstatus="1" fi done if [ -z "${lpids}" -a ! -f "${pidfile}" ]; then return 3 else echo "${lpids}" return "${exitstatus}" fi } ############################################################################### # log_success_msg() # # Usage: log_success_msg [$MESSAGE | "message"] # # # # Purpose: Print a successful status message to the screen and optionally # # a boot log file. # # # # Inputs: accepts one string value, either a quoted string or optionally # # the value of $MESSAGE if set in the running environment. # # # # Return values: Not used # ############################################################################### log_success_msg() { echo -n -e "${PREFIX_SUCCESS}${@}" echo -e "${SET_COL}${BRACKET}[${SUCCESS} OK ${BRACKET}]${NORMAL}" if [ "${BOOTLOG_ENAB}" = "yes" ]; then if [ $( hostname ) = "(none)" ]; then BTTIMESPEC="" else BTTIMESPEC="$(echo `date -u +"%b %d %T"` `hostname`) " fi if [ "${RUNLEVEL}" != "0" -a "${RUNLEVEL}" != "6" ]; then echo "${BTTIMESPEC}bootlog: ${@} Successful" >> /run/.bootlog fi fi return 0 } ############################################################################### # log_failure_msg() # # Usage: log_failure_msg [$MESSAGE | "message"] # # # # Purpose: Print a failure status message to the screen and optionally # # a boot log file. # # # # Inputs: accepts one string value, either a quoted string or optionally # # the value of $MESSAGE if set in the running environment. # # # # Return values: Not used # ############################################################################### log_failure_msg() { echo -n -e "${PREFIX_FAILURE}${@}" echo -e "${SET_COL}${BRACKET}[${FAILURE} FAIL ${BRACKET}]${NORMAL}" if [ "${BOOTLOG_ENAB}" = "yes" ]; then if [ $( hostname ) = "(none)" ]; then BTTIMESPEC="" else BTTIMESPEC="$(echo `date -u +"%b %d %T"` `hostname`) " fi if [ "${RUNLEVEL}" != "0" -a "${RUNLEVEL}" != "6" ]; then echo "${BTTIMESPEC}bootlog: ${@} Failed!" >> /run/.bootlog fi fi return 0 } ############################################################################### # log_warning_msg() # # Usage: log_warning_msg [$MESSAGE | "message"] # # # # Purpose: Print a warning status message to the screen and optionally # # a boot log file. # # # # Inputs: accepts one string value, either a quoted string or optionally # # the value of $MESSAGE if set in the running environment. # # # # Return values: Not used # ############################################################################### log_warning_msg() { echo -n -e "${PREFIX_WARNING}${@}" echo -e "${SET_COL}${BRACKET}[${WARNING} WARN ${BRACKET}]${NORMAL}" if [ "${BOOTLOG_ENAB}" = "yes" ]; then if [ $( hostname ) = "(none)" ]; then BTTIMESPEC="" else BTTIMESPEC="$(echo `date -u +"%b %d %T"` `hostname`) " fi if [ "${RUNLEVEL}" != "0" -a "${RUNLEVEL}" != "6" ]; then echo "${BTTIMESPEC}bootlog: ${@} Warning" >> /run/.bootlog fi fi return 0 } # The remaining fucntions are distro specific and are not defined by the LSB ############################################################################### # check_signal() # # Usage: check_signal [ -{signal} | {signal} ] # # # # Purpose: Check for a valid signal. This is not defined by any LSB draft, # # however, it is required to check the signals to determine if the # # signals chosen are invalid arguments to the other functions. # # # # Inputs: accepts a single string value in the form or -{signal} or {signal} # # # # Return values: # # 0 - Success (signal is valid # # 1 - Signal is not valid # ############################################################################### check_signal() { local valsig # Add error handling for invalid signals valsig="-ALRM -HUP -INT -KILL -PIPE -POLL -PROF -TERM -USR1 -USR2" valsig="${valsig} -VTALRM -STKFLT -PWR -WINCH -CHLD -URG -TSTP -TTIN" valsig="${valsig} -TTOU -STOP -CONT -ABRT -FPE -ILL -QUIT -SEGV -TRAP" valsig="${valsig} -SYS -EMT -BUS -XCPU -XFSZ -0 -1 -2 -3 -4 -5 -6 -8 -9" valsig="${valsig} -11 -13 -14 -15" echo "${valsig}" | grep -- " ${1} " > /dev/null if [ "${?}" -eq "0" ] then return 0 else return 1 fi } ############################################################################### # check_sig_type() # # Usage: check_signal [ -{signal} | {signal} ] # # # # Purpose: Check if signal is a program termination signal or a control # # signal. This is not defined by any LSB draft, however, it is # # required to check the signals to determine if they are intended # # to end a program or simply to control it. # # # # Inputs: accepts a single string value in the form or -{signal} or {signal} # # # # Return values: # # 0 - Signal is used for program termination # # 1 - Signal is used for program control # ############################################################################### check_sig_type() { local valsig # The list of termination signals (limited to generally used items) valsig="-ALRM -INT -KILL -TERM -PWR -STOP -ABRT -QUIT -2 -3 -6 -9 -14 -15" echo "${valsig}" | grep -- " ${1} " > /dev/null if [ "${?}" -eq "0" ] then return 0 else return 1 fi } ############################################################################### # chkstat() # # Usage: chckstat BIN_FILE {CONFIG_FILE} # # # # Purpose: chk_stat checks the status of a script by checking for both a # # binary file to execute, and if set, a config file that may be # # needed for the program to run successfully. # # # # Inputs: accepts first argument of an executable file, and optionally a # # second arugument of a configuration file. If BIN_FILE and # # CONFIG_FILE are set in the calling environment, either or both # # arguments may be omitted. # # # # Return values: # # 0 - The executable, and optionally the configuration file exists # # 2 - Invalid or excessive arguments # # 5 - BIN_FILE does not exist # # 6 - CONFIG_FILE (if set) does not exist # ############################################################################### chk_stat() { if [ "${#}" -gt "0" -a "${#}" -lt "3" ]; then BIN_FILE="${1}" if [ -z "${2}" ]; then CONFIG_FILE="" else CONFIG_FILE="${2}" fi elif [ -z "${BIN_FILE}" ]; then echo "Usage: 'chk_stat BIN_FILE CONFIG_FILE'" exit 1 # Generic Error fi if [ ! -e "${BIN_FILE}" ]; then log_failure_msg "${BIN_FILE} not installed" && exit 5 fi if [ ! -z "${CONFIG_FILE}" ]; then if [ ! -e "${CONFIG_FILE}" ]; then log_failure_msg "${CONFIG_FILE} does not exist" && exit 6 fi fi } ############################################################################### # loadproc() # # Usage: loadproc {arguments} # # # # Purpose: loadproc is just a wrapper to start_daemon for simple scripts, # # which will require no aruguments if $BIN_FILE is set. # # # # Inputs: Any optional arguments passed to loadproc will be passed on to the # # executable defined by $BIN_FILE. # # # # Return values: (none) # ############################################################################### loadproc() { start_daemon "${BIN_FILE}" "${@}" } ############################################################################### # endproc() # # Usage: endproc {arguments} # # # # Purpose: endproc is just a wrapper to killproc for simple scripts, which # # which will require no aruguments if $BIN_FILE is set. # # # # Inputs: Any optional arguments passed to endproc will be passed on to the # # executable defined by $BIN_FILE. # # # # Return values: (none) # ############################################################################### endproc() { killproc "${BIN_FILE}" "${@}" } ############################################################################### # statusproc() # # Usage: statusproc $BIN_FILE $MESSAGE # # # # Purpose: stautsproc is just a wrapper to pidofproc for simple scripts, # # which will require no aruguments if $BIN_FILE and MESSAGE are set. # # # # Inputs: accepts first argument of an executable file, and a second message # # arugument "MESSAGE" to be displayed. If BIN_FILE and MESSAGE are # # set in the calling environment, both arguments may be omitted. # # # # Return values: exit values of pidofproc # ############################################################################### statusproc() { if [ "${#}" -gt "0" -a "${#}" -lt "3" ]; then BIN_FILE="${1}" MESSAGE="${2}" elif [ -z "${BIN_FILE}" -o -z "${MESSAGE}" ]; then echo "Usage: 'statusproc BIN_FILE MESSAGE'" exit 1 # Generic Error fi pidlist=`pidofproc "${BIN_FILE}"` STATUS=$? echo "Checking ${MESSAGE} status:" if [ "${STATUS}" -eq "0" ]; then log_success_msg "Running with PID(s) ${pidlist}" else log_warning_msg "Not running!" fi return "${STATUS}" } ############################################################################### # reloadproc() # # Usage: reloadproc {--force} $BIN_FILE $MESSAGE # # # # Purpose: reloadproc sends a HUP signal to the running program (relaod # # configuration). It optionally, using the -force switch, checks the # # status of a particular program and starts it if it is not already # # running. # # # # Inputs: accepts one optional switch (must be the first argument), and # # either two, or zero string arguments. If BIN_FILE and MESSAGE are # # set in the calling envirnoment it will use those values, else it # # requires the bin file as the first argument (following -force if # # used), and the message as the second. If the --force argument is # # given, it follows the LSB definition of 'force-reload' - the # # program is started if not already running. # # # # Return values: 1 - generic error # ############################################################################### reloadproc() { local force="0" if [ "${#}" -gt "0" -a "${1}" = "-force" ]; then force="1" shift 1 fi if [ "${#}" -gt "0" -a "${#}" -lt "3" ]; then BIN_FILE="${1}" MESSAGE="${2}" elif [ -z "${BIN_FILE}" -o -z "${MESSAGE}" ]; then echo "Usage: 'reloadproc BIN_FILE MESSAGE'" exit 1 # Generic Error fi } ############################################################################### # evaluate_retval() # # Usage: evaluate_retval \ # # [standard|start|stop|reload|force-reload|restart|try-restart] # # # # Purpose: determines the sucess or failure of a previous command based on # # LSB exit values, and prints messages to the screen using the # # log_*_msg() functions. # # # # Inputs: accepts one argument which determines the output of the message # # displayed on the screen based on the LSB input values for init # # scripts. The 'standard' argument makes no changes to the value of # # $message or $MESSAGE, but only one can be set in the calling # # environment. # # # # Return values: (none) # ############################################################################### evaluate_retval() { local error_value="${?}" # Handle LSB defined return values case "${1}" in start) case "${error_value}" in 0) log_success_msg "Starting ${MESSAGE} " return "${error_value}" ;; 2) log_failure_msg "Starting ${MESSAGE} Error: Invalid argument!" return "${error_value}" ;; 5) log_failure_msg "Starting ${MESSAGE} Error: Not available!" return "${error_value}" ;; *) log_failure_msg "Starting ${MESSAGE} Error: General failure!" return "${error_value}" ;; esac ;; stop) case "${error_value}" in 0) log_success_msg "Stopping ${MESSAGE} " return "${error_value}" ;; 2) log_failure_msg "Stopping ${MESSAGE} Error: Invalid argument!" return "${error_value}" ;; 5) log_failure_msg "Stopping ${MESSAGE} Error: Not available!" return "${error_value}" ;; 7) log_warning_msg "Stopping ${MESSAGE} Warning: Not running!" return "${error_value}" ;; *) log_failure_msg "Stopping ${MESSAGE} Error: General failure!" return "${error_value}" ;; esac ;; force-reload) message="Forcefully reloading " ;; reload) message="Reloading " ;; restart) message="Restarting " ;; try-restart) message="Trying restart " ;; standard) # $message or $MESSAGE must be set, but not both in order # to use the 'standard' target. ;; esac # Print messages for the generic force-reload, reload, restart, # and try-restart targets if [ "${error_value}" -eq "0" ] then log_success_msg "${message}${MESSAGE} " return "${error_value}" else log_failure_msg "${message}${MESSAGE} " return "${error_value}" fi } # End /lib/lsb/init-functions