Inicialmente, eu separaria este texto em vários módulos. Porém, optei por faer algo mais sucinto e criar apenas este módulo – que complementa o Módulo #0, sobre os comandos básicos do Linux.

Neste módulo, serão abordados vários temas da programação em Shell (Bash), desde variáveis e funções, até expansões, expressões regulares etc.

Sem mais delongas, vamos ao que interessa! :)

Sumário

0. Scripts Shell
1. Variáveis
1.1 Variáveis de Ambiente
1.2. Variáveis Especiais
2. Controle de Fluxo
2.1. Condicionais
2.1.1. if
2.1.2. case
2.1.3. select
2.2. Estruturas de Repetição (Loops)
2.2.1. for
2.2.2. while
2.2.3. until…do
2.2.4. break
2.2.5. continue
3. Padrão C/C++ em Expressões “(())”
4. Entrada/Saída
4.1. Redirecionamento
4.2. Usando Pipelines
5. Expansões
5.1. Expansão de Variáveis
6. Parâmetros de linha de comando
7. Definindo Funções
7.1. Retorno de Funções
8. Expressões Regulares em Bash
9. Expressões Matemáticas
10. O Arquivo .bashrc
11. Aliases (Apelidos)
12. Referências

0. Scripts Shell

Antes de mostrar os recursos do shell, vamos dar uma olhada na maneira como devemos criar scripts shell. Isso facilitará a compreensão do restante do artigo.

Todo arquivo com códigos shell deve ter, na primeira linha, o identificador do interpretador a ser utilizado. A “linha mágica” que chama o interpretado bash é:

#!/bin/bash

O mesmo vale para outras linguagens interpretadas, como PHP, Python, Ruby, Perl etc.

Tendo essa linha no início do arquivo, o segundo passo é dar permissão de execução ao arquivo:

$ chmod +x script.sh
<pre>
 
Feito isso, basta executar o script:
 
<pre lang="bash">
$ ./script.sh

Também é possível executar o script usando o comando bash:

$ bash script.sh

Assim não é necessário haver a “linha mágica” no início do script. Também não é preciso dar permissão de execução ao arquivo.

1. Variáveis

O Bash, assim como muitas outras linguagens, possui o conceito de variável. Para definir uma variável:

nome_da_variavel="valor da variável"

É importante ressaltar que não deve haver espaços entre o símbolo de atribuição, o nome da variável e seu valor, para que o bash interprete o comando como atribuição, não chamada de comandos.

Para exibir o valor de uma variável, basta usar echo da seguinte forma:

echo $nome_da_variavel

1.1 Variáveis de Ambiente

As variáveis de ambiente são aquelas conhecidas pelos demais processos (programas em execução). Exemplos destas variáveis são: HOME, PATH, EDITOR, etc.

Para entender o seu uso, vejamos um exemplo: editores de texto, como Vi, possuem diferentes interfaces para os modos texto e gráfico e necessitam saber qual o tipo de terminal o usuário está usando. A variável de ambiente TERM é o modo pelo qual isto pode ser determinado. Outro exemplo são os programas de e-mail que permitem ao usuário editar mensagens com o editor de textos de sua preferência. Como estes programas sabem qual editor usar? É através da variável EDITOR ou VISUAL.

Qualquer variável pode se tornar uma variável de ambiente. Para isto, ela deve ser “exportada”, com o comando export:

export <variável>

Também podemos exportar e atribuir valores a uma variável numa única linha de comando:

export <variável>=<valor>

Podemos verificar quais são as variáveis de ambiente já definidas e seus respectivos valores usando o comando abaixo:

export -p

Para visualizar todas as variáveis basta usar set ou env. Uma importante variável de ambiente é PATH que ajuda o shell a encontrar os comandos que o usuário executa. Todo comando executado é, na realidade, um arquivo. Estes arquivos são chamados executáveis e estão armazenados em vários diretórios como /bin ou /usr/bin. O valor da variável PATH é uma lista de diretórios em que o shell procura toda vez que executamos um comando cujo arquivo não é encontrado no diretório corrente. Assim, não precisamos alterar o diretório de trabalho todas vez que necessitamos executar um comando que se encontra em outro diretório. Basta acrescentar o diretório que contém tal comando à variável PATH. Os nomes dos diretórios na variável são separados pelo caractere dois-pontos (:).

Caso o usuário joao queira adicionar um outro diretório, digamos /home/joao/bin à variável PATH, deve proceder como mostrado a seguir:

$ export PATH=$PATH:/home/joao/bin   # adiciona o diretório
$ echo $PATH                         # verifica
/bin:/usr/bin:/usr/local/bin:/home/joao/bin

O primeiro comando faz com que a variável receba o seu valor atual, concatenado com o nome do diretório a ser acrescentado. Observe que existe um “:” antes do nome do diretório. O segundo comando é utilizado apenas para visualizarmos o resultado do primeiro.

1.2. Variáveis Especiais

Existem algumas variáveis especiais, normalmente utilizadas em script shell, para verificação de parâmetros, valores de retorno de comandos e funções etc.

2. Controle de Fluxo

Controle de fluxo permite interromper, continuar e deslocar o fluxo de execução do script. Isso envolve controles de decisão (condicionais) e estruturas de repetição (loops).

2.1. Condicionais

2.1.1. if

Sintaxe:

if <condicao>
then
    comandos
elif <condicao_2>
    comandos 
else
    comandos 
fi

O if, ao contrário do que ocorre em muitas outras linguagens, testa o retorno de um comando, não uma expressão.

Por exemplo:

if test 5 -lt 7
then
    echo '5 é menor que 7'
fi

Porém, é possível posicionar a expressão entre colchetes, de forma a tornar o if mais parecido com o que acontece em outras linguagens:

if [ 5 -lt 7 ]
then
    echo '5 é menor que 7'
fi

O “-lt” significa “less than“, ou seja, “menor que“, equivalendo ao operador “<".

Outros possíveis operadores são:

Comparação Numérica
-lt: É menor que (LessThan)
-gt: É maior que (GreaterThan)
-le: É menor igual (LessEqual)
-ge: É maior igual (GreaterEqual)
-eq: É igual (EQual)
-ne: É diferente (NotEqual)

