Introduzione. I comandi

Transcript

1 Introduzione In un sistema UNIX, e quindi anche il linux, la shell rappresenta il suo interprete dei comandi. Possiamo dire che la shell è un interfaccia fra l'utente e il SO. È un tipo di interfaccia detto alfanumerico, poiché i comandi digitati (delle stringhe di caratteri) dall'utente sulla tastiera, vengono letti dalla shell, interpretati ed inviati al kernel per essere eseguiti. La shell quindi è un normale processo che funziona in modalità utente. A partire dagli anni 70 sono state sviluppate diverse shell. Una delle prime shell venne creata presso i Bell Laboratories AT&T ad opera di Steven R. Bourne e veniva spesso indicato con l'abbreviativo sh. Verso la fine degli anni 70 presso l'università' di Berkeley fu creata la C shell (csh) allo scopo di estendere la shell Bourne e renderla più simile al linguaggio di programmazione C. Successivamente furono sviluppate altre shell, come la Korn shell (ksh) e la TC shell (tcsh). Per evitare problemi di copyright, l'organizzazione GNU decise di sviluppare una shell completamente libera da restrizioni e nacque così la shell BASH, cioè Bourne Again Shell. La BASH è senza dubbio la più famosa ed usata in tutti i sistemi Linux ed è conforme allo standard POSIX. Posix sta per Portable Operating System Interface for unix, cioè interfaccia standard per il sistema operativo Unix e si tratta di uno standard creato verso la fine degli anni 80 allo scopo di uniformare le varie versioni di Unix. I comandi I comandi sono digitati dall'utente sulla riga comandi della shell. La riga comandi è una riga digitabile che comincia dal prompt. Il prompt è un carattere o un insieme di caratteri che possono essere personalizzati dall'utente. Il prompt di un utente inizia con il carattere '$' (dollaro). Ecco un esempio di prompt: francesco@fonta:~$_ la stringa francesco sta ad indicare lo username dell'utente collegato alla shell, mentre la stringa Fonta è il nome del computer che si sta usando. Il carattere compreso tra i due punti e il dollaro indica la directory corrente. In questo caso è la tilde '~', che sta ad indicare la cosiddetta directory home dell'utente francesco che ha il seguente path: /home/francesco 1. Questa directory è quella nella quale ci si trova appena si effettua il login a Se infatti decidiamo di passare alla directory tmp (contenuta nella directory corrente /home/francesco) usando il comando cd (change directory) avremo: francesco@fonta~:$cd tmp francesco@fonta~/tmp:$_ Il carattere di sottolineatura '_' (underscore) invece rappresenta il cursore dal quale è possibile iniziare a scrivere. I comandi della shell non sono altro sono degli eseguibili contenuti all'interno di alcune directory speciali come le directory /bin e /sbin. Quando l'utente digita il nome del comando e preme il tasto invio, la shell cerca tale file in alcune directory predefinite (come /bin e /sbin appunto) e se lo trova lo esegue. In caso contrario produce un errore del tipo: 1 In un sistema linux, quando viene creato l'utente nome_utente il sistma crea la directory /home/nome_utente

2 bash: nome_comando : command not found cioè comando non trovato. Un comando è composto da più parti: il nome del comando stesso, da una o più opzioni facoltative e da uno o più argomenti facoltativi. Un argomento è solitamente il nome di un file sul quale il comando deve agire. Alcuni comandi prevedono degli argomenti obbligatori, altri no. In generale un comando è scritto in questo modo: nome-comando -opzione argomento il nome del comando deve essere separato dalle opzioni da uno spazio, così come le opzioni e gli eventuali argomenti. Le opzioni sono specificate usando un trattino '-' e la lettera o le lettere che specificano le opzioni. L'ordine è: 1) nome-comando, spazio, 2) -opzioni, spazio, 3) argomenti. Tra il trattino ed i caratteri di opzione non devono essere presenti spazi. In pratica le opzioni rappresentano un mezzo per comunicare con il programma che si sta utilizzando. Facciamo un semplice esempio: il comando ls prevede diverse opzioni, tra cui: 'l': visualizza il contenuto della directory in formato lista, per la visualizzazione di alcune proprietà del file ; 'a': visualizza tutti i file, compresi quelli nascosti; 'i': visualizza l'indice del i-node in cui è memorizzato il file; Quindi per visualizzare l'elenco dei file di una directory si può usare il comando 'ls -lai'. Ecco un semplice esempio: francesco@fonta:~/tmp$ ls lai drwxr xr x 2 francesco francesco : drwxr xr x 57 francesco francesco : rw r r 1 francesco francesco :39 file1.txt rw r r 1 francesco francesco :39 file2.txt rw r r 1 francesco francesco :23 pippo francesco@fonta:~/tmp$_ Se si vogliono visualizzare le informazioni di un file ben preciso, occorre specificare il nome del file come argomento. Ad esempio se vogliamo visualizzare le informazioni sul file pippo: francesco@fonta:~/tmp$ ls l pippo rw r r 1 francesco francesco :23 pippo francesco@fonta:~/tmp$_ Ecco alcuni esempi dello stesso comando, alcuni errati ed alcuni corretti: ls -lai (corretto) ls - lai (errato: tra il trattino '-' e le opzioni 'l', 'a' ed 'i' non devono esserci spazi) ls -l ai (errato: tra le opzioni 'l', 'a' ed 'i' non ci devono essere spazi) ls pippo -lai (errato: l'argomento pippo deve essere scritto dopo le opzioni -lai) ls -l pippo (corretto: l'argomento pippo è specificato dopo l'opzione 'l') ls -ail (corretto: le opzioni non devono essere digitate rispettando una sequenza prestabilita).

