\documentclass[11pt, a4paper, openany]{book}
\usepackage[brazil]{babel}
\usepackage[utf8]{inputenc}
\usepackage[tmargin=2cm, bmargin=2cm, lmargin=2.25cm, rmargin=2.25cm]{geometry}
\usepackage[pdftex]{hyperref}
\usepackage{indentfirst}
\usepackage[pdftex]{graphicx}
\usepackage{framed}
\usepackage{wrapfig}
\usepackage{textcomp}
\usepackage{url}
%\usepackage{titlesec}
\usepackage{titlepic}

\setcounter{secnumdepth}{4}
\setcounter{tocdepth}{4} 

\let\oldchapter\chapter
\renewcommand{\chapter}{\leftskip=0.0cm\oldchapter}
\let\oldsection\section
\renewcommand{\section}{\leftskip=0.0cm\oldsection}
\let\oldsubsection\subsection
\renewcommand{\subsection}{\leftskip=0.8cm\oldsubsection}
\let\oldsubsubsection\subsubsection
\renewcommand{\subsubsection}{\leftskip=1.4cm\oldsubsubsection}

\title{\Huge{\textbf{Curso de Linux}}\\Módulo Básico}
\date{}
\titlepic{\includegraphics[width=6cm]{logorl.jpeg}}

\begin{document}
\maketitle

\pagenumbering{roman}
\tableofcontents
\chapter*{Introdução}
\addcontentsline{toc}{chapter}{Introdução}

Este material destina-se a qualquer pessoa que queira adentrar ao curioso mundo do sistema operacional GNU/Linux tendo pouquíssimo ou nenhum conhecimento sobre o assunto.
\\

O objetivo deste curso é que você, após concluir a leitura e prática de todo o conteúdo proposto, seja capaz de instalar e utilizar com um certo conforto o ambiente GNU/Linux.
\\

O material está estruturado da seguinte maneira: o primeiro capítulo apenas introduz o GNU/Linux e o conceito de Software Livre. A seguir, mostramos como instalar um sistema GNU/Linux - você verá como pode ser incrivelmente fácil. Nos capítulos seguintes, fornecemos uma visão geral de como trabalhar no ambiente gráfico e no modo texto. Finalizamos com um capítulo que se propõe a mostrar como obter ajuda e ampliar seus conhecimentos.

\pagenumbering{arabic}
\chapter{O que é Linux?}

O termo \textit{Linux} é usado em vários contextos com significados diferentes. A rigor, Linux é um kernel. No entanto, em alguns contextos, Linux significa sistema operacional (não qualquer sistema operacional, mas um que use o kernel Linux).

\begin{center}
\fbox{\parbox[b]{15cm}{\textbf{Sistema Operacional:} é um software que serve de interface entre o computador e o usuário, gerenciando recursos (como memória, processamento etc.).\\
\\
\textbf{Kernel:} é o núcleo ou cerne do sistema operacional (é a parte deste que fica mais ``próxima'' do hardware).}}
\end{center}

Você pode agora estar se perguntando se deve chamar apenas o kernel de Linux. Como dito anteriormente, a rigor, Linux é o kernel. Contudo, a expressão ``sistema operacional Linux'' tornou-se muito difundida. Outra pergunta pode ter surgido neste ponto: qual o nome do sistema operacional então? Mais uma controvérsia aqui. Quando algum usuário instala ``o Linux'', ele está instalando o kernel e mais uma série de outros softwares (aplicativos etc.). Grande parte desses aplicativos pertence a um projeto chamado GNU. Logo, o sistema operacional formado pelo kernel mais utilitários e aplicativos, como defendem alguns, deveria ser chamado de GNU/Linux.

\section[Um breve histórico]{Um breve histórico - Como surgiram o GNU e o Linux\\}

No ano de 1984, Richard Stallman iniciou o Projeto GNU, que tinha por objetivo criar um 
\begin{wrapfigure}{r}{0.3\textwidth}
  \vspace{-20pt}
  \begin{center}
    \includegraphics[width=0.24\textwidth]{linustorvalds.jpg}
  \end{center}
  \vspace{-20pt}
  \caption{\textit{Linus Torvalds}}
  \vspace{-10pt}
\end{wrapfigure}sistema operacional que fosse totalmente livre.
Esse sistema operacional deveria ser compatível com outro sistema operacional - o UNIX (daí o nome GNU - GNU is Not Unix). No ano seguinte, Stallman fundou a FSF (Free Software Foundation), com o propósito de eliminar restrições de uso, cópia e distribuição de software.

Por volta de 1991, o sistema GNU estava quase pronto, exceto pelo kernel. Stallman estava trabalhando no desenvolvimento de um kernel chamado Hurd. Ao mesmo tempo, o finlandês Linus Torvalds havia criado um kernel compatível com as aplicações do projeto GNU. A esse kernel foi dado o nome de Linux. 

Atualmente, Linux tornou-se um termo genérico para se referir a sistemas operacionais ``Unix-like'' baseados no kernel Linux. Tornou-se, também, o melhor exemplo de Software Livre e de código aberto.

\section{Software Livre e Licença GPL}
Na Seção anterior, foi dito que Stallman pretendia criar um sistema operacional livre e que o GNU/Linux era um exemplo de Software Livre. A definição de Software Livre, dada pela FSF é:
\begin{center}
\fbox{\parbox[t]{16cm}{Um software é considerado livre se atende às seguintes liberdades:
\begin{itemize}
\item{Executar o software com qualquer propósito (liberdade nº 0).}
\\
\item{Estudar o funcionamento do software e adaptá-lo às suas necessidades (liberdade nº 1).}
\\
\item{Redistribuir (inclusive vender) cópias do software (liberdade nº 2).}
\\
\item{Melhorar o programa e tornar as modificações públicas para que a comunidade inteira se beneficie da melhoria (liberdade nº 3).}
\end{itemize}
}}
\newline
\end{center}

Ao contrário do que as pessoas pensam, Software Livre (do inglês \textit{Free Software}) não é sinônimo 
\begin{wrapfigure}{l}{0.3\textwidth}
  \vspace{-20pt}
  \begin{center}
    \includegraphics[width=0.3\textwidth]{stallman.jpg}
  \end{center}
  \vspace{-20pt}
  \caption{\textit{Richard Stallman}}
  \vspace{-10pt}
\end{wrapfigure}de gratuito. O que ocorre é uma confusão envolvendo a palavra ``free'' em inglês, que significa tanto gratuito como livre. Mas o sentido que Stallman queria dar era de ``livre''. De qualquer forma, a maioria dos softwares livres é distribuída de forma gratuita.

Grande parte dos projetos de software livre (incluindo o GNU/Linux) é distribuída sob a GPL (\textit{General Public License} - Licença Pública Geral), que é a licença idealizada por Stallman e que se baseia nas quatro liberdades citadas anteriormente. Com a garantia destas liberdades, a GPL permite que os programas sejam distribuídos e reaproveitados, mantendo, porém, os direitos do autor por forma a não permitir que essa informação seja usada
de uma maneira que limite as liberdades originais.

\section{Distribuições}

\begin{center}
\includegraphics[width=8cm]{distros.jpg}
\end{center}

Distribuições Linux (também chamadas Distribuições GNU/Linux ou simplesmente
\textit{distros}) consistem em ``pacotes'' de software baseados no kernel Linux
que incluem determinados tipos de software para satisfazer as necessidades de um grupo específico
de usuários, dando assim origem a versões domésticas, empresariais e para servidores.

Exemplos de Distribuições Linux: Ubuntu, Debian, Slackware, Fedora, Red Hat, Arch, Gentoo, Mandriva, openSUSE etc.
Qual é a melhor distribuição é uma questão de necessidade e gosto.\\

Apresentamos a seguir uma breve descrição de algumas distros, para que você possa ter uma ideia de suas principais
características.

\subsection{Debian}
A distro Debian (ou Debian GNU/Linux) é desenvolvida pelo Projeto Debian, um grupo de voluntários mantido por doações
através da organização sem fins lucrativos Software in the Public Interest (SPI).

Debian baseia-se fortemente no projeto GNU e tem como principais características um alto compromisso com estabilidade e
segurança bem como uma grande facilidade no que concerne à instalação de programas, através de um gerenciador de pacotes
completo (dpkg) e sua interface (apt), utilizados amplamente em outras distribuições.

A última versão estável desta distro é 5.0.

\subsection{Red Hat Entreprise Linux}
Red Hat Enterprise Linux é uma distro criada pela empresa norte-americana Red Hat. O foco desta distribuição é o
mercado corporativo, incluindo versões para servidores e para desktops.

O Red Hat Enterprise Linux não possui um ciclo de lançamentos fixo: a versão atual é a 5, mas o Red Hat Entreprise Linux 6
tem previsão de lançamento para o primeiro semestre de 2010.

\subsection{Slackware}
Simplicidade e estabilidade são duas características marcantes nesta distribuição. Muito comum em servidores,
procura ser uma distribuição ``leve'', praticamente sem enfeites e rápida, muito apreciada por usuários mais experientes.

Encontra-se atualmente na versão Slackware 13.

\subsection{Ubuntu}
Ubuntu é uma distro GNU/Linux baseada na distro Debian e é patrocinada pela Canonical.

A proposta do Ubuntu é oferecer um sistema operacional que qualquer pessoa possa utilizar sem dificuldades,
independentemente de nacionalidade, nível de conhecimento ou limitações físicas (a palavra Ubuntu é de origem
africana e significa ``humanidade para os outros'').

Essa distro oferece um ambiente atualizado e estável, focado na usabilidade e na facilidade de sua instalação.

