# Yet another wireless question

## Phr34K

Alright, I can get my wireless card on a WEP network, but I can't get it to do this automatically.  

I followed the Gentoo-Wiki.com guide and it went through without a hitch, but i still have to manually start the connection.  

I have to type:

```
iwconfig eth1 essid ESSID key WEPKEYXXXX
```

then it works fine, but I want this to happen at boot tiime.

here is my /etc/conf.d/net file:

```
# /etc/conf.d/net:

# $Header: /home/cvsroot/gentoo-src/rc-scripts/etc/conf.d/net,v 1.7 2002/11/18 19:39:22 azarah Exp $

# Global config file for net.* rc-scripts

# This is basically the ifconfig argument without the ifconfig $iface

#

#iface_eth0="192.168.0.2 broadcast 192.168.0.255 netmask 255.255.255.0"

#iface_eth1="207.170.82.202 broadcast 207.0.255.255 netmask 255.255.0.0"

# For DHCP set iface_eth? to "dhcp"

# For passing options to dhcpcd use dhcpcd_eth?

#

iface_eth0="dhcp"

dhcpcd_eth0="-t 5"

iface_eth1="dhcp"

dhcpcd_eth1="-t 5"

essid_eth1="default"

preferred_aps=( "default" )

key_default="XXXXXXXXXX"

ifconfig_default=("dhcp")

dhcpcd_default="-t 5"

modules=( "wpa_supplicant" )

wpa_supplicant_eth1="ipw2100"

wpa_timeout_eth1=5

# For adding aliases to a interface

#

#alias_eth0="192.168.0.3 192.168.0.4"

# NB:  The next is only used for aliases.

#

# To add a custom netmask/broadcast address to created aliases,

# uncomment and change accordingly.  Leave commented to assign

# defaults for that interface.

#

#broadcast_eth0="192.168.0.255 192.168.0.255"

#netmask_eth0="255.255.255.0 255.255.255.0"

# For setting the default gateway

#

#gateway="eth0/192.168.0.1"

###########################################

# Hook wireless into /etc/init.d/net.eth0

# Please note, these lines should appear

# at the END of the file

#source /etc/init.d/wireless.sh

#preup() {

#   wireless_up ${1}

#   return $?

#}

#predown() {

#   wireless_down ${1}

#   return $?

#}

# End hook

###########################################

```

and this is my /etc/conf.d/wireless:

```
essid_eth1="default"

preferred_aps_eth1=( "default" )

key_default="XXXXXXXXXX"

ifconfig_default=("dhcp")

dhcpcd_default="-t 5"
```

How can I get this thing working at boot time?

also, I've noticed a change in network interface loading at boot.

It used to try starting eth0 first and then go on to eth1, but now it just stays on eth0 and it gives me an error about 'unable to start "netmount"' or something (which is what used to happen when it would try starting eth1)

eth0=ethernet

eth1=wireless

ideas?[/code]

----------

## Phr34K

Update:

I followed the walkthrough in the forums on how to setup/configure wireless networking, and now I can't get on any wireless networks.  All of my /etc/init.d/net.* point to /etc/init.d/net.lo (as per the howto).  

here are some files:

/etc/conf.d/net

```
# /etc/conf.d/net:

# $Header: /home/cvsroot/gentoo-src/rc-scripts/etc/conf.d/net,v 1.7 2002/11/18 19:39:22 azarah Exp $

# Global config file for net.* rc-scripts

# This is basically the ifconfig argument without the ifconfig $iface

#

#iface_eth0="192.168.0.2 broadcast 192.168.0.255 netmask 255.255.255.0"

#iface_eth1="207.170.82.202 broadcast 207.0.255.255 netmask 255.255.0.0"

# For DHCP set iface_eth? to "dhcp"

# For passing options to dhcpcd use dhcpcd_eth?

#

iface_eth0="dhcp"

dhcpcd_eth0="-t 5"

iface_eth1="dhcp"

dhcpcd_eth1="-t 5"

modules=( "iwconfig" )

essid_eth1="default"

preferred_aps=( "default" )

key_default="XXXXXXXXXX"

ifconfig_default=("dhcp")

iwconfig_default=("dhcp")

dhcpcd_default="-t 5"

#modules=( "wpa_supplicant" )

#wpa_supplicant_eth1="-Dipw2100"

#wpa_timeout_eth1=5

#config_default=( "dhcp" )

#dhcpcd_default="-t 5"

# For adding aliases to a interface

#

#alias_eth0="192.168.0.3 192.168.0.4"

# NB:  The next is only used for aliases.

#

# To add a custom netmask/broadcast address to created aliases,

# uncomment and change accordingly.  Leave commented to assign

# defaults for that interface.

#

#broadcast_eth0="192.168.0.255 192.168.0.255"

#netmask_eth0="255.255.255.0 255.255.255.0"

# For setting the default gateway

#

#gateway="eth0/192.168.0.1"

###########################################

# Hook wireless into /etc/init.d/net.eth0

# Please note, these lines should appear

# at the END of the file

#source /etc/init.d/wireless.sh

#preup() {

#   wireless_up ${1}

#   return $?

#}

#predown() {

#   wireless_down ${1}

#   return $?

#}

# End hook

###########################################

```

/etc/init.d/net.lo

```
#!/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.17 2005/03/08 16:07:30 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

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

   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

```

/etc/conf.d/wireless

```
essid_eth1="default"

preferred_aps_eth1=( "default" )

key_default="XXXXXXXXXX"

ifconfig_default=("dhcp")

dhcpcd_default="-t 5"

```

I am not home at the moment, so of course I will not be able to check if I can connect to my home network (settings in /etc/conf.d/wireless), but I can't detect my school's wireless network.  It used to work fine with the old setup (before doing the howto on the forums).  Another thing that happens when I try to '/etc/init.d/net.eth1 start' is it goes through but fails to setup wireless connection, thus I'm not able to get on the network.  Also when I change my /etc/conf.d/net to use wpa_supplicant, it fails because it can't find /etc/wpa_supplicant.conf (because it doesn't exist).  

Does anyone know how to remedy my situation?

Many thanks to anyone who can help.

(PS- I'll update again when I get home)

----------

## Phr34K

alright, everything works fine now.  added "any" after my actual preferrences in preferred_aps_eth1=( "default" "any" )

works like a charm.

----------

