Linux whatch exemplos

Linux comando whatch com exemplos

---
Comando watch do Linux - o utilitário watch permite executar um comando repetidamente. A seguir está a sintaxe deste comando:
---
watch [options] command
---
watch executa o comando repetidamente, exibindo sua saída e erros (a primeira tela cheia).
---
Isso permite que você observe a saída do programa mudar ao longo do tempo.
---
Por padrão, o programa é executado a cada 2 segundos. Por padrão, o relógio será executado até ser interrompido. Para interromper aperto duas teclas, as teclas Ctrl+c. A seguir estão alguns exemplos estilizados que devem dar uma boa idéia de como o comando watch funciona.
---
Como funciona o comando watch? O uso básico do watch é muito fácil - tudo o que você precisa fazer é executar a ferramenta com um nome de comando como entrada. Por exemplo:
watch date
---
Como funciona o comando watch? A primeira linha da saída informa que a saída do comando 'date' está sendo atualizada a cada 2 segundos (esse é o intervalo de tempo padrão), seguida pela data / hora atual do sistema. A segunda linha é a saída real do comando 'date' que é atualizada após alguns segundos.
---
Como fazer o relógio destacar a diferença entre as atualizações? Como já explicado na seção anterior, a saída do comando que está sendo rastreado é atualizada regularmente (após 2 segundos, por padrão). Caso você queira, você também pode fazer 'assistir' destacar a parte da saída que está mudando entre as atualizações. Isso você pode fazer usando a opção de linha de comando -d. Por exemplo:
watch -d date
---
Como já explicado, a saída do comando que está sendo rastreado é atualizada regularmente (após 2 segundos, por padrão). Caso você queira, você também pode fazer 'assistir' destacar a parte da saída que está mudando entre as atualizações. Isso você pode fazer usando a opção de linha de comando -d. Por exemplo:
watch -n 5 date
---
Este comando garantirá que a saída seja atualizada a cada 5 segundos. Por favor, note que intervalos inferiores a 0,1 segundos não são permitidos. Nota: Para garantir que o intervalo entre intervalos seja respeitado com muita precisão, use a opção de linha de comando -p.
---
Faça o watch tentar executar o comando a cada intervalo de segundos. Experimente com ntptime e observe como os segundos fracionários ficam quase) o mesmo, ao contrário do modo normal, onde eles aumentam continuamente.
---
Como desligar o cabeçalho na saída? Se desejar, você também pode pedir 'watch' para desativar o cabeçalho, mostrando o intervalo, o comando e a hora atual na parte superior da tela, bem como a seguinte linha em branco. Isso pode ser feito usando a opção de linha de comando -t. Por exemplo:
watch -t date
---
Como fazer o relógio sair quando a saída muda? Se você quiser que o comando 'watch' seja encerrado após a detecção de uma alteração na saída, use a opção de linha de comando -g. Por exemplo:
watch -g free
---
Assim, sempre que o consumo de memória no sistema for alterado, o comando watch será encerrado.
---
Para saber mais visite:
fonte
---
Até breve! 🙂
---

Linux – comandos e shell script – meu treceiro script Vi

MEU TERCEIRO SCRIPT USANDO VI:

.

#!/bin/bash

#####################################
# Nome do Script: MeuTerceiroScriptVi.sh
#
# Descrição:
# 1) monom nomnom monm
# 2) nomo nom nmonm
# 3) mon mobm nmobm
#
# Autor: Fulano de Tal
#
# Data da Criação: DD/MM/YYYY
#
# Email: meu_mail1@mail.com
#
#
#####################################
#
#
# Sobre este script:
# 1) nononono nono nono nonon
# 2) momo momoo momoom momom
# 3) nono mo mo momom
#
# Exemplo de uso:
# 1) nom nmomommn mmmnoomonm
# 2) monom monmomnom nmom nmonm
#
# Histórico de modificações:
# 1) Dia X - Inclusão da função de...
# 2) monm mnmonm mnomo nmoomn
#
# Comentário:
# 1) monom monom monomon
# 2) monom nomonmom nomo
#
# REGRAS DO CÓDIGO LIMPO:
#
# 1) Colocar apenas um comando por linha
#
# 2) Alinhar verticalmente comandos de um mesmo bloco
#
# 3) Deslocar o alinhamento a direita a cada novo bloco
#
# 4) Usar linhas em branco para separar trechos
#
# 5) Não ultrapassar o limite de 80 colunas por linha
#
#
# COMENTÁRIOS ESPECIAIS:
#
#
# TODO - indica uma tarefa a ser feita
# 1)
# 2)
# 3)
#
# FIXME - indica um bug conhecido que precisa ser arrumado
#
#
#
# XXX - Notícia, chama a atenção
#
#
#
#####################################

DATAHORA=$(date +%H:%M) # As variaveis sao sempre declaradas no comeco do script

clear
# Funcao de leitura data e hora
echo "==== Meu Terceiro Script Vi ===="
sleep 2
echo ""
echo "======================"
echo -n "Data e hora: $DATAHORA"
sleep 3

# Area de leitura da lista de criaturas
echo "======================"
echo "Listagem de Criaturas:"
sleep 2
echo "======================"
sort Alista_de_list.txt
sleep 5
echo ""
echo "======================"
echo "=== Últimos arquivos modificados: ==="
sleep 2
echo "======================"
ls -t # Lista arquivos e diretórios por data de modificação
echo "======================"
sleep 8
exit

.

Executo:

.

1) > MeuTerceiroScriptVi.sh

2) chmod +x MeuTerceiroScriptVi.sh

3) vi MeuTerceiroScriptVi.sh

4) Aperto Esc digito i e colo:

#!/bin/bash

#####################################
# Nome do Script: MeuTerceiroScriptVi.sh
#
# Descrição:
# 1) monom nomnom monm
# 2) nomo nom nmonm
# 3) mon mobm nmobm
#
# Autor: Fulano de Tal
#
# Data da Criação: DD/MM/YYYY
#
# Email: meu_mail1@mail.com
#
#
#####################################
#
#
# Sobre este script:
# 1) nononono nono nono nonon
# 2) momo momoo momoom momom
# 3) nono mo mo momom
#
# Exemplo de uso:
# 1) nom nmomommn mmmnoomonm
# 2) monom monmomnom nmom nmonm
#
# Histórico de modificações:
# 1) Dia X - Inclusão da função de...
# 2) monm mnmonm mnomo nmoomn
#
# Comentário:
# 1) monom monom monomon
# 2) monom nomonmom nomo
#
# REGRAS DO CÓDIGO LIMPO:
#
# 1) Colocar apenas um comando por linha
#
# 2) Alinhar verticalmente comandos de um mesmo bloco
#
# 3) Deslocar o alinhamento a direita a cada novo bloco
#
# 4) Usar linhas em branco para separar trechos
#
# 5) Não ultrapassar o limite de 80 colunas por linha
#
#
# COMENTÁRIOS ESPECIAIS:
#
#
# TODO - indica uma tarefa a ser feita
# 1)
# 2)
# 3)
#
# FIXME - indica um bug conhecido que precisa ser arrumado
#
#
#
# XXX - Notícia, chama a atenção
#
#
#
#####################################

DATAHORA=$(date +%H:%M) # As variaveis sao sempre declaradas no comeco do script

clear
# Funcao de leitura data e hora
echo "==== Meu Terceiro Script Vi ===="
sleep 2
echo ""
echo "======================"
echo -n "Data e hora: $DATAHORA"
sleep 3

# Area de leitura da lista de criaturas
echo "======================"
echo "Listagem de Criaturas:"
sleep 2
echo "======================"
sort Alista_de_list.txt
sleep 5
echo ""
echo "======================"
echo "=== Últimos arquivos modificados: ==="
sleep 2
echo "======================"
ls -t # Lista arquivos e diretórios por data de modificação
echo "======================"
sleep 8
exit

5) Aperto Esc e digito :wq

6) Executo com o comando:

./MeuTerceiroScriptVi.sh

.

Muito beleza. Tudo ok!

.

Viva o GNU/Linux! Se não gosta, que remova coreutils vai fazer o que da vida então?

.

https://pt.wikipedia.org/wiki/GNU_Core_Utilities

.

Anotações do Guia Foca

.

O Guia Foca de Gleydson Mazioli da Silva foi atualizado pela última vez a mais ou menos uns oito anos atrás e apesar de bastante coisa ter mudado ele é extremamente valioso quando se trata de definições, comandos, bash, shell script e vários outros assuntos.

.

Na minha opinião o material é imbatível. A gente que gosta de Linux, pode passear pelo Guia Foca como em um parque de diversões pulando entre assuntos pois o índice de conteúdo é muito bem elaborado.

.

Este artigo tem partes do Guia Foca que me chamaram a atenção um dia destes. Este artigo também tem uns pedaços de outros lugares. Outras partes deste artigo, eu reformulei, adaptei e até mesmo escrevi e reescrevi de acordo com o que aprendi praticando, lendo e pesquisando.

Não é perfeito, longe disto, mas me é útil.

Escrevi/Montei/Adaptei este artigo para o meu uso pessoal e executo o que aprendi aqui, por minha conta e risco. Este artigo é bem útil para mim. Espero que ele seja útil também para você. Perdoe erros de digitação e se alguma definição estiver inadequada.

Revisei o texto algumas vezes mas, nunca é o suficiente. O segredo é a prática. Neste mundo atual onde se pode fazer isto com facilidade? Um dos poucos lugares que conheço é no mundo Linux. Isto não é apenas estudo com objetivo profissional para muitas pessoas é uma tranquila forma de lazer, para outros é um modo de se por a prova e descobrir até onde você consegue chegar. Todo processo de aprendizado é satisfatório quando você mesmo consegue perceber efetivamente o resultado.

.

COMANDOS

.

Comandos são ordens que passamos ao sistema operacional para executar uma determinada tarefa.

Cada comando tem uma função específica, devemos saber a função de cada comando e escolher o mais adequado para fazer o que desejamos, por exemplo:

ls - Mostra arquivos de diretórios

cd - Para mudar de diretório

É sempre usado um espaço depois do comando para separá-lo de uma opção ou parâmetro que será passado para o processamento. Um comando pode receber opções e parâmetros:

OPÇÕES
As opções são usadas para controlar como o comando será executado, por exemplo, para fazer uma listagem mostrando o dono, grupo, tamanho dos arquivos você deve digitar ls -l.

Opções podem ser passadas ao comando através de um:

"-" ou "--":

-

Opção identificada por uma letra. Podem ser usadas mais de uma opção com um único hífen. O comando ls -l -a é a mesma coisa de ls -la

--

Opção identificada por um nome. Também chamado de opção extensa. O comando ls --all é equivalente a ls -a.

Pode ser usado tanto "-" como "--", mas há casos em que somente "-" ou "--" esta disponível.

PARÂMETROS
Um parâmetro identifica o caminho, origem, destino, entrada padrão ou saída padrão que será passada ao comando.

Se você digitar: ls /usr/share/doc/copyright, /usr/share/doc/copyright será o parâmetro passado ao comando ls, neste caso queremos que ele liste os arquivos do diretório /usr/share/doc/copyright.

É normal errar o nome de comandos, mas não se preocupe, quando isto acontecer o sistema mostrará a mensagem command not found (comando não encontrado) e voltará ao aviso de comando. As mensagens de erro não fazem nenhum mal ao seu sistema, somente dizem que algo deu errado para que você possa corrigir e entender o que aconteceu. No GNU/Linux, você tem a possibilidade de criar comandos personalizados usando outros comandos mais simples (isto será visto mais adiante). Os comandos se encaixam em duas categorias: Comandos Internos e Comandos Externos.

Por exemplo: "ls -la /usr/share/doc", ls é o comando, -la é a opção passada ao comando, e /usr/share/doc é o diretório passado como parâmetro ao comando ls.

.

COMANDOS INTERNOS

São comandos que estão localizados dentro do interpretador de comandos (normalmente o Bash) e não no disco. Eles são carregados na memória RAM do computador junto com o interpretador de comandos.

Quando executa um comando, o interpretador de comandos verifica primeiro se ele é um Comando Interno caso não seja é verificado se é um Comando Externo.

Exemplos de comandos internos são: cd, exit, echo, bg, fg, source, help

.

COMANDOS EXTERNOS

São comandos que estão localizados no disco. Os comandos são procurados no disco usando o ordem do PATH e executados assim que encontrados.

.

ESTRUTURA BÁSICA DE DIRETÓRIOS DO SISTEMA LINUX

.

O sistema GNU/Linux possui a seguinte estrutura básica de diretórios organizados segundo o FHS (Filesystem Hierarchy Standard):

O DIRETÓRIO RAIZ (/)

Diretório do usuário root. Todos os arquivos e diretórios do sistema Linux instalado no computador partem de uma única origem: o diretório raiz. Mesmo que estejam armazenados em outros dispositivos físicos, é a partir do diretório raiz – representado pela barra (/) – que você poderá acessá-los. O único usuário do sistema capaz de criar ou mover arquivos do diretório raiz é o root, ou seja, o usuário-administrador. Isso evita que usuários comuns cometam erros e acabem comprometendo a integridade de todo o sistema de arquivos.

BINÁRIOS EXECUTÁVEIS: /BIN

No diretório /bin estão localizados os binários executáveis que podem ser utilizados por qualquer usuário do sistema. São comandos essenciais, usados para trabalhar com arquivos, textos e alguns recursos básicos de rede, como o cp, mv, ping e grep.

BINÁRIOS DO SISTEMA: /SBIN

Diretório de programas usados pelo superusuário (root) para administração e controle do funcionamento do sistema. Assim como o /bin, este diretório armazena executáveis, mas com um diferencial: são aplicativos utilizados por administradores de sistema com o propósito de realizar funções de manutenção e outras tarefas semelhantes. Entre os comandos disponíveis estão o ifconfig, para configurar e controlar interfaces de rede TCP/IP, e o fdisk, que permite particionar discos rígidos, por exemplo.

PROGRAMAS DIVERSOS: /USR

Contém maior parte de seus programas. Normalmente acessível somente como leitura. Se você não encontrar um comando no diretório /bin ou /sbin, ele certamente está aqui. O /usr reúne executáveis, bibliotecas e até documentação de softwares usados pelos usuários ou administradores do sistema. Além disso, sempre que você compilar e instalar um programa a partir do código-fonte, ele será instalado nesse diretório.

CONFIGURAÇÕES DO SISTEMA: /ETC

Arquivos de configuração de seu computador local. No diretório /etc ficam arquivos de configuração que podem ser usados por todos os softwares, além de scripts especiais para iniciar ou interromper módulos e programas diversos. É no /etc que se encontra, por exemplo, o arquivo resolv.conf, com uma relação de servidores DNS que podem ser acessados pelo sistema, com os parâmetros necessários para isso.

BIBLIOTECAS: /LIB

Bibliotecas compartilhadas pelos programas do sistema e módulos do kernel. Neste ponto do sistema de arquivos ficam localizadas as bibliotecas usadas pelos comandos presentes em /bin e /sbin. Normalmente, os arquivos de bibliotecas começam com os prefixos ld ou lib e possuem "extensão" so.

OPCIONAIS: /OPT

Aplicativos adicionais, que não são essenciais para o sistema, terminam neste diretório.

AQUIVOS PESSOAIS: /HOME

Diretórios contendo os arquivos dos usuários. No diretório /home ficam os arquivos pessoais, como documentos e fotografias, sempre dentro de pastas que levam o nome de cada usuário. Vale notar que o diretório pessoal do administrador não fica no mesmo local, e sim em /root.

INICIALIZAÇÃO: /BOOT

Contém arquivos necessários para a inicialização do sistema, ou seja, o processo de boot do Linux, quando o computador é ligado, ficam em /boot.

VOLUMES E MÍDIAS: /MNT E /MEDIA