Comparação de Strings
=: É igual
!=: É diferente
-n: É não nula (não vazia)
-z: É nula (vazia)

Operadores Lógicos
!: NÃO lógico (NOT)
-a: E lógico (AND)
-o: OU lógico (OR)

Testes em arquivos
-b: É um dispositivo de bloco
-c: É um dispositivo de caractere
-d: É um diretório
-e: O arquivo existe
-f: É um arquivo normal
-g: O bit SGID está ativado
-G: O grupo do arquivo é o do usuário atual
-k: O sticky-bit está ativado
-L: O arquivo é um link simbólico
-O: O dono do arquivo é o usuário atual
-p: O arquivo é um named pipe
-r: O arquivo tem permissão de leitura
-s: O tamanho do arquivo é maior que zero
-S: O arquivo é um socket
-t: O descritor de arquivos N é um terminal
-u: O bit SUID está ativado
-w: O arquivo tem permissão de escrita
-x: O arquivo tem permissão de execução
-nt: O arquivo é mais recente (NewerThan)
-ot: O arquivo é mais antigo (OlderThan)
-ef: O arquivo é o mesmo (EqualFile)

2.1.2. case

Sintaxe:

case <string> in
    opcao1)
        comandos 
        ;;
    opcao2)
        comandos 
        ;;
    *)
        operação padrão
esac

Exemplo:

echo "Digite um número"
read x
 
case "$x" in 
    1)
        echo "Você digitou o número 1"
        ;;
    2)
        echo "Você digitou o número 2"
        ;;
    *)
        echo "Você digitou outro número"
esac

2.1.3. select

Sintaxe:

select <variavel> in <opcao1> <opcao2> ...
do 
    comandos 
done

O comando select é pouco utilizado, mas pode ser muito útil para montar menus. Esse comando exibe um menu, associando cada opção a um número. Quando o usuário seleciona o número da opção, o seu valor é associado à .

Exemplo:

select i in lista_arquivos lista_arquivos_tree
do
    case "$i" in 
        lista_arquivos)
            ls
            ;;
        lista_arquivos_tree)
            ls -R
            ;;
    esac
done

2.2. Estruturas de Repetição (Loops)

Loops são estruturas que permitem fazer iterações sobre algum dado.

2.2.1. for

Sintaxe:

for <var> in <lista>
do
    <comandos>
done

“var” é o nome da variável a ser usada no bloco de repetição. “lista” pode ser uma lista de dados, fixa ou retornada por outro comando (como o ls), uma sequência de números etc.

Exemplos:

Exibe uma sequência de números:

for i in 1 2 3 4 5
do
    echo $i
done

Lista os diretórios e arquivos da raiz do sistema de arquivos:

for i in $(ls /)
do
    echo $i
done

for i in $(seq 1 10)
do
    echo $i
done

for i in $(cat /etc/passwd)
do
    echo $i
done

2.2.2. while

Sintaxe:

while <condicao>
do
    <comandos>
done

Exemplos:

Exibe a sequência de 1 a 10:

i=0
while [ $i -lt 10 ]
do
    echo $i
    i=$((i+1))
done

Loop infinito que exibe “bash” na tela:

while true
do
    echo 'bash'
done

Lendo strings da entrada padrão:

while read i
do
    echo 'Voce digitou a string: ' $i
done

Exibe as linhas de um arquivo:

cat 'arquivo.txt' | while read i
do
    echo $i
done

Esse exemplo facilita o trabalho com arquivos de texto, cujas linhas possuem espaços. Se fosse usado um loop for nesse caso, seria necessário alterar a variável de ambiente IFS, definindo o separador para quebra de linha (\n).

Uma variação do exemplo anterior é esta:

while read i
do
    echo $i
done < arquivo.txt

A principal diferença entre estes dois últimos exemplos é que, no primeiro, o loop while é executado num subshell, devido ao uso do pipe (|). No segundo exemplo, o while é executado no shell corrente.

Para ilustrar o problema, crie um arquivo chamado “arq.txt” com algumas linhas de texto. Crie este script e execute-o:

#!/bin/bash
 
FILE='arq.txt'
 
total=0
cat $FILE | while read i
do
	total=$((total+1))
done
echo 'Total de linhas: ' $total
 
total=0
while read i
do
	total=$((total+1))
done < $FILE
echo 'Total de linhas: ' $total

O primeiro loop é executado num subshell, fazendo com que a variável “total”, usada no corpo do loop, existe apenas nesse subshell. No segundo caso, isso não ocorre. Isso pode gerar grandes dores de cabeça… (como já ocorreu comigo)

2.2.3. until…do

Sintaxe:

until <condicao>
do
    <comandos>
done

Nesse loop, a condição é oposta à usada no while. Por exemplo:

Com while:

i=0
while [ $i -lt 10 ]
do
    echo $i
    i=$((i+1))
done

Com unitl:

i=0
until [ $i -ge 10 ]
do
    echo $i
    i=$((i+1))
done

Para fazer a mesma coisa, tivemos que usar expressões diferentes na condição do loop.

2.2.4. break

O comando break encerra um loop imediatamente.

Exemplos:

i=0
while true
do
    if [ $i -ge 10 ]
    then
        break
    fi
    i=$((i+1))
done

while read i
do
    if [ $i -eq 0 ]
    then
        break
    fi
done

2.2.5. continue

O comando continue para a execução da iteração corrente e vai para a próxima iteração, mesmo que haja mais comandos no bloco de repetição.

3. Padrão C/C++ em Expressões “(())”

É possível usar o padrão C em expressões do shell, como em condicionais de estruturas de controle. Para isso, basta colocar a expressão entre dois parênteses.

Exemplos;

i=0
while (( i < 10 ))
do
    echo $i
    ((i++))
done

É possível, inclusive, usar o padrão do loop for do C:

for ((i = 0; i < 10; i++)
do
    echo $i
done

4. Entrada/Saída

Existem três dispositivos principais, que sempre estão abertos, que merecem destaque:

stdin (standard input): entrada padrão. Corresponde, em geral, ao teclado;
stdout (standard output): saída padrão. Corresponde, em geral, à tela do terminal;
stderr (standard error): saída padrão de erros. Corresponde, em geral, à tela do terminal, também.

Esses três dispositivos estão em /dev e estão sempre disponíveis. Quem programa em C, sabe muito bem disso, pois já deve ter usado stdin, stdout e stderr junto com fprintf, fread, fwrite e semelhantes; esses três dispositivos comportam-se como arquivos comuns, sempre abertos e que não devem ser fechados.
É possível brincar com eles no próprio shell. Experimentem dar um cat em /dev/stdin para ver o que acontece. :)

