Programação do Shell

Introdução

• Por que programação shell?
  • Permite que administradores criem pequenos programas para automatizar a administração do sistema
  • Permite configurar melhor o sistema
    • Por exemplo, toda a configuração da sequência de boot do UNIX envolve scripts shell
• O que é programação shell
  • Criação de um arquivo de texto contendo comandos do UNIX e comandos especiais do shell para:
    • Variáveis
    • Testes
    • Laços
    • Funções
    • Comentários
• Como executar?
  • Interpretação do arquivo de script por um shell
  • Interpretação pode ser lenta?
    • Sim! E lembre que cada comando que o script chama dispara um processo
    • Uma alternativa mais rápida: programar em C ou Java
    • Uma alternativa boa entre os dois extremos: perl

Scripts Shell

• O primeiro programa
  • O texto abaixo está no arquivo "alo"

#!/bin/bash
# Este programa diz alo
echo "Alo $LOGNAME, tenha um bom dia!"

• Execute o programa:

$ ./alo
bash: ./alo: Permission denied
$ bash alo
Alo  jacques, tenha um bom dia!
$ chmod a+x alo
$ ./alo
Alo  jacques, tenha um bom dia!
$ PATH=$PATH:.
$ alo
Alo  jacques, tenha um bom dia!

Variáveis e Parâmetros

Algumas variáveis pré-definidas

• $LOGNAME, $HOSTNAME, $TERM, ...
• $$ (o process id do processo corrente - o shell)

tempfile=/tmp/temp.$$
algum comando > $tempfile
.
.
comandos que usam a informação em $tempfile
.
.
rm $tempfile

• $? (o status de saída do último comando)
  • 0 significa ok
  • não 0 significa que houve erro

Substituição avançada de variáveis

Parâmetros

• Quando um script é chamado, pode receber parâmetros na linha de comando

$ cat soma
#!/bin/bash
val=`expr ${1:-0} + ${2:-0} + ${3:-0}`
echo A soma eh $val
$ soma 2 3 5
A soma eh 10
$ soma 2 3
A soma eh 5
$ soma
A soma eh 0

• Isso é equivalente:

#!/bin/bash 
echo A soma eh `expr ${1:-0} + ${2:-0} + ${3:-0}`

• Tratamento de parâmetros

• Observe que $10 não é o parâmetro 10, é $1 concatenado com "0"
  • Isso não significa que só podemos ter 9 parâmetros: não há limite (quase)
  • Veremos como acessar os demais parâmetros depois
• Exemplo

$ cat l
#!/bin/bash 
ls -l $*

• Como formar parâmetros
  • Os exemplos abaixo parecem iguais mas o primeiro tem 4 parâmetros, o segundo tem 1 parâmetro e o terceiro tem 3 parâmetros

$ echo a b c d
a b c d
$ echo "a b c d"
a b c d
$ echo "a b" c d
a b c d

Entrada-Saída Básica

• A saída é feita basicamente a saída de outros comandos que estão no script
• Se precisar de um "print", usae-se o comando echo
• A leitura de informação da entrada padrão é feita com o comando do shell "read"

$ cat testaread
#!/bin/bash
read x
echo Voce falou $x

$ cat lenome
#!/bin/bash
echo -n "Favor digitar seu nome: "
read nome
echo "Seu nome eh $nome"

Testes

Um problema a resolver

• Você acabou de ser nomeado administrador de sistema numa empresa. O administrador anterior saiu correndo quando descobriu que um servidor principal da empresa estava sendo usado para guardar pornografia,  warez (software pirata) e instruções para a fabricação de bombas caseiras.
• Suspeita-se que várias pessoas da empresa, além do ex-administrador de sistema, estavam envolvidas com a captação dessa informação. Pediu-se que você fizesse um programa para identificar pessoas que acessam sites "indesejáveis" e avisá-los da política de empresa acerca do uso apropriado da Internet com recursos da empresa. Idealmente, você deve produzir um relatório informando quem acesso quais sites restritos e quantas visitas foram feitas.
• A informação a ser analizada está num arquivo "netwatch" que contém uma lista das pessoas e dos acessos que elas fizeram
  • Um exemplo do arquivo segue abaixo

ARQUIVO: netwatch

