# [Wiffi] problema con conexión wiffi (cerrado)

## ZenPiPerS

Hola!

Estoy intentando configurar una conexión por Wifi y me pasa lo siguiente:

```
./net.wlan0 start

: command not foundne 5: 

: command not foundne 7: 

: command not foundne 11: 

: command not foundne 12: 

: command not foundne 17: 

 * Starting wlan0

" does not existe "(wpa_supplicant)

```

Esta es mi config, nunca me dio ningún problema:

```
cat /etc/conf.d/net

# This blank configuration will automatically use DHCP for any net.*

# scripts in /etc/init.d.  To create a more complete configuration,

# please review /etc/conf.d/net.example and save your configuration

# in /etc/conf.d/net (this file :]!).

 dns_domain_lo="gentoo"

 config_eth0=( "dhcp" )

 dhcp_eth0="nontp nonis"

 dns_servers_eth0=( "80.58.32.97" "80.58.0.33" )

 modules=( "wpa_supplicant" )

 essid_wlan0="linksys"

 mode_wlan0="managed"

 channel_wlan0="1"

 wpa_supplicant_wlan0="-D wext -c /etc/wpa_supplicant/wpa_supplicant.conf" 

 config_wlan0=("dhcp")

 dhcp_wlan0="nodns nontp nonis"

```

```
cat /etc/wpa_supplicant/wpa_supplicant.conf

# This is a network block that connects to any unsecured access point.

# We give it a low priority so any defined blocks are preferred

ctrl_interface=/var/run/wpa_supplicant

ap_scan=2

eapol_version=1

network={

   ssid="linksys"

   scan_ssid=1

   key_mgmt=WPA-PSK

   proto=WPA2

   pairwise=TKIP CCMP

   group=TKIP CCMP

   psk="contraseña"

   priority=5

} 

```

```

[ebuild   R   ] net-wireless/wpa_supplicant-0.7.2-r3 

[ebuild   R   ] net-wireless/iwl4965-ucode-228.61.2.24

[ebuild   R   ] net-misc/wicd-1.7.0

```

```
iwconfig

lo        no wireless extensions.

eth0      no wireless extensions.

wlan0     IEEE 802.11abgn  Mode:Managed  Access Point: Not-Associated   

          Tx-Power=15 dBm   

          Retry  long limit:7   RTS thr:off   Fragment thr:off

          Encryption key:off

          Power Management:off

```

Al ejecutar ifconfig wlan0 up se enciende la luz de wiffi del portátil. Nosé que mas puede estar pasando, llevo un rato dándole vueltas pero no doy con el problema.

¿Alguna idea?

Un Saludo!

----------

## quilosaq

 *Quote:*   

> ./net.wlan0 start

 

¿Lo ejecutas como root?

¿Puedes publicar el código del script?

----------

## ZenPiPerS

Hola,

Lo ejecuto como usuario pero como root me hace lo mismo.

Este es el código:

```
#!/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 +"

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 / --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
```

Un Saludo!

----------

## quilosaq

Yo intentaría un emerge baselayout

----------

## ZenPiPerS

Hola,

He probado a emerger baselayout pero mi sigue pasando lo mismo. He probado tambien a emerger todo el world pero me hace los mismo :S

```

./net.wlan0 start

: command not foundne 5:

: command not foundne 7:

: command not foundne 11:

: command not foundne 12:

: command not foundne 17:

: command not foundne 5:

: command not foundne 7:

: command not foundne 11:

: command not foundne 12:

: command not foundne 17:

: command not foundne 5:

: command not foundne 7:

: command not foundne 11:

: command not foundne 12:

: command not foundne 17:

 * Starting wlan0

" does not existe "(wpa_supplicant) 

```

Ya nosé que mas me queda por mirar :S

Un saludo!

----------

## gringo

despues de "emerger" baselayout has ejecutado etc-update ( si es que hacía falta) ?

saluetes

----------

## ZenPiPerS

hola,

Sí, ejecuté etc-update pero no había ningún paquete para actualizar.

Un Saludo.

----------

## quilosaq

Pudiera ser que los archivos de configuracion /etc/conf.d/net y wpa_supplicant.conf los hubieras editado en windows y estuvieran en formato de texto msdos. Prueba a convertirlos al formato de texto unix usando oppenoffice o este comando sed.

```
sed -e 's/.$//' dos.txt > linux.txt
```

----------

## ZenPiPerS

Hola,

El fichero /etc/conf.d/net si lo había recuperado de una antigua instalación y lo tenia guardado en un pendrive que llegue a manejar en su dia en Windows.

He probado lo que me comentas y he solventado el problema.

```
./net.wlan0 start

 * Caching service dependencies ...                                                              [ ok ]

 * Starting wlan0

 *   Starting wpa_supplicant on wlan0 ...                                                        [ ok ]

 *   Starting wpa_cli on wlan0 ...                                                               [ ok ]

 *     Backgrounding ...
```

Muchas Gracias por vuestra ayuda!  :Wink: 

Un Saludo!

----------

