% JLdL 17Jun02.
%	Copyright (C) 2000-2002 by Jorge L. deLyra.
% Mail: <delyra@latt.if.usp.br>. Web: "http://latt.if.usp.br".
% Este documento pode ser copiado e/ou distribuído livremente.
% Ver os termos e condições nos arquivos do sub-diretório web/.
% This document may be copied and/or distributed freely. See the
% _ terms and conditions in the files in the web/ subdirectory.

\documentclass[12pt]{article}
\usepackage[brazil]{babel}\usepackage[latin1]{inputenc}

\title{ {\huge\bf FMA 215} \\ Aula 10: Uso Básico da Rede }

\author{Prof. Jorge L. deLyra}

\date{06 de Junho de 2002}

\begin{document}\maketitle

\section{Alguns Conceitos Relevantes}

 A rede é um sistema de hardware e de software através do qual sistemas
 computacionais diferentes podem se comunicar. O tipo de comunicação que
 se pode efetuar varia, indo desde a simples transferência de uma mensagem
 ou de um arquivo de um sistema para outro a até a integração tão próxima
 de vários sistemas que eles podem passar a funcionar como um só sistema
 do ponto de vista do usuário. Hoje em dia a conexão à rede é parte
 essencial do uso de sistemas de informação, tanto que costumamos
 denominar os sistemas de informática em rede de ``sistemas de informação
 e comunicação''. Em lugares onde existem redes locais rápidas, como em
 empresas e universidades, o uso simultâneo de vários sistemas integrados
 através da rede, de forma completamente transparente para o usuário, é
 rotina.

 A rede Internet funciona através de um sistema de troca de parcelas de
 informação na forma de pacotes, conhecido como comutação de pacotes
 (packet switching). Neste sistema, qualquer quantidade de informação que
 se queira transmitir de um ponto para outro é quebrada em um determinado
 número de pacotes de tamanho mais ou menos fixo. Cada pacote contém
 vários níveis de cabeçalhos (headers) contendo as informações sobre o
 endereço de destino do pacote. Esta informação de destino inclui não só o
 endereço da máquina de destino, mas também endereçamento de conexão
 relativo ao processo (e portanto ao usuário) que deve receber o pacote no
 sistema de destino. Os pacotes são todos enviados pela rede e recebidos
 pelo sistema no endereço de destino, que os lê e re-monta o conteúdo
 completo da informação.

 A rede Internet pode ser compreendida como um sistema de interconexão de
 redes locais, integrando-as em uma única rede de alcance global, é daí
 que vem o seu nome (inter-network). O conceito de rede local, em sua
 forma mais simples, consiste de um conjunto de máquinas interligadas
 fisicamente de forma direta através de um sistema de transporte de
 pacotes de dados, que pode ser feito com fibras óticas ou cabos de
 cobre. Em geral estas máquinas estão próximas umas das outras, em um
 mesmo prédio ou em um conjunto de prédios contíguos, como é o caso do
 Instituto. Dentro desta rede local não é necessário estabelecer rotas de
 tráfego para os pacotes, pois cada máquina da rede pode se conectar
 diretamente a qualquer outra máquina da mesma rede local, sem que o
 tráfego entre as duas tenha de passar por qualquer outra máquina.

 O roteamento do pacote no caminho intermediário entre duas redes locais é
 feito de forma automática pela rede, nem o sistema de origem nem o de
 destino sabem ou precisam saber qual é a rota que vai ser usada. Tudo que
 o sistema de origem precisa saber é para onde enviar um pacote que não
 seja parte de sua rede local. Em geral isto é feito através da definição
 de um ``portal padrão'' (default gateway), que é um sistema da rede local
 para o qual o sistema de origem envia qualquer pacote cujo destinatário
 não seja um sistema na rede local à qual ele está fisicamente ligado.
 Este default gateway é, em geral, um roteador, um sistema computacional
 dedicado ao roteamento de pacotes (router). É ele que tem as ligações
 físicas externas à rede local e também as regras de roteamento para saber
 para onde enviar os pacotes, dependendo do endereço de destino.

 Entretanto, os detalhes do funcionamento da rede, que só mencionamos aqui
 como ilustração, não são importantes do ponto de vista do usuário. Tudo
 que ele precisa saber sobre a rede em si são os nomes e os endereços na
 rede do sistema onde ele está e do sistema com o qual ele quer se
 conectar. Este tipo de combinação nome--endereço tem a forma geral

\begin{center}
 {\tt <hostname>.<network-domain-name>}
\end{center}

\noindent
 onde {\tt <hostname>} é o nome da máquina na rede local à qual ela está
 ligada diretamente e {\tt <network-domain-name>} é o nome da rede local
 em si. Por exemplo, em nosso caso no Instituto de Física o servidor
 central do projeto Sócrates tem o hostname {\tt socrates} e está ligado à
 rede acadêmica do Instituto, que tem como nome de domínio {\tt
 if.usp.br}, de forma que o endereço completo da máquina na Internet é

\begin{center}
 {\tt socrates.if.usp.br}
\end{center}

\noindent
 Note que a situação é diferente com os sistemas da sala Pró-Aluno, pois
 eles estão em uma rede fechada que não é visível diretamente a partir da
 Internet, ou mesmo a partir do resto da rede local do Instituto. De todos
 os sistemas desta rede fechada apenas o servidor {\tt socrates} faz parte
 da rede local do Instituto. Os micro-computadores da sala Pró-Aluno têm
 endereços completos dados, por exemplo, por

\begin{center}
 {\tt pop01.if.usp.br}
\end{center}

\noindent
 Neste caso vemos que {\tt pop01} é o hostname do micro e {\tt if.usp.br}
 é o nome da rede do Instituto. Entretanto, neste caso isto é apenas uma
 forma de registrar que trata-se da sala Pró-Aluno do Instituto, pois em
 uma rede fechada o domínio é pura fantasia, talvez uma conveniência, mas
 não tem nenhuma função estrutural no funcionamento da rede.

 Para examinar um segundo exemplo podemos apelar para um dos servidores
 centrais de nosso vizinho, o Instituto de Matemática e Estatística. Ele
 tem como hostname {\tt mafalda} e está na rede {\tt ime.usp.br}, de forma
 que o endereço completo da máquina na Internet é

