Appendice D. Comandi di uso comune

Questa appendice raccoglie una serie di casi tipici di utilizzo di comandi di vario tipo. La descrizione di questi viene fatta subito prima di mostrare l'esempio a cui ognuna si riferisce. Questi esempi sono solo un promemoria per chi conosce già l'uso dei comandi mostrati. Se questi venissero utilizzati da persone inesperte, potrebbero produrre risultati indesiderabili, anche gravi.

Per semplificare gli esempi, la sintassi mostrata fa riferimento all'utilizzo con una shell particolare: Bash.

Gli esempi sono mostrati in forma di schema sintattico, dove le parentesi quadre conservano il ruolo di delimitazione di una componente opzionale, mentre le parentesi graffe, se utilizzate, fanno parte proprio del comando. Inoltre, dove necessario, vengono inseriti apici (singoli o doppi, a seconda della necessità) e barre oblique inverse (\) per segnalare la protezione di qualche elemento che non deve essere interpretato nel modo consueto della shell Bash.

D.1 GNU/Linux: console VGA

Definisce un cursore intermittente sottolineato (normale).
```
echo -e '\033[?2c'
```
Definisce un cursore intermittente a blocco.
```
echo -e '\033[?6c'
```

D.2 Directory, percorsi e contenuti

I comandi utilizzati negli esempi di questa sezione sono descritti nel capitolo 58.

Crea le directory indicate e anche le eventuali directory precedenti, se necessario.
```
mkdir -p directory...
```
Crea le directory indicate specificando la modalità di accesso (i permessi).
```
mkdir -m permessi directory...
```
Cancella le directory indicate e anche le eventuali directory precedenti, se queste risultano vuote.
```
rmdir -p directory...
```
Estrae il nome finale di un percorso, togliendo anche il suffisso, se indicato.
```
basename percorso [estensione]
```
Estrae la directory da un percorso. In pratica, elimina il nome finale dal percorso.
```
dirname percorso
```
Elenca tutti i file, anche quelli che iniziano con un punto.
```
ls -a nome...
```
Elenca i file indicando anche il numero di inode rispettivo.
```
ls -i nome...
```
Elenca i file, aggiungendovi un simbolo alla fine, per evidenziarne il tipo.
```
ls -F nome...
```
Elenca i file classificandone il tipo, in base al magic number.
```
file nome...
```
Calcola lo spazio totale utilizzato, espresso in Kibyte, per ogni directory indicata.
```
du -s nome...
```
Restituisce i percorsi dei file binari che verrebbero utilizzati per i comandi indicati come argomento.
```
which nome...
```
Localizza i file binari e le pagine di manuale dei comandi indicati come argomento.
```
whereis nome...
```

D.3 Proprietà, permessi e attributi

I comandi utilizzati negli esempi di questa sezione sono descritti nel capitolo 59.

Cambia la proprietà dei file indicati, in modo che appartengano all'utente specificato.
```
chown utente file...
```
Cambia la proprietà della directory indicata e dei suoi file, comprese le sottodirectory, in modo che appartengano all'utente indicato e al gruppo dello stesso utente.
```
chown -R utente. directory
```
Cambia la proprietà della directory indicata e dei suoi file, comprese le sottodirectory, in modo che appartengano al gruppo indicato, senza cambiare l'utente.
```
chgrp -R gruppo directory
```
Attribuisce i permessi in «esecuzione» a tutte le directory e ai file che ne hanno già almeno uno (per il proprietario, o il gruppo o gli altri), per tutti i tipi di utenti, a partire dalla directory indicata.
```
chmod -R a+X directory
```
Attiva il bit SGID per le sole directory a partire da quella di partenza indicata (si suppone di utilizzare la shell Bash).
```
find directory -type d -exec chmod g+s \{\} \;
```
Definisce la modalità, in sola lettura, per tutti i file normali, a partire dalla directory indicata (si suppone di utilizzare la shell Bash).
```
find directory -type f -exec chmod 0444 \{\} \;
```

