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


Capitolo 201.   Gestione dei file presi byte per byte

Alcuni programmi si occupano di elaborare i file a livello di byte. Per esempio, può trattarsi di trasformazioni di caratteri singoli o di spazi in caratteri di tabulazione e viceversa. Comunque, a questo livello, non è detto che debba sempre trattarsi di file di testo puri e semplici.

Tabella 201.1. Riepilogo dei programmi per la gestione dei file a livello di byte.

Programma Descrizione
tr Esegue alcune trasformazioni sui caratteri.
expand Trasforma i caratteri di tabulazione utilizzando il carattere spazio.
unexpand Sostituisce una serie di caratteri spazio con tabulazioni.
sum Calcola un codice di controllo (obsoleto)
cksum Calcola un codice di controllo.
md5sum Calcola un codice di controllo MD5 (una firma MD5).
sha1sum Calcola un codice di controllo SHA1 (una firma SHA1).
hexdump Mostra il contenuto di un file in esadecimale e in altri formati.
hexcat Mostra il contenuto di un file in esadecimale.

201.1   Conversione

Alcuni programmi consentono di convertire il contenuto di un file, operando a livello di byte. La situazione più comune riguarda l'espansione dei caratteri di tabulazione (ovvero la loro trasformazione in caratteri spazio normali, nella quantità necessaria a mantenere le distanze previste) e, nel senso opposto, la conversione inversa per ridurre la dimensione complessiva del file.

201.1.1   Utilizzo di «expand»

Il programma di servizio expand (1) emette attraverso lo standard output una trasformazione dei file forniti come argomento, in cui i simboli di tabulazione sono trasformati in spazi veri e propri. Se non viene specificato diversamente attraverso le opzioni, gli stop di tabulazione si intendono ogni otto caratteri.

expand [opzioni] [file...]

Tabella 201.2. Alcune opzioni.

Opzione Descrizione
-t tab1[,tab2]...
--tabs=tab1[,tab2]...
Permette di specificare una tabulazione diversa da quella predefinita (ogni otto colonne). Se viene specificato solo un numero, si intende una tabulazione ogni n colonne, altrimenti, si intende una sequenza di stop di tabulazione, in cui la prima colonna corrisponde al numero zero. Una volta esaurito l'elenco, gli stop di tabulazione successivi vengono sostituiti con uno spazio singolo.
-n
Questa è una variante dell'opzione -t, in cui si mette direttamente il numero corrispondente alla tabulazione che si vuole avere.
-i
--initial
Converte solo i caratteri di tabulazione iniziali, cioè quelli che precedono caratteri diversi da spazio, o che precedono altri caratteri di tabulazione.

I comandi mostrati sotto sono equivalenti: servono tutti a espandere i caratteri di tabulazione del file pippo.txt generando il file pippo1.txt, utilizzando intervalli di tabulazione ogni otto colonne. Il valore è stato specificato per completezza, dal momento che un intervallo di otto colonne è quello predefinito.

expand -8 pippo.txt > pippo1.txt[Invio]

expand -t 8 pippo.txt > pippo1.txt[Invio]

expand --tabs=8 pippo.txt > pippo1.txt[Invio]

201.1.2   Utilizzo di «unexpand»

Il programma di servizio unexpand (2) emette attraverso lo standard output una trasformazione dei file forniti come argomento, in cui gli spazi sono trasformati in caratteri di tabulazione per quanto possibile. Se non viene specificato diversamente attraverso le opzioni, gli stop di tabulazione si intendono ogni otto caratteri. Normalmente, il programma trasforma solo gli spazi iniziali.

unexpand [opzioni] [file...]

Tabella 201.3. Alcune opzioni.

Opzione Descrizione
-t tab1[,tab2]...
--tabs=tab1[,tab2]...
Permette di specificare una tabulazione diversa da quella predefinita (ogni otto colonne). Se viene specificato solo un numero, si intende una tabulazione ogni n colonne, altrimenti, si intende una sequenza di stop di tabulazione, in cui la prima colonna corrisponde al numero zero. Una volta esaurito l'elenco, non vengono fatte altre trasformazioni.
-a
--all
Non si limita a trasformare solo gli spazi iniziali.

201.2   Traslitterazione o cancellazione di caratteri

