ShaGma - Dicas de Linux

anterior / inicio

01/05/18 - Actualização das informações dobre o imwheel
01/03/30 - Utilização de todos os botões dos ratos Micro$oft IntelliMouse Optical / Explorer
00/11/06 - As dicas de VIM estão numa página nova
00/08/27 - Programa imwheel
00/08/24 - Reorganização, bugfixes
00/08/11 - Bugfixes
00/07/24 - Registos no VIM
00/07/24 - Várias alterações visuais, no conteudo e correcções no código HTML
00/07/13 - Varias alterações na configuração do teclado
00/05/23 - Nova secção no VIM: Ficheiros / buffers
00/05/10 - Correcção de alguns erros
00/05/08 - Correcção de alguns erros, mais informação sobre o wget
00/05/07 - Exemplos de utilização do ar e do tar

Leitura deste documento

Este documento não ensina a usar o KDE nem o GNOME =), é destinado a quem prefere usar o shell, ou quem quer aprender a usá-lo.

Como é tipico em qualquer documento deste tipo, o autor não se responsabiliza pelas consequências, boas (sempre podem agradecer =) ou más, derivadas do uso da informação aqui contida.
O documento está em desenvolvimento constante e está incompleto em algumas partes.
A ultima versão deste documento pode ser encontrada aqui.

Todas as linhas começadas por "$" representam um comando,

$ comando

os comandos escrevem-se num terminal ou são selecionados na pagina (excluindo o "$") e colados no terminal usando o botão do meio do rato (ou os dois botões simultaneamente no caso de só haver dois), depois carrega-se na tecla ENTER para o executar. As linhas começadas por "#" representam comandos que tem de ser executados como root.

# comando como root

Os termos em itálico num comando representam normalmente nomes de ficheiros ou valores, escolhidas pelo utilizador de acordo com as necessidades e resultados pretendidos.

$ comando -v valor ficheiro

As linhas que representam o conteudo ou parte do conteudo de um ficheiro ou script têm o seguinte aspecto,

# comentario de um script
# continuação do comentario
ação

Os termos em bold representam normalmente nomes de programas/comandos, para saber mais sobre um determinado comando usar "man comando".

Indice

Leitura deste documento
Teclado
Shell
Programas
- Internet [ WWWOFFLE, wget, BitchX ]
- Sistema [ instalwatch ]
- Utilidades [ grc, imwheel ]
Programação

Teclado

Consola

Aqui estão os meus mapas de teclado para a consola, desde que comecei a usar linux até agora usei sempre um mapa de teclado não standard, com a tecla BackSpace a corresponder a backspace e a tecla Delete a delete, pode parecer esquisito mas o default é ao contrario, com as teclas trocadas.

Depois de instalar o Test Cycle 2 do Potato (Debian) decidi fazer um mapa novo com o BackSpace e o Delete trocados, tem algumas vantagens porque os programas mais simples como o cp, mv (ao pedir confirmação) e mesmo o login (ao pedir a password), funcionam melhor desta maneira porque esperam as teclas ao contrário.

Condiguração default (teclas trocadas):
BackSpace = Delete,
Delete = Remove,

keycode  14 = Delete
keycode 111 = Remove

BackSpace = BackSpace,
Delete = Delete,

keycode  14 = BackSpace
keycode 111 = Delete

Contudo uma mudança destas no mapa de teclados implica alterar as configurações de outros programas (como o VIM) e do readline.

O meu mapa de teclado actual, e o mapa de teclado antigo (não aconselhado a principiantes =).

Testar com:

$ loadkeys nome_teclado

Os proprios ficheiros contêm informação de utilização.

X11

O meu xmodmap, testar com:

$ xmodmap ficheiro

coloquem esse comando no ficheiro ~/.xinitrc para que seja activado o mapa de teclado sempre que o X arranca.

Readline

O readline é uma library usada por vários pragramas em modo texto, normalmentre programas que têm uma linha de comandos, como o bash, o octave, etc. O readline oferece configuração de teclas, history, e ouras opções de edição. O ficheiro ~/.inputrc é usado para configurar a library, a variavel INPUTRC determina a localização do ficheiro.

O meu /etc/inputrc actual

As opções "meta" têm a ver com o numero de bits dos caracteres, os caracteres acentuados são de 8 bits, se queremos usar caracteres acentuados devemos activa-las.

set meta-flag on
set input-meta on
set output-meta on

A opção "completion-query-items" define o numero a partir do qual aparece a pergunta "Display all XXX possibilities? (y or n)" quando usamos a completação com a tecla TAB. Neste caso se houver mais de 200 hipoteses é feita a pergunta.

set completion-query-items 200

Para desactivar os "beeps" usamos:

set bell-style none

As duas linhas seguintes fazem com que a tecla PageUp/PageDown procurem no history do shell (lista dos comandos anteriores) o ultimo comando que coincida com o texto do comando actual até à posição anterior à do cursor.
A tecla PageDown só funciona no caso de não estarmos no fim do history, isto é, depois de usarmos a tecla Up ou PageUp.

"\e[5~": history-search-backward
"\e[6~": history-search-forward

Exemplo:
caso a linha de comandos se encontre no estado seguinte:

$ ls /var/log

com o cursor encima da letra "s" e carregarmos em PageUp, o shell vai procurar os comandos anteriores que comecem por "l", como "ln ..", "less ...".
No caso do cursor se encontrar encima da ultima "/" as opções seriam muito mais restritas, o shell iria procurar todos os comandos começados por "ls /var", experimentem ...

A linha seguinte faz com que a tecla Home se comporte como a combinação "ctrl a", move o cursor para o inicio da linha.

"\e[1~": beginning-of-line

A linha seguinte faz com que a tecla End se comporte como a combinação "ctrl e", move o cursor para o fim da linha.

"\e[4~": end-of-line

O meu /etc/inputrc antigo

Para mapas de teclados com as teclas BackSpace e Delete "como deve ser" é necessario acrescentar as linhas seguintes.
Esta linha faz com que a tecla Delete apague o caracter em que está o cursor:

DEL: delete-char

e esta faz com que a tecla BackSpace apague o caracter à esquerda do cursor.

"\C-h": backward-delete-char

Xterm / rxvt

Estes dois (e muitos outros) programas para o X usam o ficheiro de configuração ~/.Xdefaults.
Para o rxvt e o xterm usamos as linhas seguintes para configurar o BackSpace e o Delete.

