cp

Il comando cp copia uno o più file. Il comando cp non ha funzionalità di rete. Per copiare file e directory da un computer all'altro, usare scp ( secure copy ).

	cp [options] file1 file2
	cp prog.c prog.c.bak

In questo esempio, il file prog.c viene copiato nel file prog.c.bak. Se prog.c.bak già esiste, verrà sovrascritto. In caso contrario, verrà creato. Il file di destinazione mantiene modo, proprietario e gruppo del file sorgente.

	cp [options] file1 file2 file3 ... directory
	cp prog.c /home/source/c

In questo esempio, il file prog.c viene copiato nel file prog.c, nella directory /home/source/c. Il comando cp lavora silenziosamente, senza stampare alcun messaggio, in onore alla tradizione Unix, secondo la quale: "no news is good news" ( nessuna notizia è una buona notizia ). E' possibile chiedere a cp di essere un pochino più verboso:

	cp -v prog.c prog.c.bak
	cp --verbose prog.c prog.c.bak

In questo modo, cp ci terrà informati su cosa sta avvenendo.

	cp /home/janet/* /home/nick/

In questo esempio, tutti i file ( * ) della cartella /home/janet/ vengono copiati nella cartella /home/nick/. Mentre, in questo secondo caso:

	cp /home/janet/*.htm /home/nick/

saranno tutti i file con suffisso .htm ad essere copiati. Per copiare, in modo recursivo ( con tutte le sottodirectory ), una directory:

	cp ­-r directory_sorgente directory_destinazione
	cp ­-R directory_sorgente directory_destinazione
	cp ­--recursive directory_sorgente directory_destinazione

Per copiare uno o più file, preservandone gli attributi ( permessi, proprietà, date di creazione, di modifica, etc. ), utilizzare l'opzione:

	-p
	--preserve[=ATTR_LIST]

	  [=ATTR_LIST]
	  mode
	  ownership
	  timestamps
	  context
	  links
	  xattr
	  all

  cp -p /home/janet/*.htm /home/nick/
  cp --preserve=mode,ownership /home/janet/*.htm /home/nick/

Per copiare uno o più file, non preservandone gli attributi ( permessi, proprietà, date di creazione, di modifica, etc. ), utilizzare l'opzione:

	--no-preserve=ATTR_LIST

	  =ATTR_LIST
	  mode
	  ownership
	  timestamps
	  context
	  links
	  xattr
	  all

  cp --no-preserve=mode,ownership /home/janet/*.htm /home/nick/

Che fare se il file di destinazione già esiste?

	cp -i /home/janet/* /home/nick/
	cp --interactive /home/janet/* /home/nick/

L'opzione -i dice a cp di chiederci se sovrascrivere o meno il file, mentre l'opzione -n:

	cp -n /home/janet/* /home/nick/
	cp --no-clobber /home/janet/* /home/nick/

dice a cp di non sovrascrivere un file esistente. E' possibile, anche, chiedere a cp di sovrascrivere il file esistente di destinazione, ma facendone una copia ( backup ):

	cp -b /home/janet/* /home/nick/
	cp --backup /home/janet/* /home/nick/

La copia di backup avrà lo stesso nome del file originale, con il suffisso ~. Per esempio:

		mem.c
		mem.c~

Naturalmente, è possibile modificare il suffisso utilizzato, grazie all'opzione -S:

	cp -b -S .bck /home/janet/* /home/nick/
	cp --backup --suffix .bck /home/janet/* /home/nick/

In questo caso, la copia di backup avrà lo stesso nome del file originale, con il suffisso .bck:

		mem.c
		mem.c.bck

E' possibile, anche, creare una copia del file, solo quando il file originale è più recente del file di destinazione o questo è mancante:

	cp -u /home/janet/* /home/nick/
	cp --update /home/janet/* /home/nick/

Grazie a questo meccanismo, è possibile, quindi, implementare un backup incrementale:

	sudo cp -r -u -x -v / /media/MY_USB_DRIVE
	sudo cp -ruxv / /media/MY_USB_DRIVE

La sola opzione non ancora nota, in questa linea, è l'ozione -x ( --one-file-system ), che dice a cp di eseguire il comando solo sul filesystem corrente. Questa opzione diventa necessaria per evitare che cp entri in un loop infinito: infatti, senza l'opzione -x, cp eseguirebbe, su MY_USB_DRIVE, anche il backup di MY_USB_DRIVE, dove ha appena salvato il backup del disco fisso ( / ). Un backup del backup! Tenendo bene a mente la possibilità di cadere in questa trappola, è possibile effettuare un backup di intere directory anche con l'opzione -a:

	sudo cp –a dir_A dir_B
	sudo cp --archive dir_A dir_B

L'opzione -a è la somma di più opzioni. Il comando appena visto corrisponde, infatti, al seguente comando:

	sudo cp -dR --preserve=all dir_A dir_B

dove, a parte l'opzione -R ( Recursive ), che già conosciamo, troviamo le opzioni:

	-d

che rappresenta due altre opzioni:

	-P
	--no-dereference

	--preserve=links

e l'opzione:

	--preserve=all

Quindi, l'opzione -a potrebbe essere scritta:

	sudo cp -PR --preserve=all dir_A dir_B
	sudo cp --no-dereference ­--recursive --preserve=all dir_A dir_B

dove:

	-P
	--no-dereference

dice a cp di non seguire i link simbolici che trova in dir_A, mentre l'opzione:

	--preserve=all

dice a cp di conservare, anche nella directory di destinazione ( dir_B ) tutti gli attributi di ciascun file. Per chiudere, occorre ricordare che il comando cp può essere utilizzato per creare link ( simbolici o hard link ), al posto della copia del file:

	cp -s mio_file.txt mio_link.txt
	cp --symbolic-link mio_file.txt mio_link.txt

	cp -l mio_file.txt mio_link.txt
	cp --link mio_file.txt mio_link.txt

Attenzione: nel caso di un link simbolico, se si desidera creare un link esterno alla directory corrente, è necessario utilizzare i percorsi assoluti:

	cp -s /home/user/tt/rule /home/user/test/r_link

Questo perchè un link simbolico è un file a tutti gli effetti, con un numero di inode diverso dal file al quale punta, che contiene solo il percorso del file di destinazione. Nel nostro esempio, nella cartella /home/user/test, troveremo il link simbolico:

	r_link -> /home/user/tt/rule

scp

Il comando scp ( secure copy ) permette di copiare file tra computer remoti, via rete, utilizzando un protocollo chiamato, anch'esso, SCP.

	scp [[user@]host1:]file1 ... [[user@]host2:]file2

Per esempio, il comando:

	scp carlo@MyPC:~/.bash_aliases .bash_aliases

copia il file .bash_aliases, contenuto nella directory HOME ( ~ ) dell'utente carlo del computer MyPC, nel file .bash_aliases della directory corrente del PC su cui sto operando. Nel caso il trasferimento dovesse avvenire ad un computer remoto, in Internet, occorre indicare l'indirizzo web:

	scp -P 8080 giacomo@mysite.com:~/.bash_aliases .bash_aliases 

oppure, per il comando contrario:

	scp -P 8080 .bash_aliases giacomo@mysite.com:~/.bash_aliases

Il protocollo scp si occupa esclusivamente del trasporto dei dati. Quindi, il comando scp utilizza ssh() per stabilire una connessione sicura al computer remoto, richiedendo, se previsto, la password di accesso. Una parte delle opzioni disponibili per scp vengono direttamente passate al programma ssh():

     -1 ( usa il protocollo scp1 )
     -2 ( usa il protocollo scp2 )
     -3 ( local host )

Con quest'ultima opzione, il trasferimento dei dati tra due computer remoti avverrà attraverso il computer locale e non direttamente.

     -4 ( usa IPv4 )
     -6 ( usa IPv6 )
     -B ( batch mode )

La modalità batch evita che venga richiesta la password o la passphrases.

     -C

Abilita la compressione dei dati ( trasmette l'opzione -C al comando ssh ).

     -c cipher

Seleziona l'algoritmo di cifratura da utilizzare con ssh().

     -F ssh_config

Specifica un file di configurazione ssh() alternativo.

     -o ssh_option

Specifica una opzione ssh(), nel formato usato in ssh_config(5).

     -i identity_file

Dice a ssh() da quale file estrarre la chiave privata.

     -l limit

Determina il limite di banda, espressa in Kbit per second.

     -r

Copia intere directory, in modo ricorsivo.

     -p

Preserva le date di ultima modifica e di accesso al file, oltre ai permessi, del file originale. Attenzione: a differenza del comando cp ( copy ), dove l'opzione -p preserva anche i dati del proprietario del file e del gruppo principale di appartenenza, con scp non c'è modo di preservare queste informazioni. Al file salvato, il sistema operativo di destinazione assegnerà, come proprietario, i dati del proprietario dell'account da voi utilizzato per l'accesso. Per preservare le informazioni utente e gruppo, dovrete utilizzare il comando:

     rsync

rsync

Il comando rsync è, davvero, uno strumento potente, versatile e veloce per copiare file, intere directory, partizioni o dischi, sia localmente ( sullo stesso computer ), sia via rete. È particolrmente indicato per effettuare backup, grazie al suo famosissimo algoritmo, noto come " delta-transfer algorithm ", con il quale rsync è in grado di rilevare le differenze tra il file sorgente ed il file di destinazione, se già esistente, trasferendo solo i byte non coincidenti, riducendo, così, anche il traffico dati, in caso di connessione via rete. Di default, rsync utilizza un algoritmo, denominato " quick check ", che verifica le dimensioni e la data di ultimo aggiornamento dei file da trasferire. Qualsiasi altra modifica, negli attributi dei file, viene applicata direttamente ai file di destinazione, dopo che il " quick check " ha stabilito che i dati, contenuti nel file, non debbano essere aggiornati. Vediamo la sintassi di base del comando. SRC indica Source ( file sorgente ), DEST indica Destinazione. Se utilizzato in locale:

  rsync [OPTION...] SRC ... [DEST]

Se utilizzato via rete, con un'applicazione di trasporto, quale SSH o RSH, per contattare una shell remota:

  rsync [OPTION...] [USER@]HOST:SRC ... [DEST]
  rsync [OPTION...] SRC ... [USER@]HOST:DEST

  rsync User1@MyPC:~/Documents/ Documents
  rsync Documents User1@YourPC:~/Documents/

Se utilizzato per connettersi ad un demone remoto rsync ( ad un computer remoto, in cui sia in esecuzione il demone rsync ), via TCP:

  rsync [OPTION...] [USER@]HOST::SRC ... [DEST]
  rsync [OPTION...] rsync://[USER@]HOST[:PORT]/SRC ... [DEST]
  rsync [OPTION...] SRC ... [USER@]HOST::DEST
  rsync [OPTION...] SRC... rsync://[USER@]HOST[:PORT]/DEST

Una shell remota viene presunta ogni qualvolta la sorgente o la destinazione contiene i due punti ( : ) come separatore, subito dopo il nome dell'Host ( computer ). Un demone rsync remoto, al contrario, viene presunto ogni qualvolta la sorgente o la destinazione contiene i doppi due punti ( :: ) come separatore, subito dopo il nome dell'Host ( computer ), oppure, quando viene specificata una URL del tipo:

  rsync://

Quando non viene specificata alcuna destinazione, il comando restituisce un output simile a quello restituito dal comando:

  ls -l

Il comando rsync può essere utilizzato come si usa il comando rcp o scp:

	rsync -t *.c foo:src/

Questo comando invia tutti i file che contengano il pattern *.c dalla directory corrente alla directory src del computer foo. Se il percorso ai file contenesse uno spazio, lo spazio andrebbe anticipato da un escape:

	rsync -t '/media/win\ 7/Doc/' foo:src/

L'opzione:

  -t
  --times

dice a rsync di trasferire anche le date di modifica dei file e di aggiornarle nel sistema remoto di destinazione. Questo ci permette di introdurre una particolare abilità del comando rsync: quella di poter preservare ( mantenere ), nella directory di destinazione, tutti gli attributi di un file, a richiesta. Il metodo più semplice, è quello di utilizzare l'opzione:

  -a
  --archive

che dice a rsync di trasferire i file, in modo ricorsivo ( entrando nelle directory e nelle sottodirectory ), preservandone tutti gli attributi di origine:

	rsync -a foo:/var/lib/mysql/ .

In questo esempio, stiamo salvando, nella directory corrente, tutti i file e le sottodirectory contenute nella directory:

  /var/lib/mysql/

del computer denominato:

  foo

I file e le directroy verranno trasferiti, accompagnati da tutti gli attributi, compresi i proprietari ed i gruppi di appartenenza, a loro assegnati nel computer di origine. Attenzione: questo significa che nel computer di destinazione dovranno esistere un utente ed un gruppo che possano accedere a ciascun file ad essi assegnato. Il comando precedente, grazie al quale stiamo effettuando un backup di un server MySQL, copiandolo su un computer differente, è equivalente al comando:

	rsync -rlptgoD foo:/var/lib/mysql/ .

dove:

  -r
  --recursive

chiede a rsync di copiare le sottodirectory, in modo ricorsivo;

  -l
  --links

chiede a rsync di ricreare, nella cartella di destinazione, i link simbolici, presenti nella cartella di origine;

  -p
  --perms

chiede a rsync di impostare, nella cartella di destinazione, gli stessi permessi, presenti nella cartella di origine;

  -g
  --group

chiede a rsync di impostare, per il file di destinazione, lo stesso gruppo associato al file di origine;

  -o
  --owner

chiede a rsync di impostare, per il file di destinazione, lo stesso utente ( proprietario ) associato al file di origine;

  -D
  --devices --specials

chiede a rsync di trasferire, nella cartella di destinazione, i file di periferica, a caratteri o a blocchi, in modo da riprodurre quella periferica. Affinchè le opzioni:

  -o
  --owner

  -g
  --group

  -D
  --devices --specials

abbiano effetto, è necessario che il comando rsync di destinazione venga eseguito come " root ". In caso contrario, il proprietario ed il gruppo o i gruppi saranno l'utente ed i gruppi invocati nel computer di destinazione, mentre l'opzione -D non avrà alcun effetto. Affinchè rsync riesca nel suo backup incrementale, è necessario che venga lanciato con una delle due opzioni che trasferiscono la data dell'ultimo aggiornamento:

  -a
  --archive

  -t
  --times

In caso contrario, al prossimo trasferimento dei dati, rsync aggiornerà tutti i file, come se fosse stata utilizzata l'opzione -I:

	rsync -I foo:/var/lib/mysql/ .
	rsync --ignore-times foo:/var/lib/mysql/ .

con la quale si chiede a rsync di non eseguire il " quick check ".

dd

Il comando dd ( data duplicator ) copia i file, convertendoli, se richiesto, da un formato all'altro.

	dd if=input_file of=output_file [opzioni]

	dd if=test.htm of=test2.htm

In questa forma semplice, il comando dd copia il file test.htm nel file test2.htm. Il comando dd opera su blocchi di file, normalmente composti da 512 byte. E' possibile anche specificare la dimensione dei blocchi ( di byte ) su cui lavorare: per questo motivo, il comando dd viene spesso utilizzato per lavorare con i dischi e le periferiche del sistema. Quando si opera sui dischi fissi, occorre fare estrema attenzione, nell'usare il comando dd, poichè dd è un comando potente e silenzioso e, negli anni, si è meritato il soprannome di Data Destroyer. Prima di eseguire qualsiasi trasferimento da un disco all'altro, cercate di familiarizzare con il comando, lavorando su file locali.

	sudo dd if=/dev/sda of=test.bin bs=4096 count=2

In questo caso, stiamo chiedendo al comando dd di estrarre blocchi da 4096 byte alla volta ( bs ), dal disco fisso sda, e di scriverne 2 soli blocchi ( count ) nel file test.bin. Con questa tecnica, è possibile salvare, in un file, uno più settori dei dischi. Per salvare, per esempio, il Master Boot Record ( il primo settore, di 512 byte, del primo disco fisso ):

	sudo dd if=/dev/sda of=test.bin bs=512 count=1

Per ripristinare il Master Boot Record:

	sudo dd if=test.bin of=/dev/sda

Per copiare un intero disco fisso in un altro disco fisso ( backup ):

	sudo dd if=/dev/sda of=/dev/sdb bs=4096

In questo esempio, stiamo duplicando il disco fisso "sda" sul secondo disco fisso ( operazione che richiede un account "root" ): "sdb", trasferendo i dati a blocchi di 4096 byte alla volta. In sostanza, stiamo creando un backup dell'intero disco "sda". 4096 è la dimensione dei blocchi di byte utilizzati dal filesystem. E' possibile, anche, selezionare i blocchi da copiare.

	sudo dd if=/dev/sda of=tt count=5 skip=1

In questo esempio, stiamo salvando, nel file tt, 5 blocchi ( di 512 byte ciascuno ), saltando ( skip ) il primo, del disco fisso sda. Quindi, il file tt conterrà i settori 2, 3, 4, 5 e 6 del disco. Infatti:

	skip=BLOCKS

trascura BLOCKS blocchi di dati ( a partire dall'inizio ), come definiti dall'opzione ibs, dell'input.

	ibs=BYTES

legge BYTES byte di input alla volta. Il valore di default è 512. Se vogliamo, per esempio, copiare tutta la prima traccia del disco fisso, eccetto il MBR:

	sudo dd if=/dev/sda skip=1 of=tt bs=512 count=62

che salva, nel file tt, i 62 settori che seguono il MBR ( una traccia contiene 63 settori ). Attenzione: per ripristinare questi 62 byte, se necessario, occorre ricordarsi di saltare il primo byte:

	sudo dd if=tt skip=1 of=/dev/sda bs=512 count=62

E' possibile impostare limitazioni simili anche all'output:

	obs=BYTES

scrive BYTES byte alla volta ( di default: 512 ).

	seek=BLOCKS

trascura BLOCKS blocchi di dati ( a partire dall'inizio ), come definiti dall'opzione obs, dell'output.