Permissão para sair

!/bin/bash

# -----------------

## Data: 20-08-2020
## Nome do script: permissao_sair.sh

# -----------------

clear

# -----------------

echo
echo "Linux aprenda: if then elif else e fi"
echo
sleep 3

# -----------------

echo -n "Se quiser sair a noite, digite a sua idade (10 a 19) : "
read REPLY

# -----------------

# declaração: if then elif else e fi

if [[ "$REPLY" -ge 19 ]] # declaração if
then
echo 'Você pode ir para a festa.'

elif [[ "$REPLY" -eq 18 ]] # declaração elif
then
echo 'Você pode ir à festa, mas estará de volta antes da meia-noite.'

elif [[ "$REPLY" -eq 10 ]] # declaração elif
then
echo 'Você não pode ir à festa. Tome banho, escove os dentes. Vá dormir ás 22:00. Estamos te vendo pelas cameras da casa agora.'

else # comando else
echo 'Você não pode ir à festa. Fique no berço.'

fi # fechamento do if é o fi

## fim ##

Bash script buscar títulos em sites

#!/bin/bash

#####################
## Data: 20-08-2020
## Nome: busca_site_titulos.sh
## Autor: fatchadeus
#####################

# -------------------
# 1- Variáveis
# -------------------

ARQUIVO_DE_TITULOS="titulos.txt"
VERD="\033[32;1m"
VERM="\033[31;1m"
FILE="/usr/bin/lynx"

# -------------------
# 2- Testes
# -------------------

clear

## informa sobre a verificação
	echo -e "\e[1;32mO lynx está instalado?\e[0m"
	sleep 3
	
## validando se a ferramenta necessária está instalada

clear

if test -f "$FILE"; then
	echo "O lynx está instalado. Continue."
else 
	echo "O lynx não está instalado. Instalando o lynx antes de continuar."
	sudo apt update
	sudo apt install lynx
	sudo apt update
	echo "Lynx instalado"
	sleep 3
fi

# -------------------
# 3- em uma linha:
# -------------------

# clear; FILE="/usr/bin/lynx"; if test -f "$FILE"; then echo "O lynx está instalado. Continue."; else echo "O lynx não está instalado. Instalando o lynx antes de continuar." && sudo apt update && sudo apt install lynx && echo "Lynx instalado." && sleep 3; fi

# -------------------
# 4- Execução
# -------------------

	touch titulos.txt
	
	echo -e "\e[1;32mBuscando títulos no site ...\e[0m"
	sleep 3

	firejail --noprofile lynx -source https://umsite.com/ | grep blurb | sed 's/<div.*line">//;s/<\/span.*//' > titulos.txt

while read -r titulo_lxer
do
    echo -e "${VERM}Titulo: ${VERD}$titulo_lxer"  
done < "$ARQUIVO_DE_TITULOS"

rm -f titulos.txt


## fim do script

Um killswitch para o UFW

16-08-2020

Olá pessoal! Estamos aqui batendo cabeça com um killswitch que funciona e usa o firewall UFW.

O que é UFW? Bom …

Firewall descomplicado (UFW)

Um dos muitos aspectos anunciados do Linux é sua segurança.

Do desktop ao servidor, você encontrará todas as ferramentas de que precisa para manter essas máquinas bloqueadas da forma mais rígida possível.

Por muito tempo, a segurança do Linux esteve nas mãos do iptables (que funciona com o sistema netfilter subjacente). Embora incrivelmente poderoso, o iptables é complicado – especialmente para usuários mais novos. Para realmente tirar o máximo proveito desse sistema, pode levar semanas ou meses para ficar pronto.

Felizmente, um front end muito mais simples para iptables está pronto para ajudar a tornar seu sistema tão seguro quanto necessário.

Esse front-end é Uncomplicated Firewall (UFW). O UFW oferece uma estrutura muito mais amigável para gerenciar o netfilter e uma interface de linha de comando para trabalhar com o firewall.

Além disso, se você preferir não lidar com a linha de comando, o UFW tem algumas ferramentas de GUI que tornam o trabalho com o sistema incrivelmente simples.


Criamos um shell script que faz o kill switch existir. O código está logo abaixo :

Nome do bash shell script : ufw_killswitch.sh
#!/bin/bash

#############################################
## CONFIGURA UM UFW KILL SWITCH MANUAL PARA OPENVPN NO
## GNU/LINUX
## SCRIPT: ufw_killswitch.sh
## DATA: 16-08-2020
## OBS: ao reiniciar o sistema não precisa
## executar o script de novo.
## De vez em quando volto para
## as configurações originais do UFW
## para atualizar o relógio do sistema com
## o da rede (ntp) o sistema
## não funciona direito se o horário estiver
## incorreto.
## Para isto, uso outro script chamado: unfirewall.sh
#############################################
## voltando/iniciando as config normais/originais
## do ufw ... Quais? Estas : 
## default deny incoming
## allow outgoing
#############################################
## CONECÇÃO OPENVPN VIA NETWORK-MANAGER
#############################################
## OBS:
## O NETWORK-MANAGER É UM BEBÊ CHORÃO.
## O NETWORK-MANAGER É UMA MENININHA CHORONA.
#############################################

NORmconf(){
# faz o ufw voltar as configurações normais
	echo -e "\n\e[1;88;40m*** Unfirewall UFW ***\e[0m\n"
	sleep 8

	echo -e "\e[82msudo ufw reset & sudo ufw disabe\e[0m"
	sudo ufw disable
	sleep 1
	sudo ufw enable
	sleep 1
# --------------------------
	echo -e "\e[82msudo ufw --force reset\e[0m"
	sudo ufw --force reset
	sleep 1
# --------------------------
	echo -e "\e[82msudo ufw enable\e[0m"
	sudo ufw enable
	sleep 1
# --------------------------
	echo -e "\e[82msudo ufw status\e[0m"
	sudo ufw status
	sleep 8
# --------------------------
	echo -e "\e[82msudo ufw status verbose\e[0m"
	sudo ufw status verbose
	sleep 8
# --------------------------
	echo -e "\e[82msudo ufw default deny incoming\e[0m"
	sudo ufw default deny incoming
	sleep 2
# --------------------------
	echo -e "\e[82msudo ufw default allow outgoing\e[0m"
	sudo ufw default allow outgoing
	sleep 2
# --------------------------
	echo -e "\e[82msudo systemctl enable ufw\e[0m"
	sudo systemctl enable ufw
	sleep 2
# --------------------------
	echo -e "\e[82msudo ufw status verbose\e[0m"
	sleep 2
	sudo ufw status verbose
	sleep 8
# --------------------------
	echo -e "\e[82msudo ufw status numbered\e[0m"
	sleep 2
	sudo ufw status numbered
	echo ""
	sleep 2
}
NORmconf

# --------------------------

read -p "*** Conecte a VPN e depois tecle enter aqui ***"

# --------------------------

## PREPARAÇÃO PARA O KILLSWITCH 01
## PERMITIR SSH
## ACESSO A LAN NETWORK
sudo ufw allow in to 192.168.0.1/24
sudo ufw allow out to 192.168.0.1/24
# --------------------------
## PREPARAÇÃO PARA O KILLSWITCH 02
## permite a máquina se conectar a dispositivos
sudo ufw allow in on tun0 from any to any
# -------------------------
## PREPARAÇÃO PARA O KILLSWITCH 03
## PERMITIR OPENVPN
sudo ufw allow out 1198/udp
sudo ufw allow in 1198/udp
# --------------------------
## PREPARAÇÃO PARA O KILLSWITCH 04
## PARA NÃO TER QUE FICAR CONECTANDO E DESCONECTANDO
sudo ufw allow out from any to 192.168.0.1/24
# ---------------------------

