- New upstream release.

1 files changed, 1038 insertions, 228 deletions

diff --git a/testing/hosts/dave/etc/runlevels/default/net.eth0 b/testing/hosts/dave/etc/runlevels/default/net.eth0
index fa1200242..92b3851cf 100755
--- a/testing/hosts/dave/etc/runlevels/default/net.eth0
+++ b/testing/hosts/dave/etc/runlevels/default/net.eth0
@@ -1,314 +1,1124 @@
 #!/sbin/runscript
-# Copyright 1999-2004 Gentoo Technologies, Inc.
+# Copyright (c) 2004-2006 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
-#NB: Config is in /etc/conf.d/net
+# Contributed by Roy Marples (uberlord@gentoo.org)
+# Many thanks to Aron Griffis (agriffis@gentoo.org)
+# for help, ideas and patches
 
-if [[ -n $NET_DEBUG ]]; then
-	set -x
-	devnull=/dev/stderr
-else
-	devnull=/dev/null
-fi
+#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() {
-	use hotplug pcmcia
-}
+	need localmount
+	after bootmisc hostname
+	use isapnp isdn pcmcia usb wlan
 
-checkconfig() {
-	if [[ -z "${ifconfig_IFACE}" ]]; then
-		eerror "Please make sure that /etc/conf.d/net has \$ifconfig_$IFACE set"
-		eerror "(or \$iface_$IFACE for old-style configuration)"
-		return 1
+	# Load any custom depend functions for the given interface
+	# For example, br0 may need eth0 and eth1
+	local iface="${SVCNAME#*.}"
+	[[ $(type -t "depend_${iface}") == "function" ]] && depend_${iface}
+
+	if [[ ${iface} != "lo" && ${iface} != "lo0" ]] ; then
+		after net.lo net.lo0
+
+		# Support new style RC_NEED and RC_USE in one net file
+		local x="RC_NEED_${iface}"
+		[[ -n ${!x} ]] && need ${!x}
+		x="RC_USE_${iface}"
+		[[ -n ${!x} ]] && use ${!x}
 	fi
-	if [[ -n "${vlans_IFACE}" && ! -x /sbin/vconfig ]]; then
-		eerror "For VLAN (802.1q) support, emerge net-misc/vconfig"
-		return 1
+
+	return 0
+}
+
+# Define where our modules are
+MODULES_DIR="${svclib}/net"
+
+# Make some wrappers to fudge after/before/need/use depend flags.
+# These are callbacks so MODULE will be set.
+after() {
+	eval "${MODULE}_after() { echo \"$*\"; }"
+}
+before() {
+	eval "${MODULE}_before() { echo \"$*\"; }"
+}
+need() {
+	eval "${MODULE}_need() { echo \"$*\"; }"
+}
+installed() {
+	# We deliberately misspell this as _installed will probably be used
+	# at some point
+	eval "${MODULE}_instlled() { echo \"$*\"; }"
+}
+provide() {
+	eval "${MODULE}_provide() { echo \"$*\"; }"
+}
+functions() {
+	eval "${MODULE}_functions() { echo \"$*\"; }"
+}
+variables() {
+	eval "${MODULE}_variables() { echo \"$*\"; }"
+}
+
+is_loopback() {
+	[[ $1 == "lo" || $1 == "lo0" ]]
+}
+
+# char* interface_device(char *iface)
+#
+# Gets the base device of the interface
+# Can handle eth0:1 and eth0.1
+# Which returns eth0 in this case
+interface_device() {
+	local dev="${1%%.*}"
+	[[ ${dev} == "$1" ]] && dev="${1%%:*}"
+	echo "${dev}"
+}
+
+# char* interface_type(char* iface)
+#
+# Returns the base type of the interface
+# eth, ippp, etc
+interface_type() {
+	echo "${1%%[0-9]*}"
+}
+
+# int calculate_metric(char *interface, int base)
+#
+# Calculates the best metric for the interface
+# We use this when we add routes so we can prefer interfaces over each other
+calculate_metric() {
+	local iface="$1" metric="$2"
+
+	# Have we already got a metric?
+	local m=$(awk '$1=="'${iface}'" && $2=="00000000" { print $7 }' \
+		/proc/net/route)
+	if [[ -n ${m} ]] ; then
+		echo "${m}"
+		return 0
 	fi
+
+	local i= dest= gw= flags= ref= u= m= mtu= metrics=
+	while read i dest gw flags ref u m mtu ; do
+		# Ignore lo
+		is_loopback "${i}" && continue
+		# We work out metrics from default routes only
+		[[ ${dest} != "00000000" || ${gw} == "00000000" ]] && continue
+		metrics="${metrics}\n${m}"
+	done < /proc/net/route
+
+	# Now, sort our metrics
+	metrics=$(echo -e "${metrics}" | sort -n)
+
+	# Now, find the lowest we can use
+	local gotbase=false
+	for m in ${metrics} ; do
+		[[ ${m} -lt ${metric} ]] && continue
+		[[ ${m} == ${metric} ]] && ((metric++))
+		[[ ${m} -gt ${metric} ]] && break
+	done
+	
+	echo "${metric}"
 }
 
