Shell script parte 1

[bloodrain]

Quase tudo no Linux pode ser feito via linha de comando. É possível baixar e instalar programas automaticamente, alterar qualquer tipo de configuração do sistema, carregar programas ou executar operações diversas durante o boot, etc. Dentro do KDE é possível até mesmo controlar programas gráficos, minimizando uma janela, abrindo um novo email, já com o corpo da mensagem preenchido no kmail, exibir uma mensagem de aviso e assim por diante.

Um script é um arquivo de texto, com uma seqüência de comandos que são executados. Dentro de um script você pode utilizar qualquer comando de terminal (incluindo programas gráficos) e também funções lógicas suportadas pelo shell, que incluem operações de tomada de decisão, comparação, etc. Você pode até mesmo acessar bancos de dados ou configurar outras máquinas remotamente.

A princípio, o shell script lembra um pouco os arquivos .bat do DOS, que também eram arquivos de texto com comandos dentro, da mesma forma que um ser humano e uma ameba conservam muitas coisas em comum, como o fato de possuírem DNA, se reproduzirem e sintetizarem proteínas.

Mas, assim como um humano é muito mais inteligente e evoluído que uma ameba, um shell script pode ser incomparavelmente mais poderoso e elaborado que um simples .bat do DOS.

É possível escrever programas elaborados em shell script, substituindo aplicativos que demorariam muito mais tempo para ser escritos em uma linguagem mais elaborada. Seus scripts podem tanto seguir a velha guarda, com interfaces simples de modo texto (ou mesmo não ter interface alguma), de forma a desempenhar tarefas simples, quanto possuir uma interface gráfica elaborada, escrita usando o kommander e funções do kdialog.

Um exemplo de trabalho desenvolvido em shell script é o Painel de controle do Kurumin, que utiliza um conjunto de painéis gráficos, criados usando o Kommander, que ativam um emaranhado de scripts para desempenhar as mais diversas tarefas.

O programa de instalação do Kurumin é escrito em shell script, assim como a maior parte dos programas encarregados de configurar o sistema durante o boot, os painéis para instalar novos programas, configurar servidores, e tudo mais.

O principal motivo para uso de scripts em shell ao invés de programas escritos em C ou C++ por exemplo é a rapidez de desenvolvimento, combinado com a facilidade de editar os scripts existentes para corrigir problemas ou adicionar novos recursos. Você vai encontrar uma grande quantidade de scripts de configuração também no Slackware, Debian e muitas outras distribuições.

O Basico
---------------------------------------------------------------------------------------------------------------------------------------------------------------
Um shell script é um conjunto de comandos de terminal, organizados de forma a desempenhar alguma tarefa. O modo de comando do Linux é extremamente poderoso, o que dá uma grande flexibilidade na hora de escrever scripts. Você pode inclusive incluir trechos com comandos de outras linguagens interpretadas, como perl ou python por exemplo.

O primeiro passo para escrever um script, é descobrir uma forma de fazer o que precisa via linha de comando. Vamos começar um um exemplo simples:

O comando "wget" permite baixar arquivos, podemos usá-lo para baixar o ISO do Kurumin, por exemplo:

    $ wget -c http://fisica.ufpr.br/kurumin/kurumin-4.0.iso
    (o "-c" permite continuar um download interrompido)

Depois de baixar o arquivo, é importante verificar o md5sum para ter certeza que o arquivo está correto:

    $ md5sum kurumin-4.0.iso

Estes dois comandos podem ser usados para criar um script rudimentar, que baixa o Kurumin e verifica o md5sum. Abra o kedit ou outro editor de textos que preferir e inclua as três linhas abaixo:

#!/bin/sh
wget -c http://fisica.ufpr.br/kurumin/kurumin-4.0.iso
md5sum kurumin-4.0.iso

O "#!/bin/sh" indica o programa que será usado para interpretar o script, o próprio bash. Por norma, todo script deve começar com esta linha. Na verdade, os scripts até funcionam sem ela, mas não custa fazer as coisas certo desde o início. Existe a possibilidade de escrever scripts usando outros interpretadores, ou mesmo comandos como o sed. Neste caso o script começaria com "#!/bin/sed" por exemplo.

Note que a tralha, "#", é usada para indicar um comentário. Toda linha começada com ela é ignorada pelo bash na hora que o script é executado, por isso a usamos para desativar linhas ou incluir comentários no script. A linha "#!/bin/sh" é a única exceção para esta regra.

Ao terminar, salve o arquivo com um nome qualquer. Você pode usar uma extensão como ".sh" para que outras pessoas saibam que trata-se de um shell script, mas isto não é necessário. Lembre-se que no Linux as extensões são apenas parte do nome do arquivo.

Marque a permissão de execução para ele nas propriedades do arquivo, ou use o comando:

    $ chmod +x teste.sh

Execute-o colocando um "./" na frente do nome do arquivo, o que faz o interpretador entender que ele deve executar o "teste.sh" está na pasta atual. Caso contrário ele tenta procurar nas pastas /bin/, /usr/bin e /usr/local/bin que são as pastas onde ficam os executáveis do sistema e não acha o script.

    $ ./teste.sh

