Apostila 1.1

Treinamento
Linux
Versão 1.1 - 2009
1
Índice
Introdução ao Linux.....................................................................................................5
Origem do Linux.................................................................................................................................. .5
Licenciamento e Versões do Kernel do Linux................................................................................6
Distribuições Linux.................................................................................................... ..........................6
Linux Standard Base (LSB) ...................................................................................... ..........................6
Visão Geral do Sistema Linux....................................................................................................... .......7
Vantagens do Linux........................................................................................................ ......................7
Conceitos Unix........................................................................................................... ..........................7
Tudo é Arquivo........................................................................................................ ........................7
Case Sensitive.................................................................................................................. ................8
Comandos........................................................................................................................................ .8
Primeiros Passos.................................................................................................................. .................8
Prompt de Login...................................................................................................... ........................8
Bash..........................................................................................................................................
........8
Logout.........................................................................................................................
...................10
Shutdown............................................................................................................. ..........................10
halt..........................................................................................................................................
........10
Reboot.........................................................................................................................
...................10
Estruturas de Diretórios............................................................................................11
Hierarquia..............................................................................................................
.............................11
Caminho Absoluto......................................................................................................................... .11
Caminho Relativo................................................................................................ ..........................11
Localização na Estrutura de Diretórios ....................................................................... .................11
pwd............................................................................................................................................11
ls.........................................................................................................................
.......................12
cd............................................................................................................................
...................13
$path..........................................................................................................................................14
Histórico de Comandos......................................................................................................... ....15
Teclas de Atalho............................................................................................................ ............16
Tecla [TAB]................................................................................................................. .........16
Filesystem Hierarchy Standard.......................................................................... ...........................17
/bin.......................................................................................................................................
......18
/boot......................................................................................................................................
.....18
/dev..............................................................................................................................
..............18
Portas Seriais e Paralelas................................................................................. ....................19
/etc...........................................................................................................................
..................19
/home ............................................................................................................................... .........19
/root...................................................................................................................
........................19
/lib...........................................................................................................................................
...19
/mnt..........................................................................................................................................
..20
/opt.......................................................................................................................................
......20
/sbin.........................................................................................................................
..................20
/tmp..........................................................................................................................................
..20
/usr.................................................................................................................................
............20
/var........................................................................................................................................
.....21
/proc.......................................................................................................................................
....21
Manipulação de Arquivos e Diretórios ....................................................................23
mkdir...................................................................................................................................
................23
tree...................................................................................................................................................
....24
2
rmdir.............................................................................................................................................
.......25
touch.............................................................................................................................................
.......26
cp.............................................................................................................................................
............27
mv......................................................................................................................................................
..29
rm...................................................................................................................................
.....................30
cat..........................................................................................................................................
..............31
tac..........................................................................................................................................
..............32
ln.......................................................................................................................................................
...32
Inodes.............................................................................................................................................32
Links Simbólicos.................................................................................................. .........................33
Hardlinks.............................................................................................................................. ..........33
Gerenciamento de Usuários e Grupos......................................................................34
Identificadores de Usuários e Grupos (UID e GID)..........................................................................34
/etc/passwd.........................................................................................................................
............34
/etc/shadow........................................................................................................
............................35
/etc/group.............................................................................................................
..........................35
/etc/gshadow.......................................................................................................
...........................35
Gerenciamento de usuários..................................................................................... ...........................36
Adicionando usuários com useradd............................................................................................ ...36
Definindo Senhas com passwd............................................................................................. .........38
Troca de Senhas............................................................................................................. ................39
Removendo usuários com userdel...................................................................................... ...........40
Aumentando a segurança com o comando chage.........................................................................40
Gerenciando informações de usuários com chfn e finger.............................................................42
Modificando o shell do usuário com chsh.................................................................................... .43
Verificando integridade dos arquivos de senhas com pwck.........................................................43
Convertendo/Revertendo o sistema de senhas shadow............................................................... ..44
Modificando contas de usuarios com usermod............................................................... ..............44
Gerenciamento de grupos....................................................................................................... ............45
Obtendo Informações com o comando id.............................................................. .......................45
Adicionando grupos com groupadd.................................................................... ..........................47
Removendo grupos com groupdel............................................................................................ .....47
Adicionando usuarios aos grupos.......................................................................................... ........47
Removendo usuários dos grupos...................................................................................... .............48
Modificando informações sobre grupos............................................................................... .........48
Definindo administradores de grupos com gpasswd....................................................................48
Trocando grupo principal temporariamente com newgrp.............................................................49
Verificando Integridade dos arquivos de grupos com grpck........................................................50
Permissões de Arquivos e Diretórios.........................................................................51
Entendendo as permissões........................................................................................................
..........51
Definindo Permissoes com chmod........................................................................................... ..........52
Modo Simbólico de Permissões.............................................................................. ......................53
Modo octal de permissões.............................................................................................................55
Mascara de usuário (umask)................................................................................................. .........56
O Shell Bash (Boune Again Shell).............................................................................58
Redirecionamento..................................................................................................................
.............58
Entrada de dados padão (/dev/stdin)..................................................................... ........................58
Saída de dados padão (/dev/stdout).................................................................................... ...........59
Saída de erros padrão (/dev/stderr)................................................................... ............................59
Operadores de Redirecionamento........................................................................ .........................59
Operadores de Saída de dados padrão (stdout): ">" e ">>".....................................................59
Operadores de entrada de dados padrão: "<" e "<<"...............................................................60
Redirecionando a saída de erros padrão (stderr).............................................................. ........61
3
Redirecionamento com pipes: "|"...................................................................... .......................62
Diferenças entre 0 "|" e o">".......................................................................... ..........................63
Comando tee.............................................................................................................................64
Tabela de Redirecionamentos....................................................................................... ............65
Paginadores..............................................................................................................
.................65
Caracteres especiais do bash (Metacaracteres).......................................................................... ........65
Executando múltiplos comandos em ordem determinada............................................................67
Operadores de controle lógico: && e | | (AND e OR).............................................................68
Configuração do shell bash....................................................................................... .........................69
Arquivo /etc/profile.......................................................................................................................70
Arquivo ~/.bash_profile............................................................................................................. ....71
Arquivo /etc/bash.bashrc ou /etc/bashrc.......................................................................................72
Arquivo ~/.bashrc..........................................................................................................................73
Arquivo ~/.bash_logout.............................................................................................. ...................74
Arquivo~/.bash_history........................................................................................... ......................74
Aliases de shell......................................................................................................
........................74
Escape de Comandos no bash.......................................................................... .............................75
Documentação............................................................................................................76
Páginas de manual..............................................................................................................................76
Man pages....................................................................................................................
..................76
Info Pages......................................................................................................................................
.78
Sistema de buscas na documentação do sistema.................................................................. ....78
Criando a base de dados....................................................................................................... 78
Localizando arquivos no sistema...............................................................................79
Comando find...........................................................................................................
..........................79
Comando Whereis..............................................................................................................................82
Comando locate.............................................................................................................
.....................83
Editores de Texto........................................................................................................83
Vi............................................................................................................................................
.............83
Modo de comando................................................................................................ .........................84
Modo de Edição............................................................................................................... ..............86
Modo de linha............................................................................................................. ...................86
Dicas preciosas do Vim...................................................................................... ...........................87
4
Introdução ao Linux
Origem do Linux
Linux é um sistema operacional clone do UNIX, viabilizando uma alternativa barata e funcional de se
rodar um sistema operacional amplamente compatível com Unix sem ter que pagar os altos custos de
licenciamento (Unix não é gratuito!).
No ano de 1983, Richard Stallman fundou uma organização chamada Free Software Fundation
(Fundação de Software Livre), cujo projeto denominado “projeto GNU” (GNU is not Unix) tinha
como finalidade criar um clone melhorado do sistema operacional Unix, mas que fosse desenvolvido
a partir do zero, sem utilizar o código fonte do Unix.
Para alcançar tal objetivo, era necessário desenvolver o kernel (coração do sistema operacional) para
os aplicativos (comandos) que compõem um sistema operacional completo. Porém no final da década
de 80, o projeto havia fracassado, pois os programadores não haviam conseguido criar o kernel do
sistema, somente os aplicativos essenciais estavam prontos.
Na mesma época, vários esforços alternativos para se atingir o mesmo objetivo proposto pelo projeto
GNU estavam em andamento. Um desses projetos, foi o projeto Minix, liderado pelo Dr. Andrew
Tanenbaum desenvolvendo o mesmo como instrumento de ensino. O Mimix era, na verdade, similar
a um sistema operacional Unix mas para arquitetura PC (até 80386 na época), o que possibilitava que
os universitários pudessem dar continuidade aos seus estudos em seus computadores de casa.
Por ter a finalidade de ser aplicado para fins acadêmicos, o Minix era um sistema cheio de limitações
pois, devido a problemas no gerenciamento de memória virtual, ele não conseguia oferecer um
ambiente completamente multitarefa e multiusuário – isso impedia que o mesmo fosse utilizado para
fins que não fossem os acadêmicos.
Nessa mesma época um aluno da Universidade de Helsink, na Finlândia, chamado Linus Benedict
Torvalds percebeu que o 80386 era o único processador na época capaz de executar um clone de
Unix, mesmo não sendo uma alternativa barata para a época.
Linus então se dispõem a criar um kernel clone do Unix que fosse capaz de lidar com memória
virtual, multitarefa e multiusuário. Era um trabalho gigantesco para apenas uma pessoa. Na primavera
de 1991, Linus iniciou seu projeto particular inspirado no Minix. Ele limitou-se a criar um “Minix
melhor que o Minix”. Após algum tempo de trabalho, Linus consegui criar um kernel capaz de
executar utilitários de programação e comandos padrão do Unix já previamente clonados pelo projeto
GNU. Percebendo a grandiosidade do projeto, e que não conseguiria dar continuidade sozinho, ele
enviou a seguinte mensagem para a lista de discussão “comp.os.minix”: “Você aspira por melhores
dias do Minix – 1.1, quando homens serão homens e escreverão seus próprios drivers de
Dispositivos? Você está sem um bom projeto e está morrendo de vontade de colocar as mãos em um
Sistema Operacional no qual você possa modificar de acordo com as suas necessidades? Você está
achando frustrante quando tudo trabalha em Minix? Chegar de atravessar noites para obter
programas que trabalhem corretos? Então essa mensagem pode ser exatamente para você”.
Como eu mencionei há mais de um mês, estou trabalhando em um sistema operacional similar ao
Minix para computadores AT-386. Ele está finalmente próximo do estágio em que poderá ser
utilizado (embora possa não ser o que você está esperando), e eu estou disposto a colocar os fontes
para ampla distribuição. Ele está na versão 0.2... “contudo, obtive êxito rodando nele bash, gcc, gnu-
make, gnu-sed, compress, etc ”.
A primeira versão oficial do Linux foi lançada em 05 de outubro de 1991(versão 0.02). A partir daí
diversos programadores ao redor do mundo têm colaborado com esse sistema operacional de código
aberto até chegar ou que é hoje.
5
Curiosidade: O nome Linux foi escolhido por seu criador através de uma mistura de seu próprio
nome com Unix (Linus + Unix = Linux).
Licenciamento e Versões do Kernel do Linux

O Linux não é software de domínio público, mas licenciado sob uma licença chamada GPL(General
Public License1 – Licença Pública Geral ). Essa licença diz que o código-fonte deve permanecer
livremente disponível, ou seja, nada pode impedir a distribuição do software. As pessoas podem
cobrar por uma cópia do Linux ,se assim desejarem, desde que , com isso, não limitem sua
distribuição.
O kernel possui diversas versões. O versionamento do mesmo é dividido em duas partes: por exemplo
na versão 2.6.13.4, o número 2.6 é versão principal do kernel, já o 13 é o patchlevel do Kernel, ou
seja, sempre que houver alguma mudança do código não muito significativa é elevado o número do
patchlevel. Se ocorrerem mudanças significativas, o número da versão principal é elevado, e
patchlevel retorna a 0 (zero).
Outra característica do kernel é que sempre que a versão principal termina com um número par, trata-
se de uma versão considerada estável pelo time de desenvolvimento. Quando este número é ímpar, o
kernel ainda está em estágio instável, em desenvolvimento. No exemplo acima, a versão é a 2.6 – ou
seja, é um kernel considerado estável.
Distribuições Linux
No início da década de 90, começaram a surgir as primeiras distribuições Linux. A idéia de
distribuições se tornou necessário devido as dificuldades na época em se obter todas as partes que
compunham o sistema operacional completo (kernel e aplicativos), pois as partes em questão ficavam
espalhadas pelo mundo, e diversos downloads e compilações eram necessários para que fosse
possível utilizar o sistema operacional. Essas dificuldades contribuíram para dar a fama de “Sistema
Operacional de Hacker” ao Linux pois somente quem possuia um bom conhecimento na área é que
conseguia instalar o sistema. O papel de uma “distribuição” é simplesmente fazer todo esse “trabalho
sujo” ao empacotar tudo em um meio comum de distribuição como um CD, um disquete, um arquivo
compactado, um DVD entre outros. .
Atualmente existem mais de 300 distribuições diferentes. Dentre elas se destacam algumas, como:
Debian, Ubuntu , Fedora, RedHat, Mandriva, Slackware, Suse entre outros.
Linux Standard Base (LSB)

O Linux Standard Base (LSB) torna possível a compatibilização e a padronização das distribuições
Linux, de modo que os softwares desenvolvidos para “Linux em Geral” possam rodar em qualquer
distribuição. Para que tal fato seja possível, é necessário que a distribuição e aplicativo sejam
compatíveis com LSB. Nos dias atuais, a esmagadora maioria dos aplicativos disponíveis para Linux
é compatível com LSB.
1 http://www.gnu.org/philosophy/categories.pt.html
6
Visão Geral do Sistema Linux
Linux é um sistema operacional multi-camadas, como podemos ver no gráfico seguinte:
Kernel
Harware
Usuário
Shell – Iterpretador
de Comandos
Nesse arranjo, o kernel desempenha a função principal de intermediar acessos ao hardware e cria
uma interface com o usuário através do interpretador de comandos(shell). Existem vários
interpretadores de comandos – mas o mais comum, atualmente, é o bash.
Vantagens do Linux
O Linux é um sistema operacional que se destaca por diversos fatores como: Multiplataforma,
Multiusuário, Multitarefa (*), Portabilidade e Escabilidade. Multiplataforma é a capacidade do
mesmo sistema rodar em diferentes plataformas de hardware, geralmente mantendo os software
inalterados, com pouca mudança nos fontes do kernel. Multiusuário e Multitarefa denota,
respectivamente, a capacidade do sistema de lidar com múltiplos usuários rodando múltiplos
aplicativos simultaneamente. Portabilidade e Escabilidade é a capacidade do sistema de ser
facilmente portável e compatível com diversas plataformas de Hardware existentes.
Conceitos Unix
Existem algumas características do sistema Linux que foram herdadas do Unix. As principais
características são ilustradas a seguir:
Tudo é Arquivo
Um arquivo no Unix é uma seqüência de zero ou mais bytes contendo qualquer tipo de informação.
Não existe nenhuma distinção entre arquivos de texto em ASCII, arquivos binários ou qualquer outro
tipo de arquivo.
Um diretório é um arquivo que contém informações a respeito de um conjunto de arquivos. Essas
informações consistem basicamente em nome e localização do mesmo. Um dos arquivos “contidos”
num diretório pode ser também um diretório, permitindo que estes se organizem de forma
hierárquica.
Case Sensitive
O Linux difere letras maiúsculas e minúsculas, portanto “ROOT”, e “Root” e “root”, são três formas
diferentes de se escrever, e o Linux entende que são três informações diferentes. Portanto, para que
7
sejam compreendidos pelo interpretador de comandos (Shell), todos os comandos devem ser
digitados exatamente da forma que são, distinguindo maiúsculas de minúsculas. É importante notar
que a maioria dos comandos estão escritos em caixa baixa.
Comandos
Todo comando é geralmente seguindo de uma parâmetro e pode aparecer de três formas diferentes :
# comando parâmetro
Primeiros Passos
Precisamos nos familiarizar com o ambiente de linhas de comando. Portanto, iremos conhecer cada
uma das partes envolvidas.
Prompt de Login
Como já foi visto anteriormente, o Bash é um dos shells disponíveis no Linux. É no ambiente do
Shell que passaremos a maior parte do curso. Para que o sistema nos libere acesso a um shell texto,
antes é preciso autenticar-se no prompt de login, como abaixo:
host login: root
password:
Essa é a tela de login texto, onde “host” é nome da máquina. Por ser de uma hierarquia Unix, ao
digitar a senha, nenhum caractere aparece e o cursor não se move, mas as informações do teclado
estão sendo enviadas.
Bash
O bash é apenas um dentre os diversos interpretadores de comando (shells) disponíveis no Linux, tais
como csh, zsh, sh, pcsh, etc. Futuramente faremos um estudo mais profundo sobre o shell
bash, mas agora iremos apenas nos familiarizar com esse componente tão importante do sistema.
[root@host etc] #
Este é prompt do Shell, que aparece depois que você está logado. Este formato de prompt é
geralmenate utilizado nas distribuições RedHat e Mandriva (*).
A linha acima significa o seguinte:
root é o nome do usuário
@ significa at (em), ou seja, onde o usuário está logado em....
host nome da máquina
etc é o diretório corrente
(*) O Mandriva é o sucessor do Conectiva que se baseou no projeto RedHat.
portanto esta linha significa: usuário root logado na máquina host no diretório etc.
O # é simbolo de que o root está logado, caso fosse um usuário comum, o símbolo seria $ . No caso
do Debian, por exemplo, a linha do prompt costuma se parecer com o seguinte:
host: /var/tmp/#
8
Nesse caso, é mostrado o nome da máquina, seguido de “:” (dois-pontos), o caminho completo do
diretório atual mais o símbolo de quem está logado.
O prompt de login pode facilmente ser configurado através da variável

de ambiente $PS1.
Exemplo:
host: /var/tmp# echo $PS1
\h:\w$
host:/var/tmp# PS1=“[\u@ \h \W]\$”
[root@host tmp]# echo $PS1
[\u@\h \W] \$
[root@host tmp]#
No exemplo acima, primeiro foi mostrado o conteúdo da variável $PS1 (comando “echo $PS1”);
logo depois o conteúdo dessa variável foi modificada com base nos valores especiais descritos na
tabela abaixo, tornando o prompt padrão do Debian parecido com prompt padrão do RedHat.
Caracteres de escape para customização do shelll usasndo $PS1:

