Curso Linux 2010

Universidade Federal de Santa Maria
PET Ciência da Computação UFSM
Curso de Introdução ao GNU/Linux
Adriano Pereira
Fábio Weber Albiero
Victor Chitolina Schetinger
Vinícius Garcia Pinto
2010
Sumário
1 Introdução........................................................................................................................................4
1.1 O que é Linux...........................................................................................................................4
1.2 O que é GNU............................................................................................................................4
1.3 Características do sistema.........................................................................................................4
1.3.1 Usuários e grupos..............................................................................................................5
1.3.2 Arquivos e estrutura de diretórios.....................................................................................5
1.3.2.1 Nomes de arquivos....................................................................................................5
1.3.2.2 Estrutura básica dos arquivos do sistema Linux.......................................................6
1.3.2.3 Sistemas de arquivos.................................................................................................7
2 Comandos básicos...........................................................................................................................8
2.1 O primeiro comando: listando o conteúdo de um diretório......................................................8
2.2 Obtendo ajuda...........................................................................................................................9
2.3 Redirecionando a saída para um arquivo..................................................................................9
2.4 Criando arquivos................................................................................................................10
2.5 Coringas.............................................................................................................................10
2.6 Navegando pela estrutura de diretórios..............................................................................11
2.7 Criando diretórios..............................................................................................................12
2.8 Removendo arquivos e diretórios......................................................................................12
2.9 Copiando arquivos e diretórios..........................................................................................13
2.10 Movendo arquivos e diretórios........................................................................................13
2.10.1 Utilizando mais eficientemente o shell.........................................................................14
2.11 Utilizando dispositivos de armazenamento......................................................................14
2.12 Manipulação de usuários e grupos...................................................................................15
2.12.1 Adicionando usuários...............................................................................................16
2.12.2 Removendo usuários................................................................................................16
2.12.3 Definindo a senha de um usuário.............................................................................16
2.12.4 Criando grupos.........................................................................................................17
2.12.5 Removendo grupos...................................................................................................17
2.12.6 Visualizando algumas informações..........................................................................18
2.13 Permissões, donos e grupos dos arquivos........................................................................18
2.13.1 Modificando permissões...........................................................................................18
2.13.2 Modificando o dono e o grupo de um arquivo.........................................................19
2.14 Mudando de usuário.........................................................................................................19
2.15 Definindo apelidos para comandos..................................................................................19
2.16 O arquivador tar...............................................................................................................20
2.17 Utilizando o editor Vim...................................................................................................21
2.18 Outras maneiras de ver o conteúdo de um arquivo..........................................................22
2.19 Mais alguns símbolos especiais.......................................................................................23
3 Controlando a execução de programas..........................................................................................24
3.1 O comando top........................................................................................................................24
3.2 O comando jobs......................................................................................................................24
3.3 O comando pstree...................................................................................................................24
3.4 O comando pidof ...................................................................................................................24
3.5 Interrompendo a execução de processos.................................................................................24
4 Shell Script....................................................................................................................................26
4.1 O que é um Script em Shell?..................................................................................................26
4.2 Olá Mundo Cruel ...................................................................................................................26
4.3 Lendo o teclado ......................................................................................................................27
4.4 Brincando com variáveis........................................................................................................27
4.5 Laços e estruturas de controle.................................................................................................28
4.6 Testes condicionais ................................................................................................................28
4.7 Exemplos de laços e estruturas de controle............................................................................29
4.8 Entrada por argumento ...........................................................................................................30
5 Trabalhando com a Linguagem C.................................................................................................32
5.1 Compilador GCC....................................................................................................................32
5.2 Depurador GDB.....................................................................................................................32
5.3 Depurador DDD......................................................................................................................33
6 Conectando máquinas remotas utilizando SSH.............................................................................34
6.1 Utilizando o scp.......................................................................................................................34
7 Mais informações..........................................................................................................................36
7.1 Interface Gráfica.....................................................................................................................36
7.2 Buscando outras fontes de informação...................................................................................36
8 Bibliografia....................................................................................................................................37
1 Introdução
Este curso pretende fornecer os conhecimentos iniciais necessários para o uso de sistemas
GNU/Linux. Para isso serão apresentadas as principais características do sistema,
comandos básicos e alguns aplicativos úteis aos iniciantes no uso desses sistemas. O foco
principal desse curso será o uso das funcionalidades que rodam sem a utilização de
interface gráfica. Isso se deve ao fato de que essa forma de trabalho proporciona melhor
conhecimento do sistema, permite trabalho mais eficiente e executar tarefas que não são
acessíveis através de programas gráficos. Além disso há a possibilidade de os alunos
necessitarem usar uma estação na qual não há servidor gráfico, como geralmente
acontece com a maioria dos servidores Web, de banco de dados, de FTP, etc.
1.1 O que é Linux
Linux é um sistema operacional criado por Linus Torvalds em 1991, na Universidade de
Helsinki, na Finlândia. Em um sistema GNU/Linux ele é o que chamamos de kernel ou
núcleo do sistema operacional. Ele é o responsável por fazer a interface entre os outros
programas e o hardware do sistema, de maneira a abstrair detalhes do funcionamento
desse hardware. O Linux foi baseado no Minix, pequeno sistema operacional criado por
Andrew S. Tanembaum, com finalidades de ensino, que por sua vez foi baseado no
sistema Unix.
O Linux é um software livre, licenciado pela GNU Public License (GPL), o que significa
que pode ser copiado, distribuído, adaptado, executado, melhorado, sem que quem o faça
seja cobrado por isso.
1.2 O que é GNU
Fundado por Richard Stallman, em 1984, GNU é um projeto de desenvolver um sistema
operacional livre compatível com o padrão do Unix. Esses sistemas são conhecidos como
Unixlike, o Linux está incluído entre eles.
Quando surgiu o Linux já haviam sido criadas várias ferramentas como, por exemplo, um
compilador C e um editor de textos, no entanto, ainda não havia um kernel. O que
aconteceu foi que Linus Torvalds começou adaptar as aplicações do GNU para usar no
Linux, e outros desenvolvedores seguiram essa tendência. O Linux é penas um kernel
(núcleo do sistema operacional), que por si só não é usável. O que usamos é uma mistura
do kernel, que é o Linux, com o sistema GNU. Devido a isso argumentase que o sistema
deve ser chamado GNU/Linux.
1.3 Características do sistema
Nessa seção apresentaremos algumas características do sistema como usuários e grupos,
2010 PET Ciência da Computação UFSM Página 4/37
estrutura de arquivos e diretórios, sistemas de arquivos e representação dos dispositivos
de hardware.
1.3.1 Usuários e grupos
O Linux é um sistema operacional multiusuário. Cada usuário possui um identificador,
usualmente chamado “login” e uma senha, necessários para entrar no sistema. Além
disso cada usuário pertence a um ou mais grupos. Os grupos definem permissões para
acessar arquivos, utilizar alguns periféricos ou executar certos comandos.
Um desses usuários, chamado root, é o administrador do sistema, o qual é um
superusuário, autorizado a fazer qualquer coisa no sistema.
1.3.2 Arquivos e estrutura de diretórios
Em um sistema Linux existe apenas uma árvore de diretórios, que são o equivalente ao
que outros sistemas como o Windows chamam de pastas. Os diretórios nada mais são do
que arquivos especiais que contém informações, sobre outros arquivos e diretórios que
estão “dentro” dele.
Além disso, os dispositivos de armazenamento não são representados por letras, como no
DOS ou no Windows. O que acontece no Linux é que as partições de disco, os cdroms,
disquetes, etc. , são “montados” na árvore de diretórios. Isso significa que é definido um
diretório que vai conter os dados do dispositivo de armazenamento.
Outro aspecto importante do sistema é que os dispositivos de hardware também são
representados por arquivos do sistema. Isso é feito nos sistemas baseados em Unix para
facilitar a interface do programador para com esse dispositivo. Dessa forma enviar ou
receber dados de um desses dispositivos resumese a escrever ou ler um arquivo.
Mais um ponto a ressaltar é que cada arquivo possui um dono e um grupo, além de
permissões de leitura, escrita, e execução distintas para o seu dono, seu grupo, e para os
outros usuários.
1.3.2.1 Nomes de arquivos
No Linux o nome dos arquivos e diretórios é sensível à capitalização, ou seja, há
diferenciação entre letras minúsculas e maiúsculas. Um “.” no início do nome de um
arquivo e diretório indica que ele é oculto, por exemplo : .arquivo_oculto. Os
nomes de diretórios são separados hierarquicamente pelo caracter “/”. Assim, para se
referenciar ao diretório fulano, que está dentro do diretório home, devese escrever
home/fulano. O diretório principal da hierarquia, que contém todos os outros, é chamado
raiz é representado apenas por “/”. A seguir apresentase uma lista de alguns nomes
especiais de diretório e o que eles referenciam:
. referencia o diretório atual;
.. referencia o diretório pai do atual, ou seja aquele que está logo acima dele na
hierarquia, que o contém;
~ referencia o diretório do usuário, usualmente chamado de “home” do usuário;
/ referencia o diretório raiz.
1.3.2.2 Estrutura básica dos arquivos do sistema Linux
O sistema Linux geralmente possui a seguinte estrutura básica de diretórios:
/bin Contém arquivos de programas do sistema que são usados com freqüência
pelos usuários.
/boot Contém arquivos necessários para a inicialização do sistema.
/dev Contém arquivos usados para acessar dispositivos (periféricos) existentes no
computador.
/etc Arquivos de configuração de seu computador local.
/home Diretório contendo os diretórios dos usuários. Geralmente os usuários