O md5sum soma os bits do arquivo e devolve um número de 32 caracteres. No mesmo diretório do servidor onde foi baixado o arquivo, está disponível um arquivo "kurumin-4.0.md5sum.txt" que contém o md5sum correto do arquivo. O resultado do md5sum do arquivo baixado deve ser igual ao do arquivo, caso contrário significa que o arquivo veio corrompido e você precisa baixar de novo.

Você já deve estar cansado de baixar as novas versões do Kurumin e já sabe de tudo isso. Podemos aproveitar para ensinar isso ao nosso script, fazendo com que, depois de baixar o arquivo, ele verifique o md5sum e baixe o arquivo de novo caso ele esteja corrompido.

Isto vai deixar o script um pouco mais complexo:

#!/bin/sh

wget -c http://fisica.ufpr.br/kurumin/kurumin-4.0.iso
md5sum=`md5sum kurumin-4.0.iso`

if [ "$md5sum" != "ce770ea8740522750f6bb67a8603f173 kurumin-4.0.iso" ];
then
rm -f kurumin-4.0.iso
./teste.sh
else
echo "O arquivo foi baixado corretamente"
fi

Você vai perceber que ao executar este segundo script, ele vai tentar baixar o arquivo novamente sempre que o md5sum não bater, se necessário várias vezes. Para isso, começamos a utilizar algumas operações lógicas simples, que lembram um pouco as aulas de pseudo-código que os alunos de ciências da computação têm no primeiro ano.

No script anterior, usamos simplesmente o comando "md5sum kurumin-4.0.iso". Ele simplesmente mostra o md5sum do arquivo na tela, sem fazer nada mais.

Neste segundo script esta linha ficou um pouco diferente: md5sum=`md5sum kurumin-4.0.iso`. A diferença é que ao invés de mostrar o mds5um na tela, armazenamos o resultado numa variável, chamada "md5sum". O sinal usado aqui não é o apóstrofo, como é mais comum em outras linguagens, mas sim a craze (o mesmo do "à"). O shell primeiro executa os comandos dentro das crazes e armazena o resultado dentro da variável.

As variáveis podem armazenar qualquer tipo de informação, como um número, um texto ou o resultado de um comando. Elas podem ser comparadas, podemos verificar se o texto dentro da variável "md5sum" é igual ao texto que está no arquivo do servidor e fazer o script decidir se deve baixar o arquivo de novo ou não.

Para comparar duas informações num shell script, usamos o símbolo "!=" (não igual, ou seja: diferente). Para saber se o arquivo foi baixado corretamente, comparamos a variável md5sum com o md5sum correto do arquivo:

    "$md5sum" != "ce770ea8740522750f6bb67a8603f173 kurumin-4.0.iso"

Além do !=, Outros operadores lógicos que podem ser usados são:

== : Igual
> : Maior
>= : Maior ou igual
< : Menor
<= : Menor ou igual

Mas, só comparar não adianta. Precisamos dizer ao script o que fazer depois. Lembre-se que os computadores são burros, você precisa dizer o que fazer em cada situação. Neste caso temos duas possibilidades: o md5sum pode estar errado ou certo. Se estiver errado, ele deve baixar o arquivo de novo, caso contrário não deve fazer nada.

Usamos então um "if" (se) para criar uma operação de tomada de decisão. Verificamos o mds5um, se ele for diferente do correto, então (then) ele vai deletar o arquivo danificado e começar o download de novo. Caso contrário (else) ele vai simplesmente escrever uma mensagem na tela.

    if [ "$md5sum" != "ce770ea8740522750f6bb67a8603f173 kurumin-4.0.iso" ];
    then
    rm -f kurumin-4.0.iso
    ./teste.sh
    else
    echo "O arquivo foi baixado corretamente" fi

Veja que dentro da função then, usei o comando "rm -f kurumin-4.0.iso" para deletar o arquivo e depois executei de novo o "./teste.sh" que vai executar nosso script de novo, dentro dele mesmo!

Isso vai fazer com que o script fique em loop, obssessivamente, até conseguir baixar o arquivo corretamente. Uma coisa interessante nos scripts é que eles podem ser executados dentro deles mesmos e alterados durante a execução. O script pode até mesmo deletar a sí mesmo depois de rodar uma vez, uma espécie de script suicida! :-P

Por exemplo, o instalador do Kurumin, cria o script /etc/rc5.d/S99printconf ao instalar o sistema. Por estar dentro da pasta /etc/rc5.d, ele é executado durante o boot.

Este script roda o printconf, que detecta as impressoras instaladas. Depois disso o script deleta a sí mesmo, fazendo que que seja executado uma única vez, durante o primeiro boot depois da instalação:

    #!/bin/sh
    printconf -v
    rm -f /etc/rc5.d/S99printconf

Estes dois exemplos são scripts simples, que simplesmente executam alguns comandos, sem oferecer nenhum tipo de interatividade. Se você quisesse que o primeiro script baixasse outro arquivo, teria que editá-lo manualmente.