Esiste un programma di servizio che spesso passa inosservato, ma è molto importante nell'elaborazione di file a livello di byte singolo (o di carattere). Si tratta di tr,(3) il cui obiettivo fondamentale è quello di convertire un insieme di caratteri (o di simboli) in un altro insieme, ma consente anche l'eliminazione di alcuni caratteri oppure solo di quelli doppi. Dal momento che con tr è necessario distinguere tra situazioni differenti, è opportuno descrivere separatamente la sua sintassi. L'elenco di modelli sintattici che viene mostrato è semplificato rispetto alle possibilità effettive di tr; inoltre si deve considerare che l'input proviene dallo standard input e l'output viene emesso attraverso lo standard output.

Modello sintattico Descrizione
tr stringa1 stringa2
Questo rappresenta la situazione comune, in cui l'insieme di caratteri indicato nella prima stringa viene sostituito con l'insieme dei caratteri della seconda stringa.
tr -s stringa1
tr --squeeze-repeats stringa1
Con l'opzione -s (ovvero --squeeze-repeats), si intendono eliminare i doppioni, relativi ai caratteri indicati nella stringa.
tr -d [-c] stringa1
tr --delete [--complement] \
  \ stringa1
Con l'opzione -d (ovvero --delete), si intendono eliminare i caratteri indicati nella stringa. Se si usa anche l'opzione -c (--complement), i caratteri che vengono eliminati sono tutti esclusi quelli della stringa indicata.
tr -d -s stringa1 stringa2
tr --delete \
  \ --squeeze-repeats \
  \ stringa1 stringa2
Se alla cancellazione si aggiunge l'opzione di eliminazione dei doppioni, le cose vanno diversamente: prima vengono eliminati i caratteri corrispondenti a quelli della prima stringa; quindi vengono eliminati i doppioni dei caratteri appartenenti alla seconda stringa.

201.2.1   Rappresentazione dei caratteri in una stringa di «tr»

Le stringhe utilizzate come argomenti di tr vanno scritte secondo una sintassi particolare, che assomiglia vagamente alle espressioni regolari. In generale, ogni carattere (lettera, numero, simbolo) rappresenta esattamente se stesso, salvo le eccezioni che vengono descritte qui.

Sono ammissibili delle sequenze di escape formate da una barra obliqua inversa seguita da un carattere o da un numero che deve essere inteso in modo ottale. La tabella 201.5 elenca queste sequenze di escape (si veda anche la sezione 426.1).

Tabella 201.5. Sequenze di escape per le stringhe di tr.

Codice Descrizione
\a
<BEL>.
\b
<BS>.
\f
<FF>.
\n
<LF>.
\r
<CR>.
\t
<HT> (tabulazione normale).
\v
<VT>.
\nnn
Il carattere corrispondente al codice ottale indicato.
\\
Una barra obliqua inversa singola.

Possono essere indicati degli intervalli di caratteri, attraverso la notazione m-n. Il carattere iniziale, m, deve essere precedente a quello finale, in base alla sequenza stabilita dalla codifica a cui si fa riferimento. A titolo di esempio, l'intervallo 0-4, è equivalente alla sequenza di caratteri 01234.

È possibile indicare una serie di caratteri ripetuti, attraverso una notazione particolare: [x*n]. Qui le parentesi quadre fanno parte della notazione: x è il carattere da ripetere n volte. Se si omette il numero, si intende una quantità indefinitamente grande. È probabile che non sia conveniente l'uso di questa forma, anche per non complicare inutilmente l'interpretazione umana degli argomenti di tr; tuttavia è necessario conoscerne l'esistenza, per poter leggere gli script realizzati da altri.

Possono essere indicate delle classi di caratteri, in modo simile alle espressioni regolari: [:classe:]. Le classi utili nella traduzione da un insieme all'altro sono solo lower e upper, allo scopo di convertire le lettere minuscole in maiuscole, oppure per fare l'inverso. Tutte le altre classi possono servire solo per la cancellazione dei caratteri, dal momento che non si espandono in un modo ordinato e prevedibile.

In teoria, è ammissibile anche la notazione delle classi di equivalenza: [=x=], che però, allo stato attuale, nella realizzazione GNU di tr non serve a molto, dal momento che si traduce semplicemente nella stessa lettera indicata (x).

201.2.2   Traslitterazione

La traslitterazione è l'operazione più semplice da realizzare con tr; basta l'indicazione delle stringhe: quella di origine e quella di destinazione. Vengono mostrati alcuni esempi.

tr abc def < primo.txt > secondo.txt[Invio]

