xref: /freebsd/libexec/rc/rc.subr (revision 6ba2210ee039f2f12878c217bcf058e9c8b26b29)
1# $NetBSD: rc.subr,v 1.67 2006/10/07 11:25:15 elad Exp $
2# $FreeBSD$
3#
4# Copyright (c) 1997-2004 The NetBSD Foundation, Inc.
5# All rights reserved.
6#
7# This code is derived from software contributed to The NetBSD Foundation
8# by Luke Mewburn.
9#
10# Redistribution and use in source and binary forms, with or without
11# modification, are permitted provided that the following conditions
12# are met:
13# 1. Redistributions of source code must retain the above copyright
14#    notice, this list of conditions and the following disclaimer.
15# 2. Redistributions in binary form must reproduce the above copyright
16#    notice, this list of conditions and the following disclaimer in the
17#    documentation and/or other materials provided with the distribution.
18#
19# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29# POSSIBILITY OF SUCH DAMAGE.
30#
31# rc.subr
32#	functions used by various rc scripts
33#
34
35: ${RC_PID:=$$}; export RC_PID
36
37#
38#	Operating System dependent/independent variables
39#
40
41if [ -n "${_rc_subr_loaded}" ]; then
42	return
43fi
44
45_rc_subr_loaded="YES"
46
47SYSCTL="/sbin/sysctl"
48SYSCTL_N="${SYSCTL} -n"
49SYSCTL_W="${SYSCTL}"
50PROTECT="/usr/bin/protect"
51ID="/usr/bin/id"
52IDCMD="if [ -x $ID ]; then $ID -un; fi"
53PS="/bin/ps -ww"
54JID=0
55# rc_service provides the path to the service script that we are executing.
56# This is not being set here in an execution context, necessarily, so it's
57# really just a reasonable guess, and it will get overwritten later if
58# we are executing from some other means than direct execution by service(8)
59# or manual invocation of the service script.  The prime example of this is
60# during system startup, all rc scripts will be invoked via /etc/rc, so
61# run_rc_script will overwrite rc_service with the file being sourced.
62rc_service="$0"
63
64#
65#	functions
66#	---------
67
68# list_vars pattern
69#	List variables matching glob pattern.
70#
71list_vars()
72{
73	# Localize 'set' option below.
74	local -
75	local IFS=$'\n' line varname
76
77	# Disable path expansion in unquoted 'for' parameters below.
78	set -o noglob
79
80	for line in $(set); do
81		varname="${line%%=*}"
82
83		case "$varname" in
84		"$line"|*[!a-zA-Z0-9_]*)
85			continue
86			;;
87		$1)
88			echo $varname
89			;;
90		esac
91	done
92}
93
94# set_rcvar [var] [defval] [desc]
95#
96#	Echo or define a rc.conf(5) variable name.  Global variable
97#	$rcvars is used.
98#
99#	If no argument is specified, echo "${name}_enable".
100#
101#	If only a var is specified, echo "${var}_enable".
102#
103#	If var and defval are specified, the ${var} is defined as
104#	rc.conf(5) variable and the default value is ${defvar}.  An
105#	optional argument $desc can also be specified to add a
106#	description for that.
107#
108set_rcvar()
109{
110	local _var
111
112	case $# in
113	0)	echo ${name}_enable ;;
114	1)	echo ${1}_enable ;;
115	*)
116		debug "set_rcvar: \$$1=$2 is added" \
117		    " as a rc.conf(5) variable."
118		_var=$1
119		rcvars="${rcvars# } $_var"
120		eval ${_var}_defval=\"$2\"
121		shift 2
122		eval ${_var}_desc=\"$*\"
123	;;
124	esac
125}
126
127# set_rcvar_obsolete oldvar [newvar] [msg]
128#	Define obsolete variable.
129#	Global variable $rcvars_obsolete is used.
130#
131set_rcvar_obsolete()
132{
133	local _var
134	_var=$1
135	debug "set_rcvar_obsolete: \$$1(old) -> \$$2(new) is defined"
136
137	rcvars_obsolete="${rcvars_obsolete# } $1"
138	eval ${1}_newvar=\"$2\"
139	shift 2
140	eval ${_var}_obsolete_msg=\"$*\"
141}
142
143#
144# force_depend script [rcvar]
145#	Force a service to start. Intended for use by services
146#	to resolve dependency issues.
147#	$1 - filename of script, in /etc/rc.d, to run
148#	$2 - name of the script's rcvar (minus the _enable)
149#
150force_depend()
151{
152	local _depend _dep_rcvar
153
154	_depend="$1"
155	_dep_rcvar="${2:-$1}_enable"
156
157	[ -n "$rc_fast" ] && ! checkyesno always_force_depends &&
158	    checkyesno $_dep_rcvar && return 0
159
160	/etc/rc.d/${_depend} forcestatus >/dev/null 2>&1 && return 0
161
162	info "${name} depends on ${_depend}, which will be forced to start."
163	if ! /etc/rc.d/${_depend} forcestart; then
164		warn "Unable to force ${_depend}. It may already be running."
165		return 1
166	fi
167}
168
169#
170# checkyesno var
171#	Test $1 variable, and warn if not set to YES or NO.
172#	Return 0 if it's "yes" (et al), nonzero otherwise.
173#
174checkyesno()
175{
176	eval _value=\$${1}
177	debug "checkyesno: $1 is set to $_value."
178	case $_value in
179
180		#	"yes", "true", "on", or "1"
181	[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
182		return 0
183		;;
184
185		#	"no", "false", "off", or "0"
186	[Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|[Oo][Ff][Ff]|0)
187		return 1
188		;;
189	*)
190		warn "\$${1} is not set properly - see rc.conf(5)."
191		return 1
192		;;
193	esac
194}
195
196#
197# reverse_list list
198#	print the list in reverse order
199#
200reverse_list()
201{
202	_revlist=
203	for _revfile; do
204		_revlist="$_revfile $_revlist"
205	done
206	echo $_revlist
207}
208
209# stop_boot always
210#	If booting directly to multiuser or $always is enabled,
211#	send SIGTERM to the parent (/etc/rc) to abort the boot.
212#	Otherwise just exit.
213#
214stop_boot()
215{
216	local always
217
218	case $1 in
219		#	"yes", "true", "on", or "1"
220        [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
221		always=true
222		;;
223	*)
224		always=false
225		;;
226	esac
227	if [ "$autoboot" = yes -o "$always" = true ]; then
228		echo "ERROR: ABORTING BOOT (sending SIGTERM to parent)!"
229		kill -TERM ${RC_PID}
230	fi
231	exit 1
232}
233
234#
235# mount_critical_filesystems type
236#	Go through the list of critical filesystems as provided in
237#	the rc.conf(5) variable $critical_filesystems_${type}, checking
238#	each one to see if it is mounted, and if it is not, mounting it.
239#
240mount_critical_filesystems()
241{
242	eval _fslist=\$critical_filesystems_${1}
243	for _fs in $_fslist; do
244		mount | (
245			_ismounted=false
246			while read what _on on _type type; do
247				if [ $on = $_fs ]; then
248					_ismounted=true
249				fi
250			done
251			if $_ismounted; then
252				:
253			else
254				mount $_fs >/dev/null 2>&1
255			fi
256		)
257	done
258}
259
260#
261# check_pidfile pidfile procname [interpreter]
262#	Parses the first line of pidfile for a PID, and ensures
263#	that the process is running and matches procname.
264#	Prints the matching PID upon success, nothing otherwise.
265#	interpreter is optional; see _find_processes() for details.
266#
267check_pidfile()
268{
269	_pidfile=$1
270	_procname=$2
271	_interpreter=$3
272	if [ -z "$_pidfile" -o -z "$_procname" ]; then
273		err 3 'USAGE: check_pidfile pidfile procname [interpreter]'
274	fi
275	if [ ! -f $_pidfile ]; then
276		debug "pid file ($_pidfile): not readable."
277		return
278	fi
279	read _pid _junk < $_pidfile
280	if [ -z "$_pid" ]; then
281		debug "pid file ($_pidfile): no pid in file."
282		return
283	fi
284	_find_processes $_procname ${_interpreter:-.} '-p '"$_pid"
285}
286
287#
288# check_process procname [interpreter]
289#	Ensures that a process (or processes) named procname is running.
290#	Prints a list of matching PIDs.
291#	interpreter is optional; see _find_processes() for details.
292#
293check_process()
294{
295	_procname=$1
296	_interpreter=$2
297	if [ -z "$_procname" ]; then
298		err 3 'USAGE: check_process procname [interpreter]'
299	fi
300	_find_processes $_procname ${_interpreter:-.} '-ax'
301}
302
303#
304# _find_processes procname interpreter psargs
305#	Search for procname in the output of ps generated by psargs.
306#	Prints the PIDs of any matching processes, space separated.
307#
308#	If interpreter == ".", check the following variations of procname
309#	against the first word of each command:
310#		procname
311#		`basename procname`
312#		`basename procname` + ":"
313#		"(" + `basename procname` + ")"
314#		"[" + `basename procname` + "]"
315#
316#	If interpreter != ".", read the first line of procname, remove the
317#	leading #!, normalise whitespace, append procname, and attempt to
318#	match that against each command, either as is, or with extra words
319#	at the end.  As an alternative, to deal with interpreted daemons
320#	using perl, the basename of the interpreter plus a colon is also
321#	tried as the prefix to procname.
322#
323_find_processes()
324{
325	if [ $# -ne 3 ]; then
326		err 3 'USAGE: _find_processes procname interpreter psargs'
327	fi
328	_procname=$1
329	_interpreter=$2
330	_psargs=$3
331
332	_pref=
333	if [ $_interpreter != "." ]; then	# an interpreted script
334		_script="${_chroot}${_chroot:+/}$_procname"
335		if [ -r "$_script" ]; then
336			read _interp < $_script	# read interpreter name
337			case "$_interp" in
338			\#!*)
339				_interp=${_interp#\#!}	# strip #!
340				set -- $_interp
341				case $1 in
342				*/bin/env)
343					shift	# drop env to get real name
344					;;
345				esac
346				if [ $_interpreter != $1 ]; then
347					warn "\$command_interpreter $_interpreter != $1"
348				fi
349				;;
350			*)
351				warn "no shebang line in $_script"
352				set -- $_interpreter
353				;;
354			esac
355		else
356			warn "cannot read shebang line from $_script"
357			set -- $_interpreter
358		fi
359		_interp="$* $_procname"		# cleanup spaces, add _procname
360		_interpbn=${1##*/}
361		_fp_args='_argv'
362		_fp_match='case "$_argv" in
363		    ${_interp}|"${_interp} "*|"[${_interpbn}]"|"${_interpbn}: ${_procname}"*)'
364	else					# a normal daemon
365		_procnamebn=${_procname##*/}
366		_fp_args='_arg0 _argv'
367		_fp_match='case "$_arg0" in
368		    $_procname|$_procnamebn|${_procnamebn}:|"(${_procnamebn})"|"[${_procnamebn}]")'
369	fi
370
371	_proccheck="\
372		$PS 2>/dev/null -o pid= -o jid= -o command= $_psargs"' |
373		while read _npid _jid '"$_fp_args"'; do
374			'"$_fp_match"'
375				if [ "$JID" -eq "$_jid" ];
376				then echo -n "$_pref$_npid";
377				_pref=" ";
378				fi
379				;;
380			esac
381		done'
382
383#	debug "in _find_processes: proccheck is ($_proccheck)."
384	eval $_proccheck
385}
386
387# sort_lite [-b] [-n] [-k POS] [-t SEP]
388#	A lite version of sort(1) (supporting a few options) that can be used
389#	before the real sort(1) is available (e.g., in scripts that run prior
390#	to mountcritremote). Requires only shell built-in functionality.
391#
392sort_lite()
393{
394	local funcname=sort_lite
395	local sort_sep="$IFS" sort_ignore_leading_space=
396	local sort_field=0 sort_strict_fields= sort_numeric=
397	local nitems=0 skip_leading=0 trim=
398
399	local OPTIND flag
400	while getopts bnk:t: flag; do
401		case "$flag" in
402		b) sort_ignore_leading_space=1 ;;
403		n) sort_numeric=1 sort_ignore_leading_space=1 ;;
404		k) sort_field="${OPTARG%%,*}" ;; # only up to first comma
405			# NB: Unlike sort(1) only one POS allowed
406		t) sort_sep="$OPTARG"
407		   if [ ${#sort_sep} -gt 1 ]; then
408		   	echo "$funcname: multi-character tab \`$sort_sep'" >&2
409		   	return 1
410		   fi
411		   sort_strict_fields=1
412		   ;;
413		\?) return 1 ;;
414		esac
415	done
416	shift $(( $OPTIND - 1 ))
417
418	# Create transformation pattern to trim leading text if desired
419	case "$sort_field" in
420	""|[!0-9]*|*[!0-9.]*)
421		echo "$funcname: invalid sort field \`$sort_field'" >&2
422		return 1
423		;;
424	*.*)
425		skip_leading=${sort_field#*.} sort_field=${sort_field%%.*}
426		while [ ${skip_leading:-0} -gt 1 ] 2> /dev/null; do
427			trim="$trim?" skip_leading=$(( $skip_leading - 1 ))
428		done
429	esac
430
431	# Copy input to series of local numbered variables
432	# NB: IFS of NULL preserves leading whitespace
433	local LINE
434	while IFS= read -r LINE || [ "$LINE" ]; do
435		nitems=$(( $nitems + 1 ))
436		local src_$nitems="$LINE"
437	done
438
439	#
440	# Sort numbered locals using insertion sort
441	#
442	local curitem curitem_orig curitem_mod curitem_haskey
443	local dest dest_orig dest_mod dest_haskey
444	local d gt n
445	local i=1
446	while [ $i -le $nitems ]; do
447		curitem_haskey=1 # Assume sort field (-k POS) exists
448		eval curitem=\"\$src_$i\"
449		curitem_mod="$curitem" # for modified comparison
450		curitem_orig="$curitem" # for original comparison
451
452		# Trim leading whitespace if desired
453		if [ "$sort_ignore_leading_space" ]; then
454			while case "$curitem_orig" in
455				[$IFS]*) : ;; *) false; esac
456			do
457				curitem_orig="${curitem_orig#?}"
458			done
459			curitem_mod="$curitem_orig"
460		fi
461
462		# Shift modified comparison value if sort field (-k POS) is > 1
463		n=$sort_field
464		while [ $n -gt 1 ]; do
465			case "$curitem_mod" in
466			*[$sort_sep]*)
467				# Cut text up-to (and incl.) first separator
468				curitem_mod="${curitem_mod#*[$sort_sep]}"
469
470				# Skip NULLs unless strict field splitting
471				[ "$sort_strict_fields" ] ||
472					[ "${curitem_mod%%[$sort_sep]*}" ] ||
473					[ $n -eq 2 ] ||
474					continue
475				;;
476			*)
477				# Asked for a field that doesn't exist
478				curitem_haskey= break
479			esac
480			n=$(( $n - 1 ))
481		done
482
483		# Trim trailing words if sort field >= 1
484		[ $sort_field -ge 1 -a "$sort_numeric" ] &&
485			curitem_mod="${curitem_mod%%[$sort_sep]*}"
486
487		# Apply optional trim (-k POS.TRIM) to cut leading characters
488		curitem_mod="${curitem_mod#$trim}"
489
490		# Determine the type of modified comparison to use initially
491		# NB: Prefer numerical if requested but fallback to standard
492		case "$curitem_mod" in
493		""|[!0-9]*) # NULL or begins with non-number
494			gt=">"
495			[ "$sort_numeric" ] && curitem_mod=0
496			;;
497		*)
498			if [ "$sort_numeric" ]; then
499				gt="-gt"
500				curitem_mod="${curitem_mod%%[!0-9]*}"
501					# NB: trailing non-digits removed
502					# otherwise numeric comparison fails
503			else
504				gt=">"
505			fi
506		esac
507
508		# If first time through, short-circuit below position-search
509		if [ $i -le 1 ]; then
510			d=0
511		else
512			d=1
513		fi
514
515		#
516		# Find appropriate element position
517		#
518		while [ $d -gt 0 ]
519		do
520			dest_haskey=$curitem_haskey
521			eval dest=\"\$dest_$d\"
522			dest_mod="$dest" # for modified comparison
523			dest_orig="$dest" # for original comparison
524
525			# Trim leading whitespace if desired
526			if [ "$sort_ignore_leading_space" ]; then
527				while case "$dest_orig" in
528					[$IFS]*) : ;; *) false; esac
529				do
530					dest_orig="${dest_orig#?}"
531				done
532				dest_mod="$dest_orig"
533			fi
534
535			# Shift modified value if sort field (-k POS) is > 1
536			n=$sort_field
537			while [ $n -gt 1 ]; do
538				case "$dest_mod" in
539				*[$sort_sep]*)
540					# Cut text up-to (and incl.) 1st sep
541					dest_mod="${dest_mod#*[$sort_sep]}"
542
543					# Skip NULLs unless strict fields
544					[ "$sort_strict_fields" ] ||
545					    [ "${dest_mod%%[$sort_sep]*}" ] ||
546					    [ $n -eq 2 ] ||
547					    continue
548					;;
549				*)
550					# Asked for a field that doesn't exist
551					dest_haskey= break
552				esac
553				n=$(( $n - 1 ))
554			done
555
556			# Trim trailing words if sort field >= 1
557			[ $sort_field -ge 1 -a "$sort_numeric" ] &&
558				dest_mod="${dest_mod%%[$sort_sep]*}"
559
560			# Apply optional trim (-k POS.TRIM), cut leading chars
561			dest_mod="${dest_mod#$trim}"
562
563			# Determine type of modified comparison to use
564			# NB: Prefer numerical if requested, fallback to std
565			case "$dest_mod" in
566			""|[!0-9]*) # NULL or begins with non-number
567				gt=">"
568				[ "$sort_numeric" ] && dest_mod=0
569				;;
570			*)
571				if [ "$sort_numeric" ]; then
572					gt="-gt"
573					dest_mod="${dest_mod%%[!0-9]*}"
574						# NB: kill trailing non-digits
575						# for numeric comparison safety
576				else
577					gt=">"
578				fi
579			esac
580
581			# Break if we've found the proper element position
582			if [ "$curitem_haskey" -a "$dest_haskey" ]; then
583				if [ "$dest_mod" = "$curitem_mod" ]; then
584					[ "$dest_orig" ">" "$curitem_orig" ] &&
585						break
586				elif [ "$dest_mod" $gt "$curitem_mod" ] \
587					2> /dev/null
588				then
589					break
590				fi
591			else
592				[ "$dest_orig" ">" "$curitem_orig" ] && break
593			fi
594
595			# Break if we've hit the end
596			[ $d -ge $i ] && break
597
598			d=$(( $d + 1 ))
599		done
600
601		# Shift remaining positions forward, making room for new item
602		n=$i
603		while [ $n -ge $d ]; do
604			# Shift destination item forward one placement
605			eval dest_$(( $n + 1 ))=\"\$dest_$n\"
606			n=$(( $n - 1 ))
607		done
608
609		# Place the element
610		if [ $i -eq 1 ]; then
611			local dest_1="$curitem"
612		else
613			local dest_$d="$curitem"
614		fi
615
616		i=$(( $i + 1 ))
617	done
618
619	# Print sorted results
620	d=1
621	while [ $d -le $nitems ]; do
622		eval echo \"\$dest_$d\"
623		d=$(( $d + 1 ))
624	done
625}
626
627#
628# wait_for_pids pid [pid ...]
629#	spins until none of the pids exist
630#
631wait_for_pids()
632{
633	local _list _prefix _nlist _j
634
635	_list="$@"
636	if [ -z "$_list" ]; then
637		return
638	fi
639	_prefix=
640	while true; do
641		_nlist="";
642		for _j in $_list; do
643			if kill -0 $_j 2>/dev/null; then
644				_nlist="${_nlist}${_nlist:+ }$_j"
645				[ -n "$_prefix" ] && sleep 1
646			fi
647		done
648		if [ -z "$_nlist" ]; then
649			break
650		fi
651		_list=$_nlist
652		echo -n ${_prefix:-"Waiting for PIDS: "}$_list
653		_prefix=", "
654		pwait $_list 2>/dev/null
655	done
656	if [ -n "$_prefix" ]; then
657		echo "."
658	fi
659}
660
661#
662# get_pidfile_from_conf string file
663#
664#	Takes a string to search for in the specified file.
665#	Ignores lines with traditional comment characters.
666#
667# Example:
668#
669# if get_pidfile_from_conf string file; then
670#	pidfile="$_pidfile_from_conf"
671# else
672#	pidfile='appropriate default'
673# fi
674#
675get_pidfile_from_conf()
676{
677	if [ -z "$1" -o -z "$2" ]; then
678		err 3 "USAGE: get_pidfile_from_conf string file ($name)"
679	fi
680
681	local string file line
682
683	string="$1" ; file="$2"
684
685	if [ ! -s "$file" ]; then
686		err 3 "get_pidfile_from_conf: $file does not exist ($name)"
687	fi
688
689	while read line; do
690		case "$line" in
691		*[#\;]*${string}*)	continue ;;
692		*${string}*)		break ;;
693		esac
694	done < $file
695
696	if [ -n "$line" ]; then
697		line=${line#*/}
698		_pidfile_from_conf="/${line%%[\"\;]*}"
699	else
700		return 1
701	fi
702}
703
704#
705# check_startmsgs
706#	If rc_quiet is set (usually as a result of using faststart at
707#	boot time) check if rc_startmsgs is enabled.
708#
709check_startmsgs()
710{
711	if [ -n "$rc_quiet" ]; then
712		checkyesno rc_startmsgs
713	else
714		return 0
715	fi
716}
717
718#
719# run_rc_command argument
720#	Search for argument in the list of supported commands, which is:
721#		"start stop restart rcvar status poll ${extra_commands}"
722#	If there's a match, run ${argument}_cmd or the default method
723#	(see below).
724#
725#	If argument has a given prefix, then change the operation as follows:
726#		Prefix	Operation
727#		------	---------
728#		fast	Skip the pid check, and set rc_fast=yes, rc_quiet=yes
729#		force	Set ${rcvar} to YES, and set rc_force=yes
730#		one	Set ${rcvar} to YES
731#		quiet	Don't output some diagnostics, and set rc_quiet=yes
732#
733#	The following globals are used:
734#
735#	Name		Needed	Purpose
736#	----		------	-------
737#	name		y	Name of script.
738#
739#	command		n	Full path to command.
740#				Not needed if ${rc_arg}_cmd is set for
741#				each keyword.
742#
743#	command_args	n	Optional args/shell directives for command.
744#
745#	command_interpreter n	If not empty, command is interpreted, so
746#				call check_{pidfile,process}() appropriately.
747#
748#	desc		n	Description of script.
749#
750#	extra_commands	n	List of extra commands supported.
751#
752#	pidfile		n	If set, use check_pidfile $pidfile $command,
753#				otherwise use check_process $command.
754#				In either case, only check if $command is set.
755#
756#	procname	n	Process name to check for instead of $command.
757#
758#	rcvar		n	This is checked with checkyesno to determine
759#				if the action should be run.
760#
761#	${name}_program	n	Full path to command.
762#				Meant to be used in /etc/rc.conf to override
763#				${command}.
764#
765#	${name}_chroot	n	Directory to chroot to before running ${command}
766#				Requires /usr to be mounted.
767#
768#	${name}_chdir	n	Directory to cd to before running ${command}
769#				(if not using ${name}_chroot).
770#
771#	${name}_flags	n	Arguments to call ${command} with.
772#				NOTE:	$flags from the parent environment
773#					can be used to override this.
774#
775#	${name}_env	n	Environment variables to run ${command} with.
776#
777#	${name}_env_file n	File to source variables to run ${command} with.
778#
779#	${name}_fib	n	Routing table number to run ${command} with.
780#
781#	${name}_nice	n	Nice level to run ${command} at.
782#
783#	${name}_oomprotect n	Don't kill ${command} when swap space is exhausted.
784#
785#	${name}_user	n	User to run ${command} as, using su(1) if not
786#				using ${name}_chroot.
787#				Requires /usr to be mounted.
788#
789#	${name}_group	n	Group to run chrooted ${command} as.
790#				Requires /usr to be mounted.
791#
792#	${name}_groups	n	Comma separated list of supplementary groups
793#				to run the chrooted ${command} with.
794#				Requires /usr to be mounted.
795#
796#	${name}_prepend	n	Command added before ${command}.
797#
798#	${name}_login_class n	Login class to use, else "daemon".
799#
800#	${name}_limits	n	limits(1) to apply to ${command}.
801#
802#	${rc_arg}_cmd	n	If set, use this as the method when invoked;
803#				Otherwise, use default command (see below)
804#
805#	${rc_arg}_precmd n	If set, run just before performing the
806#				${rc_arg}_cmd method in the default
807#				operation (i.e, after checking for required
808#				bits and process (non)existence).
809#				If this completes with a non-zero exit code,
810#				don't run ${rc_arg}_cmd.
811#
812#	${rc_arg}_postcmd n	If set, run just after performing the
813#				${rc_arg}_cmd method, if that method
814#				returned a zero exit code.
815#
816#	required_dirs	n	If set, check for the existence of the given
817#				directories before running a (re)start command.
818#
819#	required_files	n	If set, check for the readability of the given
820#				files before running a (re)start command.
821#
822#	required_modules n	If set, ensure the given kernel modules are
823#				loaded before running a (re)start command.
824#				The check and possible loads are actually
825#				done after start_precmd so that the modules
826#				aren't loaded in vain, should the precmd
827#				return a non-zero status to indicate a error.
828#				If a word in the list looks like "foo:bar",
829#				"foo" is the KLD file name and "bar" is the
830#				module name.  If a word looks like "foo~bar",
831#				"foo" is the KLD file name and "bar" is a
832#				egrep(1) pattern matching the module name.
833#				Otherwise the module name is assumed to be
834#				the same as the KLD file name, which is most
835#				common.  See load_kld().
836#
837#	required_vars	n	If set, perform checkyesno on each of the
838#				listed variables before running the default
839#				(re)start command.
840#
841#	Default behaviour for a given argument, if no override method is
842#	provided:
843#
844#	Argument	Default behaviour
845#	--------	-----------------
846#	start		if !running && checkyesno ${rcvar}
847#				${command}
848#
849#	stop		if ${pidfile}
850#				rc_pid=$(check_pidfile $pidfile $command)
851#			else
852#				rc_pid=$(check_process $command)
853#			kill $sig_stop $rc_pid
854#			wait_for_pids $rc_pid
855#			($sig_stop defaults to TERM.)
856#
857#	reload		Similar to stop, except use $sig_reload instead,
858#			and doesn't wait_for_pids.
859#			$sig_reload defaults to HUP.
860#			Note that `reload' isn't provided by default,
861#			it should be enabled via $extra_commands.
862#
863#	restart		Run `stop' then `start'.
864#
865#	status		Show if ${command} is running, etc.
866#
867#	poll		Wait for ${command} to exit.
868#
869#	rcvar		Display what rc.conf variable is used (if any).
870#
871#	enabled		Return true if the service is enabled.
872#
873#	describe	Show the service's description
874#
875#	extracommands	Show the service's extra commands
876#
877#	Variables available to methods, and after run_rc_command() has
878#	completed:
879#
880#	Variable	Purpose
881#	--------	-------
882#	rc_arg		Argument to command, after fast/force/one processing
883#			performed
884#
885#	rc_flags	Flags to start the default command with.
886#			Defaults to ${name}_flags, unless overridden
887#			by $flags from the environment.
888#			This variable may be changed by the precmd method.
889#
890#       rc_service      Path to the service being executed, in case the service
891#                       needs to re-invoke itself.
892#
893#	rc_pid		PID of command (if appropriate)
894#
895#	rc_fast		Not empty if "fast" was provided (q.v.)
896#
897#	rc_force	Not empty if "force" was provided (q.v.)
898#
899#	rc_quiet	Not empty if "quiet" was provided
900#
901#
902run_rc_command()
903{
904	_return=0
905	rc_arg=$1
906	if [ -z "$name" ]; then
907		err 3 'run_rc_command: $name is not set.'
908	fi
909
910	# Don't repeat the first argument when passing additional command-
911	# line arguments to the command subroutines.
912	#
913	shift 1
914	rc_extra_args="$*"
915
916	_rc_prefix=
917	case "$rc_arg" in
918	fast*)				# "fast" prefix; don't check pid
919		rc_arg=${rc_arg#fast}
920		rc_fast=yes
921		rc_quiet=yes
922		;;
923	force*)				# "force" prefix; always run
924		rc_force=yes
925		_rc_prefix=force
926		rc_arg=${rc_arg#${_rc_prefix}}
927		if [ -n "${rcvar}" ]; then
928			eval ${rcvar}=YES
929		fi
930		;;
931	one*)				# "one" prefix; set ${rcvar}=yes
932		_rc_prefix=one
933		rc_arg=${rc_arg#${_rc_prefix}}
934		if [ -n "${rcvar}" ]; then
935			eval ${rcvar}=YES
936		fi
937		;;
938	quiet*)				# "quiet" prefix; omit some messages
939		_rc_prefix=quiet
940		rc_arg=${rc_arg#${_rc_prefix}}
941		rc_quiet=yes
942		;;
943	esac
944
945	eval _override_command=\$${name}_program
946	command=${_override_command:-$command}
947
948	_keywords="start stop restart rcvar enable disable delete enabled describe extracommands $extra_commands"
949	rc_pid=
950	_pidcmd=
951	_procname=${procname:-${command}}
952
953					# setup pid check command
954	if [ -n "$_procname" ]; then
955		if [ -n "$pidfile" ]; then
956			_pidcmd='rc_pid=$(check_pidfile '"$pidfile $_procname $command_interpreter"')'
957		else
958			_pidcmd='rc_pid=$(check_process '"$_procname $command_interpreter"')'
959		fi
960		_keywords="${_keywords} status poll"
961	else
962		if [ ! -z "${status_cmd}" ]
963		then
964			_keywords="${_keywords} status"
965		fi
966	fi
967
968	if [ -z "$rc_arg" ]; then
969		rc_usage $_keywords
970	fi
971
972	if [ "$rc_arg" = "enabled" ] ; then
973		checkyesno ${rcvar}
974		return $?
975	fi
976
977	if [ -n "$flags" ]; then	# allow override from environment
978		rc_flags=$flags
979	else
980		eval rc_flags=\$${name}_flags
981	fi
982	eval _chdir=\$${name}_chdir	_chroot=\$${name}_chroot \
983	    _nice=\$${name}_nice	_user=\$${name}_user \
984	    _group=\$${name}_group	_groups=\$${name}_groups \
985	    _fib=\$${name}_fib		_env=\$${name}_env \
986	    _prepend=\$${name}_prepend	_login_class=\${${name}_login_class:-daemon} \
987	    _limits=\$${name}_limits    _oomprotect=\$${name}_oomprotect \
988	    _env_file=\$${name}_env_file
989
990	if [ -n "$_env_file" ] && [ -r "${_env_file}" ]; then	# load env from file
991		set -a
992		. $_env_file
993		set +a
994	fi
995
996	if [ -n "$_user" ]; then	# unset $_user if running as that user
997		if [ "$_user" = "$(eval $IDCMD)" ]; then
998			unset _user
999		fi
1000	fi
1001
1002	[ -z "$autoboot" ] && eval $_pidcmd	# determine the pid if necessary
1003
1004	for _elem in $_keywords; do
1005		if [ "$_elem" != "$rc_arg" ]; then
1006			continue
1007		fi
1008					# if ${rcvar} is set, $1 is not "rcvar", "describe",
1009					# "enable" or "delete", and ${rc_pid} is not set, run:
1010					#	checkyesno ${rcvar}
1011					# and return if that failed
1012					#
1013		if [ -n "${rcvar}" -a "$rc_arg" != "rcvar" -a "$rc_arg" != "stop" \
1014		    -a "$rc_arg" != "delete" -a "$rc_arg" != "enable" \
1015		    -a "$rc_arg" != "describe" ] ||
1016		    [ -n "${rcvar}" -a "$rc_arg" = "stop" -a -z "${rc_pid}" ]; then
1017			if ! checkyesno ${rcvar}; then
1018				if [ -n "${rc_quiet}" ]; then
1019					return 0
1020				fi
1021				echo -n "Cannot '${rc_arg}' $name. Set ${rcvar} to "
1022				echo -n "YES in /etc/rc.conf or use 'one${rc_arg}' "
1023				echo "instead of '${rc_arg}'."
1024				return 0
1025			fi
1026		fi
1027
1028		if [ $rc_arg = "start" -a -z "$rc_fast" -a -n "$rc_pid" ]; then
1029			if [ -z "$rc_quiet" ]; then
1030				echo 1>&2 "${name} already running? " \
1031				    "(pid=$rc_pid)."
1032			fi
1033			return 1
1034		fi
1035
1036					# if there's a custom ${XXX_cmd},
1037					# run that instead of the default
1038					#
1039		eval _cmd=\$${rc_arg}_cmd \
1040		     _precmd=\$${rc_arg}_precmd \
1041		     _postcmd=\$${rc_arg}_postcmd
1042
1043		if [ -n "$_cmd" ]; then
1044			if [ -n "$_env" ]; then
1045				eval "export -- $_env"
1046			fi
1047			_run_rc_precmd || return 1
1048			_run_rc_doit "$_cmd $rc_extra_args" || return 1
1049			_run_rc_postcmd
1050			return $_return
1051		fi
1052
1053		case "$rc_arg" in	# default operations...
1054
1055		describe)
1056			if [ -n "$desc" ]; then
1057				echo "$desc"
1058			fi
1059			;;
1060
1061		extracommands)
1062			echo "$extra_commands"
1063			;;
1064
1065		enable)
1066			_out=$(/usr/sbin/sysrc -vs "$name" "$rcvar=YES") &&
1067				echo "$name enabled in ${_out%%:*}"
1068			;;
1069
1070		disable)
1071			_out=$(/usr/sbin/sysrc -vs "$name" "$rcvar=NO") &&
1072				echo "$name disabled in ${_out%%:*}"
1073			;;
1074
1075		delete)
1076			_files=
1077			for _file in $(sysrc -lEs "$name"); do
1078				_out=$(sysrc -Fif $_file "$rcvar") && _files="$_files $_file"
1079			done
1080			/usr/sbin/sysrc -x "$rcvar" && echo "$rcvar deleted in ${_files# }"
1081				# delete file in rc.conf.d if desired and empty.
1082			checkyesno service_delete_empty || _files=
1083			for _file in $_files; do
1084				[ "$_file" = "${_file#*/rc.conf.d/}" ] && continue
1085				[ $(/usr/bin/stat -f%z $_file) -gt 0 ] && continue
1086				/bin/rm "$_file" && echo "Empty file $_file removed"
1087			done
1088			;;
1089
1090		status)
1091			_run_rc_precmd || return 1
1092			if [ -n "$rc_pid" ]; then
1093				echo "${name} is running as pid $rc_pid."
1094			else
1095				echo "${name} is not running."
1096				return 1
1097			fi
1098			_run_rc_postcmd
1099			;;
1100
1101		start)
1102			if [ ! -x "${_chroot}${_chroot:+/}${command}" ]; then
1103				warn "run_rc_command: cannot run $command"
1104				return 1
1105			fi
1106
1107			if ! _run_rc_precmd; then
1108				warn "failed precmd routine for ${name}"
1109				return 1
1110			fi
1111
1112					# setup the full command to run
1113					#
1114			check_startmsgs && echo "Starting ${name}."
1115			if [ -n "$_chroot" ]; then
1116				_cd=
1117				_doit="\
1118${_nice:+nice -n $_nice }\
1119${_fib:+setfib -F $_fib }\
1120${_env:+env $_env }\
1121chroot ${_user:+-u $_user }${_group:+-g $_group }${_groups:+-G $_groups }\
1122$_chroot $command $rc_flags $command_args"
1123			else
1124				_cd="${_chdir:+cd $_chdir && }"
1125				_doit="\
1126${_fib:+setfib -F $_fib }\
1127${_env:+env $_env }\
1128$command $rc_flags $command_args"
1129				if [ -n "$_user" ]; then
1130				    _doit="su -m $_user -c 'sh -c \"$_doit\"'"
1131				fi
1132				if [ -n "$_nice" ]; then
1133					if [ -z "$_user" ]; then
1134						_doit="sh -c \"$_doit\""
1135					fi
1136					_doit="nice -n $_nice $_doit"
1137				fi
1138				if [ -n "$_prepend" ]; then
1139					_doit="$_prepend $_doit"
1140				fi
1141			fi
1142
1143					# Prepend default limits
1144			_doit="$_cd limits -C $_login_class $_limits $_doit"
1145
1146					# run the full command
1147					#
1148			if ! _run_rc_doit "$_doit"; then
1149				warn "failed to start ${name}"
1150				return 1
1151			fi
1152
1153					# finally, run postcmd
1154					#
1155			_run_rc_postcmd
1156			;;
1157
1158		stop)
1159			if [ -z "$rc_pid" ]; then
1160				[ -n "$rc_fast" ] && return 0
1161				_run_rc_notrunning
1162				return 1
1163			fi
1164
1165			_run_rc_precmd || return 1
1166
1167					# send the signal to stop
1168					#
1169			echo "Stopping ${name}."
1170			_doit=$(_run_rc_killcmd "${sig_stop:-TERM}")
1171			_run_rc_doit "$_doit" || return 1
1172
1173					# wait for the command to exit,
1174					# and run postcmd.
1175			wait_for_pids $rc_pid
1176
1177			_run_rc_postcmd
1178			;;
1179
1180		reload)
1181			if [ -z "$rc_pid" ]; then
1182				_run_rc_notrunning
1183				return 1
1184			fi
1185
1186			_run_rc_precmd || return 1
1187
1188			_doit=$(_run_rc_killcmd "${sig_reload:-HUP}")
1189			_run_rc_doit "$_doit" || return 1
1190
1191			_run_rc_postcmd
1192			;;
1193
1194		restart)
1195					# prevent restart being called more
1196					# than once by any given script
1197					#
1198			if ${_rc_restart_done:-false}; then
1199				return 0
1200			fi
1201			_rc_restart_done=true
1202
1203			_run_rc_precmd || return 1
1204
1205			# run those in a subshell to keep global variables
1206			( run_rc_command ${_rc_prefix}stop $rc_extra_args )
1207			( run_rc_command ${_rc_prefix}start $rc_extra_args )
1208			_return=$?
1209			[ $_return -ne 0 ] && [ -z "$rc_force" ] && return 1
1210
1211			_run_rc_postcmd
1212			;;
1213
1214		poll)
1215			_run_rc_precmd || return 1
1216			if [ -n "$rc_pid" ]; then
1217				wait_for_pids $rc_pid
1218			fi
1219			_run_rc_postcmd
1220			;;
1221
1222		rcvar)
1223			echo -n "# $name"
1224			if [ -n "$desc" ]; then
1225				echo " : $desc"
1226			else
1227				echo ""
1228			fi
1229			echo "#"
1230			# Get unique vars in $rcvar $rcvars
1231			for _v in $rcvar $rcvars; do
1232				case $v in
1233				$_v\ *|\ *$_v|*\ $_v\ *) ;;
1234				*)	v="${v# } $_v" ;;
1235				esac
1236			done
1237
1238			# Display variables.
1239			for _v in $v; do
1240				if [ -z "$_v" ]; then
1241					continue
1242				fi
1243
1244				eval _desc=\$${_v}_desc
1245				eval _defval=\$${_v}_defval
1246				_h="-"
1247
1248				eval echo \"$_v=\\\"\$$_v\\\"\"
1249				# decode multiple lines of _desc
1250				while [ -n "$_desc" ]; do
1251					case $_desc in
1252					*^^*)
1253						echo "# $_h ${_desc%%^^*}"
1254						_desc=${_desc#*^^}
1255						_h=" "
1256						;;
1257					*)
1258						echo "# $_h ${_desc}"
1259						break
1260						;;
1261					esac
1262				done
1263				echo "#   (default: \"$_defval\")"
1264			done
1265			echo ""
1266			;;
1267
1268		*)
1269			rc_usage $_keywords
1270			;;
1271
1272		esac
1273
1274		# Apply protect(1) to the PID if ${name}_oomprotect is set.
1275		case "$rc_arg" in
1276		start)
1277			# We cannot use protect(1) inside jails.
1278			if [ -n "$_oomprotect" ] && [ -f "${PROTECT}" ] &&
1279			    [ "$(sysctl -n security.jail.jailed)" -eq 0 ]; then
1280				[ -z "${rc_pid}" ] && eval $_pidcmd
1281				case $_oomprotect in
1282				[Aa][Ll][Ll])
1283					${PROTECT} -i -p ${rc_pid}
1284					;;
1285				[Yy][Ee][Ss])
1286					${PROTECT} -p ${rc_pid}
1287					;;
1288				esac
1289			fi
1290		;;
1291		esac
1292
1293		return $_return
1294	done
1295
1296	echo 1>&2 "$0: unknown directive '$rc_arg'."
1297	rc_usage $_keywords
1298	# not reached
1299}
1300
1301#
1302# Helper functions for run_rc_command: common code.
1303# They use such global variables besides the exported rc_* ones:
1304#
1305#	name	       R/W
1306#	------------------
1307#	_precmd		R
1308#	_postcmd	R
1309#	_return		W
1310#
1311_run_rc_precmd()
1312{
1313	check_required_before "$rc_arg" || return 1
1314
1315	if [ -n "$_precmd" ]; then
1316		debug "run_rc_command: ${rc_arg}_precmd: $_precmd $rc_extra_args"
1317		eval "$_precmd $rc_extra_args"
1318		_return=$?
1319
1320		# If precmd failed and force isn't set, request exit.
1321		if [ $_return -ne 0 ] && [ -z "$rc_force" ]; then
1322			return 1
1323		fi
1324	fi
1325
1326	check_required_after "$rc_arg" || return 1
1327
1328	return 0
1329}
1330
1331_run_rc_postcmd()
1332{
1333	if [ -n "$_postcmd" ]; then
1334		debug "run_rc_command: ${rc_arg}_postcmd: $_postcmd $rc_extra_args"
1335		eval "$_postcmd $rc_extra_args"
1336		_return=$?
1337	fi
1338	return 0
1339}
1340
1341_run_rc_doit()
1342{
1343	debug "run_rc_command: doit: $*"
1344	eval "$@"
1345	_return=$?
1346
1347	# If command failed and force isn't set, request exit.
1348	if [ $_return -ne 0 ] && [ -z "$rc_force" ]; then
1349		return 1
1350	fi
1351
1352	return 0
1353}
1354
1355_run_rc_notrunning()
1356{
1357	local _pidmsg
1358
1359	if [ -n "$pidfile" ]; then
1360		_pidmsg=" (check $pidfile)."
1361	else
1362		_pidmsg=
1363	fi
1364	echo 1>&2 "${name} not running?${_pidmsg}"
1365}
1366
1367_run_rc_killcmd()
1368{
1369	local _cmd
1370
1371	_cmd="kill -$1 $rc_pid"
1372	if [ -n "$_user" ]; then
1373		_cmd="su -m ${_user} -c 'sh -c \"${_cmd}\"'"
1374	fi
1375	echo "$_cmd"
1376}
1377
1378#
1379# run_rc_script file arg
1380#	Start the script `file' with `arg', and correctly handle the
1381#	return value from the script.
1382#	If `file' ends with `.sh' and lives in /etc/rc.d, ignore it as it's
1383#	an old-style startup file.
1384#	If `file' ends with `.sh' and does not live in /etc/rc.d, it's sourced
1385#	into the current environment if $rc_fast_and_loose is set; otherwise
1386#	it is run as a child process.
1387#	If `file' appears to be a backup or scratch file, ignore it.
1388#	Otherwise if it is executable run as a child process.
1389#
1390run_rc_script()
1391{
1392	_file=$1
1393	_arg=$2
1394	if [ -z "$_file" -o -z "$_arg" ]; then
1395		err 3 'USAGE: run_rc_script file arg'
1396	fi
1397
1398	unset	name command command_args command_interpreter \
1399		extra_commands pidfile procname \
1400		rcvar rcvars rcvars_obsolete required_dirs required_files \
1401		required_vars
1402	eval unset ${_arg}_cmd ${_arg}_precmd ${_arg}_postcmd
1403
1404	rc_service="$_file"
1405	case "$_file" in
1406	/etc/rc.d/*.sh)			# no longer allowed in the base
1407		warn "Ignoring old-style startup script $_file"
1408		;;
1409	*[~#]|*.OLD|*.bak|*.orig|*,v)	# scratch file; skip
1410		warn "Ignoring scratch file $_file"
1411		;;
1412	*)				# run in subshell
1413		if [ -x $_file ]; then
1414			if [ -n "$rc_fast_and_loose" ]; then
1415				set $_arg; . $_file
1416			else
1417				( trap "echo Script $_file interrupted >&2 ; kill -QUIT $$" 3
1418				  trap "echo Script $_file interrupted >&2 ; exit 1" 2
1419				  trap "echo Script $_file running >&2" 29
1420				  set $_arg; . $_file )
1421			fi
1422		fi
1423		;;
1424	esac
1425}
1426
1427#
1428# load_rc_config [service]
1429#	Source in the configuration file(s) for a given service.
1430#	If no service is specified, only the global configuration
1431#	file(s) will be loaded.
1432#
1433load_rc_config()
1434{
1435	local _name _rcvar_val _var _defval _v _msg _new _d
1436	_name=$1
1437
1438	if ${_rc_conf_loaded:-false}; then
1439		:
1440	else
1441		if [ -r /etc/defaults/rc.conf ]; then
1442			debug "Sourcing /etc/defaults/rc.conf"
1443			. /etc/defaults/rc.conf
1444			source_rc_confs
1445		elif [ -r /etc/rc.conf ]; then
1446			debug "Sourcing /etc/rc.conf (/etc/defaults/rc.conf doesn't exist)."
1447			. /etc/rc.conf
1448		fi
1449		_rc_conf_loaded=true
1450	fi
1451
1452	# If a service name was specified, attempt to load
1453	# service-specific configuration
1454	if [ -n "$_name" ] ; then
1455		for _d in /etc ${local_startup}; do
1456			_d=${_d%/rc.d}
1457			if [ -f ${_d}/rc.conf.d/"$_name" ]; then
1458				debug "Sourcing ${_d}/rc.conf.d/$_name"
1459				. ${_d}/rc.conf.d/"$_name"
1460			elif [ -d ${_d}/rc.conf.d/"$_name" ] ; then
1461				local _rc
1462				for _rc in ${_d}/rc.conf.d/"$_name"/* ; do
1463					if [ -f "$_rc" ] ; then
1464						debug "Sourcing $_rc"
1465						. "$_rc"
1466					fi
1467				done
1468			fi
1469		done
1470	fi
1471
1472	# Set defaults if defined.
1473	for _var in $rcvar $rcvars; do
1474		eval _defval=\$${_var}_defval
1475		if [ -n "$_defval" ]; then
1476			eval : \${$_var:=\$${_var}_defval}
1477		fi
1478	done
1479
1480	# check obsolete rc.conf variables
1481	for _var in $rcvars_obsolete; do
1482		eval _v=\$$_var
1483		eval _msg=\$${_var}_obsolete_msg
1484		eval _new=\$${_var}_newvar
1485		case $_v in
1486		"")
1487			;;
1488		*)
1489			if [ -z "$_new" ]; then
1490				_msg="Ignored."
1491			else
1492				eval $_new=\"\$$_var\"
1493				if [ -z "$_msg" ]; then
1494					_msg="Use \$$_new instead."
1495				fi
1496			fi
1497			warn "\$$_var is obsolete.  $_msg"
1498			;;
1499		esac
1500	done
1501}
1502
1503#
1504# load_rc_config_var name var
1505#	Read the rc.conf(5) var for name and set in the
1506#	current shell, using load_rc_config in a subshell to prevent
1507#	unwanted side effects from other variable assignments.
1508#
1509load_rc_config_var()
1510{
1511	if [ $# -ne 2 ]; then
1512		err 3 'USAGE: load_rc_config_var name var'
1513	fi
1514	eval $(eval '(
1515		load_rc_config '$1' >/dev/null;
1516                if [ -n "${'$2'}" -o "${'$2'-UNSET}" != "UNSET" ]; then
1517			echo '$2'=\'\''${'$2'}\'\'';
1518		fi
1519	)' )
1520}
1521
1522#
1523# rc_usage commands
1524#	Print a usage string for $0, with `commands' being a list of
1525#	valid commands.
1526#
1527rc_usage()
1528{
1529	echo -n 1>&2 "Usage: $0 [fast|force|one|quiet]("
1530
1531	_sep=
1532	for _elem; do
1533		echo -n 1>&2 "$_sep$_elem"
1534		_sep="|"
1535	done
1536	echo 1>&2 ")"
1537	exit 1
1538}
1539
1540#
1541# err exitval message
1542#	Display message to stderr and log to the syslog, and exit with exitval.
1543#
1544err()
1545{
1546	exitval=$1
1547	shift
1548
1549	if [ -x /usr/bin/logger ]; then
1550		logger "$0: ERROR: $*"
1551	fi
1552	echo 1>&2 "$0: ERROR: $*"
1553	exit $exitval
1554}
1555
1556#
1557# warn message
1558#	Display message to stderr and log to the syslog.
1559#
1560warn()
1561{
1562	if [ -x /usr/bin/logger ]; then
1563		logger "$0: WARNING: $*"
1564	fi
1565	echo 1>&2 "$0: WARNING: $*"
1566}
1567
1568#
1569# info message
1570#	Display informational message to stdout and log to syslog.
1571#
1572info()
1573{
1574	case ${rc_info} in
1575	[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
1576		if [ -x /usr/bin/logger ]; then
1577			logger "$0: INFO: $*"
1578		fi
1579		echo "$0: INFO: $*"
1580		;;
1581	esac
1582}
1583
1584#
1585# debug message
1586#	If debugging is enabled in rc.conf output message to stderr.
1587#	BEWARE that you don't call any subroutine that itself calls this
1588#	function.
1589#
1590debug()
1591{
1592	case ${rc_debug} in
1593	[Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]|[Oo][Nn]|1)
1594		if [ -x /usr/bin/logger ]; then
1595			logger "$0: DEBUG: $*"
1596		fi
1597		echo 1>&2 "$0: DEBUG: $*"
1598		;;
1599	esac
1600}
1601
1602#
1603# backup_file action file cur backup
1604#	Make a backup copy of `file' into `cur', and save the previous
1605#	version of `cur' as `backup'.
1606#
1607#	The `action' keyword can be one of the following:
1608#
1609#	add		`file' is now being backed up (and is possibly
1610#			being reentered into the backups system).  `cur'
1611#			is created.
1612#
1613#	update		`file' has changed and needs to be backed up.
1614#			If `cur' exists, it is copied to `back'
1615#			and then `file' is copied to `cur'.
1616#
1617#	remove		`file' is no longer being tracked by the backups
1618#			system.  `cur' is moved `back'.
1619#
1620#
1621backup_file()
1622{
1623	_action=$1
1624	_file=$2
1625	_cur=$3
1626	_back=$4
1627
1628	case $_action in
1629	add|update)
1630		if [ -f $_cur ]; then
1631			cp -p $_cur $_back
1632		fi
1633		cp -p $_file $_cur
1634		chown root:wheel $_cur
1635		;;
1636	remove)
1637		mv -f $_cur $_back
1638		;;
1639	esac
1640}
1641
1642# make_symlink src link
1643#	Make a symbolic link 'link' to src from basedir. If the
1644#	directory in which link is to be created does not exist
1645#	a warning will be displayed and an error will be returned.
1646#	Returns 0 on success, 1 otherwise.
1647#
1648make_symlink()
1649{
1650	local src link linkdir _me
1651	src="$1"
1652	link="$2"
1653	linkdir="`dirname $link`"
1654	_me="make_symlink()"
1655
1656	if [ -z "$src" -o -z "$link" ]; then
1657		warn "$_me: requires two arguments."
1658		return 1
1659	fi
1660	if [ ! -d "$linkdir" ]; then
1661		warn "$_me: the directory $linkdir does not exist."
1662		return 1
1663	fi
1664	if ! ln -sf $src $link; then
1665		warn "$_me: unable to make a symbolic link from $link to $src"
1666		return 1
1667	fi
1668	return 0
1669}
1670
1671# devfs_rulesets_from_file file
1672#	Reads a set of devfs commands from file, and creates
1673#	the specified rulesets with their rules. Returns non-zero
1674#	if there was an error.
1675#
1676devfs_rulesets_from_file()
1677{
1678	local file _err _me _opts
1679	file="$1"
1680	_me="devfs_rulesets_from_file"
1681	_err=0
1682
1683	if [ -z "$file" ]; then
1684		warn "$_me: you must specify a file"
1685		return 1
1686	fi
1687	if [ ! -e "$file" ]; then
1688		debug "$_me: no such file ($file)"
1689		return 0
1690	fi
1691
1692	# Disable globbing so that the rule patterns are not expanded
1693	# by accident with matching filesystem entries.
1694	_opts=$-; set -f
1695
1696	debug "reading rulesets from file ($file)"
1697	{ while read line
1698	do
1699		case $line in
1700		\#*)
1701			continue
1702			;;
1703		\[*\]*)
1704			rulenum=`expr "$line" : "\[.*=\([0-9]*\)\]"`
1705			if [ -z "$rulenum" ]; then
1706				warn "$_me: cannot extract rule number ($line)"
1707				_err=1
1708				break
1709			fi
1710			rulename=`expr "$line" : "\[\(.*\)=[0-9]*\]"`
1711			if [ -z "$rulename" ]; then
1712				warn "$_me: cannot extract rule name ($line)"
1713				_err=1
1714				break;
1715			fi
1716			eval $rulename=\$rulenum
1717			debug "found ruleset: $rulename=$rulenum"
1718			if ! /sbin/devfs rule -s $rulenum delset; then
1719				_err=1
1720				break
1721			fi
1722			;;
1723		*)
1724			rulecmd="${line%%"\#*"}"
1725			# evaluate the command incase it includes
1726			# other rules
1727			if [ -n "$rulecmd" ]; then
1728				debug "adding rule ($rulecmd)"
1729				if ! eval /sbin/devfs rule -s $rulenum $rulecmd
1730				then
1731					_err=1
1732					break
1733				fi
1734			fi
1735			;;
1736		esac
1737		if [ $_err -ne 0 ]; then
1738			debug "error in $_me"
1739			break
1740		fi
1741	done } < $file
1742	case $_opts in *f*) ;; *) set +f ;; esac
1743	return $_err
1744}
1745
1746# devfs_init_rulesets
1747#	Initializes rulesets from configuration files. Returns
1748#	non-zero if there was an error.
1749#
1750devfs_init_rulesets()
1751{
1752	local file _me
1753	_me="devfs_init_rulesets"
1754
1755	# Go through this only once
1756	if [ -n "$devfs_rulesets_init" ]; then
1757		debug "$_me: devfs rulesets already initialized"
1758		return
1759	fi
1760	for file in $devfs_rulesets; do
1761		if ! devfs_rulesets_from_file $file; then
1762			warn "$_me: could not read rules from $file"
1763			return 1
1764		fi
1765	done
1766	devfs_rulesets_init=1
1767	debug "$_me: devfs rulesets initialized"
1768	return 0
1769}
1770
1771# devfs_set_ruleset ruleset [dir]
1772#	Sets the default ruleset of dir to ruleset. The ruleset argument
1773#	must be a ruleset name as specified in devfs.rules(5) file.
1774#	Returns non-zero if it could not set it successfully.
1775#
1776devfs_set_ruleset()
1777{
1778	local devdir rs _me
1779	[ -n "$1" ] && eval rs=\$$1 || rs=
1780	[ -n "$2" ] && devdir="-m "$2"" || devdir=
1781	_me="devfs_set_ruleset"
1782
1783	if [ -z "$rs" ]; then
1784		warn "$_me: you must specify a ruleset number"
1785		return 1
1786	fi
1787	debug "$_me: setting ruleset ($rs) on mount-point (${devdir#-m })"
1788	if ! /sbin/devfs $devdir ruleset $rs; then
1789		warn "$_me: unable to set ruleset $rs to ${devdir#-m }"
1790		return 1
1791	fi
1792	return 0
1793}
1794
1795# devfs_apply_ruleset ruleset [dir]
1796#	Apply ruleset number $ruleset to the devfs mountpoint $dir.
1797#	The ruleset argument must be a ruleset name as specified
1798#	in a devfs.rules(5) file.  Returns 0 on success or non-zero
1799#	if it could not apply the ruleset.
1800#
1801devfs_apply_ruleset()
1802{
1803	local devdir rs _me
1804	[ -n "$1" ] && eval rs=\$$1 || rs=
1805	[ -n "$2" ] && devdir="-m "$2"" || devdir=
1806	_me="devfs_apply_ruleset"
1807
1808	if [ -z "$rs" ]; then
1809		warn "$_me: you must specify a ruleset"
1810		return 1
1811	fi
1812	debug "$_me: applying ruleset ($rs) to mount-point (${devdir#-m })"
1813	if ! /sbin/devfs $devdir rule -s $rs applyset; then
1814		warn "$_me: unable to apply ruleset $rs to ${devdir#-m }"
1815		return 1
1816	fi
1817	return 0
1818}
1819
1820# devfs_domount dir [ruleset]
1821#	Mount devfs on dir. If ruleset is specified it is set
1822#	on the mount-point. It must also be a ruleset name as specified
1823#	in a devfs.rules(5) file. Returns 0 on success.
1824#
1825devfs_domount()
1826{
1827	local devdir rs _me
1828	devdir="$1"
1829	[ -n "$2" ] && rs=$2 || rs=
1830	_me="devfs_domount()"
1831
1832	if [ -z "$devdir" ]; then
1833		warn "$_me: you must specify a mount-point"
1834		return 1
1835	fi
1836	debug "$_me: mount-point is ($devdir), ruleset is ($rs)"
1837	if ! mount -t devfs dev "$devdir"; then
1838		warn "$_me: Unable to mount devfs on $devdir"
1839		return 1
1840	fi
1841	if [ -n "$rs" ]; then
1842		devfs_init_rulesets
1843		devfs_set_ruleset $rs $devdir
1844		devfs -m $devdir rule applyset
1845	fi
1846	return 0
1847}
1848
1849# Provide a function for normalizing the mounting of memory
1850# filesystems.  This should allow the rest of the code here to remain
1851# as close as possible between 5-current and 4-stable.
1852#   $1 = size
1853#   $2 = mount point
1854#   $3 = (optional) extra mdmfs flags
1855mount_md()
1856{
1857	if [ -n "$3" ]; then
1858		flags="$3"
1859	fi
1860	/sbin/mdmfs $flags -s $1 ${mfs_type} $2
1861}
1862
1863# Code common to scripts that need to load a kernel module
1864# if it isn't in the kernel yet. Syntax:
1865#   load_kld [-e regex] [-m module] file
1866# where -e or -m chooses the way to check if the module
1867# is already loaded:
1868#   regex is egrep'd in the output from `kldstat -v',
1869#   module is passed to `kldstat -m'.
1870# The default way is as though `-m file' were specified.
1871load_kld()
1872{
1873	local _loaded _mod _opt _re
1874
1875	while getopts "e:m:" _opt; do
1876		case "$_opt" in
1877		e) _re="$OPTARG" ;;
1878		m) _mod="$OPTARG" ;;
1879		*) err 3 'USAGE: load_kld [-e regex] [-m module] file' ;;
1880		esac
1881	done
1882	shift $(($OPTIND - 1))
1883	if [ $# -ne 1 ]; then
1884		err 3 'USAGE: load_kld [-e regex] [-m module] file'
1885	fi
1886	_mod=${_mod:-$1}
1887	_loaded=false
1888	if [ -n "$_re" ]; then
1889		if kldstat -v | egrep -q -e "$_re"; then
1890			_loaded=true
1891		fi
1892	else
1893		if kldstat -q -m "$_mod"; then
1894			_loaded=true
1895		fi
1896	fi
1897	if ! $_loaded; then
1898		if ! kldload "$1"; then
1899			warn "Unable to load kernel module $1"
1900			return 1
1901		else
1902			info "$1 kernel module loaded."
1903		fi
1904	else
1905		debug "load_kld: $1 kernel module already loaded."
1906	fi
1907	return 0
1908}
1909
1910# ltr str src dst [var]
1911#	Change every $src in $str to $dst.
1912#	Useful when /usr is not yet mounted and we cannot use tr(1), sed(1) nor
1913#	awk(1). If var is non-NULL, set it to the result.
1914ltr()
1915{
1916	local _str _src _dst _out _com _var
1917	_str="$1"
1918	_src="$2"
1919	_dst="$3"
1920	_var="$4"
1921	_out=""
1922
1923	local IFS="${_src}"
1924	for _com in ${_str}; do
1925		if [ -z "${_out}" ]; then
1926			_out="${_com}"
1927		else
1928			_out="${_out}${_dst}${_com}"
1929		fi
1930	done
1931	if [ -n "${_var}" ]; then
1932		setvar "${_var}" "${_out}"
1933	else
1934		echo "${_out}"
1935	fi
1936}
1937
1938# Creates a list of providers for GELI encryption.
1939geli_make_list()
1940{
1941	local devices devices2
1942	local provider mountpoint type options rest
1943
1944	# Create list of GELI providers from fstab.
1945	while read provider mountpoint type options rest ; do
1946		case ":${options}" in
1947		:*noauto*)
1948			noauto=yes
1949			;;
1950		*)
1951			noauto=no
1952			;;
1953		esac
1954
1955		case ":${provider}" in
1956		:#*)
1957			continue
1958			;;
1959		*.eli)
1960			# Skip swap devices.
1961			if [ "${type}" = "swap" -o "${options}" = "sw" -o "${noauto}" = "yes" ]; then
1962				continue
1963			fi
1964			devices="${devices} ${provider}"
1965			;;
1966		esac
1967	done < /etc/fstab
1968
1969	# Append providers from geli_devices.
1970	devices="${devices} ${geli_devices}"
1971
1972	for provider in ${devices}; do
1973		provider=${provider%.eli}
1974		provider=${provider#/dev/}
1975		devices2="${devices2} ${provider}"
1976	done
1977
1978	echo ${devices2}
1979}
1980
1981# Originally, root mount hold had to be released before mounting
1982# the root filesystem.  This delayed the boot, so it was changed
1983# to only wait if the root device isn't readily available.  This
1984# can result in rc scripts executing before all the devices - such
1985# as graid(8), or USB disks - can be accessed.  This function can
1986# be used to explicitly wait for root mount holds to be released.
1987root_hold_wait()
1988{
1989	local wait waited holders
1990
1991	waited=0
1992	while true; do
1993		holders="$(sysctl -n vfs.root_mount_hold)"
1994		if [ -z "${holders}" ]; then
1995			break;
1996		fi
1997		if [ ${waited} -eq 0 ]; then
1998			echo -n "Waiting ${root_hold_delay}s" \
1999			"for the root mount holders: ${holders}"
2000		else
2001			echo -n .
2002		fi
2003		if [ ${waited} -ge ${root_hold_delay} ]; then
2004			echo
2005			break
2006		fi
2007		sleep 1
2008		waited=$(($waited + 1))
2009	done
2010}
2011
2012# Find scripts in local_startup directories that use the old syntax
2013#
2014find_local_scripts_old() {
2015	zlist=''
2016	slist=''
2017	for dir in ${local_startup}; do
2018		if [ -d "${dir}" ]; then
2019			for file in ${dir}/[0-9]*.sh; do
2020				grep '^# PROVIDE:' $file >/dev/null 2>&1 &&
2021				    continue
2022				zlist="$zlist $file"
2023			done
2024			for file in ${dir}/[!0-9]*.sh; do
2025				grep '^# PROVIDE:' $file >/dev/null 2>&1 &&
2026				    continue
2027				slist="$slist $file"
2028			done
2029		fi
2030	done
2031}
2032
2033find_local_scripts_new() {
2034	local_rc=''
2035	for dir in ${local_startup}; do
2036		if [ -d "${dir}" ]; then
2037			for file in `grep -l '^# PROVIDE:' ${dir}/* 2>/dev/null`; do
2038				case "$file" in
2039				*.sample) ;;
2040				*)	if [ -x "$file" ]; then
2041						local_rc="${local_rc} ${file}"
2042					fi
2043					;;
2044				esac
2045			done
2046		fi
2047	done
2048}
2049
2050# check_required_{before|after} command
2051#	Check for things required by the command before and after its precmd,
2052#	respectively.  The two separate functions are needed because some
2053#	conditions should prevent precmd from being run while other things
2054#	depend on precmd having already been run.
2055#
2056check_required_before()
2057{
2058	local _f
2059
2060	case "$1" in
2061	start)
2062		for _f in $required_vars; do
2063			if ! checkyesno $_f; then
2064				warn "\$${_f} is not enabled."
2065				if [ -z "$rc_force" ]; then
2066					return 1
2067				fi
2068			fi
2069		done
2070
2071		for _f in $required_dirs; do
2072			if [ ! -d "${_f}/." ]; then
2073				warn "${_f} is not a directory."
2074				if [ -z "$rc_force" ]; then
2075					return 1
2076				fi
2077			fi
2078		done
2079
2080		for _f in $required_files; do
2081			if [ ! -r "${_f}" ]; then
2082				warn "${_f} is not readable."
2083				if [ -z "$rc_force" ]; then
2084					return 1
2085				fi
2086			fi
2087		done
2088		;;
2089	esac
2090
2091	return 0
2092}
2093
2094check_required_after()
2095{
2096	local _f _args
2097
2098	case "$1" in
2099	start)
2100		for _f in $required_modules; do
2101			case "${_f}" in
2102				*~*)	_args="-e ${_f#*~} ${_f%%~*}" ;;
2103				*:*)	_args="-m ${_f#*:} ${_f%%:*}" ;;
2104				*)	_args="${_f}" ;;
2105			esac
2106			if ! load_kld ${_args}; then
2107				if [ -z "$rc_force" ]; then
2108					return 1
2109				fi
2110			fi
2111		done
2112		;;
2113	esac
2114
2115	return 0
2116}
2117
2118# check_jail mib
2119#	Return true if security.jail.$mib exists and set to 1.
2120
2121check_jail()
2122{
2123	local _mib _v
2124
2125	_mib=$1
2126	if _v=$(${SYSCTL_N} "security.jail.$_mib" 2> /dev/null); then
2127		case $_v in
2128		1)	return 0;;
2129		esac
2130	fi
2131	return 1
2132}
2133
2134# check_kern_features mib
2135#	Return existence of kern.features.* sysctl MIB as true or
2136#	false.  The result will be cached in $_rc_cache_kern_features_
2137#	namespace.  "0" means the kern.features.X exists.
2138
2139check_kern_features()
2140{
2141	local _v
2142
2143	[ -n "$1" ] || return 1;
2144	eval _v=\$_rc_cache_kern_features_$1
2145	[ -n "$_v" ] && return "$_v";
2146
2147	if ${SYSCTL_N} kern.features.$1 > /dev/null 2>&1; then
2148		eval _rc_cache_kern_features_$1=0
2149		return 0
2150	else
2151		eval _rc_cache_kern_features_$1=1
2152		return 1
2153	fi
2154}
2155
2156# check_namevarlist var
2157#	Return "0" if ${name}_var is reserved in rc.subr.
2158
2159_rc_namevarlist="program chroot chdir env flags fib nice user group groups prepend"
2160check_namevarlist()
2161{
2162	local _v
2163
2164	for _v in $_rc_namevarlist; do
2165	case $1 in
2166	$_v)	return 0 ;;
2167	esac
2168	done
2169
2170	return 1
2171}
2172
2173# _echoonce var msg mode
2174#	mode=0: Echo $msg if ${$var} is empty.
2175#	        After doing echo, a string is set to ${$var}.
2176#
2177#	mode=1: Echo $msg if ${$var} is a string with non-zero length.
2178#
2179_echoonce()
2180{
2181	local _var _msg _mode
2182	eval _var=\$$1
2183	_msg=$2
2184	_mode=$3
2185
2186	case $_mode in
2187	1)	[ -n "$_var" ] && echo "$_msg" ;;
2188	*)	[ -z "$_var" ] && echo -n "$_msg" && eval "$1=finished" ;;
2189	esac
2190}
2191
2192# If the loader env variable rc.debug is set, turn on debugging. rc.conf will
2193# still override this, but /etc/defaults/rc.conf can't unconditionally set this
2194# since it would undo what we've done here.
2195if kenv -q rc.debug > /dev/null ; then
2196	rc_debug=YES
2197fi
2198