Ovviamente un PC con su installato Linux (o una qualsiasi delle versioni di Unix disponibili in giro), una qualsiasi distribuzione va bene, anche se gli esempi saranno presi dalla RedHat 7.1. La configurazione non ha importanza, basta che il programma di shell sia bash o sh, cosa che è di default se non avete chiesto modifiche all'installazione. Se non avete idea di cosa sia bash, non preoccupatevi, ne parliamo a tempo debito.
A tutti. Sia a chi già conosce Linux come e meglio delle proprie tasche, sia a chi vorrebbe conoscerlo. Spesso mi sono trovato a voler fare qualcosa e annaspare alla ricerca di come farlo, certo che un modo ci deve essere, ma senza sapere dove cercare. Alle persone che si sono trovate in questa situazione almeno una volta è destinato il documento.
L'unica cosa che non potete fare con questo documento è venderlo o usarne parte, in qualsiasi forma o codifica, per includerla in un prodotto in vendita. Praticamente questo documento è rilasciato sotto la licenza FDL (Free Document License), per la parte applicabile, che potete trovare o allegata alla distribuzione insieme ai file di questo documento oppure potete prelevare dal sito http://www.fsf.org.
Spesso qualcuno mi ha gentilmente fornito un suggerimento o un punto di partenza. Questo documento è dedicato a queste persone ed a tutti coloro che pazientemente spiegano ai principianti, come lo siamo stati tutti, più e più volte le stesse cose, sempre a persone diverse. Come io ho tratto vantaggio da questi suggerimenti, così spero di sdebitarmi dando suggerimenti a chiunque voglia prendersi il disturbo di leggere il documento.
Quanto scritto qui non vuole essere né una bibbia né verità totale ed assoluta. L'errore è sempre in agguato. Se volete contribuire, mandare commenti, segnalazioni, critiche e suggerimenti scrivetemi pure all'indirizzo che trovate in cima al documento. Qualsiasi vostro contributo è gradito, e se si rivela determinante il vostro nome può essere citato nella lista degli ospiti di riguardo.
Potete usarlo come un manuale, essendo diviso in sezioni per destinazione d'uso dei comandi. Oppure potete leggerlo tutto di seguito, ma in questo caso potrebbe non esservi molto utile in quanto non vi è un vero filo logico che lega le sezioni, almeno non volutamente. Fate come credete meglio. L'importante è che lo usiate e che vi sia utile. Pronti? Si parte!
Per ogni comando che esamineremo Linux fornisce un sistema di help consultabile al volo: le pagine man, in inglese manpages. Praticamente per ogni comando esistono queste pagine di aiuto, ma ne esistono anche per altre funzioni o file particolari, oppure per argomenti di particolare interesse.
Basta dare il comando:
man comando_o_parola_chiave
e vi compare una pagina di spiegazioni sul comando richiesto. Per muoversi all'interno della pagina man si usano i tasti freccia e <pag sù>/<pag giù>, per uscire il tasto <q>. Si possono fare delle ricerche digitando:
/stringa_da_cercare
e man vi evidenzia tutte le parole che corrispondono a quella cercata, posizionandosi sulla prima che trova. Per andare alle successive occorrenze della parola basta premere <n>.
Niente di più semplice. Digitate:
man man
Non è uno scherzo. Anche man ha la sua pagina man. Ma è anche possibile chiedere aiuto mentre si visualizza una pagina man premendo il tasto <h>, che mostra una pagina di help su tutti i tasti che hanno funzioni in man.
La shell (in inglese guscio, conchiglia) è un qualcosa che si occupa di rendere controllabile il vostro Linux in un qualche modo. Un modo è la command-line, ossia quella cosa che si presenta in vari modi ma alla fine altro non fa che aspettare che voi scriviate qualcosa e rispondervi di rimando. La shell e la command-line le trovate, se siete nel desktop grafico, nelle "finestre terminale" oppure se non avete un desktop grafico è quello che vi trovate davanti quando Linux parte: una riga con il cursore lampeggiante in attesa. La shell è lì dietro in agguato. Aspetta che scriviate qualsiasi cosa e perfidamente vi risponde "command not found" o qualcosa di simile, ugualmente irritante. Abbiate fede. Le insegneremo il rispetto.
Se avete una RedHat, ma in generale anche altre distribuzioni le hanno, ne avete ben sei in modo testo puro ed un numero enorme in modalità grafica sotto forma di finestra. Probabilmente non ne userete mai così tante. Ma visto che ci sono, impariamo ad usarle. Siete davanti al vostro desktop grafico? Bene. Premete <Ctrl>+<Alt>+<F1> e vi trovate davanti il vostro terminale testo numero 1. Se premete invece di <F1> premete uno qualsiasi dei tasti da <F2 a <F6> vedrete gli altri. Per rivedere il vostro desktop grafico premete invece <Ctrl>+<Alt>+<F7>. In realtà per passare dai terminali in modo testo ad uno degli altri basta <Alt>+<Fn> dove Fn è uno dei tasti da <F1> a <F7>, solo per passare da quello grafico ad uno di quelli testo dovete premere <Ctrl>+<Alt>+<Fn>, ma per non sbagliare o confondervi usate sempre <Ctrl>+<Alt>+<Fn>. I puristi non me ne vogliano.
Per ulteriori informazioni andate alla pagina man di console.
Passate al primo terminale testo con <Ctrl>+<Alt>+<F1> ed identificatevi con la vostra login e la vostra password. Vi dovrebbe comparire la famigerata riga del prompt, ossia il segnale che la shell è lì che aspetta, qualcosa del tipo:
[mario@reliant ~]$ _
dove il '_' è il cursore lampaggiante, la prima parola è il nome dello user corrente (nel mio caso mario), la seconda il nome del computer su cui siete al momento (nel mio caso reliant) ed il segno '~'. Non sottovalutatelo quel simbolo. E' un alias, ossia un sinonimo, che indica la vostra directory personale, detta anche home directory. Di solito la home directory è /home/nomelogin, che nel mio caso sarà /home/mario. Per indicare la mia directory posso dire /home/mario, ma posso anche dire ~. Per la shell sono la stessa cosa. Se entrate come superuser, ossia root (l'utente onnipotente di Linux) il simbolo ~ varrà /root, almeno sulla RedHat.
La shell può essere la nostra migliore amica, se sappiamo usarla. Cominciamo da una feature basilare: l'history dei comandi. La shell si ricorda gli ultimi n comandi, di solito gli ultimi 1000. Con le frecce <alto> e <basso> si naviga tra i comandi dati in precedenza. Con <pag-sù> e <pag-giù> si salta al primo della lista o si ritorna alla riga che stavate ancora scrivendo. Scelto il comando si può ridare identico dando un <invio>, oppure modificarlo con le frecce <destra> e <sinistra>, cancellare caratteri con <canc> o <backspace>, muoversi all'inizio o alla fine della riga con <home> e <fine>, insomma quasi un editor.
Il secondo aiuto che ci fornisce la shell è il completamento automatico per i nomi file e directory. Per vedere di che si tratta, digitate:
cd /ho
esattamente così, e poi battete un <tab>. La shell vi completa la riga così:
cd /home/
ossia vi mette l'unica directory che inizia con la porzione che avete digitato. Ma non basta, digitate:
cd /usr/
e date un <tab>. Sentirete un bip con cui la shell vi comunica che ha troppo poche informazioni. Ribattete subito un <tab> e la shell vi stampa un elenco di directory che si trovano in /usr e si rimette ad aspettare che gli aggiungiate qualcosa di più preciso. Se l'elenco è troppo lungo vi chiede se siete proprio sicuri. Provate, digitando
cd /usr/share/
e poi i soliti due <tab>. Vi spiega che ci sono oltre un centinaio di corrispondenze, le volete vedere tutte? Se poi siamo più precisi e gli aggiungiamo due lettere tipo:
cd /usr/share/gn
e diamo i soliti due <tab> vi mostra tutte le directory che iniziano con le due lettere 'gn' che si trovano in /usr/share. Capito il meccanismo?
Sembra contorto, ma vedrete che dopo un paio di giorni di utilizzo di queste funzioni vi troverete a battere <tab> anche su un altro sistema operativo a finestre sperando in un completamento automatico...
Non basta. C'è di più. Questo meccanismo funziona anche con i comandi stessi. Digitate:
di
e date i due soliti <tab>. Vi viene mostrata la lista dei comandi che iniziano per 'di'. Forte, vero?
Non vi preoccupate, c'è molto di più. Ma procediamo con calma.
Cosa ve ne fate del mouse in modo testo? Senza freccetta... Tranquilli, al posto della freccetta c'è un quadratino che si muove in sincronia col mouse. Con quel quadratino selezionate una parola qualsiasi di quelle che vi compaiono in giro per lo schermo. Fatto? Bene, premete il tasto centrale del mouse (per quelli che ne hanno solo due premete insieme i due tasti). La parola selezionata vi compare nella riga di comando. A che serve? Così a nulla, ma supponete che esista un comando che vi mostra un elenco di file che si chiamano in un certo modo (ed esiste) cercandoli in giro per tutto il file system. Ad un certo punto trova il file che vi interessa, e si trova in una directory dal nome infernale tipo
/lib/modules/2.4.2-2/kernel/arch/i386/kernel/
vi sfido a digitarlo tutto senza errori e in meno di 20 secondi. Con il mouse selezionate tutta la sequenza e con un clic del tasto centrale lo incollate preciso preciso sulla riga di comando. Facile, no?
Per ulteriori informazioni andate alla pagina man di gpm (General Purpose Mouse).
Nelle versioni per il desktop grafico i terminali hanno la scrollbar laterale per rivedere le righe che sono andate oltre la parte visualizzata, ossia sono 'sopra'. Basta puntarci il mouse, e si può vedere per parecchie righe indietro. Ma la versione in modo testo del terminale non ha scrollbar. Se però tenete premuto il tasto <shift> (quello per fare le maiuscole) ed usate <pag sù> e <pag giù> scorrete avanti ed indietro il testo passato sul terminale una schermata per volta.
Vedere i file in una directory è l'operazione basilare di qualsiasi sistema operativo. Linux non smentisce questo, dedicandovi ben due differenti comandi: ls e dir. Sono praticamente identici, e per quello che mi riguarda preferisco ls solo perché è più rapido da digitare. Digitate:
ls /etc
e vi comparirà una pletora di nomi di file. Linux ci rende le cose più leggibili colorando i nomi dei file in funzione del loro impiego: normalmente in bianco i file, un blu e grassetto le directory, in verde grassetto i file eseguibili, in azzurro grassetto i collegamenti, ecc.
Se volete maggiori dettagli sui file potete usare uno switch, ossia una sequenza di caratteri preceduta da un segno '-' che cambia il comportamento del comando, in questo modo:
ls -l /etc
e vedete un elenco in cui i file sono uno per riga e per ogni file vi sono un gran numero di informazioni, qualcosa di simile a questo:
Attributi Link User Group Size Data Nome -rw-r--r-- 1 root root 833 nov 23 20:54 profile drwxr-xr-x 2 root root 4096 dic 22 14:44 profile.d -rw-r--r-- 1 root root 5809 gen 29 2001 protocols -rw-r--r-- 1 root root 134 ago 30 2000 pwdb.conf -rw-r--r-- 1 root root 5361 feb 14 2001 pxe.conf lrwxrwxrwx 1 root root 7 ott 26 21:54 rc -> rc.d/rc lrwxrwxrwx 1 root root 10 ott 26 21:49 rc0.d -> rc.d/rc0.d
dove la prima colonna contiene gli attributi del file che rappresentano i diritti di accesso ed il tipo, la seconda è il numero di link che puntano al file (potete tranquillamente ignorarlo), la terza il proprietario del file, la quarta il gruppo di utenti a cui appartiene il file, la quinta la dimensione in byte del file, la sesta la data di ultima modifica del file e per ultimo il nome.
Per nascondere i file normalmente basta dargli un nome che inizia con un punto, e per vedere i file nascosti si usa un altro switch, per cui il comando diventa:
ls -a /
che vi mostra anche i file con il nome che inizia con un punto. Potete combinare gli switch, ad esempio:
ls -la /
mostra anche i file nascosti con il formato lungo. Altre possibilità sono:
entra nelle sottodirectory e mostra il contenuto ricorsivamente. Se date il comando ls -R / vi elenca tutti i file di tutte le directory di tutto il filesystem
mette la dimensione del file in formato facilmente leggibile, ossia usa ad esempio 12M invece di 12.000.000, come pure k per kilo e G per giga
visualizza i file ordinati per dimensione, i più grandi prima.
Per maggiori informazioni e altre opzioni di funzionamento, consultate le pagine man di ls o dir.
Fate attenzione perché non lo ripeterò. In Linux/Unix c'è differenza tra lettere maiuscole e minuscole. Se voi volete dare un comando o cercare un file, fate attenzione se sono maiuscole e minuscole. Se voi date il comando LS invece di ls ottenete in risposta un bel 'command not found' o l'equivalente che spara fuori la vostra distribuzione di Linux quando non trova un comando. Questo vale per i nomi di file, per i comandi, per le opzioni dei comandi, tanto che la stessa opzione scritta maiuscola o minuscola provoca due comportamenti diversi e spesso opposti. Quindi fate attenzione a come sono le lettere, OK?
Se avete necessità di indicare invece di un solo file, un intero gruppo di file con nomi particolari, vi è la possibilità di usare dei caratteri speciali che permettono di specificare un modello di ricerca dei nomi.
Il più semplice ed usato è l'asterisco (*) che significa qualsiasi carattere in qualsiasi numero. Ad esempio se digitate:
ls /bin/mk*
ottenete una lista di file che iniziano tutti con le lettere 'mk':
mkdir mknod mktemp
Un altro carattere è il punto interrogativo (?) che significa un singolo carattere, qualunque sia. Ad esempio se digitate
ls /usr/bin/c?
ottenete una lista di file che hanno nomi di due caratteri, di cui il primo è sempre una 'c':
/usr/bin/cc /usr/bin/ci /usr/bin/co /usr/bin/ct /usr/bin/cu
Chi ha dimestichezza con il DOS avrà notato che il significato è lo stesso, ma ci sono delle differenze. Ad esempio l'asterisco ha significato in qualsiasi punto della stringa di ricerca, in DOS solo alla fine. Per cui si può digitare:
ls /usr/bin/*host*
ottenete questo risultato:
/usr/bin/ghostscript /usr/bin/host /usr/bin/hostid /usr/bin/hoststat /usr/bin/kghostview
Sperimentate varie combinazioni di asterischi e punti interrogativi, e vedrete che selezionare gruppi di file diventerà sempre più istintivo. Ma non finisce qui. Capita a volte di dover selezionare gruppi di file da lunghi elenchi con nomi numerati o che contengono lettere di numerazione, tipo file01, file02, file03, ecc. oppure fileaaa, fileaab, fileaac ecc. ed in questo caso può diventare difficile selezionare i gruppi desiderati di file, ad esempio per copiarne metà in un punto e metà in un altro. Ci viene in aiuto allora un altro metodo di selezione dei file, fatto con gli insiemi di caratteri. Per esempio, supponiamo di avere 100 file, con i nomi numerati in questo modo: file00, file01, file02, ..., file98, file99, e di voler appunto copiare i primi 50 su un floppy ed i successivi 50 su un altro. Quindi i file da file00 a file49 possono essere selezionati in questo modo:
file[0-4][0-9]
che significa: il nome inizia per 'file' seguito da un carattere che è un numero da 0 a 4 e da un altro carattere numerico qualsiasi. Il secondo gruppo di file avrà come selezione:
file[5-9][0-9]
e selezionerà da file50 a file99. Ovviamente possiamo fare delle combinazioni:
file[1,3,5,7,9]* file0[0-4] file[aAbcC]
il primo selezionerà tutti i file che iniziano con 'file' seguito da un numero dispari e poi altri caratteri qualsiasi, il secondo i file file00, file01, file02, file03, file04, ed il terzo selezionerà ad esempio fileA, filec, fileb ma non fileB o filed.
In Linux vi è una sofisticata gestione dei diritti di accesso al file. Ogni file ha due gruppi di proprietà: il primo è legato al nome e categoria dell'utente che ne è il proprietario, mentre il secondo gruppo sono i diritti di accesso. Ogni utente ha un nome (quello di login) ed appartiene ad un gruppo di utenti, che non fornisce di per sè caratteristiche particolari, ma viene legato ai diritti di accesso. Ogni file o directory ha tre gruppi di diritti di accesso ed ha assegnato un utente ed un gruppo e per convenzione si dice che quel file appartiene a quell'utente ed a quel gruppo. I diritti di accesso sono tre:
consente la sola lettura del file
consente la sola scrittura/modifica del file
consente l'esecuzione, ossia il file viene trattato con un programma, anche se contiene testo, che in questo caso deve essere "interpretato"
Ogni file o directory ha un totale di 3 gruppi di diritti di
accesso, indicati con le lettere che appaiono quando date un comando
ls -l. Ad esempio il file /bin/cat listato con ls -l /bin/cat compare
così:
-rwxr-xr-x 1 root root 14716 apr 8 2001 /bin/cat
dove il primo gruppo di caratteri a sinistra è in realtà composto da quattro sezioni in questo modo: 1222333444, ossia il primo carattere è la prima sezione, il secondo, terzo e quarto carattere sono la seconda, i successivi tre sono la terza e gli ultimi tre la quarta. La prima sezione è un carattere che indica il tipo di file e potete trovare comunemente questi caratteri:
Potete trovare anche altre lettere, ma per noi sono sufficienti
queste (per ora). La seconda sezione rappresenta i diritti del proprietario
(user) del file, che in questo caso è root, ossia il superuser, cosa
abbastanza comune per i comandi. Vi trovate i caratteri rwx, ossia
il proprietario (root) può leggere/modificare/eseguire il file, ossia
può farci ciò che vuole. La terza sezione riporta i caratteri r-x,
ossia gli appartenenti al gruppo root (il gruppo a cui di solito
appartengono gli amministratori di sistema) possono leggere ed eseguire
il file, ma non possono modificarlo. Il quarto gruppo riporta le
stesse lettere ed indica che tutti gli altri utenti (che non appartengono
al gruppo root) possono leggere ed eseguire il file, ma non modificarlo.
Facciamo un altro esempio e vediamo con ls -l /dev/ttyS0 (attenti alla
'S' maiuscola):
crw-rw---- 1 root uucp 4, 64 mar 3 19:19 /dev/ttyS0
Come vedete qui cambia qualcosa. Il primo carattere indica che il file è un device a carattere (c), in questo caso la prima porta seriale del vostro PC. Qui il proprietario è sempre root, ma stavolta non ha diritti di esecuzione, in quanto il file rappresenta una periferica. Il gruppo è uucp, ed ha gli stessi diritti del superuser. Tutti gli altri utenti non hanno nessun diritto, neanche in lettura. Per poter usare la seriale in modo diretto gli utenti normali devono appartenere anche al gruppo uucp, che è un gruppo apposito creato in Linux per rendere accessibili le seriali agli utenti normali.
Vediamo un caso ancora più particolare, con il comando ls -l /etc/shadow:
-rw------- 1 root root 998 mar 3 14:45 /etc/shadow
Come vedete qui solo il superuser ha diritti, tutti gli altri non possono neanche vederne il contenuto, il che è una buona cosa se il vostro computer è in rete, perché il file è quello che contiene i dati delle password degli utenti.
Nel caso delle directory i permessi creano comportamenti diversi:
Da qui si deduce che il permesso in lettura serve a poco se non è insieme al permesso di esecuzione e viceversa. Come pure paradossale è il fatto che se date il permesso di scrittura/esecuzione e non quello di lettura potete cancellare i file dentro la directory ma non listarli. Poi vedremo più avanti come cambiare i diritti di accesso ai file ed alle directory.
Per muoversi tra le directory si usa il comando cd (change directory). Per esempio se date il comando:
cd /usr/local
vi sposta nella directory /usr/local. Se lo date senza parametri vi porta nella home directory, esattamente come se digitaste:
cd ~
Se da un utente normale date il comando:
cd /root
ottenete un messaggio d'errore perché gli utenti normali non possono accedere alla directory /root. Per salire di una directory il comando è:
cd ..
e potete fare delle combinazioni, tipo:
cd ../local
che sale di una directory e scende di nuovo nella directory local, se esiste. Esistono tre abbreviazioni per indicare una directory particolare e sono:
vuol dire la directory che contiene quella in cui mi trovo adesso, o anche la directory "sopra".
vuol dire la directory in cui sono ora, o anche "qui".
la mia home directory, per esempio /home/mario.
Per il comando cd non esiste una specifica pagina man, in quanto è un comando particolare. Per informazioni potete però consultare la pagina man di bash (in Linux).
Per sapere dove mi trovo in quel momento, il comando è pwd (print working dir).
Per maggiori informazioni e altre opzioni di funzionamento, consultate le pagine man di pwd.
Il domando è mkdir (make directory). Basta dare come parametro il nome della nuova directory ed il gioco è fatto. Ovviamente potete creare directory solo dove potete scrivere.
Normalmente le directory vengono create una alla volta, in profondità, ma con uno switch mkdir può creare un intero percorso di directory e sottodirectory. Ad esempio se nella vostra homedir volete creare una directory src con all'interno una sottodirectory chiamata tests potete dare due comandi:
mkdir ~/src mkdir ~/src/tests
oppure potete darne uno solo usando lo switch -p:
mkdir -p ~/src/tests
ed il gioco è fatto.
Il proprietario sarà ovviamente l'utente che ha creato le directory, mentre i permessi di accesso sono impostati in un modo che vedremo più avanti.
Per maggiori informazioni e altre opzioni di funzionamento, consultate le pagine man di mkdir.
Il comando è rmdir (remove dir). La directory viene cancellata
solo se è vuota. Vi può capitare che una directory che sembra vuota
non si voglia cancellare, allora controllate con ls -a che non ci
siano file nascosti.
Anche in questo caso potete cancellare una directory alla volta o tutto un intero percorso, a patto che le directory siano tutte vuote e non contengano altre directory oltre a quelle che cancellate. Usando l'esempio del paragrafo precedente, per cancellare sia tests che src possiamo usare due comandi:
rmdir ~/src/tests rmdir ~/src
oppure usando lo switch -p, ma in questo caso è necessario entrare nella vostra homedir:
cd ~ rmdir src/test
e si ottiene lo stesso risultato. Attenzione che se specificate un intero percorso con lo switch -p rmdir lo elimina tutto, quindi se date il comando:
rmdir ~/src/tests
è equivalente a dare:
rmdir /home/mario/src/tests
per cui se ad eseguire il comando è l'utente root vi trovate che rmdir tenta di cancellare l'intero percorso.
Per maggiori informazioni e altre opzioni di funzionamento, consultate le pagine man di rmdir.
Il comando è cp (copy). La sintassi è:
cp sorgente destinazione
oppure:
cp da_dove a_dove
In questa forma il comando non chiede conferme prima di soprascrivere un file e non copia directory, nel senso che se per sorgente date una directory si rifiuta di continuare. Per ottenere comportamenti differenti potete usare:
copia ricorsivamente, ossia se sorgente è una directory, la copia regolarmente insieme al suo contenuto, file o directory che siano. Anche qui attenti alla 'R' che deve essere maiuscola.
modo interattivo, ossia se trova dei file che deve soprascrivere perché hanno lo stesso nome chiede conferma.
conserva se può i permessi del file, intesi come diritti di lettura/scrittura/esecuzione.
soprascrive la destinazione solo se è più vecchia della sorgente, ossia effettua un aggiornamento.
se deve soprascrivere dei file ne crea un backup prima, ossia rinomina i vecchi file aggiungendo di solito una tilde (~) in fondo al nome.
Le opzioni possono essere combinate tra loro, ad esempio:
cp -Rpb sorgente destinazione
copia tutti i file e le directory in sorgente dentro destinazione, conservando i permessi e creando un backup dei file che esistono già dentro destinazione. Fate attenzione a non usare l'opzione -r (con la 'r' minuscola) che ha dei comportamenti indesiderati, che i più esperti sapranno già, ma per noi basta sapere che è meglio evitarla.
Ci sono molte altre opzioni, come al solito consultate le pagine man di cp.
Diversamente dal DOS, non è possibile copiare e contemporaneamente cambiare nome ai gruppi di file che vengono copiati, quindi se usate una wildcard per indicare i file da copiare, la destinazione deve essere una directory, altrimenti si ha un errore. Questo è dovuto al modo come funzionano le wildcards e le regular expression in Linux, ossia la "shell expansion", qui sotto.
Avete presente quello che dicevamo a proposito del carattere '~'? Beh, è un esempio di shell expansion, ossia la shell sostituisce certi caratteri con qualcosaltro, nel caso della tilde la directory home dell'utente corrente. Ma non è l'unico esempio. Esistono altri tipi di expansion, molti dei quali utilissimi, ma qui ne vedremo uno in particolare, l'espansione dei nomi di file.
Per capire meglio la cosa, useremo il comando echo che stampa quello che segue sul terminale:
echo testo a caso
stampa:
<![CDATA[testo a caso ]]>
nel vostro terminale. Provate a dare il comando:
echo ~
Sorpresi? Stampa il nome della vostra homedir. Ossia, la shell ha sostituito il simbolo '~' con la vostra homedir prima di passare l'esecuzione al comando echo, come se avessimo digitato:
echo /home/mario
Andiamo oltre. Date il comando:
echo /bin/ch*
ed otterrete come risposta:
<![CDATA[/bin/chgrp /bin/chmod /bin/chown ]]>
ossia la shell ha cercato in /bin tutti i file il cui nome inizia per ch e li ha elencati passandoli ad echo separati da uno spazio. Proviamone un altro:
echo /usr/bin/c?
otterrete come risposta:
<![CDATA[/usr/bin/cc /usr/bin/ci /usr/bin/co ]]>
cioè tutti i file che iniziano per c con il nome di 2 caratteri. Lo stesso succede con gli insiemi di caratteri, quelli elencati tra parentesi quadre.
Rapportando tutto questo al comando cp, se noi diamo il comando:
cp /usr/bin/c? ~/
che copia i file visti sopra nella vostra homedir, viene trasformato dalla shell nel seguente:
cp /usr/bin/cc /usr/bin/ci /usr/bin/co /home/mario/
A questo punto è chiaro che volessimo dare il comando:
cp /usr/bin/c? ~/d?
che in DOS copierebbe i file cc, ci e co nella homedir rinominadoli dc, di, do, in Linux vi stampa un bel messaggio d'errore:
<![CDATA[cp: copying multiple files, but last argument `/home/mario/d?' is not a directory ]]>
Più avanti vedremo l'uso delle variabili.
Come avrete intuito questo comando è potenzialmente pericoloso, quindi fate estrema attenzione quando lo usate, d'accordo? Il comando è rm (remove):
rm file1 file2 ....
e consente di rimuovere uno o più file in un colpo solo, ma non rimuove directory, vuote o piene che siano. Se volete modificare il comportamento potete usare due varianti:
modo 'interattivo' ossia chiede conferma prima di cancellare per ogni file. Di solito è impostato di default per l'utente root, in quanto potrebbe per errore cancellare file necessari per il funzionamento del sistema.
modo 'brutale' ossia non stampa nessun messaggio di avviso e non chiede conferme, cancella e basta
modo 'ricorsivo', cancella file e directory con il loro contenuto, file e directory che siano
l'ultima variante è molto distruttiva, quindi controllate tutto due volte prima di impartire il comando. Se poi viene abbinata all'opzione -f non chiede conferme, cancellando tutto quello che avete specificato senza fermarsi per chiedere conferme o segnalare errori.
Per spostare un file o una directory da un punto all'altro c'è il comando mv (che sta per move). Anche qui, come nel comando di copia, la destinazione può essere un singolo file, se la sorgente è un singolo file, altrimenti la destinazione deve essere una directory, per le stesse ragioni esposte sopra. In più mv permette di rinominare file e directory singoli. Se il file o la directory che spostate sono sullo stesso filesystem (ad esempio nella stessa partizione disco) l'operazione è molto rapida, in quanto il file vero non viene mosso, viene solo spostato il nome e le strutture di dati che permettono di risalire in quale parte del disco è memorizzato. Se invece lo spostamento è tra diversi filesystem (ad esempio tra una partizione Linux ed un altro disco) il file viene copiato e poi cancellato l'originale.
Anche qui esistono switch che permettono di modificare il comportamento:
non chiede conferme se l'operazione di spostamento va a soprascrivere altri file o directory
modo interattivo, ossia chiede conferma prima di soprascrivere (il contrario di -f)
Esistono anche altre opzioni, e come sempre vi rimando alla pagina man di mv.
C'è la possibilità di creare file che in realtà puntano ad altri file, ossia sono un collegamento (link) ad altri file e directory. Date il comando:
ls -l /dev/mo*
e otterrete qualcosa del genere:
lrwxrwxrwx 1 root root 11 mar 21 17:26 /dev/modem -> /dev/ttyLT0 lrwxrwxrwx 1 root root 5 ago 2 11:11 /dev/mouse -> psaux
che sono proprio due collegamenti, e si intuisce dal simbolo '->' che indica il file a cui punta il collegamento. Su RedHat 7.x i link simbolici sono evidenziati in azzurro e grassetto.
Per creare un collegamento simbolico, si usa il comando ln (che sta per link, collegamento in inglese).
L'argomento è più complesso di quanto non sembri, dato che in Linux esistono due tipi di collegamenti: fisici (detti anche hard-link) e logici (detti anche simbolici o symbolic). Quelli indicati con il simbolo '->' sono collegamenti simbolici, simili in tutto e per tutto a quelli usati in altri sistemi operativi. Infatti, il link simbolico è uno speciale file di testo che contiene il percorso al file vero. Gli hard-link sono in realtà i normali file che vedete elencati con ls. Quindi tutti i file hanno un hard-link che permette di accedervi. E' possibile far puntare più di un hard-link ad un file, ed in questo caso non c'è modo di distinguere l'hard-link originale da quello creato successivamente. Inoltre non ci sono indicazioni evidenti tra file normali (con un solo hard-link) e file con più di un hard-link, al netto di un dettaglio. Supponiamo di avere tre file dentro una directory e di dare il comando ls -l, il cui risultato è:
-rw-r--r-- 1 root root 0 set 2 19:13 pippo -rw-r--r-- 1 root root 0 set 2 19:11 pluto -rw-r--r-- 1 root root 0 set 2 19:13 prova
tenete d'occhio il numero '1' tra i permessi e il proprietario del file. Adesso date il comando:
ln pluto coll1
che significa crea un collegamento fisico al file pluto di nome coll1.
Adesso il contenuto della directory è:
-rw-r--r-- 2 root root 0 set 2 19:11 coll1 -rw-r--r-- 1 root root 0 set 2 19:13 pippo -rw-r--r-- 2 root root 0 set 2 19:11 pluto -rw-r--r-- 1 root root 0 set 2 19:13 prova
Si nota subito che i file coll1 e pluto hanno il numero '2' invece di '1', e sta a significare che ci sono due hard-link che puntano a quel file, e dato che il file è lo stesso, se modifichiamo coll1, cambia anche pluto e viceversa. Sia pluto che coll1 riportano che il file che rappresentano ha due riferimenti. Ma la cosa curiosa è che in realtà non sappiamo quale è l'originale e quale è stato aggiunto dopo. Se adesso cancelliamo pluto otteniamo:
-rw-r--r-- 1 root root 0 set 2 19:11 coll1 -rw-r--r-- 1 root root 0 set 2 19:13 pippo -rw-r--r-- 1 root root 0 set 2 19:13 prova
e come vedete adesso sono tornati tutti '1'. Ora coll1 è il file rimasto e nulla ci dice che in realtà esso è stato creato da noi come hard-link.
I link più usati sono invece quelli simbolici. Se fate un giro nel filesystem standard di Linux ne trovate parecchi, alcuni esempi sono:
lrwxrwxrwx 1 root root 7 mar 19 23:25 /etc/rc -> rc.d/rc lrwxrwxrwx 1 root root 10 mar 19 23:25 /etc/rc0.d -> rc.d/rc0.d lrwxrwxrwx 1 root root 20 mar 20 00:19 /usr/include/X11 -> ../X11R6/include/X11 lrwxrwxrwx 1 root root 4 mar 19 23:21 /bin/sh -> bash
in cui il primo e il quarto sono collegamenti a file, il secondo e terzo sono collegamenti a directory.
Per creare collegamenti simbolici il comando è:
ln -s file linkname
dove file è il file esistente a cui vogliamo creare il collegamento, linkname è il nome del collegamento stesso, e lo switch -s serve a creare appunto un link simbolico.
Se si cancella il file a cui punta il link, Linux lo indica in bianco su sfondo rosso in ls, e se tentate di accedere al file tramite il link vi viene risposto che il file non esiste.
Ultima considerazione, sui permessi: i premessi del link simbolico sono ignorati, come pure il proprietario. Valgono sempre quelli del file a cui punta, questo per evitare che possa essere indebitamente modificato. E' per questo che i link simbolici di solito hanno tutti i permessi impostati.
Esistono altri switch, come sempre date una occhiata alla manpage di ln.
In Linux, come in tutti i dialetti Unix, non esiste niente di simile al concetto di disco, inteso nel senso DOS del termine. In Linux non esiste il "disco C", ossia il disco primario su cui è installato il sistema operativo, né tantomeno esiste il "floppy A".
Esiste invece una precisa gerarchia di directory organizzate in funzione dell'uso e del tipo di dati che dovranno contenere. Tale gerarchia forma un albero di directory, la cui radice (root in inglese) è indicata con il carattere '/'. Se dalla vostra finestra terminale date il comando:
ls -l /
vedrete comparire una lista del tipo:
drwxr-xr-x 2 root root 4096 apr 16 18:37 bin drwxr-xr-x 3 root root 4096 lug 23 22:56 boot drwxr-xr-x 17 root root 77824 set 6 21:20 dev drwxr-xr-x 46 root root 4096 set 6 21:20 etc drwxr-xr-x 3 root root 4096 apr 25 12:38 home drwxr-xr-x 6 root root 4096 mar 20 00:18 lib drwxr-xr-x 2 root root 16384 ago 2 10:57 lost+found drwxr-xr-x 2 root root 4096 ago 29 2001 misc drwxr-xr-x 4 root root 4096 mag 5 12:08 mnt drwxr-xr-x 2 root root 4096 ago 23 1999 opt dr-xr-xr-x 45 root root 0 set 6 2002 proc drwxr-x--- 23 root root 4096 set 6 21:36 root drwxr-xr-x 2 root root 4096 apr 16 18:54 sbin drwxrwxrwt 15 root root 4096 set 6 21:38 tmp drwxr-xr-x 18 root root 4096 set 1 19:10 usr drwxr-xr-x 17 root root 4096 mar 20 00:12 var
Per dirla in altro modo, root (la directory radice: '/') è il punto di partenza del vostro filesystem, tutto il resto è raggiungibile partendo da qui. Non confondete root inteso come directory radice con root l'utente, anche se il nome dell'utente viene proprio dal fatto che è (e dovrebbe essere) l'unico ad avere diritti di accesso alla radice del vostro filesystem.
Vediamo adesso di fare un parallelo con il DOS. In DOS esistono i dischi, che vengono suddivisi in partizioni, a loro volta contenenti una (se è una partizione primaria) o più unità logiche (se è una partizione estesa). Ogni unità logica rappresenta poi in DOS una unità disco, per esempio C: o E: ed ogni unità disco ha una dimensione ben precisa, e di solito in C: vi è installato il sistema operativo.
Anche in Linux esistono ovviamente dischi e partizioni, ma sono trattati in maniera diversa. Una tipica installazione DOS con un solo hard disk ha una singola partizione primaria su cui è installato il sistema operativo. Una tipica installazione Linux ha due partizioni, dedicate rispettivamente allo swap ed alla root. Lo swap è lo spazio dove il sistema operativo parcheggia dati e applicazioni in esecuzione se ha necessità di spazio in memoria (simile in tutto e per tutto al file di scambio in altri sistemi operativi), mentre la partizione di root contiene il sistema operativo e tutte le applicazioni. Fin qui le cose sembrano poco differenti, ma più avanti vedremo come le cose possono cambiare drasticamente.
Tornando alla lista di directory poco sopra, in tutte le varianti di Linux, ed in gran parte degli Unix, ogni directory ha una destinazione d'uso ben precisa, e vediamo quale è:
contiene gli eseguibili (i binari appunto) dei principali comandi del sistema operativo. Se ne elencate il contenuto, vedrete tra i file "ls", "mkdir", "rm" e tutti i comandi che usate di solito.
come suggerisce il nome, contiene i file necessari alla partenza del sistema operativo, l'operazione di bootstrap, appunto.
è la directory che contiene i punti di accesso a tutti i device e tutte le periferiche del sistema. Se ne elencate il contenuto, troverete ad esempio file con nomi tipo "mouse", "cdrom", "fd0", "modem", ecc.
contiene tutti i file di configurazione del sistema. Tutte le impostazioni principali, tutti i dati di identificazione degli utenti sono in questa directory all'interno di uno o più file ASCII. Ad esempio il file "passwd" contiene i nomi ed i dati principali di tutti gli utenti conosciuti. Il file "group" contiene tutti i gruppi di utenti conosciuti.
in molte varianti di Linux è qui che gli utenti hanno la loro directory e tutti i loro file di lavoro. I permessi di accesso e la proprietà di ogni directory è organizzata in modo che ogni utente abbia assicurata la privacy e l'integrità dei propri dati.
qui sono di solito memorizzate le librerie condivise (shared) utilizzate da praticamente tutti i comandi principali del sistema operativo. Ad esempio qui trovate la libc, basilare per il funzionamento del sistema. All'interno di una sottodirectory di nome "modules" trovate i moduli del kernel di Linux, una sorta di driver che vengono caricati quando ce n'è bisogno. Ne parleremo a tempo debito.
non è detto che abbiate questa directory fra le vostre. Dato che anche in Linux esiste il pericolo di errori nel filesystem causati da spegnimenti accidentali del computer, esiste anche la specifica utility che li cerca e li corregge. Gli eventuali file persi e ritrovati vengono memorizzati appunto qui (lost=perso e found=trovato in inglese)