1 files changed, 163 insertions, 144 deletions

diff --git a/net-scripts/init.d/net.lo b/net-scripts/init.d/net.lo
index 523dd65..f1dbfdc 100755
--- a/net-scripts/init.d/net.lo
+++ b/net-scripts/init.d/net.lo
@@ -17,7 +17,7 @@ depend() {
 	# 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}
+	[[ $(type -t "depend_${iface}") == "function" ]] && depend_${iface}
 
 	return 0
 }
@@ -34,30 +34,27 @@ 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\"; }"
+	eval "${MODULE}_after() { echo \"$*\"; }"
 }
 before() {
-	local x="$*"
-	[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
-	eval "${MODULE}_before() { echo \"$x\"; }"
+	eval "${MODULE}_before() { echo \"$*\"; }"
 }
 need() {
-	local x="$*"
-	[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
-	eval "${MODULE}_need() { echo \"$x\"; }"
+	eval "${MODULE}_need() { echo \"$*\"; }"
 }
 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\"; }"
+	eval "${MODULE}_instlled() { echo \"$*\"; }"
 }
-
-sort() {
-	LC_ALL=C /bin/sort "$@"
+provide() {
+	eval "${MODULE}_provide() { echo \"$*\"; }"
+}
+functions() {
+	eval "${MODULE}_functions() { echo \"$*\"; }"
+}
+variables() {
+	eval "${MODULE}_variables() { echo \"$*\"; }"
 }
 
 # void go_background(void)
@@ -85,8 +82,8 @@ module_load_minimum() {
 		return 1
 	fi
 
-	for f in check_installed provides check_depends depend; do
-		[[ $( type -t "${MODULE}_${f}" ) == "function" ]] && continue
+	for f in depend; do
+		is_function "${MODULE}_${f}" && continue
 		eerror "${MODULE} does not support the required function ${f}"
 		return 1
 	done
@@ -99,7 +96,7 @@ module_load_minimum() {
 # 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
+	local i j inst
 
 	# Populate the MODULES array
 	# Basically we treat evey file in ${MODULES_DIR} as a module
@@ -122,10 +119,16 @@ modules_load_auto() {
 			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;
+		if [[ ${u} == 0 ]]; then
+			inst="${MODULES[i]##*/}_check_installed";
+			if is_function "${inst}" ; then
+				${inst} false || u=1;
+			fi
+		fi
 		exit "${u}";
 		)
 
@@ -154,11 +157,13 @@ modules_check_installed() {
 	local i j missingdeps nmods="${#MODULES[@]}"
 
 	for (( i=0; i<nmods; i++ )); do
-		[[ $( type -t "${MODULES[i]}_instlled" ) != "function" ]] && continue
+		is_function "${MODULES[i]}_instlled" || continue
 		for j in $( ${MODULES[i]}_instlled ); do
 			missingdeps=true
-			if [[ $( type -t "${j}_check_installed" ) == "function" ]]; then
+			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
@@ -209,13 +214,12 @@ modules_check_user() {
 						)
 					unset MODULES[j]
 					unset PROVIDES[j]
-					break
 				fi
 			done
 			continue
 		fi
 
-		if [[ $( type -t "${umods[i]}_provides" ) != "function" ]]; then
+		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.
@@ -225,14 +229,19 @@ modules_check_user() {
 			# 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
+				is_function "${umods[i]}_check_installed" \
+					&& ${umods[i]}_check_installed true
 			else
 				eerror "The module \"${umods[i]}\" does not exist"
 			fi
 			return 1
 		fi
 
-		mod=$( ${umods[i]}_provides )
+		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
@@ -269,84 +278,82 @@ modules_check_user() {
 }
 
 # void modules_sort(void)
-
+#
+# Sort our modules
 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 )
+	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
 
-	# 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
+	# 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
-		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"
+	# 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
 
-	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++ ))
+		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)
@@ -355,7 +362,7 @@ modules_check_depends() {
 	local missingdeps p interface=false
 
 	for (( i=0; i<nmods; i++ )); do
-		if [[ $( type -t "${MODULES[i]}_need" ) == "function" ]]; then
+		if is_function "${MODULES[i]}_need" ; then
 			for needmod in $( ${MODULES[i]}_need ); do
 				missingdeps=true
 				for (( j=0; j<nmods; j++ )); do
@@ -372,7 +379,15 @@ modules_check_depends() {
 			done
 		fi
 
-		${MODULES[i]}_check_depends || return 1
+		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
@@ -418,57 +433,63 @@ modules_load()  {
 		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
+			if is_function "${modules_force[i]}_check_installed" ; then
+				${modules_force[i]}_check_installed || unset modules_force[i]
+			fi
 		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 )
+		# 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
+
+		# 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 [[ -z ${modules_force[@]} ]]; then
+	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 || return 1
+		else
+			# Always prefer iproute2 for taking down interfaces
+			if is_function iproute2_provide ; then
+				function_wrap iproute2 $(iproute2_provide)
+			fi
 		fi
 	fi
-
-	# Setup class wrappers: interface_up -> iproute2_up, for example
+	
+	# Wrap our modules
 	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]}"
+		function_wrap ${WRAP_MODULES[i]}
 	done
-
+	
 	if [[ -z ${modules_force[@]} ]]; then
 		modules_check_installed || return 1
 		modules_sort || return 1
@@ -506,7 +527,7 @@ iface_start() {
 
 	# pre Start any modules with
 	for mod in ${MODULES[@]}; do
-		if [[ $( type -t "${mod}_pre_start" ) == "function" ]]; then
+		if is_function "${mod}_pre_start" ; then
 			${mod}_pre_start "${iface}" || { eend 1; return 1; }
 		fi
 	done
@@ -554,7 +575,7 @@ iface_start() {
 	# Otherwise a default of NULL
 	if [[ -z ${config} ]]; then
 #		if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then
-			if [[ $( type -t "dhcp_start" ) == "function" ]]; then
+			if is_function "dhcp_start" ; then
 				config=( "dhcp" )
 				ewarn "Configuration not set for ${iface} - assuming dhcp"
 			else
@@ -585,7 +606,7 @@ iface_start() {
 		einfo "${conf[0]}"
 
 		# Do we have a function for our config?
-		if [[ $( type -t "${conf[0]}_start" ) == "function" ]]; then
+		if is_function "${conf[0]}_start" ; then
 			eindent
 			${conf[0]}_start "${iface}" ; x=$?
 			eoutdent
@@ -594,9 +615,9 @@ iface_start() {
 			# 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
+			if [[ ${RC_AUTO_INTERFACE} == "yes" ]] \
+				&& is_function arping_address_exists ; then
+				if arping_address_exists "${iface}" "${conf[0]}" ; then
 					eerror "${conf[0]%%/*} already taken on ${iface}"
 					x="1"
 				fi
@@ -629,7 +650,7 @@ iface_start() {
 
 	# Start any modules with _post_start
 	for mod in ${MODULES[@]}; do
-		if [[ $( type -t "${mod}_post_start" ) == "function" ]]; then
+		if is_function "${mod}_post_start" ; then
 			${mod}_post_start "${iface}" || return 1
 		fi
 	done
@@ -649,8 +670,7 @@ iface_stop() {
 
 	# pre Stop any modules
 	for mod in ${MODULES[@]}; do
-		[[ $( type -t "${mod}_pre_stop" ) == "function" ]] \
-		&& ${mod}_pre_stop "${iface}"
+		is_function "${mod}_pre_stop" && ${mod}_pre_stop "${iface}"
 	done
 
 	einfo "Bringing down ${iface}"
@@ -667,7 +687,7 @@ iface_stop() {
 	for i in ${aliases} ${iface}; do
 		# Stop all our modules
 		for mod in ${MODULES[@]}; do
-			[[ $( type -t "${mod}_stop" ) == "function" ]] && ${mod}_stop "${i}"
+			is_function "${mod}_stop" && ${mod}_stop "${i}"
 		done
 
 		# A module may have removed the interface
@@ -690,8 +710,7 @@ iface_stop() {
 	# 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}"
+		is_function "${mod}_post_stop" && ${mod}_post_stop "${iface}"
 	done
 
 	return 0
@@ -730,7 +749,7 @@ run_start() {
 	fi
 
 	# Call user-defined preup function if it exists
-	if [[ $( type -t preup ) == "function" ]]; then
+	if is_function preup ; then
 		einfo "Running preup function"
 		eindent
 		( preup "${iface}" )
@@ -762,7 +781,7 @@ run_start() {
 	fi
 
 	# Call user-defined postup function if it exists
-	if [[ $( type -t postup ) == "function" ]]; then
+	if is_function postup ; then
 		einfo "Running postup function"
 		eindent
 		( postup "${iface}" )
@@ -786,7 +805,7 @@ run_stop() {
 	[[ -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"
 		eindent
 		( predown "${iface}" )
@@ -800,7 +819,7 @@ run_stop() {
 	iface_stop "${iface}" || return 1  # always succeeds, btw
 
 	# Call user-defined postdown function if it exists
-	if [[ $( type -t postdown ) == "function" ]]; then
+	if is_function postdown ; then
 		einfo "Running postdown function"
 		eindent
 		( postdown "${iface}" )
@@ -870,7 +889,7 @@ run() {
 	else
 		if [[ ${cmd} == "start" ]]; then
 			# Call user-defined failup if it exists
-			if [[ $( type -t failup ) == "function" ]]; then
+			if is_function failup ; then
 				einfo "Running failup function"
 				eindent
 				( failup "${iface}" )
@@ -878,7 +897,7 @@ run() {
 			fi
 		else
 			# Call user-defined faildown if it exists
-			if [[ $( type -t faildown ) == "function" ]]; then
+			if is_function faildown ; then
 				einfo "Running faildown function"
 				eindent
 				( faildown "${iface}" )