Sistemi Operativi UNIX Shell + C [riassunti sintassi e comandi]

Andrea Mansi UNIUD (Last Update 20/06/2019)

UNIX/LINUX Shell Commands:

Comandi base per la navigazione e l’utilizzo della shell:

> man x --> Manuale Unix del comando x.

> echo “msg” --> printa “msg” su shell (sullo standard output).

> pwd --> Present working directory. Output: directory corrente.

> clear --> Pulisce la shell.

> who --> Lista utenti collegati al sistema.

Shortcuts utili: Le combinazioni di tasti Ctrl-A e Ctrl-E spostano il cursore, rispettivamente all’inizio ed alla fine della linea

di comando. <Tab> (mentre si sta scrivendo un comando su shell) tenta di completare un comando che stiamo scrivendo

su console, se esiste un solo possibile completamento, completerà il comando; Questa funzione è chiamata command

completion.

> cd dir --> Change directory. Go into directory "dir". Se dir è nullo, viene interpretato come cd .. ovvero la main directory.

> cd .. --> Muove l'user nella directory madre della directory attuale. “Fa un salto in su di una directory”

(un solo punto “.” Viene interpretato come dir. Corrente).

> cd --> cd e basta porta l’user nella home directory.

> ls --> Files listing. (man ls per vedere tutte le sue varianti, le più comuni sono le seguenti:)

> (-a) file nascosti. (-h) human readable. (-l) long listing format. (-r) reverse order. (-R) recursive inside directories.

(-t) in ordine di modifica, dal più recente. (-d) filtra le directory.

> ls -l

- Esempio di output

lrwxr--r-x 1 root root 512 Dec 5 2018 file.txt

<1><------2-----> < 3 > <-- 4 --> <-- 5 ---> <- 6 -> <-------------- 7 ------------> <---- 8 ---->

1 tipo di file, primo char. su 10 | 2 permessi, restanti 9 char. su 10 | 3 numero di hard link al file | 4 owner name | 5 users group with access to the file | 6 dim. file

7 data ultima modifica | 8 nome file.

----------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ PERMESSI DEI FILE:

Linux è un sistema multiutente, ogni file ha 4 categorie di utenti:

-> Root,owner,group,world.

-> Root possiede tutti i permessi su tutti i file (lettura,scrittura,esecuzione). Per le altre categorie l’accesso è regolato

dai permessi.

- Esempio permessi di un file:

[ -rw-r--r-- ] --> si suddivide a blocchi da 3 (escludendo il 1° caratt.): in ordine abbiamo: owner,group,world.

(NB: la prima lettera sta a indicare il file type. Quindi, i permessi sono tutti i caratteri escluso il primo)

(R)-read (W)-Write (X)-Execute (-)-Assenza del relativo permesso.

Andrea Mansi UNIUD (Last Update 20/06/2019)

> chmod --> modifica i permessi di un file. 2 diversi modi di utilizzo.

- Esempi modifica permessi:

> chmod 744 f1 --> i permessi di f1 diventano rwxr--r-- (111 100 100 = 744).

> chmod 711 f1 --> i permessi di f2 diventano rwx--x—x (111 001 001 = 711).

> chmod u=rwc,go=r f1 --> Questo esempio setta user a rwx, group a r-- e others a r--.

Quindi… si può anche, passare a chmod come parametro sintassi del tipo: u=rw- ,che significa: dai i permessi a user

di scrittura e lettura, non di eseguire il file.

Abbreviazioni: u = user | g = group | o = others.

Inoltre: g = r --> g = r-- con = che imposta come consegue, +x aggiunge il permesso x, -x rimuove il permesso x

----------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ CARTELLE (DIRECTORY):

> mkdir x --> creazione della directory x nell’attuale pathname (dove si trova l’user)

> rmdir x --> rimozione della directory x nell’attuale pathname (dove si trova l’user)

> cp f1 d1 --> Copia il file f1 nella directory d1. f1 può essere una lista di file!

> mv f1 f2 --> Sposta il file f1 in f2. (se f2 è = alla directory iniziale di f2, la funzione di mv diventa quella di rinominare f1).

NB: cp e mv possono ricevere una lista di file: esempio: > cp f1 f2 f3 f4 directory1.

----------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ COMANDI CAT,MORE,TAIL,HEAD, WC

> cat f1 --> Visualizza su shell f1 (lo legge e visualizza su shell la concatenazione del suo contenuto).

cat > f1 permette di scrivere su shell del testo, che verrà sovrascritto su f1.