A cada seis meses, uma nova versão da distro é lançada, a versão atual é Ubuntu 10.4. Os números 10 e 4 são,
respectivamente, o ano e o mês do lançamento da versão.

\chapter{Instalando}
Este capítulo mostrará como instalar o Ubuntu 9.10 (32 bits) através de um CD-ROM.
De fato, esta é uma tarefa muito simples, pois, ao longo dos anos, os instaladores
de quase todas as distros tornaram-se bastante amigáveis, mesmo para usuários totalmente
inexperientes.

\section{Como obter}
O Ubuntu pode ser obtido gratuitamente através do site \url{http://www.ubuntu.com/getubuntu}.

\section{Considerações sobre hardware}
Antes de proceder com a instalação, o usuário deve saber se sua configuração de hardware
irá funcionar. Todas as distros publicam alguma lista de compatibilidade de hardware, consulte-a se estiver em dúvida sobre algum dispositivo.\\

Seguem abaixo as configurações mínima e recomendada para instalação em desktop do Ubuntu 9.10. É importante salientar que,
devido ao ambiente gráfico, configurações superiores podem ser necessárias.

\subsection{Configuração mínima}
\begin{itemize}
\item{processador 300 MHz x86}
\item{64 MB de RAM}
\item{Pelo menos 4 GB de espaço em disco (para instalação completa e swap)}
\item{placa de vídeo VGA com suporte para resolução 640x480}
\item{drive CD-ROM ou placa de rede}
\end{itemize}

\subsection{Configuração recomendada}
\begin{itemize}
\item{processador 700 MHz x86}
\item{384 MB de RAM}
\item{8 GB de espaço em disco}
\item{placa de vídeo com suporte para resolução 1024x768}
\item{placa de som}
\item{conexão com a Internet}
\end{itemize}

\section{Instalando o Ubuntu 9.10}
\begin{enumerate}
\item{A primeira tela da instalação deve ser esta que
aparece abaixo. Selecione a língua de sua preferência.
\begin{center}
\includegraphics[width=12cm]{01.png}
\end{center}}

\item{A seguir, selecione a segunda opção ``Instalar o Ubuntu''.
\begin{center}
 \includegraphics[width=12cm]{02.png}
\end{center}

\textit{\textbf{\\Observação:} O CD do Ubuntu é um Live CD. Isso significa que o usuário pode executar o sistema operacional
direto do CD, sem precisar instalar nada nem efetuar qualquer mudança em seu disco rígido. Para fazer isso,
basta selecionar a opção ``Testar o Ubuntu sem qualquer mudança no seu computador''.
Esta é uma boa alternativa para quem quer testar o sistema antes de instalá-lo.}}

\item{Você verá um wallpaper por alguns segundos. Quando o instalador aparecer, você poderá selecionar a língua
de sua preferência para o processo de instalação e para o sistema.
\begin{center}
\includegraphics[width=14.5cm]{03.png}
\end{center}}

\item{Agora você deverá selecionar sua localização, para que o horário seja ajustado pelo sistema e
as atualizações sejam feitas a partir de locais mais próximos. Você
poderá fazer isso clicando no mapa ou nas listas.
\begin{center}
 \includegraphics[width=14.5cm]{04.png}
\end{center}}

\item{Selecione o layout do teclado.
\begin{center}
 \includegraphics[width=14cm]{05.png}
\end{center}}

\item{Esta é a parte em que o usuário irá decidir ``onde'' instalar o sistema. Neste módulo, não abordaremos
todos os detalhes dessa etapa. Por enquanto, apenas mostramos como instalar o Ubuntu utilizando o disco todo.
\begin{center}
 \includegraphics[width=14cm]{06.png}
\end{center}
\textit{\textbf{Observação:} É possível instalar o Ubuntu (e outras distros também) lado a lado com outros sistemas
operacionais (incluindo outras distros). Isso significa que você não precisará abandonar o Windows (ou outro
sistema de sua preferência) para poder instalar o GNU/Linux em seu HD. É possível selecionar qual sistema se
deseja usar no processo de boot da máquina. Este assunto será abordado num outro módulo do curso.}}

\item{A seguir, preencha a tela seguinte, de acordo com o que cada título diz. Preencha com seu nome, com o
nome que você deseja logar-se no Ubuntu (seu ``username''), a senha de sua preferência e o nome do computador.
\begin{center}
 \includegraphics[width=14cm]{07.png}
\end{center}}

\item{Nesta tela, você deverá conferir se as opções definidas para a instalação estão corretas.
Se estiver tudo ok, clique em ``Instalar''.
\begin{center}
 \includegraphics[width=14cm]{08.png}
\end{center}
}

\item{O sistema será instalado, podendo levar de 10 a 20 minutos (a depender do hardware de sua máquina).
Quando a instalação estiver completa, será necessário reiniciar o computador.
\begin{center}
\includegraphics[width=14cm]{11.png}
\end{center}}

\item{Pronto. O Ubuntu 9.10 está instalado em sua máquina.}

\end{enumerate}

\chapter{Ambiente Gráfico}
No Linux (como UNIX, em geral), o sistema operacional é independente da GUI (\textit{Graphical User Interface} - Interface Gráfica do Usuário, ou simplesmente, interface gráfica).
Existem várias vantagens que essa abordagem proporciona: permite que o usuário escolha a interface de sua preferência; além disso, se a interface gráfica falha, o sistema continua funcionando.
Para alguns, pode ser um pouco estranho falar em sistema sem interface gráfica. Contudo, não é somente através
do modo gráfico que o usuário consegue interagir com o sistema, é possível fazê-lo através de uma outra maneira - usando o modo texto, assunto que será abordado no Capítulo 6.

\section{X Window System}
X Window System (ou simplesmente X11 ou X) é o toolkit e protocolo padrão para interface gráfica em plataformas UNIX e similares (como o Linux). Ele não é uma interface gráfica completa: apenas define como os objetos básicos devem ser desenhados e manipulados na tela. O X pode ser executado em máquinas locais ou remotamente, através de uma rede.

\section{Ambientes Desktop}
O X é a base para a interface gráfica no GNU/Linux, mas não inclui nenhuma definição
sobre a aparência das janelas. O controle da aparência é feito por outro programa, chamado
gerenciador de janelas (\textit{window manager}). 
Exemplos de gerenciadores de janelas são o FVWM, FluxBox, Xfce, GNOME e KDE.
Estes dois últimos transcendem o conceito de gerenciador de janelas e são ambientes desktop (\textit{desktop environment}), ou seja, propõem-se a
oferecer uma interface mais completa para o sistema operacional, incluindo utilitários integrados e aplicações.\\
\begin{center}
\includegraphics[width=8cm]{kde.png}
\includegraphics[width=8cm]{fluxbox.png}
\\
\textit{\\KDE e FluxBox.}
\end{center}

\begin{center}
\includegraphics[width=12cm]{ubuntu.png}
\textit{\\GNOME (Ubuntu 9.10).}
\end{center}

\section{Desempenhando tarefas}
A proposta da interface gráfica é o uso intuitivo. Apesar disso, mostramos a seguir como desempenhar algumas tarefas simples e
corriqueiras, apenas para efeito ilustrativo. A interface usada é o GNOME (Ubuntu 9.10).

\subsection{Acessando a internet}
No Ubuntu 9.10, o navegador Firefox já vem instalado e já existe um atalho para acessá-lo:
\begin{center}
\includegraphics[width=7.5cm]{firefox.png}
\end{center}

\begin{center}
\includegraphics[width=12cm]{firefox2.png}
\end{center}

\subsection{Editando um documento num processador de texto}
A maioria dos leitores deve estar acostumada a usar o Microsoft Word (do pacote Office) para editar arquivos de texto com
formatação. No Ubuntu 9.10, já vem instalado o pacote do OpenOffice.org, que possui formatos próprios de arquivo mas que
também consegue abrir arquivos ``.doc''.
\begin{center}
\includegraphics[width=12cm]{open.png}
\end{center}

\begin{center}
\includegraphics[width=12cm]{open2.png}
\end{center}

\subsection{Instalando programas}
Existem várias maneiras de instalar programas no GNU/Linux. Mostramos aqui uma ferramente chamada Synpatic, presente não apenas
no Ubuntu, mas em outras distros também. O Synaptic nada mais é do que um programa que oferece uma interface gráfica amigável
para instalar programas.
\begin{center}
\includegraphics[width=11cm]{syn.png}
\end{center}

\begin{center}
\includegraphics[width=14cm]{syn2.png}
\end{center}

\chapter{Aplicativos}
Basicamente, para qualquer programa que você utilizava no Windows, existe uma alternativa no GNU/Linux.
A tabela abaixo propõe-se a oferecer algumas destas alternativas.

\begin{center}
\begin{tabular}{|c|c|c|}
\hline
\textbf{Descrição} & \textbf{Programas usados} & \textbf{Programas usados}\\
 & \textbf{no Windows} & \textbf{no GNU/Linux}\\ 
\hline
Pacote Office & Microsoft Office & KOffice, OpenOffice\\
\hline
Processador de Texto & Microsoft Word & KWrite, OpenOffice Writer\\
\hline
Planilhas & Excel & KSpread, OpenOffice Calc\\
\hline
Apresentações & PowerPoint & KPresenter,\\
& & OpenOffice Impress\\
\hline
E-mail & Outlook & Evolution\\
\hline
Gravação de mídia & Nero & Brasero, K3b\\
\hline
IDEs LaTeX & TeXnicCenter, WinEdit & Kile, Texmaker\\
\hline
Compactadores de arquivos & Winrar, Winzip & ark, bzip2, tar\\
\hline
Leitor de PDF & Adobe Reader & Adobe Reader, Evince, Kpdf\\
\hline
Modelagem 3D & 3D Studio MAX, Blender, Maya & Blender, K-3D, Maya\\
\hline
Players de vídeo & Windows Media Player & Kaffeine, MPlayer\\
& & Totem, VLC\\
\hline
Players de música & iTunes, Winamp,& Amarok, Audacious,\\
& Windows Media Player & RhythmBox\\
\hline
Edição de vídeos & Windows Movie Maker & Cinelerra, Kino\\
\hline
Clientes P2P BitTorrent & $\mu$Torrent, Azureus & Azureus, KTorrent,\\
& & Transmission\\
\hline
Mensageiros instantâneos & MSN & aMSN, Kopete, Pidgin\\
\hline
Browser & Firefox, Google Chrome, & Firefox, Galeon, Google Chrome,\\
& Microsoft Internet Explorer, & Konqueror, Opera\\
& Opera & \\
\hline
\end{tabular}
\end{center}

\textit{\textbf{Observação:} Vários dos aplicativos listados apenas em ``Programas usados no GNU/Linux'' também
funcionam no Windows (o VLC, por exemplo).}

\chapter{Diretórios e arquivos}
Muitos usuários têm dificuldades com o GNU/Linux porque não têm uma visão geral sobre o que está guardado
em que local. Neste capítulo, mostramos um pouco da organização dos arquivos do GNU/Linux.

\section{Visão geral da organização dos arquivos no Linux}
Grosso modo, pode-se dizer que, no Linux, tudo é arquivo. Se há algo que não seja um arquivo, então este algo
é um processo. No GNU/Linux (como no UNIX), não há diferença entre arquivo e diretório, uma vez que um diretório
é apenas um arquivo contendo nomes de outros arquivos. Imagens, músicas, textos, programas, serviços e assim por
diante são todos arquivos. Dispositivos de entrada e saída, e geralmente, todos os dispositivos, são considerados
como arquivos.\\

Todos estes arquivos estão organizados de acordo com uma hierarquia, isto é, há critérios que prevêm os principais
diretórios e seu conteúdo. Estes critérios são definidos por um padrão, o FHS (\textit{Filesystem Hierarchy Standard}).

\begin{center}
 \includegraphics[height=7cm]{fhs.png}
\end{center}

No topo da hierarquia de arquivos fica o chamado diretório raiz (ou, mais apropriadamente, diretório root), pois a estrutura
de diretórios é chamada também de ``Árvore de Diretórios''.

\subsection{Diretório root -- /}
Este é o diretório principal do sistema. Dentro dele estão todos os diretórios do sistema. O diretório root
é representado por uma barra (/).
\subsection{/bin}
Contém comandos e programas essenciais para todos os usuários (alguns desses comandos serão tratados no próximo capítulo).
\subsection{/boot}
Contém arquivos necessários para a inicialização do sistema.
\subsection{/dev}
Dispositivos: o /dev contém referências para todos os dispositivos, os quais são representados como arquivos
com propriedades especiais.
\subsection{/etc}
Contém arquivos de configuração.
\subsection{/home}
Contém os diretórios dos usuários.
\subsection{/lib}
Contém bibliotecas (que são subprogramas ou códigos auxiliares utilizados por programas) essenciais para o funcionamento do
Linux, e também os módulos do kernel.
\subsection{/media}
Este diretório contém subdiretórios que são usados como pontos de montagem para mídias removíveis, como disquetes, cdroms,
pen drives etc.
\subsection{/root}
Diretório ``home'' do super usuário (usuário root). \textbf{Não confundir com o diretório root, o /. O diretório
/root contém os arquivos do usuário root. O diretório / é o topo da hierarquia de arquivos.}
\begin{center}
\fbox{\parbox[b]{15cm}{\textbf{Usuário root:} É o administrador do sistema, possui acesso a todos os comandos
e arquivos.}}
\end{center}
\subsection{/tmp}
Para arquivos temporários.
\subsection{/usr}
Contém programas, bibliotecas etc.

\subsubsection{/usr/bin}
É onde ficam os binários de programas não-essenciais (os essenciais ficam no /bin).

\subsubsection{/usr/src}
Código-fonte.

\subsection{/var}
Contém arquivos ``variáveis'', como logs, base de dados.

\subsubsection{/var/log}
Como o próprio nome diz, possui arquivos de log.
\begin{center}
\fbox{\parbox[b]{15cm}{\textbf{Arquivo de log:} É um arquivo que armazena registros de eventos relevantes de um programa ou do sistema.}} 
\end{center}

\subsubsection{/var/run}
Contém informação sobre a execução do sistema desde a sua última inicialização.\\
\newline

\leftskip=0.0cm
Existem outros diretórios previstos no padrão, mas, por enquanto, estes já são suficientes.

\section{Caminho absoluto X Caminho relativo}
Caminho de um diretório são os diretórios que devemos percorrer até chegar a ele. Vamos diferenciar caminho absoluto de caminho
relativo por meio de um exemplo. 

Consideremos o diretório xinit (você não precisa se preocupar com ele, é apenas um exemplo. O que
importa realmente aqui é o conceito de caminho até o arquivo). Consideremos que este diretório encontra-se dentro de um outro diretório,
o diretório X11. Este X11, por sua vez, está dentro do diretório etc, que, finalmente, está sob o diretório root, o /. Recapitulando: temos
o / e dentro o etc (/etc), e dentro o X11 (/etc/X11) que contém o xinit (/etc/X11/xinit). Logo, ``/etc/X11/xinit'' é o \textbf{caminho
absoluto} para o diretório xinit, ou seja, são os diretórios que devemos percorrer, começando pelo /, até o diretório xinit.

Consideremos agora os mesmos diretórios do caso anterior (/etc/X11/xinit). Suponhamos agora que estamos no diretório etc. Para dizer
qual é o caminho do diretório xinit, bastaria dizer apenas X11/xinit - este é o \textbf{caminho relativo} do diretório (em relação ao diretório
/etc). Se estivéssemos no diretório X11, o \textbf{caminho relativo} seria simplesmente xinit.\\

Em suma, caminho absoluto é aquele que utiliza toda a estrutura de diretórios, ao passo que o relativo toma um diretório como referência
e define o caminho a partir daí.

\section{Permissões de acesso}
O Linux foi desenvolvido para ser um sistema \textit{multi-usuário}. Isto significa que vários usuários podem ter
configurações personalizadas, independentes das dos demais usuários, bem como diferentes usuários podem executar tarefas ao
mesmo tempo numa mesma máquina. Assim sendo, cada usuário pode querer negar ou permitir o acesso a determinado arquivo ou
diretório. Por isso, existem as chamadas permissões de acesso do Linux: para impedir o acesso indevido de outros usuários ou
mesmo de programas mal intencionados a arquivos e diretórios.

Mostraremos algumas destas permissões nesta seção. Mais adiante, no próximo capítulo, mostraremos como manipulá-las.

\subsection{Donos, grupos, outros}
No Linux, \textbf{para cada arquivo são definidas permissões para três tipos de usuários}: o dono do arquivo, um grupo de usuários
e os demais usuários (que não são nem o dono, nem pertencem ao grupo).
\begin{itemize}
\item{\textbf{Dono:} O dono do arquivo é o usuário que criou o mesmo. Somente o dono e o usuário root podem mudar as
permissões para um arquivo ou diretório.}
\item{\textbf{Grupo:} É um conjunto de usuários. Grupos foram criados para permitir que vários usuários tivessem acesso a
um mesmo arquivo.}
\item{\textbf{Outros:} Como dito anteriormente, são os usuários que não se encaixam nos tipos de usuários supracitados.}
\end{itemize}

\subsection{Tipos de permissões}
Os três tipos básicos de permissão para arquivos e diretórios são:
\begin{itemize}
\item{\textbf{r (read):} permissão de leitura para arquivos. Caso seja um diretório, permite listar seu conteúdo (com o
comando ls, por exemplo - que será visto no próximo capítulo).}
\item{\textbf{w (write):} permissão de escrita para arquivos. Caso seja um diretório, permite a gravação de arquivos
ou outros diretórios dentro dele. Para que um arquivo/diretório possa ser apagado, é necessário o acesso à escrita
(gravação).}
\item{\textbf{x (execute):} permite executar um arquivo. Caso seja um diretório, permite que seja acessado através
do comando cd (você verá este comando também no próximo capítulo, equivale a ``entrar'' no diretório).}
\end{itemize}

Em suma, para cada arquivo do sistema, são definidas permissões para o dono do arquivo, para um grupo de usuários e para
os demais usuários. Essas permissões são de leitura, escrita e execução (r, w ou x). Você entenderá melhor estes conceitos
no próximo capítulo, mas tente familiarizar-se com eles desde já.
\chapter{Modo texto}
Como dito anteriormente, não é apenas pelo modo gráfico que o usuário consegue interagir com o sistema. É possível fazer isso pelo
modo texto, digitando comandos e nomes de programas para conseguir uma ``resposta'' do sistema. Por isso, o modo texto é também chamado
de linha de comando. 

É importante para um usuário do GNU/Linux aprender a trabalhar no modo texto por vários motivos: otimiza várias tarefas, existem alguns programas que rodam
somente no modo texto e também porque o modo gráfico consome mais recursos. \\
\newline

Você deve estar se perguntando agora como é que se faz para usar o GNU/Linux em modo texto. Na verdade, existem duas formas.\\

Você
pode acessar um terminal ``puro'', pressionando as teclas ``Ctrl+Alt+F1'' (substituir o F1 por F2, de F3 até F6 também funciona
na maior parte das distros) e depois voltar ao modo gráfico pressionando ``Alt+F7'' (funciona para a maioria das
distros).
\begin{center}
 \includegraphics[width=9cm]{tty1.png}
\end{center}

Uma tela de login do modo texto geralmente mostra alguma informação sobre a máquina na qual você está trabalhando,
o nome da máquina e um prompt para login. Para logar-se, digite o nome de usuário e tecle Enter. Agora você
deverá digitar sua senha e teclar Enter novamente. O usuário não verá nenhuma indicação de que está digitando a
senha (não aparecerão asteriscos nem nada do gênero, por motivos de segurança), mas isso é normal no GNU/Linux.

\begin{center}
 \includegraphics[width=6cm]{login.png}
\\
\end{center}

A segunda forma é usar um ``emulador de terminal'', isto é, dentro do modo gráfico, abre-se um programa que
funciona como linha de comando.
Para fazer isso no ambiente GNOME, vá em Aplicativos $\Rightarrow$ Acessórios $\Rightarrow$ Terminal.
\begin{center}
 \includegraphics[width=11cm]{terminal.png}
\end{center}

\section{Shell}
De qualquer uma das duas formas, o que você verá rodando (após logar-se ou acessar o Terminal)
é um programa chamado shell, que é um interpretador de comandos.

\section {BASH}
O BASH (Bourne Again Shell) é o shell desenvolvido para o projeto GNU, da Free Software Foundation,
que se tornou padrão nas várias distribuições Linux (incluindo Ubuntu).

\section{Comandos}
Nesta seção, examinaremos alguns comandos simples do BASH. É importante que você saiba que não é preciso decorar
os comandos apresentados. Para aprendê-los de fato, você deve ir praticando com os exercícios propostos e
conforme a sua necessidade. 

\subsection{Prompt}
O prompt do BASH tem a seguinte aparência:
\begin{verbatim} 
        username@nomedamáquina:diretório$
\end{verbatim}

No caso de
\begin{verbatim}
        curso@curso-desktop:~$
\end{verbatim}
curso é o nome do usuário, curso-desktop é o nome da máquina, $\texttildelow$ é o diretório em que o usuário se encontra 
($\texttildelow$ representa o diretório home do usuário, nesse caso, /home/curso), e o $\textdollar$ é o
símbolo do tipo de usuário (nesse caso, um usuário normal).
Se fosse o usuário root (administrador do sistema), o símbolo seria \#.

\subsection{Sintaxe dos comandos}
É importante lembrar que a linha de comando é \textit{case sensitive}, isto é, diferencia letras maiúsculas de
minúsculas. Portanto, ``echo'' é diferente de ``Echo'', que são diferentes de ``ECHO''. Isso também vale para
nomes de diretórios e arquivos.

Os comandos são, em geral, em letras minúsculas. Muitos deles aceitam argumentos. Os argumentos que começam com
um (ou dois) ``-'' são opções.
\begin{verbatim}
        comando -opção1 -opção2 --opção3 argumento
\end{verbatim}

Quando os argumentos forem arquivos ou diretórios, tanto o caminho absoluto como o relativo poderão ser usados.

Outro ponto importante é que você pode digitar os comandos e nomes de arquivos ou diretórios pela metade e depois
pressionar ``Tab''. O shell ``tentará completar'' o que falta para você. Se houver mais de uma opção para completar
o que foi digitado, as alternativas possíveis serão mostradas. Este é um recurso que facilita muito o uso da linha 
de comando.\\
\newline
Vamos então aos comandos.

\subsection[pwd]{pwd (print working directory)}
Mostra o nome e o caminho do diretório atual (diretório em que o usuário está).
\begin{verbatim}
        curso@curso-desktop:~$ pwd
        /home/curso
\end{verbatim}
\subsection[ls]{ls (list)}
Lista os arquivos  e subdiretórios de um ou mais diretórios.\\

\textbf{Sintaxe básica:}
\begin{verbatim}
        ls [opções] [diretório1] [diretório2] ...

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{O comando abaixo lista os diretórios e arquivos do /.
\begin{verbatim}
    $ ls /
\end{verbatim}}

\item{O comando abaixo lista os diretórios e arquivos do /etc.
\begin{verbatim}
    $ ls /etc 
\end{verbatim}}

\item{Para listar o conteúdo do / e do /etc, de uma só vez, use:
\begin{verbatim}
    $ ls / /etc

\end{verbatim}}
\end{enumerate}

\textbf{Exercício:} Liste o conteúdo do diretório /tmp.\\
\newline

Para listar o conteúdo do diretório atual, basta digitar apenas ``ls''.
Se o usuário estiver em seu diretório home e digitar ls, a saída será os arquivos e diretórios
contidos no /home/username.

Suponha ainda que o usuário encontra-se em seu diretório home. Existe, dentro do home do usuário, um diretório
chamado ``Documentos''. Se quisermos listar o conteúdo deste, podemos usar o comando
\begin{verbatim}
        $ ls /home/username/Documentos
\end{verbatim}
mas também podemos usar o caminho relativo (lembra-se?):
\begin{verbatim}
        $ ls Documentos

\end{verbatim}

\textbf{Opções:}
\begin{itemize}
\leftskip=0.8cm
\item{\textbf{-a ou --all:} Lista todos os arquivos e diretórios, incluindo os ocultos. No GNU/Linux, os arquivos e diretórios
ocultos começam por ``.''. Quando usamos o comando ls como anteriormente (sem nenhuma opção), esses arquivos não são listados.\\

\textbf{Exemplo}

O comando abaixo listará todos os arquivos e diretórios contidos no barra, incluindo os ocultos.
\begin{verbatim}
        $ ls -a /
\end{verbatim}
\textbf{Exercício:} Liste todo o conteúdo do seu diretório home, incluindo os itens ocultos. (Quando fizer isso, você
notará que dois itens ``estranhos'' foram listados: o ``.'' e o ``..''. Eles representam, respectivamente, o diretório
atual e o diretório acima. Se você estiver em seu diretório home e usar o comando ``ls ../'', o conteúdo do /home será
listado).
}

\item{\textbf{-R:} Lista o conteúdo de um diretório e dos subdiretórios, recursivamente. Quando você utiliza
o comando ls, os arquivos e diretórios contidos num determinado diretório são mostrados. Usando a opção -R, serão
listados os arquivos contidos num determinado diretório, e para cada subdiretório também serão listados os arquivos
e diretórios nele contidos. E para cada um desses diretórios, também será listado todo o seu conteúdo e assim
sucessivamente. Se você usasse ``ls -R /'', o conteúdo de todos os diretórios seria mostrado (não estamos recomendando
que você rode este comando, está aqui apenas para que você entenda o que faz esta opção).}

\item{\textbf{-l:} Usa o formato longo para listagem, o que significa que serão listados detalhes sobre cada arquivo
e diretório mostrado. Vamos examinar que detalhes são estes.
\begin{verbatim}
      curso@curso-desktop:~$ ls -l
      drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Área de Trabalho
      drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Documentos
      drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Downloads
      -rw-r--r-- 1 curso curso  167 2010-01-18 11:41 examples.desktop
      -rw-r--r-- 1 curso curso    8 2010-01-18 12:24 exemplo
      drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Imagens
      drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Modelos
      drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Música
      drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Público
      drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Vídeos
\end{verbatim}
Tomemos a primeira linha do resultado obtido:
\begin{verbatim}
   drwxr-xr-x 2 curso curso 4096 2010-01-18 11:54 Área de Trabalho
\end{verbatim}
\begin{itemize}
\item{drwxr-xr-x -- indicam as permissões.}
\item{2 -- indica o número de subdiretórios contidos.}
\item{curso -- é o dono do arquivo ou diretório.}
\item{curso -- é o grupo ao qual o arquivo ou diretório pertence.}
\item{4096 -- tamanho do arquivo (em bytes).}
\item{2010-01-18 11:54 -- data e hora em que o arquivo ou diretório foi criado/modificado.}
\item{Área de Trabalho -- nome do arquivo ou diretório.} 
\\
\end{itemize}

\textbf{Permissões}

A primeira letra (d) indica que ``Área de Trabalho'' é um diretório. Se fosse um arquivo normal, teríamos um ``-'' 
no lugar (é o caso de examples.desktop e exemplo). Os próximos nove caracteres representam as permissões do diretório.
As permissões de um arquivo ou diretório são r, w e x, apresentadas no capítulo anterior (lembra-se? Leitura, escrita e
execução.).

Para cada três caracteres são mostradas as permissões para um tipo de usuário. Os três primeiros caracteres,
no caso ``rwx'', indicam as permissões para o dono do arquivo. A interpretação desta trinca é que o dono do arquivo
(no caso, o usuário ``curso''), possui as três permissões sobre o diretório (leitura, escrita e execução). Os três
próximos caracteres mostram as permissões para o grupo: ``r-x'', o que significa que o grupo possui permissão de
leitura e execução, mas não possui permissão de escrita (há um ``-'' no lugar do ``w'' de
escrita). Por último, temos a permissão para os demais usuários do sistema (``r-x'' -- permissão de leitura e
execução).\\

\textbf{Número de subdiretórios}

O número da segunda coluna representa o número de subdiretórios contidos. Se for um arquivo comum, esse número
será 1.\\

\textbf{Dono do arquivo}

A terceira coluna representa o dono do arquivo, que, como dito anteriormente, é o usuário que criou o arquivo ou
diretório.\\

\textbf{Grupo}

O grupo ao qual o arquivo pertence está mostrado na quarta coluna.\\

\textbf{Tamanho}

A coluna seguinte mostra o tamanho do arquivo em bytes. No caso de um diretório, não é mostrado o tamanho
total, isto é, considerando todo o conteúdo do diretório, mas sim o tamanho da estrutura diretório, isto é,
ainda que seja criado um diretório vazio, ele ocupará 4096 bytes de espaço em disco.\\

Como último comentário sobre este comando, vale dizer que é possível usar mais de uma opção de cada vez. Aliás,
isso vale para todo comando.

O comando a seguir lista todos os diretório e arquivos do /, incluindo os ocultos, usando o formato longo de
listagem.
\begin{verbatim}
        $ ls -a -l /
\end{verbatim}
Também é possível fazer isso da seguinte forma:
\begin{verbatim}
        $ls -al /
\end{verbatim}
\textbf{Exercícío:} Liste os arquivos e diretórios do seu diretório home, incluindo os ocultos e o conteúdo
dos subdiretórios.}
\end{itemize}

\subsection[cd]{cd (change directory)}
Entra em um diretório.\\

\textbf{Sintaxe básica:}
\begin{verbatim}
        cd [diretório]

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Para entrar no diretório root, use
\begin{verbatim}
         $ cd /
\end{verbatim}}
\item{Para entrar no diretório /tmp, basta usar o seguinte comando
\begin{verbatim}
         $ cd /tmp
\end{verbatim}}
\item{Para subir um diretório acima, use:
\begin{verbatim}
         $ cd ..
\end{verbatim}}
\item{Para voltar ao diretório imediatamente anteriormente acessado, basta
usar:
\begin{verbatim}
         $ cd -

\end{verbatim}}
\end{enumerate}