\e Quebra de linha
\h O nome curto do host (exemplo: host).
\H O nome longo do host (exemplo: host. cds.eb.mil.br)
\j O número de trabalhos atualmente sob controle do shell.
\t Hora atual no formato de 24horas.
\u Usuário logado atualmente
\W Nome do diretório de trabalho atual
\w Caminho completo do diretório atual
\$ Símbolo de Usuário. Para qualquer usuário com UID = 0 (root por exemplo)
aparecerá um sinal de #, como sinal de $ para os outros usuários do sistema.
DICAS + MAIS
Você pode ter mais de um terminal ao mesmo tempo, sendo possível manter terminais texto e gráficos. Para
alternar entre terminais texto, pressione [ALT] + [F1] (F1 até o F6). O próximo terminal logo após o último
terminal texto (Geralmente F6) é o terminal gráfico ( [ALT]+[F7] ). Para sair do terminal gráfico e voltar a
um terminal texto, pressione [CONTROL]+[ALT]+[F1] (Até o [F6] nesse caso.
Logout
Para sair do shell atual, digite o seguinte comando :
$ logout
9
Shutdown
Utilizamos o comando shutdown para interromper de alguma forma o funcionamento do sistema
(Desligar ou reiniciar, por exemplo).
shutdown [-akrhfnc] [-t secs] tempo [mensagem]
Tabela de Parâmetros
a Utiliza o arquivo /etc/shutdown.allow para definir quem tem permissão par
desligar/reiniciar o sistema.
k Somente “testa” o desligamento.
r Reinicia o Sistema.
h Desliga o sistema.
f Reinicia o sistema em modo rápido (não executa o fsck durante o boot).
F Força a execução do fsck durante a inicialização.
n Força o desligamento rápido (sem terminar os programas em execução).
c Cancela um shutdown agendado.
t Especifica o tempo, em segundos, entre a notificação e a finalização dos
processos.
Exemplos:
# shutdown -h now “O sistema será reinicializado agora”
Reinicia o sistema imediatamente e exibe a mensagem “O sistema será reinicializado agora” para os
usuários conectados atualmente.
# shutdown -r -t secs 20 10 “Reboot em 10 minutos”
halt
O comando halt tem o mesmo efeito que o comando “shutdown –h now”.
reboot
Tem o mesmo efeito que o comando “shutdown -h now”.
10
Estruturas de Diretórios
Hierarquia
O Linux tem como principais elementos estruturais arquivos e diretórios, onde arquivos guardam
informações e diretórios são compartimentos que podem conter arquivos e/ou subdiretórios.
Estes arquivos e diretórios estão organizados numa estrutura hierárquica na forma de uma árvore
invertida, ou seja, possui estrutura hierárquica porque alguns elementos têm ascendência sobre
outros.
A forma da estrutura da árvore invertida, que assim se chama porque o elemento no topo é raiz, de
onde saem o “tronco” e os “galhos” que atingem os demais elementos. De cada diretório partem
outros “galhos” que podem atingir os demais elementos.
Os nomes de arquivos e diretórios devem ser usados lembrando-se que o Linux é case sensitive, ou
seja, diferencia maiúscula de minúscula.
O diretório no topo da hierarquia é o diretório raiz que é representado por “/” . Aqueles diretórios
logo abaixo deles são seus filhos; estes filhos, por sua vez, podem ter outros diretórios filhos e
também arquivos.
Sempre que um diretório contiver um segundo diretório que vem logo abaixo dele na hierarquia diz-
se que este segundo diretório é um subdiretório do primeiro.
Caminho Absoluto
Para localizar, de maneira absoluta, um elemento qualquer no sistema de arquivos, deves exprimir o
seu caminho absoluto, ou seja, seu caminho completo. O caminho absoluto localiza, de maneira
inequívoca, um arquivo ou diretório no sistema de arquivos.
Exemplo de Caminho Absoluto: /usr/local/bin
Caminho Relativo
É possível utilizar caminhos relativos para localizar arquivos ou diretórios. O caminho é relativo ao
nosso diretório corrente (ou seja, a partir de diretórios diferentes, podemos chegar a lugares distintos
usando o mesmo caminho relativo).
Exemplo de Caminho Relativo: ../spool/mail
Podemos utilizar os comandos pwd, ls e cd como auxilio na localização em estruturas de diretórios,
conforme veremos a seguir.
Localização na Estrutura de Diretórios
A seguir estudaremos alguns comandos que são essenciais para a nossa localização na estrutura de
diretórios.
pwd
Este comando vai mostrar na tela seu diretório corrente, ou seja, em que diretório você está no
momento. Sempre que um comando necessitar de nome de arquivo, caso não especifiquemos seu
caminho, o comando assumirá que estamos nos referindo a arquivos do nosso diretório corrente.
Sintaxe:
pwd
Exemplo:
# pwd
/root
11
O comando acima mostra que o diretório atual é “/root”.
ls
Exibe o conteúdo do diretório com informações sobre um arquivo.
l Mostra o conteúdo e as informações dos arquivos do diretórios corrente de
maneira detalhada.
a Mostra o conteúdo do diretório corrente, includindo os arquivos ocultos (Que
iniciam com “.”).
F Adicionar indicadores.
G Oculta a coluna de grupo dono do arquivo. (Só funciona junto com a opção).
h Mostra o tamanho do arquivo de modo legível para “humanos”(human readable)
n Mostra a identificação de Usuários. (UID's) e grupos (GID's) ao invés de nomes.
o Listagem longa sem o grupo dono dos arquivos (o mesmo que lG).
R Lista diretórios e subdiretórios recursivamente.
fulltime Lista datas e horas no formato completo.
color Ativa a exibição colorida de arquivos para ajudar na identificação dos mesmo.Por
padrão, azul=diretório, verde=executável, azulclaro=link simbólico,
vermelho=arquivo compactado, etc.
r Inverte a ordem de classificação.
c Classifica por data de alteração.
X Classifica por extensão.
Sintaxe:
ls [parametro] < arquivo>
Exemplo:
[root@host root] # ls
diversos
evolution
latex
listamp3
materia
projetolc
teste
tlm4.doc.gz.doc
12
O comando acima simplesmente mostra o conteúdo (arquivos) do diretório corrente. É possível
mostrar o conteúdo de um ou vários diretórios ao mesmo tempo, basta acrescentar o caminho do(s)
diretório(s) a frente do comando, conforme abaixo:
# ls /mnt /tmp
mnt/:
cdrom
floppy
tmp/:
DOCUMENTO
cd
Significa “change directory” (troca de diretório) e é usado para trocar de diretório corrente.
Sintaxe:
cd diretorio
Exemplo A:
#cd /var/tmp
Saí do diretório atual e vai para /var/tmp
Exemplo B:
# cd ../
Sai do diretório atual (/var/tmp) e vai para o diretório /var, que fica um diretório acima (antes)
do atual. Isso é possível graças a duas entradas especiais que existem em todos os diretórios: “.” e
“..”. A entrada “.” refere-se ao próprio diretório, já a entrada “..” refere-se ao diretório logo “acima”
do atual.
Exemplo C:
# /etc/init.d/networking restart
reconfiguring network interfaces ...done.
# cd /etc/init.d
# ls l networking
rwxr xrx 1 root root 2607 jun 13 2004 networking
# ./networking
Reconfiguring network interfaces ...done.
Esse exemplo mostra como executar o comando que esteja no diretório /etc/init.d de duas formas. A
primeira utiliza o caminho absoluto (/etc/init.d/networking), o segundo utiliza o caminho relativo
(./networking).Ambos levam ao mesmo resultado.
Outro caminho relativo especial na estrutura de diretório “~”; Ele refere-se ao diretório home do
usuário atualmente logado no sistema. Observe o seguinte exemplo, levando em consideração que o
diretório home do usuário root é a pasta
/root:
Exemplo D:
13
#pwd
/tmp
#cd ~
#pwd
/root
Outro caminho especial utilizado com freqüência é o “-”. Ele leva de volta para o último diretório
visitado. Veja o exemplo.
Exemplo E:
#pwd
/tmp
#cd /usr/local
#pwd
/usr/local
#cd
#pwd
/tmp
$path
A variável path armazena o caminho dos executáveis, ou seja, diretórios que contém comandos e
scripts no sistema. O seguinte comando mostra o conteúdo da variável $PATH
#echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11
Nesse exemplo existem 7 diretórios do sistema cadastrados na variável PATH (separados por
“:”).Quando um comando qualquer é digitado sem o caminho absoluto (o comando ls, por exemplo),
o sistema procura o arquivo ls no diretório /usr/local/sbin, e caso não encontre, continua a
busca no diretório /usr/local/bin... seguindo assim até chegar o último diretório
“/usr/bin/X11”, senão encontrar nesse o sistema avisa que o comando não pode ser localizado.
O caminho do diretório que contém executáveis costumam já vir configurados após a instalação no
linux (verifique a variável $PATH). Caso seja necessário alterar o conteúdo dessa variável, é
recomendável fazer isso editando o campo correspondente no arquivo /etc/profile, que é lido
por todos os usuários no sistema no momento do login. Se quiser alterar somente para usuário
especifico, adicione a entrada correspondente no arquivo ~/.bashrc do(s) usuário(s) em questão.
Esses e outros arquivos relacionados a configuração do shell bash serão estudados mais afundo neste
treinamento.
Dica
Para exibir o conteúdo de uma variável no console, execute o comando echo

$NOME_DA_VARIÁVEL, lembrando que o nome da variável faz distinção entre maiúsculas e
minúsculas. Tente um echo $PATH.
Histórico de Comandos
14
Você pode executar comandos já digitados pressionando as teclas [seta para cima] e [seta para baixo].
Devemos isso ao histórico de comandos, pois conforme digitamos comandos no bash, ele os
armazena no chamado “Histórico de Comandos”, que fica em memória enquanto utilizamos o
console e quando terminamos a sessão normalmente (logout), o bash salva esse histórico no arquivo
~/.bash_history. Para fazer isso manualmente, utilizamos o comando:
# history -w ~/.bash_history
O próximo login, o bash carrega o arquivo ~/.bash_history para a memória, restaurando o

último histórico salvo. Procedimento manual para fazer isso seria:
# history r ~/.bash_history
O bash limita o tamanho máximo de comandos que podem ficar no histórico de comandos através da
variável de ambiente $HISTSIZE.
w Grava o histórico em um arquivo especificado
r Lê o histórico a partir de um arquivo previamente salvo.
c Limpa o histórico da memória (mas não apaga o ~/.bash_history).
Exemplo A:
# history
. . .
530 echo PATH
531 echo $PATH
532 cd ~
533 ls lA
534 ls la
535 vi .bashrc
536 vi /etc/profile
537 history
O comando history, quando chamado sem argumentos, mostra todas as entradas no histórico.
Exemplo B:
# history 10
. . .
531 echo $PATH
532 cd ~
533 ls lA
534 ls la
535 vi .bashrc
536 vi /etc/profile
537 history
538 history |head
539 history l0
540 history
Nesse caso, ele mostra os últimos 10 comandos no histórico. Repare que cada comando no histórico
possui um identificador numérico. Podemos utilizar desse identificador para executar novamente o
comando em questão. Por exemplo, digamos que seja preciso repetir o comando “echo $PATH
(Número 531 no histórico):
15
Exemplo C:
# !531
echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11
Outros comandos como esses podem ser verificados na tabela abaixo:

Expansões para o Histórico de Comandos
!n Refere-se à entrada n do histórico
!! Repete o último comando digitado.
!-n Refere-se ao comando atual “menos n” no histórico.
!exemplo Repete o último comando digitado que começa com “exemplo”.
DICAS MAIS
É possível fazer uma pesquisa reversa no histórico de comandos com a seqüência de teclas
[CONTROL] + [R]. Nesse modo, basta começar a digitar um comando desejado que o bash
preencha com a mais provável, conforme se digita.
Teclas de Atalho
A tela do console em modo texto pode ser rolada para cima utilizando [SHIFT] + [PAGE UP], ou
[SHIFT] + [PAGE DOWN] para rolar a tela para baixo (a tela já deve ter sido rolada para cima nesse
momento). Isto é útil para visualizar saídas de comandos que ocupam mais de uma tela no console (O
Linux tem bastante deles).
Outra forma de navegar através dos comandos no histórico é com ajuda de teclas como [SETA PARA
CIMA] (volta recursivamente os comandos do histórico, um por um) e [SETA PARA BAIXO]
(avança entre os comandos do histórico). As setas são muito utilizadas no dia-dia de um
administrador de sistemas Linux, pois se tornam muito necessárias conforme digitamos comandos.
Tecla [TAB]
A tecla [TAB] nos permite completar nomes de arquivos, diretórios, executáveis no $PATH, etc.
Exemplo A:
# ls /u[TAB]/sh[TAB]/do[TAB]
No exemplo, acionamos o comando ls /usr/share/doc utilizando a tecla tab 3 vezes para
completar o caminho.
Exemplo B:
# ifcon[TAB]
O exemplo acima completa o comando ifconfig logo após digitarmos “ifco” (somente as 4 primeiras
letras) seguido da tecla [TAB].
Filesystem Hierarchy Standard
16
O Linux usa um padrão para a estrutura de diretórios, denominado FHS (Filesystem Hierarchy
Standard), que visa padronizar o nome e a localização de diretórios e arquivos principais do sistema.
Esse padrão tem algumas características muito importantes, como a compatibilidade com outros
sistemas e a habilidade na montagem de algumas partições no modo somente de leitura.
Quando uma distribuição segue a risca os padrões da FHS, dizemos que ela está homologada neste
padrão e isso proporciona um alto nível de compatibilidade entre aplicativos criados inclusive para
outras distribuições, desde que esses aplicativos também sigam o padrão da FHS.
Um Sistema FHS divide os diretórios em 2 (duas) categorias principais:
1) Compartilháveis e Não Compartilhaveis

A distinção entre dados Compartilháveis e Não-Compartilháveis é necessária pelos
seguintes motivos:
A) Em um ambiente de rede com várias máquinas, é muito útil poder compartilhar dados
entre diferentes hosts para ecomizar espaço em disco e facilitar as tarefas de manutenção;
B) Num mesmo ambiente, certos arquivos contêm informações específicas para cada host,
portanto, esses dados não podem ser compartilhados para outros micros da rede;
2) Variáveis e Estáticos
Já a distinção entre dados Variáveis e Estáticos se torna necessária pelos motivos:
A) Devido ao diretório / (raiz) conter tanto dados variáveis quanto estáticos, alguns dados
nele contidos precisam ter permissões de leitura e escrita;
B) Existem diretórios que recebem modificações constantemente (variáveis), como o
/var, por exemplo.
A correlação entre esses tipos de diretórios forma a FHS, como mostrado na tabela abaixo:
Compartilháveis Não- Compartilháveis
Estáticos /usr /etc

/opt /boot
Variáveis /var/mail /var/run
/var/spool/news /var/lock
Os diretórios contemplados pela FHS são:

/bin
Contém os comandos que podem se usados pelo administrador de sistema e pelos usuários, isso o
torna necessário durante uma tarefa de manutenção de sistema e, portanto não pode ficar em uma
partição separada da partição que contém o / (raiz). Scripts de inicialização também fazem uso dos
comandos presentes no diretório /bin, como por exemplo:
cat Utilizados para mostrar arquivos na saída padrão.
chmod Utilizado para alterar permissões de arquivos e diretórios.
chown Utilizado para modificar dono /grupo de arquivos e diretórios.
cp Utilizados para copiar arquivos e diretórios.
17
cat Utilizados para mostrar arquivos na saída padrão.
ls Utilizado para listar conteúdo de diretórios e informações sobre arquivos.
/boot
Esse diretório contém arquivos importantes para inicialização e carregamento do kernel. É neste
diretório que se encontra o kernel. Também é nesse diretório que ficam localizados os arquivos do
Gerenciador de Boot (bootloader).
/dev
Contém os arquivos de Dispositivos pelo Linux, como floppy disk, cdrom, unidades de disco, mouse,
portas paralelas e seriais, etc...
Conforme visto anteriormente, tudo no Linux é tido como arquivo, isso inclui os dispositivos do
sistema, como hds, modens, portas, etc. Isso é possível pois o kernel conta com esses “arquivos
especiais” que ficam no diretório /dev. Esses arquivos especiais podem ser de 2 (dois) tipos:
Dispositivos de Bloco e Dispositivo de Caractere.
A diferença entre esses dois tipos de Dispositivo é que os Dispositivos de bloco são Dispositivos
geralmente associados “armazenamento de dados” (bloco de dados), pois tratam os dados em formato
binário próprio para armazenagem e leitura posterior. Assim, os dados enviados a esses Dispositivos
são armazenados em Dispositivos de armazenamento, como discos rígidos e disquetes, possibilitando
posterior leitura desses Dispositivos. Já os Dispositivos de caractere tratam o fluxo de dados num
formato de caracteres texto. O próprio terminal texto, por exemplo, utiliza um dispositivo caractere
para realizar interface com o kernel.
Exemplos de Dispositivos
/dev/hda
Blocos /dev/fd0
/dev/sdd11
/dev/tty1
Caractere /dev/ttyS0
/dev/zero
Portas Seriais e Paralelas

No linux, as porta seriais e paralelas tem uma nomenclatura própria. Na tabela a seguir mostramos a
nomenclatura em Linux e, para título de comparação, a nomenclatura para DOS:
DOS LINUX
COM1 /dev/ttyS0
COM2 /dev/ttyS1
LPT1 /dev/lp0
LPT2 /dev/lp1
18
/etc
Contém os arquivos e os diretórios de configuração que são específicos ao sistema atual. É nesse
diretório que um administrador de sistemas Linux trabalha na maior parte de seu tempo.
/home
Contém os diretórios de trabalho de todos os usuários do sistema. Neste diretório ficam informações
como personalização de Desktop, configuração de clientes de e-mail, etc...
O propósito principal dessa estrutura é facilitar as tarefas de backup, por exemplo.
/root
Este é o diretório home do administrador de sistema (usuário root). Segundo a FHS, o root é o único
usuário que interage com o sistema, onde o sistema “deve” ser capaz de funcionar somente com a
partição raiz acessível (montada).
/lib
Contém as bibliotecas compartilhadas necessárias ao carregar o sistema e para executar os comandos
localizados na raiz do sistema de arquivos. Os módulos do kernel também se localizam neste
diretório, mais especificamente em /lib/modules/<versão do kernel>/.
/mnt
Este diretório é fornecido de modo que o administrador de sistema possa temporariamente montar um
disquete, cdrom, ou sistemas de arquivos quanto necessário. Algumas distribuições Linux como
RedHat e Mandriva criam os subdiretórios floppy e cdrom aqui dentro para servir como ponto de
montagem para esse tipos de mídias. Outras distribuições como Debian e Knoppix criam esses
diretórios (cdrom e floppy) diretamente na raiz, e os utilizam como padrão para servir como ponto de
montagem a essas mídias.
/opt
É reservado para instalação de pacotes que estão fora da distribuição utilizada.
Estes pacotes fornecidos por terceiros devem ser instalados em diretórios separados. Ex: / opt / pacote
– onde o pacote deve descrever o nome do software a ser instalado.
/sbin
Contém os binários essenciais para a inicialização, recuperação e restauração do sistema. Estes
binários são usados pelo próprio sistema ou pelo adminstrador (root).
/tmp
O diretório tmp é utilizado por alguns programas que requerem arquivos temporários.
Recomenda-se que ao inicializar o sistema os arquivos contidos neste diretório sejam apagados.
Distribuições do Debian fazem isso automaticamente.
/usr
O diretório /usr é a segunda maior seção do sistema de arquivos, nele estão os dados
compartilháveis apenas para a leitura. Isso significa que não deve ser gravado nada “manualmente”
neste diretório, toda informação que for gerada com o tempo deve ser armazenada em outra parte
(existem os diretórios apropriados para isso).
Encontram-se neste diretório o gerenciador de janelas X, programas de usuários, jogos, etc...
Os subdiretórios mais importantes dentro da estrutura /usr são:
19
bin Binários não inerentes ao sistema.
include Arquivos de cabeçalho incluídos por programas em C.
lib Bibliotecas do Sistema.
local Arquivos Não-Compartilháveis (Sim, /usr é compartilhável, mas
/usr/local não é).
sbin Binários inerentes ao sistema.
share Dados compartilháveis entre os programas
DICAS MAIS
Repare que a maioria desses diretórios dentro de /usr também existe na raiz do sistema. A
diferença entre eles é que os que ficam na raiz contém dados que não podem ser compartilhados
pela rede, já os que ficam em /usr sim.
/var
Contém arquivos de dados de variáveis. Isto inclui diretórios e arquivos de spool, dados
administrativos e logs do sistema.
Devido a provável grande quantidade de dados e acessos que esse diretório receberá, uma boa prática
do administrador é alocar uma partição em um disco separado para receber o diretório /var. Isso
garante mais velocidade (menos acessos no mesmo disco que contém o sistema) e facilitar as tarefas
de backup.
/proc
O diretório /proc é ligeiramente diferente dos diretórios comuns, pois os dados nele contidos não
estão fisicamente em nenhum disco rígido do sistema, mais sim na memória RAM. Trata-se de um
sistema de arquivos virtual que é criado e gerenciado pelo Kernel em tempo real e é a forma mais
direta que o usuário tem de interagir com o kernel.
Os arquivos nele contidos contém basicamente valores de variáveis do kernel. Acompanhe os
exemplos:
Exemplo A:
20
#cat /proc/cpuinfo
processor :0
vendor_id :AuthenticAMD
cpu family :6
model :4
model name :AMD Athlon (tm)processor
stepping :2
cpu Mhz :950.066
cache size :256 KB
fdiv_bug :no
hlt_bug :no
f00f_bug :no
coma_bug :no
fpu :yes
fpu_exception :yes
cpuid level :1
wp :yes
flags :fpu vmef de pse tsc msr pae mce cx8 apic sep mtrr pge mca
cmov pat pse36 mmx fxsr syscall mmxert 3dnowext 3dnow
bogomips :1893.99
Repare que foi mostrado o conteúdo do arquivo /proc/cpuinfo com o comando cat, e que nesse
arquivo estão contidas as informações sobre o processador em uso na máquina.
O /proc está repleto de arquivos como esses, a existência ou não da maioria deles depende de
opções específicas da versão do kernel em uso no sistema. Os arquivos que costumam existir em
sistemas atuais com Kernels 2.4 e 2.6 e nos trazem informações importantes, como na tabela a seguir:
/proc/cpuinfo Informações sobre a(s) CPU(s) do sistema.
/proc/meminfo Informações sobre a memória do sistema.
/proc/pci Mostra informações sobre os Dispositivos conectados ao barramento PCI da
placa mãe.(OBS.: Esse arquivo mostra “todos” os dispositivos que estão
interconectados no barramento PCI, não somente as placas plugadas nos
slots PCI da placa mãe. A maioria dos dispositivos on-board, como placas
de som, usb e modem, aparecem na listagem).
A saída desse comando é semelhante ao comando: lspci v
/proc/interrupts Mostra quais dispositivos estão utilizando as respectivos interruções do
Sistema.(IRQs).
/proc/ioports Mostra quais portas de entrada e saída (Portas e IO), os dispositivos estão
utilizando.
/proc/cmdline Mostra a linha de parâmetros que foi passada ao kernel durante a
inicialização.
/proc/kcore Esse arquivo é exatamente o conteúdo da memória ram em binário,
portanto, não é um arquivo legível por nós humanos.
Além desses, o diretório /proc contém alguns subdiretórios com funções especiais, começando por
diretórios “numéricos” que contém informações sobre os processos rodando na máquina. O diretório
/proc/sys contém uma hierarquia de arquivos e diretórios que servem para interagirmos
diretamente com o kernel. Geralmente esses arquivos contêm um valor de lógica booleano
(verdadeiro/falso), valendo 0 (falso) ou 1 (verdadeiro). Alguns desses arquivos contêm strings que
21
são valores de variáveis passadas diretamente ao kernel. A modificação desses arquivos repercute
imediatamente.
Exemplo A:
# cat /proc/sys/net/ipv4/ip_forward
0
#echo 1 > /proc/sys/net/ipv4/ip_forward
#cat /proc/sys/net/ipv4/ip_forward
1
Nesse exemplo, primeiro foi mostrado o conteúdo do arquivo

