svclock="/var/lib/init.d/locks"

svclock=${svclock:-/var/lib/init.d/locks}

	# Create locking directory

	if [[ ! -d "${svclock}" ]] ; then

		if ! mkdir -p -m 0755 "${svclock}" 2>/dev/null ; then

			eerror "Could not create needed directory '${svclock}'!"

		fi

	fi

	rm -rf "${svclock}"/* 2>/dev/null

				lock "${x}"

				unlock "${x}"

# Callers should hold lock

		lock "${i}"

		unlock "${i}"

		lock "${i}"

		unlock "${i}"

	lock "${i}"

	unlock "${i}"

[[ ${RC_GOT_LOCKING} != "yes" ]] && source "${svclib}/sh/rc-locking.sh"

			lock "net.lo"

# Distributed under the terms of the GNU General Public License v2

RC_GOT_LOCKING="yes"

[[ ${RC_GOT_FUNCTIONS} != "yes" ]] && source /sbin/functions.sh

lock() {

	[[ ! -w ${svclock} ]] && return 0

	local lock="${svclock}/$1"

	until mkfifo "${lock}" 2>/dev/null; do

		cat "${lock}" 2>/dev/null

	done

}

unlock() {

	[[ ! -w ${svclock} ]] && return 0

	local lock="${svclock}/$1"

	local tmp="${lock}.$$"

	mv "${lock}" "${tmp}"

	touch "${tmp}"

	rm -f "${tmp}"

}

[[ ${RC_GOT_LOCKING} != "yes" ]] && source "${svclib}/sh/rc-locking.sh"

		lock "${service}"

		unlock "${service}"

		lock "${SVCNAME}"

				lock "${x}"

				unlock "${x}"

		unlock "${SVCNAME}"

		lock "${SVCNAME}"

		lock "${SVCNAME}"

		unlock "${SVCNAME}"

		lock "${SVCNAME}"

		unlock "${SVCNAME}"

		lock "${SVCNAME}"

		unlock "${SVCNAME}"

		lock "${SVCNAME}"

		unlock "${SVCNAME}"

		lock "${SVCNAME}"

		unlock "${SVCNAME}"

[[ ${RC_GOT_FUNCTIONS} != "yes" ]] && source /sbin/functions.sh

# State variables

svcpause="no"

# Functions to handle dependencies and services

[[ ${RC_GOT_SERVICES} != "yes" ]] && source "${svclib}/sh/rc-services.sh"

# Functions to control daemons

[[ ${RC_GOT_DAEMON} != "yes" ]] && source "${svclib}/sh/rc-daemon.sh"

# Source configuration files.

# (1) Source /etc/conf.d/net if it is a net.* service

# (2) Source /etc/conf.d/${SVCNAME} to get initscript-specific

#     configuration (if it exists).

# (3) Source /etc/rc.conf to pick up potentially overriding

#     configuration, if the system administrator chose to put it

#     there (if it exists).

if net_service "${SVCNAME}" ; then

	conf="$(add_suffix /etc/conf.d/net)"

	[[ -e ${conf} ]] && source "${conf}"

fi

conf="$(add_suffix "/etc/conf.d/${SVCNAME}")"

[[ -e ${conf} ]] && source "${conf}"

conf="$(add_suffix /etc/rc.conf)"

[[ -e ${conf} ]] && source "${conf}"

mylevel="${SOFTLEVEL}"

[[ ${SOFTLEVEL} == "${BOOTLEVEL}" \

	|| ${SOFTLEVEL} == "reboot" || ${SOFTLEVEL} == "shutdown" ]] \

	&& mylevel="${DEFAULTLEVEL}"

# Call svc_quit if we abort AND we have obtained a lock

#lock "${SVCNAME}"

#service_started "${SVCNAME}"

#svcstarted="$?"

#service_inactive "${SVCNAME}"

#svcinactive="$?"

#unlock "${SVCNAME}"

svc_trap() {

	trap 'eerror "ERROR:  ${SVCNAME} caught an interrupt"; exit 1' \

		INT QUIT TSTP

}

# Setup a default trap

svc_trap

svc_quit() {

	eerror "ERROR:  ${SVCNAME} caught an interrupt"

	if service_inactive "${SVCNAME}" || [[ ${svcinactive} == "0" ]] ; then

		mark_service_inactive "${SVCNAME}"

	elif [[ ${svcstarted} == "0" ]] ; then

		mark_service_started "${SVCNAME}"

	else

		mark_service_stopped "${SVCNAME}"

	fi

	exit 1

}

stop() {

	# Return success so the symlink gets removed

	return 0

}

start() {

	eerror "ERROR:  ${SVCNAME} does not have a start function."

	# Return failure so the symlink doesn't get created

	return 1

}

restart() {

	if ! service_stopped "${SVCNAME}" ; then

		svc_stop || return "$?"

	fi

	svc_start

}

status() {

	# Dummy function

	return 0

}

svc_schedule_start() {

	local service="$1" start="$2"

	[[ ! -d "${svcdir}/scheduled/${service}" ]] \

		&& mkdir -p "${svcdir}/scheduled/${service}"

	ln -snf "/etc/init.d/${service}" \

		"${svcdir}/scheduled/${service}/${start}"

}

svc_start_scheduled() {

	[[ ! -d "${svcdir}/scheduled/${SVCNAME}" ]] && return

	local x= services=

	# If we're being started in the background, then don't

	# tie up the daemon that called us starting our scheduled services

	if [[ ${IN_BACKGROUND} == "true" || ${IN_BACKGROUND} == "1" ]] ; then

		unset IN_BACKGROUND

		svc_start_scheduled &

		export IN_BACKGROUND=true

		return

	fi

	lock "${SVCNAME}"

	for x in $(dolisting "${svcdir}/scheduled/${SVCNAME}/") ; do

		services="${services} ${x##*/}"

	done

	unlock "${SVCNAME}"

	for x in $(trace_dependencies ${services}) ; do

		lock "${x}"

		service_stopped "${x}" && start_service "${x}"

		unlock "${x}"

		rm -f "${svcdir}/scheduled/${SVCNAME}/${x}"

	done

	rmdir "${svcdir}/scheduled/${SVCNAME}"

}

