SCRIPT BASH

Bash shell in 30″

Variabili di ambiente

PATH – definisce i percorsi dove trovare tutti i programmi eseguibili
HOME – directory dell’utente
MAIL – il file dove vengono archivate le email dell’utente
IFS – contiene la stringa che viene utilizzata come separatore per le linee di comando. Il valore preimpostato e’ uno spazio
PS1 e PS2 – sono rispettivamente il primo e il secondo prompt di bash. I valori preimpostati sono “$” per il primo e “>” per il secondo
USER – il nome della login utente
TERM – indica il terminale utilizzato dall’utente (importante da impostare per alcuni editor testuali, es vi)
SHELL – indica il tipo di shell utilizzata dall’utente
Note:

    * per utilizzare il valore contenuto in una variabile si deve scrivere il simbolo $ davanti al nome della variabile.
      Es.
      echo $USER
      stampa il valore contenuto nella variabile USER
    * l’assegnamento avviene con il nome della variabile, seguito dal simbolo “=” e successivamente dal valore da associare (meglio se fra virgolette).
      Es.
      PATH="/usr/local/bin:$PATH"
      aggiunge alla variabile PATH il percorso /usr/local/bin
    * le modifiche alle variabili d’ambiente possono essere rese persistenti se archiviate nel file $HOME/.bashrc

Regole di base per i file di script

    * iniziare sempre la prima riga con
      #!/bin/bash
      serve ad indicare allo script il percorso assoluto della shell da eseguire
    * una volta creato il file di script occorre dare i permessi di esecuzione
      con
      chmod ugo+x nome_dello_script.sh
      o con (forma compatta)
      chmod
    * aggiungere al nome del file l’estensione .sh, non si tratta di una regola ma di una buona norma per far sapere che si tratta di uno script di shell

Strutture di controllo

il costrutto if
valuta una condizione ed esegue un blocco di comandi
Sintassi:
if la_condizione_è_vera
then
operazioni da eseguire
else
operazioni da eseguire
fi
e’ possibile usare anche una forma piu’ complessa qualora le condizioni sia di piu’ usando questa forma
if la_condizione_è_soddisfatta
then
operazioni da eseguire
elif altra_condizione_soddisfatta
then
operazioni da eseguire
else
operazoni da eseguire
fi

Esempio
if grep "aiuto" testo.txt
then
echo "Ho trovato la parola che stavi cercando"
else
echo "Non ho trovato la parola che stavi cercando"
fi
Il comando grep “aiuto” testo.txt restituisce true se trova la parola aiuto all’interno del file testo.txt
i test

test è una funziona interna della shell.
Il test valuta la condizione posta alla sua destra e restituisce true o false in relazione al risultato.
Esistono diverse tipologie di valutazione.
Qui l’elenco
operatori di confronto
-eq uguale a
-lt minore di
-le minore o uguale a
-gt maggiore di
-ge maggiore o uguale a

operatori sui file
-f nomefile vero (true) se il file esiste
-r nomefile vero (true) se il file esiste ed è leggibile
-w nomefile vero (true) se il file esiste ed è scrivibile
-x nomefile vero (true) se il file esiste ed è eseguibile
-d nomefile vero (true) se si tratta di una directory
-s nomefile vero (true) se il file esiste ed è maggiore di zero

operatori sulle stringhe
-n string vero (true) se la stringa string non è una stringa nulla
-z string vero (true) se la stringa string è nulla
string1 == string2 vero (true) se entrambe le stringhe sono uguali
string1 != string2 vero (true) se entrambe le stringhe sono diverse
string vero (true) se alla stringa string è assegnato un valore non nullo

attraverso questi operatori logici è possibile unire fra di loro piu’ test
-a corrisponde all'operatore AND
-o corrisponde all'operatore OR

Esempi
d=12
if [ $d -eq 25]
then
echo "si"
else
echo "no il valore è $d"
fi
se il valore della variabile d e’ 25 allo scrivi “si“, altrimenti “no” assieme al valore contenuto
if [ $str1 == $str2 ]
then
echo "Le due stringhe sono uguali!"
fi

Se il contenuto della stringa str1 e’ uguale a quello di str2 allora scrivi “Le due stringhe sono uguali”

if [ -n "$str1" -a -n "$str2" ]
then
echo 'sia $str1 che $str2 non sono nulli'
fi
Se la string str1 e la stringa str2 non hanno valore nulli allora stampami il loro valori dichiarando che non sono nulli
Note importanti sull’uso dei test

    * cio’ che viene scritto fra parentesi quadre [ ] deve essere staccato da ciascuna parentesi con uno spazio
    * qualora si confrontino variabili contenenti stringhe si consiglia di scriverle fra virgolette
      es:
      [ "$str1" == "$str2" ]