/proc/sys/net/ipv4/ip_forward, que retornou 0 (desabilitado). Esse arquivo
habilita/desabilita a repassagem de pacotes IP no kernel, e vem desabilitado por padrão. No próximo
comando, o conteúdo do arquivo foi substituído pelo valor 1, o que instantaneamente ativa a
repassagem de pacotes ip no kernel.
Todas as alterações feitas dessa forma na estrutura do /proc serão perdidas na próxima
reinicialização. Para salvá-las, devemos adicionar as entradas no arquivo /etc/sysctl.conf. Para
salvar a modificação feita no exemplo acima, adicionaríamos a seguinte linha no arquivo
/etc/sysctl.conf (verifica se a linha já não existe):
net/ipv4/ip_forward=1
O comando sysctl p confirma a alteração.
22
Manipulação de Arquivos e Diretórios
A seguir veremos alguns comandos utilizados para manipular arquivos e diretórios, tarefa comum do
dia a dia de um administrador de Sistemas Linux.
mkdir
Utilizando o comando mkdir com a única finalidade de criar diretórios no sistema. Um diretório nada
mais é do que um arquivo especial contendo a lista de outros diretórios e arquivos nele contidos. Ele
pode ser entendido como uma pasta onde você guarda seus papéis (arquivos). Como uma pessoa
organizada, você utilizará uma pasta para guardar cada tipo de documento, da mesma forma você
pode criar um diretório vendas para guardas seus arquivos relacionados com vendas naquele local.
Sintaxe:
mkdir [parâmetro] <diretório> [<outro diretório>] [...]
Exemplo A:
mkdir dir1
Cria um diretório chamado dir1 dentro do diretório atual.
Exemplo B:
# pwd
/root
# mkdir dir2
# mkdir dir2/gama/beta
mkdir: connot create directory 'dir2/gama/beta/teste': No such file or
directory
# mkdir -p dir2/gama/beta/teste
# ls dir2/gama/beta/
teste
Primeiro criamos o diretório dir2 dentro da pasta atual (/root). Em seguida tentamos criar o
diretório dir2/gama/beta, sem sucesso, pois o mkdir por padrão só cria um diretório se o anterior
já existir. Para mudar esse comportamento, utilizamos a opção -p (parents), que cria os diretórios pais
caso eles não existam.
DICA
Podem ser criadas mais de um diretório com um único comando.

Exemplo: mkdir /tmp/teste /tmp/teste2 /tmp/teste3
tree
Exibe a árvore de diretórios do seu conteúdo em formato hierarquico. É um comando simplório,
porém de grande ajuda. Não possui argumentos.
Sintaxe:
tree [opções] <diretório>
-a Lista todos os arquivos, inclusive ocultos.
-d Lista somente diretórios.
23
-f Mostra caminho completo dos diretórios e arquivos.
-i Desabilita a identação.
-C Habilita saída colorida.
-p Mostra permissões dos arquivos /diretórios.
-u Mostra usuário dono dos arquivos /diretórios.
-g Mostra grupo dono dos arquivos /diretórios.
Exemplo:
# tree –f
.
|-- ./Desktop
| '-- ./Destop/starthere.desktop
|-- ./dead.letter
|-- ./dir2
| '--./dir2/gama
| '--./dir2/gama/beta
| '--./dir2/gama/beta/teste
|-- ./fedora2
| |-- ./fedora2/disc1
| | '-- ./fedora2/disc1/FCS-i386-dsc1.iso
| | '-- ./fedora2/disc2/FCS-i386-disc2.iso
| | '-- ./fedora2/disc3/FCS-i386-disc3.iso
| '-- ./fedora2/disc4/FCS-i386-disc4.iso
|-- ./historico
'-- ./iptraf.log
10 directories, 8 files
rmdir
Remove um diretório do sistema. O diretório a ser removido deve estar vazio.
Sintaxe:
rmdir <diretorio>[<outro diretorio>] [...]
24
É necessário estar um nível acima do diretório(s) que será(ão) removido(s). Para remover diretórios
que contenham arquivos, use o comando rm com o parâmetro -r.
Por exemplo, para remover o diretório /tmp/teste você deve estar fora deste diretório e executar o
comando, como no exemplo abaixo:
Exemplo:
# rmdir /tmp/teste
touch
Muda a data e hora que um arquivo foi criado. Também pode ser usado para criar arquivos vazios.
Sintaxe:
touch [parâmetros] <arquivo[s]>
Utiliza a hora especificada (MM=mês, DD=dia, hh=hora,
t [AA]MMDDhhmm mm=minuto). O ano com dois dígitos no começo são opcionais
(AA).
a Modifica a data de acesso do arquivo.
c Não cria um arquivo vazio, caso o arquivo não exista.
m Modifica a data de modificação do arquivo.
r arquivo_de_referencia Utiliza um arquivo de referência de data para o arquivo alvo.
Exemplo A:
# ls
# touch arquivo1 arquivo2 arquivo3
# ls –l
total 3
-rw-r--r-- 1 agomes cds 0 2004-l0-27 17:22 arquivo1
Criados 3 arquivos vazios. Observe a data de criação dos arquivos.

Exemplo B:
# ls -l arquivo1
# touch -t 0311201245 arquivo1
# ls -l arquivo1
Continuando o exemplo anterior, modificamos a data de criação de arquivo1 para dia 20 de novembro
25
de 2003, as 12:45.
Exemplo C:
# ls –l
# touch -r arquivo1 arquivo3
# ls -l
Agora utilizamos o touch para modificar a data de criação ao de arquivo3 com base em arquivol.
cp
Copia arquivos. Sintaxe:
cp [OPÇÃO]... ORIGEM DESTINO
cp [OPÇÃO]... ORIGEM... <DIRETORIO>
cp [OPÇÃO]... --target-directory=DIRETORIO ORIGEM...
Copia ORIGEM para DESTINO, ou múltiplas ORIGENS para DIRETÓRIO.

ORIGEM é o arquivo que será copiado. Podem ser especificados mais de um arquivo para ser
copiado e também pode-se usar "Curingas" como? e *. DESTINO é o caminho ou nome de arquivo
onde será copiado. Mesmo que o DESTINO seja a pasta atual, ele deve ser especificado (Lembrete:
"." significa o diretório atual). Se o destino for um diretório, os arquivos de origem serão copiados
para dentro do diretório.
i Pergunta antes de substituir um arquivo existente.
r Faz cópia recursiva dos arquivos.
v Mostra nomes dos arquivos enquanto copia.
a Copia todos os tipos de arquivos, inclusive links simbólicos. O cp não copia links
simbó1icos por padrão.
s Cria link simbólico no destino ao invés copiar o arquivo em si.
I Cria link (hardlink) no destino ao invés copiar o arquivo em si.
p Mantém os atributos do arquivo, se possível!
u Copia somente se o arquivo de origem e mais novo que o arquivo de destino ou quando o
arquivo de destino não existe. Cópia de atualização, na verdade.
x Não copia arquivos que estejam localizados em partições (Pontos de Montagem)
diferentes.
Antes de prosseguir, vamos criar o ambiente para os exercícios:
26
Ambiente:
$ mkdir -p ~/exercicios/cp
$ cd ~/exercicios/cp
$ mkdir /tmp/arquivos
$ touch /tmp/arquivos/arquivo{1,2,3}
$ ls /tmp/arquivos
arquivol arquivo2 arquivo3
Exemplo A:
$ ls
$ cp /tmp/arquivos/arquivol
$ ls
arquivol
Efetuada uma simples cópia do arquivo arquivol para diretório atual (~/exercícios/cp).
Exemplo B:
$ mkdir subdir
$ cp -var /tmp/arquivos subdir/
'/tmp/arquivos' -> 'subdir/arquivos'
'/tmp/arquivos/arquivol' -> 'subdir/arquivos/arquivol'
'/tmp/arquivos/arquivo2' -> 'subdir/arquivos/arquivo2'
'/tmp/arquivos/arquivo3' -> 'subdir/arquivos/arquivo3'
$ cp -var /tmp/arquivos .
'/tmp/arquivos' -> './arquivos'
'/tmp/arquivos/arquivol' -> './arquivos/arquivol'
'/tmp/arquivos/arquivo2' -> './arquivos/arquivo2'
'/tmp/arquivos/arquivo3' -> './arquivos/arquivo3'
$ tree
.
|-- arquivol
|-- arquivos
|--|-- arquivol
|--|-- arquivo2
| ‘-- arquivo3
‘-- subdir
‘--arquivos
|-- arquivol
|-- arquivo2
‘-- arquivo3
3 directories, 7 files
Copia recursivamente todo a conteúdo de /tmp/arquivos para subdir/ (recém-criado). Depois

faz a mesma copia, porém com a destino sendo a diretório atual, mas como estamos copiando uma
estrutura completa de um diretório, esse diretório também e criado, assim como toda a estrutura
anterior, como pode ser vista na saída do comando tree.
Exemplo C:
27
$ ls
arquivol arquivos subdir
agomes@pontes:~/exercicios/cp$ cp -i /tmp/arquivos/arquivol .
cp: sobrescrever ‘./arquivol'? s
$ cp /tmp/arquivos/arquivo? .
$ ls
arquivol arquivo2 arquivo3 arquivos subdir
$
Copiado a arquivo arquivol para o diretório local, porém já existia um arquivo de mesmo nome. A
opção -i garante confirmação antes de sobrescrever um arquivo. Depois foi utilizado um coringa (?)
para copiar 3 arquivos de uma só vez para a diretório atual, e dessa vez, como não foi especificada a
opção -i, a arquivo arquivol foi sobrescrito sem pedir confirmação.
mv
Move ou renomeia arquivos e diretórios. O processo é semelhante ao do comando, cp mas a arquivo
de origem e movido de seu local original para a novo local.
Sintaxe:
mv [parametro] [origem] [destino]
-f Substitui o arquivo de destino sem perguntar.
-i Pergunta antes de substituir (padrão).
-v Mostra os nomes dos arquivos que estão sendo movidos.
-u Copia somente se a arquivo de origem é mais novo que a arquivo de destino ou quando a
arquivo de destino não existe.
Exemplo A:
$ mkdir -p ~/exercicios/mv; cd ~/exercicios/mv
$ touch teste.txt
$ mv teste.txt cds.txt
$ ls
cds.txt
Muda o nome do arquivo teste.txt para cds.txt.txt.

