# After etc-update, networking doesn't work (SOLVED!)

## Evangelion

I recently went throught the etc-update-process together with system update. And now, my networking doesn't work anymore. I was prepared for the networking to not work after the update, but I can't get it up & running smoothly anymore, no matter what I try. More detaield description follows:

When I reboot the machine, I have no functional network. Running ifconfig shows only lo. If I run ifconfig eth0, it displays eth0, but it has no IP-address or the like. If I add the relevant settings with ifconfig and route, it works again. But after reboot, it's not working anymore. rc-update -s shows that net.eth0 is in default runlevel. looking at /etc/conf.d/net shows this:

```
ifconfig_eth0=(

                       "192.168.1.2 broadcast 192.168.1.255 netmask 255.255.255.0")
```

and

```
routes_eth0=(

                       "default gw 192.168.1.1"
```

Now, the strange thing I noticed is that /etc/init.d/net.eth0 is a symlink that points to /etc/init.d/net.lo  :Confused:  and net.lo brings up 127.0.0.1. What's the big idea here?

----------

## TheRAt

Here is my /etc/init.d dir contents.. the net.eth0 linked to net.lo is correct behaviour...

```
rat@io ~ $ root

root@io ~ # cd /etc/

root@io /etc # cd init.d/

root@io /etc/init.d # ls -l net*

-rwxr-xr-x  1 root root   742 Sep  5  2003 net-snmpd

lrwxrwxrwx  1 root root     6 Feb  8 17:41 net.eth0 -> net.lo

-rwxr-xr-x  1 root root 24259 Feb  8 17:41 net.lo

-rwxr-xr-x  1 root root  4655 Jul 13  2003 net.ppp0

-rwxr-xr-x  1 root root  2873 Feb  8 17:41 netmount

root@io /etc/init.d #
```

What happens if you just try to restart eth0 with:

```
# /etc/init.d/net.eth0 restart
```

Are there any error messages in the log files when you try this?

----------

## Evangelion

 *TheRAt wrote:*   

> What happens if you just try to restart eth0 with:
> 
> ```
> # /etc/init.d/net.eth0 restart
> ```
> ...

 

IIRC, eth0 goes down, and I have re-configure it. I can't really test in right now, since I'm at work, and I'm looking at the machine through ssh. If the network goes down, I can't troubleshoot it until 6 hours later.

----------

## Evangelion

I just tried restarting eth0. And it was like I remember: the network is down and there's no way to reach the machine for now. For some reason the system does not keep the settings.

----------

## Evangelion

I just checked my logs, and they show just this:

```
Mar  1 17:44:06 gothmog sshd[12489]: Received signal 15; terminating.

Mar  1 17:44:09 gothmog sshd[13296]: Server listening on :: port 22.

Mar  1 17:44:09 gothmog sshd[13296]: error: Bind to port 22 on 0.0.0.0 failed: Address already in use.

Mar  1 17:45:13 gothmog r8169: eth0: link up

Mar  1 17:45:24 gothmog eth0: no IPv6 routers present
```

the last two lines are from when I re-enabled the network manually.

----------

## Evangelion

Any ideas to this problem? Of course I can get around it by re-configuring the network every time I reboot, but that gets tedious after a while.

----------

## TheRAt

Sorry to ask again, but are there no entries about eth prior to your setting on the eth device manually?

What about dmesg | grep eth??

----------

## Evangelion

 *TheRAt wrote:*   

> Sorry to ask again, but are there no entries about eth prior to your setting on the eth device manually?

 

eth0 is mentioned before. The system recognizes the device, loads the drivers and everything seems to work. It even says during bootup that it's brining eth0 up.

 *Quote:*   

> What about dmesg | grep eth??

 

```
janne@gothmog ~ $ dmesg |grep eth0

eth0: Identified chip type is 'RTL8169s/8110s'.

eth0: RTL8169 at 0xffffff000001a700, 00:0c:76:b4:2a:49, IRQ 16

r8169: eth0: link up

eth0: no IPv6 routers present
```

----------

## TheRAt

Can you try the following for your /etc/conf.d/net

```
config_eth0=( "192.168.1.2 netmask 255.255.255.0 broadcast 192.168.1.255" )

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

----------

## Evangelion

 *TheRAt wrote:*   

> Can you try the following for your /etc/conf.d/net
> 
> ```
> config_eth0=( "192.168.1.2 netmask 255.255.255.0 broadcast 192.168.1.255" )
> 
> ...

 

Nope, doesn't work  :Sad: . It does work again if I reconfigure it manually.

I asked this before, but... Why is /etc/init.d/net.eth0 a symlink to net.lo? It seems to me that it couldn't work since net.lo looks like this:

```
start() {

   ebegin "Bringing ${IFACE} up"

   /sbin/ifconfig lo 127.0.0.1 up 2>/dev/null

   /sbin/route add -net 127.0.0.0 netmask 255.0.0.0 \

      gw 127.0.0.1 dev lo 2> /dev/null

   eend 0
```

