Configurando sistema de LVM ( Logical Managing Volumes).

Configurando sistema de LVM ( Logical Managing Volumes).

Considera??es inicicais

Sistema Operacional: Debian Gnu/Linux (Woody) 3.0 R2
Kernel: 2.4.28
M?dulos do Kernel utilizados: lvm-mod, md e linear
Hardware utilizado para o LVM: 4 discos rig?dos de 80 GB – Ultra-ATA modelo Seagate Barracuda.
Disponibilidade das parti??es de disco no sistema:

Disco 1:
/dev/hda1 /boot
/dev/hda2 /swap
/dev/hda3 /
/dev/hda4 LVM

Disco 2:
/dev/hdb1 LVM

Disco3:
/dev/hdc1 LVM

Disco4:
/dev/hdd1 LVM

Agora estaremos dividindo em etapas todos processos para cria??o da LVM.

1) Preparando o sistema operacional para LVM.

Todos os m?dulos necess?rios para cria??o de um sistema de LVM, j? se encontram no Kernel do Gnu/Linux.
Na distribui??o Debian Gnu/Linux podemos manipular estes m?dulos atrav?s de um aplicativo chamado modconf, com ele iremos instalar os m?dulos necess?rios para que nosso projeto de continuidade, para isso entre no terminal e digite:

#modconf

Entre na sess?o kernel/drivers/md
selecione lvm-mod e pressione quatro vezes a tecla “Return” para poder instalar os m?dulos, siga este mesmo exemplo e instale os m?dulos md e linear que ficam na mesma sess?o.

Os pacotes necess?rios para o projeto de cria??o do LVM ser?o o lvm10 e lvm-common, para isso usaremos o aplicativo Apt-Get para instalar os pacotes:
#apt-get install lvm10 e lvm-common

Caso voc? n?o encontre alguns dos pacotes mencionados acima, adicione em seu /etc/apt/sources.list o Mirror:

deb http://mirrors.kernel.org/debian/ stable main
deb-src http://mirrors.kernel.org/debian/ stable main

e depois use o apt-get update para atualizar o banco de dados do Apt.

2) Particionando os discos no sistema

Levando em considera??o o aspecto de hardware mostrado no in?cio deste artigo, iremos trabalhar com as parti??es que deveram ser configuradas para LVM, ou seja: /dev/hda4, /dev/hdb1, /dev/hdc1 e /dev/hdd1.

Para isso usaremos o aplicativo fdisk para particionar os discos, entre no terminal e digite

#fdisk /dev/hda
digite “n” para nova parti??o, na sequ?ncia digite “p” para parti??o prim?ria e “4” para o partition number (n?mero da parti??o).
Agora devemos mudar o tipo de parti??o que criamos, para isso ainda no fdisk digite “t” depois “4” para o partition number, ser? solicitado o Hex code ( c?digo hexa), para isso digite “8e” que refere-se ao id da parti??o LVM.
Para gravar todas as altera??es no disco devemos ent?o digitar “w” e depois “q” para sair.

Seguiremos o exemplo para particionamento dos outros discos, levando em considera??o a mudan?a do partition number nos discos.

3) Criando os grupos fis?cos para o LVM:

Agora que j? particionamos nossos discos, iremos agrupar as parti??es fis?cas de nosso LVM, para isso usaremos o aplicativo pvcreate:

#pvcreate /dev/hda4 /dev/hdb1
#pvcreate /dev/hdc1 /dev/hdd1

4) Criando os volumes para o LVM

Tendo os discos j? agrupados, agora iremos criar os volumes dos grupos, para isso usaremos o comando vgcreate

#vgcreate lvm_ab /dev/hda4 /dev/hdb1
#vgcreate lvm_cd /dev/hdc1 /dev/hdd1
Os nomes “lvm_ab” e “lvm_cd” respectivamente podem ser alterados para os de sua escolha, neste caso optei por identificar os volumes pelas associa??es dos dispositivos agrupados com seus id’s do tipo: HDA e HDB com isso o nome “lvm_ab” .

4) Verificando informa??es sobre os volumes criados:

Temos agora que verificar a disponibilidade do tamanho m?ximo para o LVM, para isso usaremos o comando vgdisplay

#vgdisplay

*procure pela linha VG Size, nela est? descrito o tamanho m?ximo a ser usador para os volumes, em nosso exemplo a sa?da do comando ficaria:

VG Size 152.01 GB

5) Criando os volumes l?gicos:

Agora que j? verificamos a disponibilidade m?xima dos volumes, iremos criar os volumes l?gicos seguindo o valor do VG Size:

#lvcreate -L150G -nvol1 lvm_ab
#lvcreate -L150G -nvol1 lvm_cd

Explicando as flags do lvcreate:
-L: tamanho do volume l?gico
-n: nome para o volume

6) Criando o sistema de arquivos no volume criados

Agora que j? temos um volume l?gico criado, devemos formatar os mesmos, no meu caso resolvi usar o File System EXT3.

Para formatar para EXT3 usaremos o aplicativo Mke2fs, para isso entre no terminal e digite
#mke2fs -j -b 4096 /dev/lvm_ab/vol1
#mke2fs -j -b 4096 /dev/lvm_cd/vol1

Explicando as flags do mke2fs:
-j : Cria o file system usando o EXT3 como padr?o.
-b: “Block Size” tamanho do bloco

7) Disponibilizando os volumes na inicializa??o do sistema.

Para disponibilizarmos os volumes na inicializa??o do sistema devemos informar no arquivo /etc/fstab os volumes LVM.

Antes de editar o arquivo crie os pontos de montagem para os volumes, em meu exemplo usarei:

mkdir -p /mnt/LVM/lvm_ab ; mkdir -p /mnt/LVM/lvm_cd
na sequ?ncia, fa?a um backup do arquivo /etc/fstab como seguran?a e depois edite com o arquivo usando seu editor preferido:

#vi /etc/fstab

*adicione as linhas:

/dev/lvm_ab/vol1 /mnt/LVM/lvm_ab ext3 defaults 0 1
/dev/lvm_cd/vol1 /mnt/LVM/lvm_cd ext3 defaults 0 1

Tendo executado todos os passos com sucesso seu sistema de LVM estar? pronta para produ??o.

Mais informa??es sobre LVM podem ser encontradas em:

http://fsbox.org/
http://www.freelinuxcdrom.com/LDP/HOWTO/LVM-HOWTO/initscriptdebian.html
http://elibrary.fultus.com/technical/index.jsp?topic=/com.fultus.linux.howtos/howtos/LVM-HOWTO/cover.html

Qualquer d?vida entrem em contato: jaccon@gmail.com

At? a pr?xima.

Posted in Sem categoria

Erro de login "System Boot in progress – please wait "

Caso voc? um dia tenha este problema voc? entra com a senha do usu?rio comun e o sistema pede para aguardar alguns minutos e depois diz que o tempo para login este esgotado, verifique se exite um arquivo chamado

/etc/nologin e /etc/nologin.boot, caso tenha remova os dois arquivos.

Desta forma voc? poder? logar normalmente.

Erro de login “System Boot in progress – please wait “

Caso voc? um dia tenha este problema voc? entra com a senha do usu?rio comun e o sistema pede para aguardar alguns minutos e depois diz que o tempo para login este esgotado, verifique se exite um arquivo chamado

/etc/nologin e /etc/nologin.boot, caso tenha remova os dois arquivos.

Desta forma voc? poder? logar normalmente.

Posted in Sem categoria

Verificando processo pendentes de volumes montados

As vezes temos problemas para desmontar um disposito, que um umount n?o resolve.
Exemplo pr?tico disto ? quando montamos um volume de um servidor NFS por problemas o volume ca? ficando o disco montado na m?quina.

Para identificar os processos em andamento deste volume montado use o comando FUSER.

ex:

#fuser -mv /mnt/NFS

a sa?da deste comando seria algo como

USER PID COMMAND
/mnt/NFS eu 193 mount.nfs

Posted in Sem categoria

Trocando o Tema do GDM por um escolhido aleatoriamente

Colabora??o: Ederson Leme Corr?a

Quem n?o gosta de um desktop bonito ?

Bom, eu pelo menos gosto. Acho que d? mais ?nimo pra ficar
horas em frente ao micro. E nessa minha busca por tornar meu
desktop mais atraente aos olhos, acabei por encontrar v?rios
temas para o GDM (Gerenciador de Login para o Gnome) e como
um bom indeciso que sou, fiquei na d?vida de qual usar.

Ent?o pensei: Por qu? n?o usar todos ?