Questo esempio mostra la lettura del file primo.txt, che viene elaborato da tr in modo da trasformare ogni lettera «a» in «d», ogni lettera «b» in «e» e ogni lettera «c» in «f». Il risultato viene salvato nel file secondo.txt.

tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ \
  \< primo.txt > secondo.txt
[Invio]

tr a-z A-Z < primo.txt > secondo.txt[Invio]

tr '[:lower:]' '[:upper:]' < primo.txt > secondo.txt[Invio]

Questi tre esempi sono molto simili: quello che si vuole ottenere è la conversione delle lettere minuscole in maiuscole. Di sicuro, il modo più corretto per raggiungere questo risultato è quello di utilizzare l'ultima delle tre forme, dal momento che così si dovrebbe garantire la compatibilità con le proprie convenzioni locali, includendo correttamente anche le lettere accentate (che qui non sono state mostrate).

201.2.3   Cancellazione e compattamento

La cancellazione serve solo per eliminare dei caratteri, senza convertirli in qualche modo. Il comando seguente può essere utile per convertire un file di testo in cui il codice di interruzione di riga è in stile Dos, ovvero è composto dalla sequenza <CR><LF>.

tr -d '\r' < primo.txt > secondo.txt[Invio]

In questo modo si elimina solo il codice <CR>, rappresentato dalla sequenza di escape \r, ottenendo di lasciare solo i codici <LF>, adatti nella maggior parte dei sistemi Unix.(4)

tr -s '\n' < primo.txt > secondo.txt[Invio]

Con questo comando si vogliono eliminare le righe vuote multiple; tuttavia, non vengono eliminate le righe che sono semplicemente bianche, intese come quelle che contengono degli spazi.

tr -c -s '[a-zA-Z0-9]' '[ *]' < primo.txt > secondo.txt[Invio]

Questo esempio mostra l'uso dell'opzione di complemento (-c). In pratica, si vogliono identificare nella prima stringa tutti i caratteri che non siano alfanumerici (escludendo le lettere accentate), sostituendoli con un carattere spazio. Per indicare tanti caratteri spazio quanti sono necessari nella seconda stringa, si utilizza la notazione speciale [ *] che ripete lo spazio in modo indefinito. Infine, gli spazi multipli vengono semplicemente eliminati.

tr -c -s '[a-zA-Z0-9]' '[\n*]' < primo.txt > secondo.txt[Invio]

Il comando appena mostrato si comporta come nell'esempio precedente, solo che invece di usare lo spazio per sostituire ciò che non è un carattere alfanumerico, si utilizza il codice <LF>, corrispondente al codice di interruzione di riga. Lo scopo è quello di individuare tutte le parole del testo e di ottenerne l'elenco, dove ognuna occupa una riga separata.

tr -c -s '[:alnum:]' '[\n*]' < primo.txt > secondo.txt[Invio]

Questa variante precisa meglio l'intenzione di selezionare tutti i caratteri non alfanumerici, perché la stringa di cui si fa il complemento contiene l'indicazione della classe alnum, che comprende anche le lettere accentate della propria localizzazione.

201.3   Controlli sommari

Alcuni programmi si occupano di calcolare valori di vario genere in base al contenuto dell'input. Può trattarsi del conteggio di elementi determinati o del calcolo di codici di controllo (checksum).

201.3.1   Utilizzo di «sum»

Il programma di servizio sum (5) calcola un codice di controllo a 16 bit per ogni file fornito negli argomenti. Emette attraverso lo standard output il valore ottenuto insieme alla dimensione (arrotondata) in blocchi. Il valore predefinito della dimensione dei blocchi è di 1 024 byte.

sum [opzioni] [file...]

Questo programma viene considerato obsoleto e al suo posto si preferisce utilizzare cksum

Tabella 201.6. Alcune opzioni.

Opzione Descrizione
-r
Utilizza l'algoritmo predefinito (compatibile con BSD).
-s
--sysv
Utilizza l'algoritmo compatibile con System V. In tal caso, i blocchi hanno una dimensione di 512 byte.

201.3.2   Utilizzo di «cksum»

Il programma di servizio cksum (6) calcola un codice di controllo CRC (Cyclic redundancy check) per ogni file fornito negli argomenti:

cksum [opzioni] [file...]

Non utilizza opzioni, tranne quelle standard dei programmi GNU.

201.3.3   Utilizzo di «md5sum»