4.1. Redirecionamento

A entrada de um programa consiste nos dados que lhe são passados inicialmente, os quais são necessários para a execução do programa. A entrada de um programa pode vir do teclado ou de um arquivo, por exemplo. Argumentos passados à comandos constituem a sua entrada.
A saída é constituída pelas informações geradas pelo programa, ou seja, o resultado de sua execução. A saída pode ser mostrada na tela ou gravada em um arquivo de registro.

Muitos comandos do Linux têm sua entrada configurada para a entrada padrão e sua saída para a saída padrão. A entrada padrão é o teclado e a saída padrão é o monitor. Vejamos um exemplo usando o comando cat, que lê dados de todos os arquivos passados como parâmetros e os envia diretamente para a saída padrão. Usando o comando abaixo, veremos o conteúdo do arquivo “arq1″ seguido pelo conteúdo de “arq2″.

$ cat arq1 arq2

Entretanto, se nenhum nome de arquivo for dado como parâmetro, o comando cat lê dados da entrada padrão e os envia para a saída padrão. Para interromper, deve-se pressionar as teclas ctrl e d simultaneamente (ctrl+d).

$ cat 
Ola! Tem alguem ai?  # usuário 
Ola! Tem alguem ai?  # eco do sistema 
Ate mais!            # usuário 
Ate mais!            # eco do sistema
              # usuário pressiona ctrl+d

Como podemos ver, cada linha que o usuário digita é imediatamente ecoada pelo comando cat. Aqui um outro exemplo: o comando sort lê dados da entrada padrão – a menos que algum arquivo seja dado como parâmetro – e ordena os dados, enviando-os para a saída padrão:

$ sort 
bananas     # usuário
peras       # usuário
goiabas     # usuário
            # ctrl+d
bananas     # eco do sistema
goiabas     # eco do sistema
peras       # eco do sistema

Digamos que queremos enviar a saída do comando sort para um arquivo, gravando os dados digitados anteriormente. O shell nos permite redirecionar a saída para um arquivo usando o símbolo “>”.

$ sort > lista
bananas  # usuário
peras    # usuário
goiabas  # usuário
         # ctrl+d

Como se pode ver, o resultado do comando sort não é mostrado imediatamente após o se digitar ctrl+d. Ao invés disso, é salvo em um arquivo chamado “lista”. Vejamos o conteúdo desse arquivo:

$ cat lista
bananas
goiabas
peras

Com o redirecionamento de saída, temos uma maneira simples de criar arquivos de texto. Para isso, utilizamos o comando cat para ler a entrada padrão (teclado) e redirecionamos sua saída para um arquivo.

Ao usar “>” para redirecionar a saída para um arquivo, estamos realizando um redirecionamento destrutivo, ou seja, o comando “ls > lista” sobrescreve o conteúdo do arquivo “lista”. Isto é equivalente a dizer que todo o conteúdo anterior de “lista” é apagado.
Se, ao invés disso, redirecionarmos usando “>>”, a saída será concatenada ao final do arquivo e o conteúdo (se houver) de “lista” será preservado. Para melhor entender isso, experimente executar a seguinte seqüência de comandos:

ls >> listagem
ls >> listagem
less listagem

O redirecionamento neste exemplo, diferentemente do exemplo anterior, é denominado redirecionamento não-destrutivo.

4.2. Usando Pipelines

Nos exemplos para o filtro sort, os dados de entrada eram digitados pelo usuário ou estavam gravados em um arquivo. O que aconteceria se quiséssemos ordenar dados vindos do saída de outro comando ? Para listar os arquivos do diretório corrente em ordem alfabética invertida devemos fazer com que a saída do comando ls seja ordenada pelo comando sort. Usando a opção “-r”, este comando ordena os dados na ordem inversa.

$ ls
historia  notas     tese      testes 
$ ls > lista 
$ sort -r lista 
testes
tese
notas
lista                             # observe esse nome de arquivo
historia

Aqui, salvamos a saída do comando ls em um arquivo (lista) e usamos sort com a opção “-r”. Porém, isso faz com que tenhamos um arquivo temporário para armazenar os dados. Assim, toda vez que fizermos isso, teremos que, em seguida, remover o arquivo lista. A solução é usar o que chamamos de pipeline, outro recurso do shell que nos permite conectar vários comandos usando um pipe, onde a saída do primeiro comando é enviada diretamente à entrada do segundo e assim por diante no caso de haver mais de dois comandos conectados por pipes.

No nosso caso, queremos enviar a saída do comando ls para a entrada do comando sort. O símbolo “|” (barra vertical) é usado para criar um pipe:

$ ls | sort -r 
testes
tese
notas
historia

Note que neste exemplo, nenhum nome de arquivo é usado na linha de comando, diferentemente do exemplo anterior que fazia o uso do arquivo intermediário lista. Outra diferença é que o nome desse arquivo intermediário aparece no resultado do penúltimo exemplo, mas não neste último. O comando é mais curto, mais fácil de digitar e o resultado é mais adequado pois não inclui nomes de arquivos intermediários.

É importante observar que o redirecionamento e o uso de pipes são características do shell e não dos comandos em si. É o shell quem provê a sintaxe dos símbolos “>”, “<" e "|". Logo, se você criar um programa que utilize entrada de dados via stdin, poderá usar redirecionamento para especificar uma entrada para o seu programa.

5. Expansões

Expansões são caracteres, ou uma sequência deles, que expressa outro significado. O intuito disso é facilitar e padronizar comandos.

~: path à home do usuário corrente
~user: path à home do usuário “user”
{a,b,c}: presença do caractere “a”, “b” ou “c”. Podem ser usadas strings em vez de simplesmente caracteres.

Exemplos:

ls ~

ls ~root

ls /dev/std{in,out,err}

5.1. Expansão de Variáveis

6. Parâmetros de linha de comando

