2006-11-26 22:02:09 +00:00
|
|
|
# $NetBSD: rc.subr,v 1.67 2006/10/07 11:25:15 elad Exp $
|
2002-06-13 22:19:42 +00:00
|
|
|
# $FreeBSD$
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2006-04-04 10:52:15 +00:00
|
|
|
# Copyright (c) 1997-2004 The NetBSD Foundation, Inc.
|
2001-06-16 07:16:14 +00:00
|
|
|
# All rights reserved.
|
|
|
|
#
|
|
|
|
# This code is derived from software contributed to The NetBSD Foundation
|
|
|
|
# by Luke Mewburn.
|
|
|
|
#
|
|
|
|
# Redistribution and use in source and binary forms, with or without
|
|
|
|
# modification, are permitted provided that the following conditions
|
|
|
|
# are met:
|
|
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
|
|
# notice, this list of conditions and the following disclaimer.
|
|
|
|
# 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
|
|
# documentation and/or other materials provided with the distribution.
|
|
|
|
#
|
|
|
|
# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
|
|
# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
|
|
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
|
|
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
|
|
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#
|
|
|
|
# rc.subr
|
|
|
|
# functions used by various rc scripts
|
|
|
|
#
|
|
|
|
|
2007-05-18 12:04:41 +00:00
|
|
|
: ${RC_PID:=$$}; export RC_PID
|
2006-04-04 10:52:15 +00:00
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
#
|
|
|
|
# Operating System dependent/independent variables
|
|
|
|
#
|
|
|
|
|
2004-07-04 07:21:18 +00:00
|
|
|
if [ -z "${_rc_subr_loaded}" ]; then
|
|
|
|
|
|
|
|
_rc_subr_loaded="YES"
|
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
SYSCTL="/sbin/sysctl"
|
|
|
|
SYSCTL_N="${SYSCTL} -n"
|
2010-01-25 20:59:04 +00:00
|
|
|
SYSCTL_W="${SYSCTL}"
|
2004-01-22 08:46:03 +00:00
|
|
|
ID="/usr/bin/id"
|
|
|
|
IDCMD="if [ -x $ID ]; then $ID -un; fi"
|
2006-08-18 12:10:18 +00:00
|
|
|
PS="/bin/ps -ww"
|
|
|
|
JID=`$PS -p $$ -o jid=`
|
2002-06-13 22:19:42 +00:00
|
|
|
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# functions
|
|
|
|
# ---------
|
|
|
|
|
2014-04-07 22:40:29 +00:00
|
|
|
# list_vars pattern
|
|
|
|
# List vars matching pattern.
|
|
|
|
#
|
|
|
|
list_vars()
|
|
|
|
{
|
|
|
|
set | { while read LINE; do
|
|
|
|
var="${LINE%%=*}"
|
|
|
|
case "$var" in
|
|
|
|
"$LINE"|*[!a-zA-Z0-9_]*) continue ;;
|
|
|
|
$1) echo $var
|
|
|
|
esac
|
|
|
|
done; }
|
|
|
|
}
|
|
|
|
|
2014-10-02 01:16:30 +00:00
|
|
|
# set_rcvar [var] [defval] [desc]
|
|
|
|
#
|
|
|
|
# Echo or define a rc.conf(5) variable name. Global variable
|
|
|
|
# $rcvars is used.
|
|
|
|
#
|
|
|
|
# If no argument is specified, echo "${name}_enable".
|
|
|
|
#
|
|
|
|
# If only a var is specified, echo "${var}_enable".
|
|
|
|
#
|
|
|
|
# If var and defval are specified, the ${var} is defined as
|
|
|
|
# rc.conf(5) variable and the default value is ${defvar}. An
|
|
|
|
# optional argument $desc can also be specified to add a
|
|
|
|
# description for that.
|
|
|
|
#
|
|
|
|
set_rcvar()
|
|
|
|
{
|
|
|
|
local _var
|
|
|
|
|
|
|
|
case $# in
|
|
|
|
0) echo ${name}_enable ;;
|
|
|
|
1) echo ${1}_enable ;;
|
|
|
|
*)
|
|
|
|
debug "set_rcvar: \$$1=$2 is added" \
|
|
|
|
" as a rc.conf(5) variable."
|
|
|
|
_var=$1
|
|
|
|
rcvars="${rcvars# } $_var"
|
|
|
|
eval ${_var}_defval=\"$2\"
|
|
|
|
shift 2
|
|
|
|
eval ${_var}_desc=\"$*\"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2009-09-12 22:19:48 +00:00
|
|
|
# set_rcvar_obsolete oldvar [newvar] [msg]
|
|
|
|
# Define obsolete variable.
|
|
|
|
# Global variable $rcvars_obsolete is used.
|
|
|
|
#
|
|
|
|
set_rcvar_obsolete()
|
|
|
|
{
|
|
|
|
local _var
|
|
|
|
_var=$1
|
2014-10-02 01:16:30 +00:00
|
|
|
debug "set_rcvar_obsolete: \$$1(old) -> \$$2(new) is defined"
|
2009-09-12 22:19:48 +00:00
|
|
|
|
|
|
|
rcvars_obsolete="${rcvars_obsolete# } $1"
|
|
|
|
eval ${1}_newvar=\"$2\"
|
|
|
|
shift 2
|
|
|
|
eval ${_var}_obsolete_msg=\"$*\"
|
|
|
|
}
|
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
#
|
2012-02-14 10:51:24 +00:00
|
|
|
# force_depend script [rcvar]
|
2002-06-13 22:19:42 +00:00
|
|
|
# Force a service to start. Intended for use by services
|
2012-02-14 10:51:24 +00:00
|
|
|
# to resolve dependency issues.
|
2002-06-13 22:19:42 +00:00
|
|
|
# $1 - filename of script, in /etc/rc.d, to run
|
2012-02-14 10:51:24 +00:00
|
|
|
# $2 - name of the script's rcvar (minus the _enable)
|
2002-06-13 22:19:42 +00:00
|
|
|
#
|
|
|
|
force_depend()
|
|
|
|
{
|
2012-02-14 10:51:24 +00:00
|
|
|
local _depend _dep_rcvar
|
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
_depend="$1"
|
2012-02-14 10:51:24 +00:00
|
|
|
_dep_rcvar="${2:-$1}_enable"
|
|
|
|
|
|
|
|
[ -n "$rc_fast" ] && ! checkyesno always_force_depends &&
|
|
|
|
checkyesno $_dep_rcvar && return 0
|
|
|
|
|
|
|
|
/etc/rc.d/${_depend} forcestatus >/dev/null 2>&1 && return 0
|
2002-06-13 22:19:42 +00:00
|
|
|
|
|
|
|
info "${name} depends on ${_depend}, which will be forced to start."
|
2005-05-22 16:22:23 +00:00
|
|
|
if ! /etc/rc.d/${_depend} forcestart; then
|
2002-06-13 22:19:42 +00:00
|
|
|
warn "Unable to force ${_depend}. It may already be running."
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# checkyesno var
|
|
|
|
# Test $1 variable, and warn if not set to YES or NO.
|
|
|
|
# Return 0 if it's "yes" (et al), nonzero otherwise.
|
|
|
|
#
|
|
|
|
checkyesno()
|
|
|
|
{
|
|
|
|
eval _value=\$${1}
|
2002-06-13 22:19:42 +00:00
|
|
|
debug "checkyesno: $1 is set to $_value."
|
2001-06-16 07:16:14 +00:00
|
|
|
case $_value in
|
|
|
|
|
|
|
|
# "yes", "true", "on", or "1"
|
|
|
|
[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
|
|
|
|
return 0
|
|
|
|
;;
|
|
|
|
|
|
|
|
# "no", "false", "off", or "0"
|
|
|
|
[Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|[Oo][Ff][Ff]|0)
|
|
|
|
return 1
|
|
|
|
;;
|
|
|
|
*)
|
2012-01-08 20:25:29 +00:00
|
|
|
warn "\$${1} is not set properly - see rc.conf(5)."
|
2001-06-16 07:16:14 +00:00
|
|
|
return 1
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2006-04-04 10:52:15 +00:00
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# reverse_list list
|
|
|
|
# print the list in reverse order
|
|
|
|
#
|
|
|
|
reverse_list()
|
|
|
|
{
|
|
|
|
_revlist=
|
2004-02-26 12:30:38 +00:00
|
|
|
for _revfile; do
|
2002-06-13 22:19:42 +00:00
|
|
|
_revlist="$_revfile $_revlist"
|
|
|
|
done
|
|
|
|
echo $_revlist
|
|
|
|
}
|
|
|
|
|
2007-05-18 12:04:41 +00:00
|
|
|
# stop_boot always
|
|
|
|
# If booting directly to multiuser or $always is enabled,
|
|
|
|
# send SIGTERM to the parent (/etc/rc) to abort the boot.
|
|
|
|
# Otherwise just exit.
|
|
|
|
#
|
|
|
|
stop_boot()
|
|
|
|
{
|
|
|
|
local always
|
|
|
|
|
2008-05-05 15:52:54 +00:00
|
|
|
case $1 in
|
|
|
|
# "yes", "true", "on", or "1"
|
2008-05-05 07:43:48 +00:00
|
|
|
[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
|
2007-05-18 12:04:41 +00:00
|
|
|
always=true
|
2008-05-05 07:43:48 +00:00
|
|
|
;;
|
|
|
|
*)
|
2007-05-18 12:04:41 +00:00
|
|
|
always=false
|
2008-05-05 07:43:48 +00:00
|
|
|
;;
|
2008-05-05 15:50:20 +00:00
|
|
|
esac
|
2007-05-18 12:04:41 +00:00
|
|
|
if [ "$autoboot" = yes -o "$always" = true ]; then
|
|
|
|
echo "ERROR: ABORTING BOOT (sending SIGTERM to parent)!"
|
|
|
|
kill -TERM ${RC_PID}
|
|
|
|
fi
|
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# mount_critical_filesystems type
|
|
|
|
# Go through the list of critical filesystems as provided in
|
|
|
|
# the rc.conf(5) variable $critical_filesystems_${type}, checking
|
|
|
|
# each one to see if it is mounted, and if it is not, mounting it.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
mount_critical_filesystems()
|
|
|
|
{
|
2002-06-13 22:19:42 +00:00
|
|
|
eval _fslist=\$critical_filesystems_${1}
|
2001-06-16 07:16:14 +00:00
|
|
|
for _fs in $_fslist; do
|
|
|
|
mount | (
|
2004-02-26 12:19:48 +00:00
|
|
|
_ismounted=false
|
2001-06-16 07:16:14 +00:00
|
|
|
while read what _on on _type type; do
|
|
|
|
if [ $on = $_fs ]; then
|
2004-02-26 12:19:48 +00:00
|
|
|
_ismounted=true
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
done
|
2004-02-26 12:19:48 +00:00
|
|
|
if $_ismounted; then
|
|
|
|
:
|
|
|
|
else
|
2001-06-16 07:16:14 +00:00
|
|
|
mount $_fs >/dev/null 2>&1
|
|
|
|
fi
|
2002-06-13 22:19:42 +00:00
|
|
|
)
|
2001-06-16 07:16:14 +00:00
|
|
|
done
|
|
|
|
}
|
|
|
|
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# check_pidfile pidfile procname [interpreter]
|
|
|
|
# Parses the first line of pidfile for a PID, and ensures
|
2001-06-16 07:16:14 +00:00
|
|
|
# that the process is running and matches procname.
|
2002-06-13 22:19:42 +00:00
|
|
|
# Prints the matching PID upon success, nothing otherwise.
|
|
|
|
# interpreter is optional; see _find_processes() for details.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
check_pidfile()
|
|
|
|
{
|
|
|
|
_pidfile=$1
|
|
|
|
_procname=$2
|
2002-06-13 22:19:42 +00:00
|
|
|
_interpreter=$3
|
2001-06-16 07:16:14 +00:00
|
|
|
if [ -z "$_pidfile" -o -z "$_procname" ]; then
|
2002-06-13 22:19:42 +00:00
|
|
|
err 3 'USAGE: check_pidfile pidfile procname [interpreter]'
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
if [ ! -f $_pidfile ]; then
|
2004-06-24 16:57:49 +00:00
|
|
|
debug "pid file ($_pidfile): not readable."
|
2001-06-16 07:16:14 +00:00
|
|
|
return
|
|
|
|
fi
|
|
|
|
read _pid _junk < $_pidfile
|
|
|
|
if [ -z "$_pid" ]; then
|
2005-01-09 23:46:37 +00:00
|
|
|
debug "pid file ($_pidfile): no pid in file."
|
2001-06-16 07:16:14 +00:00
|
|
|
return
|
|
|
|
fi
|
2002-06-13 22:19:42 +00:00
|
|
|
_find_processes $_procname ${_interpreter:-.} '-p '"$_pid"
|
2001-06-16 07:16:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# check_process procname [interpreter]
|
2001-06-16 07:16:14 +00:00
|
|
|
# Ensures that a process (or processes) named procname is running.
|
2002-06-13 22:19:42 +00:00
|
|
|
# Prints a list of matching PIDs.
|
|
|
|
# interpreter is optional; see _find_processes() for details.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
check_process()
|
|
|
|
{
|
|
|
|
_procname=$1
|
2002-06-13 22:19:42 +00:00
|
|
|
_interpreter=$2
|
2001-06-16 07:16:14 +00:00
|
|
|
if [ -z "$_procname" ]; then
|
2002-06-13 22:19:42 +00:00
|
|
|
err 3 'USAGE: check_process procname [interpreter]'
|
|
|
|
fi
|
|
|
|
_find_processes $_procname ${_interpreter:-.} '-ax'
|
|
|
|
}
|
|
|
|
|
|
|
|
#
|
|
|
|
# _find_processes procname interpreter psargs
|
|
|
|
# Search for procname in the output of ps generated by psargs.
|
|
|
|
# Prints the PIDs of any matching processes, space separated.
|
|
|
|
#
|
|
|
|
# If interpreter == ".", check the following variations of procname
|
|
|
|
# against the first word of each command:
|
|
|
|
# procname
|
|
|
|
# `basename procname`
|
|
|
|
# `basename procname` + ":"
|
|
|
|
# "(" + `basename procname` + ")"
|
2006-02-15 14:37:35 +00:00
|
|
|
# "[" + `basename procname` + "]"
|
2002-06-13 22:19:42 +00:00
|
|
|
#
|
|
|
|
# If interpreter != ".", read the first line of procname, remove the
|
|
|
|
# leading #!, normalise whitespace, append procname, and attempt to
|
|
|
|
# match that against each command, either as is, or with extra words
|
2006-04-18 15:16:55 +00:00
|
|
|
# at the end. As an alternative, to deal with interpreted daemons
|
|
|
|
# using perl, the basename of the interpreter plus a colon is also
|
|
|
|
# tried as the prefix to procname.
|
2002-06-13 22:19:42 +00:00
|
|
|
#
|
|
|
|
_find_processes()
|
|
|
|
{
|
|
|
|
if [ $# -ne 3 ]; then
|
|
|
|
err 3 'USAGE: _find_processes procname interpreter psargs'
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
2002-06-13 22:19:42 +00:00
|
|
|
_procname=$1
|
|
|
|
_interpreter=$2
|
|
|
|
_psargs=$3
|
|
|
|
|
2001-06-16 07:16:14 +00:00
|
|
|
_pref=
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ $_interpreter != "." ]; then # an interpreted script
|
2012-10-27 17:43:30 +00:00
|
|
|
_script="${_chroot}${_chroot:+/}$_procname"
|
|
|
|
if [ -r "$_script" ]; then
|
2007-06-04 11:39:35 +00:00
|
|
|
read _interp < $_script # read interpreter name
|
|
|
|
case "$_interp" in
|
|
|
|
\#!*)
|
|
|
|
_interp=${_interp#\#!} # strip #!
|
|
|
|
set -- $_interp
|
|
|
|
case $1 in
|
|
|
|
*/bin/env)
|
|
|
|
shift # drop env to get real name
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
if [ $_interpreter != $1 ]; then
|
|
|
|
warn "\$command_interpreter $_interpreter != $1"
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
warn "no shebang line in $_script"
|
|
|
|
set -- $_interpreter
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
else
|
|
|
|
warn "cannot read shebang line from $_script"
|
|
|
|
set -- $_interpreter
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
2002-06-13 22:19:42 +00:00
|
|
|
_interp="$* $_procname" # cleanup spaces, add _procname
|
2006-04-18 15:16:55 +00:00
|
|
|
_interpbn=${1##*/}
|
2002-06-13 22:19:42 +00:00
|
|
|
_fp_args='_argv'
|
|
|
|
_fp_match='case "$_argv" in
|
2013-01-10 11:08:22 +00:00
|
|
|
${_interp}|"${_interp} "*|"[${_interpbn}]"|"${_interpbn}: ${_procname}"*)'
|
2002-06-13 22:19:42 +00:00
|
|
|
else # a normal daemon
|
|
|
|
_procnamebn=${_procname##*/}
|
|
|
|
_fp_args='_arg0 _argv'
|
|
|
|
_fp_match='case "$_arg0" in
|
2005-10-17 19:01:53 +00:00
|
|
|
$_procname|$_procnamebn|${_procnamebn}:|"(${_procnamebn})"|"[${_procnamebn}]")'
|
2002-06-13 22:19:42 +00:00
|
|
|
fi
|
|
|
|
|
2006-08-18 12:10:18 +00:00
|
|
|
_proccheck="\
|
2006-08-18 13:07:38 +00:00
|
|
|
$PS 2>/dev/null -o pid= -o jid= -o command= $_psargs"' |
|
2006-04-11 09:20:47 +00:00
|
|
|
while read _npid _jid '"$_fp_args"'; do
|
2006-08-18 13:07:38 +00:00
|
|
|
'"$_fp_match"'
|
2006-04-11 09:20:47 +00:00
|
|
|
if [ "$JID" -eq "$_jid" ];
|
|
|
|
then echo -n "$_pref$_npid";
|
|
|
|
_pref=" ";
|
|
|
|
fi
|
2002-06-13 22:19:42 +00:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done'
|
|
|
|
|
2003-04-30 03:03:47 +00:00
|
|
|
# debug "in _find_processes: proccheck is ($_proccheck)."
|
2002-06-13 22:19:42 +00:00
|
|
|
eval $_proccheck
|
|
|
|
}
|
|
|
|
|
2014-04-07 22:40:29 +00:00
|
|
|
# sort_lite [-b] [-n] [-k POS] [-t SEP]
|
|
|
|
# A lite version of sort(1) (supporting a few options) that can be used
|
|
|
|
# before the real sort(1) is available (e.g., in scripts that run prior
|
|
|
|
# to mountcritremote). Requires only shell built-in functionality.
|
|
|
|
#
|
|
|
|
sort_lite()
|
|
|
|
{
|
|
|
|
local funcname=sort_lite
|
|
|
|
local sort_sep="$IFS" sort_ignore_leading_space=
|
|
|
|
local sort_field=0 sort_strict_fields= sort_numeric=
|
|
|
|
local nitems=0 skip_leading=0 trim=
|
|
|
|
|
|
|
|
local OPTIND flag
|
|
|
|
while getopts bnk:t: flag; do
|
|
|
|
case "$flag" in
|
|
|
|
b) sort_ignore_leading_space=1 ;;
|
|
|
|
n) sort_numeric=1 sort_ignore_leading_space=1 ;;
|
|
|
|
k) sort_field="${OPTARG%%,*}" ;; # only up to first comma
|
|
|
|
# NB: Unlike sort(1) only one POS allowed
|
|
|
|
t) sort_sep="$OPTARG"
|
|
|
|
if [ ${#sort_sep} -gt 1 ]; then
|
|
|
|
echo "$funcname: multi-character tab \`$sort_sep'" >&2
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
sort_strict_fields=1
|
|
|
|
;;
|
|
|
|
\?) return 1 ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
shift $(( $OPTIND - 1 ))
|
|
|
|
|
|
|
|
# Create transformation pattern to trim leading text if desired
|
|
|
|
case "$sort_field" in
|
|
|
|
""|[!0-9]*|*[!0-9.]*)
|
|
|
|
echo "$funcname: invalid sort field \`$sort_field'" >&2
|
|
|
|
return 1
|
|
|
|
;;
|
|
|
|
*.*)
|
|
|
|
skip_leading=${sort_field#*.} sort_field=${sort_field%%.*}
|
|
|
|
while [ ${skip_leading:-0} -gt 1 ] 2> /dev/null; do
|
|
|
|
trim="$trim?" skip_leading=$(( $skip_leading - 1 ))
|
|
|
|
done
|
|
|
|
esac
|
|
|
|
|
|
|
|
# Copy input to series of local numbered variables
|
|
|
|
# NB: IFS of NULL preserves leading whitespace
|
|
|
|
local LINE
|
|
|
|
while IFS= read -r LINE || [ "$LINE" ]; do
|
|
|
|
nitems=$(( $nitems + 1 ))
|
|
|
|
local src_$nitems="$LINE"
|
|
|
|
done
|
|
|
|
|
|
|
|
#
|
|
|
|
# Sort numbered locals using insertion sort
|
|
|
|
#
|
|
|
|
local curitem curitem_orig curitem_mod curitem_haskey
|
|
|
|
local dest dest_orig dest_mod dest_haskey
|
|
|
|
local d gt n
|
|
|
|
local i=1
|
|
|
|
while [ $i -le $nitems ]; do
|
|
|
|
curitem_haskey=1 # Assume sort field (-k POS) exists
|
|
|
|
eval curitem=\"\$src_$i\"
|
|
|
|
curitem_mod="$curitem" # for modified comparison
|
|
|
|
curitem_orig="$curitem" # for original comparison
|
|
|
|
|
|
|
|
# Trim leading whitespace if desired
|
|
|
|
if [ "$sort_ignore_leading_space" ]; then
|
|
|
|
while case "$curitem_orig" in
|
|
|
|
[$IFS]*) : ;; *) false; esac
|
|
|
|
do
|
|
|
|
curitem_orig="${curitem_orig#?}"
|
|
|
|
done
|
|
|
|
curitem_mod="$curitem_orig"
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Shift modified comparison value if sort field (-k POS) is > 1
|
|
|
|
n=$sort_field
|
|
|
|
while [ $n -gt 1 ]; do
|
|
|
|
case "$curitem_mod" in
|
|
|
|
*[$sort_sep]*)
|
|
|
|
# Cut text up-to (and incl.) first separator
|
|
|
|
curitem_mod="${curitem_mod#*[$sort_sep]}"
|
|
|
|
|
|
|
|
# Skip NULLs unless strict field splitting
|
|
|
|
[ "$sort_strict_fields" ] ||
|
|
|
|
[ "${curitem_mod%%[$sort_sep]*}" ] ||
|
|
|
|
[ $n -eq 2 ] ||
|
|
|
|
continue
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
# Asked for a field that doesn't exist
|
|
|
|
curitem_haskey= break
|
|
|
|
esac
|
|
|
|
n=$(( $n - 1 ))
|
|
|
|
done
|
|
|
|
|
|
|
|
# Trim trailing words if sort field >= 1
|
|
|
|
[ $sort_field -ge 1 -a "$sort_numeric" ] &&
|
|
|
|
curitem_mod="${curitem_mod%%[$sort_sep]*}"
|
|
|
|
|
|
|
|
# Apply optional trim (-k POS.TRIM) to cut leading characters
|
|
|
|
curitem_mod="${curitem_mod#$trim}"
|
|
|
|
|
|
|
|
# Determine the type of modified comparison to use initially
|
|
|
|
# NB: Prefer numerical if requested but fallback to standard
|
|
|
|
case "$curitem_mod" in
|
|
|
|
""|[!0-9]*) # NULL or begins with non-number
|
|
|
|
gt=">"
|
|
|
|
[ "$sort_numeric" ] && curitem_mod=0
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
if [ "$sort_numeric" ]; then
|
|
|
|
gt="-gt"
|
|
|
|
curitem_mod="${curitem_mod%%[!0-9]*}"
|
|
|
|
# NB: trailing non-digits removed
|
|
|
|
# otherwise numeric comparison fails
|
|
|
|
else
|
|
|
|
gt=">"
|
|
|
|
fi
|
|
|
|
esac
|
|
|
|
|
|
|
|
# If first time through, short-circuit below position-search
|
|
|
|
if [ $i -le 1 ]; then
|
|
|
|
d=0
|
|
|
|
else
|
|
|
|
d=1
|
|
|
|
fi
|
|
|
|
|
|
|
|
#
|
|
|
|
# Find appropriate element position
|
|
|
|
#
|
|
|
|
while [ $d -gt 0 ]
|
|
|
|
do
|
|
|
|
dest_haskey=$curitem_haskey
|
|
|
|
eval dest=\"\$dest_$d\"
|
|
|
|
dest_mod="$dest" # for modified comparison
|
|
|
|
dest_orig="$dest" # for original comparison
|
|
|
|
|
|
|
|
# Trim leading whitespace if desired
|
|
|
|
if [ "$sort_ignore_leading_space" ]; then
|
|
|
|
while case "$dest_orig" in
|
|
|
|
[$IFS]*) : ;; *) false; esac
|
|
|
|
do
|
|
|
|
dest_orig="${dest_orig#?}"
|
|
|
|
done
|
|
|
|
dest_mod="$dest_orig"
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Shift modified value if sort field (-k POS) is > 1
|
|
|
|
n=$sort_field
|
|
|
|
while [ $n -gt 1 ]; do
|
|
|
|
case "$dest_mod" in
|
|
|
|
*[$sort_sep]*)
|
|
|
|
# Cut text up-to (and incl.) 1st sep
|
|
|
|
dest_mod="${dest_mod#*[$sort_sep]}"
|
|
|
|
|
|
|
|
# Skip NULLs unless strict fields
|
|
|
|
[ "$sort_strict_fields" ] ||
|
|
|
|
[ "${dest_mod%%[$sort_sep]*}" ] ||
|
|
|
|
[ $n -eq 2 ] ||
|
|
|
|
continue
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
# Asked for a field that doesn't exist
|
|
|
|
dest_haskey= break
|
|
|
|
esac
|
|
|
|
n=$(( $n - 1 ))
|
|
|
|
done
|
|
|
|
|
|
|
|
# Trim trailing words if sort field >= 1
|
|
|
|
[ $sort_field -ge 1 -a "$sort_numeric" ] &&
|
|
|
|
dest_mod="${dest_mod%%[$sort_sep]*}"
|
|
|
|
|
|
|
|
# Apply optional trim (-k POS.TRIM), cut leading chars
|
|
|
|
dest_mod="${dest_mod#$trim}"
|
|
|
|
|
|
|
|
# Determine type of modified comparison to use
|
|
|
|
# NB: Prefer numerical if requested, fallback to std
|
|
|
|
case "$dest_mod" in
|
|
|
|
""|[!0-9]*) # NULL or begins with non-number
|
|
|
|
gt=">"
|
|
|
|
[ "$sort_numeric" ] && dest_mod=0
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
if [ "$sort_numeric" ]; then
|
|
|
|
gt="-gt"
|
|
|
|
dest_mod="${dest_mod%%[!0-9]*}"
|
|
|
|
# NB: kill trailing non-digits
|
|
|
|
# for numeric comparison safety
|
|
|
|
else
|
|
|
|
gt=">"
|
|
|
|
fi
|
|
|
|
esac
|
|
|
|
|
|
|
|
# Break if we've found the proper element position
|
|
|
|
if [ "$curitem_haskey" -a "$dest_haskey" ]; then
|
|
|
|
if [ "$dest_mod" = "$curitem_mod" ]; then
|
|
|
|
[ "$dest_orig" ">" "$curitem_orig" ] &&
|
|
|
|
break
|
|
|
|
elif [ "$dest_mod" $gt "$curitem_mod" ] \
|
|
|
|
2> /dev/null
|
|
|
|
then
|
|
|
|
break
|
|
|
|
fi
|
|
|
|
else
|
|
|
|
[ "$dest_orig" ">" "$curitem_orig" ] && break
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Break if we've hit the end
|
|
|
|
[ $d -ge $i ] && break
|
|
|
|
|
|
|
|
d=$(( $d + 1 ))
|
|
|
|
done
|
|
|
|
|
|
|
|
# Shift remaining positions forward, making room for new item
|
|
|
|
n=$i
|
|
|
|
while [ $n -ge $d ]; do
|
|
|
|
# Shift destination item forward one placement
|
|
|
|
eval dest_$(( $n + 1 ))=\"\$dest_$n\"
|
|
|
|
n=$(( $n - 1 ))
|
|
|
|
done
|
|
|
|
|
|
|
|
# Place the element
|
|
|
|
if [ $i -eq 1 ]; then
|
|
|
|
local dest_1="$curitem"
|
|
|
|
else
|
|
|
|
local dest_$d="$curitem"
|
|
|
|
fi
|
|
|
|
|
|
|
|
i=$(( $i + 1 ))
|
|
|
|
done
|
|
|
|
|
|
|
|
# Print sorted results
|
|
|
|
d=1
|
|
|
|
while [ $d -le $nitems ]; do
|
|
|
|
eval echo \"\$dest_$d\"
|
|
|
|
d=$(( $d + 1 ))
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
#
|
|
|
|
# wait_for_pids pid [pid ...]
|
|
|
|
# spins until none of the pids exist
|
|
|
|
#
|
|
|
|
wait_for_pids()
|
|
|
|
{
|
2010-04-06 05:20:46 +00:00
|
|
|
local _list _prefix _nlist _j
|
|
|
|
|
2004-02-26 12:30:38 +00:00
|
|
|
_list="$@"
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -z "$_list" ]; then
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
_prefix=
|
|
|
|
while true; do
|
|
|
|
_nlist="";
|
|
|
|
for _j in $_list; do
|
|
|
|
if kill -0 $_j 2>/dev/null; then
|
|
|
|
_nlist="${_nlist}${_nlist:+ }$_j"
|
2010-04-06 05:20:46 +00:00
|
|
|
[ -n "$_prefix" ] && sleep 1
|
2002-06-13 22:19:42 +00:00
|
|
|
fi
|
|
|
|
done
|
|
|
|
if [ -z "$_nlist" ]; then
|
|
|
|
break
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
2002-06-13 22:19:42 +00:00
|
|
|
_list=$_nlist
|
|
|
|
echo -n ${_prefix:-"Waiting for PIDS: "}$_list
|
|
|
|
_prefix=", "
|
2010-04-06 05:20:46 +00:00
|
|
|
pwait $_list 2>/dev/null
|
2001-06-16 07:16:14 +00:00
|
|
|
done
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -n "$_prefix" ]; then
|
|
|
|
echo "."
|
|
|
|
fi
|
2001-06-16 07:16:14 +00:00
|
|
|
}
|
|
|
|
|
2011-04-23 04:26:31 +00:00
|
|
|
#
|
|
|
|
# get_pidfile_from_conf string file
|
|
|
|
#
|
|
|
|
# Takes a string to search for in the specified file.
|
|
|
|
# Ignores lines with traditional comment characters.
|
|
|
|
#
|
|
|
|
# Example:
|
|
|
|
#
|
|
|
|
# if get_pidfile_from_conf string file; then
|
|
|
|
# pidfile="$_pidfile_from_conf"
|
|
|
|
# else
|
|
|
|
# pidfile='appropriate default'
|
|
|
|
# fi
|
|
|
|
#
|
|
|
|
get_pidfile_from_conf()
|
|
|
|
{
|
2011-04-23 05:24:17 +00:00
|
|
|
if [ -z "$1" -o -z "$2" ]; then
|
|
|
|
err 3 "USAGE: get_pidfile_from_conf string file ($name)"
|
|
|
|
fi
|
|
|
|
|
2011-04-23 04:26:31 +00:00
|
|
|
local string file line
|
|
|
|
|
|
|
|
string="$1" ; file="$2"
|
|
|
|
|
2011-04-23 05:24:17 +00:00
|
|
|
if [ ! -s "$file" ]; then
|
|
|
|
err 3 "get_pidfile_from_conf: $file does not exist ($name)"
|
2011-04-23 04:26:31 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
while read line; do
|
|
|
|
case "$line" in
|
|
|
|
*[#\;]*${string}*) continue ;;
|
|
|
|
*${string}*) break ;;
|
|
|
|
esac
|
|
|
|
done < $file
|
|
|
|
|
|
|
|
if [ -n "$line" ]; then
|
|
|
|
line=${line#*/}
|
|
|
|
_pidfile_from_conf="/${line%%[\"\;]*}"
|
|
|
|
else
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2009-10-10 22:17:03 +00:00
|
|
|
#
|
|
|
|
# check_startmsgs
|
|
|
|
# If rc_quiet is set (usually as a result of using faststart at
|
|
|
|
# boot time) check if rc_startmsgs is enabled.
|
|
|
|
#
|
|
|
|
check_startmsgs()
|
|
|
|
{
|
|
|
|
if [ -n "$rc_quiet" ]; then
|
|
|
|
checkyesno rc_startmsgs
|
|
|
|
else
|
|
|
|
return 0
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# run_rc_command argument
|
|
|
|
# Search for argument in the list of supported commands, which is:
|
|
|
|
# "start stop restart rcvar status poll ${extra_commands}"
|
|
|
|
# If there's a match, run ${argument}_cmd or the default method
|
|
|
|
# (see below).
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# If argument has a given prefix, then change the operation as follows:
|
|
|
|
# Prefix Operation
|
2001-06-16 07:16:14 +00:00
|
|
|
# ------ ---------
|
2008-01-26 11:22:12 +00:00
|
|
|
# fast Skip the pid check, and set rc_fast=yes, rc_quiet=yes
|
2002-06-13 22:19:42 +00:00
|
|
|
# force Set ${rcvar} to YES, and set rc_force=yes
|
2004-02-27 09:58:50 +00:00
|
|
|
# one Set ${rcvar} to YES
|
2008-01-26 11:22:12 +00:00
|
|
|
# quiet Don't output some diagnostics, and set rc_quiet=yes
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# The following globals are used:
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# Name Needed Purpose
|
|
|
|
# ---- ------ -------
|
2001-06-16 07:16:14 +00:00
|
|
|
# name y Name of script.
|
|
|
|
#
|
|
|
|
# command n Full path to command.
|
2002-06-13 22:19:42 +00:00
|
|
|
# Not needed if ${rc_arg}_cmd is set for
|
2001-06-16 07:16:14 +00:00
|
|
|
# each keyword.
|
|
|
|
#
|
|
|
|
# command_args n Optional args/shell directives for command.
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# command_interpreter n If not empty, command is interpreted, so
|
|
|
|
# call check_{pidfile,process}() appropriately.
|
|
|
|
#
|
2009-09-12 22:19:48 +00:00
|
|
|
# desc n Description of script.
|
|
|
|
#
|
2001-06-16 07:16:14 +00:00
|
|
|
# extra_commands n List of extra commands supported.
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# pidfile n If set, use check_pidfile $pidfile $command,
|
|
|
|
# otherwise use check_process $command.
|
|
|
|
# In either case, only check if $command is set.
|
|
|
|
#
|
|
|
|
# procname n Process name to check for instead of $command.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# rcvar n This is checked with checkyesno to determine
|
|
|
|
# if the action should be run.
|
|
|
|
#
|
2006-04-11 08:55:27 +00:00
|
|
|
# ${name}_program n Full path to command.
|
|
|
|
# Meant to be used in /etc/rc.conf to override
|
|
|
|
# ${command}.
|
|
|
|
#
|
2001-06-16 07:16:14 +00:00
|
|
|
# ${name}_chroot n Directory to chroot to before running ${command}
|
2002-06-13 22:19:42 +00:00
|
|
|
# Requires /usr to be mounted.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# ${name}_chdir n Directory to cd to before running ${command}
|
|
|
|
# (if not using ${name}_chroot).
|
|
|
|
#
|
|
|
|
# ${name}_flags n Arguments to call ${command} with.
|
|
|
|
# NOTE: $flags from the parent environment
|
|
|
|
# can be used to override this.
|
|
|
|
#
|
2012-10-27 19:09:09 +00:00
|
|
|
# ${name}_fib n Routing table number to run ${command} with.
|
|
|
|
#
|
2001-06-16 07:16:14 +00:00
|
|
|
# ${name}_nice n Nice level to run ${command} at.
|
|
|
|
#
|
|
|
|
# ${name}_user n User to run ${command} as, using su(1) if not
|
|
|
|
# using ${name}_chroot.
|
2002-06-13 22:19:42 +00:00
|
|
|
# Requires /usr to be mounted.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# ${name}_group n Group to run chrooted ${command} as.
|
2002-06-13 22:19:42 +00:00
|
|
|
# Requires /usr to be mounted.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# ${name}_groups n Comma separated list of supplementary groups
|
|
|
|
# to run the chrooted ${command} with.
|
|
|
|
# Requires /usr to be mounted.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# ${rc_arg}_cmd n If set, use this as the method when invoked;
|
2001-06-16 07:16:14 +00:00
|
|
|
# Otherwise, use default command (see below)
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# ${rc_arg}_precmd n If set, run just before performing the
|
|
|
|
# ${rc_arg}_cmd method in the default
|
|
|
|
# operation (i.e, after checking for required
|
|
|
|
# bits and process (non)existence).
|
2001-06-16 07:16:14 +00:00
|
|
|
# If this completes with a non-zero exit code,
|
2002-06-13 22:19:42 +00:00
|
|
|
# don't run ${rc_arg}_cmd.
|
|
|
|
#
|
|
|
|
# ${rc_arg}_postcmd n If set, run just after performing the
|
|
|
|
# ${rc_arg}_cmd method, if that method
|
|
|
|
# returned a zero exit code.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# required_dirs n If set, check for the existence of the given
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
# directories before running a (re)start command.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# required_files n If set, check for the readability of the given
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
# files before running a (re)start command.
|
|
|
|
#
|
|
|
|
# required_modules n If set, ensure the given kernel modules are
|
|
|
|
# loaded before running a (re)start command.
|
|
|
|
# The check and possible loads are actually
|
|
|
|
# done after start_precmd so that the modules
|
|
|
|
# aren't loaded in vain, should the precmd
|
|
|
|
# return a non-zero status to indicate a error.
|
|
|
|
# If a word in the list looks like "foo:bar",
|
|
|
|
# "foo" is the KLD file name and "bar" is the
|
|
|
|
# module name. If a word looks like "foo~bar",
|
|
|
|
# "foo" is the KLD file name and "bar" is a
|
|
|
|
# egrep(1) pattern matching the module name.
|
|
|
|
# Otherwise the module name is assumed to be
|
|
|
|
# the same as the KLD file name, which is most
|
|
|
|
# common. See load_kld().
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# required_vars n If set, perform checkyesno on each of the
|
|
|
|
# listed variables before running the default
|
|
|
|
# (re)start command.
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# Default behaviour for a given argument, if no override method is
|
|
|
|
# provided:
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# Argument Default behaviour
|
|
|
|
# -------- -----------------
|
2001-06-16 07:16:14 +00:00
|
|
|
# start if !running && checkyesno ${rcvar}
|
|
|
|
# ${command}
|
|
|
|
#
|
|
|
|
# stop if ${pidfile}
|
2002-06-13 22:19:42 +00:00
|
|
|
# rc_pid=$(check_pidfile $pidfile $command)
|
2001-06-16 07:16:14 +00:00
|
|
|
# else
|
2002-06-13 22:19:42 +00:00
|
|
|
# rc_pid=$(check_process $command)
|
|
|
|
# kill $sig_stop $rc_pid
|
|
|
|
# wait_for_pids $rc_pid
|
|
|
|
# ($sig_stop defaults to TERM.)
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# reload Similar to stop, except use $sig_reload instead,
|
|
|
|
# and doesn't wait_for_pids.
|
2001-06-16 07:16:14 +00:00
|
|
|
# $sig_reload defaults to HUP.
|
2005-10-26 04:12:34 +00:00
|
|
|
# Note that `reload' isn't provided by default,
|
|
|
|
# it should be enabled via $extra_commands.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# restart Run `stop' then `start'.
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# status Show if ${command} is running, etc.
|
|
|
|
#
|
|
|
|
# poll Wait for ${command} to exit.
|
|
|
|
#
|
|
|
|
# rcvar Display what rc.conf variable is used (if any).
|
|
|
|
#
|
2013-09-23 04:36:51 +00:00
|
|
|
# enabled Return true if the service is enabled.
|
|
|
|
#
|
2002-06-13 22:19:42 +00:00
|
|
|
# Variables available to methods, and after run_rc_command() has
|
|
|
|
# completed:
|
|
|
|
#
|
|
|
|
# Variable Purpose
|
|
|
|
# -------- -------
|
2004-02-27 09:58:50 +00:00
|
|
|
# rc_arg Argument to command, after fast/force/one processing
|
2002-06-13 22:19:42 +00:00
|
|
|
# performed
|
|
|
|
#
|
|
|
|
# rc_flags Flags to start the default command with.
|
|
|
|
# Defaults to ${name}_flags, unless overridden
|
|
|
|
# by $flags from the environment.
|
|
|
|
# This variable may be changed by the precmd method.
|
|
|
|
#
|
|
|
|
# rc_pid PID of command (if appropriate)
|
|
|
|
#
|
|
|
|
# rc_fast Not empty if "fast" was provided (q.v.)
|
|
|
|
#
|
|
|
|
# rc_force Not empty if "force" was provided (q.v.)
|
|
|
|
#
|
2008-01-26 11:22:12 +00:00
|
|
|
# rc_quiet Not empty if "quiet" was provided
|
|
|
|
#
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
run_rc_command()
|
|
|
|
{
|
2003-06-09 17:31:06 +00:00
|
|
|
_return=0
|
2002-06-13 22:19:42 +00:00
|
|
|
rc_arg=$1
|
2001-06-16 07:16:14 +00:00
|
|
|
if [ -z "$name" ]; then
|
2002-06-13 22:19:42 +00:00
|
|
|
err 3 'run_rc_command: $name is not set.'
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
2004-07-30 17:19:35 +00:00
|
|
|
# Don't repeat the first argument when passing additional command-
|
|
|
|
# line arguments to the command subroutines.
|
|
|
|
#
|
|
|
|
shift 1
|
|
|
|
rc_extra_args="$*"
|
|
|
|
|
2004-02-27 09:58:50 +00:00
|
|
|
_rc_prefix=
|
2002-06-13 22:19:42 +00:00
|
|
|
case "$rc_arg" in
|
2001-06-16 07:16:14 +00:00
|
|
|
fast*) # "fast" prefix; don't check pid
|
2002-06-13 22:19:42 +00:00
|
|
|
rc_arg=${rc_arg#fast}
|
|
|
|
rc_fast=yes
|
2008-01-26 11:22:12 +00:00
|
|
|
rc_quiet=yes
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
2009-10-18 19:51:06 +00:00
|
|
|
force*) # "force" prefix; always run
|
2002-06-13 22:19:42 +00:00
|
|
|
rc_force=yes
|
2004-02-27 09:58:50 +00:00
|
|
|
_rc_prefix=force
|
|
|
|
rc_arg=${rc_arg#${_rc_prefix}}
|
|
|
|
if [ -n "${rcvar}" ]; then
|
|
|
|
eval ${rcvar}=YES
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
one*) # "one" prefix; set ${rcvar}=yes
|
|
|
|
_rc_prefix=one
|
|
|
|
rc_arg=${rc_arg#${_rc_prefix}}
|
2001-06-16 07:16:14 +00:00
|
|
|
if [ -n "${rcvar}" ]; then
|
|
|
|
eval ${rcvar}=YES
|
|
|
|
fi
|
|
|
|
;;
|
2008-01-26 11:22:12 +00:00
|
|
|
quiet*) # "quiet" prefix; omit some messages
|
|
|
|
_rc_prefix=quiet
|
|
|
|
rc_arg=${rc_arg#${_rc_prefix}}
|
|
|
|
rc_quiet=yes
|
|
|
|
;;
|
2001-06-16 07:16:14 +00:00
|
|
|
esac
|
|
|
|
|
2006-08-22 11:17:29 +00:00
|
|
|
eval _override_command=\$${name}_program
|
2009-10-15 23:20:23 +00:00
|
|
|
command=${_override_command:-$command}
|
2006-08-22 11:17:29 +00:00
|
|
|
|
2013-09-23 04:36:51 +00:00
|
|
|
_keywords="start stop restart rcvar enabled $extra_commands"
|
2002-06-13 22:19:42 +00:00
|
|
|
rc_pid=
|
2001-06-16 07:16:14 +00:00
|
|
|
_pidcmd=
|
2002-06-13 22:19:42 +00:00
|
|
|
_procname=${procname:-${command}}
|
|
|
|
|
2004-06-26 09:27:30 +00:00
|
|
|
# setup pid check command
|
|
|
|
if [ -n "$_procname" ]; then
|
2001-06-16 07:16:14 +00:00
|
|
|
if [ -n "$pidfile" ]; then
|
2002-06-13 22:19:42 +00:00
|
|
|
_pidcmd='rc_pid=$(check_pidfile '"$pidfile $_procname $command_interpreter"')'
|
|
|
|
else
|
|
|
|
_pidcmd='rc_pid=$(check_process '"$_procname $command_interpreter"')'
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
if [ -n "$_pidcmd" ]; then
|
2002-06-13 22:19:42 +00:00
|
|
|
_keywords="${_keywords} status poll"
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -z "$rc_arg" ]; then
|
2005-10-01 20:58:03 +00:00
|
|
|
rc_usage $_keywords
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
2013-09-23 04:36:51 +00:00
|
|
|
if [ "$rc_arg" = "enabled" ] ; then
|
|
|
|
checkyesno ${rcvar}
|
|
|
|
return $?
|
|
|
|
fi
|
|
|
|
|
2001-06-16 07:16:14 +00:00
|
|
|
if [ -n "$flags" ]; then # allow override from environment
|
2002-06-13 22:19:42 +00:00
|
|
|
rc_flags=$flags
|
2001-06-16 07:16:14 +00:00
|
|
|
else
|
2002-06-13 22:19:42 +00:00
|
|
|
eval rc_flags=\$${name}_flags
|
|
|
|
fi
|
|
|
|
eval _chdir=\$${name}_chdir _chroot=\$${name}_chroot \
|
|
|
|
_nice=\$${name}_nice _user=\$${name}_user \
|
2012-10-27 19:09:09 +00:00
|
|
|
_group=\$${name}_group _groups=\$${name}_groups \
|
|
|
|
_fib=\$${name}_fib
|
2002-06-13 22:19:42 +00:00
|
|
|
|
|
|
|
if [ -n "$_user" ]; then # unset $_user if running as that user
|
2004-01-22 08:46:03 +00:00
|
|
|
if [ "$_user" = "$(eval $IDCMD)" ]; then
|
2002-06-13 22:19:42 +00:00
|
|
|
unset _user
|
|
|
|
fi
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
2012-01-20 10:31:27 +00:00
|
|
|
[ -z "$autoboot" ] && eval $_pidcmd # determine the pid if necessary
|
2008-06-19 06:11:34 +00:00
|
|
|
|
|
|
|
for _elem in $_keywords; do
|
|
|
|
if [ "$_elem" != "$rc_arg" ]; then
|
|
|
|
continue
|
|
|
|
fi
|
2010-04-15 21:18:24 +00:00
|
|
|
# if ${rcvar} is set, $1 is not "rcvar"
|
|
|
|
# and ${rc_pid} is not set, then run
|
2001-06-16 07:16:14 +00:00
|
|
|
# checkyesno ${rcvar}
|
|
|
|
# and return if that failed
|
|
|
|
#
|
2011-04-17 22:31:36 +00:00
|
|
|
if [ -n "${rcvar}" -a "$rc_arg" != "rcvar" -a "$rc_arg" != "stop" ] ||
|
|
|
|
[ -n "${rcvar}" -a "$rc_arg" = "stop" -a -z "${rc_pid}" ]; then
|
2008-06-19 06:11:34 +00:00
|
|
|
if ! checkyesno ${rcvar}; then
|
|
|
|
if [ -n "${rc_quiet}" ]; then
|
|
|
|
return 0
|
|
|
|
fi
|
|
|
|
echo -n "Cannot '${rc_arg}' $name. Set ${rcvar} to "
|
|
|
|
echo -n "YES in /etc/rc.conf or use 'one${rc_arg}' "
|
|
|
|
echo "instead of '${rc_arg}'."
|
2008-01-26 11:22:12 +00:00
|
|
|
return 0
|
|
|
|
fi
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
# if there's a custom ${XXX_cmd},
|
|
|
|
# run that instead of the default
|
|
|
|
#
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
eval _cmd=\$${rc_arg}_cmd \
|
|
|
|
_precmd=\$${rc_arg}_precmd \
|
|
|
|
_postcmd=\$${rc_arg}_postcmd
|
2003-01-20 19:30:15 +00:00
|
|
|
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
if [ -n "$_cmd" ]; then
|
|
|
|
_run_rc_precmd || return 1
|
|
|
|
_run_rc_doit "$_cmd $rc_extra_args" || return 1
|
|
|
|
_run_rc_postcmd
|
2003-06-09 17:31:06 +00:00
|
|
|
return $_return
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
case "$rc_arg" in # default operations...
|
2001-06-16 07:16:14 +00:00
|
|
|
|
|
|
|
status)
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_precmd || return 1
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -n "$rc_pid" ]; then
|
|
|
|
echo "${name} is running as pid $rc_pid."
|
2001-06-16 07:16:14 +00:00
|
|
|
else
|
|
|
|
echo "${name} is not running."
|
|
|
|
return 1
|
|
|
|
fi
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_postcmd
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
|
|
|
|
|
|
|
start)
|
2004-06-26 09:27:30 +00:00
|
|
|
if [ -z "$rc_fast" -a -n "$rc_pid" ]; then
|
2012-11-20 04:45:04 +00:00
|
|
|
if [ -z "$rc_quiet" ]; then
|
|
|
|
echo 1>&2 "${name} already running? " \
|
|
|
|
"(pid=$rc_pid)."
|
|
|
|
fi
|
2005-12-06 05:27:11 +00:00
|
|
|
return 1
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
2012-10-27 17:43:30 +00:00
|
|
|
if [ ! -x "${_chroot}${_chroot:+/}${command}" ]; then
|
2006-07-25 17:14:38 +00:00
|
|
|
warn "run_rc_command: cannot run $command"
|
2005-12-06 05:27:11 +00:00
|
|
|
return 1
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
2008-06-23 05:09:09 +00:00
|
|
|
if ! _run_rc_precmd; then
|
|
|
|
warn "failed precmd routine for ${name}"
|
|
|
|
return 1
|
|
|
|
fi
|
2001-06-16 07:16:14 +00:00
|
|
|
|
2006-07-25 17:16:48 +00:00
|
|
|
# setup the full command to run
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
2009-10-10 22:17:03 +00:00
|
|
|
check_startmsgs && echo "Starting ${name}."
|
2001-06-16 07:16:14 +00:00
|
|
|
if [ -n "$_chroot" ]; then
|
|
|
|
_doit="\
|
|
|
|
${_nice:+nice -n $_nice }\
|
2012-10-27 19:09:09 +00:00
|
|
|
${_fib:+setfib -F $_fib }\
|
2001-06-16 07:16:14 +00:00
|
|
|
chroot ${_user:+-u $_user }${_group:+-g $_group }${_groups:+-G $_groups }\
|
2002-06-13 22:19:42 +00:00
|
|
|
$_chroot $command $rc_flags $command_args"
|
2001-06-16 07:16:14 +00:00
|
|
|
else
|
|
|
|
_doit="\
|
2006-08-17 08:04:20 +00:00
|
|
|
${_chdir:+cd $_chdir && }\
|
2012-10-27 19:09:09 +00:00
|
|
|
${_fib:+setfib -F $_fib }\
|
2002-06-13 22:19:42 +00:00
|
|
|
$command $rc_flags $command_args"
|
|
|
|
if [ -n "$_user" ]; then
|
|
|
|
_doit="su -m $_user -c 'sh -c \"$_doit\"'"
|
|
|
|
fi
|
2006-08-17 08:04:20 +00:00
|
|
|
if [ -n "$_nice" ]; then
|
|
|
|
if [ -z "$_user" ]; then
|
|
|
|
_doit="sh -c \"$_doit\""
|
2009-12-27 06:25:03 +00:00
|
|
|
fi
|
2006-08-17 08:04:20 +00:00
|
|
|
_doit="nice -n $_nice $_doit"
|
|
|
|
fi
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
2002-06-13 22:19:42 +00:00
|
|
|
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
# run the full command
|
2002-06-13 22:19:42 +00:00
|
|
|
#
|
2008-06-23 05:09:09 +00:00
|
|
|
if ! _run_rc_doit "$_doit"; then
|
|
|
|
warn "failed to start ${name}"
|
|
|
|
return 1
|
|
|
|
fi
|
2002-06-13 22:19:42 +00:00
|
|
|
|
|
|
|
# finally, run postcmd
|
|
|
|
#
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_postcmd
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
|
|
|
|
|
|
|
stop)
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -z "$rc_pid" ]; then
|
2005-12-06 05:27:11 +00:00
|
|
|
[ -n "$rc_fast" ] && return 0
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_notrunning
|
2005-12-06 05:27:11 +00:00
|
|
|
return 1
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_precmd || return 1
|
2002-06-13 22:19:42 +00:00
|
|
|
|
|
|
|
# send the signal to stop
|
|
|
|
#
|
2001-06-16 07:16:14 +00:00
|
|
|
echo "Stopping ${name}."
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_doit=$(_run_rc_killcmd "${sig_stop:-TERM}")
|
|
|
|
_run_rc_doit "$_doit" || return 1
|
2002-06-13 22:19:42 +00:00
|
|
|
|
|
|
|
# wait for the command to exit,
|
|
|
|
# and run postcmd.
|
|
|
|
wait_for_pids $rc_pid
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
|
|
|
|
_run_rc_postcmd
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
|
|
|
|
|
|
|
reload)
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -z "$rc_pid" ]; then
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_notrunning
|
2005-12-06 05:27:11 +00:00
|
|
|
return 1
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
|
|
|
|
_run_rc_precmd || return 1
|
|
|
|
|
|
|
|
_doit=$(_run_rc_killcmd "${sig_reload:-HUP}")
|
|
|
|
_run_rc_doit "$_doit" || return 1
|
|
|
|
|
|
|
|
_run_rc_postcmd
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
|
|
|
|
|
|
|
restart)
|
|
|
|
# prevent restart being called more
|
|
|
|
# than once by any given script
|
|
|
|
#
|
2004-02-26 12:19:48 +00:00
|
|
|
if ${_rc_restart_done:-false}; then
|
2001-06-16 07:16:14 +00:00
|
|
|
return 0
|
|
|
|
fi
|
2004-02-26 12:19:48 +00:00
|
|
|
_rc_restart_done=true
|
2001-06-16 07:16:14 +00:00
|
|
|
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_precmd || return 1
|
|
|
|
|
|
|
|
# run those in a subshell to keep global variables
|
2005-11-16 10:45:19 +00:00
|
|
|
( run_rc_command ${_rc_prefix}stop $rc_extra_args )
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
( run_rc_command ${_rc_prefix}start $rc_extra_args )
|
|
|
|
_return=$?
|
|
|
|
[ $_return -ne 0 ] && [ -z "$rc_force" ] && return 1
|
2002-06-13 22:19:42 +00:00
|
|
|
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_postcmd
|
2002-06-13 22:19:42 +00:00
|
|
|
;;
|
|
|
|
|
|
|
|
poll)
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_precmd || return 1
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -n "$rc_pid" ]; then
|
|
|
|
wait_for_pids $rc_pid
|
|
|
|
fi
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
_run_rc_postcmd
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
|
|
|
|
|
|
|
rcvar)
|
2009-09-12 22:19:48 +00:00
|
|
|
echo -n "# $name"
|
|
|
|
if [ -n "$desc" ]; then
|
|
|
|
echo " : $desc"
|
|
|
|
else
|
|
|
|
echo ""
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
2009-09-12 22:19:48 +00:00
|
|
|
echo "#"
|
2014-10-02 01:16:30 +00:00
|
|
|
# Get unique vars in $rcvar $rcvars
|
|
|
|
for _v in $rcvar $rcvars; do
|
2009-09-12 22:19:48 +00:00
|
|
|
case $v in
|
|
|
|
$_v\ *|\ *$_v|*\ $_v\ *) ;;
|
|
|
|
*) v="${v# } $_v" ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
|
|
|
|
# Display variables.
|
|
|
|
for _v in $v; do
|
|
|
|
if [ -z "$_v" ]; then
|
|
|
|
continue
|
|
|
|
fi
|
|
|
|
|
|
|
|
eval _desc=\$${_v}_desc
|
|
|
|
eval _defval=\$${_v}_defval
|
|
|
|
_h="-"
|
|
|
|
|
|
|
|
eval echo \"$_v=\\\"\$$_v\\\"\"
|
|
|
|
# decode multiple lines of _desc
|
|
|
|
while [ -n "$_desc" ]; do
|
|
|
|
case $_desc in
|
|
|
|
*^^*)
|
|
|
|
echo "# $_h ${_desc%%^^*}"
|
|
|
|
_desc=${_desc#*^^}
|
|
|
|
_h=" "
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
echo "# $_h ${_desc}"
|
|
|
|
break
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
echo "# (default: \"$_defval\")"
|
|
|
|
done
|
|
|
|
echo ""
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
|
|
|
|
|
|
|
*)
|
2005-10-01 20:58:03 +00:00
|
|
|
rc_usage $_keywords
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
|
|
|
|
|
|
|
esac
|
2003-06-09 17:31:06 +00:00
|
|
|
return $_return
|
2001-06-16 07:16:14 +00:00
|
|
|
done
|
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
echo 1>&2 "$0: unknown directive '$rc_arg'."
|
2005-10-01 20:58:03 +00:00
|
|
|
rc_usage $_keywords
|
2005-12-06 05:27:11 +00:00
|
|
|
# not reached
|
2001-06-16 07:16:14 +00:00
|
|
|
}
|
|
|
|
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
#
|
|
|
|
# Helper functions for run_rc_command: common code.
|
|
|
|
# They use such global variables besides the exported rc_* ones:
|
|
|
|
#
|
|
|
|
# name R/W
|
|
|
|
# ------------------
|
|
|
|
# _precmd R
|
|
|
|
# _postcmd R
|
|
|
|
# _return W
|
|
|
|
#
|
|
|
|
_run_rc_precmd()
|
|
|
|
{
|
|
|
|
check_required_before "$rc_arg" || return 1
|
|
|
|
|
|
|
|
if [ -n "$_precmd" ]; then
|
|
|
|
debug "run_rc_command: ${rc_arg}_precmd: $_precmd $rc_extra_args"
|
|
|
|
eval "$_precmd $rc_extra_args"
|
|
|
|
_return=$?
|
|
|
|
|
|
|
|
# If precmd failed and force isn't set, request exit.
|
|
|
|
if [ $_return -ne 0 ] && [ -z "$rc_force" ]; then
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
check_required_after "$rc_arg" || return 1
|
|
|
|
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
_run_rc_postcmd()
|
|
|
|
{
|
|
|
|
if [ -n "$_postcmd" ]; then
|
|
|
|
debug "run_rc_command: ${rc_arg}_postcmd: $_postcmd $rc_extra_args"
|
|
|
|
eval "$_postcmd $rc_extra_args"
|
|
|
|
_return=$?
|
|
|
|
fi
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
_run_rc_doit()
|
|
|
|
{
|
|
|
|
debug "run_rc_command: doit: $*"
|
|
|
|
eval "$@"
|
|
|
|
_return=$?
|
|
|
|
|
|
|
|
# If command failed and force isn't set, request exit.
|
|
|
|
if [ $_return -ne 0 ] && [ -z "$rc_force" ]; then
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
_run_rc_notrunning()
|
|
|
|
{
|
|
|
|
local _pidmsg
|
|
|
|
|
|
|
|
if [ -n "$pidfile" ]; then
|
|
|
|
_pidmsg=" (check $pidfile)."
|
|
|
|
else
|
|
|
|
_pidmsg=
|
|
|
|
fi
|
|
|
|
echo 1>&2 "${name} not running?${_pidmsg}"
|
|
|
|
}
|
|
|
|
|
|
|
|
_run_rc_killcmd()
|
|
|
|
{
|
|
|
|
local _cmd
|
|
|
|
|
|
|
|
_cmd="kill -$1 $rc_pid"
|
|
|
|
if [ -n "$_user" ]; then
|
|
|
|
_cmd="su -m ${_user} -c 'sh -c \"${_cmd}\"'"
|
|
|
|
fi
|
|
|
|
echo "$_cmd"
|
|
|
|
}
|
|
|
|
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
# run_rc_script file arg
|
|
|
|
# Start the script `file' with `arg', and correctly handle the
|
2009-12-27 06:27:09 +00:00
|
|
|
# return value from the script.
|
|
|
|
# If `file' ends with `.sh', it's sourced into the current environment
|
|
|
|
# when $rc_fast_and_loose is set, otherwise it is run as a child process.
|
|
|
|
# If `file' appears to be a backup or scratch file, ignore it.
|
|
|
|
# Otherwise if it is executable run as a child process.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
run_rc_script()
|
|
|
|
{
|
|
|
|
_file=$1
|
|
|
|
_arg=$2
|
|
|
|
if [ -z "$_file" -o -z "$_arg" ]; then
|
|
|
|
err 3 'USAGE: run_rc_script file arg'
|
|
|
|
fi
|
|
|
|
|
2002-06-13 22:19:42 +00:00
|
|
|
unset name command command_args command_interpreter \
|
|
|
|
extra_commands pidfile procname \
|
2014-10-02 01:16:30 +00:00
|
|
|
rcvar rcvars rcvars_obsolete required_dirs required_files \
|
2009-09-12 22:19:48 +00:00
|
|
|
required_vars
|
2002-06-13 22:19:42 +00:00
|
|
|
eval unset ${_arg}_cmd ${_arg}_precmd ${_arg}_postcmd
|
|
|
|
|
2001-06-16 07:16:14 +00:00
|
|
|
case "$_file" in
|
2009-05-30 21:41:54 +00:00
|
|
|
/etc/rc.d/*.sh) # no longer allowed in the base
|
|
|
|
warn "Ignoring old-style startup script $_file"
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
2005-12-05 07:04:15 +00:00
|
|
|
*[~#]|*.OLD|*.bak|*.orig|*,v) # scratch file; skip
|
2002-06-13 22:19:42 +00:00
|
|
|
warn "Ignoring scratch file $_file"
|
|
|
|
;;
|
2001-06-16 07:16:14 +00:00
|
|
|
*) # run in subshell
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -x $_file ]; then
|
|
|
|
if [ -n "$rc_fast_and_loose" ]; then
|
2005-05-22 16:22:23 +00:00
|
|
|
set $_arg; . $_file
|
2002-06-13 22:19:42 +00:00
|
|
|
else
|
2012-02-18 00:46:18 +00:00
|
|
|
( trap "echo Script $_file interrupted >&2 ; kill -QUIT $$" 3
|
|
|
|
trap "echo Script $_file interrupted >&2 ; exit 1" 2
|
|
|
|
trap "echo Script $_file running >&2" 29
|
2005-05-22 16:22:23 +00:00
|
|
|
set $_arg; . $_file )
|
2002-06-13 22:19:42 +00:00
|
|
|
fi
|
|
|
|
fi
|
2001-06-16 07:16:14 +00:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
|
|
|
#
|
2006-04-11 08:55:27 +00:00
|
|
|
# load_rc_config name
|
|
|
|
# Source in the configuration file for a given name.
|
2001-06-16 07:16:14 +00:00
|
|
|
#
|
|
|
|
load_rc_config()
|
|
|
|
{
|
2014-08-27 09:19:22 +00:00
|
|
|
local _name _rcvar_val _var _defval _v _msg _new _d
|
2006-04-11 08:55:27 +00:00
|
|
|
_name=$1
|
|
|
|
if [ -z "$_name" ]; then
|
|
|
|
err 3 'USAGE: load_rc_config name'
|
2001-06-16 07:16:14 +00:00
|
|
|
fi
|
|
|
|
|
2011-03-13 16:27:36 +00:00
|
|
|
if ${_rc_conf_loaded:-false}; then
|
|
|
|
:
|
|
|
|
else
|
2002-06-13 22:19:42 +00:00
|
|
|
if [ -r /etc/defaults/rc.conf ]; then
|
|
|
|
debug "Sourcing /etc/defaults/rc.conf"
|
|
|
|
. /etc/defaults/rc.conf
|
|
|
|
source_rc_confs
|
|
|
|
elif [ -r /etc/rc.conf ]; then
|
|
|
|
debug "Sourcing /etc/rc.conf (/etc/defaults/rc.conf doesn't exist)."
|
|
|
|
. /etc/rc.conf
|
|
|
|
fi
|
2004-02-26 12:19:48 +00:00
|
|
|
_rc_conf_loaded=true
|
2002-06-13 22:19:42 +00:00
|
|
|
fi
|
2014-08-27 09:19:22 +00:00
|
|
|
|
|
|
|
for _d in /etc ${local_startup%*/rc.d}; do
|
|
|
|
if [ -f ${_d}/rc.conf.d/"$_name" ]; then
|
|
|
|
debug "Sourcing ${_d}/rc.conf.d/$_name"
|
|
|
|
. ${_d}/rc.conf.d/"$_name"
|
|
|
|
elif [ -d ${_d}/rc.conf.d/"$_name" ] ; then
|
|
|
|
local _rc
|
|
|
|
for _rc in ${_d}/rc.conf.d/"$_name"/* ; do
|
|
|
|
if [ -f "$_rc" ] ; then
|
|
|
|
debug "Sourcing $_rc"
|
|
|
|
. "$_rc"
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
fi
|
|
|
|
done
|
2008-06-19 07:06:11 +00:00
|
|
|
|
2009-09-12 22:19:48 +00:00
|
|
|
# Set defaults if defined.
|
2014-10-02 01:16:30 +00:00
|
|
|
for _var in $rcvar $rcvars; do
|
2011-06-18 11:05:30 +00:00
|
|
|
eval _defval=\$${_var}_defval
|
2009-09-12 22:19:48 +00:00
|
|
|
if [ -n "$_defval" ]; then
|
|
|
|
eval : \${$_var:=\$${_var}_defval}
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
|
|
|
|
# check obsolete rc.conf variables
|
|
|
|
for _var in $rcvars_obsolete; do
|
2011-06-18 11:05:30 +00:00
|
|
|
eval _v=\$$_var
|
|
|
|
eval _msg=\$${_var}_obsolete_msg
|
|
|
|
eval _new=\$${_var}_newvar
|
2009-09-12 22:19:48 +00:00
|
|
|
case $_v in
|
|
|
|
"")
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
if [ -z "$_new" ]; then
|
|
|
|
_msg="Ignored."
|
|
|
|
else
|
|
|
|
eval $_new=\"\$$_var\"
|
|
|
|
if [ -z "$_msg" ]; then
|
|
|
|
_msg="Use \$$_new instead."
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
warn "\$$_var is obsolete. $_msg"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done
|
2002-08-14 05:37:15 +00:00
|
|
|
}
|
2009-12-27 06:25:03 +00:00
|
|
|
|
2006-04-04 10:52:15 +00:00
|
|
|
#
|
2006-04-11 08:55:27 +00:00
|
|
|
# load_rc_config_var name var
|
|
|
|
# Read the rc.conf(5) var for name and set in the
|
2006-04-04 10:52:15 +00:00
|
|
|
# current shell, using load_rc_config in a subshell to prevent
|
|
|
|
# unwanted side effects from other variable assignments.
|
|
|
|
#
|
|
|
|
load_rc_config_var()
|
|
|
|
{
|
|
|
|
if [ $# -ne 2 ]; then
|
2006-04-11 08:55:27 +00:00
|
|
|
err 3 'USAGE: load_rc_config_var name var'
|
2006-04-04 10:52:15 +00:00
|
|
|
fi
|
|
|
|
eval $(eval '(
|
|
|
|
load_rc_config '$1' >/dev/null;
|
|
|
|
if [ -n "${'$2'}" -o "${'$2'-UNSET}" != "UNSET" ]; then
|
|
|
|
echo '$2'=\'\''${'$2'}\'\'';
|
|
|
|
fi
|
|
|
|
)' )
|
|
|
|
}
|
2001-06-16 07:16:14 +00:00
|
|
|
|
|
|
|
#
|
|
|
|
# rc_usage commands
|
|
|
|
# Print a usage string for $0, with `commands' being a list of
|
|
|
|
# valid commands.
|
|
|
|
#
|
|
|
|
rc_usage()
|
|
|
|
{
|
2012-01-12 06:48:11 +00:00
|
|
|
echo -n 1>&2 "Usage: $0 [fast|force|one|quiet]("
|
2001-06-16 07:16:14 +00:00
|
|
|
|
|
|
|
_sep=
|
2004-02-26 12:30:38 +00:00
|
|
|
for _elem; do
|
2001-06-16 07:16:14 +00:00
|
|
|
echo -n 1>&2 "$_sep$_elem"
|
|
|
|
_sep="|"
|
|
|
|
done
|
|
|
|
echo 1>&2 ")"
|
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
|
|
|
|
#
|
|
|
|
# err exitval message
|
|
|
|
# Display message to stderr and log to the syslog, and exit with exitval.
|
|
|
|
#
|
|
|
|
err()
|
|
|
|
{
|
|
|
|
exitval=$1
|
|
|
|
shift
|
|
|
|
|
2002-11-08 17:06:15 +00:00
|
|
|
if [ -x /usr/bin/logger ]; then
|
|
|
|
logger "$0: ERROR: $*"
|
|
|
|
fi
|
|
|
|
echo 1>&2 "$0: ERROR: $*"
|
2001-06-16 07:16:14 +00:00
|
|
|
exit $exitval
|
|
|
|
}
|
|
|
|
|
|
|
|
#
|
|
|
|
# warn message
|
|
|
|
# Display message to stderr and log to the syslog.
|
|
|
|
#
|
|
|
|
warn()
|
|
|
|
{
|
2002-11-08 17:06:15 +00:00
|
|
|
if [ -x /usr/bin/logger ]; then
|
|
|
|
logger "$0: WARNING: $*"
|
|
|
|
fi
|
|
|
|
echo 1>&2 "$0: WARNING: $*"
|
2002-06-13 22:19:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#
|
|
|
|
# info message
|
|
|
|
# Display informational message to stdout and log to syslog.
|
|
|
|
#
|
|
|
|
info()
|
|
|
|
{
|
2003-08-20 06:50:34 +00:00
|
|
|
case ${rc_info} in
|
|
|
|
[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
|
|
|
|
if [ -x /usr/bin/logger ]; then
|
|
|
|
logger "$0: INFO: $*"
|
|
|
|
fi
|
|
|
|
echo "$0: INFO: $*"
|
|
|
|
;;
|
|
|
|
esac
|
2002-06-13 22:19:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#
|
|
|
|
# debug message
|
2002-11-08 17:06:15 +00:00
|
|
|
# If debugging is enabled in rc.conf output message to stderr.
|
2002-06-13 22:19:42 +00:00
|
|
|
# BEWARE that you don't call any subroutine that itself calls this
|
|
|
|
# function.
|
|
|
|
#
|
|
|
|
debug()
|
|
|
|
{
|
|
|
|
case ${rc_debug} in
|
|
|
|
[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
|
2002-11-09 17:34:21 +00:00
|
|
|
if [ -x /usr/bin/logger ]; then
|
2006-10-02 08:20:37 +00:00
|
|
|
logger "$0: DEBUG: $*"
|
2002-11-09 17:34:21 +00:00
|
|
|
fi
|
2005-05-22 16:22:23 +00:00
|
|
|
echo 1>&2 "$0: DEBUG: $*"
|
2002-06-13 22:19:42 +00:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
|
|
|
#
|
|
|
|
# backup_file action file cur backup
|
|
|
|
# Make a backup copy of `file' into `cur', and save the previous
|
|
|
|
# version of `cur' as `backup' or use rcs for archiving.
|
|
|
|
#
|
|
|
|
# This routine checks the value of the backup_uses_rcs variable,
|
|
|
|
# which can be either YES or NO.
|
|
|
|
#
|
|
|
|
# The `action' keyword can be one of the following:
|
|
|
|
#
|
|
|
|
# add `file' is now being backed up (and is possibly
|
|
|
|
# being reentered into the backups system). `cur'
|
|
|
|
# is created and RCS files, if necessary, are
|
|
|
|
# created as well.
|
|
|
|
#
|
|
|
|
# update `file' has changed and needs to be backed up.
|
|
|
|
# If `cur' exists, it is copied to to `back' or
|
|
|
|
# checked into RCS (if the repository file is old),
|
|
|
|
# and then `file' is copied to `cur'. Another RCS
|
|
|
|
# check in done here if RCS is being used.
|
|
|
|
#
|
|
|
|
# remove `file' is no longer being tracked by the backups
|
|
|
|
# system. If RCS is not being used, `cur' is moved
|
|
|
|
# to `back', otherwise an empty file is checked in,
|
|
|
|
# and then `cur' is removed.
|
|
|
|
#
|
|
|
|
#
|
|
|
|
backup_file()
|
|
|
|
{
|
|
|
|
_action=$1
|
|
|
|
_file=$2
|
|
|
|
_cur=$3
|
|
|
|
_back=$4
|
|
|
|
|
|
|
|
if checkyesno backup_uses_rcs; then
|
|
|
|
_msg0="backup archive"
|
|
|
|
_msg1="update"
|
|
|
|
|
|
|
|
# ensure that history file is not locked
|
|
|
|
if [ -f $_cur,v ]; then
|
|
|
|
rcs -q -u -U -M $_cur
|
|
|
|
fi
|
|
|
|
|
|
|
|
# ensure after switching to rcs that the
|
|
|
|
# current backup is not lost
|
|
|
|
if [ -f $_cur ]; then
|
|
|
|
# no archive, or current newer than archive
|
|
|
|
if [ ! -f $_cur,v -o $_cur -nt $_cur,v ]; then
|
|
|
|
ci -q -f -u -t-"$_msg0" -m"$_msg1" $_cur
|
|
|
|
rcs -q -kb -U $_cur
|
|
|
|
co -q -f -u $_cur
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
case $_action in
|
|
|
|
add|update)
|
|
|
|
cp -p $_file $_cur
|
|
|
|
ci -q -f -u -t-"$_msg0" -m"$_msg1" $_cur
|
|
|
|
rcs -q -kb -U $_cur
|
|
|
|
co -q -f -u $_cur
|
|
|
|
chown root:wheel $_cur $_cur,v
|
|
|
|
;;
|
|
|
|
remove)
|
|
|
|
cp /dev/null $_cur
|
|
|
|
ci -q -f -u -t-"$_msg0" -m"$_msg1" $_cur
|
|
|
|
rcs -q -kb -U $_cur
|
|
|
|
chown root:wheel $_cur $_cur,v
|
|
|
|
rm $_cur
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
else
|
|
|
|
case $_action in
|
|
|
|
add|update)
|
|
|
|
if [ -f $_cur ]; then
|
|
|
|
cp -p $_cur $_back
|
|
|
|
fi
|
|
|
|
cp -p $_file $_cur
|
|
|
|
chown root:wheel $_cur
|
|
|
|
;;
|
|
|
|
remove)
|
|
|
|
mv -f $_cur $_back
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
fi
|
2001-06-16 07:16:14 +00:00
|
|
|
}
|
2003-08-20 06:15:18 +00:00
|
|
|
|
2003-12-09 08:51:11 +00:00
|
|
|
# make_symlink src link
|
|
|
|
# Make a symbolic link 'link' to src from basedir. If the
|
|
|
|
# directory in which link is to be created does not exist
|
|
|
|
# a warning will be displayed and an error will be returned.
|
2012-01-07 16:10:32 +00:00
|
|
|
# Returns 0 on success, 1 otherwise.
|
2003-08-20 06:15:18 +00:00
|
|
|
#
|
2003-12-09 08:51:11 +00:00
|
|
|
make_symlink()
|
2003-08-20 06:15:18 +00:00
|
|
|
{
|
2003-12-09 08:51:11 +00:00
|
|
|
local src link linkdir _me
|
|
|
|
src="$1"
|
|
|
|
link="$2"
|
|
|
|
linkdir="`dirname $link`"
|
|
|
|
_me="make_symlink()"
|
|
|
|
|
|
|
|
if [ -z "$src" -o -z "$link" ]; then
|
|
|
|
warn "$_me: requires two arguments."
|
2003-08-20 06:15:18 +00:00
|
|
|
return 1
|
|
|
|
fi
|
2003-12-09 08:51:11 +00:00
|
|
|
if [ ! -d "$linkdir" ]; then
|
2006-07-25 17:14:38 +00:00
|
|
|
warn "$_me: the directory $linkdir does not exist."
|
2003-08-20 06:15:18 +00:00
|
|
|
return 1
|
|
|
|
fi
|
2005-05-22 16:22:23 +00:00
|
|
|
if ! ln -sf $src $link; then
|
2003-12-09 08:51:11 +00:00
|
|
|
warn "$_me: unable to make a symbolic link from $link to $src"
|
2003-08-20 06:15:18 +00:00
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
# devfs_rulesets_from_file file
|
|
|
|
# Reads a set of devfs commands from file, and creates
|
|
|
|
# the specified rulesets with their rules. Returns non-zero
|
|
|
|
# if there was an error.
|
|
|
|
#
|
|
|
|
devfs_rulesets_from_file()
|
|
|
|
{
|
2013-03-28 08:13:52 +00:00
|
|
|
local file _err _me _opts
|
2003-08-20 06:15:18 +00:00
|
|
|
file="$1"
|
|
|
|
_me="devfs_rulesets_from_file"
|
|
|
|
_err=0
|
|
|
|
|
|
|
|
if [ -z "$file" ]; then
|
|
|
|
warn "$_me: you must specify a file"
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
if [ ! -e "$file" ]; then
|
|
|
|
debug "$_me: no such file ($file)"
|
|
|
|
return 0
|
|
|
|
fi
|
2013-03-28 08:13:52 +00:00
|
|
|
|
|
|
|
# Disable globbing so that the rule patterns are not expanded
|
|
|
|
# by accident with matching filesystem entries.
|
|
|
|
_opts=$-; set -f
|
|
|
|
|
2003-08-20 06:15:18 +00:00
|
|
|
debug "reading rulesets from file ($file)"
|
|
|
|
{ while read line
|
|
|
|
do
|
|
|
|
case $line in
|
|
|
|
\#*)
|
|
|
|
continue
|
|
|
|
;;
|
|
|
|
\[*\]*)
|
|
|
|
rulenum=`expr "$line" : "\[.*=\([0-9]*\)\]"`
|
|
|
|
if [ -z "$rulenum" ]; then
|
|
|
|
warn "$_me: cannot extract rule number ($line)"
|
|
|
|
_err=1
|
|
|
|
break
|
|
|
|
fi
|
|
|
|
rulename=`expr "$line" : "\[\(.*\)=[0-9]*\]"`
|
|
|
|
if [ -z "$rulename" ]; then
|
|
|
|
warn "$_me: cannot extract rule name ($line)"
|
|
|
|
_err=1
|
|
|
|
break;
|
|
|
|
fi
|
|
|
|
eval $rulename=\$rulenum
|
|
|
|
debug "found ruleset: $rulename=$rulenum"
|
2005-05-22 16:22:23 +00:00
|
|
|
if ! /sbin/devfs rule -s $rulenum delset; then
|
2003-08-20 06:15:18 +00:00
|
|
|
_err=1
|
|
|
|
break
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
rulecmd="${line%%"\#*"}"
|
|
|
|
# evaluate the command incase it includes
|
|
|
|
# other rules
|
|
|
|
if [ -n "$rulecmd" ]; then
|
|
|
|
debug "adding rule ($rulecmd)"
|
|
|
|
if ! eval /sbin/devfs rule -s $rulenum $rulecmd
|
|
|
|
then
|
|
|
|
_err=1
|
|
|
|
break
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
if [ $_err -ne 0 ]; then
|
|
|
|
debug "error in $_me"
|
|
|
|
break
|
|
|
|
fi
|
|
|
|
done } < $file
|
2013-03-28 08:13:52 +00:00
|
|
|
case $_opts in *f*) ;; *) set +f ;; esac
|
2003-08-20 06:15:18 +00:00
|
|
|
return $_err
|
|
|
|
}
|
|
|
|
|
|
|
|
# devfs_init_rulesets
|
|
|
|
# Initializes rulesets from configuration files. Returns
|
|
|
|
# non-zero if there was an error.
|
|
|
|
#
|
|
|
|
devfs_init_rulesets()
|
|
|
|
{
|
|
|
|
local file _me
|
|
|
|
_me="devfs_init_rulesets"
|
|
|
|
|
|
|
|
# Go through this only once
|
|
|
|
if [ -n "$devfs_rulesets_init" ]; then
|
|
|
|
debug "$_me: devfs rulesets already initialized"
|
|
|
|
return
|
|
|
|
fi
|
2005-05-22 16:22:23 +00:00
|
|
|
for file in $devfs_rulesets; do
|
2011-01-07 10:59:22 +00:00
|
|
|
if ! devfs_rulesets_from_file $file; then
|
|
|
|
warn "$_me: could not read rules from $file"
|
|
|
|
return 1
|
|
|
|
fi
|
2003-08-20 06:15:18 +00:00
|
|
|
done
|
|
|
|
devfs_rulesets_init=1
|
|
|
|
debug "$_me: devfs rulesets initialized"
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
# devfs_set_ruleset ruleset [dir]
|
2005-10-24 08:53:21 +00:00
|
|
|
# Sets the default ruleset of dir to ruleset. The ruleset argument
|
2003-08-20 06:15:18 +00:00
|
|
|
# must be a ruleset name as specified in devfs.rules(5) file.
|
|
|
|
# Returns non-zero if it could not set it successfully.
|
|
|
|
#
|
|
|
|
devfs_set_ruleset()
|
|
|
|
{
|
|
|
|
local devdir rs _me
|
|
|
|
[ -n "$1" ] && eval rs=\$$1 || rs=
|
|
|
|
[ -n "$2" ] && devdir="-m "$2"" || devdir=
|
|
|
|
_me="devfs_set_ruleset"
|
|
|
|
|
|
|
|
if [ -z "$rs" ]; then
|
|
|
|
warn "$_me: you must specify a ruleset number"
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
debug "$_me: setting ruleset ($rs) on mount-point (${devdir#-m })"
|
2005-05-22 16:22:23 +00:00
|
|
|
if ! /sbin/devfs $devdir ruleset $rs; then
|
2003-08-20 06:15:18 +00:00
|
|
|
warn "$_me: unable to set ruleset $rs to ${devdir#-m }"
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
# devfs_apply_ruleset ruleset [dir]
|
|
|
|
# Apply ruleset number $ruleset to the devfs mountpoint $dir.
|
|
|
|
# The ruleset argument must be a ruleset name as specified
|
|
|
|
# in a devfs.rules(5) file. Returns 0 on success or non-zero
|
|
|
|
# if it could not apply the ruleset.
|
|
|
|
#
|
|
|
|
devfs_apply_ruleset()
|
|
|
|
{
|
|
|
|
local devdir rs _me
|
|
|
|
[ -n "$1" ] && eval rs=\$$1 || rs=
|
|
|
|
[ -n "$2" ] && devdir="-m "$2"" || devdir=
|
|
|
|
_me="devfs_apply_ruleset"
|
|
|
|
|
|
|
|
if [ -z "$rs" ]; then
|
|
|
|
warn "$_me: you must specify a ruleset"
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
debug "$_me: applying ruleset ($rs) to mount-point (${devdir#-m })"
|
2005-05-22 16:22:23 +00:00
|
|
|
if ! /sbin/devfs $devdir rule -s $rs applyset; then
|
2003-08-20 06:15:18 +00:00
|
|
|
warn "$_me: unable to apply ruleset $rs to ${devdir#-m }"
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
# devfs_domount dir [ruleset]
|
|
|
|
# Mount devfs on dir. If ruleset is specified it is set
|
|
|
|
# on the mount-point. It must also be a ruleset name as specified
|
|
|
|
# in a devfs.rules(5) file. Returns 0 on success.
|
|
|
|
#
|
|
|
|
devfs_domount()
|
|
|
|
{
|
|
|
|
local devdir rs _me
|
|
|
|
devdir="$1"
|
|
|
|
[ -n "$2" ] && rs=$2 || rs=
|
|
|
|
_me="devfs_domount()"
|
|
|
|
|
|
|
|
if [ -z "$devdir" ]; then
|
|
|
|
warn "$_me: you must specify a mount-point"
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
debug "$_me: mount-point is ($devdir), ruleset is ($rs)"
|
2005-05-22 16:22:23 +00:00
|
|
|
if ! mount -t devfs dev "$devdir"; then
|
2003-08-20 06:15:18 +00:00
|
|
|
warn "$_me: Unable to mount devfs on $devdir"
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
if [ -n "$rs" ]; then
|
|
|
|
devfs_init_rulesets
|
|
|
|
devfs_set_ruleset $rs $devdir
|
2004-01-21 16:36:17 +00:00
|
|
|
devfs -m $devdir rule applyset
|
2003-08-20 06:15:18 +00:00
|
|
|
fi
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2004-03-23 23:22:35 +00:00
|
|
|
# Provide a function for normalizing the mounting of memory
|
|
|
|
# filesystems. This should allow the rest of the code here to remain
|
|
|
|
# as close as possible between 5-current and 4-stable.
|
|
|
|
# $1 = size
|
|
|
|
# $2 = mount point
|
2004-11-09 10:03:17 +00:00
|
|
|
# $3 = (optional) extra mdmfs flags
|
2005-05-22 16:22:23 +00:00
|
|
|
mount_md()
|
|
|
|
{
|
2004-03-23 23:22:35 +00:00
|
|
|
if [ -n "$3" ]; then
|
2004-11-09 10:03:17 +00:00
|
|
|
flags="$3"
|
2004-03-23 23:22:35 +00:00
|
|
|
fi
|
2005-08-24 16:25:47 +00:00
|
|
|
/sbin/mdmfs $flags -s $1 md $2
|
2004-03-23 23:22:35 +00:00
|
|
|
}
|
2004-07-04 07:21:18 +00:00
|
|
|
|
2006-06-21 09:42:55 +00:00
|
|
|
# Code common to scripts that need to load a kernel module
|
|
|
|
# if it isn't in the kernel yet. Syntax:
|
2006-07-25 17:10:35 +00:00
|
|
|
# load_kld [-e regex] [-m module] file
|
2006-06-21 09:42:55 +00:00
|
|
|
# where -e or -m chooses the way to check if the module
|
|
|
|
# is already loaded:
|
2006-07-25 17:10:35 +00:00
|
|
|
# regex is egrep'd in the output from `kldstat -v',
|
|
|
|
# module is passed to `kldstat -m'.
|
|
|
|
# The default way is as though `-m file' were specified.
|
2006-06-21 09:42:55 +00:00
|
|
|
load_kld()
|
|
|
|
{
|
|
|
|
local _loaded _mod _opt _re
|
|
|
|
|
|
|
|
while getopts "e:m:" _opt; do
|
|
|
|
case "$_opt" in
|
|
|
|
e) _re="$OPTARG" ;;
|
|
|
|
m) _mod="$OPTARG" ;;
|
2006-07-25 17:10:35 +00:00
|
|
|
*) err 3 'USAGE: load_kld [-e regex] [-m module] file' ;;
|
2006-06-21 09:42:55 +00:00
|
|
|
esac
|
|
|
|
done
|
|
|
|
shift $(($OPTIND - 1))
|
2006-07-25 17:10:35 +00:00
|
|
|
if [ $# -ne 1 ]; then
|
|
|
|
err 3 'USAGE: load_kld [-e regex] [-m module] file'
|
|
|
|
fi
|
2006-06-21 09:42:55 +00:00
|
|
|
_mod=${_mod:-$1}
|
|
|
|
_loaded=false
|
|
|
|
if [ -n "$_re" ]; then
|
|
|
|
if kldstat -v | egrep -q -e "$_re"; then
|
|
|
|
_loaded=true
|
|
|
|
fi
|
|
|
|
else
|
|
|
|
if kldstat -q -m "$_mod"; then
|
|
|
|
_loaded=true
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
if ! $_loaded; then
|
|
|
|
if ! kldload "$1"; then
|
|
|
|
warn "Unable to load kernel module $1"
|
|
|
|
return 1
|
2006-07-25 17:10:35 +00:00
|
|
|
else
|
|
|
|
info "$1 kernel module loaded."
|
2006-06-21 09:42:55 +00:00
|
|
|
fi
|
2006-07-25 17:10:35 +00:00
|
|
|
else
|
|
|
|
debug "load_kld: $1 kernel module already loaded."
|
2006-06-21 09:42:55 +00:00
|
|
|
fi
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2014-04-07 22:40:29 +00:00
|
|
|
# ltr str src dst [var]
|
2005-08-14 17:28:15 +00:00
|
|
|
# Change every $src in $str to $dst.
|
|
|
|
# Useful when /usr is not yet mounted and we cannot use tr(1), sed(1) nor
|
2014-04-07 22:40:29 +00:00
|
|
|
# awk(1). If var is non-NULL, set it to the result.
|
2005-08-14 17:28:15 +00:00
|
|
|
ltr()
|
|
|
|
{
|
2014-04-07 22:40:29 +00:00
|
|
|
local _str _src _dst _out _com _var
|
|
|
|
_str="$1"
|
|
|
|
_src="$2"
|
|
|
|
_dst="$3"
|
|
|
|
_var="$4"
|
2005-08-14 17:28:15 +00:00
|
|
|
_out=""
|
|
|
|
|
2014-04-07 22:40:29 +00:00
|
|
|
local IFS="${_src}"
|
2005-08-14 17:28:15 +00:00
|
|
|
for _com in ${_str}; do
|
|
|
|
if [ -z "${_out}" ]; then
|
|
|
|
_out="${_com}"
|
|
|
|
else
|
|
|
|
_out="${_out}${_dst}${_com}"
|
|
|
|
fi
|
|
|
|
done
|
2014-04-07 22:40:29 +00:00
|
|
|
if [ -n "${_var}" ]; then
|
|
|
|
setvar "${_var}" "${_out}"
|
|
|
|
else
|
|
|
|
echo "${_out}"
|
|
|
|
fi
|
2005-08-14 17:28:15 +00:00
|
|
|
}
|
|
|
|
|
2005-08-14 18:02:22 +00:00
|
|
|
# Creates a list of providers for GELI encryption.
|
|
|
|
geli_make_list()
|
|
|
|
{
|
|
|
|
local devices devices2
|
|
|
|
local provider mountpoint type options rest
|
|
|
|
|
|
|
|
# Create list of GELI providers from fstab.
|
|
|
|
while read provider mountpoint type options rest ; do
|
2006-02-12 12:57:07 +00:00
|
|
|
case ":${options}" in
|
|
|
|
:*noauto*)
|
|
|
|
noauto=yes
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
noauto=no
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
2005-08-14 18:02:22 +00:00
|
|
|
case ":${provider}" in
|
|
|
|
:#*)
|
|
|
|
continue
|
|
|
|
;;
|
|
|
|
*.eli)
|
|
|
|
# Skip swap devices.
|
2006-02-12 12:57:07 +00:00
|
|
|
if [ "${type}" = "swap" -o "${options}" = "sw" -o "${noauto}" = "yes" ]; then
|
2005-08-14 18:02:22 +00:00
|
|
|
continue
|
|
|
|
fi
|
|
|
|
devices="${devices} ${provider}"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done < /etc/fstab
|
|
|
|
|
|
|
|
# Append providers from geli_devices.
|
|
|
|
devices="${devices} ${geli_devices}"
|
|
|
|
|
|
|
|
for provider in ${devices}; do
|
|
|
|
provider=${provider%.eli}
|
|
|
|
provider=${provider#/dev/}
|
|
|
|
devices2="${devices2} ${provider}"
|
|
|
|
done
|
|
|
|
|
|
|
|
echo ${devices2}
|
|
|
|
}
|
|
|
|
|
2005-12-02 20:06:07 +00:00
|
|
|
# Find scripts in local_startup directories that use the old syntax
|
|
|
|
#
|
2012-07-13 06:46:09 +00:00
|
|
|
find_local_scripts_old() {
|
2005-12-02 20:06:07 +00:00
|
|
|
zlist=''
|
|
|
|
slist=''
|
|
|
|
for dir in ${local_startup}; do
|
|
|
|
if [ -d "${dir}" ]; then
|
|
|
|
for file in ${dir}/[0-9]*.sh; do
|
|
|
|
grep '^# PROVIDE:' $file >/dev/null 2>&1 &&
|
|
|
|
continue
|
|
|
|
zlist="$zlist $file"
|
|
|
|
done
|
2011-11-08 23:02:32 +00:00
|
|
|
for file in ${dir}/[!0-9]*.sh; do
|
2005-12-02 20:06:07 +00:00
|
|
|
grep '^# PROVIDE:' $file >/dev/null 2>&1 &&
|
|
|
|
continue
|
|
|
|
slist="$slist $file"
|
|
|
|
done
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2012-07-13 06:46:09 +00:00
|
|
|
find_local_scripts_new() {
|
2005-12-02 20:06:07 +00:00
|
|
|
local_rc=''
|
|
|
|
for dir in ${local_startup}; do
|
|
|
|
if [ -d "${dir}" ]; then
|
2005-12-10 20:19:08 +00:00
|
|
|
for file in `grep -l '^# PROVIDE:' ${dir}/* 2>/dev/null`; do
|
2005-12-02 20:06:07 +00:00
|
|
|
case "$file" in
|
|
|
|
*.sample) ;;
|
|
|
|
*) if [ -x "$file" ]; then
|
|
|
|
local_rc="${local_rc} ${file}"
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
MFp4:
Implement the checks for required_* objects as two functions, one
to be run before precmd and the other after it. They get the current
rc command as an argument so they can choose what requirement tests
to perform. As of now, only "start" needs such tests.
Implement a new requirement variable, required_modules. It can
list kernel modules that need to be loaded after start_precmd
indicated success. Each name in the list can be just "file", or
"file:module", or "file~regex". This will allow us to remove a lot
of duplicated code from rc.d scripts.
Perform the checks not only for the default start method, but for
any method. This allows for more flexibility and fixes a few rc.d
scripts (namely newsyslog, pf, sendmail) that rely on a required_*
variable while providing a non-default start method.
To be able to call the new check_required* functions naturally,
remove lots of crufty duplicated code pieces from run_rc_command
and replace each of them by a call to the helper function providing
a single corrected instance of the respective code snippet. Now
run_rc_command isn't as scary as it used to be, and it even appears
to have quite a nice logic that was obscured by the old crufty code.
In the default handler for restart, run start from a subshell to
protect global varibles, e.g., _postcmd, from modification by the
start handler. This enables using restart_postcmd. [x]
PR: conf/98734 [x]
Submitted by: Rick van der Zwet <rick@wzoeterwoude.net> [x]
Reviewed by: freebsd-rc (silence for an older version)
MFC after: 1 month
2006-12-27 13:15:33 +00:00
|
|
|
# check_required_{before|after} command
|
|
|
|
# Check for things required by the command before and after its precmd,
|
|
|
|
# respectively. The two separate functions are needed because some
|
|
|
|
# conditions should prevent precmd from being run while other things
|
|
|
|
# depend on precmd having already been run.
|
|
|
|
#
|
|
|
|
check_required_before()
|
|
|
|
{
|
|
|
|
local _f
|
|
|
|
|
|
|
|
case "$1" in
|
|
|
|
start)
|
|
|
|
for _f in $required_vars; do
|
|
|
|
if ! checkyesno $_f; then
|
|
|
|
warn "\$${_f} is not enabled."
|
|
|
|
if [ -z "$rc_force" ]; then
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
|
|
|
|
for _f in $required_dirs; do
|
|
|
|
if [ ! -d "${_f}/." ]; then
|
|
|
|
warn "${_f} is not a directory."
|
|
|
|
if [ -z "$rc_force" ]; then
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
|
|
|
|
for _f in $required_files; do
|
|
|
|
if [ ! -r "${_f}" ]; then
|
|
|
|
warn "${_f} is not readable."
|
|
|
|
if [ -z "$rc_force" ]; then
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
check_required_after()
|
|
|
|
{
|
|
|
|
local _f _args
|
|
|
|
|
|
|
|
case "$1" in
|
|
|
|
start)
|
|
|
|
for _f in $required_modules; do
|
|
|
|
case "${_f}" in
|
|
|
|
*~*) _args="-e ${_f#*~} ${_f%%~*}" ;;
|
|
|
|
*:*) _args="-m ${_f#*:} ${_f%%:*}" ;;
|
|
|
|
*) _args="${_f}" ;;
|
|
|
|
esac
|
|
|
|
if ! load_kld ${_args}; then
|
|
|
|
if [ -z "$rc_force" ]; then
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2014-09-13 18:54:15 +00:00
|
|
|
# check_jail mib
|
|
|
|
# Return true if security.jail.$mib exists and set to 1.
|
|
|
|
|
|
|
|
check_jail()
|
|
|
|
{
|
|
|
|
local _mib _v
|
|
|
|
|
|
|
|
_mib=$1
|
|
|
|
if _v=$(${SYSCTL_N} "security.jail.$_mib" 2> /dev/null); then
|
|
|
|
case $_v in
|
|
|
|
1) return 0;;
|
|
|
|
esac
|
|
|
|
fi
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
|
2011-06-11 21:40:37 +00:00
|
|
|
# check_kern_features mib
|
|
|
|
# Return existence of kern.features.* sysctl MIB as true or
|
|
|
|
# false. The result will be cached in $_rc_cache_kern_features_
|
|
|
|
# namespace. "0" means the kern.features.X exists.
|
|
|
|
|
|
|
|
check_kern_features()
|
|
|
|
{
|
|
|
|
local _v
|
|
|
|
|
|
|
|
[ -n "$1" ] || return 1;
|
2011-06-19 11:42:48 +00:00
|
|
|
eval _v=\$_rc_cache_kern_features_$1
|
2011-06-11 21:40:37 +00:00
|
|
|
[ -n "$_v" ] && return "$_v";
|
|
|
|
|
|
|
|
if ${SYSCTL_N} kern.features.$1 > /dev/null 2>&1; then
|
|
|
|
eval _rc_cache_kern_features_$1=0
|
|
|
|
return 0
|
|
|
|
else
|
|
|
|
eval _rc_cache_kern_features_$1=1
|
|
|
|
return 1
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2012-11-17 18:11:10 +00:00
|
|
|
# check_namevarlist var
|
|
|
|
# Return "0" if ${name}_var is reserved in rc.subr.
|
|
|
|
|
|
|
|
_rc_namevarlist="program chroot chdir flags fib nice user group groups"
|
|
|
|
check_namevarlist()
|
|
|
|
{
|
|
|
|
local _v
|
|
|
|
|
|
|
|
for _v in $_rc_namevarlist; do
|
|
|
|
case $1 in
|
|
|
|
$_v) return 0 ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
|
2009-09-12 22:19:48 +00:00
|
|
|
# _echoonce var msg mode
|
|
|
|
# mode=0: Echo $msg if ${$var} is empty.
|
|
|
|
# After doing echo, a string is set to ${$var}.
|
|
|
|
#
|
|
|
|
# mode=1: Echo $msg if ${$var} is a string with non-zero length.
|
|
|
|
#
|
|
|
|
_echoonce()
|
|
|
|
{
|
|
|
|
local _var _msg _mode
|
2011-06-18 11:05:30 +00:00
|
|
|
eval _var=\$$1
|
2009-09-12 22:19:48 +00:00
|
|
|
_msg=$2
|
|
|
|
_mode=$3
|
|
|
|
|
|
|
|
case $_mode in
|
|
|
|
1) [ -n "$_var" ] && echo "$_msg" ;;
|
|
|
|
*) [ -z "$_var" ] && echo -n "$_msg" && eval "$1=finished" ;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2011-06-19 15:23:32 +00:00
|
|
|
fi # [ -z "${_rc_subr_loaded}" ]
|
|
|
|
|
2006-04-18 15:16:55 +00:00
|
|
|
_rc_subr_loaded=:
|