%\documentclass[letterpaper]{article}
%\usepackage{linuxdoc-sgml}
%\usepackage{qwertz}
%\usepackage{url}
%\usepackage[latin1]{inputenc}
%\usepackage{t1enc}
%\usepackage{babel}
%\usepackage{epsfig}
%\usepackage{null}
%\def\addbibtoc{
%\addcontentsline{toc}{section}{\numberline{\mbox{}}\relax\bibname}
%}%end-preamble
%\setcounter{page}{1}
%\title{Como  Fazer - Dicas Linux}
\chapter{Como  Fazer - Dicas Linux}
\label{tips}
\author{Paul Anderson, {\ttfamily paul@geeky1.ebtech.net} e Conectiva Informática, {\ttfamily info@conectiva.com.br}}
\date{v3.6, June 1998}
\abstract{Este Como Fazer contém aquelas dicas difíceis de encontrar e sugestões que fazem o uso do Linux muito mais agradáveis.}


%\begin{document}
%\maketitle
%\tableofcontents

\section{Introdução}

Bem-vindo ao {\bfseries Como Fazer - Dicas Linux}, uma lista de dicas e otimizações que tornam o Linux mais agradável. Tudo o que temos até aqui são idéias minhas e dicas do antigo Como Fazer-Dicas (Porque jogá-las fora, certo?). Então caso você queira agregar mais alguns avisos e dicas, fique à vontade e escreva para mim. Assim podemos inclui-los na próxima edição do Como Fazer-Dicas.

Paul Anderson {\itshape Mantedor - Como Fazer - Dicas Linux \/}



{\ttfamily panderso@ebtech.net}


\section{Dicas Curtas}


\subsection{Dica Útil do Syslog {\itshape Paul Anderson, Mantenedor - Como Fazer - Dicas Linux \/}}

Edite o /etc/syslog.conf, e coloque a seguinte linha:
\begin{tscreen}
\begin{verbatim}
# Copia tudo em  tty8
*.*                                     /dev/tty8
\end{verbatim}
\end{tscreen}

Um detalhe: {\itshape LEMBRE-SE DE USAR TAB !\/}  syslog não gosta de espaços...




\subsection{Programa de visualização dos Como Fazer. {\itshape Didier Juges,\/} {\ttfamily dj@destin.nfds.net}}

De um iniciante para outro, segue aqui um programa curto que facilita a visualização e pesquisa em documentos Como Fazer - HOWTO. Meus documentos estão em /usr/doc/faq/howto/ e estão compactadas com gzip. O nome dos arquivos são XXX-HOWTO.gz, sendo XXX o assunto. Eu criei o seguinte programa, chamado "howto" no diretório /usr/local/sbin:
\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
#!/bin/sh
if [ "$1" = "" ]; then
    ls /usr/doc/faq/howto | less
else
    gunzip -c /usr/doc/faq/howto/$1-HOWTO.gz | less
fi
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}

Quando chamado sem argumentos, mostra o conteúdo do diretório que contém os HOWTOs disponíveis. Então ao se informar a primeira parte do nome do arquivo (antes do hífen) como argumento, ele descompacta (mantendo o original intocado) e mostra o documento.

Por exemplo, para ver o documento Serial-HOWTO.gz , deve-se informar:

\$ howto Serial






\subsection{Há espaço livre disponível??? {\itshape Hans Zoebelein,\/} {\ttfamily zocki@goldfish.cube.net}}

Segue aqui um pequeno programa que checa de tempos em tempos se há espaço em disco suficiente em qualquer dispositivo que esteja montado (discos, cdrom, disquetes,...)

Caso o espaço acabe, uma mensagem é apresentada a cada X segundos na tela e é enviado um email por dispositivo que esteja sem espaço.

\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
#!/bin/sh
#
# $Id: check_hdspace,v 1.18 1996/12/11 22:33:29 root Exp root $
#
#
# Desde que erros misteriosos ocorreram durante a compilação 
# quando arquivos encheram o diretório tmp
# eu escrevi este programa para ser avisado de que os discos estavam cheios.
#
# Caso este utilitário evite que o seu servidor exploda mande uma
# mensagem de agradecimento para zocki@goldfish.cube.net.
#
# Caso você realmente saiba como lidar com o sed, por favor desculpe-me!
#
# Atire e esqueça: ponha 'check_hdspace &' no rc.local.
# Cheque o espaço livre nos dispositivos a cada $SLEEPTIME segundos.
# Pode-se verificar inclusive disquetes e fitas.
# Caso o espaço livre esteja abaixo de $MINFREE (kb), será apresentada 
# uma mensagem e enviado um email por cada dispositivo em $MAIL_TO_ME.
# Caso haja mais espaço livre do que o limite definido, um email pode 
# também ser enviado.
#
# TODO: Diferentes $MINFREE para cada dispositivo.
# Liberar diretórios /*tmp de coisas antigas e inúteis caso não haja mais espaço # livre.


DEVICES='/dev/sda2 /dev/sda8 /dev/sda9'       # device; informe seus discos aqui
MINFREE=20480                                 # kb; abaixo daqui, avise-me
SLEEPTIME=10                                  # sec; tempo entre as checagens
MAIL_TO_ME='root@localhost'                   # fool; quem deve ser avisado