## O KILLSWITCH ## O MOTIVO DE TUDO
sudo ufw default deny outgoing
sudo ufw default deny incoming
sudo ufw allow out on tun0 from any to any

# --------------------------
## KILLSWITCH É AQUI UM BASH SHELL SCRIPT QUE
## CONFIGURA REGRAS DO PROGRAMA UFW.
## O KILLSWITCH É UMA NEGAÇÃO DUPLA DO
## UFW FIREWALL QUE NÃO PERMITE DE 
## FORMA ALGUMA ENTRADA E SAÍDA DE NADA.
## SÓ PERMITE, SE FOR POR CONECÇÃO VPN UDP
## NO CASO DO LINUX ESTA É A OPÇÃO ESCOLHIDA
## POR HORA.
# --------------------------

## ADICIONANDO PORTAS OBTIDAS DE ARQUIVOS .OVPN
## DA EMPRESA QUE OFERECE OS SERVIÇOS DE VPN

# ----------------------------
sudo ufw allow out to 84.184.165.146 port 1194 proto udp

sudo ufw allow out to 84.120.218.64 port 1194 proto udp

sudo ufw allow out to 41.182.186.285 port 1194

sudo ufw allow out to 84.84.112.20 port 1194

sudo ufw allow out to 41.182.186.285 port 1194

sudo ufw allow out on eth0 to 144.124.142.48 port 1194  proto udp

sudo ufw allow out on eth0 to 84.184.165.146 port 1194  proto udp

sudo ufw allow out on eth0 to 148.284.148.188 port 1194  proto udp

sudo ufw allow out on eth0 to 84.184.165.146 port 1194  proto udp

sudo ufw allow out on eth0 to 84.14.58.66 port 1194  proto udp

sudo ufw allow out on eth0 to 144.124.142.48 port 1194  proto udp

## AVISO DE CONCLUSÃO
echo ""
read -p "*** O KillSwitch está ativado. Tecle Ctrl+C para sair ***"
echo ""

No momento é só isto. Usamos e parece ser útil. Para funcionar para você o script deve ser alterado em :

a) ACESSO A LAN NETWORK
b) 192.168.0.1
c) PORTAS OBTIDAS DE ARQUIVOS .OVPN

Até Breve!

🙂

Terminal verificar conecção com a rede

Verificar se está conectado a rede. Existem aplicativos e sites sem fim que ganham oferecendo este serviço. Existem até mesmo aplicativos, apps, apks e programas que cobram para fazer isto. Bom, nada é de graça, nem mesmo um serviço gratuito. Ah, os anos 20 são sempre assim? Tempos de pragas e todo tipo de vilanias que talvez sirvam de base um novo mundo no final do século. De novo isto? Novo mundo? Ops, expressão errada eu usei. O mundo está sempre mudando, mas certas coisas não mudam. Chega disto.

Olha o negócio é Linux bash shell script. Se a pessoa conseguir entender de verdade como este script funciona já pode saber que não é mais um bebê Linux. Já está adulto. Uma pessoa jovem adulta. Pode-se fazer centenas de scripts diferentes usando o que está neste shell script.

Nele encontramos: while, do, if, then , break, else, break, fi, done e uns comandos simples mas importantes.

Sem mais enrolação aí vai o código.

🙂

#!/usr/bin/env bash

#######################
## 05-08-2020
## conectados.sh
## semanickz
## https:://semanickz.wordpress.com
#######################

while :
do
  if ping -c 4 google.com &>/dev/null 2>&1
  	then
    	echo -e "\n\e[1;32mEstamos online!\e[0m\n"
    	break
else
	echo -e "\n\e[1;32mNão estamos conectados!\e[0m\n"
		break
  fi
  		sleep 4
done


# --- fim do script --- #

E é só isto. Ou melhor, é tudo isto! Um pequeno script que pode ser usado para realizar grandes coisas.

Até Breve!

🙂

NordVPN em Solus 4.1 fortitude – Shell Script

Ah como é difícil achar as coisas quando a gente mais precisa. Muitas barreiras nos impedem de encontrar. Muita máquina travando… Muita perseguição. Muita mentira. Mas sempre tem outro dia. Um dia em que por acaso da pura teimosia você acha o fio da meada. Todo mundo já tinha encontrado e achavam que você também sabia. Por isto ninguém disse-lhe nada. Entra nessa! Vai ser legal.

Bom apesar de só usar Android e Windows actualmente; o Linux nunca me saiu do coração. Especialmente a Distro Solus. Especificamente o Solus Solus 4.1 fortitude com Kernel Linux 5.6 e alguma coisa.

É o seguinte, você pode instalar NordVPN no Solus a partir do repositório oficial do Debian. Aqui eu mostro como se faz isto usando um bash shell script amigo, solidário e anônimo (qualidades muito raras) que achei no Gitlab (não sei onde) e alterei um pouco. Lá vai o script:

OBS:

No final é só digitar nordvpn -h. Veja a imagem abaixo:

Vamos agora ao script.

#!/usr/bin/env bash

## ####################
## Autor: semanickzaine
## Título: skz_nordvpn_install.sh
## https://semanickz.wordpress.com
## Para os usuários do Solus Linux 2020
## Poderem usar NordVPN
## Achei o script no Gitlab e atualizei
## o link do pacote .deb que agora é
## 3.7.4 - Atualizado em 30-Jun-2020 15:54
## Também adicionei explicações
## Testei e até o momento está funcionando
## ####################

# Dependencias # Primeiro atualize o sistema
sudo eopkg upgrade
sudo eopkg install ipset ipset-devel binutils

# ---------------------

# Crie diretório
mkdir nordvpn

# ---------------------

# Navegue para ele
cd nordvpn

# ---------------------

# Baixe o deb e extraia
## Verifique se há nova atualização no repo:
## https:\//repo.nordvpn.com/deb/nordvpn/debian/pool/main/ ##

# ---------------------

wget https://repo.nordvpn.com/deb/nordvpn/debian/pool/main/nordvpn_3.7.4_amd64.deb

# ---------------------

# add-repo (ar) - Adiciona um repositório
# x - Extrai ficheiro(s) do arquivo
# Então:
# ar x arquivo.deb. Comando...

ar x nordvpn_3.7.4_amd64.deb

# ---------------------

# extraia o tar.xz opção: --one-top-level
tar -xvf data.tar.xz --one-top-level

# ---------------------

# Vá para o diretório data
cd data

# ---------------------