\textbf{Exercícios}
\begin{enumerate}
\leftskip=0.8cm
\item{Entre no diretório home do seu usuário (``/home/seu-usuario-aqui''). Agora use o seguinte comando:
\begin{verbatim}
         $ cd ../../
\end{verbatim}
Use outro comando para descobrir em que diretório você acabou de entrar.}
\item{O que acontece se você digitar apenas o comando ``cd'', sem nenhum argumento?}
\end{enumerate}

\subsection[mkdir]{mkdir (make directory)}
Cria novos diretórios (vazios).\\

\textbf{Sintaxe básica:}
\begin{verbatim}
         $ mkdir [caminho1/diretório1] [caminho2/diretório2] ...

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Para criar os diretórios ``Pasta1'' e ``Pasta2'' dentro do diretório /tmp, fazemos:
\begin{verbatim}
         $ mkdir /tmp/Pasta1 /tmp/Pasta2
\end{verbatim}

Naturalmente, se estivéssemos dentro do diretório /tmp, não seria necessário usar o caminho
absoluto:
\begin{verbatim}
         $ pwd
         /tmp
         $ mkdir Pasta1 Pasta2
\end{verbatim}}
\end{enumerate}
\subsection[rmdir]{rmdir (remove directory)}
Remove um ou mais diretórios vazios.\\