> more f1 --> Permette di visualizzare una pagina per volta di un file, permettendo di scorrere in avanti e indietro.

> tail f1 --> Mostra le ultime righe di un file.

> tail -num --> Mostra le ultime num righe del file.

> tail -n+num --> Mostra le righe dall num-esima (compresa) in poi.

> head f1 --> Mostra le prime righe di un file. (Analogamente a tail,head -num fornisce le prime num righe,

head -n+num fornisce le righe fino alla num-esima (compresa)).

> tail -n+$num f1 | head -n+1 --> Fornisce la num-esima riga in output.

> wc < path --> words_counter: fornisce numero di <linee><parole><bytes> del file .../<path>/file

Opzioni: (-c) bytes (-m) chars (-l) lines (-w) words

>wc < file_path --> esegue wc sul contenuto del file situato in file_path (se il file si trova nella

current dir. basta mettere il nome del file al posto del path completo)

>wc << delim --> delim è una parola qualsiasi. La shell ci permetterà di scrivere del testo su

console. Per completare l’inserimento basterà scrivere la parola delim e verrà

eseguito wc. (funzionalità “Here document!”).

Andrea Mansi UNIUD (Last Update 20/06/2019)

❖ METACARATTERI:

Sono caratteri speciali, interpretati dalla Shell Unix durante l’esecuzione dei comandi.

Esempio: ls *.java -> * abbrevia il nome del file, *.java indica quindi tutti i file che finiscono con .java

Lista Wildcard (metacaratteri usati per abbreviare il nome di un file in un pathname):

* -> Stringa di 0 o più caratteri

? -> Singolo carattere

[ ] -> Singolo carattere tra quelli elencati

{ } -> Sequenza di stringhe

Altri metacaratteri:

|| && -> Esecuzione condizionale (or, and).

; -> Lista di comandi, ad esempio: pwd;ls;cd

( ) -> Raggruppamento di comandi, ad esempio: (date;ls;pwd)>out.txt

Per inibire l’effetto dei metacaratteri si applica il meccanismo di “quoting”, inserendo escape \ davanti ad essi, oppure

racchiudendo una stringa tra ‘xxx’ o “xxx .

(inibisce qualsiasi metacarattere) ” (inibisce solo i metecaratteri relativi all’abbreviazione di un path)

----------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ REDIREZIONE DELL’ I/O:

By default i comandi Unix prendono l’input da tastiera, e mandano l’output sul promt (standard output). L’I/O può essere

rediretto utilizzando opportuni METACARATTERI:

> redirezione dell’output

>> redirezione dell’output (append)

< redirezione dell’input

<< redirezione dell’input dalla linea di comando (“here document”) Permette di fornire ad un comando o script

in input un testo inserito dalla shell (stdin). <<string (fino all’inserimento di string)

2> redirezione dei messaggi di errore (bash Linux)

Esempi: > ls > temp.txt l’output di ls non comparirà a video ma sovrascriverà temp.

-->

> more temp.txt leggiamo temp, quindi l’output di ls.

-->

> echo miaomiao >> temp “miaomiao” viene aggiunto in fondo a temp

-->

----------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ PIPE:

Il metacarattere | (pipe) viene utilizzato per comporre n comandi in cascata. L’output di ciascuno viene passato come

input al comando successivo.

Esempio: > ls /usr/bin > temp e poi > wc -w < temp è uguale a: > ls /usr/bin | wc -w

----------------------------------------------------------------------------------------------------------------------------------------------------------------

Andrea Mansi UNIUD (Last Update 20/06/2019)

❖ HISTORY LIST:

Memorizza gli ultimi 500 comandi inseriti dall’utente. (legge il file …/home/.bash_history)

> history | tail -n --> Lista gli ultimi n comandi effettuati dall’utente.

> !! --> ripete l’ultimo evento della history

> !n --> ripete l’evento n-esimo della history (se la history lo contiene)

È possibile scorrere l’history list con freccia su e freccia giù, la shell leggera i comandi dalla history e li digiterà su shell.

È possibile riferirsi agli eventi tramite ricerche testuali, ad esempio:

> !ls --> La shell cerca a partire dall’ultimo evento il primo che inizi con ls.

Con :s è possibile effettuare delle modifiche mentre si fa riferimento a un comando della history list, esempio:

> !ls:s/al/i/ --> dopo aver trovato il comando ls -al lo sostituise con ls -i.

Sintassi modifica: :s/<string1>/<string2>/ --> string1 verrà sostituita con string2 nel comando.

-------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ ALIAS:

> alias nome=’comando valido’ -> serve a creare nuovi alias. -> Ogni volta che si chiamerà l’alias “nome”, verrà

eseguito il comando a lui assegnato.

> unalias nome -> per rimuovere l’alias “nome”.

All’uscita dalla shell gli alias creati con il comando alias sono automaticamente rimossi.

-> Risoluzione: Sezione Login Script, più avanti.

-------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ CONTROLLO PROCESSI:

Ogni processo del sistema ha un PID (Process Identity Number).

Su Unix e su Linux, la gerarchia dei processi parte dal processo init con PID=1.

> ps --> fornisce i processi dell’utente associati al terminale corrente.

esempio output ps:

PID TTY TIME CMD

23228 pts/15 0:03 xdvi.bin

Leggenda: PID = Process Identity Number TTY = terminale TIME = tempo cpu CMD = cmnd. che ha generato il processo

Varianti: (-a) tutti i processi del terminale. (-f) full listing. (-u <name>) filtra processi dello user <name>.

(-e) tutti i processi, anche non associati al terminale. (-l) long listing.

> tty --> output: nome terminale corrente.

> jobs --> mostra la lista dei job in esecuzione.

- Terminazione di un processo:

> Ctrl-c termina il processo in esecuzione sul terminale corrente.

> kill x -> con x un PID; termina il processo con quel PID. Andrea Mansi UNIUD (Last Update 20/06/2019)

- Processi in background:

> & -> i comandi seguiti da & danno luogo a un processo in background. Vengono eseguiti in parallelo in una sottoshell.

-------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ MONITORAGGIO RISORSE

> top e >htop --> Visualizzazione grafica dell’utilizzo risorse.

> df --> controllo del disco. > du --> Spazio utilizzato dalla directory corrente, (-s dir) per lo spazio della dir. dir..

-------------------------------------------------------------------------------------------------------------------------------------------------------------

❖ OPERAZIONI SUI FILE & FILTRI:

> touch <options> <file> --> aggiorna la proprietà “ultima modifica” del file alla data attuale.

NB: Doppia utilità, se il file non esiste, viene creato!

> cmp x y --> restituisce il primo byte ed il numero di linea in cui x e y differiscono. Se sono uguali non viene restituito

alcun valore.

> diff f1 f2 -> Restituisce la lista di cambiamenti da apportare a f1 per renderlo uguale a f2.

> find <pathname> <expression> --> attraversa ricorsivamente le directory specificate in <pathnames> applicando le

regole di <expression> che può essere 1. Opzione 2. Condizione 3. Azione.

Esempio find: > find . -name ‘*.c’ -print --> cerca ricorsivamente a partire dalla directory corrente (il punto) tutti i

file con estensione c e li stampa a video.

> find <path> -name <string> -exec <action> --> Esegue <action> su tutti i file di nome <string> contenuti nel

<path> (ricorsivamente).

> uniq file --> restituisce il contenuto di “file”, sostituendo le linee adiacenti uguali con un’unica linea.

- General Regular Expression Parser

> grep --> restituisce solo le linee dell’input fornito che contengono un pattern

specificato tramite espressione regolare o stringa fissata.

Sintassi: grep [options] <pattern> <file> - (varianti: fgrep = grep -F, egrep = grep -E. etc..).

-i : ignora la distinzione fra lettere maiuscole e minuscole,

-l : fornisce la lista dei file che contengono il pattern/string,

-n : le linee in output sono precedute dal numero di linea,

-v : vengono restituite solo le linee che non contengono il pattern/string,

-w : vengono restituite solo le linee che contengono il pattern/string come parola completa,

-x : vengono restituite solo le linee che coincidono esattamente con pattern/string.

Andrea Mansi UNIUD (Last Update 20/06/2019)

- Metacaratteri delle espressioni regolari:

- Esempi di utilizzo del comando grep:

> fgrep rossi /etc/passwd --> linee del file /etc/passwd che contengono la stringa “rossi”.

> egrep -nv ‘[agt]+’ relazione.txt --> linee del file relazione.txt che non contengono stringe composte dai caratteri a,g,t.

> grep -w print *.c --> linee di tutti i file con estensione c che contengono la parole intera print.

> ls -al . | grep ‘^d…....w.’ --> sottodirectory della dir. corrente che sono modificabili dagli utenti ordinari.

> ls -l | grep ‘^-‘ --> filtra le linee che iniziano con - (ovvero solo le linee di file ordinari)

- Sort

> sort --> prende in input linee di testo e le ordin