add net.lo

svn path=/baselayout-vserver/trunk/; revision=55

1 files changed, 954 insertions, 0 deletions

diff --git a/net-scripts/init.d/net.lo b/net-scripts/init.d/net.lo
new file mode 100755
index 0000000..c408a67
--- /dev/null
+++ b/net-scripts/init.d/net.lo
@@ -0,0 +1,954 @@
+#!/sbin/runscript
+# Copyright (c) 2004-2005 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+# 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
+
+# For pcmcia users. note that pcmcia must be added to the same
+# runlevel as the net.* script that needs it.
+depend() {
+	need localmount
+	use coldplug pcmcia usb isdn 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}
+
+	return 0
+}
+
+# Define where our modules are
+MODULES_DIR="/lib/rcscripts/net.modules.d"
+
+# Some defaults
+background="${background:-no}"
+
+# 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 MODULE 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 go_background(void)
+#
+# Setup for backgrounding network script
+go_background() {
+	einfo "Backgrounding ..."
+	mark_service_inactive "net.${iface}"
+	exit 0
+}
+
+# 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
+
+	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 i j
+
+	# Populate the MODULES array
+	# Basically we treat evey file in ${MODULES_DIR} as a module
+	MODULES=( $( cd "${MODULES_DIR}" ; ls ) )
+	j="${#MODULES[@]}"
+	for (( i=0; i<j; i++ )); do
+		MODULES[i]="${MODULES_DIR}/${MODULES[i]}"
+		[[ ! -f ${MODULES[i]} ]] && unset MODULES[i]
+	done
+	MODULES=( "${MODULES[@]}" )
+
+	# 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_
+
+	j="${#MODULES[@]}"
+	loaded_interface=false
+	for (( i=0; i<j; i++ )); do
+		if [[ ${MODULES[i]##*/} == "interface" ]]; then
+			eerror "interface is a reserved name - cannot load a module called interface"
+			return 1
+		fi
+		(
+		u=0;
+		module_load_minimum "${MODULES[i]}" || u=1;
+		[[ ${u} == 0 ]] && ${MODULES[i]##*/}_check_installed false || u=1;
+		exit "${u}";
+		)
+
+		if [[ $? == 0 ]]; then
+			source "${MODULES[i]}"
+			MODULES[i]="${MODULES[i]##*/}"
+		else
+			unset MODULES[i]
+		fi
+	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[@]}" "iproute2" "dhcpcd" "iwconfig" "netplugd" )
+
+	# 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
+					# However, we put it into an array and wrap later as
+					# another module may provide the same thing
+					${MODULES[j]}_check_installed \
+						&& WRAP_MODULES=(
+							"${WRAP_MODULES[@]}"
+							"${MODULES[j]} ${PROVIDES[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
+
+			# The function may not exist because the modules software is
+			# not installed. Load the module and report its error
+			if [[ -e "${MODULES_DIR}/${umods[i]}" ]]; then
+				source "${MODULES_DIR}/${umods[i]}"
+				${umods[i]}_check_installed true
+			else
+				eerror "The module \"${umods[i]}\" does not exist"
+			fi
+			return 1
+		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} == "${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 | cut -d' ' -f2,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}" MODULE p=false i j k
+	local -a x
+	local RC_INDENTATION="${RC_INDENTATION}"
+	local -a PROVIDES WRAP_MODULES
+
+	if [[ ${iface} != "lo" ]]; then
+		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
+	fi
+
+	veinfo "Loading networking modules for ${iface}"
+	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_force=( "${modules_force[@]}" )
+
+		# Strip any duplicate modules providing the same thing
+		j="${#modules_force[@]}"
+		for (( i=0; i<j-1; i++ )); do
+			[[ -z ${modules_force[i]} ]] && continue
+			for (( k=i+1; k<j; k++ )); do
+				[[ -z ${modules_force[k]} ]] && continue
+				[[ $( ${modules_force[i]}_provides ) \
+					== $( ${modules_force[k]}_provides ) ]] \
+					&& unset modules_force[k]
+			done
+		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
+	fi
+
+	# Setup class wrappers: interface_up -> iproute2_up, for example
+	j="${#MODULES[@]}"
+	for (( i=0; i<j; i++ )); do
+		function_wrap "${MODULES[i]}" "${PROVIDES[i]}"
+
+		# Now load our dependencies - we need to use the MODULE variable
+		# here as the after/before/need functions use it
+		if [[ -z ${modules_force[@]} ]]; then
+			MODULE="${MODULES[i]}"
+			${MODULE}_depend
+		fi
+	done
+
+	# Some modules may be installed, but not selected by user preference
+	# so we wrap these if needed
+	j="${#WRAP_MODULES[@]}"
+	for (( i=0; i<j; i++ )); do
+		function_wrap "${WRAP_MODULES[i]}"
+	done
+
+	if [[ -z ${modules_force[@]} ]]; then
+		modules_check_installed || return 1
+		modules_sort || return 1
+	fi
+
+	veinfo "modules: ${MODULES[@]}"
+	eindent
+
+	${starting} && 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 config_worked=false
+	local RC_INDENTATION="${RC_INDENTATION}"
+	local -a config fallback fallback_route conf a 
+	local ifvar=$( bash_variable "$1" ) i j
+
+	# Try and work out a metric for the interface if we're on auto
+	eval x=\"\$\{metric_${ifvar}\}\"
+	if [[ -z ${x} ]]; then
+		if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then
+			eval "metric_${ifvar}=\""$( calculate_metric ${iface} )"\""
+		else
+			eval "metric_${ifvar}=0"
+		fi
+	fi
+
+	# 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
+
+	# We now expand the configuration parameters and pray that the
+	# fallbacks expand to the same number as config or there will be
+	# trouble!
+	eval a=( \"\$\{config_${ifvar}\[@\]\}\" )
+	for (( i=0; i<${#a[@]}; i++ )); do 
+		local -a b=( $( expand_parameters "${a[i]}" ) )
+		config=( "${config[@]}" "${b[@]}" )
+	done
+
+	eval a=( \"\$\{fallback_${ifvar}\[@\]\}\" )
+	for (( i=0; i<${#a[@]}; i++ )); do 
+		local -a b=( $( expand_parameters "${a[i]}" ) )
+		fallback=( "${fallback[@]}" "${b[@]}" )
+	done
+
+	# We don't expand routes
+	eval fallback_route=( \"\$\{fallback_route_${ifvar}\[@\]\}\" )
+	
+	# We must support old configs
+	if [[ -z ${config} ]]; then
+		interface_get_old_config "${iface}" || return 1
+		if [[ -n ${config} ]]; then
+			ewarn "You are using a depreciated configuration syntax for ${iface}"
+			ewarn "You are advised to read /etc/conf.d/net.example and upgrade it accordingly"
+		fi
+	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 and we're auto
+	# Otherwise a default of NULL
+	if [[ -z ${config} ]]; then
+#		if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then
+			if [[ $( type -t "dhcp_start" ) == "function" ]]; then
+				config=( "dhcp" )
+				ewarn "Configuration not set for ${iface} - assuming dhcp"
+			else
+				eerror "Cannot default to dhcp as there is no dhcp module loaded"
+				eerror "No configuration for ${iface}"
+				return 1
+			fi
+#		else
+#			config=( "null" )
+#			ewarn "Configuration not set for ${iface} - assuming null"
+#		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
+
+		# 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
+			eindent
+			${conf[0]}_start "${iface}" ; x=$?
+			eoutdent
+			[[ ${x} == 0 ]] && config_worked=true && continue
+			# 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 [[ ${RC_AUTO_INTERFACE} == "yes" \
+				&& $(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 [[ $( type -t "${mod}_post_start" ) == "function" ]]; 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.
+iface_stop() {
+	local iface="$1" i aliases need_begin=false mod
+	local RC_INDENTATION="${RC_INDENTATION}"
+
+	# 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
+		if ! interface_exists "${iface}" ; then
+			eend 0
+			continue
+		fi
+
+		# Delete all the addresses for this alias
+		interface_del_addresses "${i}"
+
+		# Do final shut down of this alias
+		if ! ${IN_BACKGROUND}; then
+			ebegin "Shutting down ${i}"
+			interface_iface_stop "${i}"
+			eend "$?"
+		fi
+	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=$( bash_variable "$1" )
+
+	# We do this so users can specify additional addresses for lo if they
+	# need too - additional routes too
+	# However, no extra modules are loaded as they are just not needed
+	if [[ ${iface} == "lo" ]]; then
+		metric_lo="0"
+		config_lo=( "127.0.0.1/8 brd 127.255.255.255" "${config_lo[@]}" )
+		routes_lo=( "127.0.0.0/8" "${routes_lo[@]}" )
+	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
+
+	# Call user-defined preup function if it exists
+	if [[ $( type -t preup ) == "function" ]]; then
+		einfo "Running preup function"
+		eindent
+		( preup "${iface}" )
+		eend "$?" "preup ${iface} failed" || return 1
+		eoutdent
+	fi
+
+	# If config is set to noop and the interface is up with an address
+	# then we don't start it
+	local config
+	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_exists "${iface}" && 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=$( bash_variable "$1" ) x
+
+	# Load our ESSID variable so users can use it in predown() instead
+	# of having to write code.
+	local ESSID=$( get_options "ESSID" ) ESSIDVAR
+	[[ -n ${ESSID} ]] && ESSIDVAR=$( bash_variable "${ESSID}" )
+
+	# Call user-defined predown function if it exists
+	if [[ $( type -t predown ) == "function" ]]; then
+		einfo "Running predown function"
+		eindent
+		( predown "${iface}" )
+		eend $? "predown ${iface} failed" || return 1
+		eoutdent
+	elif is_net_fs /; then
+		eerror "root filesystem is network mounted -- can't stop ${iface}"
+		return 1
+	fi
+
+	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}"
+	local starting=true
+	local -a MODULES mods
+	local IN_BACKGROUND="${IN_BACKGROUND}"
+
+	# No point in backgrounding if we're already there ...
+	# This is also required so we can select the "best" interface
+	if [[ ${IN_BACKGROUND} == "true" || ${IN_BACKGROUND} == "1" ]]; then
+		IN_BACKGROUND=true
+		background=false
+	else
+		IN_BACKGROUND=false
+	fi
+
+	# 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
+	[[ ${cmd} == "stop" ]] && starting=false
+
+	# We force lo to only use these modules for a major speed boost
+	[[ ${iface} == "lo" ]] && modules_force=( "iproute2" "ifconfig" "system" )
+
+	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
+			remove_state "${iface}"
+		else
+			run_start "${iface}" && r=0
+		fi
+	fi
+
+	# Only apply best state if we're on auto
+	if [[ ${r} == "0" ]]; then
+		local siface=""
+		if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then
+			siface=$( select_best_interface )
+			if [[ -n ${siface} ]]; then
+				einfo "Selecting best interface: ${siface}"
+			fi
+		elif [[ ${cmd} == "start" ]]; then
+			siface="${iface}"
+		fi
+		[[ -n ${siface} ]] && apply_state "${siface}"
+	else
+		if [[ ${cmd} == "start" ]]; then
+			# Call user-defined failup if it exists
+			if [[ $( type -t failup ) == "function" ]]; then
+				einfo "Running failup function"
+				eindent
+				( failup "${iface}" )
+				eoutdent
+			fi
+		else
+			# Call user-defined faildown if it exists
+			if [[ $( type -t faildown ) == "function" ]]; then
+				einfo "Running faildown function"
+				eindent
+				( faildown "${iface}" )
+				eoutdent
+			fi
+		fi
+	fi
+
+	return "${r}"
+}
+
+# void link_file(char *file)
+#
+# Move a config file from /etc to ${netdir} and creates a link if needed.
+# This enables net-scripts to control the config file for interface management
+# and allow /etc to become read only.
+link_file() {
+	local file="$1"
+	local link=$( readlink "/etc/${file}" 2>/dev/null )
+	if [[ ${link} != "${netdir}/${file}" ]]; then
+		if [[ -f "/etc/${file}" ]]; then
+			vewarn "Moving /etc/${file} to ${netdir}/${file} and creating link"
+			mv "/etc/${file}" "${netdir}"
+			ln -snf "${netdir}/${file}" "/etc/${file}"
+		fi
+	fi
+}
+
+# bool start(void)
+#
+# Start entry point so that we only have one function
+# which localises variables and unsets functions
+start() {
+	if [[ ${IN_HOTPLUG} == "1" ]]; then
+		# If we've been called by hotplug, check if we have
+		# a policy for the interface for not starting
+		local x ifvar=$( bash_variable "${IFACE}" )
+		eval x=\"\$\{hotplug_${ifvar}\}\"
+		if [[ ${x} == "no" || ${x} == "false" ]]; then
+			eerror "Not starting interface ${IFACE} due to hotplug policy"
+			unset -f exit
+			mark_service_stopped "net.${IFACE}"
+			exit 1
+		fi
+	fi
+
+	if [[ ! -d "${statedir}/${IFACE}" ]]; then
+		if ! mkdir -m 0755 -p "${statedir}/${IFACE}" ; then
+			eerror "Unable to create state directory!"
+			return 1
+		fi
+	fi
+
+	if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then
+		link_file "resolv.conf"
+		link_file "ntp.conf"
+		link_file "yp.conf"
+	fi
+
+	einfo "Starting ${IFACE}"
+	run "${IFACE}" start
+}
+
+# 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
+}
+
+# vim:ts=4