\textbf{Sintaxe básica:}
\begin{verbatim}
         $ rmdir [caminho1/diretório1] [caminho2/diretório2] ...

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Para remover os diretórios ``Pasta1'' e ``Pasta2'' criados como nos exemplos do comando mkdir,
poderíamos usar:
\begin{verbatim}
         $ rmdir /tmp/Pasta1 /tmp/Pasta2
\end{verbatim}}
\end{enumerate}

\textbf{Exercícios}
\begin{enumerate}
\leftskip=0.8cm
\item{Vá até seu diretório home e crie um diretório chamado ``Teste''. Use o comando ls para ver
que o diretório foi criado. Remova o diretório criado e use novamente o comando ls para ver que
a pasta foi removida.}
\end{enumerate}
\subsection{touch}
Pode ser usado para criar novos arquivos vazios e também para mudar a data e a hora de criação de
arquivos existentes.\\

\textbf{Sintaxe básica:}
\begin{verbatim}
         touch [opções] [arquivo1] [arquivo2] ...

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Para criar um arquivo vazio chamado ``arquivonovo'' no diretório atual, poderíamos usar:
\begin{verbatim}
         $ touch arquivonovo

\end{verbatim}}
\end{enumerate}

\textbf{Opções}
\begin{itemize}
\leftskip=0.8cm
\item{\textbf{-t [[YY]YY]MMDDhhmm[.ss]} - Altera a data e hora do arquivo para o ano YYYY (nesse caso, pode-se
usar os quatro dígitos ou apenas dois), para o mês MM, para o dia DD, para a hora hh, para o minuto mm e para
o segundo ss. Lembrando que as opções de ano e segundo são opcionais (por isso foram colocadas entre colchetes).}
\end{itemize}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Para alterar a data do arquivo ``arquivonovo'' para o dia 16/11 (16 de novembro), e o horário para 16h11min,
usamos:
\begin{verbatim}
          $ touch -t 11161611 arquivonovo