D.4 Copia, collegamento, spostamento, cancellazione e archiviazione

I comandi utilizzati negli esempi di questa sezione sono descritti nel capitolo 60.

Copia i file o le directory di origine, in modo ricorsivo, riproducendo il più possibile le caratteristiche originali. In particolare, i collegamenti simbolici vengono mantenuti come tali.
```
cp -dpR origine... directory_di_destinazione
```
Copia le directory di origine, ed eventuali discendenti, mentre per i file vengono generati solo collegamenti fisici.
```
cp -dpRl origine... directory_di_destinazione
```

Elimina tutti i file core (solo i file normali).

find / -type f -name core -exec rm -i \{\} \;

Archivia una directory in un file, utilizzando tar senza compressione.
```
tar cf archivio_di_destinazione directory_di_origine
```
Archivia una directory in un file, utilizzando tar e comprimendolo con gzip.
```
tar czf archivio_di_destinazione directory_di_origine
```
Archivia una directory in un file, utilizzando tar e comprimendolo al massimo con gzip.
```
tar cf - directory_di_origine | gzip -9 > archivio_di_destinazione
```
Archivia una directory in un file, utilizzando tar e comprimendolo al massimo con bzip2.
```
tar cf - directory_di_origine | bzip2 -9 > archivio_di_destinazione
```

Elenca il contenuto di un archivio tar.

tar tf archivio_di_origine ['modello_da_estrarre']...

Elenca il contenuto di un archivio tar, compresso con gzip.

tar tzf archivio_di_origine ['modello_da_estrarre']...

Elenca il contenuto di un archivio tar, compresso con gzip, utilizzando una pipeline.
```
gunzip < archivio_di_origine | tar tf - ['modello_da_estrarre']...
```

Elenca il contenuto di un archivio tar, compresso con bzip2.

bunzip2 < archivio_di_origine | tar tf - ['modello_da_estrarre']...

Estrae il contenuto di un archivio tar a partire dalla directory corrente, mantenendo il più possibile inalterati gli attributi originali dei file.
```
tar xpf archivio_di_origine ['modello_da_estrarre']...
```
Estrae il contenuto di un archivio tar, compresso con gzip, a partire dalla directory corrente, mantenendo il più possibile inalterati gli attributi originali dei file.
```
tar xpzf archivio_di_origine ['modello_da_estrarre']...
```
Estrae il contenuto di un archivio tar, compresso con gzip (utilizzando una pipeline), a partire dalla directory corrente, mantenendo il più possibile inalterati gli attributi originali dei file.
```
gunzip < archivio_di_origine | tar xpf - ['modello_da_estrarre']...
```
Estrae il contenuto di un archivio tar, compresso con bzip2, a partire dalla directory corrente, mantenendo il più possibile inalterati gli attributi originali dei file.
```
bunzip2 < archivio_di_origine | tar xpf - ['modello_da_estrarre']...
```
Archivia una directory, o un file, su una serie di dischetti formattati a 1 440 Kibyte, ma senza file system.
```
tar cf /dev/fd0 -L 1440 -M origine_da_archiviare
```
Elenca il contenuto di un archivio contenuto in una serie di dischetti da 1 440 Kibyte senza file system.
```
tar tf /dev/fd0 -L 1440 -M ['modello_da_estrarre']...
```
Estrae, nella directory corrente, il contenuto di un archivio contenuto in una serie di dischetti da 1 440 Kibyte senza file system.
```
tar xpf /dev/fd0 -L 1440 -M ['modello_da_estrarre']...
```

Suddivide un file in pezzetti da 100 Kibyte l'uno.

dd if=file_da_suddividere of=file_suddiviso_1 bs=100k count=1 skip=0

dd if=file_da_suddividere of=file_suddiviso_2 bs=100k count=1 skip=1

...

dd if=file_da_suddividere of=file_suddiviso_n bs=100k count=1 skip={n-1}

