L'essenziale
Per cominciare, quando sono in un posto nuovo, mi guardo intorno per capire dove sono. In un computer è il filesystem a dare forma all'ambiente, quindi eseguo:
pwd
Ho chiesto il nome della directory corrente o di lavoro. Il filesystem è una struttura ad albero che parte dalla radice (root directory, simbolo slash /) e si ramifica attraverso sottocartelle che contengono files. Il percorso (path) assoluto di un file è la sequenza di directoryes necessaria a raggiungere il files partendo dalla root directory. Invece un percorso relativo non inizia con la radice. Essere in una directory significa che quella diventa la cosiddetta directory corrente, ovvero il percorso che viene aggiunto automaticamente in testa ad ogni percorso relativo di files che si utilizza.
Appena entrato mi trovo nella home directory che, se sono l'amministratore, è /root, se sono l'utente salvatore, è /home/salvatore.
Ora, il comando ls mi informa sui files presenti in una directory. In particolare:
ls -al
mi dà una lista di tutti i files (opzione -a) compresi quelli nascosti (quelli il cui nome inizia con un punto) della directory corrente. L'opzione -l indica di fornire tutte le informazioni, non solo il nome. Con:
ls -al /
vedo il contenuto della directory radice. Possiamo spostarci tra le directory con il comando:
cd nomedir
Abbiamo guardato un po' in giro e abbiamo un'idea della struttura del filesystem. Ora guardiamo dentro i files. Per leggere un file di testo presente nella directory corrente:
less nomefile
Si può leggere il testo scorrendo avanti e indietro con i tasti su/giù. Se si vuole anche modificare il file, si può usare l'editor vi.
Ora spostiamoci nella home directory, se non ci siamo già. Per farlo non è necessario il percorso completo, il simbolo tilde (ALTGR+0 oppure ALT+126 dal tastierino numerico) sostituisce il percorso home:
cd ~
Ma sarebbe stato sufficiente anche solo:
cd
Creiamo una nuova directory, di nome tmp, che servirà a contenere i nostri files temporanei, ed entriamoci:
mkdir tmp
cd tmp
Per cancellare files e directories:
rm -rf nomefile
Questo comando è rischioso. L'opzione f forza la cancellazione immediata senza chiedere conferma. L'opzione r serve a cancellare anche le eventuali directories.
Se cerchiamo un file in particolare:
find nomedir -name nomefile
Questo comando mostrerà i percorsi di tutti i files di nome nomefile trovati sotto la directory nomedir
Se invece cerchiamo una particolare stringa all'interno di files:
grep stringa path
che restituisce i nomi di tutti i files che contengono stringa, trovati sotto il percorso path
Andiamo un po' più lontano: ci serve un file dalla partizione di Windows, che supponiamo si trovi nella terza partizione del primo disco IDE, /dev/hda3. Prima di tutto la montiamo:
mount -t vfat /dev/hda3 /mnt/mnt1
Ora vediamo i files di C: sotto la directory /mnt/mnt1. Copiamo i files che ci servono, ad esempio:
cp /mnt/mnt1/temp/* /home/tmp
Quando abbiamo finito di lavorare su quel filesystem, lo smontiamo per evitare perdite di dati:
umount /dev/hda3
Più avanti i dettagli sul montaggio e formattazione.
Per la copia di files sarà spesso necessario usare le opzioni -dpR (o l'equivalente -a), ad esempio:
cp -dpR /dir1/* /dir2
copia in /dir2 tutta la struttura di files e sottodirectories presente sotto /dir1, conservando la natura originale di ogni file, ad esempio un link viene copiato come link invece di copiarne il file puntato.
Ma cos'è un link? È un modo per raggiungere un file con un nome diverso. Supponiamo di avere il file /tmp/file1 contenente 10 kbytes. Spostiamoci in /tmp e creiamo due link simbolici a quel file:
cd /tmp
ln -s file1 file2
ln -s file1 file3
Ora nella directory corrente ci sono i tre files file1, file2, file3. Possiamo leggere il contenuto di file1 utilizzando uno qualsiasi dei tre nomi, perché è come se il file fosse stato copiato in due nuovi files. Ma in realtà vediamo che solo file1 occupa 10 kbytes, gli altri sono solo una specie di puntatori al file originale.
Per comprendere l'utilità di questo strumento, basta osservare i files che contengono il kernel nella directory /boot: potrebbero esserci più versioni del kernel, ad esempio, vmlinuz-2.4.14 e vmlinuz-2.4.16. Poi c'è il link vmlinuz che punta, ad esempio, al primo kernel (questo esempio è l'inverso di quello precedente, più files e un solo link). Poichè il sistema è configurato per avviare sempre il file vmlinuz, se si vuole cambiare kernel si deve solo cambiare il link per farlo puntare al nuovo kernel.
Tornando al comando cp, quando si copiano links, questi vengono sostituiti dai files originali corrispondenti (a meno che non si usino le opzioni viste) e non è detto che questo sia ciò che si voleva fare.
Tra le proprietà dei files, visualizzabili con il comando ls, ve ne sono alcune particolarmente importanti, i permessi. Ad ogni file di un filsystem unix sono associati tre permessi, lettura (r), scrittura (w), esecuzione (x), e tre classi di utenti, proprietario (u), gruppo (g), altri (o). Quando uno dei permessi è impostato per una delle classi di utenti, gli utenti che appartengono a quella classe possono eseguire quella operazione sul file.
Suppongo di essere root e di avere un file che mi appartiene, file1. Voglio dare questo file all'utente salvatore e permettergli di utilizzarlo. Sposto il file nella directory tmp di salvatore. Attualmente il file ha come proprietario root, quindi eseguo:
chown salvatore:g1 /home/salvatore/tmp/file1
Ho assegnato al file file1 il proprietario salvatore e il gruppo g1. Ora suppongo di essere l'utente salvatore. Posso fare ciò che voglio di file1 perché ne sono il proprietario. Se, ad esempio, file1 è uno script di shell, voglio che tutti possano eseguirlo e che nessuno possa modificarlo oltre a me:
chmod ugo+x file1
chmod go-w file1
Ora il file avrà i permessi rwxr-xr-x: la prima terna per il proprietario, la seconda per il gruppo, la terza per gli altri.
Notare che il permesso x rende effettivamente/apparentemente eseguibile un file. Se questo permesso non è impostato, il file non potrà essere eseguito anche se è un programma o uno script. Viceversa il sistema tenterà di eseguire ogni file con il permesso impostato. In realtà l'esecuzione è sempre decisa dal kernel in funzione del contenuto effettivo del file.
Spesso si avrà a che fare con archivi compressi che, sotto Linux, hanno il formato standard .tar.gz. Il file nome.tar.gz contiene una struttura di files che è stata prima archiviata con tar e poi compressa con gzip. Per estrarre i files mi sposto con l'archivio nella directory tmp ed eseguo:
tar xvzf nome.tar.gz
Per i dettagli vedere la sezione su archivi e compressione
Alcuni comandi interessanti:
uname -a
mi dà il nome del sistema operativo, della piattaforma, ecc.
In un sistema multiutente potrei essere interessato a sapere chi altro è entrato nel sistema, oltre a me:
w
mi dice chi altro sta lavorando sul sistema, su quale terminale e cosa sta facendo.
Vediamo cosa sta facendo il sistema. Il comando:
ps -ax
mi mostra una lista completa dei processi avviati e mi dice chi li ha avviati (nome utente) e dove (nome del terminale). Il primo numero a sinistra è il PID ed identifica univocamente il processo. Se voglio terminare un processo di cui ho perso il controllo, eseguo:
kill PID
dove PID è il numero corrispondente.
Se l'output di ps è troppo esteso, posso fare così:
ps -ax | less
ed utilizzare i tasti freccia per scorrere agevolmente il testo. Questa tecnica introduce un aspetto fondamentale della filosofia unix: non ci sono comandi che fanno tutto, ma ogni comando realizza solo una funzione molto semplice. I comandi si possono mettere insieme per realizzare operazioni più complesse. Con la tecnica vista, il pipeline, l'output del primo comando (ps) va nell'input del secondo (less) attraverso il simbolo di barra verticale o pipe. Con la cosiddetta ridirezione dell'input/output si può anche ridirigere l'output di un comando in un file o fornire un file come input a un comando. Ad esempio:
ls -al > temp.txt
crea il file temp.txt contenente il listato prodotto dal comando ls.
Infine, dove trovare informazioni e documentazione del sistema? Questo è un altro aspetto fondamentale di Linux: con un po' di pazienza si può esplorare il filesystem per scoprire la gran mole di informazioni contenuta nelle varie sottodirectories doc o negli script di configurazione. Comunque il riferimento principale è il manuale on-line, le cui pagine si leggono con il comando man nomepagina, ad esempio:
man ps
mostra la pagina di manuale relativa al comando ps.
L'editor VI
Anche se Emacs o strumenti più comodi con interfacce grafiche sono molto diffusi, VI (VIsual editor) è l'editor standard dei sistemi unix e conviene conoscerne i comandi essenziali.
Avviare l'editor con:
vi nomefile
All'inizio è attivo il modo comandi, lo schermo mostra il file nel cosiddetto buffer di editing e dopo la fine del file le righe sullo schermo iniziano con un carattere tilde (~). Nel modo comandi si possono digitare comandi di editing, ma non si può inserire testo nel file.
Per inserire del testo nel buffer, bisogna passare al modo inserimento: dal modo comandi digitare il comando i. Ora tutto ciò che si digita viene considerato come testo per il file. Per eseguire funzioni di editing si deve necessariamente tornare al modo comandi premendo Esc.
Alcuni comandi di editing:
- i avvia l'inserimento di testo alla sinistra del cursore
- x cancella il carattere corrente
- dd cancella la riga corrente
- r sostituisce il carattere corrente con quello digitato subito dopo
- R sovrascrive a partire dalla posizione corrente
- o aggiunge una riga sotto quella corrente
- O aggiunge una riga sopra quella corrente
Il taglia/copia/incolla è un po' macchinoso. Per comodità si può eseguire con il mouse, ma il supporto al mouse potrebbe non essere disponibile:
- Spostare il cursore all'inizio della porzione di testo da tagliare e, in modo comandi, eseguire ma. Questo fissa il marker 'a' in quel punto.
- Spostarsi alla fine del blocco di testo ed eseguire y'a per tagliare la porzione di testo compresa tra la posizione corrente e il marker 'a'.
- Spostare il cursore nella nuova posizione ed eseguire p per incollare il testo precedentemente tagliato, alla riga che segue il cursore.
Infine:
- ZZ per salvare il file ed uscire (due Z maiuscole)
- :w per salvare senza uscire (write)
- :w! per forzare la scrittura del file se è in sola lettura
- :q per uscire (quit)
- :q! per forzare l'uscita senza salvare le modifiche
L'immagine di un dischetto
Duplicare un dischetto o crearne un'immagine a scopo di archiviazione, sono solo due esempi di applicazione di uno dei comandi più flessibili di Linux. dd legge un flusso di dati da una sorgente e lo scrive in uscita con le modifiche eventualmente richieste. In questo esempio non servono modifiche. Il comando:
dd if=/dev/fd0 of=disk.img
legge il dischetto /dev/fd0 e ne crea un'immagine nel file disk.img ; l'immagine di un dischetto da 1.44MB sarà un file di 1474560 bytes.
Per scrivere il dischetto /dev/fd0 partendo dall'immagine nel file disk.img eseguire:
dd if=disk.img of=/dev/fd0
Il primo disk drive (A) è /dev/fd0, il secondo (B) è /dev/fd1.
ATTENZIONE a ciò che si scrive: il comando dd non ammette ripensamenti e un comando sbagliato può distruggere definitivamente i dati sbagliati.
Potrebbe risultare comodo creare uno script che semplifichi la duplicazione dei dischetti:
#!/bin/sh
echo ""
echo " *** diskcp ***"
echo " Duplica un dischetto nel primo drive"
echo ""
echo " Inserire il dischetto origine e premere INVIO"
echo " (sara' creata un'immagine temporanea nel file disk.img ,"
echo " per interrompere premere CTRL-C adesso)"
echo " ..."
read
dd if=/dev/fd0 of=disk.img
echo ""
echo " Inserire il dischetto destinazione..."
read
dd if=disk.img of=/dev/fd0
rm -f disk.img
Salvare questo script con il nome diskcp e renderlo eseguibile con il comando:
chmod +x diskcp
Formattare, montare ...
Tutto ciò che vediamo nella struttura delle cartelle fa parte di uno o più filesystems attualmente montati. Cosa significa? Eseguiamo:
mount
Se, ad esempio, vediamo che /dev/hda1 è montato sotto /, significa che la struttura di cartelle che vediamo quando andiamo in / appartiene al filesystem contenuto nel dispositivo /dev/hda1, che è la prima partizione del primo disco IDE (ATA). In fase di avvio, questo filesystem è stato montato, ovvero è stato associato alla struttura corrente, per renderne utilizzabili i suoi files.
La struttura di files corrente, visibile al sistema è una sola, inizia da / e non si usano nomi di dispositivi/partizioni (come C: o /dev/hda3) per accedere ai files. Ad esempio, se voglio accedere ai files della partizione di Windows, la devo prima montare:
mount -t vfat /dev/hda3 /mnt/mnt1
L'ho montata sotto /mnt/mnt1. Quindi se voglio accedere ad un files che in Windows era C:\nomefile, devo usare il percorso /mnt/mnt1/nomefile.
Analogamente, se voglio vedere il CDROM (porta IDE master secondaria) sotto /mnt/cdrom e il dischetto sotto /mnt/floppy, eseguo:
mount -t iso9660 /dev/hdc /mnt/cdrom
mount -t msdos /dev/fd0 /mnt/floppy
Si deve smontare un filesystem quando non serve più o comunque quando si esce dal sistema:
umount /dev/hda3
Questo è importante perché tutte le operazioni di scrittura sul filesystem, sono differite nel tempo per questioni di efficienza. Smontare forza l'esecuzione di tutte le operazioni lasciate in sospeso. Se si chiude il sistema senza smontare un filesystem attualmente montato, si va incontro a possibili perdite di dati. Per questo, al riavvio dopo una chiusura scorretta, il sistema forza il controllo del root filesystem.
La preparazione di un dischetto all'uso può chiarire definitivamente questi concetti.
Formattare il dischetto in /dev/fd0:
fdformat /dev/fd0
ora un dischetto da 1.44MB contiene esattamente 1474560 bytes, ma nesun filesystem: è completamente vuoto. Prima di essere formattato un dischetto è meno che vuoto, è inutilizzabile (ma ormai non si vendono più dischetti non formattati). Il dischetto formattato può già essere utilizzato, ma non per copiarvi files nel modo tradizionale.
Creare il filesystem sul dischetto:
mke2fs /dev/fd0
ora il dischetto può essere utilizzato per contenere files nel modo tradizionale, dopo averne montato il filesystem. Contiene sempre 1474560 bytes, ma lo spazio disponibile a livello di files è leggermente minore a causa della presenza del filesystem.
Il comando:
mount -t ext2 /dev/fd0 /mnt/mnt1
monta il filesystem del dischetto sotto la directory /mnt/mnt1; ora tutto ciò che si scrive/legge in quella directory verrà in realtà scritto/letto nella directory radice del dischetto.
Prima di estrarre il dischetto è necessario smontare il suo filesystem:
umount /dev/fd0
Ripulire un hard disk
Rendere un hard disk come nuovo cancellandone tutto il contenuto, partizioni, tabelle delle partizioni, mbr, e qualunque cosa ci sia sopra: per farlo non è sufficiente la formattazione che cancella solo i riferimenti ai dati e non i dati stessi. Bisogna operare ad un livello inferiore a quello del filesystem e questo si può fare con il comando dd:
dd if=/dev/zero of=/dev/hdb bs=512
questo sovrascrive l'intero disco /dev/hdb.
ATTENZIONE a ciò che si scrive: il comando dd non ammette ripensamenti e un comando sbagliato può distruggere definitivamente i dati sbagliati. Il punto critico del comando è il parametro of= (che sta per output file =) che indica il dispositivo di destinazione su cui scrivere.
Il disco master sulla porta ATA primaria è /dev/hda; lo slave è /dev/hdb; sulla porta secondaria /dev/hdc e /dev/hdd sono rispettivamente master e slave. I dischi SCSI sono /dev/sda, /dev/sdb, ecc.
Backup, archivi e compressione
Il comando tar (Tape ARchiver) serve ad archiviare un insieme di files inserendoli in un unico file detto appunto archivio in formato .tar, o tarball (palla di catrame). La semplice archiviazione non comprime i dati. Per la compressione si usa gzip che comprime un singolo file. Tar può chiamare automaticamente gzip se si desidera.
Per creare un archivio compresso di nome archivio.tar.gz contenente tutti i files della directory corrente, comprese le sottocartelle:
tar cvzf archivio.tar.gz *
Per elencare il contenuto dell'archivio compresso:
tar tvzf archivio.tar.gz
Per estrarre i files dall'archivio compresso nella directory corrente:
tar xvzf archivio.tar.gz
Se si vuole mettere l'archivio su dischetto, ma è troppo grande, si può creare un archivio multi-volume distribuito su più dischetti:
tar cvMf /dev/fd0 *
questo crea un archivio multi-volume con tutti i file della directory corrente e lo scrive direttamente su dischetti in /dev/fd0. I dischetti devono essere formattati ma non è necessario che contengano un filesystem. Infatti non stiamo creando un file ma stiamo scrivendo direttamente su disco il risultato di tar.
Per estrarre i files di un archivio multi-volume dai dischetti /dev/fd0 e metterli nella directory corrente:
tar xvMf /dev/fd0
Purtroppo un multi-volume tar non può utilizzare l'opzione z per la compressione. Una soluzione potrebbe essere quella di creare prima un archivio compresso in un file .tar.gz e poi riarchiviare questo file con il metodo multi-volume. Oppure usare dd per spezzare il .tar.gz in più parti e scriverle su dischetti.
Gli script seguenti implementano la prima soluzione. Il primo, zipin, crea l'archivio:
#!/bin/sh
echo ""
echo "*** zipin ***"
echo "Archivia files e sottodirectories della directory corrente, su dischetti."
echo ""
echo "Inserire il (primo) dischetto e premere INVIO"
echo "(sara' creato il file temporaneo /tmp/ziptmp.tar.gz ,"
echo "per interrompere premere CTRL-C adesso)"
echo "..."
read
tar cvzf /tmp/ziptmp.tar.gz *
echo ""
tar cvMf /dev/fd0 -C /tmp ziptmp.tar.gz
rm -f /tmp/ziptmp.tar.gz
Il secondo script, zipout, estrae i files:
#!/bin/sh
echo ""
echo "*** zipout ***"
echo "Estrae i files da un archivio multi-volume."
echo ""
echo "Inserire il (primo) dischetto e premere INVIO"
echo "(sara' creato il file temporaneo /tmp/ziptmp.tar.gz ,"
echo "per interrompere premere CTRL-C adesso)"
echo "..."
read
tar xvMf /dev/fd0 -C /tmp
tar xvzf /tmp/ziptmp.tar.gz
rm -f /tmp/ziptmp.tar.gz
Benchè il formato standard di archiviazione e compressione sotto Linux sia quello di Tar e Gzip, è possibile gestire archivi compressi nel formato .zip, più portabile tra i sistemi PC.
Per creare un archivio compresso di nome archivio.zip contenente tutti i files della directory corrente, comprese le sottodirectories:
zip -r archivio.zip *
Per estrarre i files dall'archivio compresso nella directory corrente:
unzip archivio.zip
Gestione dei pacchetti con RPM
Red Hat Package Manager traccia ogni pacchetto software e ogni singolo file installato nel sistema. Un uso efficace di RPM può accelerare la soluzione dei problemi.
Per vedere una lista ordinata dei pacchetti installati:
rpm -qa | sort | less
usare i tasti su/giù per scorrere la lista.
Il comando:
rpm -qilf `which pathname` | less
trova il package da cui proviene il file pathname. Il carattere accento grave ` , ASCII 96, si ottiene con ALTGR+' .
Per installare il package nomepackage.rpm:
rpm -ivh nomepackage.rpm
Per disinstallare il package nomepackage.rpm ignorando le dipendenze:
rpm -e --nodeps nomepackage.rpm
Se il terminale è impazzito
Può succedere che lo schermo mostri una serie di caratteri insignificanti e che quello che si vede non è ciò che si digita. I comandi però sembra che vengano ancora interpretati, anche se non si possono leggere.
Probabilmente non è sufficiente premere CTRL+L o eseguire clear, che servirebbero solo a ripulire lo schermo. La soluzione è di resettare il terminale eseguendo il comando reset al buio.
Default NumLock
In genere, all'avvio di un terminale, il tastierino numerico è inattivo. Per evitare di attivarlo manualmente ogni volta, si può utilizzare il comando setleds. Ad esempio:
setleds +num < /dev/tty1
attiva il tastierino numerico sul terminale tty1. Questo comando dovrebbe essere inserito in uno dei files di avvio (rc).
Shutdown
In genere un sistema è impostato per riavviarsi alla pressione di CTRL+ALT+CANC perché il file /etc/inittab contiene una riga simile a questa:
ca::ctrlaltdel:/sbin/shutdown -t3 -r now
l'opzione -r è responsabile del riavvio. Cambiarla in -h per ottenere un semplice halt senza riavvio. Dallo stato di halt si può spegnere o riavviare con CTRL+ALT+CANC, se la macchina non si è spenta.
La calcolatrice bc
Finchè non la si prova, è difficile credere che la calcolatrice classica di unix possa essere uno strumento di lavoro davvero efficace.
bc è un interprete di comandi e il suo linguaggio è simile al C, ma i calcoli si eseguono in modo intuitivo e immediato proprio come su una calcolatrice. Avviare la calcolatrice eseguendo:
bc
si ottiene il prompt dei comandi di bc.
Per calcolare 2128 eseguire:
2^128
si ottiene:
340282366920938463463374607431768211456
non c'è troncamento perché bc ha una precisione teoricamente illimitata.
Si deve informare bc di quante cifre frazionarie deve considerare, altrimenti supporrà di dover utilizzare solo valori interi. Ad esempio, per fissare il numero di cifre dopo la virgola a 6, eseguire:
scale=6
Se bc viene eseguito con l'opzione -l, si può usufruire delle funzioni della libreria matematica (in questo caso, per default, scale=20). Per calcolare il valore di pi greca come 4 volte l'arcotangente di 1, con una precisione di 12 cifre frazionarie, eseguire:
scale=12
4*a(1)
si ottiene:
3.141592653588
Per default, bc lavora in base 10. Per convertire un numero da base 16 a base 2, fissare le basi di input e output così:
ibase=16
obase=2
(notare che 2 è inserito in base 16) inserire un numero in base 16:
1AF5D3
(le lettere utilizzate per le cifre di valore decimale maggiore di 10 devono essere maiuscole) si ottiene lo stesso valore in base 2:
110101111010111010011
Per terminare eseguire:
quit
PPP e la connessione Internet
Il protocollo PPP (Point to Point Protocol) serve a trasportare pacchetti tra due reti collegate solo da una connessione punto-punto. Grazie al PPP è possibile estendere Internet attraverso connessioni a basso costo come linee seriali e linee telefoniche commutate.
In Linux è il programma pppd a gestire le interfacce di rete di questo tipo. Il comando seguente imposta una connessione PPP con il numero numtel, autenticando l'utente nomelogin:
pppd connect 'chat -v "" "ATZ" "OK" "ATDT numtel " "CONNECT" "" ' name nomelogin crtscts modem -detach defaultroute \
noipdefault /dev/ttyS1 115200
Il file /etc/ppp/pap-secrets deve contenere una riga con la password dell'utente nomelogin:
nomelogin * password
X Server e i clients remoti
Siamo abituati a pensare a un server come a un sistema remoto e a un client come a un sistema locale, perché in genere facciamo girare, sul nostro computer locale, programmi client che utilizzano i servizi di programmi server che girano su macchine lontane.
Quando lavoriamo con X-Window ci troviamo in una situazione inusuale. L'X-server gira proprio sulla macchina locale che stiamo utilizzando e offre i suoi servizi (come il disegno di una finestra sullo schermo) ai programmi X-client che devono creare un'interfaccia utente. Questi client possono anche girare su macchine remote.
Supponiamo di lavorare in X-Window sul computer A in una LAN. Vogliamo utilizzare Gimp che però non è presente sulla macchina locale. Possiamo eseguire quello installato sulla macchina B della LAN. Gimp girerà sulla macchina remota B, ma vedremo la sua finestra sulla nostra macchina A.
Prima di tutto dobbiamo informare il nostro X-server che dovrà accettare una connessione da un X-client remoto dalla macchina B. Per farlo, da un xterm su A, eseguiamo:
xhost B
Ora andiamo su B con telnet:
telnet B
Dopo aver ottenuto l'accesso dobbiamo dire a B che gli X-client che eseguiremo dovranno generare la loro finestra su un'altra macchina, la nostra:
export DISPLAY=A:0.0
Adesso possiamo eseguire Gimp su B. Dalla stessa sessione telnet eseguiamo:
gimp &
otterremo la finestra di Gimp sulla macchina locale A.
Si può evitare di impostare prima la variabile DISPLAY, utilizzando invece l'opzione --display di gimp:
gimp --display A:0.0 &
In genere ogni x-client ha un'opzione di questo tipo.
Anche quando eseguiamo gli X-client sulla macchina locale, le cose funzionano in questo modo, ma sono meno evidenti: l'X-client chiede l'accesso all'X-server, ma è autorizzato per default dato che si trova sulla stessa macchina; non dobbiamo impostare la variabile DISPLAY che per default è già impostata all'host locale; non dobbiamo accedere a un'altra macchina perché l'X-client sta sulla macchina locale dove siamo già entrati. Per Gimp nell'esempio, tutto si riduce solo all'esecuzione di gimp & .