3 Un esempio di comando che può accettare più argomenti è il comando 'cp' (CoPy, cioè copia) che consente di effettuare la copia di un file in un altro file con un nome diverso. La sua sintassi è la seguente cp src_file dst_file dove src_file è il nome del file da copiare e file_dst rappresenta la destinazione del file copiato. Facciamo un semplice esempio, il comando francesco@fonta:~$ cp documento /home/francesco/backup/documento.bak francesco@fonta:~$_ crea una copia del file 'documento.doc' che si trova nella directory corrente nella directory /home/francesco/backup. In questo caso al comando non viene passata nessuna opzione. Le opzioni infatti, per definizione sono facoltative. Nell'esempio specifico per il primo argomento (il file da copiare) non è stato specificato il path completo, cioè il percorso per raggiungere il file documento. In questo caso la shell sa di dover reperire tale file dalla directory corrente. Per default infatti se non si specifica un path, la shell cerca il file nella directory corrente (chiamata anche directory di lavoro). Nel secondo argomento invece è stato specificato il path completo. È anche possibile digitare più comandi sulla stessa riga di comando separandoli con il punto e virgola (carattere ';'). È inoltre possibile scrivere dei comandi su più righe usando il carattere '\' a fine riga. In questo caso, premendo invio si potrà scrivere su una nuova riga per continuare la digitazione del comando, ma niente sarà inviato alla shell. Ogni riga che termina con '\' (backslash) ed il tasto invio, crea una nuova riga ma non esegue il comando. Per eseguire il comando occorrerà premere invio avendo l'accortezza di non terminare il comando stesso con il carattere '\'. Ecco un esempio Ad esempio: francesco@fonta:~$cp /home/francesco/documenti/misc/conferenze/paper.tex \ docs/tex/conferenze/icpr08/paper.tex francesco@fonta:~$_ In pratica il carattere '\' dice alla shell: in questa riga il tasto invio non serve per inviarti il comando ma per andare a capo. Il tasto \ è in questo caso un metacarattere, cioè un carattere che assume un significato speciale. All'ultima riga, alla fine del comando, premendo invio senza \ faremo eseguire il comando alla shell. I diritti di accesso Abbiamo appena visto che il comando 'ls -l' visualizza in maniera dettagliata il contenuto della directory corrente. Ma vediamo in dettaglio il significato della sequenza di 10 caratteri che appaiono all'inizio di ogni riga. Questa sequenza rappresenta i diritti di accesso al file per gli utenti registrati sulla macchina. Ricordiamo che nei sistemi UNIX esistono tre tipi di utenti: user, che è il proprietario del file. Colui cioè che lo ha creato. group: in UNIX gli utenti sono raggruppati in gruppi. Il concetto di gruppo è molto utile sui computer condivisi da molti utenti. Facciamo un semplice esempio, al dipartimento di fisica dell'università Federico II di Napoli esistono diversi gruppi. C'è il gruppo astro che raccoglie tutti gli astrofisici, il gruppo cyber che raggruppa i cibernetici e così via. Ebbene un utente può decidere di condividere alcune delle sue risorse con tutti gli utenti del suo gruppo;