humanos possuem diretórios com o nome /home/login
/lib Bibliotecas compartilhadas pelos programas do sistema e módulos do kernel.
/mnt Contém diretórios normalmente usados como ponto de montagem temporário.
/proc Sistema de arquivos do kernel. Este diretório não existe em seu disco rígido,
ele é colocado lá pelo kernel e usado por diversos programas que fazem sua
leitura, verificam configurações do sistema ou modificam o funcionamento de
dispositivos, através da alteração em seus arquivos.
/root Diretório do administrador do sistema.
/sbin Diretório de programas usados pelo superusuário (root) para administração e
controle do funcionamento do sistema.
/tmp Diretório para armazenamento de arquivos temporários criados por programas.
/usr Contém maior parte de seus programas. Normalmente acessível somente como
leitura.
/var Contém maior parte dos arquivos que são gravados com freqüência pelos
programas do sistema, emails, spool de impressora, cache, etc.
1.3.2.3 Sistemas de arquivos
Um sistema de arquivos é o que determina como seus dados são organizados em um
dispositivo de armazenamento. O Linux possui suporte a vários sistemas de arquivo para
discos, sendo os principais o ext2, o ext3 e atualmente vem sendo bastante usado o
Reiserfs. Além disso o Linux possui suporte a sistemas de arquivos utilizados pelo DOS e
pelo MS Windows, como o fat16, o fat32 e NTFS.
2 Comandos básicos
Agora vamos começar a estudar alguns comandos do Linux. Para isso vamos ir para um
terminal virtual. O Linux usualmente possui 6 terminais virtuais em modo texto e um
terminal gráfico. Para alternar entre os terminais pressionase Alt+F#, # sendo o número
do terminal para o qual se quer alternar. Caso esteja no modo gráfico será necessário
pressionar Ctrl+Alt+F#.
No terminal, para entrar no sistema, digite seu login, e senha quando perguntado. Irá
parecer um sinal de pronto parecido com fulano@localhost~$, onde devem ser
digitados os comandos. Os comandos aí digitados serão executados pelo interpretador de
comandos ou “shell”, como é geralmente chamado. Normalmente opções são passadas
aos comandos utilizando os formatos -O ou --opcao.
2.1 O primeiro comando: listando o conteúdo de um diretório
O comando ls é usado para visualizar o conteúdo de um diretório. Sua sintaxe básica é:
ls [opções][diretório ou arquivo]
Exemplos:
ls lista conteúdo do diretório atual
ls ~ lista o conteúdo da home do usuário que executa o
comando
ls .. lista o conteúdo do diretório pai
ls /home/feliz/batatas/ lista o conteúdo do diretório batatas, que está
dentro do diretório feliz, que está dentro do
diretório home, que está dentro do raiz
ls docs/ lista o conteúdo do diretório docs, que está dentro
do diretório atual.
Algumas opções do comando ls:
l mostra informações extras sobre os arquivos, com exibição na forma de lista,
um arquivo por linha;
s mostra o tamanho dos arquivos;
a mostra os arquivos ocultos;
h “human readable”, em conjunto com s ou l, mostra os tamanhos dos
arquivos em unidades com KB, MB ou GB.
Obs.: as opções que não recebem argumentos podem ser agrupadas, na maioria dos
comandos. Por exemplo, o comando ls -la lista o conteúdo dos diretórios em uma
lista detalhada exibindo os arquivos ocultos.
2.2 Obtendo ajuda
Uma ferramenta muito importante é o comando man, ele serve para mostrar páginas do
manual de um comando. Não só os comandos do sistema são cobertos pelo man, há
também páginas sobre comandos de linguagens de programação como a linguagem C, e
sobre arquivos de configuração do sistema e de aplicativos. A sintaxe básica é:
man [seção] <tópico>
Exemplos:
man ls mostra informações sobre o comando ls;
man 3 printf mostra infromações sobre o comando printf da linguagem C.
Note que foi indicado a seção 3, para ver a seção “Linux
Programmer's Manual”. Se não fosse indicada a seção seria
mostrado o manual do comando printf do shell.
Dentro do man utilize as telas de seta, PgUp e PgDn para rolar o texto. É possível

