Criando um script de configuração

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: https://www.hardware.com.br/tutoriais/rede-wireless-linux_2/

Sobre o Autor

Redes Sociais:

Deixe seu comentário

X