Fazendo perguntas
--------------------------------------------------------------------------------------------------------------------------------------------------------------
Você pode incluir perguntas no script, para coletar as informações necessárias para montar e executar algum comando complicado.

Por exemplo, o mais legal de ter uma placa de recepção de TV é poder gravar programas, usando o micro como um videocassete. Porém, programas gráficos como o xawtv e o zapping não oferecem uma boa qualidade de gravação.

Entre os programas de modo texto, o mencoder é o que oferece melhor qualidade, mas ele oferece muitas opções e por isso não é exatamente um exemplo de amigabilidade. O comando para gravar a programação do canal 12 da TV aberta durante uma hora, compactando em Divx 4 seria:

    $ mencoder tv:// -tv driver=v4l2:input=0:normid=4:channel=12:
    chanlist=us-bcast:width=640:height=480:device=/dev/video0:
    adevice=/dev/dsp0:audiorate=32000:
    forceaudio:forcechan=2:buffersize=64
    -quiet -oac mp3lame -lameopts preset=medium -ovc lavc -lavcopts
    vcodec=mpeg4:vbitrate=3000:keyint=132 -vop pp=lb -endpos 01:00:00 -o /home/kurumin/video.avi

As partes do comando que mudariam de uma chamada a outra seriam o canal (channel=12) o tempo de gravação ("-endpos 01:00:00", para uma hora) e o arquivo que será gerado (/home/kurumin/video.avi).

Podemos fazer com que nosso script pergunte estas informações, armazenando tudo em variáveis e no final monte o comando. Isto transformaria um comando indigesto, de quase 400 caracteres num script amigável que sua avó poderia usar.

Existem várias formas de exibir uma pergunta na tela e armazenar a resposta numa variável. A forma mais simples seria usar o comando "echo" para mostar a pergunta e o comando "read" para ler a resposta, como em:

    echo "Qual canal gostaria de gravar? (ex: 12)"
    read canal
    echo "Qual o tempo de gravação? (ex: 01:00:00)"
    read tempo
    echo "Em qual arquivo o vídeo será salvo? (ex: /home/kurumin/video.avi)"
    read arquivo

O "read" faz com que o script pare e fique esperando uma resposta. Ao digitar qualquer coisa e pressionar enter, ele vai para a próxima pergunta e assim por diante até executar o último comando. Teríamos então três variáveis, "canal", "tempo" e "arquivo" que poderíamos utilizar para montar o comando principal, que, dentro do script, ficaria:

    mencoder tv:// -tv driver=v4l2:input=0:normid=4:channel=$canal:
    chanlist=us-bcast:width=640:height=480:device=/dev/video0:
    adevice=/dev/dsp0:audiorate=32000:
    forceaudio:forcechan=2:buffersize=64
    -quiet -oac mp3lame -lameopts preset=medium -ovc lavc -lavcopts
    vcodec=mpeg4:vbitrate=3000:keyint=132 -vop pp=lb -endpos $tempo -o $arquivo

Veja que ao criar uma variável, simplesmente a chamamos pelo nome, mas ao utilizá-la depois precisamos usar um símbolo de dólar, "$". É isso que faz o bash diferenciar a variável "arquivo" da palavra (ou comando) "arquivo".

Isto já seria o suficiente para ter um script funcional. A desvantagem neste caso é que o script roda em modo texto e possui um visual muito pobre.

Existem programas que permitem incrementar o script, transformando as perguntas em janelas gráficas. Os três mais usados são o dialog, o Xdialog e o kdialog.

O dialog é o mais antigo e tradicional. Ele não gera geralmente uma janela gráfica, mas sim uma janela de modo texto, que lembra os tempos do Clipper. A vantagem é que ele permite que o script seja executado em modo texto puro ou remotamente (via ssh ou telnet), mesmo em conexões lentas.

Por exemplo, para mostrar um aviso na tela, o comando seria:

    dialog --msgbox "Seu micro está pegando fogo" 10 50

O "10 50" indica o tamanho da janela, em caracteres. O dialog é capaz de exibir vários tipos de janelas, para abrir e salvar arquivos, escolher entre opções, etc. Você pode ver todas as opções através do "man dialog".

No nosso caso, precisamos ler a resposta, por isso usamos o parâmetro "--inputbox" do dialog:

    dialog --inputbox "Canal a gravar (ex: 12)" 10 60 "12" 2> /tmp/resposta.tmp
    canal=`cat /tmp/resposta.tmp`

O "10 60" indica o tamanho da janela, como já vimos. O "12" que vem a seguir é o valor default, que é assumido caso você simplesmente pressione Enter. É interessante usar um valor padrão nas perguntas, ele ao mesmo tempo serve como um exemplo do que deve ser respondido e como uma garantia que a resposta não virá em branco.

O "2> /tmp/resposta.tmp" faz com que a resposta seja gravada num arquivo de texto. Em seguida, o "canal=`cat /tmp/resposta.tmp`" cria a variável "canal", com a resposta.

O comando cat serve para listar o conteúdo de um arquivo de texto. Originalmente ele simplesmente escreveria na tela. Mas, usado desta forma, a saída do cat (o texto dentro do arquivo) é armazenado na variável, sem ser mostrado na tela.

