[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico] [volume] [parte]
In questo capitolo vengono descritti gli aspetti nella gestione dei terminali a carattere che riguardano un utilizzo un po' più evoluto rispetto al normale. La tabella 84.1 elenca i programmi e i file a cui si accenna in questo capitolo.
|
Tabella 84.1. Riepilogo dei programmi e dei file per la gestione evoluta dei terminali a caratteri.
|
L'attività svolta durante una sessione di lavoro attraverso un terminale potrebbe essere registrata volontariamente in modo da annotare le operazioni svolte, eventualmente anche a titolo di prova, come potrebbe essere l'esecuzione di un test di esame.
In aggiunta, le console virtuali di GNU/Linux possono essere osservate attraverso dei dispositivi appositi: /dev/vcs*.
Il programma script (1) permette di registrare la sessione di lavoro svolta attraverso un terminale a caratteri. Si avvia il programma e questo, a sua volta, avvia una copia della shell predefinita; da quel momento, tutto ciò che viene digitato ed emesso attraverso il terminale viene memorizzato in un file. Il file può essere indicato nella riga di comando, altrimenti viene creato il file typescript nella directory corrente.
script [-a] file |
L'opzione -a permette di continuare la registrazione in un file già utilizzato in precedenza, senza cancellarlo inizialmente.
Per terminare l'esecuzione della registrazione della sessione di lavoro, basta concludere l'attività della shell avviata da script; di solito si tratta di utilizzare il comando exit.
I file di dispositivo /dev/vcs*, definiti Virtual console capture device, possono essere usati per visualizzare lo schermo di una console particolare. Il meccanismo è estremamente banale, in quanto basta leggere il loro contenuto: in ogni momento, il risultato che si ottiene da questa lettura è l'immagine dello schermo di quella console particolare che quel dispositivo rappresenta.
# cat /dev/vcs1[Invio]
L'esempio mostra la visualizzazione del contenuto dello schermo della prima console virtuale, corrispondente al dispositivo /dev/tty1, dell'istante in cui si esegue il comando.
In particolare, il dispositivo /dev/vcs0 fa riferimento alla console virtuale attiva, mentre i file contrassegnati da un numero finale (diverso da zero) corrispondono alle rispettive console virtuali, identificate in modo preciso tramite quel numero.
Le console virtuali di GNU/Linux sono gestite normalmente attraverso la configurazione del file /etc/inittab, in cui, a seconda del livello di esecuzione, si attivano diversi programmi Getty abbinati ad altrettanti terminali o console virtuali. Generalmente, in questo modo, non vengono utilizzate tutte le console virtuali possibili, pertanto quelle rimanenti potrebbero essere sfruttate per altri scopi.
Le console virtuali disponibili possono essere utilizzate per visualizzare in modo continuo informazioni utili sul funzionamento del sistema, come per esempio quelle provenienti da un file per le registrazioni del sistema (log).
# tail -f /var/log/messages > /dev/tty10 &[Invio]
L'esempio mostra l'utilizzo di tail per visualizzare la fine del file /var/log/messages e tutte le righe che gli vengono aggiunte successivamente. Invece di impegnare il terminale dal quale viene avviato, il comando viene messo sullo sfondo (&) e l'output viene emesso attraverso la decima console virtuale (che si presume sia disponibile).
Il programma open (2) permette di avviare un comando in una nuova console virtuale (non utilizzata precedentemente). Per distinguere il comando dalle opzioni di open si utilizza un trattino doppio (--) per segnalare l'inizio del comando stesso.
open [opzioni] [--] comando [opzioni_del_comando] |
|
Tabella 84.2. Alcune opzioni. |
Segue la descrizione di alcuni esempi.
# open bash[Invio]
Avvia l'eseguibile bash nella prima console virtuale libera.
# open -l bash[Invio]
Avvia l'eseguibile bash nella prima console virtuale libera, trattando il processo relativo come una shell di login.
# open -c 10 -l bash[Invio]
Come nell'esempio precedente, utilizzando espressamente la decima console virtuale.
# open -- ls -l[Invio]
Esegue il comando ls -l utilizzando la prima console virtuale libera. In questo caso, dovendo indicare un comando con argomenti, è stato inserito il trattino doppio per segnalare l'inizio del comando stesso.
Il programma switchto (3) permette di selezionare una console virtuale particolare. Può essere utile in uno script.
switchto n |
L'esempio seguente mostra il passaggio all'undicesima console virtuale:
# switchto 11[Invio]
È già stato descritto più volte il funzionamento delle console virtuali di GNU/Linux, che, attraverso una sola console fisica, permettono la gestione di più sessioni di lavoro differenti, a cui si accede generalmente con le combinazioni di tasti [Ctrl Fn], oppure [Ctrl Alt Fn]. Un effetto simile si può ottenere attraverso dei programmi, che possono essere utilizzati anche quando non si dispone di una console GNU/Linux.
Un programma che svolga questo compito non è così comodo da utilizzare come può esserlo una console virtuale, però può offrire delle possibilità in più. Per esempio, potrebbe trasferire il terminale virtuale su un altro terminale fisico, senza dover sospendere, né interrompere, il lavoro che si stava svolgendo. In pratica, l'unico programma che si utilizzi per questo scopo è Screen, (4) che permette di fare una quantità di cose, anche il trasferimento di un terminale virtuale a un altro utente (consentendo a questo di continuare il lavoro).
Lo studio di Screen è impegnativo come lo è l'approfondimento di una shell sofisticata. Qui si vogliono mostrare solo i rudimenti, trascurando volutamente funzionalità che, se utilizzate, richiederebbero attenzione per ciò che riguarda la sicurezza.
Screen, che si compone precisamente dell'eseguibile screen, è un programma che si interpone tra una shell (o un applicativo diverso) e il terminale utilizzato effettivamente. In pratica, si tratta di un gestore di finestre a caratteri che, tra le altre cose, permette di aprire più sessioni contemporanee utilizzando un solo terminale fisico.
Ogni terminale virtuale, ovvero ogni finestra, mette a disposizione le funzionalità di un terminale VT100 con delle estensioni di vario tipo. Per ogni finestra viene conservato uno storico delle ultime righe visualizzate, permettendo lo scorrimento all'indietro e la copia di porzioni di questo all'interno dello standard input della stessa o di un'altra finestra.
Come si può intuire, per accedere alle funzionalità offerte da Screen occorre utilizzare dei comandi composti da combinazioni di tasti che vengono intercettati da questo, senza essere passati all'applicazione sottostante, provocando così un'alterazione del comportamento normale di queste applicazioni.
Spesso, viene attivato il bit SUID al binario screen, assieme all'attribuzione della proprietà all'utente root. Ciò permette a Screen di fare una serie di cose molto comode, ma richiede attenzione nella sua configurazione, perché ciò potrebbe tradursi in un pericolo in più per chi lo utilizza. Se non si vuole approfondire tanto l'uso di Screen, sarebbe meglio togliere tale permesso.
# chmod ug-s /usr/bin/screen[Invio]
Se Screen è in condizione di poterlo fare (di solito solo se è attivato il bit SUID per il binario screen e questo appartiene all'utente root), aggiorna il file /etc/utmp, cosa che consente di tenere traccia anche di tutti i terminali virtuali aperti attraverso di esso.
Per poter funzionare, Screen deve creare un file FIFO (pipe con nome), per ogni gruppo di finestre aperto, cioè per ogni terminale fisico a cui è connesso effettivamente. Tale file viene definito socket da Screen e dalla sua documentazione. Questo file può essere creato in varie posizioni, a seconda di come sono stati compilati i sorgenti. Se il binario screen è stato previsto con il bit SUID attivo, questo file FIFO potrebbe essere creato nella directory /tmp/screens/S-utente/, oppure, più utilmente, potrebbe essere creato nella directory ~/.screen/. È da ritenere che questa ultima scelta sia la migliore; volendo, si può utilizzare la variabile di ambiente SCREENDIR per indicare il percorso della directory che Screen deve usare per i file FIFO.
Il nome utilizzato per il file FIFO serve a identificare una particolare sessione di lavoro di Screen, assieme a tutte le finestre gestite attraverso questa. Di solito, si tratta di un nome articolato secondo il modello seguente:
pid.terminale.nodo |
Per esempio, 123.tty4.dinkel è il modo con cui si identifica la sessione di Screen che ha il numero PID 123, utilizza il terminale corrispondente al dispositivo /dev/tty4, sul sistema chiamato dinkel.
Una sessione di Screen, quando è in funzione regolarmente, è attaccata al terminale fisico che si utilizza effettivamente (questo terminale fisico può anche essere una console virtuale di GNU/Linux). La sessione può essere distaccata e successivamente riattaccata altrove, presso un altro terminale fisico. Le applicazioni in funzione nelle varie finestre di una sessione distaccata, continuano a funzionare regolarmente. Di solito, a meno di modificare la configurazione predefinita, un segnale di aggancio (SIGHUP), che generalmente si ottiene disconnettendo la linea attraverso cui è collegato il terminale, provoca solo il distacco della sessione, senza coinvolgere le applicazioni.
Screen può essere controllato attraverso file di configurazione, la cui collocazione può essere varia. Potrebbe trattarsi di /etc/screenrc per la configurazione globale e di ~/.screenrc per la personalizzazione di ogni utente. Le direttive di questi file non vengono mostrate qui; eventualmente si può consultare la documentazione originale: screen(1).
Screen imposta automaticamente la variabile TERM al valore screen, in modo da informare opportunamente le applicazioni di adattarsi alle sue caratteristiche.
Quasi tutti i comandi che possono essere impartiti a Screen sono prefissati dalla combinazione [Ctrl a], alla quale segue poi una sequenza di caratteri o di altre combinazioni di tasti, che ovviamente non vengono passati all'applicazione sottostante. Se però si vuole passare proprio la combinazione [Ctrl a] all'applicazione, si deve usare la sequenza [Ctrl a][a].
A volte, Screen ha la necessità di fornire delle indicazioni. Ciò viene fatto sovrascrivendo parte della finestra in uso, di solito nell'ultima riga. Dopo pochi secondi, i messaggi vengono rimossi, ripristinando il testo precedente.
Screen si compone in pratica dell'eseguibile binario screen. Come accennato in precedenza, viene predisposto spesso in modo da avere il bit SUID attivo e da essere proprietà dell'utente root. Se non si richiedono funzionalità particolari a questo programma, non è necessaria tale politica.
screen [opzioni] [comando [argomenti_del_comando]] |
Il programma screen può essere avviato per iniziare una sessione di lavoro attraverso cui gestire delle applicazioni contenute in finestre differenti, oppure per altre funzionalità descritte in occasione della presentazione delle opzioni. Quando si avvia screen in modo normale, si può aggiungere l'indicazione di un comando (con i suoi argomenti), che si vuole avviare all'interno della prima finestra. Se questo comando non viene specificato, screen avvia una shell (quella indicata nella variabile di ambiente SHELL, oppure /bin/sh in sua mancanza).
Quando un programma ospitato all'interno di una finestra di screen termina di funzionare, la finestra relativa si chiude. Quando una sessione non ha più finestre, termina di funzionare anche il processo screen relativo.
|
Tabella 84.3. Alcune opzioni. |
Segue la descrizione di alcuni esempi.
$ screen[Invio]
Avvia una sessione di Screen sul terminale da cui si esegue il comando, aprendo la shell predefinita nella prima finestra.
$ screen -U[Invio]
Come nell'esempio precedente, richiedendo espressamente l'uso della codifica UTF-8 per il terminale.
$ screen mc[Invio]
Avvia una sessione di Screen sul terminale da cui si esegue il comando, avviando il programma mc, senza argomenti, nella prima finestra.
$ screen -ls[Invio]
Elenca le sessioni aperte dall'utente.
$ screen -d tty2[Invio]
Distacca la sessione in funzione sul terminale identificato dal dispositivo /dev/tty2 (in pratica, la seconda console virtuale). Non vengono indicate altre informazioni per il nome della sessione, perché probabilmente l'informazione del terminale è sufficiente e non crea ambiguità.
$ screen -d[Invio]
Distacca la prima sessione attiva appartenente all'utente stesso.
$ screen -r tty2[Invio]
Attacca, sul terminale da cui si dà il comando, la sessione che in origine è stata avviata sul terminale /dev/tty2 e successivamente distaccata.
$ screen -r[Invio]
Attacca la prima sessione libera che trova.
$ screen -d -r tty2[Invio]
Distacca la sessione in funzione sul terminale identificato dal dispositivo /dev/tty2, riattaccandola sul terminale da cui si dà il comando.
$ screen -d -r[Invio]
Distacca la prima sessione attiva che trova e la riattacca sul terminale da cui si dà il comando.
Una volta avviato l'eseguibile screen, si può interagire con questo attraverso una serie di comandi composti da combinazioni di tasti. Nella maggior parte dei casi si tratta di sequenze iniziate dalla combinazione [Ctrl a].
Per motivi di compatibilità, spesso sono disponibili diversi tipi di sequenze per lo stesso risultato. Nella tabella 84.4 vengono elencate solo alcune di queste sequenze; per un elenco completo occorre leggere la documentazione originale, costituita dalla pagina di manuale: screen(1).
|
Tabella 84.4. Alcuni dei comandi che si possono dare a Screen, quando è in funzione. |
Le operazioni più complesse sono quelle che riguardano la copia e l'inserimento di testo che proviene da quanto visualizzato attualmente, o nel testo precedente. Infatti, per ogni finestra viene conservato uno storico delle righe visualizzate, che può essere rivisto e dal quale si possono prelevare delle parti, inserendole in una memoria tampone (la documentazione screen(1) parla di paste buffer).
Con il comando [Ctrl a][Esc] si inizia la modalità di scorrimento e copia, cosa che blocca il funzionamento dell'applicazione che utilizza la finestra attiva. Da quel momento, si possono usare i tasti freccia e pagina per spostare il cursore; eventualmente si possono usare i tasti [h], [j], [k] e [l], come si fa con VI (134.1). Si possono anche fare delle ricerche nello stile di VI, con i comandi [/] e [?].
Quando si raggiunge il pezzo che si vuole copiare nella memoria tampone, lo si deve delimitare. Ciò si ottiene normalmente premendo il tasto [barra spaziatrice] nel punto di inizio, quindi si fa scorrere il cursore nel punto finale e si preme nuovamente la [barra spaziatrice] per concludere. La selezione del testo coincide anche con la conclusione della modalità di scorrimento e copia, cosa che dopo poco fa riprendere il funzionamento del programma.
È possibile anche la selezione di testo in modo rettangolare. Per questo, dopo aver premuto la [barra spaziatrice] per indicare il punto di inizio, si deve aggiungere anche il tasto [c], a indicare un bordo sinistro, oppure [C] a indicare un bordo destro. Successivamente, quando si raggiunge anche il punto finale, si preme nuovamente [C], oppure [c] (a seconda di come si è iniziato) prima della [barra spaziatrice].
Infine, il comando [Ctrl a][]] inserisce il testo, accumulato precedentemente nella memoria tampone, nello standard input dell'applicazione contenuta nella finestra attiva.
Il programma Screen consente di definire la sua configurazione attraverso i file /etc/screenrc e ~/.screenrc (il primo per tutto il sistema; il secondo per ogni utente). In alternativa, attraverso l'opzione -c si può indicare un file differente.
Il contenuto del file di configurazione si compone di commenti, preceduti dal simbolo #, righe vuote, righe bianche e direttive. Le informazioni utili sono costituite soltanto dalle direttive, che sono istruzioni semplici, disposte normalmente su una sola riga.
A ogni terminale a caratteri gestito presso il proprio elaboratore, corrisponde un file di dispositivo, che di norma si individua con il programma tty:
$ tty[Invio]
/dev/tty5 |
Il risultato del comando tty è relativo all'elaboratore presso il quale si sta operando, pertanto, se si tratta di un accesso remoto, il file di dispositivo riportato è inteso essere quello corrispondente nell'elaboratore remoto. Si cerchi di seguire l'esempio seguente, dove dall'elaboratore «A» ci si collega all'elaboratore «B», con l'aiuto di un programma appropriato:
A$ tty[Invio]
Ci si trova seduti davanti alla console dell'elaboratore «A» e si controlla quale file di dispositivo corrisponde alla propria console; si suppone si tratti della quinta console virtuale di un sistema GNU/Linux:
/dev/tty5 |
Con l'aiuto di un programma appropriato, ci si collega all'elaboratore «B» (che ha indirizzo IPv4 172.17.1.2):
A$ ssh 172.21.1.2[Invio]
Password: digitazione_all'oscuro[Invio]
Last login: ... from ... |
B$
A questo punto, pur essendo seduti davanti alla console dell'elaboratore «A», si sta lavorando nell'elaboratore «B». Si verifica il file di dispositivo corrispondente al terminale usato:
B$ tty[Invio]
/dev/pts/2 |
Nonostante questo, rimane il fatto che il terminale usato presso l'elaboratore «A», ovvero quello locale, è /dev/tty5; attraverso tale terminale si accede all'elaboratore remoto «B»; presso l'elaboratore «B» il terminale usato è /dev/pts/2.
|
Se presso l'elaboratore «A» un programma fosse in grado di controllare il file di dispositivo |
Questa premessa è necessaria per comprendere il funzionamento del programma pconsole, (5) con il quale è possibile inviare un comando simultaneamente a più terminali, utilizzando i file di dispositivo locali:
pconsole |
Il programma pconsole si usa senza argomenti, con i privilegi dell'utente root, ma dopo l'avvio gli si devono impartire dei comandi:
# pconsole[Invio]
pconsole WJ101 pconsole command mode |
>>>
Con il comando help è possibile ottenere il riepilogo dei comandi disponibili:
>>> help[Invio]
help Give help about the available commands ? short-cut for 'help' version Display version information echo Turn echo on or off attach Attach to a tty device detach Detach from a tty device list Show devices currently attached to connect Leave command mode quit Exit pconsole exit Exit pconsole |
>>> quit[Invio]
Il programma ha due stati di funzionamento: la modalità di comando, corrispondente a quella mostrata negli esempi; la modalità di invio. La modalità di comando serve, evidentemente, per impartire dei comandi, mentre l'altra modalità consente di passare all'inserimento di testo da inviare ai terminali che risultano attaccati. In pratica, prima ci si attacca a dei terminali, ovvero ai file di dispositivo corrispondenti, quindi si passa in modalità di inserimento e ciò che si scrive, viene eseguito in tutti i terminali relativi; quello che non si può fare attraverso pconsole è di «vedere» ciò che accade presso i vari terminali.
Per passare alla modalità di comando, si usa il codice <SOH>, ovvero <^a>, che normalmente si ottiene con la combinazione [Ctrl a]; per passare alla modalità di invio, si usa il codice <EOT>, ovvero <^d>, che normalmente si ottiene con la combinazione [Ctrl d].
È abbastanza difficile mostrare un esempio completo di utilizzo del programma pconsole; per capire ciò che si vuole sintetizzare nei comandi seguenti richiede una buona dose di intuito. Per cominciare, si suppone di avere aperto diversi terminali; in particolare interessano la console virtuale corrispondente al file di dispositivo /dev/tty3 e un terminale grafico corrispondente al file di dispositivo /dev/pts/4. Presso un altro terminale libero (una console virtuale o un terminale grafico, senza che ciò faccia differenza) si avvia pconsole e ci si «attacca» ai due terminali già nominati:
# pconsole[Invio]
pconsole WJ101 pconsole command mode |
>>> attach /dev/tty3[Invio]
attaching /dev/tty3 : Ok |
>>> attach /dev/pts/4[Invio]
attaching /dev/pts/4 : Ok |
Con il comando list si può vedere quali terminali risultano attaccati:
>>> list[Invio]
Currently attached to: /dev/tty3 (device no 4, 3) /dev/pts/4 (device no 136, 4) |
Si decide di passare alla modalità di inserimento:
>>> [Ctrl d]
Press <Ctrl-A> for command mode |
>
Come si può osservare, l'invito assume una forma più breve, per ricordare che ci si trova nella modalità di inserimento. Da qui si vuole semplicemente impartire il comando ls, che viene eseguito in pratica nei due terminali controllati da pconsole:
> ls[Invio]
Dal terminale dove si sta usando pconsole, non si vede alcun risultato; per sapere cosa è successo effettivamente, occorre invece passare agli altri terminali.
Al termine, si torna alla modalità di comando:
> [Ctrl a]
pconsole command mode |
>>>
A questo punto si può chiudere:
>>> quit[Invio]
detaching from /dev/tty3 : Ok detaching from /dev/pts/4 : Ok |
Per concludere, c'è da osservare che la documentazione di Pconsole suggerisce di attribuire al programma i permessi SUID-root, per consentire a tutti gli utenti di usarlo; tuttavia, ciò è sicuramente sconsigliabile per motivi di sicurezza.
Chris Bagwell, The Linux busmouse HOWTO
<http://www.linux.org/docs/ldp/howto/HOWTO-INDEX/howtos.html>
Appunti di informatica libera 2006.07.01 --- Copyright © 2000-2006 Daniele Giacomini -- <daniele (ad) swlibero·org>
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome utilizzo_piu_evoluto_del_terminale_a_caratteri.htm
[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico]