----------

## j-m

Slightly OT, but:

```

emerge -av app-text/rcs

mkdir /etc/config-archive

nano -w /etc/dispatch-conf.conf

```

Put this into there and never use etc-update again; dispatch-conf is much better. 

```

archive-dir=/etc/config-archive

use-rcs=yes

diff="diff -Nu %s %s"

pager="less --no-init --QUIT-AT-EOF"

replace-cvs=yes

replace-wscomments=yes

replace-unmodified=yes

```

If you mess something up, your CVS style backup is in /etc/dispatch-conf directory.

----------

## TheRAt

 *Evangelion wrote:*   

> Nope, doesn't work . It does work again if I reconfigure it manually.
> 
> I asked this before, but... Why is /etc/init.d/net.eth0 a symlink to net.lo? It seems to me that it couldn't work since net.lo looks like this:
> 
> ```
> ...

 

I think your net.lo file is incorrect...

Mine is attached:

```
#!/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.13 2005/01/25 10:42:54 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

}

# 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 "$@"

}

# bool net_start(char *iface)

#

# Starts a net.${iface} if required

# This is used by bridge and bond modules as the interfaces

# they need may have to be created

net_start() {

        local iface=${1}

        interface_exists ${iface} && return 0

        [[ -f ${svcdir}/started/net.${iface} ]] && return 0

        if [[ ! -x /etc/init.d/net.${iface} ]]; then

                eerror "/etc/init.d/net.${iface} does not exist"

                eerror "Cannot start ${iface}"

                return 1

        fi

        /etc/init.d/net.${iface} start

        return $?

}

# 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 config_fallback 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 config_fallback=( \"\$\{fallback_${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 ${config_fallback[config_counter]} ]]; then

                        einfo "Trying fallback configuration"

                        config[config_counter]=${config_fallback[config_counter]}

                        config_fallback[config_counter]=''

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

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

                        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

```

----------

## TheRAt

 *j-m wrote:*   

> Slightly OT, but:
> 
> ```
> 
> emerge -av app-text/rcs
> ...

 

Great idea...

Thanks !!

----------

## j-m

What version of baselayout do you have?  :Question: 

----------

## TheRAt

 *j-m wrote:*   

> What version of baselayout do you have? 

 

This is from sys-apps/baselayout-1.11.9-r1

----------

## j-m

 *TheRAt wrote:*   

>  *j-m wrote:*   What version of baselayout do you have?  
> 
> This is from sys-apps/baselayout-1.11.9-r1

 

Sure... but that question was aimed at Evangelion. Sorry.  :Smile: 

----------

## Evangelion

 *j-m wrote:*   

> What version of baselayout do you have? 

 

1.11.9-r1

----------

## Evangelion

 *TheRAt wrote:*   

> I think your net.lo file is incorrect...
> 
> Mine is attached:

 

interesting. It could be that one config-file was updated (/etc/conf.d/net), but the other (/etc/init.d/net.lo) was not. And the two do not work together properly. Your init.d-file has copyright extending to 2005, while mine extends to 2004. It seems that mine is of an older version.

EDIT: Yep. Yours is a version v 1.38.2.13 2005/01/25. Mine is v 1.10 2004/04/21

----------

## j-m

 *Evangelion wrote:*   

>  *j-m wrote:*   What version of baselayout do you have?  
> 
> 1.11.9-r1

 

OK, emerge baselayout again and run etc-update or dispatch-conf. This cannot work, as pointed above. You must let it update net.lo  :Exclamation:   :Wink: 

----------

## UberLord

https://bugs.gentoo.org/show_bug.cgi?id=74723

----------

## Evangelion

 *j-m wrote:*   

>  *Evangelion wrote:*    *j-m wrote:*   What version of baselayout do you have?  
> 
> 1.11.9-r1 
> 
> OK, emerge baselayout again and run etc-update or dispatch-conf. This cannot work, as pointed above. You must let it update net.lo  

 

I did just that, and it did not update net.lo. I will update it manually once I get back home.

----------

## j-m

 *Evangelion wrote:*   

> 
> 
> I did just that, and it did not update net.lo. I will update it manually once I get back home.

 

Hmm, sorry. The bug posted above did not hit me...  :Confused: 

----------

## Evangelion

 *j-m wrote:*   

>  *Evangelion wrote:*   
> 
> I did just that, and it did not update net.lo. I will update it manually once I get back home. 
> 
> Hmm, sorry. The bug posted above did not hit me... 

 

I just read the bugreport. I was able to update the net.lo (along with other files). I'll take a look at the new config, and restart networking. then we will see if it works or not  :Smile: 

EDIT: Yes! it seems to work! Thank you all for your help  :Smile: .

----------