Para acessar os arquivos de um CD, pendrive ou disco rígido presente em outra máquina da rede, é necessário "montar" esse conteúdo no sistema de arquivos local, isso é, torná-lo acessível como se fosse apenas mais um diretório no sistema.

Em /media ficam montadas todas as mídias removíveis, como dispositivos USB e DVDs de dados. Já o diretório /mnt fica reservado aos administradores que precisam montar temporariamente um sistema de arquivos externo.

SERVIÇOS: /SRV

Dados de servidores e serviços em execução no computador ficam armazenados dentro desse diretório.

ARQUIVOS DE DISPOSITIVOS: /DEV

No Linux, tudo é apresentado na forma de arquivos. Ao plugar um pendrive no computador, por exemplo, um arquivo será criado dentro do diretório /dev e ele servirá como interface para acessar ou gerenciar o drive USB. Nesse diretório, você encontra caminhos semelhantes para acessar terminais e qualquer dispositivo conectado ao computador, como o mouse e até modems.

ARQUIVOS VARIÁVEIS: /VAR

Todo arquivo que aumenta de tamanho ao longo do tempo está no diretório de arquivos variáveis. Um bom exemplo são os logs do sistema, ou seja, registros em forma de texto de atividades realizadas no Linux, como os logins feitos ao longo dos meses.

PROCESSOS DO SISTEMA: /PROC

Lembra da história de que tudo funciona como um arquivo no Linux? Pois o /proc é a prova disso. Nesse diretório são encontrados arquivos que revelam informações sobre os recursos e processos em execução no sistema. Quer um exemplo? Para saber há quanto tempo o Linux está sendo usado desde a última vez em que foi iniciado, basta ler o arquivo /proc/uptime.

ARQUIVOS TEMPORÁRIOS: /TMP

Arquivos e diretórios criados temporariamente tanto pelo sistema quanto pelos usuários devem ficar nesse diretório. Boa parte deles é apagada sempre que o computador é reiniciado.

.

NOMEANDO ARQUIVOS E DIRETÓRIOS

.

No GNU/Linux, os arquivos e diretórios pode ter o tamanho de até 255 letras. Você pode identifica-lo com uma extensão (um conjunto de letras separadas do nome do arquivo por um ".").

Os programas executáveis do GNU/Linux, ao contrário dos programas de DOS e Windows, não são executados a partir de extensões .exe, .com ou .bat. O GNU/Linux (como todos os sistemas POSIX) usa a permissão de execução de arquivo para identificar se um arquivo pode ou não ser executado.

Digamos que está elaborando um trabalho de história. Ele pode ser identificado mais facilmente caso fosse gravado com o nome trabalho.text ou trabalho.txt. Também é permitido gravar o arquivo com o nome Trabalho de Historia.txt mas não é recomendado gravar nomes de arquivos e diretórios com espaços. Porque será necessário colocar o nome do arquivo entre "aspas" para acessa-lo (por exemplo, cat "Trabalho de Historia.txt"). Ao invés de usar espaços, prefira capitalizar o arquivo (usar letras maiúsculas e minúsculas para identifica-lo): TrabalhodeHistoria.txt.

.

LINUX DISCOS E PARTIÇÕES

.

Partições são divisões existentes no disco rígido que marcam onde começa e onde termina um sistema de arquivos. As partições nos permitem usar mais de um sistema operacional no mesmo computador, ou dividir o disco rígido em uma ou mais partes

.

Para gravar os dados, o disco rígido deve ser primeiro particionado no Linux hoje uso um programa gráfico chamado Gparted para fazer o particionamento

.

Podemos fazer isto também pela linha de comando do Linux usando o `cfdisk', `parted', `fdisk'

.

O tipo da partição que uso estes dias é EXT4

.

Após criada e formatada, a partição será automaticamente identificada como um dispositivo no diretório `/dev'

.

Uma partição de disco não interfere em outras partições existentes, por este motivo é possível usar o `Windows', `GNU/Linux' e qualquer outro sistema operacional no mesmo disco

.

JOURNALING O QUE É ISTO?

.

O sistema de journaling grava qualquer operação que será feita no disco em uma área especial chamada "journal", assim se acontecer algum problema durante alterações no disco, ele pode voltar ao estado anterior do arquivo, ou finalizar a operação

Desta forma, o journal acrescenta ao sistema de arquivos o suporte a alta disponibilidade e maior tolerância a falhas. Após uma falha de energia, por exemplo, o journal é analisado durante a montagem do sistema de arquivos e todas as operações que estavam sendo feitas no disco são verificadas

Dependendo do estado da operação, elas podem ser desfeitas ou finalizadas

.

TIPOS DE EXECUÇÃO DE COMANDOS/PROGRAMAS

.

Um programa pode ser executado de duas formas:

.

1. `Primeiro Plano' - Também chamado de _foreground_.

Quando em foreground você deve esperar o término da execução de um programa para executar um novo comando

Somente é mostrado o aviso de comando após o término de execução do comando/programa.

2. `Segundo Plano' - Também chamado de _background_.

Background é quando você não precisa esperar o término da execução de um programa para executar um novo comando

Após iniciar um programa em _background_, é mostrado um número PID (identificação do Processo) e o aviso de comando é novamente mostrado, permitindo o uso normal do sistema.

O programa executado em background continua sendo executado internamente

Após ser concluído, o sistema retorna uma mensagem de pronto acompanhado do número PID do processo que terminou

.

Para iniciar um programa em `primeiro plano', basta digitar seu nome normalmente

Para iniciar um programa em `segundo plano', acrescente um espaço e o caracter `"&"' após o final do comando

$ find *.jpg &

.

Mesmo que um usuário execute um programa em segundo plano e saia do sistema, o programa continuará sendo executado até que seja concluído ou finalizado pelo usuário que iniciou a execução (ou pelo usuário root)

.

Exemplo:

~ $find *.jpg &
[1] 2701
~ $find: ‘*.jpg’: Arquivo ou diretório não encontrado

[1]+ Fim da execução com status 1 find *.jpg

.

O comando será executado em segundo plano e deixará o sistema livre para outras tarefas

Após o comando `find' terminar, será mostrada uma mensagem como viste acima

.

O COMANDO PS

.

Algumas vezes é útil ver quais processos estão sendo executados no computador

O comando `ps' faz isto, e também nos mostra qual usuário executou o programa, hora que o processo foi iniciado, etc

.

`ps [_opções_]'

.

Onde:

_opções_

a
Mostra os processos criados por você e de outros usuários do sistema.

x
Mostra processos que não são controlados pelo terminal.

u
Mostra o nome de usuário que iniciou o processo e hora em que o
processo foi iniciado.

m
Mostra a memória ocupada por cada processo em execução.

f
Mostra a árvore de execução de comandos (comandos que são chamados por outros comandos).

e
Mostra variáveis de ambiente no momento da inicialização do processo.

w
Mostra a continuação da linha atual na próxima linha ao invés de cortar o restante que não couber na tela

.

Estas opções acima podem ser combinadas para resultar em uma listagem mais completa

Você também pode usar pipes "|" para `filtrar' a saída do comando `ps'

.

Para detalhes, `| (pipe)'

.

Ao contrário de outros comandos, o comando `ps' não precisa do hífen

"-" para especificar os comandos. Isto porque ele não utiliza opções longas e não usa parâmetros.

.

Exemplos: `ps', `ps ax|grep inetd', `ps auxf', `ps auxw'

.

CONTROLE DE EXECUÇÃO DE PROCESSOS - Interrompendo a execução de um processo

.

Para cancelar a execução de algum processo `rodando em primeiro plano', basta pressionar as teclas `CTRL'+`C'

A execução do programa será cancelada e será mostrado o aviso de comando

Você também pode usar o comando `kill' para interromper um processo sendo executado

.

PARANDO MOMENTANEAMENTE A EXECUÇÃO DE UM PROCESSO

.

Para parar a execução de um processo rodando em primeiro plano, basta pressionar as teclas `CTRL'+`Z'

O programa em execução será pausado e será mostrado o número de seu job e o aviso de comando

.

Para retornar a execução de um comando pausado, use `fg' ou `bg'

.

O programa permanece na memória no ponto de processamento em que parou quando ele é interrompido

Você pode usar outros comandos ou rodar outros programas enquanto o programa atual está interrompido

.

JOBS

.

O comando `jobs' mostra os processos que estão parados ou rodando em _segundo plano_

Processos em segundo plano são iniciados usando o símbolo `"&"' no final da linha de comando ou através do comando `bg'

.

O número de identificação de cada processo parado ou em segundo plano (job), é usado com os comandos `fg' e `bg'

Um processo interrompido pode ser finalizado usando-se o comando `kill %[num]', onde `[num]' é o número do processo obtido pelo comando `jobs'

.

FG

Permite fazer um programa rodando em segundo plano ou parado, rodar em primeiro plano. Você deve usar o comando jobs para pegar o número do processo rodando em segundo plano ou interrompida, este número será passado ao comando fg para ativa-lo em primeiro plano.

fg [número]

Onde número é o número obtido através do comando jobs.

Caso seja usado sem parâmetros, o fg utilizará o último programa interrompido (o maior número obtido com o comando jobs)

.

BG

Permite fazer um programa rodando em primeiro plano ou parado, rodar em segundo plano. Para fazer um programa em primeiro plano rodar em segundo, é necessário primeiro interromper a execução do comando com CTRL+ Z, será mostrado o número da tarefa interrompida, use este número com o comando bg para iniciar a execução do comando em segundo plano.

bg [número]

Onde: número número do programa obtido com o pressionamento das teclas CTRL+Z ou através do comando jobs.

.

KILL

Permite enviar um sinal a um comando/programa. Caso seja usado sem parâmetros, o kill enviará um sinal de término ao processo sendo executado.

kill [opções] [sinal] [número]

Onde:

número
É o número de identificação do processo obtido com o comando ps, Também pode ser o número após o sinal de % obtido pelo comando jobs para matar uma tarefa interrompida [jobs].

sinal
Sinal que será enviado ao processo. Se omitido usa -15 como padrão.

opções
-9
Envia um sinal de destruição ao processo ou programa. Ele é terminado imediatamente sem chances de salvar os dados ou apagar os arquivos temporários criados por ele.

Você precisa ser o dono do processo ou o usuário root para termina-lo ou destruí-lo. Você pode verificar se o processo foi finalizado através do comando ps. Os tipos de sinais aceitos pelo GNU/Linux são explicados em detalhes em Sinais do Sistema.

Exemplo: kill 500, kill -9 500, kill %1.

.

KILLALL

Permite finalizar processos através do nome.

killall [opções] [sinal] [processo]

Onde:

processo
Nome do processo que deseja finalizar

sinal
Sinal que será enviado ao processo (pode ser obtido usando a opção -i).

opções
-i
Pede confirmação sobre a finalização do processo.

-l
Lista o nome de todos os sinais conhecidos.

-q
Ignora a existência do processo.

-v
Retorna se o sinal foi enviado com sucesso ao processo.

-w
Finaliza a execução do killall somente após finalizar todos os processos.

Os tipos de sinais aceitos pelo GNU/Linux são explicados em detalhes na Sinais do Sistema.

Exemplo: killall -HUP inetd

.

KILLALL5

.

Envia um sinal de finalização para todos os processos sendo executados.

killall5 [sinal]

.

PIDOF

Retorna o PID do processo especificado

pidof [opções] [nome]

Onde:

nome
Nome do processo que seja obter o número PID

opções
-s
Retorna somente o primeiro PID encontrado.

-x
Retorna o PID do do shell que está executando o script

-o [PID]
Ignora o processo com aquele PID. O PID especial %PPID pode ser usado para nomear o processo pai do programa pidof, em outras palavras

OBS: O programa pidof é um link simbólico ao programa killall5. Cuidado ao executar o killall5 as funções e opções são completamente diferentes dependendo da forma como é chamado na linha de comando!

Exemplo: pidof -s init

.

CURINGAS

.

