# Strang stuff in /etc/init.d/net.lo

## ONEEYEMAN

Hi, ALL,

In the file /etc/init.d/net.lo I have following code:

```

# bool start(void)

#

# Start entry point so that we only have one function

# which localises variables and unsets functions

start() {

           declare -r IFACE="${SVCNAME#*.}"

           einfo "Starting ${IFACE}"

           run "${IFACE}" start

}

```

I wonder what package the "declare" command belongs to?

Thank you.

----------

## Sadako

It's a shell builtin, check out the bash man page for details.

----------

## ONEEYEMAN

Hi, Hopeless,

Than what it's doing in the start-up script, where shell is not yet introduced?

Thank you.

----------

## Sadako

 *ONEEYEMAN wrote:*   

> Than what it's doing in the start-up script, where shell is not yet introduced?

 What gave you that impression?

The init scripts for all intents and purposes are shell scripts, they're just interpreted by /sbin/runscript directly rather than /bin/sh.

You can use pretty much any shell construct you like in the init scripts.

----------

## ONEEYEMAN

Hopeless,

Let me give some input.

During the boot, when the /etc/init.d/net.lo starts, I see the error message:

```

command not foundne: 5

command not foundne: 12

```

and the boot process continues.

Since this is the first function that executes, by elimination, I found that the offending line is the first one in this script.

Therefore my question.

Thank you.

----------

## Sadako

Could you post the script?