svc_stop() {

	local x= mydep= mydeps= retval=0

	local -a servicelist=()

	# Do not try to stop if it had already failed to do so

	if is_runlevel_stop && service_failed "${SVCNAME}" ; then

		return 1

	elif service_stopped "${SVCNAME}" ; then

		if [[ ${IN_HOTPLUG} != "1" ]] ; then

			ewarn "WARNING:  ${SVCNAME} has not yet been started."

		fi

		return 0

	fi

	if ! mark_service_stopping "${SVCNAME}" ; then

		if [[ ${IN_HOTPLUG} != "1" ]] ; then

			eerror "ERROR:  ${SVCNAME} is already stopping."

		fi

		return 1

	fi

	# Ensure that we clean up if we abort for any reason

	trap "svc_quit" INT QUIT TSTP

	mark_service_starting "${SVCNAME}"

	service_message "Service ${SVCNAME} stopping"

	if in_runlevel "${SVCNAME}" "${BOOTLEVEL}" && \

	   [[ ${SOFTLEVEL} != "reboot" && ${SOFTLEVEL} != "shutdown" && \

	      ${SOFTLEVEL} != "single" ]] ; then

		ewarn "WARNING:  you are stopping a boot service."

	fi

	if [[ ${svcpause} != "yes" && ${RC_NO_DEPS} != "yes" ]] \

		&& ! service_wasinactive "${SVCNAME}" ; then

		if net_service "${SVCNAME}" ; then

			if is_runlevel_stop || ! is_net_up "${SVCNAME}" ; then

				mydeps="net"

			fi

		fi

		mydeps="${mydeps} ${SVCNAME}"

	fi

	# Save the IN_BACKGROUND var as we need to clear it for stopping depends

	local ib_save="${IN_BACKGROUND}"

	unset IN_BACKGROUND

	for mydep in ${mydeps} ; do

		for x in $(needsme "${mydep}") ; do

			if service_started "${x}" || service_inactive "${x}" ; then

				stop_service "${x}"

			fi

			service_list=( "${service_list[@]}" "${x}" )

		done

	done

	for x in "${service_list[@]}" ; do

		service_stopped "${x}" && continue

		wait_service "${x}"

		if ! service_stopped "${x}" ; then

			eerror "ERROR:  cannot stop ${SVCNAME} as ${x} is still up."

			retval=1

			break

		fi

	done

	IN_BACKGROUND="${ib_save}"

	if [[ ${retval} == "0" ]] ; then

		# Now that deps are stopped, stop our service

		(

		exit() {

			RC_QUIET_STDOUT="no"

			eerror "DO NOT USE EXIT IN INIT.D SCRIPTS"

			eerror "This IS a bug, please fix your broken init.d"

			unset -f exit

			exit "$@"

		}

		# Stop einfo/ebegin/eend from working as parallel messes us up

		if [[ ${RC_PARALLEL_STARTUP} == "yes" ]] ; then

			[[ ${RC_VERBOSE} != "yes" \

			|| -e ${svcdir}/exclusive/${SVCNAME} ]] \

				&& RC_QUIET_STDOUT="yes"

		fi

		stop

		)

		retval="$?"

		# If a service has been marked inactive, exit now as something

		# may attempt to start it again later

		if [[ ${retval} == "0" ]] && service_inactive "${SVCNAME}" ; then

			svcinactive=0

			return 0

		fi

	fi

	if [[ ${retval} != 0 ]] ; then

		# Did we fail to stop? create symlink to stop multible attempts at

		# runlevel change.  Note this is only used at runlevel change ...

		is_runlevel_stop && mark_service_failed "${SVCNAME}"

		# If we are halting the system, do it as cleanly as possible

		if [[ ${SOFTLEVEL} == "reboot" || ${SOFTLEVEL} == "shutdown" ]] ; then

			mark_service_stopped "${SVCNAME}"

		else

			if [[ ${svcinactive} == "0" ]] ; then

				mark_service_inactive "${SVCNAME}"

			else

				mark_service_started "${SVCNAME}"

			fi

		fi

		service_message "eerror" "ERROR:  ${SVCNAME} failed to stop"

	else

		svcstarted=1

		if service_inactive "${SVCNAME}" ; then

			svcinactive=0

		else

			mark_service_stopped "${SVCNAME}"

		fi

		service_message "Service ${SVCNAME} stopped"

	fi

	# Reset the trap

	svc_trap

	return "${retval}"

}

