IL SISTEMA OPERATIVO UNIX
Roberta Cantaroni - Cristina Murari -
Laura Virgili
giugno 1997
LA STORIA DI UNIX
Nel 1960 da una collaborazione tra MIT,
BellLabs e General Electric nacque un sistema di seconda generazione
time-sharing MULTICS (MULTiplexed Information and Computing Service) scritto in
PL/1
Thompson riscrisse MULTICS su un PDP-7
chiamandolo UNICS (UNIplexed Information and Computing Service), poi
trasformato in UNIX
Thompson e Kernighan trasferirono UNIX
su un PDP-11/45 e su un PDP-11/70
Per evitare di riscrivere UNIX su ogni
macchina decisero di scriverlo in un linguaggio di alto livello, denominato B
(da BPCL). Ritchie trasformò B in C, scrive un ottimo compilatore per C e
Thompson e Ritchie riscrissero UNIX in C (1974).
Grazie al fatto che UNIX era fornito
insieme al codice completo sono stati numerosi i contributi degli utilizzatori
che hanno portato alla prima versione standard Version 6 (dal fatto che era
descritta nella sesta edizione dello UNIX programmer's manual). In pochi anni si
è passati alla versione 7 e alla metà degli anni 80 alla installazione
su minicomputer e workstation e alla diffusione commerciale.
Johnson dei BellLabs scrisse una
versione del compilatore C portabile, cioè capace di produrre codice per ogni
macchina.
Nel 1984 nasce AT&T che fece uscire
la prima versione commerciale di Unix AT&T, System III e System V.
Una delle prime università che acquisto
UNIX fu quella di Berkeley in California, che modificò il sistema
sostanzialmente e, grazie al contributo del DARPA (Defense Advanced Research
Projects Agency) rilasciò la versione 1BSD (First Berkeley Software
Distribution), seguita dalla 2BSD per PDP-11 e dalla 3 e 4BSD per VAX. Tra i
contributi principali di Berkeley l' introduzione del networking con il
protocollo di rete BSD, detto TCP/IP, divenuto poi uno standard,
l'inclusione del vi, la csh, i compilatori Pascal e Lisp. Ciò fece sì che i
maggiori venditori si appoggiassero alla BSD piuttosto che alla ufficiale
System V e che tale versione di Unix si diffondesse nel mondo accademico, della
ricerca e della difesa.
Alla fine degli anni 80 ci furono
quindi due versioni di UNIX abbastanza diverse: 4.3BSD e System V Release 3,
più altre personalizzazioni dei venditori, il chè impediva la scrittura di
software generale per UNIX e ne limitava il successo.
Il primo serio tentativo di
standardizzazione è stato fatto sotto il controllo dell' IEEE Standards Board
da un gruppo di lavoro composto da industria, università e governo detto POSIX
(Portable Operating System) che produssero lo standard 1003.1, un
insieme di routine di libreria, ad esempio chiamate di sistema come open, read,
fork. Anche il C venne standardizzato da ANSI ed ISO.
Un gruppo di venditori, come HP, IBM,
DEC non soddisfatti del fatto che AT&T avesse il controllo sul resto di
UNIX decisero di fondare OSF (Open Software Foundation) per produrre un
sistema che rispondesse agli standards IEEE ma che contenesse altre utilità
come il sistema a finestre X11, una interfaccia utente grafica MOTIF, ...
AT&T creò allora un suo consorzio UI
(Unix International) per fare la stessa cosa basandosi su System V. Oggigiorno
non si parla quasi più di versione AT&T o BSD, ma si identifica il tipo di
Unix con la casa produttrice; si ha cosi HP-UX ( Unix dei sistemi HP), AIX (
Unix su IBM ) etc..
I principali sistemi sono :
HP-UX di HP
IRIX di Silicon Graphics
SunOs di Solaris
Aix di Ibm
Dec di Digital
STRUTTURA DEL SISTEMA UNIX
Il sistema operativo UNIX è un sistema MULTI-USER e MULTI-PROCESS: ogni utente
può eseguire diversi processi simultaneamente.
Unix puo` essere visto come un sistema
piramidale: alla base c'e` l'hardware con CPU, memoria, dischi, terminali e le
altre devices. Il sistema operativo Unix ha il compito di controllare
l'hardware e di fornire una interfaccia alle chiamate di sistema a tutti i
programmi. Le chiamate di sistema permettono ai programmi utente di controllare
e gestire i processi, i files e le altre risorse.
Tutte le versioni di Unix forniscono
poi un grande numero di programmi standard come shell, compilatori, editors,
programmi per la formattazione di testi e per la manipolazione di files: sono
questi i programmi richiamati dall'utente durante una sessione di lavoro.
Programmazione:
compilatore C, APL, Pascal, Basic,
Fortran, Lisp
strumenti per la costruzione di
compilatori (yacc, lex)
Text processing:
strumenti di formattazione e
preparazione di documenti e testi matematici (troff, nroff, tbl, pic, ...)
Comunicazione elettronica:
posta elettronica, talk tra utenti
Programmi di utilità:
editor vi, emacs
software di public domain -
compressori, ...
Si distinguono quindi 2 modalità di lavoro e 3 interfacce a UNIX:
USER MODE
- user interface, formata dal set di
programmi di utilita`
- library interface
KERNEL MODE
- true system call interface
Le piu` recenti versioni di Unix hanno
modificato l'interfaccia utente trasformandola da interfaccia con solo la
tastiera a interfaccia grafica GUI con finestre e mouse, senza modificare la
base del sistema operativo, tramite il sistema X Windows.
ACCESSO AL SISTEMA
Gli utenti di un sistema Unix si
dividono in tre categorie:
di sistema
root l'utente più importante
bin
daemon
sync
uucp
...
amministrativi
sysadm
setup
powerdown
...
ordinari
corso
robby
murari
...
L'accesso alla macchina avviene
digitando alla richiesta di login una username definita nella macchina e la password
che non compare durante la battitura, per ragioni di sicurezza.
Ad esempio:
login: corso
Password:
L'utente corso dopo avere digitato la
password corretta apre sulla macchina una
sessione di login.
L'utente accede automaticamente ad una
zona disco (direttorio) fissato
dall'amministratore del sistema che ha sempre nome uguale a quello dell'utente
(corso) e percorso dipendente da macchina a macchina (es. /users/corso).
Il sistema UNIX assegna all'utente
corso un interprete personale di comandi,
cioè una copia di un processo shell
(es. /bin/sh, /bin/csh)
L'utente vede comparire un prompt
variabile secondo la shell che gli è stata assegnata: in bourne shell (/bin/sh) si
hanno a disposizione due prompt di default
$ prompt per utente ordinario
# prompt per utente root
in c-shell (/bin/csh) si ha a
disposizione il prompt di default
% prompt per utente ordinario
Nelle shell avanzate (/bin/tcsh) si può
settare il prompt con nome della macchina, direttorio di lavoro, ... (es.
c220:/users/corso ->)
A questo punto l'utente può interagire
con il sistema digitando dei comandi
che verranno interpretati dalla shell, ad esempio
ls -al lista file nel direttorio di
lavoro
exit uscita dal sistema
Può inoltre creare o cancellare file o
direttori, può
editare file, fare compilazioni,
stampare, spedire messaggi di posta ad altri utenti sulla stessa macchina o
sulla rete, parlare interattivamente con altri utenti, mandare processi in
background, ...
Da quanto sopra si può osservare che:
1. Unix è un sistema operativo case-sensitive, cioè esiste differenza tra
lettere minuscole e maiuscole: tutti i
comandi Unix sono in lettere minuscole.
2. Il separatore tra il nome di un sottodirettorio e
l'altro è il simbolo / : il primo / davanti al nome di un direttorio indica la
radice dell'albero dei direttori e corrisponde anche al direttorio nel quale ci
si trova collegandosi come root.
3. L'utente colloquia con il sistema operativo attraverso
la shell e digitando comandi: i comandi Unix hanno
generalmente una sintassi standard.
<comando> <opzioni> <argomenti>
dove:
<comando> : è l'istruzione data il cui nome
corrisponde ad un file di tipo oggetto
<opzioni> : sono
variazioni ed ulteriori specifiche alcomando stesso (precedute
dal carattere "-")
<argomenti> : sono generalmente i file su cui deve
intervenire il comando
4.
Gli elementi base di un sistema Unix sono:
file
system
- directory
- files
- processi
- shell o
interprete di comandi
FILE SYSTEM
Il file system è il modo astratto del
kernel di organizzare i dispositivi di massa presenti sulla macchina (HD,
CD-Rom, ...)
I dispositivi sono integrati sotto un
unico albero con inizio in / ( root ) e le varie parti che compongono questo
albero sono appunto dette file system.
Fs principale / (root )
2° Fs /var
3° Fs /utenti
Struttura di un file system
Area per bootstrap
-------------------
superblocco inform. su dimensione
file system e I-list
-------------------
I-list inform. rel. ai file
(I-node)
-------------------
dati (data blocks)
puntatori (indirect blocks)
blocchi liberi (first free-list block)
-------------------
- data
blocks (directory entries - nomefile + numero I-node - o file data)
- indirect
blocks (per referenziare i dati oltre i 10 blocks)
- blocchi
liberi (lista di tutti i blocchi non usati, il superblocco punta al primo
libero)
Il comando df (disk free)
consente di visualizzare quali file
system sono montati sulla macchina nella quale stiamo lavorando, quale e` la
loro dimensione e quanto spazio e`ancora disponibile.
$ df -k (in blocchi da 1024 bytes)
Filesystem
kbytes used avail %used Mounted on
/dev/dsk/c0t6d0 339066 270976 34183 89%
/
/dev/rsquared/utenti 1995505 530848
1265106 30% /utenti
/dev/dsk/c0t4d0 1290610 469854 691695
40% /usr
/dev/rsquared/scratch 2003481 1407802
395330 78% /scratch
Il comando mount
Serve per montare un fs nel relativo
punto di mount ( / o altro direttorio )
Il direttorio a partire dal quale si
effettua il mount è normalmente un direttorio vuoto, se per caso contiene dati
questi saranno non visibili quando si effettua il mount, ma non verranno
cancellati, saranno visibili nuovamente quando si effettuerà l' unmount del fs.
mount device
punto_di_mount opzioni
Ad esempio :
$ mount -F vxfs /dev/dsk/c0t3d0s7 /opt
$ umount /opt
La descrizione dei fs da montare in
fase di boot sono descritti in un file il cui nome varia da sistema a sistema (
/etc/fstab oppure
/etc/checklist in HP-UX o /etc/vfstab
su Solaris)
entry
nome_device punto_di_mount tipo_di_fs
parametri opzioni
tipo_di_fs normalmnete si seleziona il
tipo di fs caratteristico del sistema oppure si possono avere particolari tipi
come nfs ( se si utilizza un fs remoto in rete )
parametri ex: rw , si determina il tipo
di permessi sul fs
rw=read+write =letture e scriittura
opzioni ex: mettere il numero 0
significa che del fs è
possibile effettuare un dump di livello
zero
Es. : /etc/fstab
questo file è letto da mount, fsck,
umount, swapon:
/dev/dsk/c0t6d0 / hfs defaults 0 1 #
root volume
/dev/rsquared/scratch /sw hfs rw,suid 0
2
/dev/rsquared/utenti /mnt hfs rw,suid 0
2
/dev/rsquared/swap1 ... swap pri=1 0 0
File che contiene la lista dei file
system montati /etc/mntab
Esempio di creazione di un file system
su floppy da 1.44mb
(sistema operativo LINUX):
Formattazione fisica:
# fdformat /dev/fd0H1440
(in aggiunta # mformat a: per creare un
filesystem di tipo msdos mediante il pacchetto /etc/mtools)
Creazione di un file system (formato ext2):
# mkfs -t ext2 -c /dev/fd0H1440 1440
Montaggio
# mount -t ext2 /dev/fd0H1440 /mnt
Utilizzo del file system:
# cp *.tex /mnt
Smontaggio del file system:
# umount /mnt
Estrazione del dischetto.
DIRECTORY
/ ____________________: home directory
utente root
/users/corso ___________: home
directory utente corso
._____________________: indica il
direttorio corrente di lavoro
.. ____________________: indica il
direttorio padre
/users/corso ___________: path assoluto
del direttorio corso
cd /users
corso ________________: pathname
relativo del direttorio corso
./corso _______________: a partire dal
direttorio /users
Il nome di un file può contenere
caratteri speciali o nascosti, non richiede estensione, è assegnato dall'utente
in base a convenzioni: ad esempio un file di testo contenente un programma C
può essere chiamato prova.c ma anche prova.
Il nome di una directory può avere
lunghezza massima 14 caratteri e può contenere caratteri speciali o nascosti.
Questo e` un elenco delle directory standard che si possono
trovare in tutti i sistemi Unix.
/................:diettorio radice
radice - contiene il kernel >
/bin.............:comandi piu` usati
(file binari)
/dev.............:file speciali per I/O
su devices
/etc.............:utilita` varie system
administration
/lib..............:librerie piu` usate
/tmp.............:direttorio per file
temporanei
/usr..............:file degli utenti
/usr/adm........:system accounting
/usr/bin.........:altri comandi (file
binari)
/usr/include....:system header files
/usr/lib..........:librerie,
precompilatori
/usr/man.........:manuali on-line
/usr/spool.......:direttorio di
spooling ed altri daemons
/usr/tmp.........:direttorio per altri
file temporanei
FILES
Un file UNIX è una sequenza di byte (8
bit = 1 carattere)
Per il sistema ed i programmi da esso
gestiti, i file su disco, i nastri magnetici, i messaggi di posta in arrivo, i
caratteri da tastiera, l'output delle stampanti, ..., non sono altro che
sequenze di byte.
Il sistema non impone alcun tipo di
struttura ai file e non assegna significato al loro contenuto, ma i byte
assumono significato in funzione del programma che li interpreta.
Esiste un solo tipo di file e tutto
quello che serve per accedervi è il nome.
Il nome di un file non deve superare i
14 caratteri ed è utile usare solo caratteri "visibili".
I file vengono raggruppati in DIRECTORY
secondo una struttura gerarchica ad albero.
Si distinguono in:
- file
ordinario
collezione di caratteri per memorizzare
informazioni
- direttorio
super-file che contiene un gruppo di
file o altri direttori (detti sottodirettori): il contenuto di un direttorio è
l'indice dei nomi dei files/direttori contenuti
- file
speciale
rappresenta una device fisica, come un
terminale, disk
drive, magnetic tape drive. Il sistema
legge e scrive i file speciali come fossero file ordinari
ls (list) lista
il contenuto di una directory
$ cd /users/corso
$ ls
provafile
$ ls -l lista lunga (esclusi i file che iniziano per .)
$ ls -al lista lunga con tutti i file (anche
quelli che iniziano per .)
Tra le opzioni del comando ls
ricordiamo:
$ ls -t lista in ordine temporale di accesso o modifica dei file
$ ls -rt lista in ordine cronologico inverso
$ ls -alR lista compresi i sottodirettori
$ ls provafile controllo esistenza file
$ ls -l /usr/bin lista lunga direttorio /usr/bin
$ ls -i i-node di un file
$ ls -Hal lista lunga con indicazione dei link
I-NODE
L'opzione -i del comando ls permette di
visualizzare in forma decimale il numero
di INODE del file che lo identifica nella I-list.
Tra le informazioni contenute nell'
i-node troviamo:
1. nome utente e gruppo
2. contenuto ed indirizzi di accesso al
contenuto
3. autorizzazioni
4. lunghezza del file
5. numero di connessioni al file (link)
6. tipo di file
7. ora (di ultima modifica, di ultimo
utilizzo, di modifica dell'inode)
Tra le informazioni non troviamo il
nome del file che è memorizzato nell'indice del direttorio: il numero di inode
collega quindi il nome del file ai dati.
Link fisico e simbolico tra file
Lo stesso numero di inode può comparire
in più di un indice ed i file possono avere nome diverso pur facendo
riferimento allo stesso file fisico su disco (si parla di link fisico tra file - comando ln).
$ ln file1 target
- crea target, se esiste già viene
cancellato e riscritto senza avviso
- file1 e target hanno lo stesso i-node
- l'i-node punta ai dati
Modificando il file vengono
automaticamente modificate le copie unite in un link. Cancellando uno di questi
file si elimina solo un link e solo eliminando l'ultima copia si elimina il
file fisico.
Il link fisico è possibile solo sullo
stesso file system.
Con il comando ln -s si ottiene invece
un link simbolico, cioè si può
attribuire ad un file fisico un nome simbolico, anche in un file system diverso
$ ln -s file1 target
- crea target, se esiste già chiede
cconferma della sovrascrittura
- file1 e target hanno i-node diverso
- l'i-node punta al nome
Cancellando l'originale (file1) si
perde il file.
Le autorizzazioni
$ ls -l
drwxr-xr-x 3 corso utenti 1024 Jan 15 14:22 preserv
-rw-r----- 1 corso utenti 80075 Jul 28 08:28 provafile
Il primo carattere identifica il tipo
di file:
- file comune
d directory
c file speciale di tipo carattere
b file speciale di tipo blocco
l link simbolico
...
Gli altri 9 caratteri identificano le
autorizzazioni:
Segue l'indicazione del numero di link
del file o di sottodirettori del direttorio, del proprietario del file, del
gruppo di appartenenza, la data e l'ora (o l'anno) di ultima modifica, la
dimensione del file (in byte) o della directory (in blocchi) e il nome del
file/directory.
COMANDI PRINCIPALI SU FILES E DIRECTORY
Ogni comando restituisce all'interprete
di comandi un valore che segnala come è andata la sua esecuzione (exit
status)
0 significa "vero", cioè
comando eseguito ottenendo i risultati richiesti
diverso da 0 significa
"falso", cioè comando eseguito senza i risultati voluti
$ cmp .profile .profile
$ echo $?
0
$ cmp provafile .profile
... (output con differenze tra i due
file)
$ echo $?
1
Unix scrive su terminale un messaggio
di errore in risposta ad un comando scorretto per:
- errore di battitura
- errato numero o tipo di parametri
- comando incompleto
Alcuni
errori tipici:
$ cd prova
prova: bad directory il nome
specificato o non esiste , o è quello di un file
$ cat prova non trova il file prova
cat: cannot open prova
$ cp prova1.c comando incompleto
cp: Insufficient arguments (1)
spiegazione errore
Usage: cp f1 f2
cp f1 ... fn d1 help su cp
$ rm prova
rm: prova non-existent non trova il
file prova
$ ls prova3.c
prova3.c: No such file or directory
non esiste un file o una
directory con quel nome
Comandi
man : comando
richiama la pagina di manuale
pwd
: (print working directory)
mkdir nome_directory
: crea una directory
cd nome_directory
: cambia directory
Es
:
$ cd /users/corso
$ cd ..
$ cd ./corso
$ cd /usr/bin
$ cd riporta nella home directory
vi file : edita un file (vd. Appendice)
mv nome_directory
nuovo_nome : cambia nome
ad una directory, anche non vuota
rmdir nome_directory : cancella una directory (solo se vuota)
cat nome_file
: stampa il contenuto dei file indicati come
argomento su terminale
Es
:
$ cd /users/corso
$ cat provafile
...(output su terminale)
$ cat provafile .profile
... (i file risultano concatenati uno
dopo l'altro su terminale)
$ cat provafile | more
$ cat provafile | pg
more
nome_file
: stampa il contenuto dei file indicati come
argomenti in paginate successive su terminale
prompt -More- 10%
comandi utili:
spacebar : videata successiva
<CR>
: avanti di una linea
q : uscita
pg nome_file stampa il contenuto dei file indicati come argomenti in paginate
successive su terminale
prompt :
comandi utili :
<CR> : videata successiva
l : linea successiva
h : help
q : uscita
/stringa : ricerca
stringa in avanti
?stringa
: ricerca stringa all'indietro
cp
nome_file altro_file
: copia un file in un altro
Es :
$ cp provafile secondo
$ ls
provafile
secondo
$ cp -r /users/corso /users/prova
esegue la copia di file e
sottodirettori
mv
nome_file altro_nome
: rinomina un file
rm nome_file : cancella un file
ATTENZIONE : i comandi mv
e cp non chiedono conferma in caso di sovrascrittura ed il comando rm non
chiede conferma della
cancellazione
(opzione -i).
file nome_file : permette di conoscere il tipo diun file
- il comando NON prende in
considerazione il nome del file, perchè l'assegnazione avviene in base a
convenzioni
- il comando legge le prime centinaia
di byte contenute in un file per rintracciare gli elementi identificativi del
tipo (eseguibile, file di testo, script di shell, ...)
od nomefile : (octal dump) permette di visualizzare in
ascii, binario, esadecimale il contenuto di un file.
Se applicato ad un direttorio, si
ottiene l'indice del direttorio nel formato "numero
di inode, nome del file" (questo consente di visualizzare anche il
nome di file/direttori precedentemente cancellati dall'indice del direttorio)
du : (disk usage) permette di visualizzare il numero di
blocchi disco (da 512 o 1024 bytes) occupati da un direttorio dato e dai suoi
files
lp : stampa un file su stampante locale/remota
in BSD
lpr file :
stampa un file
lprm jobid : rimuove un file in coda
lpq : situazione delle
stampe
in AT&T
lp file : stampa un file
cancel jobid
: rimuove un file in
coda
lpstat : situazione delle stampe
find : permette la ricerca di file a partire da un direttorio
dato : find
direttorio -condizioni -azione
condizioni
-user user : cerca i file
di user (nome o UID)
-group group : cerca i file
di group (nome o GID)
-name espres : cerca i file con
nome che verifica espres (*.txt, ...)
-perm perm
: cerca i file con
autorizzazioni perm (in ottale o in notazione -rwx....)
-type tipo
: cerca i file del tipo specificato
(f,d,l,b,c)
azione
-print scrive
: il path completo dei
file trovati
-fprint file : scrive nel
file file
-exec comando \; : esegue comando su ogni file trovato
-ok comando
\; : come exec ma chiede
conferma
Es
:
find / -name passwd -print
find / -name "core.*" -ok rm
{} \;
find /home/corso -name
"*.txt" -exec cp {} /tmp/testi \;
find / -perm 777 -fprint
/tmp/non_protetti
find /usr -name "*.Z" -exec
tar -rvf archivio.tar {} \;
grep schema nomefile
: (globally look for a regular expression and
print) ricerca e stampa le righe di nomefile in cui ricorrono gli elementi di
schema
Es :
$ grep pippo nomefile ricerca pippo in
nomefile
$ grep From $MAIL righe che contengono
From
$ grep '^From' $MAIL righe che iniziano
per From
$ ls -l | grep '^d' nomi dei
sottodirettori
$ grep -n pippo nomefile elenca anche
il numero di riga
awk 'programma' nomi_di_file : ( da Al Aho, Peter Weinberger,
Brian Kernighan)
dove : 'programma ' --->
'/espressione/ {print ...}'
1. legge l'input dai file specificati
una riga alla volta
2. ogni riga viene confrontata con
ciascuna espressione, in ordine di sequenza
3. per ogni espressione soddisfatta
dalla riga viene eseguita l'azione richiesta (es. print)
awk suddivide le righe di input in campi,
cioè in stringhe di caratteri separate da spazi o segni di tabulazione che
chiama $1, $2, ..., $NF
Es
:
$ du -a | awk '{print $2}'
scarta le informazioni relative alla
dimensione dei files
$ who | awk '{print $1, $5}'
stampa i nomi degli utenti e l'ora di
collegamento
awk prevede anche la variabile
$0 intera riga di input, non modificata
NR numero del record o della riga di input corrente
Es
:
$ awk '{print NR, $0}'
aggiunge i numeri di riga ad un flusso
di input la virgola viene sostituita dallo spazio in fase di stampa
È possibile anche la gestione dei
formati di output:
$ awk '{printf "%4d %s \n",
NR, $0}'
Altri esempi di awk:
Gli schemi BEGIN ed END:
$ awk 'BEGIN { FS=":"} \
> $2==""' /etc/passwd
le azioni di BEGIN sono eseguite prima della lettura della prima riga del
file
$ cat file_input | awk 'END {print NR}'
le azioni di END sono eseguite dopo l'elaborazione dell'ultima riga di
input
Uso di funzioni:
$ awk -F: '$2 == ""'
/etc/passwd
$ awk -F: 'length($2)==0' /etc/passwd
$ cat file_input | awk
'length($0)>72 {print "Linea", NR, "troppo lunga",
substr($0, 1, 60)} '
$ echo
Uso di operatori matematici:
$ awk -F: 'NF%2 != 0'
file_input
$ cat file_input | awk '{s=s+$1} END
{print s}'
COMANDI PER LA COMUNICAZIONE TRA UTENTI
mail servizio di posta elettronica
$ mail
visualizza i messaggi di posta uno alla
volta in ordine di arrivo
Al prompt ?
d cancella il messaggio corrente
RETURN passa al successivo
s nomefile salva nel file nomefile
q exit
e elenco comandi
h elenco messaggi
$ mail robby
..... <RETURN>
..... <RETURN>
<CTRL-D> (o . su una riga
singola)
CC: (a chi spedire una carbon copy)
$
Il comando mail viene spesso sostiuito
da altri programmi (forniti con il sistema operativo o di public domain, come
il pine) che forniscono interfacce più semplici ed immediate per la lettura
della mail, la composizione di nuovi messaggi, la gestione di folder con nomi
relativi all'argomento delle mail, ...
write/talk
dialogo tra utenti
$ talk robby
Message from Talk_Daemon on c220 (
talk: Connection requested by
robby@c220.unimo.it
talk: Respond with talk
robby@c220.unimo.it
IL PROBLEMA DELLA SICUREZZA
Uno dei problemi più rilevanti in Unix,
sistema multi-user, è quello della protezione dei file di ciascun utente
e soprattutto di quelli di sistema, generalmente appartenenti all'utente root,
bin, sys, ...
Ogni utente è identificato anche da un
numero (UID, user identificator)
Ogni utente Unix appartiene ad un
gruppo identificato da un nome e un numero (GID, group identificator): generalmente, un gruppo identifica un
insieme di utenti che lavorano ad uno stesso progetto o che hanno
caratteristiche comuni.
Un gruppo può avere più utenti che gli
appartengono.
Un utente può appartenere a più di un
gruppo.
Ogni file/directory ha tre proprietà:
- il proprietario (owner)
- il gruppo di appartenenza (group)
- le autorizzazioni (quello che gli
utenti possono fare su quel file)
Il sistema di gestione dei file stabilisce
cosa un utente può fare in base alle autorizzazioni associate a UID e GID.
UTENTI
Il file /etc/passwd contiene
tutte le informazioni di identificazione di un utente. È possibile accedere e
leggere tale file con un cat o vedere solo le informazioni relative ad un
utente con il comando:
$ grep corso /etc/passwd
corso:xL1D5z9NEIeAw:102:100:Corso
Unix:/users/corso:/bin/csh
I campi sono separati dal simbolo :
corso.... username
xL1D5z9NEIeAw.... password crittografata
102.... numero identificativo utente (UID)
100.... numero identificativo gruppo (GID)
Corso Unix.... informazione sull'utente (opzionale)
/users/corso.... home directory dell'utente corso
/bin/csh.... shell assegnata all'atto del login
All'atto del login viene inserita la
password in modalità non visibile, viene crittografata e confrontata con quella
nel file /etc/passwd.
In molti sistemi Unix recenti la
password, per ragioni di sicurezza, non è inserita in passwd ma in un altro
file (/etc/shadow oppure /etc/secure ...). Le regole sulla definizione della
password variano da sistema a sistema: generalmente sono
- almeno 6
caratteri
- almeno 2
caratteri alfabetici
- almeno 1
carattere numerico
GRUPPI
Il file /etc/group contiene la
definizione dei gruppi.
root::0:root
other::1:
bin::2:root,bin,daemon
...
user::100:corso
I campi sono separati dal simbolo :
user nome del gruppo
password crittografata (sconsigliata
!!!)
100 numero identificativo di gruppo
corso lista (separatore il simbolo ,)
di tutte le
username che appartengono a quel gruppo
AUTORIZZAZIONI
Le autorizzazioni per un file sono visualizzabili con il comando ls -l seguito dal
nome del file:
r autorizzazione alla lettura
w autorizzazione alla scrittura
(modifica/cancellazione)
x autorizzazione alla esecuzione
- mancanza di una delle precedenti
autorizzazioni
le autorizzazioni per una directory sono visualizzabili con il comando ls -ld seguito
dal nome del direttorio:
$ ls -ld preserv
drwxr-xr-x 3 corso utenti 1024 Jan 15 14:22 preserv
d è una directory
r si possono effettuare operazioni di
lettura (ls)
w si possono creare e cancellare file
(comandi vi, rm, ...): tali operazioni implicano la modifica nell'indice della
directory
Attenzione: chi è autorizzato a scrivere in un indice può rimuovere anche i file
protetti nei confronti di eventuali immissioni: questo è l'unico caso nel quale
Unix chiede conferma prima di eseguire un rm.
x si possono cercare file nella
directory (cd, find)
Ad esempio:
--x si può accedere a tutti i file di
cui si conosce l'esistenza ma non usare ls e neppure leggere l'intera directory
r-- si può listare il contenuto di una
directory con ls ma non farne uso Per modificare le autorizzazioni associate ad
un file si usa il comando chmod
chmod autorizzazioni nomi_file
2 modi possibili
1. numeri
in base 8 (es. $ chmod 666 nome_file)
R W X
4 R - - - 0 2 W - - X 1 1 X - W - 2 7 - W X 3 R - - 4
R - X 5 R W - 6 R W X 7
2. descrizioni
simboliche (es. $ chmod +x nome_file)
+ autorizzazione concessa
- autorizzazione non concessa
+x equivalente a a+x (a=all)
u+x solo owner
g+x solo group
o+x solo other
$ chmod 444 nome_file (o chmod -w
nome_file)
$ ls -l provafile
-r--r--r-- 1 corso utenti 80075 Jul 28 08:28 provafile
$ rm provafile
provafile: 444 mode?
Il comando umask stabilisce la protezione di default di ogni file o directory
creata dall'utente. La maschera di protezione per default è
666 -rw-rw-rw- per un file
777 drwxrwxrwx per una directory
ed è settata nel file di
inizializzazione (/etc/profile o /etc/csh.login) lanciato in esecuzione dopo il
login e prima della esecuzione del file di personalizzazione (.profile o
.cshrc).
Il comando umask si può utilizzare per
personalizzare le autorizzazioni su file e directory inserendolo nei file di
personalizzazione dell'ambiente (.profile, .cshrc) nel formato
umask 022 elimina il permesso di scrittura per
gli altri utenti del gruppo e per il mondo (autorizzazione 755)
PERSONALIZZARE IL PROPRIO AMBIENTE DI LAVORO
1. Cambiare la propria password
Il comando è
$ /bin/passwd
Changing password for corso
Old password: richiede la vecchia
password
New password: richiede 2 volte la nuova
Re-enter new-password:
La vecchia password non è richiesta se
è l'utente root che cambia la propria password o quella di un altro utente.
Generalmente, le due password devono
differire per almeno 3 caratteri, la nuova password deve differire dalla
username o da un suo shift circolare.
2. Settare le variabili di ambiente
Nel momento del login l'interprete di
comandi esegue i comandi presenti nel file /etc/profile (/etc/csh.login in csh)
e successivamente nel file $HOME/.profile
(~/.login e ~/.cshrc in csh)
Nel file .profile vengono definite
variabili come MAIL, PATH, TERM, PS1,
PS2, dette "variabili
dell'interprete" il cui valore è modificabile dall'utente, che può anche
crearne delle nuove.
|
PATH=/bin:/usr/bin:/etc:/usr/contrib/bin:/users/root:/usr/lib:/usr/lib/acct
TERM=hp
export
TERM /usr/bin/tset
#
Set up the terminal stty
erase "^H" kill "^U" intr "^C" eof
"^D" if
[ -x /usr/bin/tabs ] then
tabs
else
echo
"The command \"/usr/bin/tabs\" was not found." fi
#
Set up shell environment: set
-u # error if undefined variable. trap
"echo 'logout root'" 0 # what to do on exit. #
Set up shell variables: MAIL=/usr/mail/root
#
don't export, so only login shell checks. EDITOR=vi
export
EDITOR |
$HOME valore della variabile HOME, che
individua la
home directory: non deve essere
definita nel
.profile
$ $HOME
$ pwd
/users/corso
$MAIL file nel quale vanno i messaggi
di posta in arrivo e non ancora letti
$PATH percorso di ricerca dei comandi,
modificabile dall'utente secondo le sue esigenze
$ echo PATH e` $PATH
PATH e` $HOME/bin:/bin:/etc:/usr/bin
I PROCESSI
Un comando Unix corrisponde sempre ad
un programma, cioe` un file su disco (ad esempio, ls corrisponde a /bin/ls) di
tipo eseguibile, sia esso un file binario o un file di comandi.
Quando si fa eseguire un programma si
ottiene un processo: un processo e`
quindi l'unica entita` attiva in un sistema Unix.
I processi Unix sono sequenziali, cioe` ogni processo ha un
singolo flusso di controllo e quindi un contatore che tiene traccia della
prossima istruzione da eseguire.
In assenza di utenti collegati, girano
sulla macchina almeno una dozzina di processi detti daemons che partono automaticamente al bootstrap. Esempi di daemon
sono:
cron schedula altri processi (backup,
...)
sendmail posta elettronica
lpd gestione code delle stampanti
Un processo puo` essere eseguito in :
- modalita` foreground (interattivo)
il comando e` scritto accanto al
prompt, l'utente attende la fine del comando
- modalita` background (batch)
il comando e` scritto seguito dal
simbolo &, ritorna il prompt, il
sistema avvisa quando termina il comando.
Ogni processo e` identificato da un numero detto PID (process identificator).
Se lo stesso programma viene fatto
girare contemporaneamente da piu` utenti, per ognuno di essi si avra` un
diverso processo con un diverso identificatore.
Comando per contare caratteri, parole e
linee dei file ch* : l'output viene rediretto su wc.out ed il comando viene
mandato in background.
$ wc ch* > wc.out &
6944
$
Come si crea un processo ?
Ogni processo è creato da un altro
processo tramite una chiamata di sistema fork: la fork viene invocata da un
processo e crea una copia del processo che lo ha invocata.
Il processo di partenza si chiama parent
process, il processo nuovo child process.
La copia differisce dall' originale
solo per
- nuovo
numero di PID
- Ppid
uguale al numero del processo che la ha invocata
- informazioni
nuove sull' accounting
- propria
copia dei descrittori dei file coinvolti nel processo
Sia il parent che il child hanno una
propria memoria personale, cioe` se il parent cambia una variabile, i
cambiamenti non sono visibili al child e viceversa.I file aperti dal parent
prima della fork sono condivisi anche dal child.
Come fanno i processi a sapere quali di
essi deve girare il codice del parent e quali il codice del child?
Il segreto e` che la fork restituisce
come PID
zero al child
valore diverso da 0 al padre
Tale valore e` controllato da tutti i
processi secondo lo schema:
pid
= fork();
if (pid < 0) {
/* fork fallita, tabelle o memoria piene */
}
else if (pid > 0) {
/*
codice parent */
} else {
/* codice child */
}
Quando un child termina, il parent
ottiene il PID del figlio. Dato che un child puo` avere altri child, il
processo originale puo` generare un albero di processi.
Il comando ps (process status)
restituisce l'elenco dei processi attivi sulla macchina in un determinato
momento.
- BSD ps
-aux
- ATT ps
-elf ( -e informazioni su tutti i processi
-f lista completa
-l lista lunga (priorità, stato del
processo (waiting, sleeping) ...)
output
UID PID PPID C STIME TTY TIME COMMAND
root 0 0 0 Jan 2 ? 0:04 swapper
root 1 0 0 Jan 2 ? 0:01 init
root 2 0 0 Jan 2 ?
root 3 0 0 Jan 2 ?
root 4 0 0 Jan 2 ? 0:19 unhashdaemon
root 7 0 0 Jan 2 ? 0:00 ttisr
root 12 0 0 Jan 2 ? 0:00 lvmkd
root 16 0 0 Jan 2 ? 0:40 nvsisr
root 859 1 0 Jan 2 console 0:00
/usr/sbin/getty console console
root 569 1 0 Jan 2 ? 0:41
/usr/sbin/snmpdm
root 280 1 0 Jan 2 ? 0:26
/usr/sbin/swagentd
root 433 1 0 Jan 2 ?
daemon 4692 1 0
root 236 1 0 Jan 2 ?
root 338 1 0 Jan 2 ?
root 445 1 0 Jan 2 ? 0:02
/usr/sbin/portmap 1000 /var/adm/nettl /var/adm/co
root 383 382 0 Jan 2 ? 2:36
/usr/sbin/netfmt -C -F -f /var/adm/nettl.LOG00 -c /var/adm/c
root 347 1 0 Jan 2 ? 0:00
/usr/sbin/ptydaemon
root 641 1 0 Jan 2 ? 0:24
/opt/dce/sbin/rpcd
root 4763 860 0
root 497 1 0 Jan 2 ? 0:01
/usr/sbin/automount -f /etc/auto_master
root 476 1 0 Jan 2 ? 0:00
/usr/sbin/biod 4 root 509 1 0 Jan 2 ? 0:04 /usr/sbin/inetd root 837 1 0 Jan 2 ?
0:00 /usr/sbin/nfsd 4 root 678 1 0 Jan 2 ? 0:00 /usr/sbin/vtdaemon
daemon 953 860 0 Jan 2 ?
lp 727 1 0 Jan 2 ? 0:00
/usr/sbin/lpsched
root 737 1 0 Jan 2 ? 0:05 /usr/sbin/cron
root 4769 4763 0
llane 5520 5519 0
llane 5538 5520 163
root 4703 4688 0
root 4688 860 0 15:19:21 ? 0:00
/usr/vue/bin/vuelogin
rossella 2314 2285 0 12:12:42 ? 0:06
/usr/vue/bin/vuewm
root 28795 860 0 08:51:44 ? 0:00
/usr/vue/bin/vuelogin
rossella 2285 28795 0 12:12:37 ? 0:01
/usr/vue/bin/vuelitesession /usr/vue/bin/vuelitesession
rossella 2306 1 0 12:12:41 ? 0:00
/usr/vue/bin/vuecolor
root 5519 509 0 15:46:17 ttyp1 0:00
telnetd
UID username del proprietario del
processo
PID identificatore del processo
PPID identificatore del processo padre
C utilizzatore processore per
scheduling
STIME momento di partenza del processo
TTY terminale che controlla il processo
TIME tempo di esecuzione cumulativa del
processo
COMMAND nome del comando
Esiste anche un programma di pubblico
dominio top che evidenzia l'uso della cpu da parte dei vari processi
con un refresh automatico ogni n secondi.
Il programma top va usato per breve
tempo per un controllo perché utilizza lui stesso molte risorse
Stato di un processo
Un processo può trovarsi in uno dei
seguenti stati:
Runnable il processo può essere
eseguito
sleeping il processo è in attesa
swapped il processo non è in memoria
zombie il processo sta cercando di
morire
stopped il processo è sospeso (non si
permette l'esecuzione)
In fase di boot del sistema i processi
sono iniziati dal kernel , tra questi il più importante è il processo INIT ,
con pid=1, il quale , a sua volta, lancia i processi per eseguire gli script di
rc .
In un sistema tutti i processi che NON
sono inizializzati dal kernel sono discendenti di INIT.
Quando un processo termina , rilascia
un exit-code al processo padre ( in attesa tramite una WAIT) ,
in questo modo segnala la fine della
esecuzione al padre e la possibilità di rilasciare lo spazio a lui allocato.
In questa fase finale i processi sono
detti "zombie". Se ,
accidentalmente , il processo padre è già terminato allora il figlio diventa di
proprietà di INIT , il quale cerca di farlo terminare in modo corretto, se
anche questo tentativo fallisce , i processi rimangono "appesi";
questo però non ha alcun effetto sul sistema.
Altri comandi utili sui processi
wait
aspetta finche` tutti i processi
attivati con & sono terminati.
kill -n PID
invia un segnale (ad esempio n = 9
termina il processo) al processo con identificatore PID
Esempio: kill 1 PID
invia un segnale di HUP - con hangup
molti programmi
rileggono la loro configurazione ( ex:
syslog)
nohup comando & (no hangup)
permette di lanciare il processo
"comando" in background e di scollegarsi ( il logout fa terminale il
processo shell assegnato ad un utente e quindi tutti i suoi processi figli
cioe` quelli attivati dall'utente). L'output, salvo diversa indicazione, viene
salvato in nohup.out
nice -p comando &
abbassa la priorità di un comando
mandato in background
- ATT p=-19
(alta) ... +19 (bassa)
- BSD da 0
a 39
Più è alto il numero , più è bassa la
priorità.
nohup automaticamente chiama nice.
Di default un processo eredita la
niceness del padre.
renice
renice -n incremento PID
Come comunicano due processi tra di loro ?
1. PIPE
Il pipe e` un canale di comunicazione
tra due processi tale per cui un processo puo` scrivere bytes che un altro
legge. I due processi vengono sincronizzati perche` quando uno
tenta di leggere da un pipe vuoto viene bloccato fino a che` si rendono
disponibili i dati.
Comando per impaginare i file ch* e
stamparli sulla stampante di default.
$ pr ch* | lp &
6951 PID del solo processo lp
$
La shell crea due processi, pr ed lp,
setta un pipe tra di loro in modo che l'input di lp sia l'output di pr.
2. SEGNALI
Sono un modo per segnalare ai processi
che qualche evento che può essere di loro interesse si è verificato.
Un processo puo` mandare un segnale ad un altro processo membro del
suo "gruppo di processi" cioe` parent o child. I segnali che si
possono inviare sono circa una trentina, tra cui:
SIGABRT abort e creazione di un core
dump
SIGHUP linea telefonica staccata
SIGINT interrupt dall'utente con DEL
SIGQUIT l'utente richiede un core dump
SIGKILL kill un processo
Un processo dice al sistema cosa vuole
fare quando riceve un segnale:
- ignorarlo
- elaborarlo mediante apposita
procedura di gestione
- terminare
IMPLEMENTAZIONE DEI PROCESSI
Ogni processo consiste in
- uno
spazio allocato in memoria ( virtuale !)
- una
struttura dati appartenente al kernel
( con mappa spazio degli indirizzi ,
stato del processo, priorità del processo ..
Ogni processo possiede un priorità
interna che stabilisce quando deve essere eseguito dalla cpu , questa priorità
può essere influenzata tarmite il comando nice , inoltre altri fattori che
influenzano il calcolo della priorità sono
- CPU
consumata
- tempo di
attesa in coda
Il kernel mantiene due strutture ad
indici relative ai processi
1. PROCESS TABLE (sempre residente, contiene informazioni necessarie a tutti i processi
anche se non sono in memoria in quel momento)
- parametri per lo scheduling (per
individuare quale processo girerà dopo)
priorita` del processo, CPU consumata,
...
- immagine della memoria
puntatori ai segmenti text, data,
stack.
- segnali
- varie
stato corrente di ogni processo, pid,
ppid, uid e gid
2. USER STRUCTURE (caricata solo quando il processo relativo e` in memoria)
- registri
di macchina
- stato
delle system call
- tabella
dei descrittori di file
- accounting
(CPU time usata da user e system)
- stack fisso
del kernel del processo
Quando una fork viene eseguita il
processo chiamante cerca un posto libero nella process table per il child. Se
esiste, copia tutte le informazioni dalla sua posizione a quella del child
nella process table, alloca memoria per dati e stack del child e copia le sue
informazioni: la user structure viene messa adiacente allo stack segment. Il
child e` pronto per partire.
BOOTSTRAP e SHUTDOWN
1. BOOTSTRAP
Una macchina Unix
puo'"bootstrappare" (cioe' "partire", essere inizializzata
) a vari livelli ( detti init stae ), ogni livello iniziale scelto comporta
l'inizializzazione o meno di vari servizi.
I livelli di init sono:
0 shutdown
1, s, S single user con le seguenti
differenze
1 fs ON, net off, login off
s, S è lo stato di avvio del sistema se
non è presente /etc/inittab, ci si può collegare solo da console ed i fs sono
montati
2 multiuser + net
3 nfs
4 2 + possibilità di modifiche a
inittab
single user (fs parzialmente montati)
5 firmware state , rimanenza storica
del vecchio AT&T per entrare in hardware maintenance mode
6 reboot state
normalmente il livello di deafult è il
3.
Gli script di startup si trovano in
/etc/rc e/etc/init.d (es. IRIX) o in /sbin/rc e /sbin/init.d (es. HP-UX).
Questi script
- settano
il nome della macchina
- settano
il TimeZone
- effettuano
un fschk
- effettuano
il mount
- puliscono
il direttorio /tmp
- configurano
la net interface
- inizializzano
i daemon di rete
- inizializzano
l' accounting
- getty per
il settaggio dei terminali
Il file che contiene la descrizione
delle modalità di inizializzazione della macchina è /etc/inittab
(initialization table),
ogni riga del file è composta da 4 campi
inittag: runstate :action : process
dove
inittag è un identificativo della entry
di max 4 caratteri ( e minimo 1 )
runstate indica in quali init state
della macchina il processo indicato deve essere inizializzato
action come ci si deve comportare
rispetto al processo che sarà indicato nell'ultimo campo
respawn : se il processo termina , va
reinizializzato
wait : aspettare che il processo sia
terminato prima di passare alla succesiva entry del file
once : eseguire il processo una volta,
aspettare che termini e poi non eseguirlo più
boot : eseguire il processo la prima
volta che si entra in multi-user senza aspettare che termini
bootwait : eseguire il processo la
prima volta che si entra in multi-user aspettando che termini prima di
proseguire
sysinit : eseguire il processo quando
il sistema "parte"
processo il comando da eseguire
esempio di /etc/inittab
init:4:initdefault:
ioin::sysinit:/sbin/ioinitrc
>/dev/console 2>&1
tape::sysinit:/sbin/mtinit >
/dev/console 2>&1
stty::sysinit:/sbin/stty 9600 clocal
icanon echo opost onlcr ixon icrnl ignpar </dev/systty
brc1::bootwait:/sbin/bcheckrc
</dev/console >/dev/console 2>&1 # fsck, etc.
link::wait:/sbin/sh -c "/sbin/rm
-f /dev/syscon; \
< /sbin/ln /dev/systty
/dev/syscon" >/dev/console 2>&1
cprt::bootwait:/sbin/cat /etc/copyright
>/dev/syscon # legal req
sqnc::wait:/sbin/rc </dev/console
>/dev/console 2>&1 # system init
cons:123456:respawn:/usr/sbin/getty
console console # system console
vue :4:respawn:/usr/vue/bin/vuerc # VUE
invocation
ShPr::respawn:/opt/sharedprint/bin/spserver
In funzione dell' init state
selezionato ( nell' esempio sopra ho un init default state 4) vengono poi
eseguiti gli script che si trovano nelle "run state directories".
Le "run state directories" (
normalòmnete in /etc) hanno un nome del tipo rc?.d dove ? è un numero
corrispondente allo init state
/etc/rc0.d sono gli scripts di start-up
per init 0 (=shutdown), 5 e 6 (=reboot),
/etc/rc1.d sono gli scripts di start-up
per init 1, s, S (=single user),
/etc/rc2.d sono gli scripts di start-up
per init 2, 3 (=multiuser),
/etc/rc3.d sono gli scripts di start-up
per init 3 (=nfs),
/etc/shutdown
/etc/rc.d sono spesso presenti per
compatibilità con vecchie versioni di System V , pre-release 3
/etc/init.d era il "vecchio"
direttoriocontenente gli scripts di start-up, normalmente viene linkato al
rc?.d appropriato.
Esempio - sistema IRIX Silicon Graphics
/etc/init.d contiene scripts per i
cambi di init state
Ognuno di questi script è linkato con
un file appropriato nel direttorio /etc/rc?.d .
In rc.?d troviamo files i cui nomi
hanno la seguente forma
[SK]nn<init.d filename>
dove
S significa inizializza questo job
K significa termina il job
nn sequenza numerica relativa
Il file /etc/init.d/network è uno
script che inizializza i daemon di rete (quando lanciato con Start e li termina
quando è lanciato con Stop ).
E' linkato , rispettivamente ,a
/etc/rc2.d/S30network e /etc/rc2.d/K40network.
Il file e' eseguito lanciando il
comando
/etc/rc2.d/S30network start
quando è inizializzata la macchina con
init=2
ed è eseguito con
/etc/rc2.d/K40network stop
quando si effettua lo shutdown
In particolare network inizializza vari
servizi di rete e si può scegliere quali servizi inizializzare ponendo ON
oppure OFF i relativi file in /etc/config.
Per vedere come sono settati i
parametri si può utilizzare il comando chkconfig
2. SHUTDOWN
Per spegnere la macchina è necessaria
attivare la
procedura di SHUTDOWN
- shutdown
Altri comandi che si possono utilizzare
sono
- reboot
shutdown seguito da relativo reboot
- telinit,
init per cambiare init level
IL DAEMON CRON
E' un daemon che esegue i comandi
contenuti nel file di crontab.
Attraverso questo daemon è possibile
mandare in esecuzione i comandi in particolari momenti del giorno ( o
settimana, mese, etc...).
$ crontab
-l lista il file di crontab
$ crontab
-e edita il file di crontab
l'editor utilizzato di default è ed,
posso cambiarlo impostando al variabile d'ambiente EDITOR ( in ~/.cshrc)
Ogni riga del file di crontab è
caratterizzata dalla presenza di 5 campi che rappresentano minuti ore giorno
del mese mese giorno della settimana
0-59 0-23 1-31 1-12 0-6 (0=domenica)
la combinazione dei valori assegnati a
questi campi corrisponde al momento in cui verrà mandato in esecuzione il
comando relativo.
L' * equivale a "tutti i
valori"
1,6 i valori 1 e 6
1-6 i valori da 1 a 6
#copia file /var/adm/syslog/*.log
(esclusi quelli di mail)
# in
/var/adm/syslog/oldlog_nome_del_mese e azzera /var/adm/syslog/
05 04 1 * *
/usr/local/sistema/crontab/newlog
#
# BACKUP GIORNALIERO
00 2 * * 1,2,3,4,5,6
/usr/local/sistema/dump/dumpdaily<
# BACKUP SETTIMANALE DEL LUNEDI
00 3 * * 1
/usr/local/sistema/dump/dumpweekly
#
# rimozione dei core in tutto /mnt
-> /usr/people
00 23 * * *
/usr/local/sistema/crontab/purge_mnt
#
I direttori in cui sono tenuti i file
relativi al comando crontab possono essere /usr/lib, /usr/lib/cron, /etc/cron.d
Anche i singoli utenti possono
avvalersi del crontab se sono stati autorizzati dall'amministratore del
sistema. I file necessari alla autorizzazione sono:
cron.allow contiene la lista degli
utenti abilitati
cron.deny contiene la lista di chi NON
è abilitato all'uso
Attenzione:
se non esiste il file cron.allow ed
esiste VUOTO il file cron.deny , questo implica che tutti gli utenti possano
utilizzare il comando crontab.
LA BOURNE SHELL
È associata al file /bin/sh ed ha come
prompt di default il carattere $.
1. uso della shell (metacaratteri)
2. creazione di nuovi comandi
3. redirezione input/output
4. programmazione in linguaggio sh
1. METACARATTERI
(caratteri riconosciuti come speciali)
* stringhe da 0 a n caratteri
? 1 singolo carattere
# introduce un commento
> redireziona l'output in un file
>> accoda l'output ad un file
< prende l'input da un file
| pipe
; separa due comandi
& manda un processo in background
$0...$9 10 variabili che vengono
sostituite dagli
argomenti dei file di comandi
(...) raggruppa dei comandi
[...] ricerca i caratteri indicati tra
parentesi
Esempi di utilizzo:
$ echo * equivale ad ls
$ echo x*y nomi dei file x...y
$ echo hello # a tutti
hello
$ echo '***'
***
$ echo \*\*\*
(il carattere \ serve anche per andare
a capo se la linea di comando è troppo lunga dato che permette la non
interpretazione del newline)
$ echo "l'asterisco"
l'asterisco
$ echo 'hello aspetta la chiusura
dell'apice
> a tutti` > prompt secondario
(memorizzato
hello nella variabile PS2)
a tutti
$
$ rm * elimina tutti i file del
direttorio
corrente meno i sottodirettori
$ rm *.save elimina i file che
terminano per .save
$ pr ch[12346789]* (equivalente a pr
ch[1-46-9])
stampa ch1...
ch2... e non ch5...
$ ls ch?.1 elenca i file ch1.1 ...
ch9.1
ATTENZIONE: le identificazioni si hanno
solo se gli argomenti sono dei file esistenti.
$ mv ch.* chapter.* NON FUNZIONA!
$ date ; who
Fri Feb 17
corso console Feb 17
$ date; who | wc
Fri Feb 17
1 5 37
$ (date; who) | wc
2 11 66
$ sleep 5
$ dopo 5 secondi ricompare il prompt
(1) (2)
$ (sleep 5 ; date) & date
18999
Fri Feb 17
$ Fri Feb 17 18:55:32 GMT 1995 output
di (1)
2. CREAZIONE
DI NUOVI COMANDI
Ogni comando UNIX corrisponde ad un
file su disco (generalmente in /bin o /usr/bin). In generale, se un file è
eseguibile (autorizzazione x) e contiene del testo l'interprete assume che sia
un file di comandi e cerca di eseguirlo.
1^ PASSO: creare un file con i comandi
che vogliamo eseguire
$ echo 'who | wc -l' > numut
2^ PASSO: rendere eseguibile il file
$ chmod +x numut
3^ PASSO: copiare il comando in un
direttorio inserito nel path (ad esempio un proprio direttorio ./bin)
$ mkdir bin
$ cd bin
$ mv ../numut .
$ numut
4 restituisce il numero di
utenti collegati
Un comando UNIX può accettare anche
parametri.
Per fare si che anche un nostro comando
accetti parametri occorre utilizzare le variabili $0...$9 della shell: tutte le
volte che la shell incontra $1 lo sostituisce con il primo argomento, $2 con il
secondo e così via.
Ad esempio, se vogliamo un comando che
renda scrivibile un file, scrivendo nel file mio_comando
chmod +w prova
limitiamo il comando ad agire solo su
un file di nome prova.
Scrivendo invece nel file mio_comando
chmod +w $1
possiamo scrivere:
$ mio_comando pippo
$ mio_comando prova
...
purchè i file pippo e prova esistano
nel direttorio di lavoro.
$* è l'abbreviazione per "tutti
gli argomenti"
chmod +w $*
consente:
$ mio_comando pippo prova pluto ...
$0 è il programma di cui è in corso
l'elaborazione (ad esempio mio_comando).
ALTRE VARIABILI UTILI DELLA SHELL:
$# numero argomenti
$$ PID della shell che esegue il
comando
$! PID dell'ultimo comando dato con
&
3. REDIREZIONE INPUT/OUTPUT
La maggior parte dei comandi UNIX
rispetta per default lo schema seguente:
accetta input da terminale
scrive l'errore su terminale
scrive l'output su terminale
I tre flussi (input, output, error)
vengono quindi associati a tre descrittori
di file:
0 standard input
1 standard output
2 standard error
Ogni comando è anche in grado di
leggere da file e scrivere output ed error su file diversi.
redirezione output
$ ls $ ls > file
preserv $ cat file
provafile preserv
provafile
redirezione input
$ mail robby < prova
redirezione
error
$ time wc ch3.txt > wc.out 2>
time.out
$ cat time.out
real 1.0
user 0.4
sys 0.3
2>&1 redirige l'output del file
di errori nello
stesso flusso del file di output
Un esempio utile:
$ comando > /dev/null scompare
l'output
$ comando 2> /dev/null scompare
l'error
4. LA
PROGRAMMAZIONE
1. Istruzione case
case variabile in
pattern) lista_di_comandi;;
...
esac
La shell tenta di far corrispondere
variabile con ogni pattern nell'ordine in cui i pattern compaiono. Se viene
trovata una corrispondenza, la lista_di_comandi associata viene eseguita e
termina il case.
I ;; che precedono esac sono opzionali.
*) qualunque stringa
case $i in case $i in
-x|-y) ... -[xy]...
2. Istruzione if
if condizione
then
comandi se la condizione è vera
else
comandi se la condizione è falsa
fi
La parte else è facoltativa.
Esempio di comando if con l'uso del
comando test:
if test -f file # se è un file
then
... # elabora il file
else
... #comandi alternativi se non è un
file
fi
3. Istruzione for
for i in
elenco_di_parole for i
do corpo del ciclo
corpo del ciclo done
done
Esegue un insieme di comandi, che
costituiscono il corpo del ciclo, una volta sola per ciascun elemento o gruppo
di parole (in generale, nomi di file).
4. Cicli while e until
while comando
do
corpo del ciclo, che viene eseguito
finchè la
condizione in comando si mantiene vera
done
until comando
do
corpo del ciclo, che viene eseguito
mentre la
condizione in comando è falsa
done
Usando until al posto di while la
condizione di terminazione del ciclo viene invertita.
Il costrutto until non ha un
equivalente in csh.
Esempio n. 1
Programma che elenca il contenuto di tutti i sottodirettori a partire dal
direttorio dato come parametro
Scriviamo il seguente file che
chiamiamo dw:
cd $1
echo ' '
echo Contenuto direttorio: `pwd`
ls -l
for i in *
do
if test -f $i
then :
else
dw $i
fi
done
- il comando si richiama con $ dw
nome_direttorio
- se non indichiamo nome_direttorio
viene preso $HOME
- alla fine della esecuzione siamo
ancora nel direttorio di partenza perchè viene lanciata una sottoshell
- viene attuata la chiamata ricorsiva a
dw : il file deve quindi risiedere in un direttorio presente nel path
Esempio n. 2
Programma che controlla chi si collega e chi si è collegato
Scriviamo il seguente file che
chiamiamo watchwho:
new=/tmp/wwho1.$$
old=/tmp/wwho2.$$
>$old # crea un file vuoto
while : # ciclo infinito: sempre valore
vero
do
who >$new
diff $old $new
mv $new $old
sleep 60
done | awk '/>/ {$1 = "in:
"; print}
/</ {$1 = "out: "; print}'
- $$ identificatore della sottoshell
- si richiama con
$ watchwho
in: corso console Mar 22 12:05
...
$ ls -al /tmp
-rw-r--r-- 1 corso utenti 37 Mar 22
12:36 wwho2.13028
LA C-SHELL
- La shell
csh puo` essere invocata nella fase di login oppure digitando csh al
prompt (subshell)
- Quando e`
invocata al login esegue i seguenti script di configurazione: /etc/csh.cshrc ~/.cshrc e ~/.login Quando e` invocata come
subshell esegue solo lo script ~/.cshrc
- Al logout
viene eseguito il file ~/.logout
1.
ESEGUIRE I COMANDI
- Nomi di
comando come input alla shell:
- Built-in Cshell command: alias, exit, history, kill, nohup ...
- File
name: file binari (comandi di sistema, eseguibili), script
- Command
alias:
%
alias rm rm -i
%
unalias rm
- Piu`
comandi su una stessa linea devono essere separati dal carattere ;
%
who -H; df -v
- Il
carattere new-line e` interpretato come blank se preceduto da \
% echo ciao \
a tutti
- Eseguire
comandi in back-ground:
% sleep
100 & # il com. viene posto in background
% jobs
# mostra i com. in background
% fg
# riporta il com. in foreground
^Z # stop del processo
% bg
# il com. viene posto in background
% kill
%1 # uccide il primo processo in bg
% nohup sleep 100 # manda il com. in bg
e ne impedisce
# la terminazione al logout
- Ripetere
un comando un numero di volte specificato:
%
repeat 5 echo *******
- Esecuzione
condizionata di comandi
%
comando1 && comando2
# il secondo comando viene eseguito
solo se il primo
# ritorna il codice di errore 0 (no
error)
%
grep '#include' *.c | lpr && echo OK
% comando1 || comando2
# il secondo comando viene eseguito
solo se il primo
# ritorna un codice di errore diverso
da 0 (error)
%
mkdir $tmpfile || exit
- Sostituzione
di nomi:
%
ll *.c
%
ll pippo?.f
%
ll [abc]*
%
ll [a-z]*
%
ll /home/{corso,pippo,pluto}/.cshrc
% echo Files: *.txt
Files: ch1.txt ch2.txt ch3.txt
% set nomi=(*.txt)
% echo trovati $#nomi files
trovati 3 files
% echo $nomi[2]
ch2.txt
- Ridirezione
Input ed Output
< filename # usa il contenuto di filename come
# input ad un comando
<< LABEL # l'input al comando termina quando
# viene trovata la parola LABEL
% cat << FINE
ciao a tutti
FINE
> filename # scrive l'output del com. su filename
>! filename # scrive l'output su filename ed ignora
# la variabile di ambiente noclobber
che
# se settata impedisce la
sovrascrittura
# di filename
>& filename #
scrive stdout e stderr su filename
>&! filename #
>> filename #
appende l'output a filename
>>& filename #
appende stdout e stderr su filename
- Caratteri
speciali: come evitarli
I seguenti caratteri vengono
interpretati dalle shell:
~ ` ! @ # $ % ^ & * ( ) \ | { } [ ] ; ' " < . ?
Per poterli usare evitando che
la shell li interpreti esistono due modi:
- Devono
essere scritti preceduti da \
- La frase
contenente il carattere deve essere racchiusa tra virgolette. La shell riconosce tre tipi di virgolette:
- (') l'apostrofo impedisce tutte le
interpretazioni
- (") ammette il riferimento
alle variabili e l'esecuzione di comandi racchiusi tra (`)
- (`) ritorna il risultato
dell'esecuzione di un comando
%
echo "he said: \"John !\""
%
echo "*.txt"
%
set a=`ls *.txt`
%
echo "files: $a"
%
echo 'files: $a'
2.
VARIABILI
- Variabili locali
Le variabili locali non vengono passate
a script o a comandi invocati.
% set # lista le variabili definite
% set name=word # crea la variabile e la
#inizializza a word
% set name=(word-list) # crea ed inizializza una
# variabile di tipo array
% set name[indice]=word
% unset pattern # cancella tutte che variabili
# che coincidono con il pattern dato
- Variabili globali:
Le variabili globali vengono passate
agli script ed ai comandi invocati.
% setenv name=value # setta la variabile name
% unsetenv pattern # cancella la variabile
% printenv # mostra le variabili settate
- Sostituzione di Variabili
$name # sostituita con il contenuto della
# variabile
$name[n] #
sostituita con il contenuto di indice n
# della variabile
$#name # numero degli elementi della variabile
$?name # sostituita 1 se name e` settata 0
# altrimenti
Se una variabile non definita e`
referenziata genera un errore, e` quindi importante testare l'esistenza della
variabile con $?nome
- Variabili speciali:
$0 # sostituita con il nome del file di input
$?0
$1,$2,.. #
sostituite con gli argomenti del comando
$* # sostituita con tutti gli argomenti
$$ # sostituita con il numero del processo padre
$< # sostituita con una riga latta da stdin
- Variabili predefinite
argv variabile array che contiene i
parametri correnti della shell
cdpath variabile array che specifica
una lista di direttori ricercati dal comando cd
home home-directory, usato da cd e
valore di ~
noclobber impedisce la sostituzione di
file esistenti con comandi di redirezione
prompt stringa contenente il prompt
della sessione
...
3.
LA PROGRAMMAZIONE
# lista completa dei soli direttori
if ($#argv < 1) set argv=(.)
find $argv[*] -type d -exec /bin/ls -ld
\{\}\;
- Espressioni
@a=8+2*5
set x=2 y=3 sum
@sum = $x + $y
echo $sum
- Test sui
file
-r filename # vero se il file esiste ed
e` leggibile
-e filename # vero se il file esiste
-f filename # vero se il file esiste ed
e`regolare
-d filename # vero se il esiste ed e`
un direttorio
- Statement
condizionale
if (
-f newfile) then
if (
! -d ~/bin) mkdir ~/bin
mv newfile ~bin
else
echo new file: file not found
exit
endif
- Statement
switch
echo -n Do you want to proceed ?
set reply=$<
switch ($reply)
case y*:
mv newfile ~/bin
breaksw
default:
echo newfile not moved
endsw
- Statement
iterativi: while e foreach
while ($#argv > 0)
if (! -f $1) echo $1: non esiste
shift
end
set file=(a b c d)
foreach i ($file)
cp $i.c $i.bak
end
I SERVIZI DI RETE
Nel 1970, insieme al progetto DARPA del
Dipartimento della Difesa degli Stati Uniti nacque Internet, un insieme di reti
interconnesse per lo scambio di dati tra i vari paesi. La rete venne chiamata
ARPAnet ed il protocollo che eseguiva la connessione IP (Internet Protocol),
capace di fornire un servizio primitivo per la spedizione di pacchetti tra due
computer connessi a Internet.
I due protocolli più diffusi oggi sono
TCP/IP e UDP/IP.
Ogni macchina sulla rete viene dotata
di un indirizzo Internet (IP address) che la localizza sulla rete:
155.185.1.2 indirizzo numerico
c220.unimo.it nome completo della
macchina
(tradotto dal DNS - domain name server)
c220 alias
unimo.it dominio
La connessione in rete della macchina,
oltre alla connessione fisica, prevede la modifica di una serie di file
(/etc/hosts, /etc/hosts.equiv, ...) alcuni dei quali dipendenti dal sistema
operativo in uso. Tale modifica viene attuata già durante la fase di setup
della macchina o in un tempo successivo, mediante le interfacce di system
administration (sam per HP-UX, smit per AIX, setup per OSF/1, ...).
Principali comandi per la connessione
con altri host:
$ ftp host file transfer protocol
Possibilità di spedire o ricevere file
da a host: l'utente deve conoscere una username e password sull'host remoto
(esistono una serie di siti ftp da cui prelevare software di public domain,
accedendo con username anonymous e con password uguale all'indirizzo completo
dell'utente sulla macchina locale, es. corso@c220.unimo.it)
$ rlogin host remote login
Le macchine a cui si può accedere sono
listate in /etc/hosts.equiv oppure l'utente deve definire nella propria
home-directory il file .rhosts nel formato username@macchina1 per accedere a
macchina1 con un rlogin
rlogin rhost -l username chiede la
password
rlogin rhost l'utente deve avere
sull'host remoto la stessa
username e password
$
rsh (o remsh) remote shell
Uso: rsh c220 ls
Esecuzione remota di un comando
sull'host remoto: rsh copia il suo stdin nel comando remoto e lo stdout e
stderr del comando remoto nel suo stdout ed stderr, ogni segnale (es. quit) è
propagato al comando remoto.
$ telnet hostname
interfaccia utente al protocollo
telnet: permette di aprire una sessione di login (richiesta di username e
password) su hostname. Da questo momento in poi i comandi sono eseguiti dalla
macchina remota fino al termine della sessione di login con exit o logout.
Battendo telnet senza argomenti parte
una sessione di telnet in command mode (prompt telnet>)
open connessione all'host specificato
close chiusura della connessione
quit uscita
set settaggio di qualche variabile
status visualizza lo stato della
connessione
? help
AMMINISTRAZIONE DEL SISTEMA
- installare e personalizzare il
sistema
- gestire gli account degli utenti
- aggiungere nuovo software
- definire le code di stampa per
stampanti locali o remote
- effettuare copie di sicurezza di
file/direttori importanti (compressione dei file e
salvataggio con comando tar)
- fare backup giornalieri dei file
system (comando dump/restore).
- provvedere alla manutenzione dei
file di sistema (attenzione ai file che crescono in /var/adm come wtmp)
- tenere traccia dell'attivita` del
sistema (comandi w, who, finger, last, ps)
- controllare la sicurezza (indicare
in /etc/securetty quali sono i terminali sicuri, cioe` quelli dai quali e`
permesso l'accesso col nome di login root)
- controllare i messaggi di log (il
daemon syslogd lanciato in fase di bootstrap scrive i file di log indicati
in /etc/syslog.conf)
Backup
Il comando dump
comando per eseguire backup di un fs
usualmente su nastro
dump si crea una lista dei file di cui
deve fare il backup, li comprime e li salva come un unico file sulla device
indicata.
PREGI DIFETTI
il backup può occupare più tape
ogni fs va backuppato singolarmente
dump incrementali
si backuppano i fs della macchina
( non nfs, ma posso backupparli su una
device remota)
nomi lunghi quanto si vuole
I livelli di dump vanno da 0 ( intero
fs ) a 7 , il comando scrive nel file /etc/dumpdates il tipo di dump che
effettua.
Con l'opzione u
dico al comando di leggere dumpdates , senza viene effettuato sempre un dump di
livello zero.
dump 2ufsdb /mnt /dev/dat
2 livello di dump
u legge dumpdates
f specifica la destinazione
s,d,b parametri relativi al nastro
Attenzione: se si mettono più dump sullo stesso nastro,
assicurarsi che non sia rewind.
Etichettare sempre i nastri!
Cambiarli ogni tanto!
Esempio
#! /bin/csh -f
set LOGFILE=/usr/local/sistema/dump/dump.log
set
SOMMARIO=/usr/local/sistema/dump/dump.sommario
set DEVICE=/dev/datn
....
date >>& $SOMMARIO
echo '' >>& $SOMMARIO
echo 'DUMP DI LIVELLO 0 DEL
FILESYSTEM /mnt' >>&
$SOMMARIO
echo '' >>& $SOMMARIO
(/etc/dump 0uf - /mnt |
/usr/local/bin/buffer -T -s 32k -o $DEVICE) >>& $SOMMARIO
mt -t $DEVICE offl : fa il rewind del
tape e lo mette off_line
date
exit
Il comando restore
E' il comando necessario per recuperare
i file salvati con un dump.
Oramai tutti i sistemi implementano un
restore interattivo; per attivarlo selezionare l'opzione i
restore -if nome_device f è l'opzione che mi permette di specificare la device
Appare il prompt restore>
e posso utilizzare i comandi
ls per listare il contenuto del backup
add nome_file per specificare il file che desidero ripristinare
extract estrae il file selezionato e lo copia nel direttorio da cui si è lanciato
il comando
Esempio
# restore -if /dev/dat
restore> ls
janet / paul /
restore> cd
paul
restore> ls
scott.txt iamlost
restore> add scott.txt
restore> extract
You have not ready any volumes yet.
Unless you know which volume your files are on you
should start with the last volume.
Specify next volume #1:1
>set owner mode for . ? [yn] n
#
I Volumi su cui si effettua il backup
sono numerati a partire da 1.
Il comando tar
E' un comando che mi permette di creare
file di archiviazione, spostarli tra vari fs e ripristinarli.
i nomi file non possono superare i 100
char
non seguono i link (a meno di
specificarlo)
non va su più nastri
Per creare un file tar (raccomandata
l'estensione .tar)
tar cvf datafiles.tar
datafiles.doc docfile.doc ...
c create
v verbose
f specifico il nome del file
tar tvf file.tar lista il contenuto del file
tar xvf file.tar estrae il contenuto del file
Attenzione:
creare il tar in un direttorio diverso
da quello che si desidera "tarare"
Normalmente, se i file devono anche
essere spostati tra macchine, vengono compressi per diminuire lo spazio fisico
occupato.
I comandi di compressione
compress nome_file il comando compress aggiunge la
estensione .Z ai file
oppure si può utilizzare la utility di
pubblico dominio gzip
gzip nome_file
per scompattare uso rispettivamente
uncompress nome_file
gunzip nome_file
Esempio
myfiles.tar.Z va primo decompresso e
poi ripristinato.
Uncompress myfiles.tar.Z
tar xvf myfiles.tar
Gestione delle stampanti
BSD spooling system (lpd, lpc, lpr,
...)
ATT spooling system (lpsched, lpadmin,
lp, ...)
S/O Sistema di stampa
Solaris ATT (con qualche estensione
random)
HP-UX ATT (con qualche estensione tipo
BSD)
IRIX ATT e BSD con comandi doppi
SunOS BSD puro
OSF/1 BSD più un front-end ATT
In BSD
/usr/lib/lpd daemon
/etc/printcap database principale delle
stampanti
Esempio:
pro630|lp5|Laser Writer pro630:\
:lf=/usr/adm/lperr:\
:lp=:\
:rm=ps_cic01.unimo.it:\
:rp=pr1:\
:sd=/usr/spool/pro630:
lpq situazione delle stampe
lpr file stampa un file
lprm jobid rimuove un file in stampa
lpc permette il controllo delle
stampanti e delle stampe
enable/disable
printer
start/stop
printer
down/up
printer
clean
printer
topq
printer jobid
restart
printer
status
printer
In ATT
/usr/lib/lpsched daemon
/usr/lib/lpshut shutdown del print
service
enable, disable abilita/disabilita una
stampante
lpadmin configura il sistema di stampa
(cambia classe o porta ad una
stampante, rimuove stampanti e classi, consente o nega l'uso di una stampante
ad alcune username)
lpmove sposta una stampa su una altra
stampante
lp [options] [files] stampa un file
-m manda un mail dopo la stampa
-d dest stampante scelta
-n numero stampa n copie
-o nobanner non stampa il banner
cancel jobid rimuove un file in stampa
lpstat situazione delle stampe
-d quale e` la stampante di default (se
definita)
-s status summary
-t le informazioni di -s più lo stato
idle/busy
e lo stato di tutte le richieste
-r controlla se lo scheduler è attivo
oppure no
IL DAEMON SYSLOGD
Syslog , usato sulla maggioranza dei
sistemi, è un metodo per raggruppare i log di sistema.
E' composto da
syslogd il daemon lanciato in fase di boot dal sistema
syslog.conf in /etc, file di configurazione
openlog
syslog chiamate alle librerie
closelog
logger comando per inserire entries nei file di log
I file di log creati si trovano
normalmente in /var/adm/
I file di log crescono rapidamente e
normalmente vengono ruotati (una volta a settimana, o più raramente in funzione
del tipo di log)
Esistono, però, due file che non vanno
mai ruotati
/usr/adm/lastlog che contiene
l'annotazione dell'ultimo
login effettuato dall'utente
/etc/utmp dove vengono scritti i nomi
degli utenti
attualmente loggati
I programmi che utilizzano syslog
scrivono dapprima in /dev/log, poi syslogd smista le varie entries tra i file
di log seguendo le specifiche di syslog.conf
Come è fatto syslog.conf
selector <TAB> action filename (
con path completo )
localn (0-7) @hostname (se ho DNS )
facility.level @Ipaddress
0 emergency user1, user2 su video se
sono logged
1 alert * a tutti quelli logged
2 critical
3 error
4 warning
5 notice
6 informational
7 debug
Esempio syslog.conf
mail.debug /var/adm/syslog/mail.log
mail.none /var/adm/syslog/mailnone.log
*.crit /var/adm/syslog/critical.log
*.crit root
*.err /var/adm/syslog/err.log
*.warning /var/adm/syslog/warning.log
*.notice /var/adm/syslog/notice.log
*.alert /var/adm/syslog/alert.log
*.alert;*.err;kern.debug /dev/console
*.alert root
*.emerg *
local0.notice;local0.debug
/var/adm/syslog/POP3.log
local2.err /var/adm/syslog/poppassd-log
local1.notice /var/adm/syslog/wrap.log
local6.info /var/adm/syslog/tacacsd.log
local6.debug
/var/adm/syslog/tacacsd.debug
local6.notice /var/adm/syslog/tacacsd.notice
local6.err /var/adm/syslog/tacacsd.err
Il file syslog.conf viene letto dal
daemon solo in fase di boot,
se si effettuano variazioni in fasi
successive , bisogna mandare
un segnale di HUNGUP al daemon affinchè
lo rilegga .
Normalmente il sistema scrive in un
file il PID di syslogd ( /etc/syslog.pid oppure /var/run/syslog.pid ), per cui
si può lanciare un comando del tipo
kill -HUP ' /bin/cat /etc/syslog.pid '
Configurazione e controllo della rete
Inetd è il daemon che sovrintende ai
daemon di rete, li avvia quando sono necessari e li uccide
"correttamente" quando hanno terminato il loro compito.
Inetd si mette in ascolto sul porto del
servizio ( al suo posto!) e quando arriva la chiamata invoca il servizio.
Inetd ha un suo file di configurazione
/etc/inetd.conf
Ogni riga del file corrisponde alla
descrizione di un servizio di rete
esempio:
# After changing this file, tell inetd
to reread it with the command
# /etc/killall -HUP inetd
#
ftp stream
tcp nowait root /usr/etc/ftpd ftpd -l
telnet stream tcp nowait root
/usr/etc/telnetd telnetd
shell stream tcp nowait
root /usr/etc/rshd rshd -L
login stream tcp nowait
root /usr/etc/rlogind rlogind
exec stream tcp nowait
root /usr/etc/rexecd rexecd
finger stream tcp nowait
guest /usr/etc/fingerd fingerd
http stream tcp nowait
nobody ?/var/www/server/httpd httpd
ftp stream tcp nowait root
/usr/etc/ftpd ftpd -l
Come leggere una riga:
ftp tipo di servizio
i servizi sono elencati nel file
/etc/services
stream tipo
di socket
stream (tcp) datagram (udp) raw
tcp protocollo
i protocolli sono elencati in
/etc/protocols
nowait ammette risposte multiple
root proprietario del processo
/usr/etc/ftpd nome del programma da avviare
ftpd -l shortname del programma
Inetd ha un comportamento analogo a
quello di syslogd, se si effettuano modifiche al file di configurazione, devo
poi lanciare un segnale al daemon affinchè vada a rileggerlo.
kill -HUP numero_pid_inetd
Inetd è uno di quei servizi che logga
in syslog.
Il file protocols , in /etc, contiene
la descrizione dei vari protocolli della famiglia TCP/IP utilizzati dal
sistema; questo file si trova già nel sistema in fase di installazione e
difficlmnete dovrà essere cambiato.
Ex di /etc/protocols
# $Revision: 1.3 $
#
ip 0 IP # internet protocol, pseudo
protocol number
icmp 1 ICMP # internet control message
protocol
igmp 2 IGMP # internet group management
protocol
ggp 3 GGP # gateway-gateway protocol
tcp 6 TCP # transmission control
protocol
egp 8 EGP # exterior gateway protocol
pup 12 PUP # PARC universal packet
protocol
udp 17 UDP # user datagram protocol
hmp 20 HMP # host monitoring protocol
xns-idp 22 XNS-IDP # Xerox NS IDP
rdp 27 RDP # "reliable
datagram" protocol
iso-tp4 29 ISO-TP4 # ISO Transport
Protocol Class 4
Il file services, sempre in /etc,
elenca i servizi abilitati sulla macchina e quale porto utilizzano.
Ex di /etc/services
#
# Network services, Internet style
#
echo 7/tcp
echo 7/udp
daytime 13/tcp
daytime 13/udp
netstat 15/tcp
ftp-data 20/tcp
ftp 21/tcp
telnet 23/tcp
smtp 25/tcp mail
Esistono alcuni comandi che mi
permettono di verificare la configurazione della rete. I comandi sono
netstat con varie opzioni, permette di
vedere come è configurata l'interfaccia di rete ed il gateway.
In una macchina Unix con una solo
interfaccia di rete, il comando netstat avrà sempre un output simile a quello
sottostante
snowwhite:/> netstat -i
Name Mtu Network Address Ipkts Ierrs
Opkts Oerrs Coll
ec0 1500 155.185.1 snowwhite. 10649531
3686 10291061 32000 304712
lo0 8304 loopback localhost 1494439 0
1494439 0 0
snowwhite:/>
dove ec0 (o altro nome simile) è
l'interfaccia di rete che colloquia con l'esterno e lo0 è l'interfaccia vista
dall'interno ( viene detta "interfaccia di loopback ).
Quando si conosce il nome della
interfaccia di rete ( nel nostro esempio ec0) si può usare il comando ifconfig
per vedere i parametri di configurazione della interfaccia stessa.
Nell' esempio sotto posso notare che il
numero IP della macchina è
155.185.1.64, che la sua netmask è
255.255.255.0.
snowwhite:/> ifconfig ec0
ec0:
flags=c63<UP,BROADCAST,NOTRAILERS,RUNNING,FILTMULTI,MULTICAST>
inet 155.185.1.64 netmask 0xffffff00
broadcast 155.185.1.255
snowwhite:/>
snowwhite:/>
Un altra opzione del comando netstat
molto utile per controllare se sono definiti correttamente i gateway è
l'opzione -r
snowwhite:/> netstat -r
Routing tables
Internet
Destination Gateway Netmask Flags Refs
Use Interface
default modena-gw UGS 0 498852 ec0
localhost localhost UH 16 1226081 lo0
155.185.1 snowwhite.aulao2 0xffffff00 U
20 4849193 ec0
snowwhite.aulao2 localhost UGHS 6
268376 lo0<
mat18 modena2-gw UGHD 0 81 ec0
snowwhite:/>
Come leggere l'output :
snowwhite.aulao2 localhost UGHS 6
268376 lo0
la macchina snowwhite vede la sua interfaccia
di rete (ec0) attraverso la sua interfaccia interna (lo0)
155.185.1 snowwhite.aulao2 0xffffff00 U
20 4849193 ec0
snowwhite ( con numero IP 155.185.1.64
) vede la rete 155.185.1 ( a cui appartiene ) attraverso la sua interfaccia di
rete ec0
default modena-gw UGS 0 498852 ec0
snowwhite invia al gateway modena-gw i
pacchetti con destinazione diversa dalla rete su cui si trova
il numero IP del gateway modena-gw si
troverà definito nel file /etc/hosts
Il comando hostname consente di visualizzare il nome completo della macchina:
snowwhite:/> hostname
snowwhite.unimo.it
snowwhite:/>
snowwhite:/>
snowwhite:/>
Il file /etc/hosts contiene la
corrispondenza
nome_macchina numero IP
In questo file normalmente si elencano
le macchine con cui si colloquia normalmente per poterle poi identificare col
nome anziché sempre con il numero.
Se sulla rete in cui si installa la
macchina è presente il DNS, allora in hosts si elencheranno solo il nome stesso
della macchina e quello del gateway , altrimenti tutte quelle con cui si
colloquia.
In presenza di un DNS sarà necessario
un ulteriore file ( /etc/resolv.conf ) in cui si elencano i dns da interrogare,
nella prima riga del file resolv.conf è possibile specificare l'ordine di
risoluzione dei nomi ( ex: local bind
=prima file di hosts e poi dns )
Ex di /etc/hosts
# (The '192.0.2' network number is the
officially blessed 'test' network.)
155.185.1.64
snowwhite.aulao2 snowwhite
# This entry must be present or the
system will not work.
127.0.0.1 localhost
# Assigned multicast group addresses
listed in RFC-1060 ("Assigned Numbers").
# These entries can be deleted if you
don't want them.
# (They are also available via the
Internet DNS name servers.)
#224.0.0.1 all-systems.mcast.net
155.185.1.64 snowwhite.unimo.it
snowwhite
155.185.1.69 sneezy.unimo.it sneezy
Ex. di /etc/resolv.conf
hostresorder local bind
nameserver 155.185.1.2
nameserver 155.185.1.5
nameserver 130.186.1.53
Un altro comando molto utile per
verificare se la rete è funzionante è il comando oing; ping invia pacchetti al
numero ip indicato e segnala se riceve risposta oppure no.
snowwhite:/>
snowwhite:/>
ping bashful
PING bashful.unimo.it (155.185.1.70):
56 data bytes
64 bytes from 155.185.1.70: icmp_seq=0
ttl=255 time=1.162 ms
64 bytes from 155.185.1.70: icmp_seq=1
ttl=255 time=0.985 ms
64 bytes from 155.185.1.70: icmp_seq=2
ttl=255 time=1.145 ms
64 bytes from 155.185.1.70: icmp_seq=3
ttl=255 time=1.105 ms
64 bytes from 155.185.1.70: icmp_seq=4
ttl=255 time=1.044 ms
----bashful.unimo.it PING
Statistics----
5 packets transmitted, 5 packets
received, 0% packet loss
round-trip min/avg/max =
0.985/1.088/1.162 ms
snowwhite:/>
snowwhite:/> ping 155.185.1.2
PING 155.185.1.2 (155.185.1.2): 56 data
bytes
64 bytes from 155.185.1.2: icmp_seq=0
ttl=255 time=1.060 ms
64 bytes from 155.185.1.2: icmp_seq=1
ttl=255 time=1.077 ms 64 bytes from 155.185.1.2: icmp_seq=2 ttl=255 time=1.029
ms 64 bytes from 155.185.1.2: icmp_seq=3 ttl=255 time=1.356 ms
---155.185.1.2 PING Statistics----
4 packets transmitted, 4 packets
received, 0% packet loss round-trip min/avg/max = 1.029/1.131/1.356 ms
snowwhite:/>
snowwhite:/>
In particolare è possibile fare un ping
sia sulla interfaccia di loopback della macchina (sempre identificata dal
numero 127.0.0.1) che sulla macchina stessa
Il finger è un comando che mi permette
di conoscere dati sugli utenti collegati ad altri host, mi fornisce i dati
dell'utente che legge dal passwd, su molte macchien viene disabilitato per
motivi di sicurezza.
snowwhite:/>
snowwhite:/> finger lauravi@c220.unimo.it
finger: c220.unimo.it: Connection
refused
[c220.unimo.it]
snowwhite:/>
snowwhite:/> finger corsouni@snowwhite.unimo.it
[snowwhite.unimo.it]
Login name: corsouni In real life:
Corso Unix Provincia
Directory: /mnt/corsouni Shell:
/bin/tcsh
On since Jun 6 09:25:41 on ttyq0 from
baynet.unimo.it On since Jun 3 17:54:15 on ttyq1 from cicpc04
Login name: corsouni In real life:
Corso Unix Provincia No Plan.
snowwhite:/>
snowwhite:/> finger @giove.unimo.it
[giove.unimo.it]
Login Name TTY Idle When Office
teggi Sergio Teggi q0 Fri 11:06
santoro Giorgio Santoro q1 54 Fri 08:15
+39 59 5860
goldoni Guido Goldoni *q2 18: Mon 09:16
santoro Giorgio Santoro q3 43 Fri 08:35
+39 59 5860
rastelli Augusto Rastelli q4 Fri 08:41
+39 59 3784
morelli Sandra Morelli q6 1:49 Fri
09:35 +39 59 3707
morelli Sandra Morelli q7 8 Fri 11:16
+39 59 3707
rastelli Augusto Rastelli q9 5 Fri
11:19 +39 59 3784
goldoni Guido Goldoni q12 8d Thu 11:09
APPENDICE A
Editor VI
Comando :
vi [opzioni ] file1 [file2 ... fileN]
- vi file1
- consente
di attivare la sessione di editor relativa al file1
- file1
viene trasferito in un buffer temporaneo ed una parte di esso viene
visualizzato su schermo (=finestra del file )
- all'
interno della finestra e' possibile
- spostare
il cursore
- sostituire
- aggiungere
parole o linee di testo
- cancellare
- le
modifiche sono effettuate sul buffer . E' quindi necessario ricopiare le
modifiche nel file prima di terminare la sessione di editor
- vi file1 file2 file3 ... fileN
il sistema visualizza "N file to
edit" ed il primo degli N
file viene letto nel buffer di editor
per passare agli altri file :e filen
- vi -r file
in caso di caduta del sistema durante
la fase di editor recupera il file1 con le modifiche eseguite sino a quel
momento
Quando lancio il comando
vi file1
entro in modalità comandi
Esistono due modalità di lavoro in vi
- modalità
comandi
- modalità
inserimento
Si passa da una modalità all'altra
tramite il tasto ESC
modalità comandi modalità inserimento
ESC ESC
( per uscire dalla modalità comandi ) (
per uscire dall' inserimento )
i per entrare in inserimento : seguito
dal comando
Inserimento
i insert inserisce nuovo testo prima della posizione corrente
a append inserisce nuovo testo dopo la posizione corrente
o apre in inserimento una linea al di sotto della posizione corrente
O apre in inserimento una linea al di sopra della posizione corrente
Uscita dall' editor
:wq termina la sessione di lavoro salvando le modifiche fatte
:q! forza l'uscita dall'editor senza salvare le modifiche
:w scrive su file le modifiche effettuate , ma rimane in editor
:q esce da vi se non sono state effettuate modifiche
per muoversi all'
interno del file ( in modo inserimento )
sx h
alto k
destra l
basso j
Comandi
In modalità comandi , quasi tutti i
tasti (comprese le combinazioni lettere + shift o control ) corrispondono a
comandi .
Attenzione: W è diverso da w
La struttura del comando è
[contatore] operatore [contatore]
oggetto
w sposta il cursore all' inizio della parola successiva
w può essere sia operatore che oggetto
d cancella
dw cancella la parola successiva
parola = sequenza di caratteri
circondata da spazi
3dw ripete 3 volte l'operazione di "cancella parola" ( e quindi
cancella tre parole )
d3w cancella tre parole
3d3w ripete tre volte l'operazione d3w cancella 9 parole
dd cancella 1 riga
3dd cancella 3 linee
4w sposta il cursore di 4 parole
Per cancellare
x cancella il carattere su cui è posizionato il cursore
X cancella il carattere a sx del cursore
r sostituisce il carattere su cui è posizionato il cursore
Undo e repeat
u elimina l'effetto della ultima modifica fatta
U elimina tutte le modifiche fatte su una linea
. ripete l' ultimo comando dato
Ricerca di stringhe
/stringa ricerca in avanti "stringa"
?stringa ricerca indietro "stringa"
n trova la successiva occorrenza nella
medesima direzione
N ...... nella direzione opposta
Combinazioni varie
d$ $ = sino a fine riga vengono cancellati i caratteri a partire dalla
posizione corrente sino a fine riga
d^ ^ =inizio riga
vengono cancellati i caratteri da
inizio riga sino alla posizione del cursore
cw testo c= change
cw cambia la parola con testo , a
partire dalla posizione in cui si trova il cursore.
Per spostare o copiare testo all'interno del file
P paste , copia il contenuto del buffer nel testo a partire dalla posizione
in cui si trova il cursore
Y Yank, copia la riga su sui si trova il cursore nel buffer
Per copiare 2 righe consecutive del
file da una posizione ad un'altra vado a inizio riga
2Y
vado dove devo inserire la copia
2P
Per spostare 2 righe consecutive del
file da una posizione ad un'altra vado a inizio riga
2dd
vado dove devo inserire la copia
2P
BIBLIOGRAFIA CONSIGLIATA
Brian W. Kernighan, Rob Pike, UNIX, Zanichelli
A. S. Tanenbaum, Modern Operating
Systems, Prentice-Hall International, Inc, 1992
Evi Nemeth - Garth Snyder - Scott
Seabass - Trent R. Hein
Unix System Adminstration Handbook
Prentice Hall
Sams Development Team, UNIX unleashed,
Sams publishing, 1994