Exemplo B:
$ mv -v cds.txt /tmp
'cds.txt' ->'/tmp/cds.txt'
removed 'cds.txt'
Move arquivo cds.txt para dentro do diretório /tmp. Repare que o comando mv age de forma
idêntica ao cp, porém ele remove o arquivo logo após a copia.
rm
Apaga arquivos. Também pode ser usado para apagar diretórios e sub-diretórios.
28
Sintaxe:
rm [parametro] <arquivo ou diretorio> [<outro arquivo ou diretorio [...]
-r Remove Arquivos e Diretórios recursivamente. Necessário quando se quer remover algum
diretório não-vazio.
-i Pergunta antes de remover.
-v Mostra os nomes dos arquivos que estão sendo movidos.
-u Copia somente se o arquivo de origem é mais novo que o arquivo de destino ou quando o
arquivo de destino não existe.
-f Força a remoção. Remove arquivo(s) e/ou diretório(s) sem perguntar. (Perigoso se
associado com o comando).
Exemplo A:
$ mkdir -p ~/exercicios/rm; cd ~/exercicios/rm
$ touch teste.txt
$ rm -iv teste.txt
rm: remove arquivo comum vazio 'teste.txt'? s
removed 'teste.txt'
Apaga o arquivo teste.txt no diretório atual.
Exemplo B:
$ cd /
$ rm -rfv ~/exercicios/rm
removed directory:‘/home/usuario/exercicios/rm'
Remove o diretório rm, criado no Exemplo ª
cat
Concatena e exibe arquivos.
Sintaxe:
cat [parametro] <diretorio ou arquivo>
-A Exibe todos os caracteres especiais.
-b Numera apenas as linhas não-vazias da saída.
-n Numera todas as linhas da saída.
-v Exibe caracteres não-imprimíveis.
-t Exibe caracteres de tabulação.
Exemplo:
29
$ mkdir -p ~/exercicios/cat; cd ~/exercicios/cat
$ cat> testel.txt
teste 1
$ cat> teste2.txt
teste2
$ ls
testel.txt teste2.txt
$ cat testel.txt
testel
$ cat -n testel.txt
1 testel
$ cat -n testel.txt teste2.txt
1 testel
2 teste2
$ cat -n test*
1 testel
2 teste2
O primeiro comando cat redireciona a palavra digitada teste 1 para o arquivo testel.txt. Para que o
texto digitado vá definitivamente para o arquivo, devemos teclar [CONTROL]+[D] em uma linha
abaixo da última contendo texto. O mesmo e feito com teste2.txt. Depois utilizamos o comando cat
para visualizar o conteúdo do arquivo testel.txt. Repare na utilização do parâmetro –n
tac
Mostra o conteúdo de um arquivo (como o cat) em ordem inversa, ou seja, as últimas linhas primeiro.
Sintaxe:
tac [parametro] <diretorio ou arquivo>
Exemplo:
$ mkdir -p ~/exercicios/tac; cd ~/exercicios/tac
$ cat > teste.txt
linhal
linha2
linha3
$ tac teste.txt
linha3
linha2
linhal
ln
Cria links para arquivos e diretórios no sistema. O link e um mecanismo que faz referência a outro
arquivo ou diretório em outra localização (Como os atalhos no Microsoft Windows®).
Sintaxe:
ln [parametro] [origem] [link]
ln [parametro]... <destino> [link]
ln [parametro]... <destino>... <diretorio>
Tabela de parâmetros
s Cria Link simbólico.
30
v Mostra o nome de cada arquivo ao fazer o link.
d Cria Hardlink para diretórios. Somente o root pode usar essa opção.
Antes de entender os links, devemos compreender um termo sobre os sistemas de arquivos: Inodes.
Inodes
Todo arquivo criado no sistema de arquivos recebe um número que o identifica unicamente dos
demais “no mesmo sistema de arquivos (partição)”. A esse número damos o nome de inode.
E possível saber o inode de um arquivo específico com a opção -i do comando ls.
Exemplo:
$ ls -i testel.txt
554844 testel.txt
Nesse exemplo, o inode do arquivo teste1. txt é 554844.
Existem 2 tipos de links: Links Simbólicos e Hardlinks.
Links Simbólicos
O link simbólico cria um arquivo especial no disco (do tipo link) cujo conteúdo e o caminho para
chegar até o arquivo alvo (Isto pode ser verificado pelo tamanho do arquivo do link, bem menor do
que o arquivo de destino). Use a opção -s para criar links simbólicos.
Ambiente:
$ mkdir ~/exercicios/ln; cd ~/exercicios/ln
$ touch arquivol
$ mkdir ~p dirl/subl/sub2 dir2/
Esses comandos criarão o ambiente necessário para aprendermos sobre links.
Exemplo A:
$ ln -s arquivo1 link1
$ ls -li
total 8
554848 -rw-r--r-- 1 agomes cds 0 2005-l0-28 17:29 arquivo1
439830 drwxr-xr-x 3 agomes cds 4096 2005-l0-28 17:30 dir1
554850 lrwxrwxrwx 1 agomes cds 8 2005-l0-28 17:41 link1 -> arquivo1
Utilizamos o ln para criar um link simbólico (opção -s) do arquivo arquivo1 para link1. Repare que
ele aparece referendado na saída do comando ls -li. Constate também que o número dos inodes dos
arquivos "linkados" diferem, o que confirma que são realmente arquivos diferentes.
Exemplo B:
$ cd dir1/sub1/sub2/
$ ln -s ../../../dir2
$ ls -l
total 0
lrwxrwxrwx 1 agomes cds 13 2004-l0-29 09:42 dir2 -> ../../../dir2
31
Repare a possibilidade de se criar links utilizando caminhos relativos, inclusive para diretórios. Se
movermos o link de lugar, o link pode perder referência (apontar para um arquivo inexistente) e se
tornar um "link quebrado".
Hardlinks
A grande diferença entre os Links Simbólicos e os Hardlinks é a forma como eles referenciam o
arquivo "linkado". No caso dos Hardlinks, não é criado um arquivo novo no sistema de arquivos
como nos links simbólicos, e sim adicionados uma nova referência no diretório atual que aponte o
link para o "mesmo inode" do arquivo original. Dessa forma, se fizermos um hardlink de um arquivo,
não teremos dois arquivos "diferentes" no sistema, e sim uma nova referência ao mesmo inode do
arquivo linkado, o que torna o link exatamente o mesmo arquivo que o original, pois o arquivo só
sera excluído do sistema de arquivos quando o último link também for. Não e possível criar
HardLinks para arquivos que não se encontrem no mesmo sistema de arquivos (partição).
Exemplo:
$ cd ~/exercicios/ln/
$ ls -li
total 8
$ ln arquivo1 hardlink1
$ ls -li
total 8
554848 -rw-r--r-- 2 agomes cds 0 2004-l0-28 17:29 hardlink1
Criado um link do arquivo arquivo1 para hardlink1. Repare que o inode deles são idênticos
(destacados em negrito). Isso significa que são exatamente os mesmos arquivos.
32
Gerenciamento de Usuários e Grupos
Neste capítulo aprenderemos a utilizar as ferramentas para gerenciar usuários e grupos do sistema.
Tarefa crucial num ambiente de administração Linux.
Identificadores de Usuários e Grupos (UID e GID)

No GNU/Linux, assim como no Unix, os usuários e grupos do sistema possuem um identificador
numérico que os diferenciam dos demais. No caso dos usuários, esse número e chamado de UID
(User Identificator). No caso dos grupos, esse número recebe o nome de GID (Group Identificator).
Esses sistemas utilizam arquivos texto para "traduzir" o UID e GID para um nome inteligível para
humanos, além de fornecer outras informações. Para que um usuário seja válido no sistema, é preciso
que hajam registros para eles, nesses arquivos.
Esses arquivos serão mostrados a seguir.
/etc/passwd
Esse arquivo contém uma lista em modo texto de todos os usuários cadastrados no sistema, um por
linha, onde cada linha se divide em sete campos. O caractere ":" divide os campos de cada linha.
Segue um exemplo de uma linha do arquivo /etc/passwd:
camila:x:1000:1000:Camila S. Nolasco,,,:/home/camila:/bin/bash
O primeiro campo (camila) é o nome do usuário.

O segundo campo (x) e a senha criptografada do usuário. Sempre quando esse campo contiver apenas
a letra x, significa que o sistema está utilizando senhas sombreadas (Shadow Passwords), ou seja, não
está armazenando as senhas nesse arquivo, e sim no /etc/shadow, visto mais adiante.
Os campos 3 e 4 Mostram o UID e GID do usuário, respectivamente.
O quinto campo e chamado GECOS, e armazena informações adicionais sobre o usuário, divididas
com "," dentro do campo. Informações que podem ser o Nome Completo do Usuário, telefones,
número da sala, etc.
O sexto campo define qual será o diretório base do usuário (diretório home). No exemplo, o diretório
base do usuário e /home/camila.
E finalmente, o sétimo e ultimo campo define qual será a interpretador de comandos (shell) do
usuário. Nesse caso a shell do usuário e /bin/bash. Quando a usuária camila efetuar login no
sistema, será executado a comando /bin/bash, devido a isso que e aberto um bash logo após a
login.
/etc/shadow
Esse arquivo somente e utilizado quando Senhas Sombreadas (Shadow Passwords) estão um uso no
sistema. Senhas Sombreadas são utilizadas nas Distribuições atuais á muito tempo, pais oferecem
mais segurança guardando a senha em um arquivo que não pode ser lido par usuários comuns no
sistema (o /etc/passwd pode ser lido par todos).
O /etc/shadow segue a mesmo formato de divisão do /etc/passwd, porém contém 9 campos.
camila:$1$eTdnOtUz$Ck447Zu3nMzolbPXWQq3g.:12708:0:99999:7:::
Os campos estão divididos da seguinte forma:

1 - Nome do usuário:
2 - Senha criptografada.
33
3 - Data da última troca de senha (Contada em dias corridos desde 0110111970).
4 - Tempo mínimo de dias que a senha deve permanecer inalterada.
5 - Tempo máxima de dias que o usuário pode ficar com a mesma senha.
6 - Com quantos dias de antecedência a sistema deve avisar que a senha ira expirar.
7 - Número de dias de inatividade em que a sistema deve considerar a usuário bloqueado.
8 - Uma data para a expiração automática da conta. Utiliza a mesmo formato do campo 3.
9 - Esse último campo esta reservado para uso futuro.
/etc/group
É neste arquivo que são armazenados todos os grupos armazenados no sistema. Esse arquivo também
segue a mesmo formato que a /etc/passwd, mas cada linha contém apenas 4 campos. Conforme
abaixo:
cds:x:1410:camila,fulana,beltrana
O primeiro campo e a nome do grupo, a segundo a senha do grupo, seguido do GID do grupo. O
último campo, quase sempre vazio, e a lista, separada par vírgula, dos usuários que também
pertencem a esse grupo.
/etc/gshadow
O arquivo gshadow armazena informações de administradores e senhas de grupos.
games:*::
O primeiro campo e o nome do grupo; O segundo é a senha do grupo, como não esta definida,
recebe o valor de *; O terceiro campo armazena os nomes dos administradores desse grupo
(Administradores de grupos serão explicados adiante), separados por vírgula; O último campo tem a
mesma função do último campo do arquivo /etc/group.
Gerenciamento de usuários
Existem diversas formas de gerenciarmos usuários do sistema. Em qualquer uma delas, o objetivo e
gerenciar as entradas adequadas dos arquivos /etc/passwd, /etc/shadow, /etc/group e
/etc/gshadow. Adicionar as entradas manualmente editando esses arquivos e uma tarefa difícil e
perigosa, pois está mais propensa a erros. Por isso existem alguns comandos especificamente
designados para gerenciar essas entradas dos respectivos arquivos. Veremos esses comandos que a
seguir.
Adicionando usuários com useradd

Utilizamos o comando useradd para criar um novo usuário no sistema.
Sintaxe:
user add [-u uid [-0]] [-g grupo] [-G grupo-secundario,...]
[-d home] [-s shell] [-c comentario] [-m [-k template]]
[-f inativo] [-e expiração] [-p senha] usuario
user add -D [-g grupo] [-b base] [-s shell]
[-f inativo] [-e expiração]
O useradd trabalha de dois modos. O primeiro modo adiciona o usuário com as opções
34
específicas. O segundo modo e ativado quando a opção -D (Defaults) e habilitada, e serve para
visualizar e definir os padrões para criação dos usuários.
35
Informa qual deve ser o UID do usuário. Se omitido, o sistema utiliza o próximo
u uid
disponível.
o Permite criar usuário com UID duplicado (Usuário Clonado)
g grupo Especifica qual será o grupo principal do Usuário. Algumas distribuições
aderem ao sistema criado pela RedHat, chamado UPG (Unix Private Group),
que cria um grupo com o mesmo nome do usuário, no qual somente
determinado usuário pertence ao grupo. Informando esse parâmetro estamos
evitando que o sistema crie um grupo no esquema UPG, mas o grupo no qual
informarmos já deve previamente existir.
G grupo
Especifica a quais grupos secundários esse usuário deve pertencer.
secundário
d home Especifica qual será o diretório base do usuário.
s shell Especifica qual será o shell do usuário.
c comentário Adiciona informações no campo GECOS do arquivo /etc/passwd.
m
O sistema criará um diretório base para o usuário caso ele não exista

(comportamento padrão). O conteúdo do novo diretório será exatamente o

mesmo que o diretório /etc/skel, que, por sua vez, serve como um diretório

de perfil para novos usuários criados no sistema.

k template Especifica uma pasta de template (perfil) alternativa ao /etc/skel para
O usuário a ser criado. Essa opção só é valida junto com a opção –m.
f inativo
Especifica o número de dias em que a senha expire até que a conta seja

permanentemente desabilitada. O valor o expira a senha assim que a conta

houver expirado. O valor l desabilita essa característica (padrão).

e expiração Especifica uma data na qual a conta irá expirar. O Formato deve ser AAAA
MMDD, por exemplo: 2004l101 seria 01 de novembro de 2004.
p senha Especifica a senha criptografada. Inútil nos dias de hoje, pois existem comandos
específicos para gerenciar as senhas.
D Se utilizada sem nenhum outro parâmetro serve para visualizar os padrões atuais
para criação dos usuários. Se ativada em conjunto com as opções g, b, s, f ou
e é possível modificar o valor padrão de grupo, diretório base (home), shell,
inativo e expiração, respectivamente.

36
Exemplo A:
# useradd -G users,audio -d /home/cds -m -c "Cds" aluno
O comando acima adicionou o usuário "aluno" ao sistema, pertencendo aos grupos users e audio
(esses grupos já existiam). A linha no arquivo /etc/passwd ficou assim:
aluno:x:l0092:100:Cds:/home/cds:/bin/bash
Exemplo B:
# useradd -D
GROUP=lOO
HOME=/home
INACTIVE=-l
EXPIRE=
shell=
SKEL=/etc/skel
# useradd -D -s /bin/sh
# useradd -D
GROUP=lOO
HOME=/home
INACTIVE=-l
EXPIRE= shell=/bin/sh
SKEL=/etc/skel
Modificamos o grupo padrão para novos usuários para o UID 29, que em nosso sistema refere-se ao
grupo audio.
Definindo Senhas com passwd
O comando passwd modifica senhas para contas de usuários e grupos. Um usuário normal somente
pode trocar sua própria senha. Somente o superusuário root pode trocar a senha de qualquer usuário
no sistema. O passwd também e utilizado para modificar informações sobre a conta de usuário, tais
como o nome completo, o shell inicial, data de expiração de senha, etc.
Sintaxe:
Passwd [-f|-S] [usuario]
Passwd [-x maximo] [-n minimo] [-w aviso] [-i inativo] usuario
Passwd usuario {-l|-u|-d|-S|-e} usuario
f Serve para trocar o nome do usuário (campo de comentário no arquivo
/etc/passwd). Age como o comando chfn, visto adiante.
s Age como o comando chsh, visto adiante. Serve para modificar o shell do usuário.
l Trava a conta do usuário. (lock)
u Destrava a conta do usuário. (unlock)
d Deleta a senha do usuário (Deixa em Branco).
s Mostra o status da conta de usuário. (Data de expiração, etc...)
e Expira imediatamente a senha do usuário.
37
Troca de Senhas
Quando um usuário aciona o comando passwd para trocar a senha, o usuário e questionado a si
mesmo quanto a senha atual (caso exista). A senha digitada é então criptografada e comparada com a
senha criptografada já existente no sistema. .
O usuário só tem uma chance de inserir a senha correta. Somente o superusuário root pode trocar
senhas sem antes confirmar a anterior, pois isso permite que ele possa redefinir senhas "esquecidas",
por exemplo. .
Logo após a senha antiga ser validada, informações sobre a idade da senha são verificadas no sistema
para definir se o usuário tem permissão de trocar a senha naquele momento. Em caso negativo, o
passwd se recusa a trocar a senha. Em caso positivo, o usuário é então questionado sobre a nova
senha, que após digitada, é verificada quanto à complexidade. No geral, senhas devem consistir em 6
a 8 caracteres incluindo um ou mais do seguinte:
- Letras maiúsculas;
- Letras minúsculas;
- Números de 0 a 9;
- Caracteres de pontuação (Ex.: ~,. !")
O passwd irá rejeitar qualquer senha que não atender aos requisitos.
Se a senha for aceita, o usuário é então questionado para repetir a mesma senha, que é então
comparada com a senha nova para evitar que erros de digitação possam impedir que determinado
usuário acesse o sistema.
Cabe ressaltar que o passwd pode modificar a ordem de verificação em alguns sistemas, mas os
passos são os mesmos.
Exemplo A:
# passwd aluno
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
Primeiramente definimos uma senha para o usuário "aluno". Como e o usuário root que está definindo
a senha para o usuário "aluno", a checagem de complexibilidade da senha não e feita. No exemplo
definimos a senha 123 (não aparece enquanto digitamos, e normal).
Exemplo B:
$ passwd
Changing password for aluno
(current) UNIX password:
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
Agora, após logarmos como o usuário aluno, tentamos trocar sua senha, repare que foi necessário
digitar a senha atual (123). Na nova senha, escolhemos uma com boa complexibilidade:
"zxasQW12", sem as aspas.
Exemplo C:
# passwd -de aluno
Password changed.
Deletamos e expiramos a senha para o usuário aluno, isso ira requerer que o usuário cadastre uma
nova senha na próxima tentativa de login. Muito cuidado com isso, utilize somente em casos
38
extremos em que não exista outra alternativa, pois caracteriza uma grande falha de segurança.
Removendo usuários com userdel
Utilizamos o comando userdel para remover usuários do sistema.
Sintaxe:
userdel [-r] usuário
O único parâmetro disponível para o userdel é o -r, que instrui ao userde1 para remover também
todos os arquivos do usuário (na verdade o comando remove a pasta home do usuário). Por padrão
(sem a opção -r), o userdel mantém os arquivos do usuário.
Exemplo:
# ls -ld /home/aluno
drwxr-xr-x 2 aluno users 136 Nov 3 11:43 /home/aluno/
# userdel -r aluno
userdel: user aluno ls currently logged in
O sistema apresentou um erro ao tentar remover o usuário aluno, que estava logado em outro
terminal. Não e possível remover usuarios que estejam logados no momento.
# userdel -r aluno
# ls -ld /home/aluno/
ls: /home/aluno/: No such file or directory
Após o usuário efetuar logoff do terminal em que estava já é possível removê-lo. Repare que foram
removidos também seus arquivos pessoais.
Aumentando a segurança com o comando chage

O comando chage serve para gerenciar as entradas de expiração de senha encontradas no arquivo
/etc/shadow. É muito importante definir informações de expiração de senha para um sistema
Linux, pois isso agrega mais segurança, impedindo que usuários permaneciam muito tempo com a
mesma senha, ou até mesmo que contas de usuários inexistentes. permaneçam válidas.
Sintaxe:
chage [m mindias] [M max_dias] [d ultimo_dia] [I inativo]
[E data_expira] [W dias_aviso] usuário
chage l usuário
O comando chage age de duas formas. Da primeira forma ele define as opções de expiração de senha
do usuário, da segunda forma (com a opção -l) ele mostra as opções atualmente definidas para
determinado usuário.
m min dias Intervalo mínimo de dias que o usuário pode trocar a senha.
M max dias Número máximo de dias que o usuário pode permanecer com a mesma
senha.
39
d ultimo dia Especifica qual a data da última alteração de senha do usuário. O valor
a ser especificado para ultimo_dia é o número de dias desde
01/01/1970, ou uma data no formato AAAAMMDD (Ex: 2004l2l5
significa dia 15 de dezembro de 2004).
I inativo Número de dias de inatividade (Sem efetuar Login no sistema) que a
senha e automaticamente bloqueada.
Especifica até qual data a conta do usuário será válida. Útil para
E data_expira usuários de funcionários temporários. O valor para data_expira segue o
mesmo padrão que a opção d.
W dias aviso Configura com quantos dias de antecedência, determinado usuário será
avisado sobre a expiração de sua senha.
I Lista as opções atuais de expiração de senha.
Exemplo A:
# chage l zezinho
Minimun: 0
Maximun: 99999
Warning: 7
inactive: 1
Last Change: Nov 10, 2004
Password Expires: Never
Password Inactive: Never
Account Expires: Never
# chage zezinho
Changing the aging information for zezinho
Enter the new value, press ENTER for the default
Minimun Password Age [0]: 2
Maximun Password Age [99999]: 90
Last Password Change(YYYYMMDD) [20041110]:
Password Expiration Warning [7]: 5
Password Inactive [1]: 30
Account Expiration Date (YYYYMMDD) [19791231]: 20041215
# chage l zezinho
Minimun: 2
Maximun: 90
Warning: 5
inactive: 30
Last Change: Nov 10, 2004
Password Expires: Feb 08, 2005
Password Inactive: Mar 10, 2005
Account Expires: Dec 15, 2004
Repare em como ficaram os valores de expirção de senha apos as modificações e associe aos campos
40
adequados.
Exemplo B:
# chage -m2 -M90 -W5 -I30 -E2004-l2-l5 zezinho
Uma outra forma de se chegar ao mesmo resultado do exemplo anterior.
DICA
Quando uma conta e bloqueada por motivo de expiração de senha, somente o
administrador (root) e capaz de desbloqueá-Ia utilizando novos valores para o chage e,
quando necessario, desbloqueando a conta com o comando "passws –u usuario”
Gerenciando informações de usuários com chfn e finger

Podemos utilizar o comando chfn para editar informações típicas dos usuários, como seu nome
completo, telefone, departamento, etc. Essas informações ficam armazenadas em cada uma das
entradas do arquivo /etc/passwd, mais especificamente no quinto campo de cada entrada.
É bastante útil ter essas informações, pois e a forma mais fácil de obter informações sobre os usuários
cadastrados no sistema.
Sintaxe:
chfn -f nome_completo] [-r sala]
-w fone trabalho] [-h fone casa] [-o outros] [usuario]
Tabela de Parâmetro
f nome_completo Configura o Nome completo do Usuário (Ex: Joao da Silva)
r sala Número da sala em que ele trabalha
w fone trabalho Telefone Comercial
h fone casa Telefone Residencial
o outros Outras Informações e Observações
Exemplo A:
# chfn zezinho
Changing the user information for zezinho
Enter the new value, or press ENTER for the default
Full Name []: Hugo da
Room Number []: 5
Work phone []: 5555555
Home phone []: 6666666
Other []: Usuario de testes da cds
# finger zezinho
Login: zezinho Name: Jose Lima Lopes
Directory: /home/zezinho Shell: /bin/sh
Office: 5, 555-5555 Home Phone: 666-6666
Last login Thu Nov 11 14:35 (BRST) on tty2
No mail.
No Plan.
As informações definidas com chfn podem ser consultadas com o comando finger, conforme o
exemplo.
41
NOTA
O comando finger não vem instalado por padrão em algumas distribuições Linux. No Debian,
para instalalo, digite como usuario root: aptget install finger.
Exemplo B:
chfn -f " Jose Lima Lopes " -r 5 -w 5555555 -h 6666666 -0
"Usuário de testes do cds" zezinho.
A linha de comando acima leva ao mesmo resultado que o exemplo anterior.
Modificando o shell do usuário com chsh

O comando chsh lida com o último campo do arquivo /etc/passwd. O shell inicial do usuário. Um
usuário normal somente pode trocar o shell principal para sua própria conta. Somente o root tem
permissão para trocar o shell de outros usuários.
Sintaxe:
chsh [-s login_shell] [user]
Quando o comando e invocado por um usuário normal, o novo shell informado deve estar listado no
arquivo /etc/shells. Se for invocado pelo root e o comando não existir nesse arquivo, o comando
automaticamente adicionado no arquivo.
Exemplo A:
#chfn zezinho
Changing the login shell for zezinho
Enter the new value, or press retum for the defalt
Login Shell [/bin/sh]: /bin/bash
Modificado o shell inicial do usuário para /bin/bash.

Exemplo B:
# chsh s /bin/bash zezinho.
Verificando integridade dos arquivos de senhas com pwck

O comando pwck verifica a integridade de informações de autenticação dos usuários no sistema nos
arquivos /etc/passwd e /etc/shadow em busca de erros de formato.
O comando verifica o seguinte:
- O número correto de campos;
- Nomes de usuários duplicados;
- UID's e GID's orfãos;
- Grupo válido;
- Diretorio home válido;
- Shell inicial válido.
Sintaxe:
pwck [-sr][passwd shadow]
A opção -s serve para ordenar os usuários nos arquivos /etc/passwd e /etc/shadow com base
em seu UID. A outra opção (-r) não pode ser utilizada junto com -s, e serve para ativar o modo
42
somente-leitura do pwck, que apenas mostra o que esta errado mas nunca modifica nenhum arquivo.
Se especificarmos uma das opções passwd ou shadow, o pwck somente agira nos respectivos
arquivos.
Exemplo:
# pwck
user lp: directory /var/spool/lpd does not exist
user news: directory /var/spool/news does not exist
user uucp: directory /var/spool/uucp does not exist
user postgres: directory /var/lib/postgres does not exist
user list: directory /var/list does not exist
user irc: directory /var/run/ircd does not exist
user gnats: directory /var/lib/gnats does not exist
user grpadm: directory /home/grpadm does not exist
user zezinho: directory /home/zezinho does not exist
user zezinho: directory /home/zezinho does not exist
user nobody: directory /nonexistent does not exist
pwck: no changes
O comando pwck detectou que os diretórios home de alguns usuarios não existiam, mas não efetuou
nenhuma modificação no sistema, somente alertou.
Convertendo/Revertendo o sistema de senhas shadow
O linux disponibiliza dois comandos que nos permitem converter e reverter o sistema de senhas
shadow. Para migrar um sistema que ainda não utiliza senhas shadow, utilizamos o comando
pwconv. Já para reverter um sistema ja com shadow ativado, utilizamos o comando pwunconv.
DICA
Para migrar tambem as informações de grupos para shadow (Tirar as senhas do /etc/group e
migrar para o /etc/gshadow, basicamente) utilizamos grpconv. Para reverter, grpunconv.
Tem o mesmo efeito que pwconv e pwunconv, porem atua nos arquivos de grupos.
Modificando contas de usuários com usermod

Todos os dados que podem ser fornecidos ao comando useradd durante a criação de um usuário no
sistema podem ser alterados, no caso de usuários já existentes, com o comando usermod.
Sintaxe:
usermod [-u uid [-0]] [-g grupo] [-G grupo,...]
[-d home [-m]] [-s shell] [-c comentario] [-l novo
nome]
[-f inativo] [-e expira ] [-p senha] [-LI-U] nome
Exemplo A:
43
# id zezinho
uid=10095(luizinho) gid=100(users) groups=100(users)I1521(grupo)
# usermod -l ronald zezinho
# id zezinho
id: zezinho: No such user
# id ronald
uid=10095(ronald) gid=100(users) groups=100(users),1521(grupo)
# usermod -l zezinho ronald
# id zezinho
uid=10095(zezinho) gid=100(users) groups=100(users),1521(grupo)
Utilizamos o usermod para renomear o usuario zezinho para ronald. Verificado que somente o
nome do usuario mudou, em seguida renomeamos novamente o usuario para o nome original.
Exemplo B:
# id zezinho
# usermod -u 10094 zezinho
# id zezinho
uid=10094 (zezinho) gid=100(users) groups=100(users),1521(grupo)
Modificado o uid do usuario zezinho de 10095 para 10094. Lembrando que o novo uid não pode estar
atribuído a nenhum usuário já existente.
DICA
Uma boa forma de memorizar comandos como esses e associando sua utilização. Por exemplo:
useradd = user + add (Adicionar Usuário), usermod = user + mod (Modificar
usuário).
Gerenciamento de grupos
Gerenciar grupos de usuários e uma tarefa imprescindível no dia a dia de um administrador Linux.
Tarefas como adicionar e remover grupos, definir a quais grupos determinados usuários devem
participar, determinar administradores de grupos, etc.
E essencial uma boa compreensão sobre o funcionamento dos grupos de usuários no Linux, pois o
correto funcionamento do sistema depende de grande coerência no que tange gerenciamento de
grupos e usuários.
Obtendo Informações com o comando id
Uma das principais ferramentas que auxiliam no gerenciamento de usuarios e grupos e o comando
id. Com ele e possível saber, por exemplo, a quais grupos um determinado usuário pertence, com
seus respectivos gids.
Sintaxe:
id [parâmetro]...[usuário]
44
g Mostra somente o GID. Se utilizado em conjunto com o parâmetro n,
do grupo.
G Mostra todos os grupos (GIDs) que o usuário pertence. Se utilizado em conjunto com o
parâmetro n, mostra os nomes dos grupos. O primeiro grupo na listagem é o grupo
principal, os demais são os secundários.
n Mostra "nomes" ao invés de números (UIDs e GIDs) na salda do comando.
u Mostra somente UID. Se utilizado em conjunto com o parâmetro n mostra o nome do
usuário.
Exemplos:
$ id
uid=1052 (agomes) gid=1001(cds) grupos=6(disk),24(cdrom),25(floppy),29
(audio),1001(cds),1006(suporte),1507(apostilas)
$ id -G
1001 6 24 25 29 1006 1507
$ id -Gn
cds disk cdrorn floppy audio suporte apostilas
$ id root
uid=0(root) gid=0(root) grupos=0(root)
Adicionando grupos com groupadd

Cria novos grupos no sistema.
Sintaxe:
groupadd [-g gid [0]] grupo
Exemplo:
$ groupadd -g 1037 cds
O comando acima cria um novo grupo no sistema, com GID 1037. Caso UID (-g) seja omitido, o
sistema escolhe automaticamente o próximo disponível. A opção "-o" serve para forçar a utilização
daquele gid, mesmo que ele ja esteja atribuído a outro grupo.
Removendo grupos com groupdel
Para remover um grupo do sistema utilizamos o comando groupdel. Se removermos um grupo que
contenha usuários, os usuários são mantidos no sistema, porem não terao mais vínculo com o grupo
removido (ainda bem...).
Sintaxe:
45
groupdel grupo
Adicionando usuários aos grupos