XTerm*backspacekey:     ^H
XTerm*deletekey:        ^D

Para o xterm podemos redefinir as teclas usando:

XTerm**VT100.translations: #override \
        Home: string("\033[1~") \n\
        End: string("\033[4~")

Eterm

As configurações do Eterm são feitas atraves de themes, para alterar o theme default criamos o ficheiro ~/.Eterm/themes/Eterm/theme.cfg (0.9x) ou ~/.Eterm/themes/Eterm/MAIN (0.8x).
Para redefinir as teclas usamos a opção "keysym" na secção "keyboard":

keysym 0xff50 "\e[1\~"
keysym 0xff57 "\e[4\~"
keysym 0xff08 "^?"
keysym 0xffff "\e[3\~"

As duas primeiras linhas redefinem o Home e o End e as dua ultimas o BackSpace e o Delete.

indice

Shell

Eu uso o bash como shell, por isso toda a informação aqui contida é relativa a essa shell, embora não deva haver grandes diferenças em relação a outras shells, excepto na utilização de variáveis (ás quais são atribuidos valores usando `setenv variável valor` nas variantes de CSH) e gestão de processos.

Ficheiros de inicialização do BASH

/etc/profile:
Este é o ficheiro de inicialização global, afecta todos os utilizadores, deve ter permissões de escrita apenas para o utilizador root. Exemplo.

~/.bash_profile:
Este é o ficheiro de inicialização pessoal, e é executado apenas nos login shells (aqueles em que nos é pedida a password). Exemplo.

~/.bashrc:
Este é o ficheiro de inicialização pessoal que é lido cada vez que o BASH corre. O meu ~/.bashrc é um link para ~/.bash_profile.

Navegando pelo sistema de ficheiros

Ao contrário do resto dos mortais um utilizador de UNIX prefere navegar pelo sistema de ficheiros usando um shell a correr num terminal ou numa consola, em vez de usar um gestor de ficheiros grafico com icones de mil e uma cores =), tem varias vantagens, entre elas a rapidez e eficiência. Um dos principais problemas dos gestores de ficheiros graficos é não estarem perfeitamente sincronizados com o sistema de ficheiros.
O EFM e o KFM (das betas do KDE 2) já usam o FAM, um daemon que regista os acontecimentos relacionados com o sistema de ficheiros, através do imon (inode monitor, um patch para o kernel), e permite uma sincronização total entre a a informação que é mostrada e o estado do sistema de ficheiros.

Um sistema de ficheiros em UNIX está organizado em árvore, com directorias e ficheiros dentro de outras directorias, a directoria root (raiz, não confundir com o utilizador root) é representado pelo caracter "/", é o nivel mais alto, para obter uma lista dos ficheiros e directorias contidos na raiz usa-se:

$ ls /

para listar outros directorios usamos o nome do directorio em vez do directorio raiz.

Exemplos:

$ ls /etc
$ ls /home

o comando ls da maioria das distribuições Linux faz parte do GNU fileutils. A primeira coisa que eu faço quando trabalho num sistema alheio é personalizar o comportamento do ls com o comando "alias ls='/bin/ls -s --color'", de modo a mostrar o tamanho de cada ficheiro e com cores (ver dircolors).

Para mudar de directoria usa-se o comando cd, este é um comando interno da shell:

$ cd directorio

Exemplos:

$ cd /
$ cd /etc
$ cd /home

para voltarmos à nossa home directory usamos o comando cd sem argumentos ou um dos comandos seguintes:

$ cd ~
$ cd $HOME

o caracter "~", tal como a variavel HOME representam a nossa home directory. Se quisermos voltar para a directoria em que estavamos antes da ultima mudança usamos o comando:

$ cd -

o caracter "-" neste caso é equivalente à variavel OLDPWD. A variavel PWD contém sempre o path da directoria actual. Pode ser util guardá-la numa variável, para podermos lá voltar posteriormente, para isso usamos:

$ DIR=$PWD

isto guarda o conteudo da variavel PWD na variavel DIR. Para voltar lá depois usamos o comando:

$ cd $DIR

Pode ser util guardar directorias usadas frequentemente em variáveis, por exemplo os "mount points", assim, no ficheiro de inicialização (~/.bashrc ou /etc/profile) podemos pôr algo como:

export cdrom=/mnt/cdrom
export win95=/mnt/windows
export floppy=/mnt/floppy

depois podemos montar o CDROM com:

$ mount $cdrom

e ver o seu conteudo com:

$ ls $cdrom

supondo que os "mount points" referidos estão correcatmente definidos no ficheiro /etc/fstab.

Redireção

A redireção (>, <, >>, <<) é normalmente usada para enviar o output de um comando para um ficheiro.
Seguem-se alguns exemplos de utilização.

Criar ficheiros (>)

$ > ~/ficheiro_vazio
$ echo "algum texto" > ficheiro.txt

Acrescentar algo a um ficheiro (>>)

$ echo "mais algum texto" >> ficheiro.txt
$ cat parte_2.zip >> parte_1.zip

Os comandos anteriores usam apenas os operadores ">" e ">>", que redirectionam apenas o stdout, mas há comandos que além do stdout usam o stderr, que não é "apanhado" pelos operadores referidos. Para redirecionar o stderr usamos "2>", em vez de ">" (que é equivalente a "1>"). Para redirecionar ambos usamos "&>".

Fazer "log" do arranque do X

$ xinit &> xinit.log &

e da compilação/instalação de programas:

$ make &> make.log &
$ tail -f make.log

$ make install &> install.log &
$ tail -f install.log

Exemplo de um script usando o cat:

cat > ficheiro << EOF
linha 1
linha 2
linha 3
EOF

direcciona todo o texto entre EOF para o ficheiro.

Administração de processos

Vou usar o termo "processo" para designar qualquer programa que tenha sido executado e ainda não tenha terminado.
Quando um programa é executado, passa a estar activo, e é-lhe atribuido um numero de processo (PID), este numero é unico, e é usado pelo kernel para identificar o processo. Podemos usar o PID para comunicar com o processo atraves de sinais. O PID pode ser obtido usando o comando ps.

Vou usar o termo "tarefa" para designar qualquer processo executado sob uma shell.
Quando um programa é executado numa shell, é-lhe atribuido um numero de tarefa, este numero é unico relativamente aos processos executados na mesma shell, e pode ser usado para alternar entre eles. O numero de tarefa pode ser obtido usando o comando jobs, este comando, ao contrario do ps é um comando interno da shell bash.