# ------ a partir daqui nenhuma alteração será necessária (eu espero :) ) ------

MINMB=0
ISFREE=0
MAILED=""
let MINMB=$MINFREE/1024         # sim, nós somos rígidos :)

while [ 1 ]; do
    DF="`/bin/df`"
        for DEVICE in $DEVICES ; do
            ISFREE=`echo $DF | sed s#.\*$DEVICE" "\*[0-9]\*""\*[0-9]\*" "\*## | sed s#" ".\*##`
                
            if [ $ISFREE -le $MINFREE ] ; then
                let ISMB=$ISFREE/1024
                echo  "WARNING: $DEVICE only $ISMB mb free." >&2
                #echo "more stuff here" >&2
                echo -e "\a\a\a\a"
                        
                if [ -z  "`echo $MAILED | grep -w $DEVICE`" ] ; then
                    echo "WARNING: $DEVICE only $ISMB mb free.      (Trigger is set to $MINMB mb)" \
                    | mail -s "WARNING: $DEVICE only $ISMB mb free!" $MAIL_TO_ME
                    MAILEDH="$MAILED $DEVICE"
                    MAILED=$MAILEDH
                    # put further action here like cleaning
                    # up */tmp dirs...
                fi
                elif [ -n  "`echo $MAILED | grep -w $DEVICE`" ] ; then
                    # Remove mailed marker if enough disk space
                    # again. So we are ready for new mailing action.
                    MAILEDH="`echo $MAILED  | sed s#$DEVICE##`"
                    MAILED=$MAILEDH
                fi
                        
        done
        sleep $SLEEPTIME
done
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}







\subsection{Utilitário para limpar os arquivos de históricos {\itshape Paul Anderson, Mantenedor - Como Fazer - Dicas Linux \/}{$>$}}

Caso você seja como eu, deve manter uma lista com centenas de inscritos, mais de cem mensagens por dia chegando pelo UUCP. Bem, o que fazer para lidar com históricos enormes? Instalar chklogs. Chklogs foi escrito por Emilio Grimaldo, {\ttfamily grimaldo@panama.iaehv.nl}, e a versão atual é a 1.8 disponível em ftp.iaehv.nl:/pub/users/grimaldo/chklogs-1.8.tar.gz. Ele é auto explicativo na instalação (obviamente você verificará o conteúdo do subdiretório info).
Uma vez instalado, adicione uma entrada ao crontab como esta:
\begin{tscreen}
\begin{verbatim}
# Executar chklogs as 3:00AM diariamente.
00 21 * * *       /usr/local/sbin/chklogs -m
\end{verbatim}
\end{tscreen}


Enquanto você estiver lidando isso, avise ao autor quão bom seu software é.  :)






\subsection{Programa útil para limpar arquivos core. {\itshape Otto Hammersmith,\/}
{\ttfamily ohammers@cu-online.com}}

Crie um arquivo chamado rmcores (o autor chama isso de trata-cores) com o seguinte conteúdo:
\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
#!/bin/sh
USAGE="$0 <directory> <message-file>"

if [ $# != 2 ] ; then
        echo $USAGE
        exit
fi

 echo Apagando...
find $1 -name core -atime 7 -print -type f -exec rm {} \;

echo email
for name in `find $1 -name core -exec ls -l {} \; | cut -c16-24`
do
        echo $name
        cat $2 | mail $name
done
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}


E adicione uma tarefa ao cron para executar este utilitário periodicamente.






\subsection{Movendo diretórios ente sistemas de arquivos. {\itshape Alan Cox,\/} {\ttfamily A.Cox@swansea.ac.uk}}

Uma maneira rápida de mover uma árvore de diretórios e arquivos de um disco para outro.
\begin{tscreen}
\begin{verbatim}
(cd /origem/diretório && tar cf - . ) | (cd /destino/diretório && tar xvfp -)
\end{verbatim}
\end{tscreen}

{\itshape [ Mude de cd /origem/diretório; tar....etc... para prevenir possíveis danos ao diretório em caso de problemas. Agradecimentos a Jim Dennis, jim@starshine.org, por avisar-nos. ]\/}




\subsection{Descobrindo os maiores diretórios. {\itshape Mick Ghazey,\/}
{\ttfamily mick@lowdown.com}}

Quer saber quais são os maiores diretórios em seu computador? Veja como descobrir.
\begin{tscreen}
\begin{verbatim}
du -S | sort -n
\end{verbatim}
\end{tscreen}





\subsection{A Gazeta Linux }

Congratulações a John Fisk, criador do Linux Gazette. Esta é uma excelente revista eletrônica, é {\bfseries GRÁTIS!!!}  Agora o que mais você poderia perguntar? Visite A Gazeta Linux em:
\begin{tscreen}
\begin{verbatim}
http://www.linuxgazette.com
\end{verbatim}
\end{tscreen}

Por oportuno, é bom saber que LG tem periodicidade mensal, e (2) John Fisk não mais a mantém e sim o pessoal da SSC.