svc_start() {

	local x= y= retval=0 startinactive=

	# Do not try to start if i have done so already on runlevel change

	if is_runlevel_start && service_failed "${SVCNAME}" ; then

		return 1

	elif service_started "${SVCNAME}" ; then

		if [[ ${IN_HOTPLUG} != "1" ]] ; then

			ewarn "WARNING:  ${SVCNAME} has already been started."

		fi

		return 0

	elif service_inactive "${SVCNAME}" ; then

		if [[ ${IN_BACKGROUND} != "true" ]] ; then

			if [[ ${IN_HOTPLUG} != "1" ]] ; then

				ewarn "WARNING:  ${SVCNAME} has already been started."

			fi

			return 0

		fi

	fi

	if ! mark_service_starting "${SVCNAME}" ; then

		if service_stopping "${SVCNAME}" ; then

			eerror "ERROR:  ${SVCNAME} is already stopping."

		else

			eerror "ERROR:  ${SVCNAME} is already starting."

		fi

		return 1

	fi

	# Ensure that we clean up if we abort for any reason

	trap "svc_quit" INT QUIT TSTP

	service_message "Service ${SVCNAME} starting"

	if broken "${SVCNAME}" ; then

		eerror "ERROR:  Some services needed are missing.  Run"

		eerror "        './${SVCNAME} broken' for a list of those"

		eerror "        services.  ${SVCNAME} was not started."

		retval=1

	fi

	# Save the IN_BACKGROUND var as we need to clear it for starting depends

	local ib_save="${IN_BACKGROUND}"

	unset IN_BACKGROUND

	if [[ ${retval} == "0" && ${RC_NO_DEPS} != "yes" ]] ; then

		local startupservices="$(ineed "${SVCNAME}") $(valid_iuse "${SVCNAME}")"

		local netservices=

		for x in $(dolisting "/etc/runlevels/${BOOTLEVEL}/net.*") \

			$(dolisting "/etc/runlevels/${mylevel}/net.*") \

			$(dolisting "/var/lib/init.d/coldplugged/net.*") ; do

			netservices="${netservices} ${x##*/}"

		done

		# Start dependencies, if any.

		if ! is_runlevel_start ; then

			for x in ${startupservices} ; do

				if [[ ${x} == "net" ]] && ! net_service "${SVCNAME}" \

					&& ! is_net_up ; then

					for y in ${netservices} ; do

						service_stopped "${y}" && start_service "${y}"

					done

				elif [[ ${x} != "net" ]] ; then

					service_stopped "${x}" && start_service "${x}"

				fi

			done

		fi

		# We also wait for any services we're after to finish incase they

		# have a "before" dep but we don't dep on them.

		if is_runlevel_start ; then

			startupservices="${startupservices} $(valid_iafter "${SVCNAME}")"

			if net_service "${SVCNAME}" ; then

				startupservices="${startupservices} $(valid_iafter "net")"

			fi

		fi

		if [[ " ${startupservices} " == *" net "* ]] ; then

			startupservices=" ${startupservices} "

			startupservices="${startupservices/ net / ${netservices} }"

			startupservices="${startupservices// net /}"

		fi

		# Wait for dependencies to finish.

		for x in ${startupservices} ; do

			lock "${x}"

			if service_started "${x}"; then

				unlock "${x}"

				continue

			fi

			wait_service "${x}"

			if ! service_started "${x}" ; then

				# A 'need' dependency is critical for startup

				if ineed -t "${SVCNAME}" "${x}" >/dev/null \

					|| ( net_service "${x}" && ineed -t "${SVCNAME}" net \

					&& ! is_net_up ) ; then

					if service_inactive "${x}" || service_wasinactive "${x}" || \

						[[ -n $(dolisting "${svcdir}"/scheduled/*/"${x}") ]] ; then

						svc_schedule_start "${x}" "${SVCNAME}"

						[[ -n ${startinactive} ]] && startinactive="${startinactive}, "

						startinactive="${startinactive}${x}"

					else

						eerror "ERROR:  cannot start ${SVCNAME} as ${x} could not start"

						retval=1

						unlock "${x}"

						break

					fi

				fi

			fi

			unlock "${x}"

		done

		if [[ -n ${startinactive} && ${retval} == "0" ]] ; then

			# Change the last , to or for correct grammar.

			x="${startinactive##*, }"

			startinactive="${startinactive/%, ${x}/ or ${x}}"

			ewarn "WARNING:  ${SVCNAME} is scheduled to start when ${startinactive} has started."

			retval=1

		fi

	fi

	if [[ ${retval} == "0" ]] ; then

		IN_BACKGROUND="${ib_save}"

		(

		exit() {

			RC_QUIET_STDOUT="no"

			eerror "DO NOT USE EXIT IN INIT.D SCRIPTS"

			eerror "This IS a bug, please fix your broken init.d"

			unset -f exit

			exit "$@"

		}

		# Apply any ulimits if defined

		[[ -n ${RC_ULIMIT} ]] && ulimit ${RC_ULIMIT}

		# Stop einfo/ebegin/eend from working as parallel messes us up

		if [[ ${RC_PARALLEL_STARTUP} == "yes" ]] ; then

			[[ ${RC_VERBOSE} != "yes" \

			|| -e ${svcdir}/exclusive/${SVCNAME} ]] \

				&& RC_QUIET_STDOUT="yes"

		fi

		start

		)

		retval="$?"

		# If a service has been marked inactive, exit now as something

		# may attempt to start it again later

		if [[ ${retval} == "0" ]] && service_inactive "${SVCNAME}" ; then

			svcinactive=0

			service_message "ewarn" "WARNING:  ${SVCNAME} has started but is inactive"

			return 1

		fi

	fi

	if [[ ${retval} != "0" ]] ; then

		if [[ ${svcinactive} == "0" ]] ; then

			mark_service_inactive "${SVCNAME}"

		else

			mark_service_stopped "${SVCNAME}"

		fi

		if [[ -z ${startinactive} ]] ; then

			is_runlevel_start && mark_service_failed "${SVCNAME}"

			service_message "eerror" "ERROR:  ${SVCNAME} failed to start"

		fi

	else

		svcstarted=0

		mark_service_started "${SVCNAME}"

		service_message "Service ${SVCNAME} started"

	fi

	# Reset the trap

	svc_trap

	return "${retval}"

}

svc_restart() {

	# We don't kill child processes if we're restarting

	# This is especically important for sshd ....

	RC_KILL_CHILDREN="no"

	# Create a snapshot of started services

	rm -rf "${svcdir}/snapshot/$$"

	mkdir -p "${svcdir}/snapshot/$$"

	cp -pPR "${svcdir}"/started/* "${svcdir}"/inactive/* \

	"${svcdir}/snapshot/$$/" 2>/dev/null

	rm -f "${svcdir}/snapshot/$$/${SVCNAME}"

	# Simple way to try and detect if the service use svc_{start,stop}

	# to restart if it have a custom restart() funtion.

	if [[ -n $(egrep '^[[:space:]]*restart[[:space:]]*()' "/etc/init.d/${SVCNAME}") ]] ; then

		if [[ -z $(egrep 'svc_stop' "/etc/init.d/${SVCNAME}") || \

			-z $(egrep 'svc_start' "/etc/init.d/${SVCNAME}") ]] ; then

			echo

			ewarn "Please use 'svc_stop; svc_start' and not 'stop; start' to"

			ewarn "restart the service in its custom 'restart()' function."

			ewarn "Run ${SVCNAME} without arguments for more info."

			echo

			if ! service_stopped "${SVCNAME}" ; then

				svc_stop || return "$?"

			fi

			svc_start

		else

			restart

		fi

	else

		restart

	fi

	retval="$?"

	[[ -e "${svcdir}/scheduled/${SVCNAME}" ]] \

		&& rm -Rf "${svcdir}/scheduled/${SVCNAME}"

	# Restart dependencies as well

	for x in $(dolisting "${svcdir}/snapshot/$$/") ; do

		x="${x##*/}"

		lock "${x}"

		if [[ -x /etc/init.d/"${x}" ]] && service_stopped "${x}" ; then

			if service_inactive "${SVCNAME}" \

			|| service_wasinactive "${SVCNAME}" ; then

				svc_schedule_start "${SVCNAME}" "${x}"

				ewarn "WARNING:  ${x} is scheduled to start when ${SVCNAME} has started."

			elif service_started "${SVCNAME}" ; then

				start_service "${x}"

			fi

		fi

		unlock "${x}"

	done

	rm -rf "${svcdir}/snapshot/$$"

	service_started "${SVCNAME}"

	started="$?"

	if [[ ${started} == 0 ]]; then

		unlock "${SVCNAME}"

		svc_start_scheduled

		lock "${SVCNAME}"

	fi

	# Wait for services to come up

	if [[ ${IN_BACKGROUND} != "true" \

		&& ${IN_BACKGROUND} != "1" ]] ; then

		[[ ${RC_PARALLEL_STARTUP} == "yes" ]] && wait

	fi

	return ${retval}

}

svc_status() {

	# The basic idea here is to have some sort of consistent

	# output in the status() function which scripts can use

	# as an generic means to detect status.  Any other output

	# should thus be formatted in the custom status() function

	# to work with the printed " * status:  foo".

	local efunc="" state=""

	# If we are effectively root, check to see if required daemons are running

	# and update our status accordingly

	[[ ${EUID} == 0 ]] && update_service_status "${SVCNAME}"

	if service_stopping "${SVCNAME}" ; then

		efunc="eerror"

		state="stopping"

	elif service_starting "${SVCNAME}" ; then

		efunc="einfo"

		state="starting"

	elif service_inactive "${SVCNAME}" ; then

		efunc="ewarn"

		state="inactive"

	elif service_started "${SVCNAME}" ; then

		efunc="einfo"

		state="started"

	else

		efunc="eerror"

		state="stopped"

	fi

	[[ ${RC_QUIET_STDOUT} != "yes" ]] \

		&& ${efunc} "status:  ${state}"

	status

	# Return 0 if started, otherwise 1

	[[ ${state} == "started" ]]

}