Replacement init script for wireless networking

net.eth0 (text/plain), 18.18 KB, created by Roy Marples (RETIRED) on 2004-03-23 02:34:58 UTC

#!/sbin/runscript
# Copyright 1999-2004 Gentoo Technologies, Inc.
# Distributed under the terms of the GNU General Public License v2
# $Header: /etc/init.d/net.eth0,v 2.04 2004/03/23 10:12:45 UberLord Exp $

#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
}

checkconfig() {
	if [ -z "${iface_IFACE}" ]
	then
		eerror "Please make sure that /etc/conf.d/net has \$iface_$IFACE set"
		return 1
	fi
	if [ -n "${vlans}" -a \! -x ${VCONFIG} ]
	then
		eerror "For VLAN (802.1q) support, emerge net-misc/vconfig"
		return 1
	fi
	if [ "yes" == "${wireless_config_IFACE}" ] && [ ! -x ${IWCONFIG} ]
	then
		eerror "For Wireless (802.11) support, emerge net-wireless/wireless-tools"
		return 1
	fi
}

setup_env() {
	IFCONFIG="/sbin/ifconfig"
	DHCPCD="/sbin/dhcpcd"
	ROUTE="/sbin/route"
	SLEEP="/bin/sleep"
	VCONFIG="/sbin/vconfig"
        IWCONFIG="/usr/sbin/iwconfig"
        IWLIST="/usr/sbin/iwlist"
        IWPRIV="/usr/sbin/iwpriv"

	# No reason to check these multiple times in the file
	iface="${1/\./_}"
	iface_IFACE="$(eval echo \$\{iface_${iface}\})"
	dhcpcd_IFACE="$(eval echo \$\{dhcpcd_${iface}\})"
	inet6_IFACE="$(eval echo \$\{inet6_${iface}\})"
	alias_IFACE="$(eval echo \$\{alias_${iface}\})"
	status_IFACE="$(ifconfig | gawk -v IFACE="${iface}" '$0 ~ /Link/ { if ($1 == IFACE) print "up" }')"
	vlans="$(eval echo \$\{iface_${IFACE}_vlans\})"
	preifup_IFACE="$(eval echo \$\{preifup_${iface}\})"
	preifdown_IFACE="$(eval echo \$\{preifdown_${iface}\})"

	setup_wireless_env
}

setup_wireless_env() {
	# Do we have wireless extensions enabled on the interface?
	if [ -x "${IWCONFIG}" ]; then
		wireless_IFACE="$(${IWCONFIG} ${IFACE} 2>/dev/null | gawk -v IFACE=${IFACE} '{ if ($1 == IFACE) print "yes" }')"
	fi
	wireless_IFACE=${wireless_IFACE:-"no"}

	# Get the setup for the interface
	essid_IFACE="$(eval echo \$\{wireless_essid_${IFACE}\})"
	mode_IFACE="$(eval echo \$\{wireless_mode_${IFACE}\} | tr [:upper:] [:lower:])"
	config_IFACE="$(eval echo \$\{wireless_config_${IFACE}\})"
	priv_IFACE="$(eval echo \$\{wireless_priv_${IFACE}\})"
	scan_mode_IFACE="$(eval echo \$\{wireless_scan_mode_${IFACE}\})"
	sleep_scan_IFACE="$(eval echo \$\{wireless_sleep_scan_${IFACE}\})"
	sleep_scan_IFACE=${sleep_scan_IFACE:-"0"}
	sleep_associate_IFACE="$(eval echo \$\{wireless_sleep_associate_${IFACE}\})"
	sleep_associate_IFACE=${sleep_associate_IFACE:-"10"}
	priv_scan_pre_IFACE="$(eval echo \$\{wireless_priv_scan_pre_${IFACE}\})"
	priv_scan_post_IFACE="$(eval echo \$\{wireless_priv_scan_post_${IFACE}\})"

	if [ -n "${essid_IFACE}" ] || [ -n "${mode_IFACE}" ] || [ -n "${config_IFACE}" ] \
	|| [ -n "${priv_IFACE}" ] || [ -n "${scan_mode_IFACE}" ] || [ -n "${sleep_scan_IFACE}" ] \
	|| [ -n "${sleep_associate_IFACE}" ] \
	|| [ -n "${priv_scan_pre_IFACE}" ] || [ -n "${priv_scan_post_IFACE}" ]; then
		wireless_config_IFACE="yes"
	else
		wireless_config_IFACE="no"
	fi
}

