diff options
author | Rene Mayrhofer <rene@mayrhofer.eu.org> | 2006-11-06 19:00:10 +0000 |
---|---|---|
committer | Rene Mayrhofer <rene@mayrhofer.eu.org> | 2006-11-06 19:00:10 +0000 |
commit | 58d26e02cd8686e177eebb9fb81e6b17798bbb30 (patch) | |
tree | e7329ae5a85bb2d6b8bba0ebcd65c6c41999f96f /testing/hosts/winnetou/etc/init.d | |
parent | 0b5d496ea2fd532dcf5e5b6b804a7db32f488364 (diff) | |
download | vyos-strongswan-58d26e02cd8686e177eebb9fb81e6b17798bbb30.tar.gz vyos-strongswan-58d26e02cd8686e177eebb9fb81e6b17798bbb30.zip |
Load /tmp/tmp.IBEBMao893/strongswan-2.8.0+dfsg into
branches/source-dist/debian/strongswan.
Diffstat (limited to 'testing/hosts/winnetou/etc/init.d')
-rwxr-xr-x | testing/hosts/winnetou/etc/init.d/net.eth0 | 1266 | ||||
-rwxr-xr-x | testing/hosts/winnetou/etc/init.d/slapd | 2 |
2 files changed, 1039 insertions, 229 deletions
diff --git a/testing/hosts/winnetou/etc/init.d/net.eth0 b/testing/hosts/winnetou/etc/init.d/net.eth0 index fa1200242..92b3851cf 100755 --- a/testing/hosts/winnetou/etc/init.d/net.eth0 +++ b/testing/hosts/winnetou/etc/init.d/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 diff --git a/testing/hosts/winnetou/etc/init.d/slapd b/testing/hosts/winnetou/etc/init.d/slapd index d4c070b33..6e3130e90 100755 --- a/testing/hosts/winnetou/etc/init.d/slapd +++ b/testing/hosts/winnetou/etc/init.d/slapd @@ -1,7 +1,7 @@ #!/sbin/runscript # Copyright 1999-2004 Gentoo Foundation # Distributed under the terms of the GNU General Public License v2 -# $Header: /var/cvsroot/strongswan/testing/hosts/winnetou/etc/init.d/slapd,v 1.2 2005/05/31 14:04:43 as Exp $ +# $Header: /root/strongswan/testing/hosts/winnetou/etc/init.d/slapd,v 1.2 2005/05/31 14:04:43 as Exp $ depend() { need net |