4 other: sono tutti gli altri utenti presenti nel sistema; Abbiamo detto che la sequenza è composta da 10 caratteri, per rappresentarla numeriamo i suoi caratteri da 0 a 9 partendo da sinistra: Nella casella 0 compare 'd' se il nome corrispondente è una directory altrimenti, cioè nel caso di files, resta il trattino '-'. I restanti 9 caratteri specificano i diritti sul file dei tre tipi di utenti previsti nei sistemi UNIX. Gli caratteri 1,2 e3 indicano i diritti dell'utente user (il proprietario del file), mentre i caratteri 4,5 e 6 indicano i diritti degli utenti che appartengono allo stesso gruppo del proprietario. I caratteri 7,8 e 9, sono i diritti di tutti gli altri utenti. Questi tre caratteri indicano i seguenti diritti di accesso: read: indicato dal carattere 'r' e sta a significare che il file può essere letto; write: indicato dal carattere 'w' e significa che il file può essere modificato; execute: indicato dal carattere 'x' e significa che il file può essere eseguito; Un esempio chiarirà sicuramente il concetto: francesco@fonta:~/tmp$ ls l rw r r 1 francesco francesco :42 lista.txt rwxr x 1 francesco francesco :42 script1 francesco@fonta:~/tmp$_ in questo caso la directory tmp contiene due file: lista.txt e script1. Vediamo quali sono i loro diritti di accesso. Notiamo innanzitutto che per entrambi i file il primo carattere è '-', ad indicare che si tratta di files e non di directory. Per quanto riguarda il file lista.txt vediamo che esso può essere sia letto, che modificato dal proprietario, mentre non può essere eseguito in quanto si tratta di un normale file di testo. Per quanto riguarda gli utenti del suo gruppo il file può essere letto ma non modificato, e per quanto detto prima nemmeno eseguito. Anche tutti gli altri utenti possono leggerlo ma non modificarlo. Vediamo ora il file script1, in questo il proprietario può: leggerlo, modificarlo ed eseguirlo. Mentre gli utenti del gruppo del proprietario possono leggerlo ed eseguirlo, ma non modificarlo. Gli altri utenti infine non hanno nessun diritto di accesso al file. Ricordiamo che con il comando 'chmod' è possibile modificare i diritti di accesso al file. Chiaramente, questo comando può essere utilizzato su un determinato file solo dal suo proprietario e dal utente root. I Caratteri Speciali In i caratteri: '*', '?', '[' e ']' hanno un significato speciale e non possono essere usati all'interno del nome di un file. Tali caratteri sono definiti anche caratteri jolly o anche wildcards. Questi caratteri sono usati dalla shell per espandere il nome di un file. Iniziamo il carattere '*' (l'asterisco) sta a significare: qualsiasi carattere o qualsiasi sequenza di caratteri. Digitando una serie di caratteri e terminando la serie con il carattere *, la shell individuerà tutti i file all'interno della directory corrente i cui nomi iniziano con la serie di caratteri digitati e terminano con una sequenza qualsiasi di caratteri. Digitando solo il carattere *, la shell individuerà semplicemente tutti i file all'interno della directory corrente. Facciamo un piccolo esempio: la directory documenti contiene i seguenti file lettera1, lettera2, doc1, letteratura.txt, lettere e doc2: francesco@fonta:~/documenti$ ls l rw r r 1 francesco francesco :43 doc1 rw r r 1 francesco francesco :43 doc2 rw r r 1 francesco francesco :42 lettera1

5 rw r r 1 francesco francesco :42 lettera2 rw r r 1 francesco francesco :42 letteratura.txt rw r r 1 francesco francesco :42 lettere se adesso digitiamo il comando ls lett* quali file verranno visualizzati? Vediamo: francesco@fonta:~/documenti$ ls l let* rw r r 1 francesco francesco :42 lettera1 rw r r 1 francesco francesco :42 lettera2 rw r r 1 francesco francesco :42 letteratura.txt rw r r 1 francesco francesco :42 lettere La shell ha considerato solo i file che iniziano con la sequenza di caratteri 'lett' e terminano con una sequenza qualsiasi di caratteri. I file doc1 e doc2 non soddisfano tali requisiti. Se invece digitiamo il comando ls lettera* avremo: francesco@fonta:~/documenti$ ls l let* rw r r 1 francesco francesco :42 lettera1 rw r r 1 francesco francesco :42 lettera2 rw r r 1 francesco francesco :42 letteratura.txt Supponiamo ora di voler visualizzare solo i file lettera1 e lettera2. In questo caso ci torna utile il carattere speciale '?', il quale significa: qualsiasi carattere. Nel nostro esempio dovremo usare il comando ls -l lettera?: ls l lettera? rw r r 1 francesco francesco :42 lettera1 rw r r 1 francesco francesco :42 lettera2 Questa stringa sarà eseguita dalla shell cercando nella directory tutti i file che iniziano con nome lettera seguito da un solo carattere qualsiasi. Pertanto la differenza tra i caratteri '*' e '?' sta nel fatto che il carattere '*' indica una qualsiasi sequenza di caratteri la cui lunghezza non è definita, mentre il carattere '?' indica un singolo carattere qualsiasi. Se invece vogliamo specificare ulteriormente i caratteri da espandere, si può usare una coppia di parentesi quadre. I caratteri definiti tra parentesi quadre stabiliscono un insieme di caratteri validi che devono essere presenti all'interno del nome dei file da considerare. Facciamo un semplice esempio: supponiamo di avere all'interno della directory corrente i file doc1, doc2, doca1, docb1 e doca2: francesco@fonta:~/documenti$ ls l rw r r 1 francesco francesco :43 doc1 rw r r 1 francesco francesco :43 doc2 rw r r 1 francesco francesco :55 doca1 rw r r 1 francesco francesco :56 doca2 rw r r 1 francesco francesco :56 docb1 Ecco i file che verranno visualizzati con il comando 'ls doc[1a]':

6 ls l rw r r 1 francesco francesco :43 doc1 rw r r 1 francesco francesco :55 doca1 rw r r 1 francesco francesco :56 docb1 quelli cioè il cui nome inizia per doc ed è seguita da una sequenza di caratteri che contiene almeno uno dei caratteri specificati tra le parentesi quadre ('1' e 'A' in questo caso). Notiamo che il file doca2 non viene visualizzato perchè Linux è un sistema cosiddetto case sensitive, distingue cioè i caratteri maiuscoli da quelli minuscoli. Quindi i caratteri 'A' e 'a' sono due caratteri completamente diversi. Se avessimo voluto prendere in considerazione anche il file doca2, avremmo dovuto scrivere doc[1aa]. L'ordine con il quale vengono digitati i caratteri jolly all'interno delle parentesi quadre è ininfluente, perciò i comandi 'doc[aa1]', 'doc[a1a]', 'doc[1aa]' ecc. Danno lo stesso risultato. I caratteri jolly possono essere utilizzati anche per specificare caratteri che si trovano nella parte iniziale del nome. Ecco un classico esempio se la nostra directory contiene i file doc.txt, pippo.doc, lettera.doc e lettera.txt e lettera.pdf : francesco@fonta:~/documenti$ ls l rw r r 1 francesco francesco :12 doc.txt rw r r 1 francesco francesco :11 lettera.doc rw r r 1 francesco francesco :11 lettera.pdf rw r r 1 francesco francesco :11 lettera.txt rw r r 1 francesco francesco :12 pippo.doc il comando 'ls *.doc' visualizza solo i file lettera.doc e pippo.doc: francesco@fonta:~/documenti$ ls l lettera.* rw r r 1 francesco francesco :11 lettera.doc rw r r 1 francesco francesco :11 lettera.pdf rw r r 1 francesco francesco :11 lettera.txt All'interno delle parentesi quadre è possibile anche specificare una sequenza di valori usando il carattere '-'. Ad esempio la stringa doc[1-9] significa qualsiasi file il cui nome inizia per doc e termina con una cifra da 1 a 9. Supponendo di avere all'interno della nostra directory i file doc1, doc2, doc3, doc4 e doc5: francesco@fonta:~/documenti$ ls l rw r r 1 francesco francesco :17 doc1 rw r r 1 francesco francesco :17 doc2 rw r r 1 francesco francesco :17 doc3 rw r r 1 francesco francesco :17 doc4 rw r r 1 francesco francesco :17 doc5 scrivendo il comando 'doc[1-3]' la shell prenderà in considerazione unicamente i file doc1, doc2 e doc3: francesco@fonta:~/documenti$ ls l rw r r 1 francesco francesco :17 doc1

7 rw r r 1 francesco francesco :17 doc2 rw r r 1 francesco francesco :17 doc3 La potenza dei caratteri speciali deriva dal fatto che essi possono essere combinati in qualsiasi modo, pertanto la stringa d?c[1-3].* è perfettamente valida. Supponiamo ad esempio di avere all'interno della nostra directory i file doc1.txt, dic2.txt, dec3.doc, documenti, lettere, fax e moduli: francesco@fonta:~/documenti$ ls l rw r r 1 francesco francesco :22 dec3 rw r r 1 francesco francesco :22 dic2 rw r r 1 francesco francesco :17 doc1 rw r r 1 francesco francesco :22 documenti rw r r 1 francesco francesco :23 fax rw r r 1 francesco francesco :22 lettere rw r r 1 francesco francesco :23 moduli quali sono i file che verranno visualizzati se digitiamo il comando 'ls -l d?c[1-2].*'? Ecco: francesco@fonta:~/documenti$ ls l rw r r 1 francesco francesco :22 dic2 rw r r 1 francesco francesco :17 doc1 Standard input, standard output e standard error In, e quindi anche in LINUX, i dati introdotti in input con la tastiera vengono inseriti all'interno di un canale costituito da una sequenza continua di byte. Allo stesso modo i dati prodotti a video vengoni inseriti all'interno di un altro canale. Tali canali vengono definiti standard input e standard output. Pertanto la tastiera è il canale standard input ed il video è il canale standard output. Qualsiasi comando quindi, accetta in input dei valori che legge dallo standard input (la tastiera) e produce dei risultati scrivendoli nello standard output (il video). Gli eventuali messaggi di errore vengono scritti in un terzo canale, lo standard error, il quale generalmente coincide con lo standard output, nel senso che sia il risultato di un comando che eventuali errori vengono visualizzati a video. Facciamo un semplice esempio, il comando cat stampa a video il contenuto del file(s) passato come argomento(i), vediamo cosa succede se il file pippo esiste nella directory corrente con il comando 'cat pippo' avremo: francesco@fonta:~/documenti$ cat pippo ciao questo è il contenuto del file pippo poiché il comando cat accetta dallo standard input (la tastiera) l'argomento pippo e lo invia allo standard output (il video). Questi 3 canali possono essere visti come dei file ben distinti e separati, e questo è un concetto molto importante da tener bene a mente, poichè Linux (così come ) ci consente di redirigere un canale standard da o verso un qualunque file. È possibile, ad esempio, inviare l'output prodotto da un comando non a video (il canale standard output) ma all'interno di un file. Oppure è possibile far si che un comando accetti in input dei valori prendendoli da un file piuttosto che dalla

8 tastiera. Queste operazioni di redirezione vengono effettuate utilizzando gli operatori di redirezione '<', '>' e '>>'. Il primo è l'operatore di redirezione dell'input standard, mentre gli ultimi due sono gli operatori di redirezione dell'output standard. Supponiamo che la nostra directory contenga i file: pippo pluto topolino minnie: francesco@fonta:~/documenti$ ls pippo pluto topolino minnie da notare che questa volta abbiamo usato il comando 'ls' senza opzioni. Supponiamo ora di voler conservare questo elenco di file all'interno di un documento chiamato disney.txt. Bene, per eseguire tale operazione dovremmo redirigere l'output standard (il video) all'interno del file disney.txt tramite l'operatore '>' in questo modo: francesco@fonta:~/documenti$ ls > disney.txt eseguendo il comando 'ls > disney.txt' la shell ha interpretato l'operatore '>' redirigendo il risultato del comando ls all'interno del file disney.txt. In altre parole tale comando fornisce le seguenti istruzioni per la shell: esegui il comando ls ma non inviare il risultato a video ma invialo all'interno del file disney.txt; se tale file non esiste crealo. Cosi' la shell creerà il file disney.txt ed invierà l'output del comando ls all'interno di tale file. Qualora il file disney.txt fosse già presente, la shell lo creerà nuovamente, distruggendo eventuali dati già presenti. Nel nostro esempio il comando 'ls > disney.txt' creerà il file disney.txt scrivendo all' interno i nomi dei file contenuti nella directory, compreso il file disney.txt appena creato. Per visualizzare il contenuto del file possiamo utilizzare il comando cat: francesco@fonta:~/documenti$ cat disney.txt pippo pluto topolino minnie disney.txt Come possiamo notare all'interno del file disney.txt è presente anche il nome disney.txt. Infatti con l'operatore > la shell prima crea il file disney.txt e successivamente esegue il comando ls (che elencherà anche il file appena creato). Per aggiornare il file disney.txt senza distruggere il contenuto si può usare l'operatore di redirezione dello standard output '>>'. Tale operatore non distrugge il file, in quanto permette di accodare (in inglese diremo che effettua un append) alla fine del file il risultato prodotto dal comando. Per utilizzare il comando ls >> disney.txt è necessario che il file disney.txt esista già, in caso contrario otterremo un errorre dalla shell. Infatti mentre l'operatore '>' crea un nuovo file, l'operatore '>>' accoda all'interno di un file già esistente. L'operazione di redirezione può avvenire anche all'inverso, in quanto è possibile redirigere il canale di input standard. Generalmente i comandi accettano gli argomenti leggendoli dal canale di input standard cioè dalla tastiera. Per esempio il comando 'ls /home/francesco/documenti' visualizza il contenuto della directory /home/francesco/documenti. Tale directory è un argomento che abbiamo fornito noi in input digitandolo da tastiera. È possibile però fare in modo che il comando ls prenda in input l'argomento '/home/francesco/documenti' non da tastiera ma ad esempio da un file. Ciò può essere fatto redirigendo l'input standard, attraverso l'operatore '<'. Facciamo un esempio: abbiamo il solito file pippo il cui contenuto è: francesco@fonta:~/documenti$ cat pippo tmp1 tmp2 tmp3

9 poniamo che la directory corrente contenga le sottodirectory tmp1 e tmp2 e tmp3 con il comando 'ls < pippo' otterremo questo risultato: francesco@fonta:~/documenti$ ls < pippo tmp1: file1 file2 tmp2: file1 file2 pippo2 tmp3: file4 file7 in quanto l'operatore '<' redirige il contenuto del file pippo nell'input standard. Come già accennato, ogni volta che la shell esegue un comando, invia al comando stesso gli argomenti contenuti nell'input standard (la tastiera) ed invia l'output prodotto dal comando verso l'output standard (monitor): interpretando il comando, in questo caso la shell prima di inviare il contenuto del input standard al comando copia il contenuto del file pippo in quest'ultimo l'output standard e l'input standard ma prima di far ciò redirige il contenuto del file pippo all'interno dell'input standard. Perciò se all'interno del file pippo è presente la stringa 'tmp1 tmp2 tmp3', tale stringa verrà copiata dalla shell (cioè rediretta) nel canale di input standard. Quando il comando ls leggerà l'input standard, troverà quindi all'interno la stringa 'tmp1 tmp2 tmp3' appena copiata dalla shell. È importante notare che è possibile redirigere l'input e l'output standard contemporaneamente, infatti utilizzando il comando: :~/documenti$ cat < diseny.txt > pluto è viene copiato il contenuto del file disney.txt nel file pluto.txt: francesco@fonta:~/documenti$ cat pluto.txt pippo pluto topolino minnie disney.txt La pipe Spesso può essere utile inviare l'output di un comando non a video ma ad un altro comando prima di essere visualizzato. Supponiamo ad esempio di voler visualizzare l'elenco dei file contenuti all'interno di una directory. Supponiamo anche che il risultato prodotto sia un elenco interminabile di file. E possibile in questo caso utilizzare il comando more che accetta in input dei dati e li visualizza a video sotto forma di pagine formattate, consentendo la visualizzazione di una pagina per volta. Premendo un tasto qualsiasi il comando more visualizza la pagina successiva. Come è possibile collegare l'output prodotto dal comando ls al comando more? È possibile utilizzando l'operatore di pipe ' ' (è il carattere che si trova nel tasto posto sotto al tasto esc. Si ottiene premendolo contemporaneamente al tasto shift). Usando l'operatore di pipe ' ' comunichiamo alla shell che è necessario collegare l'output standard del primo comando all'input standard del secondo comando. Ad esempio il comando: francesco@fonta:~/documenti$ls more invia il risultato del comando ls al comando more. Il comando more a sua volta formatta tale risultato e

10 lo invia a video. È possibile usare il comando less al posto del comando more, in quanto tale comando permette di scorrere le pagine avanti ed indietro (il comando less è in sostanza una versione migliorata del comando more). Facciamo un altro esempio per mostrare l'uso della pipe e della redirezione dell'output. Poniamo di avere il file lista.txt che contiene una lista di nomi non ordinata: francesco@fonta:~/documenti$ cat lista.txt merola de santo cecere abbate francesco@fonta:~/documenti$ con il comando 'sort lista.txt' viene visualizzata la terminale la lista ordinata: francesco@fonta:~/documenti$ sort lista.txt abbate cecere de santo merola francesco@fonta:~/documenti$ Usando la pipe e l'operatore di redirezione '>' è possibile ordinare le stringhe contenute in lista.txt e copiarle nel file lista-ordinata.txt in maniera molto semplice e immediata: francesco@fonta:~/documenti$ cat lista.txt sort > lista ord.txt In questo modo l'output prodotto da cat viene inviato in input al comando sort attraverso la pipe (l'operatore ' '), mentre l'output di sort (la lista ordinata) viene rediretto verso il file lista-ordinata.txt con l'operatore '>'. Ed ecco il risultato: francesco@fonta:~/documenti$ cat lista ordinata.txt abbate cecere de santo merola Gestione dei Processi I programmi che sono in esecuzione sotto Linux vengono definiti processi. Quando si esegue un comando come ad esempio 'ls', viene messo in esecuzione un processo. Ogni processo sotto Linux viene identificato da un numero univoco: il PID. PID sta per Process IDentifier cioè identificatore del processo. All'interno della shell, i comandi eseguiti dagli utenti vengono definiti job. Si tratta pur sempre di processi, ma nell'ambito della shell sono distinti rispetto ai processi di sistema. Un comando, come qualsiasi processo può essere eseguito in background (che significa in sottofondo) nel senso che mentre il comando è in esecuzione l'utente può continuare ad usare la shell per altre attività. E' conveniente eseguire un comando in background quando la sua esecuzione richiede del tempo. Ad esempio la ricerca di un file all'interno di un grosso disco scorrendo tutte le directory richiede un pò di tempo: e' possibile eseguire tale ricerca in background e nel frattempo eseguire altre attività. Per eseguire un comando in background e' sufficiente apporre il carattere di e commerciale '&' alla fine del comando. Ad esempio, poniamo il caso di volere stampare il file dati.txt usando il comando 'lpr', se il file dati.txt è molto grande si può lanciare il comando lpr in questo modo:

11 lpr tesi.pdf & [1] il carattere '&' permette di eseguire il comando lpr in background, infatti dopo l'esecuzione del comando abbiamo di nuovo il prompt pronto per eseguire altre attività mentre il job relativo al comando 'lpr' è in esecuzione evitando di dover aspettare che il comando 'lpr' termini la sua esecuzione 2. Il numero tra parentesi quadre alla riga sottostante è il numero del job, mentre l'altro numero è il PID del processo. Quindi il comando 'lpr' appena lanciato e' identificato dal sistema come processo numero 18115, mentre la shell lo individua come job numero 1. E' possibile eseguire in background più di un comando contemporaneamente. Per visualizzare i job in background si utilizza il comando 'jobs'. Poniamo di lanciare un secondo comando in background: francesco@fonta:~/documenti$cat *.dat > dati.txt & [2] se adesso chiamiamo il comando 'job' avremo: francesco@fonta:~/documenti$ jobs [1] Running lpr tesi.pdf [2]+ Running cat *.dat > dati.txt Il comando 'jobs' visualizza i comandi in esecuzione in background e per ogni comando viene indicato il numero del job, lo stato del comando (running o stopped) ed il comando stesso. Un comando in stato running e' un comando in esecuzione mentre un comando in stato stopped e' un comando che al momento è sospeso. Il carattere '+' indica il job corrente, l'ultimo cioe' che è stato avviato mentre il carattere '-' indica il penultimo job. Un job è in stato running se è in esecuzione (lo scheduler gli assegna CPU), mentre è stopped se è stato temporaneamente sospeso dall'utente (lo scheduler non gli assegna la CPU). E' possibile portare un comando da modalità background a modalità foreground utilizzando il comando 'fg': francesco@fonta:~/documenti$ fg cat *.dat > dati.txt Per poter sospendere (stato stopped) un job attualmente in esecuzione in modalità foreground basta premere contemporaneamente i tasti CTRL-Z, se consideriamo ancora il caso precedente avremo: francesco@fonta:~/documenti$ fg cat *.dat > dati.txt ^Z [2]+ Stopped cat *.dat > dati.txt la shell ci avvisa che il job è stato temporaneamente bloccato. Se adesso vogliamo mandare di nuovo in esecuzione il job bloccato, ma stavolta in background possiamo usare il comando 'bg': 2Questo è un ottimo esempio di multitasking

12 bg [1]+ Running cat *.dat > dati.txt Tutto ciò può essere utile nei casi in cui l'esecuzione di un comando appena digitato richieda più tempo del previsto. Se invece vogliamo terminare (in inglese kill, che significa uccidere) un job che è in esecuzione in modalità foreground basterà digitare i tasti CTRL-C: francesco@fonta:~/documenti$ fg cat *.dat > dati.txt ^C [2]+ Killed cat *.dat > dati.txt In questo caso la shell ci avvisa che il job è stato terminato (killed). Programmare con la shell Nei sistemi Linux e' possibile programmare la shell, cioe' creare dei programmi per eseguire automaticamente delle operazioni che altrimenti si dovrebbero eseguire manualmente, digitando cioè un comando per ognuno delle operazioni da eseguire. È possibile, ad esempio, creare un programma per effettuare periodicamente il salvataggio dei dati su un supporto esterno (nastro, floppy, CD-Rom etc), oppure si potrebbe scrivere un programma che controlla lo spazio occupato sul disco e produce delle statistiche. È importante osservare che attraverso la shell è possibile scrivere qualsiasi tipo di programma. I programmi per la shell di sono dei normali file di testo che contengono delle sequenze di comandi per la shell e vengono chiamati file di script. Per chi conosce MS-DOS, possiamo dire che sono l'equivalente dei file.bat. Per scrivere uno script della shell si può utilizzare un qualsiasi editor di testo come VI, EMACS, JED e via dicendo. Una volta scritto lo script, per eseguirlo occorre renderlo eseguibile impostando i permessi di esecuzione (utilizzando il comando chmod) oppure usare il comando sh od il comando '.'. facciamo un esempio poniamo di avere appena terminato di scrivere lo script mioscript usando un qualunque editor di testo. Ebbene in questo momento il file non può ancora essere eseguito perchè gli manca il relativo permesso: francesco@fonta:~/ls l rw r r 1 francesco francesco :13 mioscript possiamo osservare che la sua stringa dei permessi è' -rw-r r--' che significa che il file può essere letto(r) e scritto (w) dal proprietario, mentre il suo gruppo e tutti gli altri utenti possono solo leggerlo. Per rendere il file eseguibile abbiamo bisogno del comando 'chmod'. Vediamo subito l'esempio: francesco@fonta:~/chmod u+x mioscript francesco@fonta:~/$ls l rwxr r 1 francesco francesco :13 mioscript Quindi con il comando 'chmod u+x mioscript' abbiamo detto alla shell di rendere il file eseguibile per il proprietario. Infatti richiamando il comando 'ls -l' possiamo osservare che il permesso osservare che adesso il file è eseguibile da parte del utente 3. Osserviamo che adesso il nostro programma viene 3 È possibile lanciare un programma senza impostare i permessi di esecuzione ma usando i comandi: 'sh mioscript' e '. mioscript'. Il comando 'sh' è appunto il nome del programma che esegue la shell. Mentre il comando '.' viene interpretato

13 visualizzato con il colore verde dalla shell: questo colore nella shell indica i programmi eseguibili. Proviamo adesso a lanciare lo script: francesco@fonta:~/mioscript bash: mioscript: command not found Cosa è successo? la shell non riconosce il nostro programma come un comando. Ma questo dovevamo aspettarcelo, in quanto come detto in precedenza la shell cerca i comandi nelle directory /bin/ e /sbin. Quindi per poter lanciare un script dobbiamo specificare il suo path. Nel nostro caso poiché si trova nella directory corrente che nei sistemi è denotata con il punto '.': francesco@fonta:~/./mioscript Uno script della shell può contenere dei comuni comandi Linux oppure delle righe di commento. I commenti non sono delle istruzioni per la shell ma delle scritte lasciate dal programmatore per descrivere a colore che leggono il programma (e anche se stesso) il funzionamento del programma stesso. Quando un file di script viene eseguito la shell legge tale file riga per riga ed esegue tutte le istruzioni che incontra: si tratta perciò di un programma interpretato. Tutte le righe che iniziano con il carattere cancelletto '#' vengono perciò ignorate dalla shell. Le righe di commento sono particolarmente utili nella scrittura di script complessi per descrivere passo passo il codice contenuto nella shell. Vediamo adesso alcuni comandi. Il comando 'echo' visualizza in output una stringa. Vediamo un classico esempio di programma che utilizza il comando echo. Se scriviamo la questa istruzione all'interno di un file di script: francesco@fonta:~/ cat mioscript # Questo è il mio primo script echo "salve gente!" se adesso lanciamo lo script ecco cosa succede: francesco@fonta:~/./mioscript salve gente! Il comando 'read', invece consente allo script di leggere i dati in input. Uno script generalmente accetta dei dati in input e genera dei dati in output: il comando read permette di leggere l'input ed il comando echo permette di scrivere in output. Ad esempio: se adesso il nostro script contiene il seguente codice: francesco@fonta:~/cat mioscript # Questo è il mio primo script echo "digita qualcosa" read var echo "hai digitato: $var" proviamo a lanciare lo script: come un modo alternativo per chiamare la shell.

14 digita qualcosa checco hai digitato: checco nello script appena visto l'istruzione read legge lo standard input e lo mette nella variabile $var, successivamente il comando echo visualizza il contenuto della variabile. Questo semplice esempio può essere molto utile a introdurre il concetto di variabile. In informatica una variabile identifica un'area di memoria che contiene dei dati (modificabili durante l'esecuzione del programma). In pratica una variabile serve ad associare un nome simbolico (più semplice da ricordare per il programmatore) all'indirizzo di memoria utilizzato per memorizzare un particolare dato. Nel esempio precedente $var indica l'area di memoria utilizzata dal programma shell per memorizzare il contenuto dela stringa che abbiamo digitato alla riga di comando. Quest'area di memoria è stata poi letta dal comando 'echo' che ne ha visualizzato il contenuto a video. In ogni sistema, una variabile per poter essere utilizzata deve essere dichiarata, bisogna cioè avvertire il sistema (la shell nel nostro caso) che abbiamo bisogno di un spazio di memoria e che a tale spazio vogliamo indicarlo con un certo nome. Nella shell la dichiarazione di variabili avviene in maniera praticamente automatica. Nel caso dell'esempio precedente il comando 'read nomi' contiene anche la dichiarazione implicita della variabile nomi. In pratica 'read' nomi dice alla shell: leggi dall'input il dato digitato dall'utente e memorizzalo in una nuova area di memoria che si chiama nomi. Nella shell le variabili precedentemente dichiarate possono essere richiamate anteponendo loro il carattere '$' (il dollaro). Sempre nel caso precedente, il contenuto della variabile var è stato passato al comando 'echo' scrivendo: hai digitato: $var. Nella shell esiste anche un altro modo per dichiarare le variabili: francesco@fonta:~/var=10 francesco@fonta:~/$ echo $var 10 In questo caso il comando 'var=10' è stato riconosciuto dalla shell come una dichiarazione di variabile poichè subito dopo la parola var ha trovato l'uguale ('='). Questo tipo di comando è un comando cosiddetto di assegnazione, infatti la variabile non viene solo dichiarata ma ad essa viene assegnato il valore 10. È importante osservare che affinché avvenga la dichiarazione è necessario che il comando non contenga spazi, infatti: francesco@fonta:~/var =10 bash: var: command not found francesco@fonta:~/$ var= 10 bash: var: command not found in entrambi i casi la stringa var è stata interpretata come comando, perchè abbiamo inserito degli spazi nel comando. Facciamo un altro esempio di script: francesco@fonta:~/cat elenco # Questo script elenca dei file echo "quale file vuoi visualizzare?" read nomi ls $nomi

15 questo script chiede all'utente il nome del file che vuole visualizzare, usando il comando 'read', il quale memorizza questo nome nella variabile nomi. Al comando 'ls' poi viene poi passato come argomento la variabile nomi (il suo contenuto) 4. Vediamo cosa succede se chiamiamo lo script (poniamo che la directory corrente contenga i seguenti file: pippo.txt, pluto.txt, paperino.txt ) : francesco@fonta:~/./elenco quali file vuoi visualizzare *.txt pippo.txt pluto.txt paperino.txt In questo caso l'utente ha digitato alla riga di comando la stringa *.txt, la quale passata come argomento al comando 'ls' ci fa visualizzare tutti i file che hanno il suffisso txt. Come qualsiasi comando Linux, anche gli script possono accettare degli argomenti in input. In uno script è possibile fare riferimento ad un argomento usando il carattere '$' seguito dal numero dell'argomento $1 e' il primo argomento, $2 e' il secondo, $3 il terzo e cosi' via. Notiamo inoltre che $0 è il nome dello script, $# rappresenta il numero degli argomenti passati in input e $* rappresenta tutti gli argomenti dello script. Passiamo al solito esempio: francesco@fonta:~/cat args script # Script di esempio sugli argomenti echo "il numero di argomenti passati è: $#" echo "il primo è: $1" echo "il secondo è: $2" echo "il terzo è: $3" echo "gli argomenti passati sono: $*" Chiamando lo script avremo: francesco@fonta:~/./args script arg1 arg2 arg3 il numero di argomenti passati è:3 il primo è: arg1 il secondo è: arg2 il terzo è: arg3 gli argomenti passati sono: arg1 arg2 arg3 4Notiamo ancora una volta che dopo che è stata dichiarata una variabile può essere denotata anteponendo il carattere '$'.