Capitolo 1. Tutorial GNU/Linux

Ecco alcuni metodi di base per ottenere il prompt di shell per root usando la password di root.

Si digita Ctrl-D, cioè il tasto_Ctrl_sinistro e il tasto_d vengono premuti contemporaneamente al prompt dei comandi per chiuderà l'attività della shell. Se si è nella console a caratteri, in questo modo si ritorna al prompt di login. Anche se questi caratteri di controllo vengono indicati con le lettere maiuscole, come "control D", non è necessario premere il tasto Maiusc. Per indicare Ctrl-D viene anche usata l'espressione abbreviata ^D. In alternativa si può digitare "exit".

In quest'ultimo modo, se si è in un emulatore di terminale (x-terminal-emulator(1)), lo si può chiudere.

Quando, dopo aver fatto qualcosa di strano come "cat <un-qualche-file-binario>", lo schermo impazzisce digitare "reset" al prompt dei comandi. Mentre lo si digita il comando potrebbe non essere visualizzato. Si può anche usare "clear" per pulire lo schermo.

Sebbene anche l'installazione minima del sistema Debian, senza alcun ambiente desktop, fornisca le funzionalità Unix di base è una buona idea installare con apt-get(8) alcuni pacchetti aggiuntivi per la riga di comando e i terminali a caratteri basati su curses, come mc e vim con cui i principianti possono fare i primi passi. Eseguire i comandi seguenti.

# apt-get update
 ...
# apt-get install mc vim sudo
 ...

Se questi pacchetti sono già installati, nessun nuovo pacchetto sarà installato.

Potrebbe essere una buona idea leggere un po' di documentazione.

Si possono installare alcuni di questi pacchetti usando i comandi seguenti.

# apt-get install nome_pacchetto

Se non si vuole usare il proprio account utente principale per le esercitazioni descritte in seguito, si può creare un account utente per esercitarsi, ad esempio pesce con il comando seguente.

# adduser pesce

Rispondere a tutte le domande.

In questo modo si crea un nuovo account chiamato pesce. Dopo aver fatto pratica si può rimuover questo account e la sua directory home digitando quanto segue.

# deluser --remove-home pesce

Per la tipica postazione di lavoro di un unico utente, come il sistema desktop Debian su un PC portatile, è frequente l'uso di una semplice configurazione di sudo(8), come qui di seguito descritto, per permettere all'utente non privilegiato, ad esempio pinguino, di ottenere privilegi di amministratore con la sola propria password, senza quella dell'utente root.

# echo "pinguino  ALL=(ALL) ALL" >> /etc/sudoers

In alternativa è uso comune usare la configurazione seguente per permettere all'utente non privilegiato, ad esempio pinguino, di ottenere privilegi di amministratore senza alcuna password.

# echo "pinguino  ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers

Questo trucco dovrebbe essere usato esclusivamente per le postazioni di lavoro con un solo utente, in cui l'utente è anche l'amministratore.

	Avvertimento
	Non impostare account per utenti regolari su postazioni di lavoro multi-utente in questo modo perché ciò sarebbe un grosso problema per la sicurezza del sistema.

	Attenzione
	Nell'esempio precedente la password e l'account di pinguino richiedono altrettanta protezione della password e account dell'utente root.

	Attenzione
	I privilegi di amministrazione in questo contesto sono forniti a qualcuno che è autorizzato ad eseguire i compiti di amministrazione del sistema sulla macchina. Non dare mai tali privilegi ad un manager del dipartimento di Amministrazione della propria azienda o al proprio capo, a meno che non siano autorizzati e capaci.

	Nota
	Per fornire privilegi di accesso a specifici device e file, si dovrebbe considerare l'uso dei gruppi per dare un accesso limitato, invece di usare i privilegi di root attraverso sudo(8).

	Nota
	Con una configurazione più attenta e precisa, sudo(8) può garantire privilegi amministrativi limitati ad altri utenti in un sistema condiviso, senza rendere nota la password di root. Questo può aiutare la tracciabilità su host con più di un amministratore, in modo che si possa dire chi ha fatto cosa. D'altra parte si potrebbe anche volere che nessuno abbia tali privilegi.

Si è ora pronti a giocare con il sistema Debian senza rischi fintanto che si usa l'account utente non privilegiato.

Ecco alcune nozioni di base sui file Unix.