Suspender uma tarefa em execução

A combinação de teclas

Ctrl z

suspende a tarefa em execução, a qual fica totalmente parada, nao recebe input, não faz output, e não processa dados (ex: correr o vi e carregar em Ctrl e z).

Listar tarefas

$ jobs

lista as tarefas suspensas na shell actual, tambem é um comando interno do bash.

Voltar á ultima tarefa

$ fg

retoma a execução da ultima tarefa suspendida, o comando fg tambem é um comando interno do bash (ex: como continuação do primeiro exemplo, voltariamos ao vi teclando fg no terminal no qual o suspendemos).

ou

$ %numero_de_tarefa

O numero_de_tarefa aparece à esquerda, entre [], quando o suspendemos ou quando executamos o comando jobs. Quando temos varias tarefas suspensos e usamos fg voltamos à ultima tarefa que suspendemos.

Continuar uma tarefa suspensa, em background

Quando suspendemos uma tarefa ela fica parada, para continuarmos a sua execução em background usamos um destes comandos, são equivalentes:

$ bg
$ %+&

isto só é util para tarefas que não necessitem de input do utilizador, como um rendering usando o POV-Ray, a compressão de ficheiros, etc, e nunca a edição de um ficheiro. O comando bg tambem é um comando interno do bash.

$ %numero_de_tarefa&

continua a execução da tarefa com numero_de_tarefa em background.

Iniciar uma nova tarefa em background

$ programa&

inicia uma nova tarefa em background.

Cancelar uma tarefa

Ctrl c

esta combinacao de teclas cancela a tarefa em execução, não funciona com todos os programas, por exemplo nos editores de texto é comum ser desactivada.

Matar um processo

$ kill PID
$ kill %num_tarefa

ao executar este comando estamos a enviar o sinal SIGTERM ao processo correspondente ao PID (PID pode ser uma sequência de numeros separada por espaços). Para enviar outros sinais usamos:

$ kill -SIG PID

em que SIG é o nome ou numero do sinal, para uma lista de sinais usar o comando "kill -l" ou para uma descrição mais completa "man 7 signal". Um comando muito usado é:

$ kill -9 PID

que envia o sinal SIGKILL, o qual força a morte do processo. O sinal SIGHUP é normalmente usado para reiniciar deamons (syslog por exemplo) depois de terem sido alterados ficheiros de configuração.

Prioridades

A prioridade de um processo define a ...

$ nice -n X programa&

executa o programa com prioridade X em background, X é um inteiro entre -20 e 19, -20 é a proiridade maxima.

$ renice +X PID
$ renice +X %numero_de_tarefa

muda a prioridade da tarefa com numero_de_tarefa ou do processo PID. Como é logico cada tarefa tambem tem um numero de processo, a unica limitação do uso do comando na segunda forma é que tem de ser usado na shell onde o programa foi corrido, se soubermos o PID da tarefa podemos usar o primeiro comando em qualquer shell.

Scrips

introdução

Um script é apenas um ficheiro contendo uma sequência de comandos.
Para que um script possa ser executado como um programa normal começamos por dar-lhe permissão de executável, para isso usamos o comando chmod:

$ chmod +x ficheiro

Para identificar um script normalmente colocamos na primeira linha:

#!/bin/sh

isto indica que o ficheiro vai ser executado pelo programa /bin/sh (a shell), existem outros tipos de scripts (scripts de python, scripts de perl, etc), dependendo do programa que os corre. Agora podemos correr o script simplesmente fazendo:

$ ./ficheiro

Para correr scripts que não tenham permissão de executavel usa-se um dos seguintes comandos:

$ sh ficheiro
$ source ficheiro
$ . ficheiro

no primeiro caso é executado uma shell (/bin/sh) novo para correr o script, no segundo caso usa-se a shell actual. O segundo caso é normalmente usado para actualizar variaveis do sistema depois de modificado um ficheiro da shell (/etc/profile, ~/.bashrc, etc), o que não é possivel com o primeiro comando, porque as variaveis vão ser criadas na nova shell, o qual termina depois de processado o ficheiro. O terceiro caso é equivalente ao segundo.

for

for variavel in lista; do
  comandos
done

Exemplo 1:

for I in 0 1 2 3 4 5 6 7 8 9; do
  echo $I
done

Exemplo 2:

for file in *; do
  echo $file
done

while

while condição; do
  comandos;
done

Exemplo:

var=s
while [ $var == "s" ]; do
  echo -n "> sim ou não [s/n]: "
  read var
done

case

case palavra in
  expressao) comandos ;;
esac

Exemplo:

echo -n "Insira um numero: "
read num
case $num in
  1) echo one ;;
  2) echo two ;;
  3) echo tree ;;
  *) echo numero desconhecido ;;
esac

a expressão "*" representa o caso por defeito, é usado quando nenhum dos outros se aplica.

funções

Uma função tem a seguinte sintaxe:

função ()
{
  # corpo da função
}

pode depois ser chamada de dentro de outra função ou de qualquer parte do script, a chamada faz-se escrevendo apenas o nome da função:

# chamada á função
função

é possivel usar recursividade, chamando a função dentro dela propria.
Para passar parâmetros a uma função que faça uso deles (como a seguinte):

função ()
{
  # numero de parametros
  echo "> numero de parâmepros: $#"
  # parametros
  echo "> parametros: $@"
}
função $@

acrescentamo-los a seguir ao nome da função quando a chamamos, no exemplo, a ultima linha chama a função com todos os parametros dados na linha de comandos, dentro da função podemos tratar os parametros separadamente.

$# - numero de parâmetros passados à função
$@ - todos os parâmetros passados à função
$0 - comando executado para correr o script
$1 - primeiro parâmetro
$2 - segundo parâmetro
$x - x-ésimo parâmetro
$? - status do ultimo programa executado

para mais informaçõs sobre paramentros ver a secção "PARAMETERS/Special Parameters" no manual do BASH.

dialog

O comando dialog é usado para mostrar caixas de dialogo num script, e da experiência que tive não gostei muito, foi necessário guardar a opção selecionada (de um menu por exemplo) num ficheiro, depois ler o seu conteudo para uma variável e finalmente testar o valor num ciclo "case".

Tipos de caixas: yesno, msgbox, infobox, inputbox, textbox, menu, checklist, radiolist e gauge.