Ricomposizione di un file suddiviso in pezzetti.
```
cat file_suddiviso... > file_riaggregato
```

D.5 Orologio di sistema

I comandi utilizzati negli esempi di questa sezione sono descritti nel capitolo 34.

Imposta la data e l'ora di sistema (SS sta per secolo, mentre ss sta per secondi).
```
date MMGGhhmm[[SS]AA][.ss]
```
Imposta la data e l'ora di sistema al giorno 31/12/1998, alle ore 20:30.
```
date 123120301998
```
Imposta l'orologio hardware secondo il tempo universale, desumendolo da quanto riportato dall'orologio di sistema.
```
clock -w -u
```
Aggiorna l'orologio di sistema in base a quanto riportato dall'orologio hardware, puntato sul tempo universale, tenendo conto dell'errore sistematico annotato nel file /etc/adjtime.
```
clock -a -u
```

D.6 Masterizzazione di CD-ROM

I comandi utilizzati negli esempi di questa sezione sono descritti nel capitolo 55.

Crea un'immagine ISO 9660 in un file, a partire da una certa directory. Vengono usate le estensioni Rock Ridge, attraverso l'opzione -r, ma la proprietà e i permessi di file e directory vengono adattati nel modo generalmente più opportuno. Attraverso l'opzione -T si ottiene la creazione del file TRANS.TBL in ogni directory.
```
mkisofs -r -T -v -o file_immagine directory_origine
```
Come nel caso precedente, con l'aggiunta delle estensioni Joliet.
```
mkhybrid -r -T -J -v -o file_immagine directory_origine
```
Come nel caso precedente (senza estensioni Joliet), ma attraverso l'opzione -a non vengono esclusi i file il cui nome contiene i simboli ~ o #.
```
mkisofs -a -r -T -o file_immagine directory_origine...
```
Come nel caso precedente, con l'aggiunta delle estensioni Joliet.
```
mkhybrid -a -r -T -J -o file_immagine directory_origine...
```
Crea un'immagine ISO 9660 in un file, a partire dalla directory corrente (l'indicazione viene ottenuta attraverso quanto restituito dal comando pwd). Vengono usate le estensioni Rock Ridge, con l'opzione -r, in modo che la proprietà e i permessi di file e directory siano adattati nel modo generalmente più opportuno. Inoltre si utilizza il file images/boot.img per l'avvio del CD-ROM, e si crea il file boot/boot.cat per lo stesso motivo.
```
mkisofs -r -T -v -o file_immagine -b images/boot.img -c boot/boot.cat `pwd`
```

Come nel caso precedente, con l'aggiunta delle estensioni Joliet.

mkhybrid -r -T -J -v -o file_immagine -b images/boot.img -c boot/boot.cat `pwd`

Come nell'esempio precedente (senza estensioni Joliet), con la differenza che la directory corrente viene ottenuta dalla variabile di ambiente PWD.
```
mkisofs -r -T -v -o file_immagine -b images/boot.img -c boot/boot.cat $PWD
```
Crea un'immagine ISO 9660 in un file, a partire da una certa directory. Vengono usate le estensioni Rock Ridge, attraverso l'opzione -R, per mantenere le proprietà e i permessi di file e directory.
```
mkisofs -R -o file_immagine directory_origine...
```
Come nel caso precedente, con l'aggiunta delle estensioni Joliet.
```
mkhybrid -R -J -o file_immagine directory_origine...
```
Inizia la registrazione alla velocità stabilita del file indicato come argomento finale, nell'unità SCSI indicata dal numero di unità e dal numero LUN.
```
cdrecord -v speed=n_velocità dev=[n_scheda_controllo,]n_unità,n_lun -data file_immagine
```
Inizia la registrazione a una velocità quadrupla (x4) del file indicato, nell'unità SCSI numero tre, senza LUN.
```
cdrecord -v speed=4 dev=3,0 -data file_immagine
```
Esegue una copia identica di un CD-ROM (un CD contenente dati) corrispondente al dispositivo /dev/hdc. La registrazione avviene a una velocità quadrupla (x4), nell'unità SCSI numero tre senza LUN. L'opzione -isosize serve per evitare di leggere dal dispositivo /dev/hdc oltre la fine del file system.
```
cdrecord -v speed=4 dev=3,0 -isosize /dev/hdc
```