\subsection{Ponteiro para uma atualização do GNU Make 3.70 para mudar o comportamento do VPATH. {\itshape Ted Stern,\/} {\ttfamily stern@amath.washington.edu}}

Eu não sei se muita gente tem esse problema, mas há uma funcionalidade da versão 3.70 do GNU make que eu não gosto. É que o VPATH age estranhamente caso se informe um caminho de nome absoluto. Há uma atualização muito robusta que conserta isso em Paul D. Smith {\ttfamily $<$psmith@wellfleet.com{$>$}}. Ele também envia mensagens e documentação após cada revisão do GNU make em {\tt\char`\"}gnu.utils.bug{\tt\char`\"} Geralmente, eu aplico as atualizações e compilo gmake em todos os sistemas nos quais trabalho.




\subsection{Como evitar que o meu sistema faça a checagem de integridade a cada inicialização? {\itshape Dale Lutz,\/} {\ttfamily dal@wimsey.com}}

Q:  Como evitar que e2fsck cheque o sistema de arquivos de meu disco a cada vez que o sistema seja inicializado.

A:  Ao reconstruir o kernel, o sistema de arquivos é marcado como ´sujo´ e então o disco será checado a cada inicialização do sistema. Para corrigir isso execute:
rdev -R /zImage 1

Isso avisa ao kernel de que os sistemas de arquivos não apresentam nenhum problema.

{\itshape Nota: caso se esteja usando LILO, então adicione \/}{\ttfamily read-only} {\itshape  à configuração do Linux no arquivo de configuração do LILO (normalmente /etc/lilo.conf) \/}




\subsection{Como evitar a checagem dos sistemas de arquivos, causados por dispositivos ocupado durante a inicialização do sistema. {\itshape Jon Tombs,\/} {\ttfamily jon@gtex02.us.es}}

Caso você tenha erros de dispositivo ocupado ao desligar o sistema e que deixam os sistemas de arquivos com indicação para verificação de integridade em tempo de inicialização, segue uma correção simples:

Em {\ttfamily /etc/rc.d/init.d/halt} ou {\ttfamily /etc/rc.d/rc.0}, adicione a linha
\begin{tscreen}
\begin{verbatim}
mount -o remount,ro /mount.dir
\end{verbatim}
\end{tscreen}

para todos os sistemas de arquivos montados, exceto /, antes de chamar o comando umount -a. Isto significa que, se por alguma razão, o desligamento falhar ao finalizar todos os processos e desmontar os discos, eles estarão limpos para reinicialização. Isso economiza bastante tempo durante a carga do sistema. 




\subsection{Como encontrar os maiores arquivos de um disco rígido.}

{\itshape Simon Amor,\/} {\ttfamily simon@foobar.co.uk}

\begin{tscreen}
\begin{verbatim}
ls -l | sort +4n
\end{verbatim}
\end{tscreen}


Ou, para aqueles que realmente necessitam de espaço, segue uma alternativa que demora um pouco mas funciona perfeitamente:

\begin{tscreen}
\begin{verbatim}
cd /
ls -lR | sort +4n
\end{verbatim}
\end{tscreen}





\subsection{Como imprimir páginas com margem para arquivamento. {\itshape Mike Dickey,\/} {\ttfamily mdickey@thorplus.lib.purdue.edu}}

\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
        #!/bin/sh
        # /usr/local/bin/print
        # um formatador simples, que permite uma margem 
        # para encadernações 
        cat $1 | pr -t -o 5 -w 85 | lpr
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}





\subsection{Um meio de pesquisar em árvores de arquivos por uma expressão regular específica.{\itshape Raul Deluth Miller,\/} {\ttfamily rockwell@nova.umd.edu}}

Eu chamo este programa ´forall´. Pode-se usar da seguinte forma:
\begin{tscreen}
\begin{verbatim}
forall /usr/include grep -i ioctl
forall /usr/man grep ioctl
\end{verbatim}
\end{tscreen}

Aqui está forall:
\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
#!/bin/sh
if [ 1 = `expr 2 \> $#` ]
then
        echo Uso: $0 dir cmd [opcargs]
        exit 1
fi
dir=$1
shift
find $dir -type f -print | xargs "$@"
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}





\subsection{Um programa para limpeza após programas que criam arquivos de cópias de segurança e salvamento automático. {\itshape Barry Tolnas,\/} {\ttfamily tolnas@nestor.engr.utk.edu}}