jamiesob mucus.slime.com
tonsloye xboys.funnet.com.fr
tonsloye sweet.dreams.com
root sniffer.gov.au
jamiesob marvin.ls.tc.hk
jamiesob never.land.nz
jamiesob guppy.pond.cqu.edu.au
tonsloye xboys.funnet.com.fr
tonsloye www.sony.com
janesk horseland.org.uk
root www.nasa.gov
tonsloye warez.under.gr
tonsloye mucus.slime.com
root ftp.ns.gov.au
tonsloye xboys.funnet.com.fr
root linx.fare.com
root crackz.city.bmr.au
janesk smurf.city.gov.au
jamiesob mucus.slime.com
jamiesob mucus.slime.com

• Os sites proibidos estão contidos num arquivo "netproib":

ARQUIVO: netproib

mucus.slime.com
xboys.funnet.com.fr
warez.under.gr
crackz.city.bmr.au
www.hotwarez.com.br

• Desenvolva um script que satisfaça os requisitos
  • Você pode ignorar qualquer consideração de ética, privacidade e censura :-)

Comandos de testes no shell

if comando
then
  comandos executados se "comando" retornar status "ok" (0)
else
  comandos executados se "comando" retornar status "não ok" (diferente de 0)
fi

if comando1
then
  comandos executados se "comando1" retornar status "ok" (0)
elif comando2
  comandos executados se "comando2" retornar status "ok" (0)
else
  comandos executados se não entrar nos "if" acima
fi

comando1 && comando2
# construção acima eh equivalente a:
if comando1
then
  comando2
fi

comando1 || comando2
# construção acima eh equivalente a:
if comando1
then
  :
else
  comando2
fi

Início do script scan

#!/bin/bash
# ARQUIVO: scan
if ls netwatch && ls netproib
then
  echo "Achei netwatch e netproib"
else
  echo "Nao pode achar um dos arquivos de dados - caindo fora"
  exit 1
fi

• O comando exit encerra o shell e retorna um status para o processo "pai"

Testes com [ ... ]

• O comando "test" e a construção [ ... ] são equivalentes e permitem testar condições envolvendo strings e arquivos
• Exemplo: o último script poderia ser:

#!/bin/bash
# ARQUIVO: scan
if [ -r netwatch ] && [ -r netproib ]
then
  echo "Achei netwatch e netproib"
else
  echo "Nao pode achar um dos arquivos de dados - caindo fora"
  exit 1
fi

• As opções de [ ... ] seguem:

Testes de strings

Testes numéricos

Testes de arquivos

Operadores adicionais

A construção case

echo -n "Sua reposta: "
read resp
case "$resp" in
Y* | y*)
  resp="sim"
  ;;
N* | n*)
  resp="nao"
  ;;
*)
  resp="talvez"
  ;;
esac
echo $resp

• Observe o casamento de expressões regulares, acima

Laços

O comando while

while comando
do
  comandos executados enquanto "comando" retornar status "ok"
done

• O que o seguinte programa faz?

#!/bin/bash
# ARQUIVO: list
#
numLinha=1
while read linha
do
  echo "$numLinha $linha"
  numLinha=`expr $numLinha + 1`
done < $1

• O que o seguinte programa faz?

while read linha
do
  usuario=`echo $linha | cut -d" " -f1`
  site=`echo $linha | cut -d" " -f2`
  if [ "$usuario" = "$1" ]
  then
    echo "$usuario visitou $site"
  fi
done < netwatch

O comando for

for var in lista_de_palavras
do
  no corpo do loop, temos $var = a próxima palavra da lista
done

• O que o seguinte programa faz?

for verifUsuario in $*
do
  while read linha
  do
    while read verifSite
    do
      usuario=`echo $linha | cut -d" " -f1`
      site=`echo $linha | cut -d" " -f2`
      if [ "$usuario" = "$verifUsuario" -a "$site" = "$verifSite" ]
      then
        echo "$usuario visitou o site proibido $site"
      fi
    done < netproib
  done < netwatch 
done

Funções

• Uma nova versão do nosso trabalho

#!/bin/bash
# ARQUIVO: scan
#

verificaArquivos() {
  if [ -r netwatch -a -r netproib ]
  then
    return 0
  else
    return 1
  fi
}

# Programa principal

if verificaArquivos
then
  echo "Arquivos de dados achados"
else
  echo "Nao pode achar um dos arquivos de dados - caindo fora"
  exit 1
fi

# o resto do trabalho

• Outra versão

#!/bin/bash
# ARQUIVO: scan
#

verificaArquivos() {
  [ -r netwatch -a -r netproib ]
  return $?
}

# Programa principal

if verificaArquivos
then
  echo "Arquivos de dados achados"
else
  echo "Nao pode achar um dos arquivos de dados - caindo fora"
  exit 1