Assim como em outras linguagens, é possível passar parâmetros para scripts shell. Para isso, usam-se as variáveis $1, $2, … A variável $0 contém o comando chamado via linha de comando.

Exemplo:

Crie um arquivo “test.sh” com este conteúdo:

#!/bin/bash
 
echo '$0 = '$0
echo '$1 = '$1
echo '$2 = '$2

Veja as saídas das execuções abaixo:

$ ./test.sh 
$0 = ./test.sh
$1 = 
$2 = 
$ ./test.sh um
$0 = ./test.sh
$1 = um
$2 = 
$ ./test.sh um dois
$0 = ./test.sh
$1 = um
$2 = dois

7. Definindo Funções

Sintaxe:

function nome_da_funcao()
{
     <comandos>
}

Para chamar a função:

nome_da_funcao
 
# caso haja parâmetros
nome_da_funcao param1 param2 ...

Exemplo:

#!/bin/bash
 
function imprime()
{
	echo "Sou a função '${0}'"
	echo "Param 1: ${1}"
	echo "Param 2: ${2}"
	echo "Lista de parâmetros: ${*}"
}
 
imprime um dois tres quatro

Da mesma forma como foram usados $0, $1 etc anteriormente, aqui essas variáveis são usadas para retornar os parâmetros da função. Logo, percebe-se que, dentro de funções, não é possível acessar parâmetros de script, a menos que eles sejam passados por parâmetro para a função.

7.1. Retorno de Funções

Antes de tudo, é preciso diferenciar retorno de função e saída de função. Por exemplo, ao se executar o comando “cat /etc/passwd”, a saída é o conteúdo do arquivo; o retorno é 0 (ou outro valor, caso ocorra erro). O retorno de uma função shell é um valor inteiro, normalmente utilizado para definir o status da função, ou seja, se ocorreu algum erro ou e ela foi executada corretamente.

Para obter o valor de retorno de uma função, usa-se a variável “$?”. Ela exibe o retorno do último comando executado. Por exemplo:

$ cat /etc/passwd
echo $?

Para retornar valor (status) numa função, usa-se o comando return.

Exemplo:

#!/bin/bash
 
function retorna()
{
    echo "sou um valor"
    return 42
}
 
valor=$(retorna)
echo $?
echo $valor

Ao se executar a função, sua saída será “sou um valor”; seu retorno será 42.

Em shell, considera-se o valor 0 como execução bem sucedida. Qualquer outro valor representa erro. É por isso que recomenda-se que toda função main de um programa em C retorne o valor 0, desde que não ocorra algum erro.

8. Expressões Regulares em Bash

Expressões regulares em shell podem ser usadas em comparações (if’s), por exemplo. Em if’s, usa-se o operador “=~” para realizar comparações usando ER’s:

s="bash"
if [[ "$s" =~ ^b ]]
then
    echo 'começa com b'
fi

9. Expressões Matemáticas

O bash não trabalha com expressões matemáticas tão facilmente. Existe o comando “let”, que permite realizar expressões matemáticas, mas é mais comum se usar a sintaxe semelhante ao C, utilizando dois parênteses:

$ a=$((1 + 1))
$ ((i++))
$ x=$((x*2))
...

10. O Arquivo .bashrc

Na home dos usuários (~), é comum haver o arquivo .bashrc (o ponto no início indica que o arquivo é oculto). Esse arquivo é sempre executado quando se abre um shell. Nele, constam diversas configurações, como definição de variáveis de ambientes, definição de aliases etc. Você pode editar esse arquivo (ou criá-lo, caso não exista):

$ vim ~/.bashrc

É possível usar outros editores, não apenas o vim.

11. Aliases (Apelidos)

Algumas vezes usamos comandos que necessitam de várias opções e argumentos. Para amenizar o trabalho de digitarmos repetidamente estes comandos o bash oferece um recurso chamado alias com o qual podemos definir sinônimos ou “apelidos” para um comando. Um alias pode ser definido na linha de comando da seguinte forma:

alias <nome>=<comando>

Observe que não pode haver espaços em branco antes ou depois do “=”.

Esta sintaxe indica que nome é um “alias” (apelido) para comando. Toda vez que digitarmos o comando “nome”, o bash o substituirá por “comando”.

Exemplo:

$ alias lf='ls -F'

Isso fará o shell executar “ls -F” toda vez que usarmos “lf” na linha de comando. Ou seja, o que o alias faz na verdade é substituir a palavra “lf” por “ls -F”. Observe neste exemplo, existe um espaço em branco entre ls e -F. Sempre que houver espaços em branco na definição de um campo, todo o campo deve ser digitado entre aspas simples (‘) ou duplas (“).

É possível definir aliases em seu .bashrc, para que eles estejam sempre disponíveis na sua sessão.

12. Referências

Linux Básico:
http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico/ ou http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico.pdf

Linux Avançado

http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxAvancado.pdf

Canivete Suiço do Shell (Bash)

http://aurelio.net/shell/canivete/

Livro Shell Script Profissional (Livro físico):

http://www.shellscript.com.br/

Não adianta querer programar usando Shell sem conhecer os comandos básicos do Linux. Por isso o primeiro módulo do “curso” abordará os comandos básicos do Linux, que são fundamentais para a construção dos scripts.

Vamos analisar apenas alguns comandos, os mais conhecidos e usados, juntamente com algumas de suas opções. A maioria dos comandos permitem o uso de inúmeras opções, não sendo possível abordar todos elas neste texto.

Antes de iniciarmos, vale lembrar que os manuais de todos os comandos podem ser lidos usando o comando man nome_do_comando, por exemplo:

$ man echo

A maioria dos comandos também têm a opção -h, ou –help, que lista os parâmetros aceitos pelo programa.

Os comandos estão ordenados alfabeticamente, sem levar em consideração relevância ou complexidade de utilização.

Sumário

awk
cat
cd
chmod
cut
date
diff
echo
find
grep
head
kill
ls
printf
rev
scp
sed
seq
sort
ssh
tac
tail
top

awk

O AWK é uma linguagem de programação para processamento de textos. Ao lado do comando SED, é capaz de realizar muitos truques.

Um post exclusivo sobre AWK pode ser visto aqui:

http://www.rberaldo.com.br/blog/tutorial-awk