(I'm using baselayout2/openrc, which has different scripts).

btw, with baselayout 1, you need to ensure /bin/sh is a symlink to /bin/bash, not /bin/dash or similar, as the version 1 init scripts aren't strictly posix compatible, maybe that's your issue?

----------

## ONEEYEMAN

OK, I will try to do that.

I have a baselayout-1.12.11.1 compiled with "USE=unicode -bootstrap -build -static"

And ls -la /bin/sh gives:

```

lrwxrwxrwx 1 root root 4 SEP 23 08:14 [color=blue]/bin/sh[/color] -> [color=green]bash[/color]

```

Thank you.

----------

## ONEEYEMAN

Hi,

Here we go:

```

#!/sbin/runscript

# Copyright 2004-2007 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

   after bootmisc hostname

   use isapnp isdn pcmcia usb wlan

   # Load any custom depend functions for the given interface

   # For example, br0 may need eth0 and eth1

   local iface="${SVCNAME#*.}"

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

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

      after net.lo net.lo0

      # Support new style RC_NEED and RC_USE in one net file

      local x="RC_NEED_${iface}"

      [[ -n ${!x} ]] && need ${!x}

      x="RC_USE_${iface}"

      [[ -n ${!x} ]] && use ${!x}

      x="RC_AFTER_${iface}"

      [[ -n ${!x} ]] && after ${!x}

      x="RC_BEFORE_${iface}"

      [[ -n ${!x} ]] && before ${!x}

      x="RC_PROVIDE_${iface}"

      [[ -n ${!x} ]] && provide ${!x}

   fi

   return 0

}

# Define where our modules are

MODULES_DIR="${svclib}/net"

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

# These are callbacks so MODULE will be set.

after() {

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

}

before() {

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

}

need() {

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

}

installed() {

   # We deliberately misspell this as _installed will probably be used

   # at some point

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

}

provide() {

   eval "${MODULE}_provide() { echo \"$*\"; }"

}

functions() {

   eval "${MODULE}_functions() { echo \"$*\"; }"

}

variables() {

   eval "${MODULE}_variables() { echo \"$*\"; }"

}

is_loopback() {

   [[ $1 == "lo" || $1 == "lo0" ]]

}

# char* interface_device(char *iface)

#

# Gets the base device of the interface

# Can handle eth0:1 and eth0.1

# Which returns eth0 in this case

interface_device() {

   local dev="${1%%.*}"

   [[ ${dev} == "$1" ]] && dev="${1%%:*}"

   echo "${dev}"

}

# char* interface_type(char* iface)

#

# Returns the base type of the interface

# eth, ippp, etc

interface_type() {

   echo "${1%%[0-9]*}"

}

# int calculate_metric(char *interface, int base)

#

# Calculates the best metric for the interface

# We use this when we add routes so we can prefer interfaces over each other

calculate_metric() {

   local iface="$1" metric="$2"

   # Have we already got a metric?

   local m=$(awk '$1=="'${iface}'" && $2=="00000000" { print $7 }' \

      /proc/net/route)

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

      echo "${m}"

      return 0

   fi

   local i= dest= gw= flags= ref= u= m= mtu= metrics=

   while read i dest gw flags ref u m mtu ; do

      # Ignore lo

      is_loopback "${i}" && continue

      # We work out metrics from default routes only

      [[ ${dest} != "00000000" || ${gw} == "00000000" ]] && continue

      metrics="${metrics}\n${m}"

   done < /proc/net/route

   # Now, sort our metrics

   metrics=$(echo -e "${metrics}" | sort -n)

   # Now, find the lowest we can use

   local gotbase=false

   for m in ${metrics} ; do

      [[ ${m} -lt ${metric} ]] && continue

      [[ ${m} == ${metric} ]] && ((metric++))

      [[ ${m} -gt ${metric} ]] && break

   done

   

   echo "${metric}"

}

# int netmask2cidr(char *netmask)

#

# Returns the CIDR of a given netmask

netmask2cidr() {

   local binary= i= bin=

   for i in ${1//./ }; do

      bin=""

      while [[ ${i} != "0" ]] ; do

         bin=$[${i}%2]${bin}

         (( i=i>>1 ))

      done

      binary="${binary}${bin}"

   done

   binary="${binary%%0*}"

   echo "${#binary}"

}

# bool is_function(char* name)

#

# Returns 0 if the given name is a shell function, otherwise 1

is_function() {

   [[ -z $1 ]] && return 1

   [[ $(type -t "$1") == "function" ]]

}

# void function_wrap(char* source, char* target)

#

# wraps function calls - for example function_wrap(this, that)

# maps function names this_* to that_*

function_wrap() {

   local i=

   is_function "${2}_depend" && return

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

      eval "${2}${i#${1}}() { ${i} \"\$@\"; }"

   done

}

# char[] * expand_parameters(char *cmd)

#

# Returns an array after expanding parameters. For example

# "192.168.{1..3}.{1..3}/24 brd +"

# will return

# "192.168.1.1/24 brd +"

# "192.168.1.2/24 brd +"

# "192.168.1.3/24 brd +"

# "192.168.2.1/24 brd +"

# "192.168.2.2/24 brd +"

# "192.168.2.3/24 brd +"

# "192.168.3.1/24 brd +"

# "192.168.3.2/24 brd +"

# "192.168.3.3/24 brd +"

expand_parameters() {

   local x=$(eval echo ${@// /_})

   local -a a=( ${x} )

   a=( "${a[@]/#/\"}" )

   a=( "${a[@]/%/\"}" )

   echo "${a[*]//_/ }"

}

# void configure_variables(char *interface, char *option1, [char *option2])

#

# Maps configuration options from <variable>_<option> to <variable>_<iface>

# option2 takes precedence over option1

configure_variables() {

   local iface="$1" option1="$2" option2="$3"

   local mod= func= x= i=

   local -a ivars=() ovars1=() ovars2=()

   local ifvar=$(bash_variable "${iface}")

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

      is_function ${mod}_variables || continue

      for v in $(${mod}_variables) ; do

         x=

         [[ -n ${option2} ]] && x="${v}_${option2}[@]"

         [[ -z ${!x} ]] && x="${v}_${option1}[@]"

         [[ -n ${!x} ]] && eval "${v}_${ifvar}=( \"\${!x}\" )"

      done

   done

   return 0

}

# bool module_load_minimum(char *module)

#

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

module_load_minimum() {

   local f="$1.sh" 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 depend; do

      is_function "${MODULE}_${f}" && continue

      eerror "${MODULE}.sh 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 inst

   # Populate the MODULES array

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

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

   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

      MODULES[i]="${MODULES[i]%.sh*}"

      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;

      if [[ ${u} == 0 ]] ; then

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

         if is_function "${inst}" ; then

            ${inst} false || u=1;

         fi

      fi

      exit "${u}";

      )

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

         source "${MODULES[i]}.sh"

         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

      is_function "${MODULES[i]}_instlled" || continue

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

         missingdeps=true

         if is_function "${j}_check_installed" ; then

            ${j}_check_installed && missingdeps=false

         elif is_function "${j}_depend" ; then

            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 iface="$1" ifvar=$(bash_variable "${IFACE}")

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

   local -a umods=()

   # Has the interface got any specific modules?

   umods="modules_${ifvar}[@]"

   umods=( "${!umods}" )

   # Global setting follows interface-specific setting

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

   # Add our preferred modules

   local -a pmods=( "iproute2" "dhcpcd" "iwconfig" "netplugd" )

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

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

            fi

         done

         continue

      fi

      if ! is_function "${umods[i]}_depend" ; then

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

         # ignore this error; whatever is available will be

         # used instead.

         (( i < ${#umods[@]} - ${#pmods[@]} )) || 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]}.sh" ]] ; then

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

            is_function "${umods[i]}_check_installed" \

               && ${umods[i]}_check_installed true

         else

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

         fi

         return 1

      fi

      if is_function "${umods[i]}_provide" ; then

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

      else

         mod="${umods[i]}"

      fi

      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)

#

# Sort our modules

modules_sort() {

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

   local -a provide=() provide_list=() after=() dead=() sorted=() sortedp=()

   # Make our provide list

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

      dead[i]="false"

      if [[ ${MODULES[i]} != "${PROVIDES[i]}" ]] ; then

         local provided=false

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

            if [[ ${provide[j]} == "${PROVIDES[i]}" ]] ; then

               provide_list[j]="${provide_list[j]} ${MODULES[i]}"

               provided=true

            fi

         done

         if ! ${provided}; then

            provide[j]="${PROVIDES[i]}"

            provide_list[j]="${MODULES[i]}"

         fi

      fi

   done

   # Create an after array, which holds which modules the module at

   # index i must be after

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

      if is_function "${MODULES[i]}_after" ; then

         after[i]=" ${after[i]} $(${MODULES[i]}_after) "

      fi

      if is_function "${MODULES[i]}_before" ; then

         for m in $(${MODULES[i]}_before); do

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

               if [[ ${PROVIDES[j]} == "${m}" ]] ; then

                  after[j]=" ${after[j]} ${MODULES[i]} "

                  break

               fi

            done

         done

      fi

   done

   # Replace the after list modules with real modules

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

      if [[ -n ${after[i]} ]] ; then

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

            after[i]="${after[i]// ${provide[j]} / ${provide_list[j]} }"

         done

      fi

   done

   

   # We then use the below code to provide a topologial sort

    module_after_visit() {

        local name="$1" i= x=

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

         [[ ${MODULES[i]} == "$1" ]] && break

      done

        ${dead[i]} && return

        dead[i]="true"

        for x in ${after[i]} ; do

            module_after_visit "${x}"

        done

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

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

    }

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

      module_after_visit "${x}"

   done

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

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

}

# 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 is_function "${MODULES[i]}_need" ; 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

      if is_function "${MODULES[i]}_functions" ; then

         for f in $(${MODULES[i]}_functions); do

            if ! is_function "${f}" ; then

               eerror "${MODULES[i]}: missing required function \"${f}\""

               return 1

            fi

         done

      fi

      [[ ${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 ! is_loopback "${iface}" ; then

      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

         if is_function "${modules_force[i]}_check_installed" ; then

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

         fi

      done

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

   fi

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

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

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

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

      MODULE="${MODULES[i]}"

      ${MODULE}_depend

      # expose does exactly the same thing as depend

      # However it is more "correct" as it exposes things to other modules

      # instead of depending on them ;)

      is_function "${MODULES[i]}_expose" && ${MODULES[i]}_expose

      # If no provide is given, assume module name

      if is_function "${MODULES[i]}_provide" ; then

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

      else

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

      fi

   done

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

      # Strip any duplicate modules providing the same thing

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

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

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

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

            if [[ ${PROVIDES[i]} == ${PROVIDES[k]} ]] ; then

               unset MODULES[k]

               unset PROVIDES[k]

            fi

         done

      done

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

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

   else

      if ${starting}; then

         modules_check_user "${iface}" || return 1

      else

         # Always prefer iproute2 for taking down interfaces

         if is_function iproute2_provide ; then

            function_wrap iproute2 "$(iproute2_provide)"

         fi

      fi

   fi

   

   # Wrap our modules

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

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

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

   done

   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=() b=()

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

   interface_exists "${iface}" && interface_up "${iface}"

   # pre Start any modules with

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

      if is_function "${mod}_pre_start" ; then

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

      fi

   done

   interface_exists "${iface}" && interface_up "${iface}"

   x="metric_${ifvar}"

   # If we don't have a metric then calculate one

   # Our modules will set the metric variable to a suitable base

   # in their pre starts.

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

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

   fi

   # We now expand the configuration parameters and pray that the

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

   # trouble!

   a="config_${ifvar}[@]"

   a=( "${!a}" )

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

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

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

   done

   a="fallback_${ifvar}[@]"

   a=( "${!a}" )

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

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

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

   done

   # We don't expand routes

   fallback_route="fallback_route_${ifvar}[@]"

   fallback_route=( "${!fallback_route}" )

   

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

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

      if is_function "dhcp_start" ; then

         config=( "dhcp" )

      else

         eerror "No DHCP client installed"

         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

      # 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 is_function "${conf[0]}_start" ; 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 ! is_loopback "${iface}" ; then

            if [[ " ${MODULES[@]} " == *" arping "* ]] ; then

               if arping_address_exists "${iface}" "${conf[0]}" ; then

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

                  x="1"

               fi

            fi

         fi

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

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

      else

         if [[ ${conf[0]} == "dhcp" ]] ; then

            eerror "No DHCP client installed"

         else

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

         fi

      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

            x="fallback_route[config_counter]"

            eval "routes_${ifvar}=( \"\${!x}\" )"

            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 is_function "${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.

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

      if is_function "${mod}_pre_stop" ; then

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

      fi

   done

   einfo "Bringing down ${iface}"

   eindent

   # Collect list of aliases for this interface.

   # List will be in reverse order.

   if interface_exists "${iface}" ; then

      aliases=$(interface_get_aliases_rev "${iface}")

   fi

   # 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

         if is_function "${mod}_stop" ; then

            ${mod}_stop "${i}" || return 1

         fi

      done

      # A module may have removed the interface

      if ! interface_exists "${iface}" ; then

         eend 0

         continue

      fi

      # We don't delete ppp assigned addresses

      if ! is_function pppd_exists || ! pppd_exists "${i}" ; then

         # Delete all the addresses for this alias

         interface_del_addresses "${i}"

      fi

      # Do final shut down of this alias

      if [[ ${IN_BACKGROUND} != "true" \

         && ${RC_DOWN_INTERFACE} == "yes" ]] ; 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

      is_function "${mod}_post_stop" && ${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[@]}" )

   elif [[ ${iface} == "lo0" ]] ; then

      metric_lo0="0"

      config_lo0=( "127.0.0.1/8 brd 127.255.255.255" "${config_lo[@]}" )

      routes_lo0=( "127.0.0.0/8" "${routes_lo[@]}" )

   elif [[ -n ${metric} ]] ; then

      eval "metric_${IFVAR}=\"${metric}\""

   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

   # Call user-defined preup function if it exists

   if is_function preup ; 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=

   config="config_${IFVAR}[@]"

   config=( "${!config}" )

   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

      if [[ ${RC_INTERFACE_KEEP_CONFIG} != "yes" \

         && ${IN_BACKGROUND} != "true" ]] ; then

         interface_del_addresses "${iface}"

      fi

      # Start the interface

      if ! iface_start "${iface}" ; then

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

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

         fi

         eend 1

         return 1

      fi

   fi

   # Call user-defined postup function if it exists

   if is_function postup ; then

      # We need to mark the service as started incase a

      # postdown function wants to restart services that depend on us

      mark_service_started "net.${iface}"

      end_service "net.${iface}" 0

      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 is_function predown ; 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

   elif is_union_fs / ; then

      for x in $(unionctl "${dir}" --list \

      | sed -e 's/^\(.*\) .*/\1/') ; do

         if is_net_fs "${x}" ; then

            eerror "Part of the root filesystem is network mounted - cannot stop ${iface}"

            return 1

         fi

      done

   fi

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

   # Release resolv.conf information.

   [[ -x /sbin/resolvconf ]] && resolvconf -d "${iface}"

   

   # Mark us as inactive if called from the background

   [[ ${IN_BACKGROUND} == "true" ]] && mark_service_inactive "net.${iface}"

   # Call user-defined postdown function if it exists

   if is_function postdown ; then

      # We need to mark the service as stopped incase a

      # postdown function wants to restart services that depend on us

      [[ ${IN_BACKGROUND} != "true" ]] && mark_service_stopped "net.${iface}"

      end_service "net.${iface}" 0

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

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

      IN_BACKGROUND=true

   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

   if is_loopback "${iface}" ; then   

      modules_force=( "iproute2" "ifconfig" "system" )

   fi

   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

         # Only hotplug on ethernet interfaces

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

            if ! interface_is_ethernet "${iface}" ; then

               eerror "We only hotplug for ethernet interfaces"

               return 1

            fi

         fi

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

      fi

   fi

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

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

         # Call user-defined failup if it exists

         if is_function failup ; then

            einfo "Running failup function"

            eindent

            ( failup "${iface}" )

            eoutdent

         fi

      else

         # Call user-defined faildown if it exists

         if is_function faildown ; then

            einfo "Running faildown function"

            eindent

            ( faildown "${iface}" )

            eoutdent

         fi

      fi

      [[ ${IN_BACKGROUND} == "true" ]] \

         && mark_service_inactive "net.${iface}"

   fi

   return "${r}"

}

# bool start(void)

#

# Start entry point so that we only have one function

# which localises variables and unsets functions

start() {

   declare -r IFACE="${SVCNAME#*.}"

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

   declare -r IFACE="${SVCNAME#*.}"

   einfo "Stopping ${IFACE}"

   run "${IFACE}" stop

}

# vim:ts=4

```

Thank you.

----------

## Sadako

I can't find any problem with that script.

What do you have in your /etc/conf.d/net* files?

is this the exact error message you recieve?

```
command not foundne: 5

command not foundne: 12
```

----------

## ONEEYEMAN

Hi, Hopeless,

Yes, those 2 messages exactly as written.

Thank you.

----------

## Mike Hunt

It seems that one possibility for those command not foundne: errors is dos style newlines.

----------

