| View previous topic :: View next topic |
| Author |
Message |
kmcmanus
n00b
Joined: 29 Jun 2003
Posts: 3
|
 Posted: Wed Sep 14, 2005 8:56 pm Post subject: dhcpcd does not run on boot after emerge world |
 |
|
I recently ran an emerge world on my system, and carefully merged the config files using etc-update (albeit at silly hours in the morning).
Before the emerge everything was running well, but now when I boot the system I get no network access, unless I manually run:
I have had a quick look at several files and the following looks a little strange (it is also identical to net.lo)
/etc/init.d/net.eth0
| Code: |
#!/sbin/runscript
# Copyright 1999-2004 Gentoo Technologies, Inc.
# Distributed under the terms of the GNU General Public License v2
# $Header: /home/cvsroot/gentoo-src/rc-scripts/init.d/net.lo,v 1.10 2004/04/21 17:09:18 vapier
Exp $
start() {
ebegin "Bringing ${IFACE} up"
/sbin/ifconfig lo 127.0.0.1 up 2>/dev/null
/sbin/route add -net 127.0.0.0 netmask 255.0.0.0 \
gw 127.0.0.1 dev lo 2> /dev/null
eend 0
}
stop() {
ebegin "Bringing ${IFACE} down"
/sbin/ifconfig ${IFACE} down &>/dev/null
eend 0
}
|
If this broken please can someone tell me what it should look like / or how I can restore the original.
Finally in case it helps (cos the above is not broken) my /etc/conf.d/net looks like:
| Code: |
# /etc/conf.d/net:
# $Header: /home/cvsroot/gentoo-src/rc-scripts/etc/conf.d/net,v 1.7 2002/11/18 1
9:39:22 azarah Exp $
# Global config file for net.* rc-scripts
# This is basically the ifconfig argument without the ifconfig $iface
#
#iface_eth0="192.168.0.2 broadcast 192.168.0.255 netmask 255.255.255.0"
#iface_eth1="207.170.82.202 broadcast 207.0.255.255 netmask 255.255.0.0"
# For DHCP set iface_eth? to "dhcp"
# For passing options to dhcpcd use dhcpcd_eth?
#
iface_eth0="dhcp"
#dhcpcd_eth0="..."
# For adding aliases to a interface
#
#alias_eth0="192.168.0.3 192.168.0.4"
# NB: The next is only used for aliases.
#
# To add a custom netmask/broadcast address to created aliases,
# uncomment and change accordingly. Leave commented to assign
# defaults for that interface.
#
#broadcast_eth0="192.168.0.255 192.168.0.255"
#netmask_eth0="255.255.255.0 255.255.255.0"
# For setting the default gateway
#
#gateway="eth0/192.168.0.1"
|
Thanks in advance |
|
| Back to top |
|
 |