cat

Exibe o conteúdo de um arquivo.

Opções:
-n : numera as linhas

Exemplos:

$ cat /etc/hostname 
orion

$ cat -n /etc/hostname 
     1	orion

cd

Muda o diretório de trabalho, ou seja, entra em um determinado diretório.

Exemplo:

$ cd /tmp

$ cd ~

chmod

O chmod (change mode) muda as permissões de um arquivo ou diretório. O sistema de permissões em sistemas Unix-Like, como Linux ou Mac OS, é um dos pontos fortes desses sistemas. Porém, infelizmente, poucos usuários realmente sabem usá-lo.

Um post exclusivo ao chmod pode ser lido aqui:

http://www.rberaldo.com.br/blog/chmod-permissoes-em-sistemas-linux-e-unix-like

cut

Separa trechos ou campos de uma linha, por meio de um delimitador. Também trunca textos, exibindo apenas um número específico de caracteres.

Opções
-d : define o delimitador
-f : define o(s) campo(s) a ser(em) exibido(s)
-c : número do caractere a ser exibido ou intervalo de caracteres

Exemplos:

$ echo "um:dois:tres:quatro" | cut -d: -f 2
dois

$ echo "um:dois:tres:quatro" | cut -d: -f 2,3
dois:tres

Também é possível definir intervalo de valores para a opção -f:

$ echo "um:dois:tres:quatro" | cut -d: -f 1-3
um:dois:tres

$ echo "um:dois:tres:quatro" | cut -d: -f 2-
dois:tres:quatro

$ echo "1234567890" | cut -c 7
7

$ echo "1234567890" | cut -c 1,3,5
135

beraldo@orion:~$ echo "1234567890" | cut -c 1-7
1234567

$ echo "1234567890" | cut -c 8-
890

beraldo@orion:~$ echo "1234567890" | cut -c -5
12345

date

Mostra a data atual ou uma data específica, com diversas opções para formatação da data.

Opções:
-d : especifica a data (Ex: tomorrow, 5 days ago)
+%? : define o padrão de formatação da data. A lista de opções pode ser lida no manual do comando (man date).

Exemplos:

$ date
Dom Mai  1 20:05:47 BRT 2011

$ date -d "yesterday"
Sáb Abr 30 20:05:59 BRT 2011

$ date -d "2 days ago"
Sex Abr 29 20:06:10 BRT 2011

beraldo@orion:~$ date -d "2 days"
Ter Mai  3 20:06:13 BRT 2011

$ date +"%d/%m/%Y"
01/05/2011

$ date -d "30 days" +"Daqui 30 dias será %d/%m/%Y"
Daqui 30 dias será 31/05/2011

diff

Exibe as diferenças entre dois arquivos.

Opções:
-i : case-insensitive (indiferente a maiúsculas e minúsculas)
-y : exibe as diferenças lado a lado
-E : ignora diferenças no tamanho do TAB
-B : ignora linhas vazias
-b : ignora quantidade de espaços

Outros comandos semelhantes muito úteis: vimdiff e diff3

O comando diff é muito útil para encontrar cópias de trabalhos de faculdade, por exemplo. :P

echo

Exibe um texto na saída padrão.

Opções:
-n : não pula linha no final do texto
-e : interpreta caracteres de escape

Exemplos:

$ echo "sou \n um \n texto"
sou \n um \n texto

$ echo -e "sou \n um \n texto"
sou 
 um 
 texto

find

Localiza arquivos no sistema de arquivos.

Esse comando possui diversas opções e truques. Por isso, merece um post específico para ele. Um post muito bom sobre o find pode ser encontrado aqui:

http://gerencievocemesmo.com.br/site/?p=56

grep

Localiza padrões dentro de um ou mais arquivos. A busca é feita usando Expressões Regulares.

Opções:
-i : case-insensitive
-v : inverte o critério de busca
-r : recursivo, busca em subdiretórios também
-n : mostra, também, o número da linha
-c : conta o número de linhas que casaram com o padrão
-l : exibe só o nome do arquivo onde o padrão foi encontrado
-A N : mostra N linhas após a linha onde o padrão foi encontrado
-B N : mostra N linhas antes da linha onde o padrão foi encontrado
-C N : mostra N linhas antes e depois da linha onde o padrão foi encontrado

$ seq 10 | grep -A2 -B3 "5"
2
3
4
5
6
7

$ echo -e "olá\nsou\n1\nteste\npara\ngrep" | grep "^[a-z]"
olá
sou
teste
para
grep

$ echo -e "olá\nsou\n1\nteste\npara\ngrep" | grep -v "^[a-z]"
1

Para usar todos os recursos das Expressões Regulares, use egrep em vez de grep, o que permite usar grupos, quantificadores “+” e “{quantificador}”.

head

Mostra o início de um arquivo. O limite pode ser estabelecido em número de linhas ou caracteres. É o inverso do comando tail.

Opções:
-n N : exibe as N primeiras linhas
-c N : exibe os N primeiros caracteres

Exemplos:

$ echo -e "olá, sou\num teste\npara o\ncomando head" | head -n 2
olá, sou
um teste

$ echo -e "ola, sou\num teste\npara o\ncomando head" | head -c 7
ola, so

kill

O comando kill “mata” processos, ou seja, encerra, ou força o encerramento, de um programa.

Opções:
-9 : força o encerramento da execução de um processo
-1 : mata todos os processos que o usuário pode matar

Exemplos:

Força o encerramento do processo 1234:

$ kill -9 1234

Encerra a sessão do usuário, ou seja, força o encerramento de todos os seus processos:

$ kill -1 -9

Os IDs dos processos (PID – Process ID) podem ser encontrados usando o comando ps, que é o gerenciador de processos. Com as opções “ux”, listam-se os processos do usuário. Com grep podemos filtrar a saída pelo processo desejado:

$ ps ux | grep skype
beraldo   2267  1.0  2.0 281508 82968 ?        Sl   09:58   0:41 skype
beraldo   5672  0.0  0.0  10128   848 pts/0    S+   11:04   0:00 grep --color=auto skype

O skype é o processo 2267. Para forçar seu encerramento, fazemos:

$ kill -9 2267

Como lição de casa, vale ler os manuais dos comandos killall e pkill. :)

