CURSO DE LINUX

----- // -----

Aqui está a lista de e-mails da turma:

NOME       LOCALIDADE                      E-MAIL
Clelia     CIRP (USP- Ribeirão Preto)      clelia@cirp.usp.br
?          ?                               famonezi@msn.com
Fernando   JLG                             fernando@jlg.com.br
?          ?                               microhouse@viazul.com.br
Marcelo    Barão de Mauá                   nunespaiva@ig.com.br
André      Homy Química                    ti.hq@homyquimica.com.br
Danilo     Loja de Informática em Pontal   danilomachado@3ax.com.br
?          ?                               esm@terra.com.br
Jonathan   WELDING (Sertãozinho)           inspecoes@welding.com.br
Marco      SANTAL                          mudimiki@santal.com.br
?          ?                               verbatin@uol.com.br

----- // -----

Aqui está a lista de e-mails do pessoal que saiu:

NOME       LOCALIDADE                      E-MAIL
Carlos     Provedor de Monte Azul          carlao@viazul.com.br
Lucas      Provedor de Monte Azul          lucas@viazul.com.br
Leandro    Provedor de Monte Azul          leandro@viazul.com.br
?          Provedor de Monte Azul          loco@viazul.com.br

----- // -----


De 23/08/03 a 11/10/03 o instrutor foi:

   Nome              : Michel Pereira
   Certificações     : Especialista em Segurança, Conectiva
   Empresa           : Mondonet (www.mondonet.com.br)
   E-mail            : michel@michel.eti.br
   ICQ               : 4553082

----- // -----

A partir de 25/10/03 o instrutor foi:

   Nome              : Daniel Constantnov
   Certificações     : MCNE, MCSE, Conectiva (há 2 anos)
   Empresa           : K9 Informática
   Ramo de Atividade : Desenvolvimento Web (MySQL, PHP, HTML)
   Produto           : Riser (www.riser.com.br)
   E-mail            : daniel@riser.com.br

*********************************************************************

O micro que uso possui a seguinte característica:
 Red Hat v8.0 (Kernel 2.4.18-14 - K6-2 500 Mhz)

*********************************************************************