setup_essid_env() {
	# Sets specific ESSID options
	# Replace invalid essid characters with _ so bash works
	local essid=${ESSID//[![:word:]]/_}

	essid_has_config="no"
	key_ESSID="$(eval echo \$\{wireless_key_${essid}\})"
	key_ESSID=${key_ESSID:-"off"}
	iface_ESSID="$(eval echo \$\{wireless_iface_${essid}\})"
	dhcpcd_ESSID="$(eval echo \$\{wireless_dhcpcd_${essid}\})"
	gateway_ESSID="$(eval echo \$\{wireless_gateway_${essid}\})"
	preassociate_ESSID="$(eval echo \$\{wireless_preassociate_${essid}\})"
	preifup_ESSID="$(eval echo \$\{wireless_preifup_${essid}\})"
	preifdown_ESSID="$(eval echo \$\{wireless_preifdown_${essid}\})"
	nameserver_ESSID="$(eval echo \$\{wireless_nameserver_${essid}\})"
	domain_ESSID="$(eval echo \$\{wireless_domain_${essid}\})"
	if [ -n "${key_ESSID}" ] || [ -n "${iface_ESSID}" ]; then
		essid_has_config="yes"
	fi

	display_ESSID=${ESSID//\\\\/\\\\}
}

setup_wireless_iface() {
	if [ -n "${iface_ESSID}" ]; then
		iface_IFACE=${iface_ESSID}
	fi
	if [ -n "${dhcpcd_ESSID}" ]; then
		dhcpcd_IFACE=${dhcpcd_ESSID}
	fi
	if [ -n "${gateway_ESSID}" ]; then
		gateway="${IFACE}/${gateway_ESSID}"
	fi
	if [ -n "${nameserver_ESSID}" ]; then
		echo "nameserver ${nameserver_ESSID}" > /etc/resolv.conf
		if [ -n "${domain_ESSID}" ]; then
			echo "domain ${domain_ESSID}" >> /etc/resolv.conf
			echo "search ${domain_ESSID}" >> /etc/resolv.conf
		fi
	fi
}

wait_for_association() {
	local counter=0
	while ((${counter} < (${sleep_associate_IFACE}))); do
		local wireless_mac=`${IWCONFIG} ${IFACE} | awk '/\<..:..:..:..:..:..\>/{print}' | sed 's/^.*\<\(..:..:..:..:..:..\)\>.*$/\1/g'`
		if [ "${wireless_mac}" != "FF:FF:FF:FF:FF:FF" ] \
		&& [ "${wireless_mac}" != "44:44:44:44:44:44" ] \
		&& [ "${wireless_mac}" != "00:00:00:00:00:00" ]; then
			return 0
		fi
		${SLEEP} 1
		counter=$((${counter} + 1))
	done
	return 1
}

associate_wireless() {
	#Restore IFS - this is needed
	local IFS=$'\n'$'\t'" "

	if [ "${ESSID}" == "any" ]; then
		${IWCONFIG} ${IFACE} ap any 2>/dev/null
		display_ESSID="any"
	else
		setup_essid_env
		${IWCONFIG} ${IFACE} key ${key_ESSID} 2>/dev/null || {
			if [ "${key_ESSID}" != "off" ]; then
				ewarn "  ${IFACE} does not support setting keys"
			fi
		}
	fi

	${IWCONFIG} ${IFACE} essid "${ESSID}" 2>/dev/null || {
		if [ "${ESSID}" != "any" ]; then
			ewarn "  ${IFACE} does not support setting essid"
		fi
	}

	einfo "  Connecting to \"${display_ESSID}\""
	${IFCONFIG} ${IFACE} up >/dev/null

	if [ -n "${preassociate_ESSID}" ]; then
		# We have a custom script to run before associating
		ebegin "Running an assocation setup script for ${display_ESSID}"
		${preassociate_ESSID} || {
			retval=$?
			eend ${retval} "Failed to run the setup script for ${display_ESSID}"
			${IFCONFIG} ${IFACE} down >/dev/null
			return ${retval}
		}
		eend 0
	fi

	wait_for_association || {
		${IFCONFIG} ${IFACE} down >/dev/null
		${IWCONFIG} ${IFACE} key off >/dev/null
		ewarn "  Failed to associate with the access point ${display_ESSID}"
		return 1
	}

	if [ "${ESSID}" == "any" ]; then
		ESSID=`${IWCONFIG} ${IFACE} | gawk -F\" '/ESSID/ {print $2}'`
		setup_essid_env
		einfo "  Connected to \"${display_ESSID}\""
		${IWCONFIG} ${IFACE} key ${key_ESSID} 2>/dev/null || {
			if [ "${key_ESSID}" != "off" ]; then
				ewarn "  ${IFACE} does not support setting keys"
			fi
		}
	fi
	
	setup_wireless_iface
	return 0
}

setup_wireless() {
	${IFCONFIG} ${IFACE} down >/dev/null
	# Set some defaults
        ${IWCONFIG} ${IFACE} rts off 2>/dev/null
        ${IWCONFIG} ${IFACE} frag off 2>/dev/null
        ${IWCONFIG} ${IFACE} power off 2>/dev/null
        ${IWCONFIG} ${IFACE} txpower auto 2>/dev/null
        ${IWCONFIG} ${IFACE} key off 2>/dev/null
        ${IWCONFIG} ${IFACE} essid any 2>/dev/null

	# Apply the user configuration
        if [ -n "${config_IFACE}" ]; then
                ${IWCONFIG} ${IFACE} ${config_IFACE} 2>/dev/null \
                || ewarn "  ${IFACE} does not support the following configuration commands" \
                && ewarn "    \"${config_IFACE}\""
        fi
        if [ -n "${priv_IFACE}" ]; then
                ${IWPRIV} ${IFACE} ${priv_IFACE} 2>/dev/null \
                || ewarn "  ${IFACE} does not support the following private ioctls" \
                && ewarn "    \"${priv_IFACE}\""
        fi

	# Set the mode. We do this after the config as the mode could have been changed there
        if [ -n "${mode_IFACE}" ]; then
                ${IWCONFIG} ${IFACE} mode ${mode_IFACE} 2>/dev/null \
                || ewarn "  ${IFACE} does not support setting the mode to \"${mode_IFACE}\""
        else
                ${IWCONFIG} ${IFACE} mode Managed 2>/dev/null
        fi

	# We only want to continue with scanning when in Managed mode
	if [ ! -z "${mode_IFACE}" ] && [ "managed" != "${mode_IFACE}" ]; then
		if [ -z "${essid_IFACE}" ]; then
			eerror "${IFACE} requires an ESSID to be set as it isn't configured for Managed mode"
			return 1
		fi
		ESSID=${essid_IFACE}
		setup_essid_env
		setup_wireless_iface
		${IWCONFIG} ${IFACE} key ${key_ESSID} 2>/dev/null || {
			if [ "${key_ESSID}" != "off" ]; then
				ewarn "  ${IFACE} does not support setting the key ${key_IFACE}"
			fi
		}
		${IWCONFIG} ${IFACE} essid ${ESSID} 2>/dev/null
		return 0
	fi

	# Has an ESSID been forced?
	if [ -n "${essid_IFACE}" ]; then
		ESSID=${essid_IFACE};
		associate_wireless && return 0
		if [ "${essid_IFACE}" != "any" ]; then return 1; fi
	fi

	local first_AP=""
	if [ "${essid_IFACE}" != "any" ]; then	
		# Initiate a scan
		# First, we may need to change mode to scan in
        	if [ -n "${scan_mode_IFACE}" ] && [ "${scan_mode_IFACE}" != "${mode_IFACE}" ]; then
	                ${IWCONFIG} ${IFACE} mode ${scan_mode_IFACE} 2>/dev/null \
        	        || ewarn "  ${IFACE} does not support setting the mode to \"${scan_mode_IFACE}\""
	        fi
		# Next we set any private driver ioctls needed
		if [ -n "${priv_scan_pre_IFACE}" ]; then
			${IWPRIV} ${IFACE} ${priv_scan_pre_IFACE} 2>/dev/null \
			|| ewarn "  ${IFACE} does not support the following private ioctls" \
			&& ewarn "    \"${priv_scan_pre_IFACE}\""
		fi
		einfo "  Scanning for access points"
		${IFCONFIG} ${IFACE} up >/dev/null
		${SLEEP} ${sleep_scan_IFACE}
		local scan_IFACE="$(${IWLIST} ${IFACE} scan 2>/dev/null)"
		# We may need to unset the previous private driver ioctls
		if [ -n "${priv_scan_post_IFACE}" ]; then
			${IWPRIV} ${IFACE} ${priv_scan_post_IFACE} 2>/dev/null \
			|| ewarn "  ${IFACE} does not support the following private ioctls" \
			&& ewarn "    \"${priv_scan_post_IFACE}\""
		fi
		# Change back to the desired mode
                if [ -n "${scan_mode_IFACE}" ] && [ "${scan_mode_IFACE}" != "${mode_IFACE}" ]; then
			if [ -n "${mode_IFACE}" ]; then
	                        ${IWCONFIG} ${IFACE} mode ${mode_IFACE} 2>/dev/null
			else
				${IWCONFIG} ${IFACE} mode Managed 2>/dev/null
			fi
                fi
		local scan_supported="$(echo ${scan_IFACE} | gawk -v IFACE=${IFACE} '/Scan completed|No scan results/ {if ($1 == IFACE) print "yes"}')"
 		scan_supported=${scan_supported:-"no"}

		if [ "no" == "${scan_supported}" ]; then
			if [ -z "${wireless_preferred}" ]; then
				eerror "${IFACE} does not support scanning!"
				eerror "You need to configure an ESSID in /etc/conf.d/net"
				eerror "    wireless_essid_${IFACE}=\"ESSID\""
				eerror "    (set to "any" to pick the strongest available access point)"
				eerror "or configure wireless_preferred to force a list of access points"
				${IFCONFIG} ${IFACE} down >/dev/null
				return 1
			else
				ewarn "  ${IFACE} does not support scanning"
			fi
		else
			local APs=""
			# Remove all word splitting - otherwise the gawk command breaks
			local IFS=""
			local scan_APs="$(IFS='' & echo ${scan_IFACE} | gawk -F: '/ESSID/ {print $2}')"
			# Setup the word splitting to that only newlines and tabs are used
			local IFS=$'\n'$'\t'
			local AP=""
			for AP in ${scan_APs}; do
				AP=${AP#*\"}
				AP=${AP%*\"}
				einfo "    Found \"${AP//\\\\/\\\\}\""
				APs=${APs}${AP}$'\n'
			done

			# Check for preferred APs
			for ESSID in ${wireless_preferred}; do
				for AP in ${APs}; do
					if [ "${ESSID}" == "${AP}" ]; then
						associate_wireless && return 0
						break
					fi
				done
			done

			# Check for configured APs that are NOT in our preferred list and try to connect
			for ESSID in ${APs}; do
				local has_preferred="no"
				for AP in ${wireless_preferred}; do
					if [ "${ESSID}" == "${AP}" ]; then
						has_preferred="yes"
						break
					fi
				done
				if [ "no" == "${has_preferred}" ]; then
					setup_essid_env
					if [ "yes" == "${essid_has_config}" ]; then
						associate_wireless && return 0
					fi
				elif [ -z "${first_AP}" ]; then
					first_AP=${essid_IFACE}
				fi
			done
		fi
	fi

	if [ -n "${wireless_preferred}" ]; then
		ewarn "  No preferred Access Points found for ${IFACE}"
		ewarn "    trying to force preferred"
	        # Setup the word splitting to that only newlines and tabs are used
        	local IFS=$'\n'$'\t'
		for ESSID in ${wireless_preferred}; do
			local foundAP="no"
			local AP=""
			for AP in ${APs}; do
				if [ "${ESSID}" == "${AP}" ]; then
					foundAP="yes"
					break
				fi
			done
			if [ "no" == "${foundAP}" ]; then
				associate_wireless && return 0
			fi
		done
		ewarn "  Failed to associate with any preferred access points"
	fi

	if [ -z "${first_AP}" ]; then
		eerror "No Access Points found for ${IFACE}"
		${IFCONFIG} ${IFACE} down >/dev/null
		return 1
	fi

	ESSID=${first_AP}
	associate_wireless && return 0
	eerror "Couldn't associate with any access points"
	return 1
}

iface_start() {
	local retval=0

	setup_env ${1}
	local IFACE="${1}"
	local display=${IFACE}

        if [ "${wireless_IFACE}" == "yes" ]; then
                ebegin "Configuring wireless network for ${IFACE}"
                setup_wireless || {
			retval=$?
			eend ${retval} "Failed to configure wireless for ${IFACE}"
			return ${retval}
		}
		eend 0
        fi

	checkconfig || return 1

	if [ -n "${preifup_IFACE}" ]; then
		# We have a custom script to run before ifconfig
		ebegin "Running a setup script for ${IFACE}"
		${preifup_IFACE} || {
			retval=$?
			eend ${retval} "Failed to run the setup script for ${IFACE}"
			return ${retval}
		}
		eend 0
	fi

        if [ -n "${preifup_ESSID}" ]; then
                # We have a custom script to run before ifconfig
                ebegin "Running a setup script for ${display_ESSID}"
                ${preifup_ESSID} || {
                        retval=$?
                        eend ${retval} "Failed to run the setup script for ${display_ESSID}"
                        return ${retval}
                }
                eend 0
        fi

	ebegin "Bringing ${IFACE} up"
  	if [ "${iface_IFACE}" != "dhcp" ]
	then
		${IFCONFIG} ${IFACE} ${iface_IFACE} >/dev/null || {
			retval=$?
			eend ${retval} "Failed to bring ${IFACE} up"
			return ${retval}
		}
		# ifconfig do not always return failure ..
		${IFCONFIG} ${IFACE} &> /dev/null || {
			retval=$?
			eend ${retval} "Failed to bring ${IFACE} up"
			return ${retval}
		}
	else
		# Check that eth0 was not brough up by the kernel ...
		if [ "${status_IFACE}" != "up" ]
		then
			/sbin/dhcpcd ${dhcpcd_IFACE} ${IFACE} >/dev/null || {
				retval=$?
				eend ${retval} "Failed to start DHCP on ${IFACE}"
				return ${retval}
			}
		fi
	fi
	eend 0

	save_options "essid" "${ESSID}"

        if [ -n "${nameserver_IFACE}" ]; then
		echo "nameserver ${nameserver_IFACE}" > /etc/resolv.conf
		if [ -n "${domain_IFACE}" ]; then
			echo "domain ${domain_IFACE}" >> /etc/resolv.conf
			echo "search ${domain_IFACE}" >> /etc/resolv.conf
		fi
	fi

	if [ -n "${alias_IFACE}" ]
	then
		local x=""
		local num=0
		local aliasbcast=""
		local aliasnmask=""

		ebegin "  Adding aliases"
		for x in ${alias_IFACE}
		do
			aliasbcast="$(eval echo \$\{broadcast_${iface}\} \| awk \'\{ print \$$((num + 1)) \}\')"
			if [ -n "${aliasbcast}" ]
			then
				aliasbcast="broadcast ${aliasbcast}"
			fi

			aliasnmask="$(eval echo \$\{netmask_${iface}\} \| awk \'\{ print \$$((num + 1)) \}\')"
			if [ -n "${aliasnmask}" ]
			then
				aliasnmask="netmask ${aliasnmask}"
			fi
		
			ebegin "    ${IFACE}:${num}"
			${IFCONFIG} ${IFACE}:${num} ${x} \
				${aliasbcast} ${aliasnmask} >/dev/null
			num=$((num + 1))
			eend 0
		done
		save_options "alias" "${alias_IFACE}"
	fi

	if [ -n "${inet6_IFACE}" ]
	then
		local x=""
		ebegin "  Adding inet6 addresses"
		for x in ${inet6_IFACE}
		do
			ebegin "    ${IFACE} inet6 add ${x}"
			${IFCONFIG} ${IFACE} inet6 add ${x} >/dev/null
			eend 0
		done
		save_options "inet6" "${inet6_IFACE}"
	fi
	
	if [ -n "${gateway}" ] && [ "${gateway%/*}" = "${IFACE}" ]
	then
		ebegin "  Setting default gateway"
		# First delete any existing routes if it was setup by kernel ..
		${ROUTE} del default dev ${gateway%/*} &>/dev/null
		${ROUTE} add default gw ${gateway#*/} dev ${gateway%/*} \
			netmask 0.0.0.0 metric 1 >/dev/null || {
			
			local error=$?
			${IFCONFIG} ${IFACE} down &>/dev/null
			eend ${error} "Failed to bring ${IFACE} up"
			stop
			return ${error}
		}
		eend 0
	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 "$(egrep '^[^#]*rp_filter' /etc/sysctl.conf 2>/dev/null)" ]
	then
		echo 1 > /proc/sys/net/ipv4/conf/${IFACE}/rp_filter
	fi
}

iface_stop() {
	local myalias="$(get_options alias)"
	local myinet6="$(get_options inet6)"

	setup_env ${1}
	local IFACE="${1}"
	local display=${IFACE}

	ESSID="$(get_options essid)"
	if [ -n "${ESSID}" ]; then
		setup_essid_env
		setup_wireless_iface
	fi

	checkconfig || return 1

        if [ -n "${preifdown_IFACE}" ]; then
                # We have a custom script to run before ifconfig
                ebegin "Running a script for ${IFACE}"
                ${preifdown_IFACE} || {
                        retval=$?
                        eend ${retval} "Failed to run the script for ${IFACE}"
                        return ${retval}
                }
                eend 0
        fi

	if [ -n "${preifdown_ESSID}" ]; then
		# We have a custom script to run before ifconfig
		ebegin "Running a script for ${display_ESSID}"
		${preifdown_ESSID} || {
			retval=$?
			eend ${retval} "Failed to run the script for ${display_ESSID}"
			return ${retval}
		}
		eend 0
	fi

	ebegin "Bringing ${IFACE} down"

	# Also down the inet6 interfaces
	if [ -n "${myinet6}" ]
	then
		local x=""
		for x in ${myinet6}
		do
			${IFCONFIG} ${IFACE} inet6 del ${x} >/dev/null
		done
	fi
	
	# Do some cleanup in case the amount of aliases change
	if [ -n "${myalias}" ]
	then
		local x=""
		local num=0
		for x in ${myalias}
		do
			${IFCONFIG} ${IFACE}:${num} down >/dev/null
			num=$((num + 1))
		done
	fi

	if [ "${iface_IFACE}" == "dhcp" ]
	then
		local count=0
		while ${DHCPCD} -z ${IFACE} &>/dev/null && [ "${count}" -lt 9 ]
		do
			# Give dhcpcd time to properly shutdown
			${SLEEP} 1
			count=$((count + 1))
		done
		if [ "${count}" -ge 9 ]
		then
			eerror "Timed out trying to stop dhcpcd"
		fi
	fi

	# We always force the interface down as dhcpcd exits at startup
	# if the lease time is infinite
	${IFCONFIG} ${IFACE} down >/dev/null
	eend 0
}

start() {
	iface_start ${IFACE} || return 1
	for vlan in ${vlans}
	do
		${VCONFIG} add ${IFACE} ${vlan} >/dev/null
		iface_start ${IFACE}.${vlan}
	done
}

stop () {
	for vlan in ${vlans}
	do
		iface_stop ${IFACE}.${vlan}
		${VCONFIG} rem ${IFACE}.${vlan} >/dev/null
	done
	iface_stop ${IFACE}
}

# vim:ts=4