Il terminale, in qualunque forma esso sia (console, terminale remoto, applicazione a finestra all'interno di X) è il mezzo normale di comunicazione tra l'utente e il sistema. Senza di esso non ci sarebbe alcuna possibilità di avviare nuovi processi e di conseguenza, nemmeno di poter compiere alcuna attività.
Per questo, l'attivazione di un programma per la gestione del terminale è l'ultima fase di una procedura di inizializzazione del sistema, ed è quella che precede immediatamente l'attivazione della procedura di accesso (il login), cioè il sistema di riconoscimento dell'utente che si accinge a utilizzare il sistema. I programmi Getty che sono quelli responsabili dell'attivazione del terminale prima dell'attivazione della procedura di accesso, verranno introdotti nel prossimo capitolo.
La tabella 32.1 elenca i programmi e i file a cui si accenna in questo capitolo.
| Nome | Descrizione |
| kbd_mode | Interroga o modifica la modalità della tastiera. |
| setleds | Impostazione di [BlocNum], [Fissamaiuscole] e [BlocScorr]. |
| showkey | Emette il codice corrispondente ai tasti premuti. |
| /usr/src/linux/drivers/char/defkeymap.c | Mappa della tastiera predefinita nel kernel. |
| /usr/lib/kbd/keymaps/ | Directory dei file di mappa delle varie nazionalità. |
| loadkeys | Modifica la mappa della tastiera. |
| dumpkeys | Emette la mappa della tastiera in funzione. |
| tty | Emette il nome corrispondente al terminale attivo. |
| stty | Definisce le caratteristiche della connessione del terminale. |
| /etc/termcap | Configurazione obsoleta delle caratteristiche dei terminali. |
| /usr/share/terminfo/?/* | Configurazione delle caratteristiche dei terminali. |
| $TERM | Variabile che definisce il tipo di terminale in uso. |
| clear | Ripulisce lo schermo. |
| reset | Reinizializza l'impostazione del terminale. |
| setfont | Definisce i caratteri per lo schermo delle console EGA/VGA. |
| /dev/mouse | Collegamento simbolico al dispositivo del mouse. |
| gpm | Programma di gestione del mouse nelle console virtuali. |
| script | Registrazione di una sessione di lavoro. |
| /dev/vcs* | Dispositivi per la cattura dello schermo di console virtuali. |
| open | Esegue un comando in una particolare console virtuale. |
| switchto | Seleziona una particolare console virtuale. |
| /dev/tty* | Dispositivi per le console virtuali. |
| /dev/console | Dispositivo della console. |
| screen | Programma per la gestione di terminali virtuali. |
La gestione della tastiera avviene attraverso un sistema piuttosto complesso. Solitamente si fa riferimento al programma loadkeys come unico responsabile della definizione delle funzioni associate ai tasti, ma questo non basta per comprendere il problema.
I segnali della tastiera vengono ricevuti direttamente dal kernel che poi li fornisce ai programmi, in vario modo, a seconda di una data modalità selezionata.
Il programma kbd_mode permette di conoscere o di modificare la modalità di funzionamento della tastiera, ma la modifica è da riservare sono a occasioni particolari, di solito utilizzando una connessione remota, quando un programma ha modificato la modalità della tastiera rendendo inutilizzabile la console.
In generale, ciò che conta è fare in modo che funzioni correttamente la tastiera connessa al proprio elaboratore. Questo è importante perché, quando si utilizza una connessione remota, per esempio attraverso Telnet, la tastiera che si adopera dipende, per la sua configurazione, dall'elaboratore a cui è connessa fisicamente, e non da quello con il quale si è collegati. Leggendolo così potrebbe sembrare una cosa evidente, ma quando ci si trova a farlo veramente, non lo è più così tanto.
In questo senso, se da una connessione remota viene dato un comando per modificare la modalità di funzionamento o la mappa della tastiera, l'effetto si risentirà sulla console dell'elaboratore che riceve il comando e non nel terminale remoto.
Queste considerazioni permettono anche di comprendere che la connessione remota è indipendente da qualunque configurazione che riguardi la tastiera di un certo elaboratore. Perciò, una configurazione errata che renda inutilizzabile una console, può essere corretta attraverso una connessione remota.
GNU/Linux, come altri sistemi Unix, consente di gestire diversi terminali sull'unica console esistente effettivamente. Questi vengono definiti console virtuali. Attraverso alcune combinazioni di tasti si riesce a passare da una console virtuale all'altra. Queste combinazioni sono normalmente [Alt+F1], [Alt+F2],... oppure [Ctrl+Alt+F1], [Ctrl+Alt+F2],... ma possono essere modificate (anche se ciò non è consigliabile).
La console vera e propria, corrisponde quasi sempre alla console virtuale in funzione in un dato momento.
La configurazione della tastiera, a seconda del tipo di modalità su cui si interviene, può avere effetto su tutte le console virtuali, oppure solo su quella attiva.
kbd_mode [<opzioni>] |
kbd_mode permette di conoscere o di modificare la modalità di funzionamento della tastiera della console. Ciò significa, implicitamente, che l'effetto riguarda la console virtuale attiva, e quando viene utilizzato a distanza, attraverso telnet o un altro programma simile, ha effetto sulla console virtuale attiva nell'elaboratore al quale si è connessi.
L'utilizzo di questo programma deve essere fatto con prudenza: la visualizzazione della modalità di funzionamento della tastiera non provoca alcun inconveniente, ma la modifica errata della modalità, comporta l'impossibilità di continuare a utilizzarla.
|
È meglio evitare di utilizzare questo programma per modificare la modalità della tastiera, da una finestra di terminale, all'interno del sistema grafico X. |
Se kbd_mode viene avviato senza opzioni, il risultato che si ottiene è la visualizzazione della modalità attiva. Questo dovrebbe essere l'uso normale del programma.
|
L'opzione -s
|
L'opzione -k
|
L'opzione -aloadkeys.
|
L'opzione -uloadkeys.
Se la console di un elaboratore è rimasta bloccata e comunque esiste la possibilità di connettersi a questo da un'altra postazione funzionante, si può ripristinare la modalità corretta della tastiera da lì. Nell'esempio seguente, l'elaboratore da sistemare è dinkel.brot.dg e quello dal quale si interviene è roggen.brot.dg.
roggen.brot.dg$ telnet dinkel.brot.dg[Invio]
Trying dinkel.brot.dg... Connected to dinkel.brot.dg. Escape character is '^]'. |
login: root[Invio]
Password: ********[Invio]
dinkel.brot.dg$ kbd_mode [Invio]-a
dinkel.brot.dg$ exit[Invio]
|
Questo esempio presume che si abbia già una certa conoscenza di come si instaura una connessione remota attraverso il programma |
setleds [<opzioni>] [<modalità>...] |
Il programma setleds interviene esclusivamente su una console virtuale attiva, o meglio, quella da cui proviene lo standard input. Non può essere utilizzato in altre situazioni. Lo scopo del programma è di intervenire sull'impostazione dei tasti [Fissamaiuscole] (capslock), [BlocNum] (numlock) e [BlocScorr] (ScrollLock).
Solitamente, questi tasti attivano o disattivano la modalità corrispondente, e questa viene segnalata da una spia luminosa sulla tastiera, una per ogni modalità. Queste spie sono notoriamente dei led (Light Emitting Diode), e spesso sono chiamati così anche in italiano.
Il programma permette di intervenire sia attivando o disattivando queste modalità che accendendo o spegnendo i led.
Utilizzando il programma senza argomenti, si ottiene il resoconto sull'impostazione dei tasti su cui può intervenire, e su quella dei led corrispondenti.
|
L'opzione -F
|
L'opzione -D-Freset.
|
L'opzione -Lsetleds con questa opzione, si sgancia il funzionamento dei led dall'uso dei tasti a cui sarebbero abbinati. Per ripristinare il collegamento tra led e tasti, si può utilizzare nuovamente setleds con l'opzione -L
+num |
|
Attiva o disattiva [BlocNum].
+caps |
|
Attiva o disattiva [Fissamaiuscole].
+scroll |
|
Attiva o disattiva [BlocScorr].
$ setleds
Mostra la configurazione attuale.
$ setleds +num
Attiva i numeri nella tastiera numerica.
$ setleds -L +scroll
Accende il led ScrollLock senza altro effetto sull'uso della tastiera.
$ setleds -L
Ripristina il collegamento tra led e tastiera.
# setleds +num < /dev/tty1
Attiva i numeri nella tastiera numerica della prima console virtuale.
Il primo problema che si incontra dal punto di vista della nazionalizzazione di un sistema operativo, è la disposizione dei tasti sulla tastiera. Quando la tastiera viene utilizzata in modalità ASCII o UNICODE, il kernel utilizza una tabella di conversione prima di trasmettere alle applicazioni i tasti premuti.
In fase di compilazione del kernel viene definita una tabella predefinita attraverso il file /usr/src/linux/driver/char/defkeymap.c. Normalmente questo file corrisponde alla mappa della tastiera USA, ma può anche essere cambiato come si vedrà in seguito.
Di solito, la mappa della tastiera viene ridefinita attraverso il programma loadkeys indicando come argomento il nome di un file contenente la mappa desiderata. I file delle varie mappe disponibili sono contenuti normalmente a partire dalla directory /usr/lib/kbd/keymaps/.
Il sistema della mappa della tastiera che si descrive qui e nelle sezioni seguenti, riguarda solo le console virtuali di GNU/Linux e non l'impostazione fatta dal sistema grafico X per i programmi che si avviano al suo interno.
showkey [<opzioni>] |
Il programma showkey permette di visualizzare, attraverso lo standard output, il codice corrispondente ai tasti che si premono e si rilasciano. Dal momento che ciò impegna totalmente la tastiera, showkey conclude il suo funzionamento dopo dieci secondi di inattività.
|
Questo programma non può funzionare in una finestra di terminale nel sistema grafico X. |
|
Fa in modo che showkey mostri i codici scancode. L'utilizzo della tastiera in questa modalità è abbastanza raro, quindi sarà raramente utile conoscere la corrispondenza della pressione e rilascio dei tasti in questa modalità.
|
Fa in modo che showkey mostri i codici keycode. È il funzionamento predefinito, quando non si indicano argomenti di alcun genere. È questa la codifica a cui si fa riferimento quando si costruiscono i file di mappa gestiti da loadkeys.
Prima di vedere come utilizzare il programma loadkeys è opportuno descrivere rapidamente come deve essere predisposto un file da usare per definire la mappa della tastiera. Fortunatamente, non esiste la necessità di modificarlo, ma ciò potrebbe essere ugualmente desiderabile.
All'interno del file sono ammessi i commenti, prefissati con un punto esclamativo (!) oppure con il simbolo #; nello stesso modo sono ignorate le righe vuote e quelle bianche. Le righe che definiscono qualcosa possono essere continuate con una barra obliqua inversa (\) che precede il codice di interruzione di riga.
Possono essere usate diverse definizioni, secondo le sintassi seguenti.
charset "iso |
In questo caso si definisce l'insieme di caratteri utilizzato e, per quanto ci riguarda, dovrebbe trattarsi di iso. Normalmente, non è nemmeno necessario inserire questo tipo di dichiarazione nei file.
-8859-1
keycode <numero-tasto> = <simbolo> <simbolo>... |
Questa definizione attribuisce a un tasto diversi significati, in funzione dell'eventuale combinazione con altri.
string <nome> = <stringa> |
Per facilitare la costruzione di un file di mappa del genere, si possono definire alcuni nomi di tasti il cui significato viene chiarito in seguito attraverso questo tipo di dichiarazione. Lo si fa normalmente con i tasti funzionali ([F1], [F2], ecc.).
Con il termine modificatore si fa riferimento a quei tasti che si possono usare per ottenere delle combinazioni. La tabella 32.2 ne mostra l'elenco e il peso.
| Modificatore | Sigla | peso |
| (nessuno) | 0 | |
| Maiuscole (indifferentemente sinistro o destro) | Shift | 1 |
| Alt destro | AltGr | 2 |
| Control (indifferentemente sinistro o destro) | Ctrl | 4 |
| Alt sinistro | Alt | 8 |
| Maiuscole sinistro | ShiftL | 16 |
| Maiuscole destro | ShiftR | 32 |
| Control sinistro | CtrlL | 64 |
| Control destro | CtrlR | 128 |
I modificatori sono otto, a cui si somma la situazione normale in cui nessun modificatore viene utilizzato. Volendo indicare tutte le combinazioni possibili di modificatori, queste sarebbero 255, ma è un po' difficile immaginare che si voglia definire una combinazione del tipo [CtrlL+CtrlR+Alt+AltGr+Shift+a] o ancora peggiore (sarebbe decisamente un bell'esercizio di digitazione).
Attraverso il numero del peso, si può fare riferimento a un modificatore o a una combinazione di modificatori, in modo molto semplice: sommandone i valori. Per esempio, 1 rappresenta [Shift], 2 rappresenta [AltGr] e 3 rappresenta [Shift+AltGr]. Di conseguenza, 255 rappresenta la pressione simultanea di tutti i modificatori.
Quando si specifica la funzione di un tasto attraverso l'istruzione keycode, si indicano una serie di funzioni in sequenza. Il significato di questa sequenza dipende dai tipi di modificatori e dalle loro combinazioni che si intendono utilizzare. Questo viene definito attraverso un'istruzione keymaps iniziale.
keymaps <peso>[,<peso>]... |
Per esempio, l'istruzione seguente indica l'utilizzo dei pesi 0, 1, 2, 4, 6, 8, 9 e 12.
keymaps 0-2,4,6,8-9,12 |
Come si vede nell'esempio, si fa riferimento anche a intervalli, quindi, 0 rappresenta tutti i valori da 0 a 2, ovvero, 0, 1 e 2. La stessa cosa avrebbe potuto essere dichiarata in un modo più esplicito come nell'esempio seguente:
-2
keymaps 0,1,2,4,6,8,9,12 |
Questi valori indicano che nella mappa definita dalle direttive successive, si fa riferimento ai tasti premuti da soli, in combinazione con [Shift], [AltGr], [Ctrl] (indifferentemente sinistro o destro), [Ctrl+AltGr], [Alt], [Alt+Shift] e [Ctrl+Alt]. Le istruzioni keycode successive all'istruzione keymaps dell'esempio vengono interpretate di conseguenza. L'esempio seguente dovrebbe chiarirlo.
keycode 26 = egrave eacute bracketleft Escape VoidSymbol Meta_bracketleft |
In questo caso, premendo il tasto corrispondente alla lettera è, nella tastiera italiana, si ottiene esattamente questa lettera (egrave). In combinazione con:
[Shift] si ottiene la lettera é;
[AltGr] si ottiene la parentesi quadra aperta (sinistra);
[Ctrl] si ottiene un escape;
[Ctrl+AltGr] non si ottiene alcunché;
[Alt] si ottiene l'equivalente di [Meta+[].
In tutti i casi rimanenti non si ottiene alcun risultato.
Dall'esempio visto nella sezione precedente dovrebbe essere apparsa finalmente chiara la differenza tra «Alt» e «Meta». Alt è il nome di un tasto di una tastiera particolare, mentre Meta è un'astrazione che serve a generalizzare le definizioni.
Dall'esempio visto in precedenza, quello riportato nuovamente qui sotto, si fa in modo di abbinare alla combinazione reale [Alt+è] la combinazione astratta [Meta+[].
keymaps 0,1,2,4,6,8,9,12 ... keycode 26 = egrave eacute bracketleft Escape VoidSymbol Meta_bracketleft |
L'istruzione keycode permette di indicare in sequenza il significato di un certo tasto, in funzione dell'eventuale combinazione con i modificatori previsti con l'istruzione keymaps.
Quando si vuole indicare un'azione nulla, si usa il nome VoidSymbol, e quello che non viene scritto nella parte finale, vale come se fosse sempre VoidSymbol.
Per facilitare l'indicazione del risultato di combinazioni si possono usare dichiarazioni keycode successive che valgono per una singola situazione. L'esempio seguente è identico, per risultato, a quello visto in precedenza, e la differenza sta nel fatto che così ci si limita a indicare un'istruzione keycode normale per le situazioni normali (tasto premuto da solo, oppure in combinazione con [shift], o anche con [AltGr]), e sotto, eventualmente, le altre combinazioni utili.
keymaps 0,1,2,4,6,8,9,12 ... keycode 26 = egrave eacute bracketleft control keycode 26 = Escape alt keycode 26 = Meta_bracketleft |
Studiando un file di mappa della tastiera si possono trovare alcune cose interessanti, come la definizione di combinazioni particolari. Gli estratti riportati di seguito provengono dalla mappa italiana normale: /usr/lib/kbd/keymaps/it.map. I modificatori utilizzati sono quelli degli esempi precedenti, ovvero: 0, 1, 2, 4, 6, 8, 9 e 12.
---------
keycode 57 = space space control keycode 57 = nul alt keycode 57 = Meta_space control alt keycode 57 = Meta_nul |
In questo caso, nelle situazioni in cui ciò potesse servire, la combinazione [Ctrl+Spazio] genera un carattere nul.
---------
keycode 59 = F1 F11 Console_13 control keycode 59 = F1 alt keycode 59 = Console_1 control alt keycode 59 = Console_1 keycode 60 = F2 F12 Console_14 control keycode 60 = F2 alt keycode 60 = Console_2 control alt keycode 60 = Console_2 ... string F1 = "\033[[A" string F2 = "\033[[B" ... string F11 = "\033[23~" string F12 = "\033[24~" ... |
Si tratta della dichiarazione del comportamento dei tasti funzionali. I nomi di questi tasti non sono riconosciuti e quindi si dichiara più avanti la stringa che deve essere generata quando si fa riferimento a questi.
Si può osservare che la combinazione [Shift+F1] genera l'equivalente di [F11].
La combinazione [Alt+F1] o [Ctrl+Alt+F1] serve notoriamente per selezionare la prima console virtuale, e questo viene definito chiaramente con le istruzioni alt keycode 59 = Console_1 e control alt keycode 59 = Console_1. Nello stesso modo si può osservare che la combinazione [AltGr+F1] seleziona la tredicesima console virtuale (ammesso che ci sia).
---------
keycode 70 = Scroll_Lock Show_Memory Show_Registers control keycode 70 = Show_State alt keycode 70 = Scroll_Lock |
Da questa dichiarazione, si osserva che la combinazione [Shift+BlocScorr] visualizza la situazione dell'uso della memoria, la combinazione [AltGr+BlocScorr] mostra la situazione dei registri e la combinazione [Ctrl+BlocScorr] mostra lo stato.
loadkeys [<opzioni>] [<file>] |
loadkeys viene usato normalmente per cambiare la mappa della tastiera utilizzata in tutte le console virtuali, attraverso le indicazioni contenute in un file fornito come argomento o attraverso lo standard input. Il file fornito come argomento, se non contiene l'indicazione di un percorso, viene cercato a partire dalla directory /usr/lib/kbd/keymaps/<piattaforma>/.
È importante considerare che la modifica interviene su tutte le console virtuali, e se si tenta qualcosa del genere attraverso una connessione remota si interviene sull'elaboratore con il quale si è connessi, e non su quello dal quale si sta operando.
loadkeys può essere utilizzato anche solo per generare un file sorgente da utilizzare al posto di /usr/src/linux/drivers/char/defkeymap.c quando si compila un nuovo kernel.
|
Emette attraverso lo standard output il contenuto di un file che può essere utilizzato al posto di /usr/src/linux/drivers/char/defkeymap.c in modo da essere incorporato nel kernel alla prossima compilazione.
$ loadkeys /usr/lib/kbd/keymaps/i386/qwerty/it.map
Carica la mappa contenuta nel file /usr/lib/kbd/keymaps/i386/qwerty/it.map.
$ loadkeys it.map
Esattamente come nell'esempio precedente, supponendo di operare su una piattaforma i386.
$ loadkeys it
Esattamente come nell'esempio precedente.
$ loadkeys -m it > /usr/src/linux/drivers/char/defkeymap.c
Genera il file /usr/src/linux/drivers/char/defkeymap.c in base alla mappa it.map.
dumpkeys [<opzioni>] |
dumpkeys viene usato normalmente per emettere attraverso lo standard output la mappa attuale della tastiera.
Vedere dumpkeys(1).
È importante poter identificare il terminale da cui si accede, almeno in base al tipo di dispositivo utilizzato. In pratica, si dispone del programma tty che è in grado di restituire il nome del file di dispositivo corrispondente. Con questa informazione si possono creare degli script opportuni, eventualmente per filtrare l'accesso da parte degli utenti.
tty [<opzioni>] |
tty emette attraverso lo standard output il nome del terminale con cui si è connessi.
|
Non emette alcuna segnalazione, si limita a restituire un valore.
0 se lo standard input è un terminale;
1 se lo standard input non è un terminale;
2 se sono stati forniti argomenti errati;
3 se si è verificato un errore di scrittura.
#!/bin/sh
if [ `tty` = "/dev/tty1" ]
then
echo "spiacente, non puoi usare questo terminale"
else
ls
fi
|
Questo esempio è solo un pretesto per mostrare in che modo potrebbe essere utile tty. Se l'utente sta utilizzando la prima console virtuale (/dev/tty1), viene respinto; altrimenti viene eseguito il comando ls.
Le caratteristiche dei terminali a caratteri possono essere molto diverse e questo è il problema principale che si pone di fronte alla ricerca verso una standardizzazione nel comportamento dei programmi per i sistemi Unix.
Si distinguono due problemi di ordine diverso: la configurazione del I/O (input/output) tra il terminale e il sistema, ovvero della linea di terminale (TTY), e la configurazione particolare dello schermo. La configurazione del I/O regola il modo in cui i dati possono essere inseriti attraverso la tastiera e come questo inserimento può essere controllato sullo schermo durante la sua digitazione (echo); la configurazione dello schermo riguarda il modo di rappresentare simboli determinati e di comportarsi di fronte a sequenze di escape determinate.
+---------+
| |
| Schermo | +-------------+
| | Linea TTY | |
+---------+......................| Sistema |
+---------+ Connessione | |
|Tastiera | | |
+---------+ +-------------+
Terminale a caratteri
|
Il tipo di connessione utilizzata (si pensi alla differenza che c'è tra una console legata strettamente con il sistema, rispetto a un terminale seriale o remoto), implica problemi differenti di gestione della linea TTY. L'utilizzatore normale non ha mai bisogno di preoccuparsi di questo, in quanto per ogni situazione c'è già un'impostazione predefinita che dovrebbe soddisfare le esigenze di tutti. Inoltre, nelle connessioni remote, il problema di questa configurazione si sposta sui programmi che si utilizzano per questi scopi; saranno poi questi programmi a definire la configurazione della linea e del I/O elementare.
All'utente è data la possibilità di verificare questa configurazione e di modificarla, attraverso il programma stty (Set TTY).
La fase successiva è la definizione delle particolarità degli schermi dei terminali, per ciò che riguarda le sequenze di escape che questi riconoscono, attraverso una sorta di database, in modo da permettere ai programmi di potervisi adattare.
Prima di descrivere l'utilizzo (sommario) di stty, conviene prendere confidenza con il problema, attraverso un po' di esercizio.
$ cat > /dev/null[Invio]
Avviando il programma cat in questo modo, si può analizzare ciò che succede quando si inserisce qualcosa attraverso la tastiera del proprio terminale.
asdfghjkl[Invio]
qwertyuiop[Invio]
Digitando lettere normali, queste appaiono semplicemente sullo schermo. L'eco dell'input, non è una cosa scontata; deriva da una configurazione, anche se questa è generalmente predefinita.
[Ctrl+p][Ctrl+l][Esc][F1][F2][Invio]
^P^L^[^[[[A^[[[B |
Generalmente, i caratteri di controllo che non hanno significati speciali, vengono visualizzati (echo) come lettere maiuscole (o brevi stringhe) precedute da un accento circonflesso, come mostra l'esempio. Anche questa è una caratteristica configurabile, anche se predefinita normalmente in questo modo.
Ad alcuni caratteri di controllo viene attribuito un significato speciale, che si traduce in un comportamento e non nell'eco di un qualche simbolo.
asdf ghjk lqwe rtyu iop[Ctrl+?][Ctrl+?][Ctrl+?][Ctrl+w][Invio]
asdf ghjk lqwe |
La combinazione [Ctrl+?] genera normalmente il carattere speciale ^?, che di solito è abbinato alla funzione erase, che a sua volta si traduce nella cancellazione dell'ultimo carattere inserito. La combinazione [Ctrl+w] genera normalmente il carattere speciale ^W, che di solito è abbinato alla funzione werase, che a sua volta si traduce nella cancellazione dell'ultima parola inserita.
Ad altri caratteri di controllo viene abbinato l'invio di un segnale al processo collegato alla linea di terminale. Ecco che così, di solito, la combinazione [Ctrl+c] genera il carattere speciale ^C, con il quale viene inviato un segnale SIGINT al processo collegato. Nello stesso modo, la combinazione [Ctrl+z] genera il carattere speciale ^Z, con il quale viene inviato un segnale SIGTSTP al processo collegato (cosa che generalmente si traduce nell'essere messo sullo sfondo dalla shell).
Per concludere questo esercizio, basta utilizzare la combinazione [Ctrl+c], per terminare il funzionamento di cat.
[Ctrl+c]
Un'altra cosa interessante è la possibilità di bloccare il flusso dell'output sullo schermo e di riprenderlo successivamente. Per questo si usano normalmente le combinazioni di tasti [Ctrl+s] e [Ctrl+q], che generano rispettivamente i codici ^S e ^Q.
Per verificarne il funzionamento, basta provare a lanciare un comando che emette un output molto lungo, come il seguente:
$ find / -print
Per sospendere il flusso visualizzato sullo schermo del terminale, basta premere [Ctrl+s]; per farlo riprendere, [Ctrl+q].
stty [<opzioni> | <configurazione>] |
stty permette di modificare le caratteristiche della connessione del terminale al sistema. Se viene avviato senza argomenti, visualizza le informazioni salienti della connessione. Gli argomenti della configurazione sono delle parole chiave che possono apparire precedute o meno dal trattino che di solito si usa per le opzioni: se non si usa il trattino, la parola chiave viene intesa come attivazione di qualcosa, con il trattino si intende la disattivazione della stessa cosa.
Il motivo più comune per servirsi di questo programma è quello di conoscere le combinazioni di tasti che si possono utilizzare per generare dei segnali particolari. Avviando stty con l'opzione -a
$ stty -a
Per esempio, si potrebbe ottenere qualcosa di simile al listato seguente:
speed 38400 baud; rows 25; columns 80; line = 0; intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V; flush = ^O; min = 1; time = 0; -parenb -parodd cs8 hupcl -cstopb cread -clocal -crtscts -ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon ixoff -iuclc -ixany -imaxbel opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0 isig icanon -iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt -echoctl echoke |
L'esempio indica in particolare che il carattere intr (interrupt) viene generato con la combinazione [Ctrl+c]; il carattere eof (end of file) viene generato con la combinazione [Ctrl+d]; il carattere susp (suspend) viene generato con la combinazione [Ctrl+z].
Per comprendere meglio il senso di questo programma, vale la pena di descrivere l'uso di alcune opzioni, anche se nella maggior parte dei casi, stty non verrà mai usato per queste cose.
---------
cs8 |
Definisce la dimensione dei caratteri a 8 bit.
hupcl |
|
Attiva o disattiva l'invio di un segnale di hungup (SIGHUP) in corrispondenza della conclusione dell'attività dell'ultimo processo, cosa che chiude la connessione con il terminale.
crtscts |
|
Attiva o disattiva il flusso di controllo RTS/CTS. Evidentemente, questo tipo di controllo di flusso riguarda i terminali connessi attraverso la porta seriale.
brkint |
|
Attiva o disattiva l'invio di un segnale di interruzione (SIGINT) in corrispondenza dell'invio di un carattere break.
istrip |
|
Attiva o disattiva l'azzeramento dell'ottavo bit dell'input.
ixon |
|
Abilita o disabilita il controllo di flusso XON/XOFF. Dalla sua abilitazione dipende il funzionamento di caratteri speciali riferiti ai comandi di stop e start (di solito [Ctrl+s] e [Ctrl+q]).
isig |
|
Abilita o disabilita l'uso di caratteri speciali, corrispondenti ai comandi interrupt, quit e suspend (di solito [Ctrl+c], [Ctrl+\] e [Ctrl+z]).
icanon |
|
Abilita o disabilita l'uso di caratteri speciali, corrispondenti ai comandi erase, kill, werase e rprnt (di solito [Ctrl+?], [Ctrl+u], [Ctrl+w] e [Ctrl+r]).
echo |
|
Abilita l'eco dei caratteri inseriti. Senza l'attivazione di questa modalità, non verrebbe visto l'input dalla tastiera.
echoctl |
|
ctlecho |
|
Attiva o disattiva l'eco dei caratteri di controllo attraverso la notazione ^x, dove x è una lettera che varia a seconda del carattere di controllo da visualizzare.
sane |
Questa opzione è una scorciatoia per definirne una serie numerosa, allo stato predefinito ritenuto generalmente corretto. In pratica implica quanto segue: cread ; inoltre imposta i caratteri speciali al loro valore predefinito.
-ignbrk brkint -inlcr -igncr icrnl -ixoff -iuclc -ixany imaxbel opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0 isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke
I caratteri speciali abbinati a funzionalità particolari in modo predefinito, possono variare da un sistema all'altro. Per modificare l'attribuzione di un carattere speciale a una certa funzione, si utilizza la sintassi seguente:
stty <nome-funzione> <carattere-speciale> |
Se al posto del simbolo del carattere speciale si utilizza la stringa ^, oppure la parola chiave -undef, quella funzionalità viene disabilitata.
Segue l'elenco di alcune parole chiave utilizzate per definire funzionalità a cui si possono attribuire caratteri speciali.
intr |
Invia un segnale di interruzione (SIGINT). Normalmente è abbinato al carattere speciale ^C, ovvero alla combinazione di tasti [Ctrl+c].
quit |
Invia un segnale di conclusione (SIGQUIT).
erase |
Cancella l'ultimo carattere digitato.
kill |
Cancella la riga corrente.
eof |
Fine del file, ovvero termina l'input. Normalmente è abbinato al carattere speciale ^D, ovvero alla combinazione di tasti [Ctrl+d].
stop |
Ferma l'output. Normalmente è abbinato al carattere speciale ^S, ovvero alla combinazione di tasti [Ctrl+s].
start |
Riprende l'output dopo uno stop. Normalmente è abbinato al carattere speciale ^Q, ovvero alla combinazione di tasti [Ctrl+q].
susp |
Invia un segnale di stop del terminale (SIGTSTP), cosa che generalmente fa sì che la shell metta il processo sullo sfondo. Normalmente è abbinato al carattere speciale ^Z, ovvero alla combinazione di tasti [Ctrl+z].
Vedere stty.info oppure stty(1).
Il primo tipo di terminale, la telescrivente, non poneva problemi particolari di configurazione: la tastiera permetteva di inserire numeri, simboli e caratteri dell'alfabeto inglese, a volte senza poter distinguere tra maiuscole e minuscole, e la stampante emetteva un normale flusso di testo interrotto da un codice di interruzione di riga.
Quando il terminale attuale viene usato ancora in questo modo, non si pongono problemi di configurazione, perché non è importante sapere le dimensioni (in caratteri) dello schermo, e non importa sapere come spostare il cursore sullo schermo.
Nel momento in cui si utilizza un programma che sfrutta lo schermo nel modo cui si è abituati di solito, mostrando bordi, colori, caselline da riempire, si ha la necessità di usare la tastiera anche per spostare il cursore, cancellare, inserire, attivare funzioni speciali. Quindi, lo schermo deve essere in grado di fare di più che visualizzare semplicemente un flusso di caratteri, deve interpretare delle sequenze particolari come la richiesta di utilizzare un colore particolare, di disegnare un bordo,...
Così, la tastiera non serve solo per scrivere lettere, numeri, punteggiatura e terminare le righe con un ritorno a carrello. Adesso occorre utilizzare anche i tasti che spostano il cursore, occorre assegnare funzionalità particolari a tasti che permettono la modifica del testo e a tasti funzionali programmabili.
Nella storia dell'informatica sono esistiti una quantità enorme di tipi diversi di terminali, intesi come complesso tastiera+schermo, e ognuno con piccole differenze rispetto agli altri. Per fare in modo che i programmi che richiedono funzionalità superiori a quelle di una normale telescrivente possano adattarsi ai vari tipi di terminale, viene utilizzato un sistema di configurazione predefinito contenente tutte le informazioni necessarie.
Di questo sistema di configurazione ne esistono due tipi: Termcap e Terminfo. Il primo è il più antico ed è ormai obsoleto, ma viene mantenuto per motivi storici e probabilmente per assicurare la compatibilità con i programmi più vecchi.
Il sistema Termcap è formato soltanto da un file di testo collocato nella directory /usr/share/misc/ (/usr/share/misc/termcap), e il suo contenuto assomiglia vagamente a quello del file /etc/printcap (il file di definizione delle stampanti).
Il sistema Terminfo è invece qualcosa di più complesso. È costituito da tanti file, uno per ogni tipo di terminale, distribuiti su una serie di directory. Il punto di partenza di questa struttura dovrebbe essere la directory /usr/share/terminfo/, ma se la propria distribuzione GNU/Linux non è organizzata perfettamente, potrebbe trovarsi in /usr/lib/terminfo/. Se ci si trova in difficoltà potrebbe essere conveniente la creazione di un collegamento simbolico che renda validi entrambi i percorsi.
A partire da terminfo/ si diramano una serie di directory composte da un solo carattere, corrispondente all'iniziale dei nomi di terminale che contengono. Il listato seguente, mostra solo un estratto minimo di questa struttura.
terminfo |-- 1 |-- 2 |-- 3 ... |-- a | `-- ansi |-- b |-- c ... |-- l | `-- linux ... |-- v | |-- vt100 | `-- vt220 ... |-- x | `-- xterm ... |
Se la definizione di un tipo di terminale può essere adatta a diversi nomi, si utilizzano normalmente dei collegamenti simbolici.
I file di definizione del sistema Terminfo sono il risultato di una compilazione attraverso il programma tic.
La directory /usr/share/terminfo/, oppure /usr/lib/terminfo/, è il punto di partenza predefinito per il sistema Terminfo, ma questo può essere alterato utilizzando la variabile di ambiente TERMINFO, per indicare una directory differente. Volendo è possibile personalizzare il sistema Terminfo creando una struttura analoga a partire da ~/.terminfo/, cioè dalla directory .terminfo/ nella propria directory personale.
La variabile di ambiente TERM è il mezzo attraverso cui si definisce il tipo di terminale che si utilizza. Normalmente viene impostata automaticamente nel modo più opportuno, con il nome di terminale la cui configurazione deve essere letta da Termcap o da Terminfo.
Quando è impostata in modo errato, si possono presentare due situazioni: il nome del terminale non è previsto, oppure il terminale che si utilizza effettivamente non è compatibile con la definizione contenuta in questa variabile. Nel primo caso, quando si avvia un programma che richiede l'utilizzo di tutto lo schermo, viene segnalato l'errore e, a seconda dei casi, il programma si avvia ugualmente facendo riferimento a un terminale elementare, oppure si rifiuta semplicemente di funzionare.
Unknown terminal: pippo Check the TERM environment variable. Also make sure that the terminal is defined in the terminfo database. |
Nel secondo caso, il terminale ha invece un comportamento insolito, per diversi aspetti: si possono notare simboli strani sullo schermo, la tastiera potrebbe non rispondere nel modo consueto, lo schermo potrebbe essere ridisegnato solo parzialmente,...
A questo punto dovrebbe essere chiaro che sia la tastiera che lo schermo funzionano in maniera differente a seconda dell'apparecchiatura fisica a disposizione e del tipo di configurazione a cui si fa riferimento per il terminale. Per esempio, il fatto che su una tastiera sia presente il tasto [Canc], non vuol dire necessariamente che poi questo darà i risultati che ci si aspetta: la sua pressione potrebbe non avere alcun effetto, oppure potrebbe dare un risultato diverso da ciò che ci si aspetta.
Dipende dal nome scelto nel sistema di configurazione dei terminali se questo è in grado di gestire il segnale generato dal tasto [Canc] della propria tastiera e se il significato che a questo viene attribuito corrisponde alle aspettative.
Volendo fare un esempio più concreto e anche piuttosto comune, si può provare a confrontare il funzionamento del programma mc (Midnight Commander), utilizzando la definizione di un terminale differente dal solito, per esempio ansi.
-mono
$ TERM=ansi-mono
$ export TERM
Si osserverà, prima di tutto, che mancano i colori, che alcune bordature non sono corrette, che i tasti funzionali non danno più l'effetto desiderato. *1*
Alle volte ci si trova veramente davanti a terminali che non possono offrire più di tanto, magari perché si sta operando da attraverso connessione remota con un programma che è in grado di emulare solo alcuni vecchi tipi di terminale.
Allora entrano in gioco due elementi:
le alternative offerte dal programma, per cui una stessa cosa può essere ottenuta in modi differenti, per poter essere utilizzato anche in presenza di terminali con poche potenzialità;
l'abilità dell'utente di adattarsi alle diverse situazioni.
L'esempio tipico di questo genere di programmi è dato dalle interpretazioni recenti di VI. Quasi tutti questi programmi sono in grado di gestire i tasti freccia, [Ins] e [Canc]. Ma quando questi non sono disponibili, si può ritornare all'uso tradizionale con i comandi h, j, k e l, per spostare il cursore, i e x per inziare l'inserimento e per cancellare.
Ciò significa che, quando si studia un nuovo programma, non si devono disdegnare i comandi apparentemente antiquati, perché sono quelli che poi permettono di «tirarsi fuori dai guai».
Esistono due situazioni in cui si può avere la necessità di ripulire lo schermo: quando si scrive uno script e si vuole ripulire tutto per mostrare un messaggio all'inizio dello schermo, e quando lo schermo sembra impazzito.
Per questo si utilizzano due programmi: clear e reset. Questi, in realtà, si avvalgono di un terzo che ha funzioni più generali: tput.
clear |
clear chiama tput con l'argomento clear, allo scopo di ripulire lo schermo e ricominciare dalla prima posizione in alto dello schermo.
reset |
reset chiama tput con una serie di argomenti volti a reinizializzare il terminale. È particolarmente utile l'uso di questo programma quando sullo schermo non appaiono più delle lettere normali. In tal caso, si può scrivere reset e premere [Invio] alla cieca. Di solito funziona.
Se si vuole sperimentare questa situazione, basta fare un cat di un file binario, per esempio un programma qualunque, per non potere più leggere quello che si scrive.
In ogni caso, questi programmi, avvalendosi di tput, funzionano solo in base a quanto conosciuto per mezzo di Terminfo o Termcap. Se la variabile TERM non contiene il nome corretto, oppure se questo non è presente nel sistema di configurazione dei terminali, a nulla serve un reset.
Vedere: tput(1), clear(1) e reset(1).
Il sistema Terminfo permette di conoscere le stringhe (i comandi) corrispondenti a determinate azioni per il terminale che si utilizza. Attraverso il programma setterm si può impostare in qualche modo il proprio terminale utilizzando implicitamente tali comandi. La documentazione di setterm, setterm(1), è stringatissima e quindi insufficiente a comprendere bene tutte le possibilità che si avrebbero a disposizione. Tuttavia si tratta di una tipo di intervento sulla gestione del terminale di importanza marginale, e quindi non vale la pena di preoccuparsene tanto.
setterm <opzione> |
Anche se si può utilizzare una sola opzione per volta, quelle disponibili sono molte, e qui ne vengono descritte solo alcune, tanto da mostrare il senso di questo programma di utilità.
|
Attiva o disattiva la ripetizione automatica del tasto premuto a lungo. Se non viene specificato l'argomento, si intende attivare l'opzione implicitamente.
|
Permette di modificare il colore di primo piano.
|
Permette di modificare il colore dello sfondo.
|
Attiva o disattiva l'inversione dei colori dello schermo. Se non viene specificato l'argomento, si intende attivare l'opzione implicitamente.
|
Ripulisce lo schermo.
|
Reinizializza lo schermo.
Le console virtuali, che normalmente utilizzano schermi VGA, possono essere configurate in modo da utilizzare un insieme di caratteri differente da quello standard (il famigerato CP437), e anche per permettere la visualizzazione di più righe ed eventualmente di più colonne.
Il programma migliore per questo genere di cose è SVGATextMode che permette una configurazione molto dettagliata. Di seguito viene mostrato anche il funzionamento elementare di setfont.
setfont [<opzioni>] <file-di-configurazione> |
setfont permette di modificare l'aspetto dei caratteri che vengono visualizzati su uno schermo EGA/VGA delle console virtuali. È molto importante questo programma quando si decide di utilizzare un insieme di caratteri esteso, come ISO 8859-1, per poter visualizzare caratteri come le lettere accentate maiuscole, che non fanno parte della codifica standard di un'interfaccia video a caratteri tipica.
Per ottenere il risultato, setfont si avvale di file di definizione dei caratteri, collocati nella directory /usr/lib/kbd/consolefonts/.
L'esempio seguente serve a ottenere la visualizzazione di caratteri dell'insieme ISO 8859-1 (Unicode), in uno schermo composto da 25 righe.
$ setfont /usr/lib/kbd/consolefonts/lat1u-16.psf
Eventualmente, se la dimensione dei caratteri non è quella desiderata, si possono provare altri file della famiglia lat1u-*.psf.
Vedere setfont(8).
SVGATextMode [<opzioni>] [<Voce-di-configurazione>] |
SVGATextMode permette di scegliere un insieme di caratteri video differenti da quelli standard e di ridimensionare lo schermo, in modo da consentire la visualizzazione di più righe e colonne.
SVGATextMode, per funzionare, non richiede il riavvio del sistema, interviene su tutte le console virtuali, però può entrare in conflitto con altri programmi che accedono direttamente alla gestione della scheda video VGA. Sotto questo aspetto, sarebbe bene limitare l'uso di questo programma ai sistemi su cui non si fanno girare programmi che richiedono la grafica o che emulano altri sistemi operativi.
È necessaria la configurazione con il file /etc/TextConfig, piuttosto complesso. Generalmente, questo viene fornito già pronto per essere utilizzato con una scheda video VGA standard, con un insieme di caratteri ISO 8859-1 normale.
Questa configurazione potrebbe andare bene, se non fosse che la codifica scelta non permette la visualizzazione dei caratteri pseudo-grafici utilizzati per le cornici nei programmi a tutto schermo come Midnight Commander (mc). Sarebbe il caso di modificare il file di configurazione in modo che contenga le righe seguenti, in pratica ritoccando quelle corrispondenti della configurazione originale.
Option "LoadFont" FontProg "/usr/bin/setfont" FontPath "/usr/lib/kbd/consolefonts" FontSelect "lat1u-16.psf" 8x16 9x16 8x15 9x15 FontSelect "lat1u-14.psf" 8x14 9x14 8x13 9x13 FontSelect "lat1u-12.psf" 8x12 9x12 8x11 9x11 FontSelect "lat1u-08.psf" 8x8 9x8 8x7 9x7 |
Più avanti, nello stesso file di configurazione sono elencate le varie risoluzioni video a cui si può fare riferimento quando si vuole utilizzare SVGATextMode.
"80x25x8" 25.2 640 680 776 800 400 412 414 449 font 8x16 "80x25x9" 28.3 640 680 776 800 400 412 414 449 font 9x16 "80x28x8" 25.2 640 680 776 800 392 412 414 449 font 8x14 "80x28x9" 28.3 640 680 776 800 392 412 414 449 font 9x14 "80x29x8" 25.2 640 680 776 800 464 490 492 525 font 8x16 "80x29x9" 28.3 640 680 776 800 464 490 492 525 font 9x16 "80x30x8" 25.2 640 680 776 800 480 490 492 525 font 8x16 "80x30x9" 28.3 640 680 776 800 480 490 492 525 font 9x16 |
In base a quanto mostrato, si può tentare di visualizzare una schermata di 80 caratteri per 30 righe, con il comando seguente:
# SVGATextMode 80x30x8
In generale, non è conveniente modificare la definizione delle risoluzioni disponibili; tuttavia, per approfondire il significato delle righe che compongono l'esempio di configurazione mostrato poco sopra, occorre conoscere in che modo si configura XFree86, in particolare la sezione Monitor, come descritto nel capitolo
68.
Vedere SVGATextMode(8) e TextConfig(5).
Il mouse, in un terminale a caratteri, non è una cosa tanto comune. È normale in un ambiente grafico, ma nel caso di GNU/Linux c'è la possibilità di usarlo anche nelle console virtuali. Per gestire un mouse in questa situazione è necessario un demone che si occupi di seguirlo e di fornire ai programmi le informazioni sulle azioni del mouse stesso. Si tratta in pratica di un server per la gestione del mouse. Trattandosi di un server, i programmi con cui si può interagire con il mouse sono dei client e dipendono dal server per il tipo di comunicazione che tra loro deve instaurarsi.
Il server utilizzato normalmente per GNU/Linux è il demone gpm, il quale ha in particolare il vantaggio di poter essere utilizzato anche con i programmi che non sono fatti per il mouse, per le operazioni di copia-incolla del testo.
In alcune situazioni, la gestione del mouse può diventare conflittuale, per esempio quando si utilizza un cosiddetto bus-mouse. In questa situazione non è possibile avere più programmi che leggono contemporaneamente il dispositivo corrispondente al mouse, e questo significa in pratica che non ci può essere in funzione il demone gpm assieme al sistema grafico X, e nemmeno che possano essere messi in funzione più sistemi grafici contemporaneamente. Il demone gpm è in grado di risolvere il problema occupandosi da solo del mouse e passando a tutte le altre applicazioni eventuali le informazioni sulle azioni compiute con il mouse stesso.
Per convenzione, il file /dev/mouse dovrebbe corrispondere al dispositivo del mouse. In pratica, si crea un collegamento simbolico con questo nome che punta al dispositivo corrispondente al mouse utilizzato effettivamente. Di solito è lo stesso programma di installazione delle distribuzioni GNU/Linux a farlo.
Nel caso particolare dei mouse seriali, cioè di quelli connessi a una porta seriale, venivano usati in passato i dispositivi /dev/cua*. Attualmente, questi sono diventati obsoleti, e al loro posto si fa riferimento ai corrispondenti /dev/ttyS*.
Quando la lettura di questo dispositivo può essere solo esclusiva, a causa della sua natura, per evitare conflitti tra i programmi nel modo descritto in precedenza, si può creare il file FIFO /dev/gpmdata. Questo viene gestito dal demone gpm allo scopo di fornire a tutti gli altri programmi che accedono direttamente al mouse le informazioni sulle azioni compiute con lo stesso.
# mknod /dev/gpmdata p
Il comando appena mostrato è ciò che serve per creare questo file nel caso non sia già disponibile. Per fare in modo che gpm gestisca questo file e di conseguenza si occupi del mouse in qualunque situazione, deve essere utilizzata l'opzione -R/etc/X11/XF86Config) nella sezione Pointer, come si vede nell'esempio seguente:
# Pointer section
Section "Pointer"
Protocol "MouseSystems"
Device "/dev/gpmdata"
|
In pratica, per il sistema grafico X, e per qualunque altro programma che dovesse accedere al dispositivo del mouse direttamente, si deve fare riferimento al tipo di mouse MouseSystems, utilizzando il file di dispositivo /dev/gpmdata.
gpm [<opzioni>] |
gpm è un programma demone in grado di permettere operazioni di copia-incolla con i programmi normali e di fornire, a quelli predisposti, l'accesso a tutte le funzionalità del mouse. Può essere messa in funzione una sola copia del programma alla volta, e di conseguenza è normale che gpm venga avviato una volta per tutte attraverso la procedura di inizializzazione del sistema.
A meno di fare uso di opzioni particolari, gpm si aspetta di trovare il collegamento /dev/mouse che punti al dispositivo corrispondente al mouse effettivamente a disposizione.
|
Se |
|
Con questa opzione è possibile definire la disposizione dei tasti. Per esempio, gpm indica di utilizzare i tasti nella posizione normale: il primo è quello a sinistra, il secondo è quello centrale e il terzo è quello a destra. Nello stesso modo si può indicare una disposizione inversa per facilitare un utente mancino (321).
-B 123
|
Permette di indicare un file di dispositivo diverso dal solito /dev/mouse.
|
Abilita la gestione del file FIFO /dev/gpmdata allo scopo di fornire ad altre applicazioni che accedono direttamente al mouse le informazioni sulle sue azioni.
|
Permette di indicare il tipo di mouse a disposizione. Quando non si specifica questa opzione, il tipo predefinito è ms, corrispondente a un mouse Microsoft con 2 o 3 tasti.
| Tipo | Sinonimo | Descrizione |
| mman | Mouseman | Mouseman. |
| ms | Microsoft a due o tre tasti e compatibili (predefinito). | |
| bare | Microsoft | Microsoft a due tasti. |
| msc | MouseSystems | SystemMouse, tre tasti. |
| sun | Variante del SystemMouse. | |
| mm | MMSeries | |
| logi | Logitech | Alcuni mouse seriali Logitech. |
| ligim | LogiMouse | Mouse Logitech che devono funzionare come mouse Msc. |
| bm | BusMouse | Busmouse Microsoft e compatibili. |
| ps2 | PS/2 | Busmouse PS/2. |
| ncr | NCR3125pen. | |
| wacom | Tavoletta Wacom. | |
| pnp | Microsoft pnp. | |
| ms3 | Mouse seriali IntelliMouse a tre tasti. |
-t
|
Forza un funzionamento a due tasti. In questo modo il primo tasto serve a evidenziare e l'altro a incollare.
|
Forza un funzionamento a tre tasti. In questo modo il primo tasto serve a evidenziare, il secondo a incollare, e il terzo a estendere la zona evidenziata. Questo è il funzionamento predefinito, perché il secondo tasto viene attivato solo a partire dal momento in cui questo viene premuto. Perciò, normalmente, non occorre preoccuparsi di indicare quanti tasti utilizzare.
|
Permette di definire dei comandi da eseguire in corrispondenza di un triplo clic sul primo e sul terzo tasto.
Il funzionamento è relativamente semplice. Quando il mouse è riconosciuto dal programma che si sta utilizzando, dipende da questo il modo di gestire e interpretare le azioni compiute con il mouse. Quando il programma non è in grado di controllare il mouse, è possibile utilizzare il supporto alle operazioni di copia-incolla.
Si seleziona una zona dello schermo premendo il primo stato e trascinando fino alla posizione finale. Per incollare si può cambiare console virtuale, per raggiungere l'applicazione all'interno della quale incollare il testo, quindi si preme il secondo tasto, o in mancanza il terzo. Il testo viene inserito come se fosse digitato, quindi occorre che il programma lo permetta.
Il terzo tasto, quando non dovesse servire per incollare, permette di estendere una selezione già iniziata e non completata.
L'opzione -S:), da eseguire in occasione di un triplo clic con in tasti 1 e 3. In pratica, si tiene premuto il primo o il terzo tasto, e con l'altro (il terzo o il primo rispettivamente) si esegue un triplo clic in rapida successione. Se entro tre secondi dal rilascio dei tasti viene premuto uno dei tre tasti, viene eseguito uno dei comandi indicati nell'argomento di questa opzione.
Per esempio, se si utilizza l'opzione -S "echo ciao:echo hello:echo bye"echo ciao, cioè viene visualizzata la parola ciao. Se invece alla fine si seleziona il secondo tasto, si ottiene la parola hello. Infine, se si trattava del terzo tasto, si ottiene bye.
Questo sistema potrebbe essere particolarmente utile per definire un comando per il riavvio del sistema, quando per qualche motivo non si può usare la tastiera per farlo e non si rendono disponibili altre alternative.
# gpm -t ps2
Avvia gpm predisponendolo per utilizzare un mouse PS/2.
# gpm -R -t ps2
Avvia gpm predisponendolo per utilizzare un mouse PS/2, abilitando la gestione del file /dev/gpmdata. Il sistema grafico X, o altri programmi che dovessero accedere direttamente al dispositivo del mouse dovrebbero essere istruiti a utilizzare il dispositivo /dev/gpmdata, corrispondente a un mouse MouseSystems.
# gpm -S "shutdown -h now:shutdown -r now:init 0"
Avvia gpm definendo i comandi speciali da eseguire in caso di un triplo clic. Se dopo il triplo clic si preme il primo tasto, si conclude l'attività del sistema; se si preme il secondo, si riavvia; se si preme il terzo, si conclude l'attività, ma attraverso una chiamata diretta all'eseguibile init.
Si è accennato al fatto che il demone gpm venga avviato normalmente dalla procedura di inizializzazione del sistema, nel modo già stabilito dalla stessa distribuzione GNU/Linux che si utilizza. Se si vogliono gestire funzionalità speciali di gpm, come per esempio il file FIFO /dev/gpmdata, cosa che si ottiene con l'opzione -R
Alcune distribuzioni, come Red Hat, prevedono un file di configurazione (in questo caso si tratta di /etc/sysconfig/mouse) contenente l'assegnamento di variabili di ambiente che poi vengono incorporate e utilizzate nello script di avvio del servizio gpm. Tuttavia potrebbe non essere stata prevista la possibilità di aggiungere delle opzioni ulteriori, e in tal caso si deve intervenire direttamente nello script.
Nel caso della distribuzione Red Hat, lo script che serve ad avviare e a fermare il servizio gpm è /etc/rc.d/init.d/gpm, in altre potrebbe trovarsi nella directory /etc/init.d/ e chiamarsi nello stesso modo o avere un nome leggermente diverso.
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*.
script [
|
script è un programma che permette di registrare la sessione di lavoro svolta attraverso un terminale a caratteri. Si avvia il programma, e questo 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.
L'opzione -a
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; 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
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, e 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 le informazioni provenienti da un file per le registrazioni del sistema (log).
# tail -f /var/log/messages > /dev/tty10 &
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 fosse disponibile).
open [<opzioni>] [ |
open permette di avviare un comando in una nuova console virtuale (non utilizzata precedentemente). Per non confondere il comando dalle opzioni di open si utilizza un doppio trattino (--
|
Questa opzione permette di definire esplicitamente quale console virtuale utilizzare attraverso l'argomento che indica il numero di questa (le console virtuali sono numerate a partire da 1).
|
Fa in modo che il comando venga trattato come se fosse una «shell di login», cioè una shell avviata dalla procedura di accesso (dopo che l'autenticazione dell'utente è avvenuta con successo). Questo comporta l'aggiunta di un trattino (-
|
Segna la fine delle opzioni di open e l'inizio del comando. È necessario l'uso di questo doppio trattino quando il comando da eseguire ha, a sua volta, degli argomenti.
# open bash
Avvia bash nella prima console virtuale libera.
# open -l bash
Avvia bash nella prima console virtuale libera, trattando il processo relativo come una shell di login.
# open -c 10 -l bash
Come nell'esempio precedente, utilizzando espressamente la decima console virtuale.
# open -- ls -l
Esegue il comando ls utilizzando la prima console virtuale libera. In questo caso, dovendo indicare un comando con argomenti, si è dovuto utilizzare il doppio trattino per segnalare l'inizio del comando stesso.
-l
switchto n |
switchto è un programma molto semplice il cui unico scopo è quello di selezionare una particolare console virtuale. Può essere utile in uno script.
# switchto 11
Passa nell'undicesima console virtuale.
È 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, 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 è un programma (in pratica si tratta dell'eseguibile screen) 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 unico 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, e non sono 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
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. Questi corrispondono ai dispositivi secondo il modello /dev/tty[a-e][0-9a-f]; in pratica si tratta di una lettera da a a e, seguita da una cifra esadecimale (i numeri da 0 a 9 e le lettere da a a f).
Per poter funzionare, Screen deve creare una pipe con nome, ovvero un file FIFO, 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 era 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 quest'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>.<host> |
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 HUNGUP (aggancio), 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, e 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 [<opzioni>] [<comando> [<argomenti-del-comando>]] |
screen è il programma binario di 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 questa politica.
screen può essere avviato per iniziare una sessione di lavoro attraverso cui gestire delle applicazioni contenute in finestre differenti, oppure per altre funzionalità che verranno 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.
|
Permette di specificare un file di configurazione alternativo a quello predefinito.
|
Permette di indicare una shell alternativa a quella contenuta nella variabile di ambiente SHELL, che viene utilizzata ogni volta che si apre una nuova finestra senza specificare il programma che deve essere avviato al suo interno.
|
Permette di dare un nome a una sessione. A questo nome viene comunque aggiunto il numero PID anteriormente. Lo scopo è quello di rendere più semplice l'identificazione di una sessione.
|
Questa opzione va usata da sola: non avvia alcuna nuova sessione e si limita a elencare quelle già aperte dall'utente che ne sta facendo richiesta. Attraverso questo elenco si possono individuare facilmente quali siano le sessioni distaccate, cioè quelle che possono essere riprese utilizzando l'opzione -r
|
|
Permette di distaccare una sessione di Screen da un terminale fisico, senza interrompere il funzionamento degli applicativi avviati al suo interno. Si può usare questa opzione assieme a -r
|
|
Permette di riattaccare sul terminale in funzione attualmente, una sessione staccata in precedenza. Se non si indica la sessione, viene avviata la prima di quelle che risultano distaccate; se in particolare si utilizza -R-d-D-d-r
|
Questa opzione permette di accedere a una sessione già aperta e funzionante presso un altro terminale fisico. Se non viene specificata la sessione, viene aperta la prima che può essere trovata. Quando si condivide una sessione tra più terminali fisici, ogni terminale può accedere solo alle finestre che non sono attive da qualche parte.
$ screen
Avvia una sessione di Screen sul terminale da cui si esegue il comando, aprendo la shell predefinita nella prima finestra.
$ screen mc
Avvia una sessione di Screen sul terminale da cui si esegue il comando, avviando il programma mc, senza argomenti, nella prima finestra.
$ screen -ls
Elenca le sessioni aperte dall'utente.
$ screen -d tty2
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
Distacca la prima sessione attiva appartenente dell'utente stesso.
$ screen -r tty2
Attacca, sul terminale da cui si dà il comando, la sessione che in origine era stata avviata sul terminale /dev/tty2 e successivamente distaccata.
$ screen -r
Attacca la prima sessione libera che trova.
$ screen -d -r tty2
Distacca la sessione in funzione sul terminale identificato dal dispositivo /dev/tty2, riattaccandola sul terminale da cui si dà il comando.
$ screen -d -r
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 32.4 vengono elencate solo alcune di queste sequenze; per un elenco completo occorre leggere la documentazione originale: screen(1).
| Sequenza | Effetto |
| Ctrl+a ? | Mostra una guida rapida ai comandi disponibili. |
| Ctrl+a a | Invia la combinazione [Ctrl+a] all'applicazione attiva. |
| Ctrl+a n | Seleziona l'n-esima finestra. La prima ha il numero 0. |
| Ctrl+a n | Passa alla finestra successiva. |
| Ctrl+a p | Passa alla finestra precedente. |
| Ctrl+a c | Crea una nuova finestra. |
| Ctrl+a d | Distacca la sessione dal terminale fisico. |
| Ctrl+a w | Mostra un breve riepilogo delle finestre esistenti. |
| Ctrl+a Esc | Inizia la modalità di scorrimento e copia all'indietro. |
| Ctrl+a ] | Incolla il testo inserito precedentemente nella memoria tampone. |
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. 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.
---------------------------
Appunti Linux 1999.09.21 --- Copyright © 1997-1999 Daniele Giacomini -- daniele @ pluto.linux.it
1.) Per terminare l'utilizzo di mc si può scrivere semplicemente il comando exit seguito da [Invio].