fi

# o resto do trabalho

Sinais e Traps

• Sinais são enviados para processos de várias formas
  • Pelo kernel, quando um processo faz besteira
  • Pelo usuário, usando o teclado (^C, ^\, encerrando a sessão)
  • Usando o comando kill
• Ação normal: o processo morre
  • Porém, um processo pode ignorar os sinais ...
  • ... ou captura-los para fazer algo
• Quais são os sinais?
  • Os sinais em negrito merecem discussão aqui, pois o administrador deve entendê-los

• Sintaxe de captura de sinais

trap "comandos" sinais ...

• Exemplo simples de captura de sinais

#!/bin/bash
tempfile=/tmp/temp.$$
trap "rm -f $tempfile" 0 1 2
algum comando > $tempfile
.
.
comandos que usam a informação em $tempfile
.
.
# nao precisa remover temp no fim: o trap se encarrega disso

Depuração

• O comando "set -x" liga o rastreamento da execução de comandos
• O comando "set +x" desliga o rastreamento

Técnicas Avançadas

• Por enquanto, nosso código de "scan" é o seguinte

#!/bin/bash
# ARQUIVO: scan
#

verificaArquivos() {
  [ -r netwatch -a -r netproib ]
  return $?
}

# Programa principal

if verificaArquivos
then
  echo "Arquivos de dados achados"
else
  echo "Nao pode achar um dos arquivos de dados - caindo fora"
  exit 1
fi

for verifUsuario in $*
do
  while read linha
  do
    while read verifSite
    do
      usuario=`echo $linha | cut -d" " -f1`
      site=`echo $linha | cut -d" " -f2`
      if [ "$usuario" = "$verifUsuario" -a "$site" = "$verifSite" ]
      then
        echo "$usuario visitou o site proibido $site"
      fi
    done < netproib
  done < netwatch 
done

• Ainda não satisfizemos todos os requisitos, pois falta a contagem do número de visitas ...

eval

• Passa duas vezes numa linha de comando
  • Só executa depois da segunda passagem

$ pipe=\|
$ eval ls $pipe more

Voltando ao programa scan

• Como fazer a contagem de visitas?
• Se um usuário jacques visitar www.hotwarez.com.br, teremos a contagem de visitas feita na variável $jacqueswwwhotwarezcombr
• Segue o programa final

#!/bin/bash
logFile=netwatch
proibFile=netproib
passwdFile=$passwdFile

processaLogFile() {
  # Varre o arquivo $logFile e salva combinacoes usuario/site
  # para sites que estao na lista de sites proibidos

  while read linha
  do
    nomeUsuario=`echo $linha | cut -d" " -f1`
    site=`echo $linha | cut -d" " -f2 | sed s/\\\.//g`
    while read verifSite
    do
      verifSite=`echo $verifSite | sed s/\\\.//g`
      # echo $verifSite $site
      if [ "$site" = "$verifSite" ]
      then
        usuarioSite="$nomeUsuario$verifSite"
        if eval [ \$$usuarioSite ]
        then
          eval $usuarioSite=\`expr \$$usuarioSite + 1\`
        else 
          eval $usuarioSite=1
        fi
      fi
    done < $proibFile
  done < $logFile
}

relatorio() {
  # Ve todas as combinações de usuários e sites restritos
  # Se uma variavel de visitas existir, inclua no relatório
  for usuario in $*
  do
    while read siteVisitado
    do
      verifSite=`echo $siteVisitado | sed s/\\\.//g`
      usuarioSite="$usuario$verifSite"
      if eval [ \$$usuarioSite ] 
      then
        eval echo "$usuario: $siteVisitado \$$usuarioSite"
        numUsuarios = `expr $numUsuarios + 1`
      fi 
    done < $proibFile
  done 
}

usuariosEmPasswd() {
  # cria uma lista de usuarios a partir do arquivo de passwd
  cut -d":" -f1 < $passwdFile
}

verificaArquivos() {
  [ -r netwatch -a -r netproib ]
  return $?
}

# Programa principal
# remover comentario na linha seguinte para depurar
#set -x


if verificaArquivos
then
  echo "Arquivos de dados achados"
else
  echo "Nao pode achar um dos arquivos de dados - caindo fora"
  exit 1
fi

numUsuarios=0