D.7 Ricerche

I comandi utilizzati negli esempi di questa sezione sono descritti nel capitolo 62.

Cerca i file che corrispondono al modello, a partire da una directory particolare.
```
find directory_di_partenza -name 'modello' -print
```
Cerca tutti i file core (solo i file normali).
```
find / -type f -name core -print
```

D.8 Comandi remoti

I comandi utilizzati negli esempi di questa sezione sono descritti nei capitoli 99 e 239.

Utilizza rsh, o un altra shell remota simile, per eseguire un comando in un elaboratore remoto, visualizzandone il risultato attraverso lo standard output e lo standard error dell'elaboratore locale.
```
rsh [-l nome_utenza_remoto] host comando
```
```
ssh [-l nome_utenza_remoto] host comando
```
```
lsh [-l nome_utenza_remoto] host comando
```

Utilizza rsh, o un altra shell remota simile, per eseguire un comando in un elaboratore remoto, utilizzando lo standard output per generare un file locale.

rsh [-l nome_utenza_remoto] host comando > file_locale

ssh [-l nome_utenza_remoto] host comando > file_locale

lsh [-l nome_utenza_remoto] host comando > file_locale

Utilizza rsh, o un altra shell remota simile, per eseguire l'archiviazione di una directory di un elaboratore remoto nell'elaboratore locale, utilizzando lo standard output come mezzo per trasferire l'archivio attraverso la rete.

Il file che si ottiene localmente potrebbe avere un'appendice aggiuntiva che non fa parte dell'archivio. In generale, questo può produrre delle segnalazioni di errore in fase di estrazione dei dati contenuti, ma niente che vada a intaccare la sostanza di quanto archiviato.

rsh [-l nome_utenza_remoto] host tar czf - origine_da_archiviare  > archivio_locale

ssh [-l nome_utenza_remoto] host tar czf - origine_da_archiviare  > archivio_locale

lsh [-l nome_utenza_remoto] host tar czf - origine_da_archiviare  > archivio_locale

Utilizza rsh, o un altra shell remota simile, per eseguire l'archiviazione di una directory di un elaboratore remoto nell'elaboratore locale, comprimendo l'archivio attraverso bzip2, utilizzando lo standard output come mezzo per trasferire l'archivio attraverso la rete, dopo che questo è stato compresso.

rsh [-l nome_utenza_remoto] host 'tar cf - origine_da_archiviare | bzip2' > archivio_locale

ssh [-l nome_utenza_remoto] host 'tar cf - origine_da_archiviare | bzip2' > archivio_locale

lsh [-l nome_utenza_remoto] host 'tar cf - origine_da_archiviare | bzip2' > archivio_locale

rsh [-l nome_utenza_remoto] host tar cf - origine_da_archiviare | bzip2 > archivio_locale

ssh [-l nome_utenza_remoto] host tar cf - origine_da_archiviare | bzip2 > archivio_locale

lsh [-l nome_utenza_remoto] host tar cf - origine_da_archiviare | bzip2 > archivio_locale

Trasferisce, in modo grossolano, una copia completa del file system di un elaboratore remoto, nell'elaboratore locale, inserendola a partire dalla directory corrente.
```
cd directory_di_destinazione ; rsh -l root host tar czf - / | tar xzpf -
```
```
cd directory_di_destinazione ; ssh -l root host tar czf - / | tar xzpf -
```

Trasferisce, in modo grossolano, una copia completa della prima partizione del primo disco IDE di un elaboratore remoto, nell'elaboratore locale, nella stessa partizione, supponendo che entrambe abbiano la stessa geometria (secondo la configurazione del firmware), e la stessa dimensione (in cilindri).