Script de exemplo:

#!/bin/sh

# chama o programa dialog, o caracter "\" no fim da linha indica que a
# proxima linha e' a continuacao do mesmo comando
dialog --backtitle "Exemplo" --title "Menu" \
# neste caso usamos um menu, os tres numeros representam
# o tamanho da janela
  --menu "" 13 50 6 \
# a seguir estao as opcoes
  "1" "Primeira opcao" \
  "2" "Segunda opcao" \
  "3" "Terceira opcao" \
  "s" "Sair" \
# a opcao escolhida vai parar ao "stderr" por isso temos que
# redireciona-la para um ficheiro, o comando acaba aqui
  2> escolha

# o conteudo do ficheiro e' colocado numa variavel
opcao=`cat escolha`
# agora usamos a opcao escolhida para decidir o que fazer
case $opcao in
  1) clear; echo -e "Primeira opcao escolhida\n";;
  2) clear; echo -e "Segunda opcao escolhida\n";;
  3) clear; echo -e "Terceira opcao escolhida\n";;
  s) clear; echo -e "Volte sempre\n";;
esac

Escape sequences

As "escape sequences" são uteis nos scripts, para colorir e especificar a localização das mensagens de output.

\033[A;Cmtexto

Escreve texto com a cor C e atributos A, exemplo:

$ echo -e "\033[1;34mBlue \033[1;31mRed\033[0m"

Os atributos (A) são:

se activarmos um atributo, ele permanece activo ate definirmos o atributo nulo (00), o qual desactiva todos os atributos.

As cores (C) são:

\033[CGtexto

Escreve o texto na coluna C, exemplo:

$ echo -e "\033[36GColumn 36"

\033[LAtexto

Posiciona o cursor L linhas acima da linha actual (ter em atenção a mudança de linha cusada pela tecla ENTER ao executar o comando) e escreve o texto, exemplo:

$ echo -e "\033[1AOne line above"

Combinação de comandos

Todos os comandos descritos até agora podem ser combinados, exemplo:

$ echo -e "\033[1A\033[36G\033[01;34mBig \
	\033[31mM\033[04;32mI\033[00;01;35mX\033[0m"

neste comando mostramos "Big" em azul com atributo bold, depois mostramos "M" em vermelho, o atributo bold continua activo, depois activamos o atributo underlined e mostramos "I" em verde, ainda com o atributo bold, depois desactivamos todos os atributos, activamos o atributo bold e mostramos "X" em roxo, agora sem o atributo underlined, e por fim desactivamos todos os atributos.

Utilização em outras linguagens

Tal como usamos as escape sequences no comando echo podemos usa-las em qualquer linguagem de programação incluindo-as no string a mostrar no ecrã, exemplo (em C):

printf ("\033[1;34mBlue \033[1;31mRed");

Visualizando ficheiros

lesspipe.sh

O lesspipe.sh é um script usado por vários programas para fazer o "pre-processamento" de ficheiros, por exemplo, para ver o conteudo de um ficheiro compactado temos que descompacta-lo antes, passando o ficheiro pelo respectivo descompactador (gunzip, bunzip2, unzip, etc), se for uma man-page passamo-lo pelo "groff", se for um MP3 podemos usar o "mp3info" ou o mpg123, tudo depende da informação que queremos "ver" acerca do respectivo ficheiro.

O script é composto por uma função "lesspipe()" que, dependendo da extensão do ficheiro de entrada, executa um comando ou uma sequencia deles (usando pipes, etc) sobre o mesmo, o output resultante vai então ser devolvido ao programa que chamou o lesspipe.sh. Os comandos dependem da informação que queremos obter do ficheiro.

Exemplo:

lesspipe() {
  case "$1" in
    *.tar.gz|*.tgz|*.tar.z)   tar ft  $1 2>/dev/null ;;
    *.gz|*.z)                 gunzip -c $1 2>/dev/null ;;
    *.bz2)                    bunzip2 -c $1 2>/dev/null ;;
    *.zip)                    unzip -l $1 2>/dev/null ;;
    *)                        file $1 ;;
  esac
}
lesspipe $1

O script deve estar no PATH, podemos substituir o que já existe (normalmente /usr/bin/lesspipe.sh) ou guardar o nosso em ~/bin e fazer com que essa directoria apareca antes das outras no PATH (export $PATH=~/bin:$PATH), para que seja usado o nosso script e não o do sistema.

Alem disso è necessario que o comando:

$ export LESSOPEN="|lesspipe.sh %s"

seja incluido num dos ficheiros de inicializacao: /etc/profile (caso tenhamos permissoes para isso) ou ~/.bash_profile (caso contrario).

nota: O Debian 2.2 (Potato) traz um lesspipe muito mais complexo, e sem a extensão ".sh".

O programa "less" usa esta variavel, é muito mais confortável fazer "less ficheiro.tar.gz" do que "tar zft ficheiro.tar.gz | less".

mailcap

O ficheiro mailcap (~/.mailcap) é usado por vários programas, como por exemplo o "mutt" ou o "w3m", para vizualizar certos tipos de ficheiros não suportados internamente, como imagens, sons, etc. Este ficheiro usa MIME para identificar o tipo de ficheiro, só temos que inserir o tipo MIME e o programa que queremos usar para abrir os ficheiros desse tipo.

Exemplo:

image/*; feh %s
audio/mp3; mpg123 %s
audio/mod; xmp %s

Usando o diff e o patch

O diff é usado para mostrar as diferenças entre dois ficheiros ou directorias (todos os ficheiros dentro delas):

$ diff -c ficheiro1 ficheiro2 > ficheiro.diff
$ diff -c dir1 dir2 > dir.diff

se um dos argumentos for um ficheiro e o outro uma directoria, o diff procura um ficheiro com o mesmo nome dentro da directoria. Como o output das diferenças é feito para o terminal, redirecionamo-lo para um ficheiro.

Ao ficheiro que contém o output do diff chama-se normalmente um patch (quando se trata de diferenças entre duas versões de um programa), é comum usar-se a opção "-u" do diff para incluir algumas linhas de contexto em cada diferença. Para aplicar um patch descomprimido usamos:

$ patch -p0 < diff_file

e no caso de um patch comprimido:

$ bunzip2 < diff_file.bz2 | patch -p0
$ gunzip < diff_file.gz | patch -p0

os comandos referem-se a um diff comprimido com o bzip2 e o gzip respectivamente.

Dividindo ficheiros

Quando temos um ficheiro grande e queremos dividi-lo em vários ficheiros mais pequenos (para transporta-los em disquetes por exemplo) podemos usar o comando split:

$ split -b bytes ficheiro prefixo

o ficheiro vai então ser dividido em vários ficheiros começados por prefix e com tamanho bytes (para disquetes de alta densidade pode usar-se "1420k", atenção, o "k" multiplica o valor por 1024), ao prefix acrescentam-se varias letras dependendo do numero de divisoes feitas, normalmente são acrescentadas duas letras, "aa" para a primeira parte, "ab" para a segunda e assim sucessivamente.

Para obtermos o ficheiro original temos que concatenar todas as partes, usando o comando cat:

$ cat prefix?? > total

isto supondo que temos apenas dois caracteres para diferenciar as varias partes (cada ponto de interrogação representa um caracter variavel). Pode-se chegar ao mesmo resultado concatenando uma parte de cada vez:

$ cat prefixaa >> total
$ cat prefixab >> total
...

$ cat prefixaa prefixab ... > total

pode ser util para fazer "remixes" de mp3 trocando a ordem das partes =).

Comandos uteis

date

O comando date pode ser muito util, num script de backup por exemplo, podemos usa-lo para ter um nome diferente para os ficheiros criados, dependendo da data actual (dia, hora, minuto, segundo, etc).

Por exemplo, para criarmos um ficheiro vazio com a data actual no nome basta fazer o seguinte:

$ > `date "+%d-%m-%Y"`_ficheiro

Script de exemplo:

#!/bin/sh
DATE=`date "+%y%m%d"`

echo -e "> Criando um backup de alguns ficheiros em /etc"
echo -e "> O ficheiro de backup é ~/$DATE-backup.tar.gz"
tar zfc ~/$DATE-backup.tar.gz /etc/profile /etc/mtab &>/dev/null
echo -e "> Backup completo"

Tambem serve para acertar a hora do sistema,

# date -s "hora:minuto:segundo"

cut

O comando cut é usado para obter um campo de um string. No ficheiro /etc/passwd cada linha está dividida em 7 campos diferentes, para obtermos o campo 2 de cada linha (a password encriptada, ou "x" no caso do sistema usar shadow passwords) usamos o comando:

$ cut -d ':' -f 2 < /etc/passwd

o parametro "-d ':'" especifica o delimitador do campo (o caracter que separa os varios campos), o parametro "-f 2" (field 2) representa o segundo campo. Isto devolve-nos um caracter em cada linha, se guardarmos a saida do comando numa variavel obtemos um string com os varios elementos separados por espaços:

$ campos=`cut -d ':' -f 2 < /etc/passwd`
$ echo $campos

para obtermos o nome (pode conter mais informação como a morada, etc) de um utilizador especifico temos que "seleciona-lo" primeiro, usando o grep, e extrair o campo 5:

$ campo=`grep "^utilizador:" /etc/passwd | cut -d ':' -f 5`
$ echo $campo

ar

O ar é usado para criar e modificar arquivos (um unico ficheiro que contém outros ficheiros numa estructura que permite recuperar os ficheiros individuais nele contidos).

O ar é usado para manipular os pacotes (ficheiros deb) da distribuição Debian. Para listar o conteudo de um ficheiro deb usamos o comando,

$ ar tv ficheiro.deb

Para extrairmos o programa de um ficheiro deb usamos,

$ ar xv ficheiro.deb data.tar.gz

o ficheiro data.tar.gz contém os ficheiros do programa, e pode ser manipulado usando o programa tar, os outros dois ficheiros, control.tar.gz e debian-binary, são usados pelo dpkg para fazer a instalação do pacote num sistema Debian.

tar

O programa tar, tal como o ar, é usado para manipular arquivos, os arquivos gerados pelos dois programas são incompativeis.

Para listar o conteudo de um arquivo tar usamos a opção contents,

$ tar ft ficheiro.tar

Para extrairmos ficheiros de um arquivo tar usamos a opção extract,

$ tar fx ficheiro.tar ficheiro(s)_a_extrair

Para criar um arquivo tar usamos a opção create,

$ tar fc ficheiro.tar ficheiros/directoria

Para manipular arquivos comprimidos com o GNU gzip adicionamos a opção 'z' ás outras duas opções.
Para manipular arquivos comprimidos com o bzip2 adicionamos a opção 'I' ou 'y', dependendo da versão do tar.

Outra opção para manipular arquivos comprimidos, que não depende da versão do tar é usar o pipe (|),

$ gzip -cd ficheiro.tar.gz | tar ft -
$ bzip2 -cd ficheiro.tar.bz2 | tar ft -

os ficheiros são descomprimidos para o stdout (-cd) usando o respectivo programa, e enviados para o tar através do pipe. Atenção ao '-' depois do tar que significa "ler os dados do stdin e não de um ficheiro".

Usando consolas / terminais

Consolas

As consolas (em modo texto) são normalmente usadas para correr "gettys", programas que esperam que o utilizador faça login, eu uso o "mingetty", que não suporta login por portas série e portanto é mais pequeno, além disso limpa o ecrã por defeito depois de um logout. Para substituir o "getty" pelo "mingetty" alteramos as linhas correspondentes do ficheiro /etc/inittab depois de colocar o programa na directoria /sbin:

linhas antigas:

1:2345:respawn:/sbin/getty 9600 tty1
2:23:respawn:/sbin/getty 9600 tty2
3:23:respawn:/sbin/getty 9600 tty3
4:23:respawn:/sbin/getty 9600 tty4
5:23:respawn:/sbin/getty 9600 tty5
6:23:respawn:/sbin/getty 9600 tty6

linhas novas:

1:2345:respawn:/sbin/mingetty --noclear tty1
2:23:respawn:/sbin/mingetty tty2
3:23:respawn:/sbin/mingetty tty3
4:23:respawn:/sbin/mingetty tty4
5:23:respawn:/sbin/mingetty tty5
6:23:respawn:/sbin/mingetty tty6

o parametro "--noclear" impede que o ecrã seja limpo, é usado na primeira consola para permitir ver as mansagens de arranque do sistema, todas as consolas excepto esta são limpas ao fazer "logout" (Ctrl d).

As consolas podem ser usadas para outras coisas como correr programas que mostram os logs do sistema em tempo real.
Para termos o ficheiro /var/log/messages a ser mostrado na consola 9 podemos acrescentar o comando seguinte ao ficheiro /etc/inittab (requer permissoes de root):

c9:123:respawn:/usr/bin/tail -f /var/log/messages > /dev/tty9

se tivermos o grc podemos ver o output a cores usando o seguinte (removam o caracter '\' e coloquem tudo numa linha):

c9:123:respawn:/usr/bin/tail -f /var/log/messages | \
	/usr/local/bin/grcat conf.log > /dev/tty9

outra maneira de obter o mesmo resultado (sem cores) é configurando o syslog, adicionando algo como o seguinte ao ficheiro /etc/syslog.conf:

daemon,mail.*;\
	        news.=crit;news.=err;news.=notice;\
	        *.=debug;*.=info;\
	        *.=notice;*.=warn       /dev/tty9

Comandos para gerir consolas

Para correr um comando numa consola livre usamos:

$ openvt -c num comando

o output do programa vai parar à consola num, para limpar todas as consolas livres (nas quais não está a correr nada) usamos o comando:

$ deallocvt num

este comando limpa a memoria e estructuras de dados do kernel referentes à consola num. Se não é dado nenhum parametro todas as consolas livres são limpas.

Terminais

Um terminal (na realidade um "emulador de terminal", pois emula um terminais em modo texto) é como uma consola a correr dentro de uma janela do X. Existem vários programas deste tipo, o xterm vem incluido no Xfree86, por isso tem mais probabilidade já estar instalado, outros fazem parte dos actuais ambientes de trabalho, o kvt/konsole vem incluido no KDE e o gnome-terminal com o GNOME, o Eterm é o mais apelativo graficamente e o mais configuravel.

A vantagem de usar terminais é que podemos ter mais de um visivel ao mesmo tempo e copiar/colar texto directamente entre eles. Podemos usar terminais para funções especificas como mostrar os logs do sistema, usando um script como este, e correndo o terminal com o parametro "-e script.sh", neste caso podemos tê-los sempre visiveis.

Teclas

A combinação Ctrl s "pausa" o fluxo de texto (equivale à tecla Scroll Lock na consola), e pausa o programa em execução, só o output, isto é util para ler informação que passa depressa, como as mensagens geradas pelo gcc, é mais util na consola onde temos um buffer menor, num terminal podemos definir o numero de linhas a guardar. Para reverter o efeito usa-se a combinação Ctrl q (ou pressiona-se novamente Scroll Lock).

Para ver as linhas que ficam para trás usam-se as combinações de teclas Shift PageUp e Shift PageDown.

Termcap/terminfo

O termcap e o terminfo são dois métodos que possibilitam o controlo total de um terminal, ambos usam um sistema de base de dados contendo as caracteristicas dos vários terminais suportados. O termcap foi desenvolvido ao mesmo tempo que o editor de texto vi para que este fosse independente do terminal, o terminfo apareceu depois, actualmente são ambos incluidos no ncurses.

A base de dados de terminais termcap consiste num so ficheiro, normalmente guardado em /etc/termcap, é um ficheiro ASCII, toda a informação é legivel (mas talvez não compreensivel =) e pode ser modificada com um editor de texto. Cada entrada consiste numa lista de nomes do terminal, seguida de uma lista das caracteristicas do terminal.

A base de dados do terminfo consiste numa hierarquia de directorias em /usr/lib/terminfo. Cada definição de terminal é compilada usando o programa tic e guardada num ficheiro. Todos as definições começadas pela letra a estao na directoria /usr/lib/terminfo/a, isto funciona para todas as letras. As definições podem ser descompiladas ou visualisadas usando o programa infocmp.

Um programa que queira usar o termcap/terminfo lê a variavel TERM para saber qual a definição a usar. Esta variavel é usada do seguinte modo:

$ export TERM=terminal

para saber o valor actual da variavel usa-se:

$ echo $TERM

o valor normalmente usado numa consola é linux. Num terminal no X o valor da variavel depende da configuração do ternimal, os mais usados são xterm e xterm-color.

dircolors

O comando dircolors (incluido no GNU fileutils) é usado para inicializar a variavel LS_COLORS de acordo com o conteudo do ficheiro usado ao chamar o programa:

$ eval `dircolors /etc/DIR_COLORS`

neste caso é usado o ficheiro /etc/DIR_COLORS, o default, nas ultimas versões do dircolors nem é preciso inclui-lo na linha de comando. Este comando é normalmente colocado num dos scripts de inicialização.
O programa ls usa a variavel referida para colorir os vários tipos de ficheiros, para isso é necessario usar o parametro "--color", normalmente inclui-se um alias num dos ficheiros de inicialização:

$ alias ls='/bin/ls --color'

Este é o meu DIR_COLORS.

indice

Programas

Internet

WWWOFFLE

introdução

O WWWOFFLE é um proxy cache, serve para manter uma cache das paginas (HTTP) e sites de ftp (FTP) acedidos recentemente, para que possam depois ser acedidos "offline".

utilização

Usando as seguintes variaveis podemos usar o lynx ou o w3m para "navegar" pelos sites que estão em cache:

$ export http_proxy="http://localhost:8080"
$ export ftp_proxy="http://localhost:8080"

estes comandos podem ser introduzidos num script de arranque (/etc/profile, ~/.bash_profile).

atenção: a variavel ftp_proxy, quando usada deste modo impossibilita o programa wget de fazer resume de ficheiros (começam do pricipio).

Para fazer com que o netscape use o WWWOFFLE basta introduzir "http://localhost:8080/wwwoffle.pac" em Edit/Preferences.../Advanced/Proxies/Automatic proxy configuration.

configuração

Utilizando o ficheiro de configuração, normalmente /etc/wwwoffle.conf, podemos por exemplo impedir que seja visto o conteudo de alguns sites (pode ser util para evitar a publicidade), colocando os enderecos indesejados na secção DontGet:

DontGet
{
 *://ads.*/*
 *://ad-*/*
 *://ad.*.com/*
}