\end{verbatim}}
\item{Suponhamos que quiséssemos alterar os segundos também (para 11, por exemplo):
\begin{verbatim}
          $ touch -t 11161611.11 arquivonovo
\end{verbatim}}
\item{Por fim, se quiséssemos que a data do arquivo ``arquivonovo'' fosse 01/01/2013, com horário
0h0min, rodaríamos o comando da seguinte forma:
\begin{verbatim}
          $ touch -t 201301010000 arquivonovo
\end{verbatim}}
\end{enumerate}

\textbf{Exercícios}
\begin{enumerate}
\leftskip=0.8cm
\item{Qual é a diferença entre o resultado produzido pelos dois comandos a seguir?
\begin{verbatim}
          $ touch "arquivo novo"
\end{verbatim}
e
\begin{verbatim}
          $ touch arquivo novo
\end{verbatim}}
\item{Crie um arquivo chamado ``teste'' em seu diretório home, usando o comando touch. Use ls (com a
opção -l) para ver a data do novo arquivo criado. Mude a data e o horário do arquivo para o seu nascimento e
use o comando ls para ver a nova data do arquivo.}
\end{enumerate}
\subsection[rm]{rm (remove)}
Remove arquivos e diretórios.\\

\textbf{Sintaxe básica:}
\begin{verbatim}
          $ rm [opções] [arquivo1] [arquivo2] ...

\end{verbatim}

\textbf{Exemplos:}
\begin{enumerate}
\leftskip=0.8cm
\item{Criamos um arquivo chamado ``teste'' no diretório /tmp:
\begin{verbatim}
          $ touch /tmp/teste
\end{verbatim}
Agora vamos removê-lo:
\begin{verbatim}
          $ rm /tmp/teste
\end{verbatim}}
\end{enumerate}

\textbf{Opções}
\begin{itemize}
\leftskip=0.8cm
\item{\textbf{-r:} Opção usada para remover recursivamente diretórios e seu conteúdo. Pode ser usada também
para remover diretórios vazios.}
\end{itemize}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Vamos criar um diretório (vazio) chamado ``Pasta''.
\begin{verbatim}
          $ mkdir Pasta
\end{verbatim}
Se usarmos o seguinte comando para removê-lo, veremos um erro e o diretório não será removido:
\begin{verbatim}
          $ rm Pasta
          ERRO!
\end{verbatim}
Para removê-lo, teríamos que fazer:
\begin{verbatim}
          $ rm -r Pasta
\end{verbatim}
Poderíamos também usar o comando rmdir já apresentado.
}
\item{Vamos criar agora um diretório chamado ``Pastateste'' dentro do diretório /tmp. E dentro de
``Pastateste'', isto é, no /tmp/Pastateste, vamos criar um arquivo chamado ``Arquivoteste''. Depois
vamos removê-los.
\begin{verbatim}
          $ mkdir /tmp/Pastateste
          $ touch /tmp/Pastateste/Arquivoteste
\end{verbatim}
Para remover, poderíamos fazer da seguinte maneira:
\begin{verbatim}
          $ rm /tmp/Pastateste/Arquivoteste
          $ rmdir /tmp/Pastateste
\end{verbatim}
Mas a opção -r do comando rm nos permite remover o diretório e todo o seu conteúdo. Por isso, o comando
a seguir já seria suficiente para remover o diretório ``Pastateste'' e seu conteúdo (no caso, o arquivo
``Arquivoteste''.
\begin{verbatim}
          $ rm -r /tmp/Pastateste
\end{verbatim}}
\end{enumerate}

\textbf{Atenção:} O comando rm é definitivo, ou seja, uma vez que o usuário removeu um arquivo (ou um diretório),
este não poderá ser recuperado. Não funciona simplesmente como uma lixeira, mas sim remove definitivamente o que
for passado como argumento.
\subsection[cp]{cp (copy)}
Este comando serve para copiar arquivos.\\

\textbf{Sintaxe básica:}
\begin{verbatim}
          $ cp [opções] [origem] [destino]

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Para copiar o arquivo ``teste'' do /tmp para o diretório home do usuário:
\begin{verbatim}
          $ cp /tmp/teste ~
\end{verbatim}}
\end{enumerate}

\textbf{Opções}
\begin{itemize}
\leftskip=0.8cm
\item{\textbf{-R:} Copia recursivamente os subdiretórios e seu conteúdo.}
\end{itemize}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Suponha que um usuário possui um diretório no /tmp (/tmp/diretorio) e quer copiá-lo para sua home. Suponha ainda
que esse diretório a ser copiado não está vazio.
\begin{verbatim}
          $ cd /tmp/diretorio
          $ ls
          arquivo
          $ cp -R /tmp/diretorio ~ 
\end{verbatim}}
\end{enumerate}
\subsection[mv]{mv (move)}
Move e renomeia arquivos e diretórios.\\