Per cambiare il proprietario di un file da un account root si usa chown(1). Per cambiare il gruppo di un file dall'account del proprietario o da quello di root si usa chgrp(1). Per cambiare i permessi di accesso di file o directory dall'account del proprietario o da quello di root si usa chmod(1). La sintassi di base per manipolare un file pippo è la seguente.

# chown <nuovoproprietario> pippo
# chgrp <nuovogruppo> pippo
# chmod  [ugoa][+-=][rwxXst][,...] pippo

Per esempio si può fare in modo che l'utente pippo sia il proprietario di un albero di directory condivisa dal gruppo pluto con i seguenti comandi.

# cd /qualche/posizione/
# chown -R pippo:pluto .
# chmod -R ug+rwX,o=rX .

Ci sono altri tre bit speciali di permessi.

Nell'output di "ls -l" il valore di questi bit è maiuscolo se il bit di permesso di esecuzione nascosto da essi è non impostato.

L'impostazione del bit set user ID per un file eseguibile permette ad un utente di eseguire quel file con l'ID del proprietario del file (per esempio root). In modo simile, l'impostazione del bit set group ID per un file eseguibile permette ad un utente di eseguire il file con l'ID del gruppo a cui appartiene il file (per esempio root). Poiché l'impostazione di questi bit può causare rischi in termini di sicurezza, il loro uso richiede una particolare cautela.

Sembra complicato, ma è in realtà piuttosto semplice. Se si guardano le prime colonne (2-10) nell'output del comando "ls -l" e le si leggono come una rappresentazione binaria (base=2) dei permessi sui file (dove "-" equivale a "0" e "rwx" equivalgono a "1"), le ultime 3 cifre del valore numerico dei permessi dovrebbero apparire come la corretta rappresentazione dei permessi sui file in numerazione ottale (base=8).

Per esempio, provare a fare quanto segue.

$ touch pippo pluto
$ chmod u=rw,go=r pippo
$ chmod 644 pluto
$ ls -l pippo pluto
-rw-r--r-- 1 pinguino pinguino 0 ott 16 21:39 pluto
-rw-r--r-- 1 pinguino pinguino 0 ott 16 21:35 pippo

	Suggerimento
	Se si deve aver accesso alle informazioni visualizzate da "ls -l" in script di shell, si dovrebbero usare i comandi pertinenti, come test(1), stat(1) e readlink(1). Si possono usare anche i comandi interni della shell come "[" o "test".

I permessi che vengono applicati ad un file o una directory appena creati sono limitati dal comando interno della shell umask. Vedere dash(1), bash(1) e builtins(7).

(permessi del file) = (permessi del file richiesti) & ~(valore di umask)