if [ $# -gt 0 ]
then
  listaUsuarios=$* 
else
  listaUsuarios=`usuariosEmPasswd`
fi

echo
echo "*** Relatorio de Acesso a Sites Proibidos ***" 
echo
echo "

Segue uma lista de usuarios que visitaram sites proibidos,
o site visitado e o numero de visitas

"
processaLogFile
relatorio $listaUsuarios

echo

if [ $numUsuarios -eq 0 ]
then
  echo "Nao houve acesso a sites proibidos"
else
  echo "$numUsuarios combinacoes de usuario/site descobertas"
fi

• Na realidade, este programa seria mais simples usando perl
  • O truque do "eval" é muito feio!
• Aqui, serviu para mostrar construções avançadas do shell
• Poderíamos ainda tratar uma opção do programa "-d" para ligar o debug

...
# Programa principal
if [ "$1" = "-d" ]
then
  set -x
  shift
}
...

Um Exemplo Final

Definição do Problema

• Seu servidor FTP provê acesso a arquivos na área /pub do sistema de arquivos
• Você desconfia que poucas pessoas estão usando o serviço FTP (devido à WWW) e você gostaria de examinar o log FTP usando uma ferramenta útil
• Você quer um programa que examine o log FP e produza estatísticas de uso sobre um certo tópico. As estatísticas devem incluir:
  • O número de acessos por usuário
  • O número de bytes transferidos
  • O número de hosts que acessaram o serviço
• O script deve aceitar uma palavra chave (o tópico de interesse) e um comando dizendo qual é a estatística desejada
  • O comando pode ser: "users", "bytes" ou "hosts"

Informação adicional necessária

• Suponha que o arquivo de log tenha o seguinte conteúdo, um acesso por linha
  • nomeUsuário poderá ser uma identificação fornecida se o FTP for anônimo

hostRemoto tamanhoEmBytes nomeDoArquivo nomeUsuário

• Exemplo do arquivo de log /var/log/ftp.log

aardvark.com 2345 /pub/85349/lectures.tar.gz flipper@aardvark.com
138.77.8.8 112 /pub/81120/cpu.gif sloth@topaz.cqu.edu.au

• Podemos supor que o nome do arquivo sempre iniciará com /pub
• Exemplos de interação com o programa

$ scanlog 85321 users
jamiesob@jasper.cqu.edu.au 1
b.spice@sworld.cqu.edu.au 22
jonesd 56

$ scanlog 85321 bytes
2322323

$ scanlog 85321 hosts
5

$ scanlog 85321 bytes users
2322323
jamiesob@jasper.cqu.edu.au 1
b.spice@sworld.cqu.edu.au 22
jonesd 56

• O programa segue:

#!/bin/sh

LOGFILE="ftp.log"
TEMPFILE="/tmp/scanlog.$$"
trap "rm $TEMPFILE" 0 1 2
# funcoes


#----------------------------------------
# printNumHosts
# - mostra o numero de maquinas unicas que acessaram o topico

printNumHosts() {
  cut -f1 $TEMPFILE | uniq | wc -l
}

#-------------------------------------------------------
# printUsers
# - mostra os usuarios que acessaram o topico

printUsers() {
  for user in `cut -f4 $TEMPFILE | sort | uniq`
  do
    echo $user `grep $user $TEMPFILE | wc -l`
  done
}

#-------------------------------------------------------
# printBytes
# - mostra o numero de bytes transferidos

printBytes() {
  # se a entrada for 2 3 4 (em 3 linhas), queremos fazer 2 + 3 + 4
  numstr=`cut -f2 $TEMPFILE | sed "s/$/ + /g"`
  expr $numstr 0
}


#------------------------------------------------------
# processaAcao
#

processaAcao() {
  # traduzir para minusculas
  acao=`echo $1 | tr [a-z] [A-Z]`
  case "$acao" in
    bytes) printBytes ;;
    users) printUsers ;;
    hosts) printNumHosts ;;
    *) echo "Comando desconhecido: $acao" ;;
  esac
}


#---- Programa principal

if [ $# -lt 2 ]
then
  echo "Sintaxe: $0 topico [users|bytes|hosts]" >&2
  exit 1
fi

topico=$1
shift
grep "/pub/$topíco" $LOGFILE > $TEMPFILE

for aAcao in $*
do
  processaAcao "$aAcao"
done

• Como exercício, refaça o comando acima usando as opções -u, -b e -h em vez do comando "users", "bytes" e "hosts"
  • Aceite qualquer combinação de opções:
    • -u
    • -u -b
    • -ub
    • -bu
    • etc.

Coisas que falta incluir

• Comando "."
• sub-shells com ()
• (cd ...; tar ...) | (cd ...; tar ...)
• export

programa anterior