# Exemplos para sistemas unix-like, comandos para shell e shell-script

# OUTRO LUGAR PARA PROCURAR:
# http://ldp.rtin.bz/LDP/abs/html/abs-guide.html
# Aos iniciantes: "$ " no inicio de linha representa o prompt do shell
# acentuação de palavras neste texto: pode existir ou nao

Listando arquivos de várias extensões
################
ls -l *.{mp3,avi,AVI,mpg}


Atributos adicionais de arquivo
############
#imutável, nem root pode apagar
chattr +i file
#listando atributos:
$ lsattr file
----i-------- file
#desfazendo:
chattr -i file
# permitindo apenas append:
chattr +a file
#desfazendo:
chattr -a file
#mais detalhes:
man chattr


Gerando barra de Progresso
##########################
#só com shell:
t=0;echo -n " 0 ";while [ $t -lt 100 ];do t=$[t+1];\
echo -ne "\e[${#t}D#$t";sleep 1;done
#idem:
t=0;echo -en "                                                  100\r 0 ";\
while [ $t -lt 100 ];do t=$[t+1];[ $[ $t%2 ] -eq 0 ]&&\
echo -ne "\e[${#t}D#$t";sleep 1;done;echo
#+1:
t=0;while [ $t -lt 100 ];do echo -ne "\r  0";x=0;while [ $x -lt 100 ];do \
[ $[$x%2] -eq 0 ]&& { echo -ne "\e[7m";[ $x -gt $t ] &&echo -en "\e[0m";\
echo -n " ";};x=$[x+1];done;echo -n 100%;sleep 1;t=$[t+1];done;echo
#com dialog:
t=0;while [ $t -lt 100 ];do t=$[t+1];echo $t;sleep .3;done\
|dialog --gauge "Barra de Progresso com dialog" 10 72


Passando arquivo para stdout no bash, sem o cat
######################
$ echo "$(<arquivo)"


#Aguardando conclusão de carga de programa
#########################
while [ $(ps o stat --pid $PID --no-headers) != "S" ]; do read -t 1;done


