# what controls net.eth0?

## badgers

hello, I am trying to figure out what controls net.eth0 on bootup?

it seems my box fails to bring up eth0 on boot or when I call certain /etc/init.d/ scripts

I had emerged and unmerged rt2500 wireless drivers because I was testing a wireless card.

when the scripts in /etc/init.d fail I see an error about not finding wireless information.

My wireless used to be called ra0

any help is apprecated.

----------

## user118696

 *badgers wrote:*   

> it seems my box fails to bring up eth0 on boot or when I call certain /etc/init.d/ scripts

 

What are the 'scripts'??

Sure you have simply tried

```
/etc/init.d/net.eth0 start
```

----------

## badgers

/etc/init.d/sshd start

/etc/init.d/net.eth0 start

both fail, It seemed that the net.eth0 start should fail since thats what the boot process calls

as root from the command line I can do the following

ifconfig eth0 up works

dhcpcd eth0 works

then I can use firefox and check my email...

----------

## user118696

 *badgers wrote:*   

> ifconfig eth0 up works
> 
> dhcpcd eth0 works
> 
> then I can use firefox and check my email...

 

I don't quite get it : does your eth0 work or not?? Do you mean it only works as root?

Can you post you initscripts logs?

----------

## badgers

what happens is that when I emerged the rt2500 wireless driver it changed the way my system trys to bring up eth0

It trys to config eth0 as a wireless device, which it isn't so it fails.

I run ifconfig and dhcpcd as root but then I log into gnome as a normal user.

The normal user can use the network connection just fine.

I don't know scripting so I can't tell why or how the script is looking for eth0 to be a wireless device.

thanks for your help.

PS I am in the office and I can't post my logs right now.

----------

## user118696

We definitely need to have a look at the net.eth0 initscript. Post them when you're at home.

----------

## badgers

hello, and thanks to everyone for your help:

here is the situation

dmesg(the important part)

dding 516088k swap on /dev/hdd3.  Priority:-1 extents:1

usbcore: registered new driver usbfs

usbcore: registered new driver hub

b44: eth0: Link is up at 100 Mbps, full duplex.

b44: eth0: Flow control is on for TX and on for RX.

NETDEV WATCHDOG: eth0: transmit timed out

b44: eth0: transmit timed out, resetting

b44: eth0: Link is down.

nvidia: module license 'NVIDIA' taints kernel.

ACPI: PCI interrupt 0000:01:00.0[A] -> GSI 16 (level, low) -> IRQ 16

NVRM: loading NVIDIA Linux x86 NVIDIA Kernel Module  1.0-7174  Tue Mar 22 06:44:39 PST 2005

b44: eth0: Link is up at 100 Mbps, full duplex.

b44: eth0: Flow control is on for TX and on for RX.

I don't know how to capture the output that scrolls by at boot but if you could tell me where it is I could post it.

here is the 'script' locations

pali log # locate net.eth0

/etc/init.d/net.eth0

/etc/runlevels/default/net.eth0

/var/lib/init.d/exitcodes/net.eth0

/var/lib/init.d/softscripts/net.eth0

/var/lib/init.d/options/net.eth0

/var/lib/init.d/options/net.eth0/ESSID

/usr/portage/app-admin/quickswitch/files/net.eth0-switchto.rc6

 it seems that init.d is the only real place that the script lives

pali log # ls -ahl /etc/init.d/net.eth0

lrwxrwxrwx  1 root root 6 Aug 27 10:17 /etc/init.d/net.eth0 -> net.lo

pali log #

but it is a link to net.lo

#!/sbin/runscript # Copyright (c) 2004-2005 Gentoo Foundation # Distributed under the terms of the GNU General Public License v2

# Contributed by Roy Marples (uberlord@gentoo.org)

# Many thanks to Aron Griffis (agriffis@gentoo.org)

# for help, ideas and patches

#NB: Config is in /etc/conf.d/net