\textbf{Sintaxe básica}
\begin{verbatim}
          $ mv [opções] [origem] [destino]

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Suponha que um usuário possui um arquivo em sua home chamado arquivo1. Para renomear
este arquivo para arquivonovo, supondo que o usuário está em sua home, bastaria usar:
\begin{verbatim}
          $ mv arquivo1 arquivonovo
\end{verbatim}}
\item{Suponhamos agora que queremos mover o ``arquivonovo'' para o diretório /tmp. Para isso,
o seguinte comando seria eficaz (estamos supondo ainda que o usuário está em sua home):
\begin{verbatim}
          $ mv arquivonovo /tmp/
\end{verbatim}
Após a execução desse comando, ``arquivonovo'' estaria no diretório /tmp e não haveria mais
uma cópia do arquivo no diretório home do usuário.}
\end{enumerate}

\textbf{Opções}
\begin{itemize}
\leftskip=0.8cm
\item{\textbf{-r:} Como outros comandos, essa opção move diretórios e seu conteúdo recursivamente.}
\end{itemize}
\subsection[cat]{cat (concatenate)}
Concatena arquivos e imprime o resultado no terminal.\\

\textbf{Sintaxe básica}
\begin{verbatim}
          $ cat [arquivo1] [arquivo2] ...
\end{verbatim}

Para ilustrar o uso deste comando, vamos primeiro criar dois arquivos de texto não-vazios. Para isso, abra
um editor de texto - pode ser qualquer um, utilizaremos o gedit por ser bastante simples.
\begin{center}
\includegraphics[width=11cm]{gedit.png}
\end{center}

Crie dois arquivos (arquivo1 e arquivo2), contendo qualquer texto e salve-os no diretório home do usuário.
\begin{center}
\includegraphics[width=11cm]{gedit3.png}
\end{center}

\begin{center}
\includegraphics[width=11cm]{gedit4.png}
\end{center}

Observe agora o uso do comando cat:
\begin{verbatim}
          curso@curso-desktop:~$ pwd
          /home/curso
          curso@curso-desktop:~$ ls
          Área de Trabalho  arquivo2    Downloads         exemplo  Modelos  Público
          arquivo1          Documentos  examples.desktop  Imagens  Música   Vídeos
          curso@curso-desktop:~$ cat arquivo1
          arquivo1
          etc.
          etc.
          curso@curso-desktop:~$ cat arquivo2
          arquivo2
          blábláblá
          curso@curso-desktop:~$ cat arquivo1 arquivo2
          arquivo1
          etc.
          etc.
          arquivo2
          blábláblá
          curso@curso-desktop:~$ cat arquivo2 arquivo1
          arquivo2
          blábláblá
          arquivo1
          etc.
          etc.
\end{verbatim}
\subsection{find}
O comando find é usado para procurar por diretórios e arquivos no disco. Possui várias opções, mas mostraremos
apenas alguns exemplos simples.\\

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Este exemplo procura por um arquivo ou diretório com o nome ``Documents'' a partir do / (diretório root):
\begin{verbatim}
          $ find / -name Documents
\end{verbatim}}
\item{Este outro procura por um arquivo ou diretório com o nome ``Music'' a partir do diretório home do usuário:
\begin{verbatim}
          $ find ~ -name Music
\end{verbatim}
É importante salientar que ``a partir do diretório x'' significa que o comando procurará dentre tudo o que estiver
contido no tal diretório, incluindo os arquivos e os subdiretórios, bem como seu conteúdo e assim por diante.}
\end{enumerate}
\subsection{clear}
Use o comando clear e descubra o que ele faz:
\begin{verbatim}
          $ clear
\end{verbatim}
\subsection{exit}
Este comando serve para sair do shell (interpretador) e para efetuar o log out
do usuário no terminal.

\subsection{echo}
Mostra um texto. Por agora, pode parecer um comando pouco útil, mas é bastante usado
sobretudo em scripts para exibir mensagens ao usuário.\\

\textbf{Sintaxe básica}
\begin{verbatim}
          $ echo mensagem

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Note que a primeira linha corresponde ao comando, a segunda, ao resultado da execução deste comando:
\begin{verbatim}
          $ echo mensagem
          mensagem
\end{verbatim}
}
\item{Mais um exemplo:
\begin{verbatim}
          $ echo Uma mensagem mais comprida
          Uma mensagem mais comprida
\end{verbatim}}
\end{enumerate}

\textbf{Exercícios}
\begin{enumerate}
\leftskip=0.8cm
\item{Rode o comando a seguir e tenha certeza de que entendeu sua saída.
\begin{verbatim}
          $ echo ~
\end{verbatim}}
\item{Rode os comandos a seguir e observe a diferença entre seus resultados.
\begin{verbatim}
          $ echo "aspas"

          $ echo \"aspas\"
\end{verbatim}}
\end{enumerate}
\subsection{date}
O comando date imprime ou modifica a data e o horário do sistema.\\

\textbf{Sintaxe básica:}
\begin{verbatim}
          $ date [data]

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Para visualizar a data e a hora do sistema:
\begin{verbatim}
          $ date
          Mon Mar  8 14:45:21 BRT 2010
\end{verbatim}}
\item{Para alterar a data e a hora do sistema, basta usar o comando da seguinte maneira:
\begin{verbatim}
          $ date MMDDhhmm[[YYyy][.ss]]
\end{verbatim}
Onde MM é o mês, DD é o dia, hh é a hora, mm são os minutos. Opcionalmente, podem ser usados
o ano (com 2 ou 4 dígitos) e os segundos (ss). Para alterar a data do sistema para o dia 1 de
fevereiro e o horário para 14:30, poderíamos fazer:
\begin{verbatim}
          $ date 02011430
\end{verbatim}}
\end{enumerate}
\subsection[chmod]{chmod (change mode)}
Este comando é usado para mudar permissões de arquivos ou diretórios.\\

\textbf{Sintaxe básica:}
\begin{verbatim}
          $ chmod [permissões] [diretório/arquivo]

\end{verbatim}

Há duas formas de usar o comando.

A primeira forma é bem simples. Você precisa saber que ``u'' representa o dono (``user''), ``g'', o grupo, ``o'',
os demais usuários e ``a'', por sua vez, representa todos (``all''). As letras ``r'', ``w'' e ``x'' são as permissões
apresentadas anteriormente. Além disso, você precisa saber que ``+'' acrescenta uma permissão, ao passo que ``-''
retira. Se usarmos ``='', teremos uma permissão exata. Vamos examinar alguns exemplos para podermos entender melhor.\\

\textbf{Exemplos}

Consideremos o arquivo exemplo (aquele que apareceu no comando ls), cuja permissão era rw-r$--$r$--$.
Consideremos ainda que estamos no diretório home do usuário curso (/home/curso). 
\begin{enumerate}
\leftskip=0.8cm
\item{Suponhamos que queremos acrescentar permissão de escrita ao grupo. Poderíamos fazer isso da seguinte forma:
\begin{verbatim}
          $ chmod g+w exemplo
\end{verbatim}}

\item{Suponhamos agora que acabamos de nos arrepender e queremos tirar a permissão de escrita para o grupo.
Poderíamos fazer da seguinte forma:
\begin{verbatim}
          $ chmod g-w exemplo
\end{verbatim}}

\item{Para acrescentar a permissão de execução a todos os usuários, fazemos:
\begin{verbatim}
          $ chmod a+x exemplo
\end{verbatim}}

\item{Para que os demais usuários fiquem sem permissão de leitura, mas tenham permissão de escrita e execução,
temos:
\begin{verbatim}
          $ chmod o=wx exemplo

\end{verbatim}}
\end{enumerate}

O outro modo de alterar permissões é usando o chamado modo octal. Para usá-lo, é preciso ter em mente o seguinte:
\begin{itemize}
\leftskip=0.8cm
\item{0 - Nenhuma permissão de acesso.}
\item{1 - Permissão de execução.}
\item{2 - Permissão de escrita.}
\item{4 - Permissão de leitura.}
\end{itemize}
 A partir disso, podemos obter qualquer permissão, somando os números correspondentes às permissões desejadas.
\begin{itemize}
\leftskip=0.8cm
\item{3 - Permissão de execução e escrita (1 + 2).}
\item{5 - Permissão de execução e leitura (1 + 4).}
\item{6 - Permissão de escrita e leitura (2 + 4).}
\item{7 - Todas as permissões: execução, escrita e leitura (1 + 2 + 4).}
\end{itemize}

Com esses algarismos, construímos números com três dígitos (XYZ, onde X representa a permissão que será definida
para o dono, Y, a permissão do grupo, e Z é a permissão para outros usuários). Vamos mostrar como usar o modo octal.\\

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Observe o exemplo a seguir:
\begin{verbatim}
          $ chmod 762 exemplo          
\end{verbatim}
ou 
\begin{verbatim}
          $ chmod 762 /home/curso/exemplo
\end{verbatim}
Nesse caso, estamos dando permissão 7 ao dono do arquivo exemplo, isso significa que estamos dando permissão
de leitura, escrita e execução ao dono do arquivo. Para o grupo, demos permissão 6 (escrita e leitura). Aos demais,
demos apenas permissão de escrita (permissão 2).\\}
\end{enumerate}

Vale lembrar que este comando (como outros) aceita caminhos relativos e absolutos.\\

\textbf{Exercícios}
\begin{enumerate}
\leftskip=0.8cm
\item {Como você daria permissão de escrita e leitura para o dono do arquivo exemplo, permissão de leitura
para o grupo e nenhuma permissão para os demais usuários, usando o modo octal?}
\item{Como você daria permissão de leitura e escrita a todos os usuários usando o primeiro modo apresentado?}
\end{enumerate}
\subsection[passwd]{passwd (password)}
Este comando é usado para atualizar informações dos usuários.