Mas ficar trocando manualmente ? muito chato e
“trabalhoso”, ent?o ap?s algumas consultas ao Or?culo
(http://www.google.com.br), acabei por encontrar um script que
ap?s pequenas altera??es ficou perfeito para o meu prop?sito.

Chega de papo, e vamos ao que interessa: O script:

#!/bin/bash
#
# Description: This script modifies the GDM theme for other randomly chosen.
# Description: Based in script posted by va7dav in http://gnome-hacks.jodrell.net/hacks.html?id=17
#
# Autor: Ederson L. Correa
# Date: 04 November 2004
# File: /etc/rc.d/rc.gdmrandom
# Last update: 04/11/2004
#

THEME_DIR=/usr/share/gdm/themes
THEMES=`ls -1 “$THEME_DIR”`
N=`echo $THEMES | wc -w`
((N=RANDOM%N+1))

# The -i.old option creates a backup copy called
# gdm.conf.old
sed -i.old s/GraphicalTheme=.*/GraphicalTheme=`echo $THEMES | cut -d ‘ ‘ -f $N`/ /etc/X11/gdm/gdm.conf

O que esse script faz ? escolher “aleatoriamente” um dentre os
temas disponiveis no diret?rio configurado em THEME_DIR. Assim,
cada vez que esse script for executado (como root) o tema do
GDM ser? trocado.

Voc? pode colocar esse script para rodar no cron de tempos em
tempos, ou na hora do boot, ou na hora do reboot, ou a cada
vez que voc? deslogar ou logar numa sess?o gr?fica. Isso fica
a gosto do fregu?s.

No meu caso, como eu ligo o PC de manh? e este permanece ligado
e logado o dia todo, preferi colocar esse script para rodar no
boot, assim, todo dia tenho uma tela de login diferente … 😀

Para isso fiz o seguinte no meu Slack:

1. Criei um arquivo chamado /etc/rc.d/rc.gdmrandom com o conte?do do script acima.
2. Tornei execut?vel: chmod +x /etc/rc.d/rc.gdmrandom
3. Acrescentei as seguintes linhas ao /etc/rc.d/rc.local:

# Pequeno Script que troca o tema do GDM aleatoriamente
if [ -x /etc/rc.d/rc.gdmrandom ]; then
echo “Changing the GDM Theme for a random one: “
. /etc/rc.d/rc.gdmrandom
fi

Assim, quando eu quiser desabilitar a mudan?a dos temas basta
eu retirar a permiss?o de execu??o do rc.gdmrandom.

Voc? pode adaptar isso para a sua distro.

Pra finalizar queria indicar alguns temas que eu achei muito
legais.

Baseados em Animes
==================

– Rurouni Kenshin (http://themes.freshmeat.net/projects/samuraix-gdmtheme/)
– Blue Rei GDM (http://themes.freshmeat.net/projects/bluereigdm/)
– I am not a doll (http://themes.freshmeat.net/projects/notadoll/)
– Dita and Hibiki from Vandread (http://themes.freshmeat.net/projects/ditaandhibiki/)
– Dita (http://themes.freshmeat.net/projects/dita/)
– Super Vandread (http://themes.freshmeat.net/projects/vandread/)
– Magna Carta GDM (http://www.gnome-look.org/content/show.php?content=13563)
– GDM Gartoon theme (http://www.gnome-look.org/content/show.php?content=13510)

Baseados em Filmes
==================

– [Fly Spider (http://www.gnome-look.org/content/show.php?content=17386]
– [Octopus GDM (http://www.gnome-look.org/content/show.php?content=13451]
– [The Matrix Reloaded (http://www.gnome-look.org/content/show.php?content=13381]
– [Matrix Reloaded GDM Theme (http://themes.freshmeat.net/projects/matrix_gdm/]
– [The Two Towers (http://themes.freshmeat.net/projects/thetwotowers/]

Diversos
========

– [SamothAngel GDM (http://themes.freshmeat.net/projects/angelgdmtheme/]
– [Shogun (http://themes.freshmeat.net/projects/shogun/]
– [Penguin Computing (http://art.gnome.org/themes/gdm_greeter/272/]
– [Angel (http://art.gnome.org/themes/gdm_greeter/89/]

Bom, voc?s tamb?m podem achar muito outros temas em:

– [GNOME-Look.org (http://www.gnome-look.org/index.php?xcontentmode=150]
– [art.gnome.org (http://art.gnome.org/themes/gdm_greeter/]
– [freshmeat.net (http://themes.freshmeat.net/browse/991/]

——————————————————————–
Colabore com a Dicas-L. Publique seu coment?rio sobre esta mensagem
em http://www.Dicas-L.unicamp.br/dicas-l/20041124.php
——————————————————————–
As mensagens da lista Dicas-L s?o veiculadas diariamente
para 26010 assinantes.

Todas as mensagens da Dicas-L ficam armazenadas em
http://www.Dicas-L.unicamp.br/dicas-l/

A redistribui??o desta e outras mensagens da lista Dicas-L pode
ser feita livremente, desde que o conte?do, inclusive esta nota,
n?o sejam modificados.
——————————————————————–

Posted in Sem categoria

Tutorial de Shell Script

.———————————-.
| Programa??o em Bourne-Again Shell `————————————,
| Por MELEU http://meleu.da.ru 05/2002 |
`————————————————————————‘

– = < ? N D I C E > = –

0. Intro

1. Come?ando

2. Vari?veis e Par?metros
2.1. Vari?veis do Usu?rio
2.1.1. Vari?veis Array
2.2. Vari?veis do Shell
2.3. Vari?veis Somente-Leitura
2.4. Par?metros
2.4.1. shift
2.4.2. set (para editar par?metros)
2.5. Substitui??o de Vari?veis

3. Entrada e Sa?da (I/O)
3.1. echo
3.1.1 Sequ?ncias de Escape ANSI
3.2. read
3.3. Redirecionamento
3.3.1. Pipe
3.3.1.1. Comandos ?teis com o Pipe

4. Comandos de Tomadas de Decis?o
4.1. if-then-else e afins
4.1.1. test
4.1.2. let
4.2. case
4.3. Tomadas de decis?o com && e ||
4.3.1. Listas

5. Comandos de Loop
5.1. for
5.1.1 “for” como na linguagem C
5.2. while
5.3. until
5.4. break e continue
5.5. Redirecionando loops

6. Fun??es
6.1 Fun??es como comandos

7. Tornando seu Script Amig?vel
7.1. getopts
7.2. select
7.3. dialog

8. Coisas ?teis de se aprender

9. Exemplos Variados
9.1. backup.sh
9.2. howto.sh
9.3. todo.sh
9.4. inseretxt.sh
9.5. Mextract.sh

10. Refer?ncias

11. Considera??es Finais

————————————————————————–

0. Intro
*****

***** PRIMEIRO DE TUDO **************************************************
* *
* Esta ? a primeira vers?o do texto e ele est? relativamente grande *
* para que um ?nico mortal revise-o por inteiro, com o agravante de que *
* este mortal ? um vestibulando. Por favor, se voc? achar algum erro, *
* algo mal explicado, ou tem alguma sugest?o para que o texto fique *
* melhor mande-me um email: meleu@meleu.cjb.net *
* Quando eu tiver tempo eu acrescentarei mais coisas… *
* *
*************************************************************************

Well… aqui estamos de volta… Dessa vez o assunto ? shell script…
Estou partindo do princ?pio de que ningu?m aqui tem d?vidas quanto a
utilidade de um shell script. Roubando uma cita??o de um amigo:

“Em alguns casos, uma rede pode nao possuir um compilador
(Vide Conectiva 5.0), logo, voce precisa se virar com o que tem,
e os Shell Scripts podem suprir a sua necessidade em muitos casos.”

Eu j? procurei um bocado de material sobre shell script em portugu?s na
net e encontrei v?rios. Por?m a maioria sobre Korn Shell, C Shell, poucos
eram sobre bash. E os de bash eram muito superficiais. Explicavam s? o
come?o de como criar seus shellscripts. Ent?o o que eu pretendo aqui ?
entrar no assunto desde o in?cio e com alguns detalhes (talvez n?o
muitos). Note tamb?m que muitas coisas explicadas aqui podem ser usadas em
outros shells.
Minhas fontes de pesquisa ser?o muito ?teis para voc?, que ? um newbie
dedicado. Portanto consulte a se??o de refer?ncias que voc? vai achar
muita coisa boa.

O ?nico pr?-requisito para o entendimento deste texto ? que o leitor
tenha alguma familiaridade com os comandos UNIX. Uma no??ozinha de
programa??o (algoritmos) cairia bem. Se voc? n?o tem (ou acha que n?o
tem) o pr?-requisito acima citado, voc? pode adquir?-lo lendo o focalinux
, ele ? um bom material em portugu?s sobre os
comandos, uso, configura??o, etc. do GNU/Linux. Leitura recomendada!

Se voc? sabe usar Express?es Regulares fica melhor ainda! Se n?o sabe
aprenda a usar! Veja um guia sobre esse assunto na se??o de refer?ncias.

? de extrema import?ncia que voc? v? praticando assim que aprender
algo novo, isso ajuda a se familiarizar e memorizar as coisas.

Por favor, n?o pense que sou um expert ou um guru em shell scripting!
Eu s? estava aprendendo e resolvi escrever isso pra ajudar quem tamb?m
est? afim de aprender.
N?o se esque?a: O aprendizado ? eterno! 😉

A maioria dos scripts chamam programas existentes no sistema, n?o
ficarei explicando o que faz cada comando. Se voc? quer saber o que ele
faz, sua sintaxe e etc. procure na p?gina man. Se voc? tiver alguma
d?vida sobre o bash use: “help” ou “man bash”. A manpage ? bastante
completa (e grande tamb?m)! Use-a como refer?ncia.

Para sua comodidade eu coloquei os c?digos entre as tags do Phrack
Extraction Utility. Voc? pode encontr?-lo na ?ltima edi??o da phrack em
. Eu fiz um script em bash para extra??o dos
c?digos baseado no Phrack Extraction Utility, chama-se Meleu Extraction
Utility (hehehe… qualquer semelhan?a N?O ? mera coincid?ncia). Ele se
encontra no t?pico “9.5. Mextract.sh” e tamb?m em
.
O esquema de organiza??o ? o seguinte: exemplos bestas ficam no
diret?rio “BashScript/” os exemplos bacanas ficam no diret?rio
“BashScript/bacanas/”.

* Aten??o na vers?o em que eu fiz os meus testes, pois em vers?es antigas
algumas coisas podem n?o funcionar (este e ? o que vem na instala??o do
Slackware 8.0):

/* -=-=-=-=-= version =-=-=-=-=- */
meleu@meleu:~$ bash –version
GNU bash, version 2.05.0(1)-release (i386-slackware-linux-gnu)
Copyright 2000 Free Software Foundation, Inc.
/* -=-=-=-=-= version =-=-=-=-=- */

Agradecimentos: A todos que fazem um esforcinho para publicar informa??es
de qualidade em portugu?s.
Especialmente para meus amiguinhos(as): lucipher, klogd, module, eSc2,
xf, Emmanuele, Mana_Laura, NashLeon, Hekodangews, Blind_Bard, clausen,
Renato , hts, EvilLord, aur?lio (assim como eu
tamb?m ? um dinossauro-amante-do-modo-texto), ?s pessoas que levam a
Unsekurity Scene a s?rio, aos camaradas
da EoH Team , e outros pessoas que eu posso n?o me
lembrar agora mas que tamb?m s?o meus camaradas. ? l?gico que tamb?m devo
agradecimentos a toda a comunidade Open Source, sem a qual tudo isso aqui
n?o existiria! Amo voc?s! =D

LICENSA: N?o quero nenhuma exclusividade! Quero ? informa??o fluindo!
Pegue este texto e espalhe em todo lugar em que ele for bem-vindo.
Se quiser extrair trechos dele e puder fazer o favor de citar de onde
foi extra?do, eu me sentiria agradecido.

————————————————————————–

1. Come?ando
*********

Como voc? j? deve saber, um shell script ? um arquivo em formato texto
puro que cont?m comandos/instru??es para serem executados em uma
determinada shell. O que vou tentar passar neste texto ? como fazer shell
script para o Bourne-Again Shell, ou bash. Esta ? uma linguagem
interpretada (voc? n?o precisa compilar para ter o execut?vel) e o bash ?
o interpretador.
Veja um exemplo de script:

/* ————— */
< ++> BashScript/primeiroexemplo.sh
#!/bin/bash
echo ‘Alo mam?e!’
echo
echo ‘Agora executarei um simples “ls -l”, veja: ‘
echo
ls -l
< -->
/* ————— */

Para que se possa executar um shell script ? necess?rio permiss?o de
execu??o (mais sobre permiss?es em http://meleu.da.ru/index.html#textos ).
Para que somente voc? (dono do arquivo) tenha permiss?o de execu??o
para o primeiroexemplo.sh voc? faz:

$ chmod u+x primeiroexemplo.sh

Agora voc? pode executar o script da seguinte forma:

$ ./primeiroexemplo.sh

Veja outro exemplo de apenas um comando:

/* —————– */
< ++> BashScript/procura_suid.sh
#!/bin/bash
# script para procurar arquivos suid
# que perten?am a determinado usu?rio
find / -user $1 -perm -4000 2> /dev/null
< -->
/* —————– */

Agora vamos a uma r?pida explica??o sobre o c?digo…
– Na primeira linha n?s dizemos qual ser? o nosso intrepretador de
comandos (o shell). Voc? deve come?ar a linha com um “#!” (conhecido como
sha-bang) e depois o caminho inteiro para o bash.
– Nas segunda e terceira linhas s?o usados coment?rios, todo
coment?rio come?a com uma cerquilha (#) e vai at? o final da linha;
– A ?ltima linha que ? realmente o comando, o $1 significa o primeiro
par?metro dado na linha de comando (ser? falado mais sobre isso daqui
a pouco), por exemplo:

$ ./procura_suid.sh level5

ir? procurar por todos os arquivos suid que perten?am ao usu?rio level5.
Como voc? deve ter reparado, esse shell script ? ?til nos wargames (veja
10. Refer?ncias), mas tem que ser muito pregui?oso pra fazer um shell
script de um comando s?! 😛

De vez em quando ? bom observar o que o script est? fazendo. Para isso
voc? pode usar alguns par?metros junto com o shell para executar seu
script. Veja:

/* -=-=-=-=-=-= debugar =-=-=-=-=-=- */
$ bash -x BashScript/primeiroexemplo.sh
+ echo ‘Alo mam?e!’
Alo mam?e!
+ echo

+ echo ‘Agora executarei um simples “ls -l”, veja: ‘
Agora executarei um simples “ls -l”, veja:
+ echo

+ ls -l
total 12
drwxr-xr-x 5 meleu users 4096 Aug 18 15:28 GNUstep
drwxr-xr-x 2 meleu users 4096 Aug 19 23:11 progs
drwxr-xr-x 2 meleu users 4096 Aug 19 22:57 txts
/* -=-=-=-=-=-= debugar =-=-=-=-=-=- */

O par?metro “-x” faz com que seja exibido o comando e depois a sa?da do
comando.
Outros par?metros interessantes para a “debuaga??o” do script s?o:

-n n?o executa os comandos, apenas verifica
erros de sintaxe (noexec);
-v mostra o script e depois executa-o
(verbose);

Outra coisa que devemos saber ? que quando um shell script ? executado
ele usa OUTRA SHELL e N?O USA A SHELL ATUAL. Desculpem eu estar berrando
deste jeito… 😛 mas ? importante termos isso em mente quando formos usar
vari?veis.

Falando em vari?veis…

————————————————————————–

2. Vari?veis e Par?metros
**********************

Ao contr?rio das outras linguagens, o bash n?o possui “tipos de dados”,
todas as vari?veis s?o strings. O bash usa strings para representar todos
os dados que ser?o usados pelas vari?veis. A seguir falaremos sobre os
*tipos de vari?veis* (e n?o “tipos de dados”).
Se voc? conhece alguma outra linguagem de programa??o sabe que os
identificadores possuem algumas regras quanto a sua nomeclatura. Pois no
bash as regras s?o parecid?ssimas:

* S? se pode usar caracteres alfanum?ricos e underline;
* S? se pode come?ar com letra ou underline (n?mero n?o pode);
* N?o pode conter espa?os em branco;
E uma coisa que n?s, falantes da l?ngua portuguesa temos que saber ?:
* Os identificadores N?O podem conter acentos!

enfim… todas aquelas regrinhas para identificadores de linguagens de
programa??o tamb?m se aplica aqui, exceto aquela famosa sobre palavras
reservadas. Voc? pode por exemplo fazer “if=lalala” que funcionar?
perfeitamente. A ?nica coisa que n?o pode ? usar um nome que j? tenha sido
definido para uma outra vari?vel e que esta seja “readonly” (mais sobre
isso adiante). Tamb?m deve-se tomar cuidado para n?o fazer bobagens com
as vari?veis do shell (explicados no t?pico 2.2.).

2.1. Vari?veis do Usu?rio
====================

As vari?veis do usu?rio s?o as vari?veis que voc? pode declarar, ler,
inicializar e modificar. No exemplo abaixo n?s criamos uma vari?vel
chamada “nome” e atribu?mos a ela o valor “Meleu”. Veja:

$ nome=Meleu

N?o pode haver espa?os nem antes nem depois do sinal de ‘=’! Se voc?
quiser atribuir um valor que contenha espa?os ? necess?rio usar as
‘aspas simples’.
Veja:

$ nome=’Meleu nao eh meleca!’

Agora para usar a vari?vel ? s? voc? colocar um cifr?o ‘$’ antes do
nome dela. Olhe um exemplo com e sem o ‘$’:

$ echo nome
nome
$ echo $nome
Meleu n?o eh meleca!

Existe diferen?a entre usar ‘aspas simples’, “aspas duplas”, `crases` e
n?o usar nada.
Veja isto:

/* -=-=-=-=-= exemplos =-=-=-=-=- */
$ caminho=’O meu path eh: $PATH’
$ echo $caminho
O meu path eh: $PATH

$ caminho=”O meu path eh: $PATH”
$ echo $caminho
O meu path eh: /usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/usr/openwin/bin

$ teste=`ls $HOME`
$ echo $teste
GNUstep/ progs/ textos/

$ conteudo_dir=”Meu diretorio home contem: `ls $HOME`”
$ echo $conteudo_dir
Meu diretorio home contem: GNUstep/ progs/ textos/

$ teste=isso nao eh valido
bash: nao: command not found

$ teste=mas_isso_eh_valido
$ echo $teste
mas_isso_eh_valido

/* -=-=-=-=-= exemplos =-=-=-=-=- */

Os mais espertos j? perceberam as diferen?as… mas para os mais
lerdinhos (como eu) a? vai uma explica??o.

+ ‘aspas simples’: atribuem ? vari?vel EXATAMENTE o que est? entre elas;

+ `crases`: atribuem ? vari?vel a *sa?da do comando* que est? entre elas,
tem a capacidade de ver o conte?do de uma vari?vel
(no exemplo acima, a vari?vel de ambiente $HOME);

+ “aspas duplas”: atribuem ? vari?vel a string, o valor das vari?veis que
porventura podem estar entre elas (no segundo exemplo, a
vari?vel de ambiente $PATH), e tamb?m a sa?da de comandos
que estejam entre `crases`;

+ nada: similar as aspas duplas, por?m ignora espa?os excedentes.

Podemos usar $(cifr?o-par?nteses) no lugar das crases. Em alguns casos
? melhor usar $(cifr?o-par?nteses) mas eu n?o vou falar em quais, voc?
vai descobrir quando. 😉
Veja estes exemplo:

/* -=-=-= exemplo =-=-=- */
$ dir_atual=$(pwd)
$ echo $dir_atual
/home/meleu

$ echo $(ls $HOME)
GNUstep/ progs/ textos/

$ tar czvf backup_$(date +%d-%m-%Y).tgz arquivo
/* -=-=-= exemplo =-=-=- */

Outra coisa interessante ? o uso das {chaves}. Voc? pode usar as chaves
para exibir uma vari?vel (ex.: echo ${teste}), isso ? ?til quando voc?
precisa separar a vari?vel do que vem depois dela. Veja isto:

/* -=-=-=-=-= exemplo =-=-=-=-=- */
$ name=coracao
$ echo ${name}deleao
coracaodeleao
/* -=-=-=-=-= exemplo =-=-=-=-=- */

Como eu disse anteriormente, quando executamos um shell script ele usa
outro shell, portanto toda vari?vel que for criada/inicializada num shell
script perder? seu valor no final da execu??o do mesmo. No entanto, voc?
pode fazer um shell script usar vari?veis de usu?rio exportando-a
com o comando “export” (ver man page do bash). Um exemplo simples:

/* -=-=-=-=-= exemplo =-=-=-=-=- */
$ cat teste.sh
#!/bin/bash

echo “$VAR”

$ export VAR=’Um abraco para os gajos de Portugal! :)’
$ ./teste.sh
Um abraco para os gajos de Portugal! 🙂
$ export VAR=’–> mudei a variavel < --'
$ ./teste.sh
–> mudei a variavel < --
/* -=-=-=-=-= exemplo =-=-=-=-=- */

2.1.1. Vari?veis Array
—————

Tamb?m conhecidas como vetores. Este tipo de vari?vel serve para se
armazenar v?rios valores sob um nome e um ?ndice. A maneira de declarar
vari?veis array ? a seguinte:

NomeDaVariavel[Indice]=Valor

sendo que Indice deve ser necessariamente um valor inteiro.

Imaginemos que EvilLord queira armazenar uma lista de suas frutas
favoritas em uma vari?vel array. Para isso ele faria o seguinte:

/* -=-=-= exemplo =-=-=- */
$ FRUTA[0]=goiaba
$ FRUTA[1]=manga
$ FRUTA[2]=pera
$ FRUTA[3]=laranja
/* -=-=-= exemplo =-=-=- */

Supondo que ele colocou esta lista em ordem decrescente de gosto, para
sabermos qual ? a sua fruta favorita basta digitarmos:

$ echo ${FRUTA[0]}

Bacana n?o acham?

Agora vejamos uma coisa interessante. Se eu declarar uma frut… ops!
digo, se eu declarar uma vari?vel assim:

$ FRUTA=goiaba

e depois quiser fazer um array com o nome FRUTA eu posso fazer assim:

$ FRUTA[1]=manga

Desta maneira ‘goiaba’ passa a ser armazenada em FRUTA[0]

Outra coisa interessante ? que podemos declarar um array inteiro numa
?nica linha de comando. Para isto usamos a sintaxe:

NomeDoArray=(valor1 valor2 … valorn)

Desta maneira o EvilLord economizaria teclado (?!) digitando isto:

$ FRUTA=(goiaba manga pera laranja)

E para vermos toda a lista de uma vez s?, podemos usar o seguinte comando:

$ echo ${FRUTA[*]}

Existem v?rias outras especifica??es para arrays mas quero passar aqui
s? o b?sico. E se voc? precisar usar arrays de maneira mais complexa que
isso: v? procurar a documenta??o oficial do bash! 😛

2.2. Vari?veis do Shell
==================

Existem vari?veis que o shell usa constantemente para um melhor
funcionamento. O pr?prio shell inicializa algumas destas vari?veis, que
podem ser lidas e alteradas pelo usu?rio, estas s?o conhecidas como
vari?veis do shell. Servem para determinar qual ? o seu diret?rio home, em
qual diret?rio o shell vai procurar por comandos que voc? digitar, seu
prompt… enfim… um bocado de coisas. Voc? pode atribuir novos valores
para estas vari?veis (uma boa ? fazer isso no seu ~/.bashrc ou
~/.bash_profile).

Vamos ver algumas destas vari?veis mais importantes e suas respectivas
fun??es.

–> HOME

Esta vari?vel tem um nome bem descritivo n?o acham? Bem… como n?s j?
sabemos, o nosso diret?rio home ? o diret?rio em que “ca?mos” assim que
nos logamos (sabemos tamb?m que esta informa??o se encontra em
/etc/passwd). Quando voc? se loga no sistema o bash pega o nome do
diret?rio que voc? est? e o atribui ? vari?vel HOME.
Voc? j? deve ter percebido que quando voc? d? um “cd” sem nenhum
argumento voc? vai para o seu diret?rio home. Pois o que o cd faz ? o
mesmo que “cd $HOME”. Se voc? alterar o valor de HOME, quando voc?
digitar cd sem nenhum argumento o bash vai tentar te levar para o $HOME.
Veja:

/* -=-=-=-=-= exemplo =-=-=-=-=- */
meleu:/usr/doc$ echo $HOME
/home/meleu
meleu:/usr/doc$ cd
meleu:~$ pwd
/home/meleu
meleu:~$ HOME=/tmp
meleu:/home/meleu$ cd
meleu:~$ pwd
/tmp
meleu:~$ HOME=lalala
meleu:/tmp$ cd
bash: cd: lalala: No such file or directory
/* -=-=-=-=-= exemplo =-=-=-=-=- */

Voc? tamb?m j? deve ter reparado que quando estamos no nosso home
aparece um til (~) logo antes do prompt. Observe este detalhe no exemplo
acima. 😉

–> PATH

Esta vari?vel armazena o caminho (path) que o shell ir? percorrer para
procurar um comando digitado pelo usu?rio. Exemplo:

/* -=-=-= exemplo =-=-=- */
meleu@meleu:/tmp$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/usr/games:/usr/share/texmf/bin
/* -=-=-= exemplo =-=-=- */

Portanto se eu digitar um “ls” o shell ir? procurar pelo “ls” em
/usr/local/bin depois em /usr/bin e da? em diante.
Esta vari?vel algumas vezes nos ? ?til no hacking! 🙂 Imagine que um
programador inexperiente tenha feito um programa suid que usa a fun??o
system() (ou qualquer outra fun??o que sirva para executar um comando
externo), e nesta fun??o ele n?o usa o caminho completo do programa, e
sim apenas o nome do programa, supondo que o programa est? no seu PATH
normal. Voc? pode alterar o PATH e executar um outro programa de sua
prefer?ncia.
Vamos supor que o cara use:

system (“date”);

no lugar de:

system(“/bin/date”);

A? voc? faz um programa ou um shell script e nomeia ele como “date”.
Agora ? s? alterar o PATH para que procure primeiro no diret?rio onde
voc? salvou o SEU date, e ent?o executar o programa suid feito pelo
incompetente programador. Fa?a uns testes a? que voc? vai me
entender melhor.
Esta situa??o ? bem dif?cil de se encontrar hoje em dia, resolvi
colocar aqui por quest?es hist?ricas. 😛

–> PS1

Esta ? a “Prompt String 1” ou “Primary Prompt String”. Nada mais ? do
que o prompt que nos mostra que o shell est? esperando um comando. Quando
voc? muda PS1 voc? muda a aparencia do prompt. Na minha m?quina o padr?o ?
‘\u@\h:\w\$ ‘ onde \u significa o nome do usuario, \h significa o nome do
host e \w ? o diret?rio atual, o que d? a seguinte apar?ncia:

meleu@meleu:/usr/doc/Linux-HOWTOs$

Veja algumas possibilidades (na man page do bash tem mais):

\d mostra a data atual
\h mostra o hostname
\s o nome do shell
\t a hora atual (no estilo 24 horas)
\T a hora atual (no estilo 12 horas)
\u nome do usu?rio que est? usando o shell
\w nome do diret?rio atual (caminho todo)
\W nome do diret?rio atual (somente o nome do diret?rio)

Se voc? estiver afim de ter a impress?o de que est? no shell do root
basta trocar o ‘$’ por ‘#’ (bah! que bobagem! 😛 ).
Para aprender a fazer um monte de gracinhas com o PS1 d? uma lida no
Bash-Prompt-HOWTO (ver 10. Refer?ncias)

–> PS2

Esta ? a “Secondary Prompt String”. ? usada quando um comando usa mais
de uma linha. Por exemplo:

/* -=-=-= exemplo =-=-=- */
$ echo m\
> e\
> l\
> e\
> u
meleu
$ echo ‘m
> e
> l
> e
> u’
m
e
l
e
u
/* -=-=-= exemplo =-=-=- */

Este sinal ‘> ‘ (maior-espa?o) ? o PS2. Voc? pode usar os mesmos
caracteres especiais que o PS1 usa.

–> MAIL

Nada mais ? do que o arquivo onde s?o guardados seus emails. Aqui na
minha m?quina eu uso o sendmail como servidor de email, portanto:

/* -=-=-= MAIL =-=-=- */
meleu@meleu:~$ echo $MAIL
/var/spool/mail/meleu
/* -=-=-= MAIL =-=-=- */

por?m se estivesse usando qmail seria:

/* -=-=-= MAIL =-=-=- */
meleu@meleu:~$ echo $MAIL
/home/meleu/Mailbox
/* -=-=-= MAIL =-=-=- */

–> SHLVL

Esta vari?vel armazena quantos shells voc? executou a partir da
primeira shell.
Confuso? Vamos a um exemplo.
Imagine que voc? est? usando o bash e executou o bash de novo, nesta
situa??o o seu SHLVL vale 2. Veja isto:

/* -=-=-= exemplo =-=-=- */
$ echo $SHLVL
1
$ bash # estou executando o bash a partir do bash
$ echo $SHLVL
2
$ exit # sa? do segundo bash
exit
$ echo $SHLVL
1
/* -=-=-= exemplo =-=-=- */

Quando voc? inicializa scripts a partir do comando “source” o script ?
executado no shell pai, portanto se tiver um “exit” no script voc? vai
executar um logoff. ? a? que est? a utilidade da vari?vel SHLVL. Quando
voc? est? no shell prim?rio o valor de SHLVL ? 1. Ent?o voc? pode, atrav?s
de um “if” por exemplo, executar o “exit” s? se SHLVL for diferente de 1
(mais informa??es sobre o source em “6.1 Fun??es como comandos”).

–> PROMPT_COMMAND

Esta ? bem interessante. Ela armazena um comando que ser? executado
toda hora que o prompt ? exibido. Veja:

/* -=-=-= exemplo =-=-=- */
$ PROMPT_COMMAND=”date +%T”
19:24:13
$ cd
19:24:17
$ ls
GNUstep/ bons.txt pratica/ teste worldwritable.txt
Mail/ hacking/ progs/ txts/
19:24:19
$
19:24:32
$ # isso eh uma linha sem nenhum comando
19:24:49
$
/* -=-=-= exemplo =-=-=- */

Esta vari?vel ? ?til quando queremos brincar com o prompt, para
aprender mais sobre isso leia o Bash-Prompt-HOWTO (v. 10. Refer?ncias).

–> IFS

O shell usa esta vari?vel para dividir uma string em palavras
separadas. Normalmente o IFS ? um espa?o, uma tabula??o (Tab) e um
caractere nova linha (\n). Desta maneira:

isto eh uma string

s?o quatro palavras, pois IFS ? um espa?o e as palavras est?o separadas
por espa?o. Agora se eu mudar IFS para um ‘:’ desta maneira:

IFS=’:’

ent?o a string:

isto:eh:uma:string

conter? quatro palavras. Isto ? ?til para casos como neste exemplo:

/* —————– */
< ++> BashScript/path.sh
#!/bin/bash

IFS=’:’

for item in $PATH ; do
echo $item
done

< -->
/* —————– */

Se IFS for uma vari?vel nula (vazia), tudo ser? considerado uma ?nica
palavra. Por exemplo:

se o IFS for nulo, toda essa linha ser? considerada uma ?nica palavra

–> RANDOM

Quando voc? exibe esta vari?vel (“echo $RANDOM”) ? exibido um n?mero
aleat?rio entre 0 e 32767.
Pra que serve isso?
Sei l?! V?rias coisas. Quem ? criativo sempre precisa de um n?mero
aleat?rio… Imagine que voc? queira um n?mero de telefone celular
qualquer (sei l? pra qu?!), voc? pode fazer um script que gera um n?mero
desse pra voc?. Aqui na minha regi?o estes n?meros come?am com 99 ou 98,
e t?m um total de 8 d?gitos. O script a seguir gera n?meros que comecem
com 98 somente:

/* —————– */
< ++> BashScript/cellnumbergen.sh
#!/bin/bash

NUM=”98$(echo $RANDOM)0″
CONT=$(echo -n $NUM | wc -c) # quantos digitos tem?

while [ $CONT -lt 8 ]; do # se nao tiver 8 digitos acrescenta 0’s
NUM=${NUM}0
CONT=$(echo -n $NUM | wc -c)
done

echo $NUM
< -->
/* —————– */

–> Outras

Outras vari?veis que s?o muito usadas:
MAILCHECK ; HISTFILE ; HOSTNAME ; LS_OPTIONS ; LS_COLOR ; MANPATH ;
SHELL ; TERM ; USER ; PS3 .

Estas s?o as mais utilizadas, por?m existem muitas outras. Para ver
quais s?o as vari?veis definidas no momento basta entrar com o comando
“set”. E para ver apenas as vari?veis de ambiente use “env”.
Olhe a man page do bash na se??o “Shell Variables” para mais detalhes.

2.3. Vari?veis Somente-Leitura
=========================

Como sabemos as vari?veis podem ter seu valor modificado pelo usu?rio,
mas se n?s quisermos vari?veis que N?O possam ter seus valores alterados
basta declararmos tal vari?vel como somente-leitura. Para tornar uma
vari?vel read-only podemos usar o comando “readonly” ou ent?o
“declare -r”.
Veja os exemplos a seguir, ambos possuem o mesmo resultado:

/* -=-=-=-=-= exemplo-1 =-=-=-=-=- */
$ readonly NOME=”Meleu Zord”
$ echo $NOME
Meleu Zord
/* -=-=-=-=-= exemplo-1 =-=-=-=-=- */

/* -=-=-=-=-= exemplo-2 =-=-=-=-=- */
$ declare -r NOME=”Meleu Zord”
$ echo $NOME
Meleu Zord
/* -=-=-=-=-= exemplo-2 =-=-=-=-=- */

Agora s? pra ter certeza:

/* -=-=-= teste =-=-=- */
$ NOME=Fulano
bash: NOME: readonly variable
$ echo $NOME
Meleu Zord
/* -=-=-= teste =-=-=- */

Um bom uso deste tipo de vari?vel ? para garantir que vari?veis
importantes de um determinado script n?o possam ser sobregravadas,
evitando assim algum resultado cr?tico.

O comando “readonly” quando usado sem par?metros (ou o comando “declare”
apenas com o par?metro “-r”) nos mostra todas as vari?veis declaradas como
somente-leitura. No exemplo a seguir se for usado “declare -r” no lugar de
“readonly” ter?amos a mesma sa?da.

/* -=-=-=-=-= readonly =-=-=-=-=- */
$ readonly
declare -ar BASH_VERSINFO='([0]=”2″ [1]=”05″ [2]=”0″ [3]=”1″ [4]=”release”
[5]=”i386-slackware-linux-gnu”)’
declare -ir EUID=”1005″
declare -ir PPID=”1″
declare -r
SHELLOPTS=”braceexpand:hashall:histexpand:monitor:ignoreeof:interactive-comments:emacs”
declare -ir UID=”1005″
/* -=-=-=-=-= readonly =-=-=-=-=- */

Existem v?rias vari?veis somente-leitura que s?o inicializadas pelo
shell, como USER, UID.

TODAS as vari?veis readonly uma vez declaradas n?o podem ser “unsetadas”
ou ter seus valores modificado. O ?nico meio de apagar as vari?veis
readonly declaradas pelo usu?rio ? saindo do shell (logout).

2.4. Par?metros
==========

Podemos passar par?metros para o shell script assim como na maioria
dos programas. Os par?metros s?o vari?veis, digamos, especiais. Para
come?ar elas n?o obedecem as regras de nomeclatura de vari?veis, pois
elas usam n?meros; e tamb?m n?s n?o podemos mudar o valor destas
vari?veis pelas vias “tradicionais”, para mudar o valor destas n?s temos
que contar com a ajuda do shift e/ou do set (como veremos adiante).

Veja esta rela??o:

$0 ? o nome do shell script (a.k.a. par?metro zero);

$1 a $9 $1 ? o primeiro par?metro, $9 o nono, e
assim por diante;

${10}, ${11}… quando o n?mero do par?metro possui mais de um
d?gito ? necess?rio o uso das chaves;

$* todos os par?metros em uma ?nica string
(exceto o $0);

$@ todos os par?metros, cada um em strings
separadas (exceto $0);

$# n?mero de par?metros (sem contar com o $0).

Outros:

$? valor de retorno do ?ltimo comando
(explicado mais adiante);

$$ PID do script.

Pra ficar mais claro, nada melhor do que um exemplo:

/* —————— */
< ++> BashScript/parametros.sh
#!/bin/bash
#
# “basename” serve para eliminar o caminho do arquivo e mostrar
# somente o ?ltimo nome dele. Neste caso: parametros.sh
echo “Nome do script: `basename $0`”
echo “N?mero total de par?metros: $#”
echo “Primeiro par?metro: $1”
echo “Segundo par?metro: $2”
echo “D?cimo quinto par?metro: ${15}”
echo “Todos os par?metros: $*”
< -->
/* —————— */

/* -=-=-=-=-= exemplo =-=-=-=-=- */
$ ./parametros.sh a b c d e f g h i j l m n o p q r s t u v x z
Nome do script: parametros.sh
N?mero total de par?metros: 23
Primeiro par?metro: a
Segundo par?metro: b
D?cimo quinto par?metro: p
Todos os par?metros: a b c d e f g h i j l m n o p q r s t u v x z
/* -=-=-=-=-= exemplo =-=-=-=-=- */

Se voc? n?o entendeu direito a diferen?a entre o $* e o $@, ent?o d?
uma olhada no seguinte script (se n?o entend?-lo tudo bem, siga em frente
e quando aprender sobre o “if” e o “for” leia-o novamente):

/* —————— */
< ++> BashScript/testargs.sh
#!/bin/bash
# Ao executar este script entre alguns parametros. Ex.:
# [prompt]$ ./testargs.sh um dois tres quatro

if [ -z “$1” ]; then
echo “Uso: `basename $0` argumento1 argumento2 etc.”
exit 1
fi

echo
echo “Listando argumentos com \”\$*\”:”
num=1
for arg in “$*”; do
echo “Arg #$num = $arg”
num=$[ $num + 1 ]
done
# Conclus?o: $* mostra todos os argumentos como uma ?nica string

echo
echo “Listando argumentos com \”\$@\”:”
num=1
for arg in “$@”; do
echo “Arg #$num = $arg”
num=$[ $num + 1 ]
done
# Conclus?o: $@ mostra cada argumento em strings separadas

echo
< -->
/* —————— */

2.4.1. shift
—–

O bash possui um comando embutido que lida com par?metros, o shift.
Quando voc? usa o shift sai o primeiro par?metro da lista e o segundo vai
para $1 o terceiro vai para $2, e assim por diante. Voc? pode ainda
especificar quantas “casas” voc? quer que os par?metros “andem” ?
esquerda atrav?s de “shift n” onde ‘n’ ? o n?mero de casas, mas se o
n?mero de casas que ele deve andar for maior que o n?mero de par?metros
o shift n?o ? executado.
Veja este exemplo:

/* —————— */
< ++> BashScript/shift-exemplo.sh
#!/bin/bash
echo “$#: $*”
echo -e “executando \”shift\””
shift
echo “$#: $*”
echo -e “executando \”shift 5\””
shift 5
echo “$#: $*”
echo -e “executando \”shift 7\””
shift 7
echo “$#: $*”
< -->
/* —————– */

/* -=-=-=-=-= shift =-=-=-=-=- */
$ ./shift-exemplo.sh 1 2 3 4 5 6 7 8 9 0
10: 1 2 3 4 5 6 7 8 9 0
executando “shift”
9: 2 3 4 5 6 7 8 9 0
executando “shift 5”
4: 7 8 9 0
executando “shift 7”
4: 7 8 9 0
/* -=-=-=-=-= shift =-=-=-=-=- */

Os valores que saem s?o perdidos. Use com aten??o!

2.4.2. set (para editar par?metros)
—————————-

O que vou passar neste t?pico n?o ? sobre como usar “todo o poder do
comando set”, e sim como usar set especificamente para editar par?metros.
N?o tem nenhum segredo! Veja este exemplo:

set um dois tres

Isso far? com que $1 seja ‘um’, $2 seja ‘dois’, $3 seja ‘tres’ e s?!
N?o existir? $4, $5, etc. mesmo que eles tenham sido usados. Veja um
exemplo de script:

/* —————– */
< ++> BashScript/setparam.sh
#!/bin/bash

echo “Os $# par?metros passados inicialmente foram: $@”
echo
echo “e agora eu vou alter?-los!”
echo “como eu sou mau… (huahuahau risada diab?lica huahuahuha)”
echo
set um dois tres
echo “Os $# novos par?metros agora s?o: $@”
echo
< -->
/* —————– */

N?o interessa quantos par?metros voc? passar para este script, no
final voc? s? ter? $1, $2 e $3 valendo ‘um’, ‘dois’ e ‘tres’,
respectivamente.

No meu Mextract.sh (t?pico 9.5.) esta caracter?stica do set ? muito
bem aproveitada! 😉

2.5. Substitui??o de Vari?veis
=========================

Isto ? muito ?til e pode ser muito mais elegante que ficar usando if’s
(explicados mais adiante) sem necessidade! Veja que bacana! 😉

–> ${variavel:-string}

Se “variavel” n?o tiver sido definida ou for vazia ser? substitu?da por
“string”. O valor da vari?vel n?o ? alterado. Veja este exemplo:

/* -=-=-= exemplo =-=-=- */
$ echo ${URL:-“http://unsekurity.virtualave.net”}
http://unsekurity.virtualave.net
$ echo $URL # observe que URL nao foi alterado

/* -=-=-= exemplo =-=-=- */

–> ${variavel:=string}

Se “variavel” n?o estiver sido definida ou for vazia, receber?
“string”. Exemplo:

/* -=-=-= exemplo =-=-=- */
$ echo ${WWW:=”http://meleu.da.ru”}
http://meleu.da.ru
$ echo $WWW
http://meleu.da.ru
/* -=-=-= exemplo =-=-=- */

–> ${variavel:?string}

Se “variavel” n?o estiver sido definido ou for vazia, “string” ser?
escrito em stderr (sa?da de erro padr?o). O valor da vari?vel n?o ?
alterado. Veja um exemplo:

/* -=-=-= exemplo =-=-=- */
$ echo ${EDITOR:?”Nenhum editor de texto”}
bash: EDITOR: Nenhum editor de texto
$ echo $EDITOR

/* -=-=-= exemplo =-=-=- */

–> ${variavel:+string}

Se “variavel” estiver definida, ser? substitu?da por “string” mas seu
valor n?o ser? alterado. Exemplo:

/* -=-=-= exemplo =-=-=- */
$ echo ${BROWSER:+”BROWSER definido como \”$BROWSER\””}
BROWSER definido como “links”
/* -=-=-= exemplo =-=-=- */

————————————————————————–

3. Entrada e Sa?da (I/O)
*********************

Comunicando-se…

3.1. echo
====

Nos j? usamos o echo para escrever na tela, mas aqui vamos tratar de
alguns “segredinhos” (que n?o s?o t?o secretos assim).

Existem alguns momentos que voc? n?o quer que a sa?da do echo pule de
linha automaticamente. Para isso use o par?metro “-n”. Este par?metro ?
?til quando voc? vai entrar com algo ap?s o echo. Veja este script:

/* —————– */
< ++> BashScript/filetype.sh
#!/bin/bash
echo -n “Entre com o nome do arquivo: “
read FILE
echo “Tipo do arquivo `file $FILE`”
< -->
/* —————– */

Execute e veja o resultado.

Muita aten??o deve ser tomada ao usar o echo, pois as aspas que voc?
pode vir a deixar de usar podem fazer uma diferen?a danada (em alguns
casos isso pode ser muito ?til).

/* -=-=-= exemplo =-=-=- */
$ echo uma boa rede de irc que conheco eh irc.linux.org
uma boa rede de irc que conheco eh irc.linux.org
$ echo “uma boa rede de irc que conheco eh irc.linux.org”
uma boa rede de irc que conheco eh irc.linux.org
$
$ # agora um exemplo com variavel
$
$ TESTE=”primeira linha da variavel
> segunda linha
> terceira…
> chega! 🙂
> “
$ echo $TESTE
primeira linha da variavel segunda linha terceira… chega! 🙂
$ echo “$TESTE”
primeira linha da variavel
segunda linha
terceira…
chega! 🙂

/* -=-=-= exemplo =-=-=- */

A esta altura voc? j? deve ter se perguntado “Como fa?o para imprimir
caracteres nova linha ou beep?!”. Os mais malandrinhos devem ter tentado um
contra-barra (backslash) ‘\’, mas voc? n?o pode simplesmente fazer isso.
? necess?rio usar o par?metro “-e” com o echo. Este par?metro permite que
usemos sequ?ncias de escape contra-barra.
As sequ?ncias s?o iguais a da linguagem C, exemplo: \n para nova
linha, \a para beep, \b para backspace, etc…
Veja este exemplo:

/* -=-=-= exemplo =-=-=- */
$ echo -e “module caiu de cara tentando \”top soul\”.\nQue paia\a”!
module caiu de cara tentando “top soul”.
Que paia!
/* -=-=-= exemplo =-=-=- */

O -e ? tamb?m usado para escrever coloridinho (ai que fofo!), e outras
coisas interessantes. Veremos isso no t?pico seguinte.

3.1.1 Sequ?ncias de Escape ANSI
————————-

Para usar cores a sequ?ncia de escape ? “\e[m” (os sinais ‘< ' e '>‘
n?o entram!). Veja um exemplo (mais a frente voc? ver? tabelas com os
significados destas sequ?ncias):

/* —————– */
< ++> BashScript/amarelinho.sh
#!/bin/bash
# imprime amarelinho no centro da linha

# A vari?vel $COLUMNS cont?m o n?mero de colunas que o terminal est?
# usando, e antes de executar este script voc? precisa export?-la:
# [prompt]$ export COLUMNS
[ $COLUMNS ] || {
echo Voc? precisa exportar a vari?vel \”COLUMNS\”:
echo “Tente \”export COLUMNS\” e tente executar novamente”
exit 1
}

POSICAO=$[ ( $COLUMNS – `expr length “$*”` ) / 2 ]
# `expr length “$*”` retorna o n?mero de caracteres digitados
# como par?metros.

echo -e “\e[${POSICAO}C\e[33;1m$*\e[0m”

< -->
/* —————– */

Agora uma explica??o ligeira: o \e diz ao echo que o que vem depois ?
uma sequ?ncia de escape.
Se voc? der a sequ?ncia ‘[C’, onde num ? um n?mero qualquer, o
cursor vai andar “num” caraceteres para a direita. Acima eu uso a vari?vel
POSICAO para mover o cursor para o centro da linha (veja o c?lculo no
c?digo).
O comando ‘[m’ muda para a cor “num”. Cada cor tem um c?digo
pr?prio. No exemplo acima o 33 faz ficar marrom, por?m combinando com o 1
fica amarelo (isso no modo texto, pois no xterm, por exemplo, o 1 faz o
marrom ficar em negrito. veja OBSERVA??ES mais adiante).

Veja uma tabela com os c?digos de movimenta??o de cursor que eu conhe?o
(os caracteres ‘< ' e '>‘ devem ser ignorados):

,————-,————————————————,
| C?digo | O que faz |
|————-|————————————————|
| \e[A | Move o cursor N linhas acima. |
|————-|————————————————|
| \e[B | Move o cursor N linhas abaixo. |
|————-|————————————————|
| \e[C | Move o cursor N colunas ? direita. |
|————-|————————————————|
| \e[D | Move o cursor N colunas ? esquerda. |
|————-|————————————————|
| \e[E | Move o cursor N linhas para baixo na coluna 1. |
|————-|————————————————|
| \e[F | Move o cursor N linhas para cima na coluna 1. |
|————-|————————————————|
| \e[G | Coloca o cursor na linha N. |
|————-|————————————————|
| \e[;H | Coloca o cursor na linha L e na coluna C. |
|————-|————————————————|
| \e[I | Move o cursor N tabula??es ? direita. |
|————-|————————————————|
| | N=0 Apaga do cursor at? o fim da tela; |
| \e[J | N=1 Apaga do cursor at? o in?cio da tela; |
| | N=2 Apaga a tela toda. |
|————-|————————————————|
| | N=0 Apaga do cursor at? fim da linha; |
| \e[K | N=1 Apaga do cursor at? o in?cio da linha; |
| | N=2 Apaga a linha toda. |
|————-|————————————————|
| \e[L | Adiciona N linhas em branco abaixo da atual. |
|————-|————————————————|
| \e[M | Apaga N linhas abaixo da atual. |
|————-|————————————————|
| \e[P | Apaga N caracteres a direita. |
|————-|————————————————|
| \e[S | Move a tela N linhas para cima. |
|————-|————————————————|
| \e[T | Move a tela N linhas para baixo. |
|————-|————————————————|
| \e[X | Limpa N caracteres ? direita (com espa?os). |
|————-|————————————————|
| \e[@ | Adiciona N espa?os em branco. |
|————-|————————————————|
| \e[s | Salva a posi??o do cursor. |
|————-|————————————————|
| \e[u | Restaura a posi??o do cursor que foi salva. |
‘————-‘————————————————‘

Sim, a lista ? grande… Fa?a uns testes para praticar um pouquinho.

Agora uma tabelinha dos atributos e seus n?meros (N deve estar no
formato “\e[m”):

,—————————–,—-,————-,—,
| Atributo | N | Cor | X |
|—————————–|—-|————-|—|
| Desligar todos atributos | 0 | Preto | 0 |
| Negrito | 1 | Vermelho | 1 |
| Cor X para o primeiro plano | 3X | Verde | 2 |
| Cor X para o segundo plano | 4X | Marrom | 3 |
| Sublinhado | 4 | Azul | 4 |
| Piscando (blink) | 5 | Roxo | 5 |
| V?deo reverso | 7 | Ciano | 6 |
| -x- | — | Branco | 7 |
‘—————————–‘—-‘————-‘—‘

OBSERVA??ES:
-> Negrito, Sublinhado e Piscando possuem comportamentos diferentes no
console e nos emuladores de terminal. Principalmente quando temos negrito
sendo usado com cores.
Por exemplo, o c?digo “\e[33m” ir? ativar o marrom mas se for usado
(no console!) com o atributo de negrito ficar? amarelo, e o c?digo ser?
assim: “\e[1;33m”. Por isso fa?a os testes que voc? descobrir? as cores
-> Estas tabelas eu fiz gra?as a uma mat?ria que o aur?lio escreveu
sobre isso. Veja em http://verde666.org/coluna/

No t?pico “6.1 Fun??es como comandos” voc? ver? o Mfunctions, ele
cont?m uma fun??o que mostra todas as combina??es de cores poss?veis.

3.2. read
====

Como voc? viu no script anterior para entrar com um dado usa-se “read”.
O read tem alguns “macetinhos”. Pra come?ar: voc? n?o precisa colocar um
echo toda hora que for usar o read para escrever um prompt. Basta fazer
“read -p prompt variavel”
Veja esta se??o de exemplos:

/* —————– */
< ++> BashScript/read1.sh
#!/bin/bash
read -p “Entre com uma string: ” string
echo $string
< -->
/* —————– */

/* -=-=-=-=-= exemplo =-=-=-=-=- */
$ ./read1.sh
Entre com uma string: klogd eh um tremendo cachacero!
klogd eh um tremendo cachacero!
/* -=-=-=-=-= exemplo =-=-=-=-=- */

/* —————– */
< ++> BashScript/read2.sh
#!/bin/bash
read -p “Entre com 3 strings: ” s1 s2 s3
echo “s1 = $s1 s2 = $s2 s3 = $s3”
< -->
/* —————– */

/* -=-=-=-=-= exemplo2 =-=-=-=-=- */
$ ./read-2.sh
Entre com 3 strings: j00nix eh cabecudo
s1 = j00nix s2 = eh s3 = cabecudo

# o mesmo script com mais de 3 strings #

$ ./read-2.sh
Entre com 3 strings: eSc2 adora ficar de copy’n’paste no IRC.
s1 = eSc2 s2 = adora s3 = ficar de copy’n’paste no IRC.
/* -=-=-=-=-= exemplo2 =-=-=-=-=- */

Quando o “read” vai ler apenas uma vari?vel, toda a string vai ser
atribu?da a esta vari?vel. Quando vai ler mais de uma vari?vel ele atribui
cada string a sua respectiva vari?vel; e quando o n?mero de strings excede
o n?mero de vari?veis a ?ltima fica com o excedente.

O par?metro “-s” serve para n?o ecoar o que for digitado. ? ?til para
digitar uma senha por exemplo. Tente “read -s PASS” e veja.

Voc? tamb?m pode determinar o n?mero de caracteres que ser?o lidos com
o par?metro “-n”. Tente fazer “read -n 10 VAR”. Mas cuidado: ao usar a
op??o -n voc? n?o poder? usar o backspace para fazer corre??es.

A op??o “-r” serve para que a contra-barra (backslash) n?o aja como um
caracter de escape. E isso me foi bastante ?til para fazer o Mextract,
como voc? ver? adiante.

Mais sobre o read na manpage do bash.

3.3. Redirecionamento
================

Quem j? sabe programar deve saber que existem tr?s “file descriptors”
abertos por padr?o (pelo menos nos sistemas operacionais que conhe?o):
stdin (standard input), stdout (standard output) e stderr (standard error).
Para fins pr?ticos, estes s?o considerados arquivos e voc? pode direcionar
destes “arquivos” para outros e vice-versa.
Veja como direcionar de:

+ arquivo para stdin
$ programa < arquivo+ stdout para arquivo
$ programa > arquivo

+ stderr para arquivo
$ programa 2> arquivo

+ stdout para stderr
$ programa 1>&2

+ stderr para stdout
$ programa 2>&1

+ stdout e stderr para arquivo
$ programa &> arquivo

Se voc? usar por exemplo “find / -perm -2 > worldwritable.txt” e no
diret?rio n?o tiver um arquivo chamado “worldwritable.txt” este ser?
criado, a sa?da do comando ser? gravada nele e a sa?da de erro padr?o
ser? impressa na tela (ou ?cran, se preferirem 😛 ). Para n?o ver as
mensagens de “Permission Denied” fa?a isso:

$ find / -perm -2 > worldwritable.txt 2> /dev/null

Ainda temos um probleminha: este comando ir? mostrar tamb?m todos os
links simb?licos e v?rios arquivos de dispositivo. Para eliminar os links
simb?licos fa?a o seguinte:

$ find / -perm -2 ! -type l > worldwritable.txt 2> /dev/null

Voc? ainda pode eliminar da sa?da os arquivos com stick bit e os
arquivos de dispositivo usando par?nt… EI!! Isto aqui ? sobre
redirecionamento, e n?o sobre o find! V? ler a man page do find! =P

Se o arquivo j? existir seu conte?do ser? sobregravado. Mas voc? pode
apenas concatenar o conte?do no final do arquivo usando “>>”. Exemplo:

$ echo ” F I M D O A R Q U I V O ” >> worldwritable.txt

Fa?a os testes e tire suas conclus?es! 😉

Veja este script a seguir a execute ele usando redirecionamento na linha
de comando pra ver os resultados

/* —————– */
< ++> BashScript/redirecionamento.sh
#!/bin/bash
echo “Isto vai para a sa?da padr?o.”
echo “Isto vai para a sa?da de erro padr?o.” 1>&2
echo “Isto vai criar um arquivo e colocar esta linha nele.” > ARQUIVO
echo “Esta linha vai para o final do arquivo.” >> ARQUIVO
< -->
/* —————– */

Tem um outro tipo de redirecionamento que ? bastante ?til. ? assim:

$ programa < < delimitadorIsto quer dizer que o programa vai ler o arquivo stdin at? encontrar o
delimitador.
Isso ? muito ?til para usar programas externos atrav?s de shell
scripts.
Voc? pode, por exemplo, usar este tipo de redirecionamento para fazer um
shell script escrever um outro arquivo usando o comando “cat”. Vamos a um
exemplo em que eu crio um c?digo de programa escrito em C atrav?s do
script (note que as vari?veis do script S?O interpretadas):

/* —————– */
<++> BashScript/catredir.sh
#!/bin/bash

NAME=`whoami`

echo -e “\n\tCRIANDO O ARQUIVO arquivo.c\n”

# O arquivo.c terminar? quando encontrar a string _EOF_
cat < < _EOF_ > arquivo.c
#include

int main (void) {
printf (“\n\tPrograma que n?o faz nada al?m disso.\n”);
printf (“\tFeito por $NAME\n\n”);
return 0;
}
_EOF_
# O arquivo.c acabou na linha ACIMA do _EOF_
# Observe no arquivo.c o $NAME ser? “traduzido” para o username adequado

echo -e “\n\tCOMPILANDO O PROGRAMA\n”
gcc arquivo.c -o arquivo

echo -e “\n\tFEITO!\n”
< -->
/* —————– */

3.3.1. Pipe
====

Agora vejamos o pipe. Sua sintaxe ?:

$ programa1 | programa2

O pipe ? usado para voc? fazer da sa?da de um programa a entrada de
outro (como usado no exemplo amarelinho.sh j? mostrado anteriormente).
Apesar de simples o pipe ? muito ?til e poderoso. Veja este exemplo
muito simples:

/* -=-=-=-=-= exemplo =-=-=-=-=- */
$ who
meleu tty1 Nov 20 01:40
hack tty2 Nov 20 01:45
root tty3 Nov 20 02:44
$ who | cut -c-9
meleu
hack
root
/* -=-=-=-=-= exemplo =-=-=-=-=- */

Mais exemplos ser?o dados ao longo do texto.

3.3.1.1. Comandos ?teis com o Pipe
=========================

–> xargs

O xargs transforma stdin em argumentos da linha de comando. Vamos usar
o exemplo anterior de novo:

/* -=-=-=-=-= exemplo =-=-=-=-=- */
$ who | cut -c-9 # lembrando: pipe transforma stdout em stdin
meleu
hack
root
$ # “echo” nao le arquivo, ele usa argumentos.
$ # A linha abaixo nao tem utilidade.
$ who | cut -c0-9 | echo

$ # “xargs” transforma o conteudo de stdin em argumentos
$ who | cut -c0-9 | xargs echo
meleu hack root
/* -=-=-=-=-= exemplo =-=-=-=-=- */

Como eu gosto do find n?o resisti e colocarei um comando interessante
que usa pipe e xargs:

$ find / -perm -2 ! -type l ! -type c | xargs ls -ld > wordwritable.txt

Se n?o entendeu algo do comando acima e quer entender, olhe as
manpages.

–> tee

Outro comando bom de se usar com pipe ? o “tee”. Ele faz com que a
sa?da do programa v? para a sa?da padr?o, normalmente a tela (?cran) *E*
para um arquivo ao mesmo tempo.
? como se voc? fizesse “programa > arquivo” s? que o sa?da do programa
tamb?m seria escrita na sa?da padr?o. Experimente:

$ ls -la |tee conteudo.txt

————————————————————————–

4. Comandos de Tomadas de Decis?o
******************************

Agora sim o neg?cio come?a a ficar legal! 🙂

O jeito como as estruturas est?o explicadas ? o que eu uso, mas n?o
? o ?nico. Se voc? quer uma refer?ncia mais completa veja a manpage do
bash.

4.1 if-then-else e afins
====================

A estrutura b?sica ? a seguinte:

if ; then

else

fi

Primeiro devemos saber que todos os comandos do UNIX possuem um c?digo de
retorno. Este c?digo tem valor 0 quando a opera??o ocorre com sucesso e
valor diferente de zero quando a opera??o N?O termina com sucesso. Ap?s
cada comando o valor de retorno ? gravado na vari?vel $?, experimente um
“echo $?” depois de algum comando e veja!
A avalia??o de verdadeiro do bash ? exatamente o oposto de outras
linguagens de programa??o (C por exemplo), que avaliam a express?o de
retorno diferente de 0 como verdadeira e 0 como falso. No bash, quando um
comando retorna 0 o if avalia como verdadeiro e quando retorna um
n?o-zero significa falso. (Para mais detalhes sobre os c?digos de
retorno, olhe a p?gina manual do bash na se??o “EXIT STATUS”).
Veja um exemplo:

/* —————– */
< ++> BashScript/return.sh
#!/bin/bash
read -p “Entre com o nome do diret?rio: ” DIR
if ( cd $DIR 2> /dev/null ); then
echo -e “‘cd $DIR’ retornou \”sucesso\” ($?)”
else
echo -e “‘cd $DIR’ retornou \”insucesso\” ($?)”
fi
< -->
/* —————– */

/* -=-=-=-=-= exemplo =-=-=-=-=- */
meleu:~$ ./return.sh
Entre com o nome do diret?rio: /usr
‘cd /usr’ retornou “sucesso” (0)

meleu:~$ ./return.sh
Entre com o nome do diret?rio: dir_invalido
‘cd dir_invalido’ retornou “insucesso” (1)
/* -=-=-=-=-= exemplo =-=-=-=-=- */

O valor de retorno do comando “cd /usr” foi 0 portanto foi executado
com sucesso, j? o retorno de “cd /dir_invalido” foi 1 porque ocorreu um
erro. Agora repare no final que mesmo com um “cd /usr” continuo no
diret?rio HOME (~). Isto prova que um shell script usa um shell a parte
(shell “filho”) e n?o o shell que chama o script (shell pai).
(Chato ficar lendo isso toda hora n?? Esta foi a ?ltima vez! :P)

4.1.1. test
—-

Para fazer testes mais arrojados usamos o comando “test”. A maneira
de usar o test muda de acordo com o que estamos querendo testar. Se estamos
comparando strings ou se estamos comparando n?meros, e por a? vai… Existe
uma sintaxe para cada tipo de interpreta??o que queremos dar a um dado. Por
exemplo: “0001” ? diferente da string “1” mas o valor num?rico ? igual.
E por isso usamos sintaxes diferentes, para que o comando saiba que tipo de
compara??o estamos fazendo.
Continue lendo…

–> express?es com strings:

O sinal de “=” verifica se a primeira string ? igual a segunda; o “!=”
verifica se a primeira string ? diferente da segunda; o par?metro “-z”
verifica se a string ? vazia; e o par?metro “-n” verifica se a string N?O ?
vazia.

/* -=-=-= exemplos =-=-=- */
$ test “abcd” = “abcd”; echo $?
0
$ test “abcd” != “abcd”; echo $?
1
$ test “abcd” = “efgh”; echo $?
1
$ test “abcd” != “efgh”; echo $?
0
$ test -z “meleu”; echo $?
1
$ test -n “meleu”; echo $?
0
$ test -n “”; echo $?
1
$ test -z “”; echo $?
0
/* -=-=-= exemplos =-=-=- */

Uma maneira mais pr?tica de usar o “test” e subistitu?-lo pelos
[colchetes]. ? muito mais pr?tico e bonitinho 😛

$ test “meleu” = “$nome”

? o mesmo que fazer:

$ [ “meleu” = “$nome” ]

Muito melhor, n?o acham?! Vamos usar esta nota??o a partir de agora!

Agora vamos a uma dica ?til pra hora de fazer compara??es entre
strings. Primeiro vamos a um exemplo e depois a uma explica??o.

/* -=-=-=-=-= exemplo =-=-=-=-=- */
$ cat strcmp1.sh
#!/bin/bash

if [ $1 = $2 ]; then
echo As strings s?o iguais.
fi

$ ./strcmp1.sh meleu
./strcmp.sh: [: meleu: unary operator expected
/* -=-=-=-=-= exemplo =-=-=-=-=- */

Note que o test deu um erro, e por isso retornou um n?o-zero para o
if.
Observe o seguinte:

/* -=-=-=-=-= exemplo2 =-=-=-=-=- */
$ cat strcmp2.sh
#!/bin/bash

if [ $1 = $2 ]; then
echo As strings s?o iguais.
else
echo As strings s?o diferentes.
fi

$ ./strcmp2.sh meleu
./strcmp.sh: [: meleu: unary operator expected
As strings s?o diferentes.
/* -=-=-=-=-= exemplo2 =-=-=-=-=- */

Aconteceu a mesma coisa que no primeiro exemplo, s? que agora temos um
else pra ser executado caso a expressao do if retorne falso (ou
n?o-zero). Uma solu??o pra que n?o d? este erro no test ? usar aspas
duplas. Veja s?:

/* —————— */
< ++> BashScript/strcmp.sh
#!/bin/bash

if [ “$1” = “$2” ]; then
echo As strings s?o iguais.
else
echo As strings s?o diferentes.
fi
< -->
/* —————— */

Com este acontece tudo certo. 😉
Voc? tamb?m N?O deve escrever tudo junto, assim: $1=$2 ou “$1″=”$2”
Desta maneira o test vai retornar sempre verdadeiro, pois seria como se
voc? estivesse passado somente um par?metro para ele.

–> express?es com arquivos

Posted in Sem categoria