Utilizamos o comando gpasswd para, dentre outras coisas, adicionar usuários em grupos já
existentes.
Sintaxe:
gpasswd –a usuario grupos
Exemplo:
# useradd -m aluno
# id aluno
uid=10092(aluno) gid=100(users) groups=100(users)
# groupadd cds
# gpasswd -a aluno cds
Adding user aluno to group cds
# id aluno
uid=10092(aluno) gid=100(users) groups=100(users),1001(cds)
Depois de adicionado o usuário aluno e o grupo cds, utilizamos o comando gpasswd para adicionar
o usuário recém-criado ao grupo.
Removendo usuários dos grupos

Para remover usuários dos grupos também fazemos uso do gpasswd, da segunite forma:
gpasswd -d usuario grupo
Exemplo:
# id aluno
uid=10092(aluno) gid=100(users) groups=100(users),1001(cds)
# gpasswd -d aluno cds
Removing user aluno from group cds
Modificando informações sobre grupos

Através do comando groupmod e possível renomear um grupo ou trocar o GID.
Sintaxe:
groupmod [-g gid [0]] [n novo_nome] grupo
Exemplo:
46
# groupadd linux
# gpasswd -a aluno linux
Adding user aluno to group linux
# id aluno
uid=10092(aluno) gid=100(users) groups=100(users),1511(linux)
# groupmod -g 1520 -n pinguim linux
# id aluno
uid=10092(aluno) gid=100(users) groups=100(users),1520(pinguim)
No exemplo, primeiro criamos o grupo linux e adicionamos o usuário aluno nele. O sistema
automaticamente atribuiu um GID para o grupo (1511, no exemplo). Utilizamos o comando
groupmod para trocar o GID e o nome do grupo linux.
Definindo administradores de grupos com gpasswd

Todos os grupos no sistema podem ter administradores, membros e uma senha. Podemos utilizar o
comando gpasswd para definir administradores e senha de grupos. Administradores de grupos saD
usuários que tem permissão (previamente concedida pelo usuário root) para adicionar usuários do
sistema aos grupos que eles administram. E importante lembrar que 0 usuário a ser adicionado ao
grupo já deve existir no sistema.
Sintaxe:
gpasswd [-A usuario,...) [-M usuario,...) grupo
A opção -A serve para "nomear" um usuário do sistema como administrador do grupo. A opção -M
faz o mesmo, porém adiciona o usuário como membro do grupo também.
Exemplo:
# useradd -m admgrupo
#id admgrupo
uid=10094 (admgrupo) gid=100(users) groups=100(users)
# groupadd grupo
# gpasswd -A admgrupo grupo
# useradd -m zezinho
# su - admgrupo
$ gpasswd -a zezinho grupo
Adding user zezinho to group grupo
$ id zezinho
$ gpasswd -d zezinho grupo
Removing user zezinho from group grupo
$ id zezinho
uid=10095(zezinho) gid=100(users) groups=100(users)
No exemplo foi definido que o usuário admgrupo e administrador do grupo grupo. Para remover esse
privilégio do usuário, e preciso remover o nome do usuário em questão do terceiro campo do arquivo
/etc/gshadow.
Trocando grupo principal temporariamente com newgrp

É possível trocar o grupo principal do usuário somente para a sessão atual (tudo volta ao normal ao
término da sessão). Isso pode ser útil quando precisamos ter privilégios específicos de determinado
47
grupo por alguns instantes.
Utilizamos o comando newgrp para essa finalidade.
Sintaxe:
newgrp [-] grupo
O parâmetro "-" instrui ao comando para carregar todas as variáveis de ambiente do shell atual.
Exemplo A:
$ id
uid=10096(admgrupo) gid=100(users) groups=100(users)
$ gpasswd grupo
Changing the password for group grupo
New Password:
Re-enter new password:
$ su - zezinho
Password:
$ id
$ newgrp grupo
$ id
uid=10095(zezinho) gid=1521(grupo) groups=100(users),1521(grupo)
$ exit
Nesse exemplo, foi definida uma senha para o grupo; Como o usuário zezinho pertence ao grupo
"grupo", não foi necessário digitar uma senha para o grupo. Quando acionamos o comando "newgrp
grupo", foi aberto um novo shell atrelado ao shell atual.
Exemplo B:
# useradd -m zezinho
# id zezinho
uid=10097(zezinho) gid=100(users) groups=100(users)
# su - zezinho
$ newgrp - grupo
Password:
$ id
uid=10097(zezinho) gid=1521(grupo) groups=100(users),1521(grupo)
$ exit
Adicionamos o usuário zezinho, que por padrão pertence somente ao grupo users. Como foi definida
uma senha para o grupo "grupo" antes, o usuário zezinho pode utilizar o comando newgrp para
temporariamente fazer parte do grupo. Para isso Ihe foi requisitada a senha do grupo, que foi
cadastrada no exemplo anterior com o comando "gpasswd grupo".
Verificando Integridade dos arquivos de grupos com grpck
O comando grpck verifica a integridade das informações de autenticação do sistema. Todas as
entradas dos arquivos /etc/group e /etc/gshadow são verificadas quanta ao formato correto
em cada campo. O usuário e questionado a deletar uma entrada defeituosa que esteja comprometcndo
a segurança do sistema.
O comando verifica o seguinte nos arquivos:
- O número correto de campos;
- Nomes de grupos duplicados;
48
- Uma lista válida de membros e administradores.
Sintaxe:
grpck [r] [group shadow]
A opção -r diz para o grpek efetuar os testes em modo somente-leitura, ou seja, não altera nenhum
arquivo, somente mostra os problemas na tela. O padrão do comando e verificar ambos os arquivos
/etc/group e /etc/shadow. Para forçar ele verificar somente um deles, basta especificar
somente o nome de um dos arquivos como parâmetro.
Para o exemplo abaixo, partimos do princípio de que exista um problema de nome de grupo
duplicado no arquivo /etc/group, conforme abaixo:
grupo:!:1521:zezinho
grupo:!:1522:
Exemplo:
# grpck
duplicate group entry
deletc line ‘grupo:!:1521:zezinho'? No
duplicate group entry
deletc line ‘grupo:!:1522:'? Yes
grpck: the files have been updated
Respondemos "No" para a primeira pergunta e "Yes" para a segunda porque a primeira pergunta
referenciava a linha correta (que não devemos apagar).
49
Permissões de Arquivos e Diretórios
As permissões são um dos aspectos mais importantes do Linux (na verdade, de todos os sistemas
baseados em Unix). Elas são usadas para vários fins, mas servem principal mente para proteger o
sistema e os arquivos dos usuários. Manipular as permissões é algo muito essencial. Mas tal
complexidade não deve ser interpretada como dificuldade e sim como grande variedade de
configurações, o que permite criar vários tipos de proteção de arquivos e diretórios.
Como você deve saber, somente o super-usuário (root) tem ações irrestritas no sistema, justamente
por ser o usuário responsável pela configuração, administração e manutenção do Linux. Cabe a ele,
por exemplo, determinar o que cada usuário pode executar, criar, modificar, etc. Naturalmente, a
forma usada para determinar o que o usuário pode fazer e a determinação de permissões.
Entendendo as permissões
$ ls l /exercicios/ln
total 8
rwrr 2 agomes cds 0 2004l028 17:29 arquivo1
drwxrxrx 3 agomes cds 4096 2004l028 17:30 dirl
drwxrxrx 2 agomes cds 4096 2004l029 10:44 dir2
rwr—r 2 agomes cds 0 2004l028 17:29 hardlink1
Repare na saída do comando ls l, que mostra as permissões dos arquivos na primeira coluna.
Esses primeiros 10 caracteres que aparecem (-rw-r-r-- por exemplo.) sao os caracteres que
demonstram as permissões atuais de cada arquivo/diretório.
Observe a linha abaixo, onde as permissões aparecem em destaque:
- rwx rwx rwx 2 agomes cds 0 2004-l0-28 17:29 arquivo1
Grupo Dono
Usuário Dono
Permissões de outros
Permissões de grupo
Permiissões de usuários
Tipo de arquivo
l link simbó1ico
b Dispositivo de Bloco
d Diretório
s Socket de Comunicação
50
c Dispositivo de Caractere
- Arquivo Comum
Cada uma das letras r, w e x dentro das permissões tem um significado diferente, conforme a tabela
abaixo:
r Leitura
w Escrita
x Execução
Como o permissionamento esta dividido em 3 seções (usuário, grupo e outros), a presença ou

ausência dessas letras determina quais permissões cada um terá.
Exemplo A:
$ ls -l apostila.sxw
-rwxrw-r-- l camila office 183627 2004-l1-01 13:09 apostila.sxw
O arquivo apostila.sxw e um arquivo comum, pertence a usuário camila e ao grupo office. O usuário
camila pode ler, gravar e executar o arquivo ( rwx ); quaisquer outros usuários que pertençam ao
grupo office podem ler e gravar no arquivo ( rw- ); Portanto, qualquer outro usuário que não seja o
dono do arquivo (camila) nem pertença ao grupo office só terá permissões de ler o arquivo ( r ).
Exemplo B:
$ ls –ld /etc
drwxr-xr-x-- 96 root root 5384 2004-l1-01 11:01 /etc
Podemos verificar que o arquivo etc na verdade e um diretório (d). Pertence ao usuário e grupo root;
Têm permissões de leitura, gravação e execução (rwx) para o usuário dono. Leitura e execução (r-x)
para o grupo dona e quaisquer outros usuários.
NOTA
Mesmo que as permissões de arquivos restrinjam o usuário root, elas não têm efeito para ele.
Definindo Permissões com chmod

Utilizamos o comando chmod (Change Mode) para configurar as permissões no Linux.
Sintaxe:
chmod [OPÇÃO]... MODO [,MODO]... ARQUIVO... [OPÇÃO]...
chmod MODOOCTAL ARQUIVO...
chmod [OPÇÃO]... reference=ARQUIVOREF ARQUIVO...
Tabela de Parâmetros ,
v Verbose. Mostra informações sobre as modificações efetuadas. Mesmo que as

permissões tenham se mantido.
c Changes. Mesmo que a opção v, porém só mostra informações se as permissões
tiverem sido modificadas.
R Recursive. Aplica as permissões recursivamente.
O chmod trabalha com dois modos de permissões: simbólico e octal. Esses dois modes não mudam a
51
Sintaxe do comando mostrada anteriormente, pois só agem no MODO (MODO e MODO OCTAL)
das permissões.
Antes de estudar os dois modos separadamente, criaremos o ambiente de testes.
Ambiente:
$ mkdir -p ~exercicios/chmod; cd ~/exercicios/chmod
$ mkdir -p dirl/dir2
$ touch arql dirl/dir2/arq2
Modo Simbólico de Permissões

O modo simbó1ico do chmod define as permissões com base em suas letras (r, w e x...) de
significado. Nesse modo, as permissões cabíveis a cada uma das partes envolvidas são representadas
par letras, conforme tabela abaixo:
u usuário
g grupo
o outros
a todos(all)
Com base nisso, basta unir as permissões com as partes afetadas. Para estabelecer essa união,
utilizamos os sinais de +, - e = (adiciona, remove ou iguala permissões, respectivamente).
Exemplo A:
$ ls -l arq1
-rw-r--r-- 1 camila camila 0 2004-l1-01 15:40 arq1
$ chmod u-w arq1
$ ls -l arq1
-r--r--r-- 1 camila camila 0 2004-l1-01 15:40 arq1
O arquivo arq1 teve a permissão de escrita (w) removida para o usuário (u) do no do arquivo, ou seja:
O "u" indica que estamos alterando permissões para o usuário, o sinal de "-" indica que estamos
removendo permissões, e em seguida, o "w" significa permissão de escrita.
Exemplo B:
$ ls -l arq1
-r--r--r-- 1 camila camila 0 2004-l1-01 15:40 arq1
$ chmod +x arq1
$ ls -l arq1 -r-xr-xr-x 1 camila camila 0 2004-l1-01 15:40 arq1
Adicionada permissão de execução para todos os campos (usuário, grupo e outros), pois não foi
especificada qual parte seria afetada pelo comando.
Exemplo C:
$ ls -l arq1
-r-xr-xr-x 1 camila camila 0 2004-l1-01 15:40 arq1
$ chmod go-x,ug+w arq1
$ ls -l arq1
-rwxrw-r—l camila camila 0 2004-l1-0115:40 arq1
Na mesma linha de comando, foi removida a permissão de execução para grupo e outros e também
foi adicionada a permissão de escrita para o usuário e grupo.
52
Exemplo D:
$ ls -ld dir1
drwxr-xr-x 3 camila camila 72 2004-l1-01 16:03 dir1
$ ls -l dir1/dir2/arq2
-rw-r--r-- 1 camila camila 0 2004-l1-01 15:40 dir1/dir2/arq2
$ chmod -R a=rx dir1
$ ls -ld dir1
dr-xr-xr-x 3 camila camila 72 2004-l1-01 16:03 dir1
$ ls -l dir1/dir2/arq2
-r-xr-xr-x 1 camila camila 0 2004-l1-01 15:40 dir1/dir2/arq2
Modificamos recursivamente (opção -R) as opções de usuário, grupo e outros (a) do diretório dir1
para leitura e execução (rx). Repare que, devido ao fato das permissões terem sido aplicadas
recursivamente, o arquivo arq2, que fica em um subdiretório abaixo de dir1 também recebeu as
permissões.
Exemplo E:
$ ls -l total 0
-rwxrw-r-- 1 camila camila 0 2004-l1-01 15:40 arq1
dr-xr-xr-x 3 camila camila 72 2004-l1-01 16:03 dirl
$ ls -l dir1
total 0
$ chmod -x dir1
$ ls -l dir1
ls: dir1/dir2: permissao negada
total 0
$ cd dir1
bash: cd: dir1: permissao negada
$ chmod +x dir1
$ ls -l dir1
total 0
$ cd dir1
O exemplo mostra que e necessário ter permissões de execução para entrar ou listar o conteúdo de
um diretório. Isso acontece porque quando entramos em um diretório, na verdade estamos
"executando" o arquivo especial que e o diretório, que contem a lista de todos os arquivos e diretórios
dentro dele. Sem a permissão de execução não podemos entrar em um diretório, somente o root
rompe essas barreiras.
Modo octal de permissões

Nesse modo, lidamos diretamente com o número de bits que compõem as permissões, conforme
tabela abaixo:
Bits Permissão
4 Leitura (n)
2 Gravação (w)
1 Execução (x)
53
Dessa forma, se quisermos obter resultados específicos, basta somar o numero de bits correspondente
às permissões, conforme tabela a seguir:
Bits Soma de Bits

rwx 4+2+1=7
rw 4+2+0=6
rx 4+0+1=5
r 4+0+0=4
wx 0+2+1=3
w 0+2+0=2
x 0+0+1=1
0+0+0=0
Por exemplo, para chegar ao resultado rwxr-xr--, utilizamos o modo 754 no chmod.
Exemplo A:
$ chmod 750 arq1
$ ls -l arq1
-rwxr-x--- 1 camila camila 0 2004-l1-01 15:40 arq1
Exemplo B:
$ chmod 644 arq1

$ ls -l arq1
DICA
Pratique bastante permissões de acesso, pois são extremamente essenciais no dia a dia de um
administrador de sistema e seu bom compreendimento evita algumas falhas de segurança.
Máscara de usuário (umask)