23/08/03

  1.1:
      - Consórcio OSDL

  1.2:
      - Checar logs
      - Manter o sistema on-line e funcionando

  1.3:
      - login: root
      - senha: a@c!rpx3 ou password

      Prompt: <usuário>@<nomedamáquina> <diretório>#
              root@77pene05

      # - usuário root
      $ - usuário comum
      IMPORTANTE: Nunca realizar tarefas de rotina como root.
      ==========

      Recurso auto-completar: <letra>+TAB(+TAB-se houver mais de um
      comando)

      P/ Desligar:
                  - shutdown -h <tempo>
                  - shutdown -h now
                  Aguardar a mensagem "Power down"

                  - halt (não recomendado, pois não avisa os usuários)

      P/ Reiniciar:
                   - reboot (ver opção -r)

      COMANDOS básicos
      - ls: lista os arquivos e diretórios
          .cores:
                 - verde: arquivos executáveis
                 - azul:  diretório
                 - ciano: link simbólico
                 - cinza: arquivos normais

      - clear: limpa a tela ou CTRL+L

      - cd: entra ou sai de diretórios
            cd <diretório>: entra
            cd -          : volta p/ o último diretório
            AJUDA: <comando> -h ou --help
            =====
          
            cd<enter>: volta p/ diretório home do usuário

      - pwd: mostra o caminho completo

      - whoami: mostra o usuário logado

      - more: exibe arquivos de texto na tela
              more <arquivo>
                 - <enter> : linha
                 - <espaço>: tela
                 - q       : sai
                 - |       : pipe (dir /s |more)

      - less: navega dentro de um arquivo de texto
              less <arquivo>
              DICA: CTRL+C: cancela o programa
              ====
                       - q: sai

      - rm: remover arquivos
            rm <arquivo>
             - i: perguntar antes
              .y: sim
              .n: não

             - r: remoção recursiva

             - f: de forma forçada (nem pergunta)
                  rm -rf <diretório>

      - mkdir: cria diretórios de nomes de até 255 caracteres
               mkdir "<diretório>" "<diretório>" "<diretório>"...
               DICA: \: anulao próximo caracter
               ====
               mkdir <diretório>\ <diretório>\ <diretório>\

               mkdir <diretório>/ <diretório>

               - p: cria uma estrutura de diretórios
                    mkdir -p <diretório>/<diretório>/<diretório>

      - rmdir: remove diretórios
               rmdir <diretório>
               OBS: P/ apagar uma estrutura usar:
                    rm -rf <diretório>

      - vi: editor de texto
            vi <arquivo>
            - Modos:
                    - Comando : logo que entra
                    - Inserção: i (p/ voltar ao modo de comando: ESC)
                    - :w      : grava arquivo
                    - :q      : p/ sair
                        - :q! : p/ sair sem gravar

                    Combinando comandos
                    - :wq     : grava e sai

                    - /<texto>: para pesquisar

                    P/ pesquisar e  substituir
                    - :1,$s/<textoprocurado>/<textosubstituir>
                       |_ substitui a 1ª ocorrência em cada linha
                       |_ p/ substituir todas as ocorrências
                          acrescentar /g no final do comando

                      :1,$s-comando (procura e substitui)
    sinal de comando _|| |_ linha final
                       |
                  linha inicial

                    - REPLACE: INSERT (substitui o texto)

      - dd: apaga a linha corrente

      - u: undo

      - <linhas> dd: apaga a qtde. de linhas informada
                     - 3dd<enter> (a partir do cursor p/ baixo)

                    P/ copiar
                    <caracteres> y ->  : p/ copiar
                    p                  : p/ colar
                    - 80y ->

      - Procurar vimtutor na internet: (tutorial do vi)
                 ========

      - x: igual a DEL
           <caracteres> x
           10x : executa o x 10 vezes

      - <linha>+SHIFT+g: vai p/ linha especificada
              - SHIFT+g: vai p/ última linha


  1.4:
      - DOCUMENTAÇÕES
      - man: lista um ajuda detalhado
            man <comando>
            - navegação: setas
        DICA: troca de consoles ALT+Fx(F1 a F6)
        ====

      - <comando> --help: resumo da ajuda

      - apropos: busca comandos por função
                 apropos <função do comando>
                 apropos copy

      - Categorias de comandos:
        (1) - User comands              (5) - Software de terceiros
        (2) - Linux Programer's Manual  (6) - UNIX reference Manual
        (3) - Linux Programer's Manual  (7) - Linux Programer's Manual
        (4) - Linux Programer's Manual  (8) - Linux Programer's Manual


      - whatis: resumo do comando
                whatis <comando>
                whatis cp

                OBS: p/ gerar o banco de dados use:
                     makewhais -v (gerar a cada instalação de um novo
                     programa) e no Red Hat ele realiza esse comando
                     toda madrugada (4:00)

      - A documentação fica em: /usr/share/man($MANPATH)
      - A documentação segue o padrão: POSIX
                                       =====
                                    
      - man --path: 2º diretório onde estão as documentações

      - info <comando>: Documentação muito detalhada com muitos expls.

      - /usr/share/docs: Exemplos prontos de documentação

      - Howto: "Receitas de bolo" de como fazer algo passo-a-passo
      - DICA: www.linuxdoc.org: reúne muita documentação!
              ldp.conectiva.com.br: Howto's em português
              www.linux-br.com.br: lista de discussão
              bazar.conectiva.com.br: lista de discussão
              - Prova LPI: Red Hat, Slackware, Debian


      VARIÁVEIS

      - printenv: exibe todas variáveis do que o linux incializou
      - DICA: P/ rolar a tela use SHIFT+PGUP ou PGDOWN

      P/ criar uma variável p/ o console corrente:
         <VARIÁVEL>=<valor>
         NOME=jonathan ou DATA=`date`

      P/ exibir o valor da variável:
         echo$<VARIÁVEL>
         echo$NOME ou echo $DATA

      - set: exibe as variáveis do que o Linux está rodando

      - Expansão do Shell
        Utilizar a crase (`) p/ "pegar" p valor de um comando

        DATA=`date`
        echo $DATA

      - echo: exibe valores na tela

      - Exemplo de expansão do Shell
        mail `mysql select*from usuários` "teste"

      - aspas duplas ("): colocar valor dentro de uma variável
        echo "a data de hoje eh" `date`
        echo "a data `date` eh"

      - underline (_): tormar cuidado! (ou qualquer outro caracter
                                        após o nome da variável)
        echo $DATA_    <- ERRADO!
        echo${DATA}_   <- OK!

      - apóstrofo ('): pode ser usado p/ realçar um texto
        echo "Curso 'de' Linux"

      P/ exportar variáveis p/ tornar disponível p/ outros shells
      (todo mundo que se loga)
        export <variável>


      ARQUIVOS DE INICIALIZAÇÃO

      - vi /etc/bashrc   (é do administrador e define a maioria das
                          variáveis)

      - vi.bashrc        (é do usuário: /home/usuário)
                     
      - vi /etc/profile  (define a maioria das variáveis)
        vi /etc/profile.d(executa scripts após todo o logon)

      ALIASES (Atalhos)
         alias<nomedoatalho>="<comando>"
         alias |="ls - lah"

         unalias<nomedoatalho>
         unalias |

         P/ ver os atalhos já definidos:
         alias

      PIPES E REDIRECIONAMENTO
         ls /usr/bin | more
         ----------- - ----
             |       |   |
 comando de saída  PIPE  comando de entrada

         P/ filtrar só o que quero:
         la | grep <texto>

         P/ contar:
         ls | grep <texto> | wc -l
              ------------   -----
                   |           |
          comando de saída   comando de entrada

         - Redirecionamento
         ls /usr/bin > <arquivo>

         - cat: mostra informações na tela
         cat < <arquivo>
         cat < texto.txt
         grep root < texto.txt
    
*********************************************************************

30/08/03

  1.6:
      - COMANDOS P/ MANIPULAÇÃO DE ARQUIVOS DE TEXTO

      - cat: mostra conteúdo de arquivos na tela (de cima p/ baixo)
             cat < <arquivo>
             cat install.log

        Se o prompt perder a formatação, digitar:
             reset <enter>
      
      - tac: mostra conteúdo de arquivos na tela (de cima p/ baixo)
             tac <arquivo>
             tac install.log
             tac.install.log | more

      - rev: mostra conteúdo de arquivos invertido (de trás p/ frente)
             rev <arquivo>
             rev install.log | more

      - tail: mostra as 10 (final) últimas linhas de um arquivo
              tail <arquivo>
            
              - f: monitora constantemente um arquivo
                   tail -f <arquivo>
                   Nota: executar em um terminal, mudar de terminal e
                         continuar trabalhando normalmente.
                      
      - head: mostra as 10 primeiras linhas de um arquivo
              head <arquivo>
              head install.log

      - wc: "word count": conta caracteres
                          wc <arquivo>
                          xxxxx    xxxxx    xxxxx
                          -----    -----   -----
                            |        |       |
                         linhas  palavras  caracteres

                         - l: conta linhas
                              wc -l <arquivo>

                         - c: conta caracteres
                              wc -c <arquivo>

                         - w: conta palavras
                              wc -w <arquivo>

                         Integrando:
                         ls -lah | wc -l (conta arquivos)
                         Nota: os diretórios "." e ".." devem ser
                               desconsiderados

      - sort: organiza arquivos
              sort <arquivo>
              sort teste | more

      DICA: Arquivo de senhas: /etc/passwd
                               ------------
      Nota: NUNCA organizar este arquivo<-|

      P/ salvar a organização:
         sort <arquivo> > <arquivoorganizado>
         sort teste > teste.novo

      P/ organizar de forma decrescente:
         sort -r <arquivo>

      Nota: espeços em branco ficam no início

      - cut: extrai informações de um arquivo
             cut -d "." -f4 <arquivo> | more
                 ------ ---           ------
                    |    |                 |
            delimitador  fields("colunas") comandos à vontade:
                                           (ex. | sort ou > <arquivo>)

      DICA: | uniq: agrupa várias ocorrências

      INTERESSANTE:
      - tr: troca caracteres em um arquivo               
            cat /etc/passwd | tr <textoatrocar> <textotrocado> | more

      Nota: este comando NÃO ACEITA arquivos diretamente:
            tr <textoatrocar> <textotrocado> <arquivo>

      - expand: troca caracter TAB por ESPAÇOS
                expand <arquivos> | wc -c

      - tee: executa um processamento tanto na tela quanto em um
arquivo
             ls - lah | tee <arquivo>

      - split: divide arquivos
               split -b <bytes> <arquivo>
               split -b 1000 install.log

               P/ juntar:
               cat * > install.log
                   |_todos os arquivos



  1.8:
      - ADM. USUÁRIOS (pág. 577 do livro)

      A conta root:
      - nuca usá-la p/ tarefas de usuário

      Arquivos de usuários e senhas:
        /etc/passwd
        /etc/shadow
    
      - O arquivo /etc/passwd (pág. 585 do livro)

        DICA: diretório de shells: /etc/shells

      - O arquivo /etc/shadow (pág. 586 do livro)
        Só o root consegue acessar este arquivo

      - md5sum: verifica a assinatura de um arquivo ou diretório
        md5sum <arquivo>

        DICA: p/ migrar de um servidor p/ outro, copiar esses 2
              arquivos (/etc/passwd e /etc/shadow) p/ o 2º servidor.
              Claro que depois você terá que que criar os diretórios
              home de cada usuário.

              Geralmente, todos os serviços tem seu próprio nome de
              usuário. Sào os "usuários de sistema"

        P/ adicionar um usuário:
           useradd <usuário>

        P/ trocar a senha:
           passwd <usuário>
           Nota: se deixar em branco, ele mantém a senha atual.
           (ou CTRL+C)

        IMPORTANTE: se um usuário tentar alterar a sua própria senha
                    por uma muito simples ou fácil, ele não vai
                    conseguir.

        P/ adicionar um usuário p/ não poder logar utilizando uma
        shell:
           useradd -s "sbin/nologin" -c "Secretaria de Curso de Linux"
           secretaria

           - Adicionar uma senha p/ este usuário:
             passwd secretaria
             senha: sss

           - P/ filtrar:
             grep secretária /etc/passwd

           - P/ editar o arquivo /etc/passwd
             vi /etc/passwd

        P/ remover um usuário:
           userdel <usuario>

           - P/ remover o diretório home:
                userdel -r <usuário>

        P/ trocar informações do usuário (pág. 593 e 587)
           - editar o arquivo /etc/passwd
           ou
           - chage:
                   DICA: p/ exibir um calendário: cal

           Nota: o horário e datas no Linux são calculados desde 1970

           -l: lista as informações de um usuário
               chage -l <usuário>

           -p: para alterar essas informações (pág. 595)
               chage -m 5 -m 30 -E 0 <usuário>
                                 ---
                                  |_formato da data: 2003/09/30

      - chsh: muda a shell de um usuário (pág. 595, 596)
              chsh <usuário> (digitar o caminho da nova shell)
              -l: lista as shells disponíveis


      DICA: Prova da Conectiva: TechTraining

      - GRUPOS (pág. 597)
        ======

        P/ listar os grupos
           cat /etc/group

        P/ adicionar um grupo:
           groupadd <grupo>

        P/ adicionar um usuário em um grupo
           useradd -G <group> <usuário>
           usermod -G <group> <usuário>

        P/ listar grupos
           groups <usuário>
           cat /etc/group

        P/ remover um grupo:
           groupdel <grupo>


      DICA: quando você quiser que algum arquivo seja copiado
            automaticamente, coloque esse arquivo em /etc/skel


  1.9:
      - USANDO SCRIPTS (pág. 504)

        Diretório de comandos: /etc/bin

        P/ achar comandos (características do bash) - pág. 504
           ls d*
           ls d?
           ls d??
           ls ??
           ls [b-c]* (pág. 505)
           ls [b-d,f]? (pág. 505)
           ls [a-z] [a-z] [a-z] (pág. 505)
           ls [a-z] [a-e] [a-z] (exemplo do curso)

        VARIÁVEIS (pág. 508-511)
           set (bash)
           printenv (sistema)


        OPERADORES DO BASH (pág. 511)


        Marco: marco.udimiki@bol.com.br
               mudimiki@santal.com.br
               santal@santal.com.br

        SCRIPTS (pág. 520)

        P/ verificar se um arquivo existe: e é ASCII
           if [ -f /etc/passwd]; then echo "Existe"; else echo "Não
           existe"; fi

        Criando um script
           vi <arquivo>.sh

           1ª linha: #!/bin/bash
           Comentários: #
           Pausar: sleep <segundos>
           P/ executar: sh <arquivo>.sh ou
                        bash <arquivo>.sh ou
                        ./<arquivo>.sh

           DICA: P/ mudar a permissão do arquivo:
                    chmod +x <arquivo>


           Exemplo: if cd /tmp ; ten "Entrou"; fi

           P/ passar parâmetros
              $1,$2,$3
              Exemplo: ./<arquivo>.sh /etc
                                      ----
                                        |
                                        $1
        FOR (pág. 523, 525)

           for i in `ls /home`; echo "diretório $i"; done

           for i in `cut -d ":" -f 1 /etc/passwd`; do mail -s "Bem-
           vindo ao meu servidor" $i < Hmp/email.text; done
                                  --
                                   |
                      poderia ser: $i@ dominio.com.br

        P/ não criar o arquivo /tmp/email.txt
           for i in `cut -d ":" -f 1 /etc/passwd`; do echo "Corpo do
           email" | mail -s "Bem-vindo ao meu servidor" $i; done

        P/ localizar um arquivo:
           find <diretório> -name <arquivo>


        P/ formatar fisicamente:
           MAXLLF

        P/ interromper um comando temporariamente
           CTRL+Z

           - p/ listar processos pausados: jobs
           - p/ voltar: fg <número> <enter>
           - p/ deixar o comando em background: bg <enter> ou
             <comando> &


        PROCESOS

        P/ mostrar os processos:
           ps <parâmetros> | grep <comando>
           - a: todos os usuários
           - u:
           - x:
           - w:

           Exemplo: ps auxw | grep script.sh

        P/ "matar" um processo:
           kill -9 <númerodoprocesso>
                --
                 |_ parâmetro p/ "matar"

      
        AUTOMATIZANDO SCRIPTS
        ============= =======

        - crontab: agenda tarefas (pág. 546)

                   - p/ visualizar tarefas agendadas:
                        crontab -l

                   - p/ adicionar tarefas:
                        crontab -e
                   sintaxe:
         Minuto Hora DiadoMes Mes DiaSemana Comando
           10    4      *      *      *     /bin/bash /root/script.sh
                 
        - Diretórios do crontab:
          /var/spool/cron/

                   - p/ monitorar processos agendados:
                        tail -f /var/log/cron

                   - p/ remover a tarefa:
                        crontab -e : e apagar a linha agendada
                                   

                   - p/ listar o crontab de outro usuário
                        crontab -l -u <usuário>

                   - p/ definir quem pode agendar com o crontab:                                
                     crontab:
                        /etc/crontab.allow (usuários permitidos)
                        /etc/crontab.demy (usuários negados)

                   - p/ agendar uma tarefa p/ um usuário como root:
                        crontab -u <usuário> -e

*********************************************************************

06/09/03

      DICA: P/ mostrar quem está utilizandoo bash:
               auxw | grep bash

            P/ mostrar os PID:
               pgrep bash


  1.10:
       - EXPRESSÕES REGULARES (aurelio.net)
                              (guia-er.sourceforge.net)


       - Exemplos:
                  - RG (000.000.000-00)
                  - Textos em posições exatas (palavras no início ou
                    no final da linha)

       - Os Programas que as utilizam:
         - Shell
         - grep (é como um filtro)
         - sed (é um editor de stream)
                     --        -
         - WORD 2000 (também tem suporte)

         PROCURAR: RTFN (na Internet) sobre o vi

         DICA: no vi, p/ repetir um busca, apertar n (de next)

         IMPORTANTE: Ler o manual do vi.
                     ===             ==
         ^ - procura no início da linha

       - Utilizando o grep:
         grep <textoaprocurar> <arquivo>
         grep 222 teste.txt
         grep ^222 teste.txt

         " " - procura exatamente o que for digitado
         grep "222" teste.txt
         NOTA: isto serve também p/ a shell não "confundir" o texto
               pesquisado com uma variável
         grep "final$" texto.txt

         \ - anula o próximo caracter
         grep Oi[teste teste.txt    <--ERRO!
         grep Oi[teste teste.txt    <--CERTO
         grep Oi\\teste texte.txt

         DICA: NUNCA utilizar o find com o grep porque pode travar o
               =====
               micro
       
         - P/ buscar em todos os arquivos em todos os subdiretórios
         grep -R <textoaprocurar> *
              --                  -
               |                  |_todos arquivos
      todos os subdiretórios

         - P/ buscar em vários arquivos
         grep <texto> <arquivo>*

         - P/ buscar de forma invertida
         grep -v <texto> <arquivo>


       - SED:
         - P/ trocar minúsculo p/ maiúsculo
           ls -lah | sed "s/teste/TROCADO/g"
                          -               -
                          |               |
                comando igual do vi    procurar todas as ocorrências

       PROCURAR: mailgraph (na Internet)

         - P/ utilizar com vários arquivos
           sed "s/teste/TESTE/g" te
                                 --
                                  |_arquivos

         | - em expressões regulares tem a função de "ou"
           texto1 | texto2
                  -
                  |_ou

         DICA: utilizado também p/ fazer filtros de SPAM

         - P/ filtrar p/ um arquivo é só utilizar o > <arquivo>
                                                    -
                                                    |
                                        redireciona p/ um arquivo


  1.11:
       - SISTEMA DE ARQUIVOS (pág. 73)

         / - diretório do root
         |_ /bin - comandos do toor e usuários
         |_ /boot - arquivos de inicialização (Kernel)
         |_ /dev - diretório de dispositivos (dmesp | more)
         |_ /etc - diretório de arquivos de configuração
         |_ /home - diretório de usuários
         |_ /lib - diretório de bibliotecas compartilhados e módulos
         |         (/lib/modules)
         |_ /mnt - diretório de montagem de dispositivos como CD-ROM

       PROCURAR: rdesktop (acessa o Terminal Services do Win2KServer)
            (www.rdesktop.org)

         |_ /opt - instalação de programas (igual a "Arquivos de
         |                                  Programas")
         |_ /proc - sistemas de arquivos de Kernel
                    Contém todas as informações do micro
                    Exemplos:
                             cat /proc/cpuinfo
                             ps auxw | more
                             cd PID -> cd 436
                             cat environ
                                 -------
                                    |_variáveis do processo escolhido
                             cd fd
                             ls

                             cat /proc/filesystems

       DICA: modprobe <módulo>: carrega módulos no Kernel
             (Ex.: modprobe vfat)
             lsmod: lista os módulos carregados

                             cat /proc/interrupts: interrupções

                             kcore: arquivo de memória do Kernel
                             (NUNCA usar o cat pois o micro trava)

             Arquivos core: são arquivos de erro de execução de
                            programas que são gerados da seguinte
                            maneira:
                                    core.PID (PID=nº do processo)


                             cat /proc/partitions: partições
                             cat /proc/swaps: partições swap
                             cat /proc/uptime: tempo que a máquina
                                               está ligada. P/ ver
                                               de forma "entendível"
                                               use o comando:
         |                                     uptime (similar ao
         |                                     medidor de recursos no
         |                                     windows)
         |
         |_ /root - diretório home do root
         |_ /sbin - contém arquivos binários usados pelo root
         |_ /tmp - arquivos temporários que, se forem apagados, não
         |         tem importância. Em outros UNIX esse diretório é
         |         apagado a cada boot
         |_ /usr - Unix Resource - programas de UNIX
         |         -    -
         |_ /var - informações variáveis (logs, cache de proxy, spool)


         - which: mostra o local de onde está um programa na variável
                  PATH
                  which ls

         - echo $PATH - mostra o PATH

         - find: busca informações no HD (demora um poco!)
                 find <diretório> <argumento> <arquivo>
                 find / -name startx
                 find . -name startx
                      =
                      |_ a partir do diretório que você está em diante

         NOTA: ver argumentos no man: man find

         SUGESTÃO: colocar entre aspas o que você quer achar


         - slocate: pesquisa em um banco de dados (é bem mais rápido)
                    slocate <arquivo>

         DICA: p/ saber qto. tempo o comando demora para executar use:
               time <comando>


         - P/ gerar o banco de dados:
              updatedb -v

         DICA: p/ gerar um arquivo de 0byte, use:
               touch <arquivo>

         - Diretório de banco de dados de slocate:
           /var/lib/slocate
         Arquivo: slocate.db

         DICA: p/ ler algo em arquivos binários, use:
               strings <arquivo>

         - fdisk: particiona o HD

         - P/ ver as partições use:
           dmesg | grep hda

           hda1 hda2 hda3 hda4 <hda5 hda6 ...>
                                -------------
                                      |
                             partições extendidas


                          ou


            fdisk -l

            Device Boot Start End Blocks Id System
                                         (*)
                                          |
                                 cada nº significa um
                                 tipo de patição. Ex:
                                 83-Linux, 82-Swap,
                                 b-Windows

            fdisk <identificação do HD>
            fdisk /dev/hda

            Comandos:
            p - lista as partições
            m - help
            d - deletar partições
            n - adiciona partições
            l - lista todos os tipos de partições que podem ser
                criadas
            w - grava as alterações e sai
            q - sai sem gravar as alterações

            Sequência p/ a criação de uma partição:
            n <enter>
            selecionar entre primáriae estendida (p ou e)
          
         - free: exibe informações sobre a memória
                 No Linux você pode:
                 - memória virtual: até 18 Gb
                 - partição de swap: até 2 Gb (Não fragmenta!)

         IMPORTANTE: O Linux não fragmenta os arquivos
         ==========

         DICAS p/ a instalação do Linux:
                                                     
         /boot: 100 Mb (primária)                     
         /    :   2 Gb (partição de sistema)           --+
         /usr :   3 Gb (partição de sistema)             |
                                                         |
         swap : até 128 Mb usar o dobro ou               |
                se acima de 128 Mb usar 128 Mb           |-(extendida)
                                                         |
         /home:  20 Gb (p/ um servidor de arquivos)      |
         /tmp :   1 Gb                                   |
         /var :  10 Gb (por causa dos logs)            --+


         PROCURAR: Swap-HOWTO (na Internet)

         - mkfs: formata as partições ou disquetes
                 mkfs /dev/fd0
                      --------
                         |
                      disquete


         NOTA: O Linux tem backup da FAT a cada x blocos que varia
               de dispositivo p/ dispositivo

         DICA: mtools:comandos similares aos do DOS.
               No site da Red Hat há uma tabela sobre isso:
               comando no Linux  --->  comando no DOS

        P/ ver uma lista dos tipos de formatação:
           mksfs TAB, TAB

        P/ formatar em um tipo específico:
           mkfs -t <formato> <dispositivo>
           mkfs -t ext3 /dev/fd0


        - mount: monta dispositivos
                 mount <dispositivo> <localondevaimontar>
                 mount /dev/fd0 /mnt/floopy

        P/ verificar o que está montado:
           mount

        IMOPORTANTE: qdo. copiamos algo p/ um disquete a cópia REAL
                     dos arquivos só ocorre qdo. desmontamos o mesmo

        P/ desmontar um dispositivo:
           unmount <dispositivo>
           unmount /mnt/floopy

           NOTA: Se você estiver acessando o dispositivo montado e
                 tentar desmontá-lo, você não vai conseguir!
                 Saia do dispositivo ANTES!

           DICA: Arquivo responsável pelas montagens:
                 /etc/fstab. Por isso que se digitarmos:
                 mount /dev/fd0 ele (o Linux) monta automaticamente
                 em /mnt/floopy

                 Dispositivos
                 Porta paralela: /dev/parport0
                 USB           : /dev/usb<dispositivo>

                 Quando você tentar montarum dispositivo e ocorrer
                 um erro e você não errou o comando, reze, pois há
                 grandes chances do dispositivo estar corrompido

        P/ montar em modo somente-leitura
           mount -o ro /dev/fd0  /mnt/foopy


        FERRAMENTAS DE RECUPERAÇÃO
        =========== == ===========
        - fsck: similar ao scandisk
                fsck <dispositivo>
                fsck /dev/fd0
                fsck -t ext2 /dev/fd0
                e2fsck -b 8193 <dispositivo>

        IMPORTANTE: p/ corromper o disquete
        ==========
                   dd if =/dev/random of=/dev/fd0 count=5
                   dd if =/dev/null of=/dev/fd0 count=5

        DICA: VFS (procurar sobre isso!)

        - VFS --> ext3 --> /home

          Diferenças
                  __                 ___________________
          ext3      |               |     |             |
          reiserts  |_ Journaling ->| 10% |    90%      |
          xfs       |               |_____|_____________|
          jfs     __|  registra todas as operações realizadas

          ext3=ext2 com Journaling ativado e corrompe muito

**********************************************************************

13/09/03

  1.13:
       - QUOTAS DE DISCO (pág. 607)
         ====== == =====

       DICA: p/  converter arquivos de texto do DOs p/ o Linux, use o
             programa DOS2UNIX

       Site: www.netfilter.org (firewall do Linux)
             HOWTO, Packet filtering HOWTO

       Arquivo: cat .etc.fstab

       2 opções de quotas
         - por usuário (individual)
         - por grupo (não recomendado, por ser mais limitado)

       P/ criar quotas é recomendado acessae o level 1 (modo de
          manutenção), usando:
                              init 1 <enter>

       Nota: fazendo isso, o micro fica monousuário!
                                        ===========
       P/ criar quotas:
                       vi /etc/fstab
       Inserir uma das opcões abaixo após o parâmetro "default":
                       - por usuário: ,usrquota
                       - por grupo  : ,grpquota
                       - ou ambos   : ,usrquota,grpquota

       IMPORTANTE: se for ativar os 2 tipos, fazer em partições
       diferentes

       P/ preparar o suporte à quotas:
          mount -o remount, rw /
                               -
                               |_local que você quer remontar

       P/ criar o bando de dados de quotas:
          touch aquota.user
          quotacheck -uv /

       Nota: uma vez por semana ele roda o quotacheck p/ verificar o
             sistema de arquivos


       P/ ATIVAR o sistema de quotas:
          quotaon /
                  |_local p/ ativar as quotas

       P/ gerar relatórios de quotas:
          repquota -uva | more
            usuário_|||
                     ||_todos os sistemas de arquivos
                  verbose

       P/ reiniciar o micro:
          init 6

       P/ confirmar:
          mount
          repquota -uva


       P/ criar uma quota p/ um usuário:
          edquota <usuário>
          edquota jonathan (abre no vi. p/ abrir em outro editor ler
                            "man edquota")
          - Prestar atenção no UID do usuário
          - Blocks = espaço que o usuário está utilizando atualmente
          - Cada bloco = 1024 Kb

       - Diferença entre SOFT e HARD

         SOFT = 5 Mb (se estourar):
                                   alerta o usuário
                                   informa um tempo p/ liberar espaço:
                                   7 dias (grace time)

         HARD = 6 Mb (SOFT+limite - 1 Mb):
                                          se estourar dentro do tempo
                                          do usuário é bloqueado para
                                          gravar mais dados até ele
                                          liberar espaço abaixo da
                                          quota SOFT

         Nota: os valores de SOFT e HARD são em Blocks

       - inodes: qtde. de arquivos que o usuário pode criar


       - SOFT e HARD (depois do inodes): não mexer
         0 = tamanho ilimitado


       - P/ verificar a quota do usuário
            quota <usuário>
            quota jonathan

       Nota: p/ exibir as informações o usuário precisa ter algum
             arquivo criado (estar ocupando algum espaço)

       - P/ "encher"a quota:
            cp /usr/sbin/*.
                          |_diretório autal (/home/jonathan)

       DICA: aplicar quota p/ e-mail:
             /var/spool/mail/<usuário> (o /var tem que estar partici-
                                        onando separadamente!)

             NÃO RECOMENDADO! pois o /var é usado também p impressão

             O recomendado é particionar tudo! (é mais trabalhoso,
             mas você tem mais flexibilidade. Ex: - você poderia
             definir quotas diferentes p/ cada serviço (arquivos=10Mb
             e e-mail=5Mb)

       IMPORTANTE: Qdo. a quota exceder o limite, ao digitar quota
                   aparecerá um * em Blocks. P/ apagar: rm -f*

       P/ editar o Grace Time:
          edquota -u -t


       P/ aplicar quota p/ muitos usuários:
          www.tldp.org/HOWTO/quota-4.html ou:
          edquota -p bob `avk -f: `$3 > 499 (print $1) /etc/passwd ou
          ainda: setquota

       Procurar: cmatrix.sh


  1.14:
       - PERMISSÕES DE ARQUIVOS E DIRETÓRIOS

       Quem pode definir permissões:
         - dono do arquivo
         - grupo do arquivo
         - regra geral (outros)

       Opções:
          _                             _
         | r - leitura  d - diretório<-| r - listar (4)
arquivos-| w - gravação                | w - criar/apagar arquivos(2)
         |_x - execução                |_x - entrar no diretório (1)

       Disposição:

       Tipo <-_ _ _ _       _ _ _      _ _ _
                 |            |          |
               dono         grupo    regra geral(outros)


       - chmod: alterna permissões

       P/ alterar:
                  chmod u=rwx <arquivo>
                        |_usuário (dono do arquivo)
                  chmod u=rwx g=rwx o=r <arquivo>
                  chmod u+w <arquivo>
                        ---
                         |_ adiciona a permissão independentemente das
                            permissões já existentes
                  chmod u-w <arquivo>: idem acima, porém retira a
                                       permissão

       - Parâmetros:
         ========== p/ arquivos no chmod.
                    u - usuário
                    g - grupo
                    o - outros
                    a - todos os usuários

       - Permissão octal:
                         4 = leitura      0 = tira permissão
                         2 = escrita
                         1 = execução     * permissão padrão: 644

         chmod 4722 <arquivo>
     diretório_||||_posição 3 = outros: permissão escrita
                ||__posição 2 = grupo: permissão escrita
                |___posição 1 = usuário: soma das permissões (4+2+1)
                                        p/ usuário

       - chmod -R <parâmetros> <arquivo> <arquivo>:

         altera as permissões de forma recursiva. Ex:
         chmod -R 640 /var/spool/mail/michel /
                                             |
                                          CUIDADO!
                                          =======
       - chown: Altera o dono do arquivo:
                chown <usuário> <arquivo>

       - chgrp: Altera o grupo do arquivo:
                chgrp <grupo> <arquivo>

         Trocar os 2 ao mesmo tempo:
         chown <usuário>.<grupo> <arquivo>

       - umask: Define o padrão de permissões
                umask - 0022
                        ||||_outros
                        |||__grupo
                        ||___usuário
                        |____diretório
                 (isso é uma forma invertida!)
       
         Procurar sobre issu: o porque é ao contrário

         umask <permissão em modo reverso>

       - BITS SUID, SGID e STICK BIT

         Permissões especiais: 0644
                               |_é isso!

         (1) t-sticky bit: somente o dono ou o root pode apagar (Hmp)
         (4) s-sUID bit: tem que ter o x antes. Acessa arquivos de
                         sistemas como root (internamente)
         (2) S-sGID bit: idem anterior, mas p/ grupo

**********************************************************************

20/09/03

       - SU (Sudo - pág 576)
         Dá mais "poder" p/ um usuário realizar tarefas
         administrativas.

         Por exemplo:
         - troca de senha
         - shutdown
         - criar usuários
         - backup

         more /etc/sudoers

         IMPORTANTE: Nunca editar este arquivo com o vi.
                     P/ isso utilize o editor visudo. Esse editor faz
                     uma checagem da sintaxe  ------
                   
       - User_Alias:
                    User_Alias PWSDMIN=usuário,<usuário>,...

       - Cmnd_Alias:
                    Cmnd_Alias PW=/usr/bin/passwd [A-z]*,!/usr/bin/
                                                  ------ -
                                                    |    |_negar
                                                  regex
                    passwd root,!/usr/bin/passwd diretor
     
                    PWADMIN ALL = PW               ou
                             |_todos os hosts

                  <usuário> ALL = <comando>

       P/ gravar e sair:
                        :wq

       Logado como um usuário digite:
                                     sudo passwd <usuário>

       LOGs:
            - Como root, digite:
                                tail -f /var/log/secure

            DICA: vlock -a: trava todas os terminais
                  w: lista as sessões
                  procurar: cobraHack, na Internet

            CUIDADO!
            Não liberar um comando sem um parâmetro

            Por exemplo:
            <usuário> ALL = /bin/cat

            Com isso o usuário consiguiria executar o comando cat em
            arquivos como o /etc/shadown, que é o arquivo de senhas


  1.15:
       - FAZENDO BACKUP (pág. 619)

         Do que fazer backup?
            - /home (usuários)
            - /etc  (configurações)
            - /var  (logs, e-mails)

         Mídias:
            - DAT (demorado)
            - DLT (tem um chip p/ cabeçalho)
            - SLR

         Dica: Norma ISO 15408: na Internet

       - Métodos:

            D    S    T    Q    Q    S    S
                                             FULL (tudo)
                                             DIF. (ver 1)
                                             INC. (ver 2)

       * 1) /dados = 5 Gb
            Se aumentar ou diminuir ele grava arquivos apenas o que
            mudou. Por exemplo:
                                        _
            Dom: /dados = 5 Gb    <--    |
                                 ___|    |
            Seg: /dados = +500 Mb <--    |-TOTAL = 5,9 Gb
                                    |    |
            Ter: /dados = +400 Mb___|   _|

       * 2) Realiza backup só do que foi alterado no dia.


       Sugestão: ARCServer


       P/ montar uma iso:
          mount -o loop -t iso9660 / arquivo/imagem.iso /mnt/cdrom
                 |
               opções

       P/ copiar um cd p/ uma iso:
          dd if=/dev/cdrom  of=conectiva.iso


       - TAR: Não é um copactador. Elé é um empacotador(pág. 626)

       P/ empacotar:
          tar -cvf backup.tar /home /etc
  arquivo novo_||| ---------- ----------
                ||     |_arquivo    |_o que você quer empacotar
                ||_nome do arquivo
                |__verbose

       Descobrir o tipo do arquivo:
          file <arquivo>

       P/ desempacotar:
          tar -xvf <arquivo>
       extrair_|

       P/ listar o conteúdo do arquivo.tar
          tar -tvf <arquivo>

       DICA: SEMPRE gerar uma assinatura
             md5sum <arquivo>.tar > <arquivo>.tar.md5

       P/ copiar p/ um micro remoto:
          scp backup.tar root@IP:/tmp
       
       DICA: gerar assinaturas de logs (principalmente em caso de
             invasão)

       P/ descompactar p/ um diretório específico:
          tar -xvf <arquivo> -C <diretório>

       P/ compactar:
          gzip backup.tar  ou   bzip2 -vv backup.tar

       P/ descompactar:
          gunzip backup.tar.gz  ou  bunzip2 -vv backup.tar.bz2

       P/ desempacotar e descompactar:
          tar -jxf backup.tar.bz2
         bzip<-| ou z=gzip

       DICA: P/ ver o processamento: top

       P/ ver os 2 comandos ao mesmo tempo:
          tar -cf - /home/etc | bzip2 > <arquivo>.tar.bz2
                  |_joga saída p/ a tela

       P/ fazer o contrário:
          bzip -cd <arquivo>.tar.bz2 | tar -xvf -
                                                |_saída p/ a tela



  1.16:
       - PACOTES (RPM) (pág. 643)
         ======= =====

         Gerencia pacotes:
       
       P/ listar pacotes instalados:
          rpm -qa
         query_||_all

       P/ obter informações de um pacote:
          rpm -qil <pacotes>
    information_||_ lista de forma longa

       P/ saber se um programa está instalado:
          rpm -q <programa>
                ou
          rpm -qa | grep <programa>

       P/ saber informações sobre um pacote não instalado:
          rpm -qilp <pacote>
                  |_pacote

       P/ instalar um pacote:
          rpm -ivh <pacote>
      instalar_|||_hash (barra de progresso)
                |__verbose
                   (se acrescentar +1 v ele mostra todo processo)

       P/ remover um pacote:
          rpm -e <pacote>

       Procurar: cmatrix em www.asty.org/cmatrix

       P/ consultar um pacote:
          rpm -qa | grep -i mysql
                         --
                          |_filtra independentemente de
                            maiúscula / minúscula

       P/ remover pacotes com dependências:
          rpm -e <pacotes>
          Se houver dependências ele irá listá-las. P/ desinstalar as
          dependências use:
          rpm -e <pacote> <pacote> ...        ou
          rpm -e <pacote> --nodeps (QUEBRA DEPENDÊNCIA!)
                                    ====== ============

       P/ consultar quais são as dependências:
          rpm -qR <pacote>

       P/ instalar pacotes com dependências:
          rpm -ivh <pacote> <pacote> ... (não importa a ordem dos
                                          pacotes)

       P/ instalar forçado:
          rpm -ivh <pacote> --force --nodeps

       NOTA: Se você desinstalar quebrando uma dependência, basta
             instalá-lo novamente p/ voltar a funcionar

       FTP no Michel: 200.136.14.164
             usuário: anonymous
               senha: guest@

       P/ atualizar um pacote:
               ||_ upgrade (muda a versão)
               |__update (não muda a versão)

          rpm -Uvh <pacote>
          ftp://
            |
     Site: (*) ftp.freshrpms.net
          ftp://apt.freshrpms.net (apt do Debian)

       Após instalar o apt, configure-o:
          vi /etc/apt/apt.conf
          - adicionar o proy: http://www1.recad.usp.br: 80

       P/ atualizar os pacotes:
          apt-get update

       P/ instalar um pacote:
          apt-get install <pacote>

       P/ atualizar todo o sistema:
          apt-get upgrade

       LER: man apt-get
       Site: www.dextra.com.br/opensource/howto/apt.htm

       Diretório de download do apt-get:
          /var/cache/apt/archives

              www
               |
       Sites: (*)rpmfind.org (rpm)
              (*)freshmeat.net (rpm, tar.gz)
              (*)iblio.org.org (rpm, tar.gz, documentos) -> um dos
              maiores depósitos de programas p/ Linux

*********************************************************************

27/09/03

  1.17:
       USANDO RED HAT NETWORK (pág. 403)

       É uma rede onde o Rad Hat informa atualizações sobre todos os
       softwares do sistema de forma personalizada

       Alternativas:
                    - autoupdate

       P/ configurar:
       No modo gráfico abra um terminal e digite:
          up2date --configure

          NOTA: se não acontecer nada, feche o terminal
          ====

       P/ abrir o assistente de atualização:
          num terminal: up2date (pág. 412)

       DICA: somente instalar os pacotes que realmente você irá usar!


  1.18:
       CONFIGURAÇÃO DE HARDWARE

       P/ teclado:
       Kbdconfig

       DICA: recomendado: us-acentos, br-abnt, br-abnt2

       P/ mouse:
       mouseconfig

          COM1 = ttyS0
          COM2 = ttyS1
          COM3 = ttyS2
          COM4 = ttyS3
       
       DICA: o 3º botão do mouse (o do meio) tem a função de colar em
               um terminal no modo gráfico

       P/ ativar o mouse no console:
          service gpm <opção>

             Opções:
                    start  = liga
                    stop   = desliga
                    status = exibe o status

       P/ data e hora:

          Temos 2 datas e horas:
                - a da BIOS
                - a do sistema

       P/ ver a data e hora do sistema:
          hwclock

       P/ ver a data e hora do sistema:
          clock

       P/ comparar os 2 relógios:
          hwclock;clock

       PROCURAR: atualizações da Conectiva p/ o horário de verão
       ========

       P/ configurar a data e hora do sistema
          date -s 09/11/2003  <-- p/ data
                  |   |   |
                 mês dia ano

          date -s 12:16       <--p/ hora

       P/ configurar a data e hora da BIOS p/ o sistema:
          hwclock --hcttosys

       P/ configurar a data e hora da BIOS:
          hwclock --set --date 09/11/2003  <-- p/ data
                               |   |   |
                              mês dia ano

          hwclock --set --date 12:15       <-- p/ hora

       P/ dispositivos Plug'n Play:
                       ===========

          Nas distribuições mais antigas há 2 comandos:
              isapnp
              pnpdump

          Nas distribuições atuais:
              Kudzu

              Nota: se não houver nenhum dispositivo novo, ele não
              ====  mostrará nada!
                             ====


  1.19:
       INTERFACE GRÁFICA (www.xfree86.org)

       Recomendação: Faça backup do arquivo de configuração antes de
                     começar a mexer!

          mkdir /backup
          cp /etc/X11/XF86Config /backup
          md5sum /etc/X11/XF86Config /backup/XF86Config


       Diretório do X11:
          /etc/X11

       Ferramentas de configuração:
          xf89cfg (somente no Conectiva)
          xf89config (no Red Hat)

          - Mouse: /dev/mouse (opção1)
            P/ descobrir qual o tipo de mouse:
               ps auxw | grep gpm
               mensagem: gpm -t ms
                                |
                            Microsoft

            P/ mouse c/ scrool: "IMPS/2" (dentro do arquivo 
            XF86config)

          - Teclado: 4
                    - Mapeamento: 3 (U.S. English w/deodkeys)
                    - XKB: n

          - Monitor: 6 (frequências recomendadas: 60-72 Hz)
                     |_Horizontal

                     2 (50-90 Hz)
                     |_Vertical

                     digite uma descrição p/ o monitor: Monitor


          - Placa de vídeo: y (p/ olhar o database) - (opção 604)

            p/ descobrir qual o tipo da placa:
               lspci -v

               driver padrão: VESA driver (generic) = 696
               memória: 8 Mb = 8192K (opção 6-Other)

          - Resolução:

            Recomendado usar 16-bit

            Paleta de cores: 4

          Gravar: y

          DICAS: fontes FreeType são livres (Linux) www.freetype.org
                 fontes TrueType são da Microsoft

                 Servidor de fontes XFS

                 Manual da placa de vídeo:
                                          man <nome da placa>
                   
          P/ rodar só o servidor X:
                                   x


          P/ mudar a exibição de monitor:
             no micro onde vai ser exibido: xhost +
             no micro onde vai ser executado: DISPLAY = <ip do
             micro onde vai ser exibido >:0
             export DISPLAY

          P/ desfazer
             unset DISPLAY
             DISPLAY =:0
             export DISPLAY

          Consultar o manual do XF86Config:
             man XF86Config


          P/ inicar no ambiente gráfico:
             vi /etc/inittab


             Alterar do modo 3 p/ 5


       GERENCIADOR DE JANELAS:
       =========== == =======

        - AfterStep             - FVWM95
        - Blackbox              - 3DWM
        - Enlightenment         Site: http://themes.freshmeat.net
        - Fluxbox
        - WindowMaker


        P/ personalizar o ambiente gráfico por usuário:
           no diretório home do usuário crie o arquivo:
              vi.wm_style
              digite o nome do gerenciador de janelas

                              ou
                              ==

              vi.xinitrc
                 exec /usr/bin/<nome do programa p/ executar ao entrar
                 no modo gráfico

  1.20:
       CONFIGURANDO DISCAGEM POR MODEM
       ============ ======== === =====

       P/ verificar as portas COM:
          dmesg | grep -i tty

       É recomendado criar uma interface p/ configuração
          vi /etc/sysconfig/network-scripts/ifcfg-ppp0
          vi /etc/sysconfig/network-scripts/chat=ppp0 __
                                                        |
                                                        |
                                               interface com o modem
                                               (usar qdo. ñ funcionar)

          Digitar:

          PHONENUM=
          PERSIST=yes         (rediscagem)
          DEFROUT=yes         (rota padrão)
          ONBOOT=no           (conectar após o boot)
          DIALCMD=ATDT
          INITSTRING=ATZ
          MODEMPORT=/dev/HyS1
          LINESPEED=57600
          DEFABORT=yes        (aborta se ocorrer erro)
          DEVICE=ppp0         (interface que vai ser criada)
       +--PAPNAME=sstone      (usuário@provedor.com.br)
       |  DISCONNECTTIMEOUT=  (p/ desconectar)
       |  RETRYTIMEOUT=       (tempo)
       |  USERCTL=yes         (usuário consegue desconectar)
       |  TIMEOUT=50          (tempo p/ estabelecer a conexão)
       |     
       |
       +--> DICA: /etc/ppp/pap-secrets: é onde fica todos os usuários
                                        que vão se autenticar

                  /etc/ppp/options: configura discagem por demanda

       P/ discar: ifup ppp0
                 ----
                   |_liga dispositivos de rede

       P/ desconectar: ifdown ppp0
                       ------
                          |_desliga dispositivos de rede

       P/ associar um modem à um dispositivo:
          setserial /dev/ttyS15 port 0x320 irq 11
                    ----------- ---------- ------
                         |           |        |
               nome do dispositivo   |       IRC
                                endereço E/S

       DICA: adicionar em: /etc/rc.local

*********************************************************************

04/10/03

   Ainda falta digitar o conteúdo!


*********************************************************************

11/10/03

  2.3:   SERVIÇOS DE INTERNET (pág. 253)

   São serviços onde usuários os utilizam.

   - Telnet: não tem uma camada de segurança.
   - OpenSSH: versão livre do SSH (comercial).
              ---
               |
               +---> Secure Shell

   O que é chave pública/privada:
   - Pública: é gerada pela chave privada.
   - Privada: sem comentários...



   SSH: Secure Shell
        -----------------

     ssh -v <usuário>@<IP>
              --
               |
               +---> modo verbose

     NOTA: se aparecer uma mensagem dizendo que a conexão com o
     servidor "não pode ser estabelecida" pode ser por causa da
     identidade do servidor (fingerprint).
   
     No processo de logon, é exibido:
     - Arquivos da chave privada:
      - /root/.ssh/identity
      - /root/.ssh/id-rsa
      - /root/.ssh/id-dsa
      
      
          Arquivo de configuração: vi /root/.ssh/known_hosts
   
   
          P/ bloquear conexão de usuários:

      DICA: digitando "w" você vê quem está logado. Para derrubar um          
      usuário, verifique o ID do bash do usuário e dê um Kill nele.
      
      - Trocar a chave dele, ou
      - vi /etc/passwd e trocar a shell do usuário p/:
        - /bin/false ou
        - dev/null


      P/ copiar arquivos remotamente:
      scp -v <usuário>@<IP>:<diretório>/<arquivo> <diretóriodestino>
      
      Ex: scp -v teste@200.136.14.165:/home/teste/arquivo.tar .
               -- ----- ------------------------------------- -
               |   |         |               |                |
   verbose <---+   |         |               |                |
       usuário <---+         |               |                |
                      IP <---+               |                |
                       diretório/arquivo <---+                |
                                        diretório destino <---+

      DICA: p/ Windows acessar SSH no Linux: putty ou winscp.
      

       P/ enviar arquivo p/ um micro remoto:
         scp -v <arquivo> <usuário>@<IP>:<diretóriodestino>/<arquivo>


          FTP com SSH: sftp <usuário>@<IP>
           P/ configurar acessar: vi /etc/ssh/sshd_config



          Gravação de Chaves
          ------------------

          P/ o usuário:
            ssh-keygen -t rsa
              vai gravar em:
               - /root/,ssh/id_rsa       (privada)
               - /root/.ssh/id_rsa.pub   (pública)

              NOTA: NÃO digitar nenhuma senha!


          P/ copiá-las para o micro remoto:
            scp .ssh/id_rsa.pub
teste@200.136.14.165:.ssh/authorized_keys2.jonathan
                                          ----+----
                                              |
                        não é necessário  <---+

          IMPORTANTE: o diretório .ssh e o arquivo authorized_keys2
                      tem que ter a seguinte permissão:

                      chmod -R 0700 .ssh


          P/ juntar vários arquivos num só:
            cat * > <arquivo>
                -
                |
                +---> todos os arquivos

          P/ ativar compactação no ssh:
            ssh -C


          Arquivo de configuração do serviço SSH:
            vi /etc/ssh/sshd_config


          DICAS:
            - Chaves de até 52 bits, tem como serem "quebradas" em até
              1 ano, considerando o poder computacional de hoje
              (2003).

            - Chaves acima de 52 bits já demorariam em torno de 10
              anos.




        XINETD (pág. 262)
        -----------------

          P/ ver as portas:
            more /etc/services


          Inicialização de serviços por demanda.

          Arquivo de configuração:
            vi /etc/xinetd.conf

          Diretório dos serviços:
            /etc/xinetd.d

            Nesse diretório ficam os arquivos de configuração dos
            serviços.

          P/ reiniciar o xinetd:
            service xinetd restart

          P/ ver as portas que estão em LISTEN:
            netstat -na | more

          P/ ver o log de inicialização:
            more /var/log/messages

          P/ descobrir a porta do serviço:
            grep chargen /etc/services



  2.4.   DNS (pág. 271)
         Traduz um nome para um IP.

         Arquivo de hosts:
           more /etc/hosts

         Domínios TOP Levels:

                              (.)
                               |
          +--------------------+-----------------------+
          |       |      |      |      |       |       |
         com     edu     br     ar     uk     mil     gov
                         |
                       FAPESP
                         |
             +-----------+---------------+
             |      |      |      |      |
            eti    com    edu    org    ind
                    |
           200.206.142.4 (Center Cursos)
                    |
               Provedor (www)
                    |
                    +---> FQDN

         P/ configurar:
           vi /etc/nsswitch.conf (configura os hosts)
           vi /etc/resolv.conf (que vai ser o servidor DNS)

           DICA: site do CIRP: www.linorg.cirp.usp.br.

           Formato do prompt: [usuário@micro <diretório>]#


         Programas:
           BIND / BIND-UTILS / CACHING
           ----   ----------   -------
            |         |           |
       servidor DNS   |        arquivos de configuração
                      |
            utilitários de pesquisa


         Arquivos de configuração (ver pág. 277):
           vi /etc/named.conf (ver pág. 278)

         zona . (ponto) ---> named.ca (arquivo dos rootservers)



         P/ criar zonas:

           - Dentro de /var/named, crie o arquivo de zona (ver exemplo
             na pág. 287).

           - Serial: <ano><mês><dia><seq>

           - Ver pág. 289 p/ ver como criar entradas no arquivo da
             zona.

           - Editar o arquivo /etc/named.conf e incluir as 
             configurações da zona que você criou.

           - Inicie o serviço named:
               service named start

           - P/ verificar se deu certo:
               tail /var/log/messages

               Verificar se a zona que você criou foi carregada com o
               serial que você informou. Ex.:

               zone jonathan.eti.br/IN: loaded serial 2003101100


               Editar o arquivo /etc/resolv.conf incluindo a linha:
                 nameserver 127.0.0.1

               Teste com o ping:
                 ping www.jonathan.eti.br

               Teste com o host:
                 host www.jonathan.eti.br

           DIG (pág. 296)
           --------------

           Faz consultas em DNS.

             dig www.jonathan.eti.br
   

           P/ fazer consultas remotas:
             dig @<IP> <DNS>



         P/ configurar uma zona slave:

           - Editar o arquivo /etc/named.conf

           - Adicionar as informações do slave, conforme pág. 292.

           - Criar o diretório /var/named/sec:
               mkdir /var/named/sec

           - Mudar a permissão deste diretório:
               chown named /var/named/sec

           - Reinicie o serviço named:
               service named restart

           - P/ verificar se deu certo:
               host www.marco.eti.br   e
               ls /var/named/sec ---> tem que ter um arquivo da zona
                                      slave que você configurou.



         P/ configurar o DNS do servidor de e-mails:

           - Edite o arquivo da zona em /var/named, conforme a pág.
             289 (ver MX RECORD e a imagem da pág. 287).

             IMPORTANTE: NÃO ESQUEÇA de alterar o último dígito do
                         serial p/ que o DNS Slave (secundário)
                         "saiba" que uma alteração foi realizada e
                         faça uma nova sincronização.

           - Reinicie o serviço named:
               service named restart

           - P/ verificar se deu certo:
               tail /var/log/messages
               dig jonathan.eti.br MX


         Copiar arquivos de exemplos:
          - /var/named/jonathan.eti.br
          - /etc/named.conf
          - /etc/resolv.conf

*********************************************************************

18/10/03

        Não tivemos aula pois houve a troca do instrutor!
      
*********************************************************************

25/10/03

  Novo Instrutor!

   Nome              : Daniel Constantnov
   Certificações     : MCNE, MCSE, Conectiva (há 2 anos)
   Empresa           : K9 Informática
   Ramo de Atividade : Desenvolvimento Web (MySQL, PHP, HTML)
   Produto           : Riser
   E-mail            : daniel@riser.com.br

  ----- // -----

  Site: www.fuipreso.com / www.fuipresa.com

        Esses sites recebem 90.000 visitas por dia, em média, processa
        todos os e-mails que são solicitados através desses sites e a
        máquina que faz isso tudo é um Celeron 500 MHz!

  ----- // -----

  Para darmos continuidade no curso, o Daniel propôs "montar" um
  provedor para podermos assimilar melhor onde aplicaríamos, na
  prática, o conteúdo do curso.

  O "Nosso Provedor" terá as seguintes características:

  - DNS     - Firewall
  - E-mail  - Proxy / NAT
  - FTP     - WWW
  - Samba   - DHCP
  - NFS     - SSH / Telnet

  Agora vamos estruturar esses serviços:

                         +-----------------+
                         |     Internet    |
                         +--------+--------+                        
                                  |
                         +--------+--------+
                         | Modem Roteador  | ---> SPEEDY (ADSL)
                         +--------+--------+
                                  |
                         +--------+--------+
                         | Placa de Rede 1 | -+
                         +--------+--------+  |
                                  |           |--> | Micro 1 Linux
                                  |           | 
                         +--------+--------+  | 
                         | Placa de Rede 2 | -+ 
                         +--------+--------+  
                                  |
                                  |
                                  |
                                  |
                                  |   +---------+
                                  |---| Micro 2 | --> Linux
                                  |   +---------+
                                  |
                                  |   +---------+
                                  |---| Micro 3 | --> Linux
                                  |   +---------+
                                  |
    +--------+--------+-----------+
    |        |        |
 +-----+  +-----+  +-----+
 |     |  |     |  |     |
 +-----+  +-----+  +-----+
   (Micros com Windows)


  De acordo com o esquema vamos dividir os serviços da seguinte
  maneira:


  Micro   Servicos

    1     Firewall, Proxy (squid) / NAT, SSH / Telnet

    2     DNS 1, E-mail, NFS (à verificar), SSH / Telnet

    3     DNS 2, WWW, FTP, Samba, DHCP, SSH / Telnet


  ----- // -----

  DICA: Livro de TCP/IP: Halting TCP/IP da CISCO.


  2.2:  REDES DE TCP/IP
      
        O protocolo TCP/IP segue o padrão OSI (que anteriormente era
        DOD) sendo constituído pelas camadas a seguir:


        Camada   Descricao
             
  h  +--- 1      FÍSICA: segue padrões como o Ethernet, Token Ring,
  a  |           entre outros.
  r -|
  d  |  
  w  +--- 2      ENLACE:
  a  |
  r  |           Armazena o MAC ADRESS que é composto por 12 dígitos
  e  |           hexadecimais sendo que 6 dígitos identificam o
     |           fabricante e os outros 6 identificam a placa.
     |
     |           A idéia do MAC ADRESS é identificar cada dispositvo
     |           de rede no mundo garantindo a comunicação com
     |           qualquer outro dispositivo pois se houver mais de 1
     |           dispositivo com o mesmo MAC ADRESS, eles jamais se
     |           comunicarão.
     |
     |           Porém, com o passar do tempo, os fabricantes passaram
     |           a utilizar números repetidos em cada país, pois
     |           imaginaram que um dispositivo fabricado na China
     |           jamais chegaria no Brasil. Mas com o contrabando e
     |           as importações, sabemos que na prática isso acaba
     |           ocorrendo.
     |
     |           Todos os dispositivos de rede lêem o endereço FF FF
     |           FF FF FF FF que chamamos de BROADCAST.
     |
     |           DICA: Elaborar um mapeamento de MAC ADRESS da rede.
     |
     |
  s  |    3      REDE:
  o  |
  f  |           Armazena o IP.
  t  |
  w -|
  a  |    4      TRANSPORTE:
  r  |
  e  |           Armazena o protocolo usado para transmitir as
     |           informações como por exemplo:
     |
     |           O protocolo TCP (que "informa" se o pacote foi
     |           recebido ou não).
     |
     |           O protocolo UDP "não informa" se o pacote foi
     |           recebido ou não).
     |
     |
     |    5      SESSÃO:
     |
     |           Armazena onde a sessão de comunicação inicia e
     |           termina. Por exemplo:
     |
     |           Telnet / FTP: a sessão inicia após o LOGIN do
     |           usuário e termina após o LOGOUT.
     |
     |
     |    6      APRESENTAÇÃO:
     |
     |           Faz a conversão de codificação de X bits para XX
     |           bits.
     |
     |
     +--- 7      APLICAÇÃO:

                 Armazena o programa que está executando a
                 camunicação. Por exemplo:

                 Internet Explorer


        IMPORTANTE: As camadas 1 e metade da 2, são controladas por
        ==========  HARDWARE. A outra metade da camada 2 e as demais,
                    são controladas por SOFTWARE.

        ----- // ----

        DICA: Quando tivermos que resolver um problema utilize a regra
              do Jack... Jack o estripador (vamos por partes!).

              "Quebre" o problema em partes e resolva cada uma.
              Na prática, isso ajuda muito!

        ----- // -----

        Quando um dispositivo é conectado em uma rede, ele envia
        um broadcast para "anunciar" para os outros dispositivos,
        que já estão conectados, que ele está ativo. E se isso
        ocorre enquanto há uma transmissão, isso acaba gerando
        uma colisão.



        O padrão Ethernet usa o sistema CSMA/CD para detectar
        colisões que funciona da seguinte maneira:

        Antes de uma placa de rede transmitir qualquer informação ela
        verifica se há algum outro dispositivo (normalmente uma outra
        placa de rede) transmitindo informações.

        Se houver, a placa de rede fica aguardando o término da
        transmissão para começar a transmitir.

        Quando ocorre de 2 ou mais placas de rede (ou outro
        dispositivo) transmitir informações ao mesmo tempo,
        identificamos isso como colisão.



        O padrão Token Ring não tem colisões. Veja:

                           +-----+
                      +->- |  1  | ->-+
                      |    +-----+    |
                      |               |
                   +-----+         +-----+ 
                   |  4  |         |  2  |
                   +-----+         +-----+
                      |               |
                      |    +-----+    |
                      +-<- |  3  | -<-+
                           +-----+

                Exemplo de uma rede Token Ring

        Nesse padrão não há colisão porque o sentido da transmissão
        ocorre num único sentido, porém, o tempo da transmissão é
        muito alto e por isso o sistema CSMA/CD, ainda que com
        colisões é mais vantajoso (pelo tempo da transmissão ser bem
        menor).



        Redes com cabo coaxial:

             +-----+     +-----+     +-----+     +-----+
        --S1-| R1  |--S2-| R2  |--S3-| R3  |--S4-| R4  |--S5-
             +-----+     +-----+     +-----+     +-----+

        Onde:
          S = Segmento
          R = Repetidor

        Então temos:
          5 segmentos (de S1 a S5)
          4 repetidores (de R1 a R4)

        Sendo que:
          1) Quando utilizava-se cabo coaxial fino, cada segmento
             poderia ter, no máximo, 185 m de comprimento e quando
             utilizava-se cabo coaxial grosso o comprimento máximo
             era de 500 m.

          2) Cada segmento podia conectar até 30 micros.

        Por isso diziam que a regra dos 10 Mbits era a dos 5, 4, 3, 2
        e 1, onde são:

        - 5 segmentos com;
        - 4 repetidores sendo;
        - 3 segmentos com micros e;
        - 2 segmentos sem micros formando;
        - 1 rede.



        Redes com cabo Ethernet de 100 Mbits:

             +-----+     +-----+                       
        --S1-| H1  |--S2-| H2  |--S3-                       
             +-----+     +-----+                       

        Onde:
          S = Segmento
          H = Hub    

        Então temos:
          3 segmentos (de S1 a S3)
          2 hubs (de H1 a H2)

        Sendo que:
          1) Os segmentos S1 e S3 poderiam ter, no máximo, 100 m cada.
             Já o segmento S2, que interliga os hubs 1 e 2 poderia
             ter, no méximo, 5 m.

          2) Como cada segmento é ligado a um micro, o limite de
             segmentos é determinado pelo número de portas do hub.




        BRIDGE:

          A bridge tem a função de dividir uma rede. Trabalham na
          camada 2 do protocolo IP, deixando passar broadcasts.


          Vejamos:

                 R1                           R2
           (colisões aqui)              (colisões aqui)
         +-----------------+          +-----------------+
         |                 |          |                 |
          +---+   +---+     +--------+     +---+   +---+
          | A |---| B |-----| BRIDGE |-----| C |---| D |
          +---+   +---+     +--------+     +---+   +---+
            |       |                        |
            +-------+                        |
            | (2a. comunicação)              |
            |                                |
            +--------------------------------+
                    (1a. comunicação)

        Onde:
          R = Rede
          A, B, C, D = Micros

        Então temos:
          2 redes (R1 e R2)
          4 micros (A e B na rede 1 e C e D na rede 2)

        Sendo que:
          1) Quando o micro A tenta se comunicar com o micro C pela
             1a. vez, a bridge verifica em que rede eles estão
             conectados. Se eles estiverem em redes diferentes,
             como mostra o esquema acima, a bridge começa a fazer
             a seguinte tabela:

             Micro   Rede (lado)
               A     Rede 1 (lado esquerdo)
               C     Rede 2 (lado direito)

             Assim, da próxima vez que o micro A quiser se comunicar
             com o micro C, a bridge já conhece o caminho e não
             precisa verificar isso novamente.

          2) Quando o micro A tenta se comunicar com o micro B pela
             1a vez, a bridge faz a mesma verificação para saber em
             que rede eles estão conectados. Como eles estão na mesma
             rede a bridge atualiza sua tabela:

             Micro   Rede (lado)
               A     Rede 1 (lado esquerdo)
               C     Rede 2 (lado direito)
               B     Rede 1 (lado esquerdo)

             Como a bridge mapeia onde estão os micros o número de
             colisões fica isolado em cada rede, ou seja conseguimos
             isolar as colisões da rede 1 para a 2 e vice-versa.




          IMPORTANTE: Cascatear é diferente de empilhar.

            Quando você empilha um hub ou switch, você pode causar um
            gargalo quando muitos micros conectados no hub ou switch A
            se comunicam com o hub ou switch B, pois todos teriam
            apenas 1 cabo para fazer isso ao mesmo tempo.

            Quando você faz o cascateamento de um hub ou switch você
            garante que cada porta de ambos os hubs ou switches se
            comunique diretamente entre si como se fosse 1 equipamento
            só.



        ROTEADOR:

          O roteador também divide uma rede mas trabalham na camada 3
          do protocolo IP, não deixando passar broadcasts.


                 R1                           R2
         +-----------------+          +-----------------+
         |                 |          |                 |
          +---+   +---+     +--------+     +---+   +---+
          | A |---| B |-----| SWITCH |-----| C |---| D |
          +---+   +---+     +--------+     +---+   +---+

        Onde:
          R = Rede
          A, B, C, D = Micros

        Então temos:
          2 redes (R1 e R2)
          4 micros (A e B na rede 1 e C e D na rede 2)



        PROTOCOLOS DE REDE:

          - NetBEUI (inventado pela Microsoft na época do LAN Manager)

            O único requisito para funcionar é que as identificações
            dos micros estejam diferentes.

            Contra-indicado numa rede maior que 5 micros.

            Ele não atravessa roteadores.



          - IPX / SPX (inventado pela Novell)

            Cada rede devia ter um servidor Novell e os nomes que
            identificavam tinham que ser de apenas 8 caracteres
            e nunca podiam repetir.

                   +---+     +---+   
              --+--| N |--+--| N |--+--
                |  +---+  |  +---+  |
                |         |         |
            AABBCCDD  BEBAC0CA  EEFFGGHH

            Onde:
              N = Servidor Novell


            A cada 30 segundos outros 2 protocolos atualizavam as
            informações da rede toda. Eram eles:

            - RIP
            - SAPI

            Isso acabava consumindo grande parte da banda da rede e
            tornou-se inviável.



          - NetBIOS (podemos dizer que ele é um mini-DNS)

            Esseprotocolo pode trabalhar em cima dos seguintes
            protocolos:

            - NetBEUI
            - TCP/IP



          - TCP/IP
          
            Para entendermos seu funcionamento temos que entender
            de base binária e decimal.

            Exemplo de base decimal:

            O número 345:

            Vamos pegar cada algarismo e multiplicar por 10 (por isso
            é que chamamos de base DECIMAL). Veja:
            
            +---+ +---+ +---+
            | 3 | | 4 | | 5 |
            +-+-+ +-+-+ +-+-+
              |     |     |
              |     |     +---> É igual a 5 x 10 (elevado a 0) que é
              |     |           igual a 5. Lembrando que qualquer
              |     |           número elevado a 0 é igual a 1 e não
              |     |           a 0.
              |     |
              |     +---------> É igual a 4 x 10 (elevado a 1) que é
              |                 igual a 40.
              |
              +---------------> É igual a 3 x 10 (elevado a 2) que é
                                igual a 300.



            Exemplo de base binária:

            O número 0101:

            Vamos pegar cada algarismo e multiplicar por 2 (por isso
            é que chamamos de base BINÁRIA). Veja:

            +---+ +---+ +---+ +---+
            | 0 | | 1 | | 0 | | 1 |
            +-+-+ +-+-+ +-+-+ +-+-+
              |     |     |     |
              |     |     |     +---> É igual a 1 x 2 (elevado a 0)
              |     |     |           que é igual a 1.
              |     |     |
              |     |     +---> É igual a 0 x 2 (elevado a 1) que é
              |     |           igual a 0.
              |     |
              |     +---------> É igual a 1 x 2 (elevado a 2 que é
              |                 igual a 4.
              |
              +---------------> É igual a 0 x 2 (elevado a 3) que é
                                igual a 0.

            Agora pegamos todos os resultados (1, 0, 4 e 0) e somamos
            para descobrir que número decimal é este.

            1+0+4+0=5 (o número é 5)!

          

            Um endereço IP é formado por números que obedecem o            
            seguinte formato:

            XXX.XXX.XXX.XXX

            Cada número (XXX) corresponde a 8 bits. Como temos 4           
            números, 4x8=32 (32 bits). Isso foi definido pelas pessoas
            que criaram o IP, pois naquela época (1970), eles
            definiram que seria necessário um número de 32 bits para
            representar qualquer micro no mundo. Algo como:

            10101010.10101010.10101010.10101010
                    |        |        |
                    +--------+--------+
                             |
                          divisões



            Mas como fazemos para representar um número decimal na
            forma binária?
            
            Para ficar mais fácil, vamos desenhar o que chamamos de
            régua binária que representa apenas 8 bits.

            +------------------------------------+
            | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
            +------------------------------------+

            Agora vamos representar alguns números decimais utilizando           
            essa régua:
            
            1º) Vamos pegar o número decimal que queremos representar
            em binário e vamos fazer a seguinte pergunta comparando-o
            a cada número da régua binária (começando da esquerda
            para a direita):
            
               O número X é maior ou igual a este da régua?
               
               Se a resposta for SIM, colocamos o número 1 abaixo do
               número da régua e subtraímos o número da régua do
               número decimal que estamos convertendo e o que sobrar
               passa a ser o número que continuamos a fazer a mesma
               pergunta.
               
               Se a resposta for NÃO, colocamos o número 0 e passamos
               para o próximo número da régua.


            Vejamos na prática:

                        +------------------------------------+
            Número      | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
            decimal     +------------------------------------+
              21           0     0    0    1   0   1   0   1

            
            Explicando passo-a-passo o número 21:

             Pergunta: 21 é maior ou igual a 128? Resposta: Não.

             Pergunta: 21 é maior ou igual a 64?  Resposta: Não.

             Pergunta: 21 é maior ou igual a 32?  Resposta: Não.

             Pergunta: 21 é maior ou igual a 16?  Resposta: Sim,
             então 21-16=5 (sobrou 5).

             Pergunta: 5 é maior ou igual a 8?    Resposta: Não.

             Pergunta: 5 é maior ou igual a 4?    Resposta: Sim,
             então 5-4=1 (sobrou 1).

             Pergunta: 1 é maior ou igual a 2?    Resposta: Não.                       

             Pergunta: 1 é maior ou igual a 1?    Resposta: Sim,
             então 1-1=0 (não sobrou nada).


             Assim, o número 21 representado na forma binária é igual
             a 00010101. Como, normalmente, não consideramos os zeros
             à esquerda, podemos representá-lo assim: 10101.



            Vamos representar mais alguns números:

                        +------------------------------------+
            Número      | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
            decimal     +------------------------------------+
              82           0     1    0    1   0   0   1   0
             143           1     0    0    0   1   1   1   1
             192           1     1    0    0   0   0   0   0



            Agora vamos ver como foram criadas as Classes de endereços
            IPs:
          
             As Classes são a divisão do IP em:
              - Redes
              - Micros
            
             E como os roteadores entendem qual é a parte do IP que se
             refere à redes e qual a parte que se refere aos micros?
          
             Como esses equipamentos trabalham apenas com bits, vamos
             pegar os 32 bits (que formam um IP) novamente.
           
             Os roteadores interpretam da seguinte maneira:

             10101010.10101010.10101010.10101010
             ||||
             ||||                     |  Faixa   |
             ||||       Classes       | (de-até) |
             |||| --------------------+----------+-----------
             0+++--> Classe A  (8/24) |   1-126  | 127.0.0.1
              |||                     |          | (localhost)           
             10++--> Classe B (16/16) |  128-191 |
               ||                     |          |
             110+--> Classe C  (24/8) |  192-223 |
                |                     |          |
             1110--> Classe D         |          |
                                      |          |
             1111--> Classe E         |          |

           
             Ou seja:

              Quando o 1º bit for 0 (zero), significa que:
               - o 1º número do IP são as Redes que vão de 1 até 126.
               - classificamos esses IPs como Classe A.            
               - são formados por 8 bits seguidos de 24 uns (1s).
             
               Exemplo: 12.18.252.23 (IP de Classe A)
                        --
                         |--> Redes

               IMPORTANTE: o IP 127.0.0.1, chamado de localhost foi
               reservado para que fosse possível realizarmos testes no
               próprio micro. Por isso, quando você ouvir falar de
               localhost, significa que alguém está se referindo ao
               próprio micro.


              Quando o 2º bit for 0 (zero), significa que:
               - o 1º e o 2º número do IP são as Redes que vão de
                 128-191.
               - classificamos esses IPs como Classe B.            
               - são formados por 16 bits seguidos de 16 uns (1s).

               Exemplo: 163.122.19.14 (IP de Classe B)
                        -------
                           |--> Redes


              Quando o 3º bit for 0 (zero), significa que:
               - o 1º, o 2º e o 3º número do IP são as Redes que vão
                 de 192-223.
               - classificamos esses IPs como Classe C.
               - são formados por 24 bits seguidos de 8 uns (1s).

               Exemplo: 210.23.0.18 (IP de Classe C)
                        --------
                           |--> Redes


              Quando o 4º bit for 0 (zero), significa que:
               - o 1º, o 2º, o 3º e o 4º número do IP são as Redes que
                 vão de 224-239.
               - classificamos esses IPs como Classe D.


              Quando o 4º bit for 1 (um), significa que:
               - o número do IP são as Redes que vão de 240-254.
               - classificamos esses IPs como Classe E.


            DICA: Nos EUA, quem administra os IPs é uma empresa
            chamada IANA.

          

            As Máscaras de IP:
             Foram criadas para determinar onde seria dividido o IP
             para sabermos que parte representaria as Redes e que
             parte representaria os Micros.

             Ela também é formada por 32 bits:

             IP      : 10101010.10101010.10101010.10101010
             Máscara : 11111111.11111111.00000000.00000000
                       ---+---- ---+----|---+---- ---+----
                          |        |    |   |        |
                         255      255   |   0        0
                                        |
                                 ponto de divisão
           
             Para a Classe A a máscara é: 255. 0 . 0 . 0
             Para a Classe B a máscara é: 255.255. 0 . 0
             Para a Classe C a máscara é: 255.255.255. 0



             A máscara funciona da seguinte maneira:
              Vamos supor que temos uma rede com 30.000 micros.
            
              Qual será o tipo de IP e Máscara que teremos que adotar
              para configurá-los?

              Resposta: Teremos que adotar um IP e Máscara de Classe
                        B, IP: 143.18.0.0,  Máscara: 255.255.0.0, pois
                        teremos 254x254=64.516 endereços
                        disponívies para utilizar.
                      


              Agora vamos supor que esta rede será dividida entre 3
              cidades: São Paulo, Rio de Janeiro e Ribeirão Preto.
              Como podemos separá-las logicamente através do IP?
            
              Resposta: Para SP adotaremos o IP 143.18.1.(1-254),
                        para RJ adotaremos o IP 143.18.2.(1-254),
                        para RP adotaremos o IP 143.18.3.(1-254) e
                        alteramos a Máscara para 255.255.255.0.
                      
                        Assim temos uma rede de Classe B subdividida
                        (chamamos isso de subnet).

                                               
                                               
              E se quisermos subdividir uma rede de Classe C?

              Resposta: Vamos considerar o IP 200.210.52.0 e Máscara
                        255.255.255.128.
                      
                        Vamos representar a máscara na régua binária
                        para entendermos melhor:
                      
                        Como o último número da máscara é 128 sua
                        representação binária está assim:
                      
                            +------------------------------------+
                        ... | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
                            +------------------------------------+
                        ...    1     0    0    0   0   0   0   0
                        -+-
                         |--> representa os 3 primeiros números
                              (255.255.255.)
                      
                        Dessa forma podemos ter os seguinte IPs:
                         IP      : 200.210. 52.(1-254)
                         Máscara : 255.255.255.128
                      
                        Como não podemos mexer na Classe do IP, vamos
                        utilizar um truque:
                      
                        Repare que, na régua binária, temos ainda 7
                        zeros que podemos utilizar para modificar a
                        máscara a nosso favor, criando assim, subredes
                        dentro da Classe C.
                      
                        Então como devemos fazer isso? Simples,
                        acompanhe:
                      
                        Como não podemos diminuir o último número da
                        máscara (128) pois estaríamos mexendo em sua
                        Classe, vamos fazer o contrário, aumentá-lo,
                        da seguinte maneira:
                      
                        Observe que na régua o próximo número ao 128 é
                        o 64. Então basta somá-lo ao 128 (128+64=192).
                      
                        Agora temos um IP de Classe C subdividido em 2
                        redes. Veja:

                        Rede 1 utilizando:
                          IP      : 200.210. 52.(1-254)
                          Máscara : 255.255.255.128

                        Rede 2 utilizando:
                          IP      : 200.210. 52.(1-254)
                          Máscara : 255.255.255.192
                        
                        E o mais interessante é que se precisarmos de
                        mais redes, podemos fazer esse mesmo
                        procedimento até que se esgotem os números da
                        régua.

            DICA: Procurar CIDR na Internet. Exemplo:
                  IP: 200.210.52.0/24
                                  -+-
                                   |--> porque é o número de 1s (uns)
                                        na representação binária que 
                                        estão antes do último número 
                                        do IP. 
                                      
                                      
                                      
            Utilizando IPs numa rede sem acesso à Internet:
          
               IPs inválidos:
               Classe A: 10.0.0.0/8
               Classe B: 172. 16.0.0 - 172. 33.  0.0
               Classe C: 192.168.0.0 - 192.168.254.0
             
               E se quisermos acessar a Internet?
               Resposta: Podemos utilizar:

                         Proxy: O micro X faz a requisição ao proxy e
                                este realiza a busca na Internet e
                                devolve um resultado para o micro X.
                              
                         NAT: O micro X faz a requisição ao NAT e este
                              substitui o IP inválido do micro X pelo
                              IP da conexão com a Internet e ao
                              devolver um resultado destroca o IP.
                            
                              Neste caso é necessário haver um Gateway
                              configurado.
                            
                         Gateway: É o micro que dá acesso à uma outra
                                  rede diferente da que você está
                                  conectado (sempre! Inclusive para a
                                  Internet).
                                
*********************************************************************

01/11/03

  Revisão prática do que vimos na aula passada:


                           +-----------------+
                           |     Internet    |
                           +--------+--------+                        
                                    |
                                    |
                                    |
                                    |
                                    |
                          Conexão com a Internet
                            IP: 200.210.25.17
                                    |
                           +--------+--------+
                           |     Roteador    | --> Firewall
                           +--------+--------+
                                    |
                                  Rede A
                          IP: 200.210.23.128/25
                          Mask: 255.255.255.128
                                    |
                                    |
             +----------------------+----------------------+
             |                      |                      |
             |                      |                      |
          Rede A                 Rede A                 Rede A
             |                      |                      |                     
       +-----+----+           +-----+----+           +-----+----+
       | Roteador |           | Roteador |           | Roteador |
       +-----+----+           +-----+----+           +-----+----+
             |                      |                      |
          Rede B                 Rede C                 Rede D
             |                      |                      |
             |                      |                      |
             |                      |                      |
   +---------+--------+   +---------+--------+   +---------+--------+



  Baseado no esquema acima, responda as seguintes perguntas:
  
  1) Quantas rede temos inicialmente?
     R: 2 redes, sendo:
        - Rede: 200.210.25.17 (que é a conexão com a Internet)
          Classe: C
          Máscara: 255.255.255.0
          
        - Rede: 200.210.23.128/25 (que é a rede interna)
          Classe: C
          Máscara: 255.255.255.128 (por causa do "/25" do IP)
          O que corresponde à METADE de uma Classe C!
        

  2) Quantas redes temos ao todo?
     R: 4 redes (A, B, C e D)
     

  3) E como fazemos para distribuir o IP de nossa rede interna para as 
     4 redes que temos ao todo?
     R: Vamos ter que subdividir esse IP da seguinte maneira:
     
        Vamos pegar, novamente, a régua binária:
        
        O IP está da seguinte maneira:
     
            +------------------------------------+
        ... | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
            +------------------------------------+
        ...    1     0    0    0   0   0   0   0
        -+-
         |--> representa os 3 primeiros números do IP
              (200.210.23.)


        Como precisamos subdividí-lo em 4 (que corresponde a 
        quantidade de redes que temos), quantos bits 
        precisaremos para isso?
        R: Considerando que cada bit pode ter 2 estados (0 e 1), 
           precisaremos de apenas 2 bits. Assim a representação na 
           régua binária ficaria assim:

               +------------------------------------+
           ... | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
               +------------------------------------+
           ...    1  |  0    0 |  0   0   0   0   0   - Rede A
           ...    1  |  0    1 |  0   0   0   0   0   - Rede B
           ...    1  |  1    0 |  0   0   0   0   0   - Rede C
           ...    1  |  1    1 |  0   0   0   0   0   - Rede D
            |  |               |                    |
            |  +---+-----------+----------+---------+
            |      |           |          |
            |  (128+0+0=128)   |   (129-158)   (159)  - Rede A
            |  (128+0+32=160)  |   (161-190)   (191)  - Rede B
            |  (128+64+0=192)  |   (193-222)   (223)  - Rede C
            |  (128+32+64=224) |   (225-254)   (255)  - Rede D
            |                  |
            |     Máscaras     |      IPs
            | 
            +--> representa os 3 primeiros números do IP
                 (200.210.23.)
           

           Explicação: Como não podemos mexer no bit 128 da régua, 
                       pegamos os 2 próximos bits da direita (bits 64 
                       e 32) e deixamos os bits restantes (16, 18, 4, 
                       2 e 1) para formar os IPs da nossa rede 
                       interna. 

                       ----- // -----

                       P/ a Rede A:
                        Os bits 64 e 32 são 0. Então:
                        128+0+0=128.
                        
                        
                        IPs: Pegamos o 128 e somamos o bit 1 
                             (128+1=129). Então nosso primeiro IP que 
                             poderemos utilizar em nossa Rede A 
                             será 200.210.23.129.

                             Mas até que IP eu posso utilizar?
                             R: Basta pegar, novamente, o 128 e somar 
                                todos os bits da direta para a 
                                esquerda até chegar no bit que 
                                antecede o bit 32 (que é o bit que 
                                vamos utilizar, junto com o bit 64, 
                                para dividir nossas 4 redes). Então 
                                fazendo as contas teremos: 
                                128+1+2+4+8+16=159.

                                Logo o nosso último IP da Rede A será 
                                200.210.23.159.
                          
                             Então qual será a faixa de IPs da Rede 
                             A?
                             R: De 200.210.23.129 até 200.210.23.158
                                Porque desconsideramos sempre o 
                                último IP (por que o último é 
                                BROADCAST).
                       
                       ----- // -----

                       P/ a Rede B:
                        O bits 64 é 0 e o bit 32 é 1. Então:
                        128+0+32=160.
                        
                        
                        IPs: Pegamos o 160 e somamos o bit 1 
                             (160+1=161). Então nosso primeiro IP que                        
                             poderemos utilizar em nossa Rede B 
                             será 200.210.23.161.

                             Mas até que IP eu posso utilizar?
                             R: Basta pegar, novamente, o 160 e somar 
                                todos os bits da direta para a 
                                esquerda até chegar no bit que 
                                antecede o bit 32 (que é o bit que 
                                vamos utilizar, junto com o bit 64, 
                                para dividir nossas 4 redes). Então 
                                fazendo as contas teremos: 
                                160+1+2+4+8+16=191.

                                Logo o nosso último IP da Rede B será 
                                200.210.23.191.
                          
                             Então qual será a faixa de IPs da Rede 
                             B?
                             R: De 200.210.23.161 até 200.210.23.190
                                Porque desconsideramos sempre o 
                                último IP (por que o último é 
                                BROADCAST).
                       
                       ----- // -----

                       P/ a Rede C:
                        O bits 64 é 1 e o bit 32 é 0. Então:
                        128+64+0=192.
                        
                        
                        IPs: Pegamos o 192 e somamos o bit 1 
                             (192+1=193). Então nosso primeiro IP que                        
                             poderemos utilizar em nossa Rede C 
                             será 200.210.23.193.

                             Mas até que IP eu posso utilizar?
                             R: Basta pegar, novamente, o 192 e somar 
                                todos os bits da direta para a 
                                esquerda até chegar no bit que 
                                antecede o bit 32 (que é o bit que 
                                vamos utilizar, junto com o bit 64, 
                                para dividir nossas 4 redes). Então 
                                fazendo as contas teremos: 
                                192+1+2+4+8+16=223.

                                Logo o nosso último IP da Rede C será 
                                200.210.23.223.
                          
                             Então qual será a faixa de IPs da Rede 
                             C?
                             R: De 200.210.23.193 até 200.210.23.222
                                Porque desconsideramos sempre o 
                                último IP (por que o último é 
                                BROADCAST).
                       
                       ----- // -----

                       P/ a Rede D:
                        O bits 64 é 1 e o bit 32 é 1. Então:
                        128+64+32=224.
                        
                        
                        IPs: Pegamos o 224 e somamos o bit 1 
                             (224+1=225). Então nosso primeiro IP que                        
                             poderemos utilizar em nossa Rede D 
                             será 200.210.23.225.

                             Mas até que IP eu posso utilizar?
                             R: Basta pegar, novamente, o 224 e somar 
                                todos os bits da direta para a 
                                esquerda até chegar no bit que 
                                antecede o bit 32 (que é o bit que 
                                vamos utilizar, junto com o bit 64, 
                                para dividir nossas 4 redes). Então 
                                fazendo as contas teremos: 
                                224+1+2+4+8+16=255.

                                Logo o nosso último IP da Rede D será 
                                200.210.23.255.
                          
                             Então qual será a faixa de IPs da Rede 
                             D?
                             R: De 200.210.23.225 até 200.210.23.254
                                Porque desconsideramos sempre o 
                                último IP (por que o último é 
                                BROADCAST).

                       ---- // -----
                       
                       Então já sabemos como subdividiremos nossas 4 
                       redes. Ficará assim:
                       
                       Rede A: 200.210.23.129-158
                       Rede B: 200.210.23.161-190
                       Rede C: 200.210.23.193-222
                       Rede D: 200.210.23.225-254
                       

                       Mas e a máscara desses IPs?
                       R: Bom, lembra que precisamos pegar 2 bits a 
                          mais para subdivirmos nosso IP original 
                          (200.210.23.128/25) que tinha a máscara 
                          255.255.255.128?
                          
                          Então... teremos que modificar também a 
                          máscara para cada rede.
                          
                          Você reparou que quando estávamos fazendo a 
                          conta para separar os IPs, nós sempre 
                          pegávamos o número 128 somávamos a 
                          combinação dos 2 bits que pegamos para 
                          subdividir as redes, e o resultado que era 
                          obtido era sempre somado o bit 1 
                          para sabermos o primeiro IP?                          
                          
                          Então... esse resultado que era obtido é a 
                          máscara de cada rede que subdividimos.
                          
                          Então as máscaras (Mask) serão:
                          
                          Rede A: 255.255.255.128
                          Rede B: 255.255.255.160
                          Rede C: 255.255.255.192
                          Rede D: 255.255.255.224
                          
                       E como nós utilizamos 2 bits adicionais devemos 
                       representar os IPs da seguinte forma:

                       Rede A: 200.210.23.129/27
                       Rede B: 200.210.23.161/27
                       Rede C: 200.210.23.193/27
                       Rede D: 200.210.23.225/27
                       
                       Isso significa que ao invés de existir 25 
                       números 1s antes do último número do IP, haverá 
                       27 números 1s (devido aos 2 bits que utilizamos 
                       para realizar a subdivisão).
                       
  
  Agora vamos distribuir esses IPs no esquema apresentado 
  inicialmente:

                           +-----------------+
                           |     Internet    |
                           +--------+--------+                        
                                    |
                                    |
                                    |
                                    |
                                    |
                          Conexão com a Internet
                            IP: 200.210.25.17
                                    |
                           +--------+--------+
                           |     Roteador    | --> Firewall
                           +--------+--------+
                                    |
                                  Rede A
                          IP: 200.210.23.129/27
                          Mask: 255.255.255.128
                                    |
                                    |
             +----------------------+----------------------+
             |                      |                      |
             |                      |                      |
          Rede A                 Rede A                 Rede A
  IP: 200.210.23.130/27  IP: 200.210.23.131/27  IP: 200.210.23.132/27
  Mask: 255.255.255.128  Mask: 255.255.255.128  Mask: 255.255.255.128
             |                      |                      |                     
       +-----+----+           +-----+----+           +-----+----+
       | Roteador |           | Roteador |           | Roteador |
       +-----+----+           +-----+----+           +-----+----+
             |                      |                      |
          Rede B                 Rede C                 Rede D
  IP: 200.210.23.161/27  IP: 200.210.23.193/27  IP: 200.210.23.225/27
  Mask: 255.255.255.160  Mask: 255.255.255.192  Mask: 255.255.255.224
             |                      |                      |
             |                      |                      |
             |                      |                      |
   +---------+--------+   +---------+--------+   +---------+--------+
          IPs:                   IPs:                   IPs:
   200.210.23.(162-190)   200.210.23.(194-222)   200.210.23.(226-254)
   
         Mask:                   Mask:                  Mask:
    255.255.255.160         255.255.255.192        255.255.255.224


  
  
  
  Uma última configuração que ainda falta é definir o Default Gateway 
  de cada rede.
  
  Lembrando que o Gateway é o dispositivo que dá acesso à uma outra 
  rede diferente da que você está conectado (sempre!).
  
  Analisando o esquema podemos deduzir o seguinte:

  
                           +-----------------+
                           |     Internet    |
                           +--------+--------+                        
                                    |
                                    |
                                    |
                                    |
                                    |
                          Conexão com a Internet
                            IP: 200.210.25.17
                                    |
                           +--------+--------+
                           |     Roteador    | --> Firewall
                           +--------+--------+
                                    |
                                  Rede A
                          IP: 200.210.23.129/27
                          Mask: 255.255.255.128
                          Gateway: 200.210.25.17
                                    |
                                    |
             +----------------------+----------------------+
             |                      |                      |
             |                      |                      |
          Rede A                 Rede A                 Rede A
  IP: 200.210.23.130/27  IP: 200.210.23.131/27  IP: 200.210.23.132/27
  Mask: 255.255.255.128  Mask: 255.255.255.128  Mask: 255.255.255.128
             |                      |                      |
             +--------> Gateway: 200.210.23.129 <----------+
             |                      |                      |                     
       +-----+----+           +-----+----+           +-----+----+
       | Roteador |           | Roteador |           | Roteador |
       +-----+----+           +-----+----+           +-----+----+
             |                      |                      |
          Rede B                 Rede C                 Rede D
 IP: 200.210.23.161/27  IP: 200.210.23.193/27   IP: 200.210.23.225/27
 Mask: 255.255.255.160  Mask: 255.255.255.192   Mask: 255.255.255.224
Gateway:200.210.23.130  Gateway:200.210.23.131  Gateway:200.210.23.132
             |                      |                      |
             |                      |                      |
   +---------+--------+   +---------+--------+   +---------+--------+
          IPs:                   IPs:                   IPs:
   200.210.23.(162-190)   200.210.23.(194-222)   200.210.23.(226-254)
   
         Mask:                   Mask:                  Mask:
    255.255.255.160         255.255.255.192        255.255.255.224
  
       Gateway:                Gateway:               Gateway:
     200.210.23.130          200.210.23.131         200.210.23.132
  

  
  --- // -----
    
  Após fazermos essa revisão prática da aula passada, o Daniel citou 
  um exemplo verídico que ocorreu com um provedor que ele prestava 
  manutenção e que precisou subdividir uma classe C de IPs.
    
  ----- // -----
  
  
  
  DHCP (Dynamic Host Configuration Proxy)
  ------------------------------------------
  
  O DHCP é responsável por distribuir endereços IPs para cada 
  dispositivo que se conectar à rede.
  
  Nos roteadores existe uma função chamada DHCP Relay (preciso 
  procurar na Internet sobre isso!).
  
  Além do IP, o DHCP pode enviar também todas as configurações 
  necessárias para que o dispositivo seja configurado corretamente na 
  rede que ele esteja se conectando, como por exemplo:
   - IP (como já dito antes)
   - Máscara
   - Gateway
   - Servidores de DNS
   - Servidores de WINS
   
  ----- // -----
   
  IMPORTANTE: Aula de 08/11/03 vai ser na Biblioteca na Sala 
              Multimídia (à direita) das 09:00 - 14:00 h.
               
  ----- // -----
   
  PING: (ICMP/IP) - Internet Control Management Protocol
  ------------------------------------------------------    
   
  Envia um ping e recebe um pong.
   
  Quando for necessário testar algum dispositivo utilizando ping, 
  sugere-se a seguinte seqüencia:
   
   - ping 127.0.0.1       (localhost)
   - ping 192.168.0.2     (uma máquina na mesma rede)
   - ping 192.168.0.6     (gateway)
   - ping ???.???.???.??? (na outra placa do roteador)
   - ping ???.???.???.??? (no servidor de Internet)
   
  ----- // -----
   
  TRACEROUTE ou TRACERT (no Windows)
  ----------------------------------
   
  É um tipo de ping que se repete automaticamente até 254 vezes.
   
  ----- // -----
   
  ARP
  ---
   
  A tabela ARP dura 5 minutos.
   
  ----- // -----
   
  RESOLUCAO DE NOMES
  ------------------
   
  A medida em que as redes iam crescendo, ficava cada vez mais 
  difícil lembrar de todos os IPs que tínhamos que usar.
  
  Então criam o arquivo HOSTS que continha as seguintes informações:
   
  IP            NOME              APELIDO
  192.168.0.1   jonathan.com.br   jonathan
   
   
  Este arquivo era digitado apenas uma vez em algum micro e copiado 
  para todos os outros micros da rede.
   
  Porém, chegou uma hora em que a quantidade de micros e a velocidade 
  com que as modificações no arquivo HOSTS aconteciam eram tão 
  grandes que seu uso se tornou inviável.
  
  Então criaram um serviço chamado DNS! (ver a seguir)
   
  ----- // -----
   
  DNS - Domain Name System
  ------------------------
   
  O DNS simplesmente traduz um nome para um endereço IP, e só!

  Quando digitamos um endereço de Internet no browser o seguinte 
  procedimento ocorre sem que o usuário perceba:
   
   - vamos supor que o endereço digitado foi www.riser.com.br
   
     Nota: apesar de digitarmos apenas www.riser.com.br, existe um 
           último ponto "." no fim do endereço. então o correto seria:

           www.riser.com.br.
           
           
           Por isso os endereços obedecem a seguinte estrutura:

                           (.)
                            |
           +-----+----+---+-+----+-----+-----+
           |     |    |   |      |     |     |
          com   edu   br  ar     uk   mil   gov ---> Domínios TOP
                      |                              levels
                    FAPESP
                      |
              +-------+-----+------+------+
              |       |      |      |      |
             eti     com    edu    org    ind
                      |
              +-------+--+---------+
              |          |         |
     +--------+---+   netdite   convex
     |        |   |
     |      riser |
     |        |   |
     |        |   +-------+
     |        |           |
     |   +----+------+    |
     |   |    |      |    |---> Zona (domínio)
     |  www  ftp   daniel |
     |                    |
     +--------------------+

   - o browser inicia uma busca de trás para frente sobre esse 
     endereço fazendo as seguintes "perguntas":
     
     Pergunta: . (ponto), onde está o endereço www.riser.com.br.?
     Resposta: Eu não sei. Mas eu sei onde está o br!
     
     Pergunta: br, onde está o endereço www.riser.com.br.?
     Resposta: Eu não sei. Mas eu sei onde está o com!
     
     Pergunta: com, onde está o endereço www.riser.com.br.?
     Resposta: Eu não sei. Mas eu sei onde está o riser!

     Pergunta: riser, onde está o endereço www.riser.com.br.?
     Resposta: Eu sei!. O micro www fica aqui!
     

   - então a solicitação é passada para o micro www, que é onde está 
     hospedado o site que queremos acessar, e esse micro retorna um 
     arquivo HTML para o browser, exibindo o site que digitamos.


  DICA: Caso seja necessário trocar o domínio de provedor, o tempo 
         dessa mudança varia (podendo ser de 7 dias).
         
         
  Há 4 tipos de serviços DNS:
   
   - Master
   - Slave
   - Cache
   - DNS Reverso
   
  ----- // -----
   
  WINS
  ----
   
  É um tipo de DNS para redes Microsoft.
   
  Numa rede ponto-a-ponto, quando os micros são ligados, eles fazem 
  algo como se fosse uma eleição para decidir quem vai ser o 
  MasterBrowser (é o que controla quem está conectado ou não) da 
  rede. O problema é que cada versão do Windows têm 
  maior ou menor relevância sobre isso. A ordem dessa relevância é 
  a seguinte:
   
   1) Windows XP
   2) Windows 2000
   3) Windows NT
   4) Windows ME
   5) Windows 98
   6) Windows 95
     
  Após isso, todos se comunicam normalmente.
   
  E para evitar esse processo é que foi criado o WINS.
   
  Para configurá-lo, você precisa ter um micro que será o Servidor 
  WINS (tem que ser no mínimo do Windows NT para cima).
   
  Também é possível rodarmos os seguintes serviços:

          DNS                  DNS
           |                    |
          WINS                 DHCP
           
    (DNS sobre WINS)     (DNS sobre DHCP)
     

  O motivo de dizermos "Tal serviço sobre TCP/IP" é porque o serviço 
  atua em alguma camda acima da do TCP/IP. Veja:
   
  Camadas
    --+
    7 |
    6 |---> Novel (NCP) / Microsoft (SMB) / Linux (NFS)
    5 |
    --+        Por isso dizemos: NFS sobre TCP/IP.
    4 = TCP
    3 = IP
    2
    1
     
  ----- // -----
   
  SOCKET
  ------
   
  Socket é o conjunto do IP com uma porta de um determinado serviço.
   
  Seria como se seu micro fosse um edifício e as portas fossem os 
  serviços que gostaríamos de acessar. Por exemplo:
   
                          +------+------+
                  www <---|  80  |  21  |---> FTP
                          +------+------+
                  pop <---| 110  |  25  |---> SMTP
                          +------+------+
                  ssh <---|  22  |      |
                          +------+------+
                          |      |      |
                          +------+------+
                          |      |      |
                          +------+------+
                          |      |      |
                          +------+------+
                                IP
                                 
  P/ listar todas as portas no Linux:
    vi /etc/services
     
  DICA: procurar LRP, Knoppix e Kurumin na Internet.
   
  ----- // -----
  
  INSTALAÇÃO DO LINUX
  -------------------
  
  Siga os procedimentos abaixo para instalar o Linux baseado na 
  distribuição RedHat:
  
  - Realize o boot pelo 1o. CD de instalação
  
  - O programa de instalação pergunta se você quer testar o CD antes 
    de iniciar a instalação. Se você tiver certeza de que o CD está 
    funcionando, responda "N" (No).
    
  - A tela de bem-vindo será exibida. Clique em "Next".
  
  - Selecione o idioma do programa de instalação (não é o idioma que o 
    sistema vai ser instalado. isso é mais adiante).
  
  - Selecione o tipo de teclado (US International - p/ habilitar a 
    acentuação).
    
  - Selecione o mouse.
  
  - Selecione o tipo da instalação (Cuidado!)
      - Escolher o tipo "Custom"
    
  - Selecione o particionamento com o "DiskDruid"
      - Mesmo que seu hd já possua uma partição de SWAP, confirme-a 
        selecionando a mesma e informando que ela é um partição de 
        SWAP.
        
      - Crie o "Mount Point" em (/) - EXT3 partição primária)
      
      - Formate as partições
      
  - Selecione instalar o "GRUB"
  
  - Configure a placa de rede
  
  - Configure o nível de segurança que seu sistema terá
      - Escolha "Firewall" - No firewall
      
  - Selecione o idioma do seu sistema (agora sim é o idioma que o 
    sistema vai ser instalado).
    
  - Configure as "Configurações Regionais"
  
  - Digite uma senha para o root (dica: digite uma senha simples e 
    depois que você terminar de configurar tudo, troque-a por uma 
    mais complicada).
    
    Dica para criar uma senha complicada:
      - Elaborar uma frase
      - Pegue as iniciais de cada palavra dessa frase
      - Intercale maiúsculas e minúsculas
      - Use números e símbolos (como @,!,#,$,%,&,?, ...)
    
  - Autenticação
      Antigamente as senhas (/etc/passwd) usavam o Crypto. Depois 
      mudaram para (/etc/shadow) usando o MD5.
      
      - NIS  = Active Directory (Win2000)
      - LDAP = É o padrão
      - Kerberos
      - SMB (Samba)
      
  - Escolha os pacotes para instalação
      A idéia é instalar a menor quantidade de pacotes para que o 
      sistema fique o mais "limpo" possível e somente com os pacotes 
      que utilizamos com maior freqüência. Se precisarmos de algum 
      pacote que não tenha sido instalado nessa etapa, basta instalá-
      lo.
      
      - Tire a parte gráfica
      - Tire som/vídeo
      - Tire os games
      - Deixe a parte de servidor
      - Tire a parte de desenvolvimento
      - Deixe as ferramentas administrativas
      
  - Clique em "Next" e aguarde a instalação.
  
  IMPORTANTE: Quando o programa de instalação perguntar sobre criar um 
              disco de boot, tenha 1 disquete em mãos para isso pois 
              nunca sabemos quando vamos precisar dele.
              
  
  Terminada a instalação, vamos começar a configurá-la:
  
    P/ configurar os serviços que serão executados no boot
      ntsysv
      
    P/ melhorar o desempenho em HDs IDEs
      hdparm /dev/hda -c1 -d1 -m16
      
      P/ verificar o desempenho antes e depois de executar o comando 
      anterior
        bannie
        
   - Configure o GRUB
   
   - Copie o diretório RPMS do CD-ROM para o diretório home do root 
     (/root/RPMS)
     
     - E crie uma listagem de todos os pacotes RPM que foram copiados
       rpm -qpli * > rpms
  
       
  ----- // -----
  
  RECOMENDAÇÕES
    - Realizar uma instalação mínima.
    - Ir adaptando-a de acordo com a função.
    
    
    P/ saber informações de comandos
      rpm -qf <comando> (retona o pacote do comando digitado)
      rpm -qi <pacote>  (retorna informações do pacote digitado)
    
    
    Dentro de /root, crie um diretório "conf" e crie links simbólicos 
    para todos os arquivos de configuração que você alterar. Após 
    terminar de alterar esses arquivos, faça um backup para um 
    disquete. Assim você terá toda a configuração do micro em apenas 1 
    disquete.
    
    
    P/ criar um disco de boot
      uname -r (para descobrirmos a versão do kernel)
      mkbootdisk --device /dev/fd0 <versão do kernel>
    
    
    Verifique no arquivo /etc/inittab
      - ID = 3 (login em modo texto)
      - Trocar o CTRL+ALT+DEL de -r p/ -h


    DICA: Procurar LANSchool (Novell) na Internet
    
    
    Se o micro que você precisa instalar o Linux não realiza o boot 
    pelo CD, você precisará criar um disquete de boot que faça 
    o boot e "passe o controle", após o boot, para o CD-ROM. Para isso 
    você precisa de um programa chamado RAWRITE que geralmente vem 
    junto com as distribuições. Para utilizá-lo siga as instruções 
    abaixo:
    
      - Insira o CD de instalação do Linux no drive
      
      - Dentro do diretório /images do CD, geralmente, há os seguintes 
        arquivos:
        
          boot.img       (realiza o boot normalmente)
          bootnet.img    (realiza o boot pela rede)
          pcmciadd.img   (utilizado em notebooks com drives de 
                         disquetes PCMCIA)
                         
      - P/ criar o disco de boot
          Dentro do diretório /images, digite:
          
          dd -if=boot.img of=/dev/fd0
          
      - P/ criar uma imagem do disquete
          dd -if=/dev/fd0 of=bootjonathan
          
      - P/ montar uma imagem
          mount -o loop bootjonathan /mnt/floppy
          
        Agora podemos criar qualquer arquivo dentro da imagem
        
      - P/ desmontarmos uma imagem
          umount /mnt/floppy
          
      - Agora gravamos a imagem novamente no disquete
          dd if=bootjonathan of=/dev/fd0
 
*********************************************************************

08/11/03

  DICA: Tomar cuidado com as documentações pois nem sempre dão certo!
  
  ----- // -----

  SERVIDOR WEB (WWW - Apache)
  ---------------------------
  
  Vamos verificar os processos (daemon - lê-se dimon) que estão 
  rodando com o seguinte comando:
    ps -ax
    
  Cada processo tem uma finalidade. Veja:
    - init         : processo que controla todos os outros processos
    - [<processo>] : processos do kernel
    - syslog       : processo que faz log de tudo do sistema
    - klog         : processo que faz log de tudo do kernel
    - sshd         : processo que é um "irmão" do telnet
    - crond        : processo que controla tarefas agendadas
    - logrotate    : processo que faz um "rodízio" de logs
    - mingetty     : processo que controla os terminais
  
  ----- // -----
  
  Procedimentos para instalação:
   
  1) Verificar se o APACHE já não está instalado:
       rpm -qa | grep apache
              
       DICA: O nome do pacote do servidor WWW pode variar. O mais 
             usado é APACHE. 
             
             Existe outro servidor WWW, que dizem, que funciona muito 
             mais rápido pois ele trabalha dentro do kernel. É o TUX!
             

      
  2) Se já estiver, pule este passo. Se não estiver instale-o:
       rpm -ivh httpd
       
       AVISO: Aqui o nome do pacote é httpd.


      
  3) Seguindo o padrão que adotamos para centralizar todos os 
     arquivos de configuração do servidor, crie um link do arquivo de 
     configuração para o diretório /root/conf:
       ln -s /etc/httpd/conf/httpd.conf


      
  4) Agora temos que editar esse arquivo
       vi /etc/http/conf/httpd.conf
       
       ou
       
       vi httpd.conf (se você estiver em /root/conf)


     
  5) Verifique e altere (se necessário) os seguintes parâmetros:
  
     NOTA: # = comentários
     
     Section 1: Configuração do Ambiente Global
       ServerRoot "/etc/httpd"
       Timeout    300
       Listen     80

       
     Section 2: Configuração do Servidor Principal
       User apache
       Group apache
       ServerAdmin root@localhost
  ---> ServerName <nomedomicro>
       DocumentRoot "/var/www/html"
       <Directory>                  ---+
            Options FollowSymlinks     |--- Opções de diretórios
            AllowOverride None         |
       </Directory>                 ---+
  ---> DirectoryIndex index.html index.htm
       AccessFileName .htaccess
       TypesConfig /etc/mime.types
       ErrorLog logs/err_log.log
  ---> Alias (pedir exemplo para o Daniel)
  

     Section 3: Configuração dos Sites
       É nesta seção que realizamos as configurações individuais 
       para cada site.
       
     
     
  6) Inicie o serviço
       service httpd start

  ----- // -----
   
  P/ testar:
   
  De um micro da rede abra o browser e digite o IP do micro que você 
  configurou. Por exemplo:
   
  Nos micros do curso testei os seguintes IPs:
    143.107.207.35 - Micro do Daniel
    143.107.207.42 - Meu próprio micro
    143.107.207.39 - Micro do Marcelo
   
  ----- // -----
  
  COMPARTILHANDO DIRETÓRIOS
  -------------------------
  
  Edite o arquivo /etc/exports:
    vi /etc/exports
    
  Adicione os diretórios que você quer comparilhar seguidos dos modos 
  como serão compartilhados. Por exemplo:
    /rh8 (RO)
    ---- ----
     |     |---- Modo de compartilhamento:
     |             (RO) = Read Only (Somente leitura)
   diretório       (RW) = Read Write (Leitura e gravação)
     
  Inicie o serviço PORTMAP e NFS tanto no micro que você compartilhou 
  os diretórios quanto no micro que vai acessá-los.
    service portmap start
    service nfs start
     
  P/ confirmar se forma feitos os compartilhamentos digite:
    showmount -e <IP do micro que contém os diretórios a serem 
                 acesados>
                  
  ----- // -----
   
  DICA: Cartaz do CIRP que está na sala: www.cirp.usp.br/sos
   
  ----- // -----
   
  CONFIGURANDO O DNS
  ------------------
   
  Como já visto e dito antes, o DNS é um serviço que simplesmente 
  traduz nomes em IPs e nada mais.
   
  - Nome do pacote para instalação   : bind
  - Nome do serviço que fica rodando : named
   

  Procedimentos para instalação:
   
  1) Verificar se o BIND já não está instalado:
       rpm -qa | grep bind
              
      
  2) Se já estiver, pule este passo. Se não estiver instale-o:
       rpm -ivh bind...
       
     Para facilitar a configuração deste serviço, instale o Webmin:
       rpm -ivh webmin...
       
       DICA: O arqivo do pacote do Webmin tem o seguinte nome:
             webmin-1.110-1.noarch.rpm
             
             Note a palavra "noarch"! Ela indica que o programa não 
             tem nenhum vínculo com nenhuma distribuição do Linux.
             
      
  3) Para acessar o Webmin abra o browser e digite:
       http://localhost:10000
       
     - Faça login como root
     - Verifique e altere (se necessário) os seguintes parâmetros:
       
       Guia: Services
         - Opção: BIND DNS Servers
         - Escolha a segunda opção porque o BIND não está instalado.
         - Opção: Criar Zona Master
             - Tipo          : Forward
             - Domain name   : jonathan.com.br
             - Master server : 143.107.207.42
             - E-mail        : root@jonathan.com.br
             - Refresh time  : 10800 seg.
             - Expiry time   : 604800 seg.
             
         Com isso você "cai" dentro da zona que você informou que 
         contém vários tipos de registro.
         
         Crie um registro do tipo A (Address):
           - Name    : servidor
           - Address : 143.107.207.42
           
         Crie um registro do tipo CN (Alias):
           - Name     : www
           - RealName : servidor
           
         Configure a placa de rede para pingar localmente para 
         realizarmos os testes:
           - Opção: Networking
           - Opção: Network Configurator
           - Opção: DNS Client
               - Hostname
               - DNS servers: 143.107.207.42
                   Os DNS servers que estavam configurados eram:
                     143.107.200.56
                     143.107.200.45
                     143.107.253.3
               - Resolution order: Hosts, NIS+, DNS
               
  4) Inicie o serviço
       service named start

  ----- // -----
   
  P/ testar:
   
  ping localhost
  ping 143.107.207.42
  ping www.jonathan.com.br
  ping servidor.jonathan.com.br
  
  ----- // -----
  
  IMPORTANTE!
  ----------
  
  A próxima aula (15/11 - feriado!) vai ser no CIRP das 08:30-16:30 h
  
*********************************************************************

15/11/03

   Ainda falta digitar!

*********************************************************************

22/11/03

   SERVIDOR DE ARQUIVOS (SAMBA)
   ----------------------------
   
   Atua a partir da camada 4 para cima no padrão OSI.
   
   A finalidade do SAMBA é compartilhar arquivos do Linux para o 
   Windows e vice-versa.
   
   Os protocolos utilizados para compartilhamento de arquivos nos 
   sistemas operacionais são os seguintes:
   
   FABRICANTE   PROTOCOLO
   Microsoft    SMB
   Linux        NFS
   Novell       NCP
   
   ----- // -----
   
   DICAS:
   
   - O mesmo usuário do SAMBA tem que existir no Linux (isso 
     influencia nas permissões dentro do Linux).
     
   - Os comandos do SAMBA são praticamente iguais aos do Linux, 
     bastando adicionar "smb" antes do comando Linux. Exemplo:
     
     p/ adicionar um usuário no Linux, digitamos "adduser".
     p/ adicionar um usuário no SAMBA, digitamos "smbadduser".
     
     
   ----- // -----
   
   Procedimentos para instalação:
   
   1) Verificar se o SAMBA já não está instalado:
        rpm -qa | grep samba
      
   2) Se já estiver, instalar apenas o SAMBA SWAT:
        rpm -ivh samba-swat...
      
   3) Seguindo o padrão que adotamos para centralizar todos os 
      arquivos de configuração do servidor, crie um link do arquivo de 
      configuração para o diretório /root/conf:
        ln -s /etc/samba/smb.conf
      
   4) Agora temos que habilitar o SAMBA SWAT no xinetd, pois é através 
      dele que ele é iniciado.
        vi /etc/xinet.d/swat
      
      Altere o parâmetro "disable" para "no"
      
      Reinicie o xinetd:
        service xinetd stop
        service xinetd start
      
   5) Realizar a configuração através do SAMBA SWAT (via browser).
      Para isso, siga os passos a seguir:
      
        startx
        abrir o browser e digitar "localhost:901"
        digite o login e senha
        
        DICA: ler a documentação do SAMBA.
        
        ----- // -----

        - opção GLOBALS
        
          após as alterações clicar no botão "Commit Changes" (p/ 
          fazer valer as alterações)
        
          alterar os seguintes parâmetros:
          - workgroup         : AULALINUX (não deve ser igual ao 
                                netbios name)
          
          - netbios name      : SAMBALINUX (não deve ser igual ao 
                                workgroup)
          
          - security          : USER
          - encrypted password: YES (NO p/ Win95 antes do SR2)
          - update encrypted  : YES
          - hosts allow       : (ver na documentação)
          - browse options    : realiza a "eleição" da rede em redes 
                                ponto-a-ponto
                                
          clique no botão "Advanced View"
            talvez seja necessário alterar os parâmetros de UMASK na 
            opção "Security Options"
          
          

        - opção SHARES
        
          escolha a opção "homes" e clique "Choose Share"
          
          alterar os seguintes parâmetros:
            Em "Browse Options"
              - browseable        : YES
              
            clique no botão "Commit Changes"
            digite o nome do compartilhamento
            clique no botão "Create Share"
            
            Em "Base Options"
              - path              : digite o diretório do 
                                    compartilhamento
                                    
              - comment           : digite um comentário p/ o 
                                    compartilhamento
   
   6) Inicie o serviço
        service smb start
        
   7) Adicione os usuários, que irão acessar os arquivos, no Linux não 
      esquecendo de definir uma senha para cada um.
      
   8) Adicione os mesmos usuários no SAMBA da seguinte maneira:
        smbadduser <usuário no Linux>:<usuário no SAMBA>
        
        Exemplos:
        
        smbadduser jonathan:jonathan
        smbadduser jonathan:martelo
        
        E digite a mesma senha do usuário do Linux!
                 -------------
   
   ----- // -----
   
   SERVIDOR PROXY / NAT (SQUID)
   ----------------------------
   
   Um proxy pode atuar de 2 formas:
   

   De dentro de uma rede para fora:

       Rede interna
        (Intranet)
   +-----------------+    SQUID
   |                 |      |
    +---+   +---+     +-----------+     +----------+
    | A |---| B |---->| PROXY/NAT |---->| Internet |
    +---+   +---+     +-----------+     +----------+
 

   ou


   De fora de uma rede para dentro (Proxy reverso):
   
     Rede interna                                         Rede Interna
      (Intranet)                                           (Intranet)
   +-------------+  SQUID                       SQUID     +----------+
   |             |    |                           |       |          |
    +---+ +---+   +--------+   +----------+   +--------+   +---+
    | A |-| B |-->| PROXY/ |-->| Internet |-->| PROXY/ |-->| A |--...
    +---+ +---+   |  NAT   |   +----------+   |  NAT   |   +---+
                  +--------+                  +--------+
                                           |                         |
                                           +-------------------------+
                                                  Proxy Reverso
                                                  
   ----- // -----
   
   Os benefícios de sua utilização são:

     - armazenamento do conteúdo acessado em cache, acelerando o 
       carregamento dos sites.
       
     - conseguir bloquear o acesso por:
         - IP
         - usuário
         - palavras (conteúdo)
         - horário
         - tipo de arquivo
         - tamanho de arquivo
         
         Nota: essas regras são chamadas de ACLS.
         
         Como isso tudo fica arquivado em LOGs, podemos utilizar 
         algumas das seguintes ferramentas para analisá-los:
         
           - SARG
           - SQMGRLOG
           - WEBALIZER
           
     DICA: Eventualmente o SQUID pára de funcionar.
           Quando isso acontecer, pare o SQUID, zere (apague) o cache 
           e inicie-o novamente.
           
   ----- // -----
   
   Procedimentos para instalação:
   
   1) Verificar se o SQUID já não está instalado:
        rpm -qa | grep squid
      
   2) Seguindo o padrão que adotamos para centralizar todos os 
      arquivos de configuração do servidor, crie um link do arquivo de 
      configuração para o diretório /root/conf:
        ln -s /etc/squid/squid.conf

   4) Agora temos que configurar o SQUID:
        vi squid.conf
      
        verificar os seguintes parâmetros:
          - http_port        : 80
          - cache_mem        ; 8 MB
          - maximum_object_size: 4096 MB
          - cache_dir ufs /var/spool/squid 100 16 256
                                           --- -- ---
                        espaço p/ cache <---|  |   |--> subdiretórios
                                               |   
                                           diretórios
          - cache_access_log /var/log/squid/access.log
          - cache_store_log /var/log/squid/store.log
          - cache_swap_log.00, cache_swap_log.01, ...
          - authenticate_program (autenticação)
          
          - ACLS (regras de acesso)
              - acl MinhaRede src 143.107.207.0/24
              - http_access allow MinhaRede
              
          - err_html_text (página de erro personalizada)
   
   DICA: programa p/ utilizar com SNMP: HP OpenView.
   
   5) Inicie o serviço
        service squid start

   ----- // -----
   
   P/ testar:
   
   De um micro da rede que NÃO TENHA acesso à Internet, abra o 
   browser e nas configurações sobre a conexão adicione as 
   informações sobre o servidor proxy que você configurou.
   
   Tente acessar algum site para ver se a conexão funciona.
   
*********************************************************************

29/11/03 (Finalmente a última aula!)

   FIREWALL
   --------
   
   O firewall no Linux já vem dentro do kernel, portanto, não 
   necessitamos instalar nenhum programa que tenha essa função para 
   utilizá-lo.
   
   No entanto, precisamos de algum programa que escreva as regras para 
   o firewaal do Linux. Um desses programas é o iptables.
   
   Existem firewalls que rodam em apenas em 1 disquete. Esse tipo de 
   firewall é conhecido como LRP (Linux Router Project).

   Por ser uma tarefa leve, fica instalado, geralmente junto com 
   o proxy.
   
   O firewall não é um serviço que pode ser iniciado ou parado com o 
   comando service firewall start ou stop.

   ----- // -----
   
   Um pouco de história:
   
     Antigamente os programas que escreviam as regras de firewall no 
     Linux eram:

       - ipfwadm
       - ipchains - versões 5, 6 e 7


     Hoje, os prgoramas são:
    
       - iptables - versões 8 e 9
       - ip6tables
   
    
   Isso pode ser útil quando você precisar pesquisar na Internet 
   sobre firewall, pois vai notar que existem exemplos escritos em 
   todos esses programas citados e ao invés de achar que o ipfwadm 
   seria um programa com uma função diferente do iptables, 
   utilizado hoje, você já sabe que ele tem a mesma função.
    
   Pode ser que esses programas mais antigos ainda sejam utilizados 
   em algum micro que não consiga rodar uma versão atual do Linux, 
   por exemplo.
    
   ----- // -----
    
   DICAS:
    
   1) Quando você estiver instalando o Linux, NÃO ESCOLHA a opção 
      de firewall, pois a instalação cria automaticamente algumas 
      regras que podem, as vezes, atrapalhar algum outro serviço.
      
   2) As regras do firewall podem ser digitadas diretamente no shell 
      entrando imediatamente em ação após o ENTER.
       
      Porém, se precisarmos desligar o micro, elas são apagadas da 
      memória exigindo que sejam digitadas novamente.
       
      Para evitarmos esse trabalho, podemos digitar as regras do 
      firewall em um shell script, gravá-lo em /etc/bin/firewall e 
      colocamos uma referência em /etc/rc.local para que esse arquivo 
      seja executado toda vez que o micro iniciar, ou seja, durante o 
      boot.
       
   3) Procure na Internet arquivos de exemplo do iptables prontos 
      antes de começar a escrever seu próprio arquivo de firewall.
       
      Começe com arquivos simples evitando os que possuem "cadeias"
      (explicado mais adiante).
       
   4) Quando você estiver instalando um servidor, configure todos os 
      outros serviços, como servidor WWW, E-mail, Proxy, SAMBA,
      deixando o firewall SEMPRE por último.

   ----- // -----
    
   Relembrando: O que faz o NAT (Network Translate Address)?

     Como visto na aula do dia 25/10/03, o NAT permite que micros com 
     IPs inválidos tenham acesso à Internet através de um dispositivo 
     que faz NAT que troca o IP inválido do micro pelo IP válido da 
     conexão com a Internet.
      
   ----- // -----
   
   A representação esquemática de um firewall é idêntica a de um 
   proxy. Veja:
   
       Rede interna
        (Intranet)
   +-----------------+
   |                 |
    +---+   +---+     +----------+     +----------+
    | A |---| B |---->| FIREWALL |---->| Internet |
    +---+   +---+     +----------+     +----------+

   ----- // -----
   
   Vamos conhecer os parâmetros para escrevermos as regras do 
   firewall:
   
   iptables       : Como já dito, este é o nome do programa que 
                    escreve as regras do firewall
   
   -t             : É o tipo da regra onde temos as seguinte opções:
     
     nat          : Regra para NAT (nat/dnat), onde temos as 
                    seguintes cadeias (categorias):
       PREROUTING : Antes de entrar no firewall
       POSROUTING : Antes de sair no firewall
       
     filter       : Regra para filtros, onde temos as seguintes 
                    cadeias (categorias):
       INPUT      : São os pacotes que vão entrar
       FORWARD    : São os pacotes que passam pelo firewall
       OUTPUT     : São os pacotes que saem do próprio firewall
     
     mangle       : Regra para marcações de pacotes
     
   -A             : Adiciona regras
   -D             : Deleta   regras
   -L             : Lista    regras
   -F             : Zera     regras
   -P             : Regra padrão
   
   -sport         : Porta de origem (Source port)
   -dport         : Porta de destino (Destiny port)
   
   -p             : É o tipo do protocolo, onde temos:
      tcp         : Protocolo TCP
      udp         : Protocolo UDP
      icmp        : Protocolo ICMP (usado pelo ping)
      
   -s <IP/MASK>   : Origem (Source), onde <IP/MASK> pode ser:
                    - um único IP: 143.107.207.42/32
                                   ou
                    - uma rede   : 143.107.207.0/24
                                   ou
                    - qualquer IP: 0.0.0.0/0

   -d <IP/MASK>   : Destino (Destiny)), onde <IP/MASK> pode ser:
                    - um único IP: 143.107.207.42/32
                                   ou
                    - uma rede   : 143.107.207.0/24
                                   ou
                    - qualquer IP: 0.0.0.0/0
   
   -j             : É a ação que o firewall executará com o pacote, 
                    onde temos:
      DROP        : Descarta o pacote sem avisar
      REJECT      : Descarta o pacote avisando a origem (quem enviou)
      RETURN      : Descarta o pacote e continua analisando as demais 
                    regras
      ACCEPT      : Aceita o pacote
      REDIRECT    : Redireciona o pacote
   
   ----- // -----
   
   Exemplos:
   
   Vamos supor a seguinte situação:
   
   Temos um micro com um IP válido na Internet (vamos supor que esse 
   IP seja 143.107.207.42). Portanto o mesmo tem acesso irrestrito 
   a qualquer conteúdo.

      +-> IP: 143.107.207.42
      |
    +-+-+        +----------+
    | A |------->| Internet |
    +---+        +----------+
       
   Mas surgiu a necessidade de bloquearmos o acesso ao site do UOL 
   (cujo IP vamos supor que seja o 200.220.55.18).
   
   Então vamos implantar um firewall da seguinte maneira:

      +-> IP: 143.107.207.42
      |
    +-+-+     +----------+     +----------+
    | A |---->| FIREWALL |---->| Internet |
    +---+     +----------+     +----------+

   
   P/ bloquearmos o acesso do micro devemos escrever a regra do 
   firewall com os seguintes parâmetros:
   
   iptables -t filter -A FORWARD -p tcp -s 143.107.207.42/32 \
   <espaço>-d 200.220.55.18/32 -j DROP
   
   Explicando:

     iptables  : É o nome do programa que escreve as regras do 
                 firewall

     -t filter : É o tipo da regra (aqui estamos filtrando)

     -A FORWARD: Estamos adicionando uma regra na cadeia dos pacotes 
                 que vão passar pelo firewall.

     -p tcp    : Utilizando o protocolo TCP
     
     -s 143.107.207.42/32: IP de origem (de onde vem a solicitação).
                           Repare que após o IP temos "/32". Isso 
                           significa que obrigatóriamente TODOS os 
                           números do IP têm que ser exatamente 
                           estes bloqueando somente este micro.
     
     \         : Essa barra invertida é usada quando você quer 
                 "quebrar" o comando em mais de uma linha para torná-
                 lo mais legível. Então colocamos essa barra no ponto 
                 em que queremos quebrar a linha, e na linha seguinte, 
                 iniciamos-a com um espaço (<espaço>) para que o Linux 
                 "entenda" que essa linha é uma continuação da 
                 anterior.
                 
     <espaço>  : Ver explicação anterior.
     
     -d 200.220.55.18/32: IP de destino (para onde vai a solicitação) 
                          que queremos bloquear. O "/32" é pelo mesmo 
                          motivo do IP de origem (ver explicação do 
                          parâmetro -s acima).
                          
     -j DROP   : É a ação que deve ser executada se o micro de origem 
                 tentar acessar o UOL, ou seja, descartar o pacote.
                 
   
   E o mais interessante é que para o usuário que tentou acessar o 
   site do UOL vai ser exibido apenas uma mensagem de que não houve 
   sucesso na tentativa de conexão. Ou seja, ele pode pensar que o 
   site está fora do ar ou com problemas. Porém, se ele tentar dar um 
   ping no site do UOL, ele vai conseguir, pois o pacote do ping 
   utiliza o procotolo ICMP e não o TCP!
   
   
   
   Vejamos mais algumas possibilidades:
   
   1) E quando queremos bloquear qualquer micro ou site?
      R: Temos 2 formas de fazer isso. Veja:

         Podemos informar o seguinte IP nos parâmetros -s e/ou -d:
         0.0.0.0/0 (esse IP significa "qualquer IP"), por exemplo:
         
         iptables -t filter -A FORWARD -p tcp -s 0.0.0.0/0 \
         <espaço> -d 200.220.55.18/32 -j DROP
         
         ou
         
         Simplesmente não informamos o parâmetro, por exemplo:

         iptables -t filter -A FORWARD -p tcp -d 200.220.55.18/32 \
         <espaço> -j DROP

   2) Bom, então se podemos suprimir alguns parâmetros, quais são os 
      parâmetros obrigatórios?
      R: São eles:

         iptables (óbvio, por ser o nome do programa que escreve as 
                  regras do firewall)

         -t       (que indica o tipo da regra)

         -A       (que indica o que queremos fazer com a regra que 
                   estamos digitando, que aqui, seria Adicionar)

         -j       (que indica a ação que o firewall executará com o 
                   pacote)
   
   3) Mas e se um pacote não bater com nenhuma regra que escrevemos? O 
      que o firewall faz?
      R: Ele executa a "Regra Padrão" que também pode ser escrita da 
         seguinte maneira:
         
         iptables -t filter -P FORWARD -j DROP
         iptables -t filter -P INPUT -j DROP
         iptables -t filter -P OUTPUT -j DROP
         
         Geralmente, a "Regra Padrão" é essa mesmo: descartar todos os 
         pacotes.
         
   4) E se eu quiser liberar uma rede que possui um IP 143.107.207.?, 
      onde ? pode ser de 1 a 254, para somente navegar na Internet?
      R: É só especificar a porta 80 com o parâmetro --dport além dos 
         demais parâmetros que já vimos. Veja:
         
         iptables -t filter -A FORWARD -s 143.107.207.0/24 \
         <espaço>-d 0.0.0.0/0 --dport 80 -j ACCEPT
         
   5) E se tivermos 2 redes com IPs diferentes e querermos tratar as 
      permissões de cada uma individualmente?
      R: Temos 2 alternativas:

         A primeira seria continuarmos fazendo extamente como os 
         exemplos já vistos porém trocando os IPs de cada rede.
         
         A segunda é começarmos a usar as "cadeias", que como dito 
         anteriormente, são como categorias. Mas a diferença é que 
         podemos criar nossas prórpias categorias. Veja:
         
         Primeiro vamos especificar os parâmetros de cada categoria 
         que queremos criar:
         
         iptables -t filter -A FORWARD -s 143.0.0.0/8 -j BIBLIO
         iptables -t filter -A FORWARD -s 107.0.0.0/8 -j CIRP
         
         Agora vamos criar as cadeias:
         
         iptables -N BIBLIO
         iptables -N CIRP
         
         Nota: p/ apagar uma cadeia use o seguinte comando:
         
         iptables -X <cadeia>
         
         E, por último, vamos aplicar os parâmetros das cadeias:
         
         iptables -t filter -A BIBLIO --dport 25 -j DROP
         iptables -t filter -A CIRP --dport 25 -j ACCEPT
         
   6) Como podemos permitir que um micro, com IP inválido 
      (192.168.1.36), possa acessar a Internet? 
      R: Vamos supor que temos um micro compartilhando o acesso à 
         Internet através de uma 2a. placa de rede cujo IP dessa seja 
         200.143.18.27. Agora basta utilizar a seguinte regra para 
         fazer NAT com o firewall.
         
         iptables -t nat -A PREROUTING -s 192.168.1.36/32 \
         <espaço>-j SNAT --toaddress 200.143.18.27
         
   7) E se quisermos redirecionar todos as requisições, de qualquer 
      micro da rede interna, para o IP 200.143.18.27:80 (onde 
      também temos um servidor WEB rodando) para um outro micro da 
      rede interna?
      R: Basta digitar a seguinte regra:
      
         iptables -t nat -A PREROUTING -d 200.143.18.27:80 \
         <espaço>-j DNAT --toaddress 192.168.1.34
         
   8) Existem programas que analizam o LOG do firewall?
      R: SNORT, MySQL e ACID.
      
   9) Como posso listar as regras do firewall?
      R: Utilize o seguinte comando:
      
         iptables -L           : p/ listar tudo
         iptables -L -t nat    : p/ listar somente as regras de NAT
         iptables -L -t mangle : p/ listar somente as regrar de MANGLE
      
   10) como posso zerar as regras das cadeias?
       R: Basta seguir a seqüência de comandos abaixo:
       
          1) Zerar as cadeias padrão
             iptables -t filter -F INPUT
             iptables -t filter -F OUTPUT
             iptables -t filter -F FORWARD
            
          2) Zerar mais alguma cadeia (se existir)
             iptables -t filter -F <cadeia>
             
          3) Apagar todas as cadeias além das cadeias padrão
             iptables -X <cadeia>
             
          4) Reconfigurar as cadeias padrão
             iptables -t filter -P INPUT ACCEPT
             iptables -t filter -P OUTPUT ACCEPT
             iptables -t filter -P FORWARD ACCEPT
             
             iptables -t filter -P INPUT DROP
             iptables -t filter -P INPUT ACCEPT
             iptables -t filter -A INPUT -p icmp -j REJECT
             iptables -t filter -F INPUT
             
          5) Reestartar o servidor WEB
             service http restart
             
          6) Testar a conexão com o servidor WEB
             telnet <IP do micro> 80
             
          
          iptables -X <cadeia> : p/ remover todas as cadeias
          
   11) Como podemos interferir numa conexão TCP?
       R: Quando uma requisição TCP é feita, há vários comandos que 
          são executados, onde podemos utilizar o firewall para 
          interferir. Veja alguns dos comandos que são executados e 
          procure na documentação do firewall como fazer isso:
          
          Comandos executados durante uma conexão TCP:
          syn, ack, rst, fin

          Veja exemplos de como ficaria uma regra que faça 
          isso:
          ... -A FORWARD -s <rede interna> -m SYN -j ACCEPT
          ... -A FORWARD -s 0.0.0.0/0 -d <rede interna> \
          <espaço>- m ESTABILISHED -j ACCEPT

          
   12) Como podemos bloquear um micro de fora da nossa rede interna,
       com IP 143.107.207.39, tentar acessar a porta 80 de qualquer 
       micro em nossa rede?
       R: Utilize a regar a seguir:
       
          iptables -t filter -A INPUT -s 143.107.207.39/32 \
          <espaço>-p tcp --dport 80 -j DROP
          
          
   13) Quais são as configurações normalmente utilizadas em uma rede 
       com SPEEDY?
       R: Veja abaixo:
       
          NAT     ---> (de dentro p/ fora)
          
          FILTER <---> (filtrar pacotes que saem e entram)
          
                  \ /
          INPUT  <-X-  (bloquear todas as portas sem uso)
                  / \  Para saber quais são as portas e p/ que cada 
                       uma serve, consulte o arquivo /etc/services.
                  
          Tendo esse princípio como base, temos que tomar cuidado ao 
          escrever as regras para não bloquearmos nossa própria rede 
          interna.
          
   14) N Ã O   E S Q U E Ç A: uma das melhores formas de aprender 
       -----   -------------- sobre as regras de firewall é procurando 
                              arquivos de exemplo na Internet.
                         
                              
                          _____   ___   __  __   _ 
                         |  ___| |_ _| |  \/  | | |
                         | |_     | |  | |\/| | | |
                         |  _|    | |  | |  | | |_|
                         |_|     |___| |_|  |_| (_)