-# Fix bug 50039 (init.d/net.eth0 localization)
-# Some other commands in this script might need to be wrapped, but
-# we'll get them one-by-one.  Note that LC_ALL trumps LC_anything_else
-# according to locale(7)
-ifconfig() {
-	LC_ALL=C /sbin/ifconfig "$@"
+# int netmask2cidr(char *netmask)
+#
+# Returns the CIDR of a given netmask
+netmask2cidr() {
+	local binary= i= bin=
+
+	for i in ${1//./ }; do
+		bin=""
+		while [[ ${i} != "0" ]] ; do
+			bin=$[${i}%2]${bin}
+			(( i=i>>1 ))
+		done
+		binary="${binary}${bin}"
+	done
+	binary="${binary%%0*}"
+	echo "${#binary}"
 }
 
-# setup_vars: setup variables based on $1 and content of /etc/conf.d/net
-# The following variables are set, which should be declared local by
-# the calling routine.
-#	status_IFACE			(up or '')
-#	vlans_IFACE				(space-separated list)
-#	ifconfig_IFACE			(array of ifconfig lines, replaces iface_IFACE)
-#	dhcpcd_IFACE			(command-line args for dhcpcd)
-#	routes_IFACE			(array of route lines)
-#	inet6_IFACE				(array of inet6 lines)
-#	ifconfig_fallback_IFACE	(fallback ifconfig if dhcp fails)
-setup_vars() {
-	local i iface="${1//\./_}"
-
-	status_IFACE="$(ifconfig ${1} 2>${devnull} | gawk '$1 == "UP" {print "up"}')"
-	eval vlans_IFACE=\"\$\{iface_${iface}_vlans\}\"
-	eval ifconfig_IFACE=( \"\$\{ifconfig_$iface\[@\]\}\" )
-	eval dhcpcd_IFACE=\"\$\{dhcpcd_$iface\}\"
-	eval routes_IFACE=( \"\$\{routes_$iface\[@\]\}\" )
-	eval inet6_IFACE=( \"\$\{inet6_$iface\[@\]\}\" )
-	eval ifconfig_fallback_IFACE=( \"\$\{ifconfig_fallback_$iface\[@\]\}\" )
-
-	# BACKWARD COMPATIBILITY: populate the ifconfig_IFACE array
-	# if iface_IFACE is set (fex. iface_eth0 instead of ifconfig_eth0)
-	eval local iface_IFACE=\"\$\{iface_$iface\}\"
-	if [[ -n ${iface_IFACE} && -z ${ifconfig_IFACE} ]]; then
-		# Make sure these get evaluated as arrays
-		local -a aliases broadcasts netmasks
-
-		# Start with the primary interface
-		ifconfig_IFACE=( "${iface_IFACE}" )
-
-		# ..then add aliases
-		eval aliases=( \$\{alias_$iface\} )
-		eval broadcasts=( \$\{broadcast_$iface\} )
-		eval netmasks=( \$\{netmask_$iface\} )
-		for ((i = 0; i < ${#aliases[@]}; i = i + 1)); do
-			ifconfig_IFACE[i+1]="${aliases[i]} ${broadcasts[i]:+broadcast ${broadcasts[i]}} ${netmasks[i]:+netmask ${netmasks[i]}}"
+
+# bool is_function(char* name)
+#
+# Returns 0 if the given name is a shell function, otherwise 1
+is_function() {
+	[[ -z $1 ]] && return 1
+	[[ $(type -t "$1") == "function" ]]
+}
+
+# void function_wrap(char* source, char* target)
+#
+# wraps function calls - for example function_wrap(this, that)
+# maps function names this_* to that_*
+function_wrap() {
+	local i=
+
+	is_function "${2}_depend" && return
+
+	for i in $(typeset -f | grep -o '^'"${1}"'_[^ ]*'); do
+		eval "${2}${i#${1}}() { ${i} \"\$@\"; }"
+	done
+}
+
+# char[] * expand_parameters(char *cmd)
+#
+# Returns an array after expanding parameters. For example
+# "192.168.{1..3}.{1..3}/24 brd +"
+# will return
+# "192.168.1.1/24 brd +"
+# "192.168.1.2/24 brd +"
+# "192.168.1.3/24 brd +"
+# "192.168.2.1/24 brd +"
+# "192.168.2.2/24 brd +"
+# "192.168.2.3/24 brd +"
+# "192.168.3.1/24 brd +"
+# "192.168.3.2/24 brd +"
+# "192.168.3.3/24 brd +"
+expand_parameters() {
+	local x=$(eval echo ${@// /_})
+	local -a a=( ${x} )
+
+	a=( "${a[@]/#/\"}" )
+	a=( "${a[@]/%/\"}" )
+	echo "${a[*]//_/ }"
+}
+
+# void configure_variables(char *interface, char *option1, [char *option2])
+#
+# Maps configuration options from <variable>_<option> to <variable>_<iface>
+# option2 takes precedence over option1
+configure_variables() {
+	local iface="$1" option1="$2" option2="$3"
+
+	local mod= func= x= i=
+	local -a ivars=() ovars1=() ovars2=()
+	local ifvar=$(bash_variable "${iface}")
+
+	for mod in ${MODULES[@]}; do
+		is_function ${mod}_variables || continue
+		for v in $(${mod}_variables) ; do
+			x=
+			[[ -n ${option2} ]] && x="${v}_${option2}[@]"
+			[[ -z ${!x} ]] && x="${v}_${option1}[@]"
+			[[ -n ${!x} ]] && eval "${v}_${ifvar}=( \"\${!x}\" )"
 		done
+	done
+
+	return 0
+}
+# bool module_load_minimum(char *module)
+#
+# Does the minimum checking on a module - even when forcing
+module_load_minimum() {
+	local f="$1.sh" MODULE="${1##*/}"
+
+	if [[ ! -f ${f} ]] ; then
+		eerror "${f} does not exist"
+		return 1
 	fi
 
-	# BACKWARD COMPATIBILITY: check for space-separated inet6 addresses
-	if [[ ${#inet6_IFACE[@]} == 1 && ${inet6_IFACE} == *' '* ]]; then
-		inet6_IFACE=( ${inet6_IFACE} )
+	if ! source "${f}" ; then
+		eerror "${MODULE} failed a sanity check"
+		return 1
 	fi
+
+	for f in depend; do
+		is_function "${MODULE}_${f}" && continue
+		eerror "${MODULE}.sh does not support the required function ${f}"
+		return 1
+	done
+
+	return 0
 }
 
-iface_start() {
-	local IFACE=${1} i x retval
-	checkconfig || return 1
-
-	if [[ ${ifconfig_IFACE} != dhcp ]]; then
-		# Show the address, but catch if this interface will be inet6 only
-		i=${ifconfig_IFACE%% *}
-		if [[ ${i} == *.*.*.* ]]; then
-			ebegin "Bringing ${IFACE} up (${i})"
-		else
-			ebegin "Bringing ${IFACE} up"
+# 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 inst
+
+	# Populate the MODULES array
+	# Basically we treat evey file in ${MODULES_DIR} as a module
+	MODULES=( $( cd "${MODULES_DIR}" ; ls *.sh ) )
+	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
+		MODULES[i]="${MODULES[i]%.sh*}"
+		if [[ ${MODULES[i]##*/} == "interface" ]] ; then
+			eerror "interface is a reserved name - cannot load a module called interface"
+			return 1
 		fi
-		# ifconfig does not always return failure ..
-		ifconfig ${IFACE} ${ifconfig_IFACE} >${devnull} && \
-		ifconfig ${IFACE} up &>${devnull}
-		eend $? || return $?
-	else
-		# Check that eth0 was not brought up by the kernel ...
-		if [[ ${status_IFACE} == up ]]; then
-			einfo "Keeping kernel configuration for ${IFACE}"
+		
+		(
+		u=0;
+		module_load_minimum "${MODULES[i]}" || u=1;
+		if [[ ${u} == 0 ]] ; then
+			inst="${MODULES[i]##*/}_check_installed";
+			if is_function "${inst}" ; then
+				${inst} false || u=1;
+			fi
+		fi
+		exit "${u}";
+		)
+
+		if [[ $? == 0 ]] ; then
+			source "${MODULES[i]}.sh"
+			MODULES[i]="${MODULES[i]##*/}"
 		else
-			ebegin "Bringing ${IFACE} up via DHCP"
-			/sbin/dhcpcd ${dhcpcd_IFACE} ${IFACE}
-			retval=$?
-			eend $retval
-			if [[ $retval == 0 ]]; then
-				# DHCP succeeded, show address retrieved
-				i=$(ifconfig ${IFACE} | grep -m1 -o 'inet addr:[^ ]*' | 
-					cut -d: -f2)
-				[[ -n ${i} ]] && einfo "  ${IFACE} received address ${i}"
-			elif [[ -n "${ifconfig_fallback_IFACE}" ]]; then
-				# DHCP failed, try fallback.
-				# Show the address, but catch if this interface will be inet6 only
-				i=${ifconfig_fallback_IFACE%% *}
-				if [[ ${i} == *.*.*.* ]]; then
-					ebegin "Using fallback configuration (${i}) for ${IFACE}"
-				else
-					ebegin "Using fallback configuration for ${IFACE}"
+			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
+		is_function "${MODULES[i]}_instlled" || continue
+		for j in $( ${MODULES[i]}_instlled ); do
+			missingdeps=true
+			if is_function "${j}_check_installed" ; then
+				${j}_check_installed && missingdeps=false
+			elif is_function "${j}_depend" ; then
+				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 iface="$1" ifvar=$(bash_variable "${IFACE}")
+	local i= j= k= l= nmods="${#MODULES[@]}"
+	local -a umods=()
+
+	# Has the interface got any specific modules?
+	umods="modules_${ifvar}[@]"
+	umods=( "${!umods}" )
+
+	# Global setting follows interface-specific setting
+	umods=( "${umods[@]}" "${modules[@]}" )
+
+	# Add our preferred modules
+	local -a pmods=( "iproute2" "dhcpcd" "iwconfig" "netplugd" )
+	umods=( "${umods[@]}" "${pmods[@]}" )
+
+	# 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]
 				fi
-				ifconfig ${IFACE} ${ifconfig_fallback_IFACE} >${devnull} && \
-				ifconfig ${IFACE} up &>${devnull}
-				eend $? || return $?
+			done
+			continue
+		fi
+
+		if ! is_function "${umods[i]}_depend" ; then
+			# If the module is one of our preferred modules, then
+			# ignore this error; whatever is available will be
+			# used instead.
+			(( i < ${#umods[@]} - ${#pmods[@]} )) || 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]}.sh" ]] ; then
+				source "${MODULES_DIR}/${umods[i]}.sh"
+				is_function "${umods[i]}_check_installed" \
+					&& ${umods[i]}_check_installed true
 			else
-				return $retval
+				eerror "The module \"${umods[i]}\" does not exist"
 			fi
+			return 1
 		fi
-	fi
 
-	if [[ ${#ifconfig_IFACE[@]} -gt 1 ]]; then
-		einfo "  Adding aliases"
-		for ((i = 1; i < ${#ifconfig_IFACE[@]}; i = i + 1)); do
-			ebegin "    ${IFACE}:${i} (${ifconfig_IFACE[i]%% *})"
-			ifconfig ${IFACE}:${i} ${ifconfig_IFACE[i]}
-			eend $?
+		if is_function "${umods[i]}_provide" ; then
+			mod=$(${umods[i]}_provide)
+		else
+			mod="${umods[i]}"
+		fi
+		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)
+#
+# Sort our modules
+modules_sort() {
+	local i= j= nmods=${#MODULES[@]} m=
+	local -a provide=() provide_list=() after=() dead=() sorted=() sortedp=()
+
+	# Make our provide list
+	for ((i=0; i<nmods; i++)); do
+		dead[i]="false"
+		if [[ ${MODULES[i]} != "${PROVIDES[i]}" ]] ; then
+			local provided=false
+			for ((j=0; j<${#provide[@]}; j++)); do
+				if [[ ${provide[j]} == "${PROVIDES[i]}" ]] ; then
+					provide_list[j]="${provide_list[j]} ${MODULES[i]}"
+					provided=true
+				fi
+			done
+			if ! ${provided}; then
+				provide[j]="${PROVIDES[i]}"
+				provide_list[j]="${MODULES[i]}"
+			fi
+		fi
+	done
+
+	# Create an after array, which holds which modules the module at
+	# index i must be after
+	for ((i=0; i<nmods; i++)); do
+		if is_function "${MODULES[i]}_after" ; then
+			after[i]=" ${after[i]} $(${MODULES[i]}_after) "
+		fi
+		if is_function "${MODULES[i]}_before" ; then
+			for m in $(${MODULES[i]}_before); do
+				for ((j=0; j<nmods; j++)) ; do
+					if [[ ${PROVIDES[j]} == "${m}" ]] ; then
+						after[j]=" ${after[j]} ${MODULES[i]} "
+						break
+					fi
+				done
+			done
+		fi
+	done
+
+	# Replace the after list modules with real modules
+	for ((i=0; i<nmods; i++)); do
+		if [[ -n ${after[i]} ]] ; then
+			for ((j=0; j<${#provide[@]}; j++)); do
+				after[i]="${after[i]// ${provide[j]} / ${provide_list[j]} }"
+			done
+		fi
+	done
+	
+	# We then use the below code to provide a topologial sort
+    module_after_visit() {
+        local name="$1" i= x=
+
+		for ((i=0; i<nmods; i++)); do
+			[[ ${MODULES[i]} == "$1" ]] && break
 		done
+
+        ${dead[i]} && return
+        dead[i]="true"
+
+        for x in ${after[i]} ; do
+            module_after_visit "${x}"
+        done
+
+        sorted=( "${sorted[@]}" "${MODULES[i]}" )
+		sortedp=( "${sortedp[@]}" "${PROVIDES[i]}" )
+    }
+
+	for x in ${MODULES[@]}; do
+		module_after_visit "${x}"
+	done
+
+	MODULES=( "${sorted[@]}" )
+	PROVIDES=( "${sortedp[@]}" )
+}
+
+# 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 is_function "${MODULES[i]}_need" ; 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
+
+		if is_function "${MODULES[i]}_functions" ; then
+			for f in $(${MODULES[i]}_functions); do
+				if ! is_function "${f}" ; then
+					eerror "${MODULES[i]}: missing required function \"${f}\""
+					return 1
+				fi
+			done
+		fi
+
+		[[ ${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
 
-	if [[ -n ${inet6_IFACE} ]]; then
-		einfo "  Adding inet6 addresses"
-		for ((i = 0; i < ${#inet6_IFACE[@]}; i = i + 1)); do
-			ebegin "    ${IFACE} inet6 add ${inet6_IFACE[i]}"
-			ifconfig ${IFACE} inet6 add ${inet6_IFACE[i]} >${devnull}
-			eend $?
+	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 ! is_loopback "${iface}" ; then
+		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
+			if is_function "${modules_force[i]}_check_installed" ; then
+				${modules_force[i]}_check_installed || unset modules_force[i]
+			fi
 		done
+		MODULES=( "${modules_force[@]}" )
 	fi
 
-	# Set static routes
-	if [[ -n ${routes_IFACE} ]]; then
-		einfo "  Adding routes"
-		for ((i = 0; i < ${#routes_IFACE[@]}; i = i + 1)); do
-			ebegin "    ${routes_IFACE[i]}"
-			/sbin/route add ${routes_IFACE[i]}
-			eend $?
+	j="${#MODULES[@]}"
+	for (( i=0; i<j; i++ )); do
+		# Now load our dependencies - we need to use the MODULE variable
+		# here as the after/before/need functions use it
+		MODULE="${MODULES[i]}"
+		${MODULE}_depend
+
+		# expose does exactly the same thing as depend
+		# However it is more "correct" as it exposes things to other modules
+		# instead of depending on them ;)
+		is_function "${MODULES[i]}_expose" && ${MODULES[i]}_expose
+
+		# If no provide is given, assume module name
+		if is_function "${MODULES[i]}_provide" ; then
+			PROVIDES[i]=$(${MODULES[i]}_provide)
+		else
+			PROVIDES[i]="${MODULES[i]}"
+		fi
+	done
+
+	if [[ -n ${modules_force[@]} ]] ; then
+		# Strip any duplicate modules providing the same thing
+		j="${#MODULES[@]}"
+		for (( i=0; i<j-1; i++ )); do
+			[[ -z ${MODULES[i]} ]] && continue
+			for (( k=i+1; k<j; k++ )); do
+				if [[ ${PROVIDES[i]} == ${PROVIDES[k]} ]] ; then
+					unset MODULES[k]
+					unset PROVIDES[k]
+				fi
+			done
 		done
+		MODULES=( "${MODULES[@]}" )
+		PROVIDES=( "${PROVIDES[@]}" )
+	else
+		if ${starting}; then
+			modules_check_user "${iface}" || return 1
+		else
+			# Always prefer iproute2 for taking down interfaces
+			if is_function iproute2_provide ; then
+				function_wrap iproute2 "$(iproute2_provide)"
+			fi
+		fi
 	fi
+	
+	# Wrap our modules
+	j="${#MODULES[@]}"
+	for (( i=0; i<j; i++ )); do
+		function_wrap "${MODULES[i]}" "${PROVIDES[i]}"
+	done
+	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=() b=()
+	local ifvar=$(bash_variable "$1") i= j= metric=0
 
-	# Set default route if applicable to this interface
-	if [[ ${gateway} == ${IFACE}/* ]]; then
-		local ogw=$(/bin/netstat -rn | awk '$1 == "0.0.0.0" {print $2}')
-		local gw=${gateway#*/}
-		if [[ ${ogw} != ${gw} ]]; then
-			ebegin "  Setting default gateway ($gw)"
-
-			# First delete any existing route if it was setup by kernel...
-			/sbin/route del default dev ${IFACE} &>${devnull}
-
-			# Second delete old gateway if it was set...
-			/sbin/route del default gw ${ogw} &>${devnull}
-
-			# Third add our new default gateway
-			/sbin/route add default gw ${gw} >${devnull}
-			eend $? || {
-				true # need to have some command in here
-				# Note: This originally called stop, which is obviously
-				# wrong since it's calling with a local version of IFACE.
-				# The below code works correctly to abort configuration of
-				# the interface, but is commented because we're assuming
-				# that default route failure should not cause the interface
-				# to be unconfigured.
-				#local error=$?
-				#ewarn "Aborting configuration of ${IFACE}"
-				#iface_stop ${IFACE}
-				#return ${error}
-			}
+	# pre Start any modules with
+	for mod in ${MODULES[@]}; do
+		if is_function "${mod}_pre_start" ; then
+			${mod}_pre_start "${iface}" || { eend 1; return 1; }
 		fi
+	done
+
+	x="metric_${ifvar}"
+	# If we don't have a metric then calculate one
+	# Our modules will set the metric variable to a suitable base
+	# in their pre starts.
+	if [[ -z ${!x} ]] ; then
+		eval "metric_${ifvar}=\"$(calculate_metric "${iface}" "${metric}")\""
 	fi
 
-	# Enabling rp_filter causes wacky packets to be auto-dropped by
-	# the kernel.  Note that we only do this if it is not set via
-	# /etc/sysctl.conf ...
-	if [[ -e /proc/sys/net/ipv4/conf/${IFACE}/rp_filter && \
-			-z "$(grep -s '^[^#]*rp_filter' /etc/sysctl.conf)" ]]; then
-		echo -n 1 > /proc/sys/net/ipv4/conf/${IFACE}/rp_filter
+	# We now expand the configuration parameters and pray that the
+	# fallbacks expand to the same number as config or there will be
+	# trouble!
+	a="config_${ifvar}[@]"
+	a=( "${!a}" )
+	for (( i=0; i<${#a[@]}; i++ )); do 
+		eval b=( $(expand_parameters "${a[i]}") )
+		config=( "${config[@]}" "${b[@]}" )
+	done
+
+	a="fallback_${ifvar}[@]"
+	a=( "${!a}" )
+	for (( i=0; i<${#a[@]}; i++ )); do 
+		eval b=( $(expand_parameters "${a[i]}") )
+		fallback=( "${fallback[@]}" "${b[@]}" )
+	done
+
+	# We don't expand routes
+	fallback_route="fallback_route_${ifvar}[@]"
+	fallback_route=( "${!fallback_route}" )
+	
+	# 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 deprecated 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
+		ewarn "Configuration not set for ${iface} - assuming DHCP"
+		if is_function "dhcp_start" ; then
+			config=( "dhcp" )
+		else
+			eerror "No DHCP client installed"
+			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
+
+		# 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 is_function "${conf[0]}_start" ; 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 ! is_loopback "${iface}" ; then
+				if [[ " ${MODULES[@]} " == *" arping "* ]] ; then
+					if arping_address_exists "${iface}" "${conf[0]}" ; then
+						eerror "${conf[0]%%/*} already taken on ${iface}"
+						x="1"
+					fi
+				fi
+			fi
+			[[ ${x} == "0" ]] && interface_add_address "${iface}" ${conf[@]}; x="$?"
+			eend "${x}" && config_worked=true && continue
+		else
+			if [[ ${conf[0]} == "dhcp" ]] ; then
+				eerror "No DHCP client installed"
+			else
+				eerror "No loaded modules provide \"${conf[0]}\" (${conf[0]}_start)"
+			fi
+		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
+				x="fallback_route[config_counter]"
+				eval "routes_${ifvar}=( \"\${!x}\" )"
+				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 is_function "${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.
 iface_stop() {
-	local IFACE=${1} i x aliases inet6 count
-
-	# Try to do a simple down (no aliases, no inet6, no dhcp)
-	aliases="$(ifconfig | grep -o "^$IFACE:[0-9]*" | tac)"
-	inet6="$(ifconfig ${IFACE} | awk '$1 == "inet6" {print $2}')"
-	if [[ -z ${aliases} && -z ${inet6} && ! -e /var/run/dhcpcd-${IFACE}.pid ]]; then
-		ebegin "Bringing ${IFACE} down"
-		ifconfig ${IFACE} down &>/dev/null
-		eend 0
-		return 0
-	fi
+	local iface="$1" i= aliases= need_begin=false mod=
+	local RC_INDENTATION="${RC_INDENTATION}"
 
-	einfo "Bringing ${IFACE} down"
+	# pre Stop any modules
+	for mod in ${MODULES[@]}; do
+		if is_function "${mod}_pre_stop" ; then
+			${mod}_pre_stop "${iface}" || return 1
+		fi
+	done
+
+	einfo "Bringing down ${iface}"
+	eindent
+
+	# Collect list of aliases for this interface.
+	# List will be in reverse order.
+	if interface_exists "${iface}" ; then
+		aliases=$(interface_get_aliases_rev "${iface}")
+	fi
 
 	# 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
-
-		# Delete all the inet6 addresses for this interface
-		inet6="$(ifconfig ${i} | awk '$1 == "inet6" {print $3}')"
-		if [[ -n ${inet6} ]]; then
-			einfo "  Removing inet6 addresses"
-			for x in ${inet6}; do 
-				ebegin "    ${IFACE} inet6 del ${x}"
-				ifconfig ${i} inet6 del ${x}
-				eend $?
-			done
+	for i in ${aliases} ${iface}; do
+		# Stop all our modules
+		for mod in ${MODULES[@]}; do
+			if is_function "${mod}_stop" ; then
+				${mod}_stop "${i}" || return 1
+			fi
+		done
+
+		# A module may have removed the interface
+		if ! interface_exists "${iface}" ; then
+			eend 0
+			continue
 		fi
 
-		# Stop DHCP (should be N/A for aliases)
-		# Don't trust current configuration... investigate ourselves
-		if /sbin/dhcpcd -z ${i} &>${devnull}; then
-			ebegin "  Releasing DHCP lease for ${IFACE}"
-			for ((count = 0; count < 9; count = count + 1)); do
-				/sbin/dhcpcd -z ${i} &>${devnull} || break
-				sleep 1
-			done
-			[[ ${count} -lt 9 ]]
-			eend $? "Timed out"
+		# We don't delete ppp assigned addresses
+		if ! is_function pppd_exists || ! pppd_exists "${i}" ; then
+			# Delete all the addresses for this alias
+			interface_del_addresses "${i}"
 		fi
-		ebegin "  Stopping ${i}"
-		ifconfig ${i} down &>${devnull}
-		eend 0
+
+		# Do final shut down of this alias
+		if [[ ${IN_BACKGROUND} != "true" \
+			&& ${RC_DOWN_INTERFACE} == "yes" ]] ; 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
+		is_function "${mod}_post_stop" && ${mod}_post_stop "${iface}"
 	done
 
 	return 0
 }
 
-start() {
-	# These variables are set by setup_vars
-	local status_IFACE vlans_IFACE dhcpcd_IFACE 
-	local -a ifconfig_IFACE routes_IFACE inet6_IFACE
+# 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[@]}" )
+	elif [[ ${iface} == "lo0" ]] ; then
+		metric_lo0="0"
+		config_lo0=( "127.0.0.1/8 brd 127.255.255.255" "${config_lo[@]}" )
+		routes_lo0=( "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
+	if is_function preup ; then
 		einfo "Running preup function"
-		preup ${IFACE} || {
-			eerror "preup ${IFACE} failed"
-			return 1
-		}
+		eindent
+		( preup "${iface}" )
+		eend "$?" "preup ${iface} failed" || return 1
+		eoutdent
 	fi
 
-	# Start the primary interface and aliases
-	setup_vars ${IFACE}
-	iface_start ${IFACE} || return 1
+	# If config is set to noop and the interface is up with an address
+	# then we don't start it
+	local config=
+	config="config_${IFVAR}[@]"
+	config=( "${!config}" )
+	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\}\"" )"
 
-	# Start vlans
-	local vlan
-	for vlan in ${vlans_IFACE}; do
-		/sbin/vconfig add ${IFACE} ${vlan} >${devnull}
-		setup_vars ${IFACE}.${vlan}
-		iface_start ${IFACE}.${vlan}
-	done
+		# There may be existing ip address info - so we strip it
+		if [[ ${RC_INTERFACE_KEEP_CONFIG} != "yes" \
+			&& ${IN_BACKGROUND} != "true" ]] ; then
+			interface_del_addresses "${iface}"
+		fi
+
+		# Start the interface
+		if ! iface_start "${iface}" ; then
+			if [[ ${IN_BACKGROUND} != "true" ]] ; then
+				interface_exists "${iface}" && interface_down "${iface}"
+			fi
+			eend 1
+			return 1
+		fi
+	fi
 
 	# Call user-defined postup function if it exists
-	if [[ $(type -t postup) == function ]]; then
+	if is_function postup ; then
+		# We need to mark the service as started incase a
+		# postdown function wants to restart services that depend on us
+		mark_service_started "net.${iface}"
+		end_service "net.${iface}" 0
 		einfo "Running postup function"
-		postup ${IFACE}
+		eindent
+		( postup "${iface}" )
+		eoutdent
 	fi
+
+	return 0
 }
 
-stop() {
+# 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
+	if is_function predown ; then
 		einfo "Running predown function"
-		predown ${IFACE}
+		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
+	elif is_union_fs / ; then
+		for x in $(unionctl "${dir}" --list \
+		| sed -e 's/^\(.*\) .*/\1/') ; do
+			if is_net_fs "${x}" ; then
+				eerror "Part of the root filesystem is network mounted - cannot stop ${iface}"
+				return 1
+			fi
+		done
 	fi
 
-	# Don't depend on setup_vars since configuration might have changed.
-	# Investigate current configuration instead.
-	local vlan
-	for vlan in $(ifconfig | grep -o "^${IFACE}\.[^ ]*"); do
-		iface_stop ${vlan}
-		/sbin/vconfig rem ${vlan} >${devnull}
-	done
+	iface_stop "${iface}" || return 1  # always succeeds, btw
 
-	iface_stop ${IFACE} || return 1  # always succeeds, btw
+	# Release resolv.conf information.
+	[[ -x /sbin/resolvconf ]] && resolvconf -d "${iface}"
+	
+	# Mark us as inactive if called from the background
+	[[ ${IN_BACKGROUND} == "true" ]] && mark_service_inactive "net.${iface}"
 
 	# Call user-defined postdown function if it exists
-	if [[ $(type -t postdown) == function ]]; then
+	if is_function postdown ; then
+		# We need to mark the service as stopped incase a
+		# postdown function wants to restart services that depend on us
+		[[ ${IN_BACKGROUND} != "true" ]] && mark_service_stopped "net.${iface}"
+		end_service "net.${iface}" 0
 		einfo "Running postdown function"
-		postdown ${IFACE}
+		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}"
+
+	if [[ ${IN_BACKGROUND} == "true" || ${IN_BACKGROUND} == "1" ]] ; then
+		IN_BACKGROUND=true
+	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
+	if is_loopback "${iface}" ; then	
+		modules_force=( "iproute2" "ifconfig" "system" )
+	fi
+
+	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
+			# Only hotplug on ethernet interfaces
+			if [[ ${IN_HOTPLUG} == 1 ]] ; then
+				if ! interface_is_ethernet "${iface}" ; then
+					eerror "We only hotplug for ethernet interfaces"
+					return 1
+				fi
+			fi
+
+			run_start "${iface}" && r=0
+		fi
+	fi
+
+	if [[ ${r} != "0" ]] ; then
+		if [[ ${cmd} == "start" ]] ; then
+			# Call user-defined failup if it exists
+			if is_function failup ; then
+				einfo "Running failup function"
+				eindent
+				( failup "${iface}" )
+				eoutdent
+			fi
+		else
+			# Call user-defined faildown if it exists
+			if is_function faildown ; then
+				einfo "Running faildown function"
+				eindent
+				( faildown "${iface}" )
+				eoutdent
+			fi
+		fi
+		[[ ${IN_BACKGROUND} == "true" ]] \
+			&& mark_service_inactive "net.${iface}"
 	fi
+
+	return "${r}"
+}
+
+# bool start(void)
+#
+# Start entry point so that we only have one function
+# which localises variables and unsets functions
+start() {
+	declare -r IFACE="${SVCNAME#*.}"
+	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() {
+	declare -r IFACE="${SVCNAME#*.}"
+	einfo "Stopping ${IFACE}"
+	run "${IFACE}" stop
 }
 
 # vim:ts=4