#!/sbin/runscript
# Copyright (c) 2004-2005 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-src/rc-scripts/net-scripts/init.d/net.lo,v 1.38.2.19 2005/05/16 18:45:35 uberlord Exp $

# Contributed by Roy Marples (uberlord@gentoo.org)
# Many thanks to Aron Griffis (agriffis@gentoo.org)
# for help, ideas and patches

#NB: Config is in /etc/conf.d/net

if [[ -n ${NET_DEBUG} ]]; then
	set -x
	devnull=/dev/stderr
else
	devnull=/dev/null
fi

# For pcmcia users. note that pcmcia must be added to the same
# runlevel as the net.* script that needs it.
depend() {
	use coldplug hotplug pcmcia usb isdn4linux wlan

	# Load any custom depend functions for the given interface
	# For example, br0 may need eth0 and eth1
	local iface=${myservice##*.}
	[[ $( type -t depend_${iface} ) == "function" ]] && depend_${iface}
}

# Define where our modules are
MODULES_DIR=/lib/rcscripts/net.modules.d

# Load some functions shared between ourselves and our dhcp helpers
source ${MODULES_DIR}/helpers.d/functions

# Make some wrappers to fudge after/before/need/use depend flags.
# These are callbacks so mods[i] will be set.
after() {
	local x="$*"
	[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
	eval "${MODULE}_after() { echo \"$x\"; }"
}
before() {
	local x="$*"
	[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
	eval "${MODULE}_before() { echo \"$x\"; }"
}
need() {
	local x="$*"
	[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
	eval "${MODULE}_need() { echo \"$x\"; }"
}
installed() {
	local x="$*"
	[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
	# We deliberately misspell this as _installed will probably be used
	# at some point
	eval "${MODULE}_instlled() { echo \"$x\"; }"
}

sort() {
	LC_ALL=C /bin/sort "$@"
}

# void module_class_wrap(char *module, char *provides)
# Setup class wrappers: interface_up -> iproute2_up, for example
module_class_wrap() {
	local module=${1} provides=${2} x 

	# Don't wrap functions if another module already has
	[[ $( type -t ${provides}_provides ) == function ]] && return

	for x in $( typeset -f | grep -o ^${module}_'[^ ]*' ); do
		eval "${provides}${x#${module}}() { ${x} \"\$@\"; }"
	done
}

# bool module_load_minimum(char *module)
#
# Does the minimum checking on a module - even when forcing
module_load_minimum() {
	local f=${1} MODULE=${1##*/}

	if [[ ! -f ${f} ]]; then
		eerror "${f} does not exist"
		return 1
	fi

	if ! source ${f} ; then
		eerror "${MODULE} failed a sanity check"
		return 1
	fi

	for f in check_installed provides check_depends depend; do
		[[ $( type -t ${MODULE}_${f} ) == function ]] && continue
		eerror "${MODULE} does not support the required function ${f}"
		return 1
	done

	# Wrap our before/after/need/use functions
	${MODULE}_depend

	return 0
}

# bool modules_load_auto()
#
# Load and check each module for sanity
# If the module is not installed, the functions are to be removed
modules_load_auto() {
	local e f i j beforefuncs afterfuncs diffs unload

	# Populate the MODULES array
	MODULES=( $( find ${MODULES_DIR}/ -maxdepth 1 -type f ! -name ".*" | sort ) )

	# Each of these sources into the global namespace, so it's
	# important that module functions and variables are prefixed with
	# the module name, for example iproute2_

	beforefuncs="$( typeset -F )"
	j=${#MODULES[@]}
	loaded_interface=false
	for (( i=0; i<j; i++ )); do

		unload=false
		module_load_minimum ${MODULES[i]} || unload=true
		MODULES[i]=${MODULES[i]##*/}

		! ${unload} && ${MODULES[i]}_check_installed false || unload=true

		if [[ ${MODULES[i]} == interface ]]; then
			eerror "interface is a reserved name - cannot load a module called interface"
			return 1
		fi

		afterfuncs="$( typeset -F )"
		if ${unload} ; then
			unset MODULES[i]
			unsetfuncs="${unsetfuncs} $( diff -U0 <( echo "${beforefuncs}" ) <( echo "${afterfuncs}" ) 2>/dev/null \
				| awk 'BEGIN { ORS = " "; } /+declare -f/ { print $3; }' )"
		fi
		beforefuncs="${afterfuncs}"

	done
	MODULES=( "${MODULES[@]}" )

	return 0
}


# bool modules_check_installed(void)
#
# Ensure that all modules have the required modules loaded
# This enables us to remove modules from the MODULES array
# Whilst other modules can still explicitly call them
# One example of this is essidnet which configures network
# settings for the specific ESSID connected to as the user
# may be using a daemon to configure wireless instead of our
# iwconfig module
modules_check_installed() {
	local i j missingdeps nmods=${#MODULES[@]}

	for (( i=0; i<nmods; i++ )); do
		[[ $( type -t ${MODULES[i]}_instlled ) != function ]] && continue
		for j in $( ${MODULES[i]}_instlled ); do
			missingdeps=true
			if [[ $( type -t ${j}_check_installed ) == function ]]; then
				${j}_check_installed && missingdeps=false
			fi
			${missingdeps} && unset MODULES[i] && unset PROVIDES[i] && break
		done
	done

	MODULES=( "${MODULES[@]}" )
	PROVIDES=( "${PROVIDES[@]}" )
}

# bool modules_check_user(void)
modules_check_user() {
	local -a umods
	local i j k l npref nmods=${#MODULES[@]}

	# Has the interface got any specific modules?
	eval umods=( \"\$\{modules_${iface}\[@\]\}\" )

	# Global setting follows interface-specific setting
	umods=( "${umods[@]}" "${modules[@]}" )

	# Add our preferred modules
	npref=3
	umods=( "${umods[@]}" "ifconfig" "dhcpcd" "iwconfig" )

	# First we strip any modules that conflict from user settings
	# So if the user specifies pump then we don't use dhcpcd
	for (( i=0; i<${#umods[@]}; i++ )); do
		# Some users will inevitably put "dhcp" in their modules
		# list.  To keep users from screwing up their system this
		# way, ignore this setting so that the default dhcp
		# module will be used.
		[[ ${umods[i]} == dhcp ]] && continue

		# We remove any modules we explicitly don't want
		if [[ ${umods[i]} == !* ]]; then
			for (( j=0; j<nmods; j++ )); do
				[[ -z ${MODULES[j]} ]] && continue
				if [[ ${umods[i]:1} == ${MODULES[j]} || ${umods[i]:1} == ${PROVIDES[j]} ]]; then
					# We may need to setup a class wrapper for it even though
					# we don't use it directly
					${MODULES[j]}_check_installed && module_class_wrap ${MODULES[j]}
					unset MODULES[j]
					unset PROVIDES[j]
					break
				fi
			done
			continue
		fi

		if [[ $( type -t ${umods[i]}_provides ) != function ]]; then
			# If the module is one of our preferred modules, then
			# ignore this error; whatever is available will be
			# used instead.
			(( i < ${#umods[@]} - npref )) || continue
			eerror "${umods[i]} is not a valid module (missing provides)"
			return 1
		fi

		# Ensure that the user specified module has its package installed
		if (( i < ${#umods[@]} - npref )); then
			# $1==true causes check_installed to report its own errors
			${umods[i]}_check_installed true || return 1
		else
			# If this happens on a preferred modules, ignore it;
			# whatever is available will be used instead.
			${umods[i]}_check_installed false || continue
		fi

		mod=$( ${umods[i]}_provides )
		for (( j=0; j<nmods; j++ )); do
			[[ -z ${MODULES[j]} ]] && continue
			if [[ ${PROVIDES[j]} == ${mod} && ${umods[i]} != ${MODULES[j]} ]]; then
				# We don't have a match - now ensure that we still provide an alternative.
				# This is to handle our preferred modules.
				for (( l=0; l<nmods; l++ )); do
					[[ ${l} -eq ${j} || -z ${MODULES[l]} ]] && continue
					if [[ ${PROVIDES[l]} == ${mod} ]]; then
						unset MODULES[j]
						unset PROVIDES[j]
						break
					fi
				done
			fi
		done
	done

	# Then we strip conflicting modules.
	# We only need to do this for 3rd party modules that conflict with
	# our own modules and the preferred list AND the user modules
	# list doesn't specify a preference.
	for (( i=0; i<nmods-1; i++ )); do
		[[ -z ${MODULES[i]} ]] && continue			
		for (( j=i+1; j<nmods; j++)); do
			[[ -z ${MODULES[j]} ]] && continue
			[[ ${PROVIDES[i]} == ${PROVIDES[j]} ]] && unset MODULES[j] && unset PROVIDES[j]
		done
	done

	MODULES=( "${MODULES[@]}" )
	PROVIDES=( "${PROVIDES[@]}" )
	return 0
}

# void modules_sort(void)

modules_sort() {
	local -a modnums sort_history modafter modbefore
	local i j k p changed_something nmods=${#MODULES[@]}

	# Sort our modules
	# We do this by assigning numbers to each module
	# We also assign modbefore and modafter so we don't
	# shell out as much because it's expensive on CPU.
	modnums=()
	for (( i=0; i<nmods; i++ )); do
		modnums[i]=${i}
		[[ $( type -t ${MODULES[i]}_after ) == function ]] && modafter[i]=$( ${MODULES[i]}_after )
		[[ $( type -t ${MODULES[i]}_before ) == function ]] && modbefore[i]=$( ${MODULES[i]}_before )
	done
	
	# Then we swap numbers based on and after/before flags
	# until we don't swap anymore. The sort_history array prevents
	# the possibility of an infinite loop
	sort_history[0]="${modnums[*]}"
	for (( k=1; 1; k++ )); do
		changed_something=false
		for (( i=0; i<nmods; i++ )); do
			for p in ${modafter[i]}; do
				for (( j=0; j<nmods; j++ )); do
					[[ ${p} != ${MODULES[j]} && ${p} != ${PROVIDES[j]} ]] && continue
					if [[ ${modnums[i]} -lt ${modnums[j]} ]]; then
						tmp=${modnums[i]}
						modnums[i]=${modnums[j]}
						modnums[j]=${tmp}
						changed_something=true
					fi
				done
			done
			for p in ${modbefore[i]}; do
				for (( j=0; j<nmods; j++ )); do
					[[ ${p} != ${MODULES[j]} && ${p} != ${PROVIDES[j]} ]] && continue
					if [[ ${modnums[i]} -gt ${modnums[j]} ]]; then
						tmp=${modnums[i]}
						modnums[i]=${modnums[j]}
						modnums[j]=${tmp}
						changed_something=true
					fi
				done
			done
		done
		${changed_something} || break

		# Make sure we aren't repeating a previous state
		# First time through, k=1, k/2=0
		sort_history[k]="${modnums[*]}"
		if [[ ${sort_history[k]} == ${sort_history[k/2]} ]]; then
			eerror "Detected an infinite loop sorting modules; blundering ahead"
			break
		fi
	done

	# Finally we sort our modules in number order
	um=""
	for (( i=0; i<nmods; i++ )); do
		um="${um}${modnums[i]} ${MODULES[i]} ${PROVIDES[i]}\n"
	done

	p=( $( echo -e "${um}" | sort -n | awk '{print $2,$3}' ) )
	MODULES=()
	PROVIDES=()
	j=0
	for (( i=0; i<${#p[@]}; i+=2 )); do
		MODULES[j]=${p[i]}
		PROVIDES[j]=${p[i+1]}
		(( j++ ))
	done
}

# bool modules_check_depends(bool showprovides)
modules_check_depends() {
	local showprovides=${1:-false} nmods=${#MODULES[@]} i j needmod
	local missingdeps p  interface=false

	for (( i=0; i<nmods; i++ )); do
		if [[ $( type -t ${MODULES[i]}_need ) == function ]]; then
			for needmod in $( ${MODULES[i]}_need ); do
				missingdeps=true
				for (( j=0; j<nmods; j++ )); do
					if [[ ${needmod} == ${MODULES[j]} || ${needmod} == ${PROVIDES[j]} ]]; then
						missingdeps=false
						break
					fi
				done
				if ${missingdeps} ; then
					eerror "${MODULES[i]} needs ${needmod} (dependency failure)"
					return 1
				fi
			done
		fi

		${MODULES[i]}_check_depends || return 1
		[[ ${PROVIDES[i]} == interface ]] && interface=true

		if ${showprovides} ; then
			[[ ${PROVIDES[i]} != ${MODULES[i]} ]] && veinfo "${MODULES[i]} provides ${PROVIDES[i]}"
		fi
	done

	if ! ${interface} ; then
		eerror "no interface module has been loaded"
		return 1
	fi

	return 0
}

# bool modules_load(char *iface, bool starting)
#
# Loads the defined handler and modules for the interface
# Returns 0 on success, otherwise 1
modules_load()  {
	local iface=${1} starting=${2:-true} mod p=false i j unsetfuncs
	local -a x
	local RC_INDENTATION=${RC_INDENTATION}	# so it will reset after function
	local -a PROVIDES

	if [[ ${iface} == lo ]]; then
		# We force lo to only use these modules for a major speed boost
		modules_force=( "iproute2" "ifconfig" )
	else
		eval x=( \"\$\{modules_force_${iface}\[@\]\}\" )
		[[ -n ${x} ]] && modules_force=( "${x[@]}" )
		if [[ -n ${modules_force} ]]; then
			ewarn "WARNING: You are forcing modules!"
			ewarn "Do not complain or file bugs if things start breaking"
			report=true
		fi
		veinfo "Loading networking modules for ${iface}"
	fi
	eindent

	if [[ -z ${modules_force} ]]; then
		modules_load_auto || return 1
	else
		j=${#modules_force[@]}
		for (( i=0; i<j; i++ )); do
			module_load_minimum "${MODULES_DIR}/${modules_force[i]}" || return 1
			${modules_force[i]}_check_installed || unset modules_force[i]
		done
		MODULES=( "${modules_force[@]}" )
	fi

	# We now buffer the _provides functions for a big speed boost
	j=${#MODULES[@]}
	for (( i=0; i<j; i++ )); do
		PROVIDES[i]=$( ${MODULES[i]}_provides )
	done

	if [[ -z ${modules_force[@]} ]]; then
		if ${starting}; then
			modules_check_user || return 1
		fi

		# We unset unloaded module functions here as so we can error
		# with a message informing the user to emerge the correct
		# package if it's in their modules
		[[ -n ${unsetfuncs} ]] && unset ${unsetfuncs}

		modules_sort
	fi

	# Setup class wrappers: interface_up -> iproute2_up, for example
	j=${#MODULES[@]}
	for (( i=0; i<j; i++ )); do
		module_class_wrap ${MODULES[i]} ${PROVIDES[i]}
	done

	modules_check_installed || return 1

	[[ ${iface} != lo ]] && veinfo "modules: ${MODULES[@]}"
	eindent

	[[ ${iface} != lo && ${starting} == true ]] && p=true
	modules_check_depends ${p} || return 1
	return 0
}

# bool iface_start(char *interface)
#
# iface_start is called from start.  It's expected to start the base
# interface (for example "eth0"), aliases (for example "eth0:1") and to start
# VLAN interfaces (for example eth0.0, eth0.1).  VLAN setup is accomplished by
# calling itself recursively.
iface_start() {
	local iface=${1} mod config_counter=-1 x warn=false config_worked=false
	local RC_INDENTATION=${RC_INDENTATION}	# so it will reset after function
	local -a config fallback fallback_route conf
	local ifvar=$( interface_variable ${iface} )

	# pre Start any modules with
	for mod in ${MODULES[@]}; do
		if [[ $( type -t ${mod}_pre_start ) == function ]]; then
			${mod}_pre_start ${iface} || { eend 1; return 1; }
		fi
	done

	# New style config - one variable fits all
	eval config=( \"\$\{config_${ifvar}\[@\]\}\" )
	eval fallback=( \"\$\{fallback_${ifvar}\[@\]\}\" )
	eval fallback_route=( \"\$\{fallback_route_${ifvar}\[@\]\}\" )

	# We must support old configs
	if [[ -z ${config} ]]; then
		interface_get_old_config ${iface} || return 1
	fi

	# Handle "noop" correctly
	if [[ ${config[0]} == "noop" ]]; then
		if interface_is_up ${iface} true ; then
			einfo "Keeping current configuration for ${iface}"
			eend 0
			return 0
		fi

		# Remove noop from the config var
		config=( "${config[@]:1}" )
	fi

	# Provide a default of DHCP if no configuration is set
	if [[ -z ${config} ]]; then
		if [[ $( type -t dhcp_start ) == function ]]; then
			config=( "dhcp" )
			warn=true
		else
			eerror "Cannot default to dhcp as there is no dhcp module loaded"
			eerror "No configuration for ${iface}"
			return 1
		fi
	fi

	einfo "Bringing up ${iface}"
	eindent
	for (( config_counter=0; config_counter<${#config[@]}; config_counter++ )); do
		# Handle null and noop correctly
		if [[ ${config[config_counter]} == "null" \
		|| ${config[config_counter]} == "noop" ]]; then
			eend 0
			config_worked=true
			continue
		fi

		if ${warn}; then
			ewarn "Configuration not set for ${iface} - assuming dhcp"
			warn=false
		fi

		# We convert it to an array - this has the added
		# bonus of trimming spaces!
		conf=( ${config[config_counter]} )
		einfo "${conf[0]}"

		# Do we have a function for our config?
		if [[ $( type -t ${conf[0]}_start ) == function ]]; then
			# Check that the module is valid
			x=false
			for mod in ${MODULES[@]}; do
				if [[ $( ${mod}_provides ) == ${conf[0]} ]]; then
					x=true
					break
				fi
			done

			if ! ${x}; then
				[[ $( type -t ${conf[0]}_check_installed == function ) ]] && ${conf[0]}_check_installed true
				eerror "No loaded modules provide \"${conf[0]}\" (${conf[0]}_start)"
			else
				eindent
				${conf[0]}_start ${iface} ; x=$?
				eoutdent
				[[ ${x} == 0 ]] && config_worked=true && continue
			fi
		# We need to test to see if it's an IP address or a function
		# We do this by testing if the 1st character is a digit
		elif [[ ${conf[0]:0:1} == [[:digit:]] || ${conf[0]} == *:* ]]; then
			x=0
#			if [[ $(type -t address_exists ) == function ]]; then
#				if address_exists ${iface} ${conf[0]} ; then
#					eerror "${conf[0]%%/*} already taken on ${iface}"
#					x=1
#				fi
#			fi
			[[ ${x} == 0 ]] && interface_add_address ${iface} ${conf[@]} ; x=$?
			eend ${x} && config_worked=true && continue
		else
			eerror "No loaded modules provide \"${conf[0]}\" (${conf[0]}_start)"
		fi

		if [[ -n ${fallback[config_counter]} ]]; then
			einfo "Trying fallback configuration"
			config[config_counter]=${fallback[config_counter]}
			fallback[config_counter]=''

			# Do we have a fallback route?
			if [[ -n ${fallback_route[config_counter]} ]]; then
				eval "routes_${ifvar}=( "\"\$\{fallback_route\[${config_counter}\]\[@\]\}\"" )"
				fallback_route[config_counter]=''
			fi

			(( config_counter-- )) # since the loop will increment it
			continue
		fi
	done
	eoutdent

	# We return failure if no configuration parameters worked
	${config_worked} || return 1

	# Start any modules with _post_start
	for mod in ${MODULES[@]}; do
		if [[ function == $( type -t ${mod}_post_start ) ]]; then
			${mod}_post_start ${iface} || return 1
		fi
	done

	return 0
}

# bool iface_stop(char *interface)
#
# iface_stop: bring down an interface.  Don't trust information in
# /etc/conf.d/net since the configuration might have changed since
# iface_start ran.  Instead query for current configuration and bring
# down the interface.
#
# However, we are currently reliant on handler and modules specified
# in /etc/conf.d/net
iface_stop() {
	local iface=${1} i aliases need_begin=false mod
	local RC_INDENTATION=${RC_INDENTATION}	# so it will reset after function

	# pre Stop any modules
	for mod in ${MODULES[@]}; do
		[[ $( type -t ${mod}_pre_stop ) == function ]] && ${mod}_pre_stop ${iface}
	done

	einfo "Bringing down ${iface}"
	eindent

	# Collect list of aliases for this interface.
	# List will be in reverse order.
	aliases=$( interface_get_aliases_rev ${iface} )

	# Stop aliases before primary interface.
	# Note this must be done in reverse order, since ifconfig eth0:1 
	# will remove eth0:2, etc.  It might be sufficient to simply remove 
	# the base interface but we're being safe here.
	for i in ${aliases} ${iface}; do
		# Stop all our modules
		for mod in ${MODULES[@]}; do
			[[ $( type -t ${mod}_stop ) == function ]] && ${mod}_stop ${i}
		done

		# A module may have removed the interface
		interface_exists ${iface} || { eend 0; continue; }

		# Delete all the addresses for this alias
		interface_del_addresses ${i}

		# Do final shut down of this alias
		ebegin "Shutting down ${i}"
		interface_iface_stop ${i}
		eend $?
	done

	# post Stop any modules
	for mod in ${MODULES[@]}; do
		# We have already taken down the interface, so no need to error
		[[ $( type -t ${mod}_post_stop ) == function ]] && ${mod}_post_stop ${iface}
	done

	return 0
}

# bool run_start(char *iface)
#
# Brings up ${IFACE}.  Calls preup, iface_start, then postup.
# Returns 0 (success) unless preup or iface_start returns 1 (failure).
# Ignores the return value from postup.
# We cannot check that the device exists ourselves as modules like
# tuntap make create it.
run_start() {
	local iface=${1} ifvar x

	if [[ ${iface} == lo ]]; then
		ebegin "Bringing up ${iface}"
		interface_loopback_create
		eend $?
		return $?
	fi

	# We may not have a loaded module for ${iface}
	# Some users may have "alias natsemi eth0" in /etc/modules.d/foo
	# so we can work with this
	# However, if they do the same with eth1 and try to start it
	# but eth0 has not been loaded then the module gets loaded as
	# eth0.
	# Not much we can do about this :(
	# Also, we cannot error here as some modules - such as bridge
	# create interfaces
	if ! interface_exists ${iface} ; then
		/sbin/modprobe ${iface} &>/dev/null
	fi

	# Setup variables for pre/post to use
	ifvar=$( interface_variable ${iface} )
	local IFACE=${iface} IFVAR=${ifvar}

	# Call user-defined preup function if it exists
	if [[ $( type -t preup ) == function ]]; then
		einfo "Running preup function"
		eindent
		preup ${iface} ; x=$?
		eoutdent
		if [[ ${x} != 0 ]]; then
			eerror "preup ${iface} failed"
			return 1
		fi
	fi

	# Don't let preup modify us
	iface=${1}
	local IFACE=${iface} IFVAR=${ifvar} config

	# If config is set to noop and the interface is up with an address
	# then we don't start it
	eval config=( \"\$\{config_${ifvar}\[@\]\}\" )
	if [[ ${config[0]} == "noop" ]] && interface_is_up ${iface} true ; then
		einfo "Keeping current configuration for ${iface}"
		eend 0
	else
		# Remove noop from the config var
		[[ ${config[0]} == "noop" ]] && eval "config_${ifvar}=( "\"\$\{config\[@\]:1\}\"" )"

		# There may be existing ip address info - so we strip it
		interface_del_addresses ${iface}

		# Start the interface
		if ! iface_start ${iface} ; then
			interface_down ${iface}
			eend 1
			return 1
		fi
	fi

	# Call user-defined postup function if it exists
	if [[ $( type -t postup ) == function ]]; then
		einfo "Running postup function"
		eindent
		postup ${iface}
		eoutdent
	fi

	return 0
}

# bool run_stop(char *iface) {
#
# Brings down ${iface}.  If predown call returns non-zero, then
# stop returns non-zero to indicate failure bringing down device.
# In all other cases stop returns 0 to indicate success.
run_stop() {
	local iface=${1} ifvar x

	# Don't run any special shutdown functions for lo
	if [[ ${iface} == lo ]]; then
		ebegin "Shutting down ${iface}"
		interface_iface_stop ${iface}
		eend $?
		return 0
	fi

	# Setup variables for pre/post to use
	ifvar=$( interface_variable ${iface} )
	local IFACE=${iface} IFVAR=${ifvar}

	# Call user-defined predown function if it exists
	if [[ $( type -t predown ) == function ]]; then
		einfo "Running predown function"
		eindent
		predown ${iface} ; x=$?
		eoutdent
		if [[ ${x} != 0 ]]; then
			eend 1 "predown ${iface} failed"
			return 1
		fi
	elif is_net_fs /; then
		eerror "root filesystem is network mounted -- can't stop ${iface}"
		return 1
	fi

	# Don't let predown modify us
	iface=${1}
	local IFACE=${iface} IFVAR=${ifvar}

	iface_stop ${iface} || return 1  # always succeeds, btw

	# Call user-defined postdown function if it exists
	if [[ $( type -t postdown ) == function ]]; then
		einfo "Running postdown function"
		eindent
		postdown ${iface}
		eoutdent
	fi

	return 0
}

# bool run(char *iface, char *cmd)
#
# Main start/stop entry point
# We load modules here and remove any functions that they
# added as we may be called inside the same shell scope for another interface
run() {
	local iface=${1} cmd=${2} r=1 RC_INDENTATION=${RC_INDENTATION}	# so it will reset after function
	local before starting=true
	local -a MODULES mods

	# We need to override the exit function as runscript.sh now checks
	# for it. We need it so we can mark the service as inactive ourselves.
	unset -f exit

	eindent

	unset_functions=${unset_functions:-false}
	${unset_functions} && before="$( typeset -F )"
	[[ ${cmd} == "stop" ]] && starting=false
	if modules_load ${iface} ${starting} ; then
		if [[ ${cmd} == "stop" ]]; then
			# Reverse the module list for stopping
			mods=( "${MODULES[@]}" )
			for ((i = 0; i < ${#mods[@]}; i++)); do
				MODULES[i]=${mods[((${#mods[@]} - i - 1))]}
			done

			run_stop ${iface} && r=0
		else
			run_start ${iface} && r=0
		fi
	fi

	# We need to remove added functions before we quit as other init
	# scripts may be launching afterwards
	${unset_functions} && \
	unset $( diff -U0 <( echo "${before}" ) <( echo "$( typeset -F )" ) 2>/dev/null \
		| awk 'BEGIN { ORS = " "; } /+declare -f/ { print $3; }' ) 2>/dev/null

	return ${r}
}

# bool start(void)
#
# Start entry point so that we only have one function
# which localises variables and unsets functions
start() {
	einfo "Starting ${IFACE}"
	run ${IFACE} start
	return $?
}

# bool stop(void)
#
# Stop entry point so that we only have one function
# which localises variables and unsets functions
stop() {
	einfo "Stopping ${IFACE}"
	run ${IFACE} stop
	return $?
}

# bool restart(void)
#
# Restart entry point
# We do this so as we only have to remove functions when stopping
restart() {
	local unset_functions=true
	service_started "${myservice}" && svc_stop
	unset_functions=false
	svc_start
	return $?
}

# vim:ts=4
