[>a271.html>] [<a269.html<] [^a2.html^]
Lo script di shell è un programma molto semplice, che di solito ha solo lo scopo di automatizzare delle operazioni banali, ma ripetitive. Tuttavia, con l'uso di programmi di servizio realizzati appositamente per questi scopi, si possono costruire degli script piuttosto sofisticati con poca fatica.
Se si realizza uno script che deve essere richiamato fornendogli degli argomenti (dei parametri), e questi sono in forma di opzione, come si è abituati con i programmi di servizio comuni, può essere conveniente l'utilizzo di programmi o comandi appositi. Tradizionalmente si fa riferimento a getopt, del quale esistono però diverse interpretazioni; in particolare, la shell Bash fornisce il comando interno getopts (simile, ma non compatibile con getopt), descritto nella sezione 49.19. È importante osservare che anche tra una distribuzione GNU/Linux e l'altra ci possono essere differenze tra i programmi di servizio getopt.
Il programma di servizio getopt tradizionale ha la sintassi seguente:
getopt stringa_di_opzioni parametro...
La stringa di opzioni è un elenco di lettere che rappresentano le opzioni ammissibili; se ci sono opzioni che richiedono un argomento, le lettere corrispondenti di questa stringa devono essere seguite dal simbolo due punti (:). Gli argomenti successivi sono i valori dei parametri da analizzare. Lo scopo del programma è solo quello di controllare che tutto sia in ordine, e di mettere a posto quello che è possibile sistemare, emettendo l'elenco delle opzioni, nel modo «corretto». Per esempio:
$ getopt ab:c -a uno -b due -c tre quattro
Potrebbe restituire il testo seguente:
-a -b due -c -- uno tre quattro
Infatti, avendo utilizzato la definizione ab:c, è stato stabilito che solo l'opzione -b ha un argomento, per cui, l'argomento uno è stato spostato alla fine delle opzioni, dopo il trattino doppio (--).
Se il programma getopt di cui si dispone è aderente strettamente alle specifiche POSIX, il risultato che si ottiene è diverso, dal momento che la scansione termina nel momento in cui si trova il primo argomento che non riguarda le opzioni:
-a -- uno -b due -c tre quattro
L'esempio seguente dovrebbe chiarire in che modo si può utilizzare getopt per scandire gli argomenti della riga di comando:
#!/bin/sh
# scansione_1.sh
# Si raccoglie la stringa generata da getopt.
STRINGA_ARGOMENTI=`getopt ab:c "$@"`
# Si trasferisce nei parametri $1, $2,...
eval set -- "$STRINGA_ARGOMENTI"
while true ; do
case "$1" in
-a) echo "Opzione a"
shift
;;
-b) echo "Opzione b, argomento «$2»"
shift 2
;;
-c) echo "Opzione c"
shift
;;
--) shift
break
;;
*) echo "Errore imprevisto!"
exit 1
;;
esac
done
echo "Argomenti rimanenti:"
for argomento in "$@"
do
echo "$argomento"
done
In pratica, si comprende che lo scopo di getopt è solo quello di fare un po' di ordine tra le opzioni, e di stabilire cosa sia un'opzione e cosa non lo sia. Supponendo che il nome dello script sia scansione_1.sh, se si utilizza come nell'esempio già visto,
$ ./scansione_1.sh -a uno -b due -c tre quattro
si dovrebbe ottenere il risultato seguente:
Opzione a Opzione b, argomento «due» Opzione c Argomenti rimanenti: uno tre quattro
Se invece, getopt è strettamente aderente alle specifiche POSIX, il risultato cambia come segue:
Opzione a Argomenti rimanenti: uno -b due -c tre quattro
I programmi di servizio Linux si compongono anche di una versione di getopt un po' più evoluta dello standard, che comunque è compatibile con il passato. È ammissibile l'uso della stessa sintassi vista nella sezione precedente, e in particolare si può anche forzare l'aderenza alle specifiche POSIX definendo la variabile di ambiente POSIXLY_CORRECT. Questa edizione di getopt è in grado di identificare anche le opzioni «lunghe». Oltre allo schema sintattico già visto, si può utilizzare in particolare quello seguente:
[getopt opzioni_di_getopt] -o|--options stringa_di_opzioni_corte [opzioni_di_getopt] -- parametro_da_scandire...
In pratica, questa versione di getopt può avere delle opzioni per conto proprio, che ne regolano il funzionamento, e tra queste, -o è obbligatoria, dal momento che il suo argomento è proprio la stringa che definisce quali opzioni possono essere presenti nei parametri. Eventualmente, per indicare opzioni lunghe, si utilizza l'opzione -l.
La stringa che definisce le opzioni corte, si comporta fondamentalmente come già spiegato nella sezione precedente. In particolare, se si usano due volte i due punti (::), si specifica che l'opzione ha un argomento facoltativo, e non obbligatorio. La stringa che definisce le opzioni lunghe, è simile a quella delle opzioni corte, con la differenza che, dovendo indicare dei nomi, e non solo delle lettere singole, questi sono separati attraverso una virgola; per quanto riguarda l'uso dei due punti, la modalità è la stessa.
Questa versione di getopt ha anche la particolarità di essere in grado di proteggere gli argomenti che ne hanno bisogno, ma per arrivare a questo deve sapere con quale shell si sta operando. Infatti, dal momento che getopt restituisce una stringa che poi deve essere scandita nuovamente, se un argomento contiene caratteri particolari che richiedono una qualche forma di protezione (come gli spazi), è necessario che venga fatta una trasformazione opportuna, che non può essere unica per tutte le situazioni. In condizioni normali, il risultato che si ottiene è adatto per Bash, altrimenti occorre utilizzare l'opzione -s.
-o stringa_di_opzioni_corte | --options stringa_di_opzioni_corte
Definisce le opzioni normali che devono essere cercate tra i parametri, specificando anche se queste hanno un argomento, obbligatorio o facoltativo.
-l stringa_di_opzioni_lunghe | --longoptions stringa_di_opzioni_lunghe
Definisce le opzioni lunghe che devono essere cercate tra i parametri, specificando anche se queste hanno un argomento, obbligatorio o facoltativo.
-s {sh|bash|csh|tcsh}
--shell {sh|bash|csh|tcsh}
Definisce il tipo di shell che si sta utilizzando, permettendo di definire il modo migliore per proteggere i caratteri che richiedono questo tipo di accortezza.
-l nome_del_programma | --name nome_del_programma
Dal momento che getopt può segnalare gli errori, con questa opzione è possibile definire il nome del programma al quale attribuire l'errore generato.
Come esempio viene mostrata una variante dello script proposto nella sezione precedente, dove si scandiscono anche le opzioni lunghe, e l'ultima ha un argomento facoltativo.
#!/bin/sh
# scansione_1.sh
# Si raccoglie la stringa generata da getopt.
STRINGA_ARGOMENTI=`getopt -o ab:c:: -l a-lunga,b-lunga:,c-lunga:: -- "$@"`
# Si trasferisce nei parametri $1, $2,...
eval set -- "$STRINGA_ARGOMENTI"
while true ; do
case "$1" in
-a|--a-lunga)
echo "Opzione a"
shift
;;
-b|--b-lunga)
echo "Opzione b, argomento «$2»"
shift 2
;;
-c|--c-lunga)
case "$2" in
"") echo "Opzione c, senza argomenti"
shift 2
;;
*) echo "Opzione c, argomento «$2»"
shift 2
;;
esac
;;
--) shift
break
;;
*) echo "Errore imprevisto!"
exit 1
;;
esac
done
echo "Argomenti rimanenti:"
for argomento in "$@"
do
echo "$argomento"
done
Supponendo che il nome dello script sia scansione_2.sh, se si utilizza come nell'esempio seguente,
$ ./scansione_2.sh -auno -bdue -ctre quattro
oppure
$ ./scansione_2.sh --a-lunga=uno --b-lunga=due --c-lunga=tre quattro
si dovrebbe ottenere il risultato seguente:
Opzione a Opzione b, argomento «due» Opzione c, argomento «tre» Argomenti rimanenti: uno quattro
Tuttavia, se utilizzando le opzioni corte, gli argomenti di queste non vengono attaccati alle lettere rispettive, come nell'esempio seguente,
$ ./scansione_2.sh -a uno -b due -c tre quattro
gli argomenti facoltativi non vengono presi in considerazione:
Opzione a Opzione b, argomento «due» Opzione c, senza argomenti Argomenti rimanenti: uno tre quattro
Quando si realizzano degli script, si ha spesso la necessità di realizzare dei file temporanei, magari solo per accumulare il risultato di un'elaborazione senza tentare di fare altri tipi di acrobazie. Il programma di servizio che si usa per queste cose è tempfile:
tempfile [opzioni]
Nella maggior parte dei casi, tempfile viene usato senza argomenti, e quello che si ottiene è la creazione di un file vuoto nella directory temporanea (/tmp/), con permessi normali (lettura e scrittura per tutti, meno quanto filtrato dalla maschera dei permessi), e il percorso assoluto di questo file viene emesso attraverso lo standard output.
-d directory | --directory directory
Se non si vuole usare la directory temporanea standard, si può specificare la directory di destinazione del file temporaneo con questa opzione.
-m modalità_dei_permessi | --mode modalità_dei_permessi
Se si vuole evitare che il file temporaneo che viene creato abbia dei permessi di accesso troppo ampi, si può utilizzare questa opzione per stabilire qualcosa di diverso.
$ tempfile
Crea un file temporaneo nella directory temporanea, e ne restituisce il nome attraverso lo standard output.
#!/bin/sh TEMPORANEO=`tempfile` ls -l / > $TEMPORANEO ... rm -r $TEMPORANEO
Quello che si vede è l'esempio tipico di uno script, incompleto, in cui si crea un file temporaneo accumulandone il nome in una variabile di ambiente; quindi si fa qualcosa con questo file (in questo caso si inserisce il risultato del comando ls -l), e infine, si elimina il file, sempre utilizzando l'espansione della variabile che ne contiene il nome.
In situazioni determinate, può essere importante avviare un programma, o un altro script con un insieme di variabili di ambiente diverso da quello che si erediterebbe normalmente. Per questo si può usare il programma di servizio env:
env [opzioni] comando [argomenti_del_comando]
Come si può intuire, le opzioni di env servono a eliminare o ad aggiungere delle variabili di ambiente, senza interferire con l'ambiente dello script.
-u variabile | --unset=variabile
Permette di eliminare la variabile di ambiente nominata.
- | -i | --ignore-environment
Azzera completamente tutto l'ambiente.
Si supponga di avere due script: nel primo viene dichiarata la variabile di ambiente CIAO, e viene chiamato il secondo eliminando questa variabile dall'ambiente; il secondo script si limita a mostrare il contenuto di questa variabile, se è disponibile.
#!/bin/sh # ./primo.sh CIAO="ciao a tutti" export CIAO env -u CIAO ./secondo.sh echo $CIAO
#!/bin/sh # ./secondo.sh echo $CIAO
Il risultato è che funziona solo la visualizzazione della variabile che avviene con il comando echo del primo script, perché nel secondo non è disponibile. Sarebbe stato diverso se il primo e unico script fosse stato quello seguente:
#!/bin/sh # ./primo.sh CIAO="ciao a tutti" export CIAO env -u CIAO echo $CIAO echo $CIAO
In questo caso, anche se il comando echo viene avviato senza la disponibilità della variabile CIAO, si otterrebbe ugualmente la sua visualizzazione, dal momento che l'espansione della stessa avviene prima della chiamata del programma env.
Spesso, la realizzazione di uno script di shell interattivo, è molto difficile; o meglio, è difficile realizzare qualcosa di pratico da usare. La shell offre il comando interno read, per leggere ciò che viene inserito attraverso la tastiera, ma questo permette di ottenere un'interazione molto banale, a livello di riga di comando. In alternativa si possono usare dei programmi realizzati appositamente per abbellire gli script, come nel caso di dialog.
Di norma, read è un comando interno della shell Bash, anche se potrebbe essere disponibile un programma di servizio equivalente, da utilizzare con una shell differente. Il modello sintattico seguente rappresenta una semplificazione di quello relativo al comando interno di Bash, e ciò volutamente per generalizzare la descrizione di questo comando che potrebbe essere disponibile in forma differente.
read [-p invito] [variabile...]
read potrebbe essere utilizzato da solo, senza argomenti, e in questo caso servirebbe soltanto per attendere la pressione del tasto [Invio], permettendo all'utente di leggere un'informazione che appare sullo schermo, prima di proseguire con altre operazioni.
L'opzione -p dovrebbe essere abbastanza chiara: permette di definire una stringa di invito all'inserimento di qualcosa. Infine, i nomi che vengono collocati in coda alla riga di comando, rappresentano altrettante variabili di ambiente che vengono create appositamente, assegnando loro le parole inserite attraverso read; in particolare, l'ultima variabile dell'elenco raccoglie tutte le parole rimanenti.
#!/bin/bash echo -n "Inserisci una frase: " read UNO DUE TRE echo "La prima parola inserita è «$UNO»" echo "La seconda parola inserita è «$DUE»" echo "Il resto della frase è «$TRE»"
L'esempio dovrebbe permettere di capire il funzionamento di read. Si osservi in particolare il fatto che l'invito viene ottenuto attraverso il comando echo, utilizzato con l'opzione -n. Supponendo che si tratti dello script read.sh:
$ ./read.sh[Invio]
Inserisci una frase: ciao come stai? io sto bene[Invio]
La prima parola inserita è «ciao» La seconda parola inserita è «come» Il resto della frase è «stai? io sto bene»
La shell Korn e la shell Bash offrono una struttura di controllo particolare, utile per la selezione interattiva di un elemento da un elenco. Si tratta di select, la cui sintassi si riassume nello schema sintattico seguente:
select variabile [in valore...]
do
lista_di_comandi
done
L'elenco di parole che segue in viene espanso, generando una lista di elementi. L'insieme delle parole espanse viene emesso attraverso lo standard error, ognuna preceduta da un numero. Se in (e i suoi argomenti) viene omesso, vengono utilizzati i parametri posizionali ($1, $2,...). In pratica è come se fosse stato usato in $@.
Dopo l'emissione dell'elenco, viene mostrato l'invito contenuto nella variabile PS3 e viene letta una riga dallo standard input. Se la riga consiste del numero corrispondente a una delle parole mostrate, allora il valore della variabile indicata dopo select viene posto a quella parola (cioè quella parola viene assegnata alla variabile). Se la riga è vuota (probabilmente è stato premuto soltanto [Invio]), l'elenco e l'invito vengono emessi nuovamente. Se viene letto il codice di EOF ([Ctrl+d]), il comando termina. Qualsiasi altro valore letto fa sì che la variabile sia posta al valore della stringa nulla. La riga letta viene salvata nella variabile REPLY. La lista di comandi che segue do viene eseguita dopo ciascuna selezione fino a che non viene incontrato un comando break o return.
Il valore restituito da select è quello dell'ultimo comando eseguito all'interno della lista do, oppure zero se nessun comando è stato eseguito.
Viene mostrato nuovamente lo stesso esempio già presentato in occasione della descrizione di select fatta nell'ambito dei capitoli dedicati a Bash: fa apparire un menù composto dagli argomenti fornitigli; a ogni selezione mostra quello scelto.
#!/bin/bash
select i in $*
do
echo "hai selezionato $i premendo $REPLY"
echo ""
echo "premi Ctrl+c per terminare"
done
L'esempio seguente proviene dagli script di nanoLinux, e rappresenta la selezione del nome di un'interfaccia di rete, che viene accumulato nella variabile di ambiente INTERFACCIA:
echo "Selezionare l'interfaccia."
select i in eth0 eth1 eth2 plip0 plip1 plip2
do
INTERFACCIA=$i
break
done
Il programma di servizio dialog è quello che permette di ottenere gli effetti più appariscenti in uno script di shell, dal momento che interagisce con l'utilizzatore attraverso schermate colorate e finestre di dialogo, anche se solo a livello di carattere, e senza una grafica vera e propria.
dialog [opzioni_generali] [definizione_del_tipo_di_interazione]
La riga di comando di dialog distingue due tipi di opzioni: quelle che hanno valore in senso generale influenzando il comportamento del programma, e quelle che definiscono un tipo di interazione con l'utilizzatore. Nella documentazione originale, queste ultime sono definite box-options, perché si riferiscono ai riquadri che vengono mostrati sullo schermo. Evidentemente, si può utilizzare al massimo una sola opzione che definisca una finestra di dialogo.
Dovendo definire delle finestre su uno schermo a caratteri, le opzioni che permettono di descriverle, fanno riferimento a delle dimensioni in caratteri. Questi valori non possono essere omessi, e in caso si voglia fare riferimento alle dimensioni ottimali, in base alla disponibilità dello schermo, basta indicare il valore zero, tenendo conto però che questa possibilità non funziona sempre.
--clear
Se si utilizza questa opzione generale, si fa in modo di ripulire lo schermo prima di mostrare il riquadro della finestra di dialogo.
--title titolo_finestra
Permette di dare un titolo alla finestra di dialogo.
--backtitle sottotitolo_finestra
Permette di dare un titolo allo sfondo, che appare nella parte superiore dello schermo, al di fuori della finestra di dialogo relativa.
--separate-output
Questa opzione altera il modo in cui viene emesso il risultato di un'interazione con dialog. Per la precisione serve quando si utilizza una finestra di dialogo contenente una lista di caselline da barrare. Si veda a questo proposito l'opzione --checklist.
--yesno testo altezza larghezza
Fa apparire una finestra di dialogo molto semplice, in cui viene mostrato il testo indicato, e al quale si deve rispondere con un «sì», oppure con un «no», rappresentati da due pulsanti grafici: <Yes> e <No>. Se la risposta è «sì», dialog restituisce Vero (il valore zero), altrimenti restituisce Falso (un valore diverso da zero).
--msgbox testo altezza larghezza
La finestra di dialogo che si ottiene, serve a mostrare un messaggio, per il quale si attende la conferma da parte dell'utilizzatore. Alla base della finestra appare il pulsante grafico <Ok>, selezionando il quale si conclude il funzionamento di dialog.
--infobox testo altezza larghezza
In questo caso, più che di una finestra di dialogo, si tratta di una finestra contenente un messaggio, per il quale non viene attesa alcuna azione da parte dell'utente. In pratica, dialog mostra il messaggio e termina immediatamente di funzionare. Può essere paragonato a un comando echo, molto più appariscente.
--inputbox testo altezza larghezza [risposta_predefinita]
Questa finestra di dialogo permette all'utilizzatore di inserire un testo libero, ed eventualmente è possibile mostrare inizialmente una risposta predefinita. Alla base della finestra appaiono i pulsanti grafici <Ok> e <Cancel>. Se si seleziona <Ok>, si conferma il testo inserito, che viene emesso da dialog attraverso lo standard output; altrimenti, con <Cancel>, non si ottiene alcun risultato. È importante osservare una cosa che può essere delicata per l'utilizzatore: di solito, sulla riga da inserire non appare un cursore (come ci si aspetterebbe), e forse è il caso di spiegare nel messaggio che è sufficiente iniziare a scrivere per vederne apparire uno.
--textbox file altezza larghezza
Questa finestra di dialogo serve a permettere la visualizzazione di un file di testo. L'utilizzatore può usare intuitivamente i tasti [Pagina su], [Pagina giù], e i tasti freccia, anche per degli spostamenti orizzontali. Alla base della finestra si vede il pulsante grafico <Exit>, che permette di concludere la visualizzazione.
--menu testo altezza larghezza altezza_menù [elemento descrizione]...
Questo tipo di finestra di dialogo comincia a essere un po' più complicato. Il suo scopo è quello di mostrare un menù, composto da coppie di valori, dove il primo è ciò che viene restituito attraverso lo standard output nel caso di selezione, e il secondo è la sua descrizione. Il menù, ovvero l'elenco di queste voci, può avere un'altezza determinata, ma anche in questo caso si può stabilire una larghezza predefinita utilizzando semplicemente lo zero. Sulle voci del menù appare un cursore in forma di barra di scorrimento, che può essere spostata con i tasti freccia o i tasti pagina, e alla base della finestra appaiono i pulsanti grafici <Ok> e <Cancel>. Selezionando <Ok>, dialog termina emettendo la stringa corrispondente all'elemento che si trova evidenziato dalla barra di scorrimento; selezionando <Cancel>, non si ottiene alcun risultato.
--checklist testo altezza larghezza altezza_menù [elemento descrizione on|off]...
Questo tipo di finestra di dialogo è simile a quella che si ottiene con l'opzione --menù. La differenza fondamentale sta nel fatto che in questo caso è possibile selezionare più voci, attraverso delle caselle di selezione: anche qui c'è una barra di scorrimento, e quando ci si trova sopra la voce desiderata, la [barra spaziatrice] mette o toglie il segno di selezione. A differenza dell'opzione --menu, le voci del menù possono essere già attivate o meno, e per questo si aggiunge la parola chiave on oppure off.
La particolarità di questo tipo di selezione, richiede attenzione nel modo in cui deve essere interpretato il risultato emesso attraverso lo standard output. Infatti, in condizioni normali, vengono restituite le stringhe corrispondenti alle voci di menù selezionate, delimitate tra apici doppi. Se questo sistema crea difficoltà, si può abbinare l'uso dell'opzione --separate-output perché queste stringhe siano separate dal codice di interruzione di riga, senza l'uso di delimitatori di altro tipo.
--radiolist testo altezza larghezza altezza_menù [elemento descrizione on|off]...
Questo tipo di finestra di dialogo si comporta in modo simile a quella ottenuta con l'opzione --checklist. La differenza sta nel fatto che si può selezionare solo una voce dall'elenco, per cui il risultato non comporta difficoltà nell'interpretazione. Evidentemente, si può preselezionare solo una delle voci del menù.
#/bin/sh
if dialog --yesno "Ti piace dialog?" 0 0
then
echo "Ottimo!"
else
echo "Peccato :-)"
fi
In questo script, viene mostrata la finestra di dialogo che si vede nella figura 51.1, e in base alla scelta affermativa o negativa, si ottiene la visualizzazione di un messaggio differente.
.-----------------------.
| Ti piace dialog? |
|-----------------------|
| < Yes > < No > |
`-----------------------'
Figura 51.1. Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione --yesno. |
dialog --title "Domanda" --yesno "Ti piace dialog?" 0 0
Questo comando rappresenta solo una variante dell'esempio precedente (a parte il fatto che manca il contorno dello script), e si vede l'aggiunta dell'indicazione di un titolo della finestra.
#!/bin/sh RISULTATO=`tempfile` dialog --title "Menù" \ --menu "Scegli il colore che preferisci" \ 0 0 0 \ 0 nero \ 1 marrone \ 2 rosso \ 3 arancio \ 4 giallo \ 5 verde \ 6 blu \ 7 viola \ 8 grigio \ 9 bianco 2> $RISULTATO echo `cat $RISULTATO`
In questo script viene mostrata la finestra di dialogo che si vede nella figura 51.2, e in base alla scelta del colore, si ottiene il numero corrispondente.
.------------- Menù --------------.
| Scegli il colore che preferisci |
| .-----------------------------. |
| | 0 nero | |
| | 1 marrone | |
| | 2 rosso | |
| | 3 arancio | |
| | 4 giallo | |
| | 5 verde | |
| | 6 blu | |
| | 7 viola | |
| | 8 grigio | |
| | 9 bianco | |
| `-----------------------------' |
|---------------------------------|
| < OK > <Cancel> |
`---------------------------------'
Figura 51.2. Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione --menu. |
#!/bin/sh
RISULTATO=`tempfile`
dialog --separate-output --title "Selezione" \
--checklist "Scegli i colori che preferisci" \
0 0 10 \
0 nero on \
1 marrone off \
2 rosso off \
3 arancio off \
4 giallo off \
5 verde off \
6 blu off \
7 viola off \
8 grigio off \
9 bianco on \
2> $RISULTATO
echo `cat $RISULTATO`
Questo script è una variante di quello precedente in cui si possono selezionare più colori assieme. Nella figura 51.3 si vede la finestra di dialogo che si ottiene.
.------------- Menù -------------.
| Scegli i colori che preferisci |
| .----------------------------. |
| | [X] 0 nero | |
| | [ ] 1 marrone | |
| | [ ] 2 rosso | |
| | [ ] 3 arancio | |
| | [ ] 4 giallo | |
| | [ ] 5 verde | |
| | [ ] 6 blu | |
| | [ ] 7 viola | |
| | [ ] 8 grigio | |
| | [X] 9 bianco | |
| `----------------------------' |
|--------------------------------|
| < OK > <Cancel> |
`--------------------------------'
Figura 51.3. Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione --checklist. |