Apostila Debian Intermediário - Desktop Parana

Transcrição

Apostila Debian
Intermediário Desktop
Parana
Direitos autorais:
Essa Apostila está licenciada sob uma Licença Creative Commons AtribuiçãoUso NãoComercial
Compartilhamento pela mesma licença 2.0 Brazil. Pode ser copiada, distribuída e modificada. Para ver uma cópia desta licença, visite http://creativecommons.org/licenses/byncsa/2.0/br/ ou envie uma carta para Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
2
Documento
Versão
1.9
Data de Revisão
29 de Janeiro de 2010, por Robson Alves Pavan
Equipe Técnica
Mantenedor: Robson Alves Pavan
Revisor: Robson Alves Pavan
Colaboradores:
Robson Alves Pavan
Felipe Camargo de Pauli
André Lucas Falco
Andre Luiz de Souza Paula
Coordenação do projeto: Jonsue Trapp Martins
Páginas
168 páginas
Índice
APROFUNDANDO-SE NO APT............................................................................................9
APT (ADVANCED PACKAGE TOOL)................................................................................9
ARQUIVOS DE CONFIGURAÇÃO “APT.CONF”............................................................14
Grupos.........................................................................................................................15
Exemplos:....................................................................................................................15
ARQUIVO DE CONFIGURAÇÃO “PREFERENCES”.....................................................16
DPKG...............................................................................................................................18
Utilizando o dpkg.........................................................................................................18
Ações............................................................................................................................... 19
Opções............................................................................................................................. 21
Exemplos de ocorrências mais comuns no uso do dpkg.................................................21
COMPILANDO PROGRAMAS A PARTIR DO CÓDIGO FONTE......................................25
GERENCIANDO DISCOS E PARTIÇÕES..........................................................................27
O QUE SÃO PARTIÇÕES...............................................................................................27
OBTENDO INFORMAÇÕES SOBRE AS PARTIÇÕES..................................................28
PARTICIONANDO DISCO COM CFDISK.......................................................................30
Excluindo uma partição...............................................................................................32
Salvando as alterações...............................................................................................32
SISTEMA DE ARQUIVOS...............................................................................................32
CRIANDO SISTEMA DE ARQUIVOS..............................................................................33
GERENCIADOR DE PARTIDA – GRUB.............................................................................34
TRABALHANDO COM DISCOS E PARTIÇÕES............................................................34
INSTALAÇÃO DO GRUB................................................................................................35
CUSTOMIZANDO O ARQUIVO MENU.LST...................................................................36
OUTROS PARÂMETROS DE CONFIGURAÇÃO DAS IMAGENS................................41
LINHA DE COMANDO DO GRUB...................................................................................42
RUNLEVEL..........................................................................................................................45
PROCESSO DE BOOT...................................................................................................45
CONHECENDO OS RUNLEVELS..................................................................................45
IDENTIFICANDO O RUNLEVEL EM UTILIZAÇÃO........................................................46
O ARQUIVO /ETC/INITTAB.............................................................................................46
ENTENDENDO O FUNCIONAMENTO DOS RUNLEVELS...........................................48
INSERINDO/ REMOVENDO SCRIPTS DO RUNLEVEL................................................49
SISTEMA DE LOGS............................................................................................................51
PRINCIPAIS ARQUIVOS DE LOG..................................................................................51
LENDO UM ARQUIVO DE LOG......................................................................................52
CONFIGURANDO O SYSLOG........................................................................................52
LOGGER..........................................................................................................................55
LOGCHECK.....................................................................................................................56
LOGROTATE...................................................................................................................57
CRON...................................................................................................................................61
COMANDOS........................................................................................................................64
ALIAS...............................................................................................................................64
BC....................................................................................................................................66
LAST................................................................................................................................73
LASTLOG........................................................................................................................75
NEWUSERS....................................................................................................................77
STAT................................................................................................................................77
CONVERT.......................................................................................................................80
CONVMV.........................................................................................................................81
ICONV..............................................................................................................................82
Identificando a codificação de caractere do arquivo e a do sistema..........................83
PASTE..............................................................................................................................84
CUT..................................................................................................................................85
DD....................................................................................................................................88
FIND.................................................................................................................................90
XARGS............................................................................................................................95
FSCK................................................................................................................................96
FUSER.............................................................................................................................98
LSOF..............................................................................................................................100
PIDOF............................................................................................................................101
NICE..............................................................................................................................102
RENICE.........................................................................................................................104
NOHUP..........................................................................................................................105
LSPCI.............................................................................................................................105
LSUSB...........................................................................................................................107
HWCLOCK.....................................................................................................................109
NMBLOOKUP................................................................................................................110
NSLOOKUP...................................................................................................................114
GERÊNCIA DE REDES DE COMPUTADORES...............................................................117
CAMADA OSI.................................................................................................................117
PROJEÇÃO DA ARQUITETURA TCP/IP SOBRE O MODELO OSI.............................119
EMPACOTAMENTO DE DADOS..................................................................................120
TCP/IP...........................................................................................................................121
CAMADA DE APLICAÇÃO............................................................................................122
CAMADA DE TRANSPORTE........................................................................................123
TCP............................................................................................................................124
UDP...........................................................................................................................124
Portas e soquetes......................................................................................................125
CAMADA INTER-REDES..............................................................................................126
IP...............................................................................................................................127
ICMP..........................................................................................................................128
ARP...........................................................................................................................128
CAMADA DE ENLACE..................................................................................................130
Ethernet.....................................................................................................................130
PARÂMETROS NECESSÁRIOS...................................................................................131
IP...............................................................................................................................131
Rede..........................................................................................................................132
Gateway.....................................................................................................................132
Nomes.......................................................................................................................132
PRIMEIROS SOCORROS.............................................................................................134
PING..............................................................................................................................135
WGET............................................................................................................................137
IFCONFIG......................................................................................................................138
up...............................................................................................................................140
down..........................................................................................................................140
IFUP E IFDOWN............................................................................................................141
ROUTE..........................................................................................................................142
Sintaxe.......................................................................................................................144
Exemplos...................................................................................................................145
5
IFTOP............................................................................................................................146
Primeira coluna..........................................................................................................147
Segunda coluna.........................................................................................................148
Terceira coluna..........................................................................................................148
Quarta, quinta e sexta coluna...................................................................................148
TRACEROUTE..............................................................................................................150
ttl (Time To Live)........................................................................................................151
ARP................................................................................................................................152
DIG.................................................................................................................................154
Servidor-de-nome......................................................................................................154
Tipo de pesquisa.......................................................................................................155
Objeto a ser pesquisado...........................................................................................155
Exemplos de saídas..................................................................................................155
MII-TOOL.......................................................................................................................157
Negociação................................................................................................................158
Alterar os modos disponíveis....................................................................................159
Mensagens de erro....................................................................................................160
NETSTAT.......................................................................................................................160
Primeira coluna (Protocolo utilizado)........................................................................161
Segunda coluna (Fila de dados a serem recebidos)................................................161
Terceira coluna (Fila de dados a serem enviados)...................................................161
Quarta coluna (Endereço local).................................................................................162
Quinta coluna (Endereço remoto).............................................................................162
Sexta coluna (Estado)...............................................................................................162
Praticando.................................................................................................................162
GERENCIADOR WICD.................................................................................................163
Estrutura do Wicd......................................................................................................164
Funcionamento e configurações...............................................................................165
REFERÊNCIAS BIBLIOGRÁFICAS.................................................................................167
6
Índice de Figuras
Figura 1: Arquivo sources.list......................................................................................................... 10
Figura 2: Tela principal do cfdisk....................................................................................................30
Figura 3: Cfdisk - criando uma nova partição.................................................................................30
Figura 4: Cfdisk - escolhendo o tipo de partição (primária ou lógica).............................................31
Figura 5: Cfdisk - definindo o tamanho da partição........................................................................31
Figura 6: Cfdisk - Selecionando tipo de partição............................................................................32
Figura 7: Exemplo resultado de uso do comando convert..............................................................81
Figura 8: Representação de uma consulta a um servidor WINS..................................................112
Figura 9: Camada OSI.................................................................................................................. 118
Figura 10: Saída do comando IFTOP...........................................................................................147
Figura 11: Janela do Wicd............................................................................................................ 165
APROFUNDANDO-SE NO APT
No Debian temos basicamente duas formas de se instalar pacotes: (a) através das ferramentas de instalação; (b) ou manualmente compilando o pacote. O Debian é capaz de trabalhar
com diversas ferramentas de instalação, dentre elas destacamos o APT e o DPKG. Quando falamos em instalação ou desinstalação em qualquer distribuição Linux, sempre esbarramos no termo
pacote em vez de programa. Isso vem da ideia de empacotamento de programas, que é um agrupamento de dados que contém os arquivos e a estrutura indicativa de onde cada arquivo deve ser
gravado no sistema para que o mesmo funcione corretamente, junto com um conjunto de instruções que são executadas antes (preinst) e após (postinst) a instalação e remoção dos mesmos.
Cada distribuição Linux possui uma extensão representativa para seus pacotes. No Debian
e seus derivados, a extensão utilizada é ”.deb”. Outra extensão comumente encontrada é “.rpm”
que é oriunda das distribuições derivadas do RedHat. Ainda é possível encontrar arquivos binários, como acontece quando instalamos alguns módulos proprietários de interfaces de rede. Estes
possuem uma série de alternativas em seu corpo, permitindo que o módulo seja instalado independente da distribuição (desde que ela seja suportada).
APT (ADVANCED PACKAGE TOOL)
O APT é a principal ferramenta de manipulação de pacotes do Debian. Com ele é possível
instalar, remover, reinstalar, configurar, atualizar, etc... É uma ferramenta completa que possui
muitos recursos que são utilizados através dos vários comandos do APT. Os comandos mais utilizados são o “apt-get” e o “apt-cache”. O APT possui uma ferramenta com interface gráfica que
permite a instalação e remoção de pacotes. Ele se chama “Gerenciador de Pacotes Synaptic”.
Antes de nos aprofundarmos no estudo do APT devemos fazer algumas observações sobre
alguns pontos com relação a seu uso.
● Com exceção dos recursos de pesquisa do APT, todos os demais só podem ser executado pelo superusuário (root). Quando tentamos utilizar esses recursos como usuários comuns, uma mensagem de erro parecida com “E: Não foi possível abrir arquivo de trava
/var/lib/dpkg/lock – open (13 Permissão negada)” é apresentada na tela.
● Não é possível executar mais de uma instância simultaneamente. Enquanto uma instância estiver sendo executada as tentativas de se iniciar uma outra resultaram em erro,
como “E: Não foi possível obter trava /var/lib/dpkg/lock – open (11 Recurso temporariamente
indisponível)”. É comum esse erro acontecer na seguinte situação: algum usuário deixa o
synaptic aberto ou esta efetuando as atualizações de segurança e tentar instalar algum pacote através do APT.
9
● Para o correto funcionamento do APT, os repositórios de onde serão baixados os pacotes devem estar corretamente configurados no arquivo “sources.list” que se encontra no
diretório “/etc/apt”.
A
configuração do arquivo “sources.list” deve ser feita da seguinte forma: primeiramente deve ser passado o tipo de pacote que será instalado, onde o parâmetro
“deb” o define que o repositório configurado nesta linha trará os pacotes que contêm os
componentes que serão instalados, ou seja, os programas e toda estrutura necessária
para seu funcionamento no sistema, e “deb-src” define os pacotes que contêm os códigos fontes dos pacotes tipo “deb”. Em seguida devemos definir qual protocolo será utili zado para transferências dos pacotes (http ou ftp), seguido do endereço (ip ou nome) do
repositório e do compartilhamento desejado. Após o endereço, devemos definir a qual
release os pacotes devem pertencer e as seções desejadas (pacotes livres, livres dependentes de proprietários ou integralmente proprietários).
Figura 1: Arquivo sources.list
Geralmente quando instalamos um pacote, para que funcione corretamente, ele depende de
outros pacotes (que podem conter bibliotecas ou outros programas). Estes pacotes, os quais ele
depende, chamamos de dependências. Um pacote pode ter várias dependências sendo que pacotes diferentes podem vir a ter dependências em comum e as próprias dependências podem vir a
ter dependências, como numa grande teia de pacotes que unidos formam um sistema funcional.
Sabendo que um pacote possui dependências ao tentarmos instalá-lo, para que ele funcione, precisamos instalar também todas as suas dependências e as dependências de suas dependências. Isso torna esse processo muitas vezes complexo e trabalhoso.
O APT é considerado por muitos como a melhor ferramenta para gerenciamento de pacotes
principalmente devido a sua capacidade, através do apt-get, de quando acionando para instalação
de um pacote, sempre seguir uma determinada ordem que possibilita a instalação dos pacotes e
de todas as dependências necessárias para que ele funcione. A ordem seguida por ele é esta: verificar se o pacote existe na lista local, resolver as dependências, solicita ao servidor todos os pacotes necessários, faz o download, descompacta, configura e instala os pacotes.
1. Verificação de existência do pacote: Verifica se o pacote indicado para instalação está
disponível nos repositórios através da lista local de pacotes.
2. Resolver dependências: Caso o pacote exista, verifica quais são as suas dependências,
10
a disponibilidade delas e se alguma já está instalada no sistema. Quando encontra dependências já instaladas, verifica se estão com a versão correta. Em seguida, caso não haja
nenhum conflito com os pacotes instalados e suas dependências sejam sanadas, será exibido um relatório com toda relação de pacotes a serem instalados, removidos e atualizados, além de, em alguns casos, mostrar uma relação de pacotes sugeridos ou recomendados para instalação junto a uma solicitação de confirmação para continuidade do processo
de instalação.
3. Baixar: Ele acessa o repositório configurado no “sources.list” e faz o download do pacote e
de suas dependências para o seu computador, no diretório “/var/cache/apt/archives”.
4. Descompactar: O pacote é descompactado para iniciar a instalação.
5. Configurar: Todas as configurações necessárias para que a instalação se dê de forma
acertada são realizadas. Estas configurações muita vezes não interagem com o administrador. Caso seja necessário que este informe algo ao instalador, será perguntado.
6. Instalar: Todos os componentes do pacote são copiados para os diretórios devidos.
Agora iremos ver algumas formas de uso do comando apt-get mostrando seus principais
parâmetros:
 apt-get update – Existe uma lista, que contém uma descrição de todos os pacotes disponíveis para o Debian, disponível dentro de cada repositório de pacotes. O “apt-get” consulta esta
lista para saber o que pode ser instalado. Este comando faz uma comparação entre a lista que
você têm armazenada e a lista que está no servidor de pacotes. Se a sua for mais velha, ele faz o
download da mais recente. A atualização de um único pacote provoca o lançamento de um nova
lista. Este comando sempre deve ser executado antes de se fazer a instalação de algum pacote e
após efetuar alterações no arquivo “sources.list”.
 apt-get upgrade – Esta é a opção responsável pela atualização de pacotes. Quando
você executa este comando, uma lista de pacotes é copiada do repositório para a máquina local
do usuário, onde é feita uma comparação entre as versões de softwares existentes no repositório
e na máquina local. Caso existam versões mais recentes para os programas que o usuário possui
em seu sistema, então, o APT automaticamente atualizará estes programas no computador do
usuário. Não é preciso dizer qual pacote você quer atualizar. Independente de ser apenas um, ou
serem vários, ele fará toda atualização necessária.
 apt-get clean - Após a instalação de um pacote, não precisamos necessariamente manter o arquivo ”.deb” em nosso sistema (em “/var/cache/apt/archives”). O processo de instalação
não remove os pacotes baixados! Se você não remover os pacotes baixados, começará a acumulá-los no disco rígido. Com o passar do tempo, isso pode causar um problema de falta de espaço.
11
O “apt-get clean” faz a remoção de todos os pacotes do diretório de cache do APT.
 apt-get install PACOTE - Executamos este comando para realizar a instalação de pacotes no sistema. Se quisermos instalar mais de um programa, basta escrever todos os nomes separados por espaço na linha de execução do comando. Se um pacote precisa de outros para ser
instalado, isto é, se ele tem pré-requisitos, eles também serão selecionados para instalação automaticamente. Quando você requisita a instalação de um pacote que não tem dependências, a instalação começa imediatamente. Caso existam dependências, elas são mostradas a você e o programa aguarda a sua confirmação (“s/n”) para continuar. Existem vários motivos para ele esperar
por uma confirmação: a lista de dependências pode ser muito grande e você pode não querer instalar todos os pacotes; pode não haver espaço em disco suficiente para instalar o programa e/ou
suas dependências; o pacote ser incompatível com outro já instalado e exigir que este seja removido; ou, ainda, o repositório não é uma fonte confiável para o Debian, que acontece quando não
existe na máquina a chave pública do repositório de onde vem a atualização. Existe ainda, um
caso em que há mais de uma versão disponível para o mesmo pacote. Se um pacote chamado
“nome” possui uma versão “1.0-0” e “2.0-0”, por exemplo, a versão mais nova será instalada por
padrão, entretanto, podemos querer instalar a versão mais antiga (1.0-0), tendo que executar o
comando da seguinte forma:
# aptget install nome=1.00
 apt-get dist-upgrade - Possibilita a atualização completa da distribuição utilizada pelo
usuário. É importante que o usuário tenha em mente que a execução deste comando num sistema
que utilize meta-pacotes customizados, como é o caso do “Debian Desktop Paraná” usado na Celepar, ou versões de software instaladas manualmente (através de compilação do código fonte,
por exemplo), poderão gerar problemas graves, impossibilitando inclusive o uso posterior do sistema. Para a devida utilização deste comando, é necessário alterar o arquivo de configuração do
APT, o “/etc/apt/sources.list”, configurando o mesmo para utilizar os repositórios da nova distribuição que será instalada no sistema.
 apt-get remove PACOTE - Remove um ou mais pacotes. Esta operação faz a desinstalação de um pacote do sistema e não a remoção do “.deb” do diretório de cache do APT. Em alguns
casos, os arquivos de configuração e/ou dados do pacote são mantidos. Isso pode ser bom ou
ruim. Se você removeu um pacote por acidente, todo o seu trabalho de configuração dele ainda
estará preservado. Preste atenção às mensagens mostradas durante a remoção de um pacote
para saber o que está acontecendo. Observe também que, se algum pacote depende do pacote a
ser removido, esse pacote também será removido.
 apt-get --purge remove PACOTE - Remove um ou mais pacotes e seus respectivos arquivos de configuração.
12
 apt-get source PACOTE - Possibilita que o código fonte de um programa seja copiado
para máquina local em vez do binário do programa e seus scripts de configuração, que compõem
o pacote do programa propriamente dito. Para baixar arquivos contendo o código fonte de programas para sua máquina, é necessário configurar adequadamente o arquivo “/etc/apt/sources.list”.
Para isso, veja o tópico “Reconfigurando a lista de pacotes”, na sequência.
 apt-get build-dep PACOTE - Este comando tenta satisfazer as dependências que um determinado pacote contendo código fonte de um programa possui, para ser compilado. Por exemplo: suponha que você deseja recompilar o código fonte do “tuxracer” (um jogo). Se você executar
o comando “apt-get build-dep tuxracer”, o APT tentará instalar todos os pacotes que sejam necessários para compilação do pacote “tuxracer”. Em algumas situações, é necessário instalar pacotes
além daqueles que são trazidos automaticamente pelo comando “apt-get build-dep”. Isto é algo
natural e você deverá se acostumar a estas situações.
 apt-get check - É uma ferramenta de diagnóstico. Ele atualiza o cache de pacotes e verifica se há alguma dependência quebrada que necessita ser resolvida (utilizando-se “apt-get -f install”) no sistema.
 apt-get install --reinstall PACOTE - Em algumas situações, precisaremos reinstalar um
pacote já presente no sistema. Para isso, podemos utilizar este o comando que permite fazer isso.
Tome o cuidado de fazer uma cópia dos seus arquivos de configuração para não ter surpresas desagradáveis.
Além do “apt-get” vamos ver também o uso do “apt-cache” que é a ferramenta de pesquisa
do APT. Através das ferramentas de pesquisa podemos procurar por pacotes assim como pesquisar informações mais detalhas sobre um determinado pacote.
 apt-cache search NOME - Para procurar por um pacote qualquer, executamos este comando. Ele faz uma pesquisa na lista de pacotes disponíveis, procurando pacotes que possuam a
expressão fornecida no argumento “NOME”. A saída deste comando, apresenta todos os pacotes
que apresentam a palavra fornecida como argumento em parte do nome ou na descrição do pacote. Existem formas mais complexas de busca que podem ser mais claras ou mais específicas,
mas geralmente, a utilização do comando “grep” para filtrar a saída já é suficiente para grande
maioria dos casos.
 apt-cache show PACOTE - Uma vez descoberto o nome correto do pacote Debian, você
pode visualizar todas as informações sobre o pacote, bem como seu mantenedor, sua versão, sua
descrição, dentre outras informações relevantes.
 apt-cache showsrc PACOTE – Tem a mesma função que o comando “apt-cache show”,
porém, atua mostrando informações sobre pacotes fontes.
13
ARQUIVOS DE CONFIGURAÇÃO “APT.CONF”
O apt possui a possibilidade, como quase todas aplicações utilizadas no Debian, de ser alterado, personalizado, ou seja, configurado de acordo com o interesse do administrador por meio de
arquivos de configuração. Sempre que uma ferramenta do grupo APT é iniciada, ela irá ler os arquivos de configuração para saber qual será o seu comportamento. Nas versões anteriores ao Debian Lenny, essas configurações eram realizadas no arquivo /etc/apt.conf. A partir da versão
Lenny, distribuição esta que é a consistência do Desktop Paraná sob a versão 2.x, foi criado um
diretório que aloca vários arquivos de configuração. O diretório é o /etc/apt/apt.conf.d, e dentro deles podemos encontrar vários arquivos. Estes arquivos seguem a mesma sintaxe do antigo apt.conf, com a diferença de existir um arquivo para cada configuração diferente. Para que o apt saiba
qual arquivo tem maior prioridade em relação ao outro, o nome dos arquivos deve iniciar com um
número de 00 a 99.
T
odas as opções que são passadas pelo usuário através da linha de comandos sobrescrevem as configurações contidas no arquivo “apt.conf”.
!! Por motivos estritamente didáticos, iremos, a partir de agora, indicar cada arquivo desses que podem ser alocados dentro do diretório /etc/apt/apt.conf.d
como apt.conf. !! O arquivo “apt.conf” é organizado sob a forma de árvore em divisões funcionais, como por
exemplo: o grupo “APT”, o grupo “Acquire”, o grupo “DPKG” e a seção “Dir” (para diretórios de
configuração). Sintaticamente, o arquivo pode ser configurado sob as seguintes formas:
APT::Get::AssumeYes "true";
ou
APT {
Get {
AssumeYes "true";
};
};
Nos exemplos acima, podemos perceber que tanto os caracteres “::”, quanto “{“ e “};”, são
utilizados para definir qual o grupo funcional, seção e opções estamos tratando naquele espaço
do arquivo de configuração. Em ambos exemplos que citamos (acima), estamos tratando da opção “Assume-Yes, da seção “Get”, do grupo funcional “APT”, contudo, de formas sintaticamente
diferentes, mas produzindo o mesmo resultado.
Linhas que se iniciam com os caracteres “//”, ou um bloco de texto, que se inicia com “/*” e
termina com “*/”, são considerados comentários e são ignorados.
14
A seguir explicaremos a finalidade de cada grupo funcional, que pode ser configurado através do “apt.conf”:
Grupos
O grupo “APT”
–
É utilizado para controlar as opções gerais para uso de todas as ferramentas do APT.
O grupo “Acquire”
–
É divisão funcional usada para configurar as rotinas de download de pacotes e manipuladores
de URI's utilizados pelas ferramentas do APT.
O grupo “Dir”
–
Definição de layout de diretórios. Usado para a configuração dos diretórios que serão utilizados pelo APT.
O grupo “Dselect”
–
Configurações que afetam o uso da ferramenta “dselect”, quando ela é utilizada em conjunto
com o APT.
O grupo “DPKG”
–
Configurações que afetam o uso do dpkg. As opções que fazem parte desta seção, alteram a
forma normal como o dpkg atua, quando invocado pelo APT.
O grupo “Debug”
–
Utilizado para configurar opções para depuração no uso das ferramentas do APT.
Cada um destes grupos funcionais possui uma gama própria de opções, que não discutiremos aqui, por ser muito vasta (cabe a vocês, caso Se você precisar saber qualquer detalhe sobre
as opções que podem ser utilizadas neste arquivo de configuração, estude a documentação oficial
do arquivo, através do comando:
# man apt.conf
Exemplos:
Exemplo 01: Configurando um serviço de proxy para ser utilizado pelo APT. Esta configuração possibilita buscar pacotes de programas na Internet através de um servidor proxy existente na
sua rede.
Acquire
15
{
http
{
Proxy “http://usuario:[email protected]:8080/”; };
};
Exemplo 02: Configurando a arquitetura e release (versão) padrão dos pacotes a serem utilizados pelo sistema.
APT {
Architecture "i386";
DefaultRelease “stable”;
};
Exemplo 03: Configurando o diretório de cache do APT.
Dir “/”
{
Cache "var/cache/apt/" {
Archives "archives/";
srcpkgcache "srcpkgcache.bin";
pkgcache "pkgcache.bin"; };
};
Um ótimo arquivo de exemplos de configuração do “apt.conf” pode ser encontrado em
“/usr/share/doc/apt/examples/configure-index.gz”.
U
se o comando # cat /etc/apt/apt.conf.d/* para ver todas as configurações do apt de
uma só vez.
ARQUIVO DE CONFIGURAÇÃO “PREFERENCES”
O arquivo “/etc/apt/preferences” controla a prioridade de versão de pacotes. É possível manter fontes stable, testing e unstable ao mesmo tempo. Caso tenha inserido no arquivo
“/etc/apt/sources.list” repositórios de versões diferentes (stable e testing por exemplo) é necessário criar o arquivo “preferences” para que possa na instalação selecionar qual versão terá prioridade e de qual versão você deseja instalar os pacotes.
16
M
uito cuidado quando estiver trabalhando com versões diferentes, uma má instalação de pacote pode gerar quebras de pacotes e até mesmo a paralisação do sistema. Isso acontece muito facilmente quando se usa um sistema personalizado, como o
Desktop Paraná.
Segue um exemplo para o arquivo “preferences”:
Package: * Pin: release a=stable PinPriority: 900
Package: *
Pin: release a=testing
PinPriority: 400
Neste exemplo para todos os repositórios stable, a prioridade será 900 e para testing 400,
ou seja, vale a prioridade mais alta, então o stable será a opção default. Sempre que utilizarmos o
comando “apt-get” com as opções “install”, “update”, “upgrade”, “source” e “dist-upgrade”, o pacote
será do stable.
Para instalar pacotes do testing devemos utilizar o comando:
# aptget t testing install [pacote] O
comando acima só funcionará SE, e somente SE, no sources.list, os repositórios
estiverem com a release definida como testing e stable. Não é aconselhável se utilizar estes valores, porque caso haja uma alteração de release, um administrador descui dado pode acabar instalando pacotes de versões novas em versões antigas. Utilizamos
esta nomenclatura nesta apostila para facilitar eventuais atualizações da mesma.
O mesmo procedimento se aplica as opções “update”, “upgrade”, “dist-upgrade” ou “source”.
Podemos definir que um pacote sempre venha da release testing. Para isso, dentro do arquivo “/etc/apt/preferences”, defina a prioridade específica de um pacote. Veja o exemplo abaixo:
Package: amule
Pin: release a=testing
PinPriority: 905
O pacote desejado vai ter prioridade maior que o de qualquer outro release, então o pacote
desejado será da release testing.
Resumindo: podemos, se tivermos conhecimento suficiente para resolver problemas de dependências desencontradas, conflitos, estrutura de diretórios e pacotes, e compilação de aplicativos, ter pacotes de várias releases em um único sistema. Algumas vezes, existirá a facilidade de
se usar o apt para instalação destes pacotes, tendo o arquivo preferences como um forte aliado
nesta tarefa. Podemos priorizar uma release em geral, e configurar exceções para pacotes específicos.
17
DPKG
O dpkg é considerado a base do Sistema de Gerenciamento de Pacotes do Debian e das
distribuições que dele derivam. O dpkg é capaz de instalar, remover e fornecer informações sobre
os pacotes .deb. É muito usado por usuários avançados da Debian e desenvolvedores para fins
de instalação, manutenção e construção de pacotes.
Ele também é utilizado como Back end por ferramentas como “apt-get” e “aptitude”, devido
aos fatos de ser muito bom na instalação de pacotes, porém falhar nas tarefas de ser capaz de
buscar pacotes em lugares remotos ou resolver conflitos complexos nas dependências dos pacotes. Assim, estes outros comandos resolvem estes problemas e, na hora de realizar a instalação
em si, chamam-no para o trabalho sujo.
Hoje em dia utilizamos o dpkg principalmente como ferramenta de obtenção de informações
sobre os pacotes instalados no sistema, na manipulação de pacotes (criação e extração) e na resolução de problemas com pacotes. Para instalação, utilizamos o apt, que, como já dito, chama o
dpkg para realizar a instalação. Os passos seguidos por ele são: (a) desempacotar os arquivos
debian; (b) executar o preinst; (c) alocação dos arquivos nos seus devidos lugares; (d) executar o
postinst.
O
s arquivos de configuração e os scripts de instalação ficam dentro do diretório
/var/lib/dpkg/info/NomeDoAplicativo. Os scripts utilizam a linguagem shell script, na
maioria das vezes. Dê uma onlhado nos arquivos que lá existem.
O dpkg é composto por uma série de ferramentas que desempenham funções especificas
em relação aos pacotes Debian. A seguir iremos fazer uma breve breve descrição do que as principais ferramentas fazem.
● dpkg - Desempenha a função em “senso estrito” do comando;
● dpkg-source - Empacota e desempacota os arquivos fontes de um .deb;
● dpkg-deb - Empacota e desempacota pacotes binários;
● dpkg-reconfigure - Permite que o usuário execute ajustes nos pacotes já instalados no
sistema. Também é conhecido como “reconfigurador de pacotes”. É uma das ferramentas mais
utilizadas do conjunto de aplicações do dpkg.
Utilizando o dpkg
O comando dpkg possui a seguinte sintaxe:
Sintaxe: dpkg <ações> <opções> <pacotes>
18
Ações
As principais ações são:
-i end<pacote> – Instala um pacote no sistema sem resolver dependências.
--unpack end<pacote> – Desempacota um arquivo .deb extraindo o conteúdo e montando
uma estrutura de diretórios e arquivos de acordo com o esqueleto que foi usado na sua construção. Perceba que não será descompactado em qualquer lugar, mas sim no lugar pré-definido. Se
o administrador verificar com o “dpkg -l” o status do arquivo verificará que o pacote possuirá a op ção U. Isto indica que o aplicativo foi somente descompactado, e não instalado da forma padrão.
-X end<pacote> <diretório> – Faz a mesma coisa que o comando anterior, porém, em vez
de extrair os arquivos nos seus devidos lugares, ele permite que o usuário escolha um novo destino. A diferença crucial está no fato de o --unpack realizar a criação dos arquivos a partir do barra
(/) e o -X iniciar a partir do diretório que você especificar, que será um “barra” falso. Você poderá
executar o aplicativo digitando o endereço completo do executável, ou colocando o binário dentro
do PATH do usuário que o irá executar.
--configure pacote – Irá realizar a configuração de todos os pacotes parcialmente instalados nos sistema (ou seja, que deram pau por algum motivo durante a instalação). Durante a instalação, algum erro pode vir a aparecer, fazendo com que o dpkg seja interrompido. Utilizando este
comando, normalmente os problemas são resolvidos, já que normalmente utilizamos o apt para
instalações (que sempre procura tomar cuidado com todos os aspectos da instalação para evitar
quase todos os problemas do mundo). Normalmente, os problemas são originados por algo não
relacionado aos scripts de instalação (como queda de luz, problema com permissões, tráfego da
rede, mal configuração dos repositórios, etc). Caso o problema seja causado pelos próprios
scripts, o administrador terá que editá-los (preinst e postinst).
-r <pacote> – Desinstala um pacote do sistema sem remover os arquivos de configuração
deste, se existirem.
-P <pacote> – Faz a remoção completa de um pacote do sistema, incluindo arquivos de dados, de configuração, etc.
-C – Auditoria de pacotes mal instalados. Procura por pacotes que foram instalados somente
parcialmente em seu sistema. O legal dele é que indica o que pode ser feito para que o problema
seja sanado.
--get-selections <padrão> – Procura na lista de aplicações instalados no sistema pela expressão fornecida através do argumento “padrão”, ou, no caso deste não ser definido, todos os
pacotes que já passaram pelo sistema. Os pacotes que estejam com o valor “install” indicam as
aplicações instaladas, enquanto os que possuírem valor “deinstall” os desinstalados.
19
--print-architecture – Imprime a arquitetura padrão utilizada pelos pacotes instalados no
sistema.
-l <pacotes> (ele)– Lista todos os pacotes instalados no sistema com suas respectivas informações, podendo ter status diferentes: estar instalado corretamente com o apt, ter sido apenas
desempacotado, ter tido sua instalação interrompida durante a instalação, etc. É muito utilizada
pelos administradores. Opcionalmente, você poderá especificar o nome de um ou mais pacotes
(separados por espaços) para verificar suas informações.
-s <pacote> – Lembre-se deste s como s de show. Exibe as informações sobre um determinado pacote, podendo este estar já instalado ou então ter sido instalado uma vez na vida. Estas
informações são retiradas do arquivo “/var/lib/dpkg/available”.
-I end<pacote> (i)– Exibe uma série de informações acerca de um pacote. Sempre, como
pode ser visto na sintaxe, devemos indicar o pacote com o endereço completo. Se o administrador
tentar utilizar apenas o nome do pacote, o erro “Arquivo ou diretório não encontrado” será apresentado na tela. As informações apresentadas são parecidas com as do parâmetro “-s”, porém o
pacote não precisa ter sido instalado nunca, e temos uma informação adicional: o tamanho do arquivo de controle e uma descrição de o quê o compõe e quanto ocupa de espaço (conffiles, control, md5sums, postinst, preinst, posrm e prerm).
-S <arquivo> – Permite descobrir qual é o pacote que possui algum arquivo. Ele é muito interessante, já que o administrador pode utilizar um comando em um computador que não existe
em outro. Para saber o nome do pacote, basta ir até o computador que o possui e verificar, com
esta opção, aquele pacote que o possui. Como já foi dito, ele pode ser usado para qualquer arquivo, não somente um binário (ex: sources.list).
O resultado será mostrado da seguinte forma:
pacote: linha que contém o arquivo (diretórios também é um arquivo)
-L <pacote> – Mostra todos os passos executados pelo dpkg na instalação de um pacote na
fase de alocação dos arquivos dentro de seus respectivos diretórios. Veja que o arquivo de configuração fabiqueta.conf do pacote fabiqueta (pacote fictício) para ser alocado dentro do diretório
“/etc/fabiqueta”, precisa criar o diretório fabiqueta. Então a ordem será:
/
/etc
/etc/fabiqueta
/etc/fabiqueta/fabiqueta.conf
Desta forma, o administrador consegue saber exatamente onde está cada um dos diretórios
e arquivos criados originalmente pelo pacote.
20
C
aso um pacote venha a ser removido, este comando terá sua fonte atualizada e
mostrará apenas aqueles arquivos e diretórios que ainda existem. Para você verificar o seu funcionamento, instale o pacote tuxpaint, utilize este parâmetro, remova com
o dpkg -r e então verifique novamente a saída do comando com o parâmetro “-L”. Você
observará que somente os arquivos de configuração permanecem no computador.
-c end<pacote> – A saída é exatamente a mesma que a do -L1, com a diferença que o -c
verifica todos os diretórios e arquivos que serão criados na instalação do pacote, diferente do -L
que verifica quais arquivos e diretórios existem realmente, ou seja, de aplicações instaladas. Ele é
interessante para que o administrador verifique, caso tenha alguma dúvida, se a instalação irá criar algum diretório ou arquivo no lugar de um outro já existente.
O
u seja: -L para aplicações instaladas e -c para pacotes .deb de aplicações não necessariamente instaladas.
Opções
As opções do comando dpkg tanto podem ser especificadas através da linha de comandos,
como através do arquivo de configuração do dpkg, o “/etc/dpkg/dpkg.cfg”. As principais opções
são:
-B – Quando um pacote é desinstalado do sistema, pode ocorrer que outros pacotes ainda
instalados dependam do que foi removido. Esta opção faz com que estes pacotes também sejam
removidos do sistema automaticamente.
--no-act – Faz uma simulação de acordo com as ações envolvidas. Por exemplo, você pode
simular a instalação ou remoção de um pacote para verificar se algum erro será gerado pelo sistema de gerenciamento de pacotes. Tenha certeza que você especificou esta opção antes da citação de qualquer ação na linha de comando, caso contrário, esta opção não terá efeito e a ação
será desempenhada de fato.
-R – Faz com que o dpkg opere no modo recursivo.
--log=arquivo – Permite especificar um arquivo onde o dpkg vai realizar os registros das
suas operações. Por padrão isto é feito em “/var/log/dpkg.log”.
Exemplos de ocorrências mais comuns no uso do dpkg
Vamos exemplificar agora tudo que foi visto. Verifique se seu apt está configurado corretamente. Vamos começar fazendo download de um pacote dos repositórios utilizando o dpkg.
# aptget clean
1 Isso quando o pacote está instalado corretamente, da forma original, já que o -L verifica até pacotes que foram
removidos sem a purificação de arquivos de configuração.
21
# aptget update
# aptget install d sl
C
aso o aplicativo sl já esteja instalado, será necessário reinstalar a aplicação utilizando o parâmetro “-d” da mesma forma como mostrado acima.
O pacote foi descarregado dentro do diretório “/var/cache/apt/archives”. Entre nele para que
nossas atividades tornem-se mais fáceis. Para verificar se a aplicação está funcionando, digite “sl”
e pressione <Enter>. Um erro aparecerá. Isso quer dizer que o pacote .deb foi descarregado no
seu computador, porém não foi instalado (quem fez isso foi o parâmetro “-d”, que indica download
only). Verifique o nome exato do pacote e instale-o.
# ls l sl*
rwrr 1 root root 25124 20071202 17:47 sl_3.0315_i386.deb # dpkg i sl_3.0315_i386.deb Selecionando pacote previamente não selecionado sl. (Lendo banco de dados ... 95880 arquivos e diretórios atualmente instalados). Desempacotando sl (de sl_3.0315_i386.deb) ... Configurando sl (3.0315) ... Processando gatilhos para mandb ...
# sl
O trem tá funcionando. Então agora podemos realizar novos testes. Apesar do aplicativo estar funcionando, será que o sistema sabe que ele está lá?
# dpkg getselections sl
sl install
Um aplicativo tão pequeno, de nada, sem utilidade nenhuma como este, provavelmente não
tem quase nenhum arquivo criado no nosso computador, certo? Verifique:
# dpkg L sl
Parece que o criador do sl tava meio que desempregado e sem ocupação, no mínimo. Tem
muita coisa, e, com o comando anterior, pudemos verificar o que foi criado pelo arquivo de controle do pacote sl. Conseguimos descobrir que até mesmo quem digitar errado o ls esquecendo o
<Caps Lock> ligado vai ser zoado (veja que possui um binário dentro do “/usr/bin” chamado LS).
Chega de sl, vamos removê-lo do sistema. Quando instalamos, o pacote .deb teve que ser
apresentado ao dpkg, mas agora que ele já está no sistema, como podemos lembrar, existem listas que o registraram e agora só precisamos indicar o nome da aplicação, e não do pacote.
# dpkg r sl
22
(Lendo banco de dados ... 94224 arquivos e diretórios atualmente instalados). Removendo sl ... Processando gatilhos para mandb ... Removido! E agora vamos verificar novamente se o sistema está realmente alerta:
# dpkg getselections sl sl purge Tá lá. Cadê o deinstall? Não tá lá, porque o deinstall só aparece quando temos um aplicativo desinstalado que possui seus arquivos de configuração ainda presentes na estrutura de diretórios do sistema. Você deve estar se perguntando, “mas eu não usei o -P de purge”. Realmente.
Acontece que o purge aparece quando não existem os arquivos de configuração e a aplicação
está desinstalada. No caso do sl, ele é um aplicativo muito simples, por isso, não possui arquivo
de configuração. Ele sempre passa do status install para o status purge. Se nós tivéssemos instalado um pacote com arquivos de configuração, utilizando o “-r” para removê-los, os arquivos serão
mantidos, enquanto com o “-P” os arquivos de configuração serão removidos.
Como já vimos, foi muito fácil instalar o pacote sl. A instalação possui vários processos realizados, definidos pelos arquivos de controle, preinst e posinst. Se quisermos realizar a criação de
todos os diretórios da estrutura que o aplicativo irá assumir, e criar todos os arquivos necessários
para o seu pleno funcionamento, podemos simplesmente extraí-lo. Iremos realizar essas atividades de duas formas diferentes. A primeira será realizar a extração nos lugares definidos pelo desenvolvedor, e a segunda a extração será realizada a partir do diretórios especificado pelo administrador.
Primeiro caso:
# sl
su: /usr/bin/sl: Arquivo ou diretório não encontrado # dpkg unpack sl_3.0315_i386.deb Selecionando pacote previamente não selecionado sl. (Lendo banco de dados ... 95880 arquivos e diretórios atualmente instalados). Desempacotando sl (de sl_3.0315_i386.deb) ... Processando gatilhos para mandb ... #
# sl
Como esse pacote não exige que o administrador configure e execute procedimentos mais
complexos, o simples fato de terem sido criados diretórios definidos pelo desenvolvedor já é o suficiente para que a aplicação funcione. Utilizando o dpkg -L você poderá verificar que todos os arquivos do pacote foram alocados nos seus respectivos lugares. Podemos inferir, então, que o “-unpack” é a etapa de criação de diretórios e alocação de arquivos já falada anteriormente. Mas e
23
se quiser instalar o pacote em um lugar diferente do especificado pelo desenvolvedor?
# mkdir /Saci/Teste ; dpkg -x sl_3.03-15_i386.deb /Saci/Teste
O comando acima criou o diretório /Saci/Teste e, logo após, foi desempacotado o conteúdo
do sl..... com toda sua estrutura a partir do diretório /Saci/Teste. Entre no diretório e verifique com
o comando “tree” como tudo está.
24
COMPILANDO PROGRAMAS A PARTIR DO CÓDIGO FONTE
Embora, atualmente, a maioria dos programas para o GNU/Debian estejam disponíveis para
instalação por meio de pacotes, ainda assim, em alguns casos, é preciso compilar programas a
partir de seu código fonte. Mas o que é compilar um programa? É a ação de criar um arquivo ins talador a partir do código fonte de uma aplicação adaptando-o ao sistema ao qual será instalado.
Isso é necessário, porque algumas vezes uma aplicação possui versão criada para uma distribuição e não para outra. Podemos baixar o código fonte da aplicação e adaptá-la à nova versão.
Adaptar é indicar ao executável instalador onde ficam alguns diretórios do sistema (como o
/var/log para arquivos de logs e o /etc para arquivos de configuração, no Debian) que serão necessários durante a instalação do aplicativo. Também é possível, durante a compilação do programa, fazer configurações ativando módulos que por padrão não estão. Ou seja, compilar um pacote
significa adaptá-lo a um sistema operacional para qual não foi criado e permitir configurações na
instalação que visam otimizar o desempenho do aplicativo que é instalado.
De modo geral, códigos fonte são distribuídos através de arquivos compactados. A grande
maioria destes arquivos possui uma estrutura de diretórios, os arquivos fonte em si, um arquivo de
configuração chamado “Makefile”, documentação e outros arquivos encapsulados em um arquivo
no formato “tar”, com compressão de dados, usando gzip (“.tar.gz” ou “.tgz”), ou bzip2 (“.bz2” ou
“.tbz2”).
Q
uando começarmos a usar o tar, para extrair arquivos compactados com o gzip utilizamos o parâmetro z, enquanto que para extrair arquivos compactados com o bz2
utilizaremos o parâmetro j. Uma forma de lembrar qual utilizar é BeiJando o GiZ.
Para iniciar a compilação de um código fonte, a primeira coisa a se fazer é obter o código
para ser compilado. Após o arquivo que contém o código fonte estar disponível localmente, você
deverá extrair o conteúdo para um diretório adequado a compilação (ex.: /comp-louco). Os arquivos-fontes são, no padrão Debian, agrupados e compactados em arquivos tarball. Para realizar
nossos testes iremos utilizar um arquivo fonte que possui o código do aplicativo TAL. Para extrair
o seu conteúdo, use um dos comando abaixo:
tar xvzf nome_do_arquivo.tar.gz
ou tar xvjf nome_do_arquivo.tar.bz2
Após a extração do conteúdo do arquivo compactado, é necessário entrar no diretório que
foi criado durante a extração dos arquivos utilizando o comando “cd”. O programa mais utilizado,
para compilar códigos fonte no GNU/Linux é o “gcc”, um compilador C/C++ livre. De maneira geral, alguns pacotes GNU são necessários para compilar um programa de código livre. Os mais co-
25
muns na distribuição Debian, são os pacotes: “make”, “autoconf”, “gcc”, “g++” e “libc6-dev”.
A seguir listaremos os procedimentos gerais para configuração/compilação de códigos fontes no GNU/Debian, estes procedimentos podem variar um pouco dependendo do código que se
está compilando mais informações sobre a compilação do código, você encontrara no arquivo
“README.txt” descompactado junto com o código fonte.
•
Executar o arquivo “configure” – Este arquivo é um script shell que examina o siste-
ma para verificar se diversas dependências necessárias para compilar o projeto serão satisfeitas. Ele deve ser executado digitando-se “./configure” dentro do diretório que contém o
código-fonte do programa a ser compilado. Esse script, também pode conter parâmetros
que podem ser passados na linha de execução para configuração de opções especificas,
para consultar a lista de parâmetros disponíveis, tente executar o script “./configure --help”.
Se o script “configure” não encontrar alguma das dependências necessárias para compilação do programa, um erro é gerado e a execução é finalizada automaticamente, gerando
uma mensagem semelhante à abaixo:
checking for SDL version >= 1.2.0... no
configure: error: *** SDL version 1.2.0 not found!
Nesse caso, nos falta a biblioteca de desenvolvimento (cabeçalhos) “SDL” versão 1.2.0 ou
mais recente. Para resolver este problema, é necessário instalar o pacote “libsdl1.2-dev” para resolver essa dependência. A maioria das bibliotecas necessárias para a compilação de programas
no GNU/Debian têm o prefixo “lib” e o sufixo “-dev”, como por exemplo, “libc6-dev”, “libsdl1.2-dev”,
etc. Após resolvidas todas as dependências.
•
Executar o comado make – O comando “make” utiliza as configurações que foram
criadas pelo script “configure” para compilar múltiplos arquivos de código fonte de um projeto. Utiliza também um arquivo de descrição (chamado “makefile” ou “Makefile”) que está
presente no diretório onde o código fonte foi extraído. Seu conteúdo é composto de regras
que definem as dependências entre arquivos fonte e os comandos necessários para a
compilação. A partir deste arquivo, ele executa sequências de comandos que são interpretados pelo shell para realizar a compilação de maneira correta.
•
Em seguida não havendo erros na execução do comando anterior executar o coman-
do make install – É o comando utilizado para compilar e em seguida executar o instalador
do programa que acabamos de compilar. Alguns programas não possuem essa facilidade,
nestes casos, o administrador terá também o trabalho manual de instalar o programa compilado corretamente, em geral, realizando atividades como copiar arquivos executáveis
para diretórios como “/usr”, e os arquivos de configuração para “/etc”, etc.
26
GERENCIANDO DISCOS E PARTIÇÕES
Neste capítulo, mostraremos como listar e obter informações a respeito das partições e discos existentes no sistema, além de aprendermos a criar, remover e formatar partições.
O QUE SÃO PARTIÇÕES
Partições são divisões feitas em um disco de armazenamento para delimitar um determinado espaço deste para instalação de um sistema de arquivos. Existem três tipos de partições: primárias, estendidas e lógicas. Os propósitos fundamentais da criação de partições são 3: (a) maior
segurança através da divisão de dados de acordo com a natureza de seus dados (sistema, usuário, de inicialização); (b) divisão de acordo com o tamanho dos dados, afim de melhorar o desempenho através de sistemas de arquivos específicos; (c) ter mais de um sistema operacional no
mesmo disco.
Não existe nenhuma diferença top-down entre partições primária e lógica. A diferença real
entre elas é o local onde são alocadas as informações acerca de uma partição. Isso foi explicado
detalhadamente na apostila de Debian Básico, sendo interessante você tirar as teias de aranha
dela e dar uma relembrada. Basicamente, o detalhamento (primeiro e último setor, número total de
blocos, etc) de uma partição primária fica dentro do primeiro setor do disco rígido (MBR -Master
Boot Record), enquanto as lógicas ficam fora da MBR. Podemos chamar este detalhamento, ou
definição de uma partição, como cabeçalho da mesma. Podemos ter 4 cabeçalhos dentro da
MBR. Estes cabeçalhos podem ser todos primários ou então de 0 a 3 primários e um estendido. A
partição estendida só indica onde está, dentro do disco rígido e fora da MBR, o cabeçalho da primeira partição lógica. Ou seja, para que tenhamos pelo menos uma partição lógica, é necessário
se ter uma partição estendida. Como esta trata apenas de um cabeçalho de ligação, dizemos que
ele define uma partição não utilizável. Para saber quantas partições utilizáveis temos em um disco, precisamos: (a) quando existe partições lógicas, subtrair do número da última partição lógica o
resultado de 4 menos o número de partições primárias; (b) quando não existe partições lógicas,
verificar o número de partições primárias, que são todas utilizáveis.
Ex: Se temos 2 partições primárias e a última partição lógica é a partição 12, então temos:
12−4−2 = 10 partições utilizáveis
Após criada e formatada, a partição passa a ser reconhecida pelo sistema operacional como
um nó de dispositivo representado por um arquivo no diretório “/dev”. É como se uma partição fosse um dispositivo diferente, sendo que, na realidade, são apenas divisões lógicas do disco, estando todas dentro de apenas um dispositivo físico. Este arquivo receberá automaticamente um
nome
e
através
deste
é
possível
identificarmos
várias
informações
referentes
ao
hardware de armazenamento.
27
A identificação de discos rígidos no Linux é feita da seguinte forma:
/dev/hda1
|
| ||
|
| | |__ Indica o número da partição do HD.
|
| |___ Letra que indica o dispositivo (a=primeiro, b=segundo...).
|
|_____ Sigla que indica o tipo de dispositivo (hd=ide, sd=scsi ou sata).
|_________ Diretório onde são armazenados dispositivos do sistema.
T
udo isso foi visto na apostila de Debian Básico, por isso, abordaremos de uma forma
superficial o assunto, somente para que você possa recordar e tornar vivo tudo que
já sabe.
OBTENDO INFORMAÇÕES SOBRE AS PARTIÇÕES
Sempre que for realizar qualquer atividade referente a partições, será muito interessante
que o administrador saiba usar o comando abaixo, que trará as primeiras informações que possivelmente precisaremos para começar a agir e planejar suas tarefas:
# fdisk l Disk /dev/sda: 250.0 GB, 250059350016 bytes 255 heads, 63 sectors/track, 30401 cylinders Units = cylinders of 16065 * 512 = 8225280 bytes Disk identifier: 0x9ebef679 Device
Boot
/dev/sda1
/dev/sda2
/dev/sda3
/dev/sda4
Start
1
17
1841
1963
End
16
1840
1962
30401
Blocks
Id System 128488+
83 Linux 14651280
83 Linux 97996582 Linux swap / Solaris 228436267+ 83 Linux Disk /dev/sdb: 4005 MB, 4005560320 bytes 16 heads, 32 sectors/track, 15280 cylinders Units = cylinders of 512 * 512 = 262144 bytes Disk identifier: 0xef6cfd35 Device
Boot
/dev/sdb1
28
Start End
Blocks
16
15280 3907648
Id System b W95 FAT32 Apostila Debian Intermediário - Desktop Parana
Deduza por si só!
1. Número de dispositivos físicos conectados:
2. Quantidade de partições em cada dispositivo:
3. Capacidade máxima de armazenamento do primeiro dispositivo:
4. Capacidade máxima de armazenamento do segundo dispositivo:
5. Quantidade de cilindros em cada dispositivo:
6. Quantidade de cabeças em cada dispositivo:
7. Arquivo que representa com certeza uma partição de área de troca:
8. A coluna Id identifica a partição ou o tipo de sistema de arquivos?
9. O sdb1 possui um sistema operacional instalado?
10. Qual é a causa de dump de backtrace e kernel panic num servidor proxy com squid no
modo slabe do kernel?
A questão 10 é apenas uma piada de mau gosto. É para você sentir que ainda falta chão,
então continue estudando e crie uma boa base, para que depois você possa brincar com seu conhecimento durante a solução de problemas.
Vale ressaltar que caso seu sistema possua discos utilizando técnicas de RAID via hardware, quando o comando for executado, os discos serão mostrados de acordo com as configurações
RAID que estiverem em vigor no seu sistema. Por exemplo, numa configuração em RAID 1
(mirroring), apesar de existirem fisicamente dois discos na máquina, apenas um será mostrado.
R
AID (Redundant Array of Independent Disks) é um sistema de linearização de discos. É um sistema que tem dois objetivos que são atingidos de várias formas diferentes. Os objetivos são acelerar o armazenamento e carregamento de dados, e aumentar a segurança desse processo, com métodos de espalhamento de dados em discos diferentes. No link a seguir, existe uma animação que mostra o funcionamento de todos
os tipos de RAID: “http://www.acnc.com/raid.html”.
Para sabermos quais outras opções temos para utilização do “fdisk”, basta digitarmos somente o comando:
# fdisk /dev/sda
ou
# fdisk /dev/hda
Serão listadas algumas informações sobre o disco e também será aberta a linha de comado
do “fdisk”, onde digitando a opção “m” será exibida uma lista com as opções disponíveis para utilização na linha de comando do “fdisk”.
29
Não iremos ver nesta apostila o funcionamento de recursos do fdisk senão a verificação das
informações com o parâmetro “-l”. Para realizar modificações nos sistemas de arquivos e manipulação de partições, usaremos o cfdisk. Podemos obter maiores informações sobre as opções do
comando “fdisk” através do seu manual (man fdisk).
PARTICIONANDO DISCO COM CFDISK
Para iniciar o particionador como root digite “cfdisk” seguido do nome do dispositivo a ser
particionado, por exemplo “cfdisk /dev/hda”. Lembre-se, “/dev/hdX” é utilizado para HD's IDE, já
“/dev/sdX” é usado para discos SCSI, SATA e Pendrives.
Para navegarmos nas opções do “cfdisk”, devemos utilizar as setas para cima e para baixo
para navegar entre as partições e as setas para esquerda e para direita para selecionar as opções
do menu inferior.
Figura 2: Tela principal do cfdisk
Para criar uma nova partição, deve-se selecionar o espaço livre do dispositivo e em seguida
selecionar a opção “Nova”.
Figura 3: Cfdisk - criando uma nova partição
30
Será, então, necessário definir se a partição será primária ou lógica. Utilizando as setas, selecione a opção desejada e pressione o <Enter> do teclado.
Figura 4: Cfdisk - escolhendo o tipo de partição (primária ou
lógica)
A
s partições estendidas não são definidas manualmente. Automaticamente, ao definir
a primeira partição como Lógica, a estendida é criada e anula-se a possibilidade de
se criar uma nova partição primária, mesmo que exista menos de 3 partições desta.
O próximo passo é definir o tamanho desejado para a partição em criação. Sempre devemos definir o tamanho em megabytes.
Figura 5: Cfdisk - definindo o tamanho da partição
31
Em seguida, devemos selecionar na listagem um dos tipos de partições que desejamos criar
(partição linux, ntfs, fat, etc...). Para selecionar digite o número correspondente sobre o já existente e pressione a tecla <Enter>.
Figura 6: Cfdisk - Selecionando tipo de partição
Para concluir a criação da partição, vá até a opção <Gravar>, pressione <Enter>, digite “yes”
por extenso (para evitar gravações de alterações por engano) e pressione <Enter> novamente.
Para sair do cfdisk, use a opção “Quit” do menu inicial.
Excluindo uma partição
Para excluir uma partição, selecione-a e então vá em “Excluir”. Este procedimento excluirá a
partição sem solicitar nenhuma confirmação antes de removê-lo. Após a exclusão, o espaço anteriormente ocupado pela partição passará a ser espaço livre podendo ser reutilizado.
Salvando as alterações
Devemos tomar muito cuidado sempre antes de selecionar e confirmar a opção “gravar”,
pois assim confirmarmos esta operação todas as alterações feitas na tabela de partição serão gravadas não tendo mais como serem desfeitas. Sempre que fizermos qualquer alteração indesejada
na tabela de partição basta sair da aplicação (“cfdisk”) sem gravar as alterações.
SISTEMA DE ARQUIVOS
Um sistema de arquivos é um conjunto de estruturas lógicas e de rotinas, que permitem ao
sistema operacional controlar o acesso ao disco rígido. Existem diversos sistemas de arquivos diferentes, que vão desde sistemas simples como o FAT16, até sistemas como o NTFS, XFS e ReiserFS, que incorporam recursos muito mais avançados.
32
O sistema de arquivos é criado durante o processo de formatação da partição, após isso
toda a estrutura necessária para leitura/gravação de arquivos e diretórios já estão prontas para serem utilizadas pelo sistema operacional.
CRIANDO SISTEMA DE ARQUIVOS
Podemos também criar uma partição sem definir o tipo dela, entretanto, para que uma partição fique funcional, temos obrigatoriamente que criar um sistema de arquivos em seu espaço.
Para criar um sistema de arquivos nesse tipo de partição basta utilizar o utilitário “mkfs” especificando o tipo de sistema de arquivos que desejamos utilizar na partição. Abaixo um exemplo de
uso deste utilitário:
mkfs t xfs /dev/hda1
No exemplo acima, criamos um sistema de arquivos do tipo “xfs” na partição “/dev/hda1”.
Essa é a maneira mais simples de se criar um sistema de arquivos numa partição criada sem um
tipo definido. Também podemos usar as extensões do utilitário mkfs, para realizar a criação de sistemas de arquivos específicos. No exemplo abaixo faremos exatamente a mesma operação que a
do exemplo anterior:
mkfs.xfs /dev/hda1
33
GERENCIADOR DE PARTIDA – GRUB
O gerenciador de partida é o responsável por carregar o sistema operacional durante o processo de inicialização além de, nos casos onde houver mais de um sistema operacional, permitir
que seja feita a escolha de qual sistema operacional deverá ser carregado. Este programa geralmente fica gravado ou numa no setor de boot de uma partição ativa ou na Master Boot Record
(MBR) do disco.
O GRUB (Grand Unified Boot Loader) é o gerenciador de partida padrão do Debian. Ele é
um dos mais poderosos e funcionais gerenciadores de partida, é capaz de inicializar vários sistemas operacionais como Windows (9x, ME, NT, 2000, XP e Vista), Dos, Linux, GNU Hurd, *BSD,
OS/2 etc. Podemos destacar também o suporte aos sistemas de arquivos EXT2, EXT3 e ReiserFS, FAT16 e FAT32 (Win 9x/ME), FFS (Fast File System usado no *BSD), minix (MINIX OS)
etc.
A
o instalarmos uma máquina com dual boot, com os sistemas operacionais Linux e
Windows, devemos sempre instalar primeiro o sistema operacional Windows. Pois o
mesmo, durante sua instalação, grava suas informações de inicialização na MBR do disco sobrescrevendo todas as configurações nela existentes, consequentemente apagando o GRUB e suas configurações fazendo que o Linux, mesmo instalado, seja ignorado
e iniciado diretamente o sistema operacional Windows.
O GRUB utiliza o padrão Multiboot o que o torna capaz de carregar diversas imagens de inicialização (uma por vez) e módulos. Além de permitir buscar imagens do Kernel pela rede, por cabos seriais, suporta discos rígidos IDE, SATA e SCSI, informar a quantidade total de memória
RAM ao sistema, tem interface voltada para linha de comandos ou menus de escolha, além de suportar sistemas sem discos e terminais remotos.
Os principais arquivos utilizados pelo GRUB para inicialização do sistema encontram-se
dentro dos diretórios “/boot” e “/boot/grub”. Dentro do diretório “/boot” encontramos os arquivos de
kernel que são os responsáveis pelo carregamento do mesmo na memória. Dentro do diretório
“/boot/grub”, encontramos os arquivos dos quais são carregados os parâmetros com as configurações para inicialização do sistema, dentre esses arquivos destacamos o “menu.lst” que é o arquivo que nos possibilita customizar as configurações do GRUB.
TRABALHANDO COM DISCOS E PARTIÇÕES
O GRUB trabalha com uma notação para apontar discos e partições, diferente da que estamos acostumados a ver em sistemas operacionais Linux. Para o GRUB independente do tipo de
disco (IDE, SATA ou SCSI) ele sempre será representado pela sigla “hd”. O primeiro disco será
representado pelo número “0” o segundo pelo número “1” e assim por diante. As partições são
representadas da mesma forma que os discos a primeira partição criada será representada pelo
34
número “0” a segunda pelo número “1” e assim por diante. Abaixo segue tabela comparativa,
através dela fica mais fácil visualizar as diferenças acima descritas:
Disco IDE
Dispositivo
no Linux
Disco SCSI ou SATA
Dispositivo
no GRUB
Dispositivo
no Linux
Dispositivo
no GRUB
/dev/hda
(hd0)
/dev/sda
(hd0)
# Disco SCSI ID 0
/dev/hda1
(hd0,0)
/dev/sda1
(hd0,0)
# Disco SCSI ID 0, partição 1
/dev/hda2
(hd0,1)
/dev/sda2
(hd0,1)
/dev/hdb
(hd1)
/dev/sdb
(hd1)
# Disco SCSI ID 1
/dev/hdb1
(hd1,0)
/dev/sdb1
(hd1,0)
/dev/hdb2
(hd1,1)
/dev/sdb2
(hd1,1)
Disquete
Dispositivo
no Linux
/dev/fd0
Dispositivo
no GRUB
(fd0)
INSTALAÇÃO DO GRUB
Após instalado o GRUB dificilmente precisaremos reinstalá-lo. As alterações ou adições de
novos sistemas a serem carregados como opção para inicialização são feitas através de alterações no arquivo de configuração “menu.lst”, com o comando:
# vim /boot/grub/menu.lst
Normalmente, durante a instalação do GNU/Debian você será questionado se deseja ou não
instalar o GRUB, se selecionada a opção de sua instalação automaticamente todos os sistemas
operacionais instalados na máquina serão listados e configurados pelo GRUB para estarem disponíveis como opções de sistemas que podem ser inicializados.
Algumas situações podem vir a apagar o GRUB da MBR do disco, por exemplo, como foi
descrito anteriormente, uma máquina com dual-boot onde a instalação do sistema operacional
Windows foi efetuada posterior a instalação do Linux. Nesses casos para podermos restaurar o
GRUB e voltarmos a utilizar o sistema operacional Linux instalado, podemos, dentre as várias alternativas para restauração do grub, executar o comando abaixo por exemplo:
# grubinstall /dev/hda
Este comando grava o GRUB no MBR do primeiro disco rígido IDE do sistema e cria o diretório “/boot/grub”, onde estarão os arquivos necessários para o seu funcionamento. É interessante
também, executar o comando:
# updategrub
Este comando atualiza dinamicamente a lista de sistemas que podem ser carregados durante a inicialização da máquina, e os adiciona ao arquivo “menu.lst” automaticamente, conforme
a instalação corrente.
35
N
o entanto, para podermos executar os comando apresentados anteriormente para
instalar o grub na MBR e para atualizar o arquivo “menu.lst”, precisamos primeiro
iniciar a máquina a partir de um CD, pendrive, ou algum outro dispositivo que possua
um sistema operacional que carregue um kernel que disponibilize um shell linux, montar
a partição com o diretório “/boot”, montar as partições “/proc” e “/dev”, transformarmos a
partição montada no nosso “/” e só então podemos utilizar aqueles comandos para restaurar o grub (instalá-lo na MBR e atualizá-lo)2.
Na linha de comando usar os seguintes comandos:
(para montar a partição com diretório /boot)
# mount t ext3 /dev/sda2* /mnt (para reconhecer o HD é necessário montar o /dev e o /proc)
# mount o bind /dev /mnt/dev # mount o bind /proc /mnt/proc (para que a partição montada vire o /)
# chroot /mnt /bin/bash (para instalar o GRUB)
# grubinstall (para atualizar o GRUB para que apareça a instalação do Windows)
# updategrub
* Neste momento deve ser indicada a partição que contenha o diretório “/boot”
CUSTOMIZANDO O ARQUIVO MENU.LST
No arquivo “menu.lst” podemos fazer dois tipos de configurações: as configurações globais
que afetam o funcionamento do GRUB de forma mais genérica e as configurações especificas que
afetaram somente as imagens a serem inicializadas. Abaixo mostraremos um exemplo do arquivo
“menu.lst” configurado onde serão inseridos comentários explicando cada um dos parâmetros
configurados.
# menu.lst See: grub(8), info grub, updategrub(8)
# grubinstall(8), grubfloppy(8),
# grubmd5crypt, /usr/share/doc/grub
# and /usr/share/doc/grubdoc/.
###################################################################
## default num
# A opção default serve para que possamos escolher qual kernel (sistema) será iniciado. Para isso
basta passar como parâmetro o número correspondente ao sistema a ser iniciado. A contagem para
representação dos sistemas é feita através da ordem de aparição do parâmetro “title” neste arqui vo, deforma que a primeira ocorrência corresponderá ao número 0 a segunda ao número 1 e assim
2 Uma boa opção de cd bootavel que podemos utilizar para isso é o “SYSTEMRESCUECD”
36
por diante.
#É possível também especificar 'saved' como argumento da opção default. Nesse caso será consi derado como opção padrão aquela que apresentar junto às suas configurações a opção 'savedde fault'.
Default
0
###################################################################
## timeout sec
# A opção timeout permite a definição o tempo, em segundos, que o menu do GRUB ficará disponível para escolha do sistema a ser inicia
do antes de iniciar automaticamente a opção definida como padrão.
Timeout
5
###################################################################
## Pretty colours
# A opção color permite que façamos customizações das cores no menu do GRUB, através do co mando 'color a/b c/d'. Onde 'a' representa à cor das opções, o 'b' representa a cor do fundo, o 'c' re presenta as letras sob o cursor e o 'd' representa acor do cursor. As cores que podem ser aplicadas
são: black (preto), blue (azul), green (verde), cyan (ciano), red (vermelho), magenta (púrpura),
brown (marron) e ligth-gray (cinza claro). Ainda são é possível aplicar as cores das fontes ('a' e 'c') as
cores: dark-gray (cinza-escuro), ligth-blue (azul-claro), ligth-green (verde-claro), ligth-cyan (cianoclaro), ligth-red (vermelho-claro), ligth-magenta (púrpura-clara), yellow (amarelo) e white (branco).
color cyan/blue white/blue
###################################################################
## password ['md5'] passwd
# A opção password permite a definição de uma senha que deverá ser informada para que seja possível a edição das opções de inicialização dos sistemas assim como a utilização da linha de comando
do GRUB através do menu para escolha do sistema a ser iniciado.
# É possível definirmos esta senha de duas formas sem criptografia ou com criptografia. A desvan tagem de utilizarmos a senha sem estar criptografada é que qualquer usuário com permissão de leitura no arquivo menu.lst poderá descobrir qual a senha setada.
Para definirmos uma senha não criptografada basta inserimos a senha desejada logo após a opção
password, como mostra o exemplo abaixo.
#password senha
#Para definirmos uma senha criptografada basta inserirmos após a opção password o parâmetro '-md5' seguido da senha já criptografada, como mostra o exemplo abaixo:
# password md5 $1$gLhU0/$aW78kHK1QfV3P2b2znUoe/3
###################################################################
3 Para criptografarmos uma senha para utilização no GRUB basta entrarmos na linha de comando do GRUB e
digitarmos o comando “md5crypt” digitarmos a senha desejada e copiarmos o resultado criptografado apresentado
para o arquivo de configuração (menu.lst).
37
##fallback num
# Com esta opção podemos definir um segunda opção do menu do GRUB para ser carregada caso a
inicialização do kernel definido como default falhar. Para o correto funcionamento deste parâmetro
o mesmo deve ser utilizado junto com o parâmetro 'hidenmenu'.
fallback 1
###################################################################
##hidenmenu=opção
# Este parâmetro oculta a exibição do menu do GRUB de forma que é exibida apenas uma mensa gem com opção para visualização do menu de cordo com o tempo definido no parâmetro 'timeout'
e esgotado o tempo é automaticamente iniciada a opção default.
hidenmenu=true
###################################################################
# Put static boot stanzas before and/or after AUTOMAGIC KERNEL LIST
## Abaixo encontraremos a seção de opções default, esta seção nunca deve ser descomentada. Os
parâmetros passados nesta seção serão utilizados na configuração do GRUB quando for executado
o comando 'update-grub' ou quando for instalada alguma atualização de segurança do GRUB.
## ## Start Default Options ##
## default kernel options
## default kernel options for automagic boot options
## If you want special options for specific kernels use kopt_x_y_z
## where x.y.z is kernel version. Minor versions can be omitted.
## e.g. kopt=root=/dev/hda1 ro
## kopt_2_6_8=root=/dev/hdc1 ro
## kopt_2_6_8_2_686=root=/dev/hdc2 ro
# kopt=root=/dev/hda4 ro vga=791 quiet splash
## default grub root device
## e.g. groot=(hd0,0)
# groot=(hd0,1)
## should updategrub create alternative automagic boot options
## e.g. alternative=true
## alternative=false
# alternative=true
## should updategrub lock alternative automagic boot options
## e.g. lockalternative=true lockalternative=false
## lockalternative=false additional options to use with the default
## boot option, but not with the alternatives e.g
##defoptions=vga=791 resume=/dev/hda5
# defoptions=
## should updategrub lock old automagic boot options
## e.g. lockold=false
## lockold=true
# lockold=false
38
## Xen hypervisor options to use with the default Xen boot option
# xenhopt=
## Xen Linux kernel options to use with the default Xen boot option
# xenkopt=console=tty0
## altoption boot targets option
## multiple altoptions lines are allowed
## e.g. altoptions=(extra menu suffix) extra boot options
## altoptions=(singleuser) single
# altoptions=(singleuser mode) single
## controls how many kernels should be put into the menu.lst
## only counts the first occurence of a kernel, not the
## alternative kernel options
## e.g. howmany=all
## howmany=7
# howmany=all
## should updategrub create memtest86 boot option
## e.g. memtest86=true
## memtest86=false
# memtest86=true
## should updategrub adjust the value of the default booted system
## can be true or false
# updatedefaultentry=false
## ## End Default Options ##
# Logo após às opções padrão começam as configurações específicas dos sistemas operacionais
que serão disponibilizados como opção para boot.
Abaixo temos listado como opção de sistema para inicialização o Debian com kernel 2.6.18-6-686.
E logo abaixo temos esse mesmo sistema mas configurado para ser inicializado no modo singlemode (somente um usuário) que é o mesmo sistema operacional com o mesmo kernel com que é
inicializado com parâmetros, de kernel, diferentes.
# Os parâmetros abaixo representam:
#
- title: define a forma de identificação que o sistema operacional (kernel) assumirá no menu
do GRUB durante a seleção do sistema a ser iniciado. Neste parâmetro podemos inserir como argumento qualquer texto que nos ajude a identificar o sistema operacional que será carregado. Ressaltamos que sempre deve ser evitado o uso de caracteres especiais.
#
- root: nesta opção indicamos em qual partição encontram-se os arquivos de inicialização (indicamos qual é a partição que contém o '/boot').
- kernel: nesta opção passamos qual o kernel deverá ser iniciado e logo após devemos indicar
qual a partição que contém o diretório '/', após isso podemos passar alguns argumentos para o ker nel, que serão carregados durante sua inicialização. No exemplo abaixo estamos utilizando os argu mentos: 'ro' que faz com que seja carregado como somente leitura e 'vga=791' que define a resolu ção que será utilizada pelo shell nesse caso 1024x768 com 65.536 cores.
- initrd: nesta opção especificamos qual a imagem que será utilizada como “Initial RAM” no
início do boot do sistema.4
- savedefault: salva uma informação de que no ultimo boot foi utilizado este bloco de configurações e a partir de então será considerada como opção padrão para inicialização no GRUB se na
4 Durante a inicialização a imagem do kernel é descompactada numa área de RAM disk (uma emulação de disco em
memória RAM).
39
opção 'default' estiver configurada com o argumento 'saved'.
title
Debian GNU/Linux, kernel 2.6.186686
root
(hd0,1)
kernel
/vmlinuz2.6.186686 root=/dev/hda4 ro vga=791
initrd
/initrd.img2.6.186686
savedefault
title
Debian GNU/Linux, kernel 2.6.186686 (singleuser mode)
root
(hd0,1)
kernel
/vmlinuz2.6.186686 root=/dev/hda4 ro vga=791 single
initrd
/initrd.img2.6.186686
### END DEBIAN AUTOMAGIC KERNELS LIST
###################################################################
# As configurações abaixo funcionam apenas como um separador que separa as opções de carregamento do Debian das opções dos demais sistemas operacionais disponíveis.
title
root
Other operating systems:
###################################################################
# Abaixo (fora da seção DEBIAN AUTOMAGIC KERNELS LIST) encontramos as configurações dos
sistemas operacionais não-linux. Essas configurações são escritas neste arquivo através do pacote
os-prober que detecta todos os sistemas operacionais instalados e repassa essas informações ao
gerenciador de boot (GRUB). Por serem detectadas automaticamente dificilmente temos a necessidade de edição dessas configurações.
# Para configurarmos um sistema operacional windows no GRUB devemos utilizar os seguintes
parâmetros de configuração:
#
- title: define a forma de identificação que o sistema operacional (kernel) assumirá no menu
do GRUB durante a seleção do sistema a ser iniciado.
#
- root: para indicarmos em qual partição o Windows esta instalado.
#
- makeactive: para tornar a partição com o Windows ativa (o Windows só pode ser iniciado se
sua partição for uma partição ativa).
#
- chainloder +1: faz com que seja feita a leitura do primeiro setor da partição carregando o
gerenciador de boot do windows.
title
Microsoft Windows XP Professional
root
(hd0,0)
savedefault
makeactive
chainloader
+1
OUTROS PARÂMETROS DE CONFIGURAÇÃO DAS IMAGENS
rootnoverify = Idêntico ao parâmetro anterior (root), mas não tenta montar a partição-alvo,
o que é necessário para alguns sistemas como o DOS e o MS Windows.
module = Faz com que algum módulo necessário para o boot seja carregado. Lembre-se
40
que estes não são módulos do kernel (módulos de som, rede, etc.) e sim módulos necessários ao
boot de alguns sistemas, como por exemplo os utilizados pelo GNU Hurd.
lock = Quando você desejar controlar se uma pessoa pode ou não iniciar um sistema que
esteja listado nas opções do menu de boot, você pode utilizar esta opção que faz com que a senha especificada com o parâmetro “password” seja solicitada no momento em que o usuário tentar carregar a imagem em questão.
pause = Emite uma mensagem na tela e espera uma tecla ser pressionada.
hide e unhide = Esconde/mostra uma partição respectivamente. Estas duas opções, são
necessárias quando houver mais de uma versão do DOS ou do Windows na máquina em partições diferentes, já que estes sistemas detectam automaticamente a partição. Vamos a um simples
exemplo para ilustrar uma situação bem comum: Suponha que o Windows esteja instalado na primeira partição primária do primeiro disco rígido (hd0,0) e o DOS na segunda partição primária
(hd0,1). Quando quisermos carregar estes sistemas, devemos ajustar o arquivo “/boot/grub/menu.lst”, adicionando as seguintes configurações:
# Porção do arquivo “/boot/grub/menu.lst”
title Windows
hide (hd0,1)
unhide (hd0,0)
rootnoverify (hd0,0)
chainloader +1
makeactive
title Dos
hide (hd0,0)
unhide (hd0,1)
chainloader +1
makeactive
map = Alguns sistemas não permitem ser iniciados quando não estão no primeiro disco
(DOS, Windows 9x etc). Para resolver esta e outras situações deste tipo, o GRUB tem um comando que permite enganar tal sistema mapeando as unidades de disco do modo como lhe for mais
conveniente.
Imagine que você tenha o primeiro disco (hd0) com o GNU/Linux instalado e em um outro
disco (hd1) com o Windows/DOS instalado. O Windows/DOS não permitem serem inicializados
desta forma, e como solução, você poderia usar a seguinte entrada no arquivo de configurações
“/boot/grub/menu.lst” do GRUB:
title Windows
41
unhide (hd1,0)
chainloader +1
map (hd1) (hd0)
makeactive
Isso faz com que o disco (hd1), onde Windows/DOS está instalado, seja apresentado a
este sistema como (hd0), um artifício que permitirá que estes sistemas sejam carregados normalmente.
Através do menu do GRUB é possível alterar as configurações para inicialização do sistema
que estiver selecionado pressionando a tecla <e>. Serão exibidos os parâmetros de configuração
para inicialização daquele sistema, para alterar esses parâmetros basta selecioná-los e novamente novamente pressionar a tecla <e>, após feitas as alterações desejadas basta pressionar a tecla
<enter> e para dar boot com as alterações efetuadas basta digitar a letra <b>.
LINHA DE COMANDO DO GRUB
O GRUB possui também o recurso de linha de comandos. Na linha de comando podemos
utilizar maioria dos comandos usados no arquivo de configuração “/boot/grub/menu.lst”, além outros comandos que são exclusivos para uso na linha de comado.
Temos duas formas de acessar o menu do GRUB:
•Com o sistema operacional carregado digitando, na linha de comando como root
# grub
•Pressionando a tecla <c> enquanto aparece a tela do menu de seleção do GRUB.
C
aso o parâmetro “password” tenha sido especificado no arquivo “/boot/grub/menu.lst”, para que seja poder acessar o menu de comandos assim como as demais
opções possíveis será necessário pressionar a tecla <p> e entrar com a senha válida.
Abaixo iremos fazer uma breve descrição de alguns comandos que podemos utilizar na linha
de comando do GRUB, onde só detalharemos os comandos mais relevantes.
•
cat - Este comando permite verificar o conteúdo de um arquivo qualquer, o qual deve es-
tar gravado em um dispositivo ligado a sua máquina. Embora seja um recurso útil, nenhuma
permissão de acesso é verificada e qualquer pessoa que tenha acesso à linha de comandos
do GRUB, poderá listar o conteúdo de arquivos importantes do seu sistema. Para contornar
este problema, configure adequadamente o parâmetro “password” no arquivo “/boot/grub/menu.lst”. Não esqueça que ainda é possível utilizar um disquete com o GRUB para iniciar a máquina, o que permite usar a linha de comandos pelo disquete.
42
Para testar o comando “cat” siga os passos descritos a seguir: deixe o arquivo menu.lst somente com permissão de leitura e escrita para o dono (grupo e outros não devem ter nenhum tipo
de permissão), com um usuário comum tente listar o conteúdo do arquivo ”menu.lst” com o comando “cat” da linha de comando do sistema operacional (deverá ser exibida mensagem de permissão negada). Em seguida como root digite o comando “grub” para entrar na linha de comandos
do GRUB, e seguida utilize, para listar o conteúdo do arquivo menu.lst, o comando “cat” passando, com a sintaxe do GRUB, qual a partição e o caminho onde se encontra o arquivo menu.lst e
perceba que o conteúdo do arquivo será exibido. Veja abaixo um exemplo de execução dos comandos descritos nesse procedimento.
# chmod 600 /boot/grub/menu.lst
# su robsonp
$ cat /boot/grub/menu.lst
cat: /boot/grub/menu.lst: Permissão negada
$ exit
# grub
grub> cat (hd0,0)/grub/menu.lst
•
cmp - Este comando é utilizado para comparar dois arquivos.
grub> cmp (hd0,0)/arquivo1 (hd0,0)/arquivo2
•
configfile - Carrega um arquivo de configuração do GRUB. Com este comando será
aberto o menu do GRUB e decorrido o tempo configurado no arquivo menu.lst, caso nenhuma
tecla seja pressionada, ocorrerá uma tentativa de inicialização da opção definida na opção default, será apresentada mensagem de erro de inconsistência na estrutura do sistema de arquivos e retornará ao menu do GRUB então basta digitar “c” para retornar a linha de comando.
grub> configfile (hd0,0)/grub/menu.lst
•
displayapm - Mostra informações sobre APM.
•
displaymem - Mostra informações sobre a memória RAM.
•
find - Permite encontrar um arquivo. A saída deste comando disponibiliza o nome com-
pleto do caminho para o arquivo e a partição onde o mesmo está localizado.
•
geometry - Mostra informações sobre a geometria reconhecida para seu dispositivo de
armazenamento principal, e permite que você defina uma geometria personalizada, caso esta
esteja sendo reconhecida de forma errada.
•
help – É um comando para ver a ajuda sobre a utilização de outros comandos.
grub> help cmp
43
•
install - Instala o GRUB, embora não seja recomendado o uso deste comando direta-
mente, já que é possível cometer erros facilmente e sobrescrever a tabela de partições de seu
disco.
•
setup - Este comando configura e instala o GRUB automaticamente. Para instalação do
GRUB através deste comando precisamos, antes, indicar em qual partição estão os arquivos
de inicialização (qual é a partição /boot) para depois podermos utilizar o comando “setup” para
efetuarmos a instalação.
grub> root = (hd0,0)
grub> setup = (hd0)
•
quit - Abandona a linha de comandos do GRUB.
•
reboot - Reinicia o computador.
•
boot - Efetua o carregamento através das opções definidas via linha de comando. Supo-
nha um sistema operacional Linux instalado com o “/boot” (os seus arquivos de inicialização)
na partição /dev/sda1 (hd0,0) e o diretório “/” na partição /dev/sda2 (hd0,1) utilizando o kernel
2.6.18-6-686. Levando em conta essas configurações podemos passar os seguintes comandos na linha de comandos para efetuar o boot (a inicialização do sistema) pela linha de comando do GRUB.
grub> root (hd0,0)
grub> kernel /vmlinuz2.6.186686 root=/dev/sda1 ro vga=6
grub> initrd /initrd.img2.6.186686
grub> boot
44
RUNLEVEL
PROCESSO DE BOOT
Antes de aprendermos sobre runlevel vale a pena entendermos um pouco como funciona o
processo de inicialização do computador.
Ao ligarmos o computador, a BIOS executa uma série de operações antes de iniciar o boot
do sistema operacional conforme sequência abaixo:
1. Computador é ligado pelo interruptor iniciando a energização dos circuitos elétricos;
2. BIOS executa várias operações;
3. BIOS lê o setor de boot (MBR);
4. Executa o programa encontrado (no Debian, por padrão, é o GRUB);
5. Carrega o kernel;
6. O kernel executa o init (PID=1. Isso mesmo, o init é uma aplicação);
7. O init lê o arquivo /etc/inittab;
8. O init executa os scripts de acordo com o inittab;
9. Sistema pronto para uso.
Os runlevels são iniciados quando o kernel executa o init, que é o primeiro processo a ser
executado e tem o PID igual a um. Uma característica específica deste processo é que ele não
pode ser finalizado forçadamente. O init lê o arquivo /etc/inittab, onde estão definidos os primeiros
parâmetros a serem configurados, como por exemplo, qual o runlevel, quais scripts devem ser
executados por quais runlevels, quantos terminais virtuais nós teremos disponíveis em nossa máquina, etc.
CONHECENDO OS RUNLEVELS
Runlevels, ou níveis de execução, constituem uma maneira de controlar como a máquina
será utilizada. Cada runlevel é configurado para que um determinado número de processos específicos estejam em execução. Convencionalmente temos 7 (sete) níveis de runlevels do 0 ao 6,
onde, por padrão no Debian, o nível zero (0) é utilizado para realizar o desligamento (shutdown)
normal da máquina; o nível 6 é usado para reinicializar (reboot) o sistema; o nível 1 (modo mono
usuário) é o modo no qual o Kernel do Linux só carrega os recursos necessários para o funcionamento básico do SO e disponibiliza apenas acesso ao superusuário do sistema (root), de modo
geral, para que este possa realizar a manutenção de algum ponto falho do sistema. Os runlevels 2
a 5 são utilizados para carga dos diferentes serviços providos pelo sistema, e possuem uma ca45
racterística comum entre si: atuarem no modo multiusuário.
Através do comando “init” podemos alterar o nível de execução atual do sistema operacional. Para isso, devemos usar o comando “init” seguido de um número (de 0 a 6) representando o
runlevel desejado. Abaixo um exemplo de uso do comando para alterar o nível de execução atual
do sistema:
# init 3
N
os sistemas Debian, após a instalação do sistema operacional, os runlevels de 2 a 5
são todos iguais e apenas iniciam aplicações. Então, executando o comando acima,
o script irá verificar que todos os serviços já estão carregados e não fará nada.
IDENTIFICANDO O RUNLEVEL EM UTILIZAÇÃO
Temos basicamente duas formas de se identificar o runlevel carregado. Uma delas é através
do comando:
# ps aux | grep init
A saída deste comando será algo como:
root 1 0.0 0.0 1984 688 ? Ss 07:45 0:01 init [2] root 4745 0.0 0.0 3264 816 pts/0 S+ 09:58 0:00 grep init
Neste exemplo, o nível de execução atual do SO é o 2, representado pela indicação “init [2]”
presente na primeira linha da saída do comando. Outra forma de se identificar o runlevel carregado é através do comando “runlevel”, como no exemplo abaixo:
# runlevel
A saída deste comando será algo como:
N 2
O “N 2” da saída do comando “runlevel”, indica que o nível de execução atual do sistema é o
2, se você mudar o nível para outro qualquer, o nível anterior será mostrado no lugar do “N” exibido na saída acima. Desta forma é possível verificar qual foi o último e o corrente.
O ARQUIVO /ETC/INITTAB
Durante o processo de inicialização, o “init” utiliza durante sua execução o arquivo “/etc/inittab” para configurar cada runlevel do sistema. Este é o principal arquivo de configuração do boot
do sistema. Nele são especificadas diversas opções que definirão o perfil do sistema.
A configuração deste arquivo, apesar de algumas variações, obedece basicamente o se46
guinte padrão:
id:runlevel:ação:diretório
● id - identificador "exclusivo" para cada linha do arquivo. Deve estar limitado a 2 caracteres.
● runlevel - identifica em qual runlevel esta linha deve ser executada. Pode definir um
ou mais de um runlevels.
● ação - identifica a ação a ser tomada. O campo ação pode ter um dos seguintes valores:
• respawn - O processo será reiniciado assim que for finalizado;
• wait - O processo será executado quando o sistema entrar no runlevel especificado e o sistema aguardará a finalização deste processo;
• once - O processo será executado quando o sistema entrar no runlevel especificado;
• boot - O processo será executado durante o boot do sistema;
• bootwait - O processo será executado durante o boot do sistema, que aguardará a sua finalização para continuar;
• off - Não faz nada;
• initdefault - especifica o runlevel que o sistema deverá entrar após o boot do
sistema. Caso este parâmetro não seja informado, o init irá questionar qual o runlevel a ser utilizado. O campo processo é ignorado.
• sysinit - O processo será executado durante o boot do sistema, antes de qualquer referencia dos parâmetros boot ou bootwait. O campo runlevel é ignorado;
• powerwait - O processo será executado quando o init receber uma mensagem
de falha na alimentação elétrica da máquina. O init aguardará a finalização deste
processo;
• powerfail - Idêntico ao powerfail, com a diferença de que o init não aguardará
a finalização deste processo;
• powerokwait - O processo será executado quando o init for informado de que
a alimentação elétrica foi restabelecida;
• powerfailnow - O processo será executado quando o init for informado de que
a alimentação elétrica da máquina (bateria, no-break) está quase vazia, e que a
energia está falhando.
• ctrlaltdel - O processo será executado quando o init receber o sinal SIGINT,
que significa que a sequencia de teclas <Ctrl>+<Alt>+<Del> foi pressionada;
• kbrequest - O processo será executado quando o init receber um sinal do dri47
ver do teclado informando que uma sequencia especial de teclas foi pressionada. A
documentação para esta função ainda não está completa, para maiores informações veja o pacote kbd-x-xx.
● Diretório – caminho completo do diretório onde se encontram os scripts a serem executados.
Analisando as principais linhas de configuração do arquivo /etc/inittab.
# /etc/inittab: init(8) configuration.
# $Id: inittab,v 1.91 2002/01/25 13:35:21 miquels Exp $
# A linha abaixo esta definindo o runlevel padrão.
id:2:initdefault: # Primeira ação a ser executada durante o processo de boot, com inicialização dos scripts de carre gamento do kernel.
si::sysinit:/etc/init.d/rcS # O que será carregado no modo mono-usuário
~~:S:wait:/sbin/sulogin # Runlevel 0 desligará a máquina.
# Runlevel 1 modo mono-usuário (single-user).
# Runlevels 2-5 Modo Multiusuário (multi-user).
# Runlevel 6 reinicialização do sistema.
# As linhas abaixo configuram cada runlevel para serem executados quando o sistema entrar no
runlevel especifico.
l0:0:wait:/etc/init.d/rc 0 l1:1:wait:/etc/init.d/rc 1 l2:2:wait:/etc/init.d/rc 2 l3:3:wait:/etc/init.d/rc 3 l4:4:wait:/etc/init.d/rc 4 l5:5:wait:/etc/init.d/rc 5 l6:6:wait:/etc/init.d/rc 6 # Inicializando os terminais (tty)
1:2345:respawn:/sbin/getty 38400 tty1 2:23:respawn:/sbin/getty 38400 tty2 3:23:respawn:/sbin/getty 38400 tty3 4:23:respawn:/sbin/getty 38400 tty4 5:23:respawn:/sbin/getty 38400 tty5 6:23:respawn:/sbin/getty 38400 tty6 ENTENDENDO O FUNCIONAMENTO DOS RUNLEVELS
Ao carregamos um runlevel simplesmente executamos um conjunto de scripts localizados
no /etc/ini.d/ com uma determinada sequencia de prioridade, através de links simbólicos existentes
48
nos diretórios /etc/rc?.d.
Na distribuição GNU/Debian, os diretórios “/etc/rc[0-6].d” contém as ligações simbólicas para
arquivos em “/etc/init.d”, que são acionados pelo “init” no nível de execução correspondente. Por
exemplo, o arquivo “S10sysklogd” em “/etc/rc2.d”, é um link simbólico para “/etc/init.d/sysklogd”.
O nome desses links simbólicos seguem um padrão através do qual é definido se o link simbólico iniciará ou interromperá a execução de um serviço em “/etc/init.d”, além indicar a prioridade
para execução do script. Segue abaixo descrição sobre os padrões de nomenclatura dos links.
•
Se um link é iniciado com a letra K (kill), quer dizer que o serviço será interrompido na-
quele nível de execução. O que ele faz na verdade, é executar o script do serviço em questão
em “/etc/init.d” seguido da opção “stop”.
•
Se um link é iniciado com a letra S (start), quer dizer que o serviço será iniciado naquele
nível de execução. Isto fará com que o script do serviço em questão em “/etc/init.d” seja invocado seguido da opção “start”.
Por ordem, os links com a letra “K” são executado primeiro seguido pelos que iniciam pela
letra “S”. A ordem com que são executados, depende também do valor numérico que acompanha
o link, quanto menor o número antes será executado, por exemplo, os seguintes arquivos são executados em sequencia:
S10sysklogd
S12kerneld
S20inetd
S20linuxlogo
S20logoutd
S20lprng
S89cron
S99xdm
Note, que os arquivos que iniciam com o mesmo número (S20*), são executados por ordem
alfabética.
INSERINDO/ REMOVENDO SCRIPTS DO RUNLEVEL
A forma mais indicada para inserir ou remover scripts nos runlevels é utilizando a ferramenta
update-rc.d. Para reconfigurarmos um script de inicialização ou um novo script incluso no diretório
/etc/init.d que deve ser iniciado automaticamente basta usar:
49
# updaterc.d nome start/stop NN runlevel . (...)
Onde nome é o nome do script em /etc/init.d, a opção start para iniciar ou stop para parar o
processo, NN faz referência à ordem de execução (prioridade) e o runlevel em que deseja incluir
ou reconfigurar o scrip. O ponto faz parte da sintaxe do comando para separar as configurações
realizadas através do update-rc.d, também havendo a necessidade de se colocar um ponto no final do comando. A Seguir alguns exemplos de uso:
Vamos imaginar que criamos o script firewall.sh no /etc/init.d. Queremos que ele seja
iniciado (argumento "start" passado) no runlevel de boot padrão (2) e fechado (argumento "stop")
quando se desliga ou reinicia (runlevels 0 e 6) e queremos que ele seja um dos últimos processos
a ser iniciado/parado. Para isso devemos utilizar o comando update-rc.d com a seguinte sintaxe:
# updaterc.d firewall.sh start 97 2 . stop 97 0 . stop 97 6 .
Uma forma mais fácil de se utilizar o update-rc.d é com a utilização das configurações padrão, ou seja, iniciar nos runlevels 2, 3, 4 e 5 e finalizar nos 0, 1 e 6. Para isso basta usar o co mando:
# updaterc.d ssh defaults
Também é possível utilizar a opção defaults do comando update-rc.d alterando sua prioridade de execução. Para isso basta após o parâmetro defaults informar também o numero referente
a prioridade desejada.
# updaterc.d ssh defaults 37
Para removermos um serviço basta utilizarmos o comando update-rc.d com a sintaxe a seguir:
# updaterc.d f ssh remove
Utilizando junto ao comando update-rc.d o parâmetro -n somente será mostrado na tela o resultado do comando, não sendo gravada nenhuma alteração nos runlevels.
# updaterc.d n ssh defaults
50
SISTEMA DE LOGS
Arquivo de Log, é uma designação dada aos arquivos que são utilizados pelos programas
do sistema para registrar suas atividades. Estes registros, em geral, são compostos por mensagens informativas, de alerta e de erro, geradas pelos programas durante sua execução. Estes arquivos possuem informações muito úteis para o administrador do sistema. Através deles é possível verificar o funcionamento do sistema, o comportamento dos programas, prevenir e corrigir erros e auditar o ambiente operacional.
O Debian conta com uma estrutura central para armazenamento e funcionamento do sistema de logs, onde os arquivos de log são guardados comumente no diretório “/var/log”, e um serviço especial denominado “syslog” faz de forma unificada todo o registro de atividades do sistema
(kernel e outros programas).
A partir da versão lenny do DEBIAN os antigos daemons do syslog, syslogd - Linux system
logging utilities e klogd - Kernel Log Daemon, foram substituídos por um único daemon o rsyslog.
As vezes temos que administrar uma grande quantidade de computadores (geralmente servidores) ficando difícil o acompanhamento das logs em cada uma das máquinas. Para facilitar
este controle podemos criar um servidor de logs, configurando uma máquina para receber os registros de log de todas as outras máquinas da rede, podendo inclusive ser configurado um banco
de dados para armazenamento das logs (este procedimento de configuração de um servidor de
log não será abordado nesta apostila).
PRINCIPAIS ARQUIVOS DE LOG
Dentro do diretório “/var/log”, podemos encontrar uma variedade de arquivos de log. Dentre
eles, alguns merecem destaque:
Nome do Arquivo
Descrição
É um arquivo de log geral do sistema. Guarda desde algumas
messages
mensagens do kernel até registros enviados pelos programas do usuário.
Usado principalmente para registrar atividades do kernel e de
syslog
alguns serviços do sistema. É o mais importante arquivo de log de um
ambiente Linux, juntamente com “/var/log/messages”.
auth.log
wtmp
Usado para guardar informações sobre a autenticação de usuários no sistema.
É um arquivo binário, que guarda a contabilidade de tempo de
51
acesso ao sistema por parte dos usuários. Para verificar o conteúdo
deste arquivo, é necessário o uso do comando “last”.
Xorg.[número].log
dmesg
Guarda informações relacionadas ao servidor X.
Mensagens do Kernel no momento de inicialização do sistema.
Pode ser lido, através do comando de nome homônimo.
possui informações com maior nível de detalhes do que em
debug
“/var/log/syslog” e “/var/log/messages”. Interessante para verificação
de problemas no sistema.
LENDO UM ARQUIVO DE LOG
O conteúdo dos arquivos de log sempre seguirão o seguinte padrão:
Data|Hora|máquina|Daemon|Mensagem
Sendo que o campo “máquina” é o nome do computador que registrou a mensagem (a máquina pode atuar como um servidor de logs registrando mensagens de diversos computadores em
sua rede). O campo “daemon”, indica qual programa gravou a mensagem e o campo mensagem
contem as informações referentes àquela log.
CONFIGURANDO O SYSLOG
As configurações do “syslog“ são feitas através de seu arquivo de configuração “/etc/rsyslog.conf”. Neste arquivo podemos definir quais as facilidades e quais níveis gerarão registros de
log além de definir o destino da log. Sua sintaxe para configuração é a seguinte:
facilidade.nível
destino
Onde facilidade faz referência ao programa ou serviço que irá gerar a mensagem, nível faz
referência importância da mensagem e destino ao local que será enviada a saída da log. Podendo
esta saída ser um arquivo, uma tty, um pipe (se iniciado por um "|"), um computador remoto (se
iniciado por uma "@"), ou para determinados usuários do sistema (especificando os logins separados por vírgula) ou para todos os usuários que estão usando o SO ou através do comando “wall”
(usando o caractere "*"). Segue abaixo uma relação das facilidades e níveis possíveis:
Facilidades:
–
auth - Mensagens de segurança/autorização (é recomendável usar “authpriv” ao invés
deste).
52
–
authpriv - Mensagens de segurança/autorização (privativas).
–
cron - Daemons de agendamento (cron e at).
–
daemon - Outros daemons do sistema que não possuem facilidades específicas.
–
ftp - Daemon de FTP do sistema.
–
kern - Mensagens do kernel.
–
lpr - Sub-sistema de impressão.
–
local0 a local7 - Reservados para uso local.
–
mail - Sub-sistema de e-mail.
–
news - Sub-sistema de notícias da USENET.
–
security - Sinônimo para a facilidade “auth” (evite usá-la).
–
syslog - Mensagens internas geradas pelo syslogd.
–
user - Mensagens genéricas de nível do usuário.
–
uucp - Sub-sistema de UUCP.
–
O caractere “*” (asterisco) - Confere com todas as facilidades.
A
lguns sinalizadores de “facilidades” como o “security”, emitem um alerta sonoro no
sistema e enviam uma mensagem para console, como forma de alerta ao administrador e usuários que estão utilizando o sistema.
Níveis:
–
emerg - O sistema está inutilizável.
–
alert - Uma ação deve ser tomada imediatamente para resolver o problema.
–
crit - Condições críticas.
–
err - Condições de erro.
–
warning - Condições de alerta.
–
notice - Condição normal, mas significante.
–
info - Mensagens informativas.
–
debug - Mensagens de depuração.
–
none - Nenhuma prioridade.
–
O caractere “*” (asterisco) - Confere com todos os níveis.
Além destes níveis, os seguintes sinônimos estão disponíveis:
53
–
error - Sinônimo para o nível “err”.
–
panic - Sinônimo para o nível “emerg”.
–
warn - Sinônimo para o nível “warning”.
A
o selecionarmos um determinado nível além do nível selecionando também serão
registradas as mensagens de todos os níveis de maior prioridade.
É possível configurar mais de uma facilidade para cada nível para isso basta separar as facilidades por “,” (vírgula) e após listar todas as facilidades utilizar o “.” (ponto) para separar as facilidades do nível desejado. É possível também configurar várias facilidades com níveis diferentes
para um mesmo destino, para isso basta separá-las por “;” (ponto e vírgula). Conforme mostram
os exemplos abaixo.
auth,authpriv.*
/var/log/auth.log
No exemplo acima temos duas facilidades (auth e authpriv separadas por vírgula) registrando suas mensagens de todos os níveis (representados pelo caracter coringa “*”) no arquivo
“/var/log/auth.log”.
syslog.*;auth,authpriv.notice
/var/log/syslog
Neste outro exemplo, temos todos os níveis da facilidade “syslog” e a partir do nível “notice”
das facilidades “auth” e “authpriv” sendo registradas no arquivo “/var/log/syslog”.
*.* /dev/tty8
No exemplo acima temos todas as facilidades em todos os níveis sendo registradas na tty8.
Neste caso se acessarmos a tty8 veremos que as logs estarão sendo exibidas em tempo real (assim que são geradas) mas não estarão sendo gravadas em nenhum arquivo para uma consulta
posterior.
S
empre utilize a tecla <TAB> ao invés da barra de espaços para separar os parâmetros do arquivo “/etc/rsyslog.conf”.
Existem ainda 4 caracteres que garantem funções especiais: "*", "=", "!" e "-". A seguir uma
breve descrição da função que cada um deles desempenha:
–
O caractere “*” - Todas as mensagens da facilidade especificada serão redirecionadas.
–
O caractere “=” - Somente o nível especificado será registrado.
–
O caractere “!” - Todos os níveis especificados e de maior importância NÃO serão re-
gistrados.
54
–
O caractere “-” - Pode ser usado para desativar a sincronização de escrita imediata do
arquivo de log. Tem a vantagem de obter maior desempenho, porém, como a gravação não é
síncrona, caso o sistema seja desligado abruptamente, você perderá a informação das atividades que ainda não foram salvas no arquivo.
Os caracteres especiais "=" e "!" podem ser combinados numa mesma regra.
LOGGER
Este comando permite enviar uma mensagem para os arquivos de log do sistema. A mensagem é enviada aos arquivos, através do daemon “rsyslog”, ou via soquete do sistema, é possível
especificar dados como prioridade, nível, nome de identificação do processo, etc. Seu uso é muito
útil em scripts ou em outros eventos do sistema.
Para podermos utilizarmos o comando “logger” num scrip precisamos primeiro configurar no
arquivo “/etc/syslog.conf” uma facilidade para receber as mensagens geradas pelo scrip. Como vimos anteriormente as facilidades local0 a local7, são reservadas para usuários, então basta configurarmos estas facilidades para gravarem suas mensagens num determinado arquivo, como mostramos abaixo.
local3.*
/var/log/robsonlog.log
A configuração acima faz com que as mensagens da facilidade local3 sejam gravadas no arquivo “robsonlog.log”, agora para o nosso scrip registrar suas logs neste arquivo basta utilizarmos
nele o comando logger. Segue abaixo código do script “testelogger.sh” que foi criado para testarmos o uso do comando logger.
#!/bin/bash
logger -t $0 -p local3.warning “teste usando comando logger num
scrip”
Neste comando do logger foram utilizados dois parâmetros: o “-t” que permite adicionar uma
tag (marcação) à mensagem, nesse caso utilizamos a variável “$0” que em shell script retorna o
nome do arquivo com o script, o outro parâmetro foi o “-p.” que permite definir o recurso do syslog
que desejo utilizar, qual o nível que representa e a mensagem desejada para envio. Com isso o
syslog já se encarrega de escrever no arquivo de log colocando essas mensagens e a data da
execução. A saída desse comando no arquivo de log é:
Jan 28 09:29:40 debianVM testelogger.sh: teste usando comando logger num script
A sintaxe para utilização do comando logger é?
55
logger [opções] [mensagem]
Onde:
mensagem
É a mensagem que será enviada ao daemon “rsyslog” para ser gravada num dos respectivos arquivos de log presentes no sistema.
opções
-i – Registra o PID (número identificador) do processo.
-s – Envia a mensagem para a saída padrão (STDOUT) e para o serviço “rsyslog”.
-f [arquivo] – Envia o conteúdo do arquivo especificado como mensagem ao “rsyslog”.
-t [nome] – Especifica o nome do processo responsável pelo log que será exibido antes do
PID na mensagem do “syslogd”.
-p [prioridade] – Especifica a prioridade da mensagem. Deve-se utilizar a notação “facilidade.nível”. Verifique os tipos de prioridade/níveis existentes no Linux no arquivo de configuração
“/etc/syslog.conf”. O valor padrão que é utilizado caso este parâmetro não seja especificado é
“user.notice”.
-u [soquete] – Envia a mensagem para o soquete especificado ao invés do “rsyslog”. Útil
para enviar mensagens através da rede para um servidor de log.
LOGCHECK
É um programa usado para enviar um e-mail periodicamente ao administrador do sistema
(através do “cron” ou outro serviço com a mesma função) alertando sobre os eventos que ocorreram desde a última execução do programa. Esta ferramenta pode ser muito útil se personalizada
adequadamente para alertar ao administrador de eventos estranhos. O Logcheck pode ser totalmente personalizado assim enviará mensagens baseadas em eventos encontrados nos logs e
passíveis de atenção.
As mensagens do logcheck são tratadas por arquivos em “/etc/logcheck” e organizadas em
categorias antes de serem enviadas por e-mail, isto garante muita praticidade na interpretação
dos eventos ocorridos no sistema. O tipo de mensagem que será incluída/ignorada nos logs enviados pela ferramenta, podem ser ajustadas pelo administrador do sistema através desses
arquivos/diretórios presentes em “/etc/logcheck”. Nomes de arquivos/diretórios contendo a palavra
"ignore" são usados para armazenar expressões regulares que NÃO serão enviadas pelo logcheck.
A instalação padrão inclui perfis para eventos ignorados e violações de políticas para três di56
ferentes configurações (workstation, server e paranoid), sendo que "server" (servidor) é o nível padrão, paranoid (paranoico) é somente recomendado para máquinas de alta segurança executando
poucos serviços quanto forem possíveis e workstation (estação de trabalho) para máquinas relativamente não críticas.
Para mais informações, leia /usr/share/doc/logcheck/README.Debian. Detalhes sobre como
escrever regras estão explicados em /usr/share/doc/logcheck-database/README.logcheck-database.gz.
LOGROTATE
Usado para fazer a rotação dos arquivos de log do sistema. A rotação de log é processo que
consiste em guardar o arquivo de log que está sendo utilizado atualmente pelo sistema e fazer
com que os daemons passem a utilizar um novo arquivo para armazenar os novos registros das
atividades do sistema. Este processo também é conhecido como arquivamento de log.
As tarefas do logrotate são programadas via “cron” ou outro serviço de agendamento disponível no sistema. Opcionalmente, os arquivos de log antigos poderão ser compactados para diminuir a utilização de espaço em disco ou enviados por e-mail. A rotação dos arquivos de log proporciona maior agilidade quando precisamos encontrar algum detalhe útil, o que seria mais difícil e
demorado usando um arquivo de log muito extenso.
O arquivo principal de configuração do logrotate é o “/etc/logrotate.conf”, segue abaixo
exemplo de configuração do arquivo.
#### As configurações abaixo, afetam globalmente o funcionamento do logrotate:
# Faz a rotação do arquivos de log semanalmente
weekly
# Mantém as últimas 4 cópias de logs anteriores
rotate 4
# Erros de não existência dos logs são enviados por e-mail ao usuário “root”
mail root
# Cria novos arquivos de log (vazios) após rotacionar os antigos
create
# O parâmetro “compress” é utilizado para fazer a compressão dos arquivos antigos. O parâmetro
“delaycompress” é usado para que o primeiro log seja mantido
compress
delaycompress
# Executam os scripts em “prerotate” e “postrotate” a cada vez que os logs forem arquivados
nosharedscripts
57
# Definimos um diretório que poderá conter definições individuais de rotação de log para cada ser viço do sistema. Contudo, alertamos que diversas configurações individuais podem deixar a inter pretação deste arquivo confusa
include /etc/logrotate.d
# Define opções específicas para a rotação mensal de “/var/log/wtmp”. As opções definidas individualmente como neste exemplo, sobrepõem as opções globais definidas anteriormente. As definições para “/var/log/wtmp”, implicam que caso o arquivo atinja 5MB (size 5M) ele será arquivado,
será criado um novo arquivo com permissão 0664 e pertencerá ao usuário “root” e o grupo “utmp”
(create 0664 root utmp)e será mantida somente uma cópia do log anterior (rotate 1).
/var/log/wtmp {
monthly
create 0664 root utmp
size 5M
rotate 1
}
# Define opções específicas para a rotação mensal de “/var/log/btmp”. Neste caso, o parâmetro
“missingok” fará com que sejam gerados alertas informando ao administrador que o arquivo não
existe.
/var/log/btmp {
missingok
monthly
rotate 1
}
# Define opções específicas para a rotação semanal de “/var/log/lastlog”.
/var/log/lastlog {
missingok
weekly
rotate 1
}
# Define opções específicas para a rotação diária de “/var/log/messages”. Neste caso, o será arquivo
ao atingir o tamanho de 1Mb (size 1M), então o novo arquivo será criado com as mesmas permissões do arquivo anterior. O comando “killall -1 syslogd” será executado após a rotação (postro tate)para que o daemon syslogd funcione corretamente, mas somente uma vez durante a rotação
de vários arquivos de logs (sharedscripts). Serão mantidas as 10 últimas cópias (rotate 10) do arquivo /var/log/messages compactadas (o parâmetro “compress” foi especificado globalmente neste arquivo de configuração).
/var/log/messages {
daily
size 1M
sharedscripts
postrotate
/sbin/killall 1 syslogd
endscript
58
rotate 10
}
# Define opções específicas para a rotação mensal dos arquivos em “/var/log/mirror/*”. A falta desses arquivos não precisa ser notificada ao administrador (missingok), mesmo assim o parâmetro
"nomail" evitará isto de qualquer forma. Os logs rotacionados não serão compactados (nocompress) e serão mantidas as últimas 7 cópias (rotate 7) dos arquivos.
/var/log/mirror/* {
montly
nomail
missingok
nocompress
rotate 7
}
# Fim do arquivo de configuração
Abaixo as opções que você pode utilizar no logrotate.conf.
● compress - comprimir os logs.
● co-mpresscmd - comprimir os logs com especificação do comando a utilizar. O padrão é gzip.
● uncompresscmd - definir o comando para descomprimir os logs. O padrão é gunzip.
● compressext - especifica a extensão usada para o arquivo de log comprimido.
● compressoptions - para possibilitar incluir opções aos comandos de compressão.
Por exemplo: gzip -5. O padrão é a compressão máxima (-9).
● copy - copia o log sem modificar o original.
● copytruncate - copia o log e move o original para outro lugar.
● create [mode owner group] - Este é o comando usado para a criação de um novo
arquivo de log vazio após a rotação. Você pode alterar as permissões, o dono do arquivo e
o grupo.
● daily - rotacionar diariamente.
● delaycompres - Atrasa a compressão do log para a próxima rotação.
● extension [ext] - Inclui uma extensão para o arquivo de log. Se a compressão usada
for a padrão, a extensão será .gz.
● ifempty - Rotaciona os logs mesmo quando vazios.
● include [file or directory] - Indica outros arquivos de configuração ou diretórios que
tenham arquivos de configuração para o logrotate.
59
● mail - envia um email com logs extintos.
● mailfirst - envia um email com os logs rotacionados.
● maillast - envia um email com os logs que serão rotacionados, os logs originais.
● missingok - não enviar mensagem de erro no caso de um arquivo de log não existir.
● monthly - rotaciona os logs mensalmente.
● nocompress/nocopy/nocopytruncate/nocreate/nodelaycompress/nomail- negativas aos comandos correspondentes.
● nomissingok/noolddir/nosharedscripts/notifempty - negativas aos comandos correspondentes.
● olddir [directory] - guardar as versões rotacionadas em outro diretório.
● postrotate/endscript - comandos a serem executados após a rotação do log.
● prerotate/endscript - comandos a serem executados antes da rotação do log, caso
o log seja rotacionado.
● firstaction/endscript - comandos a serem executados imediatamente antes dos prerotates comandos.
● lastaction/endscript - comandos a serem executados depois daqueles invocados
através do -postrotate.
● rotate - comando para rotacionar os logs.
● size - rotacionar os logs quando ultrapassarem o tamanho indicado.
● sharedscripts - postrotate e prerotate serão executados para cada log que tenha a
mesma identificação. Este comando faz com que sejam executados apenas uma vez.
● start - inclui um número para a base dos logs rotacionados, por exemplo: start 0 log.0.
● tabooext [+] list - mudar a lista de extensões taboo.
● weekly - rotacionar semanalmente.
60
CRON
O cron é um serviço, carregado durante o processo de boot, que possibilita a programação
de execução de processos e comandos para serem realizadas periodicamente5. É um recurso fundamental para automatização da administração do sistema e em outros casos onde se faz necessário o agendamento de execução de uma determina atividade.
Podemos utilizar o cron basicamente para duas finalidades: para permitir aos usuários o
agendamento da realização das suas tarefas desejadas; e para o agendamento de tarefas do sistema diariamente, semanalmente ou mensalmente.
No processo de instalação do sistema são criados, por padrão, alguns diretórios especiais
que usados na configuração de tarefas a serem executas pelo cron. São estes diretórios:
/etc/cron.d
/etc/cron.daily
/etc/cron.hourly
/etc/cron.monthly
/etc/cron.weekly
Com exceção do diretório “/etc/cron.d”, podemos utilizar esses diretórios para incluir tarefas
a serem executadas no intervalo de tempo conforme o nome de cada diretório (daily = diário,
hourly = horaria, monthly = semanal e weekly = mensal). Para isto basta copiarmos o script desejado com permissão de execução dentro de um dos diretórios conforme periodicidade desejada
para execução do script. Por exemplo, se colocarmos um script dentro do diretório “/etc/cron.hourly” esse script será executados de hora em hora.
O
s horários e datas de execução desse script dentro desses diretórios, apesar de comunmente não haver a necessidade, podem ser alterados no arquivo “/etc/crontab”.
Uma outra forma de utilização do cron é através da edição do arquivo “/etc/crontab”. Através
deste arquivo podemos agendar uma tarefa para ser executada especificando o exato momento
que queremos para execução assim como qual usuário irá executá-la.
C
omumente este arquivo só é utilizado para agendamento de tarefas a serem executadas pelo root.
Para agendar uma nova tarefa, basta editar o arquivo “/etc/crontab” com qualquer editor de
texto (como o “pico” ou “vi”) e definir as configurações desejadas para execução da tarefa. Para
isso deve ser obedecido o seguinte formato em sua sintaxe:
5 O que possibilita a execução dos comandos nas datas e horários especificados é o daemon do cron, que é acionado
de minuto em minuto para verificação da existência de novas atividades a serem executadas.
61
[minutos] [horas] [dias do mês] [mês] [dias da semana] [usuário] [comando]
Conforme mostramos no exemplo abaixo:
52
18
1
*
*
root runparts
–report /etc/cron.montly
|
|
|
|
|
|
|
|
|
|
|
|
|
\_Comando que será executado
|
|
|
|
|
| |
|
|
|
|
\_ UID que executará o comando
|
|
|
|
| |
|
|
|
\_ Dia da semana (07)
| | |
|
|
|
|
|
\_ Mês (112)
|
|
|
|
|
\_ Dia do Mês (131)
|
|
|
\_ Hora (023)
|
\_ Minuto (059)
O preenchimento de cada campo é feito da seguinte maneira:
• Minutos: informe números de 0 a 59;
• Horas: informe números de 0 a 23;
• Dias do mês: informe números de 0 a 31;
• Mês: informe números de 1 a 12;
• Dias da semana: informe números de 0 a 7;
• UID (Usuário): é o usuário que vai executar o comando (não é necessário especificá-lo se o arquivo do próprio usuário for usado);
• Comando: a tarefa que deve ser executada.
N
os comandos a serem executados podem ser usados os parâmetros normais de utilização na linha de comando.
A ordem dos valores indica o nome correspondente do campo. Por exemplo, no campo mês,
1 a 12 quer dizer de "Janeiro a Dezembro". No caso de dias da semana, 0 a 6 quer dizer de "Do mingo a Sábado". O número 7 também pode ser usado. Neste caso, assim como o número 0, o 7
equivale ao dia de "Domingo".
O caractere “*” é utilizado para especificar constância na execução, por exemplo se no lugar
de especificação do horário utilizarmos “*” a tarefa será executada de hora em hora.
62
Também pode informar intervalos no preenchimento, separando os números de início e fim
através de – (hífen), assim como utilizar vírgula para uma listagem de números. Por exemplo, se
quisermos que uma determinada tarefa seja executada pelo root às 9 horas e 30 minutos dos dias
10, 12, 25, 26, 27, 28 e 29 de todos os meses independente de qual seja o dia da semana devemos configurar o arquivo “/etc/crontab” da seguinte forma:
* * 10,12,2529 * * root comando
| | | | | | |
| | | | | | Comando
| | | | | Usuário
| | | | Dia da Semana
| | | Mês
| | Dias
| Hora
Minuto
Após criarmos um novo agendamento de tarefa a ser realizada não é necessário reiniciar o
daemon do cron, porque ele verifica seus arquivos a cada minuto.
N
unca podemos esquecer de incluir uma linha em branco no final do arquivo, pois
caso contrário o último comando listado no arquivo “/etc/crontab” não será executa-
do.
Através do comando “crontab” também podemos editar o arquivo individual do usuário para
agendamento de tarefas. Para isso basta digitarmos o comando:
crontab e
Será aberta uma janela onde poderemos configurar as tarefas de acordo com a nossa necessidade. A Sintaxex a ser utilizada para essa configuração é a mesma utilizada para configurar
o arquivo “/etc/crontab” (vista anteriormente) apenas não sendo necessário especificar o usuário,
pois nesse caso caso a tarefa será executada pelo usuário dono do arquivo.
Para visualizarmos as tarefas agendadas para o usuário basta utilizarmos o comando:
contab l
Para removermos o arquivo individual do crontab, removendo assim todas as tarefas agendadas, através do comando:
crontab r
Para removermos somente uma tarefa devemos fazer através da edição (contrab -e) do arquivo.
63
COMANDOS
ALIAS
Sintaxe: alias <apelido>='<comando_linux>'
N
ão deve existir espaços antes e depois do “=” e, caso o <comando_linux> tenha
mais de uma palavra, ele deve vir entre ‘aspas simples’.
Muitas vezes durante execução de determinadas tarefas através da linha de comando nos
deparamos com comandos extensos em que temos que utilizar vários parâmetros, e dependendo
do que estamos fazendo ainda temos que repetir este comando com todos estes parâmetros com
uma certa frequência. Para facilitar esse tipo de situação podemos utilizar o comando “alias”.
Este comando permite criarmos uma espécie de apelido para os comando e programas.
Com ele podemos atribuir um apelido para um comando que receba diversos parâmetros e a partir
de então fazermos a chamada do comando através do apelido criado.
Por exemplo, eu sempre utilizo o comando “ls” com os parâmetros “-lh” para exibir o conteúdo dos diretórios em forma de lista com o tamanho dos arquivos exibidos num formato mais inteligível. Ao invés de sempre digitar o comando e os parâmetros posso criar um alias que facilite o
uso do comando através do comando abaixo mostrado.
alias ll='ls lh'
Após executarmos este comando poderemos listar o conteúdos de um diretório em forma de
lista e com o exibição do tamanho dos arquivos de forma inteligível com o agora comando “ll”.Este
comando criado através do “alias” poderá ser usado no “bash” que estiver em execução, caso
este “bash” seja fechado ou um outro seja aberto, dentro do próprio “bash”, o comando (apelido)
criado deixará de existir.
Para removermos um alias criado devemos utilizar o comando “unalias <nome do alias>”
como mostra o exemplo abaixo:
unalias ll
Para removermos todos os alias criado de uma só vez basta utilizarmos o comando com o
parâmetro “-a”, como no exemplo abaixo:
unalias a
Para criarmos um ”alias” de forma definitiva, que não precise ser refeito quando um novo
“bash” for iniciado devemos configurá-lo através de um dos arquivos de configuração do “bash”.
64
Temos três tipos de “alias” definitivos possíveis do configuração:
● O “alias” que é configurado somente para o usuário corrente através do arquivo
“.bashrc” que encontra-se no home de cada usuário6. Segue abaixo trecho do arquivo de
configuração “.bachrc” individual dos usuários.
# Alias definitions. # You may want to put all your additions into a separate file like # ~/.bash_aliases, instead of adding them here directly. # See /usr/share/doc/bashdoc/examples in the bashdoc package. #if [ f ~/.bash_aliases ]; then # . ~/.bash_aliases #fi # enable color support of ls and also add handy aliases if [ x /usr/bin/dircolors ]; then eval "`dircolors b`" alias ls='ls color=auto' alias dir='dir color=auto' alias vdir='vdir color=auto' alias grep='grep color=auto' alias fgrep='fgrep color=auto' alias egrep='egrep color=auto' fi # some more ls aliases alias ll='ls lh' alias la='ls A' alias l='ls CF' ● O “alias” que é configurado para todos os usuários do sistema através do arquivo
“/etc/bash.bashrc”. Segue abaixo trecho do arquivo “bash.bachrc” de configuração para todos os usuários.
# enable bash completion in interactive shells if [ f /etc/bash_completion ]; then . /etc/bash_completion fi #alias para todos os usuários
alias aa='echo "funcionou"' alias instala='sudo aptget install'
● O “alias” que é configurado para o root através do arquivo “.bashrc” que encontra-se
6 Em alguns casos o arquivo “.bashrc” pode não existir no home de algum usuário, sendo então necessária sua
criação.
65
dentro da pasta “/root”7. Segue abaixo trecho do arquivo “.bachrc” do root.
# enable color support of ls and also add handy aliases if [ x /usr/bin/dircolors ]; then eval "`dircolors b`" alias ls='ls color=auto' alias dir='dir color=auto' alias vdir='vdir color=auto' alias grep='grep color=auto' alias fgrep='fgrep color=auto' alias egrep='egrep color=auto' fi # some more ls aliases alias ll='ls l' alias la='ls A' alias l='ls CF' # Some more alias to avoid making mistakes: alias rm='rm i' alias cp='cp i' alias mv='mv i' P
ara configurarmos um “alias” nos arquivos de configuração devemos utilizar a mesma sintaxe utilizada na linha de comando.
BC
O comando bc é utilizado para realizar cálculos. Pode ser utilizado por linha de comando ou
através de sua interface interativa. O bc não é exatamente uma calculadora mas sim uma linguagem para cálculos, que lembra vagamente a linguagem C. Algumas de suas características são:
permitir apresentar os resultados dos cálculos com até 99 dígitos decimais antes e depois do ponto decimal, não haver a necessidade de uma interface gráfica para sua utilização, sua sintaxe ser
bem simples quase idêntica a sintaxe utilizada na função calculadora do google para cálculos simples, permite utilizar construções como 'if', 'for', 'while', permite interação com o usuário além de
permitir o uso de "programas" escritos para o 'bc' como se usássemos um shell script.
Para podermos acessar a interface iterativa do comando bc basta na linha de comando digitar o comando, será aberta a sua interface que utilizaremos para realização dos cálculos como
mostra o exemplo a seguir:
7 Assim como ocorre com o arquivo “.bashrc” dos usuários, este arquivo pode ser criado caso o mesmo não exista
para o root.
66
Abaixo seguem as principais operações básicas do bc:
–
Adição (+), subtração (-), multiplicação (*) e divisão (/).
–
% (resto da divisão)
–
^ (potenciação)
–
sqrt(x) (raiz quadrada de x)
–
last (último resultado)
–
quit para sair
$ bc
bc 1.06
Copyright 19911994, 1997, 1998, 2000 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
600*400
240000
last + 500
240500
last – 1600
238900
last / 20
11945
last^4
20358445623150625
sqrt(last)
142683025
2/3
0
quit
Se repararmos o resultado da última operação (2/3=0) temos a impressão de que há algo errado, mas na verdade o que aconteceu é que simplesmente não foi carregada uma biblioteca de
operações matemáticas que permite o calculo com números decimais. Para carregarmos esta biblioteca para utilização com o comando bc basta utilizarmos o parâmetro “-l”.
$ bc l
bc 1.06
Copyright 19911994, 1997, 1998, 2000 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
2/3
67
.66666666666666666666
Podemos também definir o número de casas decimais que serão usadas com a opção “scale”.
$ bc l bc 1.06.94 Copyright 19911994, 1997, 1998, 2000, 2004, 2006 Free Software Foun
dation, Inc. This is free software with ABSOLUTELY NO WARRANTY. For details type `warranty'. scale=2 2/3 .66 scale=4;2/3 .6666 A
o utilizarmos o comando bc com o parâmetro “-l” alguns comandos matemáticos também ficam disponíveis, são eles;
–
- s(x): o seno de x (x em radianos)
–
- c(x): o cosseno de x (x em radianos)
–
a(x): o inverso da tangente de x (retorna radianos). Se y = tangente de x (tg x), a(y)=x
–
l(x): o logaritmo natural de x. (ln x)
–
e(x): a função exponencial ( e^x ) (exp x)
É possível definirmos funções a partir das definições matemáticas, no entanto essas definições serão perdidas que a interface do bc for finalizada. Segue abaixo exemplo abaixo de definição de função.
$ bc l bc 1.06.94 Copyright 19911994, 1997, 1998, 2000, 2004, 2006 Free Software Foun
dation, Inc. This is free software with ABSOLUTELY NO WARRANTY. For details type `warranty'. define tan(x) {return s(x)/c(x)} tan(1) 1.55740772465490223050 define ln(n) { return l(n); } define log(n) { return ln(n)/ln(10); } log(10) 1.00000000000000000000 68
Para evitarmos o transtorno de termos de sempre termos que refazer as definições toda vez
que iniciamos a utilização do bc, podemos utilizar o recurso de carregar essas definições de um
arquivo criado por nós. Para isso crie um arquivo com as definições que você queira implementar.
$ vim defmat.bc
#!/usr/bin/bc l
#incira as definições desejadas
define ln(n) { return l(n); }
define log(n) { return ln(n)/ln(10); }
define tan(x) { return sin(x)/cos(x); } Dê permissão de execução ao arquivo criado.
$ chmod +x defmat.bc
Em segida basta utilizar o comando bc indicando que o arquivo criado deve ser carregado.
As funções definidas no arquivo já estarão carregadas e prontas para serem utilizadas.
$ bc l defmat.bc bc 1.06.94 Copyright 19911994, 1997, 1998, 2000, 2004, 2006 Free Software Foun
dation, Inc. This is free software with ABSOLUTELY NO WARRANTY. For details type `warranty'. log(10) 1.00000000000000000000 Como podemos perceber o bc pode ser utilizado como uma calculadora programável capaz
de trabalhar com a utilização de funções, definição de variáveis, laços de repetição, estruturas
condicionais, etc. A baixo mostraremos um pouco dos conceitos básicos para utilização desse recurso de programação.
Podemos definir variáveis e atribuir um determinado valor a elas através do comando:
var = valor
No exemplo acima que o conteúdo da variável 'var' como sendo 'valor' que representa um
valor numérico qualquer. Por exemplo: var = 5 define o valor de var como sendo 5.
Uma outra expressão que podemos utilizar é:
var += valor:
Onde da mesma forma que vimos anteriormente 'var' representa o nome da variável e 'valor' representa um valor numérico qualquer . Essa expressão equivale a:
69
var = var + valor
Como mostramos no exemplo abaixo
var = 10
var += 20
Efetuando as expressões mostradas acima o valor da variável var fica igual a 30.
A
lém da atribuição “+=” para somar ainda podemos utilizar “-=” para subtrair, “*=” para
multiplicar e “/=” para dividir.
Temos também os operadores de comparação:
● “==” que define igualdade
x == y
● “!=” que define diferença
x!=y
● “<” que define menor que
x<y
● “<=” que define menor ou igual
x<=y
● “>” que define maior que
x>y
● “>=” que define maior ou igual
x>=y
Temos também os operadores “&&”, “||” e ”!”. para entendermos estes vamos considerar que
e1 e e2 são 2 expressões numéricas.
e1 && e2 Neste caso será retornado o valor 1 se as 2 expressões forem diferentes de zero. Ou seja
retornará verdadeiro caso ambas as expressões sejam verdadeiras.
e1 || e2
70
Neste caso retornará 1 se qualquer uma das 2 expressões forem diferentes de zero. Ou
seja retornará verdadeiro caso qualquer uma das duas expressões seja verdadeira.
!e1
Neste caso retornará 1 se o resultado da expressão for 0. Ou seja se a expressão for falsa
retornará 1.
Temos que tomar muito cuidado quando criamos as expressões, por exemplo na expressão
“x=2<7” ela não equivale a “x=(2<7)” mas sim a “(x=3)<5”.
É possível ainda utilizar valores inseridos pelo usuário através do comando “read()” . Como
mostra o exemplo a seguir:
x = read()
O comando acima faz com que o valor digitado pelo usuário seja armazenado na variável x.
Como vimos anteriormente é possível definir funções para utilização no bc, para isso basta
utilizarmos o comando “define”. Para isso devemos utilizar o comando “define” e entre “{ }“ (chaves) que servem para definir o inicio e final do bloco de código que será executado de uma só vez,
dentro das chaves devemos colocar a combinação de operações que desejamos.
Dentre os vários elemento que podemos utilizar num “define” destacamos:
● auto : que serve para definir uma variável local.
● print : que mostra mensagens especificada na tela. (equivalente ao printf em C)
● return : que retorna um valor. Esta opção deve ser usada no final da função, para retornar seu resultado final.
Além de podermos utilizar as estruturas de condicionamento e repetição.
If: é uma estrutura que efetua um teste lógico e de acordo com o resultado do teste executa
uma determinada ação, sua sintaxe é:
if (expressão) operação1 else operação2
Se o resultado de 'expressão' não for 0 (falso), será executada a operação1, senão (se o resultado for falso) será executa a operação2 (se presente). Segue abaixo um exemplo de utilização
do if.
if (d>=0) {
return (b + sqrt(d))/(2*a);
}
while: é uma estrutura de repetição que efetua um teste lógico e executa uma operação até
71
encontrar o valor 0 (falso) no teste lógico, sua sintaxe é:
while (expressão) operação
Nesta estrutura enquanto o resultado do teste lógico realizado na expressão der como resultado 0 (falso), será executa operação. Também pode-se sair do loop executando um comando
'break' dentro dele. Abaixo segue um exemplo:
ultvalor = read()
while (ultvalor != 0) {
ultvalor = read()
dados += ultvalor
contagem += 1
}
No exemplo antes de iniciar o laço de repetição (loop) estamos criando e atribuindo a variável ultvalor um valor que será digitado pelo usuário. Em seguida, na estrutura while estamos testando se o valor digitado pelo usuário for diferente de zero, se este valor for diferente de zero será
executado o bloco de código existente dentro das chaves e novamente irá efetuar o mesmo teste
lógico até que o usuário digite o número “0 “ (zero), quando isso acontecer o loop será encerrado
e as demais linhas de código da função serão executadas.
for:é uma outra estrutura de repetição onde a variável de controle do loop é inicializad e incrementada junto aos teste lógico, sua sintaxe é:
for (inicialização; condição; incremento) { operação }
Nesta estrutura podemos definir, antes de entrar no loop o estado da variável de contro deo
mesmo esse processo é o de inicialização, logo em seguida é feito o teste lógico que retornará um
valor 1 (verdadeiro) ou 0 (falso) e enquanto o resultado deste teste lógico for 1 (verdadeiro) serão
executadas as operações, no incremento podemos definir como vai ser modificado o valor da variável utilizada no teste do loop. Abaixo segue um exemplo:
for (cont=1;cont<=10;cont++){
print cont
dados +=cont
}
No exemplo acima temos a estrutura de repetição for onde a variável cont é iniciada com o
valor 1 e é feito o teste lógico se a variável cont é menor ou igual a 10, enquanto o resultado deste
teste for 1 (verdadeiro) será executado o bloco de código existente dentro das chaves, após a
execução de tudo que houver dentro das chaves será executado o incremento “cont++” que somará 1 ao valor da variável cont (cont = cont+1) e em seguida efetuará novamente o teste lógico e
novamente executara o bloco de código existente entre as chaves até que a condição testada seja
falsa (neste caso até que cont seja maior que 10).
72
Uma outra forma de se utilizar o comando bc é através da linha de comando concatenandoo à saída do comando echo. Como mostram os exemplos abaixo.
$ echo "2*93" |bc 15
$ echo "log(10)" |bc l defmat.bc 1.00000000000000000000
$ x=$(echo "3*5" | bc)
$ echo $x
15
Conhecemos um pouco sobre o comando bc vimos como usar os comandos básicos. Muito
mais poderia ser visto com relação as possibilidades de funções para uso com o bc mas o aprofundamento nesta parte depende, do conhecimento em programação e da necessidade de cada
um. Apesar de aparentemente ser um comando não muito interessante pode ser bem útil como
uma calculadora programável e em shell scripts.
LAST
O comando last mostra um registro entrada e saída dos usuários, que são registrados no arquivo binário de log “/var/log/wtmp”.
Sintaxe: last <opções>
Quando utilizamos o comando last, por padrão é exibida a listagem, que vai do mais recente
para o mais antigo, dos registros de entrada e saída de usuários com os seguintes campos:
● Nome do usuário
● Terminal onde ocorreu o evento
● O hostname (para conexões remotas) ou a console (para conexões locais).
● A data em que ocorreu o evento (login/logout), a hora de incio do evento (login) e a
hora de finalização do evento (logout).
● Tempo (em Horas:Minutos) que o usuário esteve conectado ao sistema.
C
aso o usuário ainda esteja logado no sistema ao invés de trazer a hora de finaliza ção do evento (hora em que ocorreu o logout) e o tempo que o usuário permaneceu
logado (duração do evento) será exibida a mensagem still logged in.
73
Podemos utilizar o comando last passando um argumento, que será pesquisado como uma
expressão regulares durante a listagem, por exemplo, podemos passar o nome de um determinado usuário.
# last robsonp robsonp pts/4
:0.0
Tue Sep 15 10:56 still logged in robsonp pts/3
:0.0
Mon Sep 14 18:45 still logged in robsonp pts/3
:0.0
Mon Sep 14 17:01 17:01 (00:00) robsonp pts/3
:0.0
Mon Sep 14 11:12 11:12 (00:00) robsonp pts/2
:0.0
:0.0
:0.0
Fri Sep 11 17:41 still logged in robsonp tty7
:0
Fri Sep 11 16:43 still logged in robsonp tty7
:0
Fri Sep 11 16:43 16:43 (00:00) robsonp pts/0
10.15.15.32
Fri Sep 4 08:56 08:57 (00:00) robsonp pts/0
:0.0
Thu Sep 3 18:15 18:26 (00:10) robsonp pts/0
10.15.15.32
Wed Sep 2 09:20 09:25 (00:04) robsonp pts/0
10.15.15.32
Wed Sep 2 09:16 09:17 (00:01) robsonp tty1
Tue Sep 1 18:00 18:00 (00:00) wtmp begins Tue Sep 1 14:54:31 2009 No exemplo acima temos todas as atividades de login e logout do usuário robsonp. Na primeira coluna informa o nome do usuário, a segunda informa o terminal acessado, a terceira mostra o hostname/ip das conexões remotas e a console das conexões locais, a quarta coluna apresenta o dia da semana, o mês, o dia, a hora de início e de término da conexão 8, e a última coluna
trás o tempo total de duração da seção. Podemos ainda utilizar o comando last com os seguintes
parâmetros:
-n [num] – mostra na listagem somente número de linhas passada com o parâmetro, a partir
do início da listagem.
-R – faz com que não seja exibido, na listagem, o campo hostname.
-a – faz com que o campo hostname seja exibido na última coluna.
-d – consulta o DNS para resolver os IP remotos exibindo assim, quando possível, o nome
DNS, no lugar do endereço IP.
-i – força para que seja mostrado o endereço IP ao invés do nome DNS nas conexões remotas.
Segue abaixo alguns exemplos de utilização do comando last.
# last a robsonp robsonp pts/4
robsonp pts/3
Tue Sep 15 10:56 still logged in
Mon Sep 14 18:45 still logged in
:0.0
:0.0
8 As conexões não encerradas apresentam a mensagem still logged in no lugar da hora de encerramento e do tempo
de acesso.
74
robsonp
robsonp
robsonp
robsonp
robsonp
robsonp
robsonp
robsonp
robsonp
robsonp
robsonp
pts/3
Mon Sep 14 17:01 17:01 (00:00) :0.0
pts/3
Mon Sep 14 11:12 11:12 (00:00) :0.0
pts/2
:0.0
pts/1
:0.0
pts/0
Fri Sep 11 17:41 still logged in
:0.0
tty7
:0
tty7
Fri Sep 11 16:43 16:43 (00:00) :0
pts/0
Fri Sep 4 08:56 08:57 (00:00)
10.15.15.32
pts/0
Thu Sep 3 18:15 18:26 (00:10) :0.0
pts/0
Wed Sep 2 09:20 09:25 (00:04)
10.15.15.32
pts/0
Wed Sep 2 09:16 09:17 (00:01) 10.15.15.32
wtmp begins Tue Sep 1 14:54:31 2009 No exemplo acima foi usado o parâmetro “-a” para que a coluna com os hostnames fosse
apresentada como a última coluna da listagem, facilitando assim sua identificação.
# last n 2 robsonp robsonp pts/4
robsonp pts/3
wtmp
begins
Tue Sep 1 14:54:31 2009 :0.0
:0.0
No exemplo acima utilizamos a opção “-n 2” para que só fossem exibidas as 2 (duas) primeiras linas da listagem.
# last R robsonp robsonp
pts/4
robsonp
pts/3
robsonp
pts/3
Mon Sep 14 17:01 17:01 (00:00)
robsonp
pts/3
Mon Sep 14 11:12 11:12 (00:00)
robsonp
pts/2
robsonp
pts/1
robsonp
pts/0
robsonp
tty7
robsonp
tty7
Fri Sep 11 16:43 16:43 (00:00)
robsonp
pts/0
Fri Sep 4 08:56 08:57 (00:00)
robsonp
pts/0
Thu Sep 3 18:15 18:26 (00:10)
robsonp
pts/0
Wed Sep 2 09:16 09:17 (00:01)
wtmp begins Tue Sep 1 14:54:31 2009 No exemplo acima utilizamos o parâmetro “-R” para que fosse excluída, na exibição da listagem, a coluna com os hostnames. Esta opção é muito utilizada nos casos onde só há conexões
locais na máquina.
LASTLOG
Este comando mostra informações referentes ao ultimo login dos usuários cadastrados no
75
sistema. Essas informações veêm numa listagem que apresenta o nome usado no login, o terminal onde ocorreu a conexão e a hora da última conexão. Para obtenção dessas informações o comando lastlog pesquisa no arquivo “/var/log/lastlog”.
Sintaxe: lastlog <opções> <argumentos do parâmetro>9
N
os casos o usuário nunca chegou a efetuar login na máquina, é mostrada, na coluna de ultima conexão, a mensagem ** Nunca logou**.
# lastlog
Nome de Usuário Porta De Último robsonp pts/0 10.15.15.32 Sex Set 4 08:56:34 0300 2009 faustomarinho **Nunca logou** rodrigosl **Nunca logou** fcamargo pts/3 ecelepar11940 Sex Set 11 11:09:38 0300 2009 jmmoura **Nunca logou** No exemplo acima temos a saída do comando lastalog sem ter sido passado nenhum parâmetro, o resultado é uma listagem dos usuários cadastrados para login na máquina em uso, com o
terminal onde ocorreu o login, o hostsname a partir de onde foi feito o login e a data e hora do último login.
Podemos passar como parâmetros para este comando as opções:
-u <usuário> – exibe informações referentes apenas ao usuário especificado. Também é
possível passarmos como argumento para este parâmetro um número de UID ou um range de
UID's a ser consultado.
-t <dias> – exibe informações referentes aos últimos logins dos usuários nos últimos “x” dia.
Onde “x” representa o número passado junto ao parâmetro “-t”.
-b <dias> – exibe somente as informações referentes ao último login dos usuários cadastrados mais antigos que a quantidade de dias especificadas junto ao parâmetro “-b”.
Segue abaixo um exemplo de utilização do comando lastlog.
# lastlog u 10002000 Nome de Usuário Porta De Último anapalmeira **Nunca logou** bpedrassani **Nunca logou** capaverde **Nunca logou** carmenb **Nunca logou** celia **Nunca logou** dsvieira **Nunca logou** 9 Os argumentos só precisam serem passados se o parâmetro utilizado requerer.
76
edeval **Nunca logou** No exemplo acima estão sendo listados as informações referentes aos usuários que possuem UID que vão de 1000 (mil) a 2000 (dois mil). Neste caso todos os usuários listados nunca efetuaram login na máquina em uso.
NEWUSERS
Com o comando newusers podemos criar vários usuários de uma única vez, através de uma
relação de usuários existentes num arquivo. Ao utilizarmos este comando, o usuário é inserido no
arquivo passwd, a senha é criptografada e inserida no arquivo shadown e o diretório pessoal do
usuário (/home/<usuário>) é criado.
Sintaxe: newusers <arquivo>
O arquivo com os usuários a serem criados que será apontado para uso com o comando
newusers deve ter a seguinte estrutura:
user_name:senha:uid:gid:comentário:diretorio_pessoal:/bin/bash
Segue abaixo um exemplo de arquivo Usuarios.txt configurado corretamente para inserção
de vários usuários:
joao:filho:1010:1010::/home/joao:/bin/bash
maria:naosei:1011:1011::/home/maria:/bin/bash
administrador:@dminstrador:1012:1012::/home/administrador:/bin/bash
Para usarmos o comando newusers para inserção dos usuários constantes no arquivo acima descrito (Usuarios.txt) basta usarmos o comando abaixo:
# newusers usuario.txt
Executando este comando os usuários nele contidos serão criados, e inseridos nos grupos
no arquivo referenciados, caso os grupos não existam os mesmo serão criados, e o diretório pessoal do usuário também será criado.
STAT
O comando stat é uma ferramenta extremamente útil para extrair informações de arquivo e
sistemas de arquivos.
Sintaxe: stat [opções] [arquivo]
As opções do comando stat são:
-L – esta opção faz com que o link seja seguido para exibição das informações, ou seja,
quando utilizamos esta opção na consulta de um link são exibidas as informações referentes ao
77
arquivo que o link referencia.
-f – esta opção faz com que sejam exibidas as informações referentes ao sistema de arquivos no qual pertence o arquivo consultado invés de trazer informações sobre o arquivo.
-t – esta opção faz com que as informações sejam exibidas de forma concisa.
-c '<opções>' – esta opção permite que seja passados parâmetros para definição do formato da saída deste comando, inserindo sempre uma nova linha ao término da exibição das informações.
--printf ',opções>' – esta opção é similar a opção anterior (-c), diferente apenas no fato de
que esta opção permite a utilização de caracteres de escape e de que após a exibição das informações, por padrão, não é inserida uma nova linha.
A seguir temos as principais opções que podem ser passadas como parâmetro com as opções “-c” e “--printf”, essas opções não são válidas para exibição de informações referentes a sistemas de arquivos.
%a
Exibe as permissões do arquivo no modo octal
%A
Exibe as permissões do arquivo no modo texto
%b
Exibe o número de blocos utilizados para alocação do arquivo
%B
Exibe, em bytes, o tamanho dos blocos listados pela opção “%b”
%F
Exibe informações sobre o tipo de arquivo
%g
Exibe o GID do arquivo
%G
Exibe o nome de do grupo do arquivo
%h
Exibe o número de hardlinks
%i
Exibe o número do Inode do arquivo
%n
Exibe o nome do arquivo especificado no comando
%N
78
Exibe o nome do arquivo especificado no comando exibindo,para os links simbólicos, informações sobre o arquivo de referência
%s
Exibe o tamanho do arquivo em bytes
%u
Exibe o UID do dono da pasta
%U
Exibe o nome do dono do arquivo
%x
Exibe a data e hora do último acesso ao arquivo
%y
Exibe a data e hora da última alteração realizada no arquivo
A seguir temos as principais opções que podem ser passadas como parâmetro om as opções “-fc” e “-f --printf” na obtenção de informações sobre o sistema de arquivos.
%b
Exibe o total de blocos de dados no sistema de arquivos
%f
Exibe o total de blocos livres no sistema de arquivos
%l
%T
Exibe o comprimento máximo para os nomes de arquivos e pastas suportado
pelo sistema de arquivos
Exibe o tipo do sistema de arquivos
A seguir temos alguns exemplos de utilização do comando stat:
~# stat linkSimbolico
File: `linkSimbolico' > `test' Size: 4 Blocks: 0 IO Block: 4096 link simbólico Device: 802h/2050d Inode: 51764907 Links: 1 Access: (0777/lrwxrwxrwx) Uid: ( 0/ root) Gid: ( 0/ root) Access: 20091014 11:08:41.393662080 0300 Modify: 20091014 10:41:18.337661920 0300 Change: 20091014 10:41:18.337661920 0300 ~# stat L linkSimbolico File: `linkSimbolico' Size: 28 Blocks: 8 IO Block: 4096 arquivo comum Device: 802h/2050d Inode: 51476276 Links: 1 Access: (0644/rwrr) Uid: ( 0/ root) Gid: ( 0/ root) Access: 20090914 16:53:48.026942240 0300 Modify: 20090914 16:53:34.230943160 0300 Change: 20090914 16:53:34.230943160 0300 Nos exemplos acima estamos, primeiro, utilizando o comando stat para exibir as informações referentes ao arquivo “linkSimbolico” e, baseado nas informações retornadas, percebemos
que se trata de um link simbólico. No segundo comando utilizamos a opção “-L” para que fossem
exibidas as informações referentes ao arquivo que o link simbólico esta apontando.
~# stat f linkSimbolico File: "linkSimbolico" ID: 80200000000 Namelen: 255 Type: xfs Block size: 4096 Fundamental block size: 4096 Blocks: Total: 3903243 Free: 2527451 Available: 2527451 Inodes: Total: 15623168 Free: 15468876
Neste outro exemplo, utilizamos a opção “-f” para que fossem exibidas as informações referentes ao sistema de arquivos que o arquivo “linkSimbolico” pertence, ao invés de trazer as infor79
mações referentes ao arquivo.
~# stat c 'Arquivo=%n; Permissões=%a; Dono=%U; Grupo=%G' teste Arquivo=teste; Permissões=644; Dono=robsonp; Grupo=root
No exemplo acima, utilizamos o comando stat com o parâmetro “-c” para personalizarmos a
saída do comando sendo que o %n para mostrar o nome do arquivo, %a para mostrar as permissões no modo octal, %U para mostrar o dono do arquivo e %G mostrar o grupo do arquivo.
~# stat printf 'Arquivo=%n\nPermissões=%a\nDono=%U\nGrupo=%G\n' teste Arquivo=teste Permissões=644 Dono=robsonp Grupo=root No exemplo acima, utilizamos o comando stat de forma similar ao exemplo anterior só desta
vez alterando o parâmetro “-c” por ”--printf” e inserindo o caractere de escape “\n” para que as informações fossem exibidas uma em cada linha. Tanto neste exemplo quanto no anterior optei por
escrever, antes de passar o parâmetro, um texto indicativo da informação apresentada. Esse texto
indicativo é opcional.
CONVERT
Este comando faz parte do pacote imageMagick, ele possibilita a conversão de imagem entre os principais formatos de imagem (.png , .jpg, .gif, ...). Além converter as imagem o convert
possibilita a aplicação de uma grande quantidade de efeitos e até mesmo a criação de imagens.
Sua sintaxe é:
$ convert <arquivo origem> <opções> <arquivo destino>
Abaixo mostraremos algumas das várias possibilidades que o comando nos traz.
Imagine a seguinte situação, você tem uma pasta com várias imagens, por exemplo, no formato “.jpg” e você deseja criar um catálogo em PDF para apresentação dessas imagens de forma
mais organizada. Com o comando convet conseguirmos criar este catálogo de forma simples e rápida, para isso basta, na pasta onde estão as figuras, digitarmos na linha de comando:
$ convert *.jpg catalogo.pdf
Uma outra possibilidade para este comando seria na versão de entre os principais formatos
de imagens por exemplo, para convertermos um arquivo “.jpg” para “.png” basta:
80
$ convert arquivo.jpg novoArquivo.png
Também é possível utilizarmos o comando convert para redimensionarmos uma imagem
através da opção “-resize”. Para reduzirmos o tamanho de uma imagem na metade basta:
$ convert arquivo.png resize 50% arquivoreduzido.png
Figura 7: Exemplo resultado de uso do comando convert
Para obtermos mais informações sobre as possibilidades de uso do comando convert podem ser encontradas no manual do comando.
CONVMV
Existem diferentes tipos de padrões de codificação de caracteres que podem ser aplicados
aos arquivos. Sendo os dois mais utilizados o iso-8859-1 e UTF-8. Alguns sistemas operacionais
mais antigos (windows xp e kurumin são alguns deles) utilizam o sistema de codificação, reconhecido pelos padrões internacionais como sendo do ocidente europeu, iso-8859-1 (este padrão também é usado no Brasil), mas um novo padrão começou a ser utilizado por várias distribuições e
sistemas operacionais (debian, ubuntu e Windows Vista são exemplos) esse novo padrão é o
UTF-8, que é considerado por muitos como a nova padronização internacional. E é justamente a
co-existência desses dois padrões de codificação que acabam causando os problemas com caracteres especiais (palavras acentuadas no corpo e no nome dos arquivos). Um arquivo criado
sobre codificação iso-8859-1 aparece com caracteres acentuados totalmente errados em um sistema configurado para entender a codificação UTF-8, e vice-versa.
O comando “convmv” serve para resolvermos esse problema de codificação do nome dos
arquivos. Pois com ele, podemos converter o nome dos arquivos do formato iso-8859-1 para
UTF-8 ou vice e versa. Sua sintaxe é :
$ convmv <opções> <arquivos ou diretórios>
Para podermos converter o nome de um arquivo ou diretório devemos dizer qual a codificação atual, qual a codificação desejada e qual o arquivo ou diretório. Como mostra o exemplo abaixo:
$ convmv f iso88591 t utf8 relat?orio.txt
No exemplo acima a opção “-f” é o parâmetro utilizado para passar qual a codificação atual,
e o parâmetro “-t” permite passarmos para qual codificação queremos alterar o arquivo. Quando
81
inserirmos o nome do arquivo substituímos o caractere estranho pelo caractere coringa “?”. Caso
tivéssemos completado o nome do arquivo pressionando a tecla <tab> poderíamos também ter
deixado o nome do arquivo com caractere que aparecer no terminal.
O Comando acima descrito gerará a seguinte saída:
Starting a dry run without changes... mv "./relat�rio.txt" "./rela
tório.txt" No changes to your files done. Use notest to finally rename the files.
Essa saída nos mostra que a alteração pode ser feita sem erros. Após isso para gravar a alteração no arquivo basta repetirmos o comando utilizando a opção “--noteste”, como mostra
exemplo abaixo.
$ convmv f iso88591 t utf8 relat?rio.txt –notest
ICONV
Como vimos anteriormente quando estudamos o comando convmv, existem vários padrões
de codificação de caracteres o que pode causar problemas na exibição de caracteres especiais
como acentuações, cedilha, etc.... Com o comando iconv podemos converter a codificação de caractere de um arquivo para a mesma codificação utilizada no sistema, resolvendo assim o problema de exibição dos caracteres especiais.
Sintaxe: iconv -f <codificação de origem> -t <codificação de saída> <arquivo>
Quando utilizamos o comando iconv é exibido na tela o conteúdo do arquivo especificado no
comando com a aplicação da codificação de caractere especificada no comando, mas não é feita
nenhuma alteração no arquivo original. A seguir segue a visualização, através do terminal, de um
arquivo com a codificação iso-8859-1 num sistema que utiliza a codificação UTF-8.
$ cat texto Debian � simultaneamente o nome de uma distribui��o n�o comercial livre (gratuita e de c�digo fonte aberto) de GNU/Linux (amplamente utilizada) e de um grupo de volunt�rios que o mant�m � volta do mun
do. Uma vez que o Debian se baseia fortemente no projecto GNU, � usualmente chamado Debian GNU/Linux. O Debian � especialmente conhe
cido pelo seu sistema de gest�o de pacotes, chamado APT, que permi
te: atualiza��es relativamente f�ceis a partir de vers�es realmente antigas; instala��es quase sem esfor�o de novos pacotes e remo��es limpas dos pacotes antigos. Atualmente o Debian Stable, se encontra na vers�o 5.0, codinome "Lenny". O Debian Stable procura sempre man
ter os pacotes mais est�veis, assim, ele mant�m o Gnome 2.22 e o KDE 3.5 por padr�o. O grande fato dele conter pacotes mais antigos, ga
rantindo a estabilidade, � o grande foco para servidores.
Agora vamos utilizar o comando iconv para visualização do arquivo na codificação correta.
$ iconv f iso88591 t UTF8 texto 82
Debian é simultaneamente o nome de uma distribuição não comercial livre (gratuita e de código fonte aberto) de GNU/Linux (amplamente utilizada) e de um grupo de voluntários que o mantêm à volta do mun
do. Uma vez que o Debian se baseia fortemente no projecto GNU, é usualmente chamado Debian GNU/Linux. O Debian é especialmente conhe
cido pelo seu sistema de gestão de pacotes, chamado APT, que permi
te: atualizações relativamente fáceis a partir de versões realmente antigas; instalações quase sem esforço de novos pacotes e remoções limpas dos pacotes antigos. Atualmente o Debian Stable, se encontra na versão 5.0, codinome "Lenny". O Debian Stable procura sempre man
ter os pacotes mais estáveis, assim, ele mantém o Gnome 2.22 e o KDE 3.5 por padrão. O grande fato dele conter pacotes mais antigos, ga
rantindo a estabilidade, é o grande foco para servidores. Acima temos a visualização apresentada anteriormente com a codificação de caractere
como iso-8859-1 convertida para codificação UTF-8. No entanto essa alteração de codificação
não foi gravada no arquivo, simplesmente foi exibida na tela. Para armazenarmos essa alteração
de codificação precisamos utilizar o parâmetro “-o <nome do arquivo>” ou redirecionar para um
novo arquivo. Como mostra os exemplos abaixo:
$ iconv f iso88591 t UTF8 texto o texto_utf8
ou
$ iconv f iso88591 t UTF8 texto > texto_utf8
Identificando a codificação de caractere do arquivo e a do sistema
Para identificarmos qual a codificação de caractere de um arquivo podemos utilizar o comando file.
# file texto.txt texto.txt: UTF8 Unicode text, with very long lines
No exemplo acima percebemos que o arquivo “texto.txt” utiliza a codificação de caractere
UTF-8.
# file texto texto: ISO8859 text, with very long lines
No exemplo acima percebemos que o arquivo “texto” utiliza a codificação de caractere ISO8859-1.
Para identificarmos qual a codificação de caracteres que esta sendo utilizada pelo nosso sistema operacional podemos utilizar o comando locale. O antigo charset padrão do Linux era o ISO8859-1 (também conhecido como Latin1). Por isso, quando encontrarmos os parâmetros de configuração pt_BR ou pt_BR.ISO8859-1 são representações para a codificação de caractere ISO8859-1. Se aparecer algo como pt_BR.UTF-8 representa que a codificação de caractere é UTF-8.
# locale 83
LANG=pt_BR.UTF8 LANGUAGE=pt_BR:pt:en LC_CTYPE="pt_BR.UTF8" LC_NUMERIC="pt_BR.UTF8" LC_TIME="pt_BR.UTF8" LC_COLLATE="pt_BR.UTF8" LC_MONETARY="pt_BR.UTF8" LC_MESSAGES="pt_BR.UTF8" LC_PAPER="pt_BR.UTF8" LC_NAME="pt_BR.UTF8" LC_ADDRESS="pt_BR.UTF8" LC_TELEPHONE="pt_BR.UTF8" LC_MEASUREMENT="pt_BR.UTF8" LC_IDENTIFICATION="pt_BR.UTF8" LC_ALL= No exemplo acima podemos perceber que a codificação de caracteres utilizada pelo sistema
é o UTF-8.
PASTE
Este comando mescla o conteúdo de dois arquivos em colunas verticais, ou seja, mescla os
arquivos deixando seus conteúdos lado a lado.
Sintaxe: paste [arquivo 1] [arquivo 2]
A seguir temos opções mais usadas do comando paste:
-d '<caractere>' – esta opção separa as colunas com o símbolo (caractere) especificado
dentro das aspas.
-s – esta opção faz com que a concatenação seja feita em linhas ao invés de colunas, ou
seja, o conteúdo dos arquivos serão exibidos em linhas ao invés de colunas.
Temos a seguir alguns exemplos de utilização do comando paste:
# paste a b 12 a 23 b 45 c 1 d 40 e 37 f No exemplo acima temos o arquivo “a” cujo conteúdo é: 12, 23, 45, 1, 40, 37 e um arquivo
“b” cujo conteúdo é: a, b, c, d, e, f. Utilizamos o comando paste para exibir de forma concatenada
o conteúdo dos arquivos.
84
# paste d '@' nomes email [email protected] [email protected] [email protected] [email protected]
No exemplo acima temos um arquivo “nomes” que tem como conteúdo uma relação de nomes, e o arquivo “email” que tem como conteúdo vários provedores de e-mail. Foi utilizado o comando paste com o parâmetro “-d” para inserir o caractere “@” como separador de colunas.
# paste s a 12 23 45 1 40 37
No exemplo acima usamos o mesmo arquivo “a” utilizado anteriormente, mas desta vez passamos o parâmetro “-s” para que o seu conteúdo fosse exibido em forma de linha e não de coluna.
# cat a | paste 12 23 45 1 40 37
No exemplo acima temos uma outra possibilidade de uso do comando paste. Neste caso estamos utilizando o comando cat para visualizarmos o conteúdo do arquivo “a” e concatenamos a
saída desse comando para uso com o comando paste. Foi feito uso do “-” (traço) possibilita definir
o numero de colunas desejada para exibição do conteúdo do arquivo. Neste caso utilizamos 3
(três) “-” (traços) para que o conteúdo do arquivo “a” fosse exibido em 3 (três) colunas.
CUT
Este comando é muito útil e, em geral, seu uso ocorre de forma concatenada com outros comandos. O “cut” permite cortar trechos de colunas de um determinado arquivo ou de uma saída.
Na utilização do do “cut” devemos sempre passar algum parâmetro determinado o que deverá ser exibido de cada coluna consultada, essa determinação pode ser feita, basicamente, pelo
número de campos, pelo número de bytes ou pelo número de caracteres a serem exibidos. A sintaxe básica deste comando é:
cut opções... [arquivo]...
Antes de entendermos melhor a utilização do comando “cut” vamos conhecer as principais
opções disponíveis para utilização como parâmetro do comando.
-b BI-BF: para delimitarmos através pelo número de bytes, onde BI representa byte inicial e
BF o byte final.
-c CI-CF: para delimitarmos através pelo número de caracteres, onde Ci representa caractere inicial e CF caractere final.
85
-d “<caractere>”: para determinarmos qual caractere será considerado como delimitador
de campo, onde devemos representar entre aspas duplas ou simples qual será o caractere delimitador.
-f FI-FF: para determinarmos os campos desejados, onde FI representa campo (coluna) inicial e FF campo (coluna) final.
A
s expressões utilizadas com os parâmetros acima podem ser utilizadas, também
com as seguintes variações (nas descrições a seguir consideraremos “N” para um
número qualquer, utilizaremos como exemplo a opção “-f” mas estas variações podem
ser utilizadas também para as opções: “-b” e “-c”)
-f “2-5,9-11,15”: neste exemplo estamos mandando exibir as colunas de 2 a 5 e de 9 a
11 e o 15
-f “5-”: neste exemplo estamos mandando exibir todas as colunas a partir da quinta.
-f “-3”: neste exemplo estamos mandando exibir todas as colunas a partir da primeira
até a terceira.
E
m nenhuma das expressões acima citadas é obrigatório o uso das aspas (sendo
que também poderiam ter sido utilizadas aspas simples), mas por uma questão de
melhor visualização do comando sugiro as mesmas sempre sejam utilizadas.
Agora vamos ver alguns exemplos para melhor entendermos a utilização do comando “cut”.
Vamos imaginar que por algum motivo estratégico foi solicitado que gerássemos uma lista
de todos os usuários que possam logar numa determinada máquina cuja autenticação é local.
Sabemos que as informações sobre os usuários cadastrados localmente no sistema estão
no arquivo /etc/passwd e que nele tem várias informações não relevantes ao que necessitamos
relatar. Para eliminarmos as informações não desejadas vamos utilizar o comando “cut”.
Vamos analisar uma linha do passwd para entendermos melhor a sintaxe utilizado com o comando “cut”. Segue abaixo linha do arquivo “/etc/passwd”.
parana:x:1000:1000:Desktop Parana,,,:/home/parana:/bin/bash
Através do exemplo acima podemos reparar que em cada linha do arquivo passwd sempre
temos 7 campos separados por : (dois pontos), ou seja temos um padrão na separação (delimitação) dos campos. Visto isso esta na hora de usarmos o comando “cut” para separamos da exibição as colunas não desejadas.
C
omo citado anteriormente para usar o comando “cut” precisamos sempre passar algum parâmetro, para isso devemos ter em mente basicamente duas coisas:
-1 Onde vamos cortar, ou seja, qual padrão será utilizado para cortar? (Neste momento
definimos qual das opções será mais indicada para nossa necessidade, devemos cortar a partir de um determinado número de caracteres, devemos cortar por um determinado número de campos, etc...).
86
-2 Depois de cortar, o que vamos mostrar? (Após definido o padrão a ser utilizado basta indicar o que deve ser exibido).
Para o nosso exemplo o mais indicado é utilizarmos a delimitação de campos uma vez que
os temos bem definidos através dos : (dois pontos). A informação que precisamos esta na primeira
coluna, ou seja, no primeiro campo do arquivo “/etc/passwd”, considerando isso, podemos utilizar
o comando da seguinte forma:
$ cut d ”:” f 1 /etc/passwd
No comando acima utilizamos o parâmetro “-d ” para identificarmos o caractere que delimitaria os campos (“Corte em cima dos “:” (d = delimitador)), em seguida utilizamos o parâmetro “-f”
para indicarmos o que deveria ser exibido, no caso somente a primeira coluna (“Mostre apenas o
campo (f - field - campo) 1 (um) do arquivo passwd”).
V
ale observarmos que para que o comando “cut” funcione corretamente com os parâmetros acima utilizados todas as linhas do arquivo de origem dos dados devem ter o
delimitador definido, no nosso caso todas as linhas devem ter “:” (dois pontos).
Imagine agora uma outra situação onde você precisa listar o nome e a versão todos os pacotes que estão completamente instalados em seu sistema. Para ter o resultado esperado nós teremos que listar todos os pacotes instalados, filtrar aqueles que estão totalmente instalados e em
seguida recortar as informações indesejáveis e exibir somente o nome e a versão dos pacotes instalados completamente.
Para listarmos todos os pacotes instalados basta utilizarmos o comando:
$ dpkg l |grep “îi”
Agora nos deparamos com um problema pois utilizando o comando “cut” conseguimos fazer
exibir ou o nome do pacote ou a sua versão mas não ambas as informações como necessitamos.
Para resolvermos esta situação basta utilizarmos o “cut” para armazenarmos estas informações
em arquivos diferentes e depois unirmos seus conteúdos.
$ dpkg l |grep “îi” |cut d' ' f3 > arq1
Com o comando acima nós gravamos o nome dos arquivos completamente instalados no arquivo “arq1”. Pois com o parâmetro “-d' '” estamos definindo que o “ “ (espaço) é o delimitador de
campo (coluna) e com o parâmetro “-f3” estamos definindo que deve ser exibida a terceira coluna.
$ dpkg l |grep “îi” | cut c 42 | cut d' ' f1 > arq2
Com o comando acima gravamos as versões dos pacotes instalados no arquivo “arq2”. Note
87
que para isso usamos primeiro o parâmetro “-c 42” para exibir todo o conteúdo a partir do 42 (quadragésimo segundo) caractere, pois o número de “ “ (espaços) que temos do final de cada nome
de pacote até o inicio do número das versões não é homogêneo o impossibilita o uso das opções
de campos. Em seguida utilizamos o comando “cut” com os parâmetros “-d' '” para definir o delimitador como “ “ (espaço) e “-f1” Para exibirmos somente a primeira coluna (a coluna da versões).
Agora basta unirmos ambos os arquivos num só uma das opções que temos para fazer isso
é utilizando comando “paste”, que estudaremos mais detalhadamente a seguir. Para conclusão do
nosso exemplo basta utilizarmos o comando:
$ paste d' ' arq1 arq2 > lista
O resultado desse comando será um arquivo com o nome “lista” que contém a nossa relação com o nome dos pacotes e suas versões. Como mostra abaixo trecho do arquivo.
xnest 2:1.4.210 xsane 0.9961 xsanecommon 0.9961 xserverxorg 1:7.3+18 xserverxorgcore 2:1.4.210 xserverxorginputall 1:7.3+18 xserverxorginputevdev 1:2.0.81 DD
A forma mais comum de utilização do comando “dd” é para copiar blocos de dados de um
dispositivo de armazenamento, também podemos utilizar este programa para efetuar algumas
conversões em arquivos.
Quando utilizamos o comando “dd” para efetuarmos uma cópia de um dispositivo e armazenamento, todos os dados são copiados a nível de bloco, não interessando o tipo do sistema de arquivos utilizado no dispositivo. A sintaxe do comando é:
dd if=<origem> of=<destino> <opções>
Como mostra o exemplo acima após o comando “dd” temos o parâmetro “if=” onde especificamos a origem que pode ser um dispositivo (partição) ou um arquivo, em seguida temos o parâmero “of=” que assim como o parâmetro anterior pode receber a especificação de um dispositivo
ou de um arquivo. Logo após passamos as opções do comando, sendo que a especificação das
opções é facultativa.
Este comando é muito útil em algumas situações práticas como por exemplo para limparmos
os dados da MBR, fazermos cópias fiéis de uma partição ou até mesmo de um disco inteiro, etc.
Dentre as opções disponíveis para serem passada com o comando “dd” destacamos as op88
ções:
bs: através desta opção podemos definir o tamanho do bloco que será copiado, caso esta
•
opção não seja passada com o comando, será adotado como tamanho de bloco o valor
padrão e 4k. Quando definimos um tamanho de boco obrigatoriamente temos que passar
também o parâmetro “count”.
count: esta opção permite determinar a quantidade de blocos que serão copiados. Desta
•
forma se quisermos copiar uma partição de 10GB, onde definimos que o tamanho do bloco
é de 1GB, para copiarmos toda a partição deveríamos definir a quantidade de blocos a serem copiados como 10.
conv: este parâmetro serve para efetuarmos a conversão de arquivos ou partições, junto
•
com esta opção devemos passar um argumento que definirá que tipo de conversão será
realizada. As principais opções são: ascii para converter de EBCDIC para ASCII ; ebcdic
para converter de ASCII para EBCDIC ; lcase para alterar as letras de maiúsculas para minúsculas e ucase para alterar as letras de minúsculas para maiúsculas .
Segue abaixo alguns exemplos de utilização do co,mando ”d”.
Para fazermos um backup da MBR podemos utilizar o comando abaixo listado.
dd if=/dev/sda of=/home/parana/MBR.bkp bs=512 count=1
A linha de comando do exemplo acima esta fazendo uma cópia da MBR do disco sda
no arquivo “MBR.bkp”. O parâmetro “bs” esta especificando o tamanho do bloco a ser copiado e o
parâmetro “count” esta especificando o número de blocos a serem copiados.
Para restaurarmos este backup basta efetuarmos este mesmo comando só que trocando o
argumento passado para o “of” com o argumento passado para o “if”, como mostra o exemplo
abaixo.
dd if=/home/parana/MBR.bkp of=/dev/sda bs=512 count=1
No exemplo acima estamos especificando através do parâmetro “if” que a otrigem é o arquivo MBR.bkp, com o parâmetro “of” estamos especificando que o destino é o dispositivo sda, e
com os parâmetros “bs” e “count” estamos especificando, respectivamente, o tamanho do bloco a
e a quantidade e blocos a serem copiados.
Uma outra possibilidade seria se quiséssemos na restauração manter as informações referentes à tabela de partição. Neste caso bastaria, no comando para restauração, especificar o tamanho de bloco como 446k, espaço da MBR utilizado para armazenar as informações de boot.
Como mostra o exemplo abaixo.
89
dd if=/home/parana/MBR.bkp of=/dev/sda bs=446 count=1
T
anto o gerenciador de boot quanto a tabela de particionamento do HD são salvos no
primeiro setor do HD, a famosa trilha MBR, que contém apenas 512 bytes. Destes,
446 bytes são reservados para o setor de boot, enquanto os outros 66 bytes guardam a
tabela de partição. (Site Guia do Hardware: fazendo-backup-recuperando-mbr-tabelaparticoes)
Se quisermos limpar a MBR podemos utilizar o seguinte comando:
dd if=/dev/zero of=/dev/sda bs=512 count=1
No exemplo acima estamos preenchendo com o valor zero os primeiros 512 bytes (a MBR)
do disco. O parâmetro “if=/dev/zero” vai preencher o destino indicado, no nosso caso a MBR, com
valores zero.
Um outro uso, não muito comum, para o comando “dd” é com a utilização das opções de
conversão. Imagine por exemplo que temos um arquivo onde o seu conteúdo esta todo em letras
maiúsculas e por algum motivo precisamos que este conteúdo esteja em letras minúsculas, podemo utilizar o comando a seguir para fazer a conversão.
dd if=arquivoMaiuscula of=arquivoMinuscula conv=lcase
Neste exemplo estamos especificando o arquivo a ser convertido no parâmetro “if”, e no
parâmetro “of” estamos definindo o arquivo que será criado com seu conteúdo com letras minúsculas. A opção “conv” especifica que será realizada uma conversão e o parâmetro “lcase” especifica que a conversão a ser realizada é das letras maiúsculas existentes dentro do documento para
minúsculas.
Se você quiser aprofundar seu conhecimento na utilização do comando “dd” consulte seu
manual.
FIND
Como foi visto no curso básico a principal utilização do comando find é para localização de
arquivos dentro de um sistema de arquivos. Há diversos critérios que podemos usar para melhor
lapidar a busca como por exemplo: nome, tipo, data de modificação, tamanho, proprietário, etc. Vimos também que é possível especificar o local da pesquisa, sendo que quando este não é informado, a pesquisa é feita no diretório atual (que estamos dentro) e seus subdiretórios. A sintaxe
básica do comando find é:
Sintaxe: find <a partir de que local> [parâmetro] <dados para os parâmetro>
Sendo que conforme a sintaxe apresentada só podemos definir um local para pesquisa, po-
90
demos usar quantos parâmetros forem necessários para melhor refinar a pesquisa e podemos
passar, de acordo com o parâmetro utilizado, uma representação de dados para pesquisa. Segue
abaixo, para revisão, tabela com os parâmetros apresentados no módulo básico deste curso.
Parâmetros
Descrição
-name <info> Procura um arquivo ou diretório que possua estritamente o mesmo nome com a
mesma caixa dos caracteres (case sensitive).
Exemplo: #find / -name “Tião Macalé” <ENTER>
Se existir algum arquivo ou diretório com o nome “tião macalé”, não será mostrado
no resultado.
-iname
Procura um arquivo ou diretório que possua estritamente o mesmo nome, mas
permite que a caixa dos caracteres seja diferente (não case sensitive).
Exemplo: #find / -iname “Tião Macalé” <ENTER>
Se existir algum arquivo ou diretório com o nome “tião macalé”, ele será mostrado
no resultado.
-size
Procura arquivos que possuam um determinado tamanho. Você pode definir o
tamanho exato do arquivo (o problema é que, devido aos arredondamentos dos
números reais, que são quebrados, é muito difícil você encontrar um arquivo pelo
tamanho certo), ou definir se deverão ser mostrados arquivos maiores ou menores
que o valor dado ao parâmetro.
Exemplo: #find /boot -size +5M <ENTER>
Você poderá procurar por KB (use o k minúsculo), MB (use o M) e o GB (use o G).
-maxdepth
Define o número máximo de níveis que o comando find deverá descer para fazer
sua pesquisa. O diretório que foi definido com ponto inicial assumirá o valor de
nível 1. Cada nível abaixo deverá ser incrementado pelo número um.
Exemplo: O arquivo oi.txt está dentro de /curso/1/2/3/4/.
$find /curso/1 -maxdepth 4 -name oi.txt <ENTER> Irá encontrar
/curso/1/2/3/4/oi.txt
$find /curso/ -maxdepth 4 -name oi.txt <ENTER> Não irá encontrar, porque ele
parará no diretório /curso/1/2/3.
-mindepth
Define quantos níveis abaixo o comando find deverá descer a partir do local
definido como ponto inicial da pesquisa. O número que você coloca ao lado do
parâmetro é o número de níveis abaixo, contando um no diretório especificado,
que o find deverá iniciar a pesquisa.
Exemplo: agora temos o arquivo eita.txt dentro do diretórios /curso/1/2/.
$find /curso/1 -mindepth 3 -name eita.txt <ENTER> Nada será encontrado.
$find /curso/1 -mindepth 2 -name eita.txt <ENTER> Encontrará.
/curso/1/2/eita.txt
-type
Permite que você pesquise arquivos que sejam somente do tipo que você venha a
especificar, como diretórios, arquivos especiais de bloco, caracteres, links,
socketes, etc. Você só poderá colocar uma letra por vez.
b = arquivos especiais de bloco
c = arquivos especiais de caractere
d = diretórios
l = link simbólico
s = arquivo especial de soquete
p = arquivo especial de pipe
f = arquivos regulares (arquivos normais)
Exemplo: No exemplo abaixo, pedimos ao find que procure todos os arquivos pipe
do computador:
# find / -type p
91
Parâmetros
Descrição
/var/lib/gdm/.gdmfifo
/dev/xconsole
/dev/initctl
Podemos acrescentar como parâmetro do comando find as opções:
-exec <comando> '{}' \; - este parâmetro possibilita a execução de um comando diretamente no resultado da pesquisa efetuada. Logo após o parâmetro “-exec” devemos passar o comando
a ser executado, com seus parâmetros, logo em seguida, entre aspas simples, devemos abrir e
fechar chaves (que representam o resultado da pesquisa que será utilizado com o comando) e por
fim ”;” para especificar o fim do comando a ser executado, lembrando que antes do caractere especial ”;” deve ser utilizada a “\” para denotar a utilização do caractere especial “;” na linha de comando.
Por exemplo, imagine que temos um servidor com que esta com a partição que contém as
pastas compartilhas da rede quase cheia, e por isso, há a necessidade de limpar (excluir) alguns
arquivos para liberar espaço. Detectamos que o compartilhamento de rede “publico” é o que apresenta situação mais critica, então com o comando find identificamos os arquivos que estão utilizando mais espaço e descobrimos que existem vários arquivos de “mp3” que estão indevidamente
gravados na rede. Nesse caso podemos utilizar o comando find para localizar e já remover todos
os arquivos de “mp3” existentes no compartilhamento através do comando:
# find /comp/publico type f iname '*mp3' exec rm f '{}' \;
No comando acima especificamos o local de pesquisa como a pasta onde temos o compartilhamento “publico” especificamos com o parâmetro “-type” que só deveriam ser pesquisados arquivos regulares, com o parâmetro “-iname” especificamos que deveriam ser pesquisados os arquivos que seu nome terminasse com o termo “mp3” e através do parâmetro “-exec” pudemos
passar o comando “rm -f” para excluir os arquivos encontrados como resultado da pesquisa.
-and (a) – este parâmetro possibilita a concatenação de parâmetros no refinamento da pesquisa, possibilitando a utilização de dois ou mais critérios como filtro.
Por exemplo, se quisermos localizar todos os arquivos, no nosso /home, que comecem com
a letra “a” e sejam maiores que 300KB. O comando ficaria:
~$ find type f iname 'a*' and type f size +300k
O comando acima fará com que sejam pesquisados todos os arquivos que comecem com a
letra “a” (através dos parâmetros: “-type” para definir que a pesquisa será realizada somente entre
os arquivos regulares e “-iname” para especificar que são os arquivos em que seu nome comece
com a letra “a”) e que seu tamanho seja maior que 300KB (os parâmetros; “-type” para definir que
92
a pesquisa será realizada somente entre os arquivos regulares e “-size” para especificar somente
os arquivos maiores que 300KB ).
Q
uando utilizamos o parâmetro “-exec” junto com o parâmetro “-and”, devemos utilizá-lo após o “-and” pois caso contrário o comando especificado para execução através do parâmetro “-exec” só será aplicado ao resultado da pesquisa de acordo com os
primeiros critérios estabelecidos, não sendo consideradas as especificações de pesquisa definidas após o parâmetro “-and”.
~$ find type f iname 'a*' and type f size +100k exec rm f {} \;
No exemplo acima estamos excluindo da pasta pessoal todos os arquivos que comecem
com a letra “a” e tenham o tamanho maior que 100 KB. Se tivéssemos utilizado o comando da seguinte forma:
~$ find type f iname 'a*' exec rm f {} \; and type f size +100k
Com esse comando teríamos apagado todos os arquivos que iniciassem com a letra “a” e a
informação de que deveria ter o tamanho maior que 100KB seria ignorada.
-or (o) – este parâmetro permite que sejam utilizados para pesquisa mais de um critério
para pesquisa simultaneamente.
Por exemplo, se quisermos pesquisar todos os arquivos da minha pasta pessoal que comecem com as letras “a” e “b”. Para isso o comando ficaria:
~$ find type f iname 'a*' or type f iname 'b*'
No exemplo acima o find pesquisou primeiro os arquivos que começavam com a letra “a” e
depois os que começavam com a letra “b”.
O
find trabalha de forma independente com as expressões definidas antes e após o
parâmetro “or”. Dessa forma quando utilizamos o parâmetro “-exec” junto com o
parâmetro “-or”, devemos especificá-lo para cada uma das expressões em que queremos executar o comando.
~$ find iname 'a*' or iname 'b*' exec chmod 700 {} \;
No exemplo acima só serão alteradas as permissões dos arquivos 10 que iniciarem com a letra “b”, os que iniciarem com aletra “a” não sofrerão nenhuma alteração.
~$ find iname 'a*' exec 700 {} \;or iname 'b*' exec chmod 700 {} \;
10 Neste caso como não foi especificado o tipo de arquivo através do parâmetro “-type” a alteração de permissão
afetará todos os tipos de arquivos que comecem com a letra “b”, como por exemplo diretórios, links, etc...
93
No exemplo acima esta sendo aplicada a alteração de permissão a todos os arquivos da minha pasta pessoa que comecem com as letras 'a' e “b”.
-atime <Número de dias> – procura por arquivos que tenham seu ultimo acesso conforme
o número de dias passados com o parâmetro. Também é possível definir para serem mostrados
arquivos com o ultimo acesso superior (+) ou inferior (-) ao número de dias passado ao parâmetro.
$find /home/robsonp/documentos/ atime +2
No exemplo acima serão listados todos os arquivos que tiveram seu último acesso a mais
de 2 (dois) dias.
-ctime <Número de dias> - procura por arquivos que tenham sido alterados o número de
dias que foi passados com o parâmetro. Também é possível definir para serem mostrados todos
os arquivos alterados o número de dias especificados com o parâmetro em relação à data atual.
Inserindo antes do número de dias “+” para superio ou “-” para inferior ao número de dias passado
ao parâmetro.
$ find /home/robsonp/documentos ctime 1
No exemplo acima serão listados todos os arquivos que foram alterados a menso de 1 (um)
dia.
-printf “<opções>” - permite especificarmos os termos que serão exibidos no resultado da
pesquisa. Como por exemplo, podemos usar para imprimir somente o nome do arquivo pesquisado e a sua data de alteração, como mostramos a seguir:
~$ find ctime 1 printf "%f %c\n"
As opções mais usadas com o parâmetro “-printf” são:
94
%p
mostra o nome do arquivo com o caminho
%m
mostra a permissão do arquivo no modo octal
%M
Mostra a permissão do arquivo como é mostrado com o comando ls
%f
mostra o nome do arquivo sem o caminho
%g
mostra o nome do grupo do arquivo
%G
mostra o gid
%U
mostra o uid
%h
mostra o nome dos diretórios em que o arquivo esta dentro
%u
mostra o nome do dono do arquivo
%c
mostra a data de alteração do arquivo
%a
mostra tempo de acesso
%AD
imprime a data tipo mês/dia/ano (data de acesso)
%AH
imprime a hora
%AT
hh/mm/ss
%A+
data e tempo separados pro "+"
%Ax
mostra a data de representação conforme a localidade (dd/mm/aaaa)
%n
Mostra o número de hardlinks existentes para um arquivo11
XARGS
O comando xargs utiliza o resultado de um comando enviado à saída padrão e o utiliza
como argumento na execução de um outro comando, uma ou quantas outras vezes forem necessárias.
O
comando xargs não funciona corretamente, podendo apresentar problemas, quando, na saída padrão, forem apresentados nomes de arquivos contendo “ “ (espaço
em branco).
Sintaxe: xargs [opções] [comando]
A seguir temos alguns exemplos de utilização do comando xargs.
~# ls qw | xargs rm f No exemplo acima estamos usando o comando xargs para excluir todos os arquivos existentes no diretório corrente que tenham os mesmos nomes de arquivos que foram retornados pelo
comando “ls” no diretório “qw”. Caso na listagem apresentada na saída padrão contenha algum
nome de arquivo não existente no diretório corrente será apresentada uma mensagem de erro avisando que o arquivo não pode ser removido por não existir.
Vamos imaginar agora uma outra situação onde queremos remover todos os arquivos do diretório corrente, pertencentes a um determinado usuário. Poderíamos, para isso, usar um comando find, da seguinte maneira:
$ find . type f user robsonp exec rm f {} \;
Com isso, seriam apagados todos os arquivos do usuário robsonp, mas fazendo desta forma
seriam removidos não só os arquivos do usuário robsonp contidos no diretório corrente, sem afe11 Se só existir uma referência para o conteúdo do arquivo será mostrado com este parâmetro o valor 1 (um), pois cada
referência ao conteúdo de um arquivo é considerada pelo sistema como um hardlink.
95
tar as subpastas, mas também os de todos os outros subdiretórios existentes a partir do diretório
correntes.
Uma opção para solucionar este problema seria a utilização sa seguinte linha de comando:
$ ls l | grep " robsonp " | cut c44 | xargs rm
Neste caso, o grep filtraria os arquivos listados com o comando “ls -l” que pertenciam ao
usuário robsonp. Com o comando cut pegamos somente o nome dos arquivos, que foram passados ao comando xargs, que fez a ponte para remoção através do comando rm. Evitando assim
que fossem removidos os arquivos do usuário robsonp existentes nos subdiretórios.
E
ste exemplo foi utilizado com o fim didático de apresentar a utilização do comando
xargs, pois é possível realizar esta operação do exemplo somente com o comando
find e seus parâmetros12, para isso utilizaríamos o comando find com os seguintes parâmetros:
find . -maxdepht 1 -type f -user robsonp -exec rm -f {} \;
FSCK
Sintaxe: fsck <opções> <partição>
O fsck checa a consistência e repara possíveis danos num sistema de arquivos. Muitas vezes, acaba sendo automaticamente executado nos sistemas de arquivos e nem nos damos conta
do que esta acontecendo.
Sempre que por algum motivo ocorra um desligamento incorreto (anormal) do computador,
gerando a detecção de inconsistência no sistema de arquivos, fará com que na próxima vez em
que o sistema for iniciado será executado o fsck e, na maioria dos casos, automaticamente corrigirá os problemas encontrados, tais como corrigir blocos defeituosos, etc.... Mas nos casos com
maiores danos é necessário que seja feita uma checagem manual.
É possível que quando temos um problema de inconsistência num sistema de arquivos o
sistema operacional não seja inicializado apresentando durante o processo de boot uma mensagem de erro do fsck. Nesse caso será necessário logar no sistema no modo single user ou através
de um live cd para, através da linha de comando executar o fsck para correção dos erros.
recomendado que a partição com o sistema de arquivos em que será efetuada a
É
restauração com o comando fsck esteja desmontada. O sucesso na recuperação dos
arquivos através do fsck depende diretamente do sistema de arquivos e sua forma de
funcionamento.
Quando utilizamos o fsck temos como retorno um código que representa o resultado de sua
12 Não existe uma real necessidade da utilização do comando xargs, para execução de comandos junto ao comando
find.
96
execução. Esses códigos são a soma das seguintes opções:
● 0 - nenhum erro.
● 1 - erros do sistema de arquivos corrigidos.
● 2 - o sistema deve ser reiniciado.
● 4 - erros do sistema de arquivos não corrigidos.
● 8 - erro operacional.
● 16 - erro de uso ou de sintaxe.
● 128 - erro de biblioteca compartilhada.
Os principais parâmetros do fsck são:
-t: esta opção é utilizada para especificar qual sistema de arquivos será checado.
-a: esta opção faz com que os defeitos sejam reparados automaticamente.
-A: utiliza as informações contidas no arquivo /etc/fstab e tenta verificar todos os sistemas
de arquivos, nele configurados, de uma vez.
-r: esta opção faz com que quando seja encontrada alguma falha, seja solicitada confirmação para sua recuperação.
-V: quando utilizamos esta opção a saída do comando fsck é apresentada de forma mais detalhada.
-N: faz com que seja exibido qual seria o resultado da execução do comando fsck sem que
as alterações sejam efetuadas no sistema de arquivos. Simplesmente mostra uma prévia do seria
feito.
-M: esta opção faz com que o fsck não seja executado em partições montadas, retornando
para elas o código de saída 0 (nenhum erro).
-y: esta opção força para que todas as perguntas durante o processo de restauração recebam a resposta sim, sem a necessidade da interação do usuário.
Segue a baixo um exemplo de utilização do fsck.
# fsck -A -N
fsck 1.41.3 (12-Oct-2008)
[/sbin/fsck.xfs (1) -- /] fsck.xfs /dev/sda2
[/sbin/fsck.ext3 (1) -- /boot] fsck.ext3 /dev/sda1
[/sbin/fsck.xfs (1) -- /home] fsck.xfs /dev/sda4
No exemplo acima o fsck não chegou restaurar as partições listadas. Ele simplesmente re97
tornou que os erros dos sistemas de arquivos seriam corrigidos com exito. No exemplo a seguir o
fsck é executado somente para partição sda4.
# fsck -t xfs /dev/sda4 -N
fsck 1.41.3 (12-Oct-2008)
[/sbin/fsck.xfs (1) -- /home] fsck.xfs /dev/sda4
FUSER
Este comando possibilita que sejam visualizados os processos que estão sendo executados
em um determinado diretório ou arquivo. Além de visualizar o processo, ele permite também que
sejam visualizadas e executadas outras ações como por exemplo visualizar o dono do processo
ou até mesmo matar o processo em execução. A sintaxe do comando é:
Sintaxe: fuser <opções> <Arquivo/Diretório>
Quando utilizamos o comando fuser sem passarmos nenhuma opção, somente apontando
para um diretório ou arquivo, temos como retorno o PID de todos os processos em execução. Na
exibição padrão deste comando temos como retorno o PID de cada processo seguido por uma letra, que indica o tipo de acesso, sendo as mais comumente entradas13:
c : diretório atual (a partir do qual o processo foi inicializado).
e : arquivo sendo executado pelo processo.
r : diretório raiz do sistema (ponto de inicialização do processo).
A seguir, serão apresentadas as principais opções para utilização com o comando fuser.
-u: quando utilizada esta opção é feita uma identificação do usuário dono de cada um dos
processos listados.
-k: quando utilizamos esta opção além de exibirmos os processos do arquivo ou diretórios
especificado, é efetuada a operação de encerramento de cada um dos processos, ou seja, os processos são matados.
-i: esta opção faz com que seja solicitada uma confirmação antes de matar os processos
através da opção “-k”.
-n: esta opção permite visualizar o processo que esta usando uma determinada porta TCP
ou UDP
-v: esta opção faz com que os processos sejam exibidos como uma lista com quatro colunas
com a primeira trás o nome do usuário dono do processo, a segunda coluna trás o PID do processo, a terceira coluna trás as informações de acesso e a quarta coluna trás o comando que iniciou
13 Mais informações sobre as letras de identificação de acesso podem ser obtidas no manual do comando (man fuser).
98
o processo. Segue abaixo exemplo de retorno da utilização do comando fuser com o parâmero -v.
# fuser v /bin/bash USER PID ACCESS COMMAND /bin/bash: robsonp 4547 ...e. soffice robsonp 4808 ...e. bash root 4830 ...e. bash robsonp 6671 ...e. bash root 6693 ...e. bash robsonp 7600 ...e. bash root 7622 ...e. bash É possível também utilizarmos o comando fuser para verificarmos o conteúdo em mais de
um diretório simultaneamente. Como mostram os exemplos abaixo:
# fuser /bin/bash /usr/bin/soffice /bin/bash: 4547e 4808e 4830e 6671e 6693e 7600e 7622e 7976e /usr/bin/soffice: 4547 No exemplo acima estão sendo listados todos processos vinculados aos arquivos bash e sofice. Se executarmos esse mesmo comando passando o parâmetro “-u” como opção junto com o
cada PID apresentado virá também o nome do usuário dono do processo.
# fuser u /bin/bash /usr/bin/soffice /bin/bash: 4547e(robsonp) 4808e(robsonp) 4830e(root) 6671e(robsonp) 6693e(root) 7600e(robsonp) 7622e(root) 7976e(rob
sonp) /usr/bin/soffice: 4547(robsonp) Também podemos utilizar dos caracteres especiais para designarmos mais de um diretório
ou arquivo para exibição dos processos. Como mostra exemplo abaixo:
# fuser /home/* /home/robsonp: 3126c 3186c 3205c 3207c 3209c 3286c 3288c 3289c 3349c 3452c /home/teste: 3464c 3465c A seguir esse mesmo exemplo só que desta vez com a utilização do parâmetro -v para uma
exibição mais completa.
# fuser /home/* v USER PID ACCESS COMMAND /home/robsonp: robsonp 3126 ..c.. xsessionmanag robsonp 3186 ..c.. gnomesettings robsonp 3205 ..c.. metacity robsonp 3207 ..c.. gnomepanel robsonp 3209 ..c.. nautilus 99
robsonp 3286 ..c.. gnometerminal robsonp 3288 ..c.. gnomeptyhelpe robsonp 3289 ..c.. bash robsonp 3349 ..c.. bash robsonp 3452 ..c.. bash /home/teste: teste 3464 ..c.. su teste 3465 ..c.. bash A seguir um exemplo onde usamos o comando fuser para verificar os processos que estão
utilizando a porta TCP 631.
# fuser n tcp 22 22/tcp: 2217 LSOF
O comando lsof lista todos arquivos, de todos os tipos, que estão abertos por todos os processos em execução no sistema.
Sintaxe: lsof <opções> <argumentos do parâmetro>14
Como vimos a utilização do comando lsof exibe uma lista de todos os arquivos abertos pelos
processos em execução, essa listagem por padrão apresenta nove colunas com as seguintes informações:
COMMAND – nesta coluna serão listados os primeiros 9 (nove) caracteres do nome do comando associado ao processo em execução que esta utilizando o arquivo listado.
PID – como o próprio título já diz, esta coluna lista o PID dos processos.
USER – nesta coluna serão listados os nomes dos usuários que iniciaram os processos.
FD – nesta coluna é apresentado um código que descreve o tipo do arquivo.
TYPE – nesta coluna é listado o tipo de nó associado com o arquivo.
DEVICE – nesta coluna é mostrado um número de dispositivo separado por vírgula para nó
de dispositivo de caractere, nó de dispositivo de bloco, arquivos regulares e diretórios.
SIZE – nesta coluna é listado o tamanho do arquivo em bytes.
NODE – nesta coluna é listado número do nó de um arquivo local, ou o número do inode de
um arquivo em NFS, ou o tipo de protocolo de Internet
NAME – nesta coluna é apresentado o nome para identificação de cada arquivo.
As principais opções que podem ser passadas como parâmetro do comando lsof são:
14 Os argumentos só precisam serem passados se o parâmetro utilizado requerer.
100
+D <diretório> – faz com que lsof procure por todas as instâncias do diretório especificado
no argumento homônimo que estão sendo utilizadas pelos processos do sistema.
-N – utilizado para verificar recursos (arquivos, diretórios, etc) que estão sendo utilizados em
uma estrutura de rede baseada em NFS.
-p <PID> – permite especificar o PID de um determinado processo para listar todos os recursos (arquivos, diretórios, etc) utilizados por ele.
-u <usuário/UID, ...> – verificar os recursos (arquivos, diretórios, etc) em uso por usuários.
Pode-se especificar múltiplos usuários pelo nome de login no sistema ou UID, separados por vírgula. É preciso ser administrador do sistema para verificar os recursos de outros usuários.
-U – permite verificar todos os soquetes Unix que estão em uso no momento.
-g <GID> – mostra os arquivos abertos pelo grupo especificado como argumento.
-i <argumento>15 – mostra os arquivos abertos por processo referentes às conexões de
rede.
Segue abaixo alguns exemplos de uso do comando lsof :
# lsof u robsonp |head O comando acima lista todos os arquivos abertos por processos cujo dono é o usuário robsonp.
# lsof i :22
O comando acima mostra todos os arquivos referentes a conexões feitas pela porta 22.
PIDOF
O comando pidof retorna o(s) PID(s) de um processo em execução.
Sintaxe: pidof [opções] [processo]
As opções do comando pidof são:
-s – esta opção faz com que seja exibido somente o primeiro PID encontrado.
-x – esta opção retorna o PID do shell que está executando o script.
-o [PID] – esta opção omite um determinado PID da listagem de saída do comando.
Para exemplificar o uso do comando pidof imagine a seguinte situação: Um servidor esta
com problema numa placa de rede, de forma que é necessária sua substituição. È efetua sua
substituição e reconfiguração tudo certinho. Mas devido a isso o acesso à internet de todo mundo
15 Neste caso, o argumento é opcional.
101
parou de funcionar pelo SQUID. Esse problema já havia ocorrido outras vezes e só foi necessário
reiniciar o SQUID e tudo volta a funcionar. No entanto ao tentar finalizar o serviço (com o comando
/etc/init.d squid stop) temos um retorno de erro dizendo que não é possível finalizar o serviço.
Nesse caso podemos utilizar o comando pidof para identificarmos o PID do processo squid e finalizá-lo com o comando kill.
# kill 9 $(pidof gedit)
Outros exemplos de utilização do comando pidof são:
# pidof bash 17095 13226 13204 10651 8995 7111 5358
No exemplo acima estamos listando os PIDs iniciados pelo bash.
# pidof s bash 17095
Agora repetimos o exemplo anterior mas desta vez passando o parâmetro “-s” para que só
seja exibido o primeiro PID.
NICE
Como sabemos qualquer “coisa” que executamos, no sistema operacional Debian, gera um
processo e através deste processo que é feito o controle de utilização de recursos do computador
(utilização do processador), em outras palavras, é através dos processos que é feito o controle e a
organização da fila de processamento.
O simples fato de inicializarmos o sistema operacional já é suficiente para criação de vários
processos e devido ao fato de sempre termos uma enorme quantidade de processos ativos são
necessários meios que permitam controlá-los. Para isso, os processos contam com um conjunto
de características, dentre as quais:
–
Proprietário do processo;
–
Estado do processo (em espera, em execução, etc);
–
Prioridade de execução;
–
Recursos de memória.
Neste momento vamos nos focar em enter melhor o controle da prioridade de execução dos
processos, para isso vamos entender como funciona o processamento das informações. Quando
falamos que um sistema operacional é multitarefa, não quer dizer que o processador da máquina
102
esteja processando duas ou mais tarefas ao mesmo tempo 16. O que acontece é que o sistema
operacional estipula um determinado período de tempo em que uma determina tarefa é processada e passado esse intervalo de tempo, essa tarefa é interrompida e volta para uma fila de proces samento e a tarefa da vez, na fila, é processada e assim por diante até a conclusão do processamento de todas as tarefas, esse ciclo acontece numa velocidade tão rápida que dá impressão de
que todas as tarefas foram processadas simultaneamente.
Nessa fila de tarefas a serem processadas nós encontramos os processos, e esses processos podem ter prioridade em relação aos outros em sua execução. Nesses casos dizemos um
processo tem um nível de gentileza inferior aos demais. Todo processo em execução assume um
determinado nível de prioridade, que por padrão é zero.
Quando um processo é gentil, significa que ele "oferece a gentileza" de permitir que um processo com prioridade maior seja executado antes dele. Esses níveis de gentileza, também chamados de nice, são determinados através de números, onde quanto mais alto for o valor nice, mais
gentil é o processo, ou seja, menor é sua prioridade de execução. O intervalo de números usados
no nice é o intervalo de números inteiros entre -20 e 19.
O comando nice permite nos permite executar uma determinado processo com sua prioridade de execução alterada, seja ela maior ou menor que sua prioridade padrão.
Sintaxe: nice <opções> <comando>
Quando utilizamos o comando nice passando como opção o parâmetro -n <valor>, onde o
“valor” corresponde ao nível desejado, é adiciona o valor especificado à prioridade padrão de execução no sistema para o processo iniciado. Se utilizarmos o comando nice sem passarmos o
parâmetro especificando o nível de prioridade de execução, será atribuída ao comando a prioridade execução 10 (dez).
A
penas o administrador do sistema, o usuário root, pode definir uma prioridade de
execução negativa para um processo.
Se utilizarmos somente o comando nice sem passarmos nenhum argumento, é exibida a prioridade de execução de processos padrão em uso atualmente no sistema operacional.
$ nice 0 No exemplo acima a prioridade de execução de processos padrão em uso no sistema é 0
(zero).
Imagine que temos, em nossa máquina, um determinado processo usando 95% do proces16 O processador só é capaz de processar uma informação por vez.
103
samento e que este processo ficará rodando por um longo período de tempo, e que nesse período, por algum motivo, você precise editar o arquivo “arquivo.cfg”. Ao tentar usar o editor vim para
alterar o arquivo, você percebe que o editor está extremamente lento. Para evitar essa situação, é
possível executar o editor de texto com o nível de prioridade de execução maior do que a do processo que esta ocupando 95% do processamento. Para isso basta utilizar o comando abaixo:
# nice n 20 vim arquivo.cfg
No exemplo acima o comando nice esta sendo usado para dar prioridade máxima para o
processo gerado pelo comando vim na edição do arquivo “arquivo.cfg”.
RENICE
O comando renice tem a mesma função que o comando nice, alterar a prioridade de execução de um determinado processo. A diferença é que utilizamos o comando nice para alterar a prioridade de execução dos processos que estão sendo iniciados, enquanto o comando renice é utilizado para alterara a prioridade de execução de processos que já estão em execução.
Sintaxe: renice <prioridade> <opções>
As opções do comando renice são:
-u – esta opção permite que seja especificado um usuário de forma que sejam alteradas as
prioridades de execução de todos os processos desse usuário.
-g – esta opção permite que seja especificado um um grupo de forma que sejam alteradas
as prioridades de execução de todos os processos desse grupo.
-p – esta opção permite que seja especificado o PID do(s) processo(s) que serão alteradas
as prioridade de execução17.
# renice 0 4546
No exemplo acima esta sendo alterada a prioridade de execução do processo com PID 4546
para 0 (zero).
# renice 5 u root p 4930 6123
No exemplo acima estão sendo alteradas as prioridades de execução para -5 (menos cinco)
de todos os processos do usuário root e dos processos com PID 4930 e 6123.
NOHUP
Algumas vezes precisamos executar um comando em background para que continuarmos
17 Não obrigatório o uso da opção “-p” para passar o PID de um processo para alteração de sua prioridade de
execução do comando renice.
104
usando o terminal, em alguns casos pode ser que a execução desse comando demore e por algum motivo nós podemos precisar encerrar a seção. Nesse caso ao encerrarmos a seção o processo que estava em execução em segundo plano receberá um sinal para ser encerrado e não
terminará sua execução.
S
empre que um usuário efetua logout, encerra uma seção, é enviado um sinal ( SIGHUP ) que termina ou reinicia um processo a todos os processos que este usuário
iniciou, ou seja, que ele seja dono.
Nos casos em que precisamos que um processo seja executado mesmo que sua a seção de
origem seja encerrada, ou seja, mesmo que nós efetuemos logout, podemos utilizar o comando
nohup á frente do comando que deverá ficar em execução. Pois o comando nohup faz com que
sejam ignorados os sinais de interrupção de conexão durante a execução do comando especificado (torna esse comando imune ao sinal SIGHUP). Possibilitando que o comando continue em execução mesmo após o usuário se desconectar do sistema.
Se a saída padrão para o comando é uma tty, esta saída e o erro padrão são redirecionados
para o arquivo “nohup.out” que será criado no diretório onde o comando foi executado, se por algum motivo ele não conseguir criar ou escrever neste arquivo, ele redirecionará para um arquivo
“nohup.out” que será criado no home do usuário corrente.
C
aso nenhum destes dois arquivos possam ser criados (ou alterados se já existem),
o comando não é executado.
Sintaxe: nohup [comando]
Segue abaixo um exemplo de utilização do comando nohup:
# nohup find / type f iname sources,list & [1] 16581 LSPCI
Através do comando lspci podemos obter informações detalhadas sobre os barramentos
PCI / AMR / CNR / AGP e os dispositivos que estão plugados nestes barramentos.
Sintaxe: lspci <opções>
Na maioria das vezes é identificado o nome correto do controlador de cada dispositivo conectado aos barramentos PCI / AMR / CNR / AGP do computador, no entanto, em alguns casos os
dispositivos podem ser mostrados como “Unknow Device”, informando que o dispositivo não foi reconhecido. Nesses casos podemos usar o script “update-pciids”, que fará o download de um
novo arquivo de definições para ser utilizado pelo comando lspci.
105
N
os casos onde o acesso a Internet passa por um serviço de Proxy, é necessário
ajustar a variável de ambiente “http_proxy” com as configurações do proxy (passar
hostname ou IP, a porta e se necessário usuário e senha) 18 para que assim o script update-pciids consiga acessar a internet funcione corretamente.
A utilização do comando lspci pode ser incrementada com as opções listadas a seguir:
-v – esta opção faz com que sejam exibidas informações mais detalhadas sobre cada componente presente no barramento PCI do computador. O grau de detalhamento apresentado por
esta opção pode ser aumentado através da repetição duas (-vv) ou três (-vvv) vezes da letra “v”.
-n – esta opção exibe o código do fabricante e do dispositivo ao invés de exibir seus nomes.
-nn – esta opção exibe o código do fabricante e do dispositivo, além de seus nomes.
-b – esta opção faz com que sejam exibidas informações sobre o hardware e os números de
IRQ utilizados por eles (interessante para descobrir conflitos).
-t – esta opção exibe as informações no formato de arvore.
-d <cód. fabricante>:<cód. Dispositivo> – esta opção exibe somente informações dos dispositivos de um determinado fabricante (argumento “cód. fabricante”), ou ainda de forma mais restritiva, de um determinado dispositivo de um determinado fabricante (definindo os argumentos
“cód. fabricante” e “cód. Dispositivo”).
A seguir temos alguns exemplos de utilização do comando lspci.
# lspci 00:00.0 RAM memory: nVidia Corporation MCP61 Memory Controller(rev a1) 00:01.0 ISA bridge: nVidia Corporation MCP61 LPC Bridge (rev a2) 00:01.1 SMBus: nVidia Corporation MCP61 SMBus (rev a2) 00:01.2 RAM memory: nVidia Corporation MCP61 Memory Controller(rev a2) 00:02.0 USB Controller: nVidia Corporation MCP61 USB Controller(rev a3) 00:02.1 USB Controller: nVidia Corporation MCP61 USB Controller(rev a3) 00:04.0 PCI bridge: nVidia Corporation MCP61 PCI bridge (rev a1) 00:05.0 Audio device: nVidia Corporation MCP61 High Definition Audio 00:06.0 IDE interface: nVidia Corporation MCP61 IDE (rev a2) 00:07.0 Bridge: nVidia Corporation MCP61 Ethernet (rev a2) 00:08.0 IDE interface:nVidia Corporation MCP61 SATA Controller(rev a2) 00:09.0 PCI bridge:nVidia Corporation MCP61 PCI Express bridge(rev a2) 00:0b.0 PCI bridge:nVidia Corporation MCP61 PCI Express bridge(rev 18 Uma forma de efetuar essa configurações é através do comando export a linha de comando para isso ficaria parecida
com a apresentada no exemplo a seguir: (export HTTP_PROXY='usuário:senha@poxy:porta').
106
a2) 00:0c.0 PCI bridge:nVidia Corporation MCP61 PCI Express bridge(rev a2) No exemplo acima temos a utilização simples do comando lspci onde como saída tivemos
as informações listadas acima.
# lspci v 00:00.0 RAM memory: nVidia Corporation MCP61 Memory Controller (rev a1) Subsystem: ASUSTeK Computer Inc. Device 8234 Flags: bus master, 66MHz, fast devsel, latency 0 Capabilities: [44] HyperTransport: Slave or Primary Interfa
ce Capabilities: [dc] HyperTransport: MSI Mapping Enable+ Fi
xed 00:01.0 ISA bridge: nVidia Corporation MCP61 LPC Bridge (rev a2) Subsystem: ASUSTeK Computer Inc. Device 8234 Flags: bus master, 66MHz, fast devsel, latency 0 I/O ports at 0900 [size=256] 00:01.1 SMBus: nVidia Corporation MCP61 SMBus (rev a2) Subsystem: ASUSTeK Computer Inc. Device 8234 Flags: 66MHz, fast devsel, IRQ 10 I/O ports at 0e00 [size=64] I/O ports at 0600 [size=64] I/O ports at 0700 [size=64] Capabilities: [44] Power Management version 2 Kernel driver in use: nForce2_smbus Kernel modules: i2cnforce2 No exemplo acima temos a utilização do comando lspci com a utilização do parâmetro “-v”
para uma visualização mais detalhada como visto acima.
LSUSB
O comando lsusb lista os dispositivos USB conectados ao computador, mostrando em que
posição do USB o dispositivo se encontra, qual sua identificação (ID), marca e modelo.
Sintaxe: lsusb <opções>
Para uma visualização mais incrementada das informações retornadas por este comando
podemos utilizar as seguintes opções:
-v – esta opção exibe as informações dos dispositivos USB conectados ao sistema de forma
mais detalhada.
-s [barramento]:[dispositivo] – esta opção permite visualizar informação especifica sobre
107
o dispositivo conectado a um determinado barramento USB, ou sobre todos os dispositivos plugados a um determinado barramento (especificando somente o argumento “barramento”).
# lsusb Bus 002 Device 002: ID 15d9:0a37 Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub No exemplo acima estamos utilizando o comando lsusb sem passar a ele nenhum parâmetro, onde temos como retorno a saída acima que mostras que, nesse caso, não há nenhum dispositivo conectado às entradas USB.
# lsusb v Bus 002 Device 002: ID 15d9:0a37 Device Descriptor: bLength 18 bDescriptorType 1 bcdUSB 1.10 bDeviceClass 0 (Defined at Interface level) bDeviceSubClass 0 bDeviceProtocol 0 bMaxPacketSize0 8 idVendor 0x15d9 idProduct 0x0a37 bcdDevice 1.00 iManufacturer 0 iProduct 1 USB Mouse iSerial 0 bNumConfigurations 1 Configuration Descriptor: bLength 9 bDescriptorType 2 wTotalLength 34 bNumInterfaces 1 bConfigurationValue 1 iConfiguration 0 bmAttributes 0xa0 (Bus Powered) Remote Wakeup MaxPower 100mA Interface Descriptor: bLength 9 bDescriptorType 4 bInterfaceNumber 0 bAlternateSetting 0 bNumEndpoints 1 bInterfaceClass 3 Human Interface Device 108
bInterfaceSubClass 1 Boot Interface Subclass bInterfaceProtocol 2 Mouse iInterface 0 HID Device Descriptor: bLength 9 bDescriptorType 33 bcdHID 1.10 bCountryCode 0 Not supported bNumDescriptors 1 bDescriptorType 34 Report wDescriptorLength 52 Report Descriptors: ** UNAVAILABLE ** Endpoint Descriptor: bLength 7 bDescriptorType 5 bEndpointAddress 0x81 EP 1 IN bmAttributes 3 Transfer Type Interrupt Synch Type None Usage Type Data wMaxPacketSize 0x0004 1x 4 bytes bInterval 10 Device Status: 0x0000 (Bus Powered) Acima segue um exemplo de saída mais detalhada do comando lsusb com o parâmetro “-v”.
HWCLOCK
Este comando permite acessar o relógio da BIOS, possibilitando sua consulta além de ajustes nos horários do sistema e da máquina.
Sintaxe: hwclock <opções>
Os parâmetros para utilização deste comando são:
-r ou --show : para exibir a data e a hora do relógio da máquina (BIOS).
-w ou --systohc : para copiar a hora do sistema para o relógio da máquina.
-s ou --hctosys : para copiar a hora da máquina para a hora do sistema.
--set --date=novadata : para modificar a data e a hora do relógio da máquina.
Por exemplo, para alterarmos o relógio da máquina para a seguinte data e hora: 14/07/1981
às 11:30. Devemos utilizar o comando hwclock da seguinte maneira.
# hwclock --set --date="07/14/1981 11:30"
# hwclock -r
109
Ter 14 Jul 1981 11:30:04 BRT -0.857784 segundos
No exemplo acima usamos primeiramente o comando hwclock para alterar a data e hora do
relógio da máquina (BIOS) e em seguida confirmamos a alteração efetuada usando novamente o
comando hwclock com o parâmetro “-r” para visualizarmos a data e hora do relógio da máquina.
NMBLOOKUP
Antes de aprendermos a utilização do comando nmblookup vamos conhecer um pouco sobre o NetBIOS sobre TCP/IP como serviço de resolução de nomes e sobre o serviço WINS.
Podemos definir NetBIOS como uma interface de programa desenvolvida para permitir a comunicação entre máquinas numa determinada rede. Em redes microsoft, por exemplo, o compartilhamento de arquivos é baseado no sistema de troca de mensagens do NetBIOS, chamado de
SMB (Server Message Block).
O NetBIOS disponibiliza o que chamamos de nomes NetBIOS, que através da resolução
desses nomes possibilita a comunicação entre máquinas numa rede sem a necessidade de uso
de seu endereço IP. Essa resolução de nomes NetBIOS, significa o mapeamento bem-sucedido
de um nome NetBIOS para um endereço IP.
Esse nome NetBIOS é o nome atribuído a um determinado recurso da rede (a um computador, impressora, etc), ele representa um endereço de 16 bytes que é usado para sua identificação
na rede. Ele pode ser um nome exclusivo, atribuído a um recurso especifico, ou um nome de grupo. Por exemplo, uma determinada máquina X numa rede, que utiliza o endereço IP 10.15.15.123,
pode receber o nome NetBIOS ecelepar91122 que será utilizado para identificar esta máquina na
rede, esse nome representa exclusivamente a máquina X que possui o endereço IP 10.15.15.123.
Essa mesma máquina pode fazer parte do grupo WORKGROUP, nesse caso, este grupo (nome
NetBIOS) não representa unicamente a máquina X mas todas as máquinas que fazem parte deste
grupo.
U
m nome NetBIOS possui 16 (dezesseis) posições de caracteres para sua formação.
Sendo que pode-se ter no máximo 15 (quinze) caracteres e no mínimo 1 (um) caractere para a definição do nome. Nos casos onde não forem usados os 15 (quinze) ca racteres possíveis no nome NetBIOS, as posições não utilizadas serão automaticamente
completadas com espaços em branco. O 16° (decimo sexto) caractere do nome NetBIOS é reservado para identificar a funcionalidade que está instalada no dispositivo de
rede registrado.
Numa rede é comum o compartilhamento de arquivos e impressoras, e geralmente utilizamos, para conectarmos à máquina que compartilha o recurso desejado (arquivo ou impressora)
utilizamos o nome NetBIOS para isso. Mas antes de poder estabelecer uma conexão de compartilhamento de arquivos ou impressão, é necessária a criação de uma conexão TCP. E para se esta110
belecer uma conexão TCP, o nome NetBIOS deve ser resolvido para um endereço IP. Temos diferentes mecanismos para resolução de nomes NetBIOS, sendo que estes mecanismos variam de
acordo com o tipo de nó de NetBIOS configurado. Segue abaixo uma lista de nós de NetBIOS:
Tipo de nó
Descrição
Nó B (difusão)
O nó B usa consultas de nomes NetBIOS através de difusão (broadcast)
na resolução de nomes. O nó B tem dois grandes problemas: (1) As
difusões perturbam todos os nós na rede. e (2) Os roteadores geralmente
não encaminham difusões, portanto, apenas os nomes NetBIOS na rede
local podem ser resolvidos.
O nó P usa um servidor de nomes NetBIOS (NBNS), como, por exemplo,
um servidor WINS para resolver os nomes NetBIOS. Ou seja, o nó P ao
Nó P (ponto a ponto)
invés de usar difusões faz uma consulta diretamente no servidor de
nomes (servidor WINS).
Nó M (composto)
O nó M é uma combinação do nó B e do nó P. Por padrão, um nó M
funciona como um nó B, resolvendo os nomes NetBIOS por difusão, e
quando ele não consegue resolver o nome por difusão, ele efetua uma
consulta ao servidor de nomes (servidor WINS usando o nó P.
Nó H (híbrido)
O nó H é uma combinação do nó P e do nó B. Por padrão, um nó H
funciona como um nó P, efetuando uma consulta num servidor de nomes
(servidor WINS), quando ele não consegue resolver o nome NetBIOS
dessa forma, ele usa uma difusão para resolução do nome. (Este
atualmente é o tipo de nó mais utilizado).
Agora que sabemos o que é e quais as formas para resolução de nomes NetBIOs, vamos
conhecer um pouco sobre o serviço WINS (Serviço de cadastramento na internet do Windows).
Este serviço disponibiliza um banco de dados distribuído para registrar e consultar mapeamentos
dinâmicos de nomes NetBIOS para computadores e grupos usados na rede. Os registros de
WINS são efetuados automaticamente a cada vez que os clientes iniciam e ingressam na rede.
E
ssa atualização automática do banco de dados WINS, evita que alterações dinâmicas de endereço desatualizem o banco de dados
A seguir temos uma ilustração que facilitará o entendimento da resolução de nomes NetoBIOS através de uma consulta num servidor WINS.
111
Figura 8: Representação de uma consulta a um servidor WINS.
Neste exemplo, o Computador A registra seu nome de NetBIOS, ecelepar90112, no servidor
WINS. Enquanto o Computador B primeiramente efetuou, passando o nome NetBIOS da máquina
que deseja acessar, uma consulta ao Servidor WINS para localizar o endereço IP do Computador
A, em seguida, o Servidor WINS retornou para o Computador B o endereço IP do Computador A
para que então o Computador B pudesse se conectar ao Computador A.
Agora que entendemos como funciona a resolução de nomes NetBIOS através de um servidor WINS, vamos aprender a utilizar o comando nmblookup que uma ferramenta muito útil para
verificarmos o correto funcionamento dessa resolução de nomes, pois este comando, dentre suas
funções, possibilita a consulta de um endereço IP através de seu hostname.
Sintaxe: nmblookup <opções> <host / endereço IP>
As opções do comando nmblookup são:
-U – esta opção é utilizada para passarmos o endereço IP do servidor WINS a ser consultado.
-R – esta opção é utilizada para passarmos o nome NetBIOS ou SAMBA da máquina que
será pesquisada.
-B – esta opção é utilizada para passarmos qual o broadcast será utilizado para resolução
do nome NetBIOS por difusão.
-d <Nível> – esta opção é utilizada para, dependendo do nível passado como argumento,
aumentar o detalhamento das informações retornadas pelo comando nmblookup. O nível a ser
passado como argumento dessa opção deve ser um valor inteiro compreendido entre 0 (zero) e
10 (dez), sendo que quanto maior o nível mais detalhada é a saída. Quando este parâmetro não é
passado o comando nmblookup assume o nível 0 (zero) no retorno das informações pesquisadas.
112
-T – esta opção é utilizada para que seja exibido o nome DNS da máquina antes do endereço IP.
A seguir veremos alguns exemplos da utilização do comando nmblookup.
# nmblookup U 10.15.20.85 R ecelepar10159 T querying ecelepar10159 on 10.15.20.85 ecelepar10159.celepar.parana, 10.15.17.35 ecelepar10159<00>
No exemplo acima estamos efetuando a consulta do nome NetBIOS “ecelepar10159” no
servidor WINS com endereço IP “10.15.20.85”, mostrando também o nome DNS da máquina (ecelepar10159.celepar.parana).
# nmblookup U 10.15.20.85 R ecelepar12153 querying ecelepar12153 on 10.15.20.85 10.15.17.135 ecelepar12153<00>
No exemplo acima estamos efetuando a consulta do nome NetBIOS “ecelepar12153” no
servidor WINS com endereço IP “10.15.20.85” .
# nmblookup R ecelepar10159 B 10.15.19.255 querying ecelepar10159 on 10.15.19.255 10.15.17.35 ecelepar10159<00>
No exemplo acima estamos efetuando a consulta do nome NetBIOS “ecelepar10159”, mas
desta vez por difusão através do broadcast 10.15.19.255.
# nmblookup U 10.15.20.85 R ecelepar91199 d 2 added
interface
eth0
ip=fe80::21e:8cff:fec0:297d%eth0 bcast=fe80::ffff:ffff:ffff:ffff%eth0 netmask=ffff:ffff:ffff:ffff:: added interface vmnet1 ip=fe80::250:56ff:fec0:1%vmnet1 bcast=fe80::ffff:ffff:ffff:ffff%vmnet1 netmask=ffff:ffff:ffff:ffff:: added interface vmnet8 ip=fe80::250:56ff:fec0:8%vmnet8 bcast=fe80::ffff:ffff:ffff:ffff%vmnet8 netmask=ffff:ffff:ffff:ffff:: added interface vmnet1 ip=172.16.224.1 bcast=172.16.224.255 netmask=255.255.255.0 added interface vmnet8 ip=192.168.7.1 bcast=192.168.7.255 netmask=255.255.255.0 added interface eth0 ip=10.15.17.186 bcast=10.15.19.255 netmask=255.255.252.0 querying ecelepar91199 on 10.15.20.85 Got a positive name query response from 10.15.20.85 ( 172.16.224.1 ) 172.16.224.1 ecelepar91199<00> No exemplo acima estamos efetuando a consulta do nome NetBIOS “ecelepar91199” no servidor WINS com endereço IP “10.15.20.85” , com detalhamento da saída do comando nmblookup
com nível de detalhamento 2.
113
E
m máquinas que possuem mais de uma interface de rede, o resultado do comando
nmblookup mostrará o endereço IP da primeira interface de rede a registrar-se. Para
verificar o endereço IP de uma interface de rede específica é necessário fazer a consulta
por difusão, especificando o broadcast utilizado pela interface de rede desejada.
NSLOOKUP
Para entendermos a utilização deste comando precisamos ter noção de o que é, e para que
serve um servidor DNS. De uma forma simplificada, podemos definir um servidor DNS (Domain
Name System como o responsável por efetuar a resolução de nomes, ou seja, identificar máquinas através de nomes em vez de endereços de IP.
Numa rede baseada no modelo OSI que utilize o protocolo TCP/IP, a conexão entre dois
equipamentos acontece através do endereçamento IP19. Imagine então que quiséssemos acessar
o site do google, por exemplo, se não tivéssemos configurado um servidor DNS, para acessar o
site, ao invés de digitarmos o endereço “www.google.com” teríamos que digitar um de seus endereços IPs. Para possibilitar essa navegação através de um “nome amigável”, o DNS atribui nomes
a serviços de rede e computadores, organizado de acordo com uma hierarquia de domínios.
O comando nslookup obtém informações de um servidor DNS, e as informações obtidas
com o comando nslookup podem ser utilizadas para a resolução de problemas relacionados com
o DNS.
Sintaxe: nslookup [-opções] [nome ou -] [servidor]
O comando nslookup pode ser utilizados de duas formas: interativa e não-interativa. A forma
não-interativa consiste na utilização do comando para realização de uma única consulta a ser realizada conforme os parâmetros passados. A forma interativa ocorre quando utilizamos o comando
nslookup sem passarmos nenhum parâmetro, nesse caso será aberta uma interface onde é possível realizar várias consultas com diferentes critérios de pesquisa, para sair dessa interface interativa basta digitarmos “exit” ou utilizarmos as teclas <Ctrl>+<d>. Segue abaixo alguns exemplos de
utilização do comando nslookup.
# nslookup ecelepar91199 Server: 10.15.16.6 Address: 10.15.16.6#53 Nonauthoritative answer: Name: ecelepar91199.celepar.parana Address: 10.15.17.186 No exemplo acima estamos usando o comando nslookup para consulta do endereço IP da
19 Esse conceito de que a conexão é feita através do endereço IP, é uma simplificação feita com o fim de contextualizar
a necessidade do uso do endereço IP na conexão.
114
estação de trabalho ecelepar91199. Nesse comando, como não foi especificado nenhum servidor
DNS a ser consultado, a consulta foi realizada no servidor DNS configurado como primário no arquivo “resolv.conf”.
S
ó é possível consultarmos o endereço IP de uma máquina, passando somente o
nome, sem especificar o domínio ao qual a máquina pertence, se o arquivo “resolv.conf” tiver a linha de configuração do domínio da internet setada (search celepar.parana).
# nslookup ecelepar91199 10.15.16.8 Server: 10.15.16.8 Address: 10.15.16.8#53 Nonauthoritative answer: Name: ecelepar91199.celepar.parana Address: 10.15.17.186
Neste outro exemplo, temos a mesma situação do exemplo anterior mudando somente o
fato de que desta vez apontamos no comando que o servidor DNS que deveria ser consultado era
o “10.15.16.8”.
# nslookup > ecelepar91199 Server: 10.15.16.6 Address: 10.15.16.6#53 Nonauthoritative answer: Name: ecelepar91199.celepar.parana Address: 10.15.17.186 > www.coxanautas.com.br Server: 10.15.16.6 Address: 10.15.16.6#53 Nonauthoritative answer: www.coxanautas.com.br canonical name = coxanautas.com.br. Name: coxanautas.com.br Address: 209.200.237.80 > exit No exemplo acima, estamos utilizando o comando nslookup no modo interativo, dessa forma
podemos efetuar quantas consultas forem necessárias. Neste caso estamos efetuando apenas
duas consultas, a do hostname “ecelepar91199” e a do endereço “www.coxanautas.com.br”.
Como não especificamos um servidor para consulta foi utilizada a configuração do do arquivo “resolv.conf” e consultado p servidor primário nele especificado. Após efetuadas as consultas desejadas saímos da interface do comando nslookup digitando exit.
115
# nslookup 10.15.16.8 > expresso.pr.gov.br Server: 10.15.16.8 Address: 10.15.16.8#53 Nonauthoritative answer: Name: expresso.pr.gov.br Address: 200.189.113.38 > exit No exemplo acima temos uma situação parecida com a descrita anteriormente só que desta
vez especificamos em qual servidor DNS deveria ser realizada a consulta.
116
GERÊNCIA DE REDES DE COMPUTADORES
Iremos agora depurar uma rede. Você possui uma rede problemática e precisa, urgentemente, fazê-la voltar a funcionar. Pode ser um host isolado, como pode ser uma rede completa. Antes
de qualquer coisa, o administrador da rede deverá parar e pensar quais são as possíveis causas
do problema e seguir um método para chegar a uma solução de forma mais rápida e eficaz.
Existem vários comandos que permitem que um administrador depure uma rede problemática, sendo que cada um trabalha em uma ou mais camadas da pilha de protocolos TCP/IP, estruturado parcialmente de acordo com o modelo OSI.
O TCP/IP foi desenhado segundo uma arquitetura de pilha, onde diversas camadas de
software interagem somente com as camadas acima e abaixo. Há diversas semelhanças com o
modelo conceitual OSI da ISO, mas o TCP/IP é anterior à formalização deste modelo e portanto
possui algumas diferenças.
Antes de estudarmos os comandos, precisamos entender superficialmente (já que não se
trata de um curso de ciência, e sim técnico) o que é este modelo e como ele está estruturado na
maioria das redes que conhecemos. Logicamente que, como um bom administrador, cabe a você
aprofundar-se no assunto para ter um maior domínio e destreza dos comandos e depurações,
mas o que será visto neste curso será o suficiente para serem resolvidos muitos problemas comuns.
CAMADA OSI
O modelo OSI/RM (Open Systems Interconnect Reference Model – Modelo de Referência
de Sistemas de Interconexão Aberta), ou simplesmente OSI, é um modelo que define as diretrizes
(caminhos, indicações e modelos) a serem seguidas pelos protocolos que pretendem definir regras que façam com que sistemas operacionais consigam utilizar qualquer arquitetura de rede.
Perceba que o modelo OSI em si não é nem “um”, nem um “grupo” de protocolos, mas sim o caminho que os desenvolvedores de protocolos deverão seguir para que haja uma total interoperabilidade entre sistemas e hardware. O projeto de criar o protocolo OSI foi abandonado e este modelo é usado atualmente para fins didáticos, é totalmente teórico e didático.
O modelo OSI consiste em uma pilha de camadas, sendo que cada uma delas tem uma função específica. Para que uma informação possa ser transmitida, ela precisará passar pelas pilhas
(camadas adjacentes do remetente e destinatário) seguindo uma direção e um sentido. Sempre
deverá ser respeitada a ordem das camadas. Para uma informação ser enviada, ela deve começar da camada superior e ir para as camadas mais abaixo. Para receber uma informação, o sentido será o contrário. Se existirem cinco camadas num protocolo utilizado para estabelecer uma conexão entre dois computadores, as aplicações de ambos, para trocar dados, terão que propeli-los
117
de forma que as 10 camadas sejam transpostas. A camada mais ao topo do remetente preparará
um segmento de dados que somente a mesma camada do destinatário entenderá. O mesmo
acontece com a segunda camada, e todas as outras. A “conversação” dentro da pilha é feita, então, horizontalmente, enquanto o fluxo é vertical. Vejamos agora quais são as camadas:
Figura 9: Camada OSI
Com relação a figura a cima:
Item 5 – Camada de sessão: Disponibiliza serviços como pontos de controle periódicos a partir
dos quais a comunicação pode ser restabelecida em caso de pane na rede.
Item 2 – “Altere Possui recursos de confirmação de chegada dos dados” “Realiza o controle de
acesso e transmissão no meio físico”
118
PROJEÇÃO DA ARQUITETURA TCP/IP SOBRE O MODELO OSI
O OSI é só um modelo de referência, e não necessariamente os protocolos utilizados pela
maioria das redes estruturadas hoje coincidem com ele. O protocolo TCP/IP é uma pilha de protocolos mais enxuta e prática. Não é à toa que é o protocolo mais utilizado em todo o mundo. Vejamos uma projeção da pilha TCP/IP sobre as camadas do modelo OSI.
Existem as aplicações de rede que repousam sobre a camada de aplicação, tanto no modelo OSI, quanto na arquitetura TCP/IP. Devido ao intuito deste curso, não iremos nos aprofundar
nas camadas de apresentação e aplicação já que elas têm funções diferentes e abstratas de acordo com o protocolo utilizado. Basta sabermos que tarefas de encriptação de dados, assim como
outras atividades adicionais que devem ser realizadas dependendo do aplicativo, que não estão
abrangidos em nenhuma outra camada, são realizadas nelas. Podemos dizer que, no protocolo
TCP/IP, a camada de aplicação abrange as três primeiras do modelo OSI. Depois disso, os dados
precisam iniciar o processo de comunicação com outros computadores. O primeiro passo da comunicação propriamente dita acontece na camada de transporte. Os dados precisam ser identificados para que, posteriormente, o protocolo saiba quem solicitou o quê e possa devolvê-lo ao
aplicativo certo. Isso é a multiplexação, que faz com que vários dados de aplicações diferentes
passem a ser um fluxo uniforme e homogêneo de dados atravessando o meio físico. Somente na
camada de transporte do destino é que esses dados lineares voltarão a ser divididos de acordo
com a aplicação que os aguarda. Nesta camada também é definido se a conexão vai ser feita com
controle de congestionamento, fluxo e confiabilidade de entrega (TCP), ou se, no lugar destas exigências, será priorizada a velocidade (UDP). Depois disso, temos a identificação de destino e origem e o trabalho de roteamento dos dados. No TCP/IP, esta camada recebe o nome de
inter-redes, e é nela que a geratriz dos dados reside, o IP (camada de rede). É ele quem faz o
endereçamento do destino e identificação do remetente do pacote. Continuando com o TCP/IP, é
nesta mesma camada temos o ICMP que é um protocolo de auxílio ao IP. Este protocolo ajuda
com mensagens de erro, controle de fluxo, etc. Esta camada possui os endereçamentos lógicos,
mas para que os dados consigam fluir de forma correta, é preciso que o IP seja convertido no seu
endereço MAC (camada de link). Depois disso, por fim, temos a camada de física, que nada
mais é do que o meio utilizado para se propagar os sinais que representam os dados.
Sempre que um dado vai ser enviado, ele vai descendo pela pilha de protocolos até chegar
à camada de link (ou enlace) que gera o sinal a ser transmitido. Durante a estada nesta camada,
após a fase de encapsulamento, os dados recebem o nome de quadros ou frames. Este frames
são compostos por um cabeçalho que contém informações sobre o computador de destino e de
origem, informações sobre o tamanho do quadro e um checksum (CRC), que verifica se está tudo
certo (se todos os quadros chegaram).
119
EMPACOTAMENTO DE DADOS
Os dados, no decorrer de sua jornada (pilhas abaixo ou acima), vão sendo empacotados e
desempacotados a toda hora. Isso acontece por alguns motivos, sendo dois os principais: (a) linearizar os dados em um sinal binário simples para que eles possam ser transmitidos pelos meios físicos e depois retornar esses sinais nos mesmo dados iniciais; (b) e permitir que haja um isolamento das aplicações em relação à plataforma, permitindo que os dados sejam transmitidos independente do sistema operacional ou da arquitetura dos dispositivos em comunicação.
O primeiro motivo é claro. O meio físico só entende código binário através da configuração
da tensão de cada bit. Quando se tem um zero a tensão é x, quando se tem um 1 a tensão é y. O
protocolo que trabalha na camada de enlace (ou link) é o responsável por criar a tabela de bits
para que o meio, da camada física, transmita cada um deles de uma interface a outra numa or dem exata. A preocupação da camada física é essa: garantir que aquela tabela de tensões x e
tensões y seja transmitida para seu destino exatamente na ordem da tabela criada pela camada
de enlace (transerência bruta dos dados). Como somente com códigos binários o meio físico pode
saber o destino das informações? É simples. Todas as interfaces que pertencem a mesma rede
estão conectadas fisicamente (em contato através de fios, fibras ou ar, em caso de wireless) umas
às outras. Toda vez que um dado deve ser transmitido, o remetente envia os dados para todas as
interfaces locais, mas somente aquela que é o destino é que aceita o sinal. A interface de destino
sabe que ela é a de destino, porque neste sinal temos os cabeçalhos com informações de identificação. Vejamos os três agrupamentos de dados que temos na pilha de protocolo TCP/IP:
Cabeçalho Cabeçalho Cabeçalho
Ethernet
IP
UDP
14 bytes
20 bytes
8 bytes
Camada de
Transporte
Ethernet
CRC
4 bytes
SEGMENTO UDP
Camada de
Rede
Camada de
Enlace
Dados de
Aplicações
100 bytes
PACOTE IP
QUADRO (FRAME) ETHERNET
Tabela 1: Empacotamento de dados
Um aplicativo qualquer (como um navegador) que necessite se comunicar com uma interface remota, não precisa saber como a rede funciona. Para isso, ele irá se conectar a uma interface
disponível na camada de aplicação da pilha TCP/IP. Um protocolo que permite que o navegador
“se encaixe” na pilha TCP/IP é o http. Os dados que devem ser trafegados são enviados do aplicativo para o protocolo da camada de aplicação. A camada de aplicação envia estes dados para a
camada de transporte, que começa o processo de quebra de informações em pedaços menores e
inserção de cabeçalhos. Estes “pedaços” com cabeçalhos embutidos recebem a denominação de
120
segmentos, que são enviados para a camada de rede que faz processo igual a camada anterior,
criando os pacotes. Os pacotes possuem nos seus cabeçalhos os IPa das interfaces de origem e
IPs da interfaces de destino. Os pacotes são enviados para a camada de enlace, que também vai
criar seu próprio agrupamento e dará a ele o nome de quadro (ou frame). Dentro desta camada
existe o protocolo ARP, que são as regras que, entre várias atividades, convertem um endereço IP
em endereço físico (MAC ADDRESS) e vice-versa. MAC ADDRESS é um endereço único que todas as interfaces de rede possuem. Existe um instituto regulamentador de normas técnicas que
controla a emissão destes endereços para que ele nunca se repita em nenhum lugar do mundo.
Uma empresa que fabrica estas interfaces precisa comprar uma faixa de endereços físicos para
atribuir às suas peças20. Então apesar dos IPs poderem ser iguais em redes diferentes, os MAC
ADDRESS nunca serão. Um computador mantém uma tabela dinâmica contendo os MAC ADDRESS de todas as interfaces de sua rede que se comunicaram recentemente. Se a conexão tiver que ser com uma interface de outra rede, o MAC ADDRESS endereçado será do roteador. Então o MAC ADDRESS é inserido dentro do cabeçalho e agora sim a interface de destino saberá
que aquelas informações são destinadas a ela.
Voltando a inundação de dados enviados à toda rede (conhecida como broadcast). Os frames são criados na camada de enlace. Eles são compostos do pacote IP (que para eles é uma
caixa preta) e um cabeçalho contendo o MAC ADDRESS e marcas de onde cada frame começa e
termina. Estes limites são criados pelo protocolo LLC (Logical Link Control Layer - Camada de
controle de link lógico) residente da camada de enlace. Ele cria uma tabela com as tensões que a
camada física deverá usar para definir os 1 e 0s, e indica o tempo certo que cada bit terá. Desta
forma, todos os dados são enviados para toda rede, todas as interfaces locais recebem os frames
e os convertem em pacotes IPs. É verificado no cabeçalho deste IP se o endereço do destinatário
corresponde com o próprio endereço. Se sim, os dados são enviados para cima até chegar a aplicação.
TCP/IP
O TCP/IP foi criado e implementado, sendo o conjunto de protocolo mais utilizado hoje em
redes de computadores. A internet utiliza-o, sendo assim, podemos perceber a dimensão de sua
adoção. Este protocolo cria uma interface de programação uniforme que permite que diversos tipos de hardware, independentes de suas tecnologias, consigam transportar dados e que exista interoperabilidade entre sistemas híbridos. Vejamos como ele é constituído:
Camadas
Camada de aplicação
Exemplos de protocolos
FTP - WWW - SMTP - POP - IMAP - TELNET
20 Por isso, cuidado com as placas clonadas. Provavelmente elas clonaram algum endereço existente sem pagar por ele.
Se duas placas tiverem o mesmo MAC ADDRESS haverá conflito e a comunicação será prejudicada.
121
Camada de transporte
TCP - UDP
Camada inter-redes
IP - ICMP - ARP - RARP
Camada de interface de rede
ETHERNET, TOKEN-RING, sem-fio, ATM
CAMADA DE APLICAÇÃO
A camada de aplicação é fornecida pelo programa que deseja se “encaixar” à pilha. Existem
vários protocolos utilizados nesta camada. O navegador de internet é uma aplicação, mas não podemos confundi-lo com a aplicação responsável pelo encaixe na pilha, que no caso é o http. Um
programa utilizado pelo usuário final pode escolher um dos protocolos (serviço ou aplicativo) que
fazem parte da camada de aplicação mais adequado às suas necessidades. Navegadores, como
IE, Mozilla Firefox, Opera e Epiphany utilizam o protocolo http, https e FTP na camada de aplicação. Aplicativos como Nautilus, Filezilla FTP Transport e SmartFTP utilizam o protocolo FTP.
Vejamos os principais protocolos da camada de aplicação:
HTTP (hiper text transport protocol - protocolo de transporte de texto rico) permite que haja
transferência de páginas pelas redes de computadores. O rico indica que as informações são
transmitidas com informações a respeito da formatação e recursos adicionais, permitindo que o
texto do outro lado chegue sem ser como simples texto puro.
FTP (file transport protocol - protocolo de transporte de arquivo) é um conjunto de regras e
instruções que permite que haja transferência rápida de arquivos entre computadores distintos.
SMTP (simple mail transport protocol - protocolo de transporte simples de e-mail) é um conjunto de regras e instruções que faz com que uma mensagem seja convertida em texto simples e
possibilita que seja definido, através de um endereço de e-mail, que esta mensagem seja identificada e enviada para um destinatário específico.
IMAC (internet message access protocol - protocolo de acesso a mensagem pela internet)
um protocolo mais completo de envio e recebimento de mensagens que permite que o usuário tenha mais recursos disponíveis, como manter suas mensagens no servidor depois de recebê-las.
TELNET é um protocolo simples que cria uma conexão entre computadores distintos e que
possibilita a troca de informações através de linha de comando. Para configurar modens e impressoras sem display próprio, utiliza-se este recurso.
SSH (security shell) cria uma conexão entre interfaces distintas e possibilita que remotamente um cliente acesse o shell (terminal) de um servidor. Os dados são criptografados, dando mais
segurança à troca de informações.
A camada de aplicação da pilha TCP/IP abrange três camadas do modelo OSI (aplicação,
apresentação e sessão). Assim, podemos dizer que nesta camada os dados a serem transmitidos
122
são inicialmente diferentes, mas nela começam o processo de linearização, para que as informações a serem transmitidas se tornem uma série de informações uniformes e de padrão igual para
que as próximas camadas se preocupem apenas com as suas atividades de transmissão pela
rede. Antes da conversão, eles definem com quem a conexão será realizada, estruturam os dados
num formato próprio do protocolo (compactando-os, criptografando-os, etc), e depois converte-os
numa sequência de dados que deve ser transmitida pelo meio físico da rede.
importante observar que a comunicação é feita entre as camadas iguais. A camada
É
de aplicação do cliente se comunica com a camada de aplicação do servidor, e assim
por diante. Isto quer dizer, que os dados da camada de aplicação são como várias “caixas pretas” para as camadas abaixo. As camadas abaixo vão simplesmente adicionando
cabeçalhos a estas caixas.
Imagine uma empresa, a Pilintra's Corporation, sediada no Paraná, que deseja enviar encomendas para suas filias pelo Brasil. A transportadora do Paraná utilizada para esse fim pode ser
comparada a uma rede local. Ela tem abrangência estadual, tendo que sempre repassar a tarefa
para outra transportadora quando muda de estado. A nova transportadora será uma rede remota.
A empresa Pilintra's Corporation pode ser equiparada a uma aplicação, como o Firefox, por exemplo. Quando a empresa precisa enviar uma encomenda, esta é levada até um balcão de coleta da
transportadora para que ela inicie o processo de transporte. Neste balcão é feita a coleta da encomenda, registro do remetente e destinatário e necessidades do transporte. A encomenda pode ser
compactada ou precisa ser colocada numa caixa com indicação frágil? Deve ser registrada, com
seguro ou seja o que Deus quiser? Depois da coleta ser realizada, caso seja necessário compactação, discrição, ou qualquer exigência do cliente, os funcionários atrás do balcão iniciarão o processo de preparação para o transporte.
CAMADA DE TRANSPORTE
Dentro desta camada temos os protocolos TCP e UDP, que definem as regras de envio de
segmentos de dados criados pela camada de aplicação. Os dados já são iguais, independente de
terem sido criptografados, compactados, serem ricos, texto puro, ou seja, não importa a estrutura
dos dados, agora tudo não passa de uma série de dados que devem ser transmitidos de uma interface à outra. Esta camada é responsável por identificar quais são os aplicativos responsáveis
por cada informação trafegada. Este controle é feito através de portas ou soquetes. Se o protocolo
ssh, da camada de aplicação, estiver enviando alguma informação de uma interface à outra, ele
deverá criar sua estrutura, convertê-la em dados lineares e enviar o resultado para a camada de
transporte que se encarregará de identificá-la através de uma porta. Porta é um espaço na memória que permitem que algum dado transmitido seja enviado à aplicação certa. Quando o segmento
de dados é criado (TCP ou UDP) é adicionado ao cabeçalho o endereço da porta de destino, ou
espaço na memória do computador remoto que os dados deverão ser armazenados. Desta forma,
123
uma aplicação sabe exatamente quais dados devem ser interpretados por ela. Vejamos um exemplo. A porta padrão do ssh é 22, ou seja, o espaço na memória que possui o endereço da porta 22
é associado ao aplicativo ssh. Sempre que alguma informação chegar pela rede e possuir a porta
22 como destino, os dados serão enviados a este espaço e, automaticamente, serão enviados
para o aplicativo ssh que conseguirá converter aquela “caixa preta” em dados válidos e úteis.
TCP
O TCP (transport control protocol) é responsável, assim como o UDP, pela criação do segmento de informações a ser enviado à interface distinta e o controle de identificação dos dados
que os segmentos representam.
S
egmento é a unidade de transmissão do TCP e UDP. Ele é constituído pelo cabeça lho TCP ou UDP e os dados vindos das camadas superiores, que não são tocados
por eles. Nesta camada temos os segmentos, na camada de rede temos os pacotes e
na de enlace os quadros.
Ele tem como principais atividades:
Confiabilidade: toda vez que um segmento chega à camada de transporte do destinatário,
uma mensagem de resposta chamada ACK (acknowledgment – confirmação) é enviada ao remetente para que este possa enviar o próximo segmento. Se após um determinado tempo, o ACK
não chegar, o remetente envia novamente o segmento perdido. Todos os segmentos são identificados no primeiro byte de suas estruturas com números sequenciais. Isto permite que haja o controle de quais segmentos chegaram e quais foram perdidos.
Controle de fluxo: caso o ACK seja recebido pelo remetente, nesta mensagem o destinatário registra a informação que permite que o remetente saiba como está o buffer de armazenamento da pilha TCP/IP, permitindo que o remetente envie o próximo segmento ou atrase um pouco a remessa. Isto faz com que os dados trafeguem pela rede somente se houver a quase certeza
de que eles serão recebidos, diminuindo o tráfego de quadros no meio físico.
Multiplexação: associa cada segmento a uma porta, permitindo, assim, que a interface de
destino saiba qual processo deve receber determinado segmento. Este recurso permite que vários
dados de aplicativos distintos trafeguem como se tivessem a mesma origem, independente do
hardware abaixo e software acima estejam sendo utilizados.
UDP
O UDP (user datagram protocol - protocolo de datagramas de usuários) é basicamente a interface entre a camada de aplicação e o protocolo IP. Ele não tem controle nenhum, e a única coisa que faz é a multiplexação, associando os dados a algum aplicativo determinado. Por ser bas-
124
tante simples, ele é bem mais rápido que o protocolo TCP, porém não provê garantia nenhuma de
que os segmentos irão chegar ao seu destino. Recursos como vídeos expressos da internet, como
aqueles vistos no youtube, em grande parte utilizam este protocolo de conexão. Escolha essa, devido ao fato de o quê importar nesse tipo de tarefa é a velocidade, tendo as informações perdidas
substituídas por pixels pretos, que diminuem a qualidade das imagens, mas melhora muito a velocidade de download.
Portas e soquetes
As portas e soquetes são espaços reservados na memória principal que ao receberem informações realizam alguma sincronia com um serviço (recebendo dados) ou com a camada de trasporte (enviando dados). Toda vez que um serviço precisa enviar algo a um computador remoto,
ele envia uma requisição de conexão e espera para verificar se isso será possível. Digamos que
um computador A precisará se conectar por ssh a um computador remoto B. O serviço ssh deve
estar instalado nas duas máquinas e rodando (ser um processo). Os dois processos ficam vinculados à porta 22. O servidor (computador B) fica “escutando” a porta 22, ou seja, verificando se
aquele espaço específico da memória recebe alguma informação. Quando o cliente (que chamaremos de computador A) precisa se conectar ao servidor, ele envia a requisição à sua porta 22.
Esta requisição possui, também, o número de uma porta no cliente que estará disponível para se
estabelecer uma conexão (por exemplo, a porta 55555). Esta requisição desce a pilha de protocolos TCP/IP, é transmitida pelo meio físico e então chega à porta 22 do computador B (o servidor).
O processo ssh que estava escutando esta porta, converte os dados em informação inteligível a
ele e, se verificar que é possível a realização da conexão, envia uma mensagem ao cliente informando que a conexão poderá ser realizada e estabelece um soquete, que nada mais é que o estabelecimento da porta 22 do servidor com a porta disponibilizada no cliente (no nosso casso
555555) como forma de comunicação entre os computadores. Agora o ssh do servidor continua
escutando a porta 22 por novas conexões e por requisições quaisquer, e sabe que sempre que requisições vindas do computador A devem ser enviadas à porta 55555 do mesmo. Quando a conexão finalizar, o soquete (conexão específica) será desfeito e a porta 55555 do computador A voltará a estar disponível.
P
erceba bem que porta é um espaço da memória que pode ser utilizado por um serviço, enquanto soquete é um vínculo (conexão estabelecida) entre interfaces diferentes que utiliza portas para comunicar-se uma com a outra. Uma porta não depende
de um soquete, já um soquete depende de portas.
Numa transportadora, os protocolos TCP e UDP identificam os portões a serem utilizados na
saída e entrega. Tudo que sair do portão 22 da transportadora local, deve ser entregue ao portão
22 da transportadora remota ou um outro especificado previamente. Cada porta representa uma
125
empresa contratante da transportadora. Do portão 22 saem as encomendas da Celepar, enquanto
do portão 33 saem as encomendas da Copel. Usando o protocolo TCP, um funcionário da transportadora local liga para a remota perguntando se pode enviar os dados e quantos caminhões devem sair. Toda vez que um caminhão chega, a sede receptora liga informando que a encomenda
chegou e quantos caminhões podem sair da transportadora sem causar tumulto na recepção. Isso
irá acontecer em ambas mãos, tanto da local para a remoto, como da remoto para a local. Com o
UDP, a transportadora manda toda a encomenda, independente da quantidade de caminhões necessários para isso, de uma só vez. Se houver fila ou se algum caminhão tombar na estrada, nem
os motoristas nem a transportadora remota irão avisar a local. A carga será perdida e a empresa
contratante (aplicação) é quem deverá arcar com a perda.
CAMADA INTER-REDES
Cinco computadores conectados a um hub formam uma rede com topologia de barramento.
Esta topologia mantém em contato físico todos os computadores. O hub nada mais é do que um
super T que conecta todos os computadores. Quando um deles quer enviar alguma informação
para outro, todos os outros irão receber os pacotes, mas somente aquele que é o destinatário é
quem irá desempacotá-lo por completo. Para saber qual é o endereço do destinatário, é necessário saber o seu IP. O IP é convertido em MAC pela camada mais abaixo e somente aquele destino
que possua o endereço de MAC definido no pacote é quem irá aceitá-lo. Em vez de trabalharmos
com o endereço de MAC, trabalhamos com o IP, que é tratado e inserido no pacote na camada Inter-Redes. A partir desta camada, a plataforma e hardware de comunicação podem ser qualquer
que tenha suporte ao protocolo TCP/IP. Isso quer dizer que esta camada é responsável por criar
uma barreira entre aplicações-plataforma e arquitetura dos aparelhos de comunicação. Assim, facilmente podemos ter comunicação entre um computador Windows e Linux, e também entre computadores conectados ao hub por um cabo ou por um dispositivo wireless.
Outra função importantíssima desta camada é a de roteamento. No caso estabelecido anteriormente, tínhamos uma rede com cinco computadores. E se quisermos ligar esta rede a outra
rede que contém mais cinco computadores? Somos induzidos a entender que estamos conectados a duas redes. E se quisermos conectar a nossa rede a essa outra e mais à internet? Seríamos induzidos a pensar que estamos conectados a três redes. Errado. A partir do momento que
temos acesso à segunda rede e à internet, temos acesso a apenas uma rede, ou a uma inter-rede. Apesar da primeira ser diferente da segunda, e da internet ter milhões de redes que a compõe,
dizemos que estamos conectados a apenas uma rede ampla. Isto se deve aos roteadores. Estes
equipamentos, que podem ser ou computadores com mais de uma placa de rede, ou então equipamentos próprios e dedicados à roteamento, são os pontos de ligações entre uma rede e outra.
Podemos conectar a nossa primeira rede um roteador, que fisicamente está conectado à primeira
rede e à segunda. Toda vez que precisamos enviar uma informação para a segunda rede, ela será
126
enviada para esse roteador que enviará os dados para o computador da segunda rede. Se conectarmos a esse roteador um cabo da internet, que normalmente é provido por um provedor de internet, podemos acessar em ambas redes a internet.
Os roteadores possuem tabelas de roteamento, para saberem o que fazer caso a conexão a
um determinado computador seja solicitada. Normalmente os roteadores de provedores possuem
bastante informações e conseguem definir um trajeto bastante reto até o destino, mesmo que o
computador esteja em outro continente. Quem cuida de todo o roteamento de pacotes é a camada
inter-redes da pilha TCP/IP. Ele verifica qual é o IP de destino e, através de regras específicas, indica qual é o caminho a ser tomado: uma interface conectada diretamente a ele ou um próximo roteador que estará conectado a uma nova rede.
Resumindo, esta camada tem dois objetivos principais:

Isolar aplicações e plataformas do hardware e softwares de rede;

Criar uma rede única estendida a partir de várias outras, através dos roteadores.
IP
O IP é um dos protocolos da camada de rede que implementa o endereçamento de um host
na rede que possua uma interface capaz de enviar e receber datagramas IP. Sob a versão 4, ele é
composto de 32 bits, sendo 8 para cada octeto. Um octeto pode assumir um valor de 0 a 255, totalizando 256 possibilidades por octeto. Veja o exemplo abaixo:
100.15.1.213Para sabermos qual é a rede lógica a qual este IP pertence devemos confrontá-lo à mascara de rede. Existem as seguintes classes de rede:
Classe
Classe A
Range
1.0.0.0
126.255.255.255
Classe B
Máscara Padrão
255.0.0.0
255.255.0.0
Formato
REDE . HOSTS . HOSTS . HOSTS
REDE . REDE . HOSTS . HOSTS
128.0.0.0
191.255.255.255
Classe C 192.0.0.0
224.0.0.0
Privados
255.255.255.0
REDE . REDE . REDE . HOSTS
10.0.0.0 – 169.0.0.0
127.0.0.0 (localhost) – x.x.x.0 (rede) –
Reservad
x.x.x.255 (broadcast)
os
Se a máscara for a padrão (255.0.0.0) a rede do host será a 100.0.0.0 de classe A.
ICMP
Internet Control Message Protocol - Protocolo de Controle de Mensagem na Internet
Como o próprio nome diz, ele é um protocolo que define várias mensagens de controle mui127
to úteis dentro do protocolo TCP/IP. Quando pingamos um computador, ou seja, quando enviamos
uma pergunta a um host remoto para verificar se ele está disponível na rede, é o protocolo ICMP
quem responde dizendo “Opa, tô funcionandinho aqui!”. Existem alguns tipos de pacotes deste
protocolo de controle, vejamos os principais:
•
Eco, que é a pergunta de disponibilidade da interface e a sua resposta;
•
Verificação de tangibilidade de redes, hosts, protocolos e portas;
•
Verificação de existência de redes e hosts;
•
Aviso de erro na rota de destino;
•
Impossibilidade de comunicação devido a atos administrativos (filtros como firewall);
•
Solicitação de estampa de tempo e resposta a esta solicitação (para verificação do tempo
levado pelo pacote para envio e recebimento);
•
Tempo de espera de resposta excedido.
ARP
Address Resolution Protocol - Protocolo de Resolução de Endereços
ARP é um sistema de indexação que possui um banco de dados, onde são armazenadas
associações entre endereços de alto nível (IP) e endereços físicos (MAC Address). O nome do comando que manipula o ARP recebe o mesmo nome.
A conexão entre os computadores é realizada através de uma multiplexação de dados, ou
seja, informações que precisam ser enviadas de um computador a outro são divididos em vários
pacotes e cada um deles recebe várias informações em cabeçalhos para que possam chegar a
um destino e serem reorganizados e montados na sua forma original. Numa rede bem configurada, existem computadores com IPs diferentes e roteadores que ajudam os pacotes a chegarem
em seus destinos. Mas IPs são endereços lógicos, que abstraem o endereço físico de cada uma
das interfaces (nós) da rede. Os endereços físicos são únicos e definidos pelos fabricantes das interfaces. Como nenhum nó no mundo todo pode ter o mesmo endereço físico, o número de bytes
utilizado para defini-los é bastante grande. O IP surge com a ideia de tornar mais fácil a configuração da rede, possibilitando a existência de um padrão que facilite a instalação e o gerenciamento
de ambientes complexos (numa mesma rede teremos 10.0.0.1, 10.0.0.2, etc). Só que o IP é entendido pelo computador apenas nas camadas mais altas dos protocolos de comunicação, tendo
que ser convertido em endereço físico nas camadas mais baixas. Esta conversão será feita com a
ajuda do ARP (Address Resolution Protocol – Protocolo de resolução de endereços). Este protocolo possui uma série de regras e instruções que indicam como os computadores devem descob-
128
rir o endereço físico de computadores da rede; como devem se comportar quando souberem que
outro computador estão os procurando; e criam uma tabela (cache) com associações entre IPs e
MAC Address para serem utilizados no futuro, otimizando o processo.
A pesquisa de um endereço físico é feita da seguinte forma: o computador que deseja descobrir qual é o endereço físico de um determinado IP, irá fazer um broadcast com pacotes ARP.
Estes pacotes ARP serão ignorados por todos, exceto por aquele computador que utiliza o IP pesquisado. Este irá, então, enviar um pacote ARP para o requisitante com algumas informações a
seu respeito, entre elas o seu endereço físico. Então sempre teremos dois pacotes ARP, sendo
um de pesquisa e o outro de resposta enviado pelo computador que está sendo procurado. Tanto
o computador que procura, quanto o que foi encontrado, mantêm em cache a associação do IP
com o MAC Address do outro, para que no caso de uma nova conexão, o processo seja realizado
de uma forma mais rápida.
O cache é apagado após algum tempo. Este processo é chamado de Aging.
Quando a distância está fora da abrangência da transportadora contratada, ela repassa a
encomenda para outra. Pode existir uma transportadora especializada em cada estado, e uma
que transporta encomendas para distâncias maiores, como outro continente. A única exigência é
que as transportadoras tenham contato. Imagine uma encomenda que vai ser enviada do RS para
o PR. A “Tchê transportes” (RS) enviará a encomenda para a “Barriga Verde Express” (SC) que,
por sua vez, finalmente entregará a encomenda para a “Vina on Roads” (PR). Caso precise enviar
uma encomenda para a Jamaica, será necessário utilizar a transportadora “Internetional”, que só
possui posto em São Paulo. Então a encomenda deverá ser enviada da mesma forma como no
exemplo anterior, com o adendo de trajeto PR para SP, SP para Jamaica. Para a empresa que
contratou o serviço de transporte, mandar para outra cidade ou outro país parece ter a mesma natureza de entrega, uma entrega direta ao seu destinatário, já que ela não sabe que haverá troca
entre transportadoras. Isso quer dizer que ela é induzida a imaginar que a conexão RS e Jamaica
é direta, mas, na verdade, por debaixo dos panos, a rede de transporte é heterogênea (várias redes, ou transportadoras, compondo uma única rede de transporte). Mas e como saber qual é o
trajeto a ser seguido? Através da identificação do endereço do remetente e destinatário (fornecidos pela empresa - aplicação) e das tabelas de roteamento, indicando qual é o caminho a ser seguido para que uma encomenda chegue ao seu destino. Toda essa gerência e manipulação é realizada pela camada Inter-Redes.
CAMADA DE ENLACE
Esta camada é responsável em transportar os pacotes da camada inter-redes em quadros
pelo meio físico. Um quadro é a unidade da camada de enlace. Todos os pacotes são divididos e,
129
então, são anexados a eles um novo cabeçalho. Este cabeçalho contém bits que indicam o início
de um quadro e o fim. Normalmente existe um logarítmo (não sei o que é isso, mas acho que está
errado) inserido no quadro que permite que a camada de enlace do destinatário saiba qual é o tamanho do quadro, mas isso depende da tecnologia utilizada pelos equipamentos e meios físicos.
Ethernet
Ethernet é o protocolo utilizado pela maioria das redes de computadores existentes na atualidade, mas já está sendo trocada pelas tecnologias utilizadas pelas redes wireless. Todas as interfaces estão em contato e todos os quadros são enviados para todos, cabendo a cada uma delas verificar se são as responsáveis por ele. Este protocolo tem como unidade de transporte o frame, ou quadro. Um quadro é composto por vários compartimentos que possuem naturezas distintas. São eles:
▪ Preâmbulo;
▪ End de Destino;
▪ End de Origem;
▪ Tipo;
▪ Dados;
▪ FCS.
O preâmbulo é composto por 8 bytes. Quer saber quais são as informações contidas dentro
deste compartimento? Não? Então não leia abaixo:
10101010 10101010 10101010 10101010 10101010 10101010 10101010 10101011
Este compartimento indica que um quadro irá começar. Quando uma interface recebe essas
informações, a camada de enlace dela interpretará esses dados como o início de um quadro. Depois da assinatura 11 inicia-se o segundo compartimento.
Os 2 seguintes compartimentos são facilmente entendidos. O tipo é o protocolo utilizado
pelo meio físico. No nosso caso, será o protocolo Ethernet. O compartimento Dados é reservado
para as informações a serem transmitidas. E, por fim, o FCS (Frame Check Sequence – Sequência para Checagem de Quadro) é um algoritmo que permite que a camada de enlace saiba se todos os bits do quadro foram recebidos. Isto é feito através de cálculos matemáticos.
Vamos verificar tudo que foi visto até agora. Estamos no Paraná e o nome da nossa empresa é Pilintra's Corporation (aplicação). A filial do Rio de Janeiro liga para nós pedindo uma encomenda e indica que ela pode ser enviada ao portão 50000, da transportadora do rio, que foi alugado exclusivamente para recebimento da encomenda. Nós temos um portão exclusivo na transportadora local para enviar encomendas, que é o 10. Este portão está sob a supervisão de um fiscal,
130
que verifica se as encomendas foram enviadas e espera uma confirmação de recebimento vinda
de qualquer um dos destinos. Fecha-se aí um soquete, que é a associação do portão com confirmação 10 da transportadora local (porta TCP) com o portão 50000 da transportadora remota. As
transportadoras local e remota são as redes distintas que trabalham sobre as mesmas regras e
metodologia de entrega, ou seja, mesmo protocolo (TCP/IP). Vamos até o tal balcão de recepção
(camada de aplicação) e deixamos nossa encomenda indicando qual será o destino (a filial da
Pilintra's Corporation no Rio no portão 50000). A encomenda vai para o portão 10 e, de lá, é acomodada dentro do caminhão. O motorista recebe o endereço de destino da encomenda, e percebe que está fora de sua abrangência. Ele possui uma tabela de empresas conveniadas que poderá entregar a encomenda (tabela de roteamento), e descobre que terá que enviar para uma
transportadora de São Paulo. Para encaminhamento da encomenda, eles precisam de um posto
de troca (gateway) entre as duas transportadoras (duas redes distintas), que fica bem na divisa
dos estados. Através do caminhão (quadro) e das rodovias (meio físico), a encomenda chega
até o posto, local onde é feito o encaminhamento da encomenda e do endereço de destino. O
mesmo acontece entre SP e RJ. Quando a transportadora do RJ recebe a encomenda, descobre
que a entrega está dentro de sua abrangência. Leva o caminhão até o portão 50000 e descarrega
a encomenda. O fiscal do RJ liga para o fiscal do PR e fala: Chegou, velho! - E encaminha para o
balcão de entrega com identificação do destinatário. O funcionário da Pilintra's Corporation vai até
o balcão e pega a encomenda. A transmissão foi realizada com sucesso.
PARÂMETROS NECESSÁRIOS
Para que um host possa pertencer a uma rede, é necessário que ele possua um caminho físico que o ligue à rede e alguns parâmetros configurados que fazem com que ele identifique outras interfaces conectadas a esse meio físico e vice-versa. Todos os parâmetros devem possuir
um valor, porém todos têm um valor padrão, tendo que, caso seja a vontade do administrador, valores diferentes serem definidos através de arquivos de configuração, scripts ou comandos.
IP
O IP é a identificação lógica de uma interface. É a sua identidade em uma rede. Podemos
obtê-lo através de um sevidor DHCP ou então fixando-o um enderço no arquivo
Arquivo de configuração: /etc/network/interfaces
Independente da forma escolhida, o arquivo acima deve ser configurado, já que a ativação
da procura de parâmetros através de um servidor DHCP é feita nele. Outra forma de se configurar
este parâmetro é através do comando ifconfig, porém ele funcionará apenas enquanto o serviço
networking não for reiniciado.
131
Rede
A rede que o seu host faz parte pode ser definida através do comando interfaces, e é a forma mais indicada.
C
aso a rede não seja explicitada e o sistema de obtenção de parâmetros de rede não
seja DHCP, o sistema irá confrontar a máscara padrão 255.255.255.0 sobre o IP
atribuído à interface para definir a rede. Digamos que o IP seja 10.15.20.200, a rede
será 10.15.20.0.
Também é possível definir uma máscara utilizando o comando ifconfig, porém a alteração
será temporária (será visto na página 138).
Gateway
Para se definir um gateway para que todas as vezes que o computador for ligado ele seja
definido, é possível se inserir um script de inicialização dentro de um dos rc's alocados dentro
/etc/init.d ou do diretório /etc/network/if-up.d ou então configurar no arquivo interfaces explicitando
qual será o gateway.
Também é possível inserir uma rota temporária utilizando o comando route (veremos na página 142).
Nomes
Computadores trabalham com bits (zeros e uns); a interface de programas criados para configuração da rede trabalham com números; e usuários e administradores, em suas atividades rotineiras, trabalham com nomes. Para se trabalhar com nomes, são necessários serviços que façam
a conversão de um formato em outro. Antigamente, todos os computadores conectados à internet
tinham um arquivo como o hosts, este abaixo:
Arquivo de configuração: /etc/hosts
Neste arquivo existiam todos os nomes utilizados pelas pessoas associados a um endereço
IP. Toda vez que um nome era digitado automaticamente um gerenciador de nomes recebia o
nome e transformava em um IP. A conversão de IP para bits era feita pelos protocolos de rede.
Toda vez que alguém criava um novo local na rede, enviava o IP e dados adicionais desse local
para um grupo de pessoas que ficavam responsáveis por criar um hosts completo e enviar para
todos que estiverem cadastrados em uma lista de e-mails. No começo funcionava bem, mas com
o tempo uma fila de solicitação de inclusão de nomes começou a crescer muito, e as atualizações
132
deste arquivo muito frequente. Para evitar os problemas causados pelo inchaço da internet foi criado o DNS (Domain Name Server - Servidor de nomes de domínio). Este serviço substituiu o arquivo local de nomes, servindo como um servidor de conversão de nomes. Toda vez que um
nome deve ser convertido em um IP, o DNS é consultado e ele retorna o endereço.
Mesmo com os complexos serviços de conversão de nomes existentes hoje, o arquivo hosts
permanece na maioria dos sistemas Unix-Like.
Dentro deste arquivo é possível associar nomes a IPs sem a necessidade de se consultar
um DNS. Dentro deles temos, por padrão, o nome localhost. Este nome significa Terminal Local,
ou seja, o computador em que o usuário está. Ele é muito útil em várias tarefas, como testar a in terface de rede do seu computador. Para isso o usuário pode pingar para localhost em vez do seu
próprio IP ($ ping localhost), ou então configurar o CUPS pelo navegador, digita na caixa de endereço http://localhost:631.
Vejamos um exemplo do hosts:
127.0.0.1 localhost safadim 127.0.1.1 ecelepar11940.celeparsl ecelepar11940 Sintaxe:
IP
nome1 nome2 nome3 … nome(n)
Observações importantes
Todas os campos DEVEM ser separados por espaços (pode ser um, vários ou TABs);
Os nomes DEVEM começar com um caractere alfabético;
Os nomes DEVEM finalizar com um caractere alfanumérico;
São permitidos os caracteres alfanuméricos, ponto (.) e o hífen (-).
Além destes nomes, é necessário configurar um servidor DNS para que os endereços da internet possam ser convertidos. O simples www.google.com.br não poderá ser acessado se o resolv.conf não estiver configurado com um servidor DNS válido.
Arquivo de configuração: /etc/resolv.conf
Os DNS devem ser configurados da seguinte forma:
nameserver 10.15.16.6 10.15.16.8
Sintaxe:
nameserver DNS1
DNS2 DNS3 … DNS(n)
133
Pode ser usado um nome em vez de um endereço IP.
PRIMEIROS SOCORROS
Antes de qualquer coisa, pensemos o que é necessário fazer para tentar identificar os principais problemas em uma rede de computadores:
O cabo da internet está conectado corretamente? (verificar se a luz da placa de rede
está acesa e se o seu ponto está funcionando, colocando-o em um outro computador, e colocando
o cabo do outro computador no que apresentou problema originalmente. Utilizar o comando mii-tool para verificar se o protocolo de comunicação da camada física foi negociada – página 157);
É possível “pingar” para endereços locais e externos? (pingar significa jogar um pacote
para um computador e ver se ele manda-o de volta. Se ele mandar, é que está respondendo, estando acessível. Tentar vários tipos de hosts é interessante para saber se o problema é no roteamento de dados. Pode-se ter comunicação na rede, mas quando tentado sair da rede pelo roteador, algo pode acontecer de errado. Para verificar se as interfaces estão funcionando corretamente e se a conexão com o host pode ser estabelecida, utiliza-se o comando ping – página 134);
O serviço referente à rede está rodando corretamente? (reiniciar o serviço da rede é
uma boa pedida para verificar se ele não estava apenas travado ou então para receber as primeiras informações de problemas. Para isso execute o comando /etc/init.d/networking restart, logicamente que como superusuário);
A interface utilizada para se conectar à rede está configurada apropriadamente? (deve-se verificar se a interface está ativa - ifconfig e route - e se os principais arquivos de configuração de uma rede estão configurados corretamente - /etc/network/interfaces - /etc/resolv.conf /etc/hosts - /etc/network);
Outros serviços conseguem se conectar à rede? (o navegador pode estar com problema,
mas o ssh consegue se conectar? É possível acessar um local da rede por ftp? As vezes o problema é uma configuração de uma aplicação, e não de configuração do sistema);
Este é um bom exemplo de como se comportar diante de um problema de rede. Agora que
já abordamos vários conceitos necessários para um bom administrador de redes, vamos verificar
o funcionamento de alguns comandos que devem fazer parte do seu canivete suíço.
PING
O ping é o comando mais simples e útil que você pode imaginar. Ele simplesmente pergunta
a uma interface remota se ela está acessível. É quase igual a quando você está num hospital e
aperta o botão da enfermeira sem necessidade nenhuma, só para ver ela entrando desesperada
134
no seu quarto e ter a segurança de que ela está acessível e atenta às suas requisições (com a
grande vantagem que as repostas ao comando ping não desacreditam e param de responder na
quinta chamada).
O comando ping utiliza o protocolo ICMP como colaborador principal. Como já vimos, o
ICMP está na camada de rede, junto ao protocolo IP, e auxilia-o em várias atividades. Como este
protocolo está na camada 3 do protocolo TCP/IP, o ping não realiza troca de dados de aplicativos,
e sim envia um pacote de teste que possui um cabeçalho com o IP, atributos ICMP e marcas de
tempo para fazer seus cálculos posteriormente. Todo o resto do pacote é um monte de informações binárias que servem só para preencher a estrutura do frame. O cabeçalho do IP possui 20
bytes, contendo informações sobre os IPs da origem e destino das solicitações. A parte específica
do ICMP possui 8 bytes. O padrão é de um pacote com cabeçalho de 8 bytes mais 56 bytes adicionais, com informações adicionais e bits aleatórios. Se houver resposta, ele verifica o tempo de
resposta e mostra ao usuário.
Os campos mostrados pelo comando ping são os seguintes:
PING <host> (IP_do_HOST) tam1(tam2) bytes of data.
Tam3 bytes from <host> (IP_do_HOST): icmp_seq=n ttl=n time=n.nnn ms
Os “n”s são as principais informações que o comando ping nos trazem. Eles ficam dentro do
cabeçalho ICMP e são chamados de TTL (Time To Live - Tempo de Vida) e TIME (tempo). Toda
vez que um pacote é enviado, ele pode ser considerado perdido e aparece uma mensagem de
erro. Existem vários motivos para que um pacote se perca, sendo um deles ser excedido o número máximo de hops, ou seja, o número máximo de roteadores para chegar ao seu destino. O número padrão é de no máximo 61 hopes para chegar ao destino. Já no caso de haver uma resposta, será verificado através do cabeçalho ICMP o tempo de saída e de chegada, e calculado o tempo que o pacote levou para ir e voltar do destinatário. Esta informação é mostrada em TIME.
A
unidade utilizada pelo ping é o ms e é o acrônimo de milissegundo – 1,0 x 10 -3 s ou
0,001 s.
icmp_seq traz uma informação muito valiosa para o administrador: o número de sequência
do pacote que está sendo enviado. Se 10 pacotes forem enviados e apenas o 1, 4 e 10 chegarem,
isso quer dizer que muitos problemas estão acontecendo no caminho, ocasionados provavelmente
por algum dos roteadores. Se isto acontecer, é interessante usar o comando traceroute para verificar onde estão os problemas.
A
s informações de hora e data de saída e chegada dos pacotes ficam num campo
(quadro) chamado timeval, que fica fora dos cabeçalhos. Assim, se o usuário definir
135
um pacote menor que o quadro do timeval, que é de 8 bytes, a informação TIME não
aparecerá.
Vejamos alguns exemplos da utilização do ping:
1.Verificando se um host remoto está acessível pelo IP:
~$ ping 10.15.15.1 PING 10.15.15.1 (10.15.15.1) 56(84) bytes of data. 64 bytes from 10.15.15.1: icmp_seq=1 ttl=61 time=0.453 ms O
comando ping é ininterrupto. Para finalizar a sua execução, pressione o conjunto
de teclas <CTRL><C>.
2.Verificando se um host remoto está acessível pelo nome:
~$ ping www.uglypeople.com PING www.uglypeople.com (67.55.69.153) 56(84) bytes of data. 64 bytes from 67.55.69.153: icmp_seq=2 ttl=57 time=127 ms 3.Verificando quais hosts estão disponíveis em uma rede (use o broadcast da rede):
~$ ping b 10.15.15.255 WARNING: ping broadcast address PING 10.15.19.255 (10.15.15.255) 56(84) bytes of data. 64 bytes from 10.15.15.57: icmp_seq=1 ttl=255 time=0.217 ms 64 bytes from 10.15.15.18: icmp_seq=1 ttl=64 time=0.459 ms (DUP!) 64 bytes from 10.15.15.3: icmp_seq=1 ttl=64 time=0.505 ms (DUP!) Caso um computador não esteja acessível, as seguintes mensagens poderão ser mostradas na tela:
Mensagem
136
Significado
Network unreacheable
Rede de destino intangível, ou seja, o pacote atingiu o máximo de
pulos de roteadores e não conseguiu encontrar a rede desejada.
Host unreacheable
Igual ao anterior, mas em vez de rede, não foi possível atingir um
host.
Protocol unreacheable
O protocolo utilizado pelo cliente está desativado no host remoto.
Port unreacheable
A porta pela qual o cliente tenta se comunicar com o host remoto
não possui nenhum serviço associado.
Destination
unknown
network A rede a qual o cliente está tentando se conectar não é
reconhecida. Isso quer dizer que não existe na tabela de
roteamento uma saída que o leve à rede desejada.
Destination
unknown
network Igual à mensagem anterior, porém o que não se conhece e não
se existe caminho indicado é um host.
WGET
Para realizar downloads de arquivos da internet não é necessário se ter uma interface gráfica, apenas o endereço do quê se quer baixar. O wget faz download de arquivos, pacotes e páginas completas de uma forma não interativa. Objetividade é o lema do wget. “Coloque o endereço
exato do que vai ser feito download, dê um <Enter> e espere a barra chegar a 100%”, isto é o que
o wget tem a lhe dizer. Outra vantagem da utilização do wget é que ele não é interativo, já que não
requer que o usuário que iniciou o processo fique cuidando do descarregamento, podendo até
mesmo se fazer logoff do sistema sem danos ao download. Logicamente que ele deve ser rodado em segundo plano através do parâmetro -b, ou com o e comercial (&) ou manipulando-o
com o comando bg. O wget também recomeça quantas vezes forem necessárias o download
caso ocorra algum problema (desde que o servidor tenha este recurso). Tudo isto automaticamente.
Prático e completo, este é o WGET!! Revejamos suas características:
1.Objetividade (coloque um <Enter> e pronto);
2.Rapidez (processo 100% dedicado ao download);
3.Autonomia (não é necessário se ter um usuário logado);
4.Gerenciamento de download (permite que se reinicie o download quantas vezes for desejado).
Você poderá trabalhar com os seguintes protocolos: http, https e ftp. Isso quer dizer que os
endereços devem começar com algum desses termos para que o wget saiba quais serão as regras utilizadas durante a transferência.
-b (de background)
-q (de quiet)
so de download)
Inicia o wget direto em background.
Não mostra a saída padrão do wget (mensagens e barra de progres-
-i <arquivo>
Busca dentro de um arquivo de texto puro endereços para fazer
download. Estes endereços deverão estar cada um em uma linha própria.
-r (recursivo)
Faz o download não só de uma página, mas de todas as páginas que
estiverem dentro do mesmo domínio do site especificado.
$ wget http://www.celepar.pr.gov.br
20090304 16:05:54 http://www.celepar.pr.gov.br/ Resolvendo www.celepar.pr.gov.br... 200.189.113.212 A conectar www.celepar.pr.gov.br|200.189.113.212|:80... conectado! HTTP requisição enviada, aguardando resposta... 200 OK Tamanho: nao especificado [text/html] A gravar em: 'index.html.7' [
<=> 137
] 33.246 .K/s em 0,07s 20090304 16:05:54 (457 KB/s) 'index.html.7' gravado [33246] C
aso seja necessário passar por um proxy para chegar à internet, é necessário configurá-lo no arquivo /etc/profile.
IFCONFIG
Este comando já foi visto no módulo básico deste curso, porém de forma superficial. Ele
mostra ao administrador as informações acerca de uma (ou todas) interface de rede. É possível,
também, mudar alguns parâmetros da rede através dele, mas estas alterações serão válidas somente enquanto o computador permanecer ligado ou enquanto algum daemon de rede não atualizar os parâmetros de acordo com os seus respectivos arquivos de configuração. Ou seja, as configurações sempre são temporárias.
O comando pode ser usado sem nenhuma informação adicional. Feito isso, o resultado será
todas as interfaces de rede ativas no sistema. Se o administrador desejar verificar todas as interfaces, inclusive as ocultas, deverá executar o comando com o parâmetro “-a” (de ALL - TODOS em
inglês).
$ sudo ifconfig
eth0 Link encap:Ethernet Endereço de HW 00:22:15:9e:c1:10 inet end.: 10.15.17.26 Bcast:10.15.19.255 Masc:255.255.252.0 endereço inet6: fe80::222:15ff:fe9e:c110/64 Escopo:Link UP BROADCASTRUNNING MULTICAST MTU:1500 Métrica:1 RX packets:6899938 errors:0 dropped:0 overruns:0 frame:0 TX packets:517361 errors:0 dropped:0 overruns:0 carrier:0 colisões:0 txqueuelen:1000 RX bytes:2916776889 (2.7 GiB) TX bytes:158556252 (151.2 MiB) IRQ:216 Endereço de E/S:0xc000 Existem vários campos mostrados pelo ifconfig. Vejamos quais são eles:
Link encap
Encapsulamento da comunicação
Mostra qual é o tipo de encapsulamento de dados adotado pela camada de
enlace.
Endereço de Endereço de HW - Endereço de Hardware
HW
Mostra qual é o endereço físico da interface (o MAC address).
138
inet end
Bcast
Masc
Interface Net Endereço - Endereço da interface de rede
Mostra qual é o IP atribuído à interface.
Broadcast
Mostra qual é o endereço que a interface usará quando quiser enviar
mensagens de broadcast.
Máscara
Mostra qual é a máscara da rede a qual a interface pertence.
BROADCAST Informa que a interface suporta broadcast.
MULTICAST
Informa que a interface suporta multicast.
MTU
Maxime Transfer Unit - Unidade máxima de transferência
Informa qual é o tamanho máximo de dados trafegados em cada quadro
(frame) no meio físico utilizado pela interface (quadros são os
agrupamentos criados na camada de enlace do protocolo TCP/IP).
RX
Packages Received - Pacotes recebidos livres de erros
Mostra a quantidade de pacotes recebidos da rede através da interface
indicada.
Errors: Pacotes enviados a esta interface que não chegaram.
Dropped: Pacotes negados por esta interface.
Overruns: Pacotes não recebidos por terem chegado antes do kernel ter
indicado que eles poderiam ser enviados.
frame: Pacotes que tiveram problema no momento de sua montagem,
devido a falta de algum quadro.
TX
Packages Transmitted - Pacotes transmitidos livres de erros
Mostra a quantidade de pacotes enviados para a rede através da interface
indicada.
Errors: Pacotes transmitidos por esta interface que não chegaram ao
destino.
Dropped: Pacotes transmitidos negados pela interface de destino.
Overruns: Pacotes transmitidos não recebidos por terem chegado antes do
kernel do destinatário ter indicado que eles poderiam ser enviados.
Carrier: Número de vezes que a via de transmissão (o transportador) foi
desabilitada, como um cabo de rede que foi retirado ou então um switch
que foi desligado.
colisões
Número de pacotes colididos na rede. Sempre que um computador quer
enviar algum dado pelo meio físico, ele escuta este e verifica se o caminho
está livre. Se estiver, ele manda seu quadro. Pode ser que dois
computadores escutem a rede, verifiquem a disponibilidade de transmissão
e enviem ao mesmo tempo um quadro. Isto fará com que os quadros
colidam e ambos tenham que enviar novamente.
IRQ
Interrupt Request - Requisição de Interrupção
Mostra qual é o endereço IRQ 21 utilizado pela interface. É possível verificar
este endereço, e até alterá-lo, através do arquivo /proc/interrups.
Endereço
de E/S
Endereço de Entrada e Saída
O IRQ é a identificação, aqui temos o endereço físico na memória principal
referente ao espaço específico de pedido de interrupção.
21 IRQ é um sinal que indica a necessidade de determinado dispositivo de utilizar o processador. Cada endereço IRQ é
um endereço fixo na memória. Quando um dispositivo precisa enviar dados para serem processados, ele envia um
sinal ao espaço fixo associado a ele, fazendo com que o processador saiba que deverá receber dados dele e processálos. Como os IRQ têm prioridades altas, o processador deve interromper tudo para processar os dados.
139
O
lenny traz o suporte a IPv6 nativamente. Podemos verificar o endereço atribuído à
interface após inet6. Ainda não existem muitos serviços rodando com este protocolo, mas provavelmente ele irá substituir o IPv4. Se você quiser estudá-lo, existem várias
fontes na internet a respeito.
Existem alguns flags que trabalham com o ifconfig e o permitem realizar configurações temporárias no seu computador.
A
pesar de serem configurações temporárias, é possível definir o ifconfig para ser rodado no boot do computador.
up
Faz com que a interface de rede torne-se acessível à camada inter-rede. Sem isto, o protocolo TCP/IP não sabe de sua existência.
Sempre devemos indicar qual interface deve ser ativada em relação à camada inter-rede (e
automaticamente ao sistema) e depois indicar o flag up.
# ifconfig eth0 up
Se desejado, o administrador poderá definir os parâmetros de rede da interface. Vamos criar
um alias de interface para que você possa testar:
# ifconfig eth0:0 192.168.1.100 netmask 255.255.0.0 up
Agora, executando o comando ifconfig será possível ver que a interface foi ativada:
eth0:0 Link encap:Ethernet Endereço de HW 00:22:15:9e:c1:10 inet end.: 192.168.1.100 Bcast:192.168.255.255 Masc:255.255.0.0 UP BROADCASTRUNNING MULTICAST MTU:1500 Métrica:1 IRQ:216 Endereço de E/S:0xc000 O
UP e o RUNNING indicam que a interface está ativada e já em atividade. O UP indica que a interface está disponível, com identificação IP e conectada à camada inter-rede, e o RUNNING indica que a placa está aceitando pacotes da rede e enviará dados, caso solicitado.
down
Fará o inverso que o flag up faz. Desativa a interface, ou seja, torna a interface inacessível
pela camada inter-rede. Fazendo isso, todas as entradas na tabela de roteamento que referencia-
140
rem esta interface serão apagadas.
P
A
ara enxergar todas as interfaces que não estão ativas, é necessário utilizar o parâmetro “-a”.
utomaticamente, após “derrubar” uma interface, qualquer entrada dela na tabela de
roteamento será apagada.
IFUP E IFDOWN
Tem diferença destes comandos com o ifconfig? Sim! Estes comandos usam o ifconfig e os
scripts que ficam dentro de diretórios próprios deles.
IFUP: Executa o IFCONFIG <Interface> UP e todos os scripts que ficam dentro do diretório
/etc/network/if-up.d.
IFDOWN: Executa o IFCONFIG <Interface> DOWN e todos os scripts que ficam dentro do
diretório /etc/network/if-down.d.
Toda vez que o ifup é executado ou uma interface a qual deseja-se ativar deve ser especificada, ou então o parâmetro “-a” (de auto) deve ser definido. O parâmetro -a irá ativar TODAS as
interfaces que estiverem setadas com AUTO. O mesmo pode ser feito com o idown, com a diferença que todas as interfaces serão derrubadas, independente de estarem ou não setadas como
auto.
Veja os exemplos de utilização. Dentro do arquivo /etc/network/interfaces, irei definir a seguinte interface de rede:
iface eth0:LOUCO inet static
address 10.0.0.10
netmask 255.0.0.0
Repare que não estou colocando a linha “auto eth0:LOUCO”.
Agora irei reiniciar o serviço de rede:
# invokerc.d networking restart
Executando o ifconfig posso verificar que o alias está ativo:
# ifconfig
eth0:LOUCO Link encap:Ethernet Endereço de HW 00:22:15:9e:c1:10 inet end.: 10.0.0.10 Bcast:10.255.255.255 Masc:255.0.0.0 UP BROADCASTRUNNING MULTICAST MTU:1500 Métrica:1 IRQ:216 Endereço de E/S:0xc000 Podemos perceber que a interface está funcionando. Agora iremos executar o comando
141
para desativar TODAS as interfaces ativas:
# ifdown a
Todas as interfaces vão ser desativadas. Agora iremos entrar no arquivo /etc/network/interfaces e iremos inserir o alias eth0:LOUCO na mão. As seguintes linhas serão inseridas:
auto eth0:LOUCO
iface eth0:LOUCO inet static
address 10.0.0.10
netmask 255.0.0.0
P
ara criar o alias é necessário se utilizar uma interface existente. No meu caso usei a
interface eth0 e criei um alias chamando-a de eth0:LOUCO, podendo ser qualquer
nome após os dois pontos. Outro detalhe que deve ser observado é quanto a diretiva do
eth0. Ele não pode estar setado como allow-hotplug. Se estiver, troque por auto eth0.
Verifique com ifconfig se existem alguma interface ativa. Verá que não existe nenhuma. Agora execute o comando abaixo:
# ifup a
Todas as interfaces estarão ativas, inclusive o alias eth0:LOUCO (sempre verifique com o ifconfig). Agora volte ao arquivo /etc/network/interfaces e comente a linha do alias que contém “auto
eth0:LOUCO”. Agora execute os dois comandos abaixo:
# ifdown a
# ifup a
# ifconfig
Você verá que somente a placa eth0 está ativa, isso porque o alias está sem a opção auto.
Para ativá-la será necessário especificar a interface utilizando “# ifup eth0:LOUCO”.
ROUTE
O comando route manipula ou simplesmente mostra as informações contidas na tabela de
roteamento do kernel de seu computador. A tabela de roteamento indica os caminhos possíveis
que cada pacote a ser enviado deverá seguir para chegar à interface remota. É um mapa que possui regras de navegação pela rede. É o “GPS“ dos pacotes. Cada interface tem sua própria tabela
de roteamento. Se existirem duas interfaces em um mesmo computador, ambos podem estar conectados a redes diferentes e servirem de roteadores de pacotes entre elas. Vejamos a cara de
uma tabela de roteamento:
$ route n Tabela de Roteamento IP do Kernel 142
Destino Roteador MáscaraGen. Opções Métrica Ref Uso Iface 10.15.17.22 10.15.16.1
255.255.255.255
UGH 0 0 0 eth0
10.15.16.0 0.0.0.0 255.255.252.0 U
0 0 0 eth0
192.168.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth1
0.0.0.0 10.15.16.1 0.0.0.0 UG 0 0 0 eth0 No caso acima, temos 4 regras e elas são atendidas pela prioridade. Quanto mais acima
mais prioritária.
1.A primeira linha define que todos os pacotes que tenham como destino o computador específico 10.15.17.22 deverão ser enviados ao roteador 10.15.16.1 através da interface eth0;
2.A segunda linha define que todos os pacotes que tenham como destino a rede 10.15.15.0
com máscara 255.255.252.0 devem ser enviados por broadcast para todas as interfaces que tenham conexão física direta com a interface eth0;
3.A terceira linha define que todos os pacotes que são enviados para a rede 192.168.0.0
com máscara 255.255.0.0 devem ser enviados por broadcast para todas as interfaces que tenham
conexão física direta com a interface eth1;
4.Caso nenhuma das regras anteriores forem atendidas, aí a regra padrão, indicada por
0.0.0.0 no destino (como se fosse um coringa que indica “Qualquer endereço”), é atendida. Na
quarta linha, qualquer pacote destinado a endereços que não se encaixem nas regras anteriores
devem ser enviados ao roteador 10.15.16.1.
Em opções podemos verificar algumas letras. O U indica que a regra está UP, ou seja, ATIVA; o G indica que o destino é um roteador e não um broadcast às escuras; e o H indica que o
destino é um HOST, ou seja, a regra se aplicará a um computador específico, e não a uma rede
inteira (indicação existente para diferenciar da opção mais comum, que é como destino a rede).
Vale frisar que sempre que as regras são atendidas na seguinte ordem:
1º Cache de roteamento;
2º Tabela de roteamento do kernel, tendo as primeira linhas prioridade em relação às anteriores.
E esta ordem não é editável. Quem as define é o próprio gerenciador de roteamento. Vejamos outros campos que aparecem na saída deste comando:
Colunas
Métrica
Descrição
Mostra o número de saltos necessário para chegar ao destino. Antigamente, o
roteamento de pacotes era feito na unha. Hoje em dia temos roteadores que
fazem este trabalho. Então sempre que um host não estiver na rede local, ele é
enviado para um roteador que saberá o que fazer. Como o destino será um
roteador conectado à interface de destino, não haverá nenhum salto. Sendo
assim, hoje em dia é muito difícil se encontrar algum valor de métrica diferente
143
de zero.
Ref
Também obsoleto, este campo mostra o número de interfaces que referenciam
um destino. Isto era interessante para saber se um destino que estivesse a
alguns hopes de distância possuía alguma interface (caminho alternativo)
apontando para ele.
Uso
Ao utilizar o parâmetro “-C” com o route, é possível visualizar o CACHE de
roteamento. Todos os caminhos realizados são armazenados lá até o
reiniciamento do computador. Se um mesmo destino for definido por algum
serviço de rede, o gerenciador de roteamento verificará que a entrada já existe
no cache, permitindo que ele seja encontrado da forma mais eficaz. Neste
campo verificamos quantas vezes cada uma das entradas do cache são
utilizadas.
Iface
(Interface) Indica a qual interface a regra se aplica.
Agora vamos verificar como configurar a tabela de roteamento. Cabe observar que o trabalho de roteamento é feito por softwares específicos dos roteadores, por isso, iremos configurar
apenas duas opções: pacotes destinados a computadores da rede local e computadores de redes
remotas.
Sintaxe
Você sempre precisará digitar o nome do comando
1
route
e depois dizer qual é a operação desejada
2a
add (adicionar uma nova rota)
2b
del (remover uma rota existente)
OU
Então deve-se definir se o destino vai ser
3a
-host (um computador específico)
Ex: -host 192.168.15.15
3b
-net (uma rede definida)
Ex: -net 10.15.15.15 netmask 255.255.255.0 (define a rede 10.15.15.0/24)
Ex: -net 10.15.15.0 netmask 255.255.255.0 (define a mesma rede)
S
3c
empre que o alvo “-net” for usado, devemos utilizar o complemento netmask. Se for
utilizado o alvo “-host” esta informação não deve ser passada.
default (qualquer computador do mundo que não especificado em outras regras -
pode ser substituído por “-net 0.0.0.0”)
Após isso, tem-se que configurar para quem deverá ser enviado o pacote caso o campo
144
Destino seja atendido.
4a
gw (gateway - roteador)
Ex: gw 10.15.15.1 (define que os pacotes devem ser enviados para o roteador
10.15.15.1)
4b
NADA (não define roteador)
Agora, se assim desejar, podem ser inseridos parâmetros e a interface a qual terá a regra
definida.
5
dev (device - interface que adotará a regra)
Ex: dev eth0 (define a regra para a interface eth0)
E
sta opção é obrigatória para definir uma regra para a rede local. Isso é assim porque
se existirem mais de uma interface de rede, será necessário indicar qual delas está
conectada fisicamente à rede.
Principais parâmetros:
Parâmetro
Descrição
-C (cache)
Mostra o cache de roteamentos já realizados desde que o computador foi
ligado.
-n
Não mostra nomes dos destinos ou roteadores. Dependendo do seu
DNS, esta opção torna mais rápida a consulta.
Exemplos
Então vamos para nossos exemplos. Vamos começar com uma tabela completamente zerada:
# route n
Tabela de Roteamento IP do Kernel Destino Roteador MáscaraGen. Opções Métrica Ref Uso Iface Nada. Agora iremos criar uma regra dizendo que sempre que um pacote que for destinado a
rede local 10.1.1.0 seja enviado por broadcast para todos os computadores conectados a menos
de um salto de distância. Usaremos os seguintes números vistos anteriormente:
1 = por ser configuração de rota de pacotes;
2a = por ser evento de adição de rota;
3b = por ter como destino uma rede (a rede local);
4b = porque não iremos definir um roteador;
145
5 = porque é obrigatório na configuração de pacotes destinados à rede local.
# route add net 10.1.1.0 netmask 255.255.255.0 dev eth0
# route n
Tabela de Roteamento IP do Kernel Destino Roteador MáscaraGen. Opções Métrica Ref Uso Iface 10.1.1.0
0.0.0.0
255.255.255.0 U
0 0 0 eth0
Agora já conseguiremos pingar, por exemplo, para qualquer computador da rede. Para pingar uma página da internet, precisaremos de um roteador que nos conecte a ela. No meu caso, o
roteador que me conecta ao mundo é o 10.1.1.1. Vejamos como configurar um roteador para qualquer computador de uma rede externa.
1 = por ser configuração de rota de pacotes;
2a = por ser evento de adição de rota;
3c = por se tratar de uma rede específica configurada no /etc/networks;
4a = porque um roteador será definido para tentar encontrar a rede desejada;
5 = regras serão aplicadas à primeira interface ativada pelo sistema.
# route add default gw 10.1.1.1
# route n
Tabela de Roteamento IP do Kernel Destino Roteador MáscaraGen. Opções Métrica Ref Uso Iface 10.0.0.0
0.0.0.0
255.255.255.0 U
0 0 0 eth0
0.0.0.0
10.1.1.0
0.0.0.0
UG
0 0 0 eth0
E se tivéssemos uma segunda interface de rede e quiséssemos configurar um roteador e a
rede local a qual ela está conectada? Repetiríamos os dois processos anteriores, só mudando as
interfaces e os endereços. A rede local hipotética seria 192.168.16.0
# route add net 192.168.16.0 netmask 255.255.252.0 dev eth1
# route add default gw 192.168.16.1 dev eth1
O seu computador estaria ligado, se fosse como mostrado acima, em duas redes distintas.
Se ele tiver um software específico de roteamento pode vir a se tornar um roteador.
IFTOP
É parecido com o comando que visualiza os processos carregados na memória, só que este
verifica o tráfego de rede de uma interface específica. Ele fica escutando e delatando tudo que
sua interface está fazendo. É possível definir qual interface deseja-se escutar, mas não é neces-
146
sário. Caso não seja especificada a interface, a primeira encontrada é a que será verificada.
O iftop não vem instalado por padrão. O pacote para instalação é o iftop.
A saída do comando terá a seguinte cara:
Figura 10: Saída do comando IFTOP
O iftop é meio espaçoso, e percebe-se isso pelo fato dele utilizar toda a tela. Não é possível
utilizar o terminal enquanto ele estiver rodando, já que ele roda em modo foreground22.
No topo da tela temos as taxas de transferência, que variam de 0kbps (quilo bytes por segundo) a 977kbps. As interações que estiverem com maior taxa de tráfego ficarão mais acima na
lista. A tela será atualizada a cada 2 segundos com novas informações de conexões e taxas de
transferências.
Abaixo da escala de taxas de transferência temos seis colunas com campos diferentes. Vejamos cada uma deles:
Primeira coluna
Endereço da primeira interface do par da conexão.
P
ode ser mostrado como nome, IP e pode ser habilitada a opção de mostrar a qual
porta UDP ou serviço o pacote pertence (isto é feito através do parâmetro “-p”).
22 Primeiro plano.
147
Segunda coluna
Indicação do sentido da comunicação entre o par de interfaces. Se o sentido for da interface
da esquerda para a interface da direta, a indicação será =>. O contrário será <=. Sempre teremos
as duas vias da comunicação. Na primeira linha de cada interface temos a taxa de transferência
dela para o destino, e na linha seguinte a taxa de transferência do destino para a origem.
Terceira coluna
Endereço da outra interface que está ou recebendo ou enviando algum pacote. Fecha o par
da linha.
Quarta, quinta e sexta coluna
Taxa de transferência do pacote que passou pela interface. São três colunas pois existe a
taxa de transferência entre as duas interfaces mostradas nas colunas 1 e 3 em função de três intervalos diferentes: 2, 10 e 40 segundos.
Na parte inferior da tela existe um resumo das atividades de rede da interface que está sendo analisada. Existem disponíveis para consulta as seguintes informações:
TX
Informa a quantidade de dados que foram enviados pela interface que está sendo
analisada.
cumm Total de dados enviados desde o início da execução do IFTOP.
RX
peak
Pico: Maior taxa de transferência de dados enviados nos últimos 40
segundos.
rates
Taxas: Mostra a taxa de transferência total dos pacotes enviados da
interface nos últimos 2, 10 e 40 segundos.
Informa a quantidade de dados que foram enviados pela interface que está sendo
analisada.
cumm Total de dados recebidos desde o início da execução do IFTOP.
peak
Pico: Maior taxa de transferência de dados recebidos nos últimos 40
segundos.
rates
Taxas: Mostra a taxa de transferência total dos pacotes recebidos da
interface nos últimos 2, 10 e 40 segundos.
TOTAL Mostra o total de cada coluna mostrada anteriormente.
cumm Total de dados transmitidos (recebidos e enviados) pela interface.
peak
Pico: Soma das maiores taxas de transferência dos dados enviados e
recebidos.
rates
Taxa: Mostra a taxa de transferência total dos pacotes recebidos e
enviados da interface nos últimos 2, 10 e 40 segundos.
Alguns parâmetros interessantes que podem ser usados durante a execução do comando:
148
Parâmetro
Descrição
H (maiús.) H de Help - Ajuda: irá informar-lhe quais são os principais parâmetros do iftop.
P (maiús.) P de Paralisar: paralisa a tela no momento de sua ativação. Para desparalisar,
deve-se clicar novamente sobre as teclas <SHIFT><P>.
o (minús.)
o de Ordem: este parâmetro congela a ordem das interfaces, mas não para a
atualização do monitoramento. O que está na primeira linha continuará na
primeira linha e com atualizações normais das taxas de velocidade de
transmissão; a segunda linha ficará sempre na segunda linha e assim por
diante.
p (minús.)
p de Porta: paralisa
SeD
(maíus.)
Habilita a opção de visualização de portas ou serviços que são responsáveis
pelos pacotes.
S de Source (origem): habilita a visualização da porta que está sendo
utilizada pela interface de origem.
D de Destino: habilita a visualização da porta que está sendo utilizada pela
interface de destino.
t
t de Tipo: altera o tipo de visualização. Existem quatro. Para alternar basta
pressionar seguidamente a mesma tecla.
1º: mostra a taxa de transferência do par de interface em duas vias;
2º: mostra a taxa de transferência do par de interface em uma linha;
3º: mostra a taxa de transferência somente da origem ao destino;
4º: mostra a taxa de transferência somente do destino à origem.
jek
Vão uma tela para cima e para baixo, respectivamente. Interessante de ser
usado quando a tela está congelada (através do parâmetro “o”).
l
l de Locate - Localize: localiza alguma interface específica.
Para procurar algum endereço, por exemplo, pressione a tecla <l> para que
apareça “Screen filter>” no topo da tela. Escreva o nome da interface e
pressione sobre <ENTER>. Para voltar a visualização normal pressione
novamente <l>, apague o que tiver após “Screen filter>” e pressione <ENTER>
novamente.
Não afeta os subtotais que aparecem na parte inferior da tela.
Agora que você já está hacker no iftop, vamos praticar. Iremos executar o iftop já com a opção de nomes suprimidos ativada.
# iftop n
Perceba que existem muitas linhas que são de broadcast. Toda vez que um computador
qualquer da sua rede faz um broadcast por qualquer motivo, você recebe o pacote e verifica se
ele lhe pertence. Estas entradas aparecem no iftop. Tirando estas entradas, temos apenas conexões com outros computadores, sendo você o cliente ou servidor. Abra um novo terminal e execute o comando:
$ ping <o seu gateway> s 2048
149
S
e você não souber qual é o gateway do computador em que está, então complicou.
Releia o comando route. Caso esteja com preguiça, copie o comando a seguir sem
entender nada “ route -n | grep 'UG[ \t]' | awk '{print $2}' ”.
Agora volte para o terminal que o iftop está e tente encontrar a linha que tenha o seu IP e o
gateway digitado como par. Para facilitar digite <l>, digite o ip do gateway e pressione <Enter>.
10.15.17.100
=> 10.15.16.1 8.22Kb 5.75Kb 1.44Kb <= 8.22Kb 5.75Kb 1.44Kb Veja que o filtro fez com que somente as linhas que contém o que foi usado como critério de
filtro de tela aparece. Por estarmos pingando, um pacote é enviado e deve ser respondido, sendo
que a transmissão se dá em ambos os lados de forma igual. O computador 10.15.17.100 está enviando dados para o computador 10.15.16.1 enquanto este está enviado para aquele também, e
podemos ver os dados na linha de baixo. Do meu computador para o gateway, nos últimos 2 segundos a taxa de transferência foi de 8.22kb, no últimos 10 segundos foi de 5.78kb e nos últimos
40 segundos a taxa média foi de 1.44kb. Do destino para a minha interface foi a mesma coisa.
Este comando é muito interessante para saber quem está conectado à sua máquina e quanto da
sua interface ele está exigindo. Num servidor apache utilizamos muito este comando para sabermos quem está conectado à ele e se a banda está dando conta de atender a todas as requisições.
TRACEROUTE
Irá mostrar o caminho na rede percorrido pelos pacotes até chegar ao computador de destino. Este caminho é traçado através dos hopes transpostos pelos pacotes. Se forem necessários
2 roteadores até chegar ao servidor, serão mostrados 3 pontos (2 roteadores mais o servidor). Todas as interfaces destes nós são identificados pelo IP
$ traceroute 10.15.17.186 traceroute to 10.15.17.186 (10.15.17.186), 30 hops max, 40 byte packets 1 10.15.17.186 (10.15.17.186) 4.549 ms 4.559 ms 4.554 ms
$ traceroute www.google.com.br traceroute to www.google.com.br (209.85.193.99), 30 hops max, 40 byte packets 1 10.15.16.1 (10.15.16.1) 1.087 ms 1.478 ms 1.788 ms 2 10.15.55.252 (10.15.55.252) 1.186 ms 1.226 ms 1.282 ms 3 brinf99.google.com (209.85.193.99) 2.413 ms 4.006 ms 4.044 ms No curso Debian Básico, o comando route indica qual é o roteador utilizado para acessar redes externas. Neste curso iremos estudá-lo mais aprofundadamente, mas por enquanto vejamos
um exemplo simples de seu resultado:
150
$ sudo route n Tabela de Roteamento IP do Kernel Destino Roteador MáscaraGen. Opções Métrica Ref Uso Ifa
ce 10.15.16.0 0.0.0.0 255.255.252.0 U
0 0 0 eth0 0.0.0.0 10.15.16.1 0.0.0.0 UG
0 0 0 eth0 Veja acima que existem duas regras configuradas no computador utilizado para demonstrar
o traceroute: (a) se o computador que se deseja conectar estiver na rede 10.15.16.0 com máscara
255.255.252.0 (do IP 10.15.16.0 a 10.15.19.255), então não será necessário intermédio de roteador, podendo a requisição ser mandado diretamente ao IP servidor; (b) qualquer outro computador
deverá ter a conexão estabelecida através do roteador 10.15.16.1. Beleza! Agora veja que, com o
comando traceroute, o IP 10.15.17.186 estava na rede 10.15.16.0, 255.255.252.0, por isso o caminho percorrido pelos pacotes é reto, direto, havendo apenas um passo. Já o IP do google é
209.85.193.99, que está fora da rede do computador usado para o teste. Por isso, primeiro devese passar pelo roteador (10.15.16.1) e aí os pacotes vão passando por outros roteadores até chegar ao computador requisitado (209.85.193.99, cujo nome é br-in-f99.google.com).
traceroute to 10.15.17.186 (10.15.17.186), 30 hops max, 40 byte packets 1 10.15.17.186 (10.15.17.186) 4.549 ms 4.559 ms 4.554 ms
Para entender o que está sendo mostrado acima, vamos utilizar um equipamento especial
para gravar o que o traceroute fala enquanto executa o comando.
Trançando rota da interface deste computador ao computador de destino, que é 10.15.17.186, sendo que irei passar por no máximo 30 roteadores23. Se até lá ninguém souber desse computador, desisto. Meu meio de transporte terá 40 by
tes (incluindome). Vamos lá! Opa, este computador requisitado está nesta rede mesmo, já vou listálo aqui e chega de trabalho.
1 hope para chegar ao computador de destino. Em 3 testes, levei na primeira, segunda e terceira vez, 4.549 ms, 4.559 ms e 4.554 ms respectivamente para ir e voltar.
ttl (Time To Live)
Os hopes (ou saltos) são os nós de rede transpostos pelos pacotes. Eles servem para definir um limite de saltos que o pacote poderá dar até chegar ao seu destino. Normalmente não se
precisa de mais de 5 saltos para se chegar ao destino. Se isso acontecer, o roteamento deste pa23 Mas se o máximo é de 30 hopes, o certo não seria 29 roteadores mais o servidor? Mas para o roteador tanto faz,
afinal, pode ser que o servidor seja um roteador.
151
cote está errado, podendo até estar em looping (ser jogado de um roteador para o outro infinitamente). Para calcular a quantidade de saltos, os pacotes enviados pelo traceroute possuem em
seus cabeçalhos um parâmetro ttl com o valor inicial indicado na linha inicial do comando.
traceroute to 10.15.17.186 (10.15.17.186), 30 hops max, 40 byte packets O número máximo de hops é 30. Para verificar se o número de saltos foi excedido, a cada
nó de rede que o pacote passa, o valor ttl é diminuído em um. Se o computador alvo estiver na
mesma rede do requisitante, ao chegar ao destino, este irá diminuir o valor do ttl em um e enviará
dois pacotes à origem. O primeiro enviado pelo protocolo ICMP dizendo que o alvo foi atingido
(também é responsável por indicar que o alvo não foi atingido) e o segundo com as informações
de ttl, data hora, etc. Se o pacote precisar passar por roteadores, cada um deles diminuirá o valor
do ttl em um, até chegar na interface que receber o ttl com valor 1. Ele irá enviar uma mensagem
através do protocolo ICMP informando que o alvo está inalcançável.
ARP
O Address Resolution Protocol (protocolo de resolução de endereço), mais conhecido apenas pelo seu acrônimo ARP, é o conjunto de instruções residente à camada de enlace da pilha
TCP/IP que faz a resolução de IPs e endereços físicos (MACs), mantendo uma tabela com as associações utilizadas. Como já vimos, o que trafega no meio físico da rede são os quadros, ou frames. Estas unidades de dados são pacotes, criados pelo protocolo IP, fragmentados e com cabeçalhos contendo o endereço físico de suas origens e destinos. Só que os computadores não têm
como saber qual é o endereço físico dos destinos sem ser através de um questionamento a toda
rede. Eles fazem a pergunta através de um broadcast.
–
Quem responde por este IP? - pergunta a origem.
–
Sei lá - responde o computador A - Muito menos eu - responde o computador B.
–
Ô, seus loucos, sou eu o responsável por essa treta aí! - apresenta-se o computador C - e
meu endereço físico é este aqui: 01:22:15:8e:f1:16 .
O computador A, irritado, resolve se impôr e evitar futuros incômodos:
–
Ó, velho. Vê se agora para de perguntar quem é o C porque tenho muita coisa para fazer
para ficar dando atenção desnecessária à você!
Desde então criou-se o ARP. Ele é uma tabela contendo todos os endereços físicos que res-
pondem por IPs utilizados recentemente, justamente para que após a primeira pergunta, a origem
não tenha que se preocupar novamente em pesquisar o endereço físico de seu destino e para que
a rede seja descongestionada de broadcast desnecessários.
152
O comando que manipula a tabela ARP recebe o mesmo nome do protocolo: arp. Com ele é
possível adicionar ou remover entradas à tabela, ou simplesmente visualizá-la.
Ao digitar apenas “arp” e pressionarmos <Enter>, a tabela com as associações é mostrada.
# arp Address HWtype HWaddress Flags Mask ce 10.15.16.1 ether 00:0f:23:c0:5d:ff C
10.15.16.6 ether 00:00:5e:00:01:16 C
10.15.16.2 ether 00:50:da:1f:95:4d C
10.15.18.6 ether 00:11:d8:f7:57:62 C
Ifa
eth0 eth0 eth0 eth0
A primeira coluna contém os endereços IPs de interfaces às quais o seu computador se conectou recentemente. A segunda tem o protocolo utilizado na camada física (quase sempre
será ether, de ethernet). A terceira mostra qual é o endereço físico da interface. A quarta coluna
possui algumas flags (caracteres denotativas) que informam:
C - Completa (que a associação está completa);
M - Permanente (que a associação é permanente).
A
ssociação permanente quer dizer até a reinicialização do computador ou até a reini cialização das interfaces de rede através do ifdown e ifup (executa os scripts do
ifup.d).
Para apagar uma entrada da lista, usa-se o parâmetro -d. Veja abaixo:
# arp n Address HWtype HWaddress ce 10.15.17.109 ether
00:1c:25:4a:f3:0a
Flags Mask
Ifa
C br0 # arp d 10.15.17.109 # arp n Address HWtype HWaddress Flags Mask
ce 10.15.17.109
(incompleto) Ifa
br0 V
eja que a flag C sumiu. Isso porque o kernel não sabe mais qual endereço responde
por 10.15.17.109.
Para adicionar ou alterar uma entrada, precisaremos apenas utilizar o parâmetro “-s” junto
do IP e do endereço físico. A sintaxe é a seguinte:
arp -s <IP> <MAC(com dois pontos separando os octetos)>
# arp s 10.15.17.109 00:1c:25:4a:f3:0a 153
# arp n Address HWtype 10.15.17.109
ether
HWaddress
Flags Mask Iface 00:1c:25:4a:f3:0a CM br0 Existem alguns parâmetros importantes a serem vistos. Vejamos quais:
Parâmetro
Descrição
-n (numérico)
Mostra os IPs em vez de nomes.
-H
Permite especificar outros protocolos da camada de enlace. O padrão é o
ether de ethernet. Outras opções são:
-i (interface)
Permite que o administrador especifique a qual interface irá criar a
associação. Se um computador possuir duas interfaces eth (eth0 e eth1), e
for associado a eth0 um MAC f de um IP a, quando a eth1 quiser saber
qual endereço físico responde ao IP a, ele terá que fazer um broadcast
para a rede e o computador responsável deverá enviar novamente seu
MAC f.
DIG
O comando dig é o acrônimo da frase que sintetiza sua função, que em inglês é Domain Information Groper (pesquisa às escuras de informações de um domínio). Exatamente! A função do
dig é procurar meio que às escuras, ou seja, sem certeza de que receberá resposta, em uma lista
pública (algo como uma lista telefônica) informações a respeito de um nome ou endereço de host,
domínio ou então as configurações da própria lista pública. Esta lista nada mais é do que um DNS
(um servidor do sistema de domínios de nomes). Sempre desejaremos saber o que um servidor
de nomes sabe a respeito de algum dos objetos citados acima (host, domínio, servidor), utilizamos
este comando que imergirá rede (local ou internet) adentro e trará uma resposta. O dig precisa,
então, destes campos mais o tipo de pesquisa a ser realizada para lhe entregar um resultado útil.
Iremos abordar o assunto DNS no módulo avançado deste curso, por isso, bastar-nos-á, por enquanto, saber que o dig irá permitir que consigamos as seguintes informações:
● Um IP a partir de um nome;
● Um nome a partir de um IP.
A sintaxe deste comando é a seguinte:
dig @servidor-de-nome tipo-de-pesquisa objeto-a-ser-pesquisado
Servidor-de-nome
Pode ou não ser especificado o nome ou endereço do servidor a ser indagado sobre um objeto. A especificação pode ser feita através de um número IP versão 4 (denotado por octetos separados por pontos) ou então um número IP versão 6 (denotado por números hexadecimais separa154
dos por vírgulas). Caso o servidor não seja especificado, o aplicativo dig irá realizar a pesquisa no
servidor definido no arquivo /etc/resolv.conf.
Tipo de pesquisa
Indica o que se pretende indagar ao servidor, qual é o nome a partir de um endereço ou qual
é o endereço a partir de um nome? O padrão é se ter um endereço (Address) a partir de um
nome, que, no caso, é definido utilizando-se a letra A ou omitindo esta informação. Para o inverso,
utilizamos o parâmetro “-x”.
Objeto a ser pesquisado
Nome, endereço IPv4, IPv6, ou servidor. Neste curso basta que você saiba que terá que indicar o que será resolvido: ou um IP passado para se retornar um nome ou um nome passado
para se retornar um endereço.
Exemplos de saídas
No nosso exemplo, iremos indagar ao nosso DNS padrão qual é o endereço da máquina
que responde pelo endereço www.google.com.br. O comando para realizar a consulta é fácil, porém a saída pode parecer um pouco complicada. Veja abaixo uma explicação acerca de cada uma
das partes (as partes estão identificadas com números e a explicação está após a saída):
# dig www.google.com.br ; <<>> DiG 9.5.1P3 <<>> www.google.com.br ( 1 )
;; global options: printcmd ;; Got answer: ;; >>HEADER<< opcode: QUERY, status: NOERROR, id: 52760 ;; flags: qr rd ra; QUERY: 1, ANSWER: 6, AUTHORITY: 6, ADDITIONAL: 6 ;; QUESTION SECTION: ( 2 )
;www.google.com.br. IN A ;; ANSWER SECTION: ( 3 )
www.google.com.br. 92370 IN CNAME www.google.com. www.google.com. 262286 IN CNAME www.l.google.com. www.l.google.com. 61 IN A 64.233.163.99 www.l.google.com. 61 IN A 64.233.163.103 www.l.google.com. 61 IN A 64.233.163.104 www.l.google.com. 61 IN A 64.233.163.147 ;; AUTHORITY SECTION: ( 4 )
l.google.com. 2983 IN NS a.l.google.com. l.google.com. 2983 IN NS g.l.google.com. l.google.com. 2983 IN NS e.l.google.com. 155
l.google.com. 2983 IN NS b.l.google.com. l.google.com. 2983 IN NS d.l.google.com. l.google.com. 2983 IN NS f.l.google.com. ;; ADDITIONAL SECTION: ( 5 )
g.l.google.com. 6218 IN A 74.125.95.9 d.l.google.com. 6159 IN A 74.125.77.9 b.l.google.com. 6035 IN A 74.125.45.9 e.l.google.com. 6218 IN A 209.85.137.9 a.l.google.com. 6035 IN A 74.125.53.9 f.l.google.com. 6035 IN A 72.14.203.9 ;; Query time: 2 msec ( 6 )
;; SERVER: 10.15.16.6#53(10.15.16.6) ;; WHEN: Mon Sep 21 10:20:27 2009 ;; MSG SIZE rcvd: 339 1. Na primeira parte temos apenas alguns informações básicas sobre o comando e o tipo
de pesquisa. O número 9.5.1-P3 indica a versão do DIG. Em global options é indicado
a forma como a saída se dará. O padrão é a impressão na tela. Existe a possibilidade
de se alterar esta saída, mas devido a desnecessidade desta alteração, cabe a você
consultar o menu do comando caso deseje alterar esta opção;
2. QUESTION SECTION: indica qual foi a indagação realizada. No nosso exemplo, estamos indagando qual é o endereço IP do nome www.google.com.br. O IN indica que o
endereço pertence a Internet;
3. ANSWER SECTION: indica quais foram os resultados de endereços que respondem
pelo nome. Perceba que vários endereços apareceram. Isso quer dizer que, para um
mesmo nome, vários servidores respondem para evitar que haja um congestionamento
em apenas um. Eles são redundantes, o que quer dizer que quando um é atualizado,
todos são. Caso um deles venha a sair do ar, existem outros que continuarão realizando o trabalho de servir serviços do google. O CNAME é um apelido (vem de Change
Name) e indica que o endereço que está à esquerda é um apelido do que está à direita. Podemos concluir que existem 4 endereços que respondem pelo nome pesquisado,
mas isso não acontece diretamente. Quando digitamos www.google.com.br, é verificado que ele é um apelido de www.google.com., e abaixo vemos que www.google.com. é
um apelido de www.l.google.com., que, daí sim, é o nome oficial do google, cujo servidores são listados (todo os que começam com 64);
4. AUTHORITY SECTION: Neste campo temos os domínios responsáveis pelo nome
principal (www.l.google.com.br). Existem vários DNS por quais a pesquisa pode ser realizada. Perceba que nós temos as flags IN e NS. O IN indica que a consulta foi feita
156
na Internet, e o NS indica qual é o no nome do servidor (Name Server) que é responsável pela conversão do nome da esquerda em um endereço;
5. ADDITIONAL SECTION: Campo adicional que apenas tem função de informar ao administrador qual é o endereço dos servidores com autoridade sobre a resolução do
nome principal;
6. QUERY TIME: Tempo de pesquisa informado em milissegundos (10 -3 s); SERVER: Servidor e porta utilizada para o início da pesquisa; WHEN: Data e hora da consulta. MSG
SIZE: tamanho da mensagem recebida.
MII-TOOL
A maioria das redes utiliza o protocolo Ethernet para transferência de dados pelo meio físico.
As redes Ethernet permitem que possam ser enviados ou recebidos as seguintes quantidades de
informação a cada segundo:
Velocidade da porta
Descrição
10baseT-HD
10 megabit half duplex
10baseT-FD
10 megabit full duplex
100baseTx-HD
100 megabit half duplex
100baseTx-FD
100 megabit full duplex
Tabela retirada do site http://linux-ip.net/html/tools-mii-tool.html
Vamos converter as unidades para nos situarmos no nosso mundo:
1 megabit (Mb) é igual a 1 MILHÃO de 1 BIT (b) = 1 MILHÃO DE BITS (1.000.000 bits)
1 BYTE (B) é igual a 8 BITS (b), então 1 Mb = 125kB (quilobytes)
Caso 1: 100 megabit = 100 vezes 1 Mb = 100 vezes 125kB = 12,5MB
Caso 2: 10 gigabit = 10 vezes 100 vezes 1Mb = 1.000 vezes 125kB = 125MB
No caso 1, temos que uma placa 100base Tx pode enviar ou receber 12,5MB a cada segundo. Um DVD completo de 4GB levaria 5 minutos e 20 segundos para ser enviado ou recebido
pela rede.
No caso 2, temos que uma placa 10gigabit que pode enviar ou receber 125MB a cada segundo. O mesmo DVD do exemplo acima seria enviado ou recebido pela rede em 32 segundos.
Ainda existe a possibilidade de se ter uma transmissão e uma recepção de um quadro ao
mesmo tempo durante um ciclo. No caso 1, teríamos então 200Mb por ciclo (100Mb para envio, e
100Mb para recebimento). O half (metade) e full (completo) duplex indicam se existe esta trans-
157
missão e recepção simultâneas de quadros. Uma placa de 100base Tx-HD (o HD é de Half Duplex) envia ou recebe dados numa ordem de 100Mb por segundo. Isto resulta em no máximo
100Mb por segundo trafegados. Já as placas 100 base Tx-FD transmitem e recebem quadros simultaneamente numa ordem de 100Mb por segundo cada uma das tarefas. Isto resulta em uma
taxa de transmissão máxima entre as interfaces de 200Mb por segundo.
Negociação
Toda vez que uma interface cria um link (uma ligação) entre ela e outra interface 24, desde
que tenha este recurso disponível (as placas mais modernas possuem), executa o processo de
negociação para estabelecer o melhor modo de transmissão possível. Esta negociação é automática e realizada pelos protocolos da camada de enlace. As interfaces definem a opção mais rápida
de comunicação. Imagine um computador tendo como melhor opção publicada o modo 10base
Tx-FD tentando comunicar-se com um computador com interface que possui como melhor opção
publicada o modo 100base Tx-FD. Será verificado que a melhor opção, dentre as possibilidades, é
a primeira, e será realizada a comunicação entre as duas interfaces com o ele. Isto só será possível se o meio permitir, existindo cabos próprios para HD (cabo de par trançado, que separa o meio
de envio e de recebimento). Se existirem no caminho entre os computadores cabos coaxiais ou
então hubs, automaticamente não será possível ser realizada a conexão por FULL DUPLEX, já
que estas arquiteturas propiciam um meio de transmissão único. Nestes meios, se quadros distintos forem enviados ao mesmo tempo, eles irão colidir um no outro e haverá perda de dados. Neste caso, mesmo com interfaces 100base TxFD, 1000baseTxFD ou até mesmo 10gigabit, a conexão será feita através do melhor modo HD (um ciclo para enviar e outro para receber).
Para visualizar tais informações, o usuário só precisa executar como superusuário ou com
auxílio do sudo o comando mii-tool:
$ sudo miitool eth0: negotiated 100baseTxFD, link ok eth1: no link
No exemplo acima, podemos verificar que existem duas interfaces de rede conectadas ao
meu sistema: eth0 e eth1. A primeira interface negociou com o switch a qual ela está conectada o
modo 100baseTx-FD. Ou seja, ele transmitirá, sempre que possível, com a velocidade de 100 megabits por segundo e poderá transmitir e receber quadros simultaneamente (FD - Full Duplex), ou
seja, terá uma taxa de transmissão máxima entre as interfaces de 200Mbps (o ps quer dizer per
second - por segundo). Se o administrador desejar, ele pode alterar este valor utilizando o mii-tool.
24 pode ser um outro computador através de uma topologia de barramento ou anel, ou então a um hub, switch ou
roteador através de uma topologia estrela
158
O
bserve que no exemplo acima, apesar da taxa máxima de transmissão ser de
200Mbps, não é possível se fazer download ou upload utilizando esta taxa. Só será
possível enviar a 100Mbps e ao mesmo tempo receber a 100Mbps. É como se tivéssemos em uma rodovia pós feriado. A mão que volta da praia fica congestionada e a que
vai completamente vazia.
E por que se pode conectar dois computadores, um com interface 10FD, o outro com 100FD
utilizando a opção 10FD e não com 100FD? Por que normalmente as interfaces que têm tecnologia mais avançada abrangem as tecnologias mais simples também. Utilizando o parâmetro “-v”
podemos verificar mais informações a respeito das interfaces, entre elas quais são as modos (tecnologias) disponíveis:
# miitool v eth0: negotiated 100baseTxFD, link ok //O negociado com o meio
product info: vendor 00:00:00, model 0 rev 0 basic mode: autonegotiation enabled //Autonegociação habi
litada
basic status: autonegotiation complete, link ok //Negociação completa
capabilities: 100baseTxFD 100baseTxHD 10baseTFD 10baseTHD advertising: 100baseTxFD 100baseTxHD 10baseTFD 10baseTHD link partner: 100baseTxFD 100baseTxHD 10baseTFD 10baseTHD E o quê que são estes capabilities, advertising e link partner? Isso aí é fácil. Em capabilities são apresentados todos os modos que a placa tem condição de trabalhar. O advertising mostra quais são os modos que a sua placa dirá às outras interfaces que ela trabalha. Se o administrador tiver interesse, ele pode forçar um tipo de conexão indicando apenas um modo disponível.
E para finalizar, o link partner indica quais são os modos que a interface a qual a sua está conectada trabalha. Se a sua interface tiver o modo 1000base Tx-FD, mas estiver conectada em um
switch que só tem suporte ao modo 10base Tx-HD, a conexão será estabelecida com este último
modo. Para verificar isto, basta utilizar, então, este comando com o parâmetro “-v” e verificar os
modos do link parter (parceiro de comunicação).
Alterar os modos disponíveis
Toda vez que existe uma conexão física entre duas interfaces, os protocolos da camada de
enlace irão negociar qual é o melhor modo de transmissão. Para isso, é preciso que cada uma
das interfaces digam quais são os modos os quais possuem suporte. Este “dizer” é um evento
chamado publicar. O que é publicado não necessariamente é o que a interface realmente tem suporte. O administrador pode definir apenas alguns dos modos que a interface possui. Veja como
definir modos específicos.
# miitool advertise 10baseTHD,10baseTFD
159
restarting autonegotiation...
#
Agora somente os três modos serão publicados. Os outros modos não serão utilizados. Para
separar os modos é necessário separá-los com uma vírgula. Não se preocupe com a ordem.
S
e o administrador quiser ou verificar as informações de negociação de uma interface
do seus sistema específica, basta indicar qual é a interface a ser alterada: # mii-tool
eth0 --advertise 10baseT-HD,100baseTx-HD
Mensagens de erro
Abaixo temos algumas mensagens de erro que podem ser apresentadas pelo mii-tool:
SIOCGMIIPHY on ’eth?’ failed: Invalid argument
O administrador ou executa o comando mii-tool sozinho (aparecendo todas as interfaces disponíveis) ou define uma interface de rede. Se a interface definida estiver desativada (desassociada da camada inter-rede), então o comando retornará o erro mostrado. Isso nos mostra
que só podemos verificar as informações de autonegociação em interfaces ativas.
SIOCGMIIPHY on ’eth?’ failed: Operation not permitted
O comando foi executado por um usuário normal. Somente o superusuário pode
executar o miit-tool.
SIOCGMIIPHY on ’eth?’ failed: No such device
Se o comando for executado informando-se a interface, mas esta não existir, este
comando será mostrado.
SIOCGMIIPHY on ’eth?’ failed: Operation not supported
Indica que ou a sua interface ou a interface a qual ela está tentando se conectar
não respondem aos pacotes que permitem que o mii-tool verifique estas informações.
NETSTAT
Este é um comando muito versátil de consulta de informações de rede. Não se consegue alterar nada, porém pode-se visualizar muita coisa importante para um bom gerenciamento de um
computador. Ele tem uma função padrão, que é verificar as conexões feitas nas portas UDP e
TCP, porém permite que o administrador consiga realizar vários outros tipos de consultas. Veja o
que pode ser visualizado com ele:
160

As conexões feitas pelas portas UDP e TCP;

Tabela de roteamento;

Estatísticas de tráfego das interfaces;

Conexões mascaradas (criadas por NAT);
# netstat
Conexões Internet Ativas (servidores e estabelecidas) Proto RecvQ SendQ Endereço Local Endereço Remoto Estado Acima temos um exemplo das saídas do netstat caso seja evocado na sua forma padrão.
Ele irá mostrar todas as conexões de estabelecidas nas portas TCP, UDP e soquetes, nesta ordem. A saída mostrada acima é referente à conexões TCP e UDP. Se você estiver fazendo um ssh
em outro computador, aparecerá que a porta 22 (se o ssh estiver utilizando a porta padrão) está
sendo usado por este serviço.
Cada uma das colunas traz uma informação diferente das conexões estabelecidas pelo seu
computador.
Primeira coluna (Protocolo utilizado)
Informa qual é o protocolo utilizado para fazer a identificação do serviço da camada de aplicação. Os protocolos são UDP, TCP e UNIX.
O
protocolo UNIX não faz parte da pilha TCP/IP. Ele é um protocolo próprio do kernel
linux e tem função de disponibilizar um meio de comunicação entre processos do
sistema, ou seja, indica que a conexão é local e feita por soquetes.
que quem está tratando de identificar a quais processos os segmentos
tcp6deindica
dados pertencem é o protocolo TCP, porém, na camada inter-redes, o res ponsável por realmente criar o pacote com informações de roteamento é o IPv6.
Segunda coluna (Fila de dados a serem recebidos)
Um quadro de dados chega à camada de enlace, que o joga para a camada inter-redes, que
junto vários quadros e e cria um pacote que é jogado para a camada de transporte, local este que
o protocolo pertinente irá indicar qual serviço deve buscar as informações. Se for um protocolo
TCP ou UDP, o serviço conectado à porta que recebeu dados deve ir buscá-los. Caso não faça
isso, aparecerá nesta coluna o total de bytes que estão esperando pelo pai.
Terceira coluna (Fila de dados a serem enviados)
Sempre que dados estão esperando para serem enviados na camada de transporte (esperando, por exemplo, que o buffer de dados do destinatário seja liberado - controle de fluxo do
TCP), será mostrado o total de bytes na fila.
161
T
anto nesta quanto na segunda coluna, o ideal é que o número de bytes tenda sempre a zero. Se isto não acontecer, pode estar havendo algum problema na mídia de
comunicação, na interface de destino, ou nos aplicativos instalados no seu computador,
fazendo com que as informações a serem transmitidas fiquem sempre paradas.
Quarta coluna (Endereço local)
O netstat, nesta primeira parte (TCP e UDP) sempre mostrará a conexão feita por um par de
interfaces. Estas conexões, logicamente, são feitas entre o sistema em que o administrador está e
uma interface remota. Nesta coluna é mostrado o endereço da interface local.
Quinta coluna (Endereço remoto)
Nesta coluna é mostrado o endereço do computador remoto do par da conexão. Se desejado, pressionando o parâmetro -p junto ao comando, é possível verificar quais são as portas ou
serviços que estão sendo utilizadas na conexão.
O
s nomes de serviços são resolvidos pelo arquivo /etc/services, que atribui um nome
às portas bem conhecidas. Se apenas um número aparecer, esta porta não está especificada no arquivo citado. Para forçar a saída de número em vez de nomes, usa-se o
parâmetro -n junto ao comando.
Sexta coluna (Estado)
Mostra o estado da conexão. Se existir uma conexão, será mostrado o valor “ESTABELECIDA”. Utilizando o parâmetro “-a” junto ao comando, todas as portas abertas serão mostradas. As
que estão com conexões estabelecidas, aparecem como dito antes. Se a porta estiver somente
escutando a rede, ou seja, livre e pronta a receber conexões, o valor desta coluna será “OUÇA”.
Existe a possibilidade de se ter mais dois valores nesta coluna: ESPERANDO SINCRONIA e ESPERANDO PARA ENVIAR. Em ambos os casos a fila de dados será diferente de zero, já que no
primeiro caso a porta do computador em que o administrador estiver estará esperando que os
aplicativos busquem informações, enquanto no segundo caso, a porta contém dados a espera
para enviar dados a alguma interface remota, que provavelmente está indisponível ou com buffer
de dados recheado e transbordando.
Praticando
Conecte-se ao seu próprio computador por ssh (utilize um usuário comum):
$ ssh localhost
162
S
e a conexão não se der, você já possui conhecimento suficiente para fazê-lo funcionar. Verifique se sua interface esta ativada, se a porta do ssh está aberta e se o ar quivo de configuração sshd_config está configurado de forma a permitir que o seu usuário se conecte.
Agora execute o comando netstat como superusuário e use um filtro para trazer apenas as
linhas que contiverem o serviço ssh. Abaixo utilizei os parâmetros a para
# netstat ap |grep ssh tcp 0 0 *:ssh
*:* OUÇA
23009/sshd tcp 0 0 localhost:53439 localhost:ssh ESTABELECIDA 24217/ssh tcp 0 0 localhost:ssh localhost:53439 ESTABELECIDA 24218/sshd:fcamar tcp6 0 0 [::]:ssh [::]:*
OUÇA
23009/sshd Veja que o ssh, serviço da camada de aplicação, utiliza o protocolo TCP da camada de
transporte para realizar a identificação de seus dados e atar o par de interfaces em uma conexão
confiável. Das quatro linhas, a primeira e a última estão apenas em estado de escuta. A primeira,
caso requisitada, utilizará o protocolo IPv4, enquanto a segunda irá realizar conexão com IPv6. As
duas do miolo representam uma conexão entre dois pontos com confiabilidade. A linha abaixo:
tcp 0 0 localhost:53439 localhost:ssh ESTABELECIDA 24217/ssh
esta linha mostra que o computador cliente que se conecta ao computador servidor está utilizando uma porta aleatória, que no exemplo é 53439. Todos os dados enviados ao computador de
destino vão para a porta padrão do ssh do servidor (22).
tcp 0 0 localhost:ssh localhost:53439 ESTABELECIDA 24218/sshd: fcamar A outra linha indica o servidor, já que temos uma conexão do localhost no localhost. Normalmente quando você estiver se conectando a algum computador remoto, a situação será como na
segunda linha, quando alguém se conectar ao seu computador, a situação será como na terceira
linha. Nela, o computador local utilizará a porta padrão do ssh (22) para receber dados
exibe o estado da porta TCP e UDP ativas
As portas permitem distinguir a quais aplicativos cada pacote pertence.
MTU (Maxime transfer unit - Unidade de transferência máxima) define qual é o tamanho máximo de um frame.
GERENCIADOR WICD
Acrônimo de Wired and Wireless Network Connection Daemon (gerenciador de conexões a
163
redes cabeadas e sem fio), este gerenciador vem tentar facilitar a vida do administrador unificando
todas informações da rede e das interfaces de um sistema num único programa gráfico. É interessante para configurações rápidas ou visualizações de informações de uma forma mais amigável,
porém não substitui os comandos de rede vistos anteriormente, já que um administrador de redes
deverá frequentemente trabalhar em sistemas servidores, que quase nunca possuem suporte gráfico. Abaixo temos um screenshot do wicd:
Figura 11: Janela do Wicd
O Wicd tentará sempre conectar a todas as redes que estiverem disponíveis e que o administrador indicar que ele deverá tentar. O Wicd, por si só, dará preferência para redes cabeadas,
que são mais confiáveis e estáveis. Se não existir nenhuma rede deste tipo, mas tiver uma rede
wirelesss, ele procurará aquela que tiver o melhor sinal e tentará se conectar. É obvio que o administrador pode configurar uma rede qualquer como padrão, mas este é o comportamento do wicd
nos casos em que a rede padrão não esteja disponível.
Estrutura do Wicd
Wicd é composto de duas partes principais: o daemon (gerenciador residente na memória),
que roda com privilégios de superusuário; e a interface do usuário, que roda com privilégios normais do usuário conectado à interface gráfica. Ambos rodam em processos diferentes e se comunicam através do D-Bus.
D
bus é uma interface utilizada como meio de comunicação entre aplicativos desktop.
O D indica Desktop e o BUS indica um meio de transmissão. Um bom exemplo é o
plugin do Rhytmbox que é instalado no Pidgin. Este plugin usa o Dbus para colocar em
comunicação ambas aplicações, permitindo que a música que estiver tocando seja mos-
164
trada num campo “O que estou ouvindo” no Pidgin.
O daemon é responsável por criar e configurar conexões a redes, ler e escrever arquivos de
configuração e de log, e monitorar os status das conexões. O trabalho destinado ao daemon é divido entre dois processos: (1) wicd-daemon.py e (2) monitor.py.
E
xecute o ps aux utilizando os filtros adequados para confirmar que os dois estão rodando em seu computador.
Todo monitoramento dos status das conexões e a tarefa de reconexão automática a redes é
realizada pelo monitor.py. Todo o resto do trabalho é realizado pelo wicd-daemon.py.
A interface gráfica já faz parte do wicd-client, que é constituído por um ícone no painel, uma
janela principal de configuração e suas abas funcionais. Ele não passa de uma interface “daemonusuário”, não sendo fundamental para o funcionamento da rede. Periodicamente o wicd-client pergunta ao processo correspondente como andam as coisas para que ele possa atualizar as informações em sua janela. Esta comunicação é feita através do Dbus. Outra forma dele ser atualizado é por sinais enviados pelo Dbus diretamente a ele. Normalmente informações já estabelecidas
são perguntadas pelo cliente, enquanto erros e eventos novos são avisados pelos daemon. Quando configurações são realizadas pelo assistente cliente, as novas informações são enviadas aos
dameon e estes aplicam as alterações e realizam todos os procedimentos necessários, como reinicialização dos serviços envolvidos e alteração dos arquivos de configuração, para que as mudanças perdurem.
Funcionamento e configurações
O assistente principal será aberto, e nele todas as redes disponíveis aparecerão. Iremos ver
tarefas úteis que podem ser realizadas por ele. Cada interface que o usuário tiver em seu computador terá um perfil próprio com suas configurações. Pode-se configurar um dos perfis como Padrão. Isto fará com que a conexão do seu computador utilize-a prioritariamente.
Desconectar-se de uma rede específica: selecione a rede a qual deseja se desconectar e
clique sobre o botão <Desconectar>;
Desconectar-se de todas as redes: clique sobre o botão na aba superior <Discconnect
All>;
Conectar a uma rede específica: selecione a rede a qual deseja se conectar e clique sobre
o botão <Conectar>;
Criar um novo perfil: clique sobre o botão <Adicionar> e defina o nome ao perfil;
Configurar parâmetros essenciais de uma rede: selecione o perfil que deseja configurar e
165
clique sobre o botão <Propriedades>;
Excluir um perfil existente: selecione o perfil a ser excluído utilizando o menu suspenso e
depois clique sobre o botão <Excluir>.
PREFERÊNCIAS GLOBAIS
Clicando sobre o botão <Preferences> a janela de configuração é aberta e é possível realizar configurações que serão aplicadas em todas as conexões e perfis existentes no seu computador. Vejamos o que é mais interessante:
Always switch to a wired connection when available: se existirem pelo menos duas conexões, uma wired (cabeada) e outra wireless (sem cabo), será dado preferência à rede cabeada,
que normalmente é mais estável;
User global DNS servers: permite que os DNS sejam definidos e utilizados por todas as
conexões do seu computador;
Automatic Reconnection: reconecta automaticamente a uma rede que caiu quando ela estiver UP novamente;
Notifications: com ele, mensagens na área de notificação informarão as mudanças de status das redes disponíveis.
166
REFERÊNCIAS BIBLIOGRÁFICAS
Mota Filho, João Eriberto; Descobrindo o Linux. São Paulo:NOVATEC, 2006
W. Murhammer, Martin; at all. TCP/IP Tutorial e Técnico. São Paulo: MAKRON Books, 2000.
Nemeth, Evi. Manual do Administrador do Sistema UNIX. Rio Grande do Sul: ARTMED®
EDITORA S.A., 2002.
S. Tanenbaum, Andrew. Computer Networks. New Jersey: PRENTICE HALL, 1988.
http://www.faqs.org/docs/linux_network/x-087-2-iface.ifconfig.html
http://linux-ip.net
http://www.jonny.eng.br
http://www.vivaolinux.com.br/artigo/Entendendo-o-processo-de-boot/?pagina=1
http://debian-br.sourceforge.net/docs/sgml/pratico/online/ch-init.html
http://pt.wikipedia.org/wiki/Log_de_dados
http://under-linux.org/b160-usando-syslog-em-shell-script-com-logger
http://www.cyberciti.biz/tips/howto-linux-unix-write-to-syslog.html
http://focalinux.cipsga.org.br/guia/avancado/ch-log.html
http://www.debian.org/doc/manuals/securing-debian-howto/ch4.pt-br.html
http://www.debian-administration.org/articles/56
http://www.vivaolinux.com.br/artigo/Usando-cron-e-crontab-para-agendar-tarefas/?pagina=2
http://www.debian.org/releases/stable/s390/ch08s03.html.pt_BR
http://sergioaraujo.pbwiki.com/Guia+de+comandos+Linux
http://www.basicallytech.com/blog/index.php?/archives/23-command-line-calculations-usingbc.html
http://www.vivaolinux.com.br/artigo/BC-A-sua-calculadora-programavel-no-Linux?pagina=1
http://www.guiadohardware.net/dicas/fazendo-backup-recuperando-mbr-tabela-particoes.html
http://www.vivaolinux.com.br/artigo/Checando-seu-sistema-de-arquivos-com-fsck/
http://www.uniriotec.br/~morganna/guia/fsck.html
http://pt.wikipedia.org/wiki/Fsck
167
http://linuxcommand.org/man_pages/fsck8.html
http://www.htmlstaff.org/guiafoca/intermediario/ch-cmdc.htm
http://www.uniriotec.br/~morganna/guia/last.html
http://pt.wikibooks.org/wiki/Guia_foca_Linux/Iniciante%2BIntermedi
%C3%A1rio/Comandos_para_manipula%C3%A7%C3%A3o_de_contas/last
http://www.uniriotec.br/~morganna/guia/lastlog.html
http://pt.wikibooks.org/wiki/Guia_foca_Linux/Iniciante%2BIntermedi
%C3%A1rio/Comandos_para_manipula%C3%A7%C3%A3o_de_contas/lastlog
http://www.vivaolinux.com.br/dica/O-comando-lsof/
http://danielmiessler.com/study/lsof/
http://br-net.org/post/lsof-o-canivete-suico
http://www.akadia.com/services/lsof_intro.html
http://tecinfofsj.forums-free.com/comando-lspci-t7.html
http://www.devin.com.br/comandos-informacoes-do-sistema/
http://www.dicas-l.com.br/dicas-l/20060531.php
http://www.ime.usp.br/~ueda/ldoc/rb.html
http://www.uniriotec.br/~morganna/guia/nice.html
http://www.infowester.com/linprocessos.php
http://www.juliobattisti.com.br/artigos/windows/tcpip_p35.asp
http://paginas.fe.up.pt/~mgi97018/nslookup.html
http://paginas.fe.up.pt/~mgi97018/nslookup.html
http://www.ime.usp.br/~ueda/ldoc/rb.html
http://www.uniriotec.br/~morganna/guia/nohup.html
168

Apostila Debian Intermediário - Desktop Parana

Transcrição

Documentos relacionados

Untitled - CÂMARA MUNICIPAL DE NOVA LONDRINA

Abrir Arquivo - CÂMARA MUNICIPAL DE NOVA LONDRINA

Untitled - CÂMARA MUNICIPAL DE NOVA LONDRINA

Imprimir dados do pacote - Parktur

RAFAEL CUNHA DE ALMEIDA

Assunto: : Instalação, Atualização e Configuração

Topologia do SEI-UnB

Feliz Debian novo!

(Doc de impressora redirecionado da \341rea de trabalho remota)

ATENÇÃO!