para acrescentar mais enderecos basta saber qual a localizacao de uma imagem que se queira deixar de ver (copy image location, no netscape) e substituir a parte final do endereco por um '*', normalmente existem sites especificos que contêm apenas publicidade. Infelizmente parece que existem paginas que não abrem se não conseguirem aceder à publicidade.

A secção DontCache é usada para definit o tipo de ficheiros que não queremos manter em cache, normalmente ficheiros grandes como *.tgz, *.tar, *.gz, *.zip, e ficheiros que gravamos no disco como *.pdf, *.ps, etc:

DontCache
{
 *://*/*.gz
 *://*/*.tgz
 *://*/*.tar
 *://*/*.rar
 *://*/*.zip
 *://*/*.slp
 *://*/*.ps
 *://*.*.psz
 *://*/*.pdf
}

nota: estes ficheiros só ficam em cache se fizermos download usando o proprio browser (save link as..., no netscape), um modo de evitar isso é usar o programa wget.

wget

Introdução

O wget é um programa de linha de comando usado para "puxar" ficheiros de sites http e ftp. É um programa não interactivo (pode funcionar sem a "ajuda" do utilizador), isto é, podemos deixa-lo a fazer download de ficheiros em background, ou mesmo depois de fazer logout, util se tivermos conta num sistema que esteja sempre On-Line.

