ct

    Criando um script de configuração

    Configurando redes wireless no Linux, parte 1

    Carlos E. Morimoto
    21/02/2008


    Além de configurar o sistema do jeito "certo", modificando os arquivos utilizados pela configuração da rede em cada distribuição, você pode também escrever diretamente um script de configuração, que execute os passos necessários. Esta é a solução mais simples para configurar a rede em distribuições que você não conhece tão bem ou em situações onde você precisa fazer algo mais incomum.

    Um script nada mais é do que um arquivo de texto comum, contendo uma lista de comandos que serão executados em ordem pelo sistema. Além de permitirem utilizar qualquer combinação de comandos de modo texto, os scripts permitem utilizar também operações lógicas e de tomada de decisão, o que faz com que o shell script seja considerado uma linguagem de programação.

    Como a idéia é que o script seja executado durante o boot, vamos colocá-lo na pasta "/etc/init.d/", onde ficam os scripts de configuração do sistema. Vou chamá-lo de "/etc/init.d/wireless". Crie o arquivo usando seu editor de texto preferido, como em:

    # gedit /etc/init.d/wireless

    Vamos começar "limpando a casa", para ter certeza de que o script encontrará um ambiente previsível. Estes passos são opcionais e você pode incluir outros comandos que achar necessários:

    # Desativa o networkmanager do Ubuntu/Kubuntu
    /etc/dbus-1/event.d/??NetworkManagerDispatcher stop
    /etc/dbus-1/event.d/??NetworkManager stop
    # Fecha outras instâncias ativas do wpa_supplicant
    killall wpa_supplicant
    # Desativa a interface de rede cabeada
    ifconfig eth0 down
    # Desativa o cliente dhcp
    killall dhclient3

    O networkmanager, usado no Ubuntu/Kubuntu, "sabota" a configuração manual, por isso é necessário desativá-lo usando os dois comandos. No caso do Kubuntu, é necessário também desativar o knetworkmanager dentro do ambiente gráfico, desmarcando o início automático nas configurações do programa.

    Um problema comum em scripts de configuração da rede é que pode acontecer da interface de rede mudar ao reiniciar o sistema ou ao instalar uma nova placa de rede. Se o script espera que a placa wireless seja a "eth1" e o device muda para "eth2", o script deixa de funcionar.

    Se notar o problema, instale o pacote "ifrename" e crie o arquivo /etc/iftab, relacionando cada placa com o endereço MAC correspondente, como em:

     

    #/etc/iftab
    eth0 mac 00:11:D8:76:59:2E
    wlan0 mac 00:E0:7D:56:34:AB

    O primeiro passo seria usar o comando "wpa_passphrase minharede minhapassphrase" para gerar o arquivo com a configuração do wpa_supplicant, contendo a configuração da rede. Fica faltando então apenas ativar o daemon e configurar a placa de rede, usando os comandos que já vimos.

    O script completo ficaria:

    #!/bin/sh
    # script para configurar a rede wireless
    # Desativa o networkmanager do Ubuntu/Kubuntu
    /etc/dbus-1/event.d/??NetworkManagerDispatcher stop
    /etc/dbus-1/event.d/??NetworkManager stop
    # Fecha outras instâncias ativas do wpa_supplicant
    killall wpa_supplicant
    # Desativa a interface de rede cabeada
    ifconfig eth0 down
    # Desativa o cliente dhcp
    killall dhclient3
    # Configura a rede
    wpa_supplicant -i wlan0 -c /etc/wpa_supplicant.conf -B -D wext
    ifconfig wlan0 192.168.1.65 netmask 255.255.255.0 up
    route del default
    route add default gw 192.168.1.1 dev wlan0
    echo "nameserver 208.67.222.222" > /etc/resolv.conf

    Você poderia também tornar o script mais elegante, declarando os parâmetros da rede no início. Isso permite criar uma série de variáveis que podem ser utilizadas ao longo do script. Por exemplo, ao usar a linha "gtw="192.168.1.1", você cria a variável "gtw" contendo o endereço "192.168.1.1" (que no exemplo seria o gateway da rede). Mais adiante, quando precisar usar o endereço do gateway, você pode usar "$gtw" (orientando o sistema a usar o conteúdo da variável) no lugar de escrever "192.168.1.1". A grande vantagem de fazer isso é que você só precisa alterar a variável no início do script para que a alteração seja aplicada a todo o script.

    Vamos então a mais um exemplo, dessa vez usando variáveis:

    #!/bin/sh
    # script para configurar a rede wireless
    # Declara os parâmetros
    endip="192.168.1.65"
    masc="255.255.255.0"
    gtw="192.168.1.1"
    enddns="208.67.222.222"
    placa="wlan0"
    wpadriver="wext"
    # Desativa o networkmanager do Ubuntu/Kubuntu
    /etc/dbus-1/event.d/??NetworkManagerDispatcher stop
    /etc/dbus-1/event.d/??NetworkManager stop
    # Fecha outras instâncias ativas do wpa_supplicant
    killall wpa_supplicant
    # Desativa a interface de rede cabeada
    ifconfig eth0 down
    # Desativa o cliente dhcp
    killall dhclient3
    # Descobre qual é o device da placa wireless
    placa=`cat /proc/net/wireless | tail -n 1 | cut -f 1 -d ":" | cut -c 3-`
    # Configura a rede
    wpa_supplicant -i $placa -c /etc/wpa_supplicant.conf -B -D $wpadriver
    ifconfig $placa $endip netmask $masc up
    route del default
    route add default gw $gtw dev $placa
    echo "nameserver $enddns" > /etc/resolv.conf

    Se você pretende distribuir o script para outras pessoas, ou usá-lo em vários micros, pode torná-lo mais inteligente, fazendo com que ele passe a detectar sozinho qual é a placa wireless a configurar (desde que exista apenas uma instalada). Isso é simples, pois o sistema guarda a informação no arquivo "/proc/net/wireless":

    # cat /proc/net/wireless
    Inter-| sta-| Quality | Discarded packets | Missed | WE
    face | tus | link level noise | nwid crypt frag retry misc | beacon | 21
    wlan0: 0000 65 202 160 0 0 0 0 0 0

    Podemos filtrar a informação, ficando apenas com o device da placa de rede e atribuí-lo a uma variável que poderemos usar mais adiante no script, usando o pipe, o tail e o cut, veja só:

    # Descobre qual é o device da placa wireless
    placa=`cat /proc/net/wireless | tail -n 1 | cut -f 1 -d ":" | cut -c 4-`

    Em vez de ser definida manualmente, a variável "placa" passa a conter o "wlan0", que é o device atual da placa de rede. Com isso, o script se adapta automaticamente a mudanças, descobrindo qual é o device da placa de rede instalada antes de configurá-la.

    Ao terminar, transforme o arquivo em executável e crie um link para ele dentro da pasta "/etc/rc5.d", de forma que ele seja executado durante o boot:

    # chmod +x /etc/init.d/wireless
    # cd /etc/rc5.d
    # ln -s ../init.d/wireless S99wireless

    Se preferir, você pode também adicionar o comando "/etc/init.d/wireless" em algum dos arquivos de inicialização, como o "/etc/rc.local", de forma que ele seja executado diretamente. Vai do que achar mais prático de acordo com a situação. Terminado, é só reiniciar o micro e testar.

    Este script "base" pode ser adaptado de acordo com a necessidade, incluindo outros comandos que você precise executar para ativar a placa de rede ou resolver problemas diversos.

    Por exemplo, em um Acer 5043, preciso rodar os dois comandos abaixo para ativar o transmissor da placa wireless, caso contrário a placa simplesmente não transmite dados:

    # modprobe acer_acpi
    # echo "enabled : 1" > /proc/acpi/acer/wireless

    Em outro notebook (com uma placa Atheros) notei um problema estranho onde a placa nem sempre é detectada ao ativar o módulo. O processo é aleatório, de forma que às vezes é necessário carregar e descarregar o módulo várias vezes até que placa seja detectada. Resolvi o problema na base da "força bruta" usando a função abaixo, que continua carregando e descarregando os módulos até que a placa seja ativada e o device apareça no arquivo "/proc/net/wireless":

    atheros=`cat /proc/net/wireless | grep ath0`
    while [ -z "$atheros" ]; do
    /sbin/modprobe -r ath_pci
    /sbin/modprobe -r ath_hal
    sleep 3
    /sbin/modprobe ath_hal
    /sbin/modprobe ath_pci
    atheros=`cat /proc/net/wireless | grep ath0`
    done

     

    Em ambos os casos, os comandos poderiam ser adicionados no início do script, de forma que a rede fosse ativada antes dos demais comandos. Com o tempo, você vai acabar descobrindo novas formas de automatizar tarefas e poderá assim ir incrementando seu script. A grande vantagem de estudar sobre programação em shell script é que a linguagem permite solucionar os problemas do dia-a-dia de forma bastante rápida.

    Naturalmente, escrever o script do zero pode ser bem mais complicado do que simplesmente configurar a rede usando as ferramentas disponíveis, mas agora que você tem um modelo pronto, pode usá-lo de forma bastante prática, simplesmente substituindo as informações que forem diferentes em cada situação. Esta é a beleza dos scripts de configuração: eles podem ser escritos uma vez e depois usados indefinidamente, com pequenas alterações.

    Confira a segunda parte do tutorial em: http://www.guiadohardware.net/tutoriais/rede-wireless-linux_2/



    Página 04 de 04
        



    Blog:

    Add to Google

    » Gostou do texto? Veja nossos livros impressos:
    Hardware | Redes | Servidores | Kurumin 7

    ... ou encontre o que procura usando a busca:

cb
Livros de Carlos E. Morimoto HOME