stuttura di controllo basata su casi case
Sintassi:
case espressione in
valoreatteso1) comandi da eseguire ;;
valoreatteso1) comandi da eseguire ;;
...
esac
I possibili valori ammessi sono fra le parole chiave case e esac. Il doppio punto e virgola ;; e’ utilizzato come terminatore delle istruzioni.
Il costrutto utilizza ) per dividere il valore possibile dalla serie di istruzioni da eseguire.
Esempio
echo "Fa la tua scelta : "
read scelta;
case $scelta in

1) ls -l ;;
2) ps -aux ;;
3) date ;;
4) who ;;
5) exit

esac
In questo esempio viene chiesto l’input di una stringa che viene archiviato nella variabile scelta (read scelta)
Se la stringa contiene uno dei casi proposti (i numeri da 1 a 5), lo script esegue il corrispettivo comando.
Il comando exit esce dall’esecuzione della shell
Cicli di controllo

cicli di controllo while loop
Sintassi:
while la_condizione_è_vera
do
comandi da eseguire
done
Esempi:
while [ $num -gt 100 ]
do
sleep 5
done
fino a che il valore contenuto nella variabile num è minore di 100 fa un attesa di 5 secondi (sleep 5)
cicli di controllo for
Sintassi:
for variabile in lista
do
comandi_da_eseguire
done
Esempi:
for x in 1 2 3 4 5
do
echo "il valore di x è $x";
done
Stampa 5 volte la stringa “il valore di x è … ” mostrando di volta in volta il valore assunto da x (ogni singolo valore della lista preso per volta)

for file in *~
do
rm $file
done
Cerca tutti i file che finisco con “~” (*~) e li cancella uno alla volta (rm $file)

Nota: il comando break interrompe in qualsiasi ciclo (sia while che for)
Ulteriori informazioni utili

    * assegnare l’output di un comando ad una variabile
      Sintassi:
      VARIABILE=$(comando)
      in alternativa
      VARIABILE=`comando`
      Esempi:
      SOMMA=$(echo 1+1 | bc)
      il valore contenuto in SOMMA sara’ la somma di 1+1 calcolata dal programma bc

      OGGI=`date '+%d/%m/%Y'`
      Il valore contenuto in OGGI sara’ la data espressa nella forma giorno/mese/anno
    * Variabili speciali

      $1 ... $n - i valori della sequenza dei parametri passati ad uno script si recuperano attraverso la lettura delle variabili (in sequenza) $1, $2 ...
      $* - considera l'elenco di tutti parametri passati allo script
      $0 - nome dello script eseguito
      $# - numero dei parametri passati allo script
      $? - stato di uscita dell'ultimo comando

      Esempio:
      sorgente dello script esempio.sh
      #!/bin/bash
      echo "Mi sono stati passati $# valori"
      if [ "$#" -gt 0 ]
      then
      echo "Il primo valore e' $1"
      fi

      Uso
      ./esempio.sh 100 200
      Output
      Mi sono stati passati 2 valori
      Il primo valore e' 100
    * Gestione input/output
          o aggiungendo il simbolo “>” seguito da un nome di un file a destra di un comando, l’output viene rediretto in un file sovrascrivendolo
          o aggiungendo il simbolo “>>” seguito da un nome di un file a destra di un comando, l’output viene rediretto in un file accodandolo
            Esempi
            echo "Hello" > output.txt
            cat output.txt
            Hello

            echo "World" >> output.txt
            cat output.txt
            Hello
            World
            <” seguito da un nome di un file a destra di un comando, si passa in input al comando il contenuto del file
          o mail nobody@where.no < testo_email.txt inserendo il simbolo “|” fra due comandi si passa l’output di uno come input dell’altro

            ls | more
          o creare un file di testo e il suo relativo contenuto
            cat > nomefile << EOF
            testo da inserire
            EOF
            Nota: nel file si troveranno le stringhe contenute fra le due parole chiave EOF (escluse)
            Puo’ essere usata una qualsiasi parola chiave a patto che venga ripetuta come chiusura

##Prompt a colori##
utente normale

PS1="\[\e[1;32m\]\u\[\e[1;30m\] @\[\e[0;36m\] \A\[\e[1;30m\] =>\[\e[0;36m\] \W\[\e[1;31m\] \$\[\e[m\] "

in home/.bashrc

################################################################################
utente root

