[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico] [volume] [parte]

Capitolo 126.   Archiviazione e compressione

L'archiviazione e la compressione sono le fasi attraverso le quali si realizzano delle copie di sicurezza, oppure si preparano i dati prima di una trasmissione. La tabella 126.1 elenca i programmi a cui si accenna in questo capitolo.

126.1   Archiviazione

L'archiviazione è quel procedimento con cui si impacchettano file o rami di directory in modo da facilitarne la conservazione all'interno di unità di memorizzazione senza file system. Per lo stesso motivo, l'archiviazione è il modo con cui si possono trasferire agevolmente i dati attraverso piattaforme differenti.

L'archiviazione pura e semplice non ottiene alcun risparmio nello spazio utilizzato dai dati. Per questo si utilizza la compressione che permette di ridurre questo utilizzo.

Questo argomento viene ripreso anche nel capitolo dedicato alle copie di sicurezza (625).

126.1.1   Utilizzo di Cpio

Il programma di servizio cpio ⁽¹⁾ copia file da e verso archivi cpio o tar:

cpio -o [opzioni] [< elenco_nomi] [> archivio]

cpio -i [opzioni] [modello] [< archivio]

cpio -p [opzioni] directory_di_destinazione [< elenco_nomi]

L'archivio può essere un file su disco, un nastro magnetico o il flusso di un condotto. Le tre sintassi indicate rappresentano le tre modalità operative del comando.

• copy-out (archiviazione)

  Dallo standard input viene letto un elenco di nomi di file (uno per riga) e l'archivio di questi file viene generato ed emesso attraverso lo standard output.

• copy-in (lettura di un archivio)

  Dallo standard input viene letto il contenuto di un archivio dal quale si possono estrarre i file in esso contenuti.

• copy-pass (copia)

  Dallo standard input viene letto un elenco di nomi di file (uno per riga) e questi file (con il loro contenuto) vengono copiati nella directory di destinazione.

Si può consultare il documento info cpio, oppure la pagina di manuale cpio(1) per maggiori dettagli sull'uso di questo programma.

-o

--create

-A

--append

-L

--dereference

-O nome_archivio

-i

--extract

-d

--make-directories

-E file

--pattern-file=file

-f

--nomatching

-I archivio

-t

--list

-p

--pass-through

-d

--make-directories

-l

--link

-L

--dereference

Segue la descrizione di alcuni esempi:

• $ cpio -o < elenco > /tmp/archivio.cpio[Invio]

  Archivia i file e le directory elencati nel file elenco generando il file /tmp/archivio.cpio.

• $ ls *.sgml | cpio -o > /tmp/archivio.cpio[Invio]

  Archivia i file e le directory corrispondenti al modello *.sgml generando il file /tmp/archivio.cpio.

• $ find lavoro -print | cpio -o > /tmp/archivio.cpio[Invio]

  Archivia la directory lavoro/ e tutto il suo contenuto, generando il file /tmp/archivio.cpio.

• $ cpio -i -t < /tmp/archivio.cpio[Invio]

  Elenca il contenuto dell'archivio /tmp/archivio.cpio.

• $ cpio -i < /tmp/archivio.cpio[Invio]

  estrae l'archivio /tmp/archivio.cpio a partire dalla directory corrente.

• $ cat elenco | cpio -pd /tmp/prova[Invio]

  Copia i file e le directory elencati nel file elenco, a partire dalla directory /tmp/prova/.

126.1.2   Utilizzo di Tar

Il programma di servizio tar ⁽²⁾ (Tape archive) è un programma di archiviazione nato originariamente per essere usato con i nastri:

tar opzione_di_funzionamento [opzioni] file...

Il primo argomento deve essere una delle opzioni che ne definisce il funzionamento. Alla fine della riga di comando vengono indicati i nomi dei file o delle directory da archiviare. Se non viene specificato diversamente con le opzioni, l'archivio viene emesso attraverso lo standard output.

Il tar tradizionale ammette l'uso di opzioni senza il trattino anteriore (-) consueto. Questa tradizione è stata mantenuta anche nel tar GNU a cui si vuole fare riferimento qui, ma tale forma deve essere usata consapevolmente e con prudenza. Negli esempi viene mostrato in che modo potrebbero essere usate tali opzioni senza trattino.

Per la descrizione completa di questo programma, conviene consultare il documento info tar, oppure la pagina di manuale tar(1).

A

-A

--catenate

--concatenate

c

-c

--create

d

-d

--diff

--compare

--delete

r

-r

--append

t

-t

--list

u

-u

--update

x

-x

--extract

--get

--atime-preserve