\begin{center}
 {\tt mafalda.ime.usp.br}
\end{center}

\noindent
 Como vemos, os servidores {\tt socrates} e {\tt mafalda} estão em redes
 diferentes, duas sub-redes chamadas {\tt if} e {\tt ime}, da rede da
 Universidade de São Paulo, cujo domínio é {\tt usp.br}. Como se vê,
 trata-se de um sistema hierárquico mas, mais uma vez, os detalhes não são
 relevantes para o usuário. O ponto é que, uma vez resolvidos os problemas
 técnicos de rede pelos gerentes dos sistemas, as duas máquinas saberão
 como se comunicar uma com a outra, independentemente dos detalhes de como
 elas estão ligadas fisicamente ou relacionadas logicamente.

 Do ponto de vista da ação direta pelo usuário a comunicação entre as
 máquinas pode ser de um dos seguintes tipos gerais: transferência de
 arquivos; execução remota de comandos não-interativos; estabelecimento de
 sessões interativas remotas; transferência para sistemas remotos de dados
 gráficos através do sistema de janelas X11, que veremos em uma aula
 subsequente. Nas tarefas vamos passar por cada um destes tipos de
 operação de rede. Além disso, a integração de sistemas em rede pode
 incluir outros tipos de comunicação entre eles como, por exemplo, a
 exportação de áreas de disco e de impressoras de um para outro e a
 distribuição através da rede de certos tipos de informação de
 sistema. Também veremos alguns exemplos disto em nossa rede local aqui no
 Instituto, em particular na rede fechada da sala Pró-Aluno.

\section{Tarefas}

 A maior parte destas tarefas deve ser realizada nas máquinas da sala
 Pró-Aluno. Como trata-se de lidar com uma rede, que raramente está
 disponível em casa, esta será a melhor forma de executar as tarefas.
 Também é possível realizá-las em outros sistemas a partir dos quais se
 tenha acesso ao servidor do projeto Sócrates, mas provavelmente será
 menos confortável e conveniente. Quase todas as tarefas podem ser
 realizadas nos terminais de caracteres do console, que é como as
 descrevemos abaixo, mas também é possível realizá-las de dentro do
 sistema X11, usando dois terminais {\tt xterm} em duas janelas separadas.

\begin{enumerate}

 \item Em uma das máquinas da sala Pró-Aluno, vá para o primeiro console,
 digitando {\tt [Ctrl]-[Alt]-[F1]}; faça um login em sua conta e vá para o
 diretório {\tt /temp}\footnote{Se você não estiver fazendo isto em uma
 máquina da sala Pró-Aluno do Instituto, use o diretório {\tt /tmp} em vez
 de {\tt /temp}, em todas as tarefas desta aula.}. Em seguida, vá para o
 segundo console, digitando {\tt [Ctrl]-[Alt]-[F2]}; faça um segundo login
 em sua conta e, em seguida, faça um login remoto a partir desta sessão,
 no servidor {\tt socrates}, executando o comando {\tt telnet
 socrates.if.usp.br} e digitando em seguida, mais uma vez, o seu username
 (caso seja solicitado) e a sua password. Uma vez no servidor, vá para o
 diretório {\tt /tmp}.

 Os dois terminais virtuais {\tt tty1} e {\tt tty2} associados às teclas
 {\tt [F1]} e {\tt [F2]} estão agora rodando duas sessões interativas em
 duas máquinas diferentes. Enquanto a sessão em {\tt tty1} está usando o
 CPU e a memória RAM da máquina local em frente à qual você está
 sentado/a, a sessão em {\tt tty2} está usando o CPU e a memória RAM de
 uma máquina remota, o servidor {\tt socrates}. Na realidade, neste caso o
 processamento está sendo dividido entre as duas máquinas: a máquina local
 está rodando apenas um conjunto de programas que emula um terminal ASCII,
 enquanto qualquer comando ou aplicação que você rode dentro desta sessão
 será executado no servidor. Em cada um dos dois casos você está num
 diretório local da máquina em que está processando, os diretórios {\tt
 /temp} e {\tt /tmp}.

 Em cada uma das duas sessões, execute a pipeline de comandos {\tt ps aux
 | less} para verificar as diferenças no estado de processamento das duas
 máquinas. Execute também os comandos {\tt hostname}, {\tt uname -a}, {\tt
 uptime} e {\tt w} em cada uma das duas sessões.

 \item Na sessão do {\tt socrates}, crie um arquivo na área {\tt /tmp},
 com o seu username no nome para caracterizá-lo como seu, usando o comando

 {\tt dd if=/dev/zero of=<username>.zeros bs=1024 count=100}