PS1="\[\e[1;31m\]\u \[\e[0;31m\]=> \[\e[1;31m\]\w \$\[\e[1;37m\] "

in /root/.bashrc

################################################################################
La variabile PS1

E' la variabile che vogliamo modificare per agire sull'aspetto del nostro prompt.
Potrete assegnare ad essa un valore ed esportarlo, molto utile per fare delle prove
al volo; il comando da utilizzare sarà dunque:
$ export PS1='struttura_del_prompt'

Dove struttura_del_prompt è la vostra personalizzazione del prompt di bash; queste
sono le variabili che possono comporre il vostro prompt:
\w    Directory corrente
\u    Username
\h    Hostname (default=localhost)
\d    Data (dd mm gg)
\t    Ora corrente (hh:mm:ss)
\s    Nome della shell (default=bash)

Vediamo dunque un paio di esempi di utilizzo:
$ export PS1='{\s}\w:\u $'

vi ritornerà  un prompt del genere:
{bash}/home:username $

mentre con
$ export PS1='(\d - \t)\u %'

avrete
(sab feb 07 - 22:14:54)username %

e con
$ export PS1='\u@\h using shell \s: $'

otterrete
username@localhost using shell bash: $

Credo che il concetto sia chiaro, potete disporre come meglio preferite variabili e
caratteri, parole e spazi... l'unico limite è la vostra fantasia (e la vostra tastiera :P ).




3) Colori

Ora passiamo alla fase di personalizzazione forse più divertente (e più complicata),
ossia cambieremo i colori del nostro prompt. Ogni colore è rappresentato da un codice
numerico che può essere di 5 tipi:
0;3x    con x variabile, per i colori puri
1;3x    con x variabile, per colori in grassetto
0;4x    con x variabile, per avere il testo evidenziato nel colore scelto
0;38    per il testo sottolineato
1;38      per il testo grassetto sottolineato

Ogni codice dovrà essere preceduto da \[\033[ e seguito da m\] per funzionare correttamente.
Questi sono i colori disponibili:

Nero        0;30        Grigio scuro        1;30        Evidenziato nero        0;40
Rosso        0;31        Rosso grassetto        1;31        Evidenziato rosso        0;41
Verde        0;32        Verde grassetto        1;32        Evidenziato verde        0;42
Giallo        0;33        Giallo grassetto    1;33        Evidenziato giallo        0;43
Blu        0;34        Blu grassetto        1;34        Evidenziato blu            0;44
Viola        0;35        Viola grassetto        1;35        Evidenziato viola        0;45
Azzurro        0;36        Azzurro grassetto    1;36        Evidenziato azzurro        0;46
Grigio        0;37        Bianco grassetto    1;37        Evidenziato grigio        0;47
Default        0;39        Sottolineato        0;38       

Vediamo qualche esempio per capire meglio.
Il mio consiglio è di utilizzare questa stringa le prime volte per fare delle prove,
cambiando di volta in volta il codice del colore che volete provare:
$ export PS1='\[\033[0;40m\]\u@\h  \[\033[0;39m\]$'

In questo caso state testando il testo evidenziato nero (codice 0;40), e vedrete
il vostro username seguito da una chiocciola e dal nome dell'host così colorati, per
poi ritornare al colore di default per stampare il simbolo '$' e il testo che scriverete
in seguito. Sostituite a 0;40 il codice del colore che volete provare, e quando ci avrete
preso un po' la mano datevi a combinazioni più fantasiose, ad esempio:
$ export PS1='\[\033[0;36m\]{\t}\[\033[1;37m\]\u@\h$ \[\033[1;33m\]'

così avrete un prompt del tipo
{22:55:45}username@localhost$

in cui l'orario è azzurro, la parte centrale è in bianco grassetto, e i comandi che scriverete
voi saranno in giallo grassetto.




4) Rendere effettive le modifiche

Quando avrete trovato un prompt che vi piace particolarmente e vorrete tenerlo come
prompt di default, dovrete andare a modificare il file ~/.bashrc dato che il comando
export apporta delle modifiche solo temporanee; aprite suddetto file dunque con l'editor
che preferite e cercate la sezione
# set a fancy prompt
PS1='\u@\h:\w\$ '

e modificatela o createla voi se non esiste; il succo del discorso sta nell'assegnare a PS1
un valore costante, per offrirvi un ulteriore esempio vi copio la mia attuale parte incriminata
del file in questione:
    # set a fancy prompt
        ### default
        #PS1='\u@\h:\w\$ '
        ### personalizzato
        PS1='\[\033[0;35m\][\[\033[1;37m\]\u@\h\[\033[0;35m\]]\[\033[1;37m\]\w \[\033[0;39m\]$'

