![[*]](crossref.png)
.
Quanto è importante proteggere i propri dati e i propri messaggi in rete?''
L'elenco dei comandi di seguito riportati è in ordine alfabetico per dare la possibilità di ritrovare il comando conoscendone il nome. Può capitare che vengano citati comandi non discussi e si possa sottintendere informazioni importanti. A tale scopo è stato creato il capitolo seguente, esposizione pratica di lavoro con la shell dei comandi. Le opzioni riportate con i comandi sono una minima parte di quelle esistenti. Molto spesso ogni comando offre una ampia possibilità di scelta ma la nostra scelta è caduta sulla quotidianità delle operazioni.
Ogni comando può differire da un altro per il linguaggio in cui è stato programmato
ma esistono caratteri comuni per ogni sistema Unix/Linux. Tutti i comandi sono
tendenzialmente organizzati in particolari posizioni nel file system. Le posizioni
dove il sistema cerca i comandi sono indicati nella variabile di ambiente PATH.
Per conoscere queste locazioni digitate:
# echo $PATH
/usr/sbin:/bin:/usr/bin:/usr/bin/X11
Ogni posizione è separata dal carattere '':''. Per ampliare
i percorsi di ricerca comandi è necessario indicare al sistema quest'ultime
digitando quanto segue:
# export PATH=$PATH:/usr/local/bin
rieseguendo il comando precedente la situazione cambierà come segue:
# echo $PATH
/usr/sbin:/bin:/usr/bin:/usr/bin/X11:/usr/local/bin
In questo caso è stata aggiunta la directory /usr/local/bin
al PATH e il sistema potrà lanciare i comandi presenti in quest'ultima
posizione. E' possibile lanciare comandi anche fuori dai percorsi presenti nella
variabile PATH e per fare questo è necessario precedere il nome
di comando con le lettere ./ come segue:
# ./comando
Resta inteso che sia in quest'ultima situazione come nelle precedenti il comando o file deve avere i diritti di esecuzione precedentemente analizzati.
La distribuzione di riferimento del manuale è Debian GNU/Linux ma non si è esclusa la considerazione verso le distribuzioni Red Hat Linux e affini. Nelle pagine seguenti verranno mostrati i comandi probabilmente più diffusi e comuni.
Questo comando è necessario per aggiungere un utente al sistema ed è una operazione
concessa unicamente all'utente root, l'amministratore. Digitate:
# adduser nome_scelto
dove nome_scelto è il nostro utente da aggiungere. Per configurare
una password a questo nuovo utente fate riferimento al comando passwd
a pagina .
Questo comando cerca all'interno degli elenchi whatis (pagina ) tutte le corrispondenze
relative alla parola indicata. Esempio:
$ apropos keyboard
Verranno presentate tutte le stringhe di testo contenenti la parola ``keyboard''.
Questo comando è relativo alla distribuzione Debian GNU/Linux e permette di
compiere determinate azioni sui pacchetti software. Tra quest'ultime segnaliamo:
$ apt-cache search rdate
rdate - Set the system's date from a remote host.
Per cercare informazioni sui pacchetti software con una specifica corrispondenza.
Per ottenere maggiori informazioni su un determinato pacchetto:
$ apt-cache show rdate
Package: rdate
Priority: optional
Section: net
Installed-Size: 64
Maintainer: Herbert Xu <herbert@debian.org>
Architecture: i386
Version: 1.3-3
Replaces: netstd
Depends: libc6 (>= 2.1.2)
Filename: dists/potato/main/binary-i386/net/rdate_1.3-3.deb
Size: 7040
MD5sum: 322c5b2c859e32f342457e8e46559860
Description: Set the system's date from a remote host.
Rdate displays and sets the local date and time from the host name or
address given as the argument. It uses the RFC868 protocol which is
usually implemented as a built-in service of inetd(1).
Questo comando è relativo alla distribuzione Debian GNU/Linux. Ha funzionalità
correlabili ai comandi rpm (pagina ) e dpkg
(pagina ) aggiungendo caratteristiche ulteriori e rendendo la
procedura di gestione dei pacchetti software molto più semplice per un utente
della distribuzione pocanzi citata. Per eseguire l'installazione di un pacchetto
.deb è necessario digitare:
# apt-get install nomefile
Se il pacchetto software è già installato nel sistema viene compiuto l'aggiornamento
automatico di quest'ultimo con la nuova versione. Per procedere alla disinstallazione
di un pacchetto software digitate:
# apt-get remove nomefile
Il comando è utile anche per aggiornare tutti i pacchetti software del proprio
sistema sfruttando la connettività ad Internet. Questo è possibile inserendo
un'apposita dicitura nel file /etc/apt/sources.list come segue:
deb ftp://ftp.debian.org/debian unstable main contrib non-free
e digitare al prompt:
# apt-get update
Quest'ultimo comando sfrutterà la connessione (se attiva) per aggiornare automaticamente
la lista dei pacchetti software presenti e disponibili per l'installazione e
l'aggiornamento di sistema. Una volta aggiornata quest'ultima lista è possibile
aggiornare i pacchetti software presenti nel sistema con:
# apt-get upgrade
Questo comando serve a comprimere un file tramite l'algoritmo bz2. Per comprimere
un file è necessario digitare:
$ bzip2 nuovofile
Il file ``nuovofile'' verrà compresso e verrà rinominato
come ``nuovofile.bz2''. Per scompattare il file presente
è necessario utilizzare il comando bunzip2:
$ bunzip2 nuovofile.bz2
Questo comando stampa un calendario per uno specifico mese e/o anno. Digitando
il comando senza opzioni si otterrà il calendario del mese corrente:
$ cal
novembre 1999
do lu ma me gi ve sa
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30
Un ulteriore esempio che mostra il mese di giugno (6) del 1969:
$ cal 6 1969
giugno 1969
do lu ma me gi ve sa
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30
Per mostrare l'intero calendario di un anno:
$ cal 1999
Questo comando è una utilità di controllo delle schede PCMCIA disponibili per
computer portatili. Vediamo alcune opzioni:
# cardctl status
Mostra lo stato attuale della scheda presente.
# cardctl config
Mostra le configurazioni della scheda presente.
# cardctl ident
Visualizza le informazioni identificative della scheda.
# cardctl suspend
Interrompe la corrente che alimenta la scheda.
# cardctl eject
Disabilita la gestione e interrompe l'alimentazione della scheda.
# cardctl insert
Avvisa i driver di gestione che la carta è stata nuovamente inserita e deve essere attivata.
Questo comando mostra il contenuto di un file di testo e può concatenare diversi
file insieme. Per aggiungere il contenuto del fileuno in coda al filedue è necessario
digitare la seguente sequenza di comandi:
$ cat fileuno >> filedue
Per consultare il contenuto di un file:
$ cat fileuno
Se il contenuto di un file è ampio, durante l'esecuzione del comando potreste non visualizzare la totalità delle informazioni presenti. A tale scopo è necessario utilizzare il comando more successivamente descritto.
Questo comando permette di spostarvi nella struttura ad albero delle directory.
Quando un utente si collega al sistema viene automaticamente posizionato nella
sua directory ``home'', usualmente nella posizione ''/home/nome_utente/''.
Per spostarsi in una sottodirectory chiamata ``Tesi'' disposta nella corrente
directory:
$ cd Tesi/
Per spostarsi nella directory ''/home/darshan/Tesi/Cap06/``
digitate:
$ cd /home/darshan/Tesi/Cap06/
Per spostarsi dalla directory attuale a quella superiore, digitate:
$ cd ..
Per spostarvi nella directory ``root'', digitate:
$ cd /
Per ritornare nella vostra ``home'' directory, digitate:
$ cd
Per ritornare nella directory precedente alla posizione attuale:
$ cd -
L'applicazione maggiormente utilizzata per masterizzare con GNU/Linux è sicuramente
cdrecord, un'utility da console ben testata e potente. La prima
utile operazione da compiere prima di agire è visualizzare le periferiche
presenti come segue:
# cdrecord -scanbus
Cdrecord 1.9 (i686-pc-linux-gnu) Copyright (C) 1995-2000 Jörg Schilling
Linux sg driver version: 3.1.15
Using libscg version 'schily-0.1'
scsibus0:
0,0,0 0) 'SONY ' 'CD-RW CRX140E ' '1.0n' Removable CD-ROM
0,1,0 1) 'UTI ' 'CD_ROM ' 'V4.6' Removable CD-ROM
0,2,0 2) *
0,3,0 3) *
0,4,0 4) *
0,5,0 5) *
0,6,0 6) *
0,7,0 7) *
Come è possibile vedere, esiste un masterizzatore e un lettore CD. A questo
punto il passo per masterizzare è semplice:
# cdrecord -v speed=4 dev=0,0,0 -data dati.iso
Cdrecord 1.9 (i686-pc-linux-gnu) Copyright (C) 1995-2000 Jörg Schilling
TOC Type: 1 = CD-ROM
scsidev: '0,0,0'
scsibus: 0 target: 0 lun: 0
Linux sg driver version: 3.1.15
Using libscg version 'schily-0.1'
atapi: 1
Device type : Removable CD-ROM
Version : 0
Response Format: 1
Vendor_info : 'SONY '
Identifikation : 'CD-RW CRX140E '
Revision : '1.0n'
Device seems to be: Generic mmc CD-RW.
Using generic SCSI-3/mmc CD-R driver (mmc_cdr).
Driver flags : SWABAUDIO
Drive buf size : 4183808 = 4085 KB
FIFO size : 4194304 = 4096 KB
Track 01: data 510 MB
Total size: 585 MB (58:01.78) = 261134 sectors
Lout start: 586 MB (58:03/59) = 261134 sectors
Current Secsize: 2048
ATIP info from disk:
Indicated writing power: 4
Is not unrestricted
Is not erasable
Disk sub type: Medium Type A, low Beta category (A-) (2)
ATIP start of lead in: -11318 (97:31/07)
ATIP start of lead out: 336225 (74:45/00)
Disk type: Short strategy type (Phthalocyanine or similar)
Manuf. index: 22
Manufacturer: Ritek Co.
Blocks total: 336225 Blocks current: 336225 Blocks remaining: 75091
Starting to write CD/DVD at speed 4 in write mode for single session.
Last chance to quit, starting real write in 1 seconds.
Waiting for reader process to fill input buffer ... input buffer ready.
Performing OPC...
Starting new track at sector: 0
Track 01: 510 of 510 MB written (fifo 100%).
Track 01: Total bytes read/written: 534798336/534798336 (261132 sectors).
Writing time: 876.092s
Fixating...
Fixating time: 61.167s
cdrecord: fifo had 8424 puts and 8424 gets.
cdrecord: fifo was 0 times empty and 8086 times full, min fill
was 71%.
L'opzione ``-v'' per avere il maggior numero di informazioni
durante l'esecuzione del comando, ``speed=4'' per indicare
che la velocità di masterizzazione dovrà essere di 4x, ``dev=0,0,0''
indica il dispositivo per masterizzare e ``-data dati.iso''
per utilizzare una ben determinata immagine iso dati. L'esempio era relativo
alla masterizzazione dati; per quel che riguarda l'audio il comando adeguato
cambia ben poco:
# cdrecord dev=0,0,0 -audio traccia.cdr traccia1.cdr
La masterizzazione delle tracce audio è denominata TAO (Track At Once); sarà prodotto un cd audio dove tra una traccia e l'altra intercorrono 2 secondi di pausa. Alternativa a TAO, scelta discutibile sulla qualità finale del risultato, è DAO (Disk At Once), modalità che migliora il risultato finale ed evita la possibilità di fruscii e altri effetti indesiderati.
Questo comando cambia gli attributi di un file su un file system di tipo ext2
e può essere particolarmente sotto aspetti di backupt di sistema e sicurezza.
Gli obiettivi del comando possono essere alquanto oscuri per un utente alla
prime armi ma verranno utilizzati alcuni esempi reali per semplificare l'apprendimento.
$ chattr +i documento.txt
Il comando appena digitato rende ``immutevole'' il file documento.txt
da modifiche, aggiunte e non si potranno creare link a quest'ultimo. Se volessimo
rendere ``immutevole'' una directory con tutti i file presenti al suo
interno avremmo dovuto digitare:
$ chattr -R +i documenti/
Ulteriori attributi da dare ad un file (o directory) sono i seguenti:
$ chattr +a documento.txt
L'attributo ``a'' rende il file gestibile solo in modalità
append ovvero è permesso solamente apportare aggiunte al file.
$ chattr +c documento.txt
Un file con l'attributo ``c'' viene automaticamente compresso
sul disco dal kernel. La lettura del file restituisce i dati decompressi mentre
in scrittura ogni informazione viene compressa e poi scritta sul disco.
$ chattr +d documento.txt
L'attributo ``d'' candida un file per il backup tramite
il comando dump .
$ chattr +s documento.txt
Per ulteriori informazioni si consiglia la guida in linea:
$ man chattr
Abbiamo visto che per aggiungere attributi è stato utilizzato il carattere ``+''.
Per toglierli dobbiamo alternativamente utilizzare il carattere ``-``
come nell'esempio seguente:
$ chattr -i documento.txt
Questo comando cambia i permessi associati per ogni file presente nel vostro
sistema. Di seguito viene mostrata la serie di informazioni relative ad un singolo
file. Il comando in questione agisce sulla prima decade di lettere, quelle che
specificano i ``diritti''.
-rw-r-r- 1 root root 133444 Sep 1 21:14 gsg.tex
La forma di utilizzo è la seguente:
chmod {a, u, g, o} {+/-} {r, w, x} <file>
dova ``a'' rappresenta tutti gli utenti (``all''),
``u'' l'utente proprietario del file, ``g''
il gruppo proprietario, ``o'' gli altri utenti di sistema
che non siano ne il proprietario ne il gruppo di riferimento. Il comando può
essere anche espresso in forma ottale come in lettere come segue:
$ chmod 700 gsg.tex
Il comando ha la stessa valenza della forma seguente:
$ chmod u+rwx,go-rwx gsg.tex
Il file considerato cambierà i permessi nel seguente modo:
-rwx-- 1 root root 133444 Sep 1 21:14 gsg.tex
Per capire come funzionano i permessi su un file consultare la tabella 8.1.
E' un comando storico per la compressione dei dati per Unix. Esempio di compressione
di un file:
$ compress nomefile
Ogni file viene compresso e rinominato con l'aggiunta del suffisso ``.Z''.
Per decomprimere un file di questo tipo è necessario digitare:
$ compress -d nomefile.Z
E il file verrà rinominato senza l'estensione ``.Z''.
Questo comando serve per copiare dei file, preservare gli originali e crearne
una copia identica. Se già disponete di un file digitate:
$ cp gsg.tex Documenti/gsg.tex
Nel caso sopracitato ho copiato un file presente nella directory corrente nella
sottodirectory ``Documenti/''. Se nella directory dove
ho copiato il file ci fosse stato già un documento con quel nome lo avrei sovrascritto.
Per evitare questo aggiungo la seguente opzione:
$ cp -i theGimp.tex Documenti/gsg.tex
L'opzione attiva una modalità interattiva che mi comunica particolari situazioni come quella descritta.
E' un archiviatore di file simile al comando tar (pagina ).
Per lungo tempo tar e cpio erano gli archiviatori maggiormente utilizzati, poi
con l'avvento di GNU/Linux il primo ebbe il sopravvento. Numerose sono le opzioni
di questo comando ma ci limiteremo alle due sole principali, la creazione e
l'estrazione di un archio cpio. Per la creazione la forma è la seguente:
# cpio -o < file/ > file.cpio
Per l'operazione inversa, l'estrazione di un archivio cpio, la forma è questa:
# cpio -i -make-directories < file.cpio
La vera utilità di questo comando risiede nell'utilizzo combinato con rpm2cpio
(pagina ).
Questo applicativo è utile quando si vuole automatizzare l'esecuzione di determinati
processi di sistema a scadenze temporali ben definite. Per il suo funzionamento
è necessario avere attivato il demone crond che controlla i
file di configurazione e si occupa di eseguire le operazioni indicate nei limiti
delle impostazioni indicate. Per verificare rapidamente se è attivo digitate:
$ ps -ax|grep cron
In caso positivo apparirà quanto segue:
$ ps -ax|grep cron
559 ? S 0:00 crond
563 pts/1 R 0:00 grep cron
In caso negativo (non esiste il processo crond attivo) potete
attivarlo sul momento. Per fare questo è necessario essere utente root,
l'amministratore di sistema, colui che ha i diritti necessari per lanciare il
demonetypeset@protect
@@footnote
SF@gobble@opt
demone, processo che viene attivato nel sistema e procede in background, ovvero
senza disturbare lo svolgimento delle ulteriori attività.
nel sistema. Digitate:
$ su -
Verrà chiesta la password di root e una volta autenticati potrete
lanciare il demone crond con:
typeset@protect
@@footnote
SF@gobble@opt
I prompt di comandi possono cambiare tra le varie distribuzioni.
# /etc/rc2.d/S89cron start
e poi ritornate all'utente precedente con
# exit
Il prompt dei comandi ritornerà come era. A questo punto non resta altro che
modificare il file di configurazione per eseguire i processi ad una data scadenza
temporale:
$ crontab -e
Il comando edita un file (utilizzando l'editor vi, pag. )
dove andranno impostate le vostre preferenze nella forma seguente:
| minuti | ora | gg del mese | mese | gg settimanale | applicativo |
| data | comando | ||||
Per eseguire il comando pon alle 18,30 di ogni giorno la configurazione
da aggiungere al file di cron sarà la seguente:
30 18 * * * /usr/bin/pon
Gli asterischi ``*'' indicano che il processo dovrà
essere eseguito ogni giorno del mese, ogni mese, ogni giorno della settimana.
A questo punto non vi resta altro che salvare il file e ritornare al prompt
dei comandi iniziale. Per visualizzare il file appena modificato digitate:
$ crontab -l
Se desiderate eliminare il vostro file di configurazione di cron:
$ crontab -r
Per maggiori informazioni digitate al prompt man cron.
Questo comando mostra giorno, data, ora ed anno corrente:
$ date
gio lug 6 11:14:54 CET 2000
Questo comando serve a mostrare lo spazio libero sui dischi.
$ df
Filesystem 1k-blocks Used Available Use% Mounted on
/dev/hda1 1486339 1246706 162825 88% /
/dev/hda2 694727 618131 40712 94% /home
/dev/hda3 121007 73550 41208 64% /home/redhat
Dal risultato del comando è possibile vedere lo spazio utilizzato, lo spazio disponibile, la percentuale di utilizzo e dove sono montati i dischi analizzati.
Questo comando serve per analizzare due file e riportare le differenze.
$ diff -urN it.po it.po.new
Dopo aver digitato il comando vedrete a video le differenze tra i due file.
Il comando diff viene utilizzato per la creazione di patch con le seguenti opzioni:
$ diff -urN it.po it.po.new > patch
Per creare una patch su file binari è necessario digitare quanto segue:
$ diff -a -binary bin bin.2 > patch
Per applicare i file con le differenze è necessario il comando patch
(pagina ).
Questo comando è relativo alla distribuzione Debian GNU/Linux. E' principalmente
utile per installare e aggiornare i pacchetti software sul proprio sistema e
può essere comparato al comando rpm (pagina ).
# dpkg -i nomefile.deb
Questo comando compie sia l'installazione che la procedura di aggiornamento
se viene riscontrato un pacchetto maggiormente recente. Per compiere l'operazione
opposta, ovvero la disinstallazione del pacchetto software .deb digitate:
# dpkg -r nomefile
Per evitare compromissioni del sistema è bene antecedere la seguente opzione
di controllo:
# dpkg -no-act -r nomefile
Per ottenere informazioni su un pacchetto è possibile digitare quanto segue:
# dpkg -s nomefile
Per ottenere informazioni sulla provenienza di un particolare file presente
sul sistema possiamo conoscere il pacchetto software relativo digitando:
# dpkg -S blackbox
Per avere la lista dei pacchetti software installati nel sistema digitate:
# dpkg -l
Una soluzione per avere una lista di pacchetti software da replicare su una
nuova macchina o sulla stessa in caso di ripristino è la seguente riga di comandi:
# dpkg -get-selections > pacchetti.txt
Creato il file potremo recuperare lo stato dei pacchetti software come segue:
# dpkg -set-selections < pacchetti.txt
# dpkg deselect-upgrade
Alternativa a dpkg è apt-get (pagina )
che offre numerose caratteristiche aggiuntive e maggiore semplicità di utilizzo.
Volete sapere quando spazio disco è occupato? Utilizzate il comando seguente:
$ du
Dopo aver digitato il comando ed essere stati colti da dubbi esistenziali si
consiglia la variante successivamente esposta del comando:
$ du -h -s
32M
L'opzione ``-h'' vi mostra il risultato del comando in un modo ``umanamente comprensibile'' mentre l'opzione ``-s'' per ottenere unicamente la somma delle dimensioni dei file considerati.
Questo comando converte file in formato .dvi in formato .pdf.
Digitare:
$ dvipdfm -o documento.pdf documento.dvi
Dove l'opzione ``-o'' indica il nome finale del file nel
nuovo formato. Per maggiori informazioni relative consultare pagina .
Questo comando converte file in formato .dvi in formato .ps
(Postscripttypeset@protect
@@footnote
SF@gobble@opt
Postscript è un marchio registrato da Adobe Inc.
).
$ dvips -o documento.ps documento.dvi
L'opzione ``-o'' indica il nome finale del file postscript
che verrà generato. Esistono numerose opzioni consultabili tramite la propria
pagina manuale ma quelle interessanti nell'uso comune possono essere le seguenti:
$ dvips -A -o pgpari.ps documento.dvi
$ dvips -B -o pgdispari.ps documento.dvi
Dove le opzioni aggiuntive ``-A'' e ``-B''
indicano rispettivamente di creare il file pgpari.ps con le
pagine pari dell'originale documento e pgdispari.ps con le pagine
dispari. Quest'ultime opzioni possono risultare utili se si dispone di una comune
stampante per poter stampare su entrambe i lati dei fogli. Per maggiori informazioni
relative consultare pagina .
Il comando echo serve esclusivamente a stampare sullo standard output stringhe
di testo:
$ echo ``Ciao Daniele''
Ciao Daniele
Un altro esempio può essere la stampa a video di alcune variabili di sistema:
$ echo $HOME
/home/darshan
Dove $HOME rappresenta la nostra directory home.
Se è nostra necessità convertire un file di testo in un file postscript, rtf
o html, questo comando è quello che vi serve. La forma più semplice e immediata
è la seguente:
$ enscript u in.txt o out.ps
dove l'opzione ``u'' indica il file di testo e l'opzione
``o'' il nome del file postscript da creare. Se volessimo
applicare alcune caratteristiche di ``stile'' come impostare il testo
in n colonne basta opportunamente indicarlo come segue:
$ enscript 2 u in.txt o out.ps
Verrà generato un file postscript con il testo impaginato su 2 colonne. Per
definire il formato pagina:
$ enscript M a4 u in.txt o out.ps
Dove con ``M'' definiamo il formato della carta (formato a4).
Questo comando mostra le variabili di ambiente della vostra sessione. Digitate:
$ env
Questo comando viene utilizzato per esportare delle variabili di ambiente, valori
che permettono al sistema di funzionare come desideriamo.
$ export DISPLAY=monika:0.0
Nell'esempio appena visto si è utilizzato il comando per esportare il display di X Window dal server dada al computer monika che corrisponde ad un IP nel file /etc/hosts. I comandi che lanciano applicazioni per X verranno aperti sull'ultimo computer ma il carico di processo sarà della macchina dove vengono eseguiti (in questo caso il computer dada).
Questo comando indica il formato di un file indicato. Digitate:
$ file esempio
esempio: ASCII text
Verrà indicato il formato del file che si chiama ``esempio''.
Questo comando serve per fare ricerche di file nel sistema. Per eseguire una
semplice ricerca del file ``miofile.txt'' nella directory
corrente è necessario digitare quanto segue:
$ find . -name miofile.txt -print
Se desiderate trovare tutti i file con estensione ``.txt''
è necessario digitare quanto segue:
$ find . -name ``*.txt'' -print
In questi esempi appena visti si è utilizzato il punto ``.''
per indicare la directory corrente. Se la nostra ricerca vuole essere estesa
ad un'altra directory comportatevi come segue:
$ find /home/ -name miofile.txt -print
La ricerca andrà ad analizzare se esistono file denominati ``miofile.txt''
nella directory /home e mostrerà il risultato finale.
$ find / -cmin 60 -mmin 60
Con le opzioni appena viste cerchiamo i file cambiati e modificati entro l'arco di tempo di 60 minuti.
Il comando finger riporta informazioni sugli utenti di un sistema,
visualizzando nome, cognome, ufficio e numero di telefono, ultimo login ed ulteriori
informazioni. Di seguito un esempio di utilizzo comune:
$ finger darshan
Login: darshan
Name: Daniele Medri
Directory: /home/darshan
Shell: /bin/bash
Never logged in.
No mail.
No Plan.
Se l'utente ``darshan'' (preso di esempio) ha un accesso
presso un server differente nella rete interna bisognerà specificarlo come segue:
$ finger darshan@erlug
La forma è nome ''utente@nome server''. Se l'utente ha
un accesso presso un server differente e quest'ultimo esce dalla rete interna
ed è dislocato su Internet, la forma diventa:
$ finger darshan@erlug.linux.it
Il nome del server è conforme alle regole canoniche di Internet.
Questo comando serve per formattare un documento di testo con un numero definito
di colonne:
$ fmt -w 60 doc.txt > doc2.txt
Il comando esaminerà il file doc.txt, lo formatterà con un numero di 60 colonne e passerà il risultato ridirizionandolo al file doc2.txt.
Questo comando ha funzionalità simili al comando fmt e aggiunge
alcune caratteristiche. Se si decide di formattare un file con un numero definito
di colonne e non ricevere parole troncate al termine di ogni riga sarà necessario
digitare quanto segue:
$ fold -w 50 -s doc.txt > doc2.txt
Verrà esaminato il file ''doc.txt'' formattandolo con un numero massimo di 50 colonne e disabilitando la parole troncate. Il risultato verrà passato al file''doc2.txt''.
Questo comando stampa sullo standard output l'utilizzo della memoria Ram e dello
Swap:
$ free
total used free shared buffers cached
Mem: 95504 88308 7196 40768 7568 57640
-/+ buffers/cache: 23084 72420
Swap: 60476
Dai dati si può notare l'esistenza di 96 Mbyte di memoria Ram, e una partizione di Swap di circa 60 Mbyte.
Per poter trasferire dei file da un server locale ad un server remoto è necessario
utilizzare questo comando. E' indispensabile avere un accesso al server remoto
o utilizzare una connessione anonima. Per aprire una sessione digitate:
$ ftp
ftp>
Per conoscere l'insieme delle opzioni presenti digitare ``help'':
ftp> help
Per aprire una connessione ad un server:
ftp> open nomeserver
Per chiudere una connessione:
ftp> close
Si è accennato alla connessione anonima. L'unica sostanziale differenza è in
fase di autenticazione:
$ ftp dada
Connected to dada.
220 dada FTP server Tue Sep 21 16:48:12 EDT 1999) ready.
Name (dada:darshan): anonymous
331 Guest login ok, send your complete e-mail address as password.
Password: **********
Quando viene richiesta la password utilizzare il proprio indirizzo di posta elettronica. Non è una richiesta obbligatoria ma è buona regola farlo se si utilizza il servizio in questione.
GnuPG è la versione GNU di PGP, un programma di crittografia per la protezione
della privacy personale. Questa breve descrizione non può essere esaustiva vista
la vastita delle opzioni disponibili ma sintetizzerà i passi fondamentali necessari
è utilizzati comunemente. Il primo passo è la generazione della directory personale
di gpg lanciando il comando:
$ gpg
gpg: /home/darshan/.gnupg: directory creata
gpg: /home/darshan/.gnupg/options: creato un nuovo file delle
opzioni
Come secondo passo è necessario generare le proprie chiavi (pubblica/privata)
lanciando il comando seguente:
$ gpg -gen-key
Verrà avviata una procedura interattiva che vi aiuterà a creare la chiave chiedendovi
alcune configurazioni e alcuni vostri dati personali (nome, cognome, email,
commenti). Quando tutti i dati saranno confermati dovrete digitare la vostra
passphrase, o frase segreta e proseguire nella creazione delle chiavi. Per visualizzare
la vostra chiave pubblica:
$ gpg -export -a
Per copiare la chiave su un file di testo è necessario aggiungere la seguente
opzione:
$ gpg -export -a -o chiave_pubblica.asc
Il file chiave_pubblica.asc è la vostra chiave pubblica che
potete rendere disponibile in rete. Se volete importare la chiave pubblica di
altre persone nella vostra e ampliare il livello di sicurezza dovrete digitare
quanto segue:
$ gpg -import altra_chiave_pubblica.asc
Per conoscere le chiavi importate:
$ gpg -list-keys
Il fingerprint, o ``impronte digitali'' sono informazioni univoche e invariabili
tratte da ogni chiave, informazioni che non cambiano importando ulteriori chiavi.
Servono ad identificare la chiave di una persona e la sua validità. Per conoscere
il proprio fingerprint:
$ gpg -fingerprint
E' utile copiare questi dati e utilizzarli nella propria firma delle vostre
email in modo che sia pubblica e rapidamente confrontabile.
Per utilizzare gpg per spedire un messaggio segreto ad una persona conosciuta
è necessario digitare il seguente comando:
$ gpg -e -a messaggio_segreto.asc
L'opzione ``-e'' significa encrypt e l'opzione
``-a'' è necessaria per esportare il messaggio crittato
in un file di testo. Se ora visualizziamo il file apparirà quanto segue:
$ more messaggio_segreto.asc
---BEGIN PGP MESSAGE---
Version: GnuPG v1.0.1 (GNU/Linux)
Comment: For info see http://www.gnupg.org
hQEOAxMnLse+b6VzEAP/cgfcbq2duvNZ3Msd/fUIjKRfOSj9yvWti
pOwrbvtTm3my2pQbr+w8iy71txPyP+okWUyPYYMyc0wZSYCxsert+
pZKkIftq9PMZO/Ef5EoMysq/kcA0j0vmrKF/O145VzAzYifMW043E
/iQ9LdZogUpH/w8/rS01af5YJmSNwn1TB7q/MI0ywQh6UNNExSerb
dekd1ssd7nV1TpxIxvC1ijlZ4V68uyxXWUJZoc8Mn1IAhwLCnza/Q
9GZN7PaJ94qFNQE69wqGz4TUOA5NWwJaqFSmwwDEmTIyyaferrerV
eue3SJGlfBqzJHJ2HsdLL4XpR3kZMcbZwzVhffdIbpI4gYDd/tLXR
---END PGP MESSAGE---
La sequenza di caratteri è il vostro messaggio protetto. Per visualizzarlo in
forma leggibile è necessario digitare quanto segue:
$ gpg -d messaggio_segreto.asc
Vi verrà chiesto di digitare la vostra frase segreta (passphrase) e in
seguito alla verifica di quest'ultima apparirà il messaggio reale. Per ulteriori
informazioni visualizzate la guida in linea:
$ man gpg
oppure visitate il sito Internet ufficiale: http://www.gnupg.org.
Questo comando è necessario per ritrarre da una fonte di ingresso (un file,
standard input) una particolare serie di dati che corrisponde alle richieste
poste. Una semplice forma di utilizzo può essere la seguente:
$ grep ``pippo'' doc.txt
Il comando visualizzerà a video tutte le righe del file doc.txt
dove sarà presente la parola ``pippo''. La ricerca può assumere richieste
particolari e a tale scopo entrano in gioco le espressioni regolari. Un esempio
pratico:
$ grep '\<[a-z0-9-]\+\>'
doc.txt
Verranno visualizzate solamente le righe che contengono i caratteri dalla lettera
``a'' alla lettera ``z'' e i numeri
da ``0'' a ``9''. Per maggiori informazioni
consultare la pagina manuale del comando.
$ man grep
Esistono diverse alternative al boot loader LILO che abbiamo già trattato in
precedenza e tra queste grub è un'ottima scelta. Dopo aver scaricato
il pacchetto software con
# apt-get install grub
la più semplice procedura di installazione è la seguente:
# grub-install /dev/hda
Al riavvio della macchina si otterà un prompt come il seguente:
GRUB version 0.5.96.1 (640K lower / 3072K upper memory)
[ Minimal BASH-like line editing is supported. For the first word,
TAB lists possible command completions. Anywhere else TAB lists
the possible completions of a device/filename. ]
grub>
Premendo il tasto (tabulatore) si può ottenere la lista di comandi.
Confusi? Posso capirvi ma non è così complicata la procedura basilare e si sintetizza
come segue:
grub> root (hd0,1)
grub> kernel /boot/vmlinuz-2.4.1
grub> read-only
grub> boot
Per procedere ad un'installazione definitiva:
grub> (hd0,1)/boot/grub/stage1 d (hd0) /boot/grub/stage2 p /boot/grub/menu.lst
Non mi dilungherò ulteriormente sulla spiegazione dei comandi perchè grub, nelle distribuzioni aggiornate che lo utilizzano, viene automaticamente installato in fase di installazione e non è più necessario interagire direttamente con la shell comandi. Esiste una documentazione molto ampia a riguardo sia sul sito di riferimento del software che nella directory ``/usr/share/doc/grub'' del vostro sistema locale.
Quello che era il file ``/etc/lilo.conf'' per LILO ha
molte similitudini con ``/boot/grub/menu.lst'' di grub.
Di seguito viene riportato un esempio di quest'ultimo:
#
# Sample boot menu configuration file
#
# Boot automatically after 30 secs.
timeout 30
# By default, boot the first entry.
default 0
# Fallback to the second entry.
fallback 1
# For booting Linux
title GNU/Linux-2.4.2
root (hd0,1)
#kernel (hd0,0)/vmlinuz-2.4.1 root=/dev/hda2 vga=ask apm=on
kernel (hd0,0)/vmlinuz-2.4.2 root=/dev/hda2 vga=ask
# Alternativo
title GNU/Linux-2.18
root (hd0,1)
kernel (hd0,0)/vmlinuz-2.2.18pre21 root=/dev/hda2
# For installing GRUB into the hard disk
title Install GRUB into the hard disk
root (hd0,1)
configfile (hd0,0)/grub/menu.lst
setup (hd0)
# Change the colors.
title Change the colors
color light-green/brown blink-red/blue
Una volta apportate modifiche e salvato il file, l'unica cosa necessaria da fare è riavviare la propria macchina.
Questo comando è utile per comprimere file. La forma tipica di utilizzo è:
$ gzip documento.tex
Per decomprimere tale file si può ricorrere al comando gunzip
(pagina ).
Questo comando è utile per decomprimere file. La forma tipica di utilizzo è:
$ gunzip documento.tex.gz
Questo comando è utilizzato come ultima risorsa per distruggere un programma
sospeso o che si desidera riavviare. Esistono diversi segnali/opzioni che si
possono utilizzare con il comando kill per interrompere un programma. Nell'uso
quotidiano può essere comune quanto segue:
$ kill -9 id_processo
Per visualizzare il codice identificativo di un processo è necessario utilizzare
il comando ps (pagina ).
Questo comando è necessario per fermare il vostro computer. Una volta lanciato
compierà diverse operazioni volte a interrompere i servizi attivi e disabilitare
i dispositivi che compongono il file system.
# halt
Comando con funzionalità analoghe può essere shutdown (pagina
).
Il comando è molto utile per gestire e verificare le prestazioni dei dischi
fissi ed è necessario essere l'utente root per poter eseguire
determinate operazioni. Introduciamo il discorso mostrando basilari parametri
relativi al vostro disco:
# hdparm -c /dev/hda
/dev/hda:
I/O support = 0 (default 16-bit)
Notiamo che il disco sono configurati a 16 bit senza DMA. Per ottenere una statistica
digitiamo:
# hdparm -t /dev/hda
/dev/hda
Timing buffered disk reads: 64 MB in 17.58 seconds = 3.64 MB/sec
Ora provvediamo ad attivare il supporto 32 bit e il DMA:
# hdparm -c 1 -d 1 /dev/hda
/dev/hda
setting 32-bit I/O support flag to 1
setting using_dma to 1 (on)
I/O support = 1 (on)
using_dma = 1 (on)
Verifichiamo ora se c'è stato un incremento di prestazioni in seguito all'attivazione
di questi parametri:
# hdparm -c /dev/hda
/dev/hda
Timing buffered disk reads: 64 MB in 11.77 seconds = 5.44 MB/sec
Dal confronto risulta un incremento di circa 2 MB/sec in aggiunta di trasferimento
dati. Non male! Come ulteriore aggiungiamo l'opzione seguente:
# hdparm -k 1 /dev/hda
/dev/hda
setting keep_settings to 1 (on)
keepsettings = 1 (on)
A questo punto, se vogliamo giovare dell'aumento di prestazioni ogni qual volta
si utilizzi il proprio computer possiamo aggiungere quanto segue al file ``/etc/rc.d/rc.local'',
letto da init in fase di avvio del sistema:
#!/bin/sh
# aumento prestazioni del disco
hdparm -c 1 -d 1 -k 1 /dev/hda
A questo punto non ci rimane che salvare il file e riavviare. Per maggiori informazioni sul comando si consiglia di consultare la pagina manuale (man hdparm).
Come è stato citato in precedenza (pagina ), la Bash offre
la possibilità di memorizzare la sequenza di comandi utilizzati da un utente.
Per visualizzare lo storico dei comandi basta digitare quanto segue:
$ history
Con maggiore utilità se l'output video viene rediretto al comando more o direttamente
in un file di testo. Rispettivamente:
$ history | more
$ history > storico.txt
Questo comando vi permette di gestire l'orologio hardware di sistema apportando
modifiche a piacimento. Il primo utilizzo illustrato è quello ovvio:
# hwclock -show
Sat Jul 15 13:19:14 2000 -0,888683 seconds
Questa è l'ora presente nell'orologio di sistema. Per cambiarla è necessario
aggiungere i seguenti parametri:
# hwclock -set -date=`7/15/2000 16:45:05`
Esistono due modalità di gestione dei dati: localtime, macchina locale,
o utc (Universal Coordinated Time). Se non viene specificato la modalità
è quella locale mentre per configurare l'impostazione nel secondo tipo è necessario
indicarlo:
# hwclock -set -date=`7/15/2000 16:45:05` -utc
Esistono due principali tipi di orologi: l'orologio hardware e l'orologio di sistema. Il primo è indipendente da ogni programma di controllo e rimane attivo anche a computer spento. Spesso viene definito con diverse terminologie: rtc (Real Time Clock), BIOS clock, CMOS clock. L'orologio di sistema è il sistema di gestione presente in ogni kernel di ogni sistema operativo; al momento dell'avvio della macchina vengono consultati i dati dell'orologio hardware e l'orologio di sistema si configura rispettando i timezone indicati, le fasce del fuso orario. Nei sistemi Unix l'orologio di sistema ha come data iniziale l'ora 00:00:00 del 1 Gennaio 1970 UTC.
Quando si parlava di millenium bug, il baco di fine millennio che doveva colpire i computer di tutto il mondo, si considerava una forma di inadeguatezza degli orologi hardware come degli orologi di sistema dei vari sistemi operativi che poteva creare problemi nello svolgimento delle normali attività esecutive.
Con questo comando è possibile configurare e monitorare le interfacce di rete.
Se non vengono dati parametri aggiuntivi, il comando mostra le interfacce attive
in quel preciso istante:
# ifconfig
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:3904 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
Notiamo l'esistenza dell'interfaccia lo, ovvero il Loopback
con IP 127.0.0.1
Se si dispone di una scheda di rete ed è già stata configurata, possiamo ``alzare''typeset@protect
@@footnote
SF@gobble@opt
slang per amministratori di rete che indica l'attivazione.
l'interfaccia di rete e assegnarle un indirizzo IP specifico come segue:
# ifconfig eth0 192.168.0.1
Il risultato sarà quanto segue:
# ifconfig
eth0 Link encap:Ethernet HWaddr 00:50:DA:69:43:7C
inet addr:192.168.0.1 Bcast:192.168.0.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:382 errors:0 dropped:0 overruns:0 frame:0
TX packets:629 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:100
Interrupt:10 Base address:0x6800
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:3904 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
Come si nota è stata attivata l'interfaccia eth0 e le si è assegnato
un indirizzo IP determinato.
Per disabilitare eth0:
# ifconfig eth0 down
Per maggiori dettagli si consiglia la lettura del capitolo relativo alle soluzioni di rete, successivamente trattato in questo testo.
E' un'utilità per il kernel modulare di Linux che permette di inserire un modulo
in memoria e aggiungere funzionalità ulteriori. Quest'ultimi sono genericamente
presenti nella directory:
/lib/modules/<versione del kernel utilizzato>
che in termini pratici può concretizzarsi in
/lib/modules/2.2.17/
Per inserire un modulo è necessario digitare quanto segue:
# insmod sound
oppure il percorso assoluto
# insmod /lib/modules/2.2.17/sound/sound.o
Il comando permette l'utilizzo di numerose opzioni tra le quali le più significative
sono le seguenti:
# insmod -f sound
per compiere l'inserimento del modulo ``sound'' in maniera
forzata superando eventuali discrepanze tra versioni di kernel diversi. Se si
desidera che il kernel stesso si occupi del modulo in maniera flessibile e su
necessità è bene utilizzare la seguente opzione:
# insmod -k sound
Altre utilità per la gestione dei moduli sono lsmod(pag. ),
rmmod(pag. ) e modprobe(pag.).
Questo comando lancia un minimale programma per la chat di tipo IRC.
$ irc irc.tin.it
Digitando il solo comando parte il collegamento in automatico con il server
italiano irc.tin.it che fa parte della rete Ircnet, una delle reti molto diffuse.
Durante il collegamento compariranno messaggi informativi e vi verrà chiesto
il nickname, ovvero il vostro ``nomignolo'' per la chat. Se desiderate
passare quest'ultimo come parametro al lancio del programma è necessario digitare
quanto segue:
$ irc nickname irc.tin.it
Una volta collegati al server specificato con il nickname scelto è necessario
entrare in un ``canale'' di persone, piazze virtuali dove le persone si
trovano per comunicare. Se sapete già in quale canale andare digitate al prompt:
/join #italia
Dove /join indica di entrare nel canale #italia. Una volta entrati potete comunicare
con le altre persone collegate in quel momento. Se desiderate uscire dal canale
digitate:
/leave #italia
Se desiderate ottenere la lista dei canali esistenti e aperti in quel preciso
momento digitate:
/list -MIN 5 -MAX 20 -PUBLIC -NAME
Il comando /list richiede tutti i canali aperti. Le opzioni
aggiunte servono a limitare il flusso di dati richiesti e cercare i canali con
un numero di partecipanti che varia da 5 (MIN) a 20 (MAX)
utenti, che sia aperto a chiunque (PUBLIC) e ordinati per nome
(NAME). Per ottenere la lista dei comandi possibili digitate:
/help
Per la guida specifica di un comando (es. list):
/help list
Per scollegarsi dal server IRC e chiudere il programma:
/quit
E' possibile ottenere la lista dei parametri del comando irc
digitando al prompt:
$ irc -help
In recenti distribuzioni GNU/Linux, questo comando non è presente perchè sostituito con client IRC grafici come xchat o kvirc, o l'insuperabile bitchx per la console.
Per effettuare dei controlli ortografici è molto utile questo comando. Viene
genericamente distribuito in diversi pacchetti divisi per le lingue disponibili.
Buona scelta potrebbe essere installare i seguenti pacchetti software:
ispell (applicazione base)
iitalian (dizionario delle parole in italiano)
ibritish (dizionario delle parole in inglese)
iamerican (dizionario delle parole in americano)
Per configurare il correttore in prima istanza:
$ ispellconfig
Please wait while I search for ispell dictionaries...
[1] italian
[2] british
[3] american
Select the number of the default dictionary [1]
Making italian the default ispell dictionary... done.
Come verificare il funzionamento? Un semplice esempio può essere il seguente:
$ echo ``laboratoio'' | ispell -a
@(#) International Ispell Version 3.1.20 10/10/95
& laboratoio 1 0: laboratorio
Ogni accesso al vostro sistema GNU/Linux viene monitorato e memorizzato nel
file /var/log/wtmp visualizzabile con qualsiasi editor di testi.
Malgrado questo è possibile utilizzare il comando last appositamente studiato
per l'azione. La forma per l'utilizzo è la seguente:
$ last
Per visualizzare al meglio il risultato del comando è consigliabile indicare
il numero di righe nel seguente modo:
$ last -10
Alternativamente è possibile ridirigere l'output del comando a more
(pagina )in modo di visualizzare il tutto una pagina alla volta.
La forma è:
$ last|more
Chi già conosce questo comando sarà conscio che la sua presenza in questa lista lo riduce notevolmente di valore. Non è assolutamente quello che l'autore desidera ottenere ma è vero che spesso un utente utilizza quest'ultimo in rare occasioni con limitate opzioni; questo è il caso in esame.
Cos'è LATEX? E' un insieme di macro per la formattazione e produzione di
documenti scritti in TEX. La modalità comune per elaborare un documento compatibile
è la seguente:
$ latex documento.tex
Se l'esecuzione del comando termina con successo potrete notare nella stessa
directory dove è presente ''documento.tex`` il nuovo file
``documento.dvi'' formato pronto per la stampa. Per visualizzarlo
è possibile utilizzare l'applicazione xdvi (vedi pagina ),
per la conversione in altri formati fate riferimento ai comandi dvips
(pagina ) e dvipdfm (pagina ).
Desiderosi di provare? Ok, digitate:
$ vi documento.tex
Verrà aperto l'editor vi (pag. ).
Premere il tasto per entrare in modalità inserimento e scrivere:
\documentclass{article}
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\begin{document}
Ciao Mondo!
\end{document}
Uscite e salvate premendo il tasto e i caratteri ``:wq!'' ed eseguite le istruzioni già date per compilare il documento e visualizzarlo.
I sistemi del ceppo Unix (GNU/Linux compreso) hanno un'organizzazione ottimizzata
degli esecutivi e le librerie necessarie per quest'ultime. Per vedere quali
librerie sono utilizzate da un particolare comando:
# ldd /usr/bin/bitchx
libncurses.so.5 => /lib/libncurses.so.5 (0x40021000)
libresolv.so.2 => /lib/libresolv.so.2 (0x4005f000)
libcrypt.so.1 => /lib/libcrypt.so.1 (0x40071000)
libm.so.6 => /lib/libm.so.6 (0x4009e000)
libdl.so.2 => /lib/libdl.so.2 (0x400bc000)
libc.so.6 => /lib/libc.so.6 (0x400bf000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
In questo esempio, il comando bitchx (un client famoso per IRC) richiede le librerie indicate per essere eseguito.
GNU/Linux permette di creare dei link ai file per una migliore gestione. Un
link vi permette di dare ad un singolo file nomi multipli. I file nel sistema
sono identificati da un proprio numero inode. Una directory è una lista di numeri
inode con i corrispondenti nomi dei file. Esistono due tipi di link (collegamenti):
hard link e link simbolici. Entrambi sono rappresentazioni di un file ma con
particolari differenze. Analizziamo ora l'utilizzo e in seguito le differenze
tecniche. Per creare un semplice link (hard link) digitiamo:
$ ln doc filelink
Con il comando appena digitato troveremo nella nostra directory due file che
sono la medesima cosa: doc filelink. Modificare
filelink vuol dire apportare delle variazioni a doc,
il file di riferimento. Per creare un link simbolico è necessario aggiungere
l'opzione ``s'' al nostro comando:
$ ln -s doc filelinksimbolico
Analizzando il contenuto della nostra directory troviamo ora, oltre a ''filelink'', ''filelinksimbolico'', il nuovo riferimento a ``doc''. L'approccio è il medesimo. Modificando ''filelinksimbolico`` apportiamo delle variazioni a ''doc''.
Un hard link è un collegamento al numero inode di un file. I permessi su questo tipo di file sono gli stessi del file originale. Se decidete di cancellare un hard link il file originale non viene eliminato. Un link simbolico a differenza del caso precedentemente esaminato è un ``collegamento ad un nome di file'' e non ad un numero inode. Questa forma offre maggiore flessibilità operativa nell'uso comune ed è la scelta largamente utilizzata. Il link simbolico ha permessi differenti da quello originali ma nella manipolazione del file, gli ultimi riferimento sono fatti sui permessi del file originale.
Questo comando è utile per trovare file nel sistema ma ha un comportamento diverso
dal comando find analizzato a pagina . Quest'ultimo
compie una ricerca nel sistema, mentre il secondo, locate (o
slocate per distribuzioni recenti compatibili con Red Hat),
analizza un file di testo indicizzato migliorando le prestazioni della ricerca
e riducendo il carico delle risorse utilizzate. Il file indicizzato viene creato
con un processo di cron (pagina ) generalmente
in orari notturni. Se l'utilizzo del vostro computer è quello comune e saltuario
potreste saltare spesso l'esecuzione del processo di aggiornamento e in tal
senso è possibile agire in modi differenti, modificando il file di esecuzione
del processo o lanciando quest'ultimo manualmente. Con i dovuti diritti dell'utente
root digitate:
# updatedb
Al termine dell'esecuzione del comando, la modalità di utilizzo del comando
locate per qualsiasi utente del sistema è la seguente:
$ locate stdio.h
/usr/include/stdio.h
/usr/include/bits/stdio.h
/usr/include/lam/stdio.h
Se da un lato la ricerca con locate risulta molto più efficiente, l'efficacia nel trovare determinate cose è relativa alla fase di aggiornamento del file indicizzato. In tal senso il comando find può risultare la scelta migliore.
Tramite questo comando è possibile gestire le code di stampa. Salvo particolari
configurazioni è necessario essere l'utente root per poter gestire
il programma e le operazioni annesse sulla coda di stampa. La forma è la seguente:
# lpc
lpc>
Come si nota viene attivato il prompt del programma. Per avere l'elenco dei
comandi disponibili digitate:
lpc> ?
Commands may be abbreviated. Commands are:
abort enable disable help restart status topq ?
clean exit down quit start stop up
Potete notare le diverse soluzioni disponibili per spostare file di stampa in
cima alla coda, fermare i processi e altro ancora. Il comando che probabilmente
può risultare utile nei casi reali per avere un monitor sui processi in corso
è il seguente:
lpc> status
lp:
queuing is enabled
printing is enabled
1 entry in spool area
lp is ready and printing
lp0:
queuing is enabled
printing is enabled
no entries
no daemon present
Per ottenere informazioni in merito ai comandi disponibili bisogna anteporre
la parola ``help'' al comando come segue:
lpc> help clean
clean remove cruft files from a queue
Questo comando serve per la stampa su un sistema BSD compatibile come GNU/Linux.
Per lanciare il processo di stampa di un file, digitate:
$ lpr doc
Nell'esempio appena visto si lancia in stampa il file doc. Se
si desidera stampare un file con una stampante specifica è necessario digitare
quanto segue:
$ lpr -Pstampante doc
Nel caso comune le stampanti sono collegate alle porte parallele dei computer
comuni ed è possibile sostituire il nome della stampante con la porta stessa
alla quale è collegata:
$ lpr -Plpt1 doc
Dove lpt1 rappresenta la porta parallela, il dispositivo /dev/lpt1.
Questo comando rientra nell'attività di stampa per rimuovere i processi di stampa
accodati. Esempio di utilizzo comune per rimuovere ogni cosa:
$ lprm
Se si desidera terminare un determinato processo è necessario digitare:
$ lprm 9
Verrà terminato il processo di stampa numero ``9'' tra tutti quelli attivi. Per conoscere le code di stampa relative ad ogni stampante fate riferimento al comando lpq, di seguito esposto.
Questo comando mostra le code di stampa, ovvero i documenti messi in file per
essere stampati con ordine sequenziale. Digitate:
$ lpq
Questo comando mostra il contenuto di una directory. Digitate:
$ ls
Nei sistemi unix esistono file visibili e file nascosti. Per nascondere
un file è necessario rinominarlo con un punto davanti al nome (es. .file)
e per poter visualizzarlo con il comando in questione bisogna utilizzare l'opzione
seguente:
$ ls -a
.
..
.nomefile_nascosto
nomefile_visibile
Se si desidera visualizzare permessi, proprietari e dimensioni dei file digitate:
$ ls -l
.
..
drwxrwxrwx 2 darshan darshan 1024 Set 18 22:32 Documenti
-rw-rw-rw- 4 darshan darshan 2056 Set 20 21:50 nomefile_visibile
E' un'utilità per il kernel di Linux che permette di visualizzare i moduli caricati
in memoria.
# lsmod
Module Size Used by
bsd_comp 4100 0 (autoclean)
ppp_async 6476 1 (autoclean)
parport_pc 22448 1 (autoclean)
lp 4616 4 (autoclean)
parport 26720 1 (autoclean) [parport_pc lp]
rtc 6056 0 (autoclean)
nls_cp437 4340 3 (autoclean)
smbfs 29380 0 (unused)
mpu401 18800 0 (unused)
sb_lib 33832 0 (unused)
uart401 6512 0 [sb_lib]
sound 58624 0 [mpu401 sb_lib uart401]
nls_iso8859-1 2828 3
ppp_deflate 39164 0
ppp_generic 18496 6 [bsd_comp ppp_async ppp_deflate]
slhc 4468 0 [ppp_generic]
3c59x 22424 1
dummy 1216 0 (unused)
Altre utilità per la gestione dei moduli sono insmod(pag. ),
rmmod(pag. ) e modprobe(pag.
).
Semplice programma da console per spedire e ricevere messaggi di posta. Digitate:
$ mail
Visualizza se c'è posta per l'utente.
$ mail -s ``compito'' -u madrid
Spedisce un messaggio di posta all'utente madrid con il soggetto ``compito''.
$ mail -f
Legge il contenuto della vostra casella postale.
Questo comando visualizza la pagina manuale di un comando ed è molto utile quando
si vuole conoscere le opzioni relative. A titolo di esempio, visualizziamo la
pagina manuale di un comando già citato precedentemente:
$ man ls
Esiste una pagina manuale per lo stesso comando man:
$ man man
Se non ricordate il nome del comando che vi serve a compiere una determinata
operazione potete avvalervi dell'opzione ``-k'' nel seguente
modo:
$ man -k parola
Verranno mostrate le pagine manuale che contengono la parola indicata.
Midnight Commander, una interfaccia per navigare tra le directory e i file del
sistema. Per eseguirlo:
$ mc
Nelle recenti distribuzioni di GNU/Linux, questo programma è associato a gmc, l'interfaccia grafica del programma per l'ambiente desktop GNOME.
Un semplice caso di studio: vogliamo trasferire ad un'altra persona un file
e vogliamo garantire la sua autenticità. Per fare questo possiamo utilizzare
questo comando come segue:
$ md5sum nomefile.tgz
d41d8cd98f00b204e9800998ecf8427e nomefile.tgz
La stringa alfanumerica che viene presentata è ``l'impronta digitale'' del file che può essere confrontata con quella di chi fornisce il file e chi lo riceve. In questo modo semplice possiamo tutelarci che il file non abbia subito modifiche nel passaggio.
Gli utenti di un sistema possono interagire tra di loro attraverso diversi programmi
via terminale. Potete disabilitare le richieste esterne digitando:
$ mesg n
Per riattivare in modalità ``recettiva'':
$ mesg y
E' un'utilità per il kernel di Linux che permette di caricare i moduli in memoria
attuando alcuni test per la configurazione automatica dei parametri necessari
e adeguati.
# modprobe sound
Esistono alcune interessanti opzioni tra le quali segnaliamo:
# modprobe -c
per visulizzare le configurazioni dei moduli caricati.
# modprobe -l
per visualizzare i moduli disponibili.
# modprobe -r
per scaricare uno o più moduli rispettando le dipendenze. Altre utilità per
la gestione dei moduli sono insmod(pag. ),
rmmod(pag. ) e lsmod(pag. ).
Questo comando vi serve per creare una directory. La sintassi tipica è:
$ mkdir esempio
Il comando è particolarmente sensibile ai permessi di sistema. E' chiaro che non vi sarà concesso di creare una directory dove non avete i diritti per farlo.
Argomento masterizzazione: il comando in esame serve a creare immagini iso9660 e supporta diverse opzioni importanti per superare i limiti dell'originale file system come gli 8 livelli massimi di sottodirectory, la lunghezza dei nomi dei file ristretta a 32 caratteri e la capacità di 650 Mbyte. Le opzioni più importanti sono:
# mkisofs -r -l -o immagine.iso dati/
Il file immagine.iso conterrà i dati della directory dati/
organizzati secondo il file system iso9660 e utilizzando l'estensione RockRidge.
Una volta creata l'immagine possiamo testare il risultato montando il
file come segue:
# mount -t iso9660 -o ro,loop=/dev/loop0 immagine.iso /mnt/cdrom
Il file immagine.iso verrà montata su /mnt/cdrom
e sarà possibile gestire i file presenti. Al comando mkisofs
seguono altri comandi come cdrecord (pag. )
e cdrdao, programmi necessari per gestire e creare CD-R.
Comando utile per creare file system su un dispositivo (partizione, disco fisso).
Modalità di utilizzo:
mkfs <dispositivo> -t <tipo file system>
Di seguito alcuni esempi pratici:
# mkfs /dev/hda4 -t ext2
Creare il file system ``ext2'' (quello di GNU/Linux) sul
dispositivo ``/dev/hda4/''.
# mkfs /dev/hda4 -t msdos
Creare il file system ``msdos'' (quello del DOS) sullo
stesso dispositivo ``/dev/hda4/''.
# mkfs /dev/hda4 -t vfat32
Creare il file system ``vfat32'' (quello di MS Windows)
sullo stesso dispositivo ``/dev/hda4/''. Se volessimo
creare un file system su un comune dischetto floppy:
# mkfs /dev/fd0 -t ext2
Questo comando visualizza il contenuto di un file una schermata alla volta.
$ more file
Nonostante questo semplice esempio, il comando viene utilizzato in associazione
con altri. L'esempio che segue legge l'output del comando ls
e lo redirige al comando more per visualizzare il risultato
una pagina per volta:
$ ls -la|more
Il simbolo ``|'' (pipe) viene utilizzato per passare il risultato di un comando al successivo.
Questo comando serve a montare un file system. Nell'esempio che segue viene
mostrato come montare un cd-rom con file system iso9660 alla directory /mnt/cdrom:
# mount /dev/cdrom -t iso9660 /mnt/cdrom
Le distribuzioni maggiormente diffuse di GNU/Linux inseriscono i dati utilizzati
nel file /etc/fstab per facilitare ed automatizzare le operazioni
comuni. Se nel file appena citato è presente una riga di configurazione simile:
/dev/cdrom /mnt/cdrom iso9660 owner,noauto,ro 0 0
basterà utilizzare il comando mount con una serie ridotta di opzioni:
# mount /dev/cdrom
Dopo aver digitato il comando potrete accedere al contenuto del vostro cd-rom.
Si utilizza il comando mount per condividere aree file condivise
in rete tramite il sistema NFS. La formulazione tipica può essere la seguente:
# mount monika:/mnt/nfs -t nfs /mnt/nfs
Dove si indica di montare la partizione /mnt/nfs presente sul server monika e disporla nel file system locale come /mnt/nfs. Chiaramente è necessaria la specifica configurazione lato server (pagina 18).
Se disponete di una stampante Postscript capace di stampare su entrambi i lati
del foglio è possibile utilizzare questo comando.
$ mpage -t -1 -Plp -bA4 documento.ps
L'opzione ``-1'' indica il numero di stampe per pagina e possono alternativamente essere utilizzate le opzioni ``-2'', ``-4'' per avere 2 o 4 pagine per foglio.
Un semplice client per leggere la posta elettronica (MUA, mail user agent).
Per lanciarlo:
$ mutt
Una semplice configurazione è quella che segue e deve essere inserita nel file
/.muttrc nella propria home directory:
set pop_host=''popmail.libero.it''
set pop_delete=''yes''
set pop_user=''pippo''
La prima direttiva indica il server postale, ``pop_delete'' indica se cancellare o meno la posta dal server remoto, ``pop_user'', come è semplice intuire indica il proprio username di connessione. Una volta aggiunti i propri dati nel file di configurazione basterà lanciare mutt e premere il tasto e verrà contattato il server. Per le proprie caratteristiche non è possibile configurare un server SMTP esterno, differente dal proprio server locale di posta.
Questo comando può avere una duplice funzionalità: muovere un file e rinominarlo.
Nell'esempio che segue viene rinominato un file con un nuovo nome:
$ mv vecchionome nuovonome
Per muovere un file verso un'altra directory, digitate:
$ mv nuovonome /documenti/
In questo ultimo caso viene utilizzato il simbolo ``'' che indica la directory home dell'utente. Il file viene spostato nella directory /home/darshan/documenti/.
Serve a cambiare la modalità di esecuzione di un programma. Se viene lanciato
senza opzioni viene presentata la priorità corrente:
$ nice
0
Nel caso in esame abbiamo ricevuto un valore pari a ``0''.
I valori di priorità vanno da -20 (la più alta) a 19 (la più bassa). Se volessimo
abbassare la priorità di esecuzione di un programma in modo che non disturbi
le attività del sistema digitiamo:
$ nice -n 5 nomeprogramma
L'opzione ``-n'' mi permette di indicare un valore scelto nella scala esposta precedentemente.
Se si desidera numerare ogni singola riga di un documento di testo questo è il comando che serve. Esistono diverse opzioni interessanti:
$ nl -v 1 -l 1 doc.txt > doc2.txt
Il documento con la numerazione è stato ridiretto al file ''doc2.txt''.
Serve a lanciare un programma in particolari modalità. L'utilizzo di questo
comando è particolarmente utile quando si deve eseguire un programma di calcolo
e non lo si interrompere nel momenco in cui vi disconnettete dal sistema (es.
in una connessione telnet).
$ nohup nomeprogramma
nohup: appending output to `nohup.out'
Il programma continuerà a girare in background ed eventuali messaggi saranno riportati nel file ''nohup.out'' creato nella directory corrente.
Questo comando serve per cambiare la propria password (parola d'ordine) necessaria
per l'autenticazione nel sistema. Esistono due differenti livelli di utilizzo
del comando, un livello ampliato e completo per l'utente root
(l'amministratore di sistema) e un livello ristretto ma essenziale per il resto
degli utenti nel sistema. Mentre un utente può utilizzare passwd
per gestire la propria password, l'utente root può utilizzare
il comando per gestire oltre alla propria password quelle degli utenti nel server
amministrato. Il caso seguente è quello dell'utente ``darshan'':
$ passwd
Changing password for darshan
(current) UNIX password: *******
New UNIX password: ********
Retype new UNIX password: ********
Analizziamo ogni singolo passo. In un primo momento viene chiesta la password
corrente, la parola d'ordine che attualmente ci permette di collegarci al sistema.
Se quest'ultima corrisponde viene chiesto di digitare una nuova password con
successiva verifica. Il comando è intelligente e cerca di colmare l'inesperienza
di un nuovo utente o scelte incaute che possono compromettere la sicurezza del
sistema. Le nuove password digitate vengono controllate e se non rispettano
determinati parametri si riceve un messaggio di avviso che invita a seguire
determinate norme. Una combinazione di numeri e lettere maiuscole/minuscole
può essere una valida soluzione. Esempio:
A3r0pLan0 aeroplano
MaNuCha0 manuchao
F3deRic0 federico
Il comando serve per applicare i file patch (creato con il comando patch)
creato con le differenze tra un file e un file più recente. La modalità di utilizzo
è la seguente:
$ patch -p0 < patch
Per applicare patch binarie è necessaria la seguente opzione:
$ patch -binary -p0 < patch
Il seguente comando lancia un editor di testo semplice ed intuitivo, presente
nel sistema se viene installato il pacchetto software pine.
Per utilizzarlo:
$ pico
Per poter salvare il file editato premere contemporaneamente i tasti e , oppure e . Un'alternativa GPL di questo editor è nano che aggiunge nuove funzionalità.
Questo comando serve per preparare un file per la stampa. La forma di utilizzo
è la seguente:
$ pr doc.txt
Il file ''doc.txt'' verrà formattato con una lunghezza di 66 righe (numero per la lunghezza configurabile a piacimento) e i dati relativi al file (data, ora, nome, numero di pagina).
Riporta lo stato dei processi attivi nel sistema e si utilizza nel seguente
modo:
$ ps
PID TTY TIME CMD
648 pts/2 00:00:00 bash
649 pts/2 00:00:00 ps
Nell'uso comune è frequente utilizzare il comando con le seguenti opzioni:
$ ps afx
Dove la lettera ``a'' mostra i processi degli altri utenti collegati al sistema, la lettera ``f'' la sequenza dei processi attivi organizzata in una struttura ad albero e la lettera ``x'' che mostra i processi senza terminali di controllo.
Questo comando ha un funzionamento molto simile a ps ma rappresenta
i processi attivi in un alberatura particolare. Digitate:
$ pstree -n
init-+-kflushd
|-kupdate
|-kpiod
|-kswapd
|-mdrecoveryd
|-syslogd
|-klogd
|-xfs
|-login--bash
|-5*[mingetty]
|-gdm-+-X
| `-gdm--Default--gnome-session
|-esd
|-gnome-smproxy
|-sawfish
|-xscreensaver
|-gmc
|-panel
|-gnome-terminal-+-gnome-pty-helper
| `-bash--pstree
|-gnome-name-serv
|-tasklist_applet
|-rpciod
`-gv--gs
Questo comando vi indica la posizione attuale nel file system:
$ pwd
/home/darshan/
Volete avere l'ora di sistema sincronizzata con il resto del mondo? :) Bene.
In questa operazione vi potrà essere utile il comando seguente:
# rdate -sp tempo.cstv.to.cnr.it
che si collegherà al server indicato e cambierà l'ora di sistema sincronizzandola
con quella riscontrata. Se volete successivamente trattenere l'ora per le future
sessioni digitate:
# hwclock -systohc &
Per ulteriori informazioni su hwclock andate a pagina .
Comando necessario per riavviare il sistema. Una volta lanciato compierà diverse
operazioni volte a interrompere i servizi attivi, disabilitare i dispositivi
che compongono il file system e riavviare il computer.
# reboot
Questo comando rimuove un file in maniera permanente. Nell'esempio che segue
viene mostrata la modalità interattiva ottenuta con l'opzione ``-i'':
$ rm -i file
La modalità forzata agisce in maniera inversa. Elimina il file senza
chiedere conferma preventiva:
$ rm -f file
Se si desidera cancellare una directory e i file in essa contenuti è necessario
utilizzare l'opzione ``-r'' (recursive) nel seguente modo:
$ rm -fr documenti/
E' un'utilità per il kernel di Linux che permette di rimuovere i moduli caricati
in memoria.
# rmmod sound
Per rimuovere tutti i moduli caricati è necessario utilizzare l'opzione ``-a''
come segue:
# rmmod -a
Altre utilità per la gestione dei moduli sono insmod(pag. ),
modprobe(pag. ) e lsmod(pag.
).
Questo comando serve per gestire la tavola di IP routing (networking).
Per verificare i parametri di routing definiti digitate:
# route -n
Kernel IP routing table
Destination Gateway Genmask Flags Metric Ref Use Iface
192.168.0.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0
Per aggiungere un gateway di riferimento per la macchina la sintassi è la seguente:
# route add default gw 192.168.0.3
per aggiungere un indirizzo da rifiutare:
# route add -host server.it reject
L'argomento considerato è alquanto complesso e può essere fuorviante per il target di utenti al quale si propone il manuale. Con tale motivazione non si vuole insistere sulla cosa in maniera eccessiva ma è altresì possibile ampliare le proprie conoscenze nella numerosa documentazione esterna presente su Internet.
Questo comando è lo strumento di gestione dei pacchetti software caratteristico
della distribuzione Linux Red Hat. Questo comando gestisce i pacchetti software
organizzati secondo le specifiche del formato che vengono indicati comunemente
con l'estensione ``.rpm''. Analizziamo le varie opzioni:
# rpm -i nomefile.rpm
Il comando installa un pacchetto software nel sistema.
# rpm -U nomefile.rpm
Il comando aggiorna un pacchetto software nel sistema.
# rpm -e nomefile
Il comando rimuove il software dal sistema.
# rpm -qf esempio.txt
Il comando esamina quale pacchetto software conteneva il file esempio.txt.
# rpm -qa
Il comando elenca i pacchetti software installati sul proprio sistema. Nelle
fasi di installazione e aggiornamento possono essere utilizzate ulteriori opzioni
che informano sullo stato di esecuzione del processo e mostrano una barra di
progresso.
# rpm -ivh nomefile.rpm
nomefile ############################
# rpm -Uvh nomefile.rpm
nomefile ############################
In casi particolari può capitare che il pacchetto che si desidera installare
subisca particolari vincoli di dipendenza verso altri software. Se vogliamo
sopprimere questi ultimi digitiamo:
# rpm -i nomefile.rpm -nodeps
Una scelta particolarmente orientata ad un utente esperto può anche essere la
seguente:
# rpm -i nomefile.rpm -force
Il comando digitato forza l'installazione senza controlli preventivi dei pacchetti
esistenti o sui vincoli di dipendenza. Un'ulteriore necessità può essere quella
di conoscere ogni possibile informazione sul pacchetto software che ci si approssima
ad installare nel proprio sistema. Per questo è necessario digitare quando segue:
# rpm -qpil geekcode-1.7-2.i386.rpm
Name : geekcode Relocations: /usr
Version : 1.7 Vendor: Chris Gushue
Release : 2 Build Date: mar 22 feb 2000 15:59:14
Install date: (not installed) Build Host: DeepThought.prefect.net
Group : Amusements/Games Source RPM: geekcode-1.7-2.src.rpm
Size : 159494 License: GPL
Packager : Chris Ausbrooks <weed@bucket.pp.ualr.edu>
URL : http://seymour.lazygenes.net/geekcode.html
Summary : Generates your geek code.
Description :
This program will generate a geek code block for you by simply
choosing which codes suit you from the screen.
/usr/bin/geekcode
/usr/doc/geekcode-1.7
/usr/doc/geekcode-1.7/CHANGES
/usr/doc/geekcode-1.7/COPYING
/usr/doc/geekcode-1.7/INSTALL
/usr/doc/geekcode-1.7/README
/usr/doc/geekcode-1.7/geekcode.txt
Se desiderate convertire un pacchetto software in formato ``.rpm''
in un archivio comune ``.cpio'' questo è quello che vi
serve. La forma tipica è la seguente:
# rpm2cpio nomefile.rpm > archivio.cpio
Per estrarre successivamente l'archivio creato fate riferimento al comando cpio
(pagina ).
Se è vostra necessità replicare un direttorio sul vostro filesystem o viceversa,
può esservi utile il seguente comando:
$ rsync -avz -exclude pippo.* -delete <server>:/web/
web/
In questo modo copierete nella directory ``web/'' il contenuto della directory ``/web/'' del server indicato escludendo tutti i file che iniziano con ``pippo.'' e cancellando i file locali che non esistono più sulla macchina remota.
Secure copy, un programma utile per copiare file tra macchine in rete e giovare
della protezione cifrata di ssh. La modalità di utilizzo è la
seguente:
$ scp iloveyou.tgz madrid@server.com:
copia il file locale ``iloveyou.tgz'' nella macchina ``server.com'' dove ho un account con username ``madrid''. Per copiare effettivamente il file su quella macchina verrà richiesta la password di autenticazione relativa.
Questo comando mostra le variabili di ambiente della vostra sessione:
$ set
Il comando set ha la medesima funzionalità del comando env.
Questo comando prepara il sistema per essere spento fisicamente e permette opzioni
anche per il riavvio. Presenta analogie con il comando halt
(pagina ) ma porta ulteriori opzioni relative al riavvio del
computer. La forma tipica è la seguente:
# shutdown -r now
L'opzione ``-r'' sottointende reboot, riavvio; era possibile
utilizzare anche l'opzione ``-h'' che sottointende a halt,
ferma. E' cosa gentile preavvisare gli eventuali utenti collegati al sistema
e dare loro il tempo per concludere le operazioni in corso. Digitando:
# shutdown -r +1 ``Riavvio della macchina''
Lanciamo l'interruzione del sistema con 1 minuto di attesa e un messaggio di avviso per gli utenti collegati.
Questo comando provvede a creare un collegamento tra un'interfaccia di rete
e una linea seriale in maniera molto semplice. La modalità d'uso:
$ slattach -p cslip -s 38400 ttyS1
Nell'esempio si collega un'interfaccia di rete alla porta seriale ``ttyS1'',
con la velocità di trasferimento di ``38400'' e utilizzando
il protocollo ``cslip''. Per maggiori informazioni consultare
la guida in linea:
$ man slattach
Le modalità di funzionamento di questo comando sono simili a quelle di locate
(pagina ). Differenza che contraddistingue i due comandi è
una maggiore sicurezza per slocate nella rappresentazione della ricerca. Quest'ultima
infatti mostrerà unicamente i file accessibili (in termini di diritti) dagli
utenti del sistema. La modalità di utilizzo è la seguente:
$ slocate nomefile
Il comando è parte dei comandi integrati all'interno della shell bash
ed è particolarmente utile se si vuole modificare un file di configurazione
e ricaricarlo senza dover uscire dal sistema e loggarsi nuovamente. Un esempio
chiarisce più di cento parole:
# source /.bashrc
Immaginiamo la situazione: abbiamo apportato modifiche al file /.bashrc presente nella nostra HOME directory e relativo alle configurazioni personali della nostra shell bash dei comandi. Per poter disporre subito dei cambiamenti fatti possiamo digitare il comando come illustrato oppure uscire dal sistema ed entrare nuovamente.
Questo comando è utile quando si desidera dividere un file con dimensioni elevate
in varie parti. Digitate:
$ split -b 1m moni.tif
In questo caso il file ``moni.tif'' verrà diviso in vari
file della dimensione di 1 Mbyte i quali saranno nominati con una sequenza di
lettere per determinare l'ordine. Per riottenere il nostro file è necessario
digitare:
$ cat xaa xab xac > moni.tif
Il file originale sarà ripristinato.
Utilizzare telnet (pagina ) per connessioni
remote può compromettere la propria sicurezza trasferendo dati in chiaro.
A questo viene incontro il client ssh che instaura una connessione
sicura tra due macchine in rete crittando la trasmissione dei dati. La forma
tipica di utilizzo è la seguente:
$ ssh -l nomeutente nomeserver
L'utilizzo del client prevede l'esistenza del demone sshd (lato server) attivo e configurato per accettare le connessioni di questo tipo.
Questo comando serve per cambiare la propria modalità utente in una diversa
o quella relativa all'utente root. Digitate:
$ su -
Password: *******
[root@dada /root]#
L'opzione ``-`` attiva la configurazione della shell dell'utente indicato. In ogni caso è richiesta la password tranne per il passaggio da utente root a utente normale per ovvie ragioni.
Questo comando vi permette di comunicare con altri utenti presenti sul vostro
server o collegati a server remoti nella vostra rete locale o su Internet. Se
desiderate parlare con l'utente madrid è necessario digitare quanto segue:
$ talk madrid@localhost
Nell'esempio appena visto si sottointende che l'utente ``madrid''
sia presente e collegato al nostro server. Per conoscere queste informazioni
fate riferimento al comando ps che vi permette inoltre di conoscere
l'interfaccia utilizzata dall'utente nel sistema ed utilizzarla come alternativa
al suo nome:
$ talk pts/2
Nell'esempio che segue viene illustrato l'utilizzo del comando utilizzando la
forma utente@dominio che in questo caso è la macchina locale:
$ talk madrid@localhost
Il nome dominio è ``localhost'', genericamente inteso
come il server locale sul quale vi siete collegati. Se disponete di un server
collegato ad Internet e desiderate chiamare un vostro amico collegato
su un altro server in rete è necessario specificare un dominio con la denominazione
tipica della rete:
$ talk madrid@erlug.linux.it
Se l'utente chiamato accetta la chiamata potrete dialogare direttamente con lui e scambiarvi dati in modalità testo.
Questo comando serve per archiviare un insieme di file in un solo file e viene
utilizzato nel seguente modo:
$ tar -c archivio.tar Directory/
Nell'uso quotidiano il file archivio viene spesso compresso utilizzando sempre
lo stesso carattere ma con opzioni aggiuntive:
$ tar -zcvf archivio.tar.gz Directory/
Nell'esempio appena visto si utilizza l'opzione ``z''
per la compressione dei dati tramite gzip, l'opzione ``c''
che indica la creazione di un archivio, l'opzione ``v''
(verbose) per visualizzare i messaggi di esecuzione e l'opzione ``f''
per definire il nome del file archivio. L'estensione ``.tar''
è puramente indicativa. Se si volesse creare un archivio multivolume utilizzando
dei floppy-disk HD, digitate:
$ tar -cvfM /dev/fd0H1440 archivio/
L'opzione ``M'' creerà vari volumi a seconda della situazione.
Per riunire i vari multivolumi è necessario utilizzare il comando cat nel seguente
modo:
$ cat 1.tar 2.tar > archivio.tar.gz
Per scompattare il file creato è necessario digitare:
$ tar -zxvf archivio.tar.gz
oppure con
$ tar -xvf archivio.tar
Se l'archivio non è compresso gzip.
Questo comando controlla la configurazione di TCP_WRAPPER e
vi segnala eventuali configurazioni errate. Digitate:
# tcpdchk
Se vengono riscontrati errori è necessario modificare i file /etc/hosts.deny e /etc/hosts.allow.
Utile comando per monitorare una interfaccia di rete nel sistema locale.
# tcpdump -i eth0
E' un sistema molto rudimentale e può essere sostituito con strumenti di analisi molto più gradevoli come ethereal.
Se c'è un programma storico questo è senza dubbio telnet,
un programma che permette di gestire connessioni remote ad un altro server per
amministrarlo ed eseguire programmi. Per poterlo utilizzare è chiaramente necessario
avere un accesso sul server interessato:
$ telnet
telnet>
Per conoscere l'insieme delle opzioni presenti digitare ``help'':
telnet> help
Per aprire una connessione ad un server:
telnet> open nomeserver
Per chiudere una connessione:
telnet> close
Utilizzando una forma compatta:
$ telnet -l utente nomeserver
Per effettuare una connessione sicura, crittata con particolari algoritmi,
si consiglia l'utilizzo di ssh (pagina ).
L'utilizzo di questa applicazione è utile se si intende monitorare il carico
del processore e visualizzare i processi attivi. Digitate il comando nel seguente
modo:
$ top
e successivamente apparirà quanto segue:
6:32pm up 1:16, 2 users, load average: 0.15, 0.11, 0.09
46 processes: 44 sleeping, 2 running, 0 zombie, 0 stopped
CPU states: 6.4% user, 3.6% system, 0.0% nice, 89.8% idle
Mem: 95504K av, 63940K used, 31564K free, 47496K shrd, 4964K buff
Swap: 60476K av, 0K used, 60476K free 34156K cached
PID USER PRI NI SIZE RSS SHARE STAT LIB %CPU %MEM TIME COMMAND
573 root 15 0 8784 8784 1656 R 0 5.2 9.1 3:54 X
641 root 9 0 1040 1040 836 R 0 2.7 1.0 0:01 top
631 root 4 0 3392 3392 2656 S 0 1.7 3.5 0:01 gnome-terminal
577 root 1 0 1324 1324 1008 S 0 0.3 1.3 0:02 fvwm2
4 root 0 0 0 0 0 SW 0 0.0 0.0 0:00 kpiod
...
Per uscire premete contemporaneamente i tasti e .
Questo comando agisce sullo standard input per tradurre, copiare, cambiare quest'ultimo
e riportare il risultato sullo standard output.
Conoscevo già il comando ma durante il Linux Meetingtypeset@protect
@@footnote
SF@gobble@opt
Bologna, 28/29 Ottobre 2000
typeset@protect
@@footnote
SF@gobble@opt
Linux Meeting - http://www.linuxmeeting.net
, il professor Roberto Di Cosmo durante il suo intervento ha presentato un ``utilizzo''
interessante del comando. Il suo obbiettivo era dimostrare quante informazioni
personali circolassero in un singolo documento .doc (scritto con MS Word). Il
documento mostrava all'apertura pochissime banali stringhe di testo eppure la
dimensione finale del documento era di 22k, cioè avrebbe dovuto contenere circa
22 mila caratteri, cosa del tutto falsa. Inizialmente Di Cosmo ha mostrato in
semplice analisi una visualizzazione ``cruda'' del documento tramite il
comando:
$ cat prova.doc
Le informazioni comparse erano eccessive e la seguente sequenza di comandi ha
operato per eliminare almeno gli spazi spazio(blank) presenti e altri
caratteri non significativi presenti nel documento:
$ tr -s '\000''' < prova.doc |tr -d '[:cntrl:]'
> prova.txt
La successiva visualizzazione del documento elaborato
$ cat prova.txt
ha pubblicamente dimostrato che in un documento di questo formato circolano informazioni come MAC address, codici identificativi, porzioni di testo scritto e cancellato nel documento e altro ancora. Pensate a quale valenza possono avere determinate soluzioni di sicurezza se alla fine circolano documenti in questo formato. Nessuna!
Questo comando è utile se si desidera avere un quadro generale sulle caratteristiche
del computer e conoscere alcune importanti informazioni di sistema. La forma
rapida e comune di utilizzo è la seguente:
$ uname -a
Linux dada 2.2.14-5.0 #1 Tue Mar 7 21:07:54 EDT 2000 i686 unknown
Dove l'opzione ``-a'' indica di rappresentare tutte le informazioni disponibili.
Questo comando compie una operazione inversa al comando mount
(pagina ), ovvero smonta il file system aggiunto. Riprendendo
l'esempio del cd-rom:
# umount /mnt/cdrom
Per svolgere l'operazione è necessario essere in una directory differente da quelle presenti nel file system che si desidera smontare.
Questo comando lancia un editor di testo molto diffuso nella famiglia dei sistemi
operativi Unix. Per creare un nuovo file, digitate:
$ vi pippo.txt
E' sicuramente un editor minimale nella propria interfaccia ma allo stesso tempo
molto potente. I comandi presentati nella tabella 10.1
riassumono le combinazioni di tasti per le operazioni più frequenti.
| ||||||||||||||||||||||||||||||
Questo comando blocca la console testo. Serve per proteggere ogni intrusione
locale al vostro sistema. Per attivarlo è necessario essere in modalità console
testo e digitare:
$ vlock
This TTY is now locked.
Use Atl-function keys to switch to other virtual consoles.
Please enter the password to unlock.
darshan's Password:
Per togliere la protezione è necessario digitare la propria password. Se l'ambiente
è quello grafico del Server X un comando analogo è xlock (pagina
).
Questo comando serve a comprimere un file. Per comprimere un file è necessario
digitare:
$ zip file.zip racconto.txt
Il file ``racconto.txt'' verrà compresso e verrà rinominato
come ``file.zip''. Per scompattare il file presente è
necessario utilizzare il comando unzip:
$ unzip file.zip
Questo comando serve per conoscere dati relativi ad un file di testo:
$ wc documento.txt
Verrà presentata una serie di informazioni, selezionabili con le seguenti opzioni:
$ wc -w documento.txt
560 documento.txt
otteniamo il numero di parole presenti nel file.
Questo comando serve a ricercare la descrizione per ogni comando indicizzando
la pagine manuale. Se desiderate avere la descrizione del comando ls
digitate:
$ whatis ls
Verrà presentata una breve descrizione. Se dovesse apparire un messaggio del
tipo:
ls: nothing appropriate
E' necessario eseguire da amministratore il comando makewhatis per creare l'indice
delle descrizioni. Un comando analogo a whatis è apropos
(pagina ).
Questo comando permette di mandare messaggi ad un determinato utente collegato
sul server locale. A differenza del comando talk, la comunicazione
in questo caso è unidirezionale. Per utilizzarlo è necessario digitare il comando
e il nome dell'utente di riferimento (nell'esempio seguente l'utente madrid),
premere il tasto INVIO e scrivere il proprio messaggio da riportare:
$ write madrid
Questo è un messaggio di esempio
Se l'utente ``madrid'' è collegato al server locale riceverà
quanto segue:
$
Message from darshan@dada on pts/3 at 03:46 ...
Questo è un messaggio di esempio
Attraverso questo comando è possibile avere informazioni sugli utenti connessi
al sistema. La sintassi di utilizzo è la seguente:
$ who
root tty1 Nov 8 15:02
root tty2 Nov 8 16:00
Applicazione per l'ambiente X Window. Permette di visualizzare un file con estensione
.dvi. Digitate:
$ xdvi documento.dvi
Per maggiori informazioni relative al formato file andate a pagina .
Questo comando vi permette di bloccare lo schermo e le vostre attività da intrusioni
altrui. Il concetto è simile a quello visto per vlock (pagina
) in modalità console testo. Per attivare questa protezione
è necessario digitare:
$ xlock
Utilità per aggiungere parametri aggiunti al Server X senza riavviarlo. Nell'esempio
che segue gestiamo i font path, i percorsi dove sono disposti i caratteri.
$ xset fp+ /usr/X11R6/lib/fonts/directory/
Per rimuovere un percorso:
$ xset fp- /usr/X11R6/lib/fonts/directory/
Applicazione per l'ambiente X Window. Questo comando permette di mostrare e
configurare strumenti di puntamento per l'ambiente grafico. I puntatori devono
essere precedentemente configurati nel file di configurazione XF86Config:
$ xsetpointer -l
``keyboard'' [XKeyboard]
``pointer'' [Xpointer]
``wacom'' [wacom]
Nell'esempio appena visto l'opzione ``-l'' ci elenca i
puntatori configurati. Se decidiamo di cambiare il puntatore dal mouse comune
alla tavoletta grafica presente digitiamo:
$ xsetpointer wacom
Applicazione per l'ambiente X Window. Permette di configurare lo sfondo dell'ambiente
utilizzando immagini (in formato .bmp) e colori solidi:
$ xsetroot -solid blue
Il comando appena digitato imposta il colore blu come colore di sfondo.
Applicazione per l'ambiente X Window. Rappresenta uno dei terminali maggiormente
utilizzati e supporta un'ampia serie di emulazioni terminale.
$ xterm
Se desideriamo configurare maggiormente questa applicazione possiamo aggiungere
delle opzioni sulla riga di comando:
$ xterm -rightbar -bg white -fg black
In questo modo lanciamo xterm con la barra di scorrimento sulla destra e con caratteri neri su sfondo bianco. Premendo contemporaneamente il tasto sinistro (o il tasto destro) del mouse e il pulsante compariranno dei menu descrittivi per rapide configurazioni del programma.
Applicazione per l'ambiente X Window. Permette di configurare le frequenze video
del monitor e operare sulla centratura:
# xvidtune
La direzione dei sistemi operativi, GNU/Linux compreso, punta ad ambienti desktop grafici. Le motivazioni di questa direzione sono da trovare in una maggiore semplicità ed intuitività nell'utilizzo di una soluzione informatica per i propri personali obiettivi. Nonostante gli aspetti di interattività citati, conoscere la shell e comandi in modalità testo rende facile lo svolgimento di comandi sequenziali nella logica del ``pipe''. La shell, seppur ostica per un utente alle prime armi, può offrire una flessibilità molto superiore a quella che offre un'interfaccia desktop.
.
Quanto è importante proteggere i propri dati e i propri messaggi in rete?''
La propria privacy è un diritto innegabile e la possibilità che altrui persone possano captare illecitamente le vostre comunicazioni via email è un caso remoto ma non impossibile. Misurate il vostro livello personale di paranoia e giudicate voi stessi quanto possa esservi utile proteggervi grazie alla crittografia.
La risposta è ``Sì'' e per questa esigenze torna utile il comando batch
utilizzato nella seguente forma:
# batch -f script_shell.sh
Quando il carico del processore sarà sotto il limite definito (default 0.8) l'eseguibile verrà lanciato.
Linux Facile - ver.4.0 - http://www.linuxfacile.org
autore: Daniele Medri <madrid@linux.it>