rsh -l root host 'cat /dev/hda1 | gzip -9' | gunzip > /dev/hda1

ssh -l root host 'cat /dev/hda1 | gzip -9' | gunzip > /dev/hda1

lsh -l root host 'cat /dev/hda1 | gzip -9' | gunzip > /dev/hda1

Bisogna fare molta attenzione a non sbagliare, se non si vogliono creare danni; in particolare bisogna assicurarsi di avere usato gli apostrofi nella posizione giusta (né prima né dopo). Si usi a proprio rischio!

Trasferisce, in modo ancora più grossolano, una copia completa della prima unità IDE di un elaboratore remoto, nell'elaboratore locale, che ha un disco con la stessa geometria (secondo la configurazione del firmware), e con un numero maggiore o uguale di cilindri.

rsh -l root host 'cat /dev/hda | gzip -9' | gunzip > /dev/hda

ssh -l root host 'cat /dev/hda | gzip -9' | gunzip > /dev/hda

lsh -l root host 'cat /dev/hda | gzip -9' | gunzip > /dev/hda

D.9 Copia remota e allineamento dati

I comandi utilizzati negli esempi di questa sezione sono descritti nei capitoli 99, 238, 239 e 210.

Nella copia tra elaboratori differenti si usa normalmente la notazione seguente per indicare un file o una directory. Se non viene specificato l'elaboratore di origine, si intende fare riferimento a quello locale.

[[utente@]host:]file

Copia tra elaboratori distinti, utilizzando rcp, specificando che la copia ottenuta deve essere il più possibile aderente all'originale, e deve comprendere anche le sottodirectory contenute nell'origine.
```
rcp -rp origine destinazione
```
Copia tra elaboratori distinti, utilizzando scp, specificando che la copia ottenuta deve essere il più possibile aderente all'originale, e deve comprendere anche le sottodirectory contenute nell'origine.
```
scp -rp origine destinazione
```
Allineamento tra elaboratori distinti, utilizzando rsync, specificando che la copia ottenuta deve essere il più possibile aderente all'originale, che deve comprendere anche le sottodirectory contenute nell'origine, e che il trasferimento deve essere fatto in modo compresso.

In particolare, se il percorso originale comprende la barra obliqua finale, significa che si copia e allinea il contenuto della directory, altrimenti si fa riferimento anche alla directory stessa.
```
rsync -a -zv origine[/] destinazione
```
Come nell'esempio precedente, ma si specifica l'utilizzo di ssh come shell per l'accesso remoto.
```
rsync -a -zv -e ssh origine[/] destinazione
```
Come nell'esempio precedente, ma si lascia che la proprietà e i permessi si adattino alle caratteristiche dell'utenza corrispondente nella destinazione.
```
rsync -rltD -zv -e ssh origine[/] destinazione
```
Allineamento tra elaboratori distinti, utilizzando rsync, specificando che la copia ottenuta deve essere il più possibile aderente all'originale, che deve comprendere anche le sottodirectory contenute nell'origine, e che il trasferimento deve essere fatto in modo compresso.

In particolare, si specifica che devono essere rimossi i file e le directory vuote che dovessero essere contenute della destinazione, mentre mancano nell'origine (si deve fare molta attenzione).
```
rsync -a -zv --delete origine[/] destinazione
```
Come nell'esempio precedente, ma elimina anche le directory non vuote che non risultano nell'origine (si deve fare ancora più attenzione).
```
rsync -a -zv --delete --force origine[/] destinazione
```

D.10 Amministrazione di un servizio FTP

Crea un file ls-lR.
```
ls -lR > ls-lR
```
Crea un file ls-lR.gz.
```
ls -lR | gzip -9 > ls-lR.gz
```
Si sposta nella directory iniziale dell'FTP anonimo e quindi crea il file ls-lR.gz.
```
cd ~ftp ; ls -lR | gzip -9 > ls-lR.gz
```