O resultado é o mesmo do exemplo anterior, mas desta vez com uma interface um pouco melhor:

O Xdialog possui quase as mesmas opções e sintaxe do dialog, mas gera janelas gráficas. Nem todas as distribuições trazem o Xdialog instalado por padrão, nestes casos você pode baixar a versão mais recente no: http://xdialog.dyns.net/

Em distribuições derivadas do Debian você pode instala-lo via apt-get, o pacote está disponível nos servidores principais. No caso das distribuições que usam pacotes rpm procure no http://www.rpmfind.net/linux/RPM/

Veja que o comando é exatamente igual ao exemplo anterior, muda apenas o comando:

    Xdialog --inputbox "Canal a gravar (ex: 12)" 10 60 "12" 2> /tmp/resposta.tmp
    canal=`/tmp/resposta.tmp`

Nossa janela em kdialog:

Este é o script completo, que desenvolvi para o Kurumin usando janelas em kdialog, com comentários das outras funções usadas:

#!/bin/sh
# Gravar-TV
# Script para gravar TV usando uma placa de captura.
# Escrito por Carlos E. Morimoto para o Kurumin

kdialog --title "Gravar-TV" --msgbox "Este script permite gravar programas de TV, usando uma placa de captura.
Ao gravar, você precisa fechar o TVtime ou qualquer outro programa de sintonia de TV que esteja aberto.

Os vídeos são gravados com resolução de 640x480, compactados em divx4, com uma qualidade próxima à do DVD.
Certifique-se de ter espaço suficiente no HD. Cada hora de gravação gera um arquivo de aproximadamente 1.3 GB"

var1=`kdialog --title "Gravar-TV" --inputbox "Canal a gravar (ex: 12)" "12"`

var2=`kdialog --title "Gravar-TV" --inputbox "Duração da gravação (00:01:00 = 1 minuto)" "00:01:00"`

# A opção --getsavename do kdialog abre uma janela do gerenciador de
# arquivos, para que o usuário aponte a pasta e o nome do arquivo.
# A opção :label1 faz com que a janela mostre apenas arquivos de vídeo

var3=`kdialog --getsavefilename :label1 "*.avi *.mpg *.wmf |Arquivos de vídeo"`

# As quebras de linha dentro do texto da opção faz com que o texto
# fique formatado da mesma forma dentro da janela.

var4=`kdialog --combobox "Padrão de sintonia:
us-bcast = TV aberta
us-cable = TV a cabo" "us-bcast" "us-cable"`

# A opção --passivepopup mostra um aviso que some depois do tempo especificado
# neste caso depois de 6 segundos, ou quando o aviso é clicado.

kdialog --title "Gravando" --passivepopup "Gravando o canal $var1
por: $var2 horas
no arquivo: $var3
Feche a janela de terminal para abortar" 6 &

# Aqui vai o comando de gravação, montado usando todas as informações coletadas
# acima:

mencoder tv:// -tv driver=v4l2:input=0:normid=4:channel=$var1:chanlist=$var4:
width=640:height=480:device=/dev/video0:adevice=/dev/dsp0:audiorate=32000:forceaudio:
forcechan=2:buffersize=64
-quiet -oac mp3lame -lameopts preset=medium -ovc lavc -lavcopts
vcodec=mpeg4:vbitrate=3000:keyint=132 -vop pp=lb -endpos $var2 -o $var3

# Depois do comando de gravação, ou seja, depois que a gravação termina,
# é mostrada mais uma janela de texto:

kdialog --title "Gravar-TV" --passivepopup "Ok!
A gravação terminou." 5

Este outro script, também escrito para o Kurumin, serve para montar compartilhamentos de rede em NFS. Diferentemente do script de gravar TV, ele foi escrito para funcionar tanto dentro do modo gráfico (usando janelas em Xdialog) ou em modo texto puro, usando o dialog. Uma função no início do script se encarrega de detectar se o modo gráfico está aberto ou não.

Você pode encontrar todos os scripts desenvolvidos para o Kurumin dentro da pasta /usr/local/bin/ do sistema, ou online no: http://www.guiadohardware.net/kurumin/bin/

Eles são intencionalmente escritos de forma simples, até elementar para facilitar o entendimento.

#!/bin/sh
# Monta um compartilhamento NFS, por Carlos E. Morimoto

# Esta função permite que o script funcione tanto dentro do modo gráfico, usando
# o Xdialog, quanto em modo texto, usando o dialog.