Utilização

$ wget http://site/ficheiro
$ wget ftp://site/ficheiro

O wget pode fazer resume de ficheiros, isto é continuar a "puxar" um ficheiro desde o ponto em que foi interrompido, isto depende do site onde está o ficheiro, alguns sites suportam resume, outros não. Para usar resume usa-se a opção '-c':

$ wget -c http://site/ficheiro
$ wget -c ftp://site/ficheiro

Pode-se criar um script com varios links a "puxar" abrindo um editor de texto e inserindo os links a puxar (ir ao netscape, clickar com o botão direito do rato no link, selecionar "Copy Link Location" no menu, e colar o link no ficheiro usando o rato ou Shift+Insert), depois é só adicionar "wget -c " ao principio de cada linha e correr "sh script" num terminal, podemos interrompê-lo em qualquer altura com Ctrl+C e continuar depois executando o mesmo comando ("sh script"). Convêm remover as linhas correspondentes aos links que já foram puxados, se não o fizermos corremos o risco de o wget puxar esses ficheiros desde o inicio, perdendo o ficheiro original.

Também é possivel usar recursividade, isto é, "puxar" todos os ficheiros contidos no endereço dado, se é um site ftp podemos usar wildcards (?, *, etc):

$ wget -r http://site/ficheiro
$ wget -r ftp://site/ficheiro_com_wildcards

cuidado com esta opção.

BitchX

O BitchX é um cliente de IRC em modo texto.

Variaveis

As seguintes variaveis devem ser definidas num dos ficheiros de inicialização.

export IRCSERVER="irc.netc.pt irc.telepac.pt"
export IRCNICK="o_meu_nick"
export IRCNAME="talvez_o_meu_nome_real"

Utilização

Alguns comandos standard de IRC:

/nick nick - altera o nick para nick =)
/j canal - entra no canal
/who - mostra quem está actualmente no canal
/part - sai do canal actual
/whois nick - mostra informação sobre o nick
/msg nick mensagem - envia mensagem a nick
/dcc send nick ficheiro - envia o ficheiro a nick

/quote nickserv register nick password - regista um nick, só é necessario uma vez
/quote nickserv identify password - identifica o nick (actual), necessario cada vez que nos ligamos
/quote nickserv info nick - mostra informação sobre o nick

Configuração

O meu ~/.bittchxrc que chama o script de configuração e o script de auto-identificação.

Sistema

instalwatch

O installwatch é um programa muito util para quem compila e instala os programas a partir da distribuição source. Usa-se da seguinte forma:

$ installwatch -o logfile make install

depois de ter compilado um programa, ao instalar, em vez de usar o tradicional "make install" usamos o installwatch para guardar um logfile de todos os ficheiros criados durante a execução do comando "make install", podemos fazer um script para fazer um "tar.gz", "deb", "slp", etc, dos ficheiros instalados, um script para fazer um RPM é incluido na ultima versão.

Utilidades

grc

Introdução

O grc (generic coloriser) é um script em python que processa o texto que lhe é enviado através de um pipe (|) ou redirecionado (<) e atribui cores a certas partes do texto, conforme as definições do ficheiro de configuração utilizado.
Ao contrário de outros scripts como o logcoloriser (script em Perl), que têm como objectivo colorir apenas ficheiros de log como os gerados pelo syslog, o grc pode ser usado para colorir qualquer tipo de texto, é configurado através de ficheiros de texto contendo expressões regulares que definem o texto que queremos colorir, as cores a atribuir a cada parte do texto e se procuramos uma ou mais ocorrências em cada string.

Utilização

Estes são os meus ficheiros de configuração (conf.log e conf.gcc), junto vão ficheiros de teste (test.log e test.gcc) para testar os ficheiro de configuração.

O ficheiro conf.log é usado para colorir o output do syslog.

Teste do conf.log:

$ grcat conf.log < test.log

Exemplos de uso geral:

$ grcat conf.log < /var/log/syslog
$ tail -f /var/log/syslog | grcat conf.log

o segundo comando é geralmente usado num terminal pequeno e sem "decorações" (se estamos a usar o X) ou é redirecionado para uma consola disponivel (como /dev/tty12), para sabermos sempre o que está a acontecer na maquina.

O ficheiro conf.gcc serve para colorir o output do gcc, util ao compilar programas.

Teste do conf.gcc:

$ grcat conf.gcc < test.gcc

Exempo de uso geral:

$ make | grcat conf.gcc

Os ficheiros

Os ficheiros de configuração são baseados em expresões regulares, seguem-se apenas alguns exempos, para mais informaçõs ler o ficheiro Regexp.txt e os ficheiros de exemplo que acompanham o grc.