\noindent
 O programa {\tt dd} copia blocos de dados de um dispositivo ou arquivo
 para outro, as opções {\tt bs} e {\tt count} determinam o tamanho e o
 número de blocos respectivamente. Isto irá criar um arquivo com o nome
 indicado, contendo 100~Kbytes de zeros binários. Verifique este fato
 usando o comando {\tt ls -l}. Vá agora para a sessão do terminal {\tt
 tty1} e use o comando {\tt ls -l} lá, para verificar que ainda não existe
 um arquivo com este nome no diretório {\tt /temp} na máquina local.

 \item Vamos agora transferir o arquivo {\tt <username>.zeros} de uma
 máquina para a outra através da rede, usando o sistema FTP (File Transfer
 Protocol). O comando {\tt ftp} é um programa geral de transferência de
 arquivos, que pode ser usado entre quaisquer dois sistemas computacionais
 ligados à Internet. Ele implementa o protocolo FTP de transferência de
 arquivos de forma geral, sem usar propriedades específicas deste ou
 daquele sistema operacional.

 Para fazer isto, execute em sua sessão local, no terminal {\tt tty1}, o
 comando {\tt ftp socrates.if.usp.br}. O programa irá estabelecer uma
 ligação de rede com o {\tt socrates} e em seguida solicitar a você
 informação de login no sistema remoto. Observe que, como o seu username é
 o mesmo nos dois sistemas, não será de fato necessário digitar o seu
 username, basta digitar {\tt [Enter]} que o programa usará por default o
 seu username local. Digite em seguida a sua password no sistema remoto
 (que também é a mesma, mas desta vez será necessário digitar). Caso você
 erre a password, aparecerá uma mensagem de que o login falhou, neste caso
 saia do {\tt ftp} digitando {\tt [Ctrl]-D} e inicie o processo de novo.

 \item Uma vez feito com sucesso o login no sistema remoto, você está numa
 sessão FTP naquele sistema. Esta á uma espécie de sessão interativa muito
 limitada, na qual existem apenas alguns poucos comandos disponíveis, o
 suficiente para que você possa transferir arquivos. Basicamente, você
 pode usar os comandos {\tt ls} ou {\tt dir} para listar arquivos, o
 comando {\tt cd} para mudar de diretório e os comandos {\tt get} e {\tt
 put} para pegar e colocar arquivos, respectivamente. Use o comando {\tt
 ls} dentro da sessão FTP para verificar que você está na raiz de sua
 conta no sistema remoto. Em seguida, use {\tt cd /tmp} para ir para o
 diretório {\tt /tmp} do sistema remoto e em seguida o comando {\tt ls}
 mais uma vez. Deve aparecer lá o arquivo {\tt <username>.zeros} que você
 criou.

 Antes de pegar o arquivo, execute o comando {\tt hash} dentro da sessão
 FTP. Este comando fará com que o programa reporte o progresso da
 transferência colocando na tela um símbolo {\tt \#} para cada bloco de
 1024~bytes de dados que forem transferidos. Em seguida, pegue o arquivo
 do sistema remoto usando o comando {\tt get <username>.zeros} e observe o
 que acontece. Verifique a velocidade com que o programa reporta que fez a
 transferência. Baseando-se nisto, dá para você estimar qual é a
 velocidade da rede que interliga as duas máquinas? Em seguida, saia do
 programa {\tt ftp} usando o comando {\tt exit} e use o comando {\tt ls
 -l} em sua sessão local para verificar que o arquivo foi, de fato,
 transferido para o diretório {\tt /temp} da máquina local.

 \item Vamos agora criar um segundo arquivo na máquina local que você está
 usando, para depois transferí-lo para a máquina remota. Para criar um
 arquivo com 100~Kbytes de caracteres {\tt 0} execute no terminal {\tt
 tty1} a sequência de comandos que segue, substituindo o seu username onde
 indicado.

\input{aula-10-verbatim01.tex}

\noindent
 Trata-se aqui de um pequeno exemplo de programação de linha de comando. O
 primeiro comando cria um arquivo vazio contendo o seu username no nome.
 O segundo comando inicializa um contador. O comando {\tt while} executa o
 bloco de comandos que segue, até o comando {\tt end}, enquanto a condição
 indicada for satisfeita. O caracter {\tt @} é o operador aritmético, ele
 indica que nesta linha a variável {\tt ic} está sendo manipulada segundo
 a aritmética dos números inteiros. Verifique o resultado da operação
 usando o comando {\tt ls -l}.

 Entre agora no programa {\tt ftp} da mesma forma como fez antes, uma vez
 dentro dele vá para o diretório {\tt /tmp} do servidor, execute o comando
 {\tt hash} e transfira este arquivo para o servidor usando o comando {\tt
 put <username>.chars}. Em seguida use o comando {\tt ls} dentro do
 programa {\tt ftp} para verificar que o arquivo foi de fato transferido.

 \item Para ter uma idéia de quanta informação pode estar disponível para
 seu uso através do protocolo FTP, use o comando {\tt ftp} para entrar nos
 sistemas {\tt fma.if.usp.br} ou {\tt linorg.usp.br} ou, no caso destes
 não estarem disponíveis, nos sistemas {\tt ftp.br.debian.org}, {\tt
 ftp.debian.org} ou {\tt ftp.kernel.org}. Trata-se de servidores de
 distribuição de free software que disponibilizam serviços de FTP anônimo
 a qualquer usuário da Internet, ou seja, você não precisa ter contas
 naquelas máquinas para poder puxar delas por FTP quaisquer quantidades de
 free software que deseje. Em particular, todas as versões do kernel do
 Linux e toda a distribuição Debian estão disponíveis nos servidores
 mencionados acima, entre muitas outras coisas, para que você possa pegar,
 instalar em casa, etc. Para usar este serviço, execute o comando

 {\tt ftp fma.if.usp.br}

\noindent
 e, quando aparecer o prompt para o username, digite {\tt anonymous} ou
 simplesmente {\tt ftp}. Em seguida, digite o seu endereço de e-mail no
 lugar da password. Pronto, você estará conectado/a ao servidor, use o
 comando {\tt cd} para passear à vontade por lá e o comando {\tt get} para
 pegar o que quiser. Há nestes servidores centenas de GB de free software
 disponível, na maior parte na forma de arquivos comprimidos.

 \item Existe uma outra forma de se copiar arquivos de um sistema para
 outro que é mais característica do sistema Linux. Trata-se do comando
 {\tt rcp}, que só é útil entre dois sistemas Linux ou Unix entre os quais
 existam as estruturas de autorização apropriadas. Como este é o caso
 entre o servidor {\tt socrates} e as máquinas da sala Pró-Aluno, você
 deve ser capaz de usar este comando entre o {\tt socrates} e uma das
 máquinas da sala ou entre duas das máquinas da sala.

 Para verificar o fato de que estas máquinas são todas ``trusted hosts''
 (sistema mutuamente conhecidos e autorizados) uns dos outros, examine em
 cada sistema, usando um paginador ou o seu editor preferido, os arquivos
 {\tt /etc/hosts.equiv} e {\tt /etc/netgroup}, que contêm um grupo de rede
 chamado {\tt rcmaccess} que consiste de uma lista dos hosts autorizados.
 Estas são as autorizações globais destes sistemas, mas você também pode
 definir uma estrutura de autorizações específica para a sua conta. Para
 autorizar este tipo de conexão para a sua conta, crie na raiz dela um
 arquivo de nome {\tt .rhosts}, ou modifique um que já esteja lá,
 colocando nele um conteúdo como o que segue, ou seja, diretamente uma
 lista de hosts que você deseja autorizar para acesso à sua conta.

\input{aula-10-verbatim02.tex}

\noindent
 Observe que é importante incluir o seu username na segunda coluna, bem
 como o nome completo das máquinas. Também é uma boa idéia deixar este
 tipo de arquivo legível apenas por você mesmo.

 \item Tendo estabelecido as necessárias estruturas de autorização, em sua
 sessão do terminal {\tt tty1} tente copiar mais uma vez para o {\tt
 socrates} um dos arquivos que estão na máquina local, executando o
 comando:

 {\tt rcp <file>.zeros socrates.if.usp.br:/tmp/<file>.zeros.2}

\noindent
 Tente também uma alternativa contendo explicitamente o seu username no
 sistema {\tt socrates} como parte do endereço:

 {\tt rcp <file>.chars <username>@socrates:/tmp/<file>.chars.2}

\noindent
 Finalmente, tente uma alternativa com dois arquivos e um diretório:

 {\tt rcp <username>.zeros <username>.chars socrates.if.usp.br:}

\noindent
 Neste caso, descubra onde foram parar os dois arquivos transferidos.

 \item Repita as operações do ítem anterior usando o comando {\tt scp} em
 vez de {\tt rcp}. Trata-se de um comando que faz o mesmo tipo de
 trabalho, mas encripta todo o fluxo de dados enquanto ele trafega pela
 rede, de forma a garantir a inviolabilidade do conteúdo. Este comando é
 parte do sistema {\tt ssh} que veremos logo adiante. Ele usa outras
 formas de autorização, não necessariamente o arquivo {\tt .rhosts}. Ele
 se comporta de forma diferente do {\tt rcp} no caso de não existirem as
 autorizações corretas entre os dois sistemas, em vez de falhar ele pede a
 password do usuário.

 \item O comando {\tt rcp} é parecido com um comando mais geral que nos
 permite executar comandos em uma máquina remota, sendo entretanto um
 pouco mais simples. O comando geral é a {\tt rsh} ou ``remote shell''.
 Assim como a shell nos permite executar comandos no sistema, a shell
 remota nos permite executar comandos em sistemas remotos. As limitações
 de funcionamento, em termos do acesso ao sistema remoto, são as mesmas
 que para o comando {\tt rcp}, ou seja, os dois sistemas envolvidos devem
 se conhecer mutuamente e devem existir entre eles as relações apropriadas
 de autorização. Além disso, há a limitação de que o programa a ser
 executado remotamente não seja um aplicativo do tipo que estabelece uma
 sessão interativa com o usuário. É necessário que ele seja um comando que
 faz alguma coisa e termina. A partir de seu terminal {\tt tty1} descubra
 que usuários estão usando o {\tt socrates} neste momento executando o
 comando

 {\tt rsh socrates.if.usp.br who}

\noindent
 Verifique a informação obtida executando o comando {\tt who} diretamente
 no {\tt socrates}, em seu terminal {\tt tty2}. Tente fazer o mesmo com os
 comandos {\tt df}, {\tt ls} e {\tt uptime}. No caso do {\tt ls}, observe
 bem quais são os arquivos que aparecem. Se necessário, use {\tt ls -al}.

 \item Repita as operações do ítem anterior usando o comando {\tt ssh}, a
 ``secure shell'' ou shell segura, em vez de {\tt rsh}. Trata-se de um
 comando que pode fazer o mesmo tipo de trabalho que o {\tt rsh}, entre
 outras coisas, mas encripta todo o fluxo de dados enquanto ele trafega
 pela rede, de forma a garantir a inviolabilidade do conteúdo. Ele pode
 usar várias outras formas de autorização, que não necessariamente o
 arquivo {\tt .rhosts}. Ele se comporta de forma diferente do {\tt rsh} no
 caso de não existirem as autorizações corretas entre os dois sistemas, em
 vez de falhar ele pede a password do usuário. Esta nova shell remota tem
 também várias outras vantagens. Hoje em dia é esta a shell que usamos
 como default para todas as conexões dentro de nossas redes locais.

 \item Já vimos, logo no início da aula, o uso do comando {\tt telnet}
 para estabelecer uma sessão interativa em um sistema remoto. Assim como é
 o caso do comando {\tt ftp}, trata-se de um comando de caráter bem geral,
 que não usa as especificidades do sistema Linux, nem depende delas. No
 máximo, quando ele é usado entre dois sistemas Linux apropriadamente
 configurados, ocorrem algumas mudanças de comportamento como, por
 exemplo, ele deixar de solicitar o seu username ou entrar em um modo no
 qual todo o tráfego de dados pela rede é encriptado.

 Existe um segundo comando que serve para este tipo de função, o qual é
 mais específico dos sistema Linux ou Unix. Trata-se do comando {\tt
 rlogin}, que permite que façamos um login em um sistema remoto. Entre
 sistemas que se conhecem e entre os quais há as relações apropriadas de
 autorização, de forma semelhante ao que acontece no caso dos comandos
 {\tt rcp} e {\tt rsh}, é possível fazer o login no sistema remoto sem a
 necessidade de se digitar o username e a password. Desta forma podemos
 passar de forma mais transparente de um sistema para o outro dentro de um
 ``cluster'' de sistemas que estejam integrados em rede. Experimente este
 comando, por exemplo executando-o em seu terminal {\tt tty1} da forma

 {\tt rlogin socrates.if.usp.br}

\noindent
 Verifique que você está de fato no {\tt socrates} e em seguida saia de
 novo, usando o comando {\tt exit} para terminar a shell que foi iniciada
 no login remoto.

 \item Repita as operações do ítem anterior usando o comando {\tt ssh} em
 vez de {\tt rlogin}. A {\tt ssh} pode fazer o mesmo tipo de trabalho que
 o {\tt rlogin}, comportando-se como a {\tt rsh} ou como o {\tt rlogin}
 dependendo do número de argumentos com que a utilizamos. Na realidade a
 shell {\tt rsh} também faz isto, de forma que o comando {\tt rlogin} é de
 certa forma um nome redundante. A forma de se configurar a {\tt ssh} para
 permitir o login sem password é um pouco mais complexa e a deixaremos
 para os problemas ao final da apostila. Mas a falta das autorizações
 apropriadas entre os sistemas não chega a representar um grande problema
 no caso da {\tt ssh}, pois ela sempre pede password quando isto acontece.

 \item Como mais uma forma de fazer a mesma coisa, digite simplesmente o
 nome do servidor {\tt socrates} no terminal. Verifique que, mais uma vez,
 você acaba de fazer um login remoto no sistema {\tt socrates}. Ou seja,
 esta é uma forma ainda mais transparente de ir de uma máquina para a
 outra dentro do ``cluster'' didático do Instituto. Para descobrir como
 isto aconteceu, localize o comando {\tt socrates} usando o comando {\tt
 which}, basta digitar {\tt which socrates}. Uma vez que achar o diretório
 onde está o comando, execute no arquivo o comando {\tt ls -l} para
 descobrir que tipo de coisa ele é. Sendo necessário, repita o processo
 até achar qual é o arquivo executável, contendo um comando, que está
 envolvido.

 A explicação do que acontece é uma propriedade peculiar do comando {\tt
 ssh} (que também é válida para a {\tt rsh}). Em geral o {\tt ssh} deve
 ser chamado com dois argumentos, o nome do host no qual queremos executar
 o comando e o nome do comando a ser executado. Se dermos apenas um
 argumento, ele será entendido como o nome de um host no qual se deve
 fazer um login. Por outro lado, se chamarmos o comando {\tt ssh} sem
 argumentos, mas dando a ele um nome diferente, ele tenta executar um
 login em um host cujo hostname seja o nome com o qual o comando foi
 chamado. Chamar um programa através de um link é uma forma de executá-lo
 com um nome diferente. Links para {\tt ssh} são a forma universal segundo
 a qual permitimos o tráfego de usuários entre as máquinas de um cluster
 de sistemas que estão integrados em rede, formando um único sistema
 global do ponto de vista do usuário.

 \item Existem sistemas na rede que estamos usando o tempo todo mas com os
 quais não interagimos de forma tão direta e explícita. Um deles é o
 sistema NFS (Network File System), através do qual a sua conta está
 visível a partir de qualquer das máquinas da sala Pró-Aluno, como se
 fosse uma área de disco local em cada uma delas.

 Sem este sistema você não teria um ``home'', ou teria um ``home''
 diferente em cada um dos sistemas e, toda vez que fosse usar uma das
 máquinas, teria de transferir todos os seus arquivos para ela, usando
 disquetes, ou FTP a partir da última máquina em que tenha trabalhado
 anteriormente. Esperançosamente, você ainda se lembra de onde foi que
 trabalhou da última vez, não perdeu nem danificou os seus disquetes e, se
 aquela máquina está agora sendo usada por alguém para rodar o Windows,
 bem,\ldots obviamente este esquema não seria uma idéia muito boa.

 O sistema NFS não é uma forma de copiar arquivos entre duas máquinas e
 sim uma forma de compartilhar o mesmo arquivo entre duas ou mais
 máquinas. Para verificar isto, em seu terminal {\tt tty1} volte ao
 sistema local, executando o comando {\tt exit}, caso ainda esteja numa
 sessão remota no {\tt socrates}. Execute um {\tt cd} sem argumentos, o
 que o levará para casa (para o seu ``home''). Faça o mesmo no terminal
 {\tt tty2}, onde você ainda está numa sessão remota no servidor {\tt
 socrates}. Voltando ao terminal {\tt tty1} crie com o comando {\tt touch}
 um arquivo chamado {\tt trash.nfs} na raiz de sua conta. Verifique o
 resultado com o comando {\tt ls}. Em seguida vá ao terminal {\tt tty2} e
 use o comando {\tt ls} para verificar que o arquivo que você acaba de
 criar está disponível no servidor. Não se trata de uma cópia, para
 verificar isto, ainda no terminal {\tt tty2} remova o arquivo com o
 comando {\tt rm trash.nfs}. Em seguida volte ao terminal {\tt tty1} e
 verifique que o arquivo desapareceu de lá também.

 \item O sistema NFS não é usado apenas para as áreas de usuários. Nos
 sistemas da sala Pró-Aluno usamos este sistema também para distribuir
 arquivos de sistema entre as máquinas. Execute o comando {\tt df} no
 terminal {\tt tty2} para verificar que no servidor {\tt socrates} o disco
 contendo as contas dos usuários é um disco local na máquina, montado no
 diretório {\tt /home} e que corresponde a algum dispositivo em {\tt
 /dev}. Depois execute o mesmo comando no terminal {\tt tty1} para
 verificar que no sistema local o que está montado no diretório {\tt
 /home} é um filesystem exportado pelo {\tt socrates} através da rede, com
 o uso do nome {\tt poph}, pelo qual o {\tt socrates} responde dentro da
 rede fechada.

 Verifique também que o que está montado no diretório {\tt /usr} no
 sistema local é um disco exportado pelo servidor {\tt socrates}, que no
 momento está dublando como o servidor Linux local da sala, usando desta
 vez o nome {\tt pops} dentro da rede fechada. É dentro deste diretório
 que fica a maior parte dos programas do sistema. Observe que, de todos os
 filesystems de sistema ({\tt /}, {\tt /tmp}, {\tt /var} e {\tt /usr}),
 este último é de longe o maior. Considere a economia de espaço em disco
 que estamos fazendo ao usar este mesmo sistema de arquivos contendo
 programas para todas as 28~máquinas da sala. Os discos de cada máquina
 têm cerca de 10~GB cada um, que estão sendo utilizados na maior parte
 pelo Windows e pelo diretório temporário local {\tt /temp}. Sem este tipo
 de esquema, não teria sido possível instalar em todas as máquinas um
 sistema Linux tão completo quanto o que temos e ainda dispor das amplas
 áreas temporárias locais {\tt /temp} nos terminais.

 \item Outro sistema muito importante na rede é o DNS (Domain Name
 Service), que serve para mapear endereços simbólicos em endereços
 numéricos e vice-versa. Isto é necessário porque os nomes simbólicos tais
 como {\tt socrates.if.usp.br} existem apenas para nosso benefício como
 usuários da rede. Todo o endereçamento do tráfego de pacotes que acontece
 na rede é feito, na realidade, usando os correspondentes endereços
 numéricos. Assim, toda vez que nos referimos a alguma máquina, como por
 exemplo {\tt ftp.debian.org}, o sistema precisa descobrir a que endereço
 numérico isto corresponde, para poder construir os pacotes com o
 endereçamento correto e enviá-los ao sistema de destino.

 Para descobrir quais são os endereços numéricos dos sistemas, você pode
 usar o comando {\tt host <hostname>.<network-domain-name>}, tanto no {\tt
 socrates} quanto nas máquinas da sala Pró-Aluno. Entretanto, note que as
 máquinas da sala em si estão em uma rede fechada e não estão cadastradas
 no sistema DNS da Internet, de forma que não vai funcionar usar este
 comando para as máquinas da sala. Tente executar o comando para várias
 máquinas do Instituto, tais como {\tt socrates.if.usp.br}, {\tt
 euclides.if.usp.br}, {\tt latt.if.usp.br}, {\tt gancho.if.usp.br}, {\tt
 mestre.if.usp.br} e {\tt servo.if.usp.br}. Depois disto, tente algumas
 outras máquinas da USP como, por exemplo, {\tt spider.usp.br}, {\tt
 linusp.usp.br} e {\tt linorg.usp.br}. Finalmente, tente algumas máquinas
 de fora do país como, por exemplo, {\tt ftp.debian.org} e {\tt
 ftp.kernel.org}.

 \item Outro sistema de informação importante para a rede é o sistema NIS
 (Network Information Service). Trata-se de um sistema de abrangência bem
 mais localizada, mas que distribui informações de caráter mais variado e
 mais específico de um sistema integrado de máquinas como o nosso cluster
 didático. Ele também pode ser utilizado para distribuir informação sobre
 os endereços de máquinas, mas é mais comum usá-lo para distribuir as
 informações sobre os usuários existentes nos sistemas, tais como seus
 usernames e as respectivas passwords. Na rede fechada da sala Pró-Aluno
 nós o utilizamos com estas duas funções. Sem ele, seria necessário
 cadastrar cada usuário e cada host da rede fechada em cada uma das
 máquinas, o que obviamente significaria uma grande quantidade de trabalho
 repetitivo na administração dos sistemas.

 Todos os usuários precisam estar cadastrados em algum lugar, que em geral
 é o servidor central (master server) do sistema NIS. Em nosso caso este
 sistema é (adivinhe só!) o servidor {\tt socrates}. Para ver o cadastro
 de todos os usuários dos sistemas didáticos examine, em seu terminal {\tt
 tty2}, o arquivo {\tt /etc/passwd}, usando o seu paginador ou editor
 favorito. Como você vê, há nele várias colunas de dados separadas pelo
 caracter ``{\tt :}'', que mapeiam o username do usuário em seu número de
 identificação no sistema, seu home, sua shell de login, etc. A única
 coisa que notoriamente está faltando é, curiosamente, a password! Em
 tempos passados ela costumava de fato ser mantida neste arquivo, em forma
 encriptada, mas hoje em dia a mantemos em outro, por questões de
 segurança: o arquivo {\tt /etc/shadow}, que não é legível pelos usuários.

 \item Assim como acontece no caso da rede, toda a operação do sistema é
 baseada no número de identificação do usuário e não no seu username, que
 só existe para conforto mental dos usuários mais humanos. Assim, toda vez
 que algo se refere a um usuário pelo username, o sistema tem de consultar
 o arquivo {\tt /etc/passwd} para descobrir o respectivo número (o uid).
 Entretanto, pode-se verificar que esta informação sobre a maior parte dos
 usuários não está disponível nos arquivos {\tt /etc/passwd} de cada um
 dos sistemas da sala Pró-Aluno. Para verificar este fato, em seu terminal
 {\tt tty1} dê uma olhada no arquivo {\tt /etc/passwd} do sistema local
 que você está usando. Você encontrará lá apenas dois usuários: o
 super-user {\tt root} e uma conta auxiliar chamada {\tt help}, todas as
 demais estão faltando.

 \item Esta informação está sendo distribuída para as máquinas da sala
 através do sistema NIS. Você pode obter esta informação usando comandos
 do sistema NIS. Para começar, ``descubra'' qual é o servidor NIS que está
 servindo o seu sistema local usando, no terminal {\tt tty1}, o comando
 {\tt ypwhich}. Descubra também qual é o domínio NIS ao qual ele pertence,
 usando o comando {\tt domainname}. Para obter a informação sobre os
 usuários, execute o comando {\tt ypcat passwd}. Como a informação vem
 fora de ordem, para ver algo mais ou menos como está no arquivo do {\tt
 socrates} é melhor usar a pipeline {\tt ypcat passwd | sort | less}, na
 qual o comando {\tt sort} coloca as linhas em ordem alfabética e o
 paginador permite que você olhe o resultado com calma. No {\tt socrates}
 os usuários estão organizados no arquivo {\tt /etc/passwd} por ordem de
 uid e não por ordem alfabética de usernames. Para colocar a lista nesta
 ordem de {\tt uid} use a pipeline

 {\tt ypcat passwd | sort -n -t : +2 | less}

\noindent
 Olhe as páginas de manual do comando {\tt sort} para entender o papel de
 cada opção ou argumento.

 \item Uma forma útil de descobrir informação sobre os usuário que existem
 em um sistema remoto é o comando {\tt finger}. Este comando dá
 informação, não apenas sobre que usuários estão usando o sistema naquele
 momento, mas sobre usuários que existem cadastrados naquele sistema.
 Devido ao fato de que algumas vezes este tipo de informação pode ser
 utilizado para fins ilícitos, este comando muitas vezes está desabilitado
 ou fornece apenas tipos e quantidades muito limitadas de informação. Para
 verificar qual a informação que está disponível sobre a sua própria conta
 a partir do {\tt socrates}, execute no seu terminal {\tt tty1} o comando

 {\tt finger <username>@socrates.if.usp.br}

\noindent
 e, para obter alguma informação sobre quem está no sistema no momento, o
 comando {\tt finger @socrates}. Tente também usar o finger com o username
 de alguns outros usuários do sistema.

 \item Uma forma simples e eficiente de comunicação em tempo real entre
 usuários do sistema, ou de dois sistemas diferentes, é provido pelo
 programa {\tt talk}. Para se comunicar com um usuário que esteja usando
 um determinado sistema remoto, basta executar o comando

 {\tt talk <username>@<hostname>.<network-domain-name>}

\noindent
 Se estiver de fato logado no sistema remoto, o usuário receberá uma
 mensagem o instruindo a responder com um comando do mesmo tipo.
 Entretanto, é possível que a sessão do usuário remoto não esteja
 permitindo conexões deste tipo. Cada usuário pode controlar se quer ou
 não receber este tipo de conexão com o comando {\tt mesg}. Executando-se
 {\tt mesg y} autoriza-se as conexões, com {\tt mesg n} elas são
 desabilitadas. Sem argumentos, o comando mostra a situação corrente.

 Se a conexão for realizada com sucesso, a tela de seu terminal se
 dividirá em duas, o que você escrever aparecerá numa delas e o que o seu
 interlocutor digitar aparecerá na outra. Caso os dois usuários estejam
 logados na mesma máquina, é suficiente colocar apenas o username,
 omitindo os nomes da máquina e do domínio. Este seria o caso, por
 exemplo, de dois alunos que estejam logados no {\tt socrates} a partir de
 máquinas da sala Pró-Aluno e que usem o comando dentro do servidor.

 Tente usar este comando para falar com algum colega que também esteja
 usando o Linux na sala Pró-Aluno. Faça o mesmo dentro do {\tt socrates},
 estabelecendo uma conversação com algum outro usuário que esteja logado
 no servidor. Existe também um comando {\tt ytalk}, com a mesma função,
 que pode ser utilizado dentro do sistema X11, no qual ele abre uma janela
 própria. Tente usar este comando também.

 \item Existem outros comandos e sistemas que distribuem informação pela
 rede. Na maior parte das vezes, estes sistemas envolvem dois elementos:
 um comando que o usuário usa para acessar a informação e um programa que
 roda continuamente em cada máquina e que fornece esta informação quando é
 feita uma solicitação. Estes programas que rodam de forma constante são
 chamados de ``daemons'', a maior parte dos comandos que examinamos acima
 dependem, para a sua operação, de estarem rodando os daemons adequados
 nas máquinas com as quais queremos nos conectar. Por exemplo, os comandos
 {\tt telnet}, {\tt rsh}, {\tt rlogin} e {\tt ssh} dependem de estarem
 ativos os daemons {\tt telnetd}, {\tt rshd}, {\tt rlogind} e {\tt sshd}.
 Em alguns sistemas alguns destes daemons podem não estar habilitados e os
 correspondentes serviços podem não esta funcionando.

 Em nossos sistemas mantemos ativo um outro daemon, chamado {\tt rwhod},
 que permite a operação de mais dois comandos de distribuição de
 informação pela rede. Trata-se dos comandos {\tt rwho} e {\tt ruptime},
 que são versões remotas dos comandos {\tt who} e {\tt uptime}. O primeiro
 dá informação sobre os usuários que estão usando os sistemas que estão
 rodando os daemons, o segundo dá informação sobre os próprios sistemas
 como, por exemplo, há quanto tempo estão funcionando desde o último boot
 e qual a carga em cada um.

 Experimente usar os comandos {\tt who}, {\tt uptime}, {\tt rwho} e {\tt
 ruptime} tanto no sistema local (terminal {\tt tty1}) quanto no servidor
 remoto (terminal {\tt tty2}). Observe que estes comandos de rede atuam
 apenas sobre as máquinas ligadas à mesma rede física e configuradas na
 mesma rede lógica, de forma que os resultados dos comandos de rede serão
 muito diferentes no {\tt socrates} e nas máquinas da sala Pró-Aluno.
 Estes comandos e daemons atuam por meio de ``broadcast'' e só são
 efetivos dentro de uma rede local configurada logicamente como um domínio
 de broadcast. Usando pipelines como os comandos {\tt grep}, {\tt sort},
 etc, você poderá filtrar e manipular a informação obtida para os mais
 diversos fins. O comando {\tt ruptime} tem também algumas opções úteis de
 ordenamento, dê uma olhada nas suas páginas de manual.

\end{enumerate}

\section{Problemas e Dicas}

\begin{enumerate}

 \item Dois programas que ilustram de forma interessante o funcionamento
 da rede são o {\tt ping} e o {\tt traceroute}. O primeiro é um programa
 muito simples que testa a conexão até um dado host de forma parecida com
 o funcionamento de um sonar submarino, de onde vem o seu nome. Tente usar
 este comando para verificar a disponibilidade de algum host remoto como,
 por exemplo, em {\tt ping www.debian.org} ou {\tt ping ftp.kernel.org}.
 Observe o resultado do comando e tente interpretar o seu significado. Em
 seguida execute os comandos {\tt traceroute www.debian.org} ou {\tt
 traceroute ftp.kernel.org}. Este programa determina e mostra na tela a
 rota que está atualmente funcionando até o host remoto. Mais uma vez,
 tente interpretar o significado do output que aparece. Uma olhada nas
 páginas de manual dos dois comandos pode ser muito útil.

 \item Leia as páginas de manual do comando {\tt ssh} para descobrir como
 configurar este comando de tal forma que ele deixe você entrar na máquina
 remota sem que você tenha de digitar a sua password. Os arquivos
 envolvidos nisto vão estar todos dentro de um diretório chamado {\tt
 .ssh} na raiz da sua conta. Procure em particular por referências aos
 arquivos {\tt known\_hosts} e {\tt authorized\_keys}. O comando {\tt
 ssh-keygen} será importante pois é com ele que você gera as suas chaves
 pessoais de encriptação. O comando {\tt ssh-copy-id} também é importante
 para facilitar o estabelecimento das autorizações entre hosts. Olhe as
 páginas de manual destes comandos.

 \item Entre no {\tt socrates} e use o comando {\tt ruptime} para
 descobrir quais são as máquinas mais carregadas do Instituto, entre
 aquelas que rodam o daemon {\tt rwhod}. Em seguida, descubra como usar o
 comando {\tt rwho} para obter o número de usuários diferentes que estão
 usando algum sistema no Instituto. Você vai ter de usar pipelines e os
 comandos {\tt sort}, {\tt grep}, {\tt uniq}, {\tt cut} e {\tt wc} devem
 ser úteis.

 \item Você também pode puxar software dos servidores {\tt fma.if.usp.br}
 ou {\tt ftp.debian.org} usando um ``browser'' como o {\tt netscape} ou o
 {\tt mozilla}. Denominamos o servidor {\tt fma.if.usp.br} de ``espelho'',
 pois o que ele faz é copiar e re-distribuir software a partir de vários
 sites da Internet, usando para isto um programa chamado {\tt wget}. Já o
 servidor {\tt ftp.debian.org} é um site original, do qual o servidor {\tt
 fma.if.usp.br} espelha parte do conteúdo. Descubra como usar o {\tt
 netscape} ou o {\tt mozilla} para acessar o espelho e puxar dele alguns
 pacotes de software. Considere usar como endereços, dentro do browser, as
 possibilidades

 {\tt http://fma.if.usp.br} e {\tt ftp://ftp.debian.org}.

 Você poderá navegar pela estrutura dos filesystems do espelho clicando em
 links que vão aparecer no seu browser. Para puxar arquivos por FTP ou
 HTTP e salvá-los em disco, em vez de mostrá-los na tela, clique nos links
 correspondentes enquanto mantém apertada a tecla {\tt [Shift]}. Esta é
 uma forma muito conveniente de navegar pelo espelho e puxar free
 software.

 Outra forma muito útil de puxar arquivos através da rede pelos protocolos
 HTTP e FTP, em especial em conexões lentas e que caem muito, é o uso do
 programa {\tt wget}, que é capaz de retomar as conexões pelo protocolo
 FTP do ponto onde elas pararam devido à interrupção. Tente usar este
 comando, para saber como, dê uma boa olhada no seu manual.

\end{enumerate}

\section{Uma Lista de Comandos Relevantes}

\begin{description}\setlength{\itemsep}{0ex}

 \item[\tt finger <username>@<hostname>.<network-domain-name>]: mostra
 alguma informação sobre o usuário no sistema remoto, independentemente
 dele estar ou não usando o sistema neste momento.

 \item[\tt ftp <hostname>.<network-domain-name>]: estabelece uma sessão
 interativa com capacidades limitadas numa máquina remota, através da qual
 se pode transferir arquivos entre os dois sistemas.
 
 \item[\tt host <hostname>.<network-domain-name>]: retorna o endereço
 numérico da Internet que corresponde ao endereço simbólico digitado como
 argumento.

 \item[\tt hostname]: retorna o nome na rede da máquina onde se está.

 \item[\tt mesg {[y|n]}]: habilita ({\tt y}) ou desabilita ({\tt n})
 conexões de sistemas de mensagens com o seu terminal; sem argumentos,
 mostra a situação corrente.

 \item[\tt rcp <argumento1> <argumento2>]: copia arquivos de e para uma
 máquina remota, desde que a máquina local e a máquina remota tenham entre
 si as necessárias relações de autorização; os argumentos têm a forma
 geral

 {\tt <username>@<hostname>.<network-domain-name>:<path>/<file>}

 \item[\tt rlogin <hostname>.<network-domain-name>]: estabelece uma sessão
 interativa numa máquina remota; solicita password se necessário.

 \item[\tt rsh <hostname>.<network-domain-name> <comando>]: executa um
 comando numa máquina remota, desde que a máquina local e a máquina remota
 tenham entre si as necessárias relações de autorização.

 \item[\tt ruptime]: mostra o estado do sistema das máquinas da rede
 local.

 \item[\tt rwho]: mostra os usuários correntemente logados nas máquinas da
 rede local.

 \item[\tt scp <argumento1> <argumento2>]: copia arquivos de e para uma
 máquina remota, encriptando o tráfego de dados entre as duas; solicita
 password se necessário; é parte integrante do sistema {\tt ssh}; os
 argumentos têm a forma geral

 {\tt <username>@<hostname>.<network-domain-name>:<path>/<file>}

 \item[\tt ssh <hostname>.<network-domain-name> {[<comando>]}]: estabelece
 uma sessão interativa numa máquina remota, encriptando todo o tráfego que
 passa pela rede; solicita password se necessário; também pode executar um
 comando numa máquina remota.

 \item[\tt talk <username>@<hostname>.<network-domain-name>]: estabelece
 uma \linebreak sessão de conversação escrita (digitada) com um usuário
 que esteja logado em uma máquina remota.

 \item[\tt telnet <hostname>.<network-domain-name>]: estabelece uma sessão
 interativa numa máquina remota; solicita password e username, se
 necessário.

 \item[\tt uptime]: mostra o estado do sistema local.

 \item[\tt w]: mostra quem está logado no sistema.

 \item[\tt who]: mostra os usuários do sistema local.

 \item[\tt ytalk <username>@<hostname>.<network-domain-name>]: estabelece
 uma \linebreak sessão de conversação escrita (digitada) com um usuário
 que esteja logado em uma máquina remota, criando uma janela própria no
 sistema de janelas X11.

\end{description}

\section{Arquivos de Configuração}

 Os arquivos de configuração que são específicos do ambiente de rede já
 foram mencionados no texto. São os arquivos de controle de acesso na raiz
 de sua conta, o arquivo {\tt .rlogin} e os arquivos dentro do diretório
 {\tt .ssh/}.

\end{document}

###