Il programma di servizio md5sum (7) calcola un codice di controllo MD5 (Message digest) a 128 bit per ogni file fornito negli argomenti, oppure verifica la corrispondenza di una serie di codici di controllo accumulati precedentemente in un file, con i file relativi:

md5sum [opzioni] [file...]

In condizioni normali, md5sum emette una serie di righe nella forma:

firma  file

Per esempio, una cosa del genere:

fdbf0c571fb4942a6c505d732e163876  a2ps.1.gz
f2c766c141c6e5bb55c8edf6ce4ecba6  ab.1.gz
00169ba95302aca74597f000b61c3255  access.1.gz
69cf0ef0436aff6830a8a8a11b53b27b  addftinfo.1.gz

Questa informazione può essere conservata per verificare in seguito se gli stessi file corrispondono sempre agli originali, oppure se sono stati danneggiati o manomessi. La verifica può essere manuale (visiva), oppure può essere lo stesso md5sum a verificarla, utilizzando per questo l'opzione -c.

Tabella 201.8. Alcune opzioni.

Opzione Descrizione
-c file
Utilizzando questa opzione, negli argomenti di md5sum si può indicare solo un file, che deve consistere nell'elenco di firme abbinate ai file corrispondenti: vengono ricalcolate le firme di questi file e viene verificata la corrispondenza con le firme già annotate. In caso di differenza, viene emessa una segnalazione di errore.
-v
Genera maggiori informazioni.

Segue la descrizione di alcuni esempi.

201.3.4   Utilizzo di «sha1sum»

Il programma di servizio sha1sum (8) calcola un codice di controllo SHA1 a 160 bit per ogni file fornito negli argomenti, oppure verifica la corrispondenza di una serie di codici di controllo accumulati precedentemente in un file, con i file relativi:

sha1sum [opzioni] [file...]
sha1sum [opzioni] -c file

In condizioni normali il programma serve a calcolare codice di controllo dei file indicati alla fine della riga di comando, generando un risultato simile a quello dell'esempio seguente:

sha1sum /bin/*sh[Invio]

13c36c7b1327b2bf4bc692e27e55125f6335ea82  /bin/ash
f4e6f05cafcffa4c43218f5b8c9e55a056cea459  /bin/bash
13c36c7b1327b2bf4bc692e27e55125f6335ea82  /bin/dash
20e6f3f8e2705e281be4892498550fd4a8c7c3e0  /bin/fdflush
f4e6f05cafcffa4c43218f5b8c9e55a056cea459  /bin/rbash
f4e6f05cafcffa4c43218f5b8c9e55a056cea459  /bin/sh

Questa informazione può essere conservata per verificare in seguito se gli stessi file corrispondono sempre agli originali, oppure se sono stati danneggiati o manomessi. La verifica può essere manuale (visiva), oppure può essere lo stesso programma a farla, utilizzando per questo l'opzione -c, ma in tal caso si fornisce un solo file, che corrisponde a quello contenente l'elenco accumulato in precedenza. Nell'esempio seguente si suppone di avere salvato il controllo precedente nel file elenco.sha1sum:

sha1sum -c elenco.sha1sum[Invio]

/bin/ash: OK
/bin/bash: OK
/bin/dash: OK
/bin/fdflush: OK
/bin/rbash: OK
/bin/sh: OK

Tabella 201.11. Alcune opzioni.

Opzione Descrizione
-c file
--check file
Si richiede di eseguire la verifica dei codice di controllo in base all'elenco di firme SHA1 accumulate in precedenza nel file.
-w
--warn
Mostra informazioni diagnostiche nel caso il file da usare per il confronto contenga delle righe imperfette.

201.4   Lettura di file binari

Per poter leggere il contenuto di file che non sono soltanto file di testo, diventa necessario trasformare alcuni o tutti i byte in qualcosa di leggibile, come può essere in esadecimale o in ottale.

201.4.1   Utilizzo di «hexdump» o di «hd»

Il programma di servizio hexdump, o hd, (9) consente di visualizzare il contenuto di un file binario attraverso una qualche forma di trasformazione utile per la lettura umana:

hexdump [opzioni] [file...]
hd [opzioni] [file...]

I due modelli sintattici mostrano l'uso di questo programma attraverso nomi diversi; in particolare, l'uso del nome hd implica automaticamente la presenza dell'opzione -C. Se si omette l'indicazione dei file nella riga di comando, il programma utilizza per questo lo standard input.

Tabella 201.12. Alcune opzioni.

Opzione Significato mnemonico Descrizione
-b
byte Mostra una traduzione del contenuto del file in ottale, separando i codici in ottale, byte per byte. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C.
-c
character Mostra una traduzione del contenuto del file in modo normale, quando possibile, altrimenti usa la notazione ottale. I byte vengono separati uno a uno. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C.
-C
canonical Mostra il risultato in forma «canonica», pari all'uso del comando con il nome hd.
-d
decimal Mostra una traduzione del contenuto del file in forma decimale, dove ogni valore corrisponde a una coppia di byte. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C.
-o
octal Mostra una traduzione del contenuto del file in forma ottale, a coppie di byte. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C.
-x
exadecimal Mostra una traduzione del contenuto del file in forma esadecimale, a coppie di byte. Non conviene usare questa opzione con hd, ovvero in abbinamento con -C.
-l n
length Legge solo i primi n byte.
-s n
skip Salta i primi n byte a partire dall'inizio del file.

Vengono mostrati alcuni esempi, senza spiegazione, che prendono in considerazione lo stesso file di partenza:

hexdump /bin/arch[Invio]

0000000 457f 464c 0101 0001 0000 0000 0000 0000
0000010 0002 0003 0001 0000 8300 0804 0034 0000
0000020 0710 0000 0000 0000 0034 0020 0007 0028
0000030 0018 0017 0006 0000 0034 0000 8034 0804
0000040 8034 0804 00e0 0000 00e0 0000 0005 0000
...
0000aa0 0004 0000 0000 0000 0001 0000 0003 0000
0000ab0 0000 0000 0000 0000 0658 0000 00b5 0000
0000ac0 0000 0000 0000 0000 0001 0000 0000 0000
0000ad0

hd /bin/arch[Invio]

00000000  7f 45 4c 46 01 01 01 00  00 00 00 00 00 00 00 00  |.ELF............|
00000010  02 00 03 00 01 00 00 00  00 83 04 08 34 00 00 00  |............4...|
00000020  10 07 00 00 00 00 00 00  34 00 20 00 07 00 28 00  |........4. ...(.|
00000030  18 00 17 00 06 00 00 00  34 00 00 00 34 80 04 08  |........4...4...|
00000040  34 80 04 08 e0 00 00 00  e0 00 00 00 05 00 00 00  |4...à...à.......|
...
00000aa0  04 00 00 00 00 00 00 00  01 00 00 00 03 00 00 00  |................|
00000ab0  00 00 00 00 00 00 00 00  58 06 00 00 b5 00 00 00  |........X...µ...|
00000ac0  00 00 00 00 00 00 00 00  01 00 00 00 00 00 00 00  |................|
00000ad0

hexdump -b /bin/arch[Invio]

0000000 177 105 114 106 001 001 001 000 000 000 000 000 000 000 000 000
0000010 002 000 003 000 001 000 000 000 000 203 004 010 064 000 000 000
0000020 020 007 000 000 000 000 000 000 064 000 040 000 007 000 050 000
0000030 030 000 027 000 006 000 000 000 064 000 000 000 064 200 004 010
0000040 064 200 004 010 340 000 000 000 340 000 000 000 005 000 000 000
...
0000aa0 004 000 000 000 000 000 000 000 001 000 000 000 003 000 000 000
0000ab0 000 000 000 000 000 000 000 000 130 006 000 000 265 000 000 000
0000ac0 000 000 000 000 000 000 000 000 001 000 000 000 000 000 000 000
0000ad0

hexdump -c /bin/arch[Invio]

0000000 177   E   L   F 001 001 001  \0  \0  \0  \0  \0  \0  \0  \0  \0
0000010 002  \0 003  \0 001  \0  \0  \0  \0 203 004  \b   4  \0  \0  \0
0000020 020  \a  \0  \0  \0  \0  \0  \0   4  \0      \0  \a  \0   (  \0
0000030 030  \0 027  \0 006  \0  \0  \0   4  \0  \0  \0   4 200 004  \b
0000040   4 200 004  \b   à  \0  \0  \0   à  \0  \0  \0 005  \0  \0  \0
...
0000aa0 004  \0  \0  \0  \0  \0  \0  \0 001  \0  \0  \0 003  \0  \0  \0
0000ab0  \0  \0  \0  \0  \0  \0  \0  \0   X 006  \0  \0   µ  \0  \0  \0
0000ac0  \0  \0  \0  \0  \0  \0  \0  \0 001  \0  \0  \0  \0  \0  \0  \0
0000ad0

hexdump -d /bin/arch[Invio]

0000000   17791   17996   00257   00001   00000   00000   00000   00000
0000010   00002   00003   00001   00000   33536   02052   00052   00000
0000020   01808   00000   00000   00000   00052   00032   00007   00040
0000030   00024   00023   00006   00000   00052   00000   32820   02052
0000040   32820   02052   00224   00000   00224   00000   00005   00000
...
0000aa0   00004   00000   00000   00000   00001   00000   00003   00000
0000ab0   00000   00000   00000   00000   01624   00000   00181   00000
0000ac0   00000   00000   00000   00000   00001   00000   00000   00000
0000ad0

hexdump -o /bin/arch[Invio]

0000000  042577  043114  000401  000001  000000  000000  000000  000000
0000010  000002  000003  000001  000000  101400  004004  000064  000000
0000020  003420  000000  000000  000000  000064  000040  000007  000050
0000030  000030  000027  000006  000000  000064  000000  100064  004004
0000040  100064  004004  000340  000000  000340  000000  000005  000000
...
0000aa0  000004  000000  000000  000000  000001  000000  000003  000000
0000ab0  000000  000000  000000  000000  003130  000000  000265  000000
0000ac0  000000  000000  000000  000000  000001  000000  000000  000000
0000ad0

hexdump -x /bin/arch[Invio]

0000000    457f    464c    0101    0001    0000    0000    0000    0000
0000010    0002    0003    0001    0000    8300    0804    0034    0000
0000020    0710    0000    0000    0000    0034    0020    0007    0028
0000030    0018    0017    0006    0000    0034    0000    8034    0804
0000040    8034    0804    00e0    0000    00e0    0000    0005    0000
...
0000aa0    0004    0000    0000    0000    0001    0000    0003    0000
0000ab0    0000    0000    0000    0000    0658    0000    00b5    0000
0000ac0    0000    0000    0000    0000    0001    0000    0000    0000
0000ad0

La pagina di manuale hexdump(1) riporta anche altre opzioni che qui non sono state indicate; in particolare, è possibile programmare il risultato dell'elaborazione attraverso le opzioni -e e -f.

201.4.2   Utilizzo di «hexcat»

Il programma di servizio hexcat, (10) consente di visualizzare il contenuto di uno o più file in forma esadecimale. Non prevede alcuna opzione:

hexcat [file...]

L'esempio seguente mostra il funzionamento di hexcat:

hexcat /bin/true[Invio]

00000000 - 7f 45 4c 46  01 01 01 00  00 00 00 00  00 00 00 00  .ELF............
00000010 - 02 00 03 00  01 00 00 00  60 89 04 08  34 00 00 00  ........`...4...
00000020 - b8 29 00 00  00 00 00 00  34 00 20 00  07 00 28 00  ¸)......4. ...(.
00000030 - 18 00 17 00  06 00 00 00  34 00 00 00  34 80 04 08  ........4...4...
00000040 - 34 80 04 08  e0 00 00 00  e0 00 00 00  05 00 00 00  4...............
00000050 - 04 00 00 00  03 00 00 00  14 01 00 00  14 81 04 08  ................
00000060 - 14 81 04 08  13 00 00 00  13 00 00 00  04 00 00 00  ................
00000070 - 01 00 00 00  01 00 00 00  00 00 00 00  00 80 04 08  ................
...
...
00002d40 - 00 00 00 00  00 00 00 00  20 00 00 00  00 00 00 00  ........ .......
00002d50 - 01 00 00 00  03 00 00 00  00 00 00 00  00 00 00 00  ................
00002d60 - 00 29 00 00  b5 00 00 00  00 00 00 00  00 00 00 00  .)..µ...........
00002d70 - 01 00 00 00  00 00 00 00                            ........

1) GNU core utilities   GNU GPL

2) GNU core utilities   GNU GPL

3) GNU core utilities   GNU GPL

4) Purtroppo non si può ottenere il contrario con tr.

5) GNU core utilities   GNU GPL

6) GNU core utilities   GNU GPL

7) GNU core utilities   GNU GPL

8) GNU core utilities   GNU GPL

9) BSD utils   UCB BSD

10) hexcat   software libero con licenza speciale


Appunti di informatica libera 2008 --- Copyright © 2000-2008 Daniele Giacomini -- <appunti2 (ad) gmail·com>


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

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home]

Valid ISO-HTML!

CSS validator!

Gjlg Metamotore e Web Directory