Neste módulo, diremos apenas que ele pode ser usado para alterar a senha do seu próprio usuário.\\

\textbf{Sintaxe básica}
\begin{verbatim}
          $ passwd

\end{verbatim}

Após digitar este comando no terminal, o usuário deverá digitar sua senha atual (lembrando que não
haverá nenhuma evidência - como asteriscos ou pontos - de que o usuário está digitando), depois a nova
senha e, por último, será pedido para que o usuário confirme a nova senha.
\subsection{su}
O comando su é usado para mudar de usuário ou para tornar-se superuser (administrador do sistema ou usuário
root).\\

\textbf{Sintaxe básica}
\begin{verbatim}
          $ su [usuário]

\end{verbatim}

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{Suponha que você esteja ``logado'' num terminal como ``usuarioa'' e deseja logar-se como ``usuariob'', sem
ter que encerrar a sessão como ``usuarioa'':
\begin{verbatim}
          $ whoami
          usuarioa
          $ su usuariob
          Senha:
          $ whoami
          usuariob
          $ exit
          exit
          $ whoami
          usuarioa
\end{verbatim}
Acompanhe a sequência de comandos: a princípio, o usuário que estava logado era ``usuarioa'', o que pôde ser confirmado
pelo comando whoami. A seguir, para mudar sua identidade para ``usuariob'', o comando su foi utilizado - note que foi
preciso digitar a senha de usuariob. Depois de autenticado, o usuário logado passou a ser ``usuariob''. Com o comando
exit fechou-se a sessão de ``usuariob'' e a identidade voltou a ser ``usuarioa''.}
\item{Para tornar-se o usuário root, basta usar o comando su sem nenhum argumento:
\begin{verbatim}
          $ su
          Senha:
          #
\end{verbatim}
Note que foi necessário digitar a senha do usuário root.}
\end{enumerate}
\subsection[sudo]{sudo (su ``do'')}
Comando usado para obter privilégios de outros usuários (sobretudo do usuário root) para executar determinadas tarefas.

Algumas tarefas como instalar programas, alterar configurações essenciais do sistema etc. não podem ser desempenhadas por
qualquer usuário, mas apenas pelo usuário root e/ou por alguns outros usuários que possam utilizar o comando sudo (os chamados
sudoers).

No Ubuntu 9.10, o usuário criado no momento da instalação é um sudoer e não é criada uma senha para usuário root. Isso
significa que, para desempenhar tarefas administrativas é necessário acrescentar ``sudo'' à frente do comando.

Observe o seguinte exemplo:
\begin{verbatim}
           $ whoami
           curso
           $ shutdown -h now
           shutdown: Precisa ser root
           $ sudo shutdown -h now
           [sudo] password for curso:
\end{verbatim}
O usuário curso gostaria de desligar seu computador através da linha de comando, usando o comando shutdown. Acontece que, para
executar tal comando, é necessário ser root. Por ser um sudoer, o usuário curso utilizou o comando sudo (observe que foi preciso
digitar a senha do usuário curso) e conseguiu desligar o computador.

\subsection{wc}
O comando wc é usado para contar linhas, palavras e bytes de um arquivo ou do que for escrito
no terminal.\\

\textbf{Sintaxe básica}
\begin{verbatim}
           $ wc [opções] [arquivo]

\end{verbatim}

\textbf{Opções}
\begin{itemize}
\leftskip=0.8cm
\item{\textbf{-c:} Imprimir a contagem de bytes.}
\item{\textbf{-l:} Imprimir o número de linhas.}
\item{\textbf{-w:} Imprimir o número de palavras.\\}
\end{itemize}

\textbf{Exemplos\\}

Vamos usar, para estes exemplos, o conteúdo dos arquivos ``arquivo1'' e ``arquivo2'', mostrados na explicação do comando cat.
\begin{enumerate}
\leftskip=0.8cm
\item{Para exibir o número de linhas do arquivo ``arquivo1'', usaríamos:
\begin{verbatim}
           $ wc -l arquivo1
           3 arquivo1
\end{verbatim}}
\item{Para exibir o número de palavras e de bytes do arquivo ``arquivo2'':
\begin{verbatim}
           $ wc -wc arquivo2
            2 22 arquivo2
\end{verbatim}}
\item{Se usássemos o comando wc sem nenhuma opção para ``arquivo1'', obteríamos:
\begin{verbatim}
           $ wc arquivo1
            3  3 19 arquivo1
\end{verbatim}
onde o primeiro número é a contagem de linhas, o segundo, de palavras, e o terceiro, o de bytes.}
\end{enumerate}


\section{Pipe e redirecionamento}
Além dos comandos apresentados anteriormente, a linha de comando ainda possui outros recursos para facilitar tarefas.
Nesta seção, apresentaremos algumas ferramentas de direcionamento de entrada e saída.

\subsection{$|$ (Pipe)}
O pipe ($|$) é usado para fazer encadeamento de processos, ou seja, faz com que a saída de um comando seja enviada
como entrada para o próximo comando.

Observe o exemplo a seguir para entender melhor (o conteúdo de ``arquivo1''
e ``arquivo2'' é aquele que foi apresentado junto com o comando cat):
\begin{verbatim}
           $ cat arquivo1 arquivo2 | wc -l
           5
\end{verbatim}
Vamos esclarecer o que aconteceu na execução deste comando: primeiro, utilizamos o comando cat com dois arquivos
como argumento. Se rodássemos apenas este comando, teríamos o seguinte efeito (lembra-se?):
\begin{verbatim}
           $ cat arquivo1 arquivo2
           arquivo1
           etc.
           etc.
           arquivo2
           blábláblá
\end{verbatim}
Mas acrescentamos um pipe ($|$) após a execução deste comando, o que significa que a saída foi redirecionada para
o próximo comando, isto é, o resultado da execução de ``cat arquivo1 arquivo2'' não foi impressa, mas sim serviu como
entrada para o próximo comando, ``wc -l'' - que contou o número de linhas e imprimiu este resultado no terminal.\\

Vamos mostrar agora um exemplo mais interessante:
\begin{verbatim}
           curso@curso-desktop:~$ ls -1 | wc -l
           13
\end{verbatim}
O comando antes do pipe lista o conteúdo do diretório atual, exibindo um item por linha. Se executássemos
apenas este comando, obteríamos o seguinte resultado:
\begin{verbatim}
           curso@curso-desktop:~$ ls -1
           Área de Trabalho
           arquivo1
           arquivo2
           doc
           Documentos
           Downloads
           examples.desktop
           exemplo
           Imagens
           Modelos
           Música
           Público
           Vídeos
\end{verbatim}
Mas em vez desta saída ser impressa, ela foi direcionada ao comando ``wc -l'', que contou o número de linhas. Em outras
palavras, o que o comando ``ls -1 $|$ wc -l'' fez foi contar o número de arquivos e diretórios dentro do diretório atual.
\subsection{$>$}
Esta é uma outra forma de direcionar a saída de um comando: diferente do $|$, que direcionava a saída de um comando
para um outro programa ou comando, o $>$ direciona a saída de um comando para um arquivo ou dispositivo.\\

\textbf{Exemplos}
\begin{enumerate}
\leftskip=0.8cm
\item{O comando a seguir redireciona a saída de ``cat arquivo1'' para um arquivo chamado ``arquivo3'':
\begin{verbatim}
           curso@curso-desktop:~$ ls
           Área de Trabalho  doc         examples.desktop  Modelos  Vídeos
           arquivo1          Documentos  exemplo           Música
           arquivo2          Downloads   Imagens           Público
           curso@curso-desktop:~$ cat arquivo1
           arquivo1
           etc.
           etc.
           curso@curso-desktop:~$ cat arquivo1 > arquivo3
           curso@curso-desktop:~$ ls
           Área de Trabalho  arquivo3    Downloads         Imagens  Público
           arquivo1          doc         examples.desktop  Modelos  Vídeos
           arquivo2          Documentos  exemplo           Música
           curso@curso-desktop:~$ cat arquivo3
           arquivo1
           etc.
           etc.
\end{verbatim}
Observe que o arquivo ``arquivo3'' não existia, foi criado quando da execução do comando ``cat arquivo1 $>$ arquivo3''.
Se o arquivo ``arquivo3'' já existisse, seu conteúdo seria sobrescrito.}
\item{Observe agora que ``arquivo3'' já existe:
\begin{verbatim}
           curso@curso-desktop:~$ ls
           Área de Trabalho  arquivo3    Downloads         Imagens  Público
           arquivo1          doc         examples.desktop  Modelos  Vídeos
           arquivo2          Documentos  exemplo           Música
           curso@curso-desktop:~$ cat arquivo3
           arquivo1
           etc.
           etc.
           curso@curso-desktop:~$ cat arquivo2 > arquivo3
           curso@curso-desktop:~$ ls
           Área de Trabalho  arquivo3    Downloads         Imagens  Público
           arquivo1          doc         examples.desktop  Modelos  Vídeos
           arquivo2          Documentos  exemplo           Música
           curso@curso-desktop:~$ cat arquivo3
           arquivo2
           blábláblá
\end{verbatim}}
\end{enumerate}
\subsection{$>>$}
O $>>$, assim como o $>$, também direciona a saída de um comando para um arquivo, a diferença é que ele não substitui
o conteúdo do arquivo, mas acrescenta ao final.
\begin{verbatim}
           curso@curso-desktop:~$ ls
           Área de Trabalho  arquivo3    Downloads         Imagens  Público
           arquivo1          doc         examples.desktop  Modelos  Vídeos
           arquivo2          Documentos  exemplo           Música
           curso@curso-desktop:~$ cat arquivo3
           arquivo2
           blábláblá
           curso@curso-desktop:~$ cat arquivo1 >> arquivo3
           curso@curso-desktop:~$ cat arquivo3
           arquivo2
           blábláblá
           arquivo1
           etc.
           etc.

