I riassunti , gli appunti i testi contenuti nel nostro sito sono messi a disposizione gratuitamente con finalità illustrative didattiche, scientifiche, a carattere sociale, civile e culturale a tutti i possibili interessati secondo il concetto del fair use e con l' obiettivo del rispetto della direttiva europea 2001/29/CE e dell' art. 70 della legge 633/1941 sul diritto d'autore
Le informazioni di medicina e salute contenute nel sito sono di natura generale ed a scopo puramente divulgativo e per questo motivo non possono sostituire in alcun caso il consiglio di un medico (ovvero un soggetto abilitato legalmente alla professione).
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
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.
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
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)
-------------------
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 del file:
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
(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 del file system (formato ext2):
# mount -t ext2 /dev/fd0H1440 /mnt
Utilizzo del file system:
# cp *.tex /mnt
Smontaggio del file system:
# umount /mnt
Estrazione del dischetto.
/ ____________________: 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
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:
collezione di caratteri per memorizzare informazioni
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
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
...
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.
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:
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 9/29/83 | awk '{split ($0,date,"/"); print date[3]}'
Uso di operatori matematici:
$ awk -F: 'NF%2 != 0' file_input
$ cat file_input | awk '{s=s+$1} END {print s}'
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 (11:02)
talk: Connection requested by robby@c220.unimo.it
talk: Respond with talk robby@c220.unimo.it
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 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
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)
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 |
$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
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 :
il comando e` scritto accanto al prompt, l'utente attende la fine del comando
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
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.
-f lista completa
-l lista lunga (priorità, stato del
processo (waiting, sleeping) ...)
output del comando 'ps -ef'
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 ? 1:04 vhand
root 3 0 0 Jan 2 ? 4:44 statdaemon
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 ? 1:22 /usr/sbin/named
daemon 4692 1 0 15:19:21 ? 0:00 grmd
root 236 1 0 Jan 2 ? 3:20 /usr/sbin/syncer daemon 549 1 0 Jan 2 ? 0:07 sendmail -bd -q30m -accepting connections
root 338 1 0 Jan 2 ? 1:26 /usr/sbin/syslogd -D
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 15:20:53 ? 0:00 /usr/vue/bin/vuelogin
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 ? 12:24 /usr/bin/X11/X :0
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 15:20:53 ? 0:04 vuegreet -display cix07:0
llane 5520 5519 0 15:46:18 ttyp1 0:00 -tcsh
llane 5538 5520 163 15:47:22 ttyp1 1:07 /usr/local/Mathematica/Bin/mathexe -pwpath {"/usr/local/Math
root 4703 4688 0 15:19:29 ? 0:04 vuegreet -display c220.unimo.it: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
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
( 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
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)
priorita` del processo, CPU consumata, ...
puntatori ai segmenti text, data, stack.
stato corrente di ogni processo, pid, ppid, uid e gid
2. USER STRUCTURE (caricata solo quando il processo relativo e` in memoria)
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.
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
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
Altri comandi che si possono utilizzare sono
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 18:55:27 GMT 1995
corso console Feb 17 18:48
$ date; who | wc
Fri Feb 17 18:55:27 GMT 1995
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 18:55:27 GMT 1995 output di (2)
$ 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
1. ESEGUIRE I COMANDI
% alias rm rm -i
% unalias rm
% who -H; df -v
% echo ciao \
a tutti
% 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
% repeat 5 echo *******
% 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
% 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
< 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
I seguenti caratteri vengono interpretati dalle shell:
~ ` ! @ # $ % ^ & * ( ) \ | { } [ ] ; ' " < . ?
Per poterli usare evitando che la shell li interpreti esistono due modi:
% echo "he said: \"John !\""
% echo "*.txt"
% set a=`ls *.txt`
% echo "files: $a"
% echo 'files: $a'
2. VARIABILI
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
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
$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
$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
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 \{\}\;
@a=8+2*5
set x=2 y=3 sum
@sum = $x + $y
echo $sum
-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
if ( -f newfile) then
if ( ! -d ~/bin) mkdir ~/bin
mv newfile ~bin
else
echo new file: file not found
exit
endif
echo -n Do you want to proceed ?
set reply=$<
switch ($reply)
case y*:
mv newfile ~/bin
breaksw
default:
echo newfile not moved
endsw
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
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
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
BSD spooling system (lpd, lpc, lpr, ...)
ATT spooling system (lpsched, lpadmin, lp, ...)
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 '
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
Editor VI
Comando :
vi [opzioni ] file1 [file2 ... 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
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
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
Fonte: http://www.galileicrema.it/Intraitis/documenti/MaterialeDidattico/UNIX.doc
Sito web da visitare: http://www.galileicrema.it
Autore del testo: non indicato nel documento di origine
Il testo è di proprietà dei rispettivi autori che ringraziamo per l'opportunità che ci danno di far conoscere gratuitamente i loro testi per finalità illustrative e didattiche. Se siete gli autori del testo e siete interessati a richiedere la rimozione del testo o l'inserimento di altre informazioni inviateci un e-mail dopo le opportune verifiche soddisferemo la vostra richiesta nel più breve tempo possibile.
I riassunti , gli appunti i testi contenuti nel nostro sito sono messi a disposizione gratuitamente con finalità illustrative didattiche, scientifiche, a carattere sociale, civile e culturale a tutti i possibili interessati secondo il concetto del fair use e con l' obiettivo del rispetto della direttiva europea 2001/29/CE e dell' art. 70 della legge 633/1941 sul diritto d'autore
Le informazioni di medicina e salute contenute nel sito sono di natura generale ed a scopo puramente divulgativo e per questo motivo non possono sostituire in alcun caso il consiglio di un medico (ovvero un soggetto abilitato legalmente alla professione).
"Ciò che sappiamo è una goccia, ciò che ignoriamo un oceano!" Isaac Newton. Essendo impossibile tenere a mente l'enorme quantità di informazioni, l'importante è sapere dove ritrovare l'informazione quando questa serve. U. Eco
www.riassuntini.com dove ritrovare l'informazione quando questa serve