hw-tph
l33t
Joined: 08 Jan 2004
Posts: 768
Location: Uppsala, Sweden
|
| Posted: Wed Sep 14, 2005 10:04 pm Post subject: |
|
|
That's an ancient net script you have there. Perhaps you should actually let etc-update update the scripts in /etc/init.d/ (unless you have made extensive modifications yourself!). 
Here's my stock /etc/init.d/net.lo script (which net.eth0 is a link to - hence their similarity (it's the same file)):
| Code: | #!/sbin/runscript
# Copyright (c) 2004-2005 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header$
# 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
if [[ -n ${NET_DEBUG} ]]; then
set -x
devnull=/dev/stderr
else
devnull=/dev/null
fi
# For pcmcia users. note that pcmcia must be added to the same
# runlevel as the net.* script that needs it.
depend() {
use coldplug hotplug pcmcia usb isdn4linux wlan
# 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}
}
# Define where our modules are
MODULES_DIR=/lib/rcscripts/net.modules.d
# Load some functions shared between ourselves and our dhcp helpers
source ${MODULES_DIR}/helpers.d/functions
# Make some wrappers to fudge after/before/need/use depend flags.
# These are callbacks so mods[i] will be set.
after() {
local x="$*"
[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
eval "${MODULE}_after() { echo \"$x\"; }"
}
before() {
local x="$*"
[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
eval "${MODULE}_before() { echo \"$x\"; }"
}
need() {
local x="$*"
[[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )
eval "${MODULE}_need() { echo \"$x\"; }"
}
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\"; }"
}
sort() {
LC_ALL=C /bin/sort "$@"
}
# void module_class_wrap(char *module, char *provides)
# Setup class wrappers: interface_up -> iproute2_up, for example
module_class_wrap() {
local module=${1} provides=${2} x
# Don't wrap functions if another module already has
[[ $( type -t ${provides}_provides ) == function ]] && return
for x in $( typeset -f | grep -o ^${module}_'[^ ]*' ); do
eval "${provides}${x#${module}}() { ${x} \"\$@\"; }"
done
}
# bool module_load_minimum(char *module)
#
# Does the minimum checking on a module - even when forcing
module_load_minimum() {
local f=${1} 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 check_installed provides check_depends depend; do
[[ $( type -t ${MODULE}_${f} ) == function ]] && continue
eerror "${MODULE} does not support the required function ${f}"
return 1
done
# Wrap our before/after/need/use functions
${MODULE}_depend
return 0
}
# 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 e f i j beforefuncs afterfuncs diffs unload
# Populate the MODULES array
MODULES=( $( find ${MODULES_DIR}/ -maxdepth 1 -type f ! -name ".*" | sort ) )
# 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_
beforefuncs="$( typeset -F )"
j=${#MODULES[@]}
loaded_interface=false
for (( i=0; i<j; i++ )); do
unload=false
module_load_minimum ${MODULES[i]} || unload=true
MODULES[i]=${MODULES[i]##*/}
! ${unload} && ${MODULES[i]}_check_installed false || unload=true
if [[ ${MODULES[i]} == interface ]]; then
eerror "interface is a reserved name - cannot load a module called interface"
return 1
fi
afterfuncs="$( typeset -F )"
if ${unload} ; then
unset MODULES[i]
unsetfuncs="${unsetfuncs} $( diff -U0 <( echo "${beforefuncs}" ) <( echo "${afterfuncs}" ) 2>/dev/null \
| awk 'BEGIN { ORS = " "; } /+declare -f/ { print $3; }' )"
fi
beforefuncs="${afterfuncs}"
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
[[ $( type -t ${MODULES[i]}_instlled ) != function ]] && continue
for j in $( ${MODULES[i]}_instlled ); do
missingdeps=true
if [[ $( type -t ${j}_check_installed ) == function ]]; then
${j}_check_installed && 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 -a umods
local i j k l npref nmods=${#MODULES[@]}
# Has the interface got any specific modules?
eval umods=( \"\$\{modules_${iface}\[@\]\}\" )
# Global setting follows interface-specific setting
umods=( "${umods[@]}" "${modules[@]}" )
# Add our preferred modules
npref=3
umods=( "${umods[@]}" "ifconfig" "dhcpcd" "iwconfig" )
# 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
${MODULES[j]}_check_installed && module_class_wrap ${MODULES[j]}
unset MODULES[j]
unset PROVIDES[j]
break
fi
done
continue
fi
if [[ $( type -t ${umods[i]}_provides ) != function ]]; then
# If the module is one of our preferred modules, then
# ignore this error; whatever is available will be
# used instead.
(( i < ${#umods[@]} - npref )) || continue
eerror "${umods[i]} is not a valid module (missing provides)"
return 1
fi
# Ensure that the user specified module has its package installed
if (( i < ${#umods[@]} - npref )); then
# $1==true causes check_installed to report its own errors
${umods[i]}_check_installed true || return 1
else
# If this happens on a preferred modules, ignore it;
# whatever is available will be used instead.
${umods[i]}_check_installed false || continue
fi
mod=$( ${umods[i]}_provides )
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} -eq ${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)
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 )
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
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"
done
p=( $( echo -e "${um}" | sort -n | awk '{print $2,$3}' ) )
MODULES=()
PROVIDES=()
j=0
for (( i=0; i<${#p[@]}; i+=2 )); do
MODULES[j]=${p[i]}
PROVIDES[j]=${p[i+1]}
(( j++ ))
done
}
# 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 [[ $( type -t ${MODULES[i]}_need ) == function ]]; 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
${MODULES[i]}_check_depends || return 1
[[ ${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 1
modules_load() {
local iface=${1} starting=${2:-true} mod p=false i j unsetfuncs
local -a x
local RC_INDENTATION=${RC_INDENTATION} # so it will reset after function
local -a PROVIDES
if [[ ${iface} == lo ]]; then
# We force lo to only use these modules for a major speed boost
modules_force=( "iproute2" "ifconfig" )
else
eval 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
veinfo "Loading networking modules for ${iface}"
fi
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
${modules_force[i]}_check_installed || unset modules_force[i]
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 )
done
if [[ -z ${modules_force[@]} ]]; then
if ${starting}; then
modules_check_user || return 1
fi
# We unset unloaded module functions here as so we can error
# with a message informing the user to emerge the correct
# package if it's in their modules
[[ -n ${unsetfuncs} ]] && unset ${unsetfuncs}
modules_sort
fi
# Setup class wrappers: interface_up -> iproute2_up, for example
j=${#MODULES[@]}
for (( i=0; i<j; i++ )); do
module_class_wrap ${MODULES[i]} ${PROVIDES[i]}
done
modules_check_installed || return 1
[[ ${iface} != lo ]] && veinfo "modules: ${MODULES[@]}"
eindent
[[ ${iface} != lo && ${starting} == true ]] && 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 warn=false config_worked=false
local RC_INDENTATION=${RC_INDENTATION} # so it will reset after function
local -a config fallback fallback_route conf
local ifvar=$( interface_variable ${iface} )
# pre Start any modules with
for mod in ${MODULES[@]}; do
if [[ $( type -t ${mod}_pre_start ) == function ]]; then
${mod}_pre_start ${iface} || { eend 1; return 1; }
fi
done
# New style config - one variable fits all
eval config=( \"\$\{config_${ifvar}\[@\]\}\" )
eval fallback=( \"\$\{fallback_${ifvar}\[@\]\}\" )
eval fallback_route=( \"\$\{fallback_route_${ifvar}\[@\]\}\" )
# We must support old configs
if [[ -z ${config} ]]; then
interface_get_old_config ${iface} || return 1
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
if [[ -z ${config} ]]; then
if [[ $( type -t dhcp_start ) == function ]]; then
config=( "dhcp" )
warn=true
else
eerror "Cannot default to dhcp as there is no dhcp module loaded"
eerror "No configuration for ${iface}"
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
if ${warn}; then
ewarn "Configuration not set for ${iface} - assuming dhcp"
warn=false
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 [[ $( type -t ${conf[0]}_start ) == function ]]; then
# Check that the module is valid
x=false
for mod in ${MODULES[@]}; do
if [[ $( ${mod}_provides ) == ${conf[0]} ]]; then
x=true
break
fi
done
if ! ${x}; then
[[ $( type -t ${conf[0]}_check_installed == function ) ]] && ${conf[0]}_check_installed true
eerror "No loaded modules provide \"${conf[0]}\" (${conf[0]}_start)"
else
eindent
${conf[0]}_start ${iface} ; x=$?
eoutdent
[[ ${x} == 0 ]] && config_worked=true && continue
fi
# 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 [[ $(type -t address_exists ) == function ]]; then
# if address_exists ${iface} ${conf[0]} ; then
# eerror "${conf[0]%%/*} already taken on ${iface}"
# x=1
# fi
# fi
[[ ${x} == 0 ]] && interface_add_address ${iface} ${conf[@]} ; x=$?
eend ${x} && config_worked=true && continue
else
eerror "No loaded modules provide \"${conf[0]}\" (${conf[0]}_start)"
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
eval "routes_${ifvar}=( "\"\$\{fallback_route\[${config_counter}\]\[@\]\}\"" )"
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 [[ function == $( type -t ${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.
#
# However, we are currently reliant on handler and modules specified
# in /etc/conf.d/net
iface_stop() {
local iface=${1} i aliases need_begin=false mod
local RC_INDENTATION=${RC_INDENTATION} # so it will reset after function
# pre Stop any modules
for mod in ${MODULES[@]}; do
[[ $( type -t ${mod}_pre_stop ) == function ]] && ${mod}_pre_stop ${iface}
done
einfo "Bringing down ${iface}"
eindent
# Collect list of aliases for this interface.
# List will be in reverse order.
aliases=$( interface_get_aliases_rev ${iface} )
# 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
[[ $( type -t ${mod}_stop ) == function ]] && ${mod}_stop ${i}
done
# A module may have removed the interface
interface_exists ${iface} || { eend 0; continue; }
# Delete all the addresses for this alias
interface_del_addresses ${i}
# Do final shut down of this alias
ebegin "Shutting down ${i}"
interface_iface_stop ${i}
eend $?
done
# 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}
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 x
if [[ ${iface} == lo ]]; then
ebegin "Bringing up ${iface}"
interface_loopback_create
eend $?
return $?
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
# Setup variables for pre/post to use
ifvar=$( interface_variable ${iface} )
local IFACE=${iface} IFVAR=${ifvar}
# Call user-defined preup function if it exists
if [[ $( type -t preup ) == function ]]; then
einfo "Running preup function"
eindent
preup ${iface} ; x=$?
eoutdent
if [[ ${x} != 0 ]]; then
eerror "preup ${iface} failed"
return 1
fi
fi
# Don't let preup modify us
iface=${1}
local IFACE=${iface} IFVAR=${ifvar} config
# If config is set to noop and the interface is up with an address
# then we don't start it
eval config=( \"\$\{config_${ifvar}\[@\]\}\" )
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
interface_del_addresses ${iface}
# Start the interface
if ! iface_start ${iface} ; then
interface_exists ${iface} && interface_down ${iface}
eend 1
return 1
fi
fi
# Call user-defined postup function if it exists
if [[ $( type -t postup ) == function ]]; then
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 x
# Don't run any special shutdown functions for lo
if [[ ${iface} == lo ]]; then
ebegin "Shutting down ${iface}"
interface_iface_stop ${iface}
eend $?
return 0
fi
# Setup variables for pre/post to use
ifvar=$( interface_variable ${iface} )
local IFACE=${iface} IFVAR=${ifvar}
# Call user-defined predown function if it exists
if [[ $( type -t predown ) == function ]]; then
einfo "Running predown function"
eindent
predown ${iface} ; x=$?
eoutdent
if [[ ${x} != 0 ]]; then
eend 1 "predown ${iface} failed"
return 1
fi
elif is_net_fs /; then
eerror "root filesystem is network mounted -- can't stop ${iface}"
return 1
fi
# Don't let predown modify us
iface=${1}
local IFACE=${iface} IFVAR=${ifvar}
iface_stop ${iface} || return 1 # always succeeds, btw
# Call user-defined postdown function if it exists
if [[ $( type -t postdown ) == function ]]; then
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 interface
run() {
local iface=${1} cmd=${2} r=1 RC_INDENTATION=${RC_INDENTATION} # so it will reset after function
local before starting=true
local -a MODULES mods
# 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
unset_functions=${unset_functions:-false}
${unset_functions} && before="$( typeset -F )"
[[ ${cmd} == "stop" ]] && starting=false
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
run_start ${iface} && r=0
fi
fi
# We need to remove added functions before we quit as other init
# scripts may be launching afterwards
${unset_functions} && \
unset $( diff -U0 <( echo "${before}" ) <( echo "$( typeset -F )" ) 2>/dev/null \
| awk 'BEGIN { ORS = " "; } /+declare -f/ { print $3; }' ) 2>/dev/null
return ${r}
}
# bool start(void)
#
# Start entry point so that we only have one function
# which localises variables and unsets functions
start() {
einfo "Starting ${IFACE}"
run ${IFACE} start
return $?
}
# bool stop(void)
#
# Stop entry point so that we only have one function
# which localises variables and unsets functions
stop() {
einfo "Stopping ${IFACE}"
run ${IFACE} stop
return $?
}
# bool restart(void)
#
# Restart entry point
# We do this so as we only have to remove functions when stopping
restart() {
local unset_functions=true
service_started "${myservice}" && svc_stop
unset_functions=false
svc_start
return $?
}
# vim:ts=4 |
_________________
Self-admitted computer fetishist |
|
| Back to top |
|
|
kmcmanus
n00b
Joined: 29 Jun 2003
Posts: 3
|
| Posted: Fri Sep 16, 2005 9:51 pm Post subject: |
|
|
Thanks ,
I have been a muppet - after inspecting the contents of /etc/init.d/ I noticed that my net.lo had a newer version that was still waiting to be merged.
I had forgotten that the two files were linked, and because my loopback adapter was working I didn't think there was a problem with net.lo
Having merged the file all is well again. |
|
| Back to top |
|
|
UberLord
Retired Dev
Joined: 18 Sep 2003
Posts: 6835
Location: Blighty
|
|
| Back to top |
|
|
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
|
Networking & Security
