| View previous topic :: View next topic |
| Author |
Message |
The_P
Apprentice
Joined: 13 Mar 2004
Posts: 248
|
 Posted: Thu Nov 17, 2005 1:24 pm Post subject: [solved] problems with wireless after updating baselayout |
 |
|
I had a lot of problems with my wireless conection. I read somwhere that updating the baselayout can solve my problem. So i did this. Now i have baslayout 1.12.0_pre10-r1. Now my wireless conection is still not working and i get different errormessages than befor updating. The problem before updating was the dhclient who din't work. Now the dhclient works with my lan-conection. But there are these errormessages when i try to start my wireless connection
| Code: |
* Starting ath0
* adsl does not support the required function provides
* apipa does not support the required function check_installed
* arping does not support the required function provides
* bonding does not support the required function provides
* bridge does not support the required function provides
* dhclient does not support the required function provides
* dhcpcd does not support the required function provides
* essidnet does not support the required function check_installed
* ifconfig does not support the required function provides
* ifplugd does not support the required function provides
* ipppd does not support the required function provides
* iproute2 does not support the required function provides
* iptunnel does not support the required function check_installed
* iwconfig does not support the required function provides
* macchanger does not support the required function check_installed
* macnet does not support the required function check_installed
* netplugd does not support the required function provides
* pppd does not support the required function provides
* pump does not support the required function provides
* rename does not support the required function check_installed
* system does not support the required function check_installed
* tuntap does not support the required function provides
* udhcpc does not support the required function provides
* vlan does not support the required function provides
* wpa_supplicant does not support the required function provides
* no interface module has been loaded
|
I think i did something wrong updating the config files.
Here are my config files for the network.
| Code: |
# This blank configuration will automatically use DHCP for any net.*
# scripts in /etc/init.d. To create a more complete configuration,
# please review /etc/conf.d/net.example and save your configuration
# in /etc/conf.d/net (this file :]!).
iface_eth0="dhcp"
#iface_ath0="dhcp"
#modules=( "wpa_supplicant" )
# Users of madwifi add this:
wpa_supplicant_ath0="-Dmadwifi"
wpa_timeout_ath0=60
modules_ath0=("dhcp")
|
| 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 ".*" | sor
t ) )
# 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=tru
e
if [[ ${MODULES[i]} == interface ]]; then
eerror "interface is a reserved name - cannot load a mod
ule called interface"
return 1
fi
afterfuncs="$( typeset -F )"
if ${unload} ; then
unset MODULES[i]
unsetfuncs="${unsetfuncs} $( diff -U0 <( echo "${beforef
uncs}" ) <( echo "${afterfuncs}" ) 2>/dev/null \
| awk 'BEGIN { ORS = " "; } /+declare -f/ { prin
t $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 ]] && continu
e
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 f
or 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 provi
des)"
return 1
fi
# Ensure that the user specified module has its package installe
d
if (( i < ${#umods[@]} - npref )); then
# $1==true causes check_installed to report its own erro
rs
${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]} != ${MODUL
ES[j]} ]]; then
# We don't have a match - now ensure that we sti
ll 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} != ${PR
OVIDES[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} != ${PR
OVIDES[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; blund
ering 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]} || ${n
eedmod} == ${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 "${MODUL
ES[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 functio
n
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 brea
king"
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_for
ce[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 functio
n
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 modul
e 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 dhc
p"
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]} ]]; the
n
x=true
break
fi
done
if ! ${x}; then
[[ $( type -t ${conf[0]}_check_installed == func
tion ) ]] && ${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 && continu
e
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]} == *:* ]]; t
hen
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 i
t
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 functio
n
# pre Stop any modules
for mod in ${MODULES[@]}; do
[[ $( type -t ${mod}_pre_stop ) == function ]] && ${mod}_pre_sto
p ${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}_sto
p ${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_s
top ${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}=( "\"\$\{c
onfig\[@\]: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>/d
ev/null \
| awk 'BEGIN { ORS = " "; } /+declare -f/ { print $3; }' ) 2>/de
v/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
|
Last edited by The_P on Thu Nov 17, 2005 1:37 pm; edited 1 time in total |
|
| Back to top |
|
 |
UberLord
Retired Dev
Joined: 18 Sep 2003
Posts: 6835
Location: Blighty
|
|
| Back to top |
|
|
The_P
Apprentice
Joined: 13 Mar 2004
Posts: 248
|
| Posted: Thu Nov 17, 2005 1:36 pm Post subject: |
|
|
sorry for writing this big script.
You helpd me a lot. Thank you for this. Symlinking net.lo solved my problem but I still have the old problems with my wireless connection. I don't write my problem here because it's a different problem I will do this in an other thread. |
|
| 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