-f file

--file=file

-h

--dereference

-k

--keep-old-files

-l

--one-file-system

-L Kibyte

--tape-length=Kibyte

-m

--modification-time

-M

--multi-volume

-N data

--after-date=data

--newer data

-O

--to-stdout

-p

--same-permissions

--preserve-permissions

-P

--absolute-path

--remove-files

--same-owner

-v

--verbose

-W

--verify

-Z

--compress

--uncompress

-z

--gzip

--ungzip

-j

--bzip2

--use-compress-program prog

Segue la descrizione di alcuni esempi.

• # tar -c -f /dev/fd0 -L 1440 -M -v /usr[Invio]

  Archivia la directory /usr/ con tutto il suo contenuto, comprese le sottodirectory, utilizzando i dischetti (da 1 440 Kibyte).

  Con la copia multivolume, come in questo caso, non è possibile utilizzare la compressione automatica attraverso l'opzione -z o -Z.

• # tar cf /dev/fd0 -L 1440 -M -v /usr[Invio]

  Esattamente come nell'esempio precedente, con la differenza che le opzioni -c e -f sono indicate senza il trattino iniziale.

• # tar cvf /dev/fd0 -L 1440 -M /usr[Invio]

  Esattamente come nell'esempio precedente.

• # tar -cfv /dev/fd0 -L 1440 -M /usr[Invio]

  # tar cfv /dev/fd0 -L 1440 -M /usr[Invio]

  Questi due esempi sono identici ed errati ugualmente. Non è possibile accodare lettere di altre opzioni dopo la «f», dal momento che questa richiede un argomento.

  In molti documenti su tar si vedono esempi errati di questo tipo. Possono anche funzionare, ma sono errati concettualmente ed è molto probabile incontrare un programma tar che in tali situazioni faccia qualcosa di diverso da quello che ci si aspetterebbe.

• $ tar -t -f /dev/fd0 -L 1440 -M -v[Invio]

  Visualizza l'elenco del contenuto dell'archivio fatto su dischetti.

• $ tar -x -f /dev/fd0 -L 1440 -M -v -p --same-owner[Invio]

  Estrae il contenuto dell'archivio su dischetti a partire dalla posizione corrente.

  È probabile che l'opzione --same-owner sia già predefinita all'interno di tar, ma in generale vale la pena di ricordarsene. Tuttavia, in questi esempi, dal momento che si tratta di un utente comune (lo si vede dal dollaro che viene indicato come invito), non ha significato, dal momento che l'utente comune non ha la possibilità di assegnare a un altro la proprietà dei file che crea.

• $ tar xpvf /dev/fd0 -L 1440 -M --same-owner[Invio]

  Come nell'esempio precedente, aggregando alcune opzioni e togliendo il trattino iniziale di queste.

• $ tar -c -f /tmp/archivio.tgz -z -v /usr[Invio]

  Archivia il contenuto della directory /usr/ nel file /tmp/archivio.tgz dopo averlo compresso con gzip.

• $ tar czvf /tmp/archivio.tgz /usr[Invio]

  Come nell'esempio precedente.

126.2   Compressione

La compressione dei dati è una tecnica che consente di risparmiare senza perdere informazioni. L'operazione avviene di norma in modo sequenziale, per cui può essere gestita attraverso dei programmi filtro, che alle volte permettono di rendere trasparente l'operazione. Data la facilità con cui nei sistemi Unix si possono combinare assieme delle tecniche di questo genere, in tali ambienti si tende a preferire l'archiviazione seguita da una compressione complessiva.

126.2.1   Utilizzo di «gzip», «gunzip» e «zcat»

Il programma di servizio gzip ⁽³⁾ viene usato per comprimere o decomprimere ogni file indicato negli argomenti:

gzip [opzioni] [file...]

gunzip [opzioni] [file...]

zcat [opzioni] [file...]

Il programma gzip è in grado di comprimere solo file normali, in modo singolo: per ogni file ne viene generato un altro con l'estensione .gz o un'altra se specificato diversamente con le opzioni. Se non viene indicato alcun file o se si utilizza espressamente un trattino isolato (-), lo standard input viene compresso e il risultato viene emesso attraverso lo standard output.

Il nome gunzip è un collegamento a gzip. Se gzip viene avviato con il nome gunzip si comporta come se fosse stata utilizzata l'opzione -d.

Il nome zcat è un collegamento a gzip. Se gzip viene avviato con il nome zcat si comporta come se fossero state utilizzate simultaneamente le opzioni -d e -c. In alcuni sistemi, invece di zcat potrebbe essere presente il collegamento gzcat.

