Gentoo Forums
Gentoo Forums
Gentoo Forums
Quick Search: in
problem with net.eth0
View unanswered posts
View posts from last 24 hours

 
Reply to topic    Gentoo Forums Forum Index Duplicate Threads
View previous topic :: View next topic  
Author Message
martindv
Apprentice
Apprentice


Joined: 16 Jul 2005
Posts: 171
Location: Argentina

PostPosted: Fri Jan 06, 2006 1:12 pm    Post subject: problem with net.eth0 Reply with quote

Gents,
I have the following problem. After emerge i dont remember which package the net.eth0 script is not working anymore...

this is the error i receive when i try to lauch a service regarding net.eth0

Code:

./net.eth0 start
 * Caching service dependencies ...                                       [ ok ]
 * Starting eth0
./net.eth0: line 77: is_function: command not found
 *     adsl does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     apipa does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     bonding does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     bridge does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     dhclient does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     dhcpcd does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     essidnet does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     ifconfig does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     ipppd does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     iproute2 does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     iptunnel does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     iwconfig does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     macchanger does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     pump does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     tuntap does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     udhcpc does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     vlan does not support the required function depend
./net.eth0: line 77: is_function: command not found
 *     wpa_supplicant does not support the required function depend
./net.eth0: line 214: is_function: command not found
./net.eth0: line 214: is_function: command not found
./net.eth0: line 214: is_function: command not found
./net.eth0: line 214: is_function: command not found
 *       no interface module has been loaded
./net.eth0: line 894: is_function: command not found


Any idia who to solve or regenerate this file.

Regards.
_________________
Gentoo Rulez

AMD Athlon XP 2800+ @2.08Ghz
Asus A7V8NX-E-Deluxe
Nvidia Nforce2 chipset
1GB Ram
ASUS GeForce N6600 256MB RAM
2 IDE HDDS @Primary/Secondary Master
1 120GB HDD @Sata Channel #0
Back to top
View user's profile Send private message
PsychoticRetina
Guru
Guru


Joined: 18 Dec 2005
Posts: 352
Location: behind the scalpel

PostPosted: Fri Jan 06, 2006 2:08 pm    Post subject: Reply with quote

assuming the script itself got corrupted...

Quote:
#!/sbin/runscript
# Copyright (c) 2004-2005 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-src/rc-scripts/net-scripts/init.d/net.lo,v 1.38.2.19 2005/05/16 18:45:35 uberlord Exp $

# 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_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
Back to top
View user's profile Send private message
martindv
Apprentice
Apprentice


Joined: 16 Jul 2005
Posts: 171
Location: Argentina

PostPosted: Fri Jan 06, 2006 2:32 pm    Post subject: Reply with quote

It seems it want to work but i have the following error

Gentoo init.d # ./net.eth0 start
* Caching service dependencies ... [ ok ]
./net.eth0: line 513: syntax error in conditional expression
./net.eth0: line 513: syntax error near `\'
./net.eth0: line 513: `if [[ ${config[config_counter]} == "null" \ '
* ERROR: "./net.eth0" has syntax errors in it; not executing...


Is there any way to regenerate this file?
_________________
Gentoo Rulez

AMD Athlon XP 2800+ @2.08Ghz
Asus A7V8NX-E-Deluxe
Nvidia Nforce2 chipset
1GB Ram
ASUS GeForce N6600 256MB RAM
2 IDE HDDS @Primary/Secondary Master
1 120GB HDD @Sata Channel #0
Back to top
View user's profile Send private message
PietdeBoer
Apprentice
Apprentice


Joined: 20 Oct 2005
Posts: 244
Location: Eindhoven, the Netherlands

PostPosted: Fri Jan 06, 2006 2:37 pm    Post subject: Reply with quote

kinda a huge solution.. but when my scripts got corrupted.. i did a
Code:

rm /etc/init.d/net.eth0
rm /etc/init.d/net.eth1
rm /etc/conf.d/net


and then

Code:

emerge-baselayout


this regenerates those files.... and fixed my problen


there should be easier ways to regenerate those files..

good luck :)
_________________
_ Got Root? _
Back to top
View user's profile Send private message
martindv
Apprentice
Apprentice


Joined: 16 Jul 2005
Posts: 171
Location: Argentina

PostPosted: Fri Jan 06, 2006 3:45 pm    Post subject: Reply with quote

IT SEEMS IT WORKED

THANKKKKKKKKK YOUUUU YOU SAVED MY GENTOO... )
_________________
Gentoo Rulez

AMD Athlon XP 2800+ @2.08Ghz
Asus A7V8NX-E-Deluxe
Nvidia Nforce2 chipset
1GB Ram
ASUS GeForce N6600 256MB RAM
2 IDE HDDS @Primary/Secondary Master
1 120GB HDD @Sata Channel #0
Back to top
View user's profile Send private message
nixnut
Bodhisattva
Bodhisattva


Joined: 09 Apr 2004
Posts: 10974
Location: the dutch mountains

PostPosted: Fri Jan 06, 2006 4:06 pm    Post subject: Reply with quote

Moved from Installing Gentoo to Duplicate Threads.
Moved on favour of https://forums.gentoo.org/viewtopic-p-2482626.html#2482626
_________________
Please add [solved] to the initial post's subject line if you feel your problem is resolved. Help answer the unanswered

talk is cheap. supply exceeds demand
Back to top
View user's profile Send private message
Display posts from previous:   
Reply to topic    Gentoo Forums Forum Index Duplicate Threads All times are GMT
Page 1 of 1

 
Jump to:  
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