Segue uma dica simples em duas linhas com recursividade em uma hierarquia de diretórios removendo arquivos emacs de salvamento automático (\#) e cópias de segurança (\~{}), arquivos .o e arquivos .log do Tex. Ele ainda comprime arquivos .tex e arquivos README. Eu chamo isso de encolhimento no meu sistema.
\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
#!/bin/sh
#ENCOLHER remove arquivos desnecessários e comprime arquivos .tex e README
#De Barry tolnas, tolnas@sun1.engr.utk.edu
#
echo encolhendo $PWD
find  $PWD \( -name \*~ -or -name \*.o -or -name \*.log -or -name \*\#\) -exec
rm -f {} \;
find $PWD \( -name \*.tex -or -name \*README\* -or -name \*readme\* \) -exec gzip -9 {} \;
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}





\subsection{Como encontrar os processos que estão utilizando mais memória. {\itshape Simon Amor,\/} {\ttfamily simon@foobar.co.uk}}

\begin{tscreen}
\begin{verbatim}
ps -aux | sort +4n
\end{verbatim}
\end{tscreen}

-OR-
\begin{tscreen}
\begin{verbatim}
ps -aux | sort +5n
\end{verbatim}
\end{tscreen}





\subsection{Configurando o vi para Programação C {\itshape Paul Anderson,\/}{\ttfamily  Mantenedor - Como Fazer - Dicas Linux }}

Eu programo bastante em C em meu tempo livre, e eu usei algum tempo para melhorar o vi para ser mais amigável com o C. Segue o meu arquivo .exrc:
\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
set autoindent
set shiftwidth=4
set backspace=2
set ruler
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}


Como isso funciona? Autoindent faz com que o vi automaticamente indente cada linha, saltando para direita a distância de \^{}T em 4 espaços, backspace configura o valor da tecla de retorno  e ruler mostra a régua com os números. Lembre-se que para ir a uma linha especifica, digamos número 20, use:

\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
vi +20 myfile.c
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}





\subsection{Usando ctags para facilitar a programação.}

Muitos programadores já tem ctags em seus computadores, mas não as usam. Podem ser muito úteis em diversas ocasiões. Suponha que se tenha uma função, em um dos diversos arquivos de fontes em um diretório, para um programa que está em desenvolvimento, e se deseja editar a função para sua atualização. Chamaremos esta função de foo(). Porém não lembramos onde está o fonte. É aqui que ctags começa a ser muito útil. Ao executar ctagas ele produz um arquivo chamado tags no diretório atual, o qual é uma lista de todas as funções, em quais arquivos eles estão presentes e onde elas estão naqueles arquivos. O arquivo de resultado se parece com algo como:

\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}

ActiveIconManager       iconmgr.c       /^void ActiveIconManager(active)$/
AddDefaultBindings      add_window.c    /^AddDefaultBindings ()$/
AddEndResize    resize.c        /^AddEndResize(tmp_win)$/
AddFuncButton   menus.c /^Bool AddFuncButton (num, cont, mods, func, menu, item)$/
AddFuncKey      menus.c /^Bool AddFuncKey (name, cont, mods, func, menu, win_name, action)$/
AddIconManager  iconmgr.c       /^WList *AddIconManager(tmp_win)$/
AddIconRegion   icons.c /^AddIconRegion(geom, grav1, grav2, stepx, stepy)$/
AddStartResize  resize.c        /^AddStartResize(tmp_win, x, y, w, h)$/
AddToClientsList        workmgr.c       /^void AddToClientsList (workspace, client)$/
AddToList       list.c  /^AddToList(list_head, name, ptr)$/
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}




Para editar, digamos AddEndResize() no vim, execute:

\begin{tscreen}
\begin{verbatim}
vim -t AddEndResize
\end{verbatim}
\end{tscreen}

Isto irá trazer o arquivo apropriado ao editor, com o cursor localizado no início da função.






\subsection{O que faz com que o sendmail demore 5 minutos na inicialização do Red Hat? {\itshape Paul Anderson,\/} {\ttfamily paul@geeky1.ebtech.net}}

Este é um problema muito comum, quase no ponto de tornar-se um FAQ. A Red Hat já deve ter corrigido este problema em sua distribuição, mas isso pode ser corrigido por você mesmo. Ao se verificar o conteúdo do arquivo /etc/hosts file, 
pode-se encontrar algo como:
\begin{tscreen}
\begin{verbatim}
127.0.0.1               localhost       suamáquina
\end{verbatim}
\end{tscreen}


Quando sendmail é iniciado, ele procura pelo nome da máquina (neste exemplo suamáquina). Após, ele verifica que o IP de suamáquina é 127.0.0.1, porém ele não gosta desta definição e procura novamente, continuando neste processo por um longo período até desistir e finalizar. Corrigir este problema é muito simples, bastando editar o arquivo /etc/hosts e alterá-lo para algo como:
\begin{tscreen}
\begin{verbatim}
127.0.0.1               localhost
10.56.142.1             yourbox
\end{verbatim}
\end{tscreen}







\subsection{Como configurar o Red Hat para utilizar o comando ls em cores? {\itshape Paul Anderson,\/} {\ttfamily paul@geeky1.ebtech.net}}

A distribuição da Red Hat vem com o comando ls em cores, porém ele não é configurado automaticamente na instalação. Vejam como fazê-lo. 

Primeiro, digite eval `DIRCOLORS`

Após, alias ls='ls --color=auto'

E deve-se incluir o 'alias.....' no arquivo /etc/bashrc








\subsection{Como descobrir qual biblioteca em /usr/lib contém determinada função? {\itshape Pawel Veselow,\/} {\ttfamily vps@unicorn.niimm.spb.su}}

O que fazer quando se está compilando um programa e não se sabe a biblioteca que está faltando? Todas as informações geradas pelo gcc são com nomes de funções. Veja aqui como um simples comando pode encontrar o que você está procurando: 
\begin{tscreen}
\begin{verbatim}
for i in *; do echo $i:;nm $i|grep nome_função 2>/dev/null;done
\end{verbatim}
\end{tscreen}