pesquisar um texto, pressionando “/” e logo após digitando o texto buscar e pressionando
Enter. Utilize a tecla “n” para ir para a próxima ocorrência e “Shift+n” para ir para a
anterior. Para sair do man pressinase “q”.
Outra maneira de obter informações de ajuda é o comando info, o qual mostra
informações estendidas sobre o comando. A sintaxe básica é:
info <tópico>
2.3 Redirecionando a saída para um arquivo
Para redirecionar a saída de um comando para um arquivo utilizase os símbolos “>” e
“>>”. O símbolo “>” apaga o conteúdo original do arquivo, enquanto o símbolo “>>”
concatena a saída do comando no final do arquivo original.
Exemplo:
ls > lista.txt redireciona a saída do comando ls para o arquivo
lista.txt, apagando o conteúdo desse;
ls >> lista.txt o mesmo que o anterior, mas não apaga o conteúdo
original do arquivo, apenas concatena a saída no final do
mesmo.
Vamos ver outro exemplo de uso dessa funcionalidade no próximo tópico.
2.4 Criando arquivos
Aqui vão alguns comandos que podem ser usados para criar arquivos para serem usados
nos testes dos comandos desta apostila.
O comando touch, tem por objetivo atualizar a data de acesso de um arquivo. No
entanto, quando usado um nome de arquivo não existente como argumento, é criado um
arquivo vazio. A sintaxe é:
touch nome_do_arquivo
O comando cat foi criado par concatenar o conteúdo de vários arquivos e mostrálo por
na saída padrão. Esse comando também pode ser utilizado para mostrar o conteúdo de
um arquivo.
Exemplos:
cat exemplo.txt mostra no console o conteúdo do arquivo exemplo.txt;
cat arq1 arq2.txt mostra no console os conteúdos de arq1.txt e arq2.txt,
concatenados.
O comando cat sem argumentos lê a entrada padrão do teclado. Dessa maneira se
redirecionarmos sua saída para um arquivo, podemos utilizálo para adicionar texto a
arquivos.
Exemplos:
cat > texto.txt escreve o que foi digitado no arquivo texto.txt, apagando o
conteúdo original do arquivo;
cat >> texto.txt concatena o que foi digitado no fim do arquivo texto.txt
sem apagar seu conteúdo original.
Após digitado o texto, devese pressionar Ctrl+d para sinalizar o fim de entrada, ou
Ctrl+c para cancelar.
2.5 Coringas
Coringas (ou referência global) é um recurso usado para especificar um ou mais arquivos
ou diretórios do sistema de uma só vez. Este é um recurso permite que você faça a
filtragem do que será listado, copiado, apagado, etc.
Tipos de coringas no GNU/Linux:
[a-z,1,0] Faz referência a intervalo de caracteres de a até z ou 1 ou
0 naquela posição.
? Faz referência a uma letra naquela posição.
[padrão] Faz referência a uma faixa de caracteres de um