Il sistema Debian usa, in modo predefinito, uno schema UPG (User Private Group, gruppo privato dell'utente). Ogni volta che viene aggiunto un nuovo utente al sistema, viene creato un UPG; questo ha lo stesso nome dell'utente per il quale è stato creato e quell'utente è l'unico membro dell'UPG. Lo schema UPG rende sicura l'impostazione della umask a 0002 dato che ogni utente ha il proprio gruppo privato. (In alcune varianti di Unix è abbastanza comune impostare tutti gli utenti normali come appartenenti ad un unico gruppo users ed è in quel caso una buona idea impostare umask a 0022 per ragioni di sicurezza.)

	Suggerimento
	Abilitare UPG inserendo "umask 002" nel file ~/.bashrc.

Per far sì che i permessi di un gruppo vengano applicati ad un particolare utente, tale utente deve essere inserito come membro del gruppo usando "sudo vigr" per /etc/group e "sudo vigr -s" per /etc/gshadow. Per abilitare la nuova configurazione dei gruppi è necessario fare il log out e quindi di nuovo il login (oppure eseguire "exec newgrp").

	Nota
	In alternativa, si possono aggiungere dinamicamente gli utenti ai gruppi durante il processo di autenticazione aggiungendo la riga "auth optional pam_group.so" al file "/etc/pam.d/common-auth" e configurando "/etc/security/group.conf". (Vedere Capitolo 4, Autenticazione.)

I dispositivi hardware sono, in un sistema Debian, semplicemente un altro tipo di file. Se si hanno problemi ad accedere a dispositivi quali CD-ROM e chiavette USB da un account utente, si dovrebbe inserire quell'utente nel gruppo appropriato.

Alcuni importanti gruppi pre-impostati dal sistema permettono ai loro membri l'accesso a file e device particolari senza i privilegi di root.

	Suggerimento
	È necessario far parte del gruppo dialout per riconfigurare il modem, comporre numeri, ecc. Se però root crea file di configurazione predefiniti per i peer fidati in "/etc/ppp/peers/", è necessario solamente far parte del grupo dip per creare una connessione IP dialup a tali peer fidati usando i comandi pppd(8), pon(1) e poff(1).

Alcuni importanti gruppi pre-impostati dal sistema permettono ai loro membri di eseguire particolari comandi senza i privilegi di root.

Per l'elenco completo degli utenti e gruppi forniti dal sistema, vedere la recente versione del documento "Utenti e gruppi" in "/usr/share/doc/base-passwd/users-and-groups.html" fornito dal pacchetto base-passwd.

Vedere passwd(5), group(5), shadow(5), newgrp(1), vipw(8), vigr(8) e pam_group(8) per informazioni sui comandi di gestione di utenti e gruppi sul sistema.

Ci sono tre tipi di orari per un file GNU/Linux.

	Nota
	ctime non è l'orario di creazione del file.

Nota

Persino la semplice lettura di un file su un sistema Debian genera normalmente un'operazione di scrittura sul file per aggiornare l'informazione atime nell'inode. Montando un file system con le opzioni "noatime" o "relatime" fa sì che il sistema salti questa operazione e ciò ha come risultato un accesso ai file in lettura più veloce. Viene spesso raccomandato per i portatili, perché riduce l'attività del disco fisso e fa risparmiare energia. Vedere mount(8).

Usare il comando touch(1) per cambiare l'orario di file esistenti.

Per gli orari, il comando ls produce stringhe diverse con le localizzazioni non in inglese ("it_IT.UTF-8") rispetto alla vecchia ("C").

$ LANG=it_IT.UTF-8  ls -l pippo
-rw-rw-r-- 1 pinguino pinguino 0 ott 16 21:35 pippo
$ LANG=C  ls -l pippo
-rw-rw-r-- 1 pinguino pinguino 0 Oct 16 21:35 pippo

	Suggerimento
	Vedere Sezione 9.2.5, «Visualizzazione personalizzata di date e orari» per personalizzare l'output di "ls -l".

Ci sono due metodi per associale un file "pippo" ad un diverso nome file "pluto".

Ci sono alcuni file di device speciali.

Per far sì che MC cambi la directory di lavoro in uscita e si sposti con cd nella directory, suggerisco di modificare "~/.bashrc" per includere uno scipt fornito nel pacchetto mc.

. /usr/lib/mc/mc.sh

Vedere mc(1) (sotto l'opzione "-P") per capirne la ragione. (Se non è chiaro esattamento quello di cui sto parlando, si può tornare a questo più tardi.)

MC può essere avviato nel modo seguente.

$ mc

MC si prende cura di tutte le operazioni sui file attraverso i suoi menu, richiedendo perciò solo un minimo sforzo da parte dell'utente. Premere semplicemente F1 per ottenere la schermata di aiuto. Si può giocherellare con MC premendo semplicemente i tasti freccia e i tasti funzione.

	Nota
	In alcune console, come gnome-terminal(1), le battute sui tasti funzione potrebbero essere rubate dal programma di console. Si possono disabilitare queste funzionalità per gnome-terminal in "Modifica" → "Scorciatoie da tastiera".

Se si incontrano problemi di codifica dei caratteri con visualizzazione di caratteri spazzatura, l'aggiunta dell'opzione "-a" alla riga di comando di MC può aiutare a prevenirli.

L'impostazione predefinita è con due pannelli di directory contenenti gli elenchi dei file. Un'altra utile modalità è l'impostazione della finestra destra per contenere le "informazioni" per vedere informazioni sui privilegi di accesso dei file, ecc. Di seguito sono elencati alcuni tasti essenziali. Con il demone gpm(8) in esecuzione, si può anche usare il mouse in una console a caratteri Linux. (Assicurarsi di premeri il tasto Maiusc per ottenere il comportamento normale di taglia e incolla in MC.)

L'editor interno ha un interessante schema per il taglia e incolla. La pressione di F3 marca l'inizio di una selezione, una seconda pressione di F3 marca la fine della selezione e la evidenzia. Si può poi muovere il cursore. Se si preme F6, l'area selezionata viene spostata nella posizione del cursore. Se si preme F5 l'area selezionata viene copiata ed inserita alla posizione del cursore. F2 salva il file. F10 fa uscire. La maggior parte dei tasti cursore funziona in modo intuitivo.

Si può avviare direttamente questo editor su di un file usando uno dei comandi seguenti.

$ mc -e nome_del_file_da_modificare

$ mcedit nome_del_file_da_modificare

Questo non è un editor multi-finestra, ma si possono usare più console Linux per ottenere lo stesso effetto. Per copiare tra finestre, usare i tasti Alt-F<n> per cambiare console virtuale e usare "File→Insert file" o "File→Copy to file" per spostare una porzione di un file in un altro file.

Questo editor interno può essere rimpiazzato da qualsiasi editor esterno a propria scelta.

Inoltre molti programmi usano la variabile d'ambiente "$EDITOR" o "$VISUAL" per decidere quale editor usare. Se inizialmente non ci si trova a proprio agio con vim(1) o nano(1), si può impostare queste variabili a "mcedit" aggiungendo le righe seguenti al file "~/.bashrc".

export EDITOR=mcedit
export VISUAL=mcedit

Io raccomando di impostarle a "vim", se possibile.

Se non ci si trova a proprio agio con vim(1), si può continuare ad usare mcedit(1) per la maggior parte dei compiti di manutenzione del sistema.

MC è un visualizzatore molto intelligente. È un grande strumento per cercare parole in documenti. Lo uso sempre per i file nella directory "/usr/share/doc". È il metodo più veloce per navigare tra una massa di informazioni Linux. Questo visualizzatore può essere avviato direttamente usando uno dei comandi seguenti.

$ mc -v percorso/del/nome_file_da_visualizzare

$ mcview percorso/del/nome_file_da_visualizzare

Per far sì che queste funzionalità di visualizzazione dei file e di file virtuali funzionino, i file visualizzabili non dovrebbero essere impostati come eseguibili. Cambiare il loro stato usando chmod(1) o attraverso il menu file di MC.

MC può essere usato per accedere a file in Internet usando FTP. Premere F9 per andare nel menu, poi digitare "p" per attivare il file system FTP virtuale. Inserire un URL nella forma "nomeutente:password@nomehost.nomedominio" e la directory remota apparirà come una directory locale.

Provare "[deb.debian.org/debian]" come URL e navigare nell'archivio Debian.

Si può selezionare la propria shell di login con chsh(1).

	Suggerimento
	Sebbene le shell in stile POSIX condividano la stessa sintassi di base, esse possono differire nel comportamento relativo a cose anche basilari, come le variabili della shell e l'espansione dei modelli glob. Per i dettagli controllare la loro documentazione.

In questo capitolo del tutorial la shell interattiva considerata è sempre bash.

Si può personalizzare il comportamento di bash(1) con "~/.bashrc".

Per esempio provare quanto segue.

# enable bash-completion
if ! shopt -oq posix; then
  if [ -f /usr/share/bash-completion/bash_completion ]; then
    . /usr/share/bash-completion/bash_completion
  elif [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
  fi
fi

# CD quando si esce da MC
. /usr/lib/mc/mc.sh

# impostare il CDPATH ad un buon valore
CDPATH=.:/usr/share/doc:~:~/Desktop:~
export CDPATH

PATH="${PATH+$PATH:}/usr/sbin:/sbin"
# impostare PATH in modo che includa la directory bin privata dell'utente se esiste
if [ -d ~/bin ] ; then
  PATH="~/bin${PATH+:$PATH}"
fi
export PATH

EDITOR=vim
export EDITOR

	Suggerimento
	Si possono trovare altri suggerimenti sulla personalizzazione di bash(1), come Sezione 9.2.7, «Comandi colorati», in Capitolo 9, Suggerimenti per il sistema.

	Suggerimento
	Il pacchetto bash-completion permette il completamento automatico per bash.

Il funzionamento del mouse in stile Unix è basato sul sistema a 3 pulsanti.

La rotella centrale presente nei mouse moderni viene considerata come il pulsante di mezzo e può essere usata per fare il corrispondente clic. Cliccare contemporaneamente con i pulsanti destro e sinistro funziona da clic di mezzo nelle situazioni in cui si hanno mouse a 2 pulsanti. Per poter usare il mouse in una console a caratteri Linux è necessario che gpm(8) sia in esecuzione come demone.

less(1) è il paginatore (navigatore del contenuto dei file) migliorato. Premere "h" per l'aiuto. Può fare molto di più di more(1) e può essere fornito di superpoteri eseguendo "eval $(lesspipe)" o "eval $(lessfile)" nello script di avvio della shell. Vedere ulteriori informazioni in "/usr/share/doc/lessf/LESSOPEN". L'opzione "-R" permette output raw e abilita le sequenze di escape ANSI per i colori. Vedere less(1).

Debian è fornita con svariati editor differenti. Si raccomanda di installare, come detto in precedenza, il pacchetto vim.

Debian fornisce un accesso unificato all'editor predefinito di sistema attraverso il comando "/usr/bin/editor" in modo che altri programmi (ad esempio reportbug(1)) possano richiamarlo. Lo si può modificare con il comando seguente.

$ sudo update-alternatives --config editor

Io raccomando ai principianti la scelta di "/usr/bin/vim.basic" invece di"/usr/bin/vim.tiny" dato che supporta l'evidenziazione della sintassi.

	Suggerimento
	Molti programmi usano la variabile d'ambiente "$EDITOR" o "$VISUAL" per decidere quale editor usare (vedereSezione 1.3.5, «L'editor interno di MC» e Sezione 9.3.11, «Personalizzare i programmi da avviare». Per coerenza, in un sistema Debian, impostare queste variabili a "/usr/bin/editor". (Storicamente "$EDITOR" era "ed" e "$VISUAL" era "vi".)

Si può personalizzare il comportamento di vim(1) tramite "~/.vimrc".

Per esempio, provare a fare quanto segue.

" -------------------------------
" Configurazione locale
"
set nocompatible
set nopaste
set pastetoggle=<f2>
syn on
if $USER == "root"
 set nomodeline
 set noswapfile
else
 set modeline
 set swapfile
endif
" riempimento per evitare che la riga sopra sia considerata una modeline
" riempimento
" riempimento

L'output dei comandi di shell può scorrere fuori dallo schermo e potrebbe essere perduto per sempre. È buona norma registrare le attività di shell in un file in modo da poterle riguardare in seguito. Questo tipo di registro è essenziale quando si fa una qualsiasi attività di amministrazione del sistema.

Il metodo base per registrare l'attività di shell è di eseguirla sotto script(1).

Per esempio, provare a fare quanto segue.

$ script
Script è avviato, il file è typescript

Eseguire qualsiasi comando di shell sotto script.

Premere Ctrl-D per uscire da script.

$ vim typescript

È bene imparare i comandi Unix di base. Il termine "Unix" è qui usato in senso lato; ogni SO clone di Unix offre di solito comandi equivalenti. Il sistema Debian non fa eccezione. Non ci si preoccupi se, al momento, alcuni comandi non funzionano come si vorrebbe. Se si usa alias nella shell, i corrispondenti output dei comandi sono diversi. Questi esempi non sono pensati per essere eseguiti necessariamente in questo ordine.

Provare tutti i comandi seguenti da un account utente non privilegiato.

	Nota
	Unix tradizionalmente nasconde i nomi di file che iniziano con ".". Sono tradizionalmente file contenenti informazioni di configurazione e preferenze dell'utente.

	Nota
	Per il comando cd vedere builtins(7).

	Nota
	Il paginatore predefinito del sistema di base di Debian è more(1) che non ha lo scorrimento all'indietro. Installando il pacchetto less, con la riga di comando "apt-get install less", less(1) diventa il paginatore predefinito e si può così scorrere il testo all'indietro usando i tasti freccia.

Nota

I caratteri "[" e "]" nella espressione regolare del comando "ps aux | grep -e "[e]xim4*"" sopra citato, permettono a grep di evitare di trovare corrispondenza con sé stesso. La parte "4*" nella espressione regolare significa 0 o più ripetizioni del carattere "4" e perciò permette a grep di trovare corrispondenza sia con "exim" sia con "exim4". Sebbene il carattere "*" sia usato nei nomi di file con metacaratteri della shell e nelle espressioni regolari, il suo significato è diverso nei due casi. Si possono imparare le espressioni regolari da grep(1).

Come esercizio, esplorare le directory e dare un'occhiata al sistema usando i comandi citati sopra. Se si hanno domande su uno qualsiasi dei comandi in console, assicurarsi di leggere la pagina di manuale.

Per esempio, provare a fare quanto segue.

$ man man
$ man bash
$ man builtins
$ man grep
$ man ls

Può essere un po' difficile abituarsi allo stile delle pagine man perché sono piuttosto concise, in particolar modo le più vecchie e tradizionali. Una volta che ci si fa la mano, però, si apprezza la loro concisione.

Notare che molti comandi in stile Unix, inclusi quelli da GNU e BSD, mostrano una breve informazione di aiuto se li si invoca in uno dei modi seguenti (o in alcuni casi se lo si fa senza usare opzioni).

$ <nomecomando> --help
$ <nomecomando> -h

Il valore completo di localizzazione impostato nella variabile "$LANG" consiste di 3 parti: "xx_YY.ZZZZ".

Per i codici delle lingue e dei paesi, vedere le descrizioni pertinenti in "info gettext".

In un sistema Debian moderno il codeset dovrebbe essere sempre impostato a UTF-8, a meno che non si voglia specificatamente usare uno usato in passato e avendo una buona ragione e le conoscenze per farlo.

Una tipica esecuzione di un comando usa una sequenza sulla riga della shell come la seguente.

$ date
Sun Jun  3 10:27:39 JST 2007
$ LANG=fr_FR.UTF-8 date
dimanche 3 juin 2007, 10:27:33 (UTC+0900)

In questo caso il programma date(1) viene eseguito con valori differenti della variabile d'ambiente "$LANG".

Quando si digita un comando nella shell, questa cerca il comando nelle directory nell'elenco contenuto nella variabile d'ambiente "$PATH". Il valore della variabile d'ambiente "$PATH" è anche chiamato percorso di ricerca della shell.

In una installazione Debian standard, la variabile d'ambiente "$PATH" degli account utente può non includere "/sbin" e "/usr/sbin". Il comando ifconfig, per esempio, deve essere eseguito con il percorso completo, come in "/sbin/ifconfig". (Il comando simile ip si trova in "/bin".)

Si può modificare la variabile d'ambiente "$PATH" della shell Bash tramite il file "~/.bash_profile" o "~/.bashrc".

Molti comandi memorizzano una configurazione specifica per l'utente nella directory home e cambiano il loro comportamento in base al suo contenuto. La directory home è identificata dalla variabile d'ambiente "$HOME".

Alcuni comandi accettano argomenti. Gli argomenti che iniziano con "-" o "--" sono chiamati opzioni e controllano il comportamento del comando.

$ date
dom apr 18 23:22:36 CEST 2010
$ date -R
Sun, 18 Apr 2010 23:23:08 +0200

Spesso si desidera che un comando abbia effetto su un gruppo di file senza dover digitarli tutti. I modelli di espansione dei nomi di file che usano i glob della shell, a volte detti metacaratteri o caratteri jolly, facilitano questo compito.

Per esempio, provare a fare quanto segue.

$ mkdir prova; cd prova; touch 1.txt 2.txt 3.c 4.h .5.txt ..6.txt
$ echo *.txt
1.txt 2.txt
$ echo *
1.txt 2.txt 3.c 4.h
$ echo *.[hc]
3.c 4.h
$ echo .*
. .. .5.txt ..6.txt
$ echo .*[^.]*
.5.txt ..6.txt
$ echo [^1-3]*
4.h
$ cd ..; rm -rf prova

Vedere glob(7).

	Nota
	A differenza della normale espansione dei nomi della shell, il modello shell "*" cercato dal comando find(1) con la ricerca "-name" ecc., trova corrispondenza anche con nomi di file che iniziano con ".". (Nuova funzionalità POSIX.)

	Nota
	Si può manipolare il comportamento di BASH in relazione ai modelli di glob usando le sue opzioni shopt incorporate come "dotglob", "noglob", "nocaseglob", "nullglob", "extglob", ecc. Vedere bash(1).

Ogni comando restituisce il suo stato di uscita (variabile "$?") come valore restituito.

Per esempio provare quanto segue.

$ [ 1 = 1 ] ; echo $?
0
$ [ 1 = 2 ] ; echo $?
1

	Nota
	Notare che, nel contesto logico della shell, il successo è trattato come il valore logico VERO che ha valore numerico 0 (zero). Questo è in qualche modo non intuitivo ed è bene rimarcarlo.

È bene cercare di ricordare i seguenti idiomi per comandi di shell che vengono digitati sulla stessa riga come parte del comando di shell.

Il sistema Debian è un sistema multi-tasking. I compiti sullo sfondo permettono agli utenti di eseguire più programmi in una singola shell. La gestione dei processi sullo sfondo coinvolge i comandi interni della shell jobs, fg, bg e kill. Leggere le sezioni "SIGNALS" e "JOB CONTROL" di bash(1) e builtins(1).

Per esempio, provare a fare quanto segue.

$ </etc/motd pager

$ pager </etc/motd

$ pager /etc/motd

$ cat /etc/motd | pager

Benché tutti i 4 esempi di ridirezione della shell mostrino la stessa cosa, l'ultimo esempio esegue un comando cat aggiuntivo e spreca risorse senza motivo.

La shell permette di aprire file usando il comando interno execcon un descrittore di file arbitrario.

$ echo Hello >pippo
$ exec 3<pippo 4>pluto  # apre i file
$ cat <&3 >&4       # ridirige lo stdin in 3, lo stdout in 4
$ exec 3<&- 4>&-    # chiude i file
$ cat pluto
Hello

I descrittori di file 0-2 sono predefiniti.

Si possono impostare alias per i comandi usati di frequente.

Per esempio, provare a fare quanto segue.

$ alias la='ls -la'

Ora "la" funziona da scorciatoia per "ls -la" che elenca tutti i file nel formato di elencazione esteso.

Si possono elencare tutti gli alias esistenti con alias (vedere la sezione "SHELL BUILTIN COMMANDS" in bash(1)).

$ alias
...
alias la='ls -la'

Si può identificare il percorso esatto o l'identità di un comando con type (vedere la sezione "SHELL BUILTIN COMMANDS") di bash(1)).

Per esempio, provare a fare quanto segue.

$ type ls
ls is hashed (/bin/ls)
$ type la
la is aliased to ls -la
$ type echo
echo is a shell builtin
$ type file
file is /usr/bin/file

In questo caso ls era stato cercato di recente mentre "file" no, percio "ls" risulta "hashed", cioè la shell ha un record interno per un accesso veloce alla posizione del comando "ls".

	Suggerimento
	Vedere Sezione 9.2.7, «Comandi colorati».

Ci sono alcuni strumenti di elaborazione del testo che sono usati molto spesso in un sistema *nix.

Le espressioni regolari di emacs sono fondamentalmente BRE, ma sono state estese per trattare "+" e "?" come i metacaratteri nelle ERE. Perciò, nelle espressioni regolari di emacs, non è necessario proteggerli con il carattere di escape "\".

Per effettuare ricerche di testo usando espressioni regolari si può usare grep(1).

Per esempio, provare a fare quanto segue.

$ egrep 'GNU.*LICENSE|Yoyodyne' /usr/share/common-licenses/GPL
GNU GENERAL PUBLIC LICENSE
GNU GENERAL PUBLIC LICENSE
Yoyodyne, Inc., hereby disclaims all copyright interest in the program

	Suggerimento
	Vedere Sezione 9.2.7, «Comandi colorati».

Per le espressioni di sostituzione alcuni caratteri hanno un significato particolare.

Per sostituzioni di stringhe in Perl "$n" viene usato al posto di "\n" e "&" non ha un significato particolare.

Per esempio, provare a fare quanto segue.

$ echo zzz1abc2efg3hij4 | \
sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/=&=/'
zzz=1abc2efg3hij4=
$ echo zzz1abc2efg3hij4 | \
sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/\2===\1/'
zzzefg3hij4===1abc
$ echo zzz1abc2efg3hij4 | \
perl -pe 's/(1[a-z]*)[0-9]*(.*)$/$2===$1/'
zzzefg3hij4===1abc
$ echo zzz1abc2efg3hij4 | \
perl -pe 's/(1[a-z]*)[0-9]*(.*)$/=&=/'
zzz=&=

In questo esempio si faccia particolare attenzione allo stile delle espressioni regolari tra parentesi e come le stringhe corrispondenti siano usate nel processo di sostituzione del testo dai diversi strumenti.

Queste espressioni regolari possono essere usate per spostare il cursore e per fare sostituzioni di testo anche in alcuni editor.

La barra inversa, "\" alla fine della prima riga nella riga di comando di shell protegge il carattere di a capo rendendolo uno spazio e continuando l'input della riga di comando di shell nella riga successiva.

Leggere tutte le pagine man relative per imparare l'uso di questi comandi.

Il comando ed(1) può sostituire tutte le occorrenze di "DA_REGEX" con "A_TESTO" in "file".

$ ed file <<EOF
,s/DA_REGEX/A_TESTO/g
w
q
EOF

Il comando sed(1) può sostituire tutte le occorrenze di "DA_REGEX" con "A_TESTO" in "file".

$ sed -i -e 's/DA_REGEX/A_TESTO/g' file

Il comando vim(1) può sostituire tutte le occorrenze di "DA_REGEX" with "A_TESTO" in "file" usando il comando ex(1).

$ vim '+%s/DA_REGEX/A_TESTO/gc' '+w' '+q' file

	Suggerimento
	Il modificatore "c" nell'esempio soprastante assicura che venga chiesta la conferma interattiva per ciascuna sostituzione.

Si possono elaborare file multipli ("file1", "file2" e "file3") in modo simile con vim(1) o perl(1).

$ vim '+argdo %s/DA_REGEX/A_TESTO/ge|update' '+q' file1 file2 file3

	Suggerimento
	Il modificatore "e" nell'esempio soprastante evita che un errore di nessuna corrispondenza trovata ("No match") rompa il processo.

$ perl -i -p -e 's/DA_REGEX/A_TESTO/g;' file1 file2 file3

Nell'esempio perl(1), "-i" è per la modificain-situ di ciascun file interessato, e "-p" è perreiterare implicitamente il comando su tutti i file specificati.

	Suggerimento
	L'uso dell'opzione "-i.bak" invece di "-i" preserva una copia del file originale aggiungendo il suffisso ".bak" al suo nome file. Questo permette di ripristinare le cose più facilmente in caso di errori in sostituzioni complesse.

	Nota
	ed(1) e vim(1) usano BRE; perl(1) usa ERE.

Considerare per esempio un file ti testo chiamato "DPL" in cui sono elencati, in un formato separato da spazi, alcuni nomi di leader del progetto Debian pre-2004 e la data della loro installazione.

Ian     Murdock   Agosto  1993
Bruce   Perens    Aprile  1996
Ian     Jackson   Gennaio 1998
Wichert Akkerman  Gennaio 1999
Ben     Collins   Aprile  2001
Bdale   Garbee    Aprile  2002
Martin  Michlmayr Marzo   2003

	Suggerimento
	Vedere "Una breve storia di Debian" per la storia della Guida del progetto Debian aggiornata.

Awk viene usato spesso per estrarre dati da questo tipo di file.

Per esempio, provare a fare quanto segue.

$ awk '{ print $3 }' <DPL                   # mese di inizio
Agosto
Aprile
Gennaio
Gennaio
Aprile
Aprile
Marzo
$ awk '($1=="Ian") { print }' <DPL          # leader del progetto chiamato Ian
Ian     Murdock   Agosto  1993
Ian     Jackson   Gennaio 1998
$ awk '($2=="Perens") { print $3,$4 }' <DPL # quando ha iniziato Perens
Aprile 1996

Questo tipo di file può anche essere analizzato con le shell tipo Bash.

Per esempio, provare a fare quanto segue.

$ while read nome cognome mese anno; do
    echo $mese
  done <DPL
... stesso output del primo esempio Awk

In questo caso, il comando incorporato read usa i caratteri in "$IFS" (internal field separator, separatore di campi interno) per suddividere le righe in parole.

Se si modifica "$IFS" in ":", si possono analizzare facilmente con la shell i file "/etc/passwd".

$ vecchioIFS="$IFS"   # salva il vecchio valore
$ IFS=':'
$ while read utente password uid gid resto_della_riga; do
    if [ "$utente" = "bozo" ]; then
      echo "l'ID di $utente e' $uid"
    fi
  done < /etc/passwd
l'ID di bozo e' 1000
$ IFS="$vecchioIFS"   # ripristina il vecchio valore

(Se si usa Awk per fare la stessa cosa, usare "FS=':'" per impostare il separatore di campi.)

IFS viene anche usato dalla shell per suddividere i risultati dell'espansione di parametri, sostituzione di comandi ed espansioni aritmetiche. Queste non avvengono all'interno delle virgolette singole o doppie. Il valore predefinito di IFS è la combinazione di <spazio>, <tab> e <a capo>

Essere prudenti nell'uso di questi trucchetti di shell con IFS. Possono accadere strane cose quando la shell interpreta alcune parti dello script come suo input.

$ IFS=":,"                        # usa ":" e "," come IFS
$ echo IFS=$IFS,   IFS="$IFS"     # echo e'  un comando interno di Bash
IFS=  , IFS=:,
$ date -R                         # un output di comando qualunque
Sat, 23 Aug 2003 08:30:15 +0200
$ echo $(date -R)                 # sotto-shell --> input alla shell principale
Sat  23 Aug 2003 08 30 36 +0200
$ unset IFS                       # reimposta il valore predefinito di IFS
$ echo $(date -R)
Sat, 23 Aug 2003 08:30:50 +0200

Gli script seguenti fanno alcune cose carine se inseriti in una pipe.