Una volta modificato il file, salvatelo e uscite, e per vedere aggiornate le modifiche senza
bisogno di riavviare date il comando:
$ source ~/.bashrc

che d'ora in avanti potrete usare per tornare alle impostazioni scelte nel file se farete
qualche errore durante i test di modifica del prompt.
Ovviamente ogni utente ha nella sua home un file .bashrc perciò potete avere un prompt
diverso per ogni utente (root compreso).

#!/bin/bash
#
#            +-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+
#            |C|a|t|t|u|r|a| |D|e|s|k|t|o|p|
#            +-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+

date=`date +%d_%m_%Y-%M%S`
# percorso dove viene salvata l'immagine catturata
import -pause 2 $HOME/Immagini/immagine_$date.jpg

# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples

# If not running interactively, don't do anything
[ -z "$PS1" ] && return

# don't put duplicate lines in the history. See bash(1) for more options
# ... or force ignoredups and ignorespace
HISTCONTROL=ignoredups:ignorespace

# append to the history file, don't overwrite it
shopt -s histappend

# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
HISTSIZE=1000
HISTFILESIZE=2000

# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
shopt -s checkwinsize

# make less more friendly for non-text input files, see lesspipe(1)
[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"

# set variable identifying the chroot you work in (used in the prompt below)
if [ -z "$debian_chroot" ] && [ -r /etc/debian_chroot ]; then
    debian_chroot=$(cat /etc/debian_chroot)
fi

# set a fancy prompt (non-color, unless we know we "want" color)
case "$TERM" in
    xterm-color) color_prompt=yes;;
esac

# uncomment for a colored prompt, if the terminal has the capability; turned
# off by default to not distract the user: the focus in a terminal window
# should be on the output of commands, not on the prompt
#force_color_prompt=yes

if [ -n "$force_color_prompt" ]; then
    if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
   # We have color support; assume it's compliant with Ecma-48
   # (ISO/IEC-6429). (Lack of such support is extremely rare, and such
   # a case would tend to support setf rather than setaf.)
   color_prompt=yes
    else
   color_prompt=
    fi
fi

if [ "$color_prompt" = yes ]; then
    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
else
#    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
PS1="\[\e[1;36m\]┌── \[\e[1;37m\]\u \[\e[1;36m\]── \[\e[1;33m\]@\[\e[1;36m\] \[\e[1;36m\]──\[\e[1;36m\]\A─\d──\[\e[1;33m\] user\[\e[0;36m\] §\[\e[1;36m\]
    └────\V :»>\W\$\[\e[m\] "
fi
unset color_prompt force_color_prompt

# If this is an xterm set the title to user@host:dir
case "$TERM" in
xterm*|rxvt*)
    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
    ;;
*)
    ;;
esac

# enable color support of ls and also add handy aliases
if [ -x /usr/bin/dircolors ]; then
    test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
    alias ls='ls --color=auto'
    #alias dir='dir --color=auto'
    #alias vdir='vdir --color=auto'

    alias grep='grep --color=auto'
    alias fgrep='fgrep --color=auto'
    alias egrep='egrep --color=auto'
fi

# some more ls aliases
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'

# Add an "alert" alias for long running commands.  Use like so:
#  sleep 10; alert
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//''')"'

# Alias definitions.
# You may want to put all your additions into a separate file like
# ~/.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

# enable programmable completion features (you don't need to enable
# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
# sources /etc/bash.bashrc).
if [ -f /etc/bash_completion ] && ! shopt -oq posix; then
    . /etc/bash_completion