# -qualquer string que contenha "kernel" (todo o string)
# -usa a cor "cyan"
# -procura "kernel" uma vez so em cada string
regexp=.*kernel.*
colours=cyan
count=once
...
# -formato hora:minuto:segundo, cada campo com dois digitos
# -cor verde em bold (verde claro caso o terminal não suporte bold)
# -procurado uma vez em cada string
regexp=\d\d:\d\d:\d\d
colours=bold green
count=once
...
# -numeros em formato Hexadecimal, i.e. comecados por "0x" e contendo
#  um digito de 0 a 9 (\d) ou uma letra de "a" a "f" maiuscula ou minuscula,
#  uma ou mais vezes (+), e terminado por um caracter em branco ou mudanca de
#  linha (\S)
# -cor cyan bold
# -todos os numeros em Hex que forem encontrados no string são coloridos
regexp=0x[\d[a-fA-F]+\S
colours=bold cyan
count=more
...

imwheel

Utilização

O imwheel é um programa que associa teclas a eventos do rato, isto é util para quem tem um rato com roda ou botões extra, eu estou a usá-lo para configurar o meu IntelliMouse Optical, antes de tudo é necessário configurar o rato no /etc/X11/XF86Config, estas são as minhas configurações actuais para o XFree86 4.X:

Section "Pointer"
  Device     "/dev/psaux"
  Protocol   "ExplorerPS/2"
  Buttons    7
  ZAxisMapping 6 7
EndSection

o "ZAxisMapping" faz com que as funções normalmente atribuidas à roda (botões 4 e 5) sejam atribuidas aos dois botões extra (6 e 7), foi a unica maneira que encontrei de "activar" esses botões, caso contrário não são detectados. Depois uso o comando seguinte (no ficheiro ~/.xinitrc) para que a roda volte a funcionar normalmente

xmodmap -e "pointer = 1 2 3 6 7 4 5"

Para correr o imwheel usa-se o seguinte comando depois de ter o X funcionar:

$ imwheel -k

coloquem-no no ficheiro ~/.xinitrc para que corra automaticamente quando o X arranca. O parâmetro '-k' faz com que sejam terminadas outras instâncias do programa caso existam em memória.

Configuração

A configuração do imwheel é guardada no ficheiro ~/.imwheelrc, esta é a minha configuração actual. Para reconfigurarmos o imwheel basta editar o ficheiro e voltar a executar o comando mencionado atrás.

"^programa*"
campo 1, campo 2, campo 3 [, campo 4]
...

O ficheiro está dividido em vários blocos com a forma do anterior, na primeira linha de cada bloco definimos o programa em que estes eventos vão funcionar, se a janela com focus tiver um titulo ou nome começado por "programa" serão estes os eventos a associar.
Nas linhas seguintes associamos os eventos do rato a combinações de teclas. Normalmente usam-se 3 ou 4 campos separados por virgulas.

No primeiro campo definimos uma tecla modificadora:

Control_L - tecla Control esquerda
Control_R - tecla Control direita
Alt_L - tecla Alt esquerda
Alt_R - tecla Alt direita
Shift_L - tecla Shift esquerda
Shift_R - tecla Shift direita

No segundo definimos o evento do rato que quando executado em combinação com a tecla definida anteriormente gera a acção no 3º campo. No meu rato os evento são os seguintes:

Up - roda para cima
Down - roda para baixo
Left - botão esquerdo
Right - botão direito

O 4º campo é um numero opcional, se existir a acção do 3º campo é repetida esse numero de vezes.

Exemplo:

# associações para o Browser Galeon
"^Galeon*"

# move a página 7 linhas para cima ou para baixo
# quando a roda é movida 1 vez na respectiva direcção
None, Up, Up, 7
None, Down, Down, 7

# move a pagina 7 colunas para a esquerda ou para a direita
# quando a roda é movida uma vez para cima ou para baixo enquanto é
# pressionada a tecla Control esquerda
Control_L, Up, Right, 7
Control_L, Down, Left, 7

# botão esquerdo volta à pagina anterior (botão Back do Browser)
# botão direito vai para a página seguinte (botão Forward do Browser)
None, Left, Alt_L|Right
None, Right, Alt_L|Left

Quando usamos "^.*" na primeira linha do bloco estamos a afectar todos os programas que não se identificam com nenhum dos outros blocos do ficheiro:

"^.*"
None, Up, Up
None, Down, Down
None, Left, Left
None, Right, Right
Control_L, Up, Right
Control_L, Down, Left

indice

Programação

Há tanta coisa para escrever que nem sei por onde começar, aqui fica o básico ...

Compilar

usando o gcc

O gcc é o compilador usado por defeito em Linux, para compilar um programa constituido por apenas um ficheiro C usamos o comando:

$ gcc ficheiro.c -o ficheiro -llib

Antes de tudo é necessário dizer que as funções basicas de C (printf, scanf, etc) estão incluidas na libc (GNU C library, em português, biblioteca de C da GNU), e que esta lib é usada automaticamente pelo GCC sem ser necessário especificá-lo explicitamente, e é representada pelo ficheiro /lib/libc.so.(versão). Para que uma lib possa ser usada num programa é necessario que o sistema a encontre (podemos ver a lista de todas a libs detectadas pelo sistema (e actualizar essa lista) usando o seguinte comando (como root): "/sbin/ldconfig -v". Para acrescentar novas libs ao sistema acrescenta-se a sua directoria ao ficheiro (se for necessario) /etc/ld.so.conf e corre-se o comando referido anteriormente.

Para usar uma das libs presentes acrescenta-se "-llib" à linha de comando do GCC, para usar funções matematicas da libm (/lib/libm.so.X, que acompanha a GNU libc) por exemplo, acrescentamos "-lm". Para usar algumas libs torna-se necessário dizer em que directoria se encontram, para isso usamos o parâmetro "-Ldirectoria", o que não é necessário para as directorias /lib e /usr/lib.

Para que o nosso programa saiba as definições das funções usadas no programa são incluidos ficheiros (usando a directiva "#include") que contêm essas definições, os quais são chamados "header files", e usam a extensão .h, por vezes torna-se necessário especificar a localização desses ficheiros, para isso usamos o parâmetro "-Idir".

makefiles

Os Makefiles destinam-se a automatizar o processo de compilação e instalação de um programa (embora possa ser usado para outros fins). O ficheiro deve ser chamado "Makefile" ou "makefile", e deve ter a seguinte estructura:

CC = gcc
SOURCES = file1.c file1.h
MAINFILE = file1.c
PROGRAM = prog

prog: $(SOURCES)
	$(CC) $(MAINFILE) -o $(PROGRAM)

clean:
	rm -f *.o *~ core

install:
	cp $(PROGRAM) $(HOME)/bin

As palavras seguidas de ":" são os comandos que podemos usar com o make ("make clean", "make install", etc), o primeiro comando é o default (usado quando corremos apenas "make"), todos as linhas a seguir ao ":" começam com um "tab". O primeiro comando (prog:) tem $(SOURCES) na mesma linha, isto faz com que este comando dependa desta variavel, que neste caso é uma lista de ficheiros, se algum destes ficheiros for alterado depois de uma primeira execução o comado é executado novamente, caso contrário isso não é necessário.

topo | anterior / inicio