A umask (user mask) são 3 números que definem as permissões iniciais do dono, grupo e outros
usuários que o arquivo ou diretório recebera quando for criado ou copiado pelo usuário atual. A
principal função da umask e impedir que arquivos pessoais criados pelos usuários do sistema sejam
legíveis por outros usuários assim que criados. Ela consegue esse resultado subtraindo um número de
bits (o valor da umask) das permissões do arquivo que for criado.
Por padrão, qualquer arquivo criado por um usuário no sistema não recebe permissões de execução,
com exceção dos diretórios. Por exemplo, para todos os arquivos recém-criados, as permissões
iniciais seriam 666 (tudo ativado, sem execução).
Para chegar às permissões iniciais do arquivo criado após a influência do umask, basta subtrair o
valor da umask da permissão padrão (666). Por exemplo, se o valor da umask for 22, os arquivos
54
novos teriam permissão 644 para permissão padrão de arquivos recém-criados (666 - 22 = 644).
É importante ressaltar que para arquivos copiados, o umask só modifica as permissões do arquivo de
destino se o valor partindo de 777 e subtraído do valor da umask for menor( ver Exemplo B).
A umask fica armazenada na memoria durante o shell atual. Se modificarmos o valor da umask ela
será redefinida para o padrão ao abrirmos um novo shell, e o valor modificado em um shell não
influência em outro.
Sintaxe:
umask [-p] [-s] [modo]
p Mostra a palavra umask antes do modo (sem muito sentido...)
S Utiliza o modo simbólico de permissões (igual no comando chmod)
Ambiente:
$ mkdir ~/exercicios/umask; cd ~/exercicios/umask
Exemplo A:
$ umask
0022
$ touch arq1
$ ls -l
total 0
$ umask 000
$ touch arq2
$ ls -l
total 0
-rw-rw-rw- 1 camila camila 0 2004-l1-01 18:42 arq2
Com o umask padrão, o arquivo criado (arq1) recebeu permissões 644. Após modificarmos o umask
para 000 (anulando sua influência), 0 arquivo criado (arq2) recebeu permissões 666.
Exemplo B:
55
$ touch arq3
$ chmod -v 775
modo de 'arq3'
$ umask
0022
$ cp arq3 arq4
$ ls -l
-rw-rw-rw- 1 camila camila 0 2004-l1-01 18:42 arq2
-rwxrwxr-x 1 camila camila 0 2004-l1-01 19:12 arq3
-rwxr-xr-x 1 camila camila 0 2004-l1-01 19:13 arq4
Repare que o umask (22) agiu na permissão do arquivo original (arq3 = 775) e o arquivo arq4 foi
criado com permissões 755.
E precise um pouco de atenção antes de escolher a umask. um valor mal escolhido pode causar
problemas de acesso a arquivos, diretórios ou programas não sendo executados. O valor padrão da
umask na maioria das distribuições atuais e 022.
A umask e de grande utilidade para programas que criam arquivos/diretórios temporários, desta
forma podese bloquear o acesso de outros usuários desde a criação do arquivo, evitando recorrer ao
chmod.
56
O Shell Bash (Boune Again Shell)
Conforme visto anteriormente, existe uma camada entre o sistema operacional (kernel) e o usuário,
que "interpreta" os comandos digitados e os passa para o kernel, e vice-versa. Essa camada recebe o
nome de interpretador de comandos, ou shell. Um shell no Linux utiliza-se de Dispositivos especiais
de entrada e saída (Vistos na tabela adiante) para se comunicar com o usuário. Dessa mesma forma,
programas também utilizam desse método para interação com o usuário.
Tecnicamente,o shell do Linux utiliza algum Dispositivo de caracteres (/dev/tty*, /dev/pts/*, etc...)
associado a 3 Dispositivos especiais (stdin, stdout e stderr) estudados adiante para conseguir essa
interação com o usuário.
O linux conta com diversos interpretadores de comandos (shells),. porém o mais utilizado nas
distribuições e o shell bash. O bash e um "relançamento" de um antigo shell de UNIX, o sh. Bash
significa Boume Again Shell (Algo como "O shell que nasceu novamente").
Vale a pena lembrar que podem existir diversos interpretadores de comandos instalados no sistema
operacional (Que tal uma olhada no arquivo /etc/shells ?), e que podemos escolher qual shell será o
padrão para determinado usuário com o comando chsh, visto anteriormente.
Devido ao fato do shell bash ser o padrão na grande maioria das distribuições. É ele que estudaremos
a seguir. Mesmo assim, muitas das características do bash existem em outros shells.
Redirecionamento
Tudo que e visto no terminal e formado com caracteres (por isso Dispositivos de caracteres). Esses
caracteres são resultado da saída de dados padrão dos comandos executados ou do próprio shell. Mas
os comandos não se limitam a enviar caracteres para a tela do terminal (Saída de dados padrão), mas
também podem (e devem) receber dados do terminal. Esse fluxo de caracteres pode fluir em 3
direções, conforme tabela abaixo:
Descritor de
Nome do Dispositivo Abreviação
Arquivo
0 Entrada de dados padrão stdin
1 Saída de dados padrão stdout
2 Saída de erros padrão stderr
O descritor de arquivo é utilizado para identificar "em qual direção" os caracteres irão fluir.
Entrada de dados padão (/dev/stdin)
Dispositivo que cuida do fluxo de entrada para os dados que podem ser enviados para os programas
em execução. A maior parte do tempo é o teclado que fica fica encarregado de "gerar" os dados que
acabam sendo enviados para esse Dispositivo. Porem, através de comandos de redirecionamento de
shell (visto adiante) podem associar um arquivo como a entrada de dados padrão.
Saída de dados padão (/dev/stdout)
Dispositivo pelo qual os programas normalmente enviam seus resultados de execução. Quando
57
listamos arquivos com o comando ls, por exemplo, o resultado que o comando nos mostra e
justamente a saída padrão, que visualizamos no monitor. Semelhante a entrada de dados padrão,
podemos utilizar de comandos de redirecionamento para enviar a saída de um comando para um
arquivo ou outro comando, conforme veremos em breve.
Saída de erros padrão (/dev/stderr)
Esse e um Dispositivo bastante parecido com a saída de dados padrão, porém atua em um "canal"
diferente, e serve para os programas enviarem qualquer mensagem de erro durante a execução. Assim
como a saída de dados padrão, podemos redirecionar a saída de erros padrão para um arquivo.
Operadores de Redirecionamento
Para controlar a em que os dados devem fluir, o bash conta com operadores de redirecionamento.
Esses operadores dizem basicamente para onde os caracteres tem que ir (stdin, stdout, stderr, arquivo,
comando, etc...) e podem estar antes ou depois de um comando.
Sao 3 os operadores de redirecionamento:
Operadores de Saída de dados padrão (stdout): ">" e ">>"
Sua função e redirecionar o fluxo de caracteres da stdout (que pode ser a saída de um comando, por
exemplo) para algum arquivo ou Dispositivo, lembrando que no Linux "tudo e arquivo".
Exemplo A:
$ mkdir p ~/exercicios/redirecionamento
$ cd ~/exercicios/redirecionamento
$ touch arql arq2 arq3
$ ls > listagem
$ ls arql arq2 arq3 listagem
$ cat listagem arql arq2.arq3
Nesse exemplo, após criar nosso ambiente de testes, redirecionamos a saída do comando ls para um
arquivo chamado listagem. Esse arquivo não existia anteriormente, mas foi criado devido ao
redirecionamento. Repare que o conteúdo do arquivo e exatamente a saída do comando ls.
Exemplo B:
$ cd ~/exercicios/redirecionamento/
$ cat > arquivo.txt
Um simples arquivo de texto.
Pressione [Enter]
Pressione [CTRL]+[D]
$ cat arquivo.txt
Acionamos o comando cat, sem nenhum argumento, e instruímos o bash para redirecionar a saída de
dados padrão para um arquivo chamado arquivo. txt.
Exemplo C:
58
$ cat arquivo.txt
Uma simples arquivo de texto.
$ echo "Novo conteudo" > arquivo.txt
$ cat arquivo.txt
Novo contéudo
Ainda com o mesmo arquivo de testes, efetuamos outro redirecionamento, dessa vez com a saída do
comando echo. Repare que o conteúdo do arquivo foi sobrescrito com o redirecionamento efetuado.
Para concatenar o arquivo de saída ao invés de sobrescrever o seu conteúdo, utilizamos "dois"
operadores de redirecionamento da stdout (>>), como no exemplo abaixo:
Exemplo D:
$ cat arquivo.txt
$ echo "Novo conteúdo" >> arquivo.txt
$ cat arquivo. Txt
Novo conteúdo
Compare com o exemplo anterior.

Exemplo E:
$ echo "algum texto" > arquivo.txt
$ cat arquivo.txt
algum texto
$ echo "algum texto novo" 0> arquivo.txt
algum texto novo
$ cat arquivo.txt
$ echo "algum texto novo" 0> arquivo.txt > arquivonovo.txt $ cat
arquivo.txt
$ cat arquivonovo.txt
algum texto novo
Primeiro sobrescrevemos o conteúdo do arquivo arquivo.txt e constatamos isso com o comando cat.
Logo depois, enviamos o redirecionamento da saída padrão "de volta" para a entrada padrão. Na
verdade, o redirecionamento "0>" diz para o fluxo de caracteres deve ser enviado de volta para a
entrada padrão (Descritor de arquivo 0, conforme tabela anterior), e não para o arquivo de destino. E
por isso que o arquivo arquivo.txt ficou vazio após o redirecionamento com "0>". Como o fluxo
retorna para o shell, podemos redirecionar nova mente ele, mas agora para um "novo arquivo",
chamado arquivo-novo.txt, que agora sim recebe o conteúdo do redirecionamento.
O intuito de mostrar redirecionamentos como esses, não muito comuns no dia-a-dia do administrador,
e familiarizar o administrador com o fluxo correto das informações no shell bash, assunto que tem
peso muito alto em uma prova de certificação Linux como a Linux Professional Institute 1 (LPIC-l),
que é o foco deste curso.
Operadores de entrada de dados padrão: "<" e "<<"
Não são amplamente utilizados quanta os operadores de saída de dados padrão. Sua função e
redirecionar o fluxo de caracteres da stdin (que pode ser um arquivo contendo argumentos a serem
tratados por um comando, por exemplo) para algum comando.
Ainda no mesmo ambiente de testes dos exemplos anteriores
(~/exercicios/redirecionamento), vamos aos exemplos:
Exemplo A:
59
$ cat < arquivo.txt
Novo conteúdo
$ cat < arquivo.txt
Novo conteúdo
Digitamos dois comandos no exemplo. O primeiro e um simples "cat" no arquivo; O segundo tem o
mesmo resultado, só que utiliza o redirecionamento do arquivo arquivo. txt como argumento para o
comando cat. Como a função do comando cat e enviar para a stdout o conteúdo que Ihe for passado
(geralmente um arquivo), o mesmo pode ser feito com um fluxo de dados (caracteres) vindo de um
redirecionamento da stdin.
Da mesma forma que o redirecionamento de saída de dados padrão, podemos concatenar o fluxo de
caracteres utilizando dois operadores para o mesmo sentido, nesse caso "<<".
Este redirecionamento serve principalmente para marcar o fim de exibição de um bloco. Este e
especialmente usa do em conjunto com o comando cat, mas também tem outras aplicações.
Exemplo B:
$ cat << final
> este texto
> sera mostrado
> ate que a palavra final
> seja encontrada
> sozinha na linha
> final
este texto
sera mostrado
ate que a palavra final seja encontrada
sozinha na linha
Redirecionando a saída de erros padrão (stderr)

Em quaisquer dos redirecionamentos aprendidos ate agora, podemos utilizar para redirecionar a saída
de erros padrão (stderr) ao invés da saída de dados padrão (stdout) utilizando o descritor de arquivo 2.
Recapitulando, os comandos e scripts utilizam-se da saída de dados padrão para enviar o fluxo de
caracteres a fim de notificar o usuário sobre o que esta havendo no comando (a saída de uma listagem
de arquivos com o comando ls, por exemplo. Esses mesmos comandos e scripts utilizam-se de um
"canal" diferente para enviar informações sobre erros em sua execução para o shell. O "canal", nesse
caso, e o descritor de arquivo.
Para enviar informações (caracteres) sobre erros provenientes dos comandos e scripts em execução,
estes utilizam o descritor de arquivo 2.
Exemplo A:
60
$ ls
$ ls inexistente.txt > arquivo.txt
ls: inexistente.txt: Arquivo ou diretório não encontrado
$ cat arquivo.txt
$ ls: inexistente.txt 2> erros.txt
$ cat erros.txt
Tentamos propositadamente listar um arquivo inexistente (inexistente. txt) com o comando ls,
causando um erro no programa. O comando ls utilizou-se da saída de erros padrão (stderr) para
enviar um fluxo de caracteres a fim de notificar que não encontrou o arquivo especificado. Como o
redirecionamento inicial que fizemos apenas redireciona a saída de dados padrão para o arquivo
arquivo.txt, a stderr e mostrada na tela, e visualizamos assim a mensagem de erro.
No redirecionamento seguinte, redirecionamos a stderr para um arquivo chamado erros. txt
(redirecionamento 2>>).
Exemplo B:
$ rm arquivo.txt erros.txt
$ ls > stdout.txt 2>stderr.txt
$ ls
stderr.txt stdout.txt
$ cat stderr.txt
bash: lss: command not found
$ ls stderr.txt inexistente.txt >stdout.txt 2»stderr.txt
$ ls
stderr.txt stdout.txt
$ cat stderr.txt
bash: lss: command not found
Após digitar um comando inexistente (ls), causamos um erro no shell, que nos notifica através da
stderr. A saída de nosso comando "inexistente" (vazia) foi redirecionada para o arquivo stdout. txt e a
saída de erros padrão (stderr) foi redirecionada para o arquivo stderr. txt. No redirecionamento do
comando ls, que procurava listar 2 arquivos (stderr. txt e inexistente. txt), foram gerados dois fluxos
de saída: Um deles envia para a stdout o nome do arquivo stderr. txt, que foi encontrado na listagem.
O segundo fluxo envia para a stderr uma notificação de que não foi possível encontrar o arquivo
inexistente. txt. Repare que concatenamos a saída da stderr, e assim não sobrescrevemos o conteúdo
do arquivo stderr. txt.
Redirecionamento com pipes: "|"
O pipping é um recurso que permite conectar a saída de um comando na entrada de outro comando
subseqüente, sem limitações quanta ao número de comandos a serem conectados, desde que cada um
deles leia dados da saída padrão do comando anterior e escreva sua saída na entrada de dados do
próximo comando. Isso mantém o fluxo entre os comandos.
Encare o pipe como um encanamento (E realmente "pipe" significa "cano" em inglês.), onde
interconectamos os canos uns aos outros (comandos). formando um encanamento, onde a água (fluxo
de caracteres) ira passar.
Ambiente:
61
$ mkdir ~/redirecionamento/pipe -p
$ cd ~/redirecionamento/pipe/
$ touch arql arq2 arq3
Primeiro criamos o nosso ambiente de exercícios.

Exemplo A:
$ ls
arql arq2 arq3
$ ls |grep 2
arq2
$ ls |grep [23]
arq2
arq3
No diretório atual existem 3 arquivos (arql, arq2 e arq3). Utilizamos o comando ls unido ao comando
grep através de um pipe para filtrar nossa saída de texto (stdout) duas vezes. Na primeira vez, o
comando ls envia alistados 3 arquivos para a stdin do comando grep, que por sua vez, só mostra na
tela o nome do arquivo que contem o número 2, nesse caso, arq2. Depois, a única coisa que muda e a
filtragem do grep, que passa a mostrar os nomes dos arquivos que contém o número 2 ou 3, nesse
caso são 2 arquivos, arq2 e arq3.
Exemplo B:
$ ls /bin Igrep mount
mount
mountpoint
umount
Listamos o conteúdo do diretório /bin e utilizamos um pipe para "filtrar" a saída da listagem com o
comando grep, mostrando somente os comandos que contém a palavra mount.
No dia-a-dia de um administrador de sistemas Linux, torna-se necessária a utilização de muitos pipes
em uma mesma linha de comando para chegar a algum resultado em comum. No decorrer do curso
iremos nos deparar com diversas situações assim, mas por enquanto, observe (e teste) alguns
exemplos:
$ ps aux |grep ^root |more
$ ls -lR /usr/local |grep lib |grep rwxrwxr-x |more
Diferenças entre 0 "|" e o">"
A principal diferença entre o "|" e o">", é que o pipe envolve processamento entre comandos, ou seja,
a saída de um comando e enviado a entrada do próximo comando e o">" redireciona a saída de um
comando para um arquivo ou Dispositivo (lembrando que Dispositivos também não passam de
arquivos especiais).
Em qualquer dos exemplos anteriores com pipe, um resultado diferente seria obtido usando um ">"
no lugar do "|"; No "Exemplo B", se o comando "ls /bin | grep mount" fosse substitufdo por "ls /bin
>grep mount" (o pipe trocado por >, teria um resultado completamente diferente, pois iria
redirecionar a saída do comando ls para um arquivo chamado grep.
Comando tee
É importante saber do comando tee nesse ponto do estudo, pois sua função e redirecionar o fluxo de
caracteres que lhe foi passado (por um pipe, por exemplo) para um arquivo (tal como um simples
redirecionamento ">") e ao mesmo tempo mostra na tela (stdout) o mesmo conteúdo que foi
redirecionado. Resumindo, seria como redirecionar a saída de um comando para um arquivo e
62
continuar venda a saída na tela normalmente.
Sintaxe:
Comando | tee [a] [arquivo]
Exemplo A:
$ ls -la ~/exercicios | tee /tmp/listagem.txt
total 1
drwxr-xr-x 5 camila camila 128 2004-l1-30 21:15 .
drwxr-xr-x 27 camila camila 1144 2004-l2-01 16:56 ..
drwxr-xr-x 3 camila camila 96 2004-l1-01 15:40 chmod
drwxr-xr-x 2 camila camila 112 2004-l2-01 13:36 redirecionamento
drwxr-xr-x 2 camila camila 144 2004-l1-01 19:19 umask
$ cat /tmp/listagem.txt
total 1
drwxr-xr-x 5 camila camila 128 2004-l1-30 21:15 .
drwxr-xr-x 27 camila camila 1144 2004-l2-01 16:56 ..
drwxr-xr-x 3 camila camila 96 2004-l1-01 15:40 chmod
drwxr-xr-x 2 camila camila 112 2004-l2-01 13:36 redirecionamento
drwxr-xr-x 2 camila camila 144 2004-l1-01 19:19 umask
A saída do comando foi mostrada normalmente na tela e ao mesmo tempo gravada no arquivo
listagem.txt.
Exemplo B:
$ cat /etc/fstab |tee /tmp/listagem.txt
/dev/hda2 / raiserfs defaults 0 0
/dev/hda5 none swap sw 0 0
proc /proc proc defaults 0 0
/dev/fdO /floppy auto user,noauto 0 0
/dev/cdrom /cdrom iso9660 ro,user,noauto 0 0
/dev/hda1 /boot ext3 defaults 0 2
$ ls ~/exercicios |tee -a /tmp/listagem.txt
chmod
redirecionamento
umask
$ cat /tmp/listagem.txt
/dev/hda2 / reiserfs defaults 0 0
/dev/hda5 none swap sw 0 0
proc /proc proc defaults 0 0
/dev/fdO /floppy auto user,noauto 0 0
/dev/cdrom /cdrom iso9660 ro,user,noauto 0 0
/dev/hda1 /boot ext3 defaults 0 2
chmod
redirecionamento
umask
Utilizando a opção -a, o conteúdo do arquivo de destino será concatenado, ao invés de sobrescrito.
Tabela de Redirecionamentos
A tabela abaixo mostra um resumo das funções de cada operador de redirecionamento.
Redirecionador Função
comando > arquivo Redireciona a saída de dados padrão (stdout)
comando < arquivo Redireciona a entrada de dados padrão (stdin)
comando >> arquivo Concatena a saída de dados padrão (stdout)
63
comando << arquivo Concatena a entrada de dados padrão (stdin)
comando 2> arquivo Redireciona a saída de erros padrão (stderr)
comando 2>> arquivo Concatena a saída de erros padrão (stderr)
comandol | comando2 Utiliza a stdout do comandol como stdin do comando2
Paginadores
O comando more pode ser utilizado para leitura de arquivos que ocupem mais de uma tela. Quando
toda a tela e ocupada, o more efetua uma pausa e permite que você pressione [Enter] ou [espaço]
para continuar avançando no arquivo. Para sair do more pressione [q]. O comando less também
segue o mesmo propósito geral, porém permite recuarmos o texto que já rolou a tela, sendo um
"paginador" mais eficiente que o more.
Os paginadores são amplamente utilizados para paginar fluxos de texto.
Exemplos:
ps ax | more
ps ax | less
ls /etc |less
Caracteres especiais do bash (Metacaracteres)
Também conhecidos como metacaracteres (ou wildcards), esses caracteres especiais são assim
denominados porque desempenham funções que vão além de simples caracteres. Os principais deles
são "?" e "*".
O metacaractere "?" substitui um caractere qualquer no nome de um arquivo.
O "*" e antigo conhecido ate mesmo dos tempos de DOS, onde era utilizado da seguinte forma para
referenciar todos os arquivos do diretório: *. *. No Linux, para obter o mesmo resultado, basta um
único asterisco: *.
Um bom conhecimento sobre metacaracteres e determinante durante uma prova para certificação em
Linux.
Ambiente:
$ mkdir p /exercicios/metacaracteres
$ cd ~/exercicios/metacaracteres/
$ touch brasil brazil Brasil Brazil BRASIL BRAZIL
$ ls brasil Brasil brazil Brazil BRASIL BRAZIL
Antes de começar com os exercícios, devemos criar o ambiente de testes.
Exemplo A:
$ ls br?sil
brasil brazil
$ ls ?ra?il
brasil Brasil brazil Brazil
No primeiro comando, o ls listou os arquivos que contivessem bra, seguidos de qualquer caractere, e
terminavam com il. Como haviam dois arquivos que casavam com os critérios, somente esses foram
64
mostrados. No segundo comando foi utilizado dois metacaracteres, um para o primeiro e outro para o
quarto caractere do arquivo.
Exemplo B:
$ $ ls bra*
brasil brazil
$ ls *rasil
brasil Brasil
O metacaracter * é muito mais fácil de entender, pois casa com qualquer Coisa, quantas vezes for
necessário. o que o diferencia do metacaracter "?" e que este casa com qualquer Coisa somente uma
vez.
Para casar uma pesquisa com um determinado número de caracteres, podemos agrupar o
metacaracter "?".
Exemplo C:
$ touch cas a casas casais casinhas
$ ls casa??
casais
$ ls casa*
casa casais casas
$ rm fv cas*
removed 'casa'
removed 'casais'
removed 'casas'
removed 'casinhas'
Os critérios do comando ls era basicamente qualquer arquivo que comece com "casa" e contenha
mais dois caracteres quaisquer (casa??), diferente do segundo ls, que listaria arquivos que iniciem
com casa e possam ou não conter quaisquer outros caracteres depois (casa*). Não esqueça de
remover os arquivos conforme o exemplo, para que não nos atrapalhem em outros exemplos.
Alternativamente, podemos utilizar outros metacaracteres como" [" e "]" para melhor filtrar as
critérios a serem passados a linha de comando. Conforme exemplo abaixo.
Exemplo D:
$ ls
brasil Brasil BRASIL brazil Brazil BRAZIL
$ ls [Bb]rasil brasil Brasil
$ ls ?ra[sz]il
Brasil Brazil
Repare em todos as arquivos que existem atualmente no diretório e quais arquivos foram
selecionados pelo comando ls. Pratique isso bastante, pois é de extrema importância em um exame
de certificação como a Linux Professional Institute 101 (LPI-I0l).
Também é possível especificar um range de letras ou números dentre as metacaracteres "[" e "]" para
facilitar nossas buscas.
Exemplo E:
65
$ touch 1brasil 2brasil 11brasil 22brasil
$ ls [az]rasil
brasil Brasil
$ ls [cz]rasil
ls: [cz]rasil: Arquivo ou diretório não encontrado
$ ls [O9]brasil
1brasil 2brasil
$ ls [O9][O9]brasil
11brasil 22brasil
Listamos primeiramente todos as arquivos cujo primeiro caractere é alguma letra entre a e z (O ls,
nesse caso, não faz distinção de maiúsculas e minúsculas) e a restante da palavra seja "rasil". Quando
tentamos listar as arquivos cujo primeiro caractere seja alguma letra entre c e z e o restante da palavra
seja "rasil", nenhum e encontrado. O próximo ls mostra os arquivos cujo primeiro caractere e um
numero somente seguido da palavra "brasil". Repare em como utilizamos os metacaracteres para
listar os arquivos que contenham dois números no início do nome, seguidos pela palavra "brasil".
O mesmo resultado de [a-k], por exemplo, pode ser conseguido com [abcdefghijk]. É apenas uma
forma mais fácil de se expressar a mesma coisa.
Executando múltiplos comandos em ordem determinada
Podemos desencadear a execução de diversos comandos em ordem, como apenas uma linha de
comando. Para tal, utilizamos o metacaractere ";".
Exemplo A:
$ ls ?rasil ; echo “Outro Comando"
brasil Brasil
Outro Comando
A primeira linha da saída e resultado do comando ls, já a segunda refere-se ao comando echo, que
foi executado assim que o ls executou. Esse sistema não deve ser novidade para nos, pois já
utilizamos por diversas vezes até agora no decorrer do curso.
Exemplo B:
$ numero=2
$ (numero=l; echo "Dentro: $numero"); echo "Fora: $numero”.
Dentro: 1
Fora: 2
Podemos "agrupar" comandos entre parenteses para "proteger" o conteudo de variáveis, permitindo
que o valor de alguma variável de shell seja diferente para os comandos entre parenteses, sem
interferir no valor das variáveis fora. A princípio e um pouco confuso entender, mas depois se torna
simples. Foi definido o valor 2 para a variável $numero. Repare que dentro dos parenteses essa
variável tem o valor 1, mas fora continua tendo o valor 2, pois a "clausura" imposta pelos parenteses
impede que qualquer variável ali criada altere as já existentes.
FIQUE LIGADO
Este e um outro tópico de grande peso em provas para certificações Linux de nível I básico. E
imprescindível um bom domínio sobre esse tipo de metacaracteres, pois questões assim
costumam ter um baixo nível de acertos.
Também e possível simplificar parâmetros dos comandos. Para tal façanha, o bash nos dispõe dos
metacaracteres "{" e "}" (chaves). Analise os exemplos.
66
Exemplo C:
$ echo arquivo{1,2,3}-{a,b,c}.{txt,doc}
$ cd-/exercicios/metacaracteres; rm *
$ touch arquivo{1,2,3}-{a,b,c}.{txt,doc}
$ ls
arquivol-a.doc arquivol-c.doc arquivo2-b.doc arquivo3-a.doc arquivo3c.doc
arquivol-a.txt arquivol-c.txt arquivo2-b.txt arquivo3-a.txt arquivo3c.txt
arquivol-b.doc arquivo2-a.doc arquivo2-c.doc arquivo3-b.doc
arquivol-b.txt arquivo2-a.txt arquivo2-c.txt arquivo3-b.txt
Com apenas um comando touch, agrupamos diversas instâncias do mesmo comando, mais
precisamente 18 vezes. Graças aos 3 blocos de chaves, o bash interpretou o seguinte: Primeiro
formou-se o parâmetro arquivol-a.txt, depois arquivol-a.doc, em seguida arquivolb. txt, e assim por
diante. A ordem completa pode ser constatada apenas trocando o comando touch pelo comando echo,
deixando o comando com a seguinte aparência:
$ echo arquivo{123}-{a,b,c.txt,doc}
arquivol-a.txt arquivol-a.doc arquivol-b.txt arquivo1-b.doc arquivo1-c.txt
arquivo1-c.doc arquivo2-a.txt arquivo2-a.doc arquivo2-b.txt arquivo2-b.doc
arquivo2-c.txt arquivo2-c.doc arquivo3-a.txt arquivo3-a.doc arquivo3-b.txt
arquivo3-b.doc arquivo3-c.txt arquivo3-c.doc
Operadores de controle lógico: && e | | (AND e OR)

O shell bash também dispõe de metacaracteres operadores de controle lógico, os conhecidos AND e
OR de diversas linguagens de programação. Mas aqui eles até que são bem simples de compreender.
O operador de controle AND e representado por dois sinais de "&", serve para agrupar comandos e
somente executar o próximo comando caso o primeiro tenha obtido sucesso.
Exemplo A:
$ ls
$ ls arquivo.txt 2>/dev/null && echo "Arquivo Encontrado"
$ touch arquivo.txt
$ ls arquivo.txt 2>/dev/null && echo "Arquivo Encontrado"
Arquivo.txt
Arquivo Encontrado
$ rm arquivo.txt
Causamos um erro no comando ls, pois o arquivo arquivo.txt não existia no diretorio (Repare que
direcionamos a stderr para uma saída nula). Devido ao comando ls não ter obtido exito, comando
echo não foi executado. Após a criação do arquivo arquivo.txt, o comando echo foi executado.
Esse tipo de agrupamento é muito importante para criar condicionais para rotinas de administração do
sistema. Só ejetar a fita DAT se o backup for concluído com exito, por exemplo.
Temos também o operador de controle OR, que e representado por dois sinais de pipe “| |” Ele age
basicamente da seguinte forma: o comando apos o operador de controle OR somente será executado
caso o primeiro falhe. Algo como um comando reserva, muito utilizado em scripts para notificação
caso algum comando falhe.
Exemplo B:
67
$ ls arquivo.txt 2>/dev/null || echo "Arquivo Não existe"
Arquivo Não existe
$ touch arquivo.txt
$ ls arquivo.txt 2>/dev/null || echo "Arquivo Não existe"
arquivo.txt
Repare que o comando echo entrou em ação devido ao comando ls ter falhado, o que não ocorreu
mais após criarmos o arquivo arquivo. txt.
DICA
Caso o nome de um arquivo ou o argumento de um comando contenha um caractere que
porventura seja igual a um metacaractere, esse deve ser "escapado" pelo shell. Para tal, basta
preceder o caractere com uma barra invertida "\".
Configuração do shell bash

O shell bash, apesar de ser um interpretador de comandos, também e um programa instalado no
sistema, que conta com seus arquivos de configuração. Esses arquivos são lidos quando o bash
invocado, e isto geralmente e feito quando determinado usuário efetua login no sistema.
As distribuições Linux já costumam disponibilizar estes arquivos com previas configurações
funcionais do bash. Estudaremos a seguir cada um desses arquivos, e quais suas respectivas funções.
O shell bash pode ser iniciado de forma interativa e não interativa. Um shell interativo, e o shell que
conhecemos, onde digitamos comandos "interativamente". Este tipo de shell se divide em duas
formas, shell interativo de login, que e o shell carregado quando efetuamos o login, e o shell
interativo comum, que e o shell carregado manualmente após um login. E possível carregar um shell
desse tipo invocando-se o comando bash.
Um shell não-interativo e um shell pouco usado, que não recebe comandos diretamente e só serve
para executar um comando ou script ("bash -c comando", por exemplo).
Quando o bash e invocado como um shell interativo de login, primeiro ele verifica a existência do
arquivo /etc/profile, caso ele exista, os comandos nele contidos serão lidos e executados. Após
ler e executar esse arquivo, o bash faz o mesmo com o arquivo ~/.bash_profile,
~/.bash_login e ~/.profile, nessa mesma ordem, lendo e executando os comandos presentes
nesses arquivos.
Quando um shell interativo de login e finalizado, o bash lê e executa os comandos contidos no
arquivo ~/.bash_logout, caso exista.
Se o shell bash for invocado de forma interativa comum (Não e um shell de login), o bash
somente lê e executa os comandos contidos nos arquivos /etc/bash.bashrc (ou
/etc/bashrc em algumas distribuições), em seguida no arquivo ~/.bashrc.
IMPORTANTE
Os arquivos /etc/bashrc e ~/.bashrc não são lidos pelo bash quando invocamos um
shell interativo de login, porém alguns scripts como o /etc/profile ou
~/.bash_profile podem "chamar" alguns desses arquivos e executá-los. O
importante, a saber, é que o bash não procura por esses arquivos nestas
circunstâncias.
A seguir veremos exemplos dos arquivos comentados nessa seção.
Arquivo /etc/profile
68
if [ “' id u ' ” eq 0];then
PATH=”/usr/local/sbin:/usr/local/bin:/usr/local/sbin:/usr/bin:/sbin:/bin:/usr/
bin/X11”
else
PATH=”/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games”
fi
if [ "$PSl" ]; then
if [ "$BASH" ]; then
PSl='\u@\h:\w\$ ,
else
if [ "'id u'" eq o ]; then
PSl='#
else
PSl='$
fi
fi
fi
export PATH
umask 022
Repare que este arquivo configura o PATH dos comandos, a aparencia do prompt (Variável $PSl) e
configura a umask padrão.
Arquivo ~/.bash_profile
69
# ~/.bash_profile: executed by bash(l) for login shells.
# see /usr/share/doc/bash/examples/startupfiles for examples.
# the files are located in the bashdoc package.
# the default umask is set in /etc/login.defs
#umask 022
# include .bashrc if it exists
if [f ~/.bashrc ]; then
. ~/.bashrc
fi
# the rest of this file is commented out.
# set PATH so it includes user's private bin if it exits
#if [ d ~/bin ] ; then
# PATH= ~/bin:"${PATH}"
#fi
# do the same with MANPATH
#if [ d ~/man] ; then
# MANPATH=/man:
# export MANPATH
#fi
Este arquivo possui uma rotina que verifica a existência de um outro arquivo chamado / .bashrc, e
caso este arquivo exista, será executado pelo bash.
70
Arquivo /etc/bash.bashrc ou /etc/bashrc
#systemwide .bashrc file for interactive bash(1) shells.
#To enable the settings / commands in this file for login shells as well,
#this file has to be sourced in /etc/profile.
#If not running interactively, don't do anything
[ z “$PS1” ] && retum
#check thew window size after each command and, if necessary,
#update the values od LINES and COLUMNS.
shopt s checkwinsize
#set variable indentifying the chroot you work in (used in the prompt below)
if [z “$debian_chroot” a r /etc/debian_chroot]; then
debian_chroot=$(cat /etc/debian_chroot)
fi
#set a fancy prompt (noncolor)
PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
#enable bash completion in interactive shells
#if [ f /etc/bash_completion ]; then
# ./etc/bash_completion
#fi
Arquivo /etc/bash.bashrc de uma distribuição Debian.
Arquivo ~/.bashrc
71
# ~/.bashrc: executed by bash(l) for nonlogin shells.
# see /usr/share/doc/bash/examples/startupfiles (in the package bashdoc)
# for examples
# If not running interactively, don't do anything:
[ z "$PSl" ] && retum
# don't put duplicate lines in the hIstory. See bash(l) for more options
#export HISTCONTROL=ignoredups
# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
#shopt s checkwinsize
# enable color support of ls and also add handy aliases
if [ "$TERM" != "dumb" ]; then
eval 'dircolors b'
alias ls='ls color=auto'
#alias dir='ls color=auto –format=vertical'
#alias vdir='ls color=auto format=long'
fi
# some more ls aliases
#alias ll='ls l'
#alias la='ls A'
#alias l='ls CF'
# set variable identifying the chroot you work in (used in the prompt below)
#if [ z "$debian_chroot" a r /etc/debian_chroot ]; then
# debian_chroot=$(cat /etc/debian_chroot)
#fi
# set a fancy prompt (noncolor)
PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
#Comment in the above and uncomment this below for a color prompt
#PS1='${debian_chroot:+($debian_chroot)}\[\033[Ol;32m\]\u@\h\[\033[OOm\]:\
[\033[Ol;34m\]\w\[\033[OOm\]\$'
#If this is an xterm set the title to user@host:dir
case $TERM in
xterm*lrxvt*)
PROMPT COMMAND='echo ne "\033]O;${USER}@${HOSTNAME}: ${PWD}\007'"
;;
*)
;;
esac
#enable programmable completion features (you don't need to enable
# this, if it's already enabled in /etc/bash.bashrc).
# if [ f /etc/bash_completion ]; then
# ./etc/bash_completion
#fi
Repare na existência de opções que podem ser habilitadas apenas descomentando as linhas corretas.
Este arquivo também foi retirado de um sistema Debian.
72
Arquivo ~/.bash_logout
Este arquivo não costuma existir por padrão em algumas distribuições Linux. Como dito
anteriormente, a função desse arquivo e executar alguma(s) tarefa(s) ao sairmos do sistema, que
podem se tomar necessárias com o tempo. É importante frisar que este arquivo somente será
executado ao sairmos de um shell bash interativo de login.
Execute o comando abaixo para criar um novo ~/.bash_logout:
$ echo “echo Ate Logo...; read” > ~/.bash_logout
Em seguida efetue logout do terminal de login (Faça em um terminal texto, como tty1, por

exemplo). Ao sairmos, será mostrada a mensagem “Até Logo...” na tela, que desaparecerá ao
pressionarmos qualquer outra tecla.
Arquivo~/.bash_history
Arquivo já estudado anteriormente, armazena os últimos comandos digitados pelo usuário.
Aliases de shell
Aliases de shell são formas de se "apelidar" comandos, criando comandos intermediários de atalho
para eles. Aliases são definidos com o comando alias, que é um dos comandos integrados ao shell
bash. Como o comando alias (sem nenhum argumento) podemos listar os alias atualmente
configurados no shell atual. Caso deseje apagar um alias, utilize o comando unalias.
Sintaxe:
alias nome=”qualquer comando valido do shell”
Exemplo A:
$ alias
$ alias cls="clear"
$ alias
alias cls='clear'
$ cls
Definimos um alias para o comando cls (velho conhecido do DOS), que não existe no Linux.

Como o comando clear tem o mesmo efeito em sistemas Linux, criamos um alias para que quando o
usuario digitar o comando cls, o sistema execute clear.
Exemplo B:
73
alias desligar='shutdown h now'
alias reiniciar='shutdown r now'
alias ls='ls color'
alias cdon='mount /dev/cdrom'
alias cdoff=Jumount /dev/cdrom'
alias x='startx'
alias limpa="clear ; date"
Este atalho deve ser escrito no arquivo /etc/bashrc. Se não existir esse arquivo, crie o arquivo
com vi e salveo no diretório /etc com o nome bashrc.
Dica
Os alias definidos na linha de comando manualmente se perdem ao saírmos do shell atual. Para
tomar os aliases permanentes, basta adicionaIos ao arquivo /etc/bash, bashrc ou
~/.bashrc caso queira restringir os novos aliases somente para algum(ns) usuario(s) do sistema.
o proprio ~/.bashrc costuma ter alguns aliases já prédefinidos ou comentados.
Escape de Comandos no bash
É importante que o administrador de sistemas Linux esteja habituado com o escape de comandos no
shell, sem contar que e um tópico de peso para um exame de certificação Linux do nível proposto
pelo treinamento.
Os principais caracteres de escape são: ' (aspas simples), “ (aspas duplas), e \ (barra invertida).
Qualquer string adequada entre aspas simples será interpretada literalmente pelo shell; o mesmo
acontece com as aspas duplas. A diferença entre as aspas é que no caso das simples, não é permitida a
substituição de comandos (visto adiante), já entre as aspas duplas isso é permitido. Qualquer
caractere logo após a \ e considerado literalmente. Colocar uma \ no final da linha diz ao bash para
não interpretar a quebra de linha, e continuar o comando na linha de baixo (vide exemplos).
A substituição de comandos e uma característica do bash (herdada de outros shells) que permite a um
comando utilizar como parâmetro ou parte de um parâmetro a saída de outro comando que esteja
enquadrado entre' (crases) ou no formato $ (comando), conforme exemplo abaixo:
Exemplo A:
$ echo "Existem 'ls l |wc l' arquivos em $(pwd)"
Existem 8 arquivos em /home/camila
Ocorreram 2 substituições e 1 escape de comandos na linha acima. As duas substituições referemse
a saída do comando "ls l |wc l", que listou os arquivos no diretório e em seguida usou o
comando "wc l"para "contar" quantas linhas haviam na saída, que resultou em 8. A segunda
substituição referese a saída do comando pwd, que mostra o caminho do diretório atual. Repare que
as duas substituições de comandos foram efetuadas de formas diferentes. O escape de comandos
referese a tudo que está compreendido entre as aspas duplas no comando.
Exemplo B:
74
$ echo "Um teste 'simples' demais"
Um teste 'simples' demais
$ echo 'Um teste 'simples' demais'
Um teste simples demais
$ echo 'Um teste ''simples'' demais'
Um teste “'simples” demais
Repare em como o escape de comandos atua. Quando as aspas são iguais dentro e fora, o escape de
comandos e anulado.
75
Documentação
Documentação e essencial no que tange o sistema operacional Linux, com seus diversos comandos e
termos. É de grande importância que o administrador, por mais experiente que seja, saiba consultar a
documentação do sistema.
No Linux, existem alguns padrões de documentação que servem como repositório de informações
sobre os comandos e termos relacionados ao sistema. Essas informações podem ser acessadas pelo
próprio sistema. Os comandos e termos costumam estar documentados nas chamadas páginas de
manual e diretório de documentação.
O diretório de documentação de um sistema Linux costuma ser /usr/share/doc. Dentro desse diretório
existem diversos subdiretórios que hospedam documentação sobre os comandos e termos
relacionados. Por exemplo, para obter mais informações sobre o bash, basta analisar os arquivos
dentro do diretório /usr/share/doc/bash. E bem simples.
As páginas de manual são ligeiramente mais complexas, mas iremos estuda-las em seguida.
DICA
Geralmente os comandos contam com parâmetros de ajuda no formato: "comando help" ou
"comando h". Isso facilita bastante a busca por informações sobre determinada parametro de
comando.
Páginas de manual
As páginas de manual definem um padrão com que os programas instalados devem dispor a
documentação. Atualmente, existem dois tipos de páginas de manual: As mais antigas, porem ainda
amplamente utilizadas são as "man pages" e o formato mais recente de documentação que são as
"info pages". Estudaremos com mais cautela cada uma delas.
Man pages
As páginas de manual no formate de "man pages" acompanham quase todos os programas

GNU/Linux. Elas trazem uma descrição da funcionalidade de cada comando ou programa e detalhes
sobre o funcionamento dos parâmetros. Uma página de manual e visualizada na forma de texto com
rolagem vertical. Também e comum encontrar documentação para arquivos de configuração do
sistema, e não somente para comandos.
Para "acessar" as man pages, utilizamos o comando man. Sintaxe:
Man [seção] termo
76
Sua utilização e bem simples. Para ler a página de manual do comando ls, por exemplo,
utilizamos “man ls".
Para facilitar a organização das man pages, foram definidas seções para as páginas de manual deste
formato. Estas seções estão descritas na tabela a seguir.
Seção Descrição
1 Programas executáveis ou programas do shell
2 Chamadas do sistema (Funções providas pelo Kernel)
3 Chamadas de biblioteca (Funções providas por bibliotecas do sistema).
4 Arquivos Especiais (Geralmente Arquivos dentro do diretório /dev)
5 Arquivos de configuração
6 Jogos
7 Miscelânea (Qualquer Coisa que não se enquadrar nas demais)
8 Comandos de administração do sistema (Geralmente os que ficam em /sbin)
9 Rotinas do Kernel (Ainda não e o padrão, talvez mude)
Dessa forma, podemos direcionar nossa busca por documentação para uma página de manual
específica, pois é possível que a documentação de um programa exista em 2 ou mais categorias,
como e o caso do comando crontab que e documentado na seção 1 (sobre o próprio comando) e 5
(formato do arquivo de configuração para o comando). Sendo assim, como as seções são numeradas e
estao em ordem crescente, o man ira mostrar a primeira seção sobre o comando encontrada.
Nesse caso do crontab, ao digitarmos "man crontab", o man ira nos mostrar a primeira página de
manual sobre o comando crontab que ele encontrar, nesse caso a seção 1. Caso queira acessar a
página de manual do crontab da seção 5 ao qual ele também pertence, utilizamos o comando da
seguinte forma:
man 5 crontab
Uma man page segue um formato padrão para dispor as informações na página.A primeira linha da
saída é o cabeçalho, que costuma mostrar nas duas extremidades o nome da página de manual
seguida do número da seção entre parênteses. No caso da seção 5 do comando crontab, a primeira
linha seria assim:
CRONTAB(1)
Para navegar na página de manual, utilizamos as setas do teclado, [PGUP] e [PGDOWN].Para

atualizar a tela, tecla [r], para sair [q].
Os arquivos de man pages ficam armazenados no diretório /usr/share/man. Lá

existem diversos subdiretórios que referenciam as respectivas seções em diversos idiomas
disponíveis, muitas vezes organizadas por links reside.
Dica
77
Utilize o comando man w manpage para descobrir em que seções das páginas de manual o
termo pesquisado reside.
Info Pages
É considerada a evolução das man pages. Sua principal diferença é a inclusão de um novo sistema de
navegação através das páginas, que agora permitem links umas entre as outras, lembrando muito o
conceito de páginas web. Se pressionarmos [Enter] em cima de uma palavra destacada, a info pages
nos levará a seção correspondente. É um pouco mais simples do que as man pages, pois não está
dividida em seções (ainda).
Se o nome do comando ou programa não for digitado, a info pages mostra alistade todos os manuais
de comandos e programas disponíveis. A navegação da info pages é feita através de nome marcados
com um “*”(hipertextos) que se pressionarmos [Enter], nos levará até a seção correspondente.
Info [comando ou programa]
Tabela de Navegação
Tecla Função
q Sai da info page
? Mostra a tela de ajuda de navegação
n Avança uma página
p Volta uma página
u Sobe um nível de página
m Abre de busca para localizar uma página dentro das info pages
d Volta ao índice de documentos
Exemplo:
$ info ls
Sistema de buscas na documentação do sistema
Algumas vezes nos deparamos com alguma situação em que precisamos obter informações sobre
"algo", que pode ser um comando ou termo relacionado, que não sabemos exatamente para que
serve. (Sempre aparece aquele comando inusitado).
É possível efetuar buscas por determinados critérios na documentação do sistema, a fim de
encontrar a página de manual (manpages ou infopages) correta para o comando ou termo
pesquisado.
Criando a base de dados
Antes de efetuarmos qualquer pesquisa, e precise criar (ou atualizar, se necessário) a base de dados
das páginas de manual com o comando makewhatis, portanto, e necessário rodar esse comando
78
sempre que uma nova página de manual for adicionada ao sistema (ao instalarmos programas, por
exemplo), ou antes, da primeira utilização, quando a base de dados ainda não existe.
IMPORTANTE
Algumas distribuições Linux (como o Debian, por exemplo), utilizam o comando mandb c para
criar a base de dados ao invés do comando makewhatis.
Efetuado pesquisas na documentação
Após a base já estar criada, podemos efetuar pesquisas de duas maneiras na base de dados das
páginas de manual. A primeira delas é com o comando whatis, que efetua a busca com base no
“nome do comando”. É muito utilizada quando já sabemos o nome do comando e queremos obter
mais informações sobre ele diretamente. já a outra forma é com o comando apropos, que efetua a
pesquisa com base em “parte do nome do comando ou sua descrição”. Isso permite efetuarmos
buscas com base em termos de pesquisa, o que se torna útil quando não sabemos exatamente o
nome do comando,por exemplo.
Exemplo A:
$whatis cron
cron (8) daemon to execute sheduled commands (Vixie Cron)
$apropos cron
cron (8) daemon to execute scheduled commands (Vixie Cron)
crontab (1) maintain crontab files for individual users (V3)
crontab (8) daemon to execute scheduled comman (Vixie Cron)
79
Localizando arquivos no sistema
Existem alguns utilitários no Linux que nos auxiliam a localizar arquivos na estrutura de diretórios
com base em critérios. A ferramente mais utilizada para essa tarefa e o comando find, que permite
localizarmos arquivos no sistema como base em critérios como o nome do arquivo, datas, tamanho,
etc. Gerando assim uma grande flexibilidade na busca de determinados arquivos no sistema.
Comando find
O find e uma das mais importantes ferramentas GNU disponíveis. Ele trabalha basicamente com
critérios, que podem ser combinados a fim de se encontrar um ou mais arquivos específicos. Essa
característica permite, por exemplo, utilizarmos o find para selecionar quais arquivos fará ou não
parte de uma rotina de backup no Linux.
O find também permite executarmos uma determinada ação para cada um dos arquivos resultantes
da busca.
Sintaxe:
find [caminho ... ] [expressão]
O caminho padrão e o diretório atual; a expressão padrão é print.
As principais expressões estão descritas na tabela abaixo:
name arquivo Procura por algum arquivo chamado "arquivo".
mindepth nive1 Especifica um nível mínimo de subdiretórios para a pesquisa.
maxdepth nive1 Especifica um nível máximo de subdiretórios para a pesquisa.
amin n Procura arquivos que tenham sido acessados "n" minutos atrás.
a time n Procura arquivos que tenham sido acessados "n" dias atrás.
cmin n Procura arquivos que tenham sido modificados "n" minutos atrás.
ctime n Procura arquivos que tenham sido modificados "n" dias atrás.
user usuario Procura arquivos cujo dono seja o usuário determinado.
group grupo Procura arquivos cujo dono seja o grupo determinado.
Procura arquivos de um tamanho especifico. o tamanho pode ser

size tamanho especificado em b (blocos de 512 bytes,padrão), c (bytes), k (Kilobytes)
e w (Palavras de 2 bytes, ou 16 bits)
Procura por arquivos que sejam de um tipo especifico. Os tipos podem
type tipo ser: b (Dispositivo de bloco), c (Dispositivo de caractere), d (diretório),
f (arquivo comum), 1 (link simb6Iico), entre outros.
80
perm permissão Procura arquivos que possuam determinada permissão, que pode ser
especificada em forma to de letras ou em formato octal.
Executa determinado comando para cada arquivo encontrado na busca.
exec comando \; Para referenciar o arquivo no comando utilize {} no lugar do nome de
um arquivo. (Veja exemplos a seguir).
O comando find ainda possui outros diversos para metros não mostrados nessa tabela, porém são
parâmetros dificilmente utilizados, que podem ser encontrados na man page do comando quando
necessário.
Exemplo A:
$ find /bin name ls
/bin/ls
$ find /bin name "ls*"
/bin/ls
/bin/lsmod
/bin/lspci /bin/lsmod.modutils
Procura por um arquivo chamado "ls" dentro do diretório /bin, em seguida procura por
qualquer arquivo que inicie com ls (ls*) no mesmo diretório.
DICA
Sempre que for especificar algum coringa como ls* utilizeo entre aspas, como o exemplo
acima.
Exemplo B:
# find / ~name grep maxdepth 3
Procura no diretório raiz e subdiretórios até o terceiro nível um arquivo ou diretório cujo nome seja
grep.
Exemplo C:
# find /usr size +1000k
Procura por arquivos com mais de 10MB a partir do diretório /usr.
Exemplo D:
81
# find /etc size l000k name host* type f
/etc/hosts
/etc/hosts.allow
/etc/init.d/hostname.sh
/etc/hostname
/etc/hosts.deny
/etc/host.eonf
# find /etc size l000k name host??????? type f /
/etc/hosts.allow
/etc/init.d/hostname.sh
Agora algumas pesquisas mais complexas que envolvem coringas, onde buscamos arquivos a partir
do diretório /etc cujo tamanho seja inferior a 1MB, o nome começe com host (host*) e deve ser
um arquivo comum. Depois refinamos nossa pesquisa dizendo que somente queremos encontrar
arquivos cujo nome comece com host e contenha mais 7 caracteres.
Exemplo E:
# touch /tmp/arq1
# touch t 11201204 /tmp/arq2
#ls l /tmp/arq*
rwrr 1 root root 0 Dec 20 12:04 /tmp/arq1
rwrr 1 root root 0 Nov 20 12:04 /tmp/arq2
#find /tmp name “arq*” atime +10
/tmp/arq2
#find /tmp name “arq*” atime 32
/tmp/arq1
/tmp/arq2
Repare que foram criados dois arquivos, um com a data atual (arq1) e outro com a data de acesso
propositalmente modificada para 20 dias atrás (arq2). A primeira busca do find procura por
arquivos cujo nome inicie com “arq” (arq*) e que tenha sido acessado nos últimos 10 dias (De dez
dias para cá geralmente é mais fácil de memorizar).A segunda busca é parecida, o que a diferencia é
que buscamos por uma arquivo que não tenha sido acessado nos últimos 10 dias (Tente lembrar “de
dez dias pra lá”).Por último, pesquisamos pelos mesmo arquivos que iniciem com arq, mas que
tenham sido acessados nos últimos 32 dias, o que resultou nos dois arquivos.
Exemplo F:
82
#find /dev group disk name hd[abc]2 type b
/dev/hda2
/dev/hdb2
/dev/hdc2
#find /dev group disk name hd[abc]2 type b exec echo “Arquivo {}” \;
Arquivo /dev/hda2
Arquivo /dev/hdb2
Arquivo /dev/hdc2
Tentamos localizar arquivos dentro de /dev que pertençam ao grupo disk, cujo nome comece com
hd, o terceiro caractere do nome seja a, b ou c e seja do tipo b (Dispositivo de blocos). Isso retornou
3 resultados. Depois utilizamos a mesma busca como base para o argumento exec, que executou o
comando echo para cada um dos arquivos resultantes, exemplificando como é possível executar
comandos para cada resultado individual da pesquisa.
Comando whereis
Localiza os binários e as páginas de manual para algum binário (comando ou biblioteca) do sistema.
A pesquisa é efetuada com base nos caminhos configurados na variável $PATH do shell e em
caminhos que comumente abrigam binários do sistema.
Sintaxe
whereis [opção] arquivo
Onde arquivo e o binário a ser pesquisado.
b Procura par binários.
m Procura par páginas de manual.
s Procura par códigofonte.
Exemplo A:
# whereis crontab
crontab: /usr/bin/crontab /etc/crontab /usr/share/man/manl/crontab.l.gz
/ usr/share/man/man5/crontab.5.gz
# whereis b crontab
crontab: /usr/bin/crontab /etc/crontab
# whereis m crontab
crontab: /usr/share/man/manl/crontab.l.gz
/usr/share/man/man5/crontab.5.gz
Comando locate
83
Localiza uma palavra da estrutura de arquivos ou diretórios do sistema a partir de uma base de
dados própria previa mente indexada. E útil quando queremos localizar de forma rápida um arquivo
qualquer. Como a pesquisa e efetuada em um banco de dados próprio do comando, antes precisamos
criar o banco de dados com o comando updatedb.
Sintaxe:
locate [arquivo]
Exemplo:
# touch /tmp/meunovoarquivo
# locate meunovoarquivo
# updatedb
# locate meunovoarquivo /tmp/meunovoarquivo
Repare que antes de atualização da base de dados do locate com o comando updatedb não era
possível encontrar o arquivo meunovoarquivo. Isso torna o locate muito útil para buscas rápidas,
sem ter que varrer todo ou parte do sistema de arquivos a cada busca, por exemplo.
Editores de Texto
O Linux conta com diversos editores de texto que são peça chave no dia a dia de um administrador de
sistemas. O mais utilizado entre eles e o Vi, pois esta presente em 99% das distribuições Linux além
de também estar presente em sistemas Unix. Devido a isso, o vi será o foco de nossos estudos.
Vi
O nome Vi vem de visual, pois e o que os usuários consideravam como sendo um editor visual a mais
de 3 décadas atrás. O Vi é o editor atualmente utilizado que possui mais tempo de vida (mais de 3
décadas). Na verdade, o que encontramos na maioria das distribuições Linux atuais é uma
reencarnação do Vi original denominado Vim (Vi Improved), que foi escrito desde o início por
programadores voluntários com base no Vi já existente. O objetivo desses programadores era criar
um editor de textos melhor que o Vi original, mas que mantivesse as mesmas características.
As principais características do Vi original são na verdade soluções para as necessidades da época. A
utilização do Vi e bastante baseada em teclas de atalho para executar tarefas de rolagem e edição de
texto, devido ao fato de que na época em que o original foi desenvolvido as redes eram muito lentas,
e quanta menos informações (Teclas, comandos...) pudessem trafegar pela rede ao se editar um
arquivo melhor. Essas características são bem vindas até hoje, pois permite efetuarmos edições de
arquivos remotamente (Através de uma conexão remota já estabelecida, como Telnet e SSH, por
exemplo) através de um link de banda estreita.
Sintaxe:
vim [arquivo]
O Vi possui 3 modos básicos de operação: comando, linha e edição.
OBSERVAÇÃO
Em sistemas que possuem o Vi IMproved (vim) instalado e geralmente é criado um alias do
comando vi para vim.
84
Modo de comando
É o modo de operação padrão do Vi. Neste modo o editor interpreta os caracteres digitados como
comandos internos do editor e não como texto a ser inserido no arquivo. A falta de compreensão
deste modo geralmente causa maior frustração ao utilizar este editor. Os comandos do Vi se dividem
em 4 subcategorias: movimentação, pesquisa, texto e edição, vistos na tabela abaixo:
Comandos de Movimentação
Comando Descrição
k Movimenta o cursor para cima.
j Movimenta o cursor para baixo.
l Movimenta o cursor para a direita.
h Movimenta o cursor para a esquerda.
0 (zero) Posiciona o cursor no início da linha.
$ Posiciona o cursor no final da linha.
G Posiciona o cursor na Última linha do arquivo.
[CTRL]+[F] Avança uma tela na rolagem de texto.
[CTRL]+[B] Retrocede uma tela na rolagem de texto.
H Posiciona o cursor na primeira linha da tela.
M Posiciona o cursor na linha do meio da tela.
L Posiciona o cursor na última linha da tela.
w Posiciona o cursor no início da próxima palavra (ignora pontuação).
W Posiciona o cursor no início da próxima palavra sem ignorar a pontuação.
b Posiciona o cursor no início da palavra anterior (ignora pontuação).
B Posiciona o cursor no início da palavra anterior sem ignorar a pontuação.
nG Posiciona o cursor no início da linha n (Substituir “n” pelo número da linha
desejada).
Comandos de Pesquisa
Comando Descrição
f+c Posiciona o cursor no próximo caractere “c” encontrado na linha. (Ex.: fp
posiciona o cursor sobre o próximo caractere p encontrado na linha.)
/palavra Posiciona o cursor na próxima ocorrência a palavra pesquisada abaixo do Cursor.
85
Comandos de Pesquisa
?palavra Posiciona o cursor na próxima ocorrência a palavra pesquisada acima do Cursor.
n Prossegue a busca do último comando “/” ou “?” na próxima ocorrência. Caso
chegue ao final do arquivo, a pesquisa terá continuidade no início do arquivo.
N A mesma função que o comando N, porém faz a pesquisa na ordem inversa da
última pesquisa efetuada com “/” ou “?”
[CTRL]+[G] Mostra o nome, o número da linha atual e o total de linhas do arquivo.
Comandos de Texto e Substituição
Comando Descrição
x Exclui o caractere que esteja abaixo do cursos.
dw Exclui todo o texto da posição atual do cursor ate o final da palavra.
yw Copia todo o texto da posição atual do cursor ate o final da palavra.
cw Exclui todo o texto da posição atual do cursor ate o final da palavra e
coloca o editor no modo de edição.
dd Exclui toda a linha atual. (Recorta)
yy Copia toda a linha atual. (Recorta)
D Exclui todo o texto da posição atual do cursor ate o final da linha.
(Recorta)
y Copia todo o texto da posição atual do cursor ate o final da linha.
Substitui o caractere abaixo do cursor pelo caractere "x". (Obs.:
rx
Qualquer caractere pode ser utilizado, x é somente um exemplo).
Limpa toda a linha em que o cursor se encontra e coloca o editor no
cc
modo de edição.
R Inicia o modo de "substituição de texto". Para sair, pressione [ESC].
J Une a linha atual a próxima linha.
Cola o texto que esteja em buffer após o cursor. (Obs.: Qualquer
p
comando de texto que exclua caracteres os envia para o buffer).
Inicia o modo visual para seleção do texto a partir da posição atual do
cursor. Após selecionar o texto desejado. Utilize uma das teclas como
v
[y], [c] e [d] para copiar, substituir e recortar, respectivamente, ou a tecla
[v] novamente para fechar o modo visual.
u Desfaz o último comando.
[CTRL]+[R] Refaz o último comando.
O modo de texto e uma forma pratica de substituir, organizar e inserir texto sem utilizar o modo de
edição (sem precisar digitar texto). Uma característica importante desse modo é que todo o texto
manipulado por esses comandos fica armazenado no buffer. Isso permite, por exemplo, recortar uma
86
linha inteira com o comando "dd" e colar na linha logo abaixo do cursor com o comando "p".
Modo de Edição
Ao entrarmos no modo de edição, tudo que digitarmos no teclado será enviado como texto para o
arquivo (o mais parecido possível com outros editores de texto). Para sair do modo de edição e
voltar ao modo de comando, utilizamos à tecla [ESC], ate 2 vezes se assim for necessário. Quando
estamos no modo de edição, a string " INSERT " e mostrada no canto inferior esquerdo da tela.
No modo de comando, nada e mostrado.
A partir do modo de comando, podemos utilizar quaisquer dos comandos da tabela abaixo para
iniciar o modo de edição:
Comandos para entrar no modo de edição
Comando Descrição
o Insere no início da linha abaixo.
cl Apaga o caractere sob o cursor e inicia o modo de edição.
a Insere após o cursor.
A Insere no final da linha.
i Insere na posição atual do cursor.
Modo de linha
O Modo de linha e um modo onde se tem acesso a comandos especiais do vi. Para entrar em modo
de linha devese estar em modo de comando e pressionar ":" (Doispontos).
Principais comandos do modo de linha

Comando Descrição
:e arquivo Instrui o vi para abrir um arquivo para edição.
:w [!] [arquivo] Salva o arquivo atual. Opcionalmente podemos colocar o
nome de outro arquivo para instruir o via salva o arquivo atual
como outro nome (Salva Como...). Adicionar a exclamação
“!” de frente do comando (w!)força a operação.
:q[!] Sai do arquivo sem salvar. Caso tenha feito alguma alteração o
Vi não deixara sair sem salvar, somente se utilizarmos a
exclamação(q!) para forçar a saída sem salvar o arquivo.
: r arquivo Insere o conteúdo de outro arquivo a partir do cursor.
:x[!] Saí do Vi e salva o arquivo atual. Também é possível utilizar a
exclamação para forçar a operação.
:s /antiga/nova/g Substitui a string “antiga” pela string “nova” na linha atual. O
parâmetro “g” no final é opcional, e diz para o Vi continuar
em busca de substituições na mesma linha mesmo após a
primeira ocorrência.
87
Principais comandos do modo de linha
:%s/antiga/nova/g Substitui a string “antiga” pela string “nova” em todo o
documento atual.O parâmetro “g” no final é opcional, e diz
para o Vi continuar em busca de substituições na mesma linha
mesmo após a primeira ocorrência. O comportamento padrão
do Vi (sem o “g”) é proceder para a próxima linha caso
substitui alguma palavra).
:set number e :set nonumber Ativa e desativa, respectivamente, a numeração de linhas do
arquivo.
:noh1 Desabilita o highlight que marca as palavras de alguma busca
efetuada anteriormente.
Para voltar do modo de linha para o modo de comando basta pressionar ESC.
Dicas preciosas do Vim
Existem alguns "macetes" de sobrevivência do Vim, e devem estar na ponta da língua de um
administrador Linux. Uma dica importante e lembrar que sempre e possível desfazer as alterações
efetuadas em um arquivo, até um certo limite, com a tecla [u] no modo de comando.
Outra dica importante: Para os comandos de linha que interagem com o texto (substituição, por
exemplo) é possível especificar um intervalo de linhas onde o comando terá efeito.
Digamos que você precise substituir a palavra gato pela palavra cachorro no arquivo em que esteja
editando, mas somente entre as linhas 100 e 154. A solução seria o seguinte comando de linha:
:100,154s /papagaio/macaco/g
Uma outra ocasião mais utilizada: Digamos que você precise comentar com o caractere “#” um
grande intervalo de linhas em um arquivo (pode ser maçante ficar fazendo Isso linha por linha). O
comando de linha do vi abaixo resolveria facilmente o problema, nesse caso, das linhas 10 até 25
(faça com um arquivo grande para testar).
:10.25s/^/# /
O intervalo “10,25” dia para o comando atuar somente entre as linhas 10 e 25. O comando de
substituição irá substituir o início da linha (Representado pelo caractere “^”) pelo sinal de “#”
acrescido de um espaço. Pronto.
Também é possível editar dois ou mais arquivos na mesma tela. Tal proeza se torna verdadeira com o
comando. :split. Por exemplo, digamos que você já esteja editando um arquivo e queira abrir outro na
mesma tela, dividindo a mesma ao meio.Basta utilizar o comando abaixo dentro do Vim.
:split novoarquivo
Para alternar entre as telas utilize a seqüência de teclas[CONTROL]+[W]+[W].
88

Apostila 1.1

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Apostila 1.1

Загружено:

Авторское право:

Доступные форматы

Treinamento

Versão 1.1 - 2009

Licenciamento e Versões do Kernel do Linux

Linux Standard Base (LSB)

O prompt de login pode facilmente ser configurado através da variável

Caracteres de escape para customização do shelll usasndo $PS1:

shutdown [-akrhfnc] [-t secs] tempo [mensagem]

Para exibir o conteúdo de uma variável no console, execute o comando echo

O próximo login, o bash carrega o arquivo ~/.bash_history para a memória, restaurando o

Outros comandos como esses podem ser verificados na tabela abaixo:

Filesystem Hierarchy Standard

Um Sistema FHS divide os diretórios em 2 (duas) categorias principais:

1) Compartilháveis e Não Compartilhaveis

Estáticos /usr /etc

Os diretórios contemplados pela FHS são:

Portas Seriais e Paralelas

Nesse exemplo, primeiro foi mostrado o conteúdo do arquivo

Podem ser criadas mais de um diretório com um único comando.

Criados 3 arquivos vazios. Observe a data de criação dos arquivos.

Copia ORIGEM para DESTINO, ou múltiplas ORIGENS para DIRETÓRIO.

Antes de prosseguir, vamos criar o ambiente para os exercícios:

Copia recursivamente todo a conteúdo de /tmp/arquivos para subdir/ (recém-criado). Depois

Muda o nome do arquivo teste.txt para cds.txt.txt.

Apaga o arquivo teste.txt no diretório atual.

Remove o diretório rm, criado no Exemplo ª

Identificadores de Usuários e Grupos (UID e GID)

O primeiro campo (camila) é o nome do usuário.

O /etc/shadow segue a mesmo formato de divisão do /etc/passwd, porém contém 9 campos.

Os campos estão divididos da seguinte forma:

Adicionando usuários com useradd

Aumentando a segurança com o comando chage

Uma outra forma de se chegar ao mesmo resultado do exemplo anterior.

Gerenciando informações de usuários com chfn e finger

Modificando o shell do usuário com chsh

Modificado o shell inicial do usuário para /bin/bash.

Verificando integridade dos arquivos de senhas com pwck

Modificando contas de usuários com usermod

Obtendo Informações com o comando id

Adicionando grupos com groupadd

Removendo grupos com groupdel

Adicionando usuários aos grupos

Removendo usuários dos grupos

gpasswd -d usuario grupo

Modificando informações sobre grupos

Definindo administradores de grupos com gpasswd

Trocando grupo principal temporariamente com newgrp

- rwx rwx rwx 2 agomes cds 0 2004-l0-28 17:29 arquivo1

Como o permissionamento esta dividido em 3 seções (usuário, grupo e outros), a presença ou

Definindo Permissões com chmod

­v Verbose. Mostra informações sobre as modificações efetuadas. Mesmo que as

Modo Simbólico de Permissões

Modo octal de permissões

Bits Soma de Bits

$ chmod 644 arq1

Máscara de usuário (umask)

Compare com o exemplo anterior.

Redirecionando a saída de erros padrão (stderr)

Primeiro criamos o nosso ambiente de exercícios.

Diferenças entre 0 "|" e o">"

Antes de começar com os exercícios, devemos criar o ambiente de testes.

Operadores de controle lógico: && e | | (AND e OR)

Configuração do shell bash

Em seguida efetue logout do terminal de login (Faça em um terminal texto, como tty1, por

v Verbose. Mostra informações sobre as modificações efetuadas. Mesmo que as