fi
#/usr/games/fortune
##Messaggio di benventuto
toilet --metal ENRICO
messaggio="Ciao bentornato attento a quello che fai : ) "
nLettera=${#messaggio}
i=0
while [ "$i" -lt "$nLettera" ]
do
sleep 0.02
echo -n "${messaggio:$i:1}"
(( i += 1 ))
done
echo
PROMPT_COMMAND='VAR=$? ; if [[ VAR -eq 0 ]]; then echo -ne "\033[0;32m$VAR\033[0m ;)";  else echo -ne "\033[0;31m$VAR\033[0m ;("; fi; echo -n " "'

# Si può aggiungere questa riga alla fine del proprio .bashrc se si desidera vedere il valore di ritorno dell'ultimo comando eseguito. Dovrebbe funzionare con ogni tipo di prompt finchè non si ha bisogno di PROMPT_COMMAND.
amici=( apt beavis.zen bong bud-frogs bunny calvin cheese cock cower daemon default
dragon dragon-and-cow duck elephant elephant-in-snake eyes flaming-sheep
ghostbusters gnu head-in hellokitty kiss kitty koala kosh luke-koala
mech-and-cow meow milk moofasa moose mutilated ren satanic sheep skeleton
small snowman sodomized sodomized-sheep stegosaurus stimpy supermilker
surgery suse telebears three-eyes turkey turtle tux udder vader vader-koala
www )

cowsay -f ${amici[$((RANDOM%${#amici[@]}))]} $(fortune)

#!/bin/bash
#
# Coordinate geografiche da google maps
# .....................................
#
azzurro='\e[1;36m'
NC='\e[0m'
rosso='\e[0;31m'
#
echo -e "${azzurro}                  +--------------------- --+
                  | COORDINATE GEOGRAFICHE |
                  +------------------------+${NC}"
echo -e ${rosso}
# Se si usa una connessione wlan0 sostituire eth0
#
# Consentire l'esecuzione del file
#
#
/bin/echo '{"version": "1.1.0","host": "maps.google.com","request_address": true,"address_language": "it_IT", "wifi_towers": [{"mac_address": "' $( iwlist eth0 scan 2>/dev/null | grep Address | head -n -1 | awk '{print $5}' | sed -e 's/ //g') '","signal_strength": 8,"age": 0}]}' | sed -e 's/" /"/;s/ "/"/g' | curl -sX POST -d @- http://www.google.com/loc/json | sed -e 's/{/\n/g;s/,/\n/g'

#!/bin/bash

# LOGO CON LA SCRITTA DEBIAN
rosso='\e[1;31m'
NC='\e[0m'
 
 
echo -e "${rosso}          _,edm\$\$\$\$\$on.";
echo -e "      ,d\$\$\$\$\$\$\$\$\$\$\$\$\$\$\$P.";
echo -e "    ,g\$\$P""      """Y\$\$.".";
echo -e "    ,\$\$P'              \`\$\$\$.";
echo -e "  ',\$\$P      ,ggs.    \`\$\$b:";
echo -e "  \`d\$\$'    ,\$P"'  .    \$\$\$";
echo -e "  \$\$P      d\$'    ,    \$\$P";
echo -e "  \$\$:      \$\$.  -    ,d\$\$'      ";
echo -e "  \$\$;      Y\$b._  _,d\$P'  ${NC}    _,          _,      ,'\`.";
echo -e "${rosso}  Y\$\$.    \`.\`"Y\$\$\$\$P"'${NC}        \`\$\$'        \`\$\$'    \`.  ,'";
echo -e "${rosso}  \`\$\$b      "-.__          ${NC}    \$\$          \$\$        \`'";
echo -e "${rosso}    \`Y\$\$b                    ${NC}  \$\$          \$\$        _,          _";
echo -e "${rosso}    \`Y\$\$.                ${NC} ,d\$\$\$g\$\$  ,d\$\$\$b.  \$\$,d\$\$\$b.\`\$\$' g\$\$\$\$\$b.\`\$\$,d\$\$b.";
echo -e "${rosso}      \`\$\$b.          ${NC}    ,\$P'  \`\$\$ ,\$P' \`Y\$. \$\$\$'  \`\$\$ \$\$  "'  \`\$\$ \$\$\$' \`\$\$";
echo -e "${rosso}        \`Y\$\$b.      ${NC}    \$\$'    \$\$ \$\$'  \`\$\$ \$\$'    \$\$ \$\$  ,ggggg\$\$ \$\$'  \$\$";
echo -e "${rosso}          \`"Y\$b._    ${NC}  \$\$    \$\$ \$\$ggggg\$\$ \$\$    \$\$ \$\$ ,\$P"  \$\$ \$\$    \$\$";
echo -e "${rosso}              \`""""    ${NC}  \$\$    ,\$\$ \$\$.      \$\$    ,\$P \$\$ \$\$'  ,\$\$ \$\$    \$\$";
echo -e "${NC}                          \`\$g. ,\$\$\$ \`\$\$._ _., \$\$ _,g\$P' \$\$ \`\$b. ,\$\$\$ \$\$    \$\$";
echo -e "                          \`Y\$\$P'\$\$. \`Y\$\$\$\$P',\$\$\$\$P"'  ,\$\$. \`Y\$\$P'\$\$.\$\$.  ,\$\$.";
echo -e "${rosso}Debian  GNU/Linux ${NC}" `cat /etc/debian_version`