#!/sbin/runscript# Copyright 2004-2007 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 after bootmisc hostname use isapnp isdn pcmcia usb wlan # 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 return 0}# Define where our modules areMODULES_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 caseinterface_device() { local dev="${1%%.*}" [[ ${dev} == "$1" ]] && dev="${1%%:*}" echo "${dev}"}# char* interface_type(char* iface)## Returns the base type of the interface# eth, ippp, etcinterface_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 othercalculate_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}"}# int netmask2cidr(char *netmask)## Returns the CIDR of a given netmasknetmask2cidr() { 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}"}# bool is_function(char* name)## Returns 0 if the given name is a shell function, otherwise 1is_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 option1configure_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 forcingmodule_load_minimum() { local f="$1.sh" 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 depend; do is_function "${MODULE}_${f}" && continue eerror "${MODULE}.sh 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 removedmodules_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 ( 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 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 modulemodules_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 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 eerror "The module \"${umods[i]}\" does not exist" fi return 1 fi 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 modulesmodules_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 return 0}# bool modules_load(char *iface, bool starting)## Loads the defined handler and modules for the interface# Returns 0 on success, otherwise 1modules_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 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 interface_exists "${iface}" && interface_up "${iface}" # 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 interface_exists "${iface}" && interface_up "${iface}" 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 # 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= aliases= need_begin=false mod= local RC_INDENTATION="${RC_INDENTATION}" # 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 # 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 # 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 # 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}# 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[@]}" ) elif [[ -n ${metric} ]] ; then eval "metric_${IFVAR}=\"${metric}\"" 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 is_function preup ; 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= 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\}\"" )" # 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 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" 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 is_function predown ; 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 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 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 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" 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 interfacerun() { 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 functionsstart() { 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 functionsstop() { declare -r IFACE="${SVCNAME#*.}" einfo "Stopping ${IFACE}" run "${IFACE}" stop}# vim:ts=4