# Copie os arquivos para /etc
sudo cp -R etc/* /etc/

# ---------------------

# Copie os arquivos para /usr/bin/
sudo cp -R usr/bin/* /usr/bin/

# ---------------------

# Copie os arquivos para...
sudo cp -R usr/lib/* /usr/lib/

# ---------------------

# Copie os arquivos para...
sudo cp -R usr/sbin/* /usr/sbin/

# ---------------------

# Copie os arquivos para...
sudo cp -R usr/share/* /usr/share/

# ---------------------

# Copie os arquivos para /var/
sudo cp -R var/* /var/

# ---------------------

# Finalize a instalação mandando ver no systemd
sudo systemctl enable nordvpnd.socket

# ---------------------

# Habilitando arquivos de serviço e sockets

sudo systemctl enable nordvpnd.service
sudo systemctl start nordvpnd.socket
sudo systemctl start nordvpnd.service

# ---------------------

# Crie diretório /dev/
mkdir -p /dev/net

# ---------------------

# Crie link simbólico

sudo ln -s /sbin/ip /usr/sbin/ip 
/etc/init.d/nordvpn restart &>/dev/null

# ---------------------

## Mensagem final coloridaaa

echo -e "\n\e[32mInstalação completa, digite : nordvpn -h\e[0m\n"

# ---------------------

## --- fim do script --- ##

Então é isto pessoal.

Até Breve!

🙂

Linux comentários multiline

#!/usr/bin/env bash

##################

# nome: comentario-comentarios-multiline.sh
# autor: semanickz
# site: https://semanickz.wordpress.com/
# comentários sem cerquilha # ?
# usa
# : '
# e usa
# '.
# usa espaço e aspas simples
# para aprender executo este script

##################

clear

# --------------------------------------

# Exemplo de comentários multiline:

: ' .'

# --------------------------------------

: ' COMENTÁRIO .'

# --------------------------------------

: '

O script a

seguir calcula o

valor quadrado do

número, 5.

'

# --------------------------------------

: '

O script ...

aqui calcula...

... o quadrado do número 5.

'

# --------------------------------------

var=$((area=5*5))

# --------------------------------------

echo "O quadrado do número 5 é : "

echo "$var"

# --------------------------------------

# fim do script

Linux exemplos de cores no shell script bash

#!/bin/bash

##########################

# exemplo-bash-shell-script-cores.sh

##########################

: ' Aqui estamos testando fazer um comentário mais diferente sem usar # vamos ver como é isto agora ok? ok?

Você pode deixar seu script BASH mais bonito, colorindo sua saída. Use seqüências de escape ANSI para definir propriedades de texto como cores de primeiro plano e plano de fundo. Colorizing Shell - Use o seguinte modelo para escrever texto colorido:

---

echo -e "\e[CORmAmostra Texto\e[0m"

---

Exemplo:

echo -e "\e[1;32mTexto negrito verde\e[0m"

---

Exitem cores de texto, formato de texto e cores de fundo para serem usadas no Bash. As cores de texto tem uma numeração diferente das cores de fundo. A cor do texto, formato e fundo podem ser combinados e usados todos juntos.

---

Executo no terminal:

echo -e "\e[1;33;40m*** Texto negrito, amarelo, fundo preto ***\e[0m"

---

As cores de texto por exemplo, podem ser:

preto=30, vermelho=31, verde=32, amarelo=33, azul=34, púrpura=35, cyan=36, branco=37.

---

As cores de fundo mais usadas, comaçam a partir do número 40. Exemplos:

preto=40, vermelho=41, verde=42, amarelo=43, azul=44, púrpura=45, cyan=46, branco=47.

Então de 30 a 37 cores de texto. De 40 a 47 cores de fundo.

---

O texto em si pode ser normal=0, negrito/bold=1, sublinhado=4.

---

Por exemplo, fundo amarelo com texto vermelho é bem visível. Fundo branco com verde BOLD também.

---

.'

# TODO todo O TEXTO ACIMA NÃO VAI APARECER NA EXECUÇÃO DESTE SCRIPT?

clear

# abertura SEM FECHAMENTO
echo -e "\e[33;1m Hello World"

# bold effect - negrito
# abertura SEM FECHAMENTO
echo -e "\e[33;5m Piscando"

# blink effect - piscando
# abertura SEM FECHAMENTO
echo -e "\e[33;0m Hello World"

# back to normal - normal
# abertura SEM FECHAMENTO
echo -e "\e[33;31m Hello World"

# Red color - vermelho
# abertura SEM FECHAMENTO
echo -e "\e[33;32m Hello World"

# Green color - verde
# abertura SEM FECHAMENTO
echo -e "\e[33;33m Hello World"

# See remaining on screen - ver o restante na tela
# abertura SEM FECHAMENTO
echo -e "\e[33;34m Hello World"
echo -e "\e[33;35m Hello World"
echo -e "\e[33;36m Hello World"

# FECHAMENTO \e[0m

echo -e -n "\e[0m"

echo -e "\e[33;41m Hello World\e[0m"
echo -e "\e[33;42m Hello World\e[0m"
echo -e "\e[33;43m Hello World\e[0m"
echo -e "\e[33;44m Hello World\e[0m"
echo -e "\e[33;45m Hello World\e[0m"
echo -e "\e[33;46m Hello World\e[0m"

# back to normal - voltar ao normal
echo -e "\e[33;0m Hello World\e[0m"

echo #------------------------------

echo -e "\e[33;41m Hello World33\e[0m"
echo -e "\e[33;42m Hello World33\e[0m"
echo -e "\e[33;43m Hello World33\e[0m"
echo -e "\e[33;44m Hello World33\e[0m"
echo -e "\e[33;45m Hello World33\e[0m"
echo -e "\e[33;46m Hello World33\e[0m"

echo ""

# coment abaixo aparece ou não?

: '

# este último com fechamento faz o terminal voltar ao normal

.'

: '

# abaixo abertura de cor \e[33;0m fechamento de cor \e[0m

.'

echo -e "\e[33;0m Hello World \e[0m"

echo -e "\n# -------------- fim -------------- #\n"

# fim do script

Dicas Linux Shell Script

07-05-2020

---

Dicas Linux Shell Script?

---

Algumas dicas e truques sobre como trabalhar com o shell script do Linux?

---

Dica:

Pesquise e pratique na mesma hora. Web browser, editor de texto e terminal abertos lado a lado e não fique pulando de uma distro para outra.

---

Dica:

O caminho absoluto, contém o caminho completo a partir da raiz (/).

---

Dica:

Use = em vez de == para comparações de strings

Ex.

valor1=”coisaA”
valor2=”coisaB”

if [ "$valor1" = "$valor2" ]

---

Dica:

Use $(comando) em vez de `comando`.

Usar: user=$(echo “$UID”)

Não usar: user=`echo “$UID”`

---

Dica:

Use read-only para declarar variáveis estáticas:

readonly passwd_file=”/etc/passwd”
readonly group_file=”/etc/group”

---

Dica:

Use funções em bash shell scripts.

Exceto por scripts muito pequenos (com algumas linhas de código), lembre-se sempre de usar funções para modularizar seu código e tornar os scripts mais legíveis e reutilizáveis.

function nome_função(){
comando1;
comando2;
}

---

Dica:

Para código de linha única, use caracteres de terminação após cada comando como este:

nome-da-função(){ comando1; comando2; }

---

Dica:

Chamar a função na mesma linha de código:

nome-da-função(){ comando1; comando2; }; nome-da-função

---

Dica:

-exec COM VÁRIOS COMANDOS.

Não podemos usar vários comandos junto com o parâmetro –exec. Aceita apenas um único comando, mas podemos usar um truque (hack).

Escreva vários comandos em um script de shell (por exemplo, commands.sh) e use-o com –exec da seguinte forma:

-exec ./commands.sh {} ;

---

Dica:

PESQUISE RECURSIVAMENTE MUITOS ARQUIVOS.

Dica: Para pesquisar recursivamente por um texto sobre vários diretórios de descendentes, use:

grep "texto" . -R -n

usando o comando dentro de uma função:

pesquise(){ grep "texto" . -R -n; }; pesquise

Este é um dos comandos mais utilizados pelos desenvolvedores. Ele é usado para localizar o arquivo do código-fonte no qual um determinado texto existe.

---

Dica:

Use maiúscula para variáveis de ambiente e minúsculas para variáveis personalizadas.

---

Dica:

COMANDO BEM SUCEDIDO E MALSUCEDIDO.

Dica: Quando um comando retorna após o erro, ele retorna um status de saída diferente de zero. O comando retorna zero quando termina após a conclusão bem-sucedida. O status de retorno pode ser lido da variável especial $? (execute echo $? imediatamente após a instrução de execução do comando para imprimir o status de saída).

echo $?

---

Dica:

USE UM CAMINHO ABSOLUTO PARA O EXECUTÁVEL.

---

Dica:

Um binário executável do comando time está disponível em /usr/bin/time, assim como existe um tempo nomeado no shell embutido.

Quando corremos o tempo, ele chama o shell embutido por padrão.

O tempo interno do shell tem opções limitadas. Portanto, devemos usar um caminho absoluto para o executável (/usr/bin/time) para executar funcionalidades adicionais.

---

Dica:

FORK BOMB - CUIDADO PERIGO!

:(){:|:&};:

Esta função recursiva é uma função que chama a si mesma. Ele gera processos infinitamente e acaba em um ataque de negação de serviço.

& é pós-fixado com a chamada de função para colocar o subprocesso em segundo plano. Este é um código perigoso, pois ele cria processos e, portanto, é chamado de fork bomb.

Você pode achar difícil interpretar o código acima.

---

Dica:

Veja a página da Wikipedia:

http://en.wikipedia.org/wiki/Fork_bomb para mais detalhes e interpretação da bomba.

Ele pode ser evitado restringindo o número máximo de processos que podem ser gerados a partir do arquivo de configuração /etc/security/limits.conf.

---

Dica:

ESPECIFIQUE -maxdepth e –mindepth como o terceiro argumento.

-maxdepth e -mindepth devem ser especificados como o terceiro argumento para o find.

Se eles forem especificados como quarto ou mais argumentos, isso poderá afetar a eficiência do find, já que ele precisa fazer verificações desnecessárias (por exemplo, se –maxdepth for especificado como o quarto argumento e –type como o terceiro argumento, o comando find primeiro descobre todos os arquivos que possuem o tipo especificado e, em seguida, localiza todos os arquivos correspondentes com a profundidade especificada.

No entanto, se a profundidade for especificada como o terceiro argumento e

–type

como a quarta, o find poderá coletar todos os arquivos mais a profundidade especificada e, em seguida, verifique o tipo de arquivo, que é a maneira mais eficiente de pesquisa.

---

Dica:

-n OPÇÃO PARA ORDENAÇÃO NUMÉRICA.

Sugestão:

Tenha sempre cuidado com a opção -n para ordenação numérica.

O comando sort trata a classificação alfabética e o ordenamento numérico de forma diferente. Portanto, para especificar a classificação numérica, a opção –n deve ser fornecida.

---

Dica:

O ## OPERADOR.

Dica:

O operador ## tem mais preferência sobre o operador # para extrair uma extensão de um nome de arquivo, pois o nome do arquivo pode conter vários caracteres "." Como ## faz uma combinação gananciosa, ele sempre extrai apenas extensões.

---

Dica:

COLOCAR ATRIBUIÇÕES DE VARIÁVEIS.

Geralmente, colocamos atribuições de variáveis iniciais, como var=0; e instruções para imprimir o cabeçalho do arquivo no bloco BEGIN. No bloco END {}, colocamos instruções como resultados de impressão e assim por diante.

---

Dica:

EXCLUINDO UM CONJUNTO DE ARQUIVOS DO ARQUIVAMENTO

Dica: É possível excluir um conjunto de arquivos do arquivamento especificando padrões. Use –exclude [PATTERN] para excluir arquivos correspondentes a padrões de curingas. Por exemplo, para excluir todos os arquivos .txt do uso de arquivamento:

$ tar -cf arch.tar * --exclude "*.txt"

Observe que o padrão deve ser colocado entre aspas duplas.

---

Dica:

USANDO O COMANDO CPIO PARA CAMINHOS ABSOLUTOS.

Usando o cpio, também podemos arquivar usando arquivos como caminhos absolutos. /usr/somedir é um caminho absoluto, pois contém o caminho completo a partir da raiz (/).

Um caminho relativo não será iniciado com / mas inicia o caminho a partir do diretório atual. Por exemplo, test / file significa que existe um teste de diretório e o arquivo está dentro do diretório de teste.

Ao extrair, o cpio extrai para o caminho absoluto em si. Mas no caso do tar, ele remove o / no caminho absoluto e o converte em caminho relativo.

---

Dica:

FORMATO PATH.

Para o formato PATH, se usarmos / no final da fonte, o rsync copiará o conteúdo desse diretório final especificado no source_path para o destino.

Se estiver no final da fonte, o rsync irá copiar o próprio diretório final para o destino.

---

Dica:

/ NO FINAL DO DESTINATION_PATH.

Se / estiver no final de destination_path, o rsync copiará a origem para o diretório de destino.
Se / não for usado no final do caminho de destino, o rsync criará uma pasta, com nome semelhante ao diretório de origem, no final do caminho de destino e copiará a origem nesse diretório.

---

Dica:

COMANDO DE ESPERA.

O comando wait permite que um script seja finalizado somente após o término ou completo de todos os seus processos-filhos ou processos em segundo plano.
Primeiro argumento do comando sftp

---

Dica:

-oPort deve ser o primeiro argumento do comando sftp.

---

Dica:

EXECUTANDO DU DIRECTORY.

Executar du DIRECTORY irá produzir um resultado similar, mas mostrará apenas o tamanho consumido pelos subdiretórios. No entanto, eles não mostram o uso do disco para cada um dos arquivos. Para imprimir o uso do disco por arquivos, -a é obrigatória.

---

Dica:

COMANDOS DO DIRECTORY DU TRANSVERSAL.

du pode ser restrito para percorrer apenas um único sistema de arquivos usando o argumento –x.
Suponha que du DIRECTORY seja executado, ele percorrerá todos os subdiretórios possíveis de DIRECTORY recursivamente.
Um subdiretório na hierarquia de diretórios pode ser um ponto de montagem (por exemplo, /mnt/sda1 é um subdiretório de /mnt e é um ponto de montagem para o dispositivo /dev/sda1).
du percorrerá esse ponto de montagem e calculará a soma do uso do disco para o sistema de arquivos do dispositivo também.
Para impedir que o du seja percorrido e para calcular a partir de outros pontos de montagem ou sistemas de arquivos, use o sinalizador -x junto com outras du opções.
du –x/ excluirá todos os pontos de montagem em /mnt/ para cálculo de uso do disco.

---

Dica:

ARGUMENTO -X

Dica: O argumento -x junto com -a especifica para remover a restrição TTY transmitida, por padrão, por ps. Geralmente, o uso de ps sem argumentos imprime processos conectados apenas ao terminal.

---

Dica:

PARÂMETROS PARA -o

Dica: Os parâmetros para -o são delimitados usando o operador vírgula (,). Deve-se notar que não há espaço entre o operador vírgula e o próximo parâmetro. Principalmente, a opção -o é combinada com a opção -e (every) (-oe), pois deve listar todos os processos em execução no sistema. No entanto, quando determinados filtros são usados junto com –o, como aqueles usados para listar os processos pertencentes a usuários especificados, -e não é usado junto com –o. O uso de -e com um filtro anulará o filtro e mostrará todas as entradas do processo.

---

Dica:

COMANDO PGREP

O pgrep requer apenas uma parte do nome do comando como seu argumento de entrada para extrair um comando Bash, por exemplo, pgrep ash ou pgrep bas também funcionará. Mas ps requer que você digite o comando exato.

---

Dica:

APROPOS.

Às vezes precisamos procurar se algum comando relacionado a uma palavra existe. Em seguida, podemos pesquisar as páginas de manual por strings no comando. Para isso, podemos usar:

apropos COMMAND

---

Dica:

NOVA LINHA NO COMANDO ECHO: Quando usar -n, quando usar \c.

echo: -n ou \c

Felizmente, isso está se tornando um problema menor, mas vale a pena estar ciente, especialmente se você estiver escrevendo scripts para sistemas Unix mais antigos.

Quando você usa a instrução echo, uma nova linha é adicionada no final do comando. Isto é, se o seu script se parece com isto:

#!/bin/sh
echo Hello
echo World

Então a saída será:

Hello
World

e não:

HelloWorld

---

Dica:

FREQÜENTEMENTE, é exatamente isso que você quer, mas às vezes você quer que o eco não insira essa nova linha automaticamente.

Há uma correção para isso ... bem, com mais precisão, há duas correções para isso.

Primeiro, você precisa estar ciente de que o eco é implementado pela maioria dos shells (como um comando interno do shell) e também pelo sistema operacional (normalmente como /bin/echo). Portanto, o comportamento exato depende de qual shell você está usando, se ele está configurado para usar o eco integrado ou o nativo /bin/echo e, nessa situação, você precisa saber em qual sistema operacional o script está sendo executado e como ele implementa esse recurso.

Algumas implementações usam echo -n message para dizer ao echo para não acrescentar uma nova linha; outros não têm -n, então você tem que usar echo message \c para fazer a mesma coisa. Na maioria das vezes, você vai querer echo -n, mas se você precisa que seu script seja totalmente portátil, você precisa permitir ambos:

#!/bin/sh
echo -n "Enter your name: "
read name
echo "Hello, $name"

---

Dica:

ISSO FUNCIONARÁ EM ALGUNS SISTEMAS E FICARÁ ASSIM:

Digite seu nome: Stevao
Ola stevao

No entanto, em outros sistemas, ficará assim, o que não é ideal:

-n Digite seu nome: Stevao
Ola stevao

Em outros sistemas, você precisa escrever o código assim:

echo "Enter your name: \c"
read name
echo "Hello, $name"

ISSO FORNECERÁ os resultados corretos nesses sistemas, mas poderá fornecer resultados errados em outros sistemas (onde \c não possui nenhum significado especial, será interpretado como um caractere c literal).

Bem, isso é um parto... Aqui está uma solução que funcionará em ambos:

if [ "`echo -n`" = "-n" ]; then
n=""
c="\c"
else
n="-n"
c=""
fi

echo $n "Enter your name: $c"
read name
echo "Hello, $name"

---

Dica:

SE echo -n não fosse interpretado pelo eco, seria exibido apenas o texto literal -n. Em caso afirmativo, $ n é definido como a string vazia e $c é definido como \c.

Neste exemplo, o comando echo $n "Digite seu nome: $c" será analisado como:

echo -n "Enter your name: "

Caso contrário, o echo interpretou -n como um argumento para alterar seu comportamento, portanto, $ n é definido como -n e $c é definido como a cadeia vazia. O comando echo $ n "Digite seu nome: $c" será analisado como:

echo "Enter your name: \c"

DE QUALQUER MANEIRA, O RESULTADO DESEJADO FOI ALCANÇADO.

---

Dica:

SEMPRE EXECUTE A DEPURAÇÃO PARA SCRIPTS LONGOS.

Se você estiver escrevendo scripts bash com milhares de linhas de código, encontrar erros pode se tornar um pesadelo. Para corrigir facilmente as coisas antes de executar um script, execute alguma depuração.

Métodos para ativar o modo de depuração de scripts de shell.

AS OPÇÕES DE DEPURAÇÃO.

As opções principais de depuração do script do shell:

-v (abreviação de detalhado) - informa ao shell para mostrar todas as linhas em um script enquanto elas são lidas, ele ativa o modo detalhado.

-n (abreviação de noexec ou no ecxecution) - instrui o shell a ler todos os comandos, mas não os executa. Esta opção ativa o modo de verificação de sintaxe.

-x (abreviação de xtrace ou rastreio de execução) - informa ao shell para exibir todos os comandos e seus argumentos no terminal enquanto eles são executados.

OBS:
ESTA OPÇÃO (-x) ATIVA O MODO DE RASTREAMENTO DE SHELL.

---

1. MODIFICANDO A PRIMEIRA LINHA DE UM SCRIPT DE SHELL. O primeiro mecanismo é alterando a primeira linha de um script de shell como abaixo, isso permitirá a depuração de todo o script.

#!/bin/sh opção(s)

No formulário acima, a opção pode ser uma ou uma combinação das opções de depuração acima.

2. INVOCANDO O SHELL COM OPÇÕES DE DEPURAÇÃO. A segunda é invocando o shell com opções de depuração da seguinte maneira: esse método também ativará a depuração de todo o script.

shell opções(s) script_nome argumento1 ... argumentoN

Ex:

/bin/bash opções(s) script_nome argumento1 ... argumentoN

3. USANDO O COMANDO INTERNO DO SHELL SET.

O terceiro método é usar o comando interno set para depurar uma determinada seção de um script de shell, como uma função.

Esse mecanismo é importante, pois permite ativar a depuração em qualquer segmento de um script de shell.

Podemos ativar o modo de depuração usando o comando set no formulário abaixo, em que option é uma das opções de depuração.

$ set opção

PARA HABILITAR O MODO DE DEPURAÇÃO, USE:

$ set -option

PARA DESATIVAR O MODO DE DEPURAÇÃO, USE:

$ set + option

ALÉM DISSO, SE TIVERMOS ATIVADO VÁRIOS modos de depuração em diferentes segmentos de um script de shell, podemos desativar todos eles de uma vez da seguinte maneira:

$ set -

É ISSO POR ENQUANTO, COM A ATIVAÇÃO DO MODO DE DEPURAÇÃO DE SCRIPTS DE SHELL. Como vimos, podemos depurar um shell script inteiro ou uma seção específica de um script.

---

Eis um bash shell script que uso no Nautilus

#!/usr/bin/env bash

################################

# um bash script para o Nautilus
# Título: 1a_TOUCH_.sh
# autor: semanickz
# site: https://semanickz.wordpress.com
# uso: clique no arquivo, chame o script
# pelo menu do Nautilus e arquivo tocado
# vai mudar de posição no gerenciador de arquivos
# a ficha caiu, agora vai!
################################

touch "$1"

# fim do script

Um bash shell script para o Nautilus

#!/usr/bin/env bash

######################

# titulo: 1Bb-CV-mp4-2-mkv.sh
# data: 07-05-2020
# bash shell script para o nautilus
# -------------------
# autor: semanickz
# -------------------
# site: https://semanickz.worpress.com
# -------------------
# -------------------
# obs: este script é para o gerenciador de arquivos,
# no meu entender, ele é direcionado a "UM E APENAS UM ARQUIVO EM
# QUESTÃO" neste caso o "$1".
# ele executa o serviço direto no arquivo.
# não aparece terminal nenhum. Você pode escrever
# vários tipos de scripts para um arquivo.
# por exemplo toda vez que encontrar um certo
# tipo de arquivo clica nele e o envia para determinado
# diretório, ou faz o que quiser com ele
# -------------------
# -------------------

######################

# 1 - sobrescreve metadata
exiftool -all= -overwrite_original -ext "$1" .

# 2 - converte para mkv
for f in "$1"; do
ffmpeg -i "$f" -map_metadata -1 -c:v copy -c:a copy -map 0 "${f%.*}.mkv"
done

# 3 - remove mp4
sleep 3

for f in "$1"; do
rm -f "$f"
done

# ---- até aqui para cima, tudo bem.

## 4 ajusta título e sobrescreve metadata # não funcionou para mim
#for f in "$1"; do
#mkvpropedit "$f" -e info -s title="${f::-4}"
#mkvpropedit "$f" --tags all:
#mkvpropedit "$f" -d title
#done

# --- pesquisar pela web...

# ----- alias do meu .bashrc # funcionou no lugar do item ## 4
source MKV3b-remov-metadata-mkv.sh

# fim do script

Bash shell script encerrar processos PID

#!/usr/bin/env bash

# Titulo: kill_proc.sh
# Autor: semanickz
# Versão: 0.0
# Email:
# Site: https://semanickz.wordpress.com/
# Data: 06-05-2020_01:36:25
# Distro: GNU/Linux
# Exemplo de uso:
# Objetivo:
# Variaveis:
# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - notícia, chama a atenção
# bash script para matar processos

clear
read -p "Vamos encerrar um processo. Tecle Enter para continuar : "
echo "Primeiro localizar o número do processo, o PID : "
read -p "Digite o nome do programa : " PROG
echo '--------------------------------'
echo "$PROG - Busca : "
echo '--------------------------------'
pidof "$PROG"
echo '--------------------------------'
echo 'Agora temos o número do PID do processo que queremos encerrar.'
read -p "Tecle o número PID e Enter para encerrar o processo, ou Ctrl+c para sair : " PID
killall "$PROG"
kill -9 "$PID" # mata de vez
kill -15 "$PID" # mais suave

echo "\nPronto. Tudo certo aí?\n"

# fim do script

Bash script tar.xz usando a extensão do arquivo

#!/usr/bin/env bash

#######################

# Titulo: tarxz_pela_extensao.sh
# Autor: semanickz
# Versão: 0.0
# Email:
# Site: https://semanickz.wordpress.com/
# Data: 04-05-2020_04:29:31
# Distro: GNU/Linux
# Exemplo de uso:
# Objetivo:
# Variaveis:
# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - notícia, chama a atenção

#######################

# -------------------------------
## CRIAR ARQUIVO tar.xz A SUA ESCOLHA EM UM DIRETÓRIO com read -p e loop for
# -------------------------------
# QUER DIZER QUE COMPACTA ARQUIVOS PELA EXTENSÃO
# -------------------------------
# Explicando:
# em um diretório com os mais variados tipos de arquivos vai compactar somente
# os que você determinar a extensão.
# -------------------------------
# alias fortarxz='clear ; echo ":Esteja dentro do diretório em questão" ;\
# sleep 3 ; echo "" ; read -p "Digite o nome do arquivo.tar.xz : " NOME ;\
# read -p "digite a extensão do arquivo (Ex: .txt) : " EXT ;\
# echo "Executando : " ; sleep 2 ; echo "" ; tar -cvf "$NOME" *"$EXT" ;\
# echo Listando... ; ls -t | head ; echo'
# -------------------------------

clear

echo ":Esteja dentro do diretório em questão"
sleep 3
echo ""

read -p "Digite o nome do arquivo.tar.xz : " NOME

read -p "digite a extensão do arquivo (Ex: .txt) : " EXT

echo "Executando : "
sleep 2
echo ""

tar -cvf "$NOME" *"$EXT"

echo 'Listando...'
ls -t | head
echo ""

echo ':Feito!'
echo ""

# ---------------- fim do script

lista_conteudo_arquivo_7z.sh

#!/usr/bin/env bash

# Titulo: lista_conteudo_arquivo_7z.sh
# Autor: semanickz
# Versão: 0.0
# Email:
# Site: https://semanickz.worpress.com
# Data: 03-05-2020_23:46:25
# Distro: GNU/Linux
# Exemplo de uso: ./lista_conteudo_arquivo_7z.sh
# Objetivo:
# Variaveis: f
# TODO - indica uma tarefa a ser feita
# FIXME - indica um bug conhecido que precisa ser arrumado
# XXX - notícia, chama a atenção

# ------------------------------

# Você pode criar um alias com este script.

# alias cont7z='clear ; echo -e "\nListar conteúdo de arquivo 7z: \n" ; sleep 3 ; echo Local: ; pwd ; sleep 2 ; echo "" ; echo :Lista... ; ls -t | head ; sleep 2 ; echo "" ; read -p "Digite o nome com extensão do arquivo 7z : " CONT ; echo :Listando-Cont-7z: ; sleep 2 ; echo ; 7z l "$CONT" ; echo'

# ------------------------------

clear

echo -e "\nObjetivo: listar conteúdo de arquivo 7z: \n"
sleep 3

echo Local:
pwd
sleep 2

echo ""

echo :Lista...
ls -t | head
sleep 2

echo ""
read -p "Digite o nome com extensão do arquivo 7z : " CONT

echo :Listando-Cont-7z:
sleep 2

echo ""
7z l "$CONT"
echo ""

# fim do script

Linux grep dicas e truques para o dia a dia

GNU/Linux grep dicas e truques

---

Realmente depois de um tempo, o usuário Linux precisa muito do grep. Ele(a) tem anos de arquivos em backup, na nuvem, em HDs, anotados em dezenas de espécies de arquivos e diretórios diferentes que são mil, dois, três mil arquivos (pessoais), 800, 1000, 2000 scripts, 4, 8, 12, 60 mil linhas de código, 2000 aliases (alguns enormes) e mais trabalho chegando todo dia. Novas idéias que combinam bem com um trecho de código escrito 3 anos atrás e só se lembra de um pedacinho dele... Affff maria! Aí vem o grep para lhe salvar da mais profunda insanidade, porque quando tudo está lindo e fluindo bem, o ser humano sem querer tende a se perder na selva de coisas que criou. Fomos feitos para isto. Isto é tão normal.

---

SINTAXE DE COMANDO GREP:

1) grep 'palavra' nome_do_arquivo

2) grep 'string1 string2' nome_do_arquivo

3) cat outro_arquivo | grep 'algo'

4) comando | grep 'algo'

5) comando opção1 | grep 'informação'

6) grep --color 'info' nome_do_arquivo

---

Encontrando comandos em seu histórico. A maioria dos usuários fará algo assim:

history |grep

---

Conte e exiba os comandos mais usados em seu histórico.

history | awk 'BEGIN {FS="[ \t]+|\\|"} {print $3}' | sort | uniq

---

O primeiro desses truques permite criar uma lista de arquivos que contenham qualquer sequência que você esteja procurando.
Ele usa a opção -l (lista apenas os nomes dos arquivos, não o conteúdo correspondente) mais a opção -r para repetir através de subdiretórios.
Isso pode ajudá-lo a encontrar arquivos que você pode estar procurando, sem distraí-lo com todos os motivos pelos quais determinados arquivos corresponderam aos seus critérios de pesquisa.

Exemplo:

grep -rl "string que quer encontrar" *

---

Outro truque útil do grep no Linux permite que você especifique uma expressão regular Perl no seu termo de pesquisa. Neste exemplo, podemos dar ao grep uma expressão que permita que ele corresponda a várias seqüências de caracteres, como egrep. Pode ficar muito mais complicado que os exemplos mostrados, mas aqui está a sintaxe básica:

grep -P "enquanto|para" *

grep -P 'foto\.gif' *

---

Você também pode combinar o grep com os comandos find para obter algumas extrações úteis de texto dos arquivos de destino.

find . -name "*.r" -exec grep "rho" '{}' \; -print

---

Obviamente, um dos truques grep mais úteis que encontrei até agora é o que fornece algum contexto junto com a sua descoberta. Em vez de exibir apenas as linhas que contêm o texto específico que você estava procurando, você pode imprimir as linhas que aparecem antes e depois das linhas correspondentes - geralmente necessárias para determinar se "correspondência" é realmente o que você está procurando.

Você pode especificar quantas linhas deseja ver antes da sequência correspondente com a opção "B" (para "antes") e o número de linhas após a correspondência com a opção "A" (para "depois").

grep -B 2 -A 2 echo *

---

Usar grep para buscar arquivo?

grep boo /etc/passwd

grep -i "boo" /etc/passwd

---

Usar grep recursivamente?

grep -r "192.168.1.5" /etc/

---

Usar grep para buscar apenas palavras?

Quando você pesquisa boo, o grep corresponde a fooboo, boo123 etc. Você pode forçar o grep a selecionar apenas as linhas que contêm correspondências que formam palavras inteiras, ou seja, correspondem apenas à palavra boo:

grep -w "boo" /caminho/para/arquivo

---

Contar a linha quando as palavras forem correspondidas? O grep pode relatar o número de vezes que o padrão foi correspondido para cada arquivo usando a opção -c (count):

grep -c 'muu' /caminho/para/arquivo

Observe também que você pode usar a opção -n, que faz com que o grep preceda cada linha de saída com o número da linha no arquivo de texto do qual foi obtida:

grep -n 'foo' /caminho/para/arquivo

---

Grep partida invertida? Você pode usar a opção -v para imprimir inverte a correspondência; isto é, corresponde apenas às linhas que não contêm a palavra especificada. Por exemplo, imprima todas as linhas que não contêm a barra de palavras:

grep -v bar /caminho/para/arquivo

---

Pipes Linux e comando grep? Comando grep é frequentemente usado com pipes. Por exemplo, imprimir o nome dos dispositivos de disco rígido:

dmesg | egrep '(s|h)d[a-z]'

---

Modelo nome da cpu:

cat /proc/cpuinfo | grep -i 'Model'

---

O comando acima pode ser usado sem o shell pipe:

grep -i 'Model' /proc/cpuinfo

---

Como faço para listar apenas os nomes dos arquivos correspondentes? Use a opção -l para listar o nome do arquivo cujo conteúdo mencione main ():

grep -l 'main' *.c

Finally, you can force grep to display output in colors:

grep --color vivek /etc/passwd

---

Grep é usado principalmente para filtrar a saída de um comando para restringir o que o usuário está procurando.

grep "dark" rgb.txt

---

Encontre uma instância de uma palavra com um número depois dela.

ls | grep "ppm[0-9]"

---

Exclua todos os arquivos mkv em um diretório usando grep e xargs. Você deve ter cuidado com este comando, isso não solicitará antes de excluir arquivos.

ls | grep "mkv" | xargs rm

---

Como retornar os nomes dos arquivos que não contêm uma determinada sequência de pesquisa.

grep -L "linux" *.txt

---

Imprima uma lista alfabética classificada de todos os arquivos que correspondem a uma determinada string ou palavra.

ls | grep by | sort | uniq -c | sort -n

---

Contar a quantidade de arquivos com um certo nome:

ls | grep log | wc -l

---

Bash shell script tar.xz que compacta, descompacta, divide e junta arquivos

#!/usr/bin/env bash

######################

# autor: semanickz
# email:
# test_comp_desc_split_join_tarxz.sh
# data 03-05-2020
# site: https://semanickz.wordpress.com

######################

clear

# ----------------------------------

echo -e "\n*** Abra o terminal onde está o arquivo a ser\
compactado. *** \n\nOBS: Para sair deste script tecle Ctrl+c"
sleep 2
echo ""

echo Local:
pwd
sleep 2
echo ""

echo -e "\n1- Confere os primeiros arquivos deste diretório... \n"
ls -t | head -15
sleep 2
echo ""

# -----------------------------------

echo ""

echo -e "\nOfereço 4 opções (serviços) tar.xz.\
Escolha um número e tecle Enter.\n"
sleep 3

echo -e "\n: Para compactar tecle 1 \n: Descompactar tecle 2 \n: Para dividir\
um arquivo compactado grande em pedaços de 1GB tecle 3 \n: Para juntar um\
arquivo dividido tecle 4 \n: Para sair tecle Ctrl+c : \n"
read INPUT

case $INPUT in
1)
echo -e "\nCompactando tar.xz :\n"
sleep 2
echo -e "Você digitou: $INPUT, compactando...\n"
echo :Listando...
ls -t | head -20
read -p "Digite o titulo do arquivo tar.xz. Ex.\
meu_arquivo.tar.xz : " FILE
echo -e "\nVocê digitou: $FILE\n"
sleep 2
echo ""
read -p "Digite o nome completo (com espaços entre eles)\
do(s) arquiv(os)/past(as) a ser(em) compactados : " ARQUIVOS
echo -e "\nVocê digitou: $ARQUIVOS\n"
echo :Listando...
ls -t | head -15
sleep 2
echo ""
sleep 2
tar -cJf "$FILE" "$ARQUIVOS"
echo -e "\nFeito! \n"
echo Confere:
ls -t | head
;;
2)
echo -e "\nDescompactando tar.xz\n"
sleep 2
echo -e "Você digitou: $INPUT\n"
echo :Listando
ls -t | head
sleep 2
read -p "Digite o nome do arquivo tar.xz. : " FILE
echo -e "\nVocê digitou: $FILE\n"
echo :Listando...
ls -t | head -20
sleep 2
echo ""
sleep 2
echo "\nExecutando...\n"
sleep 2
tar -xf "$FILE"
echo -e "\nFeito! \n"
echo Confere:
ls -t | head
;;
3)
echo -e "\nDividindo arquivo tar.xz"
sleep 2
echo -e "\nVocê digitou $INPUT\n"
echo :Listando...
echo ""
ls -t | head
read -p "Digite o nome do arquivo tar.xz. : " FILE
echo -e "\nVocê digitou: $FILE\n"
sleep 2
split -b 1024m "$FILE" "$FILE".part
echo -e "\nFeito! \n"
echo Confere:
ls -t | head
;;
4)
echo -e "\nJuntando arquivos tar.xz\n"
sleep 2
echo -e "Você teclou : $INPUT; juntando...\n"
ls -t | head
read -p "Digite o nome do arquivo SEM a ext .part : " FILE
echo -e "\nVocê digitou: $FILE\n"
sleep 2
echo Local:
pwd
sleep 2
cat "$FILE".parta* >backup.tar.xz.completo
echo -e "\nFeito! \n"
echo Confere:
ls -t | head
;;
*)
echo "\nEu só sei 1, 2, 3 e 4. Tente novamente,\
ou tecle Ctrl+c para sair.\n"
esac

# --------------------------- fim do script

Bash shell script – Juntar arquivos .zip

#!/usr/bin/env bash

#########################

# test_juntar_arquivos_zip.sh
# data: 02052020

#########################

clear

# --------------------------- #

echo Listando...
ls -t | head
echo
echo Local:
pwd
echo

# --------------------------- #

read -p "Juntar arquivos zip? Tecle Enter : "
echo

# --------------------------- #

echo "Digite o nome do arquivo SEM ext .part : "
read ARQUIVO
echo -e "\nPara juntar arquivos zip divididos tecle 1 (um). Para sair tecle 2 : \n"
while :
do
read INPUT
case $INPUT in
1)
echo -e "\nVocê teclou : $INPUT\n"
cat "$ARQUIVO".parta* >backup.zip.completo
break
;;
2)
echo -e "\nVocê teclou : $INPUT\n"
echo -e "\nSaindoooo...\n"
sleep 2
echo -e "\n\e[1;33;40m*** E tá tudo resolvido! ***\e[0m\n"
sleep 2
exit
;;
esac
done

# --------------------------- #

exit 0

# --------------------------- #

# zip -r nome_do_file.zip arquivo1 folder1

# fim do script

Bash shell script grep encontre duas palavras

#!/usr/bin/env bash

######################

# test_encontre_a_palavra.sh
# 02052020

######################

clear

echo Abra-no-Diretório-onde-está-o-arquivo.
echo Para-recomeçar-digite-Ctrl+c
echo

echo Local:
pwd

echo
echo Lista:
ls -tCF | head -25

echo
echo "Digite o arquivo em que procura a palavra : "
read filename

echo
echo "Digite a palavra que quer encontrar : "
read word

echo
cat $filename | grep "$word"
echo

echo Local:
pwd
echo

echo "Digite o caminho para buscar em todo o diretório : "
read dot

echo
grep -r -w "$word" "$dot" | less
echo

echo -----------------------------
echo
sleep 2

echo "Procura por duas palavras diferentes? Digite a primeira : "
read pri
echo
echo "Digite a segunda : "
read seg

echo Lista:
ls -tCF | head

echo
echo "Digite o arquivo em que procura a palavra : "
read mfile

grep -E -w "$pri|$seg" "$mfile"

# fim do script

Bash script que busca palavras num texto

#!/bin/bash

##########################

# test_grepbuscarpalavra.sh
# data: 01052020

##########################

clear

# informa executando variáveis dentro do echo
echo -e "\nVocê está em : $(pwd)\n"

# listar
/bin/ls -t | head -20

# verifica se o diretório existe
if [[ -d $PATH ]] ; then
echo ""
echo "Saiba que o diretório existe."
fi

# busca com grep verifica a existência do arquivo
read -p "Digite o nome do arquivo : " filename

if [[ -f $filename ]] ; then
echo "O $filename existe."
read -p "Digite a palavra que busca: " word
grep "$word" "$filename"
else
echo "O $filename não existe."
fi

# fim do script

Bash shell script: zip e unzip

#!/usr/bin/env bash

#########################################

# test_compactar_e_desc_zip.sh

# data: 01052020

#########################################

clear

# -------------------------------------------

echo -e "\n*** Abra o terminal onde está o arquivo a ser compactado. *** \n\nOBS: Para sair deste script tecle Ctrl+c"

sleep 2

# -------------------------------------------

echo ""

echo -e "\nConfere os primeiros arquivos deste diretório... \n"

ls -t | head -15

echo ""

read -p "Digite o titulo do arquivo zip a ser criado.\
Ex. meu_arquivo.zip : " FILE # armazena URL

echo -e "Você digitou: $FILE" # imprime a FILE

echo -e "\n1- Confere os primeiros arquivos deste diretório... \n"

ls -tCF | head -21

echo ""

read -p "Digite titulo completo (com espaços entre eles)\
dos arquiv(os)/past(as) a ser(em) compactados : " ARQUIVOS

echo -e "Você digitou: $ARQUIVOS"

# -------------------------------------------

echo -e "\n\e[1mPara compactar em zip digite um (1),\
descompactar digite dois (2)\e[0m\n"

while : # loop while
do # fechamento de do é done
read DIGITE # armazena digito 1 ou 2
case $DIGITE in # caso o digito seja...
# fechamento de case é esac

# --------------------------------------- #

1) # dígito 1 executa...

echo -e "Você digitou: $DIGITE, compactando... "

zip -r "$FILE" "$ARQUIVOS"

break # sai após executar comando
;;

# --------------------------------------- #

2) # dígito 2 executa...
echo -e "Você digitou $DIGITE, descompactando... "

unzip "$FILE" # comando 2

break # sai após executar comando
;;

# --------------------------------------- #

*)
echo -e "Desculpe eu só entendo 1 e 2." # se não for nem 1 nem 2...

;;
esac # fechamento de case e sai

# --------------------------------------- #

done # fechamento de do e acabou

# --------------------------------------- #

echo ""

echo -e "\n:2- Confere a lista de arquivos:\n"

sleep 2

ls -tCF | head -15

# --------------------------------------- #

echo ""

read -p "Para deletar o arquivo original Tecle Enter.\
Para sair sem deletar tecle Ctrl+c."

echo ""

ls -tCF | head

echo ""

read -p "Certeza mesmo? Ok, tecle Enter : "

rm -f "$FILE"

# --------------------------------------- #

echo -e "\n:3- Confere a lista de arquivos:\n"

sleep 2

ls -tCF | head -15

# --------------------------------------- #

echo -e "\n\e[1;33;40m*** E tá tudo resolvido! ***\e[0m\n" # mensagem final

# --------------------------------------- #

# zip -r nome_do_file.zip arquivo1 folder1

# fim do script

Linux execução do bash shell script

Linux Execução do Bash Shell no Shell e no Bash shell script

Execução do Shell - Se você deseja usar a saída de uma execução do shell dentro de uma string, pode fazê-lo com um cifrão seguido de parênteses.

($ ())

Por exemplo, o comando whoami imprimirá seu usuário atual. Para usá-lo em uma cadeia, envolva whoami na sintaxe de execução do shell. Digito no terminal:

---

echo "Olá, $(whoami)!"

Resultado:

Olá ArceuValenti!

---

echo "Aqui é $(pwd)"

---

echo "Listando os mais novos primeiro : $(ls -t | head)"

echo -e "\nListando os mais novos primeiro :\n\n$(ls -t | head)\n"

---

Aprenda esta po**a de uma vez cac*t* do c*r*io!!!

---

Veja este caso abaixo digito no terminal:

VAR="O local é : $(pwd) - Listando... $(ls -t | head)"

---

A variável VAR que possui dois comandos de execução em si, está armazenada na seção deste terminal onde estou. Quero executar esta variável VAR! Tento:

---

echo "$(VAR)" # Parece seguro, mas... Não funciona!

echo $(VAR) # Parece inseguro e... Também não funciona!

echo $VAR # Funciona, mas me sinto jogado aos lobos.

echo ${VAR} # Funciona, mas me sinto jogado as hienas.

echo "${VAR}" # Funciona direito e me sinto seguro como um neném seio materno!

---

Agora imagine que poderia colocar dezenas de comandos e códigos negros como a noite coletados na web numa variável, criar outras mais com mais comandos dentro delas e executar tudo de uma vez só com um objetivo específico cheio de vigor e amor/ódio numa rede, num arquivo em nuvem... Enviar de alguma forma para alguma coisa/alguém... Nem pensar! Um simples link num comentário te leva a estes cógigos negativos. Tenha atenção e cuidado.

---

Continuando...

Entrada do usuário? Declaramos uma variável no último exemplo, mas também podemos fazer com que o usuário defina o valor de uma variável dinamicamente. Por exemplo, em vez de apenas fazer com que o script diga Olá, Mundo !, podemos fazer com que ele solicite o nome da pessoa que está chamando o script e, então, produza esse nome. Faremos isso usando o comando read.

---

Eu crio estas variáveis abaixo:

ddd='Quem ser você?'
eee='Arceu Valenti'
fff='Olá! Como vai'
ggg='Ora, eu sô'
hhh='Colé o pobrema?'

---

Digito no terminal:

clear ; ddd='Quem ser você?' ; eee='Arceu Valenti' ; fff='Olá! Como vai' ; ggg='Ora, eu sô' ; hhh='Colé o pobrema?' ; echo "$ddd" ; echo ; sleep 2 ; echo "$ggg $eee $hhh" ; sleep 2 ; echo ; echo "$fff seu $eee!" ; sleep 2 ; echo ; echo "Senhor $eee?" ; sleep 2 ; echo ; echo "$hhh" ; sleep 2 ; echo

---

Resultado:

~:$ clear ; ddd='Quem ser você?' ; eee='Arceu Valenti' ; fff='Olá! Como vai' ; ggg='Ora, eu sô' ; hhh='Colé o pobrema?' ; echo "$ddd" ; echo ; sleep 2 ; echo "$ggg $eee $hhh" ; sleep 2 ; echo ; echo "$fff

Quem ser você?

Ora, eu sô Arceu Valenti Colé o pobrema?

Olá! Como vai seu Arceu Valenti!

Senhor Arceu Valenti?

Colé o pobrema?

~:$

---

No script abaixo o usuário que dá o nome quando executa o script:

#!/usr/bin/env bash

#############

# qservc.sh

#############

echo 'Quem ser você?'

read quem

echo "Olá! Como vai $quem!"

---

Assim:

$ ./qservc.sh

$ Arceu

$ Olá! como vai Arceu!

---

Por isto que os nerds Linux são paranóicos com tudo. Compreendeu? Não? Nem eu!

---

Até Breve!

---