# For pcmcia users. note that pcmcia must be added to the same

# runlevel as the net.* script that needs it.

depend() {

        need localmount

        use coldplug 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"

# Some defaults

background="${background:-no}"

# 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 MODULE 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 go_background(void)

#

# Setup for backgrounding network script

go_background() {

        einfo "Backgrounding ..."

        mark_service_inactive "net.${iface}"

        exit 0

}

# 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

        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 i j

        # Populate the MODULES array

        # Basically we treat evey file in ${MODULES_DIR} as a module

        MODULES=( $( cd "${MODULES_DIR}" ; ls ) )

        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

                if [[ ${MODULES[i]##*/} == "interface" ]]; then

                        eerror "interface is a reserved name - cannot load a module called interface"

                        return 1

                fi

                (

                u=0;

                module_load_minimum "${MODULES[i]}" || u=1;

                [[ ${u} == 0 ]] && ${MODULES[i]##*/}_check_installed false || u=1;

                exit "${u}";

                )

                if [[ $? == 0 ]]; then

                        source "${MODULES[i]}"

                        MODULES[i]="${MODULES[i]##*/}"

                else

                        unset MODULES[i]

                fi

        done

        MODULES=( "${MODULES[@]}" )

        return 0

}

# bool modules_check_installed(void)

#

# Ensure that all modules have the required modules loaded

# This enables us to remove modules from the MODULES array

# Whilst other modules can still explicitly call them

# One example of this is essidnet which configures network

# settings for the specific ESSID connected to as the user

# may be using a daemon to configure wireless instead of our

# iwconfig 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[@]}" "iproute2" "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

                                        # 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]

                                        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

                        # 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]}" ]]; then

                                source "${MODULES_DIR}/${umods[i]}"

                                ${umods[i]}_check_installed true

                        else

                                eerror "The module \"${umods[i]}\" does not exist"

                        fi

                        return 1

                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} == "${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 | cut -d' ' -f2,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}" MODULE p=false i j k

        local -a x

        local RC_INDENTATION="${RC_INDENTATION}"

        local -a PROVIDES WRAP_MODULES

        if [[ ${iface} != "lo" ]]; then

                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

        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

                        ${modules_force[i]}_check_installed || unset modules_force[i]

                done

                modules_force=( "${modules_force[@]}" )

                # Strip any duplicate modules providing the same thing

                j="${#modules_force[@]}"

                for (( i=0; i<j-1; i++ )); do

                        [[ -z ${modules_force[i]} ]] && continue

                        for (( k=i+1; k<j; k++ )); do

                                [[ -z ${modules_force[k]} ]] && continue

                                [[ $( ${modules_force[i]}_provides ) \

                                        == $( ${modules_force[i]}_provides ) ]] \

                                        && unset modules_force[k]

                        done

                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

        fi

        # Setup class wrappers: interface_up -> iproute2_up, for example

        j="${#MODULES[@]}"

        for (( i=0; i<j; i++ )); do

                function_wrap "${MODULES[i]}" "${PROVIDES[i]}"

                # Now load our dependencies - we need to use the MODULE variable

                # here as the after/before/need functions use it

                if [[ -z ${modules_force[@]} ]]; then

                        MODULE="${MODULES[i]}"

                        ${MODULE}_depend

                fi

        done

        # Some modules may be installed, but not selected by user preference

        # so we wrap these if needed

        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

        local ifvar=$( bash_variable "$1" ) i j

        # Try and work out a metric for the interface if we're on auto

        eval x=\"\$\{metric_${ifvar}\}\"

        if [[ -z ${x} ]]; then

                if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then

                        eval "metric_${ifvar}=\""$( calculate_metric ${iface} )"\""

                else

                        eval "metric_${ifvar}=0"

                fi

        fi

        # 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

        # We now expand the configuration parameters and pray that the

        # fallbacks expand to the same number as config or there will be

        # trouble!

        eval a=( \"\$\{config_${ifvar}\[@\]\}\" )

        for (( i=0; i<${#a[@]}; i++ )); do

                local -a b=( $( expand_parameters "${a[i]}" ) )

                config=( "${config[@]}" "${b[@]}" )

        done

        eval a=( \"\$\{fallback_${ifvar}\[@\]\}\" )

        for (( i=0; i<${#a[@]}; i++ )); do

                local -a b=( $( expand_parameters "${a[i]}" ) )

                fallback=( "${fallback[@]}" "${b[@]}" )

        done

        # We don't expand routes

        eval fallback_route=( \"\$\{fallback_route_${ifvar}\[@\]\}\" )

        # 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 depreciated 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

#               if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then

                        if [[ $( type -t "dhcp_start" ) == "function" ]]; then

                                config=( "dhcp" )

                                ewarn "Configuration not set for ${iface} - assuming dhcp"

                        else

                                eerror "Cannot default to dhcp as there is no dhcp module loaded"

                                eerror "No configuration for ${iface}"

                                return 1

                        fi

#               else

#                       config=( "null" )

#                       ewarn "Configuration not set for ${iface} - assuming null"

#               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 [[ $( type -t "${conf[0]}_start" ) == "function" ]]; 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 [[ ${RC_AUTO_INTERFACE} == "yes" \

                                && $(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 [[ $( type -t "${mod}_post_start" ) == "function" ]]; then

                        ${mod}_post_start "${iface}" || return 1

                fi

        done

        return 0

}

# bool iface_stop(char *interface)

#

# iface_stop: bring down an interface.  Don't trust information in

# /etc/conf.d/net since the configuration might have changed since

# iface_start ran.  Instead query for current configuration and bring

# down the interface.

iface_stop() {

        local iface="$1" i aliases need_begin=false mod

        local RC_INDENTATION="${RC_INDENTATION}"

        # pre Stop any modules

        for mod in ${MODULES[@]}; do

                [[ $( 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

                if ! interface_exists "${iface}" ; then

                        eend 0

                        continue

                fi

                # Delete all the addresses for this alias

                interface_del_addresses "${i}"

                # Do final shut down of this alias

                if ! ${IN_BACKGROUND}; 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

                [[ $( 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=$( 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[@]}" )

        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  :Sad: 

        # 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

                einfo "Running preup function"

                eindent

                ( preup "${iface}" )

                eend "$?" "preup ${iface} failed" || return 1

                eoutdent

        fi

        # If config is set to noop and the interface is up with an address

        # then we don't start it

        local config

        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=$( 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

                einfo "Running predown function"

                eindent

                ( predown "${iface}" )

                eend $? "predown ${iface} failed" || return 1

                eoutdent

        elif is_net_fs /; then

                eerror "root filesystem is network mounted -- can't stop ${iface}"

                return 1

        fi

        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}"

        local starting=true

        local -a MODULES mods

        local IN_BACKGROUND="${IN_BACKGROUND}"

        # No point in backgrounding if we're already there ...

        # This is also required so we can select the "best" interface

        if [[ ${IN_BACKGROUND} == "true" || ${IN_BACKGROUND} == "1" ]]; then

                IN_BACKGROUND=true

                background=false

        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

        [[ ${iface} == "lo" ]] && modules_force=( "iproute2" "ifconfig" )

        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

                        remove_state "${iface}"

                else

                        run_start "${iface}" && r=0

                fi

        fi

        # Only apply best state if we're on auto

        if [[ ${r} == "0" ]]; then

                local siface=""

                if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then

                        siface=$( select_best_interface )

                        if [[ -n ${siface} ]]; then

                                einfo "Selecting best interface: ${siface}"

                        fi

                elif [[ ${cmd} == "start" ]]; then

                        siface="${iface}"

                fi

                [[ -n ${siface} ]] && apply_state "${siface}"

        else

                if [[ ${cmd} == "start" ]]; then

                        # Call user-defined failup if it exists

                        if [[ $( type -t failup ) == "function" ]]; then

                                einfo "Running failup function"

                                eindent

                                ( failup "${iface}" )

                                eoutdent

                        fi

                else

                        # Call user-defined faildown if it exists

                        if [[ $( type -t faildown ) == "function" ]]; then

                                einfo "Running faildown function"

                                eindent

                                ( faildown "${iface}" )

                                eoutdent

                        fi

                fi

        fi

        return "${r}"

}

# void link_file(char *file)

#

# Move a config file from /etc to ${netdir} and creates a link if needed.

# This enables net-scripts to control the config file for interface management

# and allow /etc to become read only.

link_file() {

        local file="$1"

        local link=$( readlink "/etc/${file}" 2>/dev/null )

        if [[ ${link} != "${netdir}/${file}" ]]; then

                if [[ -f "/etc/${file}" ]]; then

                        vewarn "Moving /etc/${file} to ${netdir}/${file} and creating link"

                        mv "/etc/${file}" "${netdir}"

                        ln -snf "${netdir}/${file}" "/etc/${file}"

                fi

        fi

}

# bool start(void)

#

# Start entry point so that we only have one function

# which localises variables and unsets functions

start() {

        if [[ ${IN_HOTPLUG} == "1" ]]; then

                # If we've been called by hotplug, check if we have

                # a policy for the interface for not starting

                local x ifvar=$( bash_variable "${IFACE}" )

                eval x=\"\$\{hotplug_${ifvar}\}\"

                if [[ ${x} == "no" || ${x} == "false" ]]; then

                        eerror "Not starting interface ${IFACE} due to hotplug policy"

                        unset -f exit

                        mark_service_stopped "net.${IFACE}"

                        exit 1

                fi

        fi

        if [[ ! -d "${statedir}/${IFACE}" ]]; then

                if ! mkdir -m 0755 -p "${statedir}/${IFACE}" ; then

                        eerror "Unable to create state directory!"

                        return 1

                fi

        fi

        if [[ ${RC_AUTO_INTERFACE} == "yes" ]]; then

                link_file "resolv.conf"

                link_file "ntp.conf"

                link_file "yp.conf"

        fi

        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() {

        einfo "Stopping ${IFACE}"

        run "${IFACE}" stop

}

# vim:ts=4

----------

## jamapii

There might be something in

/etc/conf.d/net.eth0

/etc/conf.d/net

To prevent gentoo's initscripts from trying wireless stuff, put 

```
modules=( "!wireless" )
```

 in /etc/conf.d/net.eth0 . If this results in an error message about nonexistant module "wireless", put 

```
modules=( "!iwconfig" "!wpa_supplicant" )
```

 there. 

Remove anything from /etc/conf.d/net that is remaining from the "ra0" test.

Make sure /etc/init.d/net.eth0 is a link to net.lo, and net.ra0 doesn't exist.

----------

## badgers

thanks to everyone.

It is now working

I did not have a file called /etc/conf.d/net.eth0 

there was a net.wireless and that is what started things looking for the wireless card.

I deleted that and copied net.example over to net.eth0

then I found out that my dhcpcd 1.3 version was too old and the new scripts wanted a newer version.

I have a big question now that I went though that file.

How Can I set a static IP address but have the system get all the other data from dhcpcd?

I have a mythtv box that I would like to set up a static address for, but it needs to get gateway and dns info from the dhcp server

thanks a million

----------

## jamapii

That's part of the configuration in the dhcp server, for example, if you use dchpd:

```
host slimp31 {

    hardware ethernet 00:04:20:04:02:52;

    fixed-address 192.168.20.70;

}

```

You can also set a static address in the client, in /etc/conf.d/net:

```
config_eth0=( "192.168.20.70/24" )

routes_eth0=( "default via 192.168.20.1" )
```

----------

