<< Back to man.lupaworld.com

[ precedente ] [ Contenuti ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ 10 ] [ 11 ] [ 12 ] [ 13 ] [ 14 ] [ 15 ] [ A ] [ successivo ]

La guida Debian
Capitolo 4 - Lezioni di Debian

Questa sezione fornisce delle coordinate di base per orientarsi nel mondo Debian, mirate all'utente inesperto. Se è un pò di tempo che utilizzate un sistema Unix-like, probabilmente saprete già tutto di quello che verrà spiegato qui. In tal caso, usatela come ripasso.

4.1 Per iniziare

Dopo aver installato Debian sul vostro PC, dovete imparare alcune cose per renderlo utile. Partiamo a tambur battente con le lezioni.

4.1.1 Login come root al prompt dei comandi

Dopo il reboot vi si presenterà o la schermata grafica di accesso al sistema, oppure quella a carattere, a seconda della vostra selezione iniziale dei pacchetti. Per semplicità, se avete davanti la schermata grafica, premete Ctrl-Alt-F1 [3] per accedere alla schermata di accesso a carattere.

Supponiamo che il vostro hostname sia foo, il prompt del login sarà così: 

     foo login:

Digitate root , premete il tasto Enter e digitate la password scelta durante il processo di installazione. In Debian,come da tradizione del mondo Unix, la password è dipendente anche dal maiuscolo/minuscolo. Dopo di ciò, il sistema parte con il messaggio di benvenuto e vi presenta il prompt dei comandi di root in attesa di un vostro comando. [4] 

     foo login: root
     Password: 
     Last login: Sun Oct 26 19:04:09 2003 on tty3
     Linux foo 2.4.22-1-686 #6 Sat Oct 4 14:09:08 EST 2003 i686 GNU/Linux
     
     Most of the programs included with the Debian GNU/Linux system are
     freely redistributable; the exact distribution terms for each program
     are described in the individual file in /usr/share/doc/*/copyright
     
     Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
     permitted by applicable law.
     
     root@foo:root#

A questo punto siete pronti per amministrare il sistema dal prompt dei comandi di root. L'account root è anche chiamato utente privilegiato o superuser. Tramite questo account potete fare qualsiasi cosa:

E' un'idea veramente pessima condividere l'accesso all'account di root condividendone la password. Il modo giusto di condividere i privilegi dell'amministratore è mediante l'uso di programmi come sudo(8).

Notate che è considerata una buona abitudine in ambito Unix accedere prima ad un account senza privilegi, anche quando si pensa di eseguire delle attività di amministrazione di sistema. Utilizzate i comandi sudo, super, o su -c per guadagnare dei privilegi di root limitati quando ne avete necessità. Vedere sudo – lavorare con maggiore sicurezza, Sezione 9.2.4. [5]

4.1.2 Impostare un ambiente minimale per il novizio

Credo che imparare ad usare un sistema operativo sia come imparare una nuova lingua. Sebbene le guide siano utili, uno deve fare pratica con strumenti che lo possano aiutare. In questo contesto, credo sia una buona idea installare alcuni pacchetti aggiuntivi, tipo mc, vim, lynx, doc-linux-text e debian-policy. [6] 

     # apt-get update
      ...
     # apt-get install mc vim lynx doc-linux-text debian-policy 
      ...

Se avete questi pacchetti già installati, non accadrà nulla.

4.1.3 Aggiungere un account utente

Durante l'installazione avrete creato un account utente senza privilegi, che utilizzerete per ricevere le mail inviate all'account di root. [7] Dato che non volete usare questo account speciale per le esercitazioni che andrete a fare, dovrete creare un nuovo account utente.

Supponiamo che vogliate come username penguin, digitate: 

     root@foo:root# adduser penguin
     ... rispondete a tutte le domande

eccolo creato. [8] Prima di andare avanti, impariamo alcune cose.

4.1.4 Muoversi tra le console virtuali

In un sistema Debian standard esistono 6 pseudo-terminali disponibili, cioè potete usare lo schermo a carattere VGA del PC come 6 terminali VT-100 intercambiabili. Potete passare da uno all'altro premendo simultaneamente i tasti Alt-sinistro ed uno dei tasti F1–F6. Ciascun (pseudo)terminale permette i login indipendenti agli account. L'ambiente multiutente è una grande ed avvincente caratteristica di Unix.

Se premete accidentalmente Alt-F7 su un sistema con X Window System e lo schermo mostra l'interfaccia grafica di login, potete riguadagnare l'accesso all'interfaccia a carattere premendo Ctrl-Alt-F1. Per abituarvi, provate a muovervi tra le varie console e a tornare indietro su quella di partenza.

4.1.5 Lo spegnimento del PC

Come qualsiasi moderno sistema operativo, in cui i file vengono tenuti in memoria, il sistema Debian una procedura di arresto appropriata, prima che l'interruttore possa essere spento con sicurezza, per mantenere l'integrità dei file. Date il seguente comando dal prompt di root per spegnere il sistema: 

     # shutdown -h now

Questo è per la normale modalità multiutente. In modalità singolo utente, sempre da prompt di root, è invece: 

     # poweroff -i -f

In alternativa, potete premere Ctrl-Alt-Delete (o Ctrl-Alt-Canc per la tastiera italiana) per spegnere. [9]

Attendete finchè non appare la scritta "System halted", poi spegnete il computer. Se le funzioni APM o ACPI sono state attivate dal BIOS e su Linux, il sistema si spegnerà da solo. Per i dettagli, vedere Grosse memorie e spegnimento automatico, Sezione 3.7.4.

4.1.6 E' tempo di giocare

Ora siete pronti per giocare con Debian senza rischi, finchè utilizzate l'account utente senza privilegi penguin. [10]

Accediamo come penguin. Se eravate al prompt di root, premete Ctrl-D [11] per chiudere l'attività della shell di root e tornare al prompt del login. Inserite lo username appena creato penguin e la password corrispondente. [12] Vi si presenterà il seguente prompt dei comandi. 

     penguin@foo:penguin$

Da ora in poi l'esempio utilizzerà dei prompt semplificati per maggiore chiarezza. Userò:

Cominceremo ad imparare il sistema Debian nel modo più facile Midnight commander (MC), Sezione 4.2 e poi in quello più giusto Ambiente di lavoro Unix-like, Sezione 4.3.

4.2 Midnight commander (MC)

Midnight commander (MC) può essere considerato come uno di quei coltellini svizzeri multiuso, per la console Linux ed altri terminali. Ciò offre al novizio un'esperienza con una console con menu, molto più semplice per imparare i comandi Unix standard.

Usate questo comando per esplorare il sistema Debian. E' il modo migliore per imparare. Esplorate alcune locazioni chiave usando solo i tasti cursore ed il tasto Enter:

4.2.1 Migliorare MC

Per far cambiare ad MC la directory di lavoro in uscita, dovete modificare ~/.bashrc (o /etc/bash.bashrc, chiamato da .bashrc), come spiegato nella sua pagina di manuale, mc(1), sotto l'opzione -P. [13]

4.2.2 Lanciare MC

     $ mc

MC si prende cura di tutte le operazioni sui file tramite il proprio menu, richiedendo il minimo sforzo da parte dell'utente. Basta premere F1 per accedere alla schermata di aiuto. Potete giocare con MC premendo i tasti cursore ed i tasti funzione. [14]

4.2.3 Il file manager in MC

Come default vengono presentate due finestre affiancate che mostrano la lista di file contenuti nelle directory correnti. Un'altra modalità utile è impostare la finestra di destra ad "informazioni", per avere tute le informazioni su file, tipo privilegi di accesso, ecc. A seguire si riportano i tasti fondamentali. Se il demone gpm sta girando, potete usare anche il mouse. (Ricordatevi di premere il tasto maiscolo per avere il normale comportamento sotto MC per taglia ed incolla).

4.2.4 Trucchi per la riga di comando in MC

4.2.5 L'editor in MC

L'editor interno ha un sistema di taglia ed incolla interessante. Premendo F3 si marca l'inizio della selezione, un secondo F3 ne segna la fine e la evidenzia. Muovete ora il cursore. Premendo F6 l'area selezionata viene mossa dove è il cursore. Con F5 l'area verrà copiata dove è il cursore. F2 salva il file, F10 esce. Gran parte dei tasti cursori ha un funzionamento intuitivo.

Questo editor può essere lanciato direttamente per un determinato file: 

     $ mc -e file_da_modificare
     $ mcedit file_da_modificare

Non è un editor multifinestra, si può ottenere lo stesso effetto utilizzando più console. Per copiare da una finestra all'altra, usate la combinazione Alt-Fn per passare da una console ad un'altra e"File->Insert file" o "File->Copy to file" per muovere parti di un file in un altro.

L'editor interno può essere sostituito da qualsiasi editor esterno preferiate.

Molti programmi usano variabili d'ambiente tipo EDITOR o VISUAL per decidere quale editor usare. Se vi trovate male con vim, impostatele a mcedit aggiungendo queste righe a ~/.bashrc: 

     ...
     export EDITOR=mcedit
     export VISUAL=mcedit
     ...

Raccomando comunque di impostarle a vim, se possibile. Abituarsi ai comandi di vim sarebbe la cosa giusta da fare, dato che gli editor-Vi sono una costante nel mondo Linux/Unix. [15]

4.2.6 Il visualizzatore in MC

Molto valido. E' uno strumento notevole per la ricerca di parole nei documenti. Lo uso sempre per i file nella directory /usr/share/doc. Rappresenta uno dei modi più rapidi di girare tra la massa di informazioni su Linux. Può essere lanciato direttamente con: 

     $ mc -v file_da_vedere

4.2.7 Le caratteristiche di lancio automatico di MC

Premete Invio su un file, ed il programma appropriato si prenderà cura del suo contenuto. E' una caratteristica di MC molto utile. 

     eseguibile:        Esegue il comando
     file man, html:    Dirotta il contenuto al viewer corrispondente
     file tar.gz, deb:  Sfoglia il contenuto come fosse una sottodirectory

Per permettere a queste utilità di svolgere il loro compito, i file da leggere non devono essere segnati come eseguibili. Cambiatene lo stato tramite il comando chmod, oppure attraverso il menu file di MC.

4.2.8 Il fileystem FTP virtuale di MC

MC può essere utilizzato per accedere a file tramite Internet, usando FTP. Attivate il menu premendo F9, poi attivate il file system virtuale FTP premendo `p'. Inserite una URL sotto forma di username:passwd@nomehost.nomedomain, che raggiungerà una directory remota che apparirà come una locale.

Provate http.us.debian.org/debian come URL e scorrete l'archivio dei file Debian. Vedere Gli archivi Debian, Sezione 2.1 per come sono organizzati.

4.3 Ambiente di lavoro Unix-like

Nonostante MC vi permetta di fare qualsiasi cosa, è bene che impariate come usare gli strumenti da riga di comando invocati dal prompt della shell e che familiarizziate con l'ambiente di lavoro Unix-like. [16]

4.3.1 Combinazioni speciali di tasti

Nell'ambiente Unix-like, esistono alcune combinazioni di tasti che hanno un significato particolare. [17]

la shell di default, bash, prevede l'editing della cronologia ed il completamento mediante il tasto tab per facilitarne l'uso interattivo.

Altre combinazioni importanti da ricordare:

Per usare il mouse sotto la console a caretteri Linux, dovete avere gpm lanciato come demone. [19] Vedere Configurare il mouse, Sezione 3.3.

4.3.2 Comandi base Unix

Impariamo i comandi base Unix. [20] Provate tutti i comandi dall'account utente senza privilegi penguin :

Come esercizio, attraversate le directory e sbirciate nel sistema usando i comandi sopraelencati. Se avete dubbi sui comandi, assicuratevi di aver letto le pagine di manuale. Per esempio, un buon inizio sono questi comandi: 

     $ man man
     $ man bash
     $ man ls

Questo è anche il momento giusto per lanciare vim e premere il tasto F1. Dovreste leggere almeno le prime 35 righe. Poi fate un pò di esercizio in linea muovendo il cursore su |tutor| e premendo Ctrl-]. Vedere Gli Editor, Capitolo 11 per impararne di più sugli editor.

Notate che molti comandi Unix-like, compresi quelli provenienti da GNU e BSD, mostreranno delle brevi informazioni di aiuto se invocati in uno dei modi seguenti (o senza argomenti, in alcuni casi): 

     $ nomecomando --help
     $ nomecomando -h

Come esercizio, provate anche gli esempi in Trucchi per Debian, Capitolo 8.

4.3.3 Esecuzione dei comandi

Avete avuto un assaggio su come usare il sistema Debian. Addentriamoci ora nei meccanismi di esecuzione dei comandi. [27]

4.3.4 Il comando semplice

Un comando semplice è una sequenza di

  1. compiti della variabile (opzionale)
  2. nome comando
  3. argomenti (opzionale)
  4. redirezioni (opzionale: > , >> , < , << , etc.)
  5. operatore di controllo (opzionale: && , || ; <newline> , ; , & , ( , ) )

Per comandi più complessi, con quotazioni e sostituzioni, vedere Processamento delle righe di comando, Sezione 13.2.6.

4.3.5 Esecuzione dei comandi e variabili d'ambiente

Una tipica esecuzione di un comando usa una sequenza di shell coma la seguente: [28] 

     $ date
     Sun Oct 26 08:17:20 CET 2003
     $ LC_ALL=fr_FR date
     dim oct 26 08:17:39 CET 2003

In questo caso il programma date viene eseguito in primo piano. La variabile di ambiente LC_ALL è:

Gran parte delle esecuzioni dei comandi non sono generalmente preceduti da una definizione della variabile di ambiente. In riferimento all'esempio precedente, potete eseguire, in alternativa: 

     $ LC_ALL=fr_FR
     $ date
     dim oct 26 08:17:39 CET 2003

Come potete vedere, il risultato del comando viene influenzato dalla variabile di ambiente, che produrrà un risultato in francese. Se volete che la variabile di ambiente venga inglobata dai sottoprocessi (quando chiamate uno script della shell, per esempio), dovete "esportarla", usando: 

     $ export LC_ALL

4.3.6 Il percorso di ricerca dei comandi

Quando date un comando nella shell, essa lo cerca nella lista di directory contenuta nella variabile PATH. Il valore di PATH viene anche chiamato percorso di ricerca della shell.

In una installazione Debian di base, la variabile PATH degli account utenti può non comprendere /sbin/. Quindi, se volete lanciare un comando tipo ifconfig da /sbin/, dovete modificare PATH in maniera da includerlo. La variabile PATH viene di solito impostata dal file di inizializzazione ~/.bash_profile, vedere Configurare Bash, Sezione 3.2.

4.3.7 Opzioni della riga di comando

Alcuni comandi richiedono degli argomenti. Gli argomenti che cominciano con - o con -- vengono chiamati opzioni e controllano il comportamento del comando. 

     $ date
     Mon Oct 27 23:02:09 CET 2003
     $ date -R
     Mon, 27 Oct 2003 23:02:40 +0100

In questo caso l'argomento -R modifica il comportamento di date per dare come risultato una stringa con una data compatibile RFC-2822.

4.3.8 Metacaratteri della shell

Spesso capita che vogliate che un comando funzioni su un gruppo di file, senza digitarli tutti. Il modello di espansione dei nomi dei file che utlizza metacaratteri facilita questo compito.

Come esempio, provate da voi e ragionateci su: 

     $ mkdir junk; cd junk; touch 1.txt 2.txt 3.c 4.h .5.txt
     $ echo *.txt
     1.txt 2.txt
     $ echo *
     1.txt 2.txt 3.c 4.h
     $ echo *.[hc]
     3.c 4.h
     $ echo .*
     . .. .5.txt
     $ echo .[^.]*
     .5.txt
     $ echo [^1-3]*
     4.h
     $ cd ..; rm -rf junk

4.3.9 Restituire il valore dei comandi

Ogni comando restituisce il suo stato in uscita come valore restituito.

Si può accedere al valore restituito attraverso la variabile di shell $? subito dopo l'esecuzione. 

     $ [ 1 = 1 ] ; echo $?
     0
     $ [ 1 = 2 ] ; echo $?
     1

Notate che, quando il valore restituito viene usato nel contesto logico della shell, il successo viene trattato come il VERO in logica. Ciò è poco intuitivo, dato che successo ha valore zero.

Vedere Condizionali, Sezione 13.2.5.

4.3.10 Tipiche sequenze di comandi

Proviamo a ricordare i seguenti comandi idiomatici della shell. Vedere Parametri della shell, Sezione 13.2.3, Redirezione, Sezione 13.2.4, Condizionali, Sezione 13.2.5, e Processamento delle righe di comando, Sezione 13.2.6 dopo aver letto questi idiomi.

4.3.10.1 comando &

Il comando viene eseguito nella subshell nello sfondo. I lavori nello sfondo permettono all'utente di lanciare più programmi in una singola shell.

La gestione dei processi nello sfondo coinvolge i fondamentali della shell: jobs, fg, bg, e kill. Leggete le sezioni della pagina di manuale bash(1) sotto "SIGNALS", "JOB CONTROL", e "SHELL BUILTIN COMMANDS". [29]

4.3.10.2 comando1 | comando2

Lo standard output di comando1 viene dato allo standard input di comando2 . Entrambi i comandi possono essere eseguiti contemporaneamente. Questa si chiama pipeline.

4.3.10.3 comando1 ; comando2

comando1 e comando2 sono eseguiti in sequenza.

4.3.10.4 comando1 && comando2

comando1 viene eseguito. Se con successo, comando2 viene eseguito in sequenza. Verrà restituito un successo se sia comando1 che comando2 sono stati eseguiti con successo.

4.3.10.5 comando1 || comando2

comando1 viene eseguito. Se non con successo, allora anche comando2 viene eseguito in sequenza. Verrà restituito un successo se comando1 oppure comando2 sono stati eseguiti con successo.

4.3.10.6 comando > foo

Redireziona lo standard output di comando ad un file foo. (sovrascrive)

4.3.10.7 comando >> foo

Redireziona lo standard output di comando ad un file foo. (appende)

4.3.10.8 comando > foo 2>&1

Redireziona sia lo standard output che lo standard error di comando ad un file foo.

4.3.10.9 comando < foo

Redireziona lo standard input di comando ad un file foo. Provate: 

     $ </etc/motd pager
      ... (il saluto)
     $ pager </etc/motd
      ... (il saluto)
     $ pager /etc/motd
      ... (il saluto)
     $ cat /etc/motd | pager
      ... (il saluto)

Sebbene tutte e 4 le sintassi mostrino la stessa cosa, l'ultimo esempio lancia un comando in più, cat e spreca risorse senza motivo.

4.3.11 Alias dei comandi

Potete impostare un alias per i comandi usati più di frequente. Per esempio: 

     $ alias la='ls -la'

Da adesso in poi, la funzionerà come abbreviazione di ls -la, che elenca tutti i file in formato esteso.

Potete identificare il percorso esatto o l'identità di un comando tramite il comando type. Per esempio: 

     $ type ls
     ls is hashed (/bin/ls)
     $ type la
     la is aliased to `ls -la'
     $ type echo
     echo is a shell builtin
     $ type file
     file is /usr/bin/file

In questo caso ls è stato usato di recente, mentre file no, per cui ls è "hashed", ovvero la shell ha un registro interno per un accesso veloce alla locazione del comando ls.

4.4 Elaborazione del testo Unix-like

Esistono alcuni strumenti standard per l'elaborazione del testo, che vengono spesso utilizzati nei sistemi Unix-like.

Vedere Sostituzione delle espressioni regolari, Sezione 8.6.13, Parti di script per il piping, Sezione 8.6.18, e Brevi follie in Perl script, Sezione 8.6.20 per alcuni script di esempio.

4.4.1 Le espressioni regolari

Le espressioni regolari vengono utilizzate da molti strumenti di elaborazione del testo. Sono analoghe ai metacaratteri della shell (vedere Metacaratteri della shell, Sezione 4.3.8), ma molto più complesse e potenti.

L'espressione regolare descrive il modello corrispondente da trovare ed è fatta da caratteri di testo e da metacaratteri. Il metacarattere è semplicemente un carattere con un significato speciale. esistono due stili maggiori, BRE ed ERE, aseconda degli strumenti utilizzati, come descritto in Elaborazione del testo Unix-like, Sezione 4.4.

In ERE, i metacaratteri comprendono "\ . [ ] ^ $ * + ? ( ) { } |". L'espressione regolare significa:

In BRE i metacaratteri "+ ? ( ) { } |" perdono il loro significato speciale; al loro posto si usano le versioni con la backslash "\+ \? \( \) \{ \} \|". Perciò il costrutto (r1|r2) deve essere protetto come \(r1|r2\). Siccome emacs, sebbene sia di base BRE, tratta "+ ?" come metacaratteri, non c'è necessità di proteggerli. Vedere Espressioni sostitutive, Sezione 4.4.2 per come il costrutto viene utilizzato.

Per esempio, grep può essere utilizzato per eseguita una ricerca di testo mediante l'espressione regolare: 

     $ egrep 'GNU.*LICENSE|Yoyodyne' /usr/share/common-licenses/GPL
                         GNU GENERAL PUBLIC LICENSE
                         GNU GENERAL PUBLIC LICENSE
       Yoyodyne, Inc., hereby disclaims all copyright interest in the program

4.4.2 Espressioni sostitutive

Per le espressioni sostitutive, i caratteri seguenti hanno significati speciali:

Nelle stringhe sostitutive in Perl si usa, $n al posto di \n e & non alcun significato speciale meaning.

Per esempio: 

     $ echo zzz1abc2efg3hij4 | \
       sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/=&=/'
     zzz=1abc2efg3hij4=
     $ echo zzz1abc2efg3hij4 | \
       sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/\2===\1/'
     zzzefg3hij4===1abc
     $ echo zzz1abc2efg3hij4 | \
       perl -pe 's/(1[a-z]*)[0-9]*(.*)$/$2===$1/'
     zzzefg3hij4===1abc
     $ echo zzz1abc2efg3hij4 | \
       perl -pe 's/(1[a-z]*)[0-9]*(.*)$/=&=/'
     zzz=&=

Ponete particolare attenzione allo stile delle espressioni regolari tra parentesi e a come le stringhe corrispondenti siano state usate nel processo di sostituzione del testo dai vari strumenti.

Queste espressioni regolari possono anche essere usate per i movimenti del cursore e la sostituzione del testo negli editor.

Per imparare questi comandi, leggete le loro pagine di manuale.

4.5 Il filesystem Unix-like

Nei sistemi operativi GNU/Linux e negli altri Unix-like, i file sono organizzati in directory. [30] Tutti i file e le directory sono organizzati in un unico grande albero, la gerarchia dei file, la cui radice è /.

Questi file e directory possono essere sparsi su vari device. Il comando mount(8) attacca il file system trovato su un device al grande albero. Al contrario, il comando umount(8) lo staccherà nuovamente.

4.5.1 Le basi dei file Unix

I principi basilari:

Le pratiche migliori e più dettagliate per la gerarchia dei file vengono descritte nelFilesystem Hierarchy Standard. per iniziare, dovreste ricordare i seguenti fatti:

4.5.2 Il concetto di filesystem in Debian

Seguendo la tradizione Unix, il sistema Debian fa sì che i filesystem sotto i quali i dati fisici sui dischi rigidi e sugli altri dispositivi di memorie di massa e l'interazione con i dispositivi hardware tipo le console su schermo e le console remotes vengano rappresentati in maniera unificata.

Ciascun file, directory, pipe, o dispositivo fisico in un sistema Debian ha una struttura di dati chiamata inode che descrive gli attributi ad esso associati, come l'utente a cui appartiene (proprietario), il gruppo a cui appartiene, la data di ultimo accesso, ecc.. Vedere /usr/include/linux/fs.h per la definizione precisa di struct inode nel sistema Debian GNU/Linux.

Questa rappresentazione unificata di entità fisiche risulta molto potente, in quanto permette l'uso degli stessi comandi per lo stesso tipo di operazioni su dispositivi complatamente differenti

Tutti i vostri file potrebbero risiedere su un disco --- oppure potreste averne 20, alcuni connessi a computer diversi situati altrove sulla rete. Non potreste distinguerli guerdando semplicemente l'albero delle directory, e quasi tutti i comandi lavorerebbero alla stessa maniera, non importa su quale dispositivo(i) fisico(i) i file risiedono realmente.

4.5.3 Permessi di accesso a file e directory

I permessi di accesso a file e directory vengono definiti separatamente per ciascuna delle seguenti tre categorie di utenti:

Dato un file, ciascun permesso corrispondente permette:

Data una directory, ciascun permesso corrispondente permette:

In questo caso il permesso in esecuzione sulla directory non solo permette di leggere i file nella directory, ma anche di vedere i lori attributi, come le dimensioni e la data dell'ultima modifica.

per mostrare le informazioni sui permessi (e molto altro) dei file e delle directory si usa ls. Vedere ls(1). Quando ls viene invocato con l'opzione -l mostrerà le seguenti informazioni, nell'ordine:

Per cambiare il proprietario del file, si usa chown dall'account di root. Per cambiarne il gruppo, si utlizza chgrp o dall'account del proprietario, o da quello di root. Per cambiare i permessi di accesso al file ed alla directory, si usa chmod dall'account del proprietario, o da quello di root. La sintassi di base per manipolare un dato file foo file è: 

     # chown nuovoproprietario foo
     # chgrp nuovogruppo foo 
     # chmod  [ugoa][+-=][rwx][,...] foo

Vedere chown(1), chgrp(1), e chmod(1) per i dettagli.

Per esempio, per rendere proprietario di una directory l'utente foo e condivisa da un gruppo bar, eseguite i seguenti comandi dall'account di root: 

     # cd /una/locazione/
     # chown -R foo:bar .
     # chmod -R ug+rwX,o=rX .

Esistono altri tre bit di permessi speciali:

In questo caso l'output di ls -l per detti bit viene dato in maiuscolo se la modalità nascosta per i bit di esecuzione non è impostata.

Impostare set user ID su un file eseguibile permette all'utente di eseguirlo con l'owner ID del file (per esempio root). Allo stesso modo, impostare set group ID su un eseguibile permette all'utente di eseguirlo con il group ID del file (per esempio root). Poichè queste impostazioni possono causare seri problemi di sicurezza, abilitarle richide estrema cautela.

Impostare set group ID su una directory abilita lo schema di creazione dei file stile BSD, dove tutti i file creati nella directory appartengono al gruppo della directory.

Impostare lo sticky bit in una directory previene la rimozione di un file in detta directory da un utente che non sia il proprietario del file. Per rendere sicuro il contenuto di un file in una directory scrivibile da tutti, come ad esempio /tmp o in diretory scrivibile dal gruppo, non bisogna solamente disabilitare i permessi in scrittura del file, ma anche impostare lo sticky bit nella directory. Altrimenti il file potrebbe essere rimosso e sostituito da un nuovo fiole con lo stesso nome, da qualsiasi utente con accesso in scrittura alla directory.

Ecco alcuni esempi interessanti sui permessi. 

     $ ls -l /etc/passwd /etc/shadow /dev/ppp /usr/sbin/pppd
     crw-rw----    1 root     dip      108,   0 Jan 18 13:32 /dev/ppp
     -rw-r--r--    1 root     root         1051 Jan 26 08:29 /etc/passwd
     -rw-r-----    1 root     shadow        746 Jan 26 08:29 /etc/shadow
     -rwsr-xr--    1 root     dip        234504 Nov 24 03:58 /usr/sbin/pppd
     $ ls -ld /tmp /var/tmp /usr/local /var/mail /usr/src
     drwxrwxrwt    4 root     root         4096 Feb  9 16:35 /tmp
     drwxrwsr-x   10 root     staff        4096 Jan 18 13:31 /usr/local
     drwxrwsr-x    3 root     src          4096 Jan 19 08:36 /usr/src
     drwxrwsr-x    2 root     mail         4096 Feb  2 22:19 /var/mail
     drwxrwxrwt    3 root     root         4096 Jan 25 02:48 /var/tmp

Esiste un metodo numerico alternativo di descrivere i permessi per i comandi chmod(1). Questo metodo usa numeri da 3 a 4 cifre in ottale (base 8). Ogni cifra corrisponde a:

Suona complicato, ma è in effetti molto semplice. Se guardate alle prime (2-10) colonne dell'output del comando ls -l e le leggete come una rappresentazione binaria (base 2) dei permessi dei file ("-" essendo "0" e "rwx" essendo "1"), il valore numerico diventa una rappresentazione in ottale dei permessi. [33] Provate ad esempio: 

     $ touch foo bar
     $ chmod u=rw,go=r foo
     $ chmod 644 bar
     $ ls -l foo bar
     -rw-r--r--    1 penguin  penguin  0 Nov  3 23:30  foo
     -rw-r--r--    1 penguin  penguin  0 Nov  3 23:30  bar

La maschera di default dei permessi può essere impostata tramite il comando di shell umask. Vedere builtins(7).

4.5.4 Timestamp

Per un file GNU/Linux, ci sono tre tipi di timestamp:

Notate che ctime non è l'orario di creazione del file.

Notate che anche una semplice lettura del file in un sistema Debian causerà una normale operazione di scrittura del file, per aggiornare le informazioni relative a atime nell' inode. Montare un filesystem con l'opzione noatime farà si che il sistemi salti questa operazione, risultando un tempo di accesso del file più breve in lettura. Vedere mount(8).

Usate il comando touch(1) per cambiare i timestamp dei file esistenti.

4.5.5 Collegamenti

Due sono i metodi per associare un dato file foo con un diverso nome bar.

Vedere il seguente esempio per i cambiamenti nella conta dei collegamenti e le sottili differenze nel risultato del comando rm. 

     $ echo "Contenuto Originale" > foo
     $ ls -l foo
     -rw-r--r--    1 osamu    osamu           4 Feb  9 22:26 foo
     $ ln foo bar     # hard link
     $ ln -s foo baz  # symlink
     $ ls -l foo bar baz
     -rw-r--r--    2 osamu    osamu           4 Feb  9 22:26 bar
     lrwxrwxrwx    1 osamu    osamu           3 Feb  9 22:28 baz -> foo
     -rw-r--r--    2 osamu    osamu           4 Feb  9 22:26 foo
     $ rm foo
     $ echo "Nuovo Contenuto" > foo
     $ cat bar
     Contenuto Originale
     $ cat baz
     Nuovo Contenuto

Il collegamento simbolico ha sempre i permessi nominali di accesso impostati su "rwxrwxrwx", come mostrato nell'esempio precedente, con i permessi effettivi dettati dai permessi del file a cui punta.

La directory . è collegata alla directory nella quale appare, per cui la conta dei collegamenti di qualsiasi nuova directory parte da 2. La directory .. e collegata alla directory genitore, per cui la conta dei collegamenti della directory aumenta all'aggiungere nuove sottodirectory.

4.5.6 Named pipe (FIFO)

Una named pipe è un file che agisce come una pipe. Inserite qualcosa in un file da un lato ed esce dall'altro. Da qui il nome FIFO, o First-In-First-Out: la prima cosa che infilate nella pipe è anche la prima ad uscirne.

Se avviate un processo di scrittura verso una named pipe, il processo non terminerà finchè l'informazione che viene scritta non è letta dalla pipe. Se avviate un processo di lettura dalla pipe, il processo aspetterà prima di terminare che non ci sia altro da leggere. Le dimesioni della pipe sono sempre zero --- non memorizza dati, si limita ad unire due processi, come il carattere | della shell. Comunque, poichè questa pipe ha un nome, i due processi non devono necessariamente stare sulla riga di comando, nè essere lanciati dallo stesso utente.

Provate facendo quanto segue: 

     $ cd; mkfifo miapipe
     $ echo "hello" >miapipe & # gira nello sfondo
     [1] 5952
     $ ls -l miapipe
     prw-r--r--    1 penguin penguin  0 2003-11-06 23:18 miapipe
     $ cat miapipe
     hello
     [1]+  Done                    echo hello >miapipe
     $ ls miapipe
     prw-r--r--    1 penguin penguin  0 2003-11-06 23:20 miapipe
     $ rm miapipe

4.5.7 Socket

Il socket è simile alla named pipe (FIFO) è permette ai processi di scambiarsi informazioni. per il socket questi processi non devono girare allo stesso tempo, nè devono essere figli dello stesso genitore. Questo è il traguardo di qualsiasi comunicazione interprocesso. Lo scambio di informazioni può avvenire attraverso una rete, fra host differenti.

4.5.8 Device

Un device fa riferimento ad un dispositivo fisico o virtuale presente nel sistema, come il disco rigido, la scheda grafica, lo schermo o la tastiera. Esempio di dispositivo virtuale è la console, rappresentata da /dev/console.

Esistono due tipi di device:

Potete leggere e scrivere sui device, anche se il file potrebbe contenere dati binari, incomprensibili ai comuni mortali. Scrivere direttamente i dati su questi file può essere utile per diagnosticare problemi nelle connessioni hardware. Per esempio, inviare un file di testo al device della stampante /dev/lp0 oppure inviare i comandi del modem alla porta seriale appropriata /dev/ttyS0. Attenzione che, se eseguite imprudentemente, queste manovre possono portare a disastri notevoli.

4.5.8.1 /dev/null ecc.

/dev/null è un device speciale che elimina qualsiasi cosa gli si vada a scrivere. Se c'è qualcosa che non volete, gettatela in /dev/null. E' fondamentalmente un pozzo senza fondo. Se andate a leggere /dev/null, ottenete immediatamente un carattere end-of-file (EOF).

/dev/zero is simile, solo che se andate a leggerlo, ottenete il carattere \0 (diverso dal numero zero in ASCII). Vedere File fantoccio, Sezione 8.6.34.

4.5.8.2 Numeri dei nodi dei device

I numeri dei nodi dei device lanciando ls come: 

     $ ls -l /dev/hda /dev/ttyS0 /dev/zero
     brw-rw----    1 root     disk       3,   0 Mar 14  2002 /dev/hda
     crw-rw----    1 root     dialout    4,  64 Nov 15 09:51 /dev/ttyS0
     crw-rw-rw-    1 root     root       1,   5 Aug 31 03:03 /dev/zero

Qui,

Nei vecchi sistemi il processo di installazione crea i nodi dei device tramite il comando /sbin/MAKEDEV command. Vedere MAKEDEV(8).

Nei sistemi più recenti il filesystem sotto /dev viene popolato automaticamente in maniera analoga al filesystem /proc.

4.5.9 Il filesystem /proc

Il filesystem /proc è uno pseudo-filesystem e contiene informazioni sul sistema e sui processi in corso.

La gente in genere si spaventa quando nota un file in particolare - /proc/kcore - che è generalmente enorme. Esso è (più o meno) una copia della memoria del vostro computer. Viene utilizzato per il debug del kernel. In pratica non esiste da nessuna parte, per cui non preoccupatevi delle sue dimensioni.

Vedere Mettere a punto il kernel tramite il filesystem proc, Sezione 7.3 and proc(5).

4.6 Il sistema X Window

Vedere X, Sezione 9.4.

4.6.1 Lanciare il sistema X Window

X Window può essere lanciato automaticamente con xdm-come demone per il login grafico, o digitando quanto segue da console. 

     $ exec startx

4.6.2 Il menu di X Window

Poichè l'ambiente di X è in grado di ospitare molti window manager, le loro interfacce variano molto. Ricordate che cliccando col pulsante destro del mouse sulla root window evidenzierà il menu delle scelte. Questo è sempre disponibile.

Se vi manca la voce nel menu, installate i pacchetti corrispondenti. Vedere Iniziare la gestione dei pacchetti Debian, Sezione 6.2.

4.6.3 Sequenze di tasti per X Window

Alcune combinazioni da ricordare quandi si è in X:

4.7 Studi ulteriori

In questo momento, vi raccomando la lettura delle guide fondamentali da The Linux Documentation Project: Guides:

Vedere Supporto per Debian, Capitolo 15 per ulteriori fonti di apprendimento.

[ precedente ] [ Contenuti ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ 10 ] [ 11 ] [ 12 ] [ 13 ] [ 14 ] [ 15 ] [ A ] [ successivo ]

La guida Debian

CVS, lun apr 3 22:57:30 UTC 2005

Osamu Aoki osamu@debian.org
Editor: David Sewell dsewell@virginia.edu
Traduzione italiana: Davide Di Lazzaro mc0315@mclink.it
Autori, Sezione A.1