Curingas (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. São usados 4 tipos de curingas no GNU/Linux:

"*" - Faz referência a um nome completo/restante de um arquivo/diretório.

"?" - Faz referência a uma letra naquela posição.

[padrão] - Faz referência a uma faixa de caracteres de um arquivo/diretório. Padrão pode ser:

[a-z][0-9] - Faz referência a caracteres de a até z seguido de um caractere de 0 até 9.

[a,z][1,0] - Faz a referência aos caracteres a e z seguido de um caractere 1 ou 0 naquela posição.

[a-z,1,0] - Faz referência a intervalo de caracteres de a até z ou 1 ou 0 naquela posição.

A procura de caracteres é "Case Sensitive" assim se você deseja que sejam localizados todos os caracteres alfabéticos você deve usar [a-zA-Z].

Caso a expressão seja precedida por um ^, faz referência a qualquer caractere exceto o da expressão. Por exemplo [^abc] faz referência a qualquer caractere exceto a, b e c.

{padrões} - Expande e gera strings para pesquisa de padrões de um arquivo/diretório.

X{ab,01} - Faz referência a sequencia de caracteres Xab ou X01

X{a-z,10} Faz referencia a sequencia de caracteres Xa-z e X10.

O que diferencia este método de expansão dos demais é que a existência do arquivo/diretório é opcional para geração do resultado. Isto é útil para a criação de diretórios. Lembrando que os 4 tipos de curingas ("*", "?", "[]", "{}") podem ser usados juntos. Para entender melhor vamos a prática:

Vamos dizer que tenha 5 arquivo no diretório /usr/teste: teste1.txt, teste2.txt, teste3.txt, teste4.new, teste5.new.

Caso deseje listar todos os arquivos do diretório /usr/teste você pode usar o coringa "*" para especificar todos os arquivos do diretório:

cd /usr/teste e ls * ou ls /usr/teste/*.

Não tem muito sentido usar o comando ls com "*" porque todos os arquivos serão listados se o ls for usado sem nenhum Coringa.

Agora para listar todos os arquivos teste1.txt, teste2.txt, teste3.txt com exceção de teste4.new, teste5.new, podemos usar inicialmente 3 métodos:

Usando o comando ls *.txt que pega todos os arquivos que começam com qualquer nome e terminam com .txt.

Usando o comando ls teste?.txt, que pega todos os arquivos que começam com o nome teste, tenham qualquer caractere no lugar do coringa ? e terminem com .txt. Com o exemplo acima teste*.txt também faria a mesma coisa, mas se também tivéssemos um arquivo chamado teste10.txt este também seria listado.

Usando o comando ls teste[1-3].txt, que pega todos os arquivos que começam com o nome teste, tenham qualquer caractere entre o número 1-3 no lugar da 6a letra e terminem com .txt. Neste caso se obtém uma filtragem mais exata, pois o coringa ? especifica qualquer caractere naquela posição e [] especifica números, letras ou intervalo que será usado.

Agora para listar somente teste4.new e teste5.new podemos usar os seguintes métodos:

ls *.new que lista todos os arquivos que terminam com .new

ls teste?.new que lista todos os arquivos que começam com teste, contenham qualquer caracter na posição do coringa ? e terminem com .new.

ls teste[4,5].* que lista todos os arquivos que começam com teste contenham números de 4 e 5 naquela posição e terminem com qualquer extensão.

Existem muitas outras formas de se fazer a mesma coisa, isto depende do gosto de cada um. O que pretendi fazer aqui foi mostrar como especificar mais de um arquivo de uma só vez. O uso de curingas será útil ao copiar arquivos, apagar, mover, renomear, e nas mais diversas partes do sistema. Alias esta é uma característica do GNU/Linux: permitir que a mesma coisa possa ser feita com liberdade de várias maneiras diferentes.

.

PSTREE

.

Mostra a estrutura de processos em execução no sistema em forma de árvore.

pstree [opções] [pid]

Onde:

pid
Número do processo que terá sua árvore listada. Se omitido, lista todos os processos.

opções
-a
Mostra opções passadas na linha de comando.

-c
Mostra toda a estrutura (inclusive sub-processos do processo pai).

-G
Usa caracteres gráficos no desenho da árvore de processos.

-h
Destaca o processo atual e seus antecessores.

-H [pid]
Destaca o processo especificado.

-l
Não faz quebra de linha

-n
Classifica pelo número PID ao invés do nome.

-p
Mostra o número PID entre parênteses após o nome do processo.

-u
Mostra também o dono do processo.

-U
Usa o conjunto de caracteres Unicode para o desenho da árvore

.

FECHANDO UM PROGRAMA QUANDO NÃO SE SABE COMO SAIR

.

Muitas vezes quando se esta iniciando no GNU/Linux você pode executar um programa e talvez não saber como fecha-lo. Este capítulo do guia pretende ajuda-lo a resolver este tipo de problema.

Isto pode também ocorrer com programadores que estão construindo seus programas e por algum motivo não implementam uma opção de saída, ou ela não funciona!

Em nosso exemplo vou supor que executamos um programa em desenvolvimento com o nome contagem que conta o tempo em segundos a partir do momento que é executado, mas que o programador esqueceu de colocar uma opção de saída. Siga estas dicas para finaliza-lo:

Normalmente todos os programas UNIX (o GNU/Linux também é um Sistema Operacional baseado no UNIX) podem ser interrompidos com o pressionamento das teclas e . Tente isto primeiro para finalizar um programa. Isto provavelmente não vai funcionar se estiver usando um Editor de Texto (ele vai entender como um comando de menu). Isto normalmente funciona para comandos que são executados e terminados sem a intervenção do usuário.

Caso isto não der certo, vamos partir para a força! ;-)

Mude para um novo console (pressionando e ), e faça o login como usuário root.

Localize o PID (número de identificação do processo) usando o comando: ps ax, aparecerão várias linhas cada uma com o número do processo na primeira coluna, e a linha de comando do programa na última coluna. Caso aparecerem vários processos você pode usar ps ax|grep contagem, neste caso o grep fará uma filtragem da saída do comando ps ax mostrando somente as linhas que tem a palavra "contagem". Para maiores detalhes, veja o comando grep

Feche o processo usando o comando kill PID, lembre-se de substituir PID pelo número encontrado pelo comando ps ax acima.

O comando acima envia um sinal de término de execução para o processo (neste caso o programa contagem). O sinal de término mantém a chance do programa salvar seus dados ou apagar os arquivos temporários que criou e então ser finalizado, isto depende do programa.

Alterne para o console onde estava executando o programa contagem e verifique se ele ainda está em execução. Se ele estiver parado mas o aviso de comando não está disponível, pressione a tecla . Frequentemente acontece isto com o comando kill, você finaliza um programa mas o aviso de comando não é mostrado até que se pressione .

Caso o programa ainda não foi finalizado, repita o comando kill usando a opção -9: kill -9 PID. Este comando envia um sinal de DESTRUIÇÃO do processo, fazendo ele terminar "na marra"!

Uma última dica: todos os programas estáveis (todos que acompanham as boas distribuições GNU/Linux) tem sua opção de saída. Lembre-se que quando finaliza um processo todos os dados do programa em execução podem ser perdidos (principalmente se estiver em um editor de textos), mesmo usando o kill sem o parâmetro -9.

Procure a opção de saída de um programa consultando o help, as páginas de manual, a documentação que acompanha o programa, info pages.

.

ELIMINANDO CARACTERES ESTRANHOS

.

As vezes quando um programa mal comportado é finalizado ou quando você visualiza um arquivo binário através do comando cat, é possível que o aviso de comando (prompt) volte com caracteres estranhos.

Para fazer tudo voltar ao normal, basta digitar reset e teclar ENTER. Não se preocupe, o comando reset não reiniciará seu computador (como o botão reset do seu computador faz), ele apenas fará tudo voltar ao normal.

Note que enquanto você digitar reset aparecerão caracteres estranhos ao invés das letras. Não se preocupe! Basta digitar corretamente e bater ENTER e o aviso de comando voltará ao normal

.

GREP

.

Procura por um texto dentro de um arquivo(s) ou no dispositivo de entrada padrão.

grep [expressão] [arquivo] [opções]

Onde:

expressão
palavra ou frase que será procurada no texto. Se tiver mais de 2 palavras você deve identifica-la com aspas "" caso contrário o grep assumirá que a segunda palavra é o arquivo!

arquivo
Arquivo onde será feita a procura.

opções
-A [número]
Mostra o [número] de linhas após a linha encontrada pelo grep.

-B [número]
Mostra o [número] de linhas antes da linha encontrada pelo grep.

-f [arquivo]
Especifica que o texto que será localizado, esta no arquivo [arquivo].

.

TOUCH

.

Muda a data e hora que um arquivo foi criado. Também pode ser usado para criar arquivos vazios. Caso o touch seja usado com arquivos que não existam, por padrão ele criará estes arquivos.

touch [opções] [arquivos]

Onde:

arquivos
Arquivos que terão sua data/hora modificados.

opções
-t MMDDhhmm[ANO.segundos]
Usa Mês (MM), Dias (DD), Horas (hh), minutos (mm) e opcionalmente o ANO e segundos para modificação do(s) arquivos ao invés da data e hora atual.

-a, --time=atime
Faz o touch mudar somente a data e hora do acesso ao arquivo.

-c, --no-create
Não cria arquivos vazios, caso os arquivos não existam.

-m, --time=mtime
Faz o touch mudar somente a data e hora da modificação.

-r [arquivo]
Usa as horas no [arquivo] como referência ao invés da hora atual.

Exemplos:

touch teste - Cria o arquivo teste caso ele não existir.

touch -t 10011230 teste - Altera da data e hora do arquivo para 01/10 e 12:30.

touch -t 120112301999.30 teste - Altera da data, hora ano, e segundos do arquivo para 01/12/1999 e 12:30:30.

touch -t 12011200 * - Altera a data e hora do arquivo para 01/12 e 12:00.

.

ECHO

.

Mostra mensagens. Este comando é útil na construção de scripts para mostrar mensagens na tela para o usuário acompanhar sua execução.

echo [mensagem]

A opção -n pode ser usada para que não ocorra o salto de linha após a mensagem ser mostrada

.

SHUTDOWN

.

Desliga/reinicia o computador imediatamente ou após determinado tempo (programável) de forma segura. Todos os usuários do sistema são avisados que o computador será desligado . Este comando somente pode ser executado pelo usuário root ou quando é usada a opção -a pelos usuários cadastrados no arquivo /etc/shutdown.allow que estejam logados no console virtual do sistema.

shutdown [opções] [hora] [mensagem]

hora
Momento que o computador será desligado. Você pode usar HH:MM para definir a hora e minuto, MM para definir minutos, +SS para definir após quantos segundos, ou now para imediatamente (equivalente a +0).

O shutdown criará o arquivo /etc/nologin para não permitir que novos usuários façam login no sistema (com exceção do root). Este arquivo é removido caso a execução do shutdown seja cancelada (opção -c) ou após o sistema ser reiniciado.

mensagem
Mensagem que será mostrada a todos os usuários alertando sobre o reinicio/desligamento do sistema.

opções
-h
Inicia o processo para desligamento do computador.

-r
Reinicia o sistema

-c
Cancela a execução do shutdown. Você pode acrescentar uma mensagem avisando aos usuários sobre o fato.

-a
Permite que os nomes de usuários contidos no arquivo /etc/shutdown.allow possam utilizar o shutdown para reinicializar/desligar o sistema. Deve ser colocado um nome de usuário por linha. O limite máximo de usuários neste arquivo é de 32.

Este arquivo é útil quando o shutdown é usado para controlar o pressionamento das teclas CTRL+ALT+DEL no /etc/inittab.

-k
Simula o desligamento/reinicio do sistema, enviando mensagem aos usuários.

-f
Não executa a checagem do sistema de arquivos durante a inicialização do sistema. Este processo é feito gravando-se um arquivo /fastboot que é interpretado pelos scripts responsáveis pela execução do fsck durante a inicialização do sistema.

-F
Força a checagem do sistema de arquivos durante a inicialização. É gravado um arquivo chamado /forcefsck que é interpretado pelos scripts responsáveis pela execução do fsck durante a inicialização do sistema.

-n
Faz com que o shutdown ignore a execução do init fechando todos os processos.

-t [num]
Faz com que o shutdown envie um sinal de término aos processos e aguarde [num] segundos antes de enviar o sinal KILL.

O shutdown envia uma mensagem a todos os usuários do sistema alertando sobre o desligamento durante os 15 minutos restantes e assim permite que finalizem suas tarefas. Após isto, o shutdown muda o nível de execução através do comando init para 0 (desligamento), 1 (modo monousuário), 6 (reinicialização). É recomendado utilizar o símbolo "&" no final da linha de comando para que o shutdown seja executado em segundo plano.

Quando restarem apenas 5 minutos para o reinicio/desligamento do sistema, o programa login será desativado, impedindo a entrada de novos usuários no sistema.

O programa shutdown pode ser chamado pelo init através do pressionamento da combinação das teclas de reinicialização CTRL+ALT+DEL alterando-se o arquivo /etc/inittab. Isto permite que somente os usuários autorizados (ou o root) possam reinicializar o sistema.

Exemplos:

"shutdown -h now" - Desligar o computador imediatamente.

"shutdown -r now" - Reinicia o computador imediatamente.

"shutdown 19:00 A manutenção do servidor será iniciada às 19:00" - Faz o computador entrar em modo monousuário (init 1) às 19:00 enviando a mensagem A manutenção do servidor será iniciada às 19:00 a todos os usuários conectados ao sistema.

"shutdown -r 15:00 O sistema será reiniciado às 15:00 horas" - Faz o computador ser reiniciado (init 6) às 15:00 horas enviando a mensagem O sistema será reiniciado às 15:00 horas a todos os usuários conectados ao sistema.

shutdown -r 20 - Faz o sistema ser reiniciado após 20 minutos.

shutdown -c - Cancela a execução do shutdown.

shutdown -t 30 -r 20 - Reinicia o sistema após 20 minutos, espera 30 segundos após o sinal de término para enviar o sinal KILL a todos os programas abertos.
-h, --no-filename
Não mostra os nomes dos arquivos durante a procura.

-i, --ignore-case
Ignora diferença entre maiúsculas e minúsculas no texto procurado e arquivo.

-n, --line-number
Mostra o nome de cada linha encontrada pelo grep.

-E
Ativa o uso de expressões regulares.

-U, --binary
Trata o arquivo que será procurado como binário.

Se não for especificado o nome de um arquivo ou se for usado um hífen "-", grep procurará a string no dispositivo de entrada padrão. O grep faz sua pesquisa em arquivos texto. Use o comando zgrep para pesquisar diretamente em arquivos compactados com gzip, os comandos e opções são as mesmas.

Exemplos: grep "capitulo" texto.txt, ps ax|grep inetd, grep "capitulo" texto.txt -A 2 -B 2

.

CMP

.

Compara dois arquivos de qualquer tipo (binário ou texto). Os dois arquivos especificados serão comparado e caso exista diferença entre eles, é mostrado o número da linha e byte onde ocorreu a primeira diferença na saída padrão (tela) e o programa retorna o código de saída 1.

cmp [arquivo1] [arquivo2] [opções]

Opções:

arquivo1/arquivo2
Arquivos que serão comparados.

opções
-l
Mostra o número do byte (hexadecimal) e valores diferentes de bytes (octal) para cada diferença.

-s
Não mostra nenhuma diferença, só retorna o código de saída do programa.

Use o comando zcmp para comparar diretamente arquivos binários/texto compactados com gzip.

Exemplo: cmp teste.txt teste1.txt

.

DIFF

.

Compara dois arquivos e mostra as diferenças entre eles. O comando diff é usado somente para a comparação de arquivos em formato texto. As diferenças encontradas podem ser redirecionadas para um arquivo que poderá ser usado pelo comando patch para aplicar as alterações em um arquivo que não contém as diferenças. Isto é útil para grandes textos porque é possível copiar somente as modificações (geradas através do diff, que são muito pequenas) e aplicar no arquivo para atualiza-lo (através do patch) ao invés de copiar a nova versão. Este é um sistema de atualização muito usado na atualização dos código fonte do kernel do GNU/Linux.

diff [diretório1/arquivo1] [diretório2/arquivo2] [opções]

Opções:

diretório1/arquivo1 diretório2/arquivo2
Arquivos /diretórios que serão comparados. Normalmente é usado como primeiro arquivo/diretório o mais antigo e o mais novo como segundo.

opções
-lines [num]
Gera a diferença com [num] linhas de contexto. Por padrão o diff gera um arquivo com 2 linhas que é o mínimo necessário para o correto funcionamento do patch.

-a
Compara os dois arquivos como arquivos texto.

-b
Ignora espaços em branco como diferenças.

-B
Ignora linhas em branco inseridas ou apagadas nos arquivos.

-i
Ignora diferenças entre maiúsculas e minúsculas nos arquivos.

-H
Usa análise heurística para verificar os arquivos.

-N
Em uma comparação de diretórios, se o arquivo apenas existe em um diretório, trata-o como presente mas vazio no outro diretório.

-P
Em uma comparação de diretórios, se o arquivos apenas existe no segundo diretório, trata-o como presente mas vazio no primeiro diretório.

-q
Mostra somente se os dois arquivos possuem diferenças. Não mostra as diferenças entre eles.

-r
Compara diretórios e sub-diretórios existentes.

-S [nome]
Inicia a comparação de diretórios pelo arquivo [nome]. É útil quando cancelamos uma comparação.

-t
Aumenta a tabulação das diferenças encontradas.

-u
Usa o formato de comparação unificado.

Use o comando zdiff para comparar diretamente arquivos compactados pelo utilitário gzip

Use o comando sdiff para visualizar as linhas diferentes entre os dois arquivos em formato texto simples.

Exemplo:

diff texto.txt texto1.txt - Compara o arquivo texto.txt com texto1.txt e exibe suas diferenças na tela.

diff -Bu texto.txt texto1.txt - Compara o arquivo texto.txt com texto1.txt ignorando linhas em branco diferentes entre os dois arquivos e usando o formato unificado.

diff texto.txt texto1.txt >texto.diff - Compara o arquivo texto.txt com texto1.txt e gera um arquivo chamado texto.diff contendo a diferença entre eles. Este arquivo poderá ser usado pelo patch para aplicar as diferenças existente entre os dois no arquivo texto.txt.

diff -r /usr/src/linux-2.2.13 /usr/src/linux-2.2.14 >patch-2.2.14.diff - Compara o diretório e sub-diretórios linux-2.2.13 e linux-2.2.14 e grava as diferenças entre eles no arquivo patch-2.2.14.diff

.

PR

.

Página arquivos texto ou a entrada padrão para impressão. Este comando faz a paginação de um arquivo texto e opcionalmente ajusta o número de colunas e mostra o resultado na saída padrão.

pr [opções] [arquivo]

Onde:

arquivo
Arquivo que será paginado para impressão.

opções
+[NUM]
Inicia a numeração de páginas na página [PAGINA]

-[NUM]
Mostra a saída com [NUM] colunas.

-c
Imprime o caracter CTRL como "^" na saída padrão.

-F, -f
Usa avanço de página ao invés de linhas em branco para separar páginas.

-e[caracter][tamanho]
Usa o caracter [caracter] como tabulação (o padrão é tab) e o espaço da tabulação [tamanho].

-h [nome]
Mostra [nome] ao invés do nome do arquivo no cabeçalho.

-l [num]
Define o número máximo de linhas por página para [num].

-m
Imprime vários arquivos em paralelo, um por coluna.

-r
Oculta mensagens de erro de abertura de arquivos.

-w [num]
Ajusta a largura da página para [num] colunas (o padrão é 72).

Exemplo: pr -l 50 -h "Teste do comando pr" teste.txt

.

CUT

.

Mostra seções de cada linha do arquivo dependendo das opções passadas ao programa.

cut [opções] [arquivo]

Onde:

arquivo
Arquivo que será verificado pelo comando cut.

opções
-b, --bytes [bytes]
Mostra somente a lista de [bytes] do arquivo.

-c, --characters [numero]
Mostra somente o [número] de caracteres no arquivo. É semelhante a opção "-b" mas tabs e espaços são tratados como qualquer caracter.

-f, --field [campos]
Mostra somente a lista de [campos].

-d, --delimite [delimitador]
Para uso com a opção -f, os campos são separados pelo primeiro caracter em [delimitador] ao invés de tabulações.

-s
Para uso com a opção -f, somente mostra linhas que contém o caracter separador de campos.

Devem ser especificadas opções para o funcionamento deste comando. Os bytes, campos e delimitadores podem ser especificados através de intervalos de caracteres (usando a-z), através de vírgulas (a,b,d) ou da combinação entre eles.

cut -b 1,3 /etc/passwd - Pega a primeira e terceira letra (byte) de cada linha do arquivo /etc/passwd

cut -b 1,3-10 /etc/passwd - Pega a primeira letra (byte) e terceira a décima letra de cada linha do arquivo /etc/passwd.

cut -c 1,3-10 /etc/passwd - Pega o primeiro caracter e terceiro ao décimo caracter de cada linha do arquivo /etc/passwd

.

PING

.

Verifica se um computador está disponível na rede. Este comando é muito utilizado por alguns programas de conexão e administradores para verificar se uma determinada máquina está conectada na rede e também para verificar o tempo de resposta de cada máquina da rede. O ping envia pacotes ICMS ECHO_REQUEST para um computador, este quando recebe o pacote envia uma resposta ao endereço de origem avisando que está disponível na rede.

ping [opções][IP/DNS]

onde:

IP/dns
Endereço IP ou nome DNS do endereço.

opções
-c [num]
Envia num pacotes ao computador de destino.

-f
Flood ping. Envia novos pacotes antes de receber a resposta do pacote anterior. Para cada requisição enviada, um "." é mostrado na tela e para cada resposta recebida, um backspace é mostrado. Somente o usuário root pode utilizar esta opção e pode te auxiliar muito na detecção de erros de transmissão de pacotes em interfaces das máquinas em sua rede.

-i [seg]
Aguarda [seg] segundos antes de enviar cada pacote.

-q
Não mostra as requisições enquanto são enviadas, somente mostra as linhas de sumário no inicio e término do programa.

-s [tamanho]
Especifica o tamanho do pacote que será enviado.

-v, --verbose
Saída detalhada, tanto os pacotes enviados como recebidos são listados.

Exemplo: ping 192.168.1.1, ping www.debian.org

.

FINGER

.

Mostra detalhes sobre os usuários de um sistema. Algumas versões do finger possuem bugs e podem significar um risco para a segurança do sistema. É recomendado desativar este serviço na máquina local.

finger [usuário] [usuário@host]

Onde:

usuário
Nome do usuário que deseja obter detalhes do sistema. Se não for digitado o nome de usuário, o sistema mostra detalhes de todos os usuários conectados no momento.

usuário@host
Nome do usuário e endereço do computador que deseja obter detalhes.

-l
Mostra os detalhes de todos os usuários conectados no momento. Entre os detalhes, estão incluídos o nome do interpretador de comandos (shell) do usuário, diretório home, nome do usuário, endereço, etc. Estes dados são lidos de /etc/passwd.

-p
Não exibe o conteúdo dos arquivos .plan e .project

Se for usado sem parâmetros, mostra os dados de todos os usuários conectados atualmente ao seu sistema.

Exemplo: finger, finger root

.

FTP

.

Permite a transferência de arquivos do computador remoto/local e vice versa. O file transfer protocol é o sistema de transmissão de arquivos mais usado na Internet. É requerida a autenticação do usuário para que seja permitida a conexão. Muitos servidores ftp disponibilizam acesso anônimo aos usuários, com acesso restrito.

Uma vez conectado a um servidor ftp, você pode usar a maioria dos comandos do GNU/Linux para operá-lo.

ftp [ip/dns]

Abaixo alguns dos comandos mais usados no FTP:

ls
Lista arquivos do diretório atual.

cd [diretório]
Entra em um diretório.

get [arquivo]
Copia um arquivo do servidor ftp para o computador local. O arquivo é gravado, por padrão, no diretório onde o programa ftp foi executado.

hash [on/off]
Por padrão esta opção está desligada. Quando ligada, faz com que o caracter "#" seja impresso na tela indicando o progresso do download.

mget [arquivos]
Semelhante ao get, mas pode copiar diversos arquivos e permite o uso de curingas.

send [arquivo]
Envia um arquivo para o diretório atual do servidor FTP (você precisa de uma conta com acesso a gravação para fazer isto).

prompt [on/off]
Ativa ou desativa a pergunta para a cópia de arquivo. Se estiver como off assume sim para qualquer pergunta.

Exemplo: ftp ftp.debian.org

.

WHO

.

Mostra quem está atualmente conectado no computador. Este comando lista os nomes de usuários que estão conectados em seu computador, o terminal e data da conexão.

who [opções]

onde:

opções
-H, --heading
Mostra o cabeçalho das colunas.

-b, --boot
Mostra o horário do último boot do sistema.

-d, --dead
Mostra processos mortos no sistema.

-i, -u, --idle
Mostra o tempo que o usuário está parado em Horas:Minutos.

-m, i am
Mostra o nome do computador e usuário associado ao nome. É equivalente a digitar who i am ou who am i.

-q, --count
Mostra o total de usuários conectados aos terminais.

-r, --runlevel
Mostra o nível de execução atual do sistema e desde quando ele está ativo.

-T, -w, --mesg
Mostra se o usuário pode receber mensagens via talk (conversação).

+ O usuário recebe mensagens via talk

- O usuário não recebe mensagens via talk.

? Não foi possível determinar o dispositivo de terminal onde o usuário está conectado

.

NETSTAT

.

Mostra conexões de rede, tabela de roteamento, estatísticas de interfaces, conexões masquerade, e mensagens.

netstat [opções]

Onde:

opções
-i [interface]
Mostra estatísticas da interface [interface].

-M, --masquerade
Se especificado, também lista conexões masquerade.

-n, --numeric
Usa endereços numéricos ao invés de tentar resolver nomes de hosts, usuários e portas.

-c, --continuous
Mostra a listagem a cada segundo até que a CTRL+C seja pressionado.

-l
Lista sockets aguardando por conexão.

-t, --tcp
Lista conexões TCP.

-u, --udp
Lista conexões UDP.

Se não for especificada nenhuma opção, os detalhes das conexões atuais serão mostrados.

Exemplos: netstat -n, netstat -lt, netstat -M

.

TRACEROUTE

.

Mostra o caminho percorrido por um pacote para chegar ao seu destino. Este comando mostra na tela o caminho percorrido entre os Gateways da rede e o tempo gasto de retransmissão. Este comando é útil para encontrar computadores defeituosos na rede caso o pacote não esteja chegando ao seu destino.

traceroute [opções] [host/IP de destino]

Onde:

host/IP destino
É o endereço para onde o pacote será enviado (por exemplo, www.debian.org). Caso o tamanho do pacote não seja especificado, é enviado um pacote de 38 bytes.

opções
-l
Mostra o tempo de vida do pacote (ttl)

-m [num]
Ajusta a quantidade máximas de ttl dos pacotes. O padrão é 30.

-n
Mostra os endereços numericamente ao invés de usar resolução DNS.

-p [porta]
Ajusta a porta que será usada para o teste. A porta padrão é 33434.

-r
Pula as tabelas de roteamento e envia o pacote diretamente ao computador conectado a rede.

-s [end]
Usa o endereço IP/DNS [end] como endereço de origem para computadores com múltiplos endereços IPs ou nomes.

-v
Mostra mais detalhes sobre o resultado do traceroute.

-w [num]
Configura o tempo máximo que aguardará por uma resposta. O padrão é 3 segundos.

Exemplos: traceroute www.debian.org, traceroute www.guiafoca.org

.

REDIRECIONAMENTOS E PIPE

.

O funcionamento dos recursos de direcionamento de entrada e saída do sistema GNU/Linux.

>

Redireciona a saída padrão de um programa/comando/script para algum dispositivo ou arquivo ao invés do dispositivo de saída padrão (tela). Quando é usado com arquivos, este redirecionamento cria ou substitui o conteúdo do arquivo.

Por exemplo, você pode usar o comando ls para listar arquivos e usar ls >listagem para enviar a saída do comando para o arquivo listagem. Use o comando cat para visualizar o conteúdo do arquivo listagem.

O mesmo comando pode ser redirecionado para o segundo console /dev/tty2 usando: ls >/dev/tty2, o resultado do comando ls será mostrado no segundo console (pressione ALT e F2 para mudar para o segundo console e ALT e F1 para retornar ao primeiro). O mesmo resultado pode ser obtido com o comando ls 1>/dev/tty2, sendo que o número 1 indica que será capturada a saída padrão do comando.

Para redirecionar somente a saída de erros do comando ls, use a sintaxe: ls 2>/tmp/erros-do-ls

>>

Redireciona a saída padrão de um programa/comando/script para algum dispositivo ou adiciona as linhas ao final de arquivo ao invés do dispositivo de saída padrão (tela). A diferença entre este redirecionamento duplo e o simples, é se caso for usado com arquivos, adiciona a saída do comando ao final do arquivo existente ao invés de substituir seu conteúdo. .

Por exemplo, você pode acrescentar a saída do comando ls ao arquivo listagem do capítulo anterior usando ls / >>listagem. Use o comando cat para visualizar o conteúdo do arquivo listagem.

<

Direciona a entrada padrão de arquivo/dispositivo para um comando. Este comando faz o contrário do anterior, ele envia dados ao comando.

Você pode usar o comando cat <teste.txt para enviar o conteúdo do arquivo teste.txt ao comando cat que mostrará seu conteúdo (é claro que o mesmo resultado pode ser obtido com cat teste.txt mas este exemplo serviu para mostrar a funcionalidade do <).

<<

Este redirecionamento serve principalmente para marcar o fim de exibição de um bloco. Este é especialmente usado em conjunto com o comando cat, mas também tem outras aplicações. Por exemplo:

cat <"

A principal diferença entre o "|" e o ">", é que o Pipe envolve processamento entre comandos, ou seja, a saída de um comando é enviado a entrada do próximo e o ">" redireciona a saída de um comando para um arquivo/dispositivo.

Você pode notar pelo exemplo acima (ls -la | more) que ambos ls e more são comandos porque estão separados por um "|". Se um deles não existir ou estiver digitado incorretamente, será mostrada uma mensagem de erro.

Um resultado diferente seria obtido usando um ">" no lugar do "|"; A saída do comando ls -la > more seria gravada em um arquivo chamado more.

tee

Envia ao mesmo tempo o resultado do programa para a saída padrão (tela) e para um arquivo. Este comando deve ser usado com o pipe "|".

comando |tee [arquivo]

Exemplo: ls -la | tee listagem.txt, a saída do comando será mostrada normalmente na tela e ao mesmo tempo gravada no arquivo listagem.txt

.

GUIA DE COMANDOS LINUX

.

Sobre os comandos do Linux

.

comando [opções] [argumentos]

.

Descrição:

Os comandos do Linux são utilizados na linha de comandos (prompt) do sistema: as opções definem parâmetros do comando e usualmente começam com o caractere "-" seguido de uma ou mais letras; e os argumentos definem dados a serem usados no processamento do comando.

.

O responsável por interpretar e executar um comando é o shell do usuário.

.

Um comando pode ser implementado pelo próprio shell (builtin command) ou pode ser uma aplicação presente em um dos diretórios do sistema como, por exemplo, /bin, /sbin, /usr/bin, etc.

.

Atualmente, acho que existem mais de 3 mil comandos a disposição do usuário de GNU/Linux.

.

Exemplos:

Por exemplo, para listar os arquivos e os diretórios filhos do diretório atual, basta digitar:

.

ls

.

Já o comando:

.

ls -al :: Exibe informações (tamanho, dono, grupo, etc) sobre os arquivos e os diretórios (opção l) e inclui na listagem os arquivos escondidos (opção a).
Importante: os arquivos escondidos no Linux possuem nome que começam com um ponto (".")

.

As opções podem possuir um ou mais argumentos.

.

Além disso, é possível existir argumentos que não pertençam a uma opção. Observe, por exemplo, o comando abaixo.

awk -F: -farq.txt /etc/passwd

Neste caso, temos o comando awk com duas opções (F e f) e três argumentos (:, arq.txt e /etc/passwd), sendo que o último argumento não pertence a nenhuma opção (é usada pelo comando).

Para obter informações sobre algum comando do Linux, digite man seguido do nome do comando. Por exemplo, para obter uma explicação sobre o comando ls digite

man ls

É também possível obter a lista dos parâmetros disponíveis usando o parâmetro/comando help.

Entrada e saída padrão dos comandos do Linux:

.

Temos no Linux a entrada padrão a saída padrão e a saída de erro.

.

stdin (standard input) - entrada padrão para os comandos do Linux. Normalmente, a entrada padrão é o teclado, mas é possível usar o redirecionador de saída para alterar a saída padrão.

.

Por exemplo:

.

ls > teste

.

ou

.

ls 1> teste

.

Cria o arquivo teste com o conteúdo do diretório atual.

stderr (standard error) - saída padrão para os erros encontrados durante a execução de um comando do Linux. Normalmente, a saída padrão é a tela da sessão onde o comando foi digitado, mas é possível usar o redirecionador de saída 2> para alterar a saída padrão.

.

Suponha que o diretório /meu_dir não exista. Portanto, o comando:

.

ls /meu_dir 2> teste

.

Cria o arquivo teste com a mensagem de erro relacionada a execução do comando acima.

.

É possível digitar mais de um comando de uma vez. Se ";" for usado para separar os comandos, então o sistema executa todos os comandos, independentemente do resultado.

.

man ls > teste; ls -l teste

.

Se "&&" for usado entre os comandos, um comando só é executado quando os comandos anteriores não apresentam erro.

.

man ls > teste && ls -l teste

.

Observações:

.

Neste Guia de Referências foi adotada a seguinte norma na apresentação dos comandos:

.

Opções/argumentos não obrigatórios (os usuários podem ou não digitá-los) estão entre colchetes.

argumentos obrigatórios (devem ser fornecidos pelos usuários) não são delimitados por nenhum símbolo.

.

Por exemplo, o comando:

.

cat [-n] arquivo

.

Possui uma opção (-n) e um argumento (arquivo), sendo que apenas o segundo deve ser obrigatoriamente informado pelo usuário.

.

Por exemplo, suponha que você queira exibir o conteúdo do arquivo teste.txt, então você pode digitar:

cat -n teste.txt

.

ou

.

cat teste.txt

.

Onde o primeiro comando numera as linhas do arquivo e o segundo comando apenas exibe o arquivo.

.

Linux comandos de manipulação de diretório

.

mkdir
cria um diretório

exemplo: mkdir docs

.

rmdir
exclui um diretorio (se estiver vazio)

.

rm -rf
exclui um diretório e todo o seu conteúdo

.

cd
entra num diretório (exemplo: cd docs) ou retorna para HOME

.

cd ~
vai direto para o diretório home do usuário logado.

.

cd -
volta ao último diretório acessado

.

pwd
exibe o local do diretório atual

.

ls
listar o conteúdo do diretório

.

ls -alh
mostra o conteúdo detalhado do diretório

.

ls -ltr
mostra os arquivos no formado longo(l) em ordem inversa(r) de data (t)

.

du -msh
mostra o tamanho do diretório em Megabytes

.

whereis
mostra onde se encontra determinado arquivo (binários)

exemplo: whereis samba

.

which
mostra qual arquivo binário está sendo chamado pelo shell quando chamado via linha de comando

.

Para obter uma listagem de diretórios em sistemas GNU/Linux, ordenados do maior para o menor, use o comando:

du -Sk | sort -nr | more

.

ou

.

du -Sh | sort -nr | more

.

SABER O TAMANHO DE CADA DIRETÓRIO OU SUBDIRETÓRIO:

.

du -ach --max-depth=1 /var/

du -ach --max-depth=1 /var/| sort -nr

du -ach --max-depth=1 /var/| sort -nr | more

.

CRIAR DIRETÓRIOS DENTRO DE DIRETORIOS:

mkdir -p /teste/teste1/teste2/teste3

.

CRIAR UMA ÁRVORE COMPLETA DE DIRETÓRIOS:

mkdir -p docs/{img/{fotos,icons,wallpapers,svg},textos/{artigos,man},tmp}

.

A REGRA AQUI É A SEGUINTE:

.

para cada pasta que conterá subpastas use "nome/{}"
dentro das chaves coloque os nomes separados por vírgula não esquecendo de usar o parâmetro '-p' no começo do comando.

.

Linux comandos para manipulação de arquivos

.

cat
mostra o conteúdo de um arquivo binário ou texto

tac
semelhante ao cat mas inverte a ordem

tail
mostra as últimas 10 linhas de um arquivo (util para ler logs)

head
mostra as primeiras 10 linhas de um arquivo

less
mostra o conteúdo de um arquivo de texto com controle

vi
editor de ficheiros de texto

vim
versão melhorada do editor supracitado

rm
remoção de arquivos (também remove diretórios)

cp
copia diretórios

'cp -r'
copia recursivamente

mv
move ou renomeia arquivos e diretórios

chmod
altera as permissões de arquivos ou directórios

chown
altera o dono de arquivos ou diretórios

cmd>txt
cria um novo arquivo(txt) com o resultado do comando(cmd)

cmd>>txt
adiciona o resultado do comando(cmd) ao fim do arquivo(txt)

touch
touch um_titulo.txt
cria um arquivo um_titulo.txt vazio; também altera data e hora de modificação para agora

> arquivo.txt
mais rápido que o touch para criação de arquivos

split
divide um arquivo

recode recodifica um arquivo ex: recode iso-8859-15..utf8 file_to_change.txt

[mc] poderoso editor de texto

.

LINUX COMANDOS PARA ADMINISTRAR

.

man
mostra informações sobre um comando

adduser
adiciona usuários

addgroup
adiciona grupos

apropos
realiza pesquisa por palavra ou string

dmesg
exibe as mensagens da inicialização(log)

du
exibe estado de ocupação dos discos/partições

find comando de busca ex: find ~/ -cmin -3

userdel
remove usuários

chfn
altera informação relativa a um utilizador

who
informa quem está logado no sistema

whoami
informa com qual usuário você está logado

passwd
modifica senha (password) de usuários

umask
define padrões de criação de arquivos e diretórios

ps
mostra os processos correntes

ps -aux
mostra todos os processos correntes no sistema

kill
manda um sinal para um processo. Os sinais SIGTERM e SIGKILL encerram o processo

killall
manda um sinal para todos os processos

su
troca para o super-usuário root (é exigida a senha)

su user
troca para o usuário especificado em 'user' (é exigida a senha)

chown
altera a propriedade de arquivos e pastas (dono)

env
mostra variaveis do sistema

.

COMANDOS PARA ADMINISTRAÇÃO DE REDE

ifconfig
mostra as interfaces de redes ativas e as informações relacionadas a cada uma delas

.

route
mostra as informações referentes as rotas

.

mtr
mostra rota até determinado IP

.

nmap
lista as portas de sistemas remotos/locais atras de portas abertas e pode checar sistema operacional em execução no host remoto

.

netstat
exibe as portas e protocolos abertos no sistema

.

iptraf
analisador de trafego da rede com interface gráfica baseada em diálogos

.

tcpdump
sniffer muito popular. Sniffer é uma ferramenta que "ouve" os pacotes que estão passando pela rede

.

traceroute
traça uma rota do host local até o destino mostrando os roteadores intermediários

.

nslookup
consultas a serviços DNS

.

dig
consultas a serviços DNS

.

LINUX COMMAND LINE QUICK REFERENCE - LINUX COMANDOS GUIA DE REFERÊNCIA RÁPIDO

.

1

Linux Comandos de Informação do sistema

cat /etc/*-release # Mostra qual sistema Linux está usando - Show which version of GNU/Linux installed

uptime # Show how long the system has been running + load

hostname # Show system host name

hostname -I # Display the IP addresses of the host

last reboot # Show system reboot history

date # Show the current date and time - Mostra o dia e a hora atual

cal # Show this month's calendar - Mostra o mês do calendário que estamos

w # Display who is online - Mostra quem está online

whoami # Who you are logged in as - Mostra o nome que você está logado

.

2

Linux Comandos Hardware Information - Informação do Hardware

dmesg # Display messages in kernel ring buffer

cat /proc/cpuinfo # Display CPU information

cat /proc/meminfo # Display memory information

free -h # Display free and used memory ( -h for human readable, -m for MB, -g for GB.)

lspci -tv # Display PCI devices

lsusb -tv # Display USB devices

dmidecode # Display DMI/SMBIOS (hardware info) from the BIOS

hdparm -i /dev/sda # Show info about disk sda

hdparm -tT /dev/sda # Perform a read speed test on disk sda

badblocks -s /dev/sda # Test for unreadable blocks on disk sda

.

3

Linux Comandos Performance Monitoring and Statistics - Monitoramento estatistico de performance

top # Display and manage the top processes

htop # Interactive process viewer (top alternative)

mpstat 1 # Display processor related statistics

vmstat 1 # Display virtual memory statistics

iostat 1 # Display I/O statistics

tail 100 /var/log/messages # Display the last 100 syslog messages (Use /var/log/syslog for Debian based systems.)

tcpdump -i eth0 # Capture and display all packets on interface eth0

tcpdump -i eth0 'port 80' # Monitor all traffic on port 80 ( HTTP )

lsof # List all open files on the systemlsof

-u user # List files opened by user

free -h # Display free and used memory ( -h for human readable, -m for MB, -g for GB.)

watch df -h # Execute "df -h", showing periodic updates

.

4

Linux Comandos User Information and Management - Informações do usuário e gerenciamento

id # Display the user and group ids of your current user.

last # Display the last users who have logged onto the system.

who # Show who is logged into the system.

w # Show who is logged in and what they are doing.

groupadd test # Create a group named "test".

useradd -c "John Smith" -m john # Create an account named john, with a comment of "John Smith" and create the user's home directory.

userdel john # Delete the john account.

usermod -aG sales john # Add the john account to the sales group

.

5

Linux Comandos File and Directory Commands - Linux Comandos de arquivos e diretórios

ls -al # List all files in a long listing (detailed) format

pwd # Display the present working directory

mkdir directory # Create a directory

rm file # Remove (delete) file

rm -r directory # Remove the directory and its contents recursively

rm -f file # Force removal of file without prompting for confirmation

rm -rf directory # Forcefully remove directory recursively

cp file1 file2 # Copy file1 to file2

cp -r source_directory destination # Copy source_directory recursively to destination . If destination exists, copy source_directory into destination , otherwise create destination with the contents of source_directory .

mv file1 file2 # Rename or move file1 to file2 . If file2 is an existing directory, move file1 into directory file2

ln -s /path/to/file linkname # Create symbolic link to linkname

touch file # Create an empty file or update the access and modification times of file.

cat file # View the contents of file

less file # Browse through a text file

head file # Display the first 10 lines of file

tail file # Display the last 10 lines of file

tail -f file # Display the last 10 lines of file and "follow" the file as it grows.

.

6

Linux Comandos Process Management - Gerenciamento de processos

ps # Display your currently running processes

ps -ef # Display all the currently running processes on the system.

ps -ef | grep processname # Display process information for processname

top # Display and manage the top processes

htop # Interactive process viewer (top alternative)

kill pid # Kill process with process

HanSmi, [17.02.18 21:03]
ID of p id

killall processname # Kill all processes named

process_name_program & # Start program in the background

bg # Display stopped or background jobs

fg # Brings the most recent background job to foreground

fg n # Brings job n to the foreground

.

7

Linux Comandos File Permissions - Permissões de arquivo

U = User
G = Group
W = World
r = Read
w = write
x = execute
- = no access

.

8

Linux Comandos Networking - Gerenciamento de rede

ifconfig -a # Display all network interfaces and ip address

ifconfig eth0 # Display eth0 address and details

ethtool eth0 # Query or control network driver and hardware settings

ping host # Send ICMP echo request to hostwhois domain# Display whois information for domain

dig domain # Display DNS information for domain

dig -x IP_ADDRESS # Reverse lookup of IP_ADDRESS

host domain # Display DNS ip address for domain

hostname -i # Display the network address of the host name.

hostname -I # Display all local ip addresses

wget http://domain.com/file # Download http://domain.com/file

netstat -nutlp # Display listening tcp and udp ports and corresponding programs

.

9

Linux Comandos Archives (TAR Files) - Arquivos TAR

tar cf archive.tar directory # Create tar named archive.tar containing directory .

tar xf archive.tar # Extract the contents from archive.tar .

tar czf archive.tar.gz directory # Create a gzip compressed tar file name archive.tar.gz .

tar xzf archive.tar.gz # Extract a gzip compressed tar file.

tar cjf archive.tar.bz2 directory # Create a tar file with bzip2 compression

tar xjf archive.tar.bz2 # Extract a bzip2 compressed tar file.

.

10

Linux Comandos Instalação de pacotes

tar zxvf sourcecode.tar.gz
cd sourcecode
./configure
make
make install

.

11

Linux Comandos de busca

grep pattern file # Search for pattern in file

grep -r pattern directory # Search recursively for pattern in directory

locate name # Find files and directories by name

find /home/john -name 'prefix*' # Find files in /home/john that start with "prefix".

find /home -size +100M # Find files larger than 100MB in /home

.

12

Linux Comandos SSH Logins

ssh host # Connect to host as your local username.

ssh user@host # Connect to host as user

ssh -p port user@host # Connect to host using port

.

13

Linux Comandos Transferencia de arquivos - File Transfers

scp file.txt server:/tmp # Secure copy file.txt to the /tmp folder on server

scp server:/var/www/*.html /tmp # Copy *.html files from server to the local /tmp folder.

scp -r server:/var/www /tmp # Copy all files and directories recursively from server to the current system's /tmp folder.

rsync -a /home /backups/ # Synchronize /home to /backups/home

rsync -avz /home
server:/backups/ # Synchronize files/directories between the local and remote system with compression enabled

.

14

Linux Comandos de uso de disco - Disk Usage

df -h # Show free and used space on mounted filesystems

df -i # Show free and used inodes on mounted filesystems

fdisk -l # Display disks partitions sizes and types

du -ah # Display disk usage for all files and directories in human readable format

du -sh # Display total disk usage off the current directory

.

15

Linux Comandos navegação de diretórios

Directory Navigation

cd .. # To go up one level of the directory tree. (Change into the parent directory.)

cd # Go to the $HOME directory

cd /etc # Change to the /etc directory

.

# Linux Comandos File/Directory Basics - Básicos para Diretórios e arquivos

ls
List files

cp
Copy files

mv
Rename files

rm
Delete files

ln
Link files

cd
Change directory

pwd
Print current directory name

mkdir
Create directory

rmdir
Delete directory

.

Linux Comandos File Viewing - Visualização de arquivos

cat
View files

less
Page through files

head
View file beginning

tail
View file ending

nl
Number lines

od
View binary data

xxd
View binary data

gv
View Postscript/PDF files

xdvi
View TeX DVI files

.

Linux Comandos File Creation and Editing - Editar e criar arquivos

emacs
Text editor

vim
Text editor

umask
Set default file protections

soffice
Edit Word/Excel/ PowerPoint docs

abiword
Edit Word documents

gnumeric
Edit Excel documents

.

Linux Comandos File Properties - Propriedades de arquivos

stat
Display file attributes

wc
Count bytes/words/lines

du
Measure disk usage

file
Identify file types

touch
Change file timestamps

chown
Change file owner

chgrp
Change file group

chmod
Change file protections

chattr
Change advanced file attributes

lsattr
List advanced file attributes

.

Linux Comandos File Location - Localização de arquivos

find
Locate files

slocate
Locate files via index

which
Locate commands

whereis
Locate standard files

.

Linux Comandos File Text Manipulation - Manupulação de arquivos de texto

grep
Search text for matching lines

cut
Extract columns

paste
Append columns

tr
Translate characters

sort
Sort lines

uniq
Locate identical lines

tee
Copy stdin to a file and o stdout simultaneously

.

Linux Comandos File Compression - Compressão de arquivos

gzip
Compress files (GNU Zip)

compress
Compress files (Unix)

bzip2
Compress files (BZip2)

zip
Compress files (Windows Zip)

.

Linux Comandos File Comparison - Comparação de arquivos

diff
Compare files line by line

comm
Compare sorted files

cmp
Compare files byte
by byte

md5sum
Compute checksums

.

Linux Comandos Disks and Filesystems - Sistema de arquivos e discos

df
Show free disk space

mount
Make a disk accessible

fsck
Check a disk for errors

sync
Flush disk caches

.

Linux Comandos Backups and Remote Storage - Gerenciamento remoto e Backups

mt
Control a tape drive

dump
Back up a disk

restore
Restore a dump

tar
Read/write tape archives

cdrecord
Burn a CD

rsync
Mirror a set of files

.

Linux Comandos File/Directory Basics - Básicos para Diretórios e arquivos

ls
List files

cp
Copy files

mv
Rename files

rm
Delete files

ln
Link files

cd
Change directory

pwd
Print current directory
name

mkdir
Create directory

rmdir
Delete directory

.

SHELL SCRIPT LINUX BASH

.

COMANDOS MAIS USADOS DO BASH EM SHELL SCRIPT

.

Qual é o seu usuário?

.

Se você não tem certeza qual é o seu usuário, use o comando "whoami" sem aspas, para saber.

.

Como o prompt de usuário normal pode ser diferente para cada um, podemos em algum momento usar "prompt$" para indicar o prompt da linha de comando.

.

ESCOLHER O DIRETÓRIO ONDE COLOCAR O SCRIPT

Para que o script possa ser executado de qualquer parte do sistema, mova-o para um diretório que esteja no seu PATH. Para ver quais são estes diretórios, abra agora o terminal pelo menu do sistema e digite o comando:

echo $PATH

.

Se não tiver permissão de mover para um diretório do PATH, deixe-o dentro de seu diretório pessoal ($HOME). Digite no terminal: $HOME

.

CRIAR O ARQUIVO E COLOCAR NELE OS COMANDOS

Abra pelo menu do sistema o editor de texto gedit, pluma, leafpad, mousepad ou outro editor de textos de sua preferência para colocar todos os comandos dentro do arquivo.

.

COLOQUE A CHAMADA DO SHELL NA PRIMEIRA LINHA

A primeira linha do script deve ser:

#!/bin/bash

Para que ao ser executado, o sistema saiba que é o bash quem irá interpretar estes comandos.

.

TORNE O SCRIPT UM ARQUIVO EXECUTÁVEL

Use o seguinte comando para que seu script seja reconhecido pelo sistema como um comando executável:

chmod +x nome-do-teu-shellscript.sh

.

Para permitir que todos os usuários possam executar o script:

chmod a+x nome-do-teu-shellscript.sh

.

EXECUTE O SCRIPT

./nome-do-teu-shellscript.sh (Aqui "./" representa o diretório atual)

/home/seu-usuário/bin/nome-do-teu-shellscript.sh (Aqui informa onde está o script para que o bash execute em outra pasta)

.

BASH EXECUTANDO COMANDOS

.

Shell script é uma linguagem de script usada em vários sistemas operacionais, com diferentes dialetos, dependendo do interpretador de comandos utilizado.

Um exemplo de interpretador de comandos é o bash, usado na grande maioria das distribuições GNU/Linux.

A maior parte dos usuários classificam shell script como uma linguagem de fácil aprendizagem. O primeiro passo é, saber o que se deseja fazer, então ver qual o código que executa este comando em shell e aí criar, basta escrever o código em algum editor de texto e salvar. Veja só por exemplo, que de tempos em tempos você quer saber informações do sistema, instalar programas, remover programas, converter/alterar arquivos, fazer backups, adicionar informações, remover informações, etc.

.

AGORA ABRE O TERMINAL E DIGITA COMANDOS, POR EXEMPLO, DIGITE ESTES COMANDOS ABAIXO UM DE CADA VEZ:

echo

ls

echo ''

echo ""

echo "Olá!"

printf 'Bem vindo ao bash!' (Aperte a tecla enter e digite: ls)

echo '#!/bin/bash'

echo "#!/bin/bash"

echo ; echo "Olá!" ; echo

echo -e 'Bom\nDia\nMundo!'

echo -e "Bom\nDia\nMundo!"

echo "Hello world!"

echo "Hello "world"!"

echo "Hello \"world\"!"

printf "Hello world" (Aperte a tecla enter e digite: cd ~)

pwd

ls -t

sleep 7

echo ; echo 'Olá!' ; sleep 3 ; ls -t

free -h -t

free -th

sleep 4

date

cal

du -h

uptime

df -h

clear

free -tmlh

df -a -h

df -k -l

df -T -m

echo ; whoami ; echo

ls ; echo ; pwd ; echo

echo ; ls -at ; echo

du *

ls -lah

du -hcs

du -ach

du -Sh

du -Sk

clear

echo ; echo 'df: Relata o espaço de disco usado pelo sistema (Usado e Livre)' ; echo

ls -hat

echo ; echo "du: Relata o espaço utilizado no disco de tal arquivo ou diretório" ; echo

whereis bash

VALOR="Linux"

echo $VALOR

echo $VALOR $VALOR

VALOR='ls -t'

$VALOR

echo $VALOR

clear

VALOR='free -h -t'

$VALOR

echo $VALOR

echo VALOR

read VALOR (aperte a tecla enter, digite: "ls" sem aspas e aperte enter.)

$VALOR

read VALOR (aperte a tecla enter, digite: "uptime" sem aspas e aperte enter.)

$VALOR

echo ; $VALOR ; echo ; $VALOR ; echo

echo ; $VALOR ; sleep 4 ; echo ; $VALOR ; echo

clear

unset VALOR

echo ; $VALOR

$VALOR

echo -e '\nOlá!\nVamos\nSaber\nOs\nComandos\ndo\nShellscript Linux!'

clear ; echo -e '\n \nOlá!\n \nVamos\n \nSaber\n \nOs\n \nComandos\n \ndo\n \nShellscript Linux!\n'

HOJE=$(lsblk)

echo "Informação sobre dispositivos de bloco: $HOJE"

clear

echo 'Informação sobre dispositivos de bloco: $HOJE'

unset HOJE

echo $HOJE

echo $((2*3))

echo $((2*4-2/2+3))

VALOR=44

echo $((VALOR*1))

echo $((VALOR*2))

echo $((VALOR*3))

VALOR=$((VALOR+1))

echo $VALOR

VALOR=$((VALOR+11))

echo $VALOR

VALOR=$((VALOR+1))

echo $VALOR

VALOR=$((VALOR+11))

echo $VALOR

unset VALOR

echo $VALOR

VALOR=$(uname -a)

echo $VALOR

HOJE=$(arch)

echo $HOJE

clear

echo "Informação sobre o kernel: $VALOR" ; echo ; echo "Informação sobre a arquitetura do sistema: $HOJE"

echo 'Informação sobre o kernel: $VALOR' ; echo ; echo 'Informação sobre a arquitetura do sistema: $HOJE'

echo ; echo 'Informação sobre o kernel: $VALOR' ; echo ; echo 'Informação sobre a arquitetura do sistema: $HOJE' ; echo

unset VALOR

unset HOJE

echo "Informação sobre o kernel: $VALOR" ; echo ; echo "Informação sobre a arquitetura do sistema: $HOJE"

echo 'Informação sobre o kernel: $VALOR' ; echo ; echo 'Informação sobre a arquitetura do sistema: $HOJE'

clear

printf "%-5s %-10s %-4s\n" No Nome Pontos

printf "%-5s %-10s %-4.2f\n" 1 Marta 8

printf "%-5s %-10s %-4.2f\n" 2 Joel 9

printf "%-5s %-10s %-4.2f\n" 3 Carlos 7

echo -e "\e[1;31m Este é o texto em vermelho \e[0m"

unset NUM

clear

exit

.

Muito bom que você digitou um comando de cada vez!!!

O comandos mais longos pode copiar e colar no terminal se quiser, mas no início seria melhor digitar...

Saiba que a partir deste momento você já está entendendo coisas extremamente úteis para escrever shellscript usando o Bash!

Uma coisa interessante sobre os comandos acima, é que para estudar eles, você não precisa estar conectado a internet.

Os comandos acima oferecem informações interessantes e úteis. Podemos colocar todos eles em um só script e executar. Dependendo do caso, é mais fácil que digitar um a um de cada vez toda vez que precisar.

.

SE PUDER, ANTES DE CONTINUAR EXECUTE OS COMANDOS ACIMA QUE TE CHAMARAM MAIS A ATENÇÃO DE NOVO POIS, EXECUTAR ELES É MUITO DIDÁTICO. NADA MELHOR QUE APRENDER PRATICANDO.

.

ASPAS SIMPLES ' E ASPAS DUPLAS ":

Aspas duplas permitem interpretar caracteres especiais.

Aspas simples desabilitam esta interpretação.

.

CARACTERES DE ESCAPE:

echo "Hello \"world\"!"

.

TODO SCRIPT ESCRITO PARA RODAR NO BASH COMEÇA COM:

#!/bin/bash

Após "#!/bin/bash" de um espaço entre linhas e então pode começar a digitar comandos.

.

Exemplo:

#!/bin/bash

clear

echo ; date ; echo ; sleep 4

echo ; cal ; echo ; sleep 4

echo ; uptime ; echo ; sleep 4

echo ; df -h ; echo ; sleep 4

echo ; free -html ; echo ; sleep 4

echo ; whoami ; echo ; sleep 4

echo ; pwd ; echo ; sleep 4

echo ; ls -at ; echo ; sleep 4

echo ; whereis bash ; echo ; sleep 4

echo ; echo 'Este é o fim do script 01-script.sh' ; echo ; sleep 4

exit

# Fim do script

.

ESTE SCRIPT ÚTIL E INOFENSIVO ACIMA SERÁ SALVO NA PASTA HOME, A PASTA DA CASINHA, USANDO UM EDITOR DE TEXTO COM O NOME DE:

01-script.sh

.

Posso melhorar/tornar mais amigável este script acima explicando sobre cada comando:

#!/bin/bash

clear

echo ; echo 'Hoje é data:' ; echo ; sleep 2

echo ; date ; echo ; sleep 4

echo ; echo 'Hoje pelo calendário é:' ; echo ; sleep 2

echo ; cal ; echo ; sleep 4

echo ; echo 'Esta máquina está funcionando a:' ; echo ; sleep 2

echo ; uptime ; echo ; sleep 4

echo ; echo 'Sobre o tamanho desta pasta:' ; echo ; sleep 2

echo ; df -h ; echo ; sleep 6

echo ; echo 'Sobre a memória RAM:' ; echo ; sleep 2

echo ; free -html ; echo ; sleep 6

echo ; echo 'Você está logado como:' ; echo ; sleep 2

echo ; whoami ; echo ; sleep 4

echo ; echo 'Você está em:' ; echo ; sleep 2

echo ; pwd ; echo ; sleep 4

echo ; echo 'Neste diretório/pasta tem:' ; echo ; sleep 2

echo ; ls -at ; echo ; sleep 6

echo ; echo 'O Bash está em:' ; echo ; sleep 2

echo ; whereis bash ; echo ; sleep 4

echo ; echo 'Este é o fim do script 01-script.sh' ; echo ; sleep 4

exit

# Fim do script

.

No Linux o script deve ter permissão de execução, isto pode ser feito abrindo o terminal pelo menu do sistema e executando o comando:

chmod +x 01-script.sh

.

Depois de salvo você tem que executar o arquivo, dessa forma:

./01-script.sh

.

Viu alguma utilidade neste pequeno script?

Então siga adiante.

.

IMPORTANTE:

Para estudar shell script tem que ser como usuário normal. Se você está acessando o sistema como usuário administrador (root), saia e entre como um usuário normal. É muito perigoso estudar shell usando o superusuário, você pode danificar o sistema com um comando errado.

Ok, continuemos.

.

Para exibir um manual do bash ou mesmo do comando 'chmod', digite na linha de comando:

man bash

man chmod

.

É possível executar o arquivo mesmo sem modificar a permissão de execução, por exemplo, se for um arquivo escrito para ser executado pelo bash, usar:

sh ./"Nome do arquivo, sem aspas"

.

SHELL

É importante saber o que é um Shell.

Na linha de comandos de um shell, podemos utilizar diversos comandos um após o outro, ou mesmo combiná-los numa mesma linha.

Se colocarmos diversas linhas de comandos em um arquivo texto simples, teremos em mãos um Shell Script, ou um script em shell, já que Script é uma descrição geral de qualquer programa escrito em linguagem interpretada, ou seja, não compilada.

Outros exemplos de linguagens para scripts são o PHP, Perl, Python, JavaScript e muitos outros. Podemos então ter um script em php, um script perl e assim em diante.

Uma vez criado, um ShellScript pode ser reutilizado quantas vezes for necessário.

Seu uso, portanto, é indicado na automação de tarefas que serão realizadas mais de uma vez.

Todo sistema Unix e similares são repletos de scripts em shell para a realização das mais diversas atividades administrativas e de manutenção do sistema.

Os arquivos de lote (batch - arquivos *.bat) do Windows são também exemplos de ShellScripts, já que são escritos em linguagem interpretada e executados por um Shell do Windows, em geral o command.com ou hoje em dia o cmd.exe.

Os Shells do Unix, porém, são inumeras vezes mais poderosos que o interpretador de comandos do Windows, podendo executar tarefas muito mais complexas e elaboradas.

OS SCRIPTS SHELL PODEM SER AGENDADOS PARA EXECUÇÃO ATRAVÉS DA TABELA CRONTAB, ENTRE OUTRAS COISAS.

É uma ferramenta indispensável aos administradores de sistemas Unix.

O Shell mais comum e provavelmente o que possui mais scripts escritos para ele é também um dos mais antigos e simples, o sh.

Este shell está presente em todo o sistema tipo Unix, incluído o Linux, FreeBSD, AIX, HP-UX, OpenBSD, Solaris, NetBSD, Irix, etc. Por ser o shell nativo mais comum é natural que se prefira escrever scripts para ele, tornando o script mais facilmente portável para outro sistema.

Os Shells não estão diretamente associados a um ou outro tipo de Unix, embora várias empresas comerciais tenham suas próprias versões de Shell. No software livre o Shell utilizado em um sistema em geral é exatamente o mesmo utilizado em outro. Por exemplo, o bash encontrado no Linux é o mesmo shell bash encontrado no FreeBSD e pode também facilmente ser instalado no Solaris, Windows através do Cygwin [1] ou outros sistemas Unix comerciais para passar a ser utilizado como interface direta de comandos ou como interpretador de scripts. O mesmo acontece com o tcsh e vários outros shells desenvolvidos no modelo de software livre.

.

INTERAGIR COM O USUÁRIO

.

Para o script ficar mais completo, vamos colocar uma interação mínima com o usuário, pedindo uma confirmação antes de executar os comandos.

.

#!/bin/bash

clear

echo "Vou buscar os dados do sistema. Posso continuar? [S/n] "

read RESPOSTA

test "$RESPOSTA" = "n" && exit

echo ; echo "Data e Horário:" ; echo

date

echo

echo "Uso do disco:" ; echo

df -ht

echo

echo "Usuários conectados:" ; echo

w

echo ; echo "Seu nome de login é:"

whoami

echo

exit

# Fim do script

.

O comando "read" leu o que o usuário digitou e guardou na variável RESPOSTA. Logo em seguida, o comando "test" verificou se o conteúdo dessa variável era "n". Se afirmativo, o comando "exit" foi chamado e o script foi finalizado. Nessa linha há vários detalhes importantes:

O conteúdo da variável é acessado colocando-se um cifrão "$" na frente

O comando test é útil para fazer vários tipos de verificações em textos e arquivos

O operador lógico "&&", só executa o segundo comando caso o primeiro tenha sido OK. O operador inverso é o "||"

.

MELHORAR O CÓDIGO DO SCRIPT

.

Com o tempo, o script vai crescer, mais comandos vão ser adicionados e quanto maior, mais difícil encontrar o ponto certo onde fazer a alteração ou corrigir algum erro. Para poupar horas de estresse, e facilitar as manutenções futuras, é preciso deixar o código visualmente mais agradável e espaçado, e colocar comentários esclarecedores.

.

#!/bin/bash

# nome-do-script - script que mostra informações sobre o sistema

# Autor: Fulano da Silva

# Pede uma confirmação do usuário antes de executar

clear

echo "Vou buscar os dados do sistema. Posso continuar? [S/n]"

read RESPOSTA

# Se ele digitou 'n', vamos interromper o script

test "$RESPOSTA" = "n" && exit

# O date mostra a data e a hora correntes

sleep 3 ; echo "Data e Horário:" ; echo

date

sleep 3

echo

# O df mostra as partições e quanto cada uma ocupa no disco
echo "Uso do disco:"

sleep 3

echo

df

echo

sleep 6

# O w mostra os usuários que estão conectados nesta máquina

echo "Usuários conectados:"

sleep 3

echo

w

sleep 3

echo

# Fim do script

.

Basta iniciar a linha com um "#" e escrever o texto do comentário em seguida. Estas linhas são ignoradas pelo shell durante a execução. O cabeçalho com informações sobre o script e seu autor também é importante para ter-se uma visão geral do que o script faz, sem precisar decifrar seu código. Também é possível colocar comentários no meio da linha # como este

.

CARACTERÍSTICAS

.

OS SCRIPTS SHELL PODEM CONTER ESTRUTURAS DE PROGRAMAÇÃO TAIS COMO:

.

ESTRUTURAS DE DECISÃO (if)

Recurso utilizado para dar sequencia em fluxos de execução baseado decisões. Cuja sintaxe é:

- Condição Verificada é o teste que definirá se controle deve ser passado para dentro do bloco then, observe que esse teste é feito sobre a saída de um comando.
- Ação são comandos a serem executados em caso verdadeiro da condição verificada.

.

OPERADORES PARA NÚMEROS

-eq Verifica se é igual,
-ne Verifica se é diferente,
-lt Verifica se é menor,
-gt Verifica se é maior,
-le Verifica se é menor ou igual,
-ge Verifica se é maior ou igual.

.

OPERADORES PARA TEXTO

!= Verifica se é diferente,
= Verifica se é igual.

.

OPERADORES LÓGICOS

! Lógica NOT,
-o Lógica OU, (OR) ou ||,
-a Lógica E, (AND) ou &&.

.

OPERADOR PARA arquivos/

-d Verifica se é diretório,
-f Verifica se é arquivo,
-e Verifica se existe.

.

Ex:

# !/bin/baxh
# Uso de Estrutura de Decisão
clear

echo 'opções'
echo '======'
echo ' -> Data do Sistema'
echo ' -> Uso do Sistema'

read opcao

if [ "$opcao" -eq 1 ]
then
echo 'Data do sistema: ' && date

elif [ "$opcao" -eq 2 ]
then

echo 'Uso do disco: ' && df -Th
fi

# Fim do script

.

ESTRUTURAS DE REPETIÇÃO (FOR)(WHILE)

.

ESTRUTURA DE REPETIÇÃO FOR

Permite que ações de iteração sejam executadas sobre determinados comandos ou variáveis até que a condição seja satisfeita.

# !/bin/bash

clear

echo "DIAS DA SEMANA"
for dia in seg ter qua qui sex sab dom
do
echo "$dia"
done

# Fim do script

.

ESTRUTURA DE REPETIÇÃO WHILE

Em situações onde sabemos até onde o loop irá realizar uma contagem o ideal é usar o for entretanto em cenarios onde a iteração deve cessar somente após se satisfazer uma condição o uso do laço while é mais indicado. Ex:

# /bin/bash

clear
var=1
while [ $var -le 7 ]
do
echo "Valor de var: $var"
var=$((var+1))
done

# Fim do script

.

FUNÇÕES E ARGUMENTOS

Ex:

# !/bin/bash
# REALIZAR BACKUP DO DIR

echo -e " \033[1;33m Digite o caminho de origem.: \033[0m "
read DIR_ORIGEM

clear

echo -e " \033[1;34m Digite o caminho de destino.: \033[0m "
read DIR_DESTINO

clear

verifica_argumentos(){

if [ $# -lt 1 ];
then
echo "Faltou informar um dos argumentos (parametros) necessarios!"
exit 1
fi
}

copia_arquivos(){

verifica_argumentos

clear

echo "Realizando backup..."

#Verificando se o dir de destino existe

if ! [ -d $DIR_DESTINO ]
then
mkdir $DIR_DESTINO
echo "Diretorio de Destino Criado"
fi

#COPIANDO ARQUIVOS

for arq in `ls $DIR_ORIGEM`
do
cp /$DIR_ORIGEM/$arq $DIR_DESTINO/$arq.bak
done

}

copia_arquivos

# Fim do script

DEFINIÇÕES DE VARIÁVEIS E ESCOPO DESTAS

Variáveis são definidas pela nomenclatura NOME_VARIAVEL="Valor da Variável". O valor pode ser tanto numérico quanto texto.

Nome="Joel"

Se quisermos acessá-la, basta fazer referência a ela com o caractere $ (cifrão) antes do nome: o comando echo $Nome, por exemplo, retornará a palavra "Joel".

Se quiser sabe informações sobre os sistemas de arquivo nos quais cada ARQUIVO reside ou, por padrão, sobre todos os sistemas de arquivos posso abrir um terminal e digitar:

VarInfo="df -h"

Depois digito no terminal "$VarInfo" sem aspas.

.

VARIÁVEIS DE AMBIENTE

As variáveis de ambiente independem da definição do usuario. Elas são criadas automaticamente, no momento em que se faz o login no sistema.

Ex:

PATH: define diretórios de procura por programas executados no shell;
USER: informa o nome do usuário do shell;
HOME: informa o caminho do diretório home do usuário;
PWD: diretório atual;

.

As variáveis são a base de qualquer script. É dentro delas que os dados obtidos durante a execução do script serão armazenados. Para definir uma variável, basta usar o sinal de igual "=" e para ver seu valor, usa-se o "echo":

.

Execute estes comandos abaixo no terminal:

.

VARIAVEL="um dois tres"

echo $VARIAVEL

echo $VARIAVEL $VARIAVEL

.

Para remover a variável acima:

unset VARIAVEL

.

Teste:

echo $VARIAVEL

.

É possível armazenar a saída de um comando dentro de uma variável. Ao invés de aspas, o comando deve ser colocado entre "$(...)", execute no terminal os comandos abaixo:

HOJE=$(date)

echo "Hoje é: $HOJE"

unset HOJE

echo $HOJE

HOJE=$(ls)

echo "O conteúdo desta pasta tem: $HOJE"

unset HOJE

echo $HOJE

HOJE=$(free -hmt)

echo "Informando sobre a memória desta máquina: $HOJE"

unset HOJE

echo $HOJE

.

Exemplos de uso do shell script:

Apagar arquivos velhos - Apagar periodicamente arquivos mais velhos que 30 dias do diretório /tmp:

#!/bin/bash

cd /tmp
find . -type f -mtime +30 -delete

# Fim do script

Este seria o conteúdo de um shell script que sempre que fosse executado apagaria arquivos com data de modificação maior que 30 dias a partir do diretório /tmp do sistema de arquivos.

Notem que ele é nada mais do que uma associação de 2 comandos (cd e find) em um arquivo para facilitar a repetição da tarefa. Este poderia ser, por exemplo, o conteúdo do arquivo /bin/limpatmp.sh e poderíamos chamar este script pela linha de comandos sempre que desejássemos repetir esta ação:

$ limpatmp.sh

Onde o símbolo "$" representa o prompt de comandos. Do ponto de vista do usuário este seria mais um comando disponível para uso.

Os scripts em shell são também muito empregados junto à inicialização do sistema (para auto-iniciar tarefas) ou como mini-aplicativos, que facilitam tarefas dos usuários, tais como montagem de dispositivos, menus de ajuda, etc.

Sua primeira linha obrigatoriamente começa com um "#!" (que não se deve confundir com um comentário qualquer, pois realmente é uma exceção; este par se chama, em inglês, de shebang), informando diretamente ao núcleo (kernel) qual interpretador ele deverá usar, juntamente com seu caminho, de acordo com a necessidade de cada caso. Exemplo:

#!/bin/bash

Em seguida, são adicionados os comandos desejados, um por linha, ou separados por ponto e vírgula. Exemplo:

mount -t reiserfs /dev/hda1 /mnt/hda1

ls /mnt/hda1

cp -r /mnt/hda1/* /home/user/backup
umount /dev/hda1

Por fim, dá-se a permissão de execução a este arquivo de texto simples ("chmod +x arquivo").

.

DATA ANTERIOR

.

#!/bin/bash

# Função em Bash para retornar a data anterior, levando em conta o mês e ano.

fn_data_anterior()
{
DIA=$D
MES=$M
ANO=$A

# Dado DIA, MES e ANO numéricos, obtém a data do dia anterior

DIA=`expr $DIA - 1`
if [ $DIA -eq 0 ]; then
MES=`expr $MES - 1`
if [ $MES -eq 0 ]; then
MES=12
ANO=`expr $ANO - 1`
fi
DIA=`cal $MES $ANO`
DIA=`echo $DIA | awk '{ print $NF }'`
fi
}

ano=`date +%Y`;
mes=`date +%m`;
let dia=10\#`date +%d`;

if (( $dia". Para guardar a saída do comando anterior no arquivo "saida", basta fazer:

cat /etc/passwd | grep root | cut -c1-10 > saida

cat saida

.

O COMANDO TEST

O canivete suíço dos comandos do shell é o "test", que consegue fazer vários tipos de testes em números, textos e arquivos. Ele possui várias opções para indicar que tipo de teste será feito, algumas delas:

-lt Núm. é menor que (LessThan)

-d É um diretório

-gt Núm. é maior que (GreaterThan)

-f É um arquivo normal

-le Núm. é menor igual (LessEqual)

-r O arquivo tem permissão de leitura

-ge Núm. é maior igual (GreaterEqual)

-s O tamanho do arquivo é maior que zero

-eq Núm. é igual (EQual)

-w O arquivo tem permissão de escrita

-ne Núm. é diferente (NotEqual)

-nt O arquivo é mais recente (NewerThan)

= String é igual

-ot O arquivo é mais antigo (OlderThan)

!= String é diferente

-ef O arquivo é o mesmo (EqualFile)

-n String é não nula

-a E lógico (AND)

-z String é nula

-o OU lógico (OR)

.

SCRIPT QUE TESTA ARQUIVOS

Tente fazer um script "testa-arquivos", que pede ao usuário para digitar um arquivo e testa se este arquivo existe. Se sim, diz se é um arquivo ou um diretório.

.

CONCEITOS MAIS AVANÇADOS

.

If, for e while

.

Assim como qualquer outra linguagem de programação, o shell também tem estruturas para se fazer condicionais e loop. As mais usadas são if, for e while.

.

Então daqui por diante, sabemos o básico, o necessário para se fazer um script de funcionalidade mínima. E este mínimo pode fazer coisas incríveis.

.

Ex:

if COMANDO
then
comandos
else
comandos
fi

# Fim do script

Ex:

for VAR in LISTA
do
comandos
done

# Fim do script

Ex:

while COMANDO
do
comandos
done

# Fim do script

.

Diferente de outras linguagens, o if testa um comando e não uma condição. Porém como já conhecemos qual o comando do shell que testa condições, é só usá-lo em conjunto com o if. Por exemplo, para saber se uma variável é maior ou menor do que 10 e mostrar uma mensagem na tela informando:

.

Ex:

if test "$VARIAVEL" -gt 10
then
echo "é maior que 10"
else
echo "é menor que 10"
fi

# Fim do script

.

Há um atalho para o test , que é o comando [. Ambos são exatamente o mesmo comando, porém usar o [ deixa o if mais parecido com o formato tradicional de outras linguagens:

.

Ex:

if [ "$VARIAVEL" -gt 10 ]
then
echo "é maior que 10"
else
echo "é menor que 10"
fi

# Fim do script

.

Se usar o [, também é preciso fechá-lo com o ], e sempre devem ter espaços ao redor. É recomendado evitar esta sintaxe para diminuir suas chances de erro.

.

Já o while é um laço que é executado enquanto um comando retorna OK. Novamente o test é bom de ser usado. Por exemplo, para segurar o processamento do script enquanto um arquivo de lock não é removido:

.

Ex:

while test -f /tmp/lock
do
echo "Script travado..."
sleep 1
done

# Fim do script

.

Ex:

E por fim, o for percorre uma lista de palavras, pegando uma por vez:

for numero in um dois três quatro cinco
do
echo "Contando: $numero"
done

# Fim do script

.

Uma ferramenta muito útil para usar com o for é o seq, que gera uma seqüência numérica.

.

Para fazer o loop andar 10 passos, pode-se fazer:

for passo in $(seq 10)

.

O mesmo pode ser feito com o while, usando um contador:

i=0
while test $i -le 10
do
i=$((i+1))
echo "Contando: $i"
done

# Fim do script

.

Até Breve

.

:)

.

Fonte: https://semanickz.wordpress.com/2018/02/22/comandos-mais-usados-em-shellscript-linux/

.

Crie seu próprio epub deste artigo usando o programa Sigil

.

Linux e o NTFS – Comandos para consertar HD Externo NTFS inadministrável

.

Para verificar partições do disco rígido e espaço em disco

.

fdisk, sfdisk, cfdisk > Ferramentas de partição que também informam sobre as partições

.

sudo fdisk -l

.

sudo sfdisk -l -uM

.

cfdisk > Editor de partições com interface baseada em ncurses.

.

lsblk

.

sudo cfdisk /dev/sdb

.

sudo parted -l

.

df -h

.

df -h | grep ^/dev

.

df -h --output=source,fstype,size,used,avail,pcent,target -x tmpfs -x devtmpfs

.

pydf

.

Para consertar HD Externo NTFS > Problemas de desfragmentação que acontecem ao longo do tempo. As mudanças em Bios, novos tipos de HDs, mudanças em Distros Linux podem fazer parecer que um HD externo NTFS quebrou, que um gerenciador de arquivos enlouqueceu, Que a Área de Trabalho odeia HDs Externos NTFS.

.

Porém as coisas não são assim de fato. Problema se resolve, porque o mundo Linux, os grupos, comunidades programam, gostam e sempre aparece um modo das coisas funcionarem.

.

Escolher uma boa Distro é importante. Uma boa Distro é por exemplo o Solus, o Manjaro, o Debian e o Linux Mint.

.

Mas quando um HD NTFS, tipo de backup, fica esquisito é complicado atualmente resolver o problema apenas com o auxílio do sistema operacional Linux.

.

Na maioria das vezes o usuário Linux atualmente só tem a opção de usar o Windows e programs para o Windows e assim resolver de modo inteligente HDs externos NTFS.

.

Porém existe algo que pode fazer para tentar ajeitar um HD externo NTFS que funciona junto com o sistema operacional Linux.

.

Executo o tutorial na prática abrindo o terminal pelo menu do sistema por minha conta e risco.

.

lsblk

.

sudo umount /dev/sdb1

.

sudo ntfsfix /dev/sdb1

sudo ntfsfix -b /dev/sdb1

sudo ntfsfix -d /dev/sdb1

sudo ntfsfix -V /dev/sdb1

.

sudo touch /dev/sdb1

.

sudo mount -t /dev/sdb1

.

Outro Driver:

.

lsblk

.

sudo umount /dev/sdc1

.

sudo ntfsfix -b /dev/sdc1

sudo ntfsfix -d /dev/sdc1

sudo ntfsfix -V /dev/sdc1

.

sudo touch /dev/sdc1

.

sudo mount -t /dev/sdc1

.

Resumindo:

.

lsblk ; sudo umount /dev/sdb1 ; sudo ntfsfix /dev/sdb1 ; sudo touch /dev/sdb1 ; sudo mount -t ntfs-3g /dev/sdb1

.

sudo ntfsfix /dev/sdXY

.

sudo ntfsfix /dev/sdc1

.

lsblk ; sudo umount /dev/sdc1 ; sudo ntfsfix /dev/sdc1 ; sudo touch /dev/sdc1 ; sudo mount -t ntfs-3g /dev/sdc1

.

lsblk ; sudo umount /dev/sdb1 ; sudo ntfsfix /dev/sdb1 ; sudo touch /dev/sdb1 ; sudo mount -t ntfs-3g /dev/sdb1 ; lsblk ; sudo umount /dev/sdc1 ; sudo ntfsfix /dev/sdc1 ; sudo touch /dev/sdc1 ; sudo mount -t ntfs-3g /dev/sdc1

.

sudo apt-get check ; sudo ntfsfix /dev/sdb1 ; sudo ntfsfix /dev/sdc1 ; sudo ntfsfix /dev/sdd1 ; sudo apt install -f

.

sudo apt-get check ; sudo apt install -f ; sudo --dpkg configure -a

.

sudo apt-get check ; sudo apt update ; sudo ntfsfix /dev/sdb1 ; sudo apt install -f ; sudo apt-get check ; sudo apt upgrade -y ; sudo apt update ; sudo ntfsfix /dev/sdc1 ; sudo apt install -f ; sudo apt-get check ; sudo apt upgrade -y ; sudo dpkg --configure -a ; sudo apt --fix-broken install ; sudo update-grub

.

Forçar o HD Externo a ser montado:

.

sudo mount -t ntfs-3g /dev/sdX1 /mnt/ -o force

.

sudo apt-get check ; sudo ntfsfix /dev/sdb1 ; sudo ntfsfix /dev/sdc1 ; sudo ntfsfix /dev/sdd1 ; sudo apt install -f

.

sudo mount -t ntfs-3g /dev/sdb1 /mnt/ -o force ; sudo mount -t ntfs-3g /dev/sdc1 /mnt/ -o force ; sudo mount -t ntfs-3g /dev/sdd1 /mnt/ -o force

.

HD notebook Disco rígido

.

Ativar chache de escritura de disco rigido

.

Está ativa?

1
sudo hdparm -W /dev/sda

.
Desativar:

1
sudo hdparm -W0 /dev/sda

.

Exemplo:

.

# mount -t ntfs-3g /dev/sdc1 /media/ntfs_stick

# mount -t ntfs-3g /dev/sdc1 /media/ntfs_stick -o rw,nosuid,nodev,uhelper=udisks,uid=0,gid=0,dmask=0077,fmask=0177

# /sbin/mount.ntfs /dev/sdc1 /media/ntfs_stick -o rw,nosuid,nodev,uhelper=udisks,uid=0,gid=0,dmask=0077,fmask=0177

# ntfs-3g /dev/sdc1 /media/ntfs_stick -o rw,nosuid,nodev,uhelper=udisks,uid=0,gid=0,dmask=0077,fmask=0177

.

Linux-Como-Converter-de-Txt-para-PDF-e-de-PDF-para-ePub

2017

.

Para Debian e derivados

.

Vou por minha conta e risco, criar um arquivo .txt, depois um PDF e por fim um ePub deste texto aqui. Tudo pelo terminal.

Vou copiar este texto para a pasta Modelos. Instalo o programa Calibre.

.

sudo apt install calibre ; sudo apt update

.

O calibre também pode ser instalado com os comandos abaixo:

.

sudo -v && wget -nv -O- https://raw.githubusercontent.com/kovidgoyal/calibre/master/setup/linux-installer.py | sudo python -c "import sys; main=lambda:sys.stderr.write('Download failed\n'); exec(sys.stdin.read()); main()"

.

echo -e '[Desktop Entry]\n Version=1.0\n Name=calibre\n Exec=/opt/calibre/calibre\n Icon=/opt/calibre/resources/images/library.png\n Type=Application\n Categories=Application' | sudo tee /usr/share/applications/calibre.desktop

.

sudo chmod +x /usr/share/applications/calibre.desktop

.

cp /usr/share/applications/calibre.desktop ~/Área\ de\ Trabalho/

.

Convertendo arquivos pelo terminal:

.

Usarei o exemplo abaixo para converter o arquivo .txt para .epub:

$ ebook-convert nome-do-arquivo.txt nome-do-arquivo.epub --enable-heuristics

.

O título do arquivo .txt é:


converter-de-txt-para-pdf.txt

Fica assim:


ebook-convert converter-de-txt-para-pdf.txt converter-de-txt-para-pdf.pdf --enable-heuristics

.

Tenho agora o arquivo PDF:

converter-de-txt-para-pdf.pdf

.

Agora vou converter o PDF para ePub usando o exemplo abaixo:


$ ebook-convert converter-de-txt-para-pdf.pdf converter-de-txt-para-pdf.epub --enable-heuristics

.

Terei o arquivo ePub:

converter-de-txt-para-pdf.epub

.

Agora posso renomear os arquivos para o título que eu quiser usando o mouse mesmo escolhendo renomear.

.

Executo os comandos abaixo:

ls -t

ls -lah

ls -C

pwd

exit

.

Até Breve

.

🙂

Como-compilar-código-fonte-de-programas-no-linux

2017

.

Como-fazer-para-compilar-código-fonte-de-programas-no-linux?

.

Baixe o código-fonte do site do projeto, nunca de site de terceiros, e compile localmente a coisa. Após o download do arquivo não esqueça de fazer uma checagem no pacote usando uma dessas chaves: MD5 checksum, SHA1 checksum, SHA256 checksum. Para ter certeza e a segurança que irá compilar o fonte original.

.

Resumindo o processo de instalação de programas disponibilizados a partir do código-fonte em 4 partes.

 

1- Descompactar o arquivo tar.gz que contém o código-fonte.

.

2- Resolver dependências necessárias para a instalação correta do programa – cada programa possui suas próprias dependências, e isso torna processo demorado e um pouco mais complicado. Cada programa tem sua peculiaridade.

.

3- Compilar.

.

4- Instalar.

Compilar é é traduzir as instruções, no arquivo de código fonte, dadas pelo programador, para instruções legíveis pelo computador. Alguns desenvolvedores de softwares disponibilizam seus programas diretamente pelo código-fonte (source) – que por sinal era, nos primórdios, o único método utilizado.

.

Para compilar, cabe ao usuário ter conhecimento prévio para compilar e instalar programas Linux distribuídos diretamente pelo código-fonte, normalmente compactados via tar.gz.

.

Em resumo, eu tenho acesso a um arquivo compactado no formato .tar.gz (na maioria das vezes), contendo o código-fonte do programa, e a instalação consiste em compilar e instalar os executáveis gerados na máquina.

.

Compilar até chegar a um código binário executável pelo meu sistema.

.

Devido às diferenças que existem entre uma distribuição e outra um pacote do Fedora não funcionará no Debian, por exemplo.

.

Assim, essa técnica garante suporte a todas as distribuições Linux, universalmente! Ou seja, baixando um programa distribuído a partir do código-fonte (source), não será preciso se ater a qual distro Linux você está usando; pois, verificada as dependências necessárias, será possível compilar e instalar o programa.

.

É do código binário que eu preciso para rodar e usar um programa.

.

Para saber como um programa funciona internamente ou se eu quiser modificá-lo, adicionando recursos e funcionalidades, eu preciso do código fonte.

.

Depois de alterado o código fonte, pode-se usar o compilador para produzir um novo binário.

.

Se baixei um arquivo com o código fonte de algum programa, antes de instalá-lo, vou precisar compilar.

.

A compilação diz respeito ao processamento de arquivos com o código fonte (.C, .CC, .CPP etc. — caso a linguagem de programação, usada pelo desenvolvedor, seja C ou C++) e à criação de um arquivo “objeto” – este último passo, não cria qualquer coisa útil pro usuário final, mas apenas as instruções em linguagem de máquina, correspondentes ao que foi compilado do código fonte.

.

1

Processar arquivos do código fonte.

2

Criar um arquivo objeto

3

Criar um link na pasta onde está o executável.

.

A sintaxe do comando é esta:

sudo ln -s /original /link

.

Se você compilar e não linkar, vai acabar com três arquivos separados – cada qual com um nome semelhante a nome_de_arquivo.o ou nome_de_arquivo.obj.

.

A extensão vai depender do seu compilador.

.

Estes arquivos precisam ser linkados para que se tornem executáveis.

.

O código fonte vem compactado com várias outras bibliotecas – que são arquivos de código fonte acessório ao código principal.

.

Há outros arquivos de texto, que servem para dar instruções sobre os outros arquivos, sobre como compilar ou instalar todo o aplicativo.

.
Entre estes arquivos, o README (leia-me) e o INSTALL, são comumente encontrados.

.

O ideal é que estes arquivos contenham instruções completas sobre como compilar e instalar — mas, este nem sempre é o caso.

.

Exemplo de compilação e instalação de um programa

.

Depois de baixar o pacote com o fonte, o procedimento mais comum é descompactar, ler o conteúdo dos arquivos README e INSTALL, configurar a compilação e fazer a instalação.

.

tar -xzvf programa.tar.gz

.
cd programa/

.

more README

.

more INSTALL

.

./configure

.

make

.

make install

.

Como descompactar o arquivo com o código fonte?

.

Cada desenvolvedor escolhe um programa de compactação para envolver e empacotar seu código fonte.

.

Através da compactação, o desenvolver guarda vários (podem ser centenas ou milhares de) arquivos dentro de um só pacote. Assim, é mais fácil transferir via Internet.

.

O programa para desempacotar varia, dependendo do tipo de pacote usado pelo desenvolvedor.

.

A extensão do arquivo-pacote é que indica o programa que deve ser usado para desempacotá-lo.
.
Veja, abaixo, exemplos de nomes e extensões de arquivos e os comandos a usar para descompactá-los:

.

nome do arquivo como descompactar…

exemplo.tar.gz ou exemplo.tgz:

tar -xvzf exemplo.tar.gz ou tar -xvzf exemplo.tgz

.

exemplo.tar.bz2 ou exemplo.tbz:

tar -xvjf exemplo.tar.bz2 ou tar -xvjf exemplo.tbz

.

exemplo.tar:

tar -xvf exemplo.tar

.

exemplo.zip:

unzip exemplo.zip

.

Dentro do diretório onde você descompactou os arquivos, deve haver um script chamado configure. Use o comando ls para obter uma listagem dos arquivos disponíveis no diretório atual.

.
Usualmente, o script configure pode ser executado de diversas formas. Veja algumas das mais comuns.

.

Para obter ajuda genérica sobre a execução do configure:

./configure –help

.

Para executar o script com suas opções padrão.

./configure

.

Para especificar o meu diretório home para instalar o binário executável, depois da compilação.

./configure –prefix=~/

.

Normalmente, você não precisa especificar, com a opção –prefix o diretório de instalação. Pode deixar que o programa siga seus padrões (usualmente, o diretório /usr/local/).

.

Compilando, instalando e desinstalando.

.

Após a configuração, rode o utilitário make – para ler o arquivo Makefile, no diretório local e compilar o programa para você.

.

Devo adverti-lo(a), que compilar um programa pode ser um tanto demorado.

.

Mas programas simples, de tamanho reduzido, podem levar apenas 1 ou 2 minutos, como o mpg123.

.

Dependendo da velocidade do seu computador, pode levar horas ou dias para compilar um set de aplicativos como o KDE.

.

Enfim, para concluir a instalação do aplicativo, use o comando make install, deste jeito:

.

make install

.

Se quiser desinstalar, mais tarde, execute (dentro do mesmo diretório em que fez a instalação) o seguinte comando:

.

make uninstall

.

A desinstalação nem sempre é tão simples assim. O comando acima, acima, [e um conceito universal, que nem sempre é posto em prática pelos desenvolvedores.

.

Se ela não funcionar, você vai precisar ler a documentação do programa sobre como proceder com a desinstalação.

.

Veja exemplo de como compilar programas no link abaixo:

.

https://semanickz.wordpress.com/2017/08/26/solus3-instalando-programas-manualmente-no-solus-linux-3/

.

Conclusão:

 

1- Baixo e descompacto o arquivo tar

.

Entro no diretório descompactado com o comando cd.

.

2- Resolvo dependências

.

Caso as dependências necessárias, da aplicação, não sejam atendidas o código-fonte não poderá ser compilado e instalado, futuramente.

.

Cada aplicação possui um leque diferente de dependências.

.

3- Depois de satisfazer as dependências do sistema, é preciso resolver as pendências da aplicação. Para isso, eu devo executar o comando:

.

./configure

.

Sobre o comando ./configure, ele verifica todas dependências que o programa precisa, como se o pacote de compiladores está instalado; por exemplo. O prefixo ./ diz ao sistema Linux para procurar o arquivo de configuração no diretório atual e executá-lo. Assim, você precisa estar dentro do diretório do programa.

.

Se tudo correr bem, eu não verei quaisquer erros.

.

Caso apresente algum erro, basta examinar a saída do comando ./configure e instalar/configurar todas as dependências ausentes usando meu gerenciador de pacotes.

.

Executo ./configure quantos vezes for preciso até que eu não veja mais erros

.

3- Compilação

.

Depois de ter resolvido todas as dependências, eu devo compilar o programa. Uso o comando make para fazer isso:

.

make

.

4- Instalação

.

Não tendo apresentado nenhum erro até agora, eu preciso instalar o programa.

.

Basta executar sudo make install. Este passo move todos os binários em seu local correto no meu sistema para que o programa fique pronto para usar:

.

sudo make install

.

Se eu desejar remover o programa, que acabei de instalar, basta entrar no diretório que eu instalei o programa e executar os 2 comandos abaixo:

.

sudo make uninstall

sudo make clean

.

Para instalar a maioria dos programas a partir do código-fonte (source), eu passarei por estas situações.

.

Contudo, com algumas diferenças das mostrados aqui.

.

Por exemplo, posso precisar usar cmake em vez de make.

.

Por isso, sempre leia o arquivo “README” contido no diretório de cada programa!! Além dele, normalmente, existe o arquivo “Install”

.

Resumão completo:

.

Os arquivos compilados ficam em:

 

1
/opt/

.

2
/usr/bin/

.

3
/usr/share/applications

.

Estes 3 tem que ser linkados. Vinculados uns aos outros para o programa funcionar.

.

Baixo o arquivo tar com “wget -c endereço-de-download-http -O nome-compacto.tar.xz” desta forma baixo o arquivo tar renomeio ele para um “nome-compacto” e o download ficará já na pasta correta que é a /opt/.

.

Depois crio uma pasta para o programa na pasta /opt/

.

sudo mkdir /opt/nome-compacto

.

Descompacto o arquivo tar.xz, poderia ser tar.gz baixado que está na pasta /opt/ que será movido para a pasta criada com o comando mkdir acima.

 

sudo tar Jxf nome-compacto.tar.xz -C /opt/nome-compacto/

 

Se fosse tar.gz:

 

sudo tar -vzxf nome-compacto.tar.gz -C /opt/nome-compacto/

 

Se fosse tar.bz2:

 

sudo tar -jxvf nome-compacto.tar.bz2 -C /opt/nome-compacto/

.

Se fosse bz2

.

sudo bunzip nome-compacto.bz2 -C /opt/nome-compacto/

 

###

 

Verifico o que existe do programa na pasta /opt/, na pasta /bin/ e na pasta /usr/share/applications.

.

Crio o link entre a pasta /opt/ e a pasta /bin/ para a execução do programa:

.

sudo ln -sf /opt/nome-compacto/Nome-Compacto /usr/bin/Nome-Compacto

.

Crio um lançador para o programa.

.

Eu posso criar um lançador de qualquer coisa – como um script que eu arrumei ou um programa que eu instalei no meu sistema.

.

Este método não é exclusivo de qualquer distribuição – você pode usá-lo no Debian, Linux Mint ou qualquer outra versão Linux.

.

Criar um lançador personalizado:

.

Exemplo:

Criar um arquivo vazio e chamá-lo de “nome-compacto” Clico com o botão direito do mouse sobre o arquivo e abro com o meu editor de texto favorito. Colo o texto apropriado para o programa como reproduzido a seguir, a título de exemplo usando nome-compacto:

 

[Área de Trabalho Entrada]
Name = nome-compacto
Comment =
Informação sobre nome-compacto Exec = nome-compacto /opt/nome-compacto-arquivo-exec
Icon =/opt/nome-compacto/icon.jpg
Terminal = false
Type =
Aplicação Categorias = procuro-esta-info-na-pasta-descompactada; aplicação-procuro-esta-info-na-pasta-descompactada;

.

Muita gente usa o método do comando echo, mas sempre tenho que saber o nome do programa, comentário, informação de execução do programa, aonde está a imagem ícone do programa, o tipo do programa, em qual categoria de aplicação o programa pertence, nome da aplicação.

.

Crio um lançador para o programa usando o comando echo:

.

echo -e ‘[Desktop Entry]\n Version=1.0\n Name=nome-compacto\n Exec=/opt/nome-compacto/Nome-Compacto\n Icon=/opt/nome-compacto/src/app/images/icon.png\n Type=Application\n Categories=Application’ | sudo tee /usr/share/applications/nome-compacto.desktop

.

Coloco o atalho na área de trabalho:

.

sudo chmod +x /usr/share/applications/nome-compacto.desktop

.

cp /usr/share/applications/nome-compacto.desktop ~/Área\ de\ Trabalho/

.

Até Breve!

.

Fonte:

http://www.control-escape.com/linux/lx-swinstall-tar.html

Who are YOU? Who? Who?

XXI

.

Quem somos nós, apenas uma centelha semi lúcida de consciência, para dizer o que é, e o que existe na nossa escuridão?

.

O que existe na fria vastidão do universo?

.

Quem sabe o que nos aguarda, depois que o véu da morte é atravessado?

.

Quem somos nós, para dizer que conhecemos a nós mesmos?

.

Quando você fica inconsciente, talvez outras coisas possam usar o seu corpo.

.

A maior parte das pessoas, vive inconsciente o tempo todo.

.

O tempo todo.

.

Blog Semanickzaine