Si può consultare il documento info gzip, oppure la pagina di manuale gzip(1) per maggiori dettagli sull'uso di questo programma.

-c

--stdout

--to-stdout

-d

--decompress

--uncompress

-r

--recursive

-t

--test

-1

-2

-3

-4

-5

-6

-7

-8

-9

Segue la descrizione di alcuni esempi:

• $ gzip *.sgml[Invio]

  Comprime i file *.sgml, utilizzando un livello intermedio di compressione, sostituendo i file originali con quelli compressi: *.sgml.gz.

• $ gzip -d *.sgml.gz[Invio]

  Espande i file corrispondenti al modello *.sgml.gz, togliendo loro l'estensione .gz.

• $ cat pippo | gzip -9 > pippo.gz[Invio]

  Genera il file pippo.gz come risultato della compressione di pippo. In particolare, viene utilizzato il livello di compressione massima e il file originale non viene cancellato.

• $ cat pippo.gz | gzip -d > pippo[Invio]

  Fa l'opposto dell'esempio precedente: espande il file pippo.gz generando pippo, senza cancellare il file originale.

126.2.2   Utilizzo di «bzip2» e «bunzip2»

Il programma di servizio bzip2 ⁽⁴⁾ è un programma di compressione funzionalmente analogo a gzip, nel senso che viene creato un file compresso per ogni file indicato negli argomenti:

bzip2 [opzioni] [file...]

bunzip2 [opzioni] [file...]

Il programma bzip2, come gzip, è in grado di comprimere solo file normali, in modo singolo, dove per ogni file ne viene generato un altro con l'estensione .bz2. Se non viene indicato alcun file o se si utilizza espressamente un solo trattino isolato (-), lo standard input viene compresso e il risultato viene emesso attraverso lo standard output.

Il programma bzip2 utilizza un algoritmo di compressione differente, rispetto a gzip, con un carico di elaborazione maggiore, che diventa efficace solo in presenza di file di grandi dimensioni. In generale, per garantire la massima portabilità di un archivio compresso, conviene utilizzare gzip, salvo quando le dimensioni dell'archivio sono tali da rendere realmente conveniente l'utilizzo di bzip2.

La sintassi di bzip2 è molto simile a quella di gzip, anche se non è del tutto identica. Prima di decidere di utilizzare bzip2 per archiviare i propri dati, conviene leggere la documentazione originale: il documento info bzip2, oppure la pagina di manuale bzip2(1), in modo da poter valutare correttamente.

Il nome bunzip2 è un collegamento a bzip2, il quale, se avviato con questo nome, utilizza implicitamente l'opzione -d per decomprimere i file indicati alla fine della riga di comando.

-c

--stdout

-d

--decompress

-f

--compress

-t

--test

-1

-2

-3

-4

-5

-6

-7

-8

-9

126.2.3   Copie di sicurezza

Quello che segue è l'esempio di uno script molto semplice per l'archiviazione di una serie di file e directory attraverso la coppia tar e gzip.