arquivo/diretório.
[a-z][0-9] Faz referência a caracteres de a até z seguido de um
caracter de 0 até 9.
[a,z][1,0] Faz a referência aos caracteres a e z seguido de um
caracter 1 ou 0 naquela posição.
Caso a expressão seja precedida por um ^, faz referência a qualquer caracter exceto o da
expressão. Por exemplo [^abc] faz referência a qualquer caracter exceto a, b e c.
Lembrando que os tipos de coringas ("*", "?", "[]") podem ser usados juntos. Para
entender melhor vamos à prática:
ls /usr/teste/* lista todos os arquivos do diretório /usr/teste
ls *.txt pega todos os arquivos que começam com qualquer
nome e temina terminam com .txt
ls teste?.txt pega todos os arquivos que começam com o nome
teste, tenham qualquer caracter no lugar do coringa ?
e terminem com .txt
ls teste[13].txt pega todos os arquivos que começam com o nome
teste, tenham qualquer caracter entre o número 13
no lugar da 6a letra e terminem com .txt
ls teste[4,5].* lista todos os arquivos que começam com teste
contém números de 4 e 5 naquela posição e terminem
com qualquer extensão
2.6 Navegando pela estrutura de diretórios
Para navegar pela estrutura de diretórios utilizase o comando cd, que significa “change
directory”.
Sintaxe:
cd <diretório>
Exemplos:
cd .. muda para o diretório pai;
cd ../pix muda para o diretório pix que está dentro do diretório pai;
cd textos muda o diretório atual para o diretório textos que está no diretório
atual;
cd /usr/bin muda para o diretório /usr/bin;
cd ~ muda para o diretório home do usuário.
cd equivalente ao exemplo anterior
2.7 Criando diretórios
Para criar diretórios utilizase o comando mkdir.
Sintaxe:
mkdir [opções] nome do diretório
Opções interessantes:
p cria o diretório e todos os diretórios
inexistentes primeiro;
Exemplos:
mkdir teste cria o diretório teste no diretório atual;
mkdir /home/xyz/doc cria o diretório doc dentro do diretório /home/xyz já
existente;
mkdir -p /home/xyz/doc o mesmo que o anterior exceto que /home/xyz será
criado se não existir.
2.8 Removendo arquivos e diretórios
Para remover arquivos e diretórios utilizase o comando rm. A sintaxe básica é:
rm [opções] <lista de arquivos e diretórios>
Algumas opções do rm:
-r apaga recursivamente diretório;
-i pede confirmação;
-r apaga recursivamente diretório;
-f apaga arquivos protegidos contra escrita sem pedir confirmação (desde que
pertençam ao usuário)
Exemplos de uso:
rm abacate apaga o arquivo abacate, no diretório atual;
rm rf verde azul cores apaga os diretório ou arquivos com nomes
verde azul cores, do diretório atual, sem pedir
confirmação.
2.9 Copiando arquivos e diretórios
Para copiar arquivos e diretórios utilizase o comando cp. Sua sintaxe é a seguinte:
cp [opções] <origem 1> [origem 2] ... [origem n] <destino>
Se destino não existir ou for um arquivo, então apenas uma origem deve ser fornecida. Se
destino já existir e for um diretório, então todos os ítens especificados como origem serão
copiados para dentro dele.
Opções:
-r copia recursivamente diretório (necessário para copiar diretórios);
-f sobrescreve arquivos sem pedir permissão.
2.10 Movendo arquivos e diretórios
O comando mv é usado para mover arquivos e diretórios para outro arquivo ou diretório.
Esse comando pode ser usado também para renomear arquivos.
Sintaxe:
mv <lista de arquivos ou diretórios> <destino>
Se o destino for um arquivo, apenas um arquivo poderá ser especificado como origem, se
o arquivo já existir será sobrescrito, caso contrário será criado um novo arquivo com o
nome de destino. Caso seja um diretório, se já existir, os arquivos e diretórios de origem
serão movidos para dentro do diretório. É impossível mover um arquivo para um
diretório não existente.
Algumas opções úteis:
-i pede confirmação ao sobrescrever um arquivo já existente.
Exemplos:
mv nome1 nome2 Se nome2 for um arquivo: equivalente a renomear
nome1 como nome2 (se arquivo2 já existir será
sobrescrito).
Se nome2 for um diretório já existente: move
nome1 para dentro de nome2;
mv origem1 origem2 move origem1 origem2 e origem3, que está dentro
/home/origem3 destino do diretório /home, para dentro da pasta destino .
2.10.1 Utilizando mais eficientemente o shell
Há algumas facilidades que o shell fornece, que possibilitam seu uso mais eficiente. São
comandos e atalhos que podem poupar um pouco de trabalho ao usuário.
No shell, é possível circular entre comandos usados anteriormente utilizando as setas
para cima e para baixo. Digitando o comando history no shell é mostrado o histórico
de comandos armazenado. Pressionando Ctrl+r, aparecerá um campo de busca do tipo
“find as you type”(busca enquanto você digita), de comandos no histórico.
Para limpar a tela, digitase o comando clear, ou mais eficientemente, utilizase o
atalho Ctrl+l. Quando o usuário quiser sair do shell, basta digitar o comando exit, ou o
atalho Ctrl+d.
É possível mandar um sinal de término (break) para um programa, forçando o
encerramento de sua execução, utilizando o atalho Ctrl+c. Pressionando Ctrl+z, é
possível parar a execução do programa. Após pressionar Ctrl+z, digite bg para continuar
a execução em segundo plano (background), ou fg (foreground) para continuála em
primeiro plano.
Além disso o shell possui o recurso de auto completar comandos e nomes de arquivos.
Para usar isso basta inicar a digitação e pressionar a tecla Tab, caso exista apenas uma
possibilidade o nome de arquivo ou comando será completado automaticamente. Se
houver mais de uma possibilidade, pressionando Tab novamente, aparecerá uma lista de
possibilidades de compleção. Caso não haja nenhuma possibilidade de autocompletar a
digitação não acontecerá nada ao pressionar Tab pela segunda vez.
Para “rolar” a tela do terminal segure a tecla Shift e pressione PageUp para subir e
PgDown para descer.
2.11 Utilizando dispositivos de armazenamento
No sistema GNU/Linux para utilizar dispositivos de armazenamento é necessário
primeiro montálos. Alguns dispositivos são montados automaticamente na inicialização
do sistema, como as partições onde estão os arquivos do S.O. e os dos usuários.
Olhando o conteúdo do diretório /dev, vêse vários arquivos que representam
dispositivos, os discos e as partições, assim como outros dispositivos de armazenamento.
Normalmente os discos rígidos são representados da seguinte maneira:
BIOS Windows Linux
Primary Master C: /dev/hda
Primary Slave D: /dev/hdb
Secondary Master E: /dev/hdc
Secondary Slave F: /dev/hdd
Drive CDROM /dev/cdrom
Drive de Disquetes A: /dev/fd0
As partições de um disco são nomeadas anexando o número da partição ao do

dispositivo. Assim, a primeira partição do disco /dev/hdb se chamará /dev/hdb1.
Os nomes aqui fornecidos são apenas exemplos do que acontece na maioria dos sistemas,
em alguns casos o drive CDROM pode ser representado por /dev/cdroms/cdrom0,
por exemplo.
Para montar um dispositivo ou uma partição utilizase o comando mount. Geralmente
utilizase:
mount <dispositivo> <ponto de montagem>
No entanto esse comando só pode ser rodado pelo usuário root. Os usuários normais só
podem montar dispositivos que o superusuário tenha configurado para isso.
Principalmente em sistemas desktop é comum os usuários poderem montar algumas
mídias removíveis, como CDROM e discos flexíveis.
Para montar um desses dispositivo usase algo como: mount <ponto de
montagem>. Pontos de montagem comumente usados para CDROM são
/mnt/cdrom, /media/cdrom, /cdrom, drivers/cdrom. Para disquetes:
/mnt/floppy, /media/floppy, /floppy, drivers/floppy.
Antes de remover a mídia é preciso desmontála utilizando o comando umount. Basta
digitar o comando umount <ponto de montagem>. Para desmontar um
dispositivo é necessário que ele não esteja sendo usado.
Alguns sistemas atuais estão configurados para usar automount, que faz com que os
dispositivos sejam montados e desmontados automaticamente.
2.12 Manipulação de usuários e grupos
Nessa seção apresentaremos comandos para criação, remoção de usuários e grupos,
visualização dos grupos a que um usuário pertence, e dos usuários pertencentes a um
grupo. Essas tarefas só podem ser executadas pelo superusuário.
2.12.1 Adicionando usuários
Para adicionar usuários usase o comando useradd. A sintaxe básica do comando é:
useradd <login> [opções]
Algumas opções:
-m cria a home do usuário, utilizando a localização padrão, normalmente
/home/login;
-G recebe como argumento uma lista dos grupos a que o usuário pertencerá,
separados por vírgulas, o primeiro grupo será o grupo principal do usuário;
-p recebe como argumento a senha do usuário criptografada;
-d permite definir uma home diferente da padrão.
Exemplo:
useradd loco m G users,inf2006 cria um usuário com o login loco,
adicionandoo aos grupos users e
inf2006 e cria sua home na
localização padrão do sistema.
2.12.2 Removendo usuários
Para remover usuários usase o comando userdel. A sintaxe é:
userdel [opções] login
A opção -r faz com que a home do usuário seja apagada.
Exemplo:
userdel r loco remove o usuário com o login loco,
e apaga seu diretório home.
2.12.3 Definindo a senha de um usuário
A senha de um usuário pode ser definida utilizandose o comando passwd. Se você
criou um usuário utilizando useradd, sem a opção p, então será necessário criar uma
senha para ele. A sintaxe básica do comando é:
passwd <login>
Ao usar esse comando o usuário será solicitado a inserir uma senha, logo após, a senha
deverá ser repetida para confirmação. Feito isso, se as senhas coincidirem, estará definida
a nova senha do usuário. O usuário pode modificar sua própria senha digitando o
comando passwd sem argumentos, no interpretador de comandos.
Exemplo:
passwd loco pede para mudar a senha do usuário
loco.
2.12.4 Criando grupos
O comando groupadd é usado para criar grupos. A sintaxe é:
groupadd <nome_de_grupo>
Exemplo:
groupadd inf2009 cria o grupo inf2009.
2.12.5 Removendo grupos
O comando groupdel é usado para remover grupos. A sintaxe é:
groupdel <nome_de_grupo>
Exemplo:
groupdel inf2009 remove o grupo inf2009.
2.12.6 Visualizando algumas informações
Para ver a que grupos pertence um usuário digitase:
groups usuário
Omitindo o usuário no comando, são mostrados os grupos do usuário atual.
2.13 Permissões, donos e grupos dos arquivos
Ao executar o comando ls -l, em cada linha aparece algo assim:
drwxr-xr-- 2 fulano users 1024 Jun 18 14:30 textos
Preste atenção na primeira parte dessa linha, aquelas letras que aparecem lá estão dizendo
se o ítem é um diretório ou não, e as permissões de leitura (r), escrita (w) e execução
(x), para o dono do arquivo, para o grupo do arquivo, e para os outros usuários,
respectivamente. Um “” em uma posição significa que o atributo está desativado.
Também temos as informações de que o arquivo pertence ao usuário fulano e ao grupo
users. Agora vamos ver nas subseções seguintes como modificar as permissões de um
arquivo, seu dono e seu grupo.
2.13.1 Modificando permissões
O comando chmod é usado para mudar as permissões de arquivos e diretórios. O modo
mais prático de mudar permissões é passar para o comando uma seqüência de 3 dígitos
que representam, cada um, as permissões para o usuário dono do arquivo, para o grupo e
para os outros, nessa ordem. Para fromar essa seqüência de dígitos levase em conta os
valores das permissões que são:
1: Execução;
2: Escrita;
4: Leitura.
Agora basta somar as permissões e ordenálas na ordem ugo (usuário, grupo, outros).
Assim, para dar permissão de leitura escrita e execução para o dono do arquivo, digitase
7 (1+2+4). Para dar permissões de leitura e execução para o grupo digitase 5 (1+4)e para
dar nenhuma permissão aos outros usuários digitase 0. Assim formase a seqüência 750.
O comando para dar essa permissão a um diretório chamado textos, ficaria assim:
chmod 750 textos
Executando o comando ls l teríamos na linha em que aparece o diretório, o seguinte:
drwxr-x--- 2 fulano users 1024 Jun 18 14:30 textos
A opção -R é usada para modificar recursivamente as permissões de um diretórios, ou
seja, ao utilizála estase modificando as permissões de tudo o que está dentro do
diretório também.
Uma curiosidade: de onde surgiram esses valores para leitura, escrita e gravação? Basta
considerar a seqüência rwx como uma seqüência de bits, o bit “1” significando ativo e o
bit “0”, inativo. Assim, as permissões que demos para o grupo, no exemplo anterior, em
binário, ficariam assim: “101” (rx). Convertendo esse número para a notação decimal
temos como resultado “5”.
2.13.2 Modificando o dono e o grupo de um arquivo
Para modificar o dono de um arquivo ou diretório utilizase o comando chown. Basta
digitar:
chown <usuário> <lista de arquivos ou diretórios>
A opção -R tem o mesmo efeito que no comando chmod.
Exemplo:
chown beltrano textos faz de beltrano o novo dono de textos;
chown R beltrano textos faz de beltrano o novo dono do diretório textos
e de todo o seu conteúdo.
O comando chgrp modifica o grupo de um arquivo. A sintaxe mais usada é:
chgrp <grupo> <lista de arquivos ou diretórios>
A opção -R tem o mesmo efeito que no comando chmod.
Exemplo:
chgrp adm textos muda o grupo de textos para adm;
chgrp R adm textos muda o grupo de textos e de todo o seu conteúdo para
adm.
2.14 Mudando de usuário
É possível mudar de usuário sem ter de sair do shell ou iniciar outro. Para isso utilizase o
comando su. Basta digitar:
su <usuário>
O programa perguntará pela senha do usuário especificado. Ao terminar de utilizar o
outro usuário, use o comando exit ou pressione Ctrl+d para voltar ao usuário que
executou o comando su.
2.15 Definindo apelidos para comandos
O comando alias permite criar apelidos para comandos. Geralmente utilizase:
alias <apelido>=<comando>
Se o comando possuir espaços ou caracteres especiais pode ser preciso colocálo entre
aspas.
Exemplos:
alias lista=ls a partir de agora, ao digitar o comando lista no shell,
ele substituirá por ls ao interpretar o comando;
alias a partir de agora, ao digitar ls no shell ele substituirá
ls=”ls color” por ls --color.
Para remover um apelido criado anteriormente, utilizase o comando unalias. A sintaxe é:
unalias <apelido>
Exemplo:
unalias lista o apelido lista deixa de existir.
2.16 O arquivador tar
O arquivador tar é usado para arquivar vários arquivos em um único. Usualmente ele é
usado para compactar arquivos. A sintaxe é:
tar <operações> [opções] [destino] <origem>
Algumas operações comuns são:
c criar
x extrair
u atualizar
t listar
Algumas opções comumente utilizadas:
z compactar utilizando gzip;
v verbose mode – mostra detalhes da operação;
p preserva permissões;
j compacta com bzip2;
f usado para especificar um arquivo para gravação.
Exemplos:
tar czvf mydir.tgz mydir cria um arquivo mydir.tgz que contém o
conteúdo de mydir compactado no formato
gzip e mostra informação extra sobre o
processo, na tela;
tar xzvf mydir.tgz descompata o arquivo criado
anteriormente, no diretório atual;
tar cjvfp mydir.tar.bz2 mydir mesmo que o primeiro, exceto que
compacta com bzip2 e guarda as
permissões dos arquivos;
tar xjvfp mydir.tar.bz2 descompacta o arquivo criado no exemplo
anterior e preserva as permissões.
2.17 Utilizando o editor Vim
O editor Vim (Vi Improved) é uma versão “melhorada” de um editor chamado Vi. O
Vim funciona em modo texto e é muito popular entre usuários GNU/Linux por oferecer
muitas funções e poder rodar em qualquer máquina Linux, estando instalado em quase
todos os sistemas. Recomendase que se aprenda pelo menos o o básico sobre o
programa.
Para abrir o Vim digite o comando:
vim
Para abrir um arquivo com o vim a partir da linha de comando digite:
vim <nome_do_arquivo>
Ao entrar no Vim você estará no modo normal, para entrar no modo de inserção,
pressione a tecla “i”. Para sair do modo de inserção pressione a tecla “ESC”.
No modo normal temos os comandos:
:q sai do editor;
:q! força a saída do editor, mesmo que haja modificações não
savas;
:w grava o arquivo;
:w nome grava o arquivo com o nome especificado;
:e nome abre o arquivo com o nome especificado, se não existir então
será criado ao gravar;
:/padrao busca pelo padrão após a “/”, usase “n” para ir para a
próxima ocorrência e “Shift+n” para ir para a anterior;
:s/padrao/subst substitui a primeira ocorrência do padrão padrao por
subst, na linha atual;
: substitui todas as ocorrências do padrão padrao por subst,
s/padrao/subst/g na linha atual;
:número vai para a linha indicada por numero;
u desfazer;
Ctrl+r refazer;
Ctrl+v ir para o modo visual block, que permite selecionar um bloco
de texto;
Shift+v ir para o modo visual line, que permite selecionar linhas de
texto;
yy copia a linha atual;
p cola uma linha abaixo da atual, ou um bloco após o cursor;
dd apaga a linha atual;
d$ apaga até o fim da linha atual;
#dd substituindo # por um número, indica a quantidade de linhas
a serem apagadas.
Pressionando Ctrl+v ou Shift+v entrase nos modos visual block e visual line,
respectivamente. Nesses modos basta mover o cursor para selecionar texto. Pressione “y”
para “copiar” ou “d” para “cortar” o texto selecionado.
Obs.: alguns comandos precedidos por “:” podem ser concatenados, por exemplo, o
comando “:wq” grava o arquivo e sai do Vim.
2.18 Outras maneiras de ver o conteúdo de um arquivo
O comando sort mostra o conteúdo do arquivo, ordenando as linhas, quando usado da
seguinte forma:
sort <nome_do_arquivo>
É possível procurar um texto em um arquivo usando o comando grep. Assim:
grep <texto> <nome do arquivo>

O comando less permite visualizar um arquivo de texto, tendo a possibilidade de
“rolar” o texto. É possível buscar texto, utilizando os mesmos comandos do programa
man. A maneira trivial de usálo é:
less <nome do arquivo>
O comando head mostra as primeiras linhas de um arquivo e o comando tail mostra as
últimas. Suas formas de uso mais comuns são:
head <nome do arquivo>
tail <nome do arquivo>
A opção n recebe como argumento o número de linhas a ser mostrado, para ambos os
comandos.
2.19 Mais alguns símbolos especiais
Além dos símbolos “>” e “>>”, já abordados, há outros que podem ser usados no shell.
Um deles é o “|”, chamado pipe, que serve para redirecionar a saída de um comando
para outro.
Exemplo:
ls -l|grep users
Esse comando mostrará todas as linhas do resultado de ls -l que contiverem a palavra
“users”.
O símbolo “&”, quando colocado no final do comando, faz com que esse seja executado
em segundo plano.
Exemplo:
tar czf exemplos.tar.gz exdir&
O símbolo “&&”, entre dois comandos, faz com que eles sejam executados em
seqüência. No entanto, se um dos comandos falhar, todos os que estão depois dele não
serão executados.
Exemplo:
tar czvf exem.tar.gz exdir && cp exem.tar.gz /mnt/floppy
3 Controlando a execução de programas
Abaixo estão descritos alguns comandos e métodos úteis para o controle da execução de
processos no GNU/Linux.
3.1 O comando top
O comando top apresenta uma lista dos processos sendo
executados no sistema, que estão ocupando mais recursos.
Geralmente é usado assim:
top
Para sair do top basta digitar “q”.
3.2 O comando jobs
O comando jobs mostra os processos que estão parados ou
rodando em segundo plano.
Sintaxe:
jobs
O número de identificação de cada processo parado ou em segundo plano (job), é usado
com os comandos bg, fg e kill.
3.3 O comando pstree
Mostra a estrutura de processos em execução no sistema em forma de árvore.
Exemplo:
pstree
3.4 O comando pidof
Mostra o process id (pid) de um programa.
Sintaxe:
pidof programa
Exemplo:
pidof wget
3.5 Interrompendo a execução de processos
Para interromper a execução de um processo (matar um
processo) rodando em primeiro plano, basta digitar

“Ctrl+c”. Caso contrário podese utilizar os comandos kill
ou killall. O comando killall mata todos os processos com o
nome que recebe como argumento.
Sintaxe:
kill <pid>
killall <comando>
O pid do processo pode ser encontrado utilizando o comando
ps ax. Caso não consiga matar o processo usando kill pid,
experimente kill -9 pid. Esse último comando envia o sinal
de destruição ao processo, obrigandoo a encerrar na marra.
4 Shell Script
O shell como anteriormente já dito é um aplicativo que serve de interface entre o usuário
e o sistema Linux. Contudo essa ferramenta também é muito utilizada em todos os
sistemas UNIX/Like. Existem diversas implementações de programas do tipo shell.
Podemos destacar:
 csh;
 tcsh;
 sh;
 bash;
 ksh;
 zsh.
Cada implementação de um Shell possui suas peculiaridades. O formato em que se deve
escrever comandos, a forma como se declaram variáveis, formas de acessar variáveis de
ambiente, entre outras coisas. O foco dessa apostila é o Bash, que basicamente é uma
versão melhorada do sh.
4.1 O que é um Script em Shell?
É uma seqüência de comandos armazenada em um arquivo no formato texto capaz de ser
executada a partir de um interpretador shell. Diversas atividades administrativas de
servidores ou mesmo atividades de usuários podem ser facilmente beneficiadas por esse
recurso do shell.
Uma das grandes vantagens nesse tipo de script é a possibilidade de se utilizar vários
programas já implementados para funcionar por linha de comando.
4.2 Olá Mundo Cruel
Nesse momento iremos abordar o “princípio do início” ;). O famoso “olá mundo” esse
que normalmente é o primeiro programa a ser feito em uma nova linguagem de
programação.
Crie um arquivo com o nome “ola_mundo.sh”. Podese utilizar o editor da sua
preferência. Como nesse curso o foco é linha de comando sugerimos que utilize o vim,
nano ou GNU/emacs.
vim ola_mundo.sh
ou
nano ola_mundo.sh
ou outro editor qualquer.
Em seguida coloque o conteúdo abaixo no arquivo e logo em seguida salveo.
#!/bin/bash
#echo “estou comentado”

echo “ola mundo cruel”
Para poder executar nosso script existem duas abordagens possíveis:
1. Utilizase do comando bash;
bash ola_mundo.sh
2. Trocar as permissões do arquivo configurando ele como executável a partir do
comando chmod.
chmod +x ola_mundo.sh
./ola_mundo.sh
4.3 Lendo o teclado
É um fato bastante comum a necessidade de interação com o usuário, por isso existe o
comando read. Esse comando é responsável por ler a entrada do teclado e inicializar uma
variável conforme o exemplo de código abaixo:
#!/bin/bash
echo “Qual é o seu nome? ”
read PESSOA
echo “Olá $PESSOA”
Note nesse exemplo o uso da variável PESSOA. No nosso exemplo usamos a variável
toda em caixa alta. Entretanto, não é necessário que o nome da variável seja toda em
maiúsculo. Outro fato bastante importante é o fato da utilização do caractere “$” no
momento em que imprimimos o valor da variável.
4.4 Brincando com variáveis
Na programação em scripts para o bash existem algumas maneiras específicas para
trabalhar com as variáveis. Diferentemente de linguagens como C, C++, Java, entre
outras não existe a necessidade de se declarar uma variável para usála e nem de se
definir o tipo dela. No exemplo de código abaixo veremos algumas maneiras para se
trabalhar com variáveis.
#!/bin/bash
echo "Digite alguma coisa"
#lendo entrada do teclado
read var_teclado
#inicializando uma variável inteira
num_int=2
echo "Teclado + numero="$((num_int+var_teclado))
4.5 Laços e estruturas de controle
Apesar de scripts em shell serem mais simples que muitas linguagens ele apresenta boa
parte de estruturas de controle e de blocos de repetição.
if COMANDO for VARIAVEL in LISTAGEM while COMANDO
then do do
comandos comandos comandos
else done done
comandos
fi
4.6 Testes condicionais
Testes de variáveis numéricas:
lt menor que. (LessThan)
gt maior que. (GreaterThan)
le menor igual. (LessEqual)
ge maior igual.(GreaterEqual)
eq igual. (Equal)
ne diferente de. (NotEqual)
Testes de variáveis String:
n não nula.
z é nula.
= igual.
=! diferente de
Testes de arquivos:
d é diretório .
f é arquivo normal.
r tem permissão de leitura .
s tamanho maior que zero.
w tem permissão de escrita.
nt mais recente que. (NewerThan)
ot mais antigo que. (OlderThan)
ef é o mesmo.
a E lógico (AND)
o OU lógico (OR)
4.7 Exemplos de laços e estruturas de controle
#!/bin/bash
lista="1 2 3 4 5 6 7 8 9 10"
echo "exemplo de for"
for i in $lista
do
echo $i
done
num1=1
num2=30
echo "exemplo if"
if [ $num1 -lt $num2 ]

then
echo $num1"<"$num2
else
echo $num1">="$num2
fi
echo "exemplo while"

while [ $num2 -gt $num1 ]
do
num1=$((num1+1))
echo $num2">"$num2
done
4.8 Entrada por argumento
Algo bastante corriqueiro ao desenvolver uma aplicação ou um script é a possibilidade de
receber argumentos direto pela linha de comando. Dessa forma, podemos receber dados
como entrada sem precisar usar o comando read.
Variáveis de entrada:
$# Número de argumentos
$1 argumento 1
$2 argumento 2
$3 argumento 3
$4 argumento 4
$n argumento de número n. Sendo que n é um valor numérico.
$* lista com todos os valores de entrada na forma de uma lista.
#!/bin/bash
primeiro_nome=$1
echo "Olá"$primeiro_nome
echo "O seu nome completo é: "$*
echo "Seu nome completo é composto por "$#"palavras"
5 Trabalhando com a Linguagem C
Nessa seção mostraremos um pouco de informação sobre ferramentas utilizadas para a
programação com a linguagem C. Falaremos sobre o compilador GCC (GNU Compiler
Collection), depurador gdb e seu frontend, o DDD.
5.1 Compilador GCC
O GCC é utilizado para compilar arquivos fontes e gerar arquivos executáveis. Vamos
mostrar um exemplo simples de como compilar um programa em linguagem C.
Primeiramente vamos criar um arquivo teste.c com o seguinte conteúdo:
#include <stdio.h>
main()
{
printf(“Olá Calouros!\n”);
}
Para compilar o programa acima executamos o comando:
gcc -o ola teste.c
Será gerado o arquivo executável ola, para executálo basta digitar ./ola na linha de
comando.
Algumas opções úteis do GCC:
o recebe como argumento o arquivo de saída, se não for
especificado, será gerado um arquivo chamado a.out;
g adiciona ao executável informações de depuração. Necessário
para o uso de um depurador como o gdb;
Wall faz com que o compilar mostre alertas sobre possíveis erros que
antes eram ignorados;
l<biblioteca> recebe como argumento bibliotecas necessárias para o programa.
5.2 Depurador GDB
O GDB (GNU DeBugger) é uma ferramenta que auxilia o programador a encontrar erros
no código. Para utilizálo para depurar um programa é necessário que o mesmo tenha
sido compilado utilizando a opção g. Basta digitar o comando:
gdb <nome do executável>
Os principais comandos para a utilização do GDB são:
run roda o programa, só irá parar quando o
programa terminar normalmente ou
devido a uma falha fatal, ou então quando
atingir um breakpoint;
break <número da linha> insere um breakpoint na linha
especificada;
list mostra o código das 5 linhas anteriores e
5 linhas posteriores da posição atual;
next passa para a linha seguinte do programa;
step passa para a linha do próximo comando
executado, no código;
print <nome da variável> imprime o conteúdo da variável no
momento.
5.3 Depurador DDD
O DDD (Data Display Debugger) é um frontend gráfico para o GDB, ou seja é um
programa em interface gráfica que utiliza o GDB. Ele fornece uma interface que permite
enviar comandos para o GDB, utilizando o mouse e mostrar informações coletadas pelo
mesmo, de forma gráfica. O comando de inicialização é o seguinte (é necessário estar em
um terminal gráfico):
ddd <nome do arquivo executável>
Utilização básica:
 para criar um breakpoint: clique com o botão direito do mouse na linha desejada
e selecione a opção “set breakpoint”;
 para executar o programa: clique em “run”;
 para visualizar o conteúdo de uma variável: dê um duplo clique no nome da
variável;
 para passar para o próximo passo: clique em “step”;
 para passar para a próxima linha, sem ver os passos intermediários: clique
em “next”;
 para interromper a execução do programa: clique em “interrupt”.
6 Conectando máquinas remotas
utilizando SSH
SSH executa um shell remoto, proporcionando conexão segura a uma máquina rodando
um servidor SSH. Para conectar a um servidor digitase:
ssh <usuário>@<servidor>
Exemplo:
ssh aluno@ssh.local.com.br solicita uma conexão ao servidor
ssh.local.com.br utilizando o usuário
aluno.
É possível também usar o sftp para transferir arquivos para ou de um servidor remoto.
O comando é:
sftp <usuário>@<servidor>
Dentro do sftp você pode usar os comandos:
pwd mostra o diretório atual no servidor;
ls lista os arquivos do diretório atual no servidor;
cd <nome_do_diretório> muda o diretório atual no servidor;
get <nome_de_arquivo> transfere arquivos do servidor para o cliente;
put <nome_de_arquivos> transfere arquivos do cliente para o servidor;
bye ou Ctrl+d sai do sftp.
6.1 Utilizando o scp
O comando scp permite a cópia de arquivos entre duas máquinas utilizandose os
recursos de criptografia do SSH e pode ser uma alternativa ao uso do FTP.
Sua forma básica é:
$ scp arquivo-origem arquivo-destino
A origem e o destino podem se localizar na máquina cliente ou na máquina servidor,
além do mais, pode ser necessário fornecer o login também. Por exemplo, para copiar um
arquivo da máquina local para o servidor você poderá usar o scp assim:
$ scp arquivo usuario@servidor:/home/usuario
Note que é necessário indicar o caminho absoluto no servidor e não o caminho relativo
apenas à sua área home.
Para copiar um arquivo do servidor para sua máquina utilize:
$ scp usuario@servidor:/caminho/arquivo .
7 Mais informações
7.1 Interface Gráfica
Em sistemas GNU/Linux a interface gráfica não faz parte do sistema operacional. O que
se tem é um servidor gráfico, chamado servidor X, independente do SO, que fornece
serviços gráficos a outros programas que fazem interface com ele através de bibliotecas.
Usualmente são rodados “em cima” do X , programas chamados gerenciadores de
janelas e Ambientes de Desktop ou simplesmente desktops.
Os gerenciadores de janelas tem por objetivo principal controlar o posicionamento das
janelas gráficas, seu redimensionamento e movimento. Eles também controlam barras de
título, foco de janelas, e atalhos de mouse e teclado. Esses programas controlam a
aparência das janelas e as maneiras pelas quais os usuários interagem com elas.
Exemplos de gerenciadores de janelas são Fluxbox, AfterStep, WindowMaker, IceWM,
Metacity(usado pelo Gnome) e Kwin (usado pelo KDE).
Os desktops rodam no topo de um gerenciador de janelas. Eles objetivam prover uma
interface mais completa com o sistema operacional, e suprir seu próprio conjunto de
aplicações e utilitários integrados. Essa conveniência e facilidade de uso faz deles
particularmente atrativos para usuários iniciantes. Os desktops mais populares são
Gnome, KDE e XFCE.
O Gnome é um desktop relativamente rápido (se comparado ao KDE), e que provê as
vantagens de um desktop, sem trazer uma sobrecarga de efeitos visuais supérfluos. O
KDE é um desktop poderoso, com muitos recursos. Agrada àqueles acham que vale a
pena que sacrificar um pouco de performance, em troca de um visual mais elaborado,
com mais efeitos e possibilidades de configuração. Já o XFCE tem por objetivo ser leve,
e essa é sua característica mais interessante.
7.2 Buscando outras fontes de informação
O “Guia foca GNU/Linux”, cujo endereço está na bibliografia, é um guia bastante
completo, possuindo os níveis iniciante, intermediário e avançado. O site
http://www.linuxrsp.ru/winlinsoft/tableeng.html possui uma tabela de programas
Linux, boa parte sendo gráficos, divididos em categorias, e os programas Windows dos
quais são possíveis equivalentes. A mais, na Internet pode ser encontrada extensa
documentação sobre GNU/Linux e sobre os utilitários e aplicativos que rodam nesse
sistema. Também não pode ser esquecido o comando man.
8 Bibliografia
Silva, G. M. “Guia Foca GNU/Linux”, 2005. Disponível em:
http://www.guiafoca.org/download/inic_interm/focalinux12html.tar.gz
Chapman M., “Window Managers for X”. Disponível em: http://xwinman.org/
Miranda, M. D., “Tutorial do Vim”. Disponível em: http://br
linux.org/artigos/vim_intro.htm
“The table of equivalents / replacements / analogs of Windows software in Linux”,
Disponível em: http://www.linuxrsp.ru/winlinsoft/tableeng.html
Wikipédia. “Shell” . Disponível em: “http://pt.wikipedia.org/wiki/Shell”
Jargas, A. M. “Introdução ao Shell Script”, 2004 Disponível
em:http://aurelio.net/shell/apostilaintroducaoshell.pdf

Curso Linux 2010

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Curso Linux 2010

Uploaded by

Copyright:

Available Formats

Universidade Federal de Santa Maria

/home Diretório contendo os diretórios dos usuários. Geralmente os usuários

Dentro do man utilize as telas de seta, PgUp e PgDn para rolar o texto. É possível

[padrão] Faz referência a uma faixa de caracteres de um

As partições de um disco são nomeadas anexando o número da partição ao do

grep <texto> <nome do arquivo>

processo) rodando em primeiro plano, basta digitar

#echo “estou comentado”

echo "Teclado + numero="$((num_int+var_teclado))

if [ $num1 -lt $num2 ]

echo "exemplo while"

echo "Seu nome completo é composto por "$#"palavras"

$ scp arquivo-origem arquivo-destino

$ scp arquivo usuario@servidor:/home/usuario

You might also like