ls

Lista o conteúdo de um diretório.

Opções:
-a : lista arquivos e diretórios ocultos
-l : mostra diversos atributos dos arquivos e diretórios, como data de criação, dono, permissões etc
-R : lista o conteúdo recursivamente

Exemplos:

$ ls

$ ls -a

$ ls -l

$ ls -la

$ ls -laR

printf

Exibe um texto na tela, com várias opções de formatação, semelhante à função printf(), da linguagem C.

As opções de formatação são praticamente as mesmas da linguagem C. A lista completa pode ser vista no manual (man printf).

Exemplos:

$ printf "%x\n" 15
f

$ printf "%o\n" 7
7

$ printf "%o\n" 8
10

$ printf "%05d\n" 70
00070

$ printf "%.2f\n" 70
70,00

rev

Esse comando inverte uma string.

Exemplos:

$ echo "texto" | rev
otxet

$ echo "duh" | rev
hud

scp

Copia arquivos e diretórios via ssh, ou seja, cópia segura entre máquinas remotas.

Opções:
-r : cópia recursiva

Sintaxe:

$ scp [opções] maquina:origem destino
$ scp [opções] origem maquina:destino

Exemplos:

$ scp 192.168.0.100:~/arquivo.txt .

$ scp arquivo.txt 192.168.0.102:~

sed

Linguagem para edição de arquivos e textos. Veja um post exclusivo a ela aqui:

http://www.rberaldo.com.br/blog/o-comando-sed-do-linux/

seq

Exibe uma sequência de números.

Opções:
-s : separador (padrão “\n”)
-f : formato (padrão “%g”)

Exemplos:

$ seq 3
1
2
3

$ seq 3 5
3
4
5

$ seq 3 2 10
3
5
7
9

$ seq 10 -2 0
10
8
6
4
2
0

$ seq -s, 10 -2 0
10,8,6,4,2,0

$ seq -s, -f"%04g" 10 -2 0
0010,0008,0006,0004,0002,0000

sort

Ordena linhas de um texto, alfabética ou numericamente.

Opções:
-n : ordena numericamente
-r : ordena inversamente (de Z para A e de 9 para 1)
-f : case-insensitive
-k N : ordena pela coluna N do texto
-t : separador de coluna para a opção -k (padrão TAB)
-o : define um arquivo para a saída do comando

Exemplos:

$ echo -e "um\ndois\ntres\nquatro" | sort
dois
quatro
tres
um

$ echo -e "um\tdois\ntres\tquatro" | sort -k 2
um	dois
tres	quatro

$ echo -e "um\tdois\ntres\tquatro" | sort -k 2 -r
tres	quatro
um	dois

$ echo -e "1\n10\n100\n2\n20\n200" | sort 
1
10
100
2
20
200

$ echo -e "1\n10\n100\n2\n20\n200" | sort -n
1
2
10
20
100
200

ssh

O SSH (Secure Shell) realiza acesso remoto a outras máquinas Linux. Um post exclusivo a SSH pode ser lido aqui:

http://www.rberaldo.com.br/blog/usando-o-ssh

tac

Inverso do comando cat. Exibe o conteúdo de um arquivo do fim para o início.

tail

Exibe o fim de um texto, exatamente o oposto do comando head

Opções:
-n N : número de linhas a exibir
-c N : número de caracteres a exibir

Exemplos semelhantes ao do comando head.

top

O comando top exibe os processos atualmente em execução. É semelhante ao ps, citado na seção do comando kill, mas atualiza-se automaticamente, além de possuir várias opções de ordenação.

Exemplo:

$ top

O comando “htop” é mais completo e user-friendly, mas normalmente não vem instalado nas distros Linux. É possível instalá-lo via gerenciador de pacotes. Por exemplo, em sistemas baseados em Debian:

# apt-get install htop

Em Linux, há programas gráficos para isso, mas a linha de comando é interessante pois permite converter vários arquivos de uma só vez, automaticamente. Por isso mostrarei como executar essa ação via Terminal. Além disso postarei um Shell Script completo para isso.

É necessário ter instalados os pacotes mplayer e mencoder para executar os comandos.

Supondo que queremos converter o arquivo video.avi em video.mp4, executaremos:

mencoder video.avi -o video.mp4 -oac copy -ovc lavc -lavcopts vcodec=mpeg1video -of mpeg

E este é um Shell Script para facilitar a tarefa:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#!/bin/bash
#
# Converte arquivos AVI em MP4
#
# Sintaxe: avi2mp4.sh arquivo.avi
#
# Ao fim da execução, será gerado o arquivo arquivo.mp4
 