Visualizando caracteres nao imprimiveis,controle,hexa
###################
#puro shell:
showctrl(){ V='\e[33;41;1m';P='\e[0;m'
while read l;do
 l="$l${V}n$P" # n newline \n 0x0A
 l=${l//$'\t'/${V}t${P}} # t tab \t 0x09
 l=${l//$'\x07'/${V}BELL${P}} # BELL \a ^G 0x07
 l=${l//$'\x15'/${V}^U${P}} # ^U 0x15
 l=${l//$'\x1b'/${V}e${P}} # e Esc \e 0x1b
echo -e "$l";done;}
#usando a função:
$ showctrl <arquivo
$ grep "trecho alvo" arquivo|showctrl
#com o cat
cat -A arquivo
# com editor
vi arquivo # no editor => :set list
#observando tudo:
grep "trecho da linha" arquivo|xxd
#com editor:
hexedit arquivo # estilo do pico/nano
#ou
elvis arquivo # no editor => ^Wd


#Testando script em variantes de shell
################
for SH in bash zsh ksh tcsh;do echo $SH:;$SH script;done


Trafegando por redes publicas com segurança
####################
ssh fulano@sua.maquina.remota -p 2222 # fazendo acesso remoto
# fazendo um tunel criptográfico entre o terminal em uso e sua máquina de
# confiança para acessar uma terceira, neste exemplo, um servidor pop
ssh -l fulano -L 110:servidor.pop:110 sua.maquina.remota 


Vendo na maquina local "L" o relógio da máquina remota "R" :
##########################
xhost +R; ssh R xclock -display L:0.0


tail -f só adimite um pipe
###################
#vá retirando pipes e confirme:
tail -f arquivo|cut -c1-9|cut -c1-7|cut -c1-5|cut -c1-3
#com auxílio do read use pipes à vontade:
tail -f arquivo|while read L;do
 echo "$L"|cut -c1-9|cut -c1-7|cut -c1-5|cut -c1-3
done


#Tratando logs "ao vivo" com o shell
###############################
# Experimento:
#primeiro comande em um term ou xterm
echo xxxx >>/tmp/a
# Em outro term ou xterm digite:
tail -f /tmp/a|while read x;\
do "${x:0:3}" == IP= ]&&echo -ne '\a';echo $x;done
#continue dando echo no term1; quando o echo for IP=.... o beep devera soar


Cada linha de uma cor
#########################
tail -f /var/log/messages |while read line; do
 if [ "$var" -eq 0 ]; then echo -e "\033[40;33m $line \033[m";var=1
 else echo -e "\033[40;36m $line \033[m";var=0;
 fi
done


Verificando subdiretórios que mais consomem espaço do disco
#####################
du -s .[A-z]* /usr/* | sort -n




Resto de uma divisão
####################
$ echo $[7 % 3] $[8 % 3] $[9 % 3]
1 2 0


Números randômicos em intervalo definível
#############################################
min=0;max=100;echo $[($max+1-$min)*$RANDOM/32768+$min]
# A quantidade de possibilidades não poderá ser a mesma para todos os
#números, pois a divisão do número de valores possíveis de $RANDOM pelo 
#número de itens do universo desejado não é um inteiro, lembrando que 
#zero é um elemento como outro qualquer. De 0 a 100 há 101 elementos:
echo 'scale=6;32768/101'|bc 
324.435643
# Verificando número de possibilidades para 3 pontos da faixa de saída:
# faixa $RANDOM  =>  result  possib
#    0 ...   324 =>    0      325
#16222 ... 16546 =>   50      325
#32444 ... 32767 =>  100      324
#Já se o divisor fosse uma potência de 2, essa diferença não ocorreria. De
#qualquer forma o gerador de $RANDOM pode ser mais tendencioso que isso
#outra opção:
min=36;max=78;echo $(($RANDOM % $((max-min+1)) + $min))
#para brincar:
hwclock|cut -c34-35
#mais uma idéia:
date +%N|cut -c2-6
#com intervalo:
rand(){ echo "`date +%N|cut -c1-6`*($2-$1+1)/999999 +$1"|bc;}
$ rand 15 78
30
#Script para testes: /sh/probab


Strings/números randômicos,aleatório,randomico,imprevisível
###################
#Listando dispositivos disponíveis:
ls -l /dev/*rand*
#gerando arquivo com conteúdo randômico de 128 bits a partir de /dev/urandom:
head -c $[128/8] /dev/urandom >file.rnd
#valor hexa de 512 bytes aleatórios:
head -c 512 /dev/urandom| xxd -p | tr -d "\n";echo
#numero decimal randômico de comprimento 6:
echo "ibase=16;obase=A;`head -c 16 /dev/urandom\
|xxd -p|tr 'a-f' 'A-F'|tr -d \\n`"|bc|cut -c1-6
#outra opção, aleatoriedade decimal de comprimento 9:
head -c 32 /dev/urandom|xxd -p|tr -d \\nabcdef|cut -c1-9


Apendando algo em todos os arquivos de nome arq01, arq02, arq03 ...
################
for f in arq??; do echo ======= >> $f;done


Data de arquivos,datas de arquivo
#################################
stat arquivo # todas as informações sobre o arquivo
stat -c %x arquivo # ultimo acesso
stat -c %X arquivo # ultimo acesso em segundos desde Época (1970)
stat -c %y arquivo # ultima modificação
stat -c %z arquivo # ultima mudança
ou
date --reference=arquivo # última modificação
ou
ls --full-time arquivo # último acesso
ou
echo `find arquivo -printf %Td/%Tm/%TY` # data da últ modificação
echo `find arquivo -printf %Cd/%Cm/%CY` # data da últ modificação de status
echo `find arquivo -printf %Ad/%Am/%AY` # data do últ acesso


Listando os arquivos do dia
##########################
find /tmp -type f -mtime -1 -exec ls -l {} \;


Achando arquivos de determinado usuario/dia/hora
################################
#ordenado por hora graças ao sort -k, último mais recente -r
ls -lR /home 2>/dev/null|grep ' Jun 10 '|grep 'bat nogroup'\
|tr -s \ |sort -k6 -r
#ou
ls --full-time -R /home 2>/dev/null|grep ' bat nogroup '|\
grep ' 2005-06-10 ' |tr -s \ |sort -k6 -r


Inibindo tecla <Enter> em um script:
##############################
stty igncr # ignore carriage return, ou melhor new line (Enter do teclado)
stty -igncr # para reabilitar o Enter
#Testando o 'igncr' no terminal:
$ stty igncr;read -t8 -p'tecla Enter em 8 segundos...';stty -igncr;echo
#Confirmando que a tecla Enter emite New Line:
$ read -d = x 
# Em seguida pressione as teclas 1 2 Enter Enter 3 4 = 
# Ao voltar o promp:
$ echo -n "$x" |xxd
0000000: 3132 0a0a 3334                           12..34
#Ou seja, com a tecla Enter obteve-se '\n', isto é, new line
#Para confirmar:
y=$'12\n\n34'
$ echo -n "$y" |xxd
0000000: 3132 0a0a 3334                           12..34
# Ou seja, exatamente o mesmo resultado obtido com o teclado


Eliminando CARRIAGE RETURN de variável
#######################
$ STREAM=$'MSDOSline PROTOS: HTTP SMTP POP3\r\n'
$ read x < <(echo $STREAM)
$ echo "^x=${x}Z"
Zx=MSDOSline PROTOS: HTTP SMTP POP3
#Eis o problema: o ultimo char de x é '\r'
#Solucao:
$ { read -d$'\r' x ; read ;}< <(echo $STREAM)
$ echo "^x=${x}Z"
^x=MSDOSline PROTOS: HTTP SMTP POP3Z
#Solucao:
$ read x < <(echo $STREAM) ; x=${x%?}
$ echo "^x=${x}Z"
^x=MSDOSline PROTOS: HTTP SMTP POP3Z


Usando o echo para limpar/filtrar variáveis
#######################
#Entendendo primeiro um exemplo bem simples:
$ x=0123456789abcdefghij;IFS=25d7;echo $x
01 34 6 89abc efghij
# Dando valor à variável para teste:
$ VAR=`echo -ne "A\x20B\x09C\x0a   D\x0dE"`
$ echo -n "$VAR"|xxd
0000000: 4120 4209 430a 2020 2044 0d45
# Valor default do IFS:
$ echo -n "$IFS"|xxd
0000000: 2009 0a
$ echo "$VAR"
A B     C
E  D
$ echo $VAR 
E B C D    (vide efeito do \r sobrescrevendo a letra A com a letra E)
	# Agora, exemplo fazendo o IFS igual ao valor abaixo,
	# espaço, <TAB>, carriage return, line feed e a letra "C"
	# sao convertidos para espaço
$ IFS=`echo -ne "\x20\x09C\x0a\x0d"`
$ echo -n "$IFS"|xxd
0000000: 2009 430a 0d
$ echo "$VAR"
A B     C
E  D
$ echo $VAR
A B D E   (sumiu o CR e seu efeito, além da letra C, como previsto)


Quem está conectado ao seu computador, sem usar "netstat -na"
####################
cat /proc/net/tcp
Vide mais com:
ls -l /proc/net


Alternando escrita entre negrito e standard
#############################
B=$'\e[0;1m';S=$'\e[0;0m';echo UUU ${B}UUU ${S}UUU ${B}UUU ${S}UUU


Registrando diferença nos arquivos de 2 diretórios:
#################
diff -ur dir1 dir2 > mydiffs.patch


Atribuindo alguns valores especiais a variáveis
#############
TAB=$'\t'
NL=$'\n'
CR=$'\r'


A marca de fim de leitura automatizando comandos
#########################
# com cat, com ftp, etc., exemplo:
ftp -n IP <<EOT
user anonymous eu@subdom.dom
cd /pub
get file.txt
bye
EOT


Verificando status com pipes ($?)
#####################
$ ls -ld * |grep usuarioX;echo ${PIPESTATUS[@]}
0 1
# resumindo, o comando ls foi bem sucedido, mas o grep não
# ou echo ${PIPESTATUS[*]}


# Procurando por qualquer porta aberta,segurança
#################
#Como root:
nmap -sS -p 0-65535 IP
#Informações sobre a porta:
fuser -av num_porta/tcp
#Verificando especificamente a porta do X:
nmap localhost -p 6000


FORK BOMB, CUIDADO!!!
###############################
A função, chama a si mesma (recursividade) com um pipe para ela própria
em background. A utilização da máquina vai crescer exponencialmente até 
estourar o limite de processos, provavelmente deixando a máquina inutilizável.
NÃO execute em máquina de produção, principalmente se ela não estiver
configurada para limitar número de processos por usuário.
Eis o "pequeno" monstro:
:() { :|:&};:    # CUIDADO!
Uma função de nome ":", o mesmo do builtin "true", que tem o apelido ":", é
criada. Funções têm precedência total sobre tudo. Ela poderia ter outro nome 
qualquer, . = , ? ou algo mais tradicional, mas daí o efeito fica mais à vista:
foo() {
foo | foo &
}
foo
--ou
funcao() { funcao | funcao& ;} ; funcao
Uma forma de tentar limitar o efeito dessa chamada seria utilizar, por exemplo,
ulimit -u 300


Executando trecho do /path/script como outro usuário
#####################
... comandos ...
if [ "`whoami`" == web ]
then
 #get_S
 /usr/bin/lynx -source $Path>$arq
 chmod +x $arq
 #get_E
else
 echo senha do usuário \"web\" para obter último arquivo NVidia via http
 su web -c \
 "`grep -m 1 -A 99 "#get_S" /path/script | grep -m 1 -B 99 "#get_E"`"
fi
 ... + comandos ...


Encerrando todos os processos de determinado programa
###########################
killall -HUP java # encerra todos os processos desse programa
ou
killall -9 java # mata "brutalmente" todos os processos
ou
pkill java # talvez também resolva


resposta automática para o read
###############################
L=;read L< <(echo yes);echo $L


Mostrando apenas palavras que casam com uma substring
######################
IFS=' ;.,:()!?/=+-#
'
Linha="Teste#1234:procurando 7779 eventos, ocorridos em 48 arquivos diversos"
alvo=nt
for palavra in $Linha;do echo $palavra | grep $alvo;done


Binário: lendo com o read do shell Bash e escrevendo integralmente:
#######################################
# A solução é mais lenta que um "cat $file", mas pode ter timeout
TMOUT=20
rm fileout
write(){ REPLY=${REPLY//\\/\\x5c}
echo -ne "${REPLY//`echo -ne '\x7f'`/\\x7f}$2">>$1;}
while read -r -d "`echo -ne '\x00'`";do
 write fileout "\x00"
done<filein # ou file descriptor, sua principal utilidade (socket tcp/ip)
write fileout
# se funcionar corretamente, conteudo de fileout deve ser igual a filein


Escrevendo todos os caracteres ASCII:
############################
file=xxxx
base='0 1 2 3 4 5 6 7 8 9 a b c d e f'
rm $file
for p in $base;do
 for s in $base;do
  echo -ne "\x$p$s">>$file
 done
done


Determinando último dia de um mes:
###########################
ud(){ ano=2005
 m=$1;ud=312831303130313130313031
 ud=${ud:$(($m*2-2)):2}
 [ $ud -eq 28 ]&&{ [ "$ano" ]||{ echo ano=$ano;return 1;}
  [ $(($(($ano/4))*4)) -eq $ano ]&&ud=29 # bissexto
 };echo -n $ud;}


Determinando o driver de CD e a localização
###################
dmesg | grep CD
e
ls -lR /dev/*rom*


Listando arquivos com permissão de execução
################
find . -type f -perm +111


Listando usuários com id acima 1000:
###############################
egrep :[0-9]{4}: /etc/passwd
ou
awk -F: '$3 > 999 {print $0}' /etc/passwd
ou
awk -F ':' '$3 >= 1000 {print $3}' /etc/passwd
ou
for i in "$(awk -F: '$3 > 999 {print $0}'/etc/passwd)"
do echo -e "$i\n"
done
ou
cut -d : -f 3 /etc/passwd | grep -E '^[0-9]{4,}$'
ou
cut -f3 -d: /etc/passwd | xargs -i bash -c "[ {} -gt 1000 ] && echo {}"
ou
find /home/ -type d -maxdepth 1|xargs stat --format=%u|grep -Eo '^[0-9]{4,}$'
ou talvez:
getent passwd | cut -d: -f1,3 | sort -t: -k 2 -n


Detetando arquivos não nulos (tamanho maior que 0)
####################
[ -s F ]&&echo arquivo F existe e seu tamanho nao é nulo
Ou, listando os não nulos:
for F in *; do [ -s $F ] && echo $F; done



Removendo arquivos com tamanho nulo:
######################
find /dir -size 0 -name *.ext | xargs rm -f


CDs de audio e Linux
###############
gerando imagem de CD no HD:
$ dd if=/dev/cdrom of=/caminho/imagem/ISO/arquivo.iso
=
criando CD a partir de uma imagem ISO:
$ cdrecord -v -dev=0,0,0 -data speed=16 /caminho/imagem/ISO/arquivo.iso
=
gerando arquivos WAV a partir de CD:
$ cdparanoia -B
arquivos tipo "track??.cdda.wav" serão gerados
=
gerando CD a partir de arquivos WAV:
$ cdrecord -v -dev=0,0,0 -pad -dao -audio *.wav


Sinonimo de true = :
#####################
while :;do read -p 1- -t 2 ;done


Executando tarefas por etapas
#########################
na agenda do crond:
00 20 * * * /caminho/do/programa
30 07 * * * /usr/bin/killall -HUP programa
assim o programa, ciclicamente,  iniciará às 20h e às 07:30 será morto


Mantendo uma variável após um pipe
###########################
unset i
while read line
do
# Com let não precisa inicializar variável (i=0)
# "let i++" ou "((i++))"
let i++
echo -n $i
done < <(seq 10)
echo -e "\nfim $i"


Verificando se uma variável é numerica
#########################
a=12a34;[ "$a" == "${a//[^0-9]}" ]&&echo so num
#ou
$ VAR='7';[[ ${VAR:0:1} = [0-9] ]]&&echo ok num


Obtendo o valor hexadecimal de uma string
#########################
echo -n "123"|od -h
ou
echo -n "123"|xxd


Verificando o nivel do shell, sub-shell
################
echo $SHLVL


Alterando a montagem de linhas
################
seq 3 2 15|paste -s
3       5       7       9       11      13      15
o delimitador default é o <TAB>, a opção -d permite especificar outro:
seq 3 2 15|paste -s -d ' '
3 5 7 9 11 13 15
ou
seq 3 2 15|paste -s -d '\n'
3
5
7
9
11
13
15


Inserindo caracteres de controle na linha de comando
##################################
no bash, na linha de comando primeiro digite Ctrl+V,
depois o TAB, por exemplo, e é inserido um TAB


Trocando finais de linha com '%\n' por ' '
##############################
cat lixo
texto0 texto0 texto0
texto1 texto1 texto1%
texto2 texto2 texto2
texto3 texto3 texto3
#----
cat lixo | sed '/%$/{N;s/%\n/ /;}'
texto0 texto0 texto0
texto1 texto1 texto1 texto2 texto2 texto2
texto3 texto3 texto3
#destrinchando:
/%$/ nas linhas que terminarem em %
{
N junte a proxima
s/%\n/ / troque o % e a quebra de linha
por um espaço em branco
}


Insere o texto na linha apos a 1855 ( ou seja, 1856 )
##################
 sed '1855a\
Ola tudo bem' arquivo


Substitui o texto da linha 1856 pelo nosso texto
##################
$ sed '1856c\
Ola tudo bem' arquivo


Retirando apóstrofos de um campo
#######################
echo "'a', 'b', 'c'" | sed "s/'//4 ; s/'//3"
'a', b, 'c'
ou
N=2;N=$[$N*2-1];echo "'a', 'b', 'c'"|sed "s/'//$N;s/'//$N"
'a', b, 'c'


Separando campo alfabetico de campo numerico por virgula
###################################
echo RUA PALMAS 89 | sed 's/\([A-Z]\) \([0-9]\)/\1, \2/'
RUA PALMAS, 89


#Determinando o comprimento da maior linha
################################
wc -L arquivo


Usando trap
############
trap -l # lista relação de sinais e nomes
#Inserindo trap para todos os sinais:
$ for ((s=0;s<64;++s));do trap "echo SIGNAL $s" $s;done
$ trap # ou trap -p # lista traps ativas
determinado evento gera sinal? basta produzi-lo e ler o resultado na tela
#Para o ^C:
trap 'echo -n ^C' 2 # apenas avisa na tela
trap '' 2 # não executa ação
trap 2 # volta ao valor default
#Se o ^\ gerar SIGQUIT (3), vai afetar o processo; para bloqueá-lo:
trap "" 3
#Para bloquear ambos, ^C e ^\ , usar:
trap "" 2 3


Sobre processos e kill
###########
kill -l # lista relação de sinais e nomes
kill -0 x 2>/dev/null # retorna status 0 se o processo x existir
variavel "$!" = número do último processo disparado em background pelo shell
Avisando quando um processo termina:
$ trap "echo -e '\aTerminou'" 17
$ sleep 3&
Monitorando e acompanhando um subprocesso:
$ sleep 10&
$ while kill -0 $! ;do echo -n '#';sleep 1;done
#Aguardando um processo filho:
$ wait x # onde x é o número do processo


Mudando tamanho da tela
#########################3
Linhas=$(tput lines)
Colunas=$(tput cols)
trap "echo mudou o tamanho da minha tela" 28
ou:
trap  'echo alterado tamanho da janela do xterm \(RESIZE\)' SIGWINCH
Cancelando o trap:
trap 28


Plotando pontos em um plano
###############################
# coordenadas : parametro1 : ex.:  3,7
LC=${1%,*};CC=${1#*,};L=0;C=0
while read ;do
REPLY="$REPLY                             "
 L=$(($L+1))
if [ $L -eq $LC ]
then echo "${REPLY:0:$(($CC-1))}#${REPLY:$CC:$((20-$CC))}"
else echo "${REPLY}";fi
done<arq


Qualquer instante de tempo, futuro ou passado
###################
data1="1973-11-21 13:18:12"
delta="+3 year -7 month +23 day -15 hour +98min -139 sec"
data2=$(date --utc -d "$base UTC $delta" +"%Y-%m-%d %X")
echo "resultado: $data2
 esperado: 1976-05-13 23:53:53 =
 =  (1973+3)-(11-7)-(21+23) (13-15):(18+98):(12-139)"


Manipulando tempo,utc,local
##############################
Convertendo tempo utc para local:
dutc="16-May-2005 02:38";date -d "$dutc UTC"
Sun May 15 23:38:00 2005
Tirando 31 minutos de um horário utc e convertendo para local:
dutc="16-May-2005 02:38";date -d "$dutc UTC -$[31*60] sec"
Sun May 15 23:07:00 2005


Tempo qualquer, em segundos (number of seconds since epoch ~ 1970)
###############################
exemplos:
date -d '1969-12-31 21:00:00' +%s # epoch
0
date -d '1999-12-31 23:59:59' +%s
946695599
date -d '2004-12-13 18:08:15' +%s
1102968495


Convertendo tempo unix (em segundos) para algo mais legivel
######################
#Sendo "t" o tempo em segundos, simplesmente:
$ t=1116210844;date -d "1970-01-01 UTC $t sec"
Sun May 15 23:34:04 ??? 2005
#Detalhando:
#unix epoch foi estipulada como 00:00:00 de 01 de Jan de 1970 UTC (GMT)
#ou seja, unix epoch foi a:
#21:00:00 de 31 de Dez de 1969 em Brasília (-3GMT, não houve horário de verão)
#A data completa é:
t=1116210844;date -d "00:00:00 1970-01-01 UTC $t sec" # [0h:0m:0s é default]
#É possível especificar normalmente, a gosto, os formatos de saída:
date;date -d "1970-01-01 UTC `date --utc +%s` sec" +"%x %X %z"
Sun Jun  5 07:42:30 ??? 2005
06/05/05 07:42:30 -0300
$ t=1116210844;date -d "00:00:00 1970-01-01 UTC $t sec" +"%Y-%m-%d %T %z"
2005-05-15 23:34:04 -0300
#Especificar --utc (acima) com date %s não faz sentido:
#O número de segundos desde epoch é o mesmo em qualquer lugar do planeta, por
#isso ao falar em segundos unix, não faz sentido falar em fuso horário, por 
#exemplo, no Brasil date %s é o mesmo número de segundos, só que desde
#21:00:00 de 31/12/1969
#O último instante unix disponível, com os sistemas de tempo atuais, deverá 
#ser o segundo de número 2147483647:
t=2147483647;date -d "1970-01-01 UTC $t sec"
Tue Jan 19 00:14:07 ??? 2038
#No próximo segundo:
t=2147483648;date -d "1970-01-01 UTC $t sec"
Fri Dec 13 17:45:52 ??? 1901
#Até lá algo será definido. E no seu sistema? É só testar! :)


Testando se data é válida
########################
DT=20041131;[ `date -d $DT +%Y%m%d` == $DT ]&&echo data OK


Obtendo datas
###############
#dia anterior:
date  --date '1 days ago' +%Y-%m-%d
#ou
date -d yesterday '+%y-%m-%d'
# proximo domingo
date -d sun


Formatando datas
################
$ date -d 12Sep2005 +%Y-%m-%d
2005-09-12
$ oL=$LANG;export LANG=pt_BR;DT=20041113;date -d $DT +"%A, %d de %B de %Y"\
;export LANG=$oL
sábado, 13 de novembro de 2004


Calculo de horarios,tempo,diferença
#############
date '+%T' --date='-11 hours 20 minutes'
Ex: agora são 20:07, executando-se o comando acima temos:
date '+%T' --date='-11 hours 20 minutes'
 09:27:41
pode somar, subtrair, escolher formato de saída (ex.'+%H:%M')
escrevendo data/hora de outro fuso horário
date --date="outradata"


Escrevendo datas passadas aleatóriamente
###############
date --date "$RANDOM days ago" "+%d/%m/%Y"


Inserindo data e hora em cada linha de um arquivo de log
###########################
A linha com $RANDOM é apenas para simular o gerador de log:
while true;do echo $RANDOM;sleep 1;done\
|while read;do echo $(date '+%x %X') $REPLY;done
ou
while read;do echo $(date '+%x %X') $REPLY;done< \
<(while true;do echo $RANDOM;sleep 1;done)


Traduzindo a saída de um comando:
###############################
echo `date '+%b %e'|sed 's/Fev/Feb/'|sed 's/Abr/Apr/;s/Ago/Aug/;\
s/Set/Sep/;s/Out/Oct/;s/Dez/Dec/'`
ou
echo $(LANG=pt_BR date '+%b %e')
ou, de ambiente em portugues para ingles:
echo $(LANG=C date '+%b %e')


Visualizando inodes de arquivos
#########################
ls -li zz*
3747000 -rw-r--r--  1 web ppp 14173 Sep 10 09:34 zz1.htm
3747003 -rw-r--r--  1 web ppp 41273 Sep 10 09:15 zz2.htm
3747006 -rw-r--r--  1 web ppp 41237 Sep 10 10:17 zz4.htm
# opção -i, util para detetar hardlinks


Recuperando arquivos apagados recentemente:
###############################
Se lembra de algum conteúdo do arquivo excluído, pode tentar com:
grep -a -B5 -A100 "Dados de vendas" /dev/sda4 >/mnt/outraparticao/recover.txt
O comando busca pela string "Dados de vendas" tratando o 'arquivo binário' 
/dev/sda4 como texto (-a) e traz, juntamente com as ocorrências encontradas, 
as 5 linhas anteriores (-B5) e as 100 linhas posteriores (-A100) à ocorrência, 
direcionando a saída para o arquivo recover.txt.
É conveniente direcionar a saída para um arquivo em outra partição, para 
evitar que os inodes que contêm os dados apagados sejam sobre-escritos.



Como manter o valor de uma variável aós um loop:
############################
z=0 ; for i in $(seq 5); do z=$((z+i)); done ; echo $z
15
z=0 ; seq 5 | while read i; do z=$((z+i)); done ; echo $z
0
z=0 ; while read i; do z=$((z+i)); done < <(seq 5); echo $z
15


Separando cada caracter de uma string por outro caracter:
############################
echo aabccdddee | sed 's/./&:/g'
a:a:b:c:c:d:d:d:e:e:
explicação:
. qualquer caractere
& o trecho casado anteriormente (cada caractere)
: o caractere literal :
g troque todas as ocorrências


Separando campos só com o shell,colunas
##############
IFS=';';while read x y w z;do
echo -e "\$x=$x\n\$y=$y\n\$w=$w\n\$z=$z\n"
done< <(echo -e "12;3 4;5 #%6;7.?~+=8\nasd;fgh")
#ou:
IFS=';';while read linha; do echo "linha=$linha"
set - $linha;echo -e "\$1=$1\n\$2=$2\n\$3=$3\n\$4=$4\n"
done < <(echo -e "12;3 4;5 #%6;7.?~+=8\nasd;fgh")


Ordenando por campos não sequenciais
################################
sort -t'/' -k 3.1,3.2 -k 1.8,1.9 -k 2.1,2.2 t2
11/24/04 DAJ262 full DATA.AA.188
11/24/04 DAJ263 full DATA.AA.189
03/24/05 DAJ282 full AIX.AA.001
06/04/05 DEG622 full ARCHIVE.AA.001
06/06/05 DAJ106 full AIX.AA.002
06/06/05 DEG619 full ARCHIVE.AA.002
06/06/05 DEG620 full ARCHIVE.AA.003
07/29/13 DAJ200 full DATA.AA.134
onde:
-t informa o separador de campos;
-k posições dentro de cada campo, no formato campo.pos_ini,campo.pos_fim
considerando GNU sort e formato mm/dd/aa no inicio da linha ou seja:
3.1,3.2 - terceiro campo da posição 1 a 2 (ano);
1.8,1.9 - primeiro campo da posição 8 a 9 (mes). Comecei na 8 para ignorar
os brancos iniciais;
2.1,2.2 - segundo campo da posição 1 a 2.


Testando se é número
##################
isnum(){ (($1+0));} # a funcao
isnum 45;echo $?
x=3456;isnum $x&&echo yes
x=any;isnum $x&&echo yes||echo not
#ou:
isnum(){ [ ! "${1//[0-9]/}" ];} # outra fun


Escrevendo números como valor monetário
####################
echo 000987654321 | sed -r 's/^[0]*([0-9]+)([0-9]{2})/R$ \1,\2/'
R$ 9876543,21


Colocando new line em sed antigo
################################
echo 'um dois tre'| sed 's/ /\
/'
# Apagando carriage return e incluindo new line
echo -ne 'abcdefg\r098R$ 123'|sed "
s/`echo -ne '\r'`//g
s/R$ /\\
Valor=/g
"
#Antes:
098R$ 123
# Passando pelo sed:
abcdefg098
Valor=123


Descobrindo processos que estão usando algum recurso
######################$
Ex:
fuser /mnt/floppy
ou
fuser /dev/fd0


Screen saver ao estilo do filme matrix
##################################
#!/bin/bash
trap "echo -e '\033[m0';clear;setterm -cursor on;exit" 2
setterm -cursor off
Chars="abcdefghijklmnopqrstuvxywzABCDEFGHIJKLMNOPQRSTUVXYWZ01234567890!@#$%¨
&*()_-+=^~{}[];:?"
clear
while true; do
lin=0
[ ${#Cols[@]} -eq $(($(tput cols)-2)) ] && unset Cols
while true; do
COL=$((RANDOM%$(tput cols)))
[ "${Cols[$COL]}" ] && continue
Cols[$COL]=1
break
done
COR="\e[3$((RANDOM%7+1));1m"
while [ $lin -lt $(tput lines) ]; do
Char=$(echo $Chars | cut -c$((RANDOM%86+1)))
tput cup $lin $COL; echo -en "$COR$Char";sleep 0.01
let lin++
done
done


Trocando '\n' por virgula
##########################
paste -s -d "," arquivo
ou
tr '\n' ,
ou
VAR1="${VAR//
/,}"


Concatenando linhas de dois arquivos
###################################
paste arq1 arq2 -d""


Eliminando CR '\r' e NL '\n' sem usar tr ou sed, so no shell
##############################
VAR=`echo -n ${VAR//$(echo -ne '\r')/}`
Obs.: O valor do IFS afeta o comportamento do "echo"


Desordenando linhas, mostrando linhas em ordem aleatória
################################
while read i; do echo $RANDOM $i; done <arquivo| sort | cut -d\  -f2


Dividindo um arquivo com milhares de linhas em arquivos de 100 linhas
#########################
split -l 100 arquivo


Passando a saída para tela e arquivos simultanemanete,spy,capture
##########################
echo "Fim" `date` | tee -a a1 a2 a3 a4


Somando números em linhas de arquivo
################
$ cat credito
2
3
$ soma(){ t=0;while read x;do t=$(($t+$x));done<$1;echo $t;}
$ creditotal=$(soma credito)
$ echo creditotal=$creditotal
creditotal=5
###outro ex.:
$ cat arq
123456
1234567
12345678
#opções:
$ while read p;do t=$[t+p];done<arq;echo $t
13703701
$ (cat arq |tr \\n +;echo 0)|bc
13703701
$ echo $(cat arq)|tr \  +|bc
13703701
$ cat arq|xargs|tr ' ' '+'|bc
13703701
$ paste -s -d + arq|bc
13703701


Somando a 3.a coluna do arquivo arq, colunas separadas por espaço
###############################
echo $[`echo $(cut -d" " -f 3 arq)|tr " " +`]
ou
echo $((`echo $(cut -d" " -f 3 arq)|tr " " +`))
ou
echo $(cut -d" " -f 3 arq)|tr " " +|bc
ou
awk '{sum += $3} END { print sum; }' arq


Desordenando linhas de um arquivo, unsort, aleatório
##########################
$ sort -k 5 -t " " arquivo
ordena pelo campo 5 com espaço como delimitador, ou seja, desordena pelo 1.o


Exemplo atualização hn.org usando shell e netcat
##################################
# Fonte: http://www.portfolio16.de/dyndns/provider.HAMMERNODE.htm.de
{
echo "GET /vanity/update/?VER=1&IP=${ip} HTTP/1.1"
echo "Host: dup.hn.org"
echo "Connection: close"
echo "Authorization: Basic [BASE64 of [Username]:[Password]]"
echo "User-Agent: netcat/1.10"
echo ""
} | netcat -w 30 "dup.hn.org" "80"


Passando um valor para o read, input, file descriptor
###################################
echo -n aqui >&0|read V;echo -n $V


Verificando relação entre programas, sockets,processos e usuários
#####################
fuser -auv /bin/bash # exemplo para o programa bash


Executando comandos ao sair do shell
############
#em shell de login: é executado "~/.bash_logout" (ou .logout)
#uma solução para exit de sub-shell:
$ trap 'read -p "executar: " r;$r;read -p fim...' EXIT


Executando lista de programas em seqüência:
################################
for prog in prg1 prg2 prg3 prgn
do
$prog
done
a variável prog assume o nome de cada programa na lista e executa um-a-um
outra opcão:
# monitorar o sinal 17 com um trap; quando o processo filho termina um 
# sinal 17 é gerado. Exemplo:
$ trap "echo processo filho terminou" 17
$ sleep 3&
# 3 segundos após, vc receberá a msg: "processo filho terminou"
# Para restaurar o sinal para o seu default faça:
$ trap 17
outra solução:
# usar o built-in do shell "wait", assim vc pode montar um loop disparando 
# os programas em backgound e fazendo um wait $!, já que $! contem o PID 
# do último programa colocado em bg. Exemplo em um xterm:
$ xterm &         
$ wait $!


Shell restrito,bash,segurança,cd, PATH
##########################
É possível deixar o shell bash muito restrito chamando-o assim:
$ bash -r


Obtendo a versão do Linux, version:
####################################
cat /proc/version
ou
uname -a            


Compilador para shell-script
############################
http://www.datsi.fi.upm.es/~frosal/sources/


Pegando trechos de linha de arquivos e montando novas linhas
#################
cat arq1:
1234567890
1234567890
cat arq2
udtqcmsonz
udtqcmsonz
paste <(cut -c-6 arq2) <(cut -c7 arq1) <(cut -c8- arq2) -d ''
udtqcm7onz
udtqcm7onz
O paste admite um delimitador -d para marcação a cada troca de arquivo
ref: http://br.groups.yahoo.com/group/shell-script/message/8580


Listando diretorios de usuarios com permissões diferentes de 700
################
find /home/* -type d ! -perm 700 -print


Visualizando caracteres de controle/especiais em arquivos
#####################################
vim arquivo
depois, :set list


eliminando linha de arquivo,string,palavra
##################
grep -v "string proibida" arquivo
ou
sed /"string proibida"/d arquivo


Mostrando linhas que começam por P1 ou P2
#################
grep "^P1\|^P2" arq
#ou:
egrep "^P1|^P2" arq
#ou:
egrep "^(P1|P2)" arq


Copiando vários diretórios para outro, neste exemplo, /bkp:
######################################
cp -pR /sbin /bin /usr ... /bkp
com a lista é possível exluir /bkp, /tmp, /proc, /var, ...
Fazendo a mesma coisa, mas citando as exclusões:
cd /;cp -pR $(ls /|grep -vE "^bkp|^tmp|^pr|^va"|tr "\n" " ") /bkp


Usando o programa screen
#######################
rodar por exemplo:
screen -d wget -m www.site.com &
e irá para bg
depois, fazendo screen -ls voce verá o pid aberto
e para voltar para a sessão, basta fazer
screen -r pid


Senha em scripts
###################
No bash:
read -sp "senha: " pw
em outro shell ou no bash:
stty -echo
echo -n "senha: "
read pw
stty echo
No segundo caso, é bom colocar a seguinte linha no início do programa:
trap "stty echo; exit" 2 3 15
para que o terminal não ficar sem echo com um ctrl+c, um ctrl +\ou um kill.


Substituindo uma linha por outras
########################################
sed -e '/minha string velha/c\' -e 'blablabla\' -e 'blablbal'
nos seds mais recentes pode ser:
sed '/minha string velha/ s/.*/primeira\nsegunda\nterceira/'


Apagando a última linha de um arquivo
#######################
no sed, o $ como número de linha, significa a última linha
o "d" apaga linha, assim:
sed '$d' arquivo = arquivo sem a ultima linha


Deixar progs rodando após logout
#################################
alem do "nohup", existe o "screen", que mantem a execução com 
pid proprio, dessa forma voce pode deixar o seu programa,
não só em bash rodando em bg, voltar para o mesmo depois.
Isso é muito útil em SSH, pois com o nohup, se voce fecha
a sessão, o processo não é recuperável.


Tratando strings só com bash,sem cut,substr,vars
###########################################
v=1234567890;echo ${v#1234} # retira a parte inicial informada
v=nomedir/;echo ${v%/} # retira o final da string mostrado
v=nome.com;echo ${v%.com} # retira o final da string mostrado
v="01234567889";echo ${v:$[${#v}-2]} # mostra 2 ultimos char
n=0123456789;echo ${n#${n%??}} # mostra 2 ultimos char (comprimento fixo)
n=0123456789;echo ${n%???} # elimina 3 ultimos char
n=0123456789;echo ${n#????} # elimina 4 primeiros char
echo ${z: -1} # mostra o último caracter de uma variável
u=1234567890;echo ${u:2:5} # mostra, depois da posição 2, 5 caracteres
u=1234567890;echo ${u:4} # motra tudo depois da posição 4
L='1234567890';echo ${L#*5} # elimina caracter e tudo à sua esquerda
L='1234567890';echo ${L%5*} # elimina caracter e tudo à sua direita
S=`echo -e "\t"`;L=ab"$S"12;echo "${L%%$S*}" # exclui do 1.o $S até o final
S=" ";L="joao  10,00";echo ${L##*$S} # exclui do início até o último $S
v=c1:c2:c3:c4;echo ${v/:/ } # troca primeiro : por " "
v=c1:c2:c3:c4;echo ${v//:/-ax-} # troca todos : por "-ax-"
v='';echo ${v:=4} # se v for nula valor mostrado é 4, senão é $v
echo ${2:-47} # se o parametro 2 do prog/funcao for nulo o valor 47 será usado
v=123456;echo ${#v} # comprimento do valor de v
echo ${!va*} # lista nome de todas as variáveis que começam com "va"
=======
LAPIDAR:
# A="teste maior" => Defino a variável A
# echo ${A/e/E} => Substituo o PRIMEIRO "e" por "E" (maiúsculo)
tEste maior
# echo ${A//e/E} => Substituo TODOS os "e" por "E" (maiúsculo)
tEstE maior
# arquivo="/etc/config.config" => substitui arquivo por config
# echo ${arquivo//ig} => troca TODOS ig por NADA (del)
/etc/conf.conf
# echo ${arquivo//%ig} => troca o ÚLTIMO(%) ig por NADA
/etc/config.conf
# echo ${arquivo/%ig} => idem.
/etc/config.conf
#o símbolo (%) direciona a substituição para a string ao final da variável


Alinhamento à direita, colunas, unidade, milhar,comprimento fixo/constante
##############################
cat lixo
pedro            10.00
helio            1.00
joao             1000.00
maria            10000.00
cat lixo | sed -e ':a' -e '/^.\{1,25\}$/s/ /  /;ta'
pedro                10.00
helio                 1.00
joao               1000.00
maria             10000.00
--- ou 100% bash
COMP=20                         # comprimento da linha de saída
SPS="                         " # variável contendo espaços
SEP=`echo -e "\t"`              # separador no arquivo de origem
#SEP=" "
while read L;do
 C1=${L%%$SEP*}                 # exclui do 1.o $SEP até o final
 C2=${L##*$SEP}                 # exclui do início até o último $SEP
 NSP=$(($COMP-${#C1}-${#C2}))   # número de espaços a inserir p/comprim=$COMP
 echo "$C1${SPS:0:$NSP}$C2"     # saída do script
done\
<lixo


Escrevendo números alinhados pela unidade (comprimento fixo)
#######################
C=8;SP='          '
for N in 12 1234567 1234;do
 echo "${SP:0:$[$C-${#N}]}$N"
done


Escrevendo números, comprimento fixo,inteiro,00
###############################################
O "%04i" é o formato de saida usado no printf (igual o do C). a entrada é um 
inteiro (i) com 4 casas decimais e complementados de 0 caso o numero possua 
menos de 4 casas decimais. Vide "man printf"
Exemplo de script envia email p/usuários no arquivo, com senha sequencial:
#!/bin/bash
n=1
for user in $(cat teste.txt); do
 msg=$($user senha $(printf "%04i" $n))
 n=$(($n+1))
 echo $msg | mail -s "Sua Senha..." $user
done


Somando a 5ª coluna 
###########################
bin bin 512 May 17
root system 67734 Oct 18
root system 91 Mar 07
root system 512 Jun 05
bin bin 7168 Apr 19
root system 31 Apr 02
bin bin 5 May 17
-
Supondo a lista seja o STDOUT do comando "DISCOS". Então:
DISCOS | awk '{soma +=$5} END {print soma}'
-ou
soma=0
for valor in `programaquegerasuasaida | grep system | tr -s " " |
cut -d" " -f5`; do soma=$[ $soma + $valor ]; done


Listando atributos de todos os diretorios
#########################################
DirsAtts(){ ls -lR "$1"|grep :$|while read D;do ls -ld "${D%:}";done;}
DirsAtts /


Copiar arquivo para diretorio/filhos/netos
############################
find /home/usrmail -type d -exec cp arquivo.txt {} \;


Tentando obter o atributo de video de um dado caracter
####################################################
cut -b6 /dev/vcsa1|tr -d "\n"|xxd -p | tr -d "\n"


Obtendo o nome da máquina
#############################
hostname   
ou
echo $HOSTNAME


Eliminando strings
#####################
echo 12837alou 48348nome 2838| tr -d 'alou | nom'


Mostrando linhas:
#######################################
#começando com . (ponto)
grep "^\." arq
#começando com " " (espaço)
grep "^\ " arq
grep ^\  arq
#começando com # ou vazias
grep -E "^#|^$" ./yy
grep "\(^$\|^#.*\)" ./yy
#a linha 10633
sed -n 10633p arq
#ou
head -10633 arq | tail -1


Mostrando a partir da 3.a linha até o fim
######################################
tail +3 arquivo


Procurando linhas que contenham 2 strings em qualquer ordem
###########################################
grep 'string1.*string2\|string2.*string1'


Procurando linhas que contenham pelo menos 1 string
###################################################
egrep 'string1|string2' arquivo
ou
grep -E 'string1|string2' arquivo



Procura mais de uma palavra, string
###################################
egrep "falhou|error|fault|etc" arquivo


Listando apenas o nome dos arquivos que atenderam o grep
##########################
grep -l '^\.' * # aqui o alvo é ponto no início da linha


Verificando se um diretório não está vazio
###########################################
nedir(){ ls -a1 $1|while read;do R="$R$REPLY";[ "${R:5}" ]&&break;done;}
ou
[ "`ls /tmp/fuu|head -n 1`" ]||echo vazio
ou
[ "`ls /tmp/fuu|cut -c1`" ]||echo vazio
ou
[ -f /tmp/fuu/* ]&&echo nao vazio


Redirecionando a saída de erro para variável
##########################
var=$(cp 2>&1)
echo $var


Automatizando ftp (sera que funciona?????)
#####################################
---1
#!bin/sh
HOST='localhost'
USER='user'
PASSWD='senha'
CMD='ls RPL'$1'*.zip '$1'.txt'
FILES=`cat $1.txt | wc -l`

for i in `cat filiais.txt`
1=$i
do ftp -n -i $HOST << END_SCRIPT
quote user $USER
quote PASS $PASSWD
cd logfacil.com.br/transfer
$CMD
exit
END_SCRIPT
echo " A base $1 tem $FILES arquivos para serem baixados "
done
---2
echo "
    open ftp.host.com.br
    user usuario senha
    ls -l string*
    bye
" | ftp -i -n | wc -l
---3
Tem um modo mais fácil de fazer isso.
O comando é rcp (remote file copy)
Procure no seu man como fazer isso.
Nos dois servidores, vc precisa de uma relação de confiança.
Para isso, edite o arquivo hosts.equiv, que fica no /etc, e adicione 
o login ao qual fará a cópia. 
Nota.: o login tem que ter o mesmo nome nos dois servidores, e nos 
arquivos hosts.equiv tem que ter o nome do mesmo login.
Aí é só fazer a cópia, deleção, etc.
---4
Tem o rdiff-backup que faz todo o procedimento de backup (mirror + 
increments). Ele trabalha com ssh, com conexão segura e de modo mais 
rápido que o ftp.
Tem gente utilizando no trabalho (com + de 20 GB de arquivo).
O Rdiff-backup tem o opcao de apenas mirror.
Para fazer autenticacação direta (sem pedidr a senha) tem o seguinte 
tutorial: http://www.arctic.org/%7Edean/rdiff-backup/unattended.html*


Loop for numerico
##################
for ((a=1;a<8;a++)) do echo  $a;done


Criando um arquivo de swap
##############################
dd if=/dev/zero of=swapfile bs=1024 count=65536 # cria arquivo 64MB
mkswap swapfile # prepara e assina o arquivo
swapon swapfile # ativa swap no arquivo
free -m # mostra parâmetros da memória


Desligando e religando área de swap
#######################
swp=`swapon -s|grep /|tr -s \ |cut -d\  -f 1|cut -c1`
swapoff -a # desativa todas as áreas de swap
... operações sem swap
[ $swp ]&&\
swapon -a # religa swap, ativando todos os pontos indicados em /etc/fstab
unset swp


Trocando usuario no script e executando varios comandos
###########################################
Usa `sudo'. Ele vai guardar um ticket.
No final dos comandos, para zerar a validade do ticket, `sudo -k'.


Disquete no linux com 1.72MB
##################################
fdformat /dev/fd0u1722 # formata
dd if=dsk.img of=/dev/fd0u1722 count=3444 # grava arq.imag.disq. no disquete
cmp dsk.img /dev/fd0u1722 # compara imagem com disquete


Conectando stdin/stdou com a net
###############################
- inetd --> put 'www stream tcp nowait nobody httpd.sh' into /etc/inetd.conf
- faucet 80 httpd.sh
- nc -l -p 80 -e httpd.sh
- sinetd 80 /sh/httpd.bash
- socketd
- micro_inetd
- linetd -p 1080 /sh/http.sh
- socker 1080 /sh/http.sh &


Obtendo dados remotos, http, tcp,arquivo
############################
um tail remoto:
#!/bin/sh
[ "$1" ] && while :; do
        exec 3<>/dev/${tu:-tcp}/${2:-127.1}/${rp:-80} && {
        s=$(du -b ${1##*/}|tr \\t :) && s="\nRange: bytes=${s%%:*}-"
        echo "GET /$1 HTTP/1.0$s\n\n" >&3
        sed 0,/^.$/d <&3; } && sleep ${3:-5}
done || echo ${0##*/} arq [end] [tem]

      Exemplo, pegando um pedaço de um log:

$ rtail mesg|tee -a mesg
dkcsum: wd0 matched BIOS disk 80
root on wd0a
^C
$ echo $BASH_VERSION
2.05b.0(1)-release
------- ou
#!/bin/sh
[ "$1" ] && while :; do
      socket $2 ${rp:-80} |& echo -n >&p && {
        s=$(du -b ${1##*/}|tr \\t :) && s="\nRange: bytes=${s%%:*}-"
        echo "GET /$1 HTTP/1.0$s\n\n" >&p
        sed 0,/^.$/d <&p; } && sleep ${3:-5}
done || echo ${0##*/} arq [end] [tem]
$ rtail mesg
rootdev=0x0 rrootdev=0x300 rawdev=0x302
^C
$ echo $KSH_VERSION
@(#)PD KSH v5.2.14 99/07/13.2
-------


Fazendo um disquete de boot:
#############################
makebootdisk


Alterando a resolução do monitor on the fly
######################################
Para listar as opções:
xrandr
Para selecionar uma: 
xrandr -s N # pode ser necessário dar um restart no gerenciador de janelas


Gerando thumbnail, resize, imagens
###################################
convert -size 120x120 image.jpg -resize 120x120 +profile "*" thumbnail.jpg


Fazendo um screenshot de tela
###################################
xwd -root | convert - testeshot.jpg


Mudando a senha na linha de comando
####################################
echo usuario:senha | chpasswd
ou script (nao testado):
#!/bin/bash
if test $UID = 0
then
adduser $1
echo $2 | passwd $1 --stdin
echo "Usuário $1 adicionado no Sistema com sucesso ! ! !"
else
echo Você não é o ROOT
fi


Usando o Ctrl+Alt+End para desligar o computador 	
############################################
No /etc/inittab abaixo da linha do ctrlaltdel inclua: 
kb::kbrequest:/sbin/shutdown -t5 -h now
No /etc/rc.d/rc.local coloque:
echo "control alt keycode 107 = KeyboardSignal" | loadkeys -
Pronto: Ctrl+Alt+Del irá rebootar e o Ctrl+Alt+End irá desligar.


Mostrando condições do computador,máquina,situação
##########################
memory; memória:
cat /proc/meminfo
partições, partitions,particoes:
cat /proc/partitions


Verificando memória no Linux
##########################
free
# ou
cat /proc/meminfo


Fazendo um /tmp na memória, ram
#################################
a memória é alocada dinâmicamente. Do zero, on the fly até o limite especif.
Ex.: adicione no seu /etc/fstab: 
/dev/shm        /tmp            tmpfs   defaults,size=64m       0 0
size=tamanho máximo que a partição pode possuir (64m = 64 MB)


É possível desabilitar checagem forçada de HD: 
########################################
tune2fs -c 0 -i 0 /dev/hdxn
onde x é uma letra e n número. Desativa a checagem por número de montagens 
(-c) e por intervalo de tempo (-i), vide man tune2fs.


Port scanner seguranca
############################
nc -vz PARAMETER hostname PORTRANGES
Parameter	Meaning	
-v	show the closed ports as well	
-w <seconds>	timeout for connection setup	
-u	udp instead of tcp. Best used together with -w	
-r	try the ports in random order	
-i <seconds>	delay after each tested port	
Examples for a tcp- and an udp-scan:
$ nc -vz www.jfranken.de 1-1024
$ nc -vz -vur -i 1 -w 2 localhost 1024 108-112


Copiando diretórios através da internet
##############################
receptor: netcat listen on port 51330, and redirect it's output to a tar:
alias receive='nc -vlp 51330 | tar xzvp'
$ receive
listening on [any] 51330 ...
No trasmissor call a shell function, which tars the given files/directories 
and sends them to port 51330 at the receiving host. 
send() {j=$*; tar cpz ${j/%${!#}/}|nc -w 1 ${!#} 51330;}
$ send dir* tp.jfranken.de


Usando o nc (netcat) para ficar ouvindo 1 porta
##############################
PROGRAM | nc -l -p PORT -w TIMEOUT
ou
nc -l -p PORT -w TIMEOUT | PROGRAM
netcat will wait for exactly one connection to port PORT, then attach to 
PROGRAM's out- or input and wait maximum TIMEOUT seconds for the connection 
to abort.
For ports below 1024, you need to be root.
If the port should be bidirectional (do input as well as output), you can type
nc -l -p PORT -e PROGRAM
como só aceita uma conexão e sai, pode ser cíclico assim:
$ cat <<EOF>mydemon
#!/bin/bash
export port=${port:-$1} # inherit $1 as $port
nc -l -p $port -e $0 &  # await further connections on this port
[ $1 ]|| PROGRAM        # do the work (not for the first invocation)
EOF
$ chmod +x mydemon
$ ./mydemon 3000


Verificando resposta de sevidor web,www,http
#####################
echo -ne 'GET / HTTP/1.0\n\n'|\
nc -w 10 $1 80|\
sed '/^\r$/q' # pega a stream até o final do cabecalho




Mostrando linhas
######################
cat -n arq
ou
nl arq


Eliminando as 3 ultimas linhas de um arquivo
#########################
A=nome_arquiv;L=3
n=`wc -l $A`;n=`echo ${n% *}`;sed $[$n-$L+1],$n\d $A


Arquivos e o loop for
######################
for f in *;{ echo $f;}# lista todo conteúdo do dir atual apenas em seu nível (0)
for f in */*;{ echo $f;}# aqui lista todo o conteúdo dos subdir no nivel 1
for f in */*/*;{ echo $f;}# aqui lista todo o conteúdo dos subdir no nivel 2


usuário terminal momento_de_login
##############
who
whoami
who am i


Escrevendo no terminal
#########
echo a > /dev/tty
echo a > `tty`


Video reverso no xterm
########################
tput smso
tput rmso # video normal


Apagando arquivos maiores que certo tamanho
###################################
for arquivo in `find /root/ -type f -size +40000k`;do echo>$arquivo;done
zera conteúdo arq.maiores 40MB;p/apagar trocar "echo >" por "rm -f"
ou
find ./ -type f -size +1024k -exec rm -f {} \;
apaga arquivos maiores de 1024kb no dir.atual e seus subdir.
ou
find . -size +10000k -exec rm -fv {} \;
ou
find /home1/abc /var/log -size +10000k -exec rm -fv {} \;


Não diferenciando maiúsculas e minúsculas
##########################################
ls *.[wW][aA][vV]


Determinando se uma letra é maiúscula ou minúscula
######################
A=i;case $A in [A-Z])C=1;;[a-z])C=2;;*)C=3;esac;echo $C


Vários and e or
######################
[ b == b -a d == d -o b != b ];echo scrip




Procurando uma palavra no inicio de linha começando com maiusacula ou minuscula
#########################
grep ^[Vv]ida teste.txt 


Mudando configuração de rede se um caminho falhar,net
########################################
# Testa com um ping, se falhar altera para:
ifconfig eth0 xxx.xxx.xxx.xx
route add default gw xxx.xxx.xxx.xxx


Pegando o IP da maquina so com shell
######################################
IP(){ /sbin/ifconfig $1 2>/dev/null|\
while read L;do
[ "${L:0:1}" == i ]&&{ L=${L#*:};echo ${L%% *};break;}
done;}
IP $1


Registrando entrada,saída e erros em arquivos,stdin,stdout,stderr
###########################################
Enter(){ [ "$REPLY" == "`echo`" ];}
echo >>sti
while read -r -s -n 1;do
 [ "$REPLY" == "`echo -ne "\x7f"`" ]&&REPLY=`echo -ne "\x08"`
 if Enter;then echo >>sti
 else echo -n "$REPLY">>sti;fi
 echo -ne "\r";tail -n 1 sti
 Enter&&eval `tail -n 1 sti`>>sto 2>>ste
done


Pegando o conteúdo da tela de um terminal em outro,captura,console,spyware
########################
O que existe em tty# talvez esteja disponível em texto em /dev/vcs# e com 
atributos de vídeo (cor) em /dev/vcsa#, onde # é o número do terminal, 
ainda que rodando o X.
Exemplo:
cat /dev/vcs1
deverá colocar no term/xterm a tela de tty1 (terminal caracter)
a princípio só o root deve ter poder de aceso, por razões óbvias.
cat /dev/vcs1 > arquivo   grava a tela em arquivo
ou
colocar no script de login:
script  -q  -a  /tmp/log
ao sair da sessão o programa é encerrado


Criptografia ridícula,crypto
########################################################
# Para ampliar é só trocar 2 caracteres entre si em K2
K1='
 0123456789abcdefghijklmnopqrstuvwxyz@ABCDEFGHIJKLMNOPQRSTUVWXYZáéúãõâçÁÉÚÃÕÂ'
K2='
xz123p56n89VãYdKfghHjkqP7G4lustrOw y0@ABCDEFoiIJeLMçvmQRSTUaWXéZácúbõâNÁÉÚÃÕÂ'
echo "$1"|tr "$K1" "$K2"
echo "$1"|tr "$K1" "$K2"|tr "$K2" "$K1"
echo -- outra opcao
echo $1| tr 'a-zA-Z' 'n-za-mN-ZA-M'|tr ' a' 'a '
echo $1| tr 'a-zA-Z' 'n-za-mN-ZA-M'|tr ' a' 'a '|\
tr 'a ' ' a'|tr 'n-za-mN-ZA-M' 'a-zA-Z'


Lendo linhas de arquivo com o bash
######################################
File=./arq;{ read line1;read line2;} < $File
echo "First line in $File is:";echo "$line1"
echo "Second line in $File is:";echo "$line2"


Substituindo a última linha de arquivo por "NOVOTEXTO":
#############################################
sed '$cNOVOTEXTO' arquivo > arquivo.new


Substituindo a ocorrencia de certa string em determinada posiçao de linha
############################################
while read L;do echo -n "${L:0:80}">>aux.txt
 if [ "${L:80:2}" == "$1" ];then echo -n "$2">>aux.txt
 else echo -n "${L:80:2}">>aux.txt; fi
 echo  "${L:82}">>aux.txt
done<arq


Tamanho, size, de arquivo
############################
ls -l ul1|tr -s ' ' |cut -d" " -f 5
ou
set -- `ls -l ul1`;echo $5
ou
find ul1 -printf "%s\n"
ou
ls -l ul1 | awk '{print $5}'
ou
du -hb ul1
ou
ls -hs ul1
ou
stat -c %s ul1


for em intervalo numérico
#########################
for ((i = 1; i <= 25; i++)) { echo $i; }
ou
for i in $(seq 25); { echo $i; }


Alterando o prompt do shell
##########################
$ oP=$PS1;PS1='(:> ' # esse é em homenagem ao Linux :)
(:> echo xyz
xyz
(:> PS1=$oP;unset oP # retornando ao promp original
$ 
#Colocando cor:
PS1="\[\033[1;34m\][\$(date +%H:%M)][\u@\h:\w]$\[\033[0m\] "
#Idem, mostrando número do processo:
PS1="\[\033[1;33;41m\$\$ \u@\h:\w)\[\033[0m "


operador OU prático
##############
case B in A|B|C|D)echo está na lista;esac


Escrevendo o dia da Semana por extenso
#######################################
DiaDaSemana(){
case `date +%u` in
1)DdS=Segunda
;;2)DdS=Terça
;;3)DdS=Quarta
;;4)DdS=Quinta
;;5)DdS=Sexta
;;6)DdS=Sábado
;;7)DdS=Domingo
esac
echo -n $DdS
[ ${DdS##*o} ]&&echo -n -Feira
unset DdS
}
ou com esta condicional para escrever "na" ou "no" antes do dia:
if [ `echo -n ${DdS##*o}` ];then echo -n "na $DdS-Feira"
else echo -n "no $DdS";fi
-- adicionando um parâmetro ainda escolhe se quer preceder com o na/no 
-- outra opção, com array:
dias=('' Segunda-Feira Terça-Feira Quarta-Feira
 Quinta-Feira Sexta-Feira Sábado Domingo)
echo "O dia é ${dias[`date +%u`]}"
--ou
dias=('' Segunda Terça Quarta Quinta Sexta Sábado Domingo)
dia=${dias[`date +%u`]}
echo -n $dia;[ ${dia##*o} ]&&echo -n -Feira
número de elementos da array = echo ${#dia[*]}


Mostrando linhas vazias em arquivos tipo DOS (fim de linha 0D0A)
################################################################
FL=`echo -e "\015"`;while read L;do
 [ "$L" == "$FL" ]&&echo VAZIA
done<arquivo


Selecionando linhas
######################
começam com hifen:
grep "^-" arquivo.txt
não começam com zero:
grep -v "^0" arquivo.txt
começam com espaços:
grep "^[[:space:]]*-" arquivo.txt
grep -v "^[[:space:]]*0" arquivo.txt
pelo número:
awk 'NR=numero' arquivo


Para eliminar linhas em branco
###################################
echo -e 'um\ndois\n\nquatro' | grep .
ou
echo -e 'um\ndois\n\nquatro' | grep -v '^$'
ou
echo -e 'um\ndois\n    \nquatro' | grep -v '^ *$'
onde ' *' significa qualquer quantidade de espaços


Pegando a linha seguinte a um padrão
######################################
unset prox;while read L;do
 [ $prox ]&&echo $L|cut -c2-|cut -d" " -f 1,2,4&&unset prox
 echo $L|grep -q "Sending buffer"&&prox=1
done<arquivo
ou
grep -A1 "Sending buffer" arquivo| grep -v Sending |
  tr -s " " | cut -d" " -f1-3
ou
sed -n '/Sending buffer/{n;p;}' arquivo|  tr -s " " |
  cut -d" " -f1-3


Usando a tecla backspace em um case
####################################
`echo -e "\b"`) comandos ;;



Impedindo abortar entrada de dados com Ctrl-C e obrigando comprimMin=6
#######################################################
L='';while [ ${#L} -lt 6 ]&&trap "" 2; do read L ; done


Tratando Ctrl-C em um script
################################
# Funcao que tratara o Ctrl+C
ctrlc()
{
 # Nao intercepta mais o sinal
 trap 2
 # Funcao propriamente dita
 tput clear
 echo "\t\t\tDeseja abortar os processos (S/N)?"
}
# intercepta o sinal de Ctrl+C (Ctrl+C == SIGINT == 2)
trap ctrlc 2
# script propriamente
#tail -f /log/Mnglog10.log
read
echo tail


Desativando o ctrl+c em script
###############################
(trap "" 2 20)


tratando apenas um certo número de arquivos
############################################
x=0;ls -1|while read A ;do echo "$A";x=$(($x+1));[ $x == 5 ]&&break;done


Numerando linhas em um arquivo
###############################
Da uma olhada no comando nl.
Tem um parametro --number-format que deve te atender


Selecionando arquivos com o dialog
###############################################
DIALOG=dialog # ou Xdialog para visualizar no X
lst=""
num=0
for i in `ls $1`
do
let num++
mp3$num=$i
lst=" $lst $num $i off "
done
file=$($DIALOG --stdout --radiolist "Selecione" 0 0 0 $lst)


Coloca texto piscante na console
###################################
Experimentar: tput blink # no xterm parece que não


Pegando versão de software
###########################
ver(){ echo $1|while read -d\- V;do
[ "${V#*.}" != "$V" ]&&echo $V&&break
done;}
#Ex.: ver gtk-engines-2.2.0-i486-4; resultado: 2.2.0


Testando se uma variável existe
##########################
$ : ${VAR:?"nao existe"}
ou
$ (: ${VAR:?}) 2> /dev/null || echo -n "nao "&&echo existe


testando se uma variavel é um num.inteiro
################################
N=459;expr $N + 0 >/dev/null 2>&1&&echo ok||echo erro
só são aceitos números positivos e zero é considerado erro


testando existência de string ou caracter
#######
VAR=teste;[ "$VAR" != "${VAR/est}" ]&&echo existe
#ou
VAR=teste;[[ $VAR == *est* ]]&&echo existe


determinando posição do caracter "-"
#############
SIZE=${#VAR}
POS=${VAR%-*} # % para posição do ultimo; %% para posição do primeiro hifen
POS=${#POS}
[ $SIZE -ne $POS ]&& echo "Encontrado - na posição $((POS+1))"


Convertendo versão de software para inteiros, para processamento,version
########################################################################
v='';vp=''
for x in 1 2 3 4 5;do		# máximo de algarismos de versão
 vp=`echo $1|cut -d. -f $x`
 [ $vp ]||break			# sai se não há mais algarismos de versão
 v=$v$(printf "%02i" $vp)       # 2 é o núm.algarimos decimais
done                            # para cada algarimo da versão
echo $v


Removendo arquivos com +xx dias
############################################
sem acesso:
find /diretorio -name "*.log" -atime +xx(dias) -exec rm {} \;
de modificado:
find ~/mail/d -mtime +30 -name '*' -type f -exec rm -f '{}' \;


Eliminando letras, traços e pontos
###################################
NOV=linux-2.6.0-Test9;echo ${NOV//[a-zA-Z-.]}


Contando a quantidade de um certo caracter em uma string
#########################################################
n=$(echo "/usr/ruevers/arquivos/novos/teste.txt" | sed -e 's,[^/],,g')
echo ${#n}
ou
echo -n /usr/ruevers/arquivos/novos/teste.txt | \
sed 's/[^/]//g' | wc -c


Contando comprimento de strings
#################################
expr length "quantos tem aqui?"





Deixando sequencia de espaços como um espaço
############################################
echo $linha | tr -s " "|cut -d " " -f 1
ou
echo "11-03-03        09:39AM             13291    arquivo.txt" |\
 awk '{print $1}'


usando tcp/ip no bash
##############################################
echo -ne "GET / HTTP/1.0\n\n" 1>&0   ## envia
cat <&0                              ## lê
##############################################
o script é chamado assim:
./script.sh <> /dev/tcp/1.2.3.4/80
ou############
3<>/dev/tcp/1.2.3.4/80
echo -ne "GET / HTTP/1.0\n\n" 1>&3
cat <&3
############
Não inretativo


Mudando as linhas pares
#########################
$ cat lixo | sed '2~2 s/.*/AQUI/'


Substituindo uma string em um arquivo
#####################################
pelo número da linha:
	sed '3 s/OK/NOK/' arquivo
ou pela string:
	sed '/rj09/ s/OK/NOK/' arquivo


Aceitando apenas algarismos nos parâmetros,números
#################################################
[ "`echo $*|tr -d ' 0123456789'`" ]&&{
echo "Tem algo que não é algarismo";return;ou exit;}


Retirando parte do conteúdo de um arquivo compactado
#######################################################
tar -xjvf /path/arquivo.tar.bz2 usr/sbin/arquivo.desejado


Usando formato brasileiro de data, não americano
################################################
D=23/01/2004;date -d ${D:3:2}/${D:0:3}${D:6}
ou
D=23/01/2004;date -d `echo $D|cut -d/ -f 2`/`echo $D|cut -d/ -f 1,3`


Mostrando resto da linha após uma string
########################################
echo /max/maxtux/TIM/EXE/ti542m08.rej |sed 's|.*/||'


Pegando arquivo até uma determinada string
##########################################
sed '/^.\r$/q' arquivo # aqui a string é "0d 0a . 0d 0a"


Pegando os últimos 2 caracteres da linha de arquivo, sem repetir:
##############################################
#arq
00000600536758500000000000000041
00000600536758500000000000000041
00000600677687000000000000000048
00000600677687000000000000000048
---
awk '{ print substr($1,31)}' arq | sort -u
ou
cat arq | rev | cut -c 1,2 | rev | sort | uniq
ou
sed 's/[0-9]\{0,\}\([0-9]\{2\}\)$/\1/g' arq|sort -u
ou
sed 's/.*\(..\)$/\1/'|sort|uniq
resultado:
41
48


usando o sed para apagar os 4 últimos caracteres:
#################################
sed 's/....$//'
apagar especificamente '.dat' e '.txt'do final:
sed 's/\.\(dat\|txt\)$//'


Testando algarismos de IP
##############################################
[ $1 ]&&[ "`echo $1|tr -d 0123456789`" == "" ]\
&&[ $1 -gt 0 ]&&[ $1 -lt 256 ]&&echo OK
Deve cobrir vazio, letras, números com letras, etc.


testando faixa de ip
##############################
linha de chamada:
ipok 255.54.256.25 1.0.0.0 255.255.255.255;echo '$?='$?
1 nome do script
2 ip a testar
3 limite inferior (se fixo pode embutir no script)
4 limite superior (idem)
5 status do return
------- ipok: script, ou alterar para função
ip_=''
for z in 1 2 3 4;do
if [ `echo $1|cut -d. -f$z` -ge `echo $2|cut -d. -f$z` -a \
`echo $1|cut -d. -f$z` -le `echo $3|cut -d. -f$z` ];then
 ip_=$ip_\v
else
 ip_=$ip_\f
fi
done
echo $ip_ # comentar/retirar esta linha depois da fase de debug
[ $ip_ == "vvvv" ]&&exit 0
exit 1
-------


mostrando linhas de um arquivo. Ex.: (sim,não,sim,não,não),Sempre nesse ciclo
###################
seq 12 | sed -n 'p;n;n;p;n;n'
1
3
6
8
11
comando 'n' do sed pra "pular" linhas que não quer mostrar
o comando funciona para a primeira sequencia, e o sed se encarrega de repeti-la





Colorindo uma saída grep
#########################
if [ $# -lt 2 ];then
 echo "Uso: `basename $0` cadeia arquivo1 [arquivo2] ... [arquivon]"
 exit
fi
SMSO=`tput smso`
RMSO=`tput rmso`
arg=`echo "$1" | sed 's/^-/\\\-/'`
shift
if [ $# -gt 1 ];then
 IFS=:
 grep "$arg" $* |
 while read Arq Linha;do
  echo "$Arq:"`echo "$Linha" | sed "s/$arg/$SMSO$arg$RMSO/g"`
 done
else
 grep "$arg" $* | sed "s/$arg/$SMSO$arg$RMSO/g"
fi


Fracionando uma string
######################
echo 00e03de5f2ab | sed 's/../&:/g'
	00:e0:3d:e5:f2:ab:
que é trocar cada dois caracteres por eles mesmos (&)
seguidos de dois-pontos. como sobrou um : no final,
basta arrancá-lo:
echo 00e03de5f2ab | sed 's/../&:/g ; s/:$//'
	00:e0:3d:e5:f2:ab


Separador em vários comandos
############################
IFS - separador de campos. Default value is <space><tab><newline>
outra opção interessante é:
IFS="
"  # com isso o separador será o avanço de linha


Número par ou ímpar, impar no bash
====================================
NUMERO=3;NUM=$[ $NUMERO & 1 ]                                        
if [ $NUM -eq 0 ];then echo "PAR"
else
echo "impar";fi


Mais sed
##################
cat teste.txt | sed 's/ \([0-9/]*\)$/:\1/g; s/\ .*\ / /g; s/:/ /g'
s/ \([0-9/]*\)$/:\1/g  --> Substitui qualquer sequência de números e 
barras, que iniciem com um espaço e estejam no final da linha, pela 
mesma sequênca com um dois-pontos no lugar do espaço.
s/\ .*\ / /g  --> Substitui qualquer coisa que comece e termine com 
um espaço por espaço. Assim ele acaba com os nomes do meio, já que o 
último nome não é separado da data por espaço, e sim por dois-pontos.
s/:/ /g  --> Tira o dois-pontos que colocamos no início e coloca o 
espaço de volta


Retirando zeros iniciais de um número
################
$ echo $((10#000000012345678900))
12345678900
ou:
$ echo $[10#000000012345678900]
12345678900
ou:
$ a=000000012345678900;echo $[10#$a]
12345678900
ou:
a=000000012345678900;printf '%0.0f\n' "$a"
12345678900
ou:
$ echo 000000012345678900 | bc
12345678900
ou:
$ echo 000000012345678900 | sed 's/^0*//'
12345678900


Substituindo todos os zeros iniciais por apenas um zero
####################################
$ echo 0000744303387|sed 's/^0*/0/g'
0744303387
ou:
$ echo 0000744303387|sed 's/^0\+/0/'
0744303387


Retirando zeros iniciais em um campo
#####################
echo "20040902;1;ATM;000000000075;28"|sed 's/;0\+/;/'
20040902;1;ATM;75;28


Obtendo a diferença matemática entre as colunas
###############################################
0.2566    0.2805
.         .
.         .
0.2805 - 0.2566
-------
cat cols.txt | sed 's/\(.*\)\t\(.*\)/\2-\1/' | bc
ou
cat cols.txt | awk '{printf("%f\n",$2-$1)}'
Desvantagem da 1.a, o resultado sai sem o 0 antes do ponto decimal


Pegando uma string após uma palavra
###################################
captura todo o texto apos e inclusive a  palavra 'adsl'
	host1.xx1.adsl.provedor1.com.br
	exmaple.adsl.provedor2.com.br
	adsl.provedor3.com.br
	.123.qualquercoisa.talvez.adsl.provedor4.com.br
cat hosts.txt | sed 's/.*adsl/adsl/g'
adsl.provedor1.com.br
adsl.provedor2.com.br
adsl.provedor3.com.br
adsl.provedor4.com.br


Usuario com poder exclusivo de shutdown
##########################################
No último campo do registro do usuário "user1" no /etc/passwd, troque o
ambiente shell de carga que fica no final desse registro, por exemplo,
"/bin/bash" por "/home/shutdown.bsh".
Troque o "owner" desse script que chamamos de /home/shutdown.ksh para root;
é esse script que deverá ter como única função executar o "shutdown".
O registro do "user1" no arquivo /etc/passwd ficaria mais ou menos assim:
user1:*:0:1:Usuario que faz shutdown:/home/user1:/home/shutdown.bsh





Evitando aborto de scripts,^C
############################
Para impedir açao de (crtl-c, crtl-z , etc) seja no profile ou em
qquer script, utilize o "trap".


tempo de execução de um comando
#################################
# exemplo para o sleep
time sleep 3


obtendo header (cabeçalho) de servidor http
###################################
L=www.google.com
exec 3<> /dev/tcp/$L/80
printf 'GET / HTTP/1.0\r\n\r\n'>&3
while read L<&3&&[ ${#L} -gt  1 ];do echo $L;done
exec 3<&-
ou
/sh/http www.google.com|grep -m 1 -B 100 "^`echo -ne "\r"`$"


obtendo informaçao de servidores diretamente com o bash,shell,script
###################################
exec 3<> /dev/tcp/servidor/80 printf 'GET %s HTTP/1.0\r\n\r\n' /file.htm >&3
sed -e '1,/^'$'\r''$/d' <&3 > file
-ou
wget [url="http://www.my.url.com/with.html.code/index.html"]\
http://www.my.url.com/with.html.code/index.html[/url] -O file 
-ou
lynx --source --dump http://www.and.so.on.com > file
-ou
telnet www.host.domain 80 < file GET \
/dir/subdir/subsubsubdir/file.html HTTP/1.1 END
ou, para vários dir, será que funcionaria?:
wget -r -i - $(echo $url/{$dir1,$dir2,dir3,...})


Automatizando telnet
####################
Executando sem a intervenção do usuário os comandos:
telnet 192.168.42.254 9000 >> /home/1.txt
service patw
user lg
pass lg
fazer isto:
$ echo 'service patw\nuser lg\npass lg|telnet 192.168.42.254 9000


Fazendo autenticação em servidores http
###########################################
lynx -source -auth=username:password 'http://dynamic.zoneedit.com/\
auth/dynamic.html?host=www.mydomain.com' 
ou
wget -O - --http-user=username --http-passwd=password 'http://dynamic.\
zoneedit.com/auth/dynamic.html?host=www.mydomain.com'


Tira tags html
#########################
sed -e ':a' -e 's/<[^>]*>//g;/</N;//ba'


Ativando numlock, teclado numérico, colocar no final de rc.local
#####################################
# ativa para todos os terminais
echo "Enabling NumLock..."
for tty in /dev/tty{1,2,3,4,5,6}; do
 setleds -D +num < $tty
done


Eliminando as quebras de linha do unix
##############################
echo -e "a\nb\nv"|tr -d "\012"


Convertendo final de linha DOS/WINDOWS e UNIX
####################
tr -d \\r <arqW>arqU
ou:
cat dosfile | tr -d \r > unixfile # DOS para Unix, dos,unix
ou:
todos arquivo_unix > newarq_dos
fromdos arquivo_dos > newarq_unix
# "todos" e "fromdos" são binarios e provavelmente existam em /usr/bin


Convertendo formatos de arquivo,strings:
###################################
echo -e "1\n3-a\r\nb"|tr -s [:cntrl:] . # prot.http subst. Ctrls por "."


Substituindo "avanço de linha + caracter" por "caracter", no caso "ponto"
####################
echo -e "00\n11\n.22\n33\n44" | sed ':a;N;$!ba;s/\n\././g'


Retirando lf e cr, DOS,unix,carriage return,line feed
#####################
echo -e "abcdefghij1234567890" | tr -d '\012\015' # 12 e 15 são em octal


Listando códigos de controle
######################
for i in $(echo "obase=8; $(seq 16)" | bc);do
 echo -e "$i=\0$i|" | cat -v
done


????????
###########
nada(){
if [ "$1" = "" ];then
 echo "1. echo "'$2'"|grep "'$3'
 echo 2. for
 echo 3. case
 return
fi
OpT=$1
shift


?????
###########
#echo $1
FaZ="echo $1|grep -F $2"
echo $FaZ
# if [ $? = 0 ];then
 echo '$?'=$?
# fi






CADASTRANDO AUTOMATICAMENTE USUARIO COM SENHA
#########################
for usuario in `cat usuario` # Pergunta, porque a senha nao entrava
 do
 adduser -s /dev/null $usuario
 for senha in `cat senha`
  do
  passwd $usuario (preciso passar o parametro $senha que para o passwd)
 done
done
----- Resp1
echo novasenha | passwd --stdin usuario
-------Resp2
# usuarios.txt: um usuario e senha por linha
while read USER PASS ; do
      adduser -s /dev/null $USER
      echo 'spawn passwd '$USER'
expect "password:"
send '$PASS'
send "\r"
expect "password:"
send '$PASS'
send "\r"' | expect - > /dev/null
done<usuarios.txt
-----Resp3
#CRIA OS USUARIOS
while read texto
do
#PEGA SOMENTE O USARIO
user=`echo $texto | cut -f1 -d":"`
#VERIFICA SE O JÁ EXISTE O USUARIO
pode=`cat /etc/passwd | grep "^""$user"":x"`
#SE NÃO EXISTIR CRIA
if [ "$pode" = "" ]; then
/usr/sbin/useradd -c "$usuario" -d "/home/$user" "$user"
fi
done < seuarquivo
#DEFINE AS SENHAS
cat seuarquivo | chpasswd
Formato do arquivo seuarquivo deve ser :
user1:pass1
user2:pass2


Obtendo senhas aleatórias automaticamente
####################################
head -c 6 /dev/random | mimencode
ou
head -c 6 /dev/urandom | uuencode - | cat -n | grep 2 \
| cut -f2 | cut -c 2,3,4,5,6,7,8,9


Automatizando a troca de senha (passwd com expect)
#####################################
cat usuarios.txt | while read USER PASS ; do
 adduser -s /dev/null $USER
 echo 'spawn passwd '$USER'
 expect "password:"
 send '$PASS'
 send "\r"
 expect "password:"
 send '$PASS'
 send "\r"' | expect - > /dev/null
done


PEGANDO STRINGS ENTRE E, EM VARIAS, POSICOES APOS UM DELIMITADOR
###################### 
grep 'state NEW:' /var/log/syslog|cut -d' ' -f7-10,14,15,21-23


mostrando linhas de um arquivo
##############################
sed --silent 10p arquivo	# somente a linha 10 será mostrada
ou
sed -n 10p
ou
sed '10!d'


PEGANDO UMA PALAVRA POR VEZ DE UMA LINHA,string
########## 
Ex.: palavra1,palavra2,palavra3,...
$ cut -d "," -f1 arquivo	# resp.1
----- resp2
palavra1 = $( echo $linha | cut -d "," -f1 )
palavra2 = $( echo $linha | cut -d "," -f2 )
------resp3
#para utilizar uma palavra de cada vez, nao importa quantas tenha
#na linha, e automaticamente pular para a linha seguinte:
sed 's/,/\n/g' arquivo | while read palavra ; do
  # aqui vc pode colocar qq comando com a palavra
done
#ou
awk -F, '{for (i = 1; i <= NF; i++) { system("<comando> $i");}}' arquivo
#se vc quiser passar a lista de palavras para um comando, e sabe que ela
#não vai estourar o limite de argumentos do shell, pode utilizar:
LISTA=`sed 's/,/ /g
s/\n/ /g' arquivo`
<comando> $LISTA
#ou ainda
sed 's/,/\n/g' arquivo | xargs <comando>


Colocando uma palavra por linha
###################
$ cat usuario
gr|Geraldo Russo|escola|info
gf|Jose da Silva|escola|agro
#
OLDIFS="$IFS"
IFS=""
for i in `awk -F "\|" '{print $2}' usuario`;do
 NOME[$n]=$i
 echo ${NOME[$n]} 
 let n+=1
done
IFS="$OLDIFS"


script recebendo numero indeterminado de argumentos
#####################
i=1
echo "linha = $*"  
for j in $*;do
 echo "argumento $i = $j" 
 i=`expr $i + 1`
done


Exemplo usando lista,variavel,substring,separador
#################################
DENY_ALL="$1 $2 $3 $4 $5 $6 $7 $8 $9"
if [ "$DENY_ALL" != "" ] ; then
 echo "Denying hosts: "
 for rule in ${DENY_ALL} ; do
  echo "$rule" | {
   IFS='<' read shost dhost
   if [ "$dhost" == "" ] ; then
    echo shost=${shost}
   else
    echo dhost=${dhost}
   fi
  }
  echo -n "${rule} "
 done
 echo
fi


cores,colors,tela,screen
##########################
NORMAL="\033[0m";GREEN=$'\e[32;01m';YELLOW=$'\e[33;01m';\
RED=$'\e[31;01m';NORMAL=$'\e[0m';\
echo "$GREEN Green ${RED}Red ${YELLOW}Yellow ${NORMAL}Normal"
-- Listando todas as cores:
M='42;2';echo -en "\e[$M"m;echo '  x          1         2         3'\
'         4         5         6         7      ';\
echo "y  0123456789012345678901234567890123456\
7890123456789012345678901234567890123456";\
y=-1;while [ $[y++] -lt 21 ];do x=-1;echo -ne "\e[0;0m\e[$M"m" \
${y:$[${#y}-1]:1} ";while [ $[x++] -lt 76 ];do T="$x;$y";echo -en \
"\e[$T""m${x:$[${#x}-1]:1}";done;echo;done;\
echo -en "\e[0;0m\e[$M"m'   echo -en "\\e[$x;$y"m$x  ';echo -en "\e[0m"
-- Usando setterm:
f='setterm -foreground';b='setterm -background'
f(){ [ $1 ]||{ $f default;return;};$f $1;}
b(){ [ $1 ]||{ $b default;return;};$b $1;}
echo "  bgbgbgbgbgbgbg    7 cores:  $b b ; $f f"
y=-1;while [ $[y++] -lt 7 ];do x=-1;while [ $[x++] -lt 7 ];\
do b $x;f $y;echo -n "$x$y";done;f 7;b 0;echo;done;f;b


enviando texto p/ tela/null,coment,echo,print
########################################
cat<<EOF
Mostrando este
texto na tela
e enviando
para /dev/null
o resto
EOF
cat>>/dev/null<<EOF
tudo o que esta
neste intervalo
portanto,
nao sera visivel
EOF


Outra opção para comentário, comments
#######################################
---------------
#!/bin/bash
ls antes34
<<=

        Estou tentando aqui uma solução elegante para comentários em escripts
no bash. Assim já parece adequado! Espero que não possua efeitos colaterais
ainda não observados e que, futuras versões do bash não inviabilizem esta solu-
ção.
                                 26/09/03
ls durante56
obs.: para exibir na tela é só trocar "<<=" por "cat<<=" ; se não gostar de "="
use "," ou "c" ou ...
=
ls depois78
----------------
[ ]&&"
outra solução
usando um trecho entre 
aspas que nunca será
executado
"


Nomes de variáveis em variáveis
###############################
suf=23
var=input
read $var$suf
eval "echo $var$suf=\$$var$suf"


executando,executar,conteudo,variavel
####################
$ touch x1 x2
$ ls -la | grep x1
-rw-r--r--    1 thec  staff           0 Jul 11 11:09 x1
$ X="ls -la | grep x1"
$ $X
ls: |: Arquivo ou diretório não encontrado
ls: grep: Arquivo ou diretório não encontrado
-rw-r--r--    1 thec  staff           0 Jul 11 11:09 x1
$ eval $X
-rw-r--r--    1 thec  staff           0 Jul 11 11:09 x1
$


Evitando danos por uma variável vazia
####################################
rm *${ext:-VARIAVEL_VAZIA} # se $ext='' valor '-VARIAVEL_VAZIA' será usado


Pegando campo 2 de uma linha,string palavra
############################################
echo "jksdjkd 1234567 ckjchdsj 123"|awk '{print $2}'
ou
echo "jksdjkd 1234567 ckjchdsj 123"|cut -f2 -d ' '


Elimina (-v) linhas de "arquivo" que contenham 
qualquer linha de "remover",campo,palavra
###################################
grep -v -f remover arquivo



Debug no bash
#######################
_P_="\e[0"m;_V_="\e[0;33;41;1"m
while read _C_;do echo -e "$_V_$_C_$_P_";eval "$_C_";done <script
#Mais:
Bash com opções avançadas de debug => http://bashdb.sourceforge.net/
sh -x ./teu-script.sh # mostra cada linha executada
sh -v ./script # mostra cada comando antes de executá-lo.
??? Para incluir um `read' antes de cada comando: `trap read DEBUG
#Mais:
$ cat debuga.sh
#!/bin/sh
# debuga.sh - script para debugar passo-a-passo scripts shell
[ "$1" ] || { echo "uso: debuga <arquivo.sh>"; exit ; }
sed 'p;s/.*/read foo/' $1 > $1.debug
bash -x $1.debug
rm $1.debug
#Mais:
#registra em arquivo os comandos executados
bash -xv nome-do-script  2>/tmp/log
#Mais:
#apresenta o valor da variavel x antes da execução de cada comando
trap 'echo "debug> \$x=\"$x\""' DEBUG
#pára antes da execução de cada comando
trap read DEBUG


Inserindo palavras em linha de um arquivo
###################################
sed '5 s/^/palavras/' arquivo # insere palavras no inicio da linha 5
sed '5 s/$/palavras/' arquivo # insere no final da linha


Inserindo linha na linha 3 de uma arquivo
###################################
seq 5 | sed -e '3i\' -e 'texto extra'


Ordenar o conteúdo de uma linha
####################################
echo "dghd dsjkd 123 sdhs wrioio wruu" |"tr " " "\n" | sort | tr "\n" " "
#ou
cat teste.txt | while read linha;do
 echo $linha | tr " " "\n" | sort | tr "\n" " ";echo
done
#ou
echo 5 4 3 2 1 | xargs -n1 | sort -n | xargs


Ordenando campos
################
tsort <<EOF
a b c
d
e f
b c d e
EOF


Ordenando linhas arquivo pela 2.a coluna
#############################
$ cat lixo
1  1
3  4
2  5
4  2
6  3
$
$ cat lixo | sort
1  1
2  5
3  4
4  2
6  3
$ cat lixo | sort -k2
1  1
4  2
6  3
3  4
2  5
$
o -k especifica o campo. o -t especifica caractere usado para separar os campos
cat lixo | sort -t "$(echo -ne '\t')" -k2 (se <tab> for o separador)




Para eliminar a 3.a linha de um arquivo
####################################
sed '3d' arquivo


Trocando palavras
####################################################
sed -e 's/PALAVRA_ANTIGA/PALAVRA_NOVA/g' arquivo.txt


TIRANDO O ECHO DA TELA,sem echo,escuro,mostra,visivel
############################
stty -echo;read passwd;stty echo;echo $passwd
#ou
read -s passwd


Para transformar minúsculas em maiúsculas
#########################################
echo $var | tr [a-z] [A-Z]
#ou
echo $var | tr [:lower:] [:upper:]
#para acentuados:
tr aáàbcdeéf... AÁÀBCDEÉF...
#ou colocar outro tr após o primeiro, tratando as exceções:
tr áàé... ÁÀÉ...


Somando 4 + 7 ,cálculos,números,soma,adição
###########################################
expr 4 + 7
#ou
echo 4 + 7 | bc
#ou
echo $[4 + 7]
#ou
echo $((4 + 7))
#ou
let a=4+7;echo $a
#ou
echo $a;((a+=1));echo $a


Primeiras letras maiúsculas
###########################
#Em um arquivo assim:
JOAO DE SOUZA
JOSE DA SILVA
#mudar para:
Joao de Souza
Jose da Silva
#
$ cat x
JOAO DE SOUZA
JOSE DA SILVA
#
sed ':a;G;s/$/AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz/;
> tc;:c;s/\([A-Za-z]\)\([A-Z]\)\(.*\)\n.*\2\(.\).*/\1\4\3/;ta;
> s/\n.*//' x
Joao De Souza
Jose Da Silva
##Para trocar aquele D e deixar mais genérica a solução:
#!/bin/bash
$ cat x | while read l;do
echo $l | sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/;
s/ /\
/g' | sed '/^\(dos\?\|das\?\|de\)$/b;G;
s/$/AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz/;
s/^\(.\)\(.*\)\n.*\(.\)\1.*/\3\2/' | sed ':a;$!N;s/\n/ /;ta'
done
##
$ ./script.sh
Joao de Souza
Jose da Silva
a idéia é no primeiro sed trocar tudo para a-z e deixar uma 
palavra por linha. Depois trocamos a primeira letra para A-Z 
somente se a palavra não for do da de dos das..., basta adicionar os outros 
termos que você não quer trocar a primeira letra para A-Z.


Case exemplo
############################
case $1 in
'Leste')echo L;;
'Oeste')echo O;
esac


Colocando conteúdo de arquivo em  variável
##########################################
VAR=$(cat arq.txt)
#ou
VAR=$(<arq.txt)



Enviando diretórios por email
#######################################
tar -cvf saida.tar nome_do_diretorio
uuencode saida.tar saida.tar > saida.uu
mailx -v -r sender@?.? -s teste destin@?.? < saida.uu


Enviando arquivo anexo por email
######################
fonte: http://www.experts-exchange.com/Operating_Systems/Unix/Q_10310142.html
[
uuencode testfile.txt testfile.dat > testfile.dat
where testfile.txt is the file to be encoded,
testfile.dat - becomes the name of the attachment
and > testfile.dat - the piped encoded file.
Used emailbody.txt as the body of the message,
blanklines.txt to separate. Appended all by:
cat emailbody.txt blanklines.txt testfile.dat > email.msg
mailx -s "Test Email UUENCODE Attachment" somebloke@s... < email.msg
]
#ou
(uuencode testfile.txt testfile.txt )| mailx -s "subject" m@s.com
#ou
uuencode /diretorio/arquivo nome_arquivo | mail -s assunto m@s.dom


email com anexo
#####################
Para enviar:
uuenconde arq1 arq2|mail -s subject user@domain
Ao receber salve a mensagem em disco e:
uudecode nome_arquivo


email com varios arquivos anexos
#####################
(uuencode arq1 arq1 && uuencode arq2 arq2 && ... && uuencode arqn arqn) |\
mail -s "assunto teste" user@dom.com




email com attachment
###########################################
#Serve apenas como exemplo, e aceita apenas um anexo. Modificar para aceitar
#mais arquivos e algumas outras coisas é simples, aqui vai o exemplo, faça as
#modificações. Testado com um arquivo gzip funcionou sem problemas, e
#ainda passado por um servidor não local, exemplo:
$ msh-attach smtp.nho.terra.com.br/25 $m 'arquivo\n-f' "" imdb-280703.gz
250 Ok: queued as 3BC373DC1DA
$ cat !!:0
#!/bin/sh
t[0]="text/plain; charset=us-ascii\n\n"
t[1]="application/octet-stream; name=\"${5##*/}\"\n"
t[2]="multipart/mixed; boundary=\""
t[3]="Content-Type: "
t[4]="${0##*/}: <s/p> <to> <m> <[from]> [file]"
t[5]="MIME-Version: 1.0\n"
t[6]="Content-Transfer-Encoding: base64\n"
t[7]="Content-Disposition: attachment; filename=\"${5##*/}\"\n\n"
alias m='uuencode -m' && shopt -s xpg_echo && b="\n--$RANDOM-$$"
[[ "$#" > "2" ]] || { echo -e "${t[4]}"; exit; };
e() { while [[ "$1" ]]; do echo -e "$1"; read n; shift; done; }
exec 3<>/dev/tcp/$1 <&3 >&3; read n && (set $n && e "helo $2")
e "mail from: <${4:-$USER}>" "rcpt to: <$2>"
[ -f "$5" ] && {
 m="${t[5]}${t[3]}${t[2]}${b:4}\"\ntweeeety :-)\n$b\n${t[3]}${t[0]}$3"
 m=$m"$b\n${t[3]}${t[1]}${t[6]}${t[7]}$(m $5 ? <$5|sed '1d;$d')\n$b--"
} || m="$3\n"; e "data" "$m\n."; echo $n >&2; e "quit"
#ou
uuencode arq.txt  arq.txt | mail seila@seila.com.br
#ou
#é possível tambem usar o metamail em um shell-script com uns "read -p"...
$ rpm -qi metamail
Name        : metamail                     Relocations: (not
relocateable)
Version     : 2.7                               Vendor: Conectiva
Release     : 28cl                          Build Date: Sáb 14 Abr 2001
13:03:27 BRT
Install date: Qua 12 Fev 2003 09:22:37 BRST      Build Host:
mapi2.distro.conectiva
Group       : Correio Eletrônico            Source RPM:
metamail-2.7-28cl.src.rpm
Size        : 300980                           License: BSD
Summary     : Coleção de utilitários de manipulação MIME
Description :
Metamail é uma implementação de MIME ( Multipurpose Internet
Mail Extensions), um padrão proposto para mail multimídia
na Internet. Metamail implementa MIME, e também implementa
extensibilidade e configuração via o mecanismo "mailcap", descrito
em um RFC que acompanha o documento MIME.


Contar arquivos com o tar
##########################
tar -ztvf nome.tar.gz | wc -l


Como mostrar a linha 2
#########################
echo -e "A\nB\nC" | sed '2!d'


Exemplo dinâmico de criação de vetores/matriz
###############################
cd /;vetor=(`ls`);echo ${vetor[0]}


Validação CPF CNPJ com bash
################################
#FUNÇÃO DESENVOLVIDA PARA O BASH, PARTINDO DO ALGORITMO VISTO EM:
# http://www.clubedainformatica.com.br/documentos/mostraartigo.php?artigo=62
cpf() {
#Verifica se o comprimento é 11
[ ${#1} -eq 11 ]||return

#Verifica se só há algarismos
[ ! "${1//[0-9]/}" ]||return

#Exclui os digitos verificadores informados
CPF=${1:0:9}

for d in 8 9;do
 B=$((${#CPF}+1))
 P=0
 for i in $(echo $(seq 0 $d))
  do P=$(($P+$((${CPF:$i:1}*$(($B-$i))))))
 done

 #Define digito verificador
 Q=$(($P/11))
 D=$(($P- $((11*$Q))))
 [ $D -lt 2 ]&&D=0||D=$((11-$D))

 #Acrescenta dígito verificador ao CPF
 CPF=$CPF$D

done

[ $CPF == $1 ] \
# ||{ echo CPF $1 inválido, correto seria $CPF;return 1;}
# Tirar comentário (#) da linha acima para exibir mensagem de erro
}
##### outra solução, vista no grupo shell-script do Yahoo
#!/bin/bash
## shell script em bash2 para validação de CIC
for digpos in 10 11; do
 matriz=(`seq $digpos 2`);dig=0;pos=1
 for fator in ${matriz[*]}; do
  let dig=$dig+`echo $1 | cut -c$pos`*$fator;let pos=$pos+1
 done
 dig=`echo 11-$dig%11 | bc`
 if [ $dig -ge 10 ]; then dig=0;fi
 if [ $dig -ne `echo $1 | cut -c$digpos` ]; then
  echo -e "\nCIC inválido\n";exit
 fi
done
echo -e "\nCIC válido\n"
#####outra, também no yahoo
#!/bin/bash
for digpos in 10 11;do
 dig=0
 pos=0
 for fator in `seq $digpos 2`;do
  dig=$((dig + ${1:$pos:1} * fator))
  pos=$((pos + 1))
 done
 dig=$((11 - dig % 11))
 [ $dig -ge 10 ] && dig=0
 [ $dig -ne ${1:$pos:1} ] && { echo "CPF invalido"; exit; }
done
echo "CPF valido"


Limitando escrita de redirecionamento
###################################
$ cat teste.txt
teste
$ set -o noclobber
$ echo teste > teste.txt
bash: teste.txt: cannot overwrite existing file


Pegando o número de um processo
################################
$ ps --no-headers -C program -o %p  
 1770
 1772
ou:
PID=`ps -ef|grep processos_cron|grep -v grep|awk '{print $2}'`>/dev/null
ex. economizando um grep:
ps ax | grep [p]rograma


Pegando o número de processo do próprio script
##############################################
ps a|grep "$0"|grep -v grep                 
ps --no-headers -C `basename $0`


Retirando final do nome de arquivo
################################
$ basename teste.txt.bz2 .bz2
teste.txt


Testando se caract é letra
##############
[[ "$VAR" == [A-z] ]]&&echo yes


Só letras minusculas e numeros
##################################
$ f(){ r=${1//[[:lower:][:digit:]]/} && return ${#r}; }
# Colocamos em `r' o parâmetro de f, tirando todos `lower' e `digit', 
#retornamos o tamanho de `r'. Sabemos que qualquer função que retorna 0 é
# verdadeira, no caso de f o resultado ainda pode ser usado para informar
# quantos caracteres estavam errados. Exemplo:
g(){ f "$1" && echo é valido || echo não validos: $?; }
for i in "" 1abc3 1abc, .abc,; do echo -n "'$i': " && g "$i"; done


Substitui qualquer quantidade sequencial do caracter 1 por uma do carcter 2
##########################################
tr -s 1 2
tr -s ' ' ' ' # bom para subtituir vários espaços por um único


Trocando caracteres por outros,trocando,substituir,arquivo
###########################
script arq1 arq2 arq3 ...
cat "$@" |tr '\344\366\374\304\326\334\337' '\204\224\201\216\231\232\341'


Só digitos,algarismos
##################################
[ `echo $1 | tr -d '[:digit:]' | wc -w` -ne 0 ] &&  { 
echo "Valor não numérico"; exit; }
echo "Valor numérico"
#ou
[ ! `echo $1 | tr -d [0-9]` ]&&echo "Valor numerico"||echo "Valor nao numerico"
#ou
f() { r=${1//[[:digit:]]/}; return ${#r}; }
#Ou mais simples:
f() { [ ! "${1//[[:digit:]]/}" ]; }
#Outra função apenas para testar, chama f:
g() { f "$1" && echo numérico || echo não numérico; }
#ou, em qualquer shell
f() { [ "$1" = "${1#*[^1234567890]}" ]; }
#ou
if expr "$1" + 1 > /dev/null 2>&1;then   
 echo "Valor numérico em "'$1'
else 
 echo "Valor não numérico" 
fi 


Colocando caracter no inicio de linha que contem determinada string
################################################
IP=172.16.255.255
rm  /diretorio/iptable_output
while read REGRA;do
 if [ $(grep ${IP} ${REGRA}) ];then
  echo "\#${REGRA}" >> /diretorio/iptable_output
 else
  echo   "${REGRA}" >> /diretorio/iptable_output
 fi
done < /diretorio/iptable_input
mv /diretorio/iptable_output /diretorio/iptable_input


calculando com o bash
###########
#porcento
$ x=3;y=15;echo $[x*100/y]%
20%
#percento com 2 decimais
x=7;y=31;r=$[x*10000/y];echo ${r%??},${r: -2}%
22,58%
#com 3
$ x=2;y=176;r=$[x*100000/y];echo ${r%???},${r: -3}%
1,136%


Quando o shell(bash) usa a base númerica errada
#########################
echo $[ 10 * 60 + 09 ]
bash: 10 * 60 + 09: value too great for base (error token is "09")
#números inteiros na base 10 não devem ser iniciados com o algarismo zero
#mas é possível, basta avisar o shell que a base é dez:
echo $[10*60+10#09]
609


Números em qualquer base no bash,hexadecimal,octal,binário, até 64
################################
declare -i var=16#f;echo $var


Convertendo números entre bases
###############################
d2b(){ echo "obase=2;$1"|bc;}
d2h(){ echo "obase=16;$1"|bc;}
h2d(){ echo "ibase=16;`echo $1|tr a-z A-Z`"|bc;}
h2b(){ echo "ibase=16;obase=2;`echo $1|tr a-z A-Z`"|bc;}
b2d(){ echo "ibase=2;$1"|bc;}
b2h(){ echo "ibase=2;obase=16;$1"|bc;}
#Exemplo de uso:
h2d 5a7C


Convertendo hexadecimal, decimal,ascii,octal
##############################################
#hex>dec 
 let x=0x3f;echo $x
 let x=0xfffe;echo $x
 echo $[0xfffe]
 echo $((0xfffe))
 nao interativo: bash -c 'let x=0x3F ; echo $x'
 usando bc: echo 'ibase=16;3F'|bc
 printf "%d\n", 0x7B
#dec>hex
 /sh/funcs: d2h 1234 # (lim.pouco abaixo de
			999999999999999999999999999999999999)
 printf "%02X\n" 1234 # (lim.pouco abaixo de
 			99999999999999999999)
 echo "obase=16;ibase=10;1234"|bc # (lim.muito alto)
#asc>hex
 echo -n ABCDEFGHIJKLMNOPQRSTU|hexdump -C|cut -c9-60|tr -d ' \n'
 echo -n ABCDEFHIJKLMNOPUFDTYTRFD|xxd|cut -c10-50|tr -d ' \n'
#asc>oct
 echo ABCD|hexdump -b
#hexa>asc
 echo -n "61626364"|xxd -p -r


Ler i caracteres, sem enter ao final
####################################
read -n i (ler i caracteres):
read -p 'digite opcao ' -n 1 ver # para 1 caracter


removendo diretorios encontrados pelo find
##########################################
find . -type d -name 'fuub*' -exec rm -irv {} \;
rm: remove directory `./fuu/fuubar'?
removed directory: `./fuu/fuubar'


Procurar string em arquivos
#############################
grep -l sequencia-de-caracteres * # procura no diretório atual
#ou, para procurar a partir de um diretório, recursivamente:
find diretorio-inicio-de-pesquisa -type f -print | xargs grep -l \
sequencia-de-caracteres
#ou
find diretorio-inicio-de-pesquisa -type f -exec grep -l \
sequencia-de-caracteres {} \;
#ou
grep -R sequencia-de-caracteres diretorio-inicio-de-pesquisa/*


copia estrutura de diretórios
#############################
cptree(){ [ $1 ]||{
 echo copia a estrutura de diretórios a partir do diretório corrente
 echo uso: cptree destino;return;}
# for i in `find . -type d`;do echo mkdir -p $1/`echo $i|cut -c2-`;done
#find . -type d -exec mkdir -p /path/novo/{} \;
 for i in `ls -lR|grep '^d'|cut -c57-`;do echo mkdir -p $1/$i;done
}


substituição geral de ç ã õ por c a o 
#################################
sed 's/ç/c/g;s/ã/a/g;s/õ/o/g' arquivo > arquivo2


substituição geral de caracteres acentuados por não acentuados
#################################
sed "s/[\"']//g"'
 y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/;s/^-/_/
 y/ÀàÁáÂâÃãÄÅäåÈèÉéÊêËëÌìÍíÎîÏïÇçÑñ/aaaaaaaaaaaaeeeeeeeeiiiiiiiiccnn/
 y/ÒòÓóÔôÕõÖöÙùÚúÛûÜüߢУØø§µÝý¥¹²³/oooooooooouuuuuuuubcdloosuyyy123/
 s/[^A-Za-z0-9._-]/"
#ou
  y/áóúç/aouc/
#ou
  tr áóúç aouc


Tratando strings
##################
#para ler o numero do usuário numa variável:
read NUMERO
#para saber o tamanho total dessa variável:
echo ${#NUMERO}
#para inserir o sinal de + entre os números:
echo 12345 | sed 's/./&+/g'
1+2+3+4+5+
#para fazer a conta:
echo 2+2 | bc
#ou:
expr 2 + 2


Ordenando campos de um arquivo
####################
#campos separado por (;), exemplo de uma linha:
#200031023;60;78;73463;100;655;65867;3743;32
#ordenar usando a primeira coluna, depois a 4ª, depois a 5ª depois a 8ª:
sort -t';' -n -k1 -k4 -k5 -k8 arquivo
#com o -t você especifica o separador
#o -k diz a seqüência dos campos na ordenação


Pegando o valor de uma variável de nome variável
####################
variáveis exemplo arq1,arq2,arq3,...
eval 'echo -e "\t\t$'arq$c'"'


separar arquivo mailbox em arquivos individuais
#####################
o programa formail do pacote procmail pode ajudar
ou usando programas de string:
para casar From: ???@??? no começo de linha:
^From [^@]*@
e para colocar como alternativa o From -
^From \(-\|[^@]*@\)
o ^ é um marcador de começo de linha
o \| separa as alternativas
o \( e \) apenas agrupam (como em expressões matemáticas)


Contando linhas de arquivo
###############
sed -n '$=' arquivo
#a flag '-n' suprime a saída padrão, o indicador '$' é a última linha e o
# comando '=' imprime o número da linha
#ou
wc -l arquivo


Coleta de dados, com filtro e armazenamento
##########################
get(){
 [ -f arquivo ]|| echo -n >arquivo
 eval "
 while [ \"\$3\" == \"\${3/:\$$2:/}\" ];do read -p \"$1$3 \" $2;done
 grep -q ^$2= arquivo||echo $2=\$$2 >>arquivo
 "
}
. ./arquivo # retorna dados armazenado; os já ok nao serão pedidos
get "número de canais" CH :1:2:3:4:5:6:7.1:
get "legendas" LI :0:1:
echo $CH
cat arquivo


menu no bash
############
#funções:
menu(){ z=
 while [ $1 ];do echo "${1:0:1} ${1:1}";z="$z|${1:0:1}";shift;done;z="$z|"
 while read -s -n 1 menu;do
  [ "$z" != ${z/|$menu|/} ]&&return 0
  echo -ne " \atecla invalida, aguarde ...\r"
  while read -t 2 -n 1 menu;do echo -n ;done
  echo -ne "                            \r"
 done
}
menu Iincluir Aalterar 2apagar Ssair
echo menu=$menu
#outra:
menu1(){ x=0;y=;z=
while [ $1 ];do x=$[x+1];echo $x.$1;z=$z$x;shift;done
while [ $z == ${z/$y/} ];do echo -ne '\r';read -n 1 y;done;echo;return $y
}
menu1 incluir alterar apagar sair;x=$?;echo x=$x
#builtin:
select x in incluir alterar apagar sair; do [ "$x" ]&&break;done;echo x=$x


menu no console com dialog
############
#ex.:
dialog --stdout --title 'Nome' \
--inputbox 'Digite seu nome: ' 15 40 >> dados.txt
#ex.:
----arquivo lixo
192.168.0.1
192.168.0.2
168.168.0.3
------- script usando dialog gera menu para seleção itens de lixo 
CMD=''
for IP in $(cat lixo); do CMD="$CMD $IP ip off"; done
echo $CMD
192.168.0.1 ip off 192.168.0.2 ip off 168.168.0.3 ip off
dialog --checklist escolha 0 0 0 $CMD
#Mais detalhes: man dialog


Divide um arquivo grande em arquivos menores (separador linha em branco)
##############################################
#!/bin/sh
inicio=1;passo=3;fim=50;i=$inicio
while [ $i -lt $fim ]
 do maximo=$((i+passo))
 cat arquivo | 
 awk 'BEGIN { MIN=$i ; MAX=$maximo ; FS="\n" ; RS="" }
 { if (NR>=MIN && NR<MAX) print $0,"\n" }' > saida$i.txt
 i=$maximo
done


O terminal atual,console,tty,data
##########################
TTY='/dev/'`ps |tail -n 1 |cut -c7-11`
Para pasar dados do teclado para um terminal qualquer
read -s -n 1 -t 10 yy < $TTY