Onde nome\_função é o nome da função que se está procurando. 






\subsection{Eu compilei um pequeno programa de testes em C, mas ao executá-lo não aparece nenhuma informação de saída! }

Provavelmente o programa foi compilado em um binário chamado test. Porém Linux tem um programa de mesmo nome, o qual testa se determinada condição é verdadeira, e nunca produz resultados na tela. Para testar seu programa, estando no diretório onde ele está localizado, digite: ./test








\section{Dicas Detalhadas }


\subsection{Compartilhando partições de troca entre o Linux e o Windows. {\itshape Tony Acero,\/} {\ttfamily ace3@midway.uchicago.edu}}

\begin{enumerate}
\item Formatar a partição como uma partição DOS, e criar o arquivos de troca Windows nela, mas sem rodar o Windows ainda. (deve-se manter o arquivo de troca completamente vazio por enquanto, assim ele pode ser compactado com eficiência). 
\item  Inicie o Linux e salve a partição em um arquivo. Por exemplo, se a partição é /dev/hda8:
\begin{tscreen}
\begin{verbatim}
dd if=/dev/hda8 of=/etc/dosswap
\end{verbatim}
\end{tscreen}
\item  Compacte o arquivo de troca; uma vez que tudo que ele contém são  zeros, a compressão terá um excelente resultado 
\begin{tscreen}
\begin{verbatim}
gzip -9 /etc/dosswap
\end{verbatim}
\end{tscreen}
\item Adicione a seguinte linha ao arquivo /etc/rc para preparar e instalar a área de troca sob o Linux: 
{\itshape XXXXX é o número de blocos da partição de troca\/}
\begin{tscreen}
\begin{verbatim}
mkswap /dev/hda8 XXXXX
swapon -av   
\end{verbatim}
\end{tscreen}

Esteja seguro de adicionar uma linha de definição da área de troca no arquivo /etc/fstab 
\item  Caso o pacote init/reboot  suporte /etc/brc ou /sbin/brc adicione o seguinte ao arquivo /etc/brc, ou faça manualmente ao iniciar o DOS $|$ OS/2 para converter de volta a partição em uma versão do DOS/Windows:
\end{enumerate}

\begin{tscreen}
\begin{verbatim}
swapoff -av
zcat /etc/dosswap.gz | dd of=/dev/hda8 bs=1k count=100
\end{verbatim}
\end{tscreen}

\# Note-se que este comando grava somente os primeiros 100 blocos da partição. Eu encontrei empiricamente este número como suficiente. 

$>$$>$  Quais os prós e contras de se utilizar essa sistemática?

Prós: pode-se economizar uma quantidade substancial de disco. 

Contras: caso o passo 5 não seja realizado de forma automática, deve-se lembrar de executá-lo manualmente, e isso pode atrasar a inicialização em nanosegundos. :-)




\subsection{Recuperação de arquivos apagados. {\itshape Michael Hamilton,\/} {\ttfamily michael@actrix.gen.nz}}

Segue aqui uma dica, usada por mim algumas vezes.

Recuperação de arquivos textos pessoais. 

Caso acidentalmente um arquivo texto tenha sido apagado, por exemplo, algum email ou os resultados da última noite de programação, há uma chance de recuperá-los. Caso o arquivo tenha sido gravado em disco, isto é se não foi gravado há mais de 30 segundos, seu conteúdo pode ainda estar na partição em disco. 

Pode-se usar o comando grep para procurar o conteúdo do arquivo diretamente na partição em disco.

Por exemplo, recentemente, eu acidentalmente apaguei um email. Então imediatamente cesse qualquer atividade que possa modificar a partição:
Neste caso basta suspender qualquer atividade de salvamento de arquivos ou executar compilações, etc... Em algumas situações eu na verdade desliguei o sistema e o inicializei em modo monousuário, sem montar os sistemas de arquivos. 

Após eu utilizei o comando egrep na partição do disco: no meu caso uma mensagem eletrônica em /usr/local/home/walter/. Inicialmente pode-se ver que o diretório está localizado em /dev/hdb5, utilizando-se o comando df:

\begin{tscreen}
\begin{verbatim}
  sputnik3:~ % df
    Filesystem         1024-blocks  Used Available Capacity Mounted on
    /dev/hda3              18621    9759     7901     55%   /
    /dev/hdb3             308852  258443    34458     88%   /usr
    /dev/hdb5             466896  407062    35720     92%   /usr/local

    sputnik3:~ % su
    Password:
    [michael@sputnik3 michael]# egrep -50 'ftp.+COL' /dev/hdb5 > /tmp/x
 
\end{verbatim}
\end{tscreen}


Agora deve-se ser extremamente cuidadoso ao lidar com partições de discos, devendo-se verificar cuidadosamente o comando a ser aplicado antes de pressionar enter. Neste caso procuro o email contendo a palavra ftp seguido de algum texto que contenha a palavra COL. A mensagem continha aproximadamente 20 linhas, tendo então usado -50 para recuperar todas as linhas no entorno da mensagem. No passado eu cheguei a usar -3000 para ter certeza de recuperar todas as linhas de algum código fonte. A saída do comando egrep foi direcionada para uma partição diferente do disco - prevenindo-se assim alguma gravação sobre a área que contém as informações desejadas. 