if [ $# -ne 1 ]
then
	echo "Erro de sintaxe."
	echo "Uso: avi2mp4.sh <video.avi>"
fi
 
FILE=$1
BASENAME=${FILE%.*}
 
mencoder "${FILE}" -o "${BASENAME}".mp4 -oac copy -ovc lavc -lavcopts vcodec=mpeg1video -of mpeg

Não somente usuários Linux devem conhecer o sistema de permissões. Desenvolvedores que programam sistemas que rodarão em plataforma Linux devem conhecer o sistema de permissões também. É muito comum vermos programadores PHP falando “dê chmod 777, que resolve o problema de permissão”. Isso não é solução, é apenas o começo de um possível problema – e grave – futuro.

Sumário

Dono, Grupo e Outros
Divisão dos bits da permissão
Leitura, Escrita e Execução
Os riscos da permissão 777

Dono, Grupo e Outros

As permissões estão divididas em três níveis: permissões para o dono do arquivo, permissões para o grupo ao qual pertence o dono do arquivo e permissões para os outros usuários.

É por isso que sempre são mostrados três números, como 755, 644 ou três grupos de letras, como rwxr-xr-x ou rw-r–r–. Cada grupo corresponde a um nível de permissão.

O primeiro conjunto corresponde às permissões do dono do arquivo. O segundo, do grupo ao qual pertence o dono do arquivo. E o terceiro, ao outros usuários.

Divisão dos bits da permissão

Cada conjunto citado acima corresponde a três bits. Com três bits, é possível formar oito combinações:

000 = 0
001 = 1
010 = 2
011 = 3
100 = 4
101 = 5
110 = 6
111 = 7

O primeiro bits corresponde a permissão de leitura (read). O segundo corresponde à permissão de escrita (write). O terceiro, à de execução (execution). Sendo assim, podemos reescrever as combinações acima da seguinte forma:

000 = --- = 0 = nenhuma permissão
001 = --x = 1 = somente permissão de execução
010 = -w- = 2 = somente permissão de escrita
011 = -wx = 3 = somente permissões de escrita e execução
100 = r-- = 4 = somente permissão de leitura
101 = r-x = 5 = somente permissões de leitura e execução
110 = rw- = 6 = somente permissões de leitura e escrita
111 = rwx = 7 = permissões de leitura, escrita e execução (acesso total)

Leitura, Escrita e Execução

Vamos esclarecer o que significa ter permissão de leitura, escrita e execução em arquivos e diretórios.

Arquivos

Permissão de escrita em arquivo significa poder modificar o conteúdo do arquivo.
Permissão de leitura de arquivo significa poder acessar (ler) o conteúdo do arquivo.
Permissão de execução de arquivo significa poder executar o arquivo no terminal de comandos (shell).

Diretórios

Permissão de escrita em diretórios significa poder criar arquivos no diretório. Além disso, permissão de escrita possibilita a remoção de arquivos existentes, assim como a modificação das permissões dos arquivos desse diretório.
Permissão de leitura de diretórios significa poder acessar (ler) o conteúdo do diretório, ou seja, fazer a listagem do conteúdo do diretório.
Permissão de execução em diretórios significa poder entrar no diretório, seja por meio do comando cd ou acessando via URL no navegador.

Os riscos da permissão 777

Permissão 777 significa acesso total. Se um diretório tem permissão 777, qualquer uduário pode mexer naquele diretório, inserindo ou removendo arquivos, além de poder mudar as permissões deles. Qualquer usuário pode inserir um script ou programa executável malicioso, dar permissão de execução e executá-lo quando quiser. Imagine isso ocorrendo em um servidor de hospedagem! É um risco enorme! É por isso que sempre insisto: nunca use permissão 777.

É muito comum vermos “programadores” PHP postando dúvidas em fóruns falando que estão recebendo mensagem de erro de permissão. Aí alguém responde “dá chmod 777″. Nunca façam isso!

O correto é verificar o dono do arquivo e definir as permissões adequadas. Normalmente usa-se 755 para diretórios e 644 para arquivos não executáveis, como é o caso do PHP rodando em servidores WEB.

Mais detalhes no link abaixo:

http://www.debian.org/News/2011/20110205a

Com o SED é possível substituir e “casar” padrões, sempre por meio de Expressões Regulares, outra grande ferramenta do mundo da Computação.

O SED, assim como o AWK, lê um arquivo, linha por linha, e aplica a expressão do parâmetro a cada uma delas.

A sintaxe do SED é a seguinte:

sed 'expressão' arquivo

É possível filtrar a saída de outro comando, em vez de filtrar um arquivo, usando pipe. Usarei saídas do comando echo para explicar o sed.

SED usa Expressões Regulares (ER’s). Se você não conhece ER’s, sugiro ler o Expressões Regulares – Guia de Consulta Rápida

1. Substituindo textos: comando s
1.1. Escapando o delimitador
1.2. Usando a expressão casada em ER na substituição
1.3 Usando “retrovisores” (\1, \2…)
2. Modificadores
2.1. Modificador “g”: tratar linha inteira
2.2. Modificador “p”: exibir na tela
3. Restringindo por linhas
4. Restringindo por padrões
5. Remover linha: comando d
6. Sair: comando q
7. Adicionando linha: comando “a”
8. Adicionando linha: comando “i”
9. Mudando uma linha: comando c
10. Links

1. Substituindo textos: comando s

Sintaxe: s/ER/sub/[modificadores]: Substitui os padrões “casados” em “ER” por “sub”.

A utilidade mais conhecida do SED é a substituição de textos. Para isso, usamos o comando “s” do sed:

echo "Tutorial sobre sed: aprenda a trabalhar com sed" | sed 's/sed/awk/'

A saída será: Tutorial sobre awk: aprenda a trabalhar com sed. Note que a última ocorrência de “sed” não foi modificada. Isso porque o sed faz a modificação na primeira ocorrência e, em seguida, já procura pelo padrão na linha seguinte, se houver. Para que o sed execute a ação na linha toda, usamos o modificador “g”:

echo "Tutorial sobre sed: aprenda a trabalhar com sed" | sed 's/sed/awk/g'

Agora a saída é a esperada: Tutorial sobre awk: aprenda a trabalhar com awk.

Os modificadores serão abordados com mais detalhes logo mais abaixo. Não percam! =P

1.1. Escapando o delimitador

Como estamos usando a barra (/) como delimitador, se quisermos usar esse caractere na ER ou na substituição, temos de escapá-lo, com barra invertida:

echo "o arquivo /proc/cpuinfo possui informações importantes" | sed 's/\/proc\/cpuinfo/\/etc\/passwd/'

Saída: o arquivo /etc/passwd possui informações importantes

1.2. Usando a expressão casada em ER na substituição

Às vezes queremos acrescentar algo ao texto original. Por isso, é preciso que tenhamos o texto casado na ER. Para isso, usamos o caractere & para nos referirmos à expressão casada pela ER.

Suponhamos que queremos colocar todos os caminhos de arquivos entre aspas. Para isso:

echo -e "o arquivo /proc/cpuinfo possui informações importantes \nEste tutorial está em /home/beraldo/tutoriais. Há muitos outros nesse diretório" | sed -r 's/(\/[^ .,]*)+/"&"/'

Saída:
o arquivo “/proc/cpuinfo” possui informações importantes
Este tutorial está em “/home/beraldo/tutoriais”. Há muitos outros nesse diretório

A opção “-r” usa o padrão estendido de expressões regulares – o mesmo usado por “egrep”. Isso possibilita o uso da lista negada.

1.3 Usando “retrovisores” (\1, \2…)

Muitas vezes queremos substituir partes de um texto, mas manter outras. Para isso, podemos usar os “retrovisores”, que inserem na string final os padrões casados na ER inseridos em grupos (( e )). O primeiro grupo casado é referenciado por \1, o segundo, por \2 e assim sucessivamente, até \9.

Por exemplo, vamos manter apenas a primeira palavra de cada linha do texto:

echo -e "primeira linha\nsegunda linha\nterceira linha" | sed -r 's/^([a-z]+).*/\1/g'

Importante: Para usar os retrovisores, é necessário usar a opção -r do sed, que ativa o padrão estendido de ERs.

2. Modificadores

2.1. Modificador “g”: tratar linha inteira

Já vimos o modificador g anteriormente, que serve para forçar o SED a aplicar a expressão na linha inteira.

É possível associar um número ao modificador “g”, para fazer com que o SED atue apenas a partir de uma determinada ocorrência do padrão.
Por exemplo, vamos substituir por NULL todas as palavraas do texto:

echo "palavra1 palavra2 palavra3" | sed -r 's/([a-zA-Z0-9]+)/NULL/g'

Vamos supor que gostaríamos de remover todas as ocorrências, exceto a primeira. Para isso executaríamos o sed assim:

echo "palavra1 palavra2 palavra3" | sed -r 's/([a-zA-Z0-9]+)/NULL/2g'

O “2″ faz com que a substituição ocorra apenas a partir da segunda ocorrência do padrão.

2.2. Modificador “p”: exibir na tela

Por padrão, o SED imprime na saída padrão todas as linhas lidas – e modificadas. A opção -n impede que o sed faça a impressão das linhas. É nessa situação que o modificador “p” é útil. Quando quisermos imprimir somente as linhas alteradas pelo SED, usaremos o modificador “p”.

echo -e "linha sem números \nLinha com números: 1 2 3 4 5 6 \nLinha com mais números 42 81" | sed -r -n 's/[0-9]+/X/gp'

Serão mostradas apenas as linhas que casaram com o padrão.

Como foi possível ver no exemplo acima, é possível misturar os modificadores.

3. Restringindo por linhas

E possível fazer o SED atuar somente num intervalo de linhas.

Vamos mostrar os dez primeiros usuários do sistema, listando as dez primeiras linhas do arquivo /etc/passwd.

sed -r -n '1,10 s/([^:]+).*/\1/p' /etc/passwd

Note a opção -n e o modificador “p”, para mostrar somente o padrão casado.

É possível usar o caractere $ (cifrão) para se referir à última linha do arquivo:

sed -r -n '1,$ s/([^:]+).*/\1/p' /etc/passwd

4. Restringindo por padrões

Além de restringir por número de linhas, podemos restringer por padrão:

echo -e "esta\né\numa\nlinha\nusada\npara\ntestar\no\ncomando\nsed" | sed  -e '/uma/,/comando/s/[ae]/X/g'

5. Remover linha: comando d

O comando “d” do sed remove linhas.
Vamos remover as dez primeiraas linhas de /etc/passwd:

sed '1,10 d' /etc/passwd

6. Sair: comando q

O comando “q” faz o sed parar após encontrar o padrão

Imprime as dez primeiras linhas de /etc/passwd

sed '10 q' /etc/passwd

Para após encontrar um número:

echo -e "sou uma linha\nsou outra linha\nesta linha tem número 1\nesta já não tem número" | sed -r '/[0-9]+/ q'

7. Adicionando linha: comando “a”

É possível inserir linha após achar um padrão:

Insere linha após uma linha que contenha número

echo -e "sou uma linha\nsou outra linha\nesta linha tem número 1\nesta já não tem número" | sed -r '/[0-9]+/ a Oi. Sou novo aqui'

8. Adicionando linha: comando “i”

Quase igual ao comando “a”, mas insere a nova linha antes da linha casada com o padrão

Insere linha antes de uma linha que contenha número

echo -e "sou uma linha\nsou outra linha\nesta linha tem número 1\nesta já não tem número" | sed -r '/[0-9]+/ i Oi. Sou novo aqui'

9. Mudando uma linha: comando c

Semelhante a “a” e “i”, mas muda a linha que casou com o padrão

echo -e "sou uma linha\nsou outra linha\nesta linha tem número 1\nesta já não tem número" | sed -r '/[0-9]+/ c Fui modificado'

10. Links

http://www.grymoire.com/Unix/Sed.html
http://www.zago.eti.br/script/sed.html
http://www.linuxmanpages.com/man1/sed.1.php
http://guia-er.sourceforge.net/

http://www.junauza.com/2010/07/how-to-make-windows-faster-than-linux.html

Demonstrarei aqui como usar o SSH por meio de linha de comando em Linux, porém há ferramentas para Windows com a mesma finalidade, como o PuTTY. Porém, não os abordarei.

Uma das principais vantagens do SSH sobre outras formas de acesso remoto é a ênfase em segurança.

É possível abrir uma sessão remota via SSH usando apenas a senha do shell de destino. Porém, uma forma mais segura de se fazer esse acesso é usando um par de chaves público/privado, o que aprimora a segurança da conexão. O funcionamento do par de chaves é semelhante ao que ocorre na vida real, com as assinaturas manuscritas: para que sua assinatura seja legalmente reconhecida, um cartório deve autenticá-la. No caso de assinaturas digitais, essa autenticação é feita por meio de uma passphrase. Ao gerar um par de chaves com o comando ssh-keygen, geram-se dois arquivos no diretório .ssh, dentro de sua home: id_dsa (ou id_rsa) e id_dsa.pub (ou id_dsa.pub). O arquivo finalizado por .pub representa sua chave pública, enquanto o outro contém sua chave privada. Sua chave privada deve ser visível apenas por você, logo, mantenha-a com permissão 600 (permissão padrão desse arquivo). Esse arquivo deve ser sigiloso, pois somente você deve ter acesso à sua chave privada. Já a chave pública pode, e deve, ser visível a qualquer máquina à qual você deseja ter acesso. O conteúdo o arquivo .pub deve estar no arquivo authorized_keys, dentro de $HOME/.ssh, no servidor que deseja acessar.

$ ssh-keygen -t dsa

$ ssh-copy-id -i ~/.ssh/id_dsa.pub login@servidor

$ ssh login@servidor

$ scp origem destino

$ scp meu_arquivo_local beraldo@rberaldo.com.br:~

$ scp beraldo@rberaldo.com.br:~/arquivo_remoto .

$ sftp login@servidor