\end{verbatim}

\textbf{Exercício: }Pesquise sobre outras formas de redirecionamento: $<$ e $<<$. 
\section{Instalando programas pela linha de comando}
Já mostramos como instalar programas usando o Synaptic, agora mostraremos como fazer isso através da linha de comando.
Para isso, utilizaremos uma ferramenta chamada apt-get.

Tanto o Synaptic quanto o apt-get são baseados no APT (Advanced Packaging Tool), que é um gerenciador de pacotes que permite instalar e atualizar programas de forma prática,
resolvendo dependências automaticamente. Convém salientar que o APT (assim como o apt-get e o Synaptic) está presente em
várias distros, como Debian e Ubuntu.\\

Com o apt-get é possível, portanto, instalar, remover e atualizar programas.\\

Para usar o apt-get, o primeiro passo é rodar o comando ``apt-get update'', que faz com que o apt-get baixe a lista
com os pacotes disponíveis. Isso permite que ele crie uma espécie de banco de dados com os pacotes disponíveis,
onde cada um pode ser encontrado e qual endereço contém a versão mais recente.
Este comando deve ser executado periodicamente. O ideal é que você o use uma vez por semana, ou sempre que for fazer
alguma instalação importante:
\begin{verbatim}
           # apt-get update
\end{verbatim}
Note que foi preciso executar tal comando como root. Você também poderia executá-lo usando sudo:
\begin{verbatim}
           $ sudo apt-get update

\end{verbatim}

Depois disso, você poderá instalar os programas desejados, usando a seguinte sintaxe:
\begin{verbatim}
           # apt-get install [nome do programa]
\end{verbatim}
ou
\begin{verbatim}
           $ sudo apt-get install [nome do programa]

\end{verbatim}

Para desinstalar um programa, também é muito simples:
\begin{verbatim}
           # apt-get remove [nome do programa]
\end{verbatim}
ou
\begin{verbatim}
           $ sudo apt-get remove [nome do programa]

\end{verbatim}

Finalmente, existe a opção de atualizar todo o sistema, o que é feito usando os comandos:

\begin{verbatim}
           # apt-get update
           # apt-get upgrade
\end{verbatim}

O ``apt-get update'' é o comando que baixa a lista dos pacotes disponíveis, como já vimos. O ``apt-get upgrade'', por sua
vez, age de forma bem diferente: ele verifica todos os pacotes do sistema e tenta atualizar todos de uma vez,
o que geralmente resulta em uma longa lista de atualizações.

\chapter{Obtendo ajuda}
O que foi apresentado neste curso tem caráter introdutório: mostramos neste capítulo algumas formas de se aprofundar e
de achar respostas para alguns problemas.

\section{Comandos e opções}
Através da própria linha de comando é possível obter ajuda e informações a respeito dos comandos.

\subsection[man]{man (manual)}
O comando man mostra uma página de manual para um determinado comando.\\

\textbf{Sintaxe básica}
\begin{verbatim}
          $ man [comando]

\end{verbatim}

Para visualizar o manual do comando ls, basta usar
\begin{verbatim}
          $ man ls
\end{verbatim}
Para sair de uma página de manual, basta digitar ``q''.

\subsection{apropos}
Este comando faz buscas de palavras em um banco de dados que contém descrições curtas de comandos e programas.\\

\textbf{Sintaxe básica}
\begin{verbatim}
          $ apropos [busca]

\end{verbatim}

Suponhamos que quiséssemos procurar como remover arquivos. Poderíamos usar
\begin{verbatim}
          $ apropos remove
\end{verbatim}
Provavelmente, esta busca retornaria muitos resultados. Sejamos então mais específicos:
\begin{verbatim}
          $ apropos "remove files"
\end{verbatim}
Esta busca retornaria o seguinte resultado:
\begin{verbatim}
          rm                   (1)  - remove files or directories
\end{verbatim}

\subsection{$-$$-$help}
Quase todos os comandos do GNU/Linux possuem a opção ``$--$help'', usada, obviamente, para obter ajuda sobre o comando em
questão.\\

\textbf{Sintaxe básica}
\begin{verbatim}
          $ [comando] --help

\end{verbatim}

Para obtermos ajuda sobre o wc, por exemplo, usamos
\begin{verbatim}
          $ wc --help
\end{verbatim}

\section{Internet e literatura}
É até dispensável mencionar que você sempre pode pesquisar na internet quando encontrar
algum problema ou dúvida em relação ao GNU/Linux: existem muitos fóruns de discussões e
tutorias, assim como a documentação dos programas, bibliotecas etc. também está disponível
na rede.\\

Outra boa fonte de informações é a literatura: existem vários livros disponíveis sobre diversos
tópicos do GNU/Linux. Sugerimos aqui os da editora O'Reilly (\url{http://oreilly.com/pub/topic/linux}).

\section{Sugestões}
Finalizamos este módulo com sugestões de sites que podem ajudá-lo a entender melhor o GNU/Linux.

\begin{itemize}
\item{\textbf{Rede GNU/Linux:} Site da Rede GNU/Linux do Instituto de Matemática e Estatística da USP.\\
\url{www.linux.ime.usp.br}}
\item{\textbf{Make The Move:} Tem como objetivo apresentar o Linux e o Software Livre como alternativas
viáveis ao sistema em seu computador.\\
\url{makethemove.net}}
\item{\textbf{Free Software Foundation:} Site da FSF.\\
\url{www.fsf.org}}
\item{\textbf{Debian - The Universal Operating System:} Site da distro Debian.\\
\url{www.debian.org}}
\item{\textbf{Ubuntu-BR:} Site da Comunidade Ubuntu brasileira.\\
\url{www.ubuntu-br.org}}
\item{\textbf{Fedora Project:} Site da distro Fedora.\\
\url{fedoraproject.org}}
\item{\textbf{Distro Watch:} Notícias e informações sobre distribuições Linux e BSD.\\
\url{distrowatch.com}}
\item{\textbf{Google:}} Dispensa apresentações.\\
\url{www.google.com}
\end{itemize}

\begin{thebibliography}{1}
\bibitem{Filesystem}
\textit{1234407730filesystem.gif},
disponível in
\url{http://www.linuxplanet.com/graphics/screenshots/1234407730filesystem.gif}
$[$Fevereiro de 2010$]$

\bibitem{Fluxbox}
\textit{Ficheiro: Fluxbox.png - Wikipédia, a enciclopédia livre},
disponível in
\url{http://pt.wikipedia.org/wiki/Ficheiro:Fluxbox.png}
$[$Janeiro de 2010$]$

\bibitem{KDE}
\textit{Ficheiro: KDE 4.png - Wikipédia, a enciclopédia livre},
disponível in
\url{http://pt.wikipedia.org/wiki/Ficheiro:KDE_4.png}
$[$Janeiro de 2010$]$

\bibitem{Linus}
\textit{Ficheiro: Linus Torvalds.jpeg - Wikipédia, a enciclopédia livre},
disponível in
\url{http://pt.wikipedia.org/wiki/Ficheiro:Linus_Torvalds.jpeg}
$[$Janeiro de 2010$]$

\bibitem{Stallman}
\textit{Ficheiro: Richard Matthew Stallman.jpeg - Wikipédia, a enciclopédia livre},
disponível in
\url{http://pt.wikipedia.org/wiki/Ficheiro:Richard_Matthew_Stallman.jpeg}
$[$Janeiro de 2010$]$

\bibitem{Filesystem2}
\textit{Filesystem Hierarchy Standard - Wikipédia, a enciclopédia livre},
disponível in
\url{http://pt.wikipedia.org/wiki/Filesystem_Hierarchy_Standard}
$[$Fevereiro de 2010$]$

\bibitem{GPL}
\textit{GNU General Public License - Wikipédia, a enciclopédia livre},
disponível in
\url{http://pt.wikipedia.org/wiki/GNU_General_Public_License}
$[$Janeiro de 2010$]$

\bibitem{Foca}
SILVA, Gleydson Mazioli da,
\textit{Guia Foca GNU/Linux},
novembro de 2007,
disponível in
\url{http://www.guiafoca.org/download/iniciante/focalinux1-pdf.tar.gz}
$[$Janeiro de 2010$]$

\bibitem{Linux}
\textit{Linux - Wikipédia, a enciclopédia livre},
disponível in
\url{http://pt.wikipedia.org/wiki/Linux}
$[$Janeiro de 2010$]$

\bibitem{Linux2}
\textit{O que é Linux},
disponível in
\url{http://www.vivaolinux.com.br/linux/}
$[$Janeiro de 2010$]$

\bibitem{Linux3}
CAMPOS, Augusto,
\textit{O que é Linux},
Florianópolis, março de 2006,
disponível in
\url{http://br-linux.org/faq-linux}
$[$Janeiro de 2010$]$

\bibitem{APT}
MORIMOTO, Carlos E.,
\textit{Tutorial completo do apt-get},
abril de 2007,
disponível in
\url{http://www.guiadohardware.net/tutoriais/tutorial-completo-apt-get/}
$[$Março de 2010$]$

\bibitem{Ubuntu}
\textit{Ubuntu System Requirements - Community Ubuntu Documentation},
disponível in
\url{https://help.ubuntu.com/community/Installation/SystemRequirements}
$[$Janeiro de 2010$]$
\end{thebibliography}
\end{document}
