La shell di Unix - Dipartimento di Scienze Ambientali, Informatica e

Transcript

La shell di Unix
Uso interattivo e scripting
Paolo Baldan
[email protected]
Dipartimento di Informatica
Università di Venezia
La shell di Unix – p.1/96
Obiettivi
L’obiettivo di questo ciclo di lezioni è quello di illustrare le funzionalità
principali della shell di U NIX e di tools comunemente presenti nelle
distribuzioni di U NIX.
Uso interattivo della shell
Concetti di base, interazione con la shell, comandi di base, personalizzazione.
Struttura e funzionalità della shell di U NIX (con particolare
riferimento a Linux ed alla Bash shell).
Espansione della riga di comando, ridirezione, comandi composti (liste, pipe, sequenze
condizionali).
Programmazione della shell (shell scripting).
Funzioni, pattern matching, costrutti di controllo, tipi, segnali, debugging.
Introduzione a UNIX
(Ripasso)
Cos’è UNIX
U NIX è un sistema operativo multiutente e multitasking.
Più utenti possono avere vari tasks/processi che sono eseguiti
contemporaneamente.
U NIX è anche un ambiente di sviluppo software.
È nato ed è stato progettato per questo scopo. (Ad esempio fornisce
utilità di sistema, editor, compilatori, assemblatori, interpreti, . . . )
U NIX è stato appositamente progettato per essere generale e
indipendente dall’hardware (facilmente portabile essendo scritto nel
linguaggio ad alto livello C).
Breve storia di UNIX/A
1965: La AT&T, il MIT e la General Electric si uniscono nel
progetto di un s.o. innovativo, che sia multiutente, multitasking,
multiprocessore, con multilevel file system: M ULTICS .
1969: Il progetto M ULTICS “fallisce”.
Presso i Bell Laboratories della AT&T, dalle ceneri di M ULTICS
nasce U NIX , sviluppato da Ken Thompson e Dennis Ritchie del
gruppo Multics per un PDP-7. Anche sulla base dell’ esperienza
M ULTICS, incorpora alcune caratteristiche e supera i limiti di sistemi
operativi preesistenti, supportando, in modo efficiente, multiutenza e
multitasking.
Il nome U NIX (inizialmente Unics) è scelto da Kernighan in
opposizione a M ULTICS.
Breve storia di UNIX / C
1973: La terza versione viene scritta nel linguaggio di
programmazione ad alto livello C (anziché in assembler), sviluppato
ai Bell Labs da Dennis Ritchie (come evoluzione di B) proprio per
supportare UNIX.
È un passo importante dato che esisteva la convinzione che solo il
linguaggio Assembly permettesse di ottenere un livello di efficienza
accettabile.
Fine anni ’70: AT&T rende U NIX largamente disponibile, offrendolo
alle Università a basso costo e distribuisce i sorgenti di varie versioni
(costretta da un decreto dell’antitrust che le impone di scegliere tra
telecomunicazioni e informatica).
Breve storia di UNIX / D
1984: presso l’Università di Berkeley (California) nasce la Berkeley
Software Distribution (BSD).
versione 4BSD: sviluppata con una sovvenzione del DARPA al
fine di progettare uno standard UNIX per uso governativo.
versione 4.3BSD: sviluppata originariamente per il VAX, è una
delle versioni più influenti. Verrà “portata” su molte altre
piattaforme.
1984: molte caratteristiche della BSD vengono incorporate nella
nuova versione di AT&T: la System V.
Esistono oggi diverse implementazioni di UNIX supportate da molte
case costruttrici di computer: SunOS/Solaris (Sun Microsystems),
Ultrix (DEC), XENIX (Microsoft), AIX (IBM), . . . .
Storia di “free” UNIX
1983: Richard Stallmann (MIT) inizia una reimplementazione “free”
di UNIX, detta GNU (acronimo ricorsivo di “GNU is not UNIX”) che
porterà a un editor (emacs), un compilatore (gcc), un debugger
(gdb) e numerosi altri tools.
1991: Linus Torvald (studente ad Helsinki) inizia l’implementazione
di un kernel POSIX compatibile, che prenderà il nome di Linux.
Arricchito con i tools GNU esistenti ed altri sviluppati da volontari,
diviene un sostituto completo di UNIX.
1991: L’ Università di Berkeley rilascia una versione “free” di UNIX,
rimuovendo il codice proprietario rimanente della AT&T. Progetti
volontari continueranno poi il suo sviluppo (FreeBSD, NetBSD,
OpenBSD).
Copyleft
Public domain
Il metodo più semplice per produrre “free software” è quello di
renderlo di pubblico dominio, senza copyright.
In questo modo, però, qualcuno può modificare il software e
distribuirlo come un prodotto proprietario.
Copyleft: permette di distribuire un software come free, garantendo
che eventuali versioni modificate ed estese saranno ancora free.
Ogni utente può avere accesso libero al software.
Può avere accesso ai sorgenti, modificare il programma ed
estenderlo.
Può ridistribuirlo, ma con lo stesso tipo di licenza.
Filosofia di UNIX
Influenzata da problematiche relative all’HW disponibile all’epoca della
progettazione di UNIX: i dispositivi di I/O erano teletype e più tardi
terminali video con 80 caratteri per linea (ASCII fixed width).
Comandi, sintassi di input e output succinti (per ridurre il tempo di
battitura).
Ogni componente/programma/tool realizza una sola funzione in
modo semplice ed efficiente (UNIX vs. MULTICS). Es. who e sort.
L’output di un programma può diventare l’input di un altro.
Programmi elementari possono essere combinati per eseguire
compiti complessi (Es. who | sort).
Il principale software di interfaccia (la shell) è un normale
programma, sostituibile, senza privilegi speciali.
Supporto per automatizzare attività di routine.
Motivi del successo di UNIX
Ha dimensioni relativamente ridotte, un progetto modulare e “pulito”
Indipendenza dall’hardware
Il codice del SO è scritto in C anziché in uno specifico
linguaggio assembler.
UNIX e le applicazioni UNIX possono essere “facilmente”
portate da un sistema hardware ad un altro. Il porting
usualmente consiste nel trasferire il codice sorgente e
ricompilarlo.
È un ambiente produttivo per lo sviluppo del software
Ricco insieme di tool disponibili.
Linguaggio di comandi versatile.
Principali caratteristiche di UNIX
Gestione dei Processi
Sono basati sul modello fork / exec
Hanno un’identità ed un possessore, informazioni utilizzate per
protezione e scheduling.
La CPU è gestita in time-sharing, suddividendo il tempo di CPU
in slice (quanti di tempo), assegnate ai processi in base a priorità
(e comportamento passato).
Supporto alla programmazione concorrente e distribuita, tramite
meccanismi di IPC.
Gestione della memoria
basata su paginazione
con varianti, es. buddy system
Principali caratteristiche di UNIX/A
File System
Struttura gerarchica grafo radicato (aciclico), in cui file e
processi hanno una propria locazione.
Strumenti per la creazione, modifica e distruzione e protezione
(controllo degli accessi) ai file.
Unix è orientato ai file: Tratta i dispositivi periferici come se
fossero dei file (speciali). Stampanti, terminali ed altri
dispositivi sono accessibili nello stesso modo di file ordinari.
Componenti di UNIX
Kernel: nucleo del sistema (gestore di risorse: CPU, memoria,
dispositivi, . . . )
System Call e routine di libreria: facilitano la programmazione,
permettendo di accedere a funzionalità del kernel (manipolazione di
file, gestione di processi concorrenti e comunicazione tra processi).
Shell: interprete di comandi (interfaccia tra l’utente ed il kernel).
Utilities: programmi di utilità (editor, operazioni su file, stampa,
supporto alla programmazione, . . . )
Programmi di utilità
6System call
?
kernel
HW
Shell
Utente
Uso interattivo della shell
La Shell (informalmente . . . )
Interfaccia (testuale) tramite la quale l’utente interagisce con il
sistema dopo il login.
È un interprete di comandi: legge ciascuna linea di comando, ne
interpreta le diverse componenti e la esegue.
Ogni sistema UNIX mette a disposizione vari tipi di shell. Le shell
più diffuse sono:
Bourne shell (sh), C shell (csh), Korn shell (ksh), TC shell (tcsh),
Bourne Again shell (bash).
Inizialmente, l’amministratore del sistema fornisce all’utente una
shell di default che però può essere cambiata o personalizzata.
Ogni shell fornisce un linguaggio di programmazione. I programmi
di shell, chiamati shell script, sono sequenze di comandi, con
costrutti di controllo, che automatizzano semplici task.
Perché usare una shell testuale?
Ormai tutti i sistemi UNIX hanno un’interfaccia grafica. Perché usare i
comandi in linea di una shell testuale?
Potenza e semplicità: I comandi UNIX sono progettati per risolvere
problemi specifici. Sono semplici (senza menù e opzioni nascoste) e
proprio per questo potenti (es. grep parola filename).
Velocità e flessibilità: è più veloce scrivere pochi caratteri da tastiera
piuttosto che cercare un programma opportuno e usare le operazioni
che fornisce sulla base delle proprie specifiche esigenze.
Accessibilità: permette di accedere efficientemente ad un sistema in
remoto.
I comandi UNIX
La sintassi tipica dei comandi UNIX (builtin e file eseguibili) è la seguente
comando <opzioni> <argomenti>
Opzioni
Sono opzionali e influiscono sul funzionamento del comando.
Consistono generalmente di un hyphen (-) seguito da una sola lettera
(Es. ls -l). Hanno anche una forma estesa (Es. ls --format
long). Possono avere un argomento (Es. dvips -o p.ps p.dvi).
Spesso più opzioni possono essere raggruppate insieme dopo un solo
hyphen (Es. ls -al).
Argomenti
Si possono avere più argomenti o nessuno.
Alcuni argomenti sono opzionali. Se non specificati assumono valori
di default.
I comandi di UNIX - Esempi
nessun argomento: il comando date mostra data e ora corrente.
date
un solo argomento: il comando cd cambia la directory di lavoro
corrente in quella specificata dal suo argomento.
cd mydir
un’opzione ed un argomento: il comando wc conta il numero di
parole/caratteri/righe in un file, in base all’opzione specificata.
wc -w file1
conta le parole in file1
wc -c file1
conta i caratteri in file1
wc -l file1
conta le linee in file1
I comandi di UNIX - Esempi / A
numero arbitrario di argomenti: il comando cat concatena e mostra
sullo schermo il contenuto dei file argomento.
cat file1 file2 file3
più opzioni ed un argomento di default:
ls -als
lista dettagliata (l, long) di tutti (a, all) i file, con dimensione
(s, size). L’argomento di default è la directory corrente.
Più comandi, separati da “;” possono essere scritti sulla stessa linea.
cd newdir ; ls -l
I comandi possono essere scritti su più linee usano il carattere
backslash (\). Ad esempio,
cp /users/kelly/recipe kelly.recipe ; \
lpr -Pps3 kelly.recipe
Caratteri di controllo
Alcune combinazioni di tasti hanno un effetto particolare sul terminale.
I caratteri di “controllo” sono ottenuti tenendo premuto il tasto Ctrl e
quindi premendo un secondo tasto. Ecco i più comuni:
Ctrl-u
Ctrl-c
Ctrl-h
Ctrl-z
Ctrl-s
Ctrl-q
Ctrl-d
-
erase the command line
stop/kill a command
backspace (usually)
suspend a command
stop the screen from scrolling
continue scrolling
exit an interactive program
(signals end of data)
Esempio - Ctrl-d
Il programma cat, senza argomenti, copia l’input (battuto da
tastiera) sull’output (schermo). Es.
/home/rossi$ cat
Questo l’ho scritto io! ← input
Questo l’ho scritto io! ← output
La mancanza del prompt indica che siamo ancora in cat.
Per segnalare a cat (ed a molti altri programmi interattivi) la fine
dell’inserimento dei dati occorre digitare Ctrl-d, detto carattere di
fine-file (End-Of-File o EOF).
Esempio: Provate il programma sort: se inserite un paio di linee e
poi premete Ctrl − d, sort le visualizzerà in ordine alfabetico.
Editing della linea di comando
Molte shell, tra cui bash, offrono funzioni di editing della linea di
comando che sono “ereditate” dall’editor emacs. Ecco alcune delle
funzioni più utili:
Ctrl-a
Ctrl-e
Ctrl-k
Ctrl-y
Ctrl-d
-
va a inizio riga
va a fine riga
cancella il resto della linea
reinserisce la stringa cancellata
cancella il carattere sul cursore
La shell, inoltre, registra i comandi inseriti dall’utente. Il comando
history li elenca. Per richiamarli . . .
!! - richiama il comando precedente
!n - richiama la n-ma entry
↑, ↓ - naviga nella history
Completamento dei comandi
Un’altra caratteristica di bash è il completamento automatico della linea di
comando con il tasto Tab.
Vediamo un esempio di utilizzo. Supponiamo di essere in questa
situazione.
/home/rossi$ ls
un-file-con-un-nome-molto-lungo
Per copiare il file su corto, anziché digitare per esteso il nome si
può digitare cp un. Quindi premendo il tasto Tab il resto del nome
viene mostrato nella riga di comando e si potrà a questo punto
completare il comando.
Se esistono più completamenti possibili, premendo Tab verrà emesso
un suono. Premendo nuovamente Tab si ottiene la lista di tutti i file
che iniziano in quel modo.
Gestione dei files
File system
File system: è la struttura che permette la memorizzazione e
l’organizzazione dei dati nel sistema.
È estremamente importante perché UNIX è un sistema orientato ai
file nel senso che molte operazioni vengono effettuate tramite essi
(accesso a periferiche e comunicazione tra processi).
Un nome nel file system può riferirsi a:
file dati (che può anche essere una directory)
dispositivo di input/output (disco, nastro, stampante, . . . )
memoria interna
informazioni sul sistema hardware e software
File system / A
Un file può essere visto come una sequenza di byte,
indipendentemente dal tipo di file (file dati, dispositivo, . . . )
Una directory può essere vista come un contenitore di file o di
directory, si ha quindi una struttura gerarchica (ad albero . . . se si
trascurano i link).
/P
Z PP P
J Z
PP
J
P
P
Z
usr
tmp
home
etc
lib
bin
"
dev
D
"
D
"
" lib local
E
bin
E
ttya null passwd group
user1 user2 user3
sh date csh
BB
mail
bin
papers
Organizzazione del file system
Per tradizione esistono alcune directory che nel file system assumono un ruolo
particolare.
\
bin
sbin
è la radice della gerarchia;
comandi più importanti del sistema;
comandi che riguardano alcune importanti funzioni di gestione del sistema
(dump, shutdown, ecc.);
dev
etc
lib
mnt
var
dispositivi di input/output che possono essere visti dalla macchina (dischi, nastri, ecc.);
usr
contiene i file non essenziali ma utili (es: le sottodirectory bin con emacs, gzip, ...
X11R6 con il sistema XWindow, man con tutti i manuali, src con tutti i sorgenti);
proc
è un file system virtuale che contiene tutte le informazioni di sistema, dai processi
alla cpu (cpuinfo, version, . . . ).
home
contiene le directory personali di tutti gli utenti.
file di configurazione del sistema (passwd, fstab, lilo.conf, ecc.);
librerie condivise per ridurre la dimensione dei file eseguibili;
mount point dei dispositivi esterni;
contiene file di dimensione variabile (es. in log ci sono i file di log, in spool
ci sono file usati da altri programmi (posta in ingresso, stampe, . . . );
Working e Home directory
In UNIX ogni processo ha associata una working directory (directory
di lavoro).
Per conoscere la directory corrente si può utilizzare il comando pwd
$ pwd
/home/rossi
$
Ogni utente “username” ha una home directory — la parte del file
system riservata per suoi file. È indicata con
˜username
Dopo il login, l’utente si trova automaticamente nella propria home
directory, da dove comincia a lavorare.
Navigare nel file system - cd
Ci si può spostare all’interno del file system e quindi modificare la
working directory con il comando cd.
cd [<dir>]
Il parametro <dir> è opzionale. Se non viene indicato, il comando
porta nella home directory. Es:
/home/rossi$ cd /bin
/bin$ cd
/home/rossi$
Per la navigazione risultano utili le directory: “.” (working directory)
e “..” (directory padre). Es:.
/home/rossi$ cd ..
/home$ cd .
/home$
Pathname
Specifica la locazione di un file all’interno di un file system.
Pathname assoluto: dice come raggiungere un file partendo dalla
radice del file system; comincia sempre con / (slash).
/usr/local/doc/training/sample
Pathname relativo: dice come raggiungere un file a partire dalla
working directory o dalla home directory di un utente.
training/sample
../bin
˜/projects/report
˜rossi/projects/report
Esempio: Per spostarsi da /home/rossi a /home/bianchi:
cd ../bianchi
cd /home/bianchi
- relative pathname
- absolute pathname
Visualizzare una directory
Il comando ls permette di visualizzare il contenuto di una (o più)
directory.
ls [-alsFR] [<dir1> ... <dirn>]
Alcune opzioni:
-a
-l
-s
-F
-R
visualizza anche i file nascosti (che iniziano con “.”)
visualizza informazione estesa sui file
visualizza la dimensione
aggiunge un carattere finale al nome che ne denota il tipo:
“/” per directory, “*” per eseguibile, “@” per link,
“=” per socket, nessuno per i file ordinari).
mostra ricorsivamente le sottodirectory
Se non viene specificata nessuna directory, ls si riferisce alla directory
corrente.
Creare e rimuovere directory
Tramite i comandi mkdir e rmdir si possono creare e cancellare directory.
mkdir <dir1> [<dir2> ... <dirn>]
rmdir <dir1> [<dir2> ... <dirn>]
Ognuno degli argomenti è considerato una directory da creare/cancellare.
Es.:
/home/rossi$ mkdir report-2000 report-2001
/home/rossi$ ls -F
report-2000/ report-2001/
/home/rossi$ rmdir report-2000 report-2002
rmdir:
report-2002:
No such file or directory
/home/rossi/$ ls -F
report-2001/
Una directory può essere rimossa solo se è vuota:
/home/rossi$ rmdir ..
rmdir:
‘..’: Directory not-empty
Copiare, spostare, rimuovere file
Tramite il comando cp si possono copiare file:
cp -i <oldname> <newname>
cp -ir <name1> [<name2> ... <namen>] <destdir>
Prima forma: crea una copia <newname> del file <oldname>. Con l’opzione
“-i” il sistema chiede conferma prima di sovrascrivere un file. Es:
/home/rossi$ ls
chap1
/home/rossi$ cp chap1 chap2; ls
chap1 chap2
Seconda forma: il comando ha più di due argomenti. In questo caso
l’ultimo <destdir> deve essere una directory, dove vengono inseriti i file
<name1> ... <namen>. L’opzione “-r” permette di copiare
ricorsivamente le sottodirectory.
Copiare, spostare, rimuovere file / A
Il comando mv per spostare/rinominare file ha sintassi e
funzionamento simile a cp, se non per il fatto che il file originale
scompare
mv -i <oldname> <newname>
mv -i <name1> [<name2> ... <namen>] <dest>
Copia + rimozione? Move tra fs diversi?
Il comando per la cancellazione di file è rm ed ha sintassi
rm -ir <name1> <name2> ... <namen>
Particolarmente interessante l’opzione “-r” che permette di
rimuovere una directory con tutto il corrispondente “sottoalbero”.
I Metacaratteri
Accade spesso di voler operare su più file contemporaneamente. Ad es.
supponiamo di voler copiare tutti i file che cominciano con data nella
directory ˜/backup).
UNIX
fornisce un modo molto efficiente per ottenere questo scopo:
/home/rossi/report$ ls -F
data-new
data1
data2
inittab2
pippo
/home/rossi/report$ mkdir ˜/backup
/home/rossi/report$ cp data* ˜/backup
/home/rossi/report$ ls -F ˜/backup
data-new
data1
data2
/home/rossi/report$
(Cosa farebbe cp d*2 ˜/backup?)
I Metacaratteri / A
Ecco un elenco dei metacaratteri:
?
ogni carattere
*
ogni stringa di caratteri
[set]
ogni carattere in set
[!set]
ogni carattere non in set
dove set può essere una lista di caratteri (es. [abc]) oppure un intervallo
(es. [a-c]) o una combinazione dei due.
Se la shell trova un’espressione contenente metacaratteri in una linea di
comando, la espande con tutti i nomi di file che “soddisfano” (match)
l’espressione (espansione di percorso).
I Metacaratteri / B
Per capire meglio come funziona l’espansione di percorso introduciamo un
nuovo comando, echo. È un comando estremamente semplice: rimanda
sullo schermo ogni parametro.
/home/rossi$ echo Ciao!
Ciao!
/home/rossi$ cd report
/home/rossi/report$ ls -F
data-new
data1
data2
inittab
/home/rossi/report$ echo data*
data-new
data1
data2
/home/rossi/report$ echo data?
data1
data2
/home/rossi/report$ echo [!id]*
pippo
pippo2
/home/rossi/report$
pippo
pippo2
Es. Cosa accade se si esegue cd *?
Caratteri speciali
NEWLINE - initiates command execution
; - separates commands on same line
( ) - groups commands or identifies a function
& - executes a command in the background
| - pipe
> - redirects standard output
>> - appends standard output
< - redirects standard input
* - wildcard for any number of characters in a file name
? - wildcard for a single character in a file name
- quotes the following character
’ - quotes a string preventing all substitutions
" - quotes a string allowing variable and command substitution
‘ - performs command substitution
[ ] - denotes a character class in a file name
$ - references a variable
- command grouping within a function
. - executes a command (if at beginning of line)
# - begins a comment
: - null command
Accesso ai file
Informazioni sui file
Time stamp — Ad ogni file sono associate tre date: cambiamento
attributi, la data di ultima modifica e ultimo accesso.
User (Proprietario) — Ogni file in UNIX è di proprietà di un utente
del sistema.
Group (Gruppo) — Ogni file è associato ad un gruppo di utenti:
quello più comune per i file utente è chiamato users, ed è
generalmente condiviso da tutti gli account utente del sistema.
Permessi — Ad ogni file sono associati dei permessi (chiamati anche
“privilegi”), che specificano chi e in che modo (lettura, modifica,
esecuzione) può accedere a quel file. Ognuno di questi permessi può
essere impostato separatamente per il proprietario, il gruppo e tutti
gli altri utenti (others).
Modificare le informazioni sui file
Le informazioni sui file possono essere visualizzate tramite il
comando ls -l. Per esempio
rossi@linuslab:/home/rossi/report
total 2
-rw-r--r-- 1 rossi users
15
-rw-r--r-- 1 rossi users
155
drwxr-xr-x 2 rossi users
1024
> ls -l
Mar 9 12:40 pippo
Mar 9 12:41 pluto
Mar 7 17:33 OLD
In particolare, ogni linea include:
il tipo del file (primo carattere)
i permessi di accesso (caratteri 2-10):
2-4: owner
5-7: group
il proprietario
il gruppo
8-10: other
Permessi di accesso
I permessi possono (sostanzialmente) essere:
r = permesso di lettura
w = permesso di scrittura
x = permesso di esecuzione
- = mancanza di permesso
Alcuni esempi
-rw-------rw-r--r--rwxr-xr-x
drwxr-x---
1
1
1
1
rossi
rossi
rossi
rossi
users
users
users
users
3287
13297
4133
1024
Apr
Apr
Apr
Jun
8
8
8
7
12:10
12:11
12:10
10:00
file1
file2
myprog
SCCS
Il permesso x su una directory consente di “attraversarla”.
C’è una forma di dipendenza: per accedere ad un file, oltre ai diritti
necessari per l’operazione desiderata, occorre il permesso x su ogni
directory che compare nel pathname.
Cambiare i permessi con chmod
chmod <triads> <filename>*
dove triads sono della forma who action permission
who
action
permission
u
=
user
+
=
aggiunge
r
=
read
g
=
group
-
=
rimuove
w
=
write
o
=
other
=
=
assegna
x
=
execute
a
=
all
=
user
Cambiare i permessi con chmod / A
Alcuni esempi:
chmod a+r sample.c
chmod o-r sample.c
chmod og+rx prog*
chmod g=rw rep*
chmod +w *
L’opzione -R cambia (ricorsivamente) i permessi di una directory e
di tutti i file e sottodirectory di quella directory.
chmod “numerico”
I permessi di accesso rwx possono essere rappresentati come un
numero ottale. Es. r-x diviene 101 e quindi 58 .
Il permesso r è rappresentato da 4, w da 2 e x da 1. Per ciascuna
categoria di utenti (proprietario, gruppo, altri) questi valori possono
essere sommati. Quindi, si ha
0
1
2
3
=
=
=
=
----x
-w-wx (1+2)
4
5
6
7
=
=
=
=
r-r-x (4+1)
rw- (4+2)
rwx (4+2+1)
I permessi di accesso possono allora essere espressi con 3 cifre ottali.
chmod 640 file1
chmod 754 file1
chmod 664 file1
user
rwrwx
rw-
group
r-r-x
rw-
others
--r-r-La shell di Unix – p.46/96
Stabilire i permessi con umask
umask <mask>
Può essere utilizzato per assegnare i permessi di default.
Tipicamente è usato in uno dei file di startup (per esempio, .login,
.cshrc, .profile) ma può essere usato anche in modo interattivo.
Specifiche ottali (anche simboliche in bash). Diversamente da chmod,
rappresentano i permessi da “mascherare” (cioè, da rimuovere).
Octal number
0
1
2
3
4
5
6
7
Access
rwx
rwr-x
r--wx
-w--x
---
permissions given
read, write and execute
read and write
read and execute
read only
write and execute
write only
execute only
no permissions
Stabilire i permessi con umask / A
Il sistema assegna di default i permessi 666 per i file e 777 per le
directory.
Alcuni esempi:
umask 077
Sottrae 077 dai permessi di default del sistema per i file e le
directory. Il risultato è che i permessi di default diventano 600
per i file (rw-------) e 700 (rwx------) per le directory.
umask 002
Sottrae 002 dai permessi di default del sistema per i file e le
directory. Il risultato è che i permessi di default diventano 664
per i file (rw-rw-r--) e 775 (rwxrwxr-x) per le directory.
! umask sottrae i valori passati come parametri sempre ai valori di
default (666 e 777), anche se usato più volte consecutivamente.
Cambiare proprietario e gruppo
Per cambiare il proprietario (owner) di un file
chown <new owner> <filename>
Nella maggior parte dei sistemi UNIX, per modificare il proprietario
di un file bisogna essere un super-user (es. l’amministratore del
sistema).
Il proprietario di un file può cambiare il gruppo (group) del file con
un qualsiasi altro gruppo a cui l’utente stesso appartenga.
chgrp <new group> <filename>
Per entrambi i comandi al’opzione -R permette di propagare
ricorsivamente il cambiamento su tutta una directory.
Visualizzare i file
Mostrare il contenuto di un file
Il comando cat concatena e visualizza sullo schermo (standard
output) il contenuto di uno o più file .
cat [<filename1> ...<filenamen>]
Il comando echo visualizza sullo schermo l’argomento che gli viene
passato (a cui aggiunge un carattere newline, a meno che non si
specifichi l’opzione -n).
echo [-n] <string>
I comandi more, less e pg (potrebbero non essere tutti disponibili)
mostrano il contenuto di un file una schermata alla volta. Inoltre,
permettono di tornare a pagine precedenti, di effettuare ricerche, . . . .
Il comando less
Una volta digitato
less <filename>
si può navigare nel file. Ecco alcune opzioni
↑, ↓ scorre su e giù di una riga;
←, → scorre a dx e sx di una schermata;
/<pattern> cerca <pattern> in avanti;
?<pattern> cerca <pattern> indietro;
<n>g va alla riga <n>;
g, G va ad inizio/fine file;
q esce e torna al prompt;
e molte altre (h dà l’help in linea).
Mostrare parte di un file
Il comando head mostra le prime 10 linee di un file. Se si usa
l’opzione -n, head mostra le prime n linee.
head [-n] file
Il comando tail mostra le ultime 10 linee di un file. Se si usa
l’opzione -n, tail mostra le ultime n linee.
tail [-n] file
Cercare file e comandi
Cercare un file
Il comando find permette di cercare un file che soddisfi un dato pattern.
find <pathname> -name <filename> -type <t> -print
dove
pathname indica la directory da cui deve iniziare la ricerca . La
ricerca continuerà in ogni sottodirectory.
<filename> è il nome del file da cercare; può essere anche un
pattern costruito con metacaratteri.
L’opzione -print viene usata per mostrare i risultati della ricerca.
Vediamo alcuni esempi d’uso del comando (con ulteriori opzioni):
find .
-name mtg jan92 -print
find ˜/ -name README -print
find .
-name ’*.ps’ -print
find /usr/local -name gnu -type d -exec ls {} \;
Cercare un file / A
Un problema di find è la sua pesantezza computazionale.
Una soluzione è data dal comando locate, che basandosi su di un
database, periodicamente aggiornato (con updatedb), risulta molto più
efficiente
locate <modello>
Elenca i file che nelle basi di dati corrispondono a <modello>.
Esempio:
/home/rossi$ locate astri
/usr/include/g++-3/std/bastring.cc
/usr/include/g++-3/std/bastring.h
/home/rossi$
Cercare i programmi
Per cercare la locazione di un programma (tra i sorgenti, tra i file eseguibili
e nelle pagine del manuale in linea):
whereis [-bms] <command>
Alcune opzioni utili sono:
-b
solo file binari
-m
solo pagine dei manuali
-s
solo file sorgenti
Esempio
/home/rossi$ whereis -bms mail
mail:/bin/mail /usr/bin/mail /etc/mail.rc /etc/mail
/home/rossi$
Cercare un comando
Accade talvolta di essere a conoscenza dell’esistenza di un comando e di
voler sapere quale file sarà eseguito quando il comando viene invocato.
which <command>
fornisce
il pathname completo del file eseguibile
l’alias corrispondente a <command>
Un comando (builtin nella bash) simile, ma più completo è type
type [-all -path] <command>
indica come la shell interpreta <command>, specificandone la natura (alias,
funzione, file eseguibile, builtin, parola chiave della shell) e la definizione.
Con l’opzione -all vengono fornite tutte le definizioni di <command>,
mentre l’opzione -path restringe la ricerca ai file eseguibili.
Gestire archivi
Il comando tar permette di archiviare insiemi di file (in realtà parti del
filesystem, con informazioni sulla gerarchia delle directory) in un unico
file.
tar [-ctvx] [-f <file>.tar] [<directory/file>]
Alcune opzioni comuni sono
-c
-t
-x
-f <file>.tar
-v
crea un archivio
mostra il contenuto di un archivio
estrae da un archivio
specifica il nome del file di archivio
fornisce informazioni durante l’esecuzione
Alcuni esempi
tar -cf logfile.tar mylogs/logs.*
tar -tf logfile.tar
tar -xf logfile.tar
Comprimere file
Sono presenti alcuni tool che permettono di ridurre la dimensione di file
con algoritmi di compressione (che sfruttando la ridondanza dei dati danno
risultati migliori su file di testo):
compress [opt] <file>
uncompress [opt] <file>.Z
Ad esempio
compress logs.*
uncompress logfile.tar.Z
Oppure si può usare gzip (Lempel-Ziv coding LZ77) o bzip2
(Burrows-Wheeler block sorting text compression algorithm):
gzip [opt] <file> gunzip [opt] <file>.gz
Ad esempio
gunzip logfile.tar.gz
gzip logs.*
Esercizio
Scrivere un comando che crea una sottodirectory della directory corrente,
con nome text-files. Quindi copia in questa directory tutti i file con
estensione txt contenuti nella propria home directory. Se la directory
text-files è già presente rimuove da questa i file il cui nome non inizia
con almeno due caratteri alfanumerico o che non hanno estensione txt.
[Sugg.: Usare la concatenazione di comandi, il comando find e i
metacaratteri.]
Comandi di stampa
Alcuni comandi per la stampa dei file e la gestione della coda di stampa
UNIX BSD e Linux
lpr [opt] <filename>
lpq [opt] [<job#>] [<username>]
lprm [opt] [<job#>] [<username>]
Un’opzione usata frequentemente è -P <printername>.
UNIX System V
lp [opt] <filename>
lpstat [opt]
cancel [<requestID>] <printer>
Manipolazione di testi
Linguaggi formali
Dato un alfabeto A = {a1 , . . . , an }, l’insieme delle stringhe (finite)
sull’alfabeto A è indicato con A∗ , ovvero
A∗ = {s0 . . . sk : si ∈ A}.
Un linguaggio L sull’alfabeto A è un insieme di stringhe su A,
ovvero L ⊆ A∗ .
Operazioni sui linguaggi
Unione:
L + L0 = {α : α ∈ L ∨ α ∈ L0 }
Concatenazione: L · L0 = {αα0 : α ∈ L ∧ α0 ∈ L0 }
Potenza: Ln definito induttivamente
L0 = {}
Ln+1 = L · Ln
S
∗
Stella di Kleene: L = n∈N Ln
Linguaggi Regolari
Classificazione dei linguaggi (Noam Chomsky)
Linguaggi
Grammatiche [α → β]
Automi
tipo 0
generali
automi di Turing
tipo 1
monotone / context sensitive
automi limitati linearm.
tipo 2
context-free
automi a pila
tipo 3
regolari
automi a stati finiti
I linguaggi regolari sono molto semplici da trattare (ad es. il
problema dell’appartenenza al linguaggio ha complessità lineare).
b
a
q0
q0
L = {abn : n ≥ 0}
Espressioni regolari
Teorema (Kleene) Un linguaggio L sull’alfabeto A è regolare
se e solo se
è ottenibile a dai linguaggi ∅ e {a} con a ∈ A, utilizzando gli operatori di
unione +, concatenazione · e stella (_)∗ .
Espressioni Regolari su di un alfabeto A = {a0 , . . . , an } sono
re := ∅ | a0 | . . . |an | re + re | re · re | re∗
A ciascuna espressione regolare re è associato un linguaggio L(re):
L(∅) = ∅
L(ai ) = {ai }
L(re1 + re2 ) = L(re1 ) + L(re2 )
L(re1 · re2 ) = L(re1 ) · L(re2 )
L(re∗ ) = L(re)∗
Per il teorema di Kleene, ogni linguaggio regolare è denotato da
un’espressione regolare e viceversa.
Espressioni Regolari in Unix
Patterns (modelli) che individuano insiemi di stringhe (linguaggi) e
rappresentano uno strumento piuttosto potente e sofisticato di UNIX.
Ispirate alle espressioni regolari della teoria dei linguaggi formali,
ma risultano molto più potenti.
Utilizzate da vari programmi di elaborazione di testi (ad es. grep,
sed, awk, vi, emacs) per:
elencare/eliminare righe che contengono un’espressione
regolare
sostituire un’espressione regolare (~ find/replace)
...
Espressioni Regolari in Unix/A
insiemi di caratteri: pattern elementari che specificano la presenza un
carattere appartenente ad un certo insieme.
ancore: legano il pattern a comparire una posizione specifica della
riga (es. inizio, fine).
gruppi: “racchiudono” l’espressione regolare che può quindi essere
riferita come una singola entità.
modificatori: specificano ripetizioni dell’espressione che precede il
modificatore stesso.
Espressioni Regolari: Sintassi
[abc]
[a-d]
[ˆset]
.
match any of the characters enclosed
match any character in the enclosed range
match any character not in the following set
match any single character except <newline>
[:alpha:]
[:digit:]
some predefined character sets
\
treat the next char literally. Normally used to
escape special characters such as "." and "*"
Esempi
[ˆ[:alpha:]]
[â-c]
[\.a]
any non alphabetic char (same as [â-zA-Z])
any char except ’a’, ’b’, ’c’
chars ’z’ and ’.’
Espressioni Regolari: Sintassi / A
exp1 | exp2
match either exp1 or exp2
exp1 exp2
match exp1 followed by exp2
êxp
exp$
exp must start at the beginning of the line
exp must end at the end of the line
Esempi:
a|the
cat
.at
ˆcat
cat$
[cC]at
[0-9]$
either the string ’a’ or the string ’the’
the string ’cat’
any char followed by ’at’, such as ’cat’, ’rat’,
’mat’, ’bat’, ’fat’, ’hat’
’cat’ at the beginning of the line
’cat’ at the end of the line
’cat’ or ’Cat’
any digit ending a line
Espressioni regolari: Sintassi / A
exp{n}
exp{n,m}
exp{m,}
exp*
exp+
exp?
match the regular expression exp exactly n times
match exp a minimum of n times and a maximum
of m times
match exp a minimum of n times
(0 <= n,m <= 255)
match exp zero or more times
match exp one or more times
match exp zero or one times
Esempi:
xy*z
any occurrence of an ’x’, followed by zero or
more ’y’s, followed by a ’z’
xy{3,5}z
an ’x’, followed by 3 to 5 ’y’ and then ’z’
[A-Z][A-Z]* one or more upper case letters (same as [A-Z]+)
[A-Z]*
zero or more upper case letters.
Espressioni regolari: Sintassi / B
\<exp\>
match exp as long as it is a separate word
(exp)
saves the matching exp in a buffer, for future reference.
Up to nine patterns can be saved for each line.
\n
where n is a digit (1-9). Matches the nth expression
previously saved for this line.
Expressions are numbered starting from the left.
Esempi:
\<cat\>
’cat’ as a separate word (es. ’concatenate’ not ok)
(.*)\1
strings of the kind s s, where s is any string
(not regular nor context-free)
Questa è la sintassi per le espressioni regolari estese accettata da egrep, sed, awk, ma
non da grep (vedere man per ulteriori informazioni).
Cercare espressioni regolari
Unix fornisce i comandi grep ed egrep (acronimo per [extended]
generalized regular expression parser) per cercare espressioni regolari
(estese) nei file.
egrep [-ivnwx] <regexpr> [<filename1> ...
<filenamen>]
Il modo più semplice di usarlo è:
egrep <regexpr> <filename>
Esempio:
/home/rossi$ cat ugolino
La bocca sollevo’ dal fiero pasto
quel peccator, forbendola a’capelli
del capo ch’elli avea di retro guasto.
/home/rossi$ egrep pasto ugolino
Cercare espressioni regolari / A
/home/rossi$ egrep ’(p|gu)asto’ ugolino
/home/rossi$ egrep ’\<d.l\>’ ugolino
Si osservi che non compare la riga
/home/rossi$ egrep ’ˆ.a|li$’ ugolino
Cercare espressioni regolari / B
Alcune opzioni utili di egrep
-i
non distingue tra maiscolo e minuscolo
-n
mostra anche il numero di linea
-v
mostra le linee che non contengono l’espressione
-w
cerca parole intere
-x
cerca linee intere
Se non si specifica <filename>, egrep esamina lo standard input.
Una versione semplificata di egrep è fgrep
fgrep [-ivn] <text> <filename>
è utilizzato per cercare stringhe in file di tipo testo. Le opzioni -i, -n
e -v funzionano come per egrep.
Sostituire caratteri
Il comando tr converte un testo, carattere per carattere, secondo una
corrispondenza specificata.
tr ’<sourceCh>’ ’<destCh>’ < <file>
Esempio:
/home/rossi$ tr ’aeiuo’ ’eiuoa’ < ugolino
Le bacce salliva’ del fuira pesta
qoil piccetar, farbindale e’cepillu ...
trasforma a → e, . . . , o → a.
Se ’<destCh>’ è più corto di ’<sourceCh>’, si usa l’ultimo carattere in
’<destCh>’.
Opzioni
-c
-s
-d
trasforma i caratteri non in ’<sourceCh>’ (complement)
elimina caratteri uguali vicini (squeeze)
cancella i caratteri in ’<sourceCh>’ (delete)
Sostituire caratteri / A
Esempi:
trasforma tutti i caratteri maiuscoli in minuscoli
tr ’A-Z’ ’a-z’ < filename
semplice encryption (a → b, b → c . . . , z → a)
tr ’a-zA-Z’ ’b-zA-Za’ < filename
rimuove tutte le cifre dall’input
tr -d ’0-9’ < filename
scompone l’input in parole, sistemandole una per riga
tr -cs ’a-zA-Z0-9’ ’\n’ < filename
sed - editor di stream
Il comando sed permette di scandire uno o più file, modificando le linee
che soddisfano una particolare condizione (nello stile dell’editor vi).
sed -e ’<edit commands>’ <filename>
sed -f <edit command file> <filename>
Nel primo caso le azioni da eseguire sono inserite nella linea di comando,
nel secondo caso in un file, ed hanno forma <selettore><comando>.
Alcuni comandi di Editing
p
stampa la linea corrente
d
cancella la linea corrente
s/RegExp/Repl/
sostituisce la prima occorrenza di RegExp con Repl.
s/RegExp/Repl/g
sostituisce ogni occorrenza di RegExp con Repl.
sed - editor di stream / A
I comandi di editing possono essere qualificati con un pattern che
seleziona le linee alle quali tali comandi devono essere applicati.
Alcuni selettori di Linea
n
linea numero n
n,m
le linee dal numero n ad m
/RegExp/
le linee che corrispondono a RegExp
/RegExp1/,/RegExp2/
tutte le linee tra ogni occorrenza di RegExp1
e la successiva occorrenza di RegExp2
Un’opzione interessante è
-n
sopprime ogni linea non esplicitamente selezionata (si ricordi che, altrimenti, sed copia in output ogni linea, possibilmente modificata).
sed - editor di stream / B
Rimuove tutte le linee che contengono la stringa guasto
sed -e ’/guasto/d’ ugolino
Stampa solo le prime dieci linee di un file (simile a head)
sed -n -e ’1,10p’ ugolino
Mostra il file delle password, fornendo solo le linee da root a
nobody, ovvero gli account di sistema.
sed -n -e ’/ ˆ root/,/ ˆ nobody/p’ /etc/passwd
Aggiunge due spazi all’ inizio di ogni riga.
sed -e ’s/ ˆ / /’ filename
Elimina l’indentazione in un file, ovvero elimina tutti gli spazi ad
inizio riga.
sed -e ’s/ ˆ *//’ filename
sed - Esercizi
Scrivere un comando sed che
visualizzi un file, cancellando le linee da 3 a 5.
visualizzi solo la parte di un file che inizia alla prima linea che
contiene “start” e finisce alla prima linea che contiene “stop”.
visualizzi solo le linee non vuote di un file (cioè le linee che
contengono almeno un carattere).
visualizzi solo le linee non vuote e non costituite di soli spazi.
dato un file lo visualizzi sostituendo ogni linea contenente la parola
bomba con OMISSIS.
dato un file con riferimenti bibliografici del tipo “si veda [Kant12],
visualizzi solo i riferimenti, uno per riga.
Manipolare testi con awk
awk è un utility per la manipolazione di testi, il cui nome deriva dalle
iniziali degli autori (Aho, Weinberger, Kerningham)
La sintassi, nelle forme più semplici, è la seguente:
awk ’<programma>’ <file>
awk -f <progfile> <file>
scorre un file (o più) ed esegue alcune azioni sulle linee che
soddisfano una data condizione, concordemente con quanto
specificato nel programma.
La sintassi dei programmi è simile a quella del linguaggio C.
Si tratta di un’utility estremamente flessibile e potente. Qui ci
limiteremo a vedere solo alcuni esempi (→ Perl).
Manipolare testi con awk - campi
Ogni linea di testo letta viene scomposta in campi (i separatori di
campo di default sono <space> e <tab>).
Il primo campo di una linea può essere riferito con $1, il secondo
con $2, .... L’intera linea è riferita da $0. Il numero di campi è
riferito dalla variabile predefinita NF.
Ad esempio
awk ’{print NF,$0}’ pippo
mostra il file pippo sullo schermo premettendo ad ogni linea il
numero NF di campi (parole) che la compongono.
Manipolare testi con awk - script
Un programma awk è costituito da una o più linee della forma
[ <condizione> ]
{ <azione> }
<condizione> può essere
un’espressione che coinvolge operatori logici e relazionali,
oppure espressioni regolari.
uno dei token speciali BEGIN e END, che risultano attivati
all’inizio del file (prima della prima linea) ed alla fine del file
(dopo l’ultima linea)
<azione> è un insieme di istruzioni C-like.
Manipolare testi con awk - script / A
L’elenco di istruzioni C-like può contenere, ad esempio:
if (conditional) statement [ else statement]
while (conditional) statement
for (expr; conditional; expr) statement
for (var in array) statement
break
continue
variable = expression
print list-of-expressions
printf format list-of-expressions
statement; statement
{ statement }
Manipolare testi con awk - script / B
Il programma awk viene eseguito secondo i passi seguenti:
il testo viene analizzato linea per linea e per ogni regola del tipo
[ <condizione> ] { <azione> }
si valuta <condizione> e se questa è vera viene eseguita
<azione>
se <condizione> è assente allora <azione> viene eseguita in
ogni caso.
se <azione> è assente allora la riga corrente è stampata
immutata.
Manipolare testi con awk - script / C
Si supponga che il file wordcount.awk contenga
BEGIN { print ‘‘Inizio ad elaborare il file ...’’ }
{ for (i = 1; i <= NF; i++)
num[$i]++
}
END { for (word in num)
print word, num[word];
print ‘‘Fine del file:’’, FILENAME
}
allora il comando
awk -f wordcount.awk file
restituisce la lista delle parole che compaiono nel file file e la loro
frequenza (word in num permette di scorrere gli indici di un array).
Manipolare testi con awk - variabili
awk supporta variabili definite dall’utente;
le variabili non devono essere dichiarate (tipico dei linguaggi di
scripting);
inizialmente ogni variabile ha valore null o 0
File: lfcount.awk
BEGIN { print ‘‘Inizio ad elaborare il file ...’’ }
NF == 5 {
printf ‘‘Linea %d: %s \n’’, NR, $0;
lineCount++;
wordCount += NF;
}
END { printf ‘‘Linee: %d, Campi: %d’’, lineCount, wordCount) }
Seleziona le linee che contengono 5 campi, le visualizza con il numero di
riga, ne conta il numero ed il numero dei campi e lo visualizza.
Manipolare testi con awk - regexp
La condizione può essere
un’espressione regolare (estesa):
/RegExp/
valida per ogni riga che corrisponda all’espressione;
una coppia di espressioni regolari
/RegExp1/, /RegExp2/
in questo caso l’azione <action> si applica ad ogni linea tra la prima
che corrisponde a /RegExp1/ e la linea successiva a questa che
corrisponde a /RegExp2/.
Esempio:
awk ’/start/, /stop/ { printf ‘‘line %d: %s’’, NR, $0}’
filename
awk - pattern matching
Potenti funzioni di pattern matching su espressioni regolari:
Condizioni: str ˜exp oppure str !˜exp
Esempi:
‘‘abbc’’
/a[b]+c/: ok
‘‘ac’’
/a[b]+c/: no
Operatori su stringhe:
gensub(exp, str, h [, target]):
Sostituisce la prima/tutte le occorrenze di exp in target con
str (a seconda del valore di t). Quando target è assente usa
$0. La stringa str può contenere \n.
split(str, array [, exp]):
Suddivide la stringa str e mette i frammenti in un array. Usa
come separatore exp (default FS)
Manipolare testi con awk - esercizi
Data un agenda con righe:
<cognome, nome, indirizzo, città, numero>
scrivere un programma awk per stampare le righe con nome uguale a
Giovanni e città uguale a Milano.
Scrivere un programma awk che stampi le righe di un file dall’ultima
alla prima.
scrivere un programma awk per sostituire in un testo la parola
sempre con la parola mai e contare le sostituzioni effettuate.
Scrivere un programma awk che spezzi una riga subito dopo il 20mo
carattere, appenda uno come avvertimento e scriva a capo il resto
della riga, giustificato a destra (la funzione substr(str,i,j)
fornisce la sottostringa di str dall’indice i all’indice j).
Eliminare doppioni
L’utility uniq permette di modificare un file, sostituendo righe identiche
adiacenti con un’unica occorrenza della riga ripetuta.
uniq [-c] <infile> <outfile>
Con l’opzione -c ogni riga è preceduta dal numero di occorrenze.
/home/rossi$ cat uniqfile
questa e’ una riga doppia
questa e’ una riga doppia
questa e’ una riga singola
questa e’ una riga tripla
/home/rossi$ uniq
2 questa e’ una
1 questa e’ una
3 questa e’ una
-c uniqfile
riga doppia
riga singola
riga tripla
Confrontare due file
Due utility permettono di confrontare file:
cmp <file1> <file2>
Verifica l’uguaglianza di <file1> e <file2> e
nel caso siano diversi fornisce la riga e l’offset (numero di byte
dall’inizio del file) del primo mismatch
se uno è un prefisso dell’altro si ottiene un messaggio di EOF
sul file più corto.
diff <file1> <file2>
Simile a cmp, ma fornisce una lista di differenze tra i due files
(cambiamenti necessari per convertire il primo file nel secondo).
Un sommario dei comandi visti
awk
cat
cd
chgrp
chmod
cmp
chown
compress
cp
date
diff
file
find
grep
gzip
head
lp
lpr
-
search for and process patterns in a file,
display, or join, files
change working directory
change the group associated to a file
change the access mode of a file
compare files
change the owner of a file
compress files
copy files
view/set the date of the system
show differences between files
display file classification
find files
search for a pattern in files (egrep, fgrep)
compress files
display the first few lines of a file
print files (System V)
print files (Berkeley)
Un sommario dei comandi visti / A
lprm
ls
mkdir
more
mv
pwd
rm
rmdir
sed
sort
tail
tar
tr
umask
uniq
wc
whereis
which
-
remove a job from the print queue
list information about files
create a directory
display a file one screen at a time (System V)
move and/or rename a file
print the working directory
remove (delete) files
remove (delete) a directory
stream editor
sort and/or merge files
display the last few lines of a file
store or retrieve files from an archive file
transliterate charaters
set file creation permissions
remove duplicates
counts lines, words and characters in a file
show where executable is located in path
locate an executable program using "PATH"
Altri comandi
df
du
fsck
groups
ln
spell
split
cut
paste
whatis
-
display the amount of available disk space
display information on disk usage
check and repair a file system
show user groups
create a link to a file
check a file for spelling errors
split files
cut columns from a file
join coulumns in a single file
list man page entries for a command

La shell di Unix - Dipartimento di Scienze Ambientali, Informatica e

Transcript

Documenti analoghi

Scheda_INFORMATICA_2016

Unix - Shell dei comandi – Es. 1

Introduzione alla Shell

Introduzione • Storia e Principi di Unix • Il Progetto GNU

Progr. svolto - Appunti di INFORMATICA

IL S IS T E M A O PE RA T IV O UN IX : S T RU M E N T I PE R L O

W9x/ME Mac Mac OS X Unix / Linux W NT 2K XP

Un Sistema Operativo multiuser-multitask UNIX

Lezione 1: Introduzione alla Shell di Unix