case "`tty`" in
/dev/tty[1-8])
MODE=text
DIALOG=dialog
;;
/dev/pts/*|/dev/ttyp*)
MODE=x
export XDIALOG_HIGH_DIALOG_COMPAT=1
[ -x /usr/bin/gdialog ] && DIALOG=gdialog
[ -x /usr/bin/Xdialog ] && DIALOG=Xdialog
[ $DIALOG = dialog ] && MODE=text
;;
*)
esac

# Este script corresponde ao ícone "NFS - Montar Compartilhamento" no iniciar.
# Ele facilita o acesso a compartilhamentos NFS que normalmente são uma tarefa
# um tanto quanto indigesta para os iniciantes.

# Começa perguntando ao usuário qual compartilhamento será montado:

$DIALOG --title "Acessar compartilhamento NFS" \
--backtitle "Acessar compartilhamento NFS" \
--ok-label "Continuar" --cancel-label "Sair" \
--inputbox "O NFS é um protocolo que permite compartilhar arquivos facilmente entre máquinas Linux.
Para compartilhar uma pasta no Kurumin clique no Iniciar > Sistema > NFS - Ativar Servidor.\n\n
Este script é um cliente que permite acessar compartilhamentos em outras máquinas.
Para isso você precisa apenasx informar o endereço IP do servidor, seguido da pasta que ele está compartilhando.\n\n
Ex: 192.168.0.3:/home/arquivos" 21 70 '192.168.0.3:/home/arquivos' > /dev/null 2> /tmp/nfs1
retval=$?

compartilhamento=`cat /tmp/nfs1`

# O texto digitado é armazenado na variável "compartilhamento" que usaremos adiante.
# Além de saber qual compartilhamento será montado, é preciso saber onde ele será montado:

$DIALOG --title "Acessar compartilhamento NFS" \
--backtitle "Acessar compartilhamento NFS" \
--ok-label "Continuar" --cancel-label "Sair" \
--inputbox "Preciso saber agora em qual pasta local você deseja que o compartilhamento fique acessível.
Um recurso interessante do NFS é que os arquivos ficam acessíveis como
se fossem arquivos locais, você pode até mesmo gravar um CD diretamente a partir da pasta com o compartilhamento.\n\n
Você pode usar qualquer pasta dentro do seu diretório de usuário. Se a pasta não existir vou tentar criá-la para você.\n\n
Ex: /mnt/nfs" 21 70 '/mnt/nfs' > /dev/null 2> /tmp/nfs2
retval=$?
localmount=`cat /tmp/nfs2`

# Mais uma variável, agora armazenando o texto com o diretório local onde o
# compartilhamento será montado, localmount

# Para o caso de alguma mente perturbada tentar montar o compartilhamento
# numa pasta que não existe, vamos criá-la primeiro, antes de montar. O
# comando mkdir não é destrutível, se a pasta já existir ele não fará nada:

mkdir $localmount

# Vamos iniciar alguns serviços necessários para o NFS funcionar. Não sabemos
# se eles vão estar ou não abertos na máquina do usuário, por isso é melhor
# ter certeza.
# Ao mesmo tempo em que os comandos são executados, eles são escritos na tela,
# o que tem uma função didática. O sleep 2 faz com que o script pare por dois
# segundos ao executar cada um dos comandos, dando tempo para que ele leia
# alguma mensagem de erro.

Echo " "
echo "Executando comando:"
echo "sudo /etc/init.d/portmap/start"
/etc/init.d/portmap start
sleep 1

echo " "
echo "Executando comando:"
echo "sudo /etc/init.d/nfs-common start"
/etc/init.d/nfs-common start
sleep 1

BT="Acessar compartilhamento NFS"
T1="Acessar compartilhamento NFS"
M1="Você gostaria de adicionar uma entrada no /etc/fstab e um ícone no desktop, para que este
compartilhamento possa ser acessado mais tarde com mais facilidade? Ao responder yes você poderá acessar
os arquivos posteriormente apenas clicando no ícone que será criado no desktop."
$DIALOG --title "$T1" --yesno "$M1" 18 60

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

echo '# Acessa compartilhamento de rede nfs, adicionado pelo nfs-montar:' >> /etc/fstab
echo "$compartilhamento $localmount nfs noauto,users,exec 0 0" >> /etc/fstab
echo " " >> /etc/fstab

$DIALOG --msgbox "Vou abrir agora o arquivo /etc/fstab para que você possa revisar e,
caso necessário, alterar a entrada incluída. Delete as linhas repetidas no final do arquivo caso necessário."

kedit /etc/skel-fix/editar-fstab &
sleep 2
sudo kedit /etc/fstab

sleep 10

# Por fim é criado um ícone no desktop permitindo montar o mesmo compartilhamento
# facilmente depois. Os ícones do KDE são apenas arquivos de texto comuns.
# Esta parte me fez quebrar um pouco a cabeça. Se o usuário for criar vários ícones,
# cada um precisará ter um nome de arquivo diferente. Eu poderia pedir para que ele
# digitasse um número por exemplo e usa-lo como nome para o arquivo, mas nada
# impedidiria que ele simplesmente digitasse o mesmo número repetidamente, o
# que não resolveria o nosso problema :-P

# Existe um dispositivo chamado /dev/urandom que gera números aleatórios, então
# usei-o para gerar uma string de 8 caracteres que vou usar como nome de arquivo.
# Armazeno os 8 caracteres num arquivo usando o dd e depois carrego-os numa variável
# que é usada como nome de arquivo. O que aparece escrito no desktop não é o nome
# do arquivo mas sim o campo "Name" dentro do texto.
# Atualmente isso é feito através do script "passgen" do Nawtage, que gera os 8
# caracteres a partir do /dev/urandom.

nome=`passgen`

# Estas duas linhas comentadas fazem algo semelhante, usando o
# o /dev/urandom:

#rm -f of=/tmp/kramdom
#dd if=/dev/urandom of=/tmp/kramdom bs=8 count=1

clear

echo "[Desktop Entry]" >> ~/Desktop/$nome
echo "Type=FSDevice" >> ~/Desktop/$nome
echo "Dev=$compartilhamento" >> ~/Desktop/$nome
echo "MountPoint=$localmount" >> ~/Desktop/$nome
echo "FSType=nfs" >> ~/Desktop/$nome
echo "ReadOnly=0" >> ~/Desktop/$nome
echo "Icon=hdd_mount" >> ~/Desktop/$nome
echo "UnmountIcon=hdd_unmount" >> ~/Desktop/$nome
echo "Name=$compartilhamento" >> ~/Desktop/$nome

fi

# As duas variáveis que foram lidas acima são usadas para montar o comando
# que monta o compartilhamento

echo "Executando comando:"
echo "mount -t nfs $compartilhamento $localmount"
mount -t nfs $compartilhamento $localmount
sleep 2

# Remove os arquivos temporários que foram usados:

sudo rm -f /tmp/nfs1
sudo rm -f /tmp/nfs2

# Concluindo, abrimos uma janela do Konqueror já mostrando os arquivos do
# compartilhamento, provendo gratificação imediata. Estamos na era do
# fast-food de software... :-P

konqueror $localmount

# Ao fechar a janela do Konqueror o compartilhamento é desmontado:

umount $localmount

exit 0

Uma dúvida freqüente é sobre o uso das aspas. Num script você pode tanto utilizar aspas duplas, ", quanto aspas simples ', mas as duas possuem funções ligeiramente diferentes.

As aspas duplas fazem com que o conteúdo seja interpretado literalmente, isso permite incluir nomes de arquivos com espaços entre outras coisas. As aspas simples fazem o mesmo, mas de uma forma mais estrita, sem interpretar variáveis.

Por exemplo, o comando: echo "mount -t nfs $compartilhamento $localmount" do script anterior usa duas variáveis. Ao executar o script elas seriam substituídas pelos valores correspondentes, fazendo com que fosse mostrado na tela algo como: "mount -t nfs 192.168.0.1/arquivos /mnt/nfs".

Porém, se usássemos aspas simples: echo 'mount -t nfs $compartilhamento $localmount', o resultado do comando seria diferente. O bash escreveria a frase literalmente, sem interpretar as variáveis: "mount -t nfs $compartilhamento $localmount"

Ou seja, só usamos aspas simples quando realmente queremos usar um bloco de texto que não deve ser interpretado de forma alguma nem conter variáveis. No restante do tempo, usamos sempre aspas duplas.

[bloodrain]

Mais dicas sober k dialog
-----------------------------------------------------------------------------------------------------------------------------------------------------------
O Kdialog oferece uma quantidade generosa de opções de caixas de diálogo. Além do --msgbox, temos também o --sorry e --error, que podem ser usadas de acordo com o contexto:

    $ kdialog --sorry "Desculpe, não foi possível criar o arquivo, verifique as permissões da pasta."

    $ kdialog --error "O arquivo está corrompido. Experimente baixá-lo novamente"

A opção --yesno permite fazer perguntas. A resposta é armazenada na variável "$?". Se a resposta for "sim", ela assume o valor 0, caso seja "não" ela armazena o valor 1. Se por acaso a janela for fechada, sem uma resposta, a variável também fica com o valor 1:

    $ kdialog --yesno "Sua conexão é muito lenta! A atualização do sistema vai demorar duas semanas. Quer continuar mesmo assim? :-P"

Como temos apenas duas possibilidades, você pode usar um if para especificar o que o script deve fazer em cada caso:

    resposta=$?
    if [ "$resposta" = "0" ]
    then
    apt-get upgrade
    fi
    if [ "$resposta" = "1" ]
    then
    kdialog --msgbox "Ok, abortando..."
    fi

Aqui usei dois if, uma para o sim e outro para o não. Você pode economizar algumas linhas usando um else:

    resposta=$?
    if [ "$resposta" = "0" ]
    then
    apt-get upgrade
    else
    kdialog --msgbox "Ok, abortando..."
    fi

Existe uma pequena variação do --yesno que é a opção "--warningcontinuecancel", onde a legenda dos botões muda para continuar/cancelar.

Outra variação é a opção "--yesnocancel" que mostra uma caixa com três opções. Respondendo sim ou não, a variável $? assume o valor 0 ou 1, mas respondendo "Cancelar" ela assume o valor 2.

A opção "Cancelar" pode ser usada para fechar o script, usando o comando "exit", que encerra a execução, sem executar o resto dos comandos. Isto pode ser útil num script longo, com muitos passos. É importante que nestes casos você encontre uma forma de desfazer as alterações feitas nas opções anteriores, deixando tudo como estava antes de executar o script.

Como agora temos três possibilidades de resposta, podemos utilizar a função "case", que permite especificar ações para um número indefinido de opções.

    kdialog --yesnocancel "Sua conexão é muito lenta! A atualização do sistema vai demorar duas semanas. Quer continuar mesmo assim? :-P"
    resposta=$?
    case $resposta in
    0) apt-get upgrade ;;
    1) kdialog --msgbox "Ok, abortando..." ;;
    2) exit 0 ;;
    *) kdialog -- msgbox "Ops, isto não deveria acontecer... :-P" ;;
    esac

Depois do "case $resposta in" você adiciona cada uma das possibilidades de valor para a variável, seguida de um parêntese. No final de cada linha vai obrigatoriamente um ponto e vírgula duplo, que faz o bash entender que deve passar para a próxima opção. Se precisar colocar vários comandos dentro de uma mesma opção, você pode separá-los por um único ponto e vírgula como em:

    1) apt-get -f install; apt-get update; apt-get upgrade ;;

O esac funciona da mesma forma que o else, uma opção "default" que é executada se nenhuma das outras for válida.

O kdialog oferece três opções de diálogos para abrir, salvar arquivos e selecionar pastas. Vimos uma delas no script gravar-tv, o --getsavefilename. As outras duas opções são o --getopenfilename (para selecionar um arquivo a ser aberto) e o --getexistingdirectory

As três opções são semelhantes no sentido de que permitem escolher um arquivo ou diretório, muda basicamente a forma como o diálogo é apresentado ao usuário.

A sintaxe é um pouco diferente da das caixas de diálogo. Você pode especificar uma pasta padrão e também um filtro, com os formatos de arquivos que serão mostrados. O diálogo pode mostrar apenas arquivos de imagem e salvar com a extensão .png por exemplo.

Um diálogo simples seria:

A variável $arquivo é criada com o nome escolhido, como por exemplo "/home/kurumin/Desktop/teste.txt". O diálogo não vai reclamar caso você tente salvar o arquivo num diretório onde o usuário não têm permissão de escrita. É preciso que o próprio script verifique isso na hora de realmente criar ou modificar o arquivo.

O "*.txt |Arquivos de texto" permite especificar os formatos de arquivo que serão mostrados na janela, e a legenda do filtro. Para mostrar apenas arquivos de imagem, deixando a extensão .png como padrão, você poderia utilizar algo como "*.png *.jpg *.gif *bmp |Arquivos de Imagem".

A opção --getexistingdirectory é mais simples, você só precisa especificar um diretório padrão, como por exemplo:

    $ pasta=`kdialog --getexistingdirectory "/home/kurumin"`

Como no exemplo anterior, a variável $pasta será criada com o diretório escolhido.

Existem ainda três opções diferentes de menus de seleção, criados usando as opções: --menu, --checklist e --combobox

Na opção --menu é mostrado um menu com as opções. onde você só pode escolher uma. Como por exemplo:

    $ operacao=`kdialog --menu "O que você gostaria de fazer?" a "Redimensionar a imagem" b "Girar a imagem" c "Deletar a imagem" d "Converter para outro formato"`

A variável $operacao assume um dos 4 valores possíveis, a, b, c ou d. Você pode usar um case para especificar os comandos referentes a cada uma das opções.

    imagem=`kdialog --getopenfilename "/home/kurumin/" "*.png *.gif *.jpg *.bmp |Arquivos de Imagem"`
    operacao=`kdialog --menu "O que você gostaria de fazer?" a "Redimensionar a imagem" b "Girar a imagem" c "Deletar a imagem" d "Converter para outro formato"`
    case $operacao in
    a) mv $imagem $imagem-OLD;
    tamanho=`kdialog --inputbox "Redimensionar para qual tamanho?" "640x480"`;
    convert -size $tamanho "$imagem"-OLD $imagem ;;
    b) jpegorient +90 $imagem ;;
    c) rm -f $imagem ;;
    d) formato=`kdialog --inputbox "Converter a imagem para qual formato?" ".jpg"`;
    convert $imagem "`echo $imagem | perl -pe 's/\.[^.]+$//'`$formato" ;;
    *) kdialog -- msgbox "Cancelado" ;;
    esac

Este script usa um pouco de cada coisa que já aprendemos, junto com algumas coisas novas. O convert permite realizar várias operações com imagens via linha de comando, ideal para uso em scripts. Ele possui muitas opções, que você pode ver no manual (man convert). Na opção d usei uma função em perl, que copiei do script de um dos servicemenus do Konqueror, o: /usr/share/apps/konqueror/servicemenus/imageconverter.desktop

Lembre-se que a melhor fonte de aprendizado e pesquisa para desenvolver scripts são justamente outros scripts.

A opção --combobox é similar, mas as opções são mostradas dentro de uma caixa de seleção. A sintaxe também muda. Ao invés de especificar as opções, a, b, c, d. etc. você pode especificar diretamente as opções:

    $ operacao=`kdialog --combobox "O que deseja fazer?" "girar" "redimensionar" "deletar" "converter"`

A terceira opção, --checklist permite que seja escolhida mais de uma opção, ideal para fornecer um menu de alternativas que não conflitam entre sí e podem ser escolhidas simultaneamente:

    $ fazer=`kdialog --checklist "O que gostaria de fazer?" 1 "Instalar o programa" off 2 "Ler o manual" on 3 "Ler o Wiki" off`

A variável $fazer vai armazenar uma linha contendo todas as opções selecionadas. Marcando as opções 2 e 3 como no screenshot, ela assume o valor: "2" "3"

Um último exemplo, também útil, é a opção --textbox, que exibe arquivos de texto. Ela é diferente de abrir o arquivo dentro do kedit por exemplo pois não permite editar, apenas ler. Serve como um "extrato para simples conferência".

Você pode usá-lo também para exibir a saída de comandos de modo texto, como por exemplo o ifconfig, que mostra as configurações da rede. Diferente das outras opções do kdialog, você deve especificar também as dimensões da janela:

    ifconfig > /tmp/ifconfig.txt
    kdialog --textbox /tmp/ifconfig.txt 500 320

Controlando aplicativos via DCOP
---------------------------------------------------------------------------------------------------------------------------------------------------------------
Dentro do KDE você pode utilizar mais um recurso interessante, o DCOP. Ele permite que o script envie sinais para os programas gráficos abertos.

Por exemplo, para abrir o kmix e logo em seguida minimizá-lo ao lado do relógio você pode usar o comando:

    $ kmix &
    $ dcop kmix kmix-mainwindow#1 hide

O dcop oferece muitas funções, com o tempo você acaba decorando as mais usadas, mas no início a melhor forma de aprender é ir vendo e testando as opções disponíveis.

Abra o aplicativo que deseja controlar e rode o comando: dcop, sem argumentos. Ele mostrará uma lista dos programas do KDE, que suportam chamadas que estão abertos:

    $ dcop

    kwin
    kicker
    kded
    kmix
    knotify
    kio_uiserver
    kcookiejar
    konsole-16265
    klauncher
    konqueror-21806
    khotkeys
    kopete
    kdesktop
    ksmserver

Veja que alguns aplicativos, como o konqueror e o konsole aparecem com números ao lado. Estes são os aplicativos que podem ser abertos várias vezes, os números servem para identificar cada instância.

Usar funções do dcop para eles é um pouco mais complicado, pois cada vez que são abertos usam um número diferente. Nestes casos uso um "filtro" para obter o nome da primeira instância, seja qual for o número de identificação e colocá-lo numa variável que posso usar depois:

    konqueror-dcop=`dcop | grep konqueror | head -n 1`

Executando o comando dentro do script, acabo com o valor "konqueror-21806", a identificação do konqueror atual carregada dentro da variável.

Para ver uma lista das opções disponíveis para o aplicativo, rode o comando dcop seguido do aplicativo, como em:

    $ dcop $konqueror-dcop

    qt
    KBookmarkManager-/home/kurumin/.kde/share/apps/konqueror/bookmarks.xml
    KBookmarkNotifier
    KDebug
    KIO::Scheduler
    KonqFavIconMgr
    KonqHistoryManager
    KonqUndoManager
    KonquerorIface (default)
    MainApplication-Interface
    html-widget1
    html-widget2
    html-widget3
    konqueror-mainwindow#1
    ksycoca

Cada uma destas opções possui uma lista de funções. Por exemplo, a opção konqueror-mainwindow#1 controla a janela principal do konqueror. Para ver as funções relacionadas a ela, rode um:

    $ dcop $konqueror-dcop konqueror-mainwindow#1

Este comando retorna uma longa lista de opções. Você pode fazer de tudo, desde esconder a janela até mudar a fonte, título, página exibida ou ícone na barra de tarefas. Algumas opções básicas são:

    $ dcop $konquerordcop konqueror-mainwindow#1 maximize
    $ dcop $konquerordcop konqueror-mainwindow#1 minimize
    $ dcop $konquerordcop konqueror-mainwindow#1 hide
    $ dcop $konquerordcop konqueror-mainwindow#1 reload
    $ dcop $konquerordcop konqueror-mainwindow#1 show

Este exemplo parece complicado, mas a maioria dos aplicativos suporta a opção "default" que permite que você vá direto à função desejada. Por exemplo, para fazer o kmail aberto baixar novas mensagens use o comando:

    $ dcop kmail default checkMail

fonte: Carlos E. Morimoto
obs: dps ajeito as imaggens

[Anonymous]

Morimoto é muito bom mesmo.

[bloodrain]

e olha que essa es soh a 1 parte sao 3

[Anonymous]

Muito bom brother.
Parabéns

[Anonymous]

Muito bom cara!!!

[bloodrain]

qual eh  respectiva area dele progeamaçao?

[Anonymous]

Hehehe, creio que Programação, sub-fórum Shell Script.

[bloodrain]

desculpa o flood mas eh que nao tinha visto esse subforum la nao 

[rodweb]

ótimo post

[Anonymous]

kra, mto show² huhuhu

linux rulez³

[Anonymous]

Outra vez eu postando,hehe,a parte 1 como ja disse esta bom,mais kd a parte 2??demorando neh,hehe

bye...