Após, utilizei o comando strings para auxiliar na avaliação da saída anterior: 
\begin{tscreen}
\begin{verbatim}
   strings /tmp/x | less
 
\end{verbatim}
\end{tscreen}


Seguro o suficiente para garantir que o email estava lá. 

Este método não é totalmente seguro, pois parte ou toda a área utilizada pelo arquivo anteriormente já pode ter sido utilizada. 

Esta dica é provavelmente útil somente em sistemas monousuários. Em sistemas multiusuários com alto nível de atividade em disco, o espaço liberado pode já ter sido utilizado. 

Em meu sistema doméstico esta dica pode ser utilizada com sucesso em pelo menos três ocasiões nos últimos anos - principalmente quando acidentalmente eu apaguei o resultado de dias de trabalho. E caso a tarefa na qual eu esteja trabalhando chegue a um ponto onde eu sinta um progresso significativo, é aconselhável copiá-lo em um ou mais disquetes, não sendo necessário usar esta dica com muita freqüência.






\subsection{Como utilizar um indicador imutável. {\itshape Jim Dennis,\/} {\ttfamily jadestar@rahul.net}}

Uso de Um Sistema Imutável

Imediatamente após a instalação e configuração de um sistema, vá aos diretórios /bin, /sbin/, /usr/bin, /usr/sbin e /usr/lib (e alguns outros prováveis candidatos) e utilize livremente o comando 'chattr +i'. Adicione também os arquivos do kernel no raiz. Após execute 'mkdir /etc/.dist/' e copie todo o conteúdo de /etc/ nele (eu normalmente faço isto em dois passos usando /tmp/etcdist.tar para evitar a recursividade) no diretório. (Opcionalmente pode-se simplesmente criar /etc/.dist.tar.gz) - e indicá-lo como imutável.

A razão para tudo isso é limitar eventuais danos que podem ser feitos pelo usuário que acessa o sistema como superusuário root.  Assim  não se apagará arquivos importantes com um redirecionamento ou com um comando acidental 'rm -fr' (apesar destes comandos ainda poderem causar um grande estrago no sistema - ao menos as bibliotecas e executáveis estarão à salvo). 

Isso torna o sistema ainda mais seguro pois evita serviços de busca de falhas de segurança, tornando mais difícil ou praticamente impossível o seu uso (uma vez que muitos deles fundamentam-se na regravação de arquivos que executem ações com o programa SUID e tenham acesso a ambientes de trabalho). 

O único incoveniente deste procedimento aparece ao se executar 'make install' em diversos binários do sistema. Caso se esqueça de executar o comando chattr -i nos arquivos a serem regravados e nos diretórios onde eles estão localizados, o comando make falhará. Basta executar o comando e executar novamente  make. Pode-se ainda mover os binários antigos, bibliotecas, e tudo o mais para um diretório .old/ ou renomeá-los ou ainda aplicar o comando tar, etc... 






\subsection{Sugestão de onde colocar novos programas.
{\itshape Jim Dennis,\/} {\ttfamily jadestar@rahul.net}}

Todos os arquivos e comandos novos podem estar em /usr/local! ou /usr/local/`nome\_da\_máquina`. Caso a sua distribuição deixe vazio o diretório /usr/local , então simplesmente crie os diretórios /usr/local/src, /usr/local/bin, etc... e utilize-os. Caso a sua distribuição coloque arquivos em /usr/local, então pode-se criar um diretório com o comando  'mkdir /usr/local/`hostname`' e atribuir a permissão de grupo +w para ele(eu ainda faço uso de SUID e SGID para garantir que cada membro do grupo w possa somente lidar com arquivos que a eles pertencem, e que assim todos os arquivos criados pertencerão ao grupo w). 

Após, adquira o hábito de sempre colocar novos pacote em /usr/local/src/.from/\$NOME\_DO\_PACOTE/ (para arquivos .tar ou qualquer outro) e construa-os em /usr/local/src (ou .../\$NOME\_DA\_MÁQUINA/src). Esteja seguro que ele seja instalado sob a hierarquia de diretórios local. Caso ele necessariamente deva ser instalado em /bin ou /usr/bin ou algum outro local, crie uma ligação simbólica da hierarquia local com cada elemento que deva ser  colocado em outro local.

A razão para isto - mesmo que dê um pouco mais de trabalho - reside na capacidade de isolar o que deve ser copiado e restaurado ou reinstalado no caso de uma reinstalação completa a partir de uma mídia da distribuição (normalmente um CD). Usando um diretório /usr/local/.from pode-se ainda manter-se um histórico informal da origem dos fontes  -- o que auxilia na hora de buscar atualizações - o que pode ser crítico ao se monitorar a lista de questões de segurança.

Por exemplo, todos os sistemas que eu configurei no trabalho (quando eu era encarregado da administração do sistema) e que foram administrados por muitos contratados e outras pessoas, e tiveram um grande número de atualizações, mantiveram uma idéia precisa dos elementos que foram adicionados ao sistema após a instalação e configuração iniciais. 




\subsection{Convertendo os nomes de todos os arquivos de um diretório para letras minúsculas. {\itshape Justin Dossey,\/} {\ttfamily dossey@ou.edu}}



Eu reparei em uma dificuldade desnecessária nos procedimentos recomendados na seção 2c das dicas, edição 12 da LG. Neste caso estou enviando uma alteração para facilitar o processo:
\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
#!/bin/sh
       # lowerit
         # converte os nomes de todos os arquivos do diretório atual para letras 
       # minúsculas. Funciona somente em arquivo - não muda nomes de diretórios
       # e solicitará confirmação antes de regravar um arquivo já existente 
         for x in `ls`
           do
           if [ ! -f $x ]; then
             continue
             fi
           lc=`echo $x  | tr '[A-Z]' '[a-z]'`
           if [ $lc != $x ]; then
             mv -i $x $lc
           fi
           done
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}

Bem, é um programa longo. Ao invés de usar tudo isso pode-se usar o seguinte comando:

\begin{tscreen}
\begin{verbatim}
for i in * ; do [ -f $i ] && mv -i $i `echo $i | tr '[A-Z]' '[a-z]'`;
done;
\end{verbatim}
\end{tscreen}





\subsection{Encerrando os processos de um usuário. {\itshape Justin Dossey,\/} {\ttfamily dossey@ou.edu}}



Na próxima dica pode-se encerrar todo os processos de um determinado usuário com o seguinte comando.

\begin{tscreen}
\begin{verbatim}
kill -9 `ps -aux |grep ^<nome_usuário> |tr -s " " |cut -d " " -f2`
\end{verbatim}
\end{tscreen}


Por exemplo, caso o usuário se chame paloma 
\begin{tscreen}
\begin{verbatim}
kill -9 `ps -aux |grep ^paloma |tr -s " " |cut -d " " -f2`
\end{verbatim}
\end{tscreen}





\subsection{Senha de superusuário perdida. }



Agora com cuidado, vamos falar de senhas do superusuário que foram esquecidas ou perdidas. 

A solução dada na Linux Gazette é a mais universal, mas não a mais simples. Tanto com o LILO como com o loadlin, pode-se incluir o parâmetro {\tt\char`\"}single{\tt\char`\"} para se iniciar diretamente no ambiente de trabalho padrão, sem a necessidade de informar senhas. A partir daqui, pode-se mudar ou remover quaisquer senhas, antes de digitar {\tt\char`\"}init 3{\tt\char`\"} para iniciar o sistema em modo multiusuário. 
Justin Dossey






\subsection{Como atualizar o  Sendmail {\itshape Paul Anderson,\/} {\ttfamily paul@geeky1.ebtech.net}}

Começaremos do princípio, dos fontes do programa. Inicialmente deve-se obter os fontes do sendmail. Eu estou utilizando a versão 8.9.0, a qual é, no momento em que escrevo este artigo, o que há de mais recente. Eu o obtive em ftp.sendmail.org:/pub/sendmail/sendmail.8.9.0.tar.gz

Tem o tamanho de aproximadamente 1 Mb e considerando que se esteja executando a versão 8.7.6, eu creio que o esforço vale a pena. Caso funcione, certamente você saberá prontamente, de outra forma não há como receber as novas versões dos HOWTOs :-) 

Agora que já se tem os fontes, deve-se descomprimi-los. Pode-se criar um diretório chamado {\ttfamily sendmail-8.9.0} dentro do diretório atual. Vá para o diretório (com o comando cd), e leia os arquivos README e RELEASE\_NOTES (e esteja ciente das atualizações que foram feitas). Agora pode-se ir para o diretório src. Aqui é onde a maior parte do trabalho será executada.

{\itshape Nota: Sendmail é um pequeno, poderoso e bem escrito programa. O binário é compilado em menos de 5 minutos em uma máquina 5x86 133 com 32Megs RAM! A compilação completa e a instalação (configuração) levam menos de 15 minutos.\/} 

{\itshape Eu normalmente não executo o BIND em meu sistema, então encontrei as seguintes linhas:\/}

\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
# ifndef NAMED_BIND
#  define NAMED_BIND    1       /* usando Servidor de Domínios Berkeley */
# endif
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}


e mudando 1 para 0:

\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
# ifndef NAMED_BIND
#  define NAMED_BIND    0       /* usando Servidor de Domínios Berkeley */
# endif
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}




No Debian 1.3.1, db.h é por padrão instalado em /usr/include/db, ao invés de /usr/include, onde sendmail espera encontrá-lo. Vá para os diretórios src, 
mailstats, makemap, praliases, rmail e smrsh  e execute o seguinte comando: 

\begin{tscreen}
\begin{verbatim}
 ./Build -I/usr/include/db
\end{verbatim}
\end{tscreen}




Uma vez feito isso, execute cd.. e digite make install. Voilá! Sendmail versão 8.9.0 deve estar instalado. Isso claro, assumindo que a configuração original já foi realizada. Para que tudo funcione corretamente, uma vez que eu hospedo listas de mensagens usando majordomo, é necessário adicionar o seguinte no início de /etc/sendmail.cf:

\begin{tscreen}
\par
\addvspace{\medskipamount}
\nopagebreak\hrule
\begin{verbatim}
O DontBlameSendmail=forwardfileinunsafedirpath, forwardfileinunsafedirpathsafe
\end{verbatim} 
\nopagebreak\hrule 
\addvspace{\medskipamount}
\end{tscreen}


Sendmail 8.9.0 é desagradável sobre permissões de arquivos e diretórios, e irá reclamar sobre arquivos e diretórios em aliases ou .forward que tenham permissões de escrita para todos os usuários ou para o grupo. Uma vez que não é uma boa idéia desabilitar estes avisos, como sou o único que utiliza o sistema, sinto-me à vontade para fazê-lo.
YMMV.




\subsection{Algumas dicas para novos administradores de sistemas.
{\itshape Jim Dennis,\/} {\ttfamily jadestar@rahul.net}}

Criar e manter um arquivo /LEIAME.`nome\_máquina` e/ou um        /etc/LEIAME.`nome\_máquina` {\itshape [Ou possivelmente /usr/local/etc/LEIAME.`nome\_máquina` -Maint. ]\/}

Desde o primeiro dia da administração do sistema, tome notas neste arquivo como um histórico on-line. Pode-se incluir a linha {\tt\char`\"}vi /LEIAME.\$(nome\_máquina){\tt\char`\"} no arquivo ~/bash\_logout do superusuário. Uma outra forma de fazer isso é criar um programa su ou sudo que faça mais o menos o seguinte: 
\begin{tscreen}
\begin{verbatim}
                function exit \
                        { unset exit; exit; \
                          cat ~/tmp/session.$(date +%y%m%d) \
                          >> /LEIAME.$(nome_máquina) && \
                          vi /LEIAME.$(nome_máquina)
                          }
                script -a ~/tmp/session.$(date +%y%m%d)
                /bin/su.org -
\end{verbatim}
\end{tscreen}


(use o comando typescript para criar um histórico da sessão e criar uma função para automatizar a inclusão e atualização do histórico).

Eu admito que não utilizei essa política de automação, confiando sempre na minha disciplina. De qualquer forma a idéia está formatada.

Minha última sugestão é manter o caminho para o superusuário com o seguinte formato 'PATH=~/bin'

Somente isso e nada mais. Assim tudo o que o superusuário fizer pode ser provido por uma ligação simbólica com ~/bin ou por um nome alternativo ou por uma função de ambiente de trabalho, ou ainda pela digitação explícita do caminho.

Isso torna qualquer usuário acessando o sistema como superusuário ciente de que binários estão sendo utilizados. O administrador inteligente de um sistema multiusuário irá periodicamente observar os arquivos ~/bin e ~/.*history procurando padrões ou mensagens freqüentes.

O administrador realmente interessado irá buscar seqüências que podem ser automatizadas, colocar checagens em pontos necessários, e verificar quais privilégios do {\tt\char`\"}superusuário{\tt\char`\"} podem ser revistos (uso de editores, MTA e outros programas interativos com funcionalidades elaboradas que podem agregar informações em arquivos de dados - como o famoso vi ./.exrc e emacs ./.emacs e mesmo o \$EXINIT e as macros header/footer). Naturalmente estes comandos podem ser executados da seguinte forma: 

\begin{tscreen}
\begin{verbatim}
                cp $data $algum_diretório_usuário/tmp
                su -c $comando_origem $mudanças
                cp $algum_diretório_usuário/tmp $data
\end{verbatim}
\end{tscreen}

(...onde os dados variam de comando para comando).

Muitas destas precauções podem ser consideradas exageradas em estações de trabalho domésticas ou de usuários individuais, mas são altamente recomendadas como política de administração de sistemas multiusuários, particularmente um sistema exposto ao público. 






\subsection{Como configurar o seletor de servidor do xdm.{\itshape Arrigo Triulzi,\/} {\ttfamily a.triulzi@ic.ac.uk}}

\begin{enumerate}
\item  Edite o arquivo que inicializa o xdm, (possivelmente /etc/rc/rc.6 ou /etc/rc.local) e que contenha as seguintes linhas na seção de início do xdm.

\begin{tscreen}
\begin{verbatim}
        
/usr/bin/X11/xdm
exec /usr/bin/X11/X -indirect servidor
\end{verbatim}
\end{tscreen}
\item  Edite o arquivo /usr/lib/X11/xdm/Xservers, comentando a linha que inicia o servidor na máquina local (por exemplo  starting 0:)
\item Ao reinicializar o computador, você estará em casa e além. 
\end{enumerate}




Eu inclui isso quando eu estava desesperadamente tentando configurar minha própria subrede a partir de uma máquina e levei mais de uma semana para corrigir todos os problemas. 

Adicional: com o velho SLS (1.1.1) por alguma razão pode-se utilizar o parâmetro -nodaemon após a linha do xdm - porém isso {\bfseries NÃO} funciona para versões mais recentes. 

