# Need to re-emerge net.eth0 [solved]

## a2gentoo

I had an unfortunate incident with my laptop and a cup of coffee. That made me pull the power without warning.

I trashed my /etc/init.d/net.lo file.

How do I get a new one?

Chip

p.s. The laptop is ok  :Very Happy: 

----------

## gentoo_dude

Copy and paste the following script.  

```

#!/sbin/runscript

# Copyright (c) 2004-2005 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

# $Header$

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

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

# for help, ideas and patches

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

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

   set -x

   devnull=/dev/stderr

else

   devnull=/dev/null

fi

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

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

depend() {

   use coldplug hotplug pcmcia usb isdn4linux wlan

   # Load any custom depend functions for the given interface

   # For example, br0 may need eth0 and eth1

   local iface=${myservice##*.}

   [[ $( type -t depend_${iface} ) == "function" ]] && depend_${iface}

}

# Define where our modules are

MODULES_DIR=/lib/rcscripts/net.modules.d

# Load some functions shared between ourselves and our dhcp helpers

source ${MODULES_DIR}/helpers.d/functions

# Make some wrappers to fudge after/before/need/use depend flags.

# These are callbacks so mods[i] will be set.

after() {

   local x="$*"

   [[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )

   eval "${MODULE}_after() { echo \"$x\"; }"

}

before() {

   local x="$*"

   [[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )

   eval "${MODULE}_before() { echo \"$x\"; }"

}

need() {

   local x="$*"

   [[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )

   eval "${MODULE}_need() { echo \"$x\"; }"

}

installed() {

   local x="$*"

   [[ $# -gt 1 ]] && x=$( echo -e "${x// /\n}" | sort | xargs )

   # We deliberately misspell this as _installed will probably be used

   # at some point

   eval "${MODULE}_instlled() { echo \"$x\"; }"

}

sort() {

   LC_ALL=C /bin/sort "$@"

}

# void module_class_wrap(char *module, char *provides)

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

module_class_wrap() {

   local module=${1} provides=${2} x 

   # Don't wrap functions if another module already has

   [[ $( type -t ${provides}_provides ) == function ]] && return

   for x in $( typeset -f | grep -o ^${module}_'[^ ]*' ); do

      eval "${provides}${x#${module}}() { ${x} \"\$@\"; }"

   done

}

# bool module_load_minimum(char *module)

#

# Does the minimum checking on a module - even when forcing

module_load_minimum() {

   local f=${1} MODULE=${1##*/}

   if [[ ! -f ${f} ]]; then

      eerror "${f} does not exist"

      return 1

   fi

   if ! source ${f} ; then

      eerror "${MODULE} failed a sanity check"

      return 1

   fi

   for f in check_installed provides check_depends depend; do

      [[ $( type -t ${MODULE}_${f} ) == function ]] && continue

      eerror "${MODULE} does not support the required function ${f}"

      return 1

   done

   # Wrap our before/after/need/use functions

   ${MODULE}_depend

   return 0

}

# bool modules_load_auto()

#

# Load and check each module for sanity

# If the module is not installed, the functions are to be removed

modules_load_auto() {

   local e f i j beforefuncs afterfuncs diffs unload

   # Populate the MODULES array

   MODULES=( $( find ${MODULES_DIR}/ -maxdepth 1 -type f ! -name ".*" | sort ) )

   # Each of these sources into the global namespace, so it's

   # important that module functions and variables are prefixed with

   # the module name, for example iproute2_

   beforefuncs="$( typeset -F )"

   j=${#MODULES[@]}

   loaded_interface=false

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

      unload=false

      module_load_minimum ${MODULES[i]} || unload=true

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

      ! ${unload} && ${MODULES[i]}_check_installed false || unload=true

      if [[ ${MODULES[i]} == interface ]]; then

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

         return 1

      fi

      afterfuncs="$( typeset -F )"

      if ${unload} ; then

         unset MODULES[i]

         unsetfuncs="${unsetfuncs} $( diff -U0 <( echo "${beforefuncs}" ) <( echo "${afterfuncs}" ) 2>/dev/null \

            | awk 'BEGIN { ORS = " "; } /+declare -f/ { print $3; }' )"

      fi

      beforefuncs="${afterfuncs}"

   done

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

   return 0

}

# bool modules_check_installed(void)

#

# Ensure that all modules have the required modules loaded

# This enables us to remove modules from the MODULES array

# Whilst other modules can still explicitly call them

# One example of this is essidnet which configures network

# settings for the specific ESSID connected to as the user

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

# iwconfig module

modules_check_installed() {

   local i j missingdeps nmods=${#MODULES[@]}

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

      [[ $( type -t ${MODULES[i]}_instlled ) != function ]] && continue

      for j in $( ${MODULES[i]}_instlled ); do

         missingdeps=true

         if [[ $( type -t ${j}_check_installed ) == function ]]; then

            ${j}_check_installed && missingdeps=false

         fi

         ${missingdeps} && unset MODULES[i] && unset PROVIDES[i] && break

      done

   done

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

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

}

# bool modules_check_user(void)

modules_check_user() {

   local -a umods

   local i j k l npref nmods=${#MODULES[@]}

   # Has the interface got any specific modules?

   eval umods=( \"\$\{modules_${iface}\[@\]\}\" )

   # Global setting follows interface-specific setting

   umods=( "${umods[@]}" "${modules[@]}" )

   # Add our preferred modules

   npref=3

   umods=( "${umods[@]}" "ifconfig" "dhcpcd" "iwconfig" )

   # First we strip any modules that conflict from user settings

   # So if the user specifies pump then we don't use dhcpcd

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

      # Some users will inevitably put "dhcp" in their modules

      # list.  To keep users from screwing up their system this

      # way, ignore this setting so that the default dhcp

      # module will be used.

      [[ ${umods[i]} == dhcp ]] && continue

      # We remove any modules we explicitly don't want

      if [[ ${umods[i]} == !* ]]; then

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

            [[ -z ${MODULES[j]} ]] && continue

            if [[ ${umods[i]:1} == ${MODULES[j]} || ${umods[i]:1} == ${PROVIDES[j]} ]]; then

               # We may need to setup a class wrapper for it even though

               # we don't use it directly

               ${MODULES[j]}_check_installed && module_class_wrap ${MODULES[j]}

               unset MODULES[j]

               unset PROVIDES[j]

               break

            fi

         done

         continue

      fi

      if [[ $( type -t ${umods[i]}_provides ) != function ]]; then

         # If the module is one of our preferred modules, then

         # ignore this error; whatever is available will be

         # used instead.

         (( i < ${#umods[@]} - npref )) || continue

         eerror "${umods[i]} is not a valid module (missing provides)"

         return 1

      fi

      # Ensure that the user specified module has its package installed

      if (( i < ${#umods[@]} - npref )); then

         # $1==true causes check_installed to report its own errors

         ${umods[i]}_check_installed true || return 1

      else

         # If this happens on a preferred modules, ignore it;

         # whatever is available will be used instead.

         ${umods[i]}_check_installed false || continue

      fi

      mod=$( ${umods[i]}_provides )

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

         [[ -z ${MODULES[j]} ]] && continue

         if [[ ${PROVIDES[j]} == ${mod} && ${umods[i]} != ${MODULES[j]} ]]; then

            # We don't have a match - now ensure that we still provide an alternative.

            # This is to handle our preferred modules.

            for (( l=0; l<nmods; l++ )); do

               [[ ${l} -eq ${j} || -z ${MODULES[l]} ]] && continue

               if [[ ${PROVIDES[l]} == ${mod} ]]; then

                  unset MODULES[j]

                  unset PROVIDES[j]

                  break

               fi

            done

         fi

      done

   done

   # Then we strip conflicting modules.

   # We only need to do this for 3rd party modules that conflict with

   # our own modules and the preferred list AND the user modules

   # list doesn't specify a preference.

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

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

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

         [[ -z ${MODULES[j]} ]] && continue

         [[ ${PROVIDES[i]} == ${PROVIDES[j]} ]] && unset MODULES[j] && unset PROVIDES[j]

      done

   done

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

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

   return 0

}

# void modules_sort(void)

modules_sort() {

   local -a modnums sort_history modafter modbefore

   local i j k p changed_something nmods=${#MODULES[@]}

   # Sort our modules

   # We do this by assigning numbers to each module

   # We also assign modbefore and modafter so we don't

   # shell out as much because it's expensive on CPU.

   modnums=()

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

      modnums[i]=${i}

      [[ $( type -t ${MODULES[i]}_after ) == function ]] && modafter[i]=$( ${MODULES[i]}_after )

      [[ $( type -t ${MODULES[i]}_before ) == function ]] && modbefore[i]=$( ${MODULES[i]}_before )

   done

   

   # Then we swap numbers based on and after/before flags

   # until we don't swap anymore. The sort_history array prevents

   # the possibility of an infinite loop

   sort_history[0]="${modnums[*]}"

   for (( k=1; 1; k++ )); do

      changed_something=false

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

         for p in ${modafter[i]}; do

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

               [[ ${p} != ${MODULES[j]} && ${p} != ${PROVIDES[j]} ]] && continue

               if [[ ${modnums[i]} -lt ${modnums[j]} ]]; then

                  tmp=${modnums[i]}

                  modnums[i]=${modnums[j]}

                  modnums[j]=${tmp}

                  changed_something=true

               fi

            done

         done

         for p in ${modbefore[i]}; do

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

               [[ ${p} != ${MODULES[j]} && ${p} != ${PROVIDES[j]} ]] && continue

               if [[ ${modnums[i]} -gt ${modnums[j]} ]]; then

                  tmp=${modnums[i]}

                  modnums[i]=${modnums[j]}

                  modnums[j]=${tmp}

                  changed_something=true

               fi

            done

         done

      done

      ${changed_something} || break

      # Make sure we aren't repeating a previous state

      # First time through, k=1, k/2=0

      sort_history[k]="${modnums[*]}"

      if [[ ${sort_history[k]} == ${sort_history[k/2]} ]]; then

         eerror "Detected an infinite loop sorting modules; blundering ahead"

         break

      fi

   done

   # Finally we sort our modules in number order

   um=""

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

      um="${um}${modnums[i]} ${MODULES[i]} ${PROVIDES[i]}\n"

   done

   p=( $( echo -e "${um}" | sort -n | awk '{print $2,$3}' ) )

   MODULES=()

   PROVIDES=()

   j=0

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

      MODULES[j]=${p[i]}

      PROVIDES[j]=${p[i+1]}

      (( j++ ))

   done

}

# bool modules_check_depends(bool showprovides)

modules_check_depends() {

   local showprovides=${1:-false} nmods=${#MODULES[@]} i j needmod

   local missingdeps p  interface=false

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

      if [[ $( type -t ${MODULES[i]}_need ) == function ]]; then

         for needmod in $( ${MODULES[i]}_need ); do

            missingdeps=true

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

               if [[ ${needmod} == ${MODULES[j]} || ${needmod} == ${PROVIDES[j]} ]]; then

                  missingdeps=false

                  break

               fi

            done

            if ${missingdeps} ; then

               eerror "${MODULES[i]} needs ${needmod} (dependency failure)"

               return 1

            fi

         done

      fi

      ${MODULES[i]}_check_depends || return 1

      [[ ${PROVIDES[i]} == interface ]] && interface=true

      if ${showprovides} ; then

         [[ ${PROVIDES[i]} != ${MODULES[i]} ]] && veinfo "${MODULES[i]} provides ${PROVIDES[i]}"

      fi

   done

   if ! ${interface} ; then

      eerror "no interface module has been loaded"

      return 1

   fi

   return 0

}

# bool modules_load(char *iface, bool starting)

#

# Loads the defined handler and modules for the interface

# Returns 0 on success, otherwise 1

modules_load()  {

   local iface=${1} starting=${2:-true} mod p=false i j unsetfuncs

   local -a x

   local RC_INDENTATION=${RC_INDENTATION}   # so it will reset after function

   local -a PROVIDES

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

      # We force lo to only use these modules for a major speed boost

      modules_force=( "iproute2" "ifconfig" )

   else

      eval x=( \"\$\{modules_force_${iface}\[@\]\}\" )

      [[ -n ${x} ]] && modules_force=( "${x[@]}" )

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

         ewarn "WARNING: You are forcing modules!"

         ewarn "Do not complain or file bugs if things start breaking"

         report=true

      fi

      veinfo "Loading networking modules for ${iface}"

   fi

   eindent

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

      modules_load_auto || return 1

   else

      j=${#modules_force[@]}

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

         module_load_minimum "${MODULES_DIR}/${modules_force[i]}" || return 1

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

      done

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

   fi

   # We now buffer the _provides functions for a big speed boost

   j=${#MODULES[@]}

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

      PROVIDES[i]=$( ${MODULES[i]}_provides )

   done

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

      if ${starting}; then

         modules_check_user || return 1

      fi

      # We unset unloaded module functions here as so we can error

      # with a message informing the user to emerge the correct

      # package if it's in their modules

      [[ -n ${unsetfuncs} ]] && unset ${unsetfuncs}

      modules_sort

   fi

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

   j=${#MODULES[@]}

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

      module_class_wrap ${MODULES[i]} ${PROVIDES[i]}

   done

   modules_check_installed || return 1

   [[ ${iface} != lo ]] && veinfo "modules: ${MODULES[@]}"

   eindent

   [[ ${iface} != lo && ${starting} == true ]] && p=true

   modules_check_depends ${p} || return 1

   return 0

}

# bool iface_start(char *interface)

#

# iface_start is called from start.  It's expected to start the base

# interface (for example "eth0"), aliases (for example "eth0:1") and to start

# VLAN interfaces (for example eth0.0, eth0.1).  VLAN setup is accomplished by

# calling itself recursively.

iface_start() {

   local iface=${1} mod config_counter=-1 x warn=false config_worked=false

   local RC_INDENTATION=${RC_INDENTATION}   # so it will reset after function

   local -a config fallback fallback_route conf

   local ifvar=$( interface_variable ${iface} )

   # pre Start any modules with

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

      if [[ $( type -t ${mod}_pre_start ) == function ]]; then

         ${mod}_pre_start ${iface} || { eend 1; return 1; }

      fi

   done

   # New style config - one variable fits all

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

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

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

   # We must support old configs

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

      interface_get_old_config ${iface} || return 1

   fi

   # Handle "noop" correctly

   if [[ ${config[0]} == "noop" ]]; then

      if interface_is_up ${iface} true ; then

         einfo "Keeping current configuration for ${iface}"

         eend 0

         return 0

      fi

      # Remove noop from the config var

      config=( "${config[@]:1}" )

   fi

   # Provide a default of DHCP if no configuration is set

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

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

         config=( "dhcp" )

         warn=true

      else

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

         eerror "No configuration for ${iface}"

         return 1

      fi

   fi

   einfo "Bringing up ${iface}"

   eindent

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

      # Handle null and noop correctly

      if [[ ${config[config_counter]} == "null" \

      || ${config[config_counter]} == "noop" ]]; then

         eend 0

         config_worked=true

         continue

      fi

      if ${warn}; then

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

         warn=false

      fi

      # We convert it to an array - this has the added

      # bonus of trimming spaces!

      conf=( ${config[config_counter]} )

      einfo "${conf[0]}"

      # Do we have a function for our config?

      if [[ $( type -t ${conf[0]}_start ) == function ]]; then

         # Check that the module is valid

         x=false

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

            if [[ $( ${mod}_provides ) == ${conf[0]} ]]; then

               x=true

               break

            fi

         done

         if ! ${x}; then

            [[ $( type -t ${conf[0]}_check_installed == function ) ]] && ${conf[0]}_check_installed true

            eerror "No loaded modules provide \"${conf[0]}\" (${conf[0]}_start)"

         else

            eindent

            ${conf[0]}_start ${iface} ; x=$?

            eoutdent

            [[ ${x} == 0 ]] && config_worked=true && continue

         fi

      # We need to test to see if it's an IP address or a function

      # We do this by testing if the 1st character is a digit

      elif [[ ${conf[0]:0:1} == [[:digit:]] || ${conf[0]} == *:* ]]; then

         x=0

#         if [[ $(type -t address_exists ) == function ]]; then

#            if address_exists ${iface} ${conf[0]} ; then

#               eerror "${conf[0]%%/*} already taken on ${iface}"

#               x=1

#            fi

#         fi

         [[ ${x} == 0 ]] && interface_add_address ${iface} ${conf[@]} ; x=$?

         eend ${x} && config_worked=true && continue

      else

         eerror "No loaded modules provide \"${conf[0]}\" (${conf[0]}_start)"

      fi

      if [[ -n ${fallback[config_counter]} ]]; then

         einfo "Trying fallback configuration"

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

         fallback[config_counter]=''

         # Do we have a fallback route?

         if [[ -n ${fallback_route[config_counter]} ]]; then

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

            fallback_route[config_counter]=''

         fi

         (( config_counter-- )) # since the loop will increment it

         continue

      fi

   done

   eoutdent

   # We return failure if no configuration parameters worked

   ${config_worked} || return 1

   # Start any modules with _post_start

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

      if [[ function == $( type -t ${mod}_post_start ) ]]; then

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

      fi

   done

   return 0

}

# bool iface_stop(char *interface)

#

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

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

# iface_start ran.  Instead query for current configuration and bring

# down the interface.

#

# However, we are currently reliant on handler and modules specified

# in /etc/conf.d/net

iface_stop() {

   local iface=${1} i aliases need_begin=false mod

   local RC_INDENTATION=${RC_INDENTATION}   # so it will reset after function

   # pre Stop any modules

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

      [[ $( type -t ${mod}_pre_stop ) == function ]] && ${mod}_pre_stop ${iface}

   done

   einfo "Bringing down ${iface}"

   eindent

   # Collect list of aliases for this interface.

   # List will be in reverse order.

   aliases=$( interface_get_aliases_rev ${iface} )

   # Stop aliases before primary interface.

   # Note this must be done in reverse order, since ifconfig eth0:1 

   # will remove eth0:2, etc.  It might be sufficient to simply remove 

   # the base interface but we're being safe here.

   for i in ${aliases} ${iface}; do

      # Stop all our modules

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

         [[ $( type -t ${mod}_stop ) == function ]] && ${mod}_stop ${i}

      done

      # A module may have removed the interface

      interface_exists ${iface} || { eend 0; continue; }

      # Delete all the addresses for this alias

      interface_del_addresses ${i}

      # Do final shut down of this alias

      ebegin "Shutting down ${i}"

      interface_iface_stop ${i}

      eend $?

   done

   # post Stop any modules

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

      # We have already taken down the interface, so no need to error

      [[ $( type -t ${mod}_post_stop ) == function ]] && ${mod}_post_stop ${iface}

   done

   return 0

}

# bool run_start(char *iface)

#

# Brings up ${IFACE}.  Calls preup, iface_start, then postup.

# Returns 0 (success) unless preup or iface_start returns 1 (failure).

# Ignores the return value from postup.

# We cannot check that the device exists ourselves as modules like

# tuntap make create it.

run_start() {

   local iface=${1} ifvar x

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

      ebegin "Bringing up ${iface}"

      interface_loopback_create

      eend $?

      return $?

   fi

   # We may not have a loaded module for ${iface}

   # Some users may have "alias natsemi eth0" in /etc/modules.d/foo

   # so we can work with this

   # However, if they do the same with eth1 and try to start it

   # but eth0 has not been loaded then the module gets loaded as

   # eth0.

   # Not much we can do about this :(

   # Also, we cannot error here as some modules - such as bridge

   # create interfaces

   if ! interface_exists ${iface} ; then

      /sbin/modprobe ${iface} &>/dev/null

   fi

   # Setup variables for pre/post to use

   ifvar=$( interface_variable ${iface} )

   local IFACE=${iface} IFVAR=${ifvar}

   # Call user-defined preup function if it exists

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

      einfo "Running preup function"

      eindent

      preup ${iface} ; x=$?

      eoutdent

      if [[ ${x} != 0 ]]; then

         eerror "preup ${iface} failed"

         return 1

      fi

   fi

   # Don't let preup modify us

   iface=${1}

   local IFACE=${iface} IFVAR=${ifvar} config

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

   # then we don't start it

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

   if [[ ${config[0]} == "noop" ]] && interface_is_up ${iface} true ; then

      einfo "Keeping current configuration for ${iface}"

      eend 0

   else

      # Remove noop from the config var

      [[ ${config[0]} == "noop" ]] && eval "config_${ifvar}=( "\"\$\{config\[@\]:1\}\"" )"

      # There may be existing ip address info - so we strip it

      interface_del_addresses ${iface}

      # Start the interface

      if ! iface_start ${iface} ; then

         interface_exists ${iface} && interface_down ${iface}

         eend 1

         return 1

      fi

   fi

   # Call user-defined postup function if it exists

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

      einfo "Running postup function"

      eindent

      postup ${iface}

      eoutdent

   fi

   return 0

}

# bool run_stop(char *iface) {

#

# Brings down ${iface}.  If predown call returns non-zero, then

# stop returns non-zero to indicate failure bringing down device.

# In all other cases stop returns 0 to indicate success.

run_stop() {

   local iface=${1} ifvar x

   # Don't run any special shutdown functions for lo

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

      ebegin "Shutting down ${iface}"

      interface_iface_stop ${iface}

      eend $?

      return 0

   fi

   # Setup variables for pre/post to use

   ifvar=$( interface_variable ${iface} )

   local IFACE=${iface} IFVAR=${ifvar}

   # Call user-defined predown function if it exists

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

      einfo "Running predown function"

      eindent

      predown ${iface} ; x=$?

      eoutdent

      if [[ ${x} != 0 ]]; then

         eend 1 "predown ${iface} failed"

         return 1

      fi

   elif is_net_fs /; then

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

      return 1

   fi

   # Don't let predown modify us

   iface=${1}

   local IFACE=${iface} IFVAR=${ifvar}

   iface_stop ${iface} || return 1  # always succeeds, btw

   # Call user-defined postdown function if it exists

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

      einfo "Running postdown function"

      eindent

      postdown ${iface}

      eoutdent

   fi

   return 0

}

# bool run(char *iface, char *cmd)

#

# Main start/stop entry point

# We load modules here and remove any functions that they

# added as we may be called inside the same shell scope for another interface

run() {

   local iface=${1} cmd=${2} r=1 RC_INDENTATION=${RC_INDENTATION}   # so it will reset after function

   local before starting=true

   local -a MODULES mods

   # We need to override the exit function as runscript.sh now checks

   # for it. We need it so we can mark the service as inactive ourselves.

   unset -f exit

   eindent

   unset_functions=${unset_functions:-false}

   ${unset_functions} && before="$( typeset -F )"

   [[ ${cmd} == "stop" ]] && starting=false

   if modules_load ${iface} ${starting} ; then

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

         # Reverse the module list for stopping

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

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

            MODULES[i]=${mods[((${#mods[@]} - i - 1))]}

         done

         run_stop ${iface} && r=0

      else

         run_start ${iface} && r=0

      fi

   fi

   # We need to remove added functions before we quit as other init

   # scripts may be launching afterwards

   ${unset_functions} && \

   unset $( diff -U0 <( echo "${before}" ) <( echo "$( typeset -F )" ) 2>/dev/null \

      | awk 'BEGIN { ORS = " "; } /+declare -f/ { print $3; }' ) 2>/dev/null

   return ${r}

}

# bool start(void)

#

# Start entry point so that we only have one function

# which localises variables and unsets functions

start() {

   einfo "Starting ${IFACE}"

   run ${IFACE} start

   return $?

}

# bool stop(void)

#

# Stop entry point so that we only have one function

# which localises variables and unsets functions

stop() {

   einfo "Stopping ${IFACE}"

   run ${IFACE} stop

   return $?

}

# bool restart(void)

#

# Restart entry point

# We do this so as we only have to remove functions when stopping

restart() {

   local unset_functions=true

   service_started "${myservice}" && svc_stop

   unset_functions=false

   svc_start

   return $?

}

# vim:ts=4

```

----------

## PaulBredbury

emerge baselayout, when you're able, to ensure that you have the correct version of the net.lo script.

----------

## a2gentoo

I went and did an emerge -e system

Didnt fix the problem

Maybe this error has something

 *Quote:*   

> /lib/rcscripts/sh/rc-daemon.sh: line 328: syntax error near unexpected token `('
> 
> /lib/rcscripts/sh/rc-daemon.sh: line 328: `     local -a RC_DAEMONS=() RC_PIDFILES=()'
> 
> /etc/init.d/net.eth1: line 286: syntax error near unexpected token `('
> ...

 

Any Ideas

----------

## PaulBredbury

See bash 3.1 thread.

----------

## a2gentoo

That fixed it.

I thought it was me.

Thanks

----------