#!/bin/sh
###
### salva DIRECTORY_DI_DESTINAZIONE  < ELENCO
###
### Archiviazione di tutti i file e directory indicati attraverso lo
### standard input, utilizzando <directory-di-destinazione> come luogo
### di destinazione degli archivi.
###
### Gli archivi vengono generati in formato .tgz, cioè tar+gzip.
###
##
## Variabili.
##
#
# L'elenco dei file e delle directory da archiviare proviene dallo
# standard input.
#
ELENCO_DA_ARCHIVIARE=`cat`
#
# Directory di destinazione.
#
DESTINAZIONE=$1
##
## Funzioni.
##
#
# Visualizza la sintassi corretta per l'utilizzo di questo script.
#
function sintassi () {
    echo ""
    echo "cat elenco | $0 <directory-di-destinazione>"
    echo ""
}
##
## Inizio.
##
#
# Verifica la quantità di argomenti.
#
if [ $# != 1 ]
then
    #
    # La quantità di argomenti è errata. Richiama la funzione
    # «sintassi» e termina l'esecuzione dello script restituendo
    # un valore corrispondente a «falso».
    #
    sintassi
    exit 1
fi
#
# Verifica se esiste la directory di destinazione.
#
if [ -e $DESTINAZIONE ]
then
    #
    # Qualcosa con quel nome esiste già.
    # Si deve verificare che si tratti di una directory.
    #
    if [ ! -d $DESTINAZIONE ]
    then
        #
        # Non si tratta di una directory.
        #
        echo "Non è possibile procedere con l'archiviazione"
        echo "perché $DESTINAZIONE esiste e non è una directory."
        #
        # Lo script termina restituendo un valore corrispondente
        # a «falso».
        #
        exit 1
    fi
else
    #
    # La directory non esiste.
    # Si tenta di crearla.
    #
    if ! mkdir $DESTINAZIONE
    then
        #
        # Non è stato possibile creare la directory
        #
        echo "Non è possibile creare la directory"
        echo "$DESTINAZIONE"
        #
        # Lo script termina restituendo un valore corrispondente
        # a «falso».
        #
        exit 1
    fi
fi
#
# Giunti a questo punto, dovrebbe esistere la directory
# di destinazione.
# Inizia il ciclo di archiviazione.
#
for DA_ARCHIVIARE in $ELENCO_DA_ARCHIVIARE
do
    #
    # Estrae il nome del file o della directory senza il suo
    # percorso.
    #
    BASE_NAME=`basename $DA_ARCHIVIARE`
    #
    # Comprime il file o il contenuto della directory ottenendo un
    # file compresso con lo stesso nome e l'aggiunta
    # dell'estensione «.tgz».
    # Si utilizza «tar» specificando in particolare l'opzione «z»
    # che permette di comprimere automaticamente l'archivio
    # attraverso «gzip»;
    #
    tar czvf $DESTINAZIONE/$BASE_NAME.tgz $DA_ARCHIVIARE
done
#
# L'operazione di archiviazione e' terminata.
#
echo "L'archiviazione e' terminata."
##
## Fine.
##

126.2.4   UPX

UPX, ovvero il programma di servizio upx, ⁽⁵⁾ consente di comprimere dei programmi eseguibili, in modo da poter poi essere avviati senza bisogno di procedere alla loro espansione. In pratica, si prende un programma, lo si comprime e, all'apparenza, questo continua a funzionare come prima.

Il programma UPX è realizzato per vari tipi eseguibili e il suo comportamento si adatta alle circostanze. In particolare, per quanto riguarda i sistemi GNU/Linux, l'avvio del programma compresso implica una fase di estrazione nella directory temporanea /tmp/ e l'avvio successivo di quanto estratto. Come conseguenza più importante si ha che il processo che viene messo in funzione ha un'apparenza diversa rispetto al solito. A titolo di esempio, si suppone di avere compresso il programma yes e di averlo avviato in questo modo:

$ yes ciao > /dev/null &[Invio]

Se si osserva con il programma ps, in certi casi potrebbe sembrare ancora tutto normale:

$ ps x[Invio]

  PID TTY      STAT   TIME COMMAND
...
 7513 tty5     R      0:41 yes ciao
 7529 tty5     R+     0:00 ps x

Ma in altri casi, il processo si mostra attraverso un numero:

$ ps[Invio]

  PID TTY          TIME CMD
 6173 tty5     00:00:00 sh
 7513 tty5     00:01:36 3
 7545 tty5     00:00:00 ps

$ pstree[Invio]

init-+-ahc_dv_0
    ...
     |-sh-+-3
     |    `-pstree
    ...

Segue la descrizione del modello sintattico per l'uso di upx:

upx [comando] [altre_opzioni] [file_eseguibile...]

Il modello sintattico indica la presenza di un'opzione iniziale, con lo scopo di dichiarare il tipo di azione da compiere (se viene omessa, si intende la volontà di comprimere i file), seguita eventualmente da altre opzioni, quindi dai file da comprimere. La tabella successiva riepiloga i comandi disponibili; si rammenti che si può usare una sola opzione di questo tipo, ovvero si può indicare un solo comando.

-1|2|3|4|5|6|7|8|9

--best

-d

-t

-l

Segue la descrizione di alcuni esempi.

• $ upx mio_programma[Invio]

  Comprime il file ./mio_programma:

  Ultimate Packer for eXecutables Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 UPX 1.25 Markus F.X.J. Oberhumer & Laszlo Molnar Jun 29th 2004 File size Ratio Format Name -------------------- ------ ----------- ----------- 12536 -> 7822 62.40% linux/386 mio_programma Packed 1 file.

• $ upx -d mio_programma[Invio]

  Estrae il file compresso in precedenza:

  Ultimate Packer for eXecutables Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 UPX 1.25 Markus F.X.J. Oberhumer & Laszlo Molnar Jun 29th 2004 File size Ratio Format Name -------------------- ------ ----------- ----------- 12536 <- 7822 62.40% linux/386 mio_programma Unpacked 1 file.

• $ upx --best mio_programma[Invio]

  Comprime il file ./mio_programma utilizzando il grado di compressione maggiore, anche se in tal caso non si ottengono miglioramenti:

  Ultimate Packer for eXecutables Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 UPX 1.25 Markus F.X.J. Oberhumer & Laszlo Molnar Jun 29th 2004 File size Ratio Format Name -------------------- ------ ----------- ----------- 12536 -> 7822 62.40% linux/386 mio_programma Packed 1 file.

126.2.5   Utilizzo di «unp» e di «ucat»

Unp ⁽⁶⁾ è un pacchetto composto di piccoli programmi frontali per facilitare l'estrazione di file compressi, senza dover ricordare comandi e sintassi differenti, che invece vengono avviati in modo trasparente e appropriato.

unp file... [-- opzioni_specifiche]

ucat file...

Il primo dei due modelli sintattici mostrati fa riferimento al programma unp, con il quale si estraggono i file indicati come argomento; eventualmente, preceduti da due trattini --, si possono aggiungere delle opzioni specifiche per il programma che si ritiene venga usato da unp per l'estrazione, ma ovviamente in questo modo perde di significato l'uso del programma frontale. Il secondo dei due modelli fa riferimento al programma ucat, da intendere come un programma che legge i file indicati, li estrae e li emette attraverso lo standard output. Segue la descrizione di alcuni esempi.

• $ unp mio.tar.gz[Invio]

  In questo caso, si presume che il file mio.tar.gz sia stato generato con la coppia «tar+gzip». Il programma lo fa estrarre, come se venisse usato il comando seguente:

  $ tar xzvf mio.tar.gz[Invio]

• $ unp mio.gz[Invio]

  In questo caso, si presume che il file mio.gz sia stato generato da Gzip. Il programma lo fa estrarre, come se venisse usato il comando seguente:

  $ gunzip < mio.gz > mio[Invio]

  In pratica, rispetto al comportamento comune di Gzip, il file originale rimane intatto e l'estrazione avviene nella directory corrente.

• $ ucat mio.bz2[Invio]

  Mostra il contenuto del file mio.bz2.

126.3   Altri programmi affini

• star(1) ⁽⁷⁾

  Si tratta di un programma Tar alternativo e compatibile con gli standard.

• arc(1) ⁽⁸⁾

  Si tratta di un programma di archiviazione e compressione, per gruppi di file, originario per sistemi CP/M e Dos.

• arj(1) ⁽⁹⁾

  Si tratta di un programma di archiviazione e compressione, per gruppi di file, originario per sistemi Dos. Si osservi che nelle sue versioni originali, questo programma non era software libero.

• zoo(1) ⁽¹⁰⁾

  Si tratta di un programma di archiviazione e compressione, per gruppi di file, sviluppato originariamente per sistemi Dos.

• zip(1), unzip(1) ⁽¹¹⁾

  Si tratta di un programma di archiviazione e compressione, per gruppi di file, sviluppato originariamente per i sistemi Dos.

• lzop(1) ⁽¹²⁾

  Si tratta di un programma di compressione, per file singoli, che funziona sostanzialmente come Gzip, ma con l'obiettivo di essere più veloce.

• PPMd(1) ⁽¹³⁾

  Si tratta di un programma di compressione, per file singoli, che funziona sostanzialmente come Gzip.

• dact(1) ⁽¹⁴⁾

  Si tratta di un programma di compressione, per file singoli, che funziona sostanzialmente come Gzip, utilizzando algoritmi di compressione differenti e selezionando di volta in volta quello che si dimostra più adatto.

• makeself(1) ⁽¹⁵⁾

  Si tratta di uno script, in grado di creare un altro script che incorpora un archivio compresso di dati. Tale script ottenuto, se avviato, provvede da solo a usare gli strumenti necessari a estrarre il contenuto incorporato.

  Si osservi che l'archivio ottenuto è sì autoestraente, ma per questo si avvale di programmi esterni, anche se comuni, pertanto non è autonomo.

Appunti di informatica libera 2006.07.01 --- Copyright © 2000-2006 Daniele Giacomini -- <daniele (ad) swlibero·org>

1) GNU cpio   GNU GPL

2) GNU tar   GNU GPL

3) Gzip   GNU GPL

4) Bzip2   software libero con licenza speciale

5) UPX   GNU GPL con eccezioni e precisazioni

6) Unp   GNU GPL

7) Star   GNU GPL

8) Arc   GNU GPL

9) Arj   GNU GPL

10) Zoo   dominio pubblico

11) InfoZip   software libero con licenza speciale

12) Lzop   GNU GPL

13) PPMd   software libero con licenza speciale

14) Dact   GNU GPL

15) Makeself   GNU GPL

Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome archiviazione_e_compressione.htm

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico]