Little X Manual

Piccola guida
Versione 4.5

27 giugno 2007

Olivio Mariano - olivio.mariano@gmail.com

1
 L’autore non si assumerà in alcun caso la responsabilità per eventuali danni diretti o indi-
retti riguardanti l’uso proprio o improprio del presente, o qualora il suo uso violi gli accordi
sottoscritti con Apple. Scritto a soli fini informativi. “Little X Manual” è ,c tutti i diritti
riservati. Il logo “Dog using an iMac” c è stato disegnato da Nina Mariano.
Documento generato con L TEXA

Questa versione del Little X Manual è liberamente scaricabile dal sito

www.oliviomariano.net

e non è abilitata alla stampa. Se desiderate riceverne una versione stampabile sarà necessario
richiederla all’indirizzo olivio.mariano@gmail.com.

2
Introduzione

Il Little X Manual giunge finalmente alla versione 4 approfondendo ed espletando i vari temi
abbordati dalle prime edizioni. Questo manuale vuole essere un contenitore didattico nel quale
vengono spiegate le varie caratteristiche del sistema operativo Mac OS X, affrontando -quando
possibile- il confronto con i sistemi operativi Unix fratelli.

Una prima parte, più argomentata, raccoglie una serie di informazioni per comprendere
pienamente il significato di sistema operativo e le origini di quello che noi tutti chiamiamo sem-
plicemente “Unix”. Successivamente, procedendo per categorie e microcategorie, spiegheremo,
attraverso esempi pratici, le funzionalità della linea di comando, adattando l’uso di quest’ultima
a quelle che potrebbero essere le esigenze di un utente comune.

Non me ne vorranno gli utenti più esperti per l’uso, talvolta, di termini semplicistici per ren-
dere comprensibile ed accessibile questa piccola guida alla maggior parte dell’utenza. Sperando,
come consueto, di aver offerto un buon servizio alla comunità Mac...

Olivio Mariano

3
Indice

I Sistema operativo e hardware 1

1 Il sistema operativo 1
1.1 L’affidabilità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 L’hardware 5
2.1 Mainframes Minicomputers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Personal computers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3 Unix 7
3.1 Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2 Mac OS, un cuor di Unix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.1 A/UX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.2 NeXTSTEP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2.3 Mac OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

II Il sistema 17

4 Kernel e terminali 17
4.1 Kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2 Metodi di accesso ad un sistema operativo Unix . . . . . . . . . . . . . . . . . . 17
4.2.1 Console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2.2 Dumb terminals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2.3 Smart terminals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3 Terminale e shells . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.4 Il prompt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.5 Uso dei tasti freccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.6 Logging in e logging out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.7 Logging in . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.8 Il nome utente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4
 4.9 La password . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.10 Logging out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.11 Tipi di login . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.11.1 Il superutente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.11.2 Utilizzare il comando sudo . . . . . . . . . . . . . . . . . . . . . . . . . . 23

III I comandi terminale 24

5 Comandi utili per l’apprendimento 24

5.1 man . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.2 whatis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.3 apropos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.4 Cartelle “.” e “..” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.5 Il tasto tab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

6 Muoversi nel filesystem 27

6.1 Dischi e sistemi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.2 Gestione dei dischi: i comandi df e mount . . . . . . . . . . . . . . . . . . . . . 28
6.3 Arborescenza di un sistema operativo Unix-like . . . . . . . . . . . . . . . . . . 28
6.4 Arborescenza di Mac OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
6.5 I file nascosti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
6.6 Uso del filesystem : pwd, cd, ls... . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6.7 cp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.8 mv, rm, unlink . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.9 mkdir, rmdir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.10 ln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

7 Gestione dei documenti 36

7.1 cat, more, less, od . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
7.2 head, tail, sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
7.3 Cercare: find, locate, grep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
7.4 Cercare con Spotlight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

5
 7.4.1 Dove cerca Spotlight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.4.2 Ricerche da terminale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.4.3 Operatori booleani . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.4.4 Metadata per documenti singoli . . . . . . . . . . . . . . . . . . . . . . . 45
7.4.5 Controllare Spotlight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.5 Comparare: diff, cmp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7.6 Comandi vari: split, touch, du, wc... . . . . . . . . . . . . . . . . . . . . . . . . . 49

IV Gli editor di testo 50

8 VI, VIsual Editor 50

8.1 Avvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.2 Modalità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.3 Terminare Vi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.4 I comandi Vi di inserimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.4.1 Inserire prima del cursore . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.4.2 Cancellazione dei caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.4.3 Cancellazione delle righe . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.4.4 Uso delle frecce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.4.5 Inserzione del testo a inizio e fine riga . . . . . . . . . . . . . . . . . . . . 56
8.4.6 Creazione di una nuova riga . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.5 I comandi Vi di spostamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.5.1 Spostamenti unitari: caratteri o righe . . . . . . . . . . . . . . . . . . . . 57
8.5.2 Inizio e fine riga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
8.5.3 Ricerca di un carattere nella riga . . . . . . . . . . . . . . . . . . . . . . 59
8.5.4 Spostamenti a parole . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
8.5.5 Spostamenti a righe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.5.6 Spostamenti a pagine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.5.7 Spostamenti ad inizio e fine documento ed ad un numero di riga specificata 62
8.5.8 Ricercare nel testo: stringhe . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.6 I comandi Vi di cancellazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
8.6.1 Cancellazione di caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . 65

6
 8.6.2 Cancellazione parole, righe e altre unità di testo . . . . . . . . . . . . . 65
8.6.3 Cancellazione righe intere . . . . . . . . . . . . . . . . . . . . . . . . . . 67
8.6.4 Cancellazione della parte finale di una riga . . . . . . . . . . . . . . . . . 67
8.6.5 Ripristino righe cancellate . . . . . . . . . . . . . . . . . . . . . . . . . . 68

V I processi 69

9 Gestione dei processi 69

9.1 Visualizzare i processi: ps e top . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
9.2 Lancio dei processi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
9.3 Interruzione dei processi: kill . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
9.4 Pianificazione dei processi: at, atq, atrm . . . . . . . . . . . . . . . . . . . . . . 71
9.5 Pianificazione dei processi avanzata . . . . . . . . . . . . . . . . . . . . . . . . . 73
9.6 Esecuzione in background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

VI Gestire gli accounts 76

10 I comandi id, groups e finger 76

11 Il documento passwd 76
11.1 Gestire gli utilizzatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
11.2 Gestione dei gruppi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

12 Mac OS senza passwd ? 79

13 La sicurezza del sistema 79

13.1 chmod, chown, chgrp, umask : modificare i privilegi . . . . . . . . . . . . . . . . 82
13.2 Lo sticky bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
13.3 Come proteggere il proprio Mac PPC: open-firmware . . . . . . . . . . . . . . . 85

VII Le shells 88

7
14 Convenzioni e utilizzo 88
14.1 Variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
14.2 Le espressioni regolari o caratteri “joker” . . . . . . . . . . . . . . . . . . . . . . 91
14.3 Pipes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
14.4 Redirezione di uscite / entrate . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
14.5 Alcuni esempi sull’uso delle convenzioni . . . . . . . . . . . . . . . . . . . . . . . 95
14.6 Il comando test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

15 Scripts shell 98
15.1 Istruzioni di strutturazione, if, case, for, while . . . . . . . . . . . . . . . . . . . 100

VIII Installazione delle applicazioni 105

16 I tarballs : pacchetti GNU 105

IX Unix e le reti 109

17 Il TCP/IP 109
17.1 Consultazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
17.2 Test di connettività . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

18 SSH 111
18.1 Sdoppiare i terminali : screen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
18.2 Sicurezza in remoto con PAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

19 Samba 116
19.1 Componenti Samba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
19.2 Configurazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
19.3 Sintassi del documento smb.conf . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
19.4 Lan manager e Smb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

8
Parte I

Sistema operativo e hardware

1 Il sistema operativo
Capire il funzionamento del sistema operativo Apple presuppone una minima conoscenza degli
“altri” sistemi operativi presenti sul mercato. Elencare tutte le caratteristiche di ciascun OS
richiederebbe parecchie pagine e, in ogni caso, questo non è l’intento del Little X Manual. Ci
limiteremo quindi a offrire al lettore una panoramica di quello che dovrebbe essere un sistema
operativo. Questo per offrire un metro di paragone a chi sta ancora scegliendo la sua piattaforma
di utilizzo.
Una definizione esemplificativa del sistema operativo può essere la seguente:

“il sistema operativo è una sorta di strato che si pone sopra la macchina fisica
e permette di fare richieste ad una macchina virtuale ma che l’utente crede vera;
inoltre il compito del sistema operativo, oltre a quello di controllare l’esecuzione degli
altri programmi, consiste nell’impedire alle applicazioni di eseguire dei comandi che
potrebbero rivelarsi dannosi”

Qualsiasi computer, senza sistema operativo, è dunque perfettamente “stupido”. Non

può assolutamente capire quello che gli si chiede e quindi quello che deve offrire al proprio
utente. Il SO rende possibile questa interazione gestendo ed elaborando l’immagazinamento
dell’informazione.
Al di sopra del sistema operativo “girano” delle applicazioni dette “esterne” che implemen-
tano altre caratteristiche. In definitiva quest’ultima affermazione non è del tutto esatta quando,
in taluni SO, alcune applicazioni tendono ad “invadere” delle funzionalità prettamente riservate
al sistema in se stesso (vedi le varie incarnazioni di Windows e IE). Diciamo che in linea di
massima tutto quanto segue fa parte di qualunque OS in commercio:

• Gestione dei Processi (multitasking)

• Gestione della memoria (scheduler)

1
• Gestione dei files (file system)

• Gestione degli utenti (multiutenza)

• Gestione dell’ I/O (stampanti, video, tastiera, ...)

• Gestione servizi di Rete

• Protezione del sistema

• Interprete di comandi

Ciascun OS potrà poi appartenere a una particolare categoria:

• Singolo utente / Multi utente

• Real time

• Sistemi distribuiti

2
 • Embedded

Sarà dunque possibile differenziare i diversi sistemi operativi a seconda delle funzionalità
hardware proposte dal calcolatore su cui girano.

1.1 L’affidabilità
Definendo come qualità di un assieme o di un sistema comunque complesso la sua ri-
spondenza ai criteri di specifica di funzionamento, si definisce affidabilità la capacità
di rispettare le specifiche di funzionamento nel tempo.

In sintesi, l’affidabilità di un assieme (un apparato elettronico, una macchina, etc.), di un

sistema comunque complesso o di un semplice componente (ad esempio una resistenza elettrica)
è la misura della probabilità che l’assieme (od il componente) considerato non si guasti (ovvero
non presenti deviazioni dal comportamento descritto nella specifica) in un determinato lasso di
tempo.
In un sistema operativo, questa immunità dai guasti, è data dal misurato equilibrio del-
le modalità operative. Lo scopo principale delle modalità operative è quello di proteggere
“l’hardware dal software”. Il software, poiché estremamente complesso e soggetto agli errori di
programmazione umani, può incorrere in malfunzionamenti che declinano la corretta esecuzione
dell’hardware. Per evitare questi possibili inconvenienti esistono, dunque, dei modi operativi
distinti della CPU.
Le modalità operative che elenchiamo più avanti, sono strettamente legate, costituendo
un insieme sottostante di ciò che comunemente chiamiamo sistema operativo. Una modalità
operativa è generalmente strettamente connessa in parallelo ad un altra. La possibilità di
effettuare un case switch tra due modalità operative indica un perfetto e intelligente controllo
della CPU dalla parte del software. Diremo, allora, che i sottoinsiemi di modalità operative
che, pur guastandosi, non pregiudicano la funzionalità dell’insieme superiore (dunque il sistema
operativo in se stesso) sono da un punto di vista dell’affidabilità perfettamente in sincrono e
funzionali. Viceversa, nel caso sia sufficiente l’avaria di un singolo sottoinsieme per determinare
l’avaria dell’insieme superiore, diremo che tale sottoinsieme è connesso in serie. Come tale non
può essere disgiunto: il crash di uno dei due implica, dunque, il crash anche dell’altro.
In tutti i sistemi operativi odierni le modalità operative sono gestite tramite una sorta di
“ridondanza”. Ciascun “mattone” del sistema operativo ha diversi modi per essere raggiunto

3
con diverse “modalità operative”. Questo, come può apparire ovvio, è utile e determinante nel
caso siano presenti avarie di diversi sottosistemi (sottoinsiemi). Ciò che chiamiamo ridondanza
, corrisponde a porre, dunque, più elementi in parallelo che, in quanto tali, forniranno al sistema
operativo una maggiore affidabilità.
Vediamo quali sono le modalità operative:

• USER MODE (esecuzione di operazioni per un utente. Es. applicativi). La user mode
gestisce i vari processi attribuendo ad ognuno di essi un determinato periodo di tempo
oltre il quale non possono operare.

• KERNEL MODE (esecuzione di operazioni per il sistema operativo). E’ una moda-

lità protetta nella quale il processore non interrompe e non esclude il processo che sta
operando.

Un esempio di corretto utilizzo delle modalità operative:

CP U KernelM ode KernelM ode U serM ode KernelM ode U serM ode
Processo 1 Waiting Ready Ready Waiting Ready
Processo 2 Waiting Waiting Waiting Waiting Waiting
Sistema operativo Ready Ready - Ready -

Da sinistra a destra possiamo osservare come l’avvicendarsi delle diverse modalità operative
conserva una certa armonia . L’esistenza di una modalità utente (User Mode) implica un uso
nullo della cpu da parte del sistema operativo. L’esistenza di una modalità kernel (Kernel
Mode) implica un uso -possibilmente- complementare della cpu da parte dei processi e da parte
del sistema operativo.
L’interazione e la cooperazione delle modalità operative permette, dunque, ad una CPU di
dare “l’illusione” all’utente di un’effettiva concorrenza tra i vari processi attivi sulla macchina.
In realtà ciò che noi tutti chiamiamo multitasking è semplicemente il passaggio del controllo
della CPU, ad elevatissima velocità, da un processo all’altro, da un processo(i) al sistema
operativo.

Il turno di ciascun processo viene espletato con l’uso della priorità e il passaggio tra lo
stato di running e gli altri comporta un cambiamento di stato (di contesto) della CPU (context
switch).

4
 Potremmo analizzare in maniera approfondita come ciascun sistema operativo a tutt’oggi
presente sul mercato può implementare in maniera corretta o meno queste funzionalità. Ciò
richiederebbe molto più che un “piccolo” manuale di duecento pagine... Diremo, sinteticamente,
che la famiglia Unix e i sistemi operativi Windows modelizzano e espletano l’interazione tra
i processi tramite un modo del tutto concorrenziale che rende l’uso efficente delle modalità
operative una priorità per le aziende che ne sviluppano il kernel. Possiamo capire, dunque,
che l’efficenza e l’operatività di un OS sono direttamente influenzate da queste funzionalità. Il
difficile equilibrio che si raggiunge nella gestione delle modalità operative e funzionali indica
la qualità dell’OS scelto. Viceversa, l’incapacità di un sistema operativo di saper gestire in
modo elegante le risorse hardware della macchina su cui gira implica quasi sempre una scarsa
affidabilità.

2 L’hardware
Per capire in maniera precisa come classificare il sistema operativo, è necessario conoscere su
quali tipologie di macchina gira o da quale sistema operazionale deriva. Iniziamo con il dire
che tutti i computer digitali moderni sono concettualmente molto simili. Il fatto che abbiano
diverse funzionalità, costi e prestazioni li caratterizza in:

5
 • Supercomputers

• Mainframes and minicomputers

• Personal computers

• Real-time computers

Ci interesseremo, in questo tutorial, alla definizione di Mainframes (Minicomputers) e

Personal Computers.

2.1 Mainframes Minicomputers

Negli anni 60 / 70 l’elaboratore era inteso come mainframe atto ad essere usato da centinaia di
persone contemporaneamente tramite terminali collegati ad un unico grande cervello che spesso
occupava un intero piano delle grandi aziende cui forniva servizio. I minicomputer erano delle
versioni miniaturizzate dei mainframe: costavano di meno e potevano supportare un massimo
di venti utenti treminale. Questo tipo di sistemi erano ideali per organizzazioni di piccola-
media grandezza ed entravano in concorrenza con i mainframes solo quando i loro bassi costi
ne giustificavano l’installazione rispetto a grossi macchinari. In tutti e due i casi un termine
preciso si fa strada: multiutenza. Il termine utilizzato per indicare la capacità di un elaboratore
di creare diversi spazi di lavoro per ciascun utente è ora di “moda” sulle piattaforme Windows
ma, di fatto, questa tecnologia nasce già con i primi mainframes. Possiamo quindi capire quanto
questa filosofia di utilizzo sia radicata nei sistemi Unix che nascono con il preciso intento di
rendere possibile la cooperazione dei vari utenti che hanno accesso al sistema. Ovviamente,
l’adozione del concetto di multiutenza, implica che un tale sistema non possa mai andare in
crash, poichè il lavoro di più utenti che traggono profitto dalla stessa macchina non può essere
interrotto dal crashing dell’applicazione di un singolo utente. Allo stesso modo ciascun utente
non potrà mai occupare la totale potenza processore vista la necessità di fornire risorse di
sistema sufficenti a ciscun utente connesso.
Un sistema di questo tipo ha dunque 3 principali vantaggi:

• la multiutenza - ciascun utente possiede un spazio di lavoro dedicato al quale gli altri
utenti non possono accedere

6
 Figura 1: Un esempio di mainframe

• il multitasking - la possibilità di far operare il processore senza che un particolare utente

–e dunque un determinato processo- occupi l’intera potenza macchina

• la memoria protetta - più processi operanti sulla macchina non interferiscono tra loro
evitando di coinvolgere l’operatività dell’intero elaboratore se uno di questi va in crash

2.2 Personal computers

I personal computer proprio perchè “personal” e dedicati all’utenza consumer usavano sistemi
operativi molto semplici che non avevano bisogno di molta potenza per operare, nè necessitavano
di un sistema client-server (e dunque neanche di multiutenza e multitasking) per operare.
L’impossibilità di accedere a tecnologie di questo tipo era certamente dovuta al loro altissimo
costo di produzione e sviluppo. Tra i primi computer “personali” troviamo storicamente la serie
degli Apple (I, II e via dicendo) e i primi Macintosh atti a rendere l’informatica una scienza
per l’uomo comune.

3 Unix
Una breve rilettura delle concezioni di sistema operativo e hardware ci avrà fatto capire una cosa
molto importante: Unix non nasce per essere un sistema operativo “personale” ; non appartiene,
dunque, a una categoria di OS per “il resto di noi” ma nasce con il preciso intento di soddisfare

7
 Figura 2: L’Apple II, primo computer “personale”

i professionisti dell’informatica. Mac OS in se stesso non fa parte di questa categoria d’èlite.

Diciamo, quindi, -anche se in maniera un pò semplicistica- che Mac OS (X beninteso), Linux
e tutte le varie distribuzioni odierne di Unix capaci di girare su processori di grande consumo,
sono delle versioni derivate da sistemi professionali di costo molto alto, adattate ad hoc per
l’utenza “personale”.
Unix è stato sviluppato da ATT agli inizi degli anni 70. Fu concepito e sviluppato usando
il linguaggio C per dimostrarsi ampiamente multi-piattaforma tramite la ricompilazione del
kernel. Due versioni distinte nascono da questo stadio di sviluppo di Unix: UNIX System V di
ATT e UNIX BSD dell’ Università di Berkeley. Su queste due basi, le diverse aziende svilup-
pano le loro varianti di Unix, ciascuna adattandola alle proprio esigenze:

OS Azienda
SunOS Sun Microsystems
AIX IBM
IRIX Silicon Graphics
HP-UX Hawlett Packard
Linux -
Open BSD -

Grazie alla semplicità e alla compostezza di sviluppo, Unix ha una struttura molto semplice.
Questa comprende:

8
 • un kernel incaricato della gestione della memorie, delle entrate/uscite, de lo scheduling
dei processi, dell’acceso alle periferiche.

• un interprete di comandi (detto shell ) incaricato della gestione dell’interfaccia kernel -

utente.

• delle utilità di sistema comprendenti la gestione dell’interfaccia grafica, la gestione delle

componenti di amministrazione, i compilatori, le applicazioni.

3.1 Linux
Linux è un sistema operativo nato dalla mente del suo creatore Linux Torvalds nel 1991. Lo
sviluppo fu ripreso in seguito dalla comunità open source (Licenza GPL). Questa particolare
filosofia di sviluppo ha permesso a Linux l’integrazione in un numero sempre crescente di imprese
commerciali (IBM, Oracle, Dell, Silicon Graphics, Corel..) e la nascita di vere e proprie aziende
intorno al suo sviluppo (RedHat, Debian..) con lo scopo di vendere il servizio di distribuzione
di questo OS. Il grande successo di Linux è dovuto alla risposta di questo OS a delle particolari
esigenze:

• robustezza

• sicurezza

• funzionalità server

• tecnologie di infrastruttura reti

• compatibilità Unix

• alternativa di minor costo rispetto a Microsoft Windows Server

Facendo tesoro di queste caratteristiche, diverse ditribuzioni (più o meno riuscite) sono dispo-
nibili per l’utente in versione Client o Server, gratuite o commerciali, con supporto tecnico o
meno. Queste distribuzioni (RedHat, Fedora, Debian, Ubuntu, Mandrake...) sono carattetiz-
zate da dei numeri di distribuzione facenti appello a diverse evoluzioni del kernel, quest’ultime
caratterizzate a loro volta da un numero di kernel (ad esempio, Ubuntu 6.0 è basato sul kernel

9
2.6). É dunque possibile trovare un kernel Linux “comune” e normalizzato con integrato in
ciascuna distribuzione dei servizi e delle utilità di amministrazione comuni. Questa “normaliz-
zazione” del kernel ha permesso di possedere una referenza comune per tutti coloro vogliano
accedere ad un sistema operativo di derivazione Unix. Detto questo, esistono comunque molte
differenze tra le diverse distribuzioni quali l’arborescenza delle cartelle sistema e gli script di
amministrazione. Nonostante questa eterogeneità i sistemi che installano Linux sono altamente
competitivi a livello di costi di manutenzione (o semplicemente di acquisto) rispetto alle diver-
se versioni di Windows Server per l’impiantazione su piccoli server di documenti, stampanti o
anche di piccoli-medi gruppi di lavoro. Tutto questo risultando molto spesso altrettanto com-
petitivi rispetto agli stessi sistemi operativi Unix proprietari quando è l’installazione di servers
Web o basi di dati l’obiettivo da raggiungere.
Linux è dunque un ottimo sistema operativo che, per quanto unico nel suo genere ed efficente,
pecca in alcune caratteristiche ed esigenze:

• è un sistema nato per essere amministrato. Uno o più amministratori sono designati
per gestire le macchine. Gli altri utilizzatori definiti non sono tecnicamente autorizzati
e possono realizzare unicamente le azioni previste per essi. A questo si aggiunge anche
il piccolo “’difetto” (riconosciuto e in via di risoluzione) dell’inesistenza talvolta di GUI
locali che possano realizzare gli stessi interventi ottenuti via una linea di comando. Esiste,
dunque, un problema principale per chi possiede piccoli reti locali: formare e pagare un
amministratore di sistema è spesso difficile.

• i drivers. É vero, le cose stanno cambiando...ma rimane difficile per un non-esperto

procurarsi e utilizzare i drivers specifici per talune periferiche.

• Supporto del sistema. A volte risulta “aleatorio” sia dal punto di vista correttivo (patchs)
che dal punto di vista dell’assistenza e dell’installazione.

• Mancanza di standard. Come sopra descritto, l’abbondanza di distribuzioni linux crea

caos e rende spesso difficile la cooperazione di macchine con -di base- lo stesso sistema.

Le linee guida di Linux diventano quindi abbastanza difficili da comprendere per un non
esperto. Difficilmente chi ha appena comprato una qualunque macchina di tipo informatico ca-
pirà cosa voglia dire, ad esempio, “saper scegliere” tra diverse interfaccie, una diversa dall’altra,
tutte con funzionalità diverse.

10
 Figura 3: Il desktopswitch di Linux, capace di cambiare interfaccia a seconda delle esigenze.

L’utente comune ha quasi sempre bisogno di uno standard, qualunque esso sia - buono
o cattivo, ma UNO standard. Il cambiamento e la libertà di scelta sono ottime cose, ma il
problema non è offrirle alla propria fascia di utenza ma saperle offrire con esattezza ed eleganza
a chiunque senza imporre una conoscenza approfondita al cliente finale.

Figura 4: Tanti “Linux”

11
3.2 Mac OS, un cuor di Unix
3.2.1 A/UX

Unix ed Apple, un connubio che non nasce certo con Mac OS X. Apple si era già avvicinata
a Unix con il poco conosciuto A/UX. A/UX (da Apple Unix) fu l’implementazione di Apple
Computer del sistema operativo Unix per alcuni Macintosh dell’epoca. L’ultima versione di
A/UX data del 1995 (3.1.1) e girava su gran parte dei Macintosh II, Quadra, e Centris. Questo
Unix modificato si basava sul System V 2.2 con alcune caratteristiche aggiunte dal SysV 3 e 4,
BSD 4.2 e 4.3. Compatibile pienamente con i sistemi POSIX e con SVID (System V Interface
Definition), includeva il supporto TCP/IP dalla versione 2 in poi.

Figura 5: L’interfaccia di A/UX

Questa prima prova di “connubio” tra Mac OS e Unix includeva, con successo, un’interfaccia
grafica del tutto simile al consueto Finder. In realtà il Finder A/UX era una versione del Finder
7 adattata per essere eseguita come processo Unix e ridisegnata per interagire con il kernel Unix
e il suo filesystem. A/UX includeva anche una CommandShell che offriva -da vero Unix- una
interfaccia a linea di comando e, con particolari layers, poteva supportare in egual misura tutte
le applicazioni del Macintosh System 7.0.1. Al solito Apple, avendo anticipato di gran lunga

12
i tempi, si ritrovò a sviluppare un sistema operativo con una fascia di utenza assai ridotta e
con elevati costi di mantenimento. La storia di A/UX si concluse con una disfatta; anche se
il sistema operativo sviluppato era efficente, Apple non effettuò mai il porting di A/UX sui
PowerPC e preferı̀ addirittura usare una versione modificata dell’AIX IBM sui propri server a
metà degli anni ’90.

3.2.2 NeXTSTEP

Unix era il destino di Apple. Seppur con un nuovo system in via di sviluppo (stile system 7),
Apple -nel periodo più nero della sua storia- abortı̀ il progetto Copland e si ritrovò a dover
scegliere una “base” per il suo nuovo sistema operativo del futuro. Una scelta obbligata, poiché
troppo in ritardo rispetto al principale concorrente del momento: il System 7.5.3 si scontra con
il sempre più efficente e simile al Mac OS, Windows 95. Apple sceglie NeXT e il suo sistema
operativo NeXTSTEP riportando in azienda anche una delle persone più carismatiche della
storia dell’informatica, Steve Jobs. Il 4 febbraio 1997, Apple Computer acquisisce NeXT e uti-
lizza OpenStep per sviluppare l’interfaccia grafica di Mac OS X e portando con se la tecnologia
(in Objective C) Cocoa. NeXTSTEP si basa essenzialmente su un kernel Mach con codice BSD
UNIX che usa il potente Display PostScript per la gestione dell’interfaccia. Flessibile ed elastico
il NeXTSTEP gestiva a livello di oggetti le componenti del SO e comprendeva componentistica
di estrema qualità per lo sviluppo rapido delle applicazioni. La bellezza e l’eleganza di questo
SO derivano principalmente da queste due caratteristiche che, implementate con un’interfaccia
grafica raffinata, ne facevano un prodotto estremamente innovativo. La sua GUI introduceva il
concetto di dock, l’uso del 3D, e l’utilizzo di componenti che accettavano come ingresso oggetti
grafici. La grafica e il suono erano i campi in cui NeXTSTEP eccelleva integrando una gestione
avanzata dei colori per la tipografia e la trasparenza e un processore DSP Motorola che per-
metteva di gestire i suoni in maniera molto efficente. Oltre a tutto questo NeXTSTEP portava
con sé il PDO (Portable Distributed Objects) che permetteva l’invocazione remota degli oggetti
contribuendo cosı̀ al definitivo successo delle tecnologie orientate oggetti.
Con queste solidi basi e con il ritorno di un protagonista d’eccezione (Steve Jobs), Apple
ricominciò a credere in un sistema operativo capace di poter sostituire l’anziano system 7, che
nelle sua varie incarnazioni (System 6,7,7.1,7.5,... fino al 9.2.2) era fondamentalmente rimasto
lo stesso. Steve Jobs, alla prima presentazione di Mac OS X in forma di Public Beta, disse
che ciò che era nato dalle ceneri di NeXTSTEP sarebbe stato il sistema operativo Apple per

13
 Figura 6: L’interfaccia di NeXTSTEP

i prossimi 10 anni: di fatto la longevità del nostro OS X oltrepassa molto più che la decade
poiché NeXTSTEP nacque più di 16 anni fa.

3.2.3 Mac OS X

Rhapsody. Questo era il nome che internamente Apple usava per indicare cosa stava sviluppan-
do partendo dall’eredità di NeXTSTEP. Di fatto, il sistema operativo “ideale” sarebbe dovuto
nascere dalle librerie OpenStep con accanto una “Blue Box” capace di emulare le applicazioni
Mac OS Classic. Previsto inizialmente per la fine del 1998, Rhapsody non fu mai commercia-
lizzato. Il principale problema di Rhapsody era una strategia di riscrittura delle applicazioni
alquanto ambiziosa che pretendeva un risviluppo completo delle applicazioni da parte delle
software house. Visti i risultati finanziari disastrori di Apple, Macintosh era un piattaforma
considerata in piena decadenza e la maggior parte degli sviluppatori si rifiutò di continuare a
dar fiducia al Mac OS.
Molto cambiò alla World Wide Developer Conference del 1999, quando Steve Jobs inaugurò
il progetto Mac OS Ten. Rhapsody avrebbe contribuito con il suo kernel, POSIX e OpenStep

14
a integrare il nuovo “Ten” con l’uso delle vecchie API del Mac OS riscritte e rinnovate per
l’occasione sotto il nome di Carbon. Le altre valide tecnologie del Mac OS Classic, quali
QuickTime, AppleEvents, AppleScript e ColorSync sarebbero state portate sotto OS Ten per
la gioia di sviluppatori e utenti finali.
Ed eccoci infine al nostro Mac OS X. Il kernel XNU e lo strato BSD sono stati riorganizzati
e redistribuiti in licenza open source (Apple Public Source Licence) sotto il nome di Darwin.
Fornendo un sistema operativo stabile, solido ed efficente, Darwin è in piena competizione con
gli altri sistemi di derivazione Unix, essendo del tutto “Made in Apple” e avendo abbandonato
tecnologie proprietarie come, ad esempio, il linguaggio PostScript sul quale l’interfaccia di
OpenStep si basava. Con estrema precisione e rispettando in pieno le date di sviluppo, Mac OS
X nasce nel 2001 e continua ad essere sviluppato con continui aggiornamenti a cadenza quasi
semestrale (anche se attualmente -con lo scopo di stabilizzare la piattaforma di sviluppo- Apple
ha deciso di allungare i cicli di sviluppo). Ma ciò che rende Mac OS uno dei sistemi operativi più
avanzati al mondo è la sua GUI. Facendo tesoro dell’esperienza del Mac OS Classic, l’interfaccia
Aqua è considerata una delle migliori ed eleganti. Riuscendo a coniugare questa stupefacente
creatività nello sviluppo delle GUI e la stabilità di un OS Unix, Apple è diventata una delle
compagnie con il maggior numero di installato Unix.
Di fatto, però l’appelazione “Based on Unix” è da considerare “ufficiosa”. Apple non ha
mai fatto parte del “The Open Group”, un’organizzazione nata per certificare l’appartenenza
dei SO alla famiglia Unix. Possiamo dunque definire Mac OS X un sistema operativo ibrido;
un abile miscuglio dei migliori prodotti che l’informatica è riuscita a produrre durante la sua
storia, dalla nascita di Unix al primo Macintosh.

15
Figura 7: L’interfaccia di Mac OS X “Ten” 10.0

16
Parte II

Il sistema
4 Kernel e terminali
4.1 Kernel
Il kernel è il core di Unix. Si tratta, principalmente, di un grosso programma caricato nella
memoria quando la macchina viene accesa e controlla l’allocazione delle risorse hardware da
quel momento in avanti. Il kernel conosce quali risorse hardware sono disponibili e possiede i
programmi necessari per “parlare” con le varie periferiche. Per far ciò ha bisogno dei controlli
di configurazione e alcune utilità standard. Il kernel Unix e le utilità sono programmi flessibili,
e alcuni aspetti delle loro caratteristiche possono essere controllati cambiando i documenti di
configurazione. Tipico esempio di un file di configurazione è il documenoi di sistema “fstab” che
comunica al kernel dove trovare i files presenti sul disco rigido. Altro esempio è il documento
di configurazione del system log che comunica al kernel come effettuare la registrazione dei vari
eventi e errori che si possono riscontrare durante la sessione di lavoro.

4.2 Metodi di accesso ad un sistema operativo Unix

Esistono diverse metodologie di accesso ad un sistema operativo Unix. Per far questo è ne-
cessario sempre e comunque iniziare una sessione di lavoro effettuando il login all’interno del
sistema. Il metodo principale per iniziare un sessione di login su una macchina Unix è attra-
verso un terminale che include quasi sempre una tastiera e un monitor. Quando il terminale
stabilisce una connessione con il sistema Unix, il kernel fa partire un processo chiamato tty per
accettare l’input dal terminale e visualizzare l’output sul terminale. Quando il processo tty è
creato, è necessario che gli sia detto con che tipo di terminale ha a che fare. Se il processo
tty non ricevesse questo tipo di informazioni, non potrebbe comunicare correttamente con il
terminale e di conseguenza l’utente potrebbe ottenere risultati non voluti.

17
4.2.1 Console

Ogni sistema operativo Unix possiede una console principale connessa direttamente con la
macchina su cui è installata. La console è una particolare tipo di terminale che viene riconosciuto
quando il sistema è in funzione. Alcune operazioni relative al sistema possono essere attuate
da console. É per questo che è molto spesso accessibile solo dagli operatori del sistema e dagli
amministratori.

4.2.2 Dumb terminals

Alcuni terminali vengono denominati “muti” poiché possiedono risorse sufficienti solo per man-
dare caratteri come input al sistema e ricevere caratteri come output dal sistema. Molto spesso
i “personal computer” possiedono programmi di emulazione terminale in modo da potersi con-
nettere ad un sistema Unix in questa modalità. I terminali “muti” possono essere connessi
direttamente ad una macchina Unix, in remoto, attraverso un modem, un terminale server o
altre connessioni network.

4.2.3 Smart terminals

I terminale cosidetti “smart”, come l’X terminal, possono interagire con il sistema ad un livello
più alto rispetto ai terminali “dumb”. Questi hanno sufficente memoria per provvedere un
adeguato supporto alle interfacce grafiche. L’interazione tra un terminale di questo tipo e
Unix può avvenire attraverso semplici caratteri quali icone, finestre, menu e azioni attraverso
il mouse.

4.3 Terminale e shells

Il Terminale rappresenta l’interfaccia “primitiva” di OS X e di qualunque OS Unix-based. Di
fatto è stata la prima in senso assoluto. Essendo la più anziana è quella che lavora sin dalle prime
build di Unix e quindi è sicuramente quella che richiede minor impegno da parte della CPU
grazie a un’interazione macchina-utente che si avvale esclusivamente del testo. Il fatto di non
dover necessariamente caricare un’interfaccia grafica tipo “punta e clicca” diventa estremamente
vantaggioso per macchine che non dispongono di cospicue risorse hardware. L’applicazione
Terminale (/Applicazioni/Utility/Terminale) rappresenta cosı̀ una sorta di finestra sul “vero

18
puro ” Unix. In questo modo è possibile inviare comandi al Subsystem BSD che ne riceve le
istruzioni direttamente. Con queste caratteristiche il Terminale diventa uno strumento molto
potente di cui un amministratore può disporre. Se se ne hanno le capacità è teoricamente
possibile fare di tutto via terminale, usufruendo delle sue enormi capacità di interazione.

4.4 Il prompt
Prima di spiegare il funzionamento di qualsiasi comando della shell bash (default da Mac OS X
“Panther”) è necessario che si conosca bene l’importanza di ciò che ci appare a schermo al primo
avvio del terminale. Ciò che ci troviamo di fronte all’avvio dell’applicazione Terminale.app è il
prompt:
Last login: Tue Mar 4 06:19:35 on console
Welcome to Darwin!
[mistral:~] olivio\%
La parte tra parentesi quadre indica il nome della macchina. Questa informazione risulta
importantissima per chi ha intenzione di cimentarsi con il controllo remoto dell’elaboratore.
Ci informa, di fatto, su quale macchina stiamo operando. In successione dopo i due punti
troveremo la directory di utilizzo attuale (in gergo: working directory). Di default Mac OS
X imposta come directory iniziale la home directory indicata dalla tilde. Fuori dalle parentesi
quadre appare il nome utente attualmente operante sul terminale. Tutto ciò che si scrive sul
terminale appare sulla destra del nome dell’utilizzatore subito dopo il caratterere “percento”.

4.5 Uso dei tasti freccia

In genere sono usati per riprendere i comandi già dati (su e giù). Freccia sinistra e freccia destra
invece spostano il cursore lungo la linea di comando per rendere più semplice la correzione degli
errori.

4.6 Logging in e logging out

Per assicurare la massima privacy a ciasun utente che ha accesso all’elaboratore le macchine
Unix implementano un sistema per l’accesso separato di ciascun utente. La cosidetta mul-
tiutenza permette di separare le risorse di ciascuna macchina e dunque rendere più efficente

19
e intelligente l’esecuzione dei vari processi consentendo oltretutto di amministrare in perfetta
sicurezza la propria parte di sistema. Per far ciò è necessario che il sistema operativo vi “ri-
conosca” e dunque vi si chiederà di effettuare un’operazione di login. Vi starere chiedendo a
cosa serve questa operazione dato che all’avvio del Terminale il prompt ci dice già da subito
con quale nome siamo stati loggati. Questo succede perché di default Mac OS X ha abilitato
il login automatico che sarà necessario disabilitare se si vuole usufruire della multiutenza. A
login automatico attivo o meno la fase di login sarà effettuata comunque nell’ambiente grafico
e dunque all’avvio del terminale saremmo già autenticati.
Un’opzione ancora più diretta per accedere all’interfaccia testuale è quella di scegliere
“Altri...” nella finestra di login e scrivere nel campo destinato al nome utente :

>console

A questo punto potermmo effettuare la procedura di login testuale descritta.

4.7 Logging in
Autenticarsi su un sistema operativo Unix richiede due informazioni fondamentali. Un nome
utente e una password. Quando si accede al terminale di Unix, il sistema operativo richiede
queste due informazioni:

Login:

Dopo aver scritto il proprio nome utente e premuto il tasto invio il sistema vi richiederà
una password. In questo caso quando scriverete il sistema non provvederà a visualizzare la
password digitata.

4.8 Il nome utente

La cosidetta username è assegnata dalla persona (quindi un amministratore) che crea il vostro
account. Mac OS X indicherà come username di default il vostro short name. La vostra
username sarà unica e indicherà al sistema operativo come identificarvi.

20
4.9 La password
Quando il vostro account sarà creato, anche una password sarà assegnata al nuovo utente. In
questo caso è utile sapere come cambiare la propria password trovandosi di fronte alla linea di
comando. Dopo essersi loggati è necessario digitare:

% passwd

Il sistema vi chiederà di indicare la vecchia password e successivamente la nuova richieden-

done poi la conferma. É molto importante che si scelga una “buona” password in modo tale da
salvaguardare l’accesso alla propria porzione di sistema. É necessario per questo seguire alcune
regole fondamentali. Sarà importante :

1. Non usare nessuna parte del proprio nome o il nome di qualcun altro. Né usare l’ana-
gramma di alcun nome

2. Non usare un numero facilmente reperibile tipo il proprio numero di telefono, il proprio
indirizzo.

3. Non usare alcuna parola reperibile in qualunque dizionario italiano o straniero

4. Non usare tutte le stesse lettere, o una sequenza banale di queste.

5. L’ideale è l’utilizzo anche di caratteri maiuscoli e minuscoli insieme. L’importante è che

si usino al massimo sei caratteri.

6. Se si hanno diversi account su diverse macchine non usare sempre la stessa password su
ogni macchina.

4.10 Logging out

Quando si è terminata la sessione di lavoro è necessario “deautenticarsi” digitando:

% exit

21
 Dopo aver lasciato il proprio terminale è necessario assicurarsi che venga visualizzata la
prompt di login affinché si abbia l’assoluta certezza di essere stati effettivamente deautenticati
dal sistema. Se alcuni processi non sono stati terminati prima del loggin out il sistema richiederà
che questi vengano terminati. La shell di Mac OS X usa anche il comando :

% logout

Per effettuare la deautenticazione. É sempre buona norma cancellare ciò che è rimasto
visualizzato sul terminale prima del logout. Potrebbero essere rimaste informazioni importanti
tipo alcune informazioni a proposito di voi o a proposito del lavoro effettuato sul sistema. In
questo caso sarà opportuno digitare il comando:

% clear

4.11 Tipi di login

Il login che si compie all’avvio della macchina è quindi essenziale per la sicurezza dell’intero
sistema. Su Mac OS X abbiamo tre tipi di login che corrispondono a tre particolari set di
privilegi.

• Superuser– Il superutente è denominato anche “root”. Il carattere loggato con questo

nome ha privilegi assoluti su tutti i files e cartelle, comprese quelle del system che possono
essere tranquillamente cancellate da questo tipo di utente.

• Administrator– L’amministratore è l’utente che viene creato al primo avvio di OS X .

Questo utente ha il privilegio di modificare le impostazioni del sistema, ma gli è impossibile
cancellare e modificare gli script di sistema che sono monopolio del superutente. L’utente
amministratore è stato creato da Apple per evitare che l’utente alle prime armi possa
inavvertitamente mettere mano ai files di sistema.

• User– L’utente “ospite” non ha alcun diritto sulle impostazioni della macchina. In
definitiva deve sempre richiedere l’autorizzazione all’Amministratore per un qualsiasi
cambiamento sulle impostazioni prestabilite.

22
4.11.1 Il superutente

Il cosı̀detto super utente (detto anche root) è il carattere che può tutto in Unix. É utile cono-
scerlo poiché permette la modifica di parametri nei documenti di sistema altrimenti impossibile
con l’account creato da Mac OS X al primo avvio. Per abilitarlo sarà necessario utilizzare
l’applicazione Netinfo Manager (vedi in /Applications/Utilities/Netinfo Manager). Utilizzando
questa applicazione possiamo autenticare e assegnare al root una password.
Vediamo la procedura di autenticazione:

• In Mac OS 10.2.x e successivi, apriamo NetInfo Manager e scegliamo dal menu “Security”
l’opzione “Enable root user”.

• In Mac OS 10.x.x scegliamo dal menu “Domain” l’opzione “Security”. Dal sottomenu
scegliamo “Enable root user”.

• Ci verrà chiesta la password da amministratore e poi quella da root. A questo punto

l’utente root è abilitato in tutte le sue funzioni.

Per richiamare questo tipo di utente via terminale sarà necessario utilizzare il comando:

[mistral:~] olivio % su
Password:
[mistral:/Users/olivio] olivio#

4.11.2 Utilizzare il comando sudo

Si tratta di un’utlità di sistema.

% sudo

Il comando sudo sta per “substitute-user do ” e permette di accedere ai privilegi dell’utente

“root” immediatamente. Per usare questo comando scriveremo:

[mistral:~] olivio % sudo nomecomando

Il sistema richiederà una password di amministratore. Scritta la password di amministratore

il sistema effettuerà il comando come se l’utente attivo fosse il super utente. Ricordiamo che
con questo comando non è necessario abilitare l’utente root.

23
Parte III

I comandi terminale
Generalmente un comando Unix si presenta sempre sotto questa forma:

% Nomecomando [-options]

Il nome del comando è il nome del programma che il terminal eseguirà. L’opzione ci viene in
genere suggerita dalla shell stessa e altera la funzionalità del comando in base al compito che
l’utente vuole che esegua. L’argomento possono essere dei documenti, delle cartelle o anche
programmi. Provando a scrivere per esempio:

olivio@mistral:~$ cp

La nostra shell ci verrà in aiuto indicandoci quali sono le opzioni possibili per il comando.

olivio@mistral:~$ cp
usage: cp [-R [-H | -L | -P]] [-f | -i | -n] [-pv] src target
cp [-R [-H | -L | -P]] [-f | -i | -n] [-pv] src1 ... srcN directory

Nell’utilizzare qualunque comando della shell può capitare di incappare in errori. Niente
paura. Se si vuole abortire l’esecuzione di un comando sarà sufficente usare la combinazione di
tasti ctrl + c.

5 Comandi utili per l’apprendimento

5.1 man
Comando per richiamare il manuale in linea relativo a un comando specifico, una funzione o una
nozione. E’ forse uno dei comandi più usati per chi si avvicina per la prima volta al terminale
Unix. E’ dunque una convenzione conoscerne l’esistenza. Questo comando da infatti accesso
alla documentazione in linea (“man” sta per manual). Scrivendo:

% man [capitolo] nome_del_comando

24
 Se nome-del-comando è un comando valido (naturalmente la sua man page deve esistere),
viene mostrata la documentazione relativa. Ricordiamo che le man pages non sono solo adibite
alla descrizione dei comandi, ma anche alla descrizione di molti files di configurazione. Se si
scrive:

% man [capitolo] rc

Si otterà la documentazione in linea del file di booting “rc”. In qualunque caso il valore
“capitolo” è un numero che indica in quale parte della man page si vuole ricercare l’informazione
voluta. Omettendo questo valore il comando man mostrerà direttamente la prima pagina del
manuale. Il “valore capitolo“ è importante poichè in ambito Unix ci si trova spesso davanti a
frasi del tipo “per dettagli vedere nomadelcomando(6)”, dove il valore tra parentesi corrisponde
al capitolo delle man pages da consultare. Come “regole” di consultazione ricordiamo che per
andare avanti nello scorrimento del testo delle man pages è sufficente tener premuto il tasto invio
mentre per “sfogliare” le pages si può premere la barra spaziatrice. Chi prende consiglio dalle
man pages molto spesso desidera salvare su disco e tenere sempre a portata di mano il manuale
ricavato. In questo caso si pone un problema. Il testo delle man pages è formattato in maniera
particolare. Non possiamo dunque fare un semplice copia e incolla poichè il testo incollato
sarebbe in definitiva poco leggibile. Occorre oltre che filtrare l’output di man attraverso il
comando “col” anche instradarlo in un file di testo specifico. Usiamo dunque:

% man cp | col -b >testomanuale.txt

e il file testomanuale.txt conterrà le informazioni desiderate correttamente formattate e

fruibili durante una sessione di lavoro.

5.2 whatis
Dopo l’introduzione del comando man ci sarà utile apprendere l’uso del comando “whatis”.
Quest’ultimo infatti riporta informazioni sintetiche su un comando, quali le man pages esistenti
e il suo funzionamento in generale. Il comando whatis crea il suo database partendo da man
pages già esistenti e disponibili sul computer.

25
5.3 apropos
In correlazione con whatis, riporta tutte le ricorrenze del testo inserito. Scrivere:

% apropos cp

troverà tutte le ricorrenze di cp nel database di whatis. Il comando risulta molto comodo
quando si vuole verificare l’esistenza di quel comando in più man pages (in diversi capitoli, ad
esempio).

5.4 Cartelle “.” e “..”

Il singolo punto indica la directory corrente mentre i due punti indicano la directory che contiene
la directory in cui si sta lavorando. Scrivere:

% ./pwd

significa eseguire il programma pwd escludendo con ./ tutte le directory all’infuori di quella
in cui si sta operando. Questo comando è molto importante se sappiamo che sulla nostra mac-
china risiedono programmi con lo stesso nome. Potrebbe capitare di lavorare su un programma
che risiede in tutt’altra directory. E’ dunque buona norma specificare sempre la directory nella
quale si sa che risiede il programma da eseguire.

5.5 Il tasto tab

Per rendere la navigazione delle cartelle più veloce e flessibile la shell usa il tasto tab per
autocompletare quello che si sta scrivendo. In altre parole scrivendo parte del nome di una
directory o file e poi premere tab significa far completare sintatticamente il nome. Se la directory
che si vuole non coincide in alcun modo con la porzione di nome già scritta la shell emetterà un
beep di errore. In ogni caso se il nome da completare è una directory, il nome verrà completato
con una barra alla fine indicando di fatto la presenza di un file o cartella al suo interno.

26
6 Muoversi nel filesystem
6.1 Dischi e sistemi
Loggati all’interno del sistema è necessario capire come esso opera e in quale direzione ci stiamo
muovendo digitando i diversi comandi. Ovviamente, come l’interfaccia grafica, il terminale ha
un suo sistema di documenti che non ricalca sempre quella utilizzato dalla GUI. All’interno dei
sistemi Unix a linea di comando osserviamo l’esistenza di una arborescenza unica di cartelle
impiantata sulla root del disco detta “/”. In questo modo il sistema ci “inganna” facendoci
pensare all’esistenza di un solo sistema di documenti. In realtà, è possibile l’unione di più
alberi corrispondenti a sistemi di documenti diversi situati su dischi o anche macchine diverse.
É dunque possibile il “mounting” di ciascun albero su una cartella vuota (o meno) di un albero
già disponibile e creato. In questo caso parliamo di costruzione di un’arborescenza logica.
I vantaggi di questa soluzione sono molteplici:

• Elasticità

• Estensibilità

• Gestione di periferiche estraibili

I sistemi di documenti (filesystems) possono essere cosı̀ creati in una partizione, a sua volta
situata su uno o più dischi (o supporti di immagazzinamento). Unix supporta diversi sistemi
di documenti.; di per se anche Mac OS X lo fa in maniera egregia limitandosi spesso in alcune
sue possibilità usando prevalentemente il filesystem “di serie” per Mac, l’HFS+. Generalmente,
usando un sistema Unix possiamo confidare nel fatto che esso supporti:

• ext2, ext3 : Linux nativo

• swap : memoria virtuale su sistemi Unix

• msdos : FAT16 (MsDos)

• umsdos : MsDos esteso per una migliore compatibilità con Unix (nomi lunghi, UID,
GID..)

• vfat : FAT32 (Windows)

27
 • ntfs : NTFS (Windows NT)

• smb : Condivisione Lan Manager

• nfs : Condivisione nfs

• iso9660 : Sistema di documenti CDRom

6.2 Gestione dei dischi: i comandi df e mount

All’interno del nostro terminale useremo i comandi df e mount per visualizzare o aggiungere i
volumi a noi necessari.

• df - il comando df visualizza le informazioni relative ai sistemi di documenti montati (le

dimensioni sono contate in blocchi di 1 kn o in inode).

olivio@mistral:/etc$ df
Filesystem 1k-blocks Used Available Use% Mounted on
/dev/disk0s2 77814832 45281652 32277180 59% /
devfs 1 1 0 100% /dev
fdesc 1 1 0 100% /dev
<volfs> 512 512 0 100% /.vol
olivio@mistral:/etc$

• mount - monta un sistema di documenti su una cartella. Le principali opzioni sono:

1. -t - tipo di sistema di documenti

2. -options - opzioni di mounting (ro ou rw, umask, dmask, ...)

6.3 Arborescenza di un sistema operativo Unix-like

Iniziando una sessione di login in una shell, quest’ultima ci colloca da qualche parte nel file
system. Formalmente il file system è l’insieme ordinato dei tipi di dati astratti necessari per
memorizzare e organizzare gerarchicamente la manipolazione, la navigazione, l’accesso e la
lettura delle informazioni. Semplicisticamente parlando, il file system è un meccanismo con

28
il quale file e cartelle sono immagazzinati e organizzati su un dispositivo di archiviazione. In
questo sistema di documenti, Unix ci colloca, al suo avvio, in una working directory . A partire
da questa cartella “base” ci accorgeremo che l’esplorazione avviene tramite una sequenza di
“nodi” di tipo gerarchico, molto simile ad un albero. L’albero è piantato nel terreno in un luogo
chamato root(radice) chiamata “/”. Ogni elemento che troviamo in questo catalogo gerarchico è
o una cartella o un documento. Per specificare un particolare documento o cartella è necessario
che si specifichi anche un percorso per giungerci. Il percorso partirà sempre dalla root del
catalogo gerarchico per arrivare al file o cartella voluta. Ogni directory nella sequenza sarà
seguita da “/”. Ricordiamo che il simbolo “/” indica anche la root directory. Non confondiamo
dunque il carattere “/” usato ad inizio sequenza per indicare la root directory e il carattere “/”
usato solamente per separare le cartelle del catalogo gerarchico. L’arborescenza di un sistema
Unix è quasi sempre comune a molti OS di tale derivazione. Di seguito forniamo un elenco delle
varie cartelle presenti a livello “radice” “/”. Ovviamente questo listing è “generale” e varia a
seconda delle varie distribuzioni di Unix installate.

• /bin : comandi del sistema operativo (Unix)

• /dev : documenti di descrizione delle periferiche (device) hardware e software.

• /etc : documenti di configurazone del sistema

• /etc/rc.d : Scripts di avvio

• /home : Cartelle personali degli utenti (home). Ovviamente a seconda della configura-
zione questa arborescenza può cambiare

• /lib : Documenti libreria necessari al compilatore C e a l’esecuzione dei programmi

compilati (librerie dinamiche condivisibili)

• /mnt : Cartelle di “mounting” delle periferiche di stoccaggio di massa.

• /root : Cartelle di base dell’utilizzatore root.

• /sbin : Demoni del sistema operativo.

• /tmp : Documenti temporanei.

29
 • /usr : Comandi del sistema

• /usr/bin : Comandi del sistema operativo specifici a Linux (ad esempio) e all’installazione
realizzata. Molto spesso vi si trovano degli alias verso i comandi di /bin.

• /usr/doc : Documentazione

• /usr/include : Intestazioni dei document *.c

• /usr/lib : Bibliotecche dei sotto-programmi.

• /usr/local/bin : Comandi locali.

• /usr/sbin : Demoni del sistema specifici all’installazione del sistema Unix in question.

• /usr/src : Sorgenti del sistema operativo.

• /usr/tmp : Documenti temporanei.

• /usr/X11R6 : X-Window

• /var : Tavola di definizione dei servizi.

• /var/cron : Servizio cron.

• /var/log : Docmenti di “giornalizzazione” del sistema Unix specifico alla distribuzione.

• /var/mail : Mail

• /var/spool : Documenti in attesa di trattamento.

• /var/spool/mail : Documenti e cartelle riferiti alle mail.

6.4 Arborescenza di Mac OS X

Qualunque esperto Unix rimarrà sorpreso dall’osservare la mancanza della familiare arbore-
scenza Unix aprendo una qualunque finestra del finder in Mac OS X. Le familiari cartelle /var
e /usr sono completamente inesistenti, almeno nell’interfaccia grafica. Un comando di listing
(ls) nella nostra root ci indicherà che le cartelle in questione sono presenti (come anche /Library

30
e /Developer) ma nascoste. Qui di seguito forniamo una lista dei documenti e cartelle visibili
alla radice del disco (o in altre parti del sistema) legati esclusivamente a Mac OS X:

• .DS Store - Documento contenente i settaggi del finder in ogni cartella creata.

• .Trashes - Cartella contenente i documenti che sono stati spostati nel cestino.

• .vol/ - Cartella contenente il mapping del sistema HFS+.

• Applications/ - Cartella contenente tutte le applicazioni Mac OS X.

• Desktop DB, Desktop DF - Il database desktop del Mac OS Classic.

• Desktop Folder/ - La cartella desktp del Mac OS Classic.

• Developer/ - Cartella delle applicazioni di sviluppo Apple. Presente sul disco unicamente
se i Developer Tools sono installati.

• Library/ - Documenti di supporto per le applicazioni installate localmente.

• Network/ - Applicazioni via Network. Allo stesso modo Librerie , cartelle Utente via
Network sono usate attraverso l’uso di questa cartella.

• Shared Items/ - Cartella usata da OS 9 per condividere gli elementi tra diversi utenti.

• System Folder/ - La cartella di sistema Mac OS 9.

• System/ - Contiene i documenti di supporto per il sistema e le applicazioni di sistema.

• Temporary Items/ - Documenti temporanei usati da Mac OS 9.

• TheVolumeSettingsFolder/ - Questa cartella tiene traccia delle cartelle aperte e delle

stampanti da scrivania usate.

• Trash/ - Il cestino di Mac OS 9.

• Users/ - Le cartelle home dei vari utenti.

• VM Storage - La cartella che contiene i documenti per la memoria virtuale diMac OS 9.

31
 • Volumes/ - Contiene tutti i volumi montati dal sistema.

• automount/ - La cartella che manovra il mounting dei dischi NFS.

• bin/ - I binari dei documenti essenziali del sistema.

• cores/ - Se il “core dumps’ è in funzione sarà allora creato in questa cartella sotto il nome
di core.pid.

• dev/ - Documenti/drivers delle varie periferiche.

• etc/ - Documenti di configurazione del sistema.

• lost+found - Cartella contenente i documenti ”orfani“ di fsck.

• mach - Si tratta di un alias simbolico al file /mach.sym.

• mach.sym - Simboli kernel.

• mach kernel - Il kernel Darwin.

• private/ - Contiene le cartelle tmp, var, etc e cores.

• sbin/ - Eseguibili per l’amministrazione del sistema e la configurazione.

• tmp/ - Documenti temporanei. Temporary files.

• usr/ - Applicazioni e documenti di supporto BSD.

• var/ - I documenti di log sono contenuti in questa cartella. Generalmente anche tutti i
documenti modificati più di frequente.

6.5 I file nascosti

I documenti invisibili in Mac OS X sono generalmente in questa condizione poiché davanti al loro
nome è stato inserito un ”.“. É questo il motivo per il quale ció che osserviamo nell’interfaccia
grafica non è del tutto simile a quello appare nel terminale. Di fatto gran parte delle cartelle
elencate pocanzi non sono visibili. Mac OS X usa, talvolta, una tecnica tutta sua per rendere
invisibili i documenti: il documento .hidden presente alla radice del disco ha questo scopo,

32
mantenendo una lista dei documenti che non dovrebbero essere visibili nel Finder. Usando poi
i Developer Tools forniti da Apple, il comando :

SetFile -a V documento

ci permetterà di aggiungere l’attributo ”invisibile“ al documento passato in argomento. In

questo caso questa impostazione avrà effetto solo al rilancio del Finder. L’operazione sarà poi
reversibile con:

SetFile -a v documento

6.6 Uso del filesystem : pwd, cd, ls...

Come già detto in Unix il proprio “luogo di lavoro” è chamato current working directory. Se si
vuole sapere dove ci si trova è necessario digitare:

% pwd

che significa print working directory . Quando si ha intenzione di cambiare la propria

directory di lavoro è necessario usare il comando:

cd nome_directory

che significa change directory seguito dal nome della cartella in cui si vuole arrivare. L’ar-
gomento può anche essere un percorso che definisce la directory nella quale si vuole lavorare.
Scrivere semplicemente :

% cd

nel prompt vuol dire chiedere alla shell di reindirizzarci direttamente nella nostra home-
directory. Scrivere:

cd ..

significa chiedere alla shell di scalare di un livello la gerarchia delle directory. Quando si è
nella cartella voluta possiamo chiedere al terminale di dirci cosa vi è dentro scrivendo:

33
% ls

che significa list . In questo caso otterremo il isting dei documenti escludento tutti quelli
che cominciano con ”.“. Più utile è da usare l’opzione del comando ”-l“:

% ls -l

Otterremo sette colonne con ognuna delle informazioni dettagliate:

drwxr-xr-x 33 olivio guest 1122 Aug 27 09:06 Photos

-rw-r--r-- 1 olivio olivio 611292 Oct 23 11:22 Picture 1.png
drwxr-xr-x 7 olivio olivio 238 Jun 24 01:33 mistralG4
-rw-r--r-- 1 olivio obs 52579 Oct 28 23:35 Untitled 2.rtf

1. Tipo di documento e autorizzazioni (cartella indicata da ”d“, alias indicato da ”l“)

2. Numero di alias materiali o numero di blocchi per una cartella.

3. Proprietario

4. Gruppo

5. Dimensione

6. Data e ora dell’ultima modifica

7. Nome del documento

“ls“ si dimostra molto potente. É possibile effetture dei listing molto specifici e dettagliati.
Per esempio scrivendo:

% ls -lR /lib/l*

l’opzione “I” e “R” sono invocate insieme. L’opzione “I” richiede un long output e l’opzione
“R” chede a ls di listare le directory scendendo la gerarchia. L’ultima parte del comando “
/lib/l*” chiede al comando di listare documenti e cartelle comincianti per “l” nella cartella
/lib. Il carattere * significa qualunque carattere, dunque tutte le cartelle comincianti per “l” e
con qualunque seguito di caratteri.

34
6.7 cp
cp è un’utilità di sistema e permette di effettuare una copia del documento o cartella passato
in argomento. Ad esempio:

olivio@mistral:~$ cp Stato.txt Desktop

olivio@mistral:~$

In questo caso abbiamo copiato il documento Stato.txt sulla Scrivania.

6.8 mv, rm, unlink

I due comandi (mv, rm) permettono rispettivamente di spostare o di rinominare un documento
e di rimuovere un documento. Nel caso di cartelle sarà necessario usare l’opzione ”-r“ con il
comando rm per ottenere una effettiva rimozione della directory passata in argomento. unlink
allo stesso modo permette di cancellare un documento.

Alcuni esempi possono essere :

• olivio@mistral:~$ mv Stato.txt Desktop

olivio@mistral:~$
Abbiamo spostato il file Stato.txt sulla Scrivania.

• olivio@mistral:~/Desktop$ rm Stato.txt
olivio@mistral:~/Desktop$
Abbiamo rimosso il documento Stato.txt dalla Scrivania

• olivio@mistral:~/Desktop$ unlink Stato.txt

olivio@mistral:~/Desktop$
Abbiamo rimosso il documento Stato.txt dalla Scrivania

6.9 mkdir, rmdir

I due comandi permettono di creare ed eliminare una cartella.

• mkdir - crea una cartella

35
 • rmdir - cancella una cartella

6.10 ln
ln serve alla creazione di alias materiali o simbolici. Un alias materiale è una referenza a un
documento. In questo caso ciò corrisponde a un’uguaglianza totale tra tutti gli alias materiali
sullo stesso documento o cartella; ciò comporta la distruzione reale di un documento quando
l’ultimo alias materiale su quest’ultimo viene eliminato. Un alias simbolico è invece una sem-
plice “scorciatoia” verso un documento: l’alias simbolico rimarrà attivo nel caso il documento
sorgente venga elimitato.
Ad esempio: se creiamo un alias materiale e 2 simbolici sullo stesso documento otterremo la
soppressione dell’alias materiale e di uno dei due alias simbolici. Se sopprimiamo un documento
di destinazione otterremo un errore dall’ultimo degli alias simbolici.

7 Gestione dei documenti

Generalmente un documento Unix implica un nome che può comportare un numero massimo
di caratteri da 10 a 255 a seconda del file-system utilizzato. Possiamo dire che questo genere
di caratteristica non è gestito da Unix in se stesso ma dalle applicazioni e dai servizi in esso. I
documenti che possiamo trovare nel sistema di documenti di Unix sono generalmente di questo
tipo:

36
 Estensione Servizio/applicazione
.c Documento sorgenti in C
.cpp Documento sorgenti in C++
.h Documento di intestazione in linguaggio C o C++
.o Documento oggetto generato dall’applicazione
.a Biblioteca statica
.so Biblioteca dinamica
.sh Script shell
.gz o .z Documento compresso utilizzando gzip
.bz2 Documento compresso utilizzando bzip2
.jpeg, .jpg, .gif, .png, ... Documento immagine
.txt Documento testo
.tgz Documento in formato tar compresso utilizzando gzip
.deb Pacchetto di installazione debian
.rpm Pacchetto di installazione RedHat
.ns Documenti NeXTSTEP ancora presenti in Mac OS X talvolta

Su questo tipo di documenti possiamo effettuare diverse operazioni attraverso particolari

comandi. Vediamo quali.

7.1 cat, more, less, od

Sono dei paginatori . Servono quando un comando invia a video parecchie pagine in risultato,
che ci scorrono davanti agli occhi senza la possibilità di leggerle. Questo genere di comando si
usa spesso tramite pipe (di cui parliamo in altra sede in questo manuale) che convoglia l’uscita
di un programma all’ ingresso di un altro.
Ad esempio :

% ls /dev | more

dove | ridirigerà l’uscita del comando all’ingresso di more. Il risultato sarà una schermata
pagingdi 24 righe al termine della quale il comando more mosterà a schermo:

--more--

37
attendendo la pressione della barra spaziatrice da parte dell’utente per passare alla pagina
successiva. Allo stesso modo il comando:

% less

Permette di paginare il documento passato in parametro. less da questo punto di vista è un

more migliorato; è possibile scorrere il documento sia avanti che indietro usando i tasti freccia
della tastiera.
Il comando:

% cat

espressamente conCATenate , al pari di less e more stampa a schermo il testo del documento
in parametro ma, come suggerisce il nome del comando, cat può essere in effetti usato per
concatenare e stampare più file. Nel seguente esempio osserverete come vengono stampati uno
di seguito all’altro (senza interruzione o demarcazione del cambio di file) i file resolv.conf e
rc.shutdown:

olivio@mistral:/etc$ cat resolv.conf rc.shutdown

Il comando:

% od

Può essere utile se il documento da esaminare non è di testo ma, per esempio, un file dati.
In questo caso non ha senso cercare di visualizzarlo o editarlo come fosse un file di testo. É
cosı̀ possibile effettuare un dump ottenendo una rappresentazione visualizzabile del contenuto
binario. od (propriamente Octal Dump ) senza opzioni produce una visualizzazione ottale
delle “parole” del documento. Altre opzioni consentono di dividere il file in altre unità (byte
invece che parole)o di darne una rappresentazione decimale o esadecimale o ASCII . Per ottenere
quest’ultima possibilità usare l’opzione -c (visualizzazione a byte tentando una rappresentazione
ASCII):

olivio@mistral:~$ od -c q.log
0000000 T h i s i s T e X , V e r
0000020 s i o n 3 . 1 4 1 5 9 2 ( W

38
0000040 e b 2 C 7 . 5 . 5 ) ( f o r
0000060 m a t = t e x 2 0 0 6 . 5 . 4
0000100 ) 2 J U N 2 0 0 6 1 5
0000120 : 2 6 \n * * q \n ( / u s r / l o
0000140 c a l / t e T e X / s h a r e /
0000160 t e x m f . t e t e x / t e x /
0000200 l a t e x / t o o l s / q . t e
0000220 x F i l e i g n o r e d \n )
0000240 \n ! E m e r g e n c y s t o
0000260 p . \n < * > q \n \n *
0000300 * * ( j o b a b o r t e d ,
0000320 n o l e g a l \ e n d f
0000340 o u n d ) \n \n N o p a g e s
0000360 o f o u t p u t . \n
0000373
olivio@mistral:~$

La prima colonna visualizzata rappresenta un contatore ottale dei byte. Le coppie di

caratteri

\n

rappresentano, seguendo le convenzioi del linguaggio C, dei < CT RL − J > cioè dei < N EW −
LIN E > (se questi file sono stati ottenuti manualmente per es. con un editing, questi caratteri
< N EW − LIN E > sono stati però scritti non premendo il tasto < N EW − LIN E > (talvolta
indicato con < LF > o < LIN E − F EED > sulla tastiera) ma con un < RET U RN >: la
traduzione in < N EW − LIN E > avviene automaticamente). Le coppie di caratteri

\0

rappresentano i caratteri nulli. Per esaminare il contenuto binario del direttorio corrente dare
il comando:
Altro esempio di paginazione con od: Visualizzazione in esadecimale del documento /etc/rc.

39
olivio@mistral:/etc$ od -x /etc/rc
0000000 2123 622f 6e69 732f 0a68 2023 6f43 7970
0000020 6972 6867 2074 3931 3739 322d 3030 2034
0000040 7041 6c70 2065 6f43 706d 7475 7265 202c
0000060 6e49 2e63 0a0a 202e 652f 6374 722f 2e63
0000100 6f63 6d6d 6e6f 0a0a 7865 6f70 7472 2d20
0000120 206e 6153 6566 6f42 746f 650a 7078 726f
0000140 2074 6e2d 5620 7265 6f62 6573 6c46 6761
0000160 650a 7078 726f 2074 6e2d 4620 6373 536b
0000200 616c 6873 650a 7078 726f 2074 6e2d 4e20
0000220 7465 6f42 746f 0a0a 6669 5b20 2d20 2064
0000240 532f 7379 6574 2f6d 6e49 7473 6c61 616c

7.2 head, tail, sort

Questi comandi permettono di effettuare una selezione da visualizzare all’interno del documen-
to. Rispettivamente i comandi di seguito servono:

• head - visualizza la parte iniziale del documento.

• tail - visualizza la parte finale del documento.

• sort - dispone per ordine alfabetico le linee di un documento di testo.

7.3 Cercare: find, locate, grep

La ricerca di un documento tramite terminale implica l’utilizzo di diversi comandi. Più avanti
in questo manuale descriveremo anche l’implementazione di Apple per le ricerche via terminale
tramite l’utilizzo della tecnologia Spotlight. Al momento ci limiteremo ad offrire una panormica
dei comandi classici per la ricerca.

• find - è estremamente potente, anche se abbastanza lento. E’ lo strumento di ricerca

classico per tutti coloro che usano un OS Unix-like ed è veramente efficace se si vuole un
controllo completo sulla ricerca effettuata oppure se si cerca qualcosa che locate non è

40
 stato ancora in grado di indicizzare . E’ anche largamente obsoleto data la sua lentezza
nelle ricerche.Se proviamo ad effettuare una ricerca del tipo:

olivio@mistral:/etc$ find / -name fstab.hd

/etc/fstab.hd

il terminale cercherà a partire dalla “radice” del disco il documento fstab. All’occorrenza
questa operazione potrà rivelarsi abbastanza lunga.

• locate - è basato su un database statico generato periodicamente dalle operazioni di

mantenimento di OS X. Eventualmente questo comando può essere usato per ricerche su
documenti che rimangono “statici” e non cambiano molto. Il pregio di locate è quello di
essere molto veloce poichè, come già detto, si basa su un database.

• grep - ci permette di effettuare delle ricerche di catene di caratteri presenti in documenti.

Ad esempio:

olivio@mistral:/etc$ sudo grep apple /etc/*

/etc/authorization:&lt;key&gt;com.apple.TestApp.benign&lt;/key&gt;
/etc/authorization:&lt;key&gt;com.apple.TestApp.dangerous&lt;/key&gt;
/etc/authorization: <key>com.apple.</key>
...

In questo caso ho cercato la catena di caratteri apple in tutti i documenti presenti nella
cartella /etc/

7.4 Cercare con Spotlight

Spotlight si dimostra davvero fulmineo nelle sue ricerche. Dalla sua introduzione con Mac OS
X “Tiger” l’algoritmo di ricerca è stato via via modificato per garantire estrema rapidità. Il
principio di funzionamento è quello alla base di molti motori di ricerca: un indice, che viene
aggiornato in maniera continuativa, contiene e lista tutte le informazioni presenti su disco.
Queste informazioni non sono altro che i “metadati” dei documenti. Letteralmente i metadati,

41
 Figura 8: Albero di “metadati”

sono “dati che descrivono dati” e sono cotenuti nell’header di un qualsiasi file indicizzato. Il
file, di per sé, sarà rappresentato sotto forma di “albero” contenente le diverse informazioni.
In questo modo Mac OS X può identificare molto velocemente il tipo di documento e tutte
le informazioni contenute in esso. La ricerca viene dunque effettuata sull’indice e non sul disco
come succedeva nelle precedenti versioni di Mac OS X e soprattutto questo tipo di ricerca è

42
attivabile da qualsiasi applicazione del sistema operativo. La funzione di ricerca dei dati diventa
dunque accessibile ovunque, integrandosi elegantemente con tutte le funzionalità di qualsiasi
processo.

Chi usa la linea di comando per lavorare e cercare i propri documenti, probabilmente usa i
classici comandi locate e find. Come già spiegato, in entrambi i casi i due comandi hanno pregi
e difetti. Per supplire a questo classici comandi, Spotlight introduce una “suite” di comandi da
terminale dimostrandosi veloce e “specifico” nelle sue ricerche se usato correttamente.

7.4.1 Dove cerca Spotlight

Come già accennato, Spotlight si basa su un database di metadati per effettuare le sue ricerche.
Di per sé, Spotlight usa un plugin specifico per ogni applicazione con la quale interagisce. Questo
plugin estrae i dati dal documento dell’applicazione trattata e lo colloca nel suo database. I
cosidetti plug-in “ importatori ” sono contenuti in

/System/Library/Spotlight

/Library/Spotlight

7.4.2 Ricerche da terminale

Una semplice ricerca da linea di comando con Spotlight può essere effettuata in questo modo:

mdfind termine

La ricerca avrà questo risultato:

olivio@mistral:~$ mdfind pino

/Users/olivio/Desktop/Workin’On/ documento.tex

Se vogliamo restringere la ricerca a una cartella specifica l’opzione

43
 mdfind -onlyin

ci sarà utile:

olivio@mistral:~/Desktop$ mdfind -onlyin /Users/olivio/Desktop/mistralG4 pino

/Users/olivio/Desktop/mistralG4/Desktop/Workin’On/JAVA/ Curriculum vitae.tex

Allo stesso modo l’opzione:

mdfind -live

ci permetterà di vivere in tempo reale ogni cambiamento effettuato sui documenti ricercati.
Se vogliamo effettuare ricerche avanzate e più specifiche, un possibile esempio può essere
questo per la ricerca di un particolare autore nella nostra libreria iTunes:

$ mdfind ‘‘kMDItemComposer == ’*Queen*’’’

Come avrete capito passare in argomento più parole chiave alla shell Unix significa mettere
le parole in questione tra virgolette. L’uso di queste convezioni implica una minima conoscenza
degli operatori booleani. Vediamo come funzionano nel caso di Spotlight.

7.4.3 Operatori booleani

Gli operatori booleani sono del tutto simili a quelli descritti tra le espressioni regolari in questo
tutorial:

• il simbolo | indica OR

• il simbolo — indica l’esclusione di un termine

• () crea gruppi

Certamente, all’inizio può sembrare difficoltoso usare queste convenzioni, in compenso si

possono effettuare delle ricerche del tutto personalizzate. Qualche esempio di seguito:

44
 1. $ mdfind ‘‘livio|pino’’
In questo modo cercheremo tutti i documenti che contengono o “livio” o “pino”.

2. $ mdfind ‘‘livio(-pino)’’
cercheremo tutti i documenti contenenti “livio”, ma non “pino”

3. $ mdfind ‘‘(livio|nina) pino’’

cercheremo tutte le ricorrenze di livio o nina in pino

Notiamo in ogni caso che se passiamo un solo parametro al comando le doppie virgolette
non saranno necessarie. Se invece anche una “simple quote” è passata in parametro il comando
mdfind risponderà in questo modo:

$ mdfind l’altro
>

Il terminale attende che la virgoletta sia chiusa per cominciare la ricerca. Quindi effettueremo
la nostra ricerca in questo modo in caso siano presenti delle virgolette nel nostro argomento:

$ mdfind ‘‘l’altro’’

Infine se vogliamo “filtrare” il numero di risultati di mdfind:

$ mdfind Livio | grep -i Nina

Filtreremo i risultati di “Livio” con il comando grep che in questo caso sarà accompagnato
dall’opzione -i affiché sia case sensitive .

7.4.4 Metadata per documenti singoli

Il comando

mdls

elenca i metadati contenuti nel documento passato in parametro. Se osserviamo come un

documento di metadati è composto possiamo migliorare le nostre ricerche.
Se usiamo il comando:

45
olivio@mistral:~/Desktop/Music$ mdls Ani\ difranco.mp3

Il nostro documento metadati conterrà queste infromazioni:

Ani difranco.mp3 -------------

kMDItemAttributeChangeDate = 2006-05-02 19:09:53 +0200
kMDItemAudioBitRate = 128
kMDItemAudioChannelCount = 2
kMDItemAudioSampleRate = 44100
kMDItemContentCreationDate = 2006-04-11 21:50:41 +0200
kMDItemContentModificationDate = 2006-04-11 21:50:41 +0200
kMDItemContentType = ’’public.mp3’’
kMDItemContentTypeTree = (
’’public.mp3’’,
’’public.audio’’,
’’public.audiovisual-content’’,
’’public.data’’,
’’public.item’’,
’’public.content’’
)
kMDItemDisplayName = ’’Ani difranco.mp3’’
kMDItemDurationSeconds = 348
kMDItemFSContentChangeDate = 2006-04-11 21:50:41 +0200
kMDItemFSCreationDate = 2006-04-11 21:50:41 +0200
kMDItemFSCreatorCode = 0
kMDItemFSFinderFlags = 0
kMDItemFSInvisible = 0
kMDItemFSIsExtensionHidden = 0
kMDItemFSLabel = 0
kMDItemFSName = ’’Ani difranco.mp3’’
kMDItemFSNodeCount = 0
kMDItemFSOwnerGroupID = 502
kMDItemFSOwnerUserID = 501

46
kMDItemFSSize = 5583098
kMDItemFSTypeCode = 0
kMDItemID = 479939
kMDItemKind = ’’MP3 Audio File’’
kMDItemLastUsedDate = 2006-04-11 21:50:41 +0200
kMDItemMediaTypes = (Sound)
kMDItemTotalBitRate = 128
kMDItemUsedDates = (2006-04-11 21:50:41 +0200)

Osserveremo che attraverso l’uso attento degli attributi

kMDIdem*

le nostre ricerche potranno diventare più complete e specifiche conoscendo la funzione di

ciascuno di questi.

Invitiamo il lettore ad una lettura delle appendici per un elenco completo degli attributi dei
metadati e delle loro funzionalità.

7.4.5 Controllare Spotlight

Spotlight può essere in parte personalizzabile. Per configurare Spotlight useremo il comando

mdutil

mdimport.

Vediamo cosa può fare mdutil per noi:

1. mdutil può attivare o disattivare l’indexing su un volume:

# mdutil -i off /Volumes/mistral

/Volumes/mistral:
Indexing disabled for volume.

47
 2. può ispezionare le impostazioni su un volume:

# mdutil -s /Volumes/mistral

/Volumes/mistral/:
Status: Indexing Disabled

3. può resettare completamente il database:

# sudo mdutil -E /

mdimport gestisce gli ”importatori” installati sulla nostra macchina:

Ad esempio:
$ mdimport -L
2005-02-26 22:10:53.296 mdimport[268] Paths: id(501) (
’’/System/Library/Spotlight/Image.mdimporter’’,
....
L’opzione -A ci permetterà di listare tutti gli attributi per ciascuno degli importatori.

7.5 Comparare: diff, cmp

Il comando diff ci permette di comparare linea per linea due documenti di testo. Ad esempio:
olivio@mistral:/$ diff hola hola1
1,2c1
< cicciobello
<
---
> cicciobelli
Chiedo al terminale di comparare i due documenti passati in parametro, hola, hola1. diff
mi mostrerà in cosa i due documenti differiscono. In egual misura il comando cmp ci permette
la comparazione di due documenti ottetto per ottetto. Ad esempio:
olivio@mistral:/$ cmp hola hola1
hola hola1 differ: char 11, line 1

48
7.6 Comandi vari: split, touch, du, wc...
• split - ci permette di dividere un documento testo in più parti.

• touch - cambia la data di ultima modifica di un documento verso la data instantanea. Ad

esempio:

olivio@mistral:/$ ls -l hola
-rw-r--r-- 1 olivio admin 13 Oct 29 18:34 hola
olivio@mistral:/$ date
Sun Oct 29 18:44:11 CET 2006
olivio@mistral:/$ touch hola
olivio@mistral:/$ ls -l hola
-rw-r--r-- 1 olivio admin 13 Oct 29 18:44 hola

Osserviamo in questo caso (tramite l’uso del comando ls- l) come il file hola abbia cambiato
la data di creazione.

• du - calcola la dimensione approssimativa di un documento o di una cartella (in maniera

ricorsiva per le cartelle).

• wc - calcola il numero di linee, di parole e di caratteri in un documento.

49
Parte IV

Gli editor di testo

Molti editor di testo sono presenti di default in Mac OS X. Tra questi il più classico è “vi”
o “vim”. Pur essendo estremamente potenti questi editor di testo sono abbastanza difficili da
utilizzare e richiedono una certa esperienza. Affinché la vostra prima volta con un editor di
testo Unix non si riveli disastrosa, vi consiglio di utilizzare il più semplice “nano” o “emacs”.
Generalmente la sintassi da utilizzare per l’apertura o la creazione di un documento è quasi
sempre la stessa. Usiamo ad esempio l’editor nano per aprire il documento “miodocumento.txt”:

% nano miodocumento.txt

Nel caso questo documento non esista, nano ne creerà uno con tale nome. Nano ha il
vantaggio di essere abbastanza trasparente verso l’utente. In basso troverete una tool bar
testuale con una lista delle combinazioni tastiera da utilizzare per effettuare le diverse operazioni
sui documenti.
A chi vuole invece conoscere il funzionamento di uno dei più classici e potenti editori di
testo presenti da sempre su Unix consigliamo la lettura della prossima sezione.

8 VI, VIsual Editor

Il termine Vi sta per VIsual editor ; si tratta di uno degli applicativi più conosciuti nel mondo
Unix per editare in full screen i testi. Sviluppato dall’Università della California a Berkeley Vi
è un editor di testo molto potente e flessibile nato per soddisfare le esigenze di immediatezza
e semplicità del programmatore. Questa filosofia di sviluppo non impedisce a Vi un uso più
ampio, insclusa la formattazione del testo o più in generale l’inserzione di testi non impaginati.
Detto questo possiamo capire bene come Vi non sia un word processor data la sua complessità
di utilizzo. Vi non fornisce alcun tipo di aiuto online durante il suo impiego e, per quanto
la documnetazione fornita con esso sia davvero molto completa, questa serve solo dopo aver
appreso in minima parte i principi di funzionamento di tale strumento.
Le sezioni che seguono introducono a Vi cercando di far apprendere al lettore una parte dei
comandi di questo editor. In sé stesso Vi si dimostra molto potente e permette praticamente di

50
tutto. Un’ulteriore volume appropriato all’apprendimento di Vi può essere il tutorial interattivo
presente in ogni distribuzione.

8.1 Avvio
Come già spiegato in introduzione, per richiamare l’editor Vi, sarà necessario inserire il comando
vi e successivamente il documento da trattare o da creare.

jobs@mistral:~$ vi documento

L’esistenza o meno del documento passato in argomanto farà si che Vi si comporti in due
modi diversi. Nel primo caso vi aprirà il documento in questione proponendone l’editing. Nel
secondo Vi creerà un documento nuovo. Se il documento passato in argomento è invece già in
stato di editing in un altro terminale, Vi chiederà all’utente le opzioni riportate in figura.

Figura 9: Comportamento di Vi a seconda dell’esistenza o meno del documento passato in

argomento.

Nel nostro primo utilizzo di Vi, quest’ultimo non è certamente preconfigurato e lo schermo
ci appararirà in questo modo:

~
~
~
~
"doc" [New File]

51
 É del tutto normale che l’editor non sia preconfigurato. Spiegheremo in uno dei paragrafi
di seguito come configurare correttamente il proprio editor di testo. Le righe che vediamo
rappresentate sotto forma di :

sono righe di schermo atte a delimitare le zone di testo inseribili; quindi non si tratta di righe
di file, ma essenzialmente, righe oltre l’ End of File . L’ultima riga che precede immediatamente
queste è l’ultima riga del buffer in questione.

8.2 Modalità
Vi è un editor di testo che funziona secondo la modalità di utilizzo in cui si trova. I due
principali stati o mode sono:

• command mode (modalità comandi

• input mode / append mode (modalità inserzione

Per editare sarà necessario impartire i comandi con Vi nel primo stato, mentre per inserire
nuovo testo Vi dovrà trovarsi nel secondo stato.
Al momento dell’invocazione di Vi, l’editor si pone all’utente in modalità comandi. Per
passare dalla modalità inserzione alla modalità comandi sarà necesario premere il tasto :

<ESC>

Vi non mostra mai a schermo in quale modalità si trova quindi, in caso di incertezza, sarà
utile premere comunque il tasto ESC. Il tasto in questione, dato in modalità comandi elimina
eventuali comandi già presenti in buffer e di cui, quindi, la scrittura non è stata portata a
termine; se invece alcun comando di tipo parziale è stato imparito, Vi emette una segnalazione
acustica.
Riepilogando:

• modalità comandi → modalità inserzione:

i, I, a, A, o, O, s, c

52
 • modalità inserzione →modalità comandi:

ESC

Essenzialmente, in modlità inserzione, si può solo inserire del testo o impartire il comando
ESC: per spostarsi nel testo, dunque, avremo bisogno di un particolare set di comandi che
vedremo più avanti.

8.3 Terminare Vi
Per terminare il processo Vi è necessario usare il comando:

ZZ

Ovviamente per attuare il comando sarà necessario essere in modalità comandi. In questa
modalità alcune considerazioni possono tornare utili:

• ricordiamoci che Unix è case sensitive . ZZ non è uguale a zz.

• in modalità comandi, i comandi non vanno mai seguiti dal tasto:

<RETURN>

poiché appena completati sono eseguiti da Vi automaticamente.

• durante la digitazione del comando a schermo non viene presentato niente. Nel caso di
un comando a doppia lettera come ZZ, se digitiamo la prima Z Vi non presenterà niente
a schermo.

8.4 I comandi Vi di inserimento

I comandi Vi di inserimento sono attuabili unicamente in modalità inserzione e permettono
di modificare il testo aggiungendo alla composizione i caratteri desiderati in una posizione
specifica.

53
8.4.1 Inserire prima del cursore

Il comando classico per passare in modalità inserzione è

Il testo è inserito prima del carattere che interessa il cursore. Anche in questo caso Vi, nel
passaggio in questa modalità, non mostrerà alcunché a schermo. I caratteri digitati dopo “i”
verrranno dunque scritti nel buffer di Vi per essere poi salvati unicamente alla pressione del
tasto ESC per tornare in modalità comandi.
Un breve esempio di sessione Vi :
Supponiamo di voler creare il documento prova aggiungendo due righe di testo:

• jobs@mistral:~$ vi prova
seguito dal tasto RETURN

• i :
passiamo in modalità inserzione aggiungendo un “:” seguito dal tasto RETURN per
andare a capo.

• prova
seguito dal tasto ESC e dal comando ZZ

Vi si presenterà come di seguito in modalità inserzione:

:
prova
~
~
~
~
-- INSERT --

54
8.4.2 Cancellazione dei caratteri

Usando semplicemente il tasto:

<DELETE>

è possibile cancellare uno o più caratteri tra quelli appena battuti, ovviamente in modalit
à inserzione. In Vi il risultato dell’uso del suddetto tasto può risultare non proprio chiaro: il
cursore arretra verso sinistra di un carattere ma non cancella dallo schermo il carattere voluto.
Affinché avvenga, in realtà, una “sostituzione” basta premere il carattere che si vuole immettere
al posto di quello preso in esame da Vi nell’arretramento.
Inoltre alcune considerazioni sull’uso del tasto DELETE in Vi ci sembrano doverose:

• il tasto DELETE si può usare solo in modalità inserzione. Per cancellare testo in modalità
comandi si usano altre combinazioni da tastiera.

• il tasto DELETE cancella solo i caratteri che sono stati inseriti dopo l’ultima inserzione
nel buffer o, se vogliamo, dopo l’ultima richiesta di inserzione.

• se vogliamo effettuare la cancellazione di un’intera catena di caratteri (parola) precedente,

è possibile usare la combinazione:

<CTRL-W>

8.4.3 Cancellazione delle righe

Per la cancellazione delle righe in Vi si può ricorrere alla combinazione:

<CTRL-U>

Questo in caso ci si trovi con il cursore sulla riga effettivamente interessata. Ovviamente
questa combinazione non implica mai la cancellazione di un testo la cui inserzione si avvenuta
prima dell’ultima operazione effettuata. Se, ad esempio , l’inserzione del testo è avvenuta
quando una riga è già stata inserita in precedenza, questa combinazione di tasti non cancellerà
tutta la riga, ma solo quella nuova, dunque corrente .

55
8.4.4 Uso delle frecce

A questo punto, è essenziale parlare dell’uso dei tasti freccia. I tasti freccia non possono
essere usati in modalità inserzione, poiché alcun comando è compreso da Vi se posto in tale
configurazione. I tasti freccia non fanno parte della tastiera alfanumerica di base e, dunque,
questo genere di tasti equivalgono ad una sequenza di caratteri. Una tale sequenza è chiamata
escape sequence ed inizia sempre con il carattere ESC. Vi, dunque, interpreta l’uso dei tasti
freccia come un ESC con, in aggiunta, un altro carattere: di conseguenza uscirà prima dalla
modalità inserzione e poi cercherà di interpretare il carattere dopo l’ESC.
Generalmente, il risultato dell’uso dei tasti freccia, è non voluto o erroneo.

8.4.5 Inserzione del testo a inizio e fine riga

Per l’inserzione del testo a inizio o a fine riga si usa il comando:

insert , maiuscolo in questo caso. Questo comando è equivalente a una coppia di comandi:

1. porta al primo carattere che non sia:

<SPAZIO> <TAB>

2. effettua un’inserzione di testo all’inizio della riga corrente, come se usassimo il tazto “i”
di inserzione classica

In maniera parallela, il comando:

abbreviazione di append , inserisce al termine della riga corrente.

In ogni caso, l’uso di entrambi i caratteri, porta in modalità inserzione.

56
8.4.6 Creazione di una nuova riga

Prendiamo in considerazione i comandi:

o, O

Questi permettono di inserire una nuova riga tra due altre già scritte. Se, infatti, in modalità
inserzione si continua a scrivere andando a capo ad ogni fine riga usando il tasto RETURN,
inseriremo un testo su più righe.
Useremo, dunque, i comandi ’o’ oppure ’O’ open . Il comando ’o’ minuscolo, stipula una
riga sotto quella corrente in maniera del tutto indipendente dalla posizione del cursore su
quest’ultima e, ovviamente, mette Vi in modalità inserzione. Al termine dell’operazione si pùo
tornare in modalità comandi premendo, al solito, il tasto ESC.
Se invece, l’ obiettivo, è quello di aprire una nuova riga sopra la corrente possiamo usare il
comando ’O’ maiuscolo. Allo stesso modo termineremo l’operazione con il tasto ESC.

8.5 I comandi Vi di spostamento

Appurato che i tasti freccia non ci sono utili per spostarci nel testo, introduciamo di seguito una
serie di comandi per spiegare come il cursore possa essere posizionato all’interno delle nostre
catene di caratteri usando Vi.

8.5.1 Spostamenti unitari: caratteri o righe

In modalità inserzione, il modo più semplice ed immediato per spostarsi di un carattere o di

una riga è l’uso dei comandi seguenti:

• ←: h sposta il cursore a sinistra di un carattere.

• →: l sposta il cursore a destra di un carattere.

• ↓: j sposta il cursore alla riga seguente.

• ↑: k sposta il cursore alla riga precedente.

57
 Figura 10: La disposizione dei tasti di spostamento in Vi

Ad un primo impatto, la scelta di tali lettere per lo spostamento, può sembrare poco intui-
tiva; potremo osservare, in seguito, come i tasti enunciati sono disposti “strategicamente” sulla
tastiera e quindi la loro posizione risulterà, con il passare del tempo, del tutto naturale.
Ovviamente faremo attenzione ad usare esclusivamente caratteri minuscoli.
Il terminale di Mac OS X, nello specifico, supporta i tasti freccia; al posto dei quattro
comandi sopra indicati è probabile che possano essere impegati i tasti speciali per ottenere
lo stesso effetto. Ricordiamo che Vi è stato progettato per una totale indipendenza dai tasti
speciali della tastiera. É consigliato, dunque, assecondare questa filosofia evitando i tasti freccia.
Inoltre, Vi, prevede anche dei comandi speciali per l’equivalenza delle freccie:

• ←: CT RL − H sposta il cursore a sinistra di un carattere.

• →: SP AZIO sposta il cursore a destra di un carattere.

• ↓: CT RL − J oppure CTRL-N sposta il cursore alla riga seguente.

• ↑: CT RL − P sposta il cursore alla riga precedente.

8.5.2 Inizio e fine riga

Il comando:

58
(zero), porta il cursore sul primo carattere della riga corrente. Il comando:

porta al primo carattere che non sia < SP AZIO >< T AB > della riga in questione.
Il comando:

porta il cursore sull’ultimo cursore sul primo carattere della riga corrente.

8.5.3 Ricerca di un carattere nella riga

Con Vi è possibile portare direttamente il cursorse su un carattere specifico della riga corrente.
É possibile, altresı̀, portarsi anche su una stringa specifica appartenente alla riga corrente. I
comandi presentati di seguito sono:

• “f” - comando find seguito da un carattere porterà il cursore sulla prima occorrenza del
carattere sulla riga.

• “F” - ricerca il caratere specificato nella riga corrente escludendo il carattere specificato
sempre nella riga corrente e, dunque, escludendo il carattere sotto il cursore.

• “t” - molto simile al comando “f”, ma in questo caso il cursore si sposta sul carattere che
precede quello ricercato.

Alcuni esempi :

• nel caso si applichi il comando:

fO

sulla stringa di caratteri “Mara Olivio Nina”, il cursore si porterà sulla prima occorrenza
del carattere. Sempre sullo stesso esempio, se il cursore si trova inizialmente su una
delle lettere centrali della stringa, esso proseguirà sino a trovare la giusta occorrenza del
carattere specificato.

59
 • nel caso si applichi il comando:

tF

sempre sulla stessa stringa di caratteri riportata nel precedente esempio, il cursore si
porterà sullo

<SPAZIO>

precedente alla “O” di Olivio.

I comandi citati possono essere resi più potenti, facendoli precedere da un contatore: in
questo modo indicheremo a Vi quante volte deve essere ripetuta la ricerca del carattere in
questione sulla riga.
Ricordiamo inoltre che il comando:

ha come funzione quella di ricercare ancora una volta la ricerca iniziata con uno dei comandi
“f” o “F”, usando lo stesso carattere di ricerca sulla stessa riga.
Allo stesso modo, il comando:

effettua le stesse operazioni che il comando “;”, ma in questo caso effettua la ricerca in direzione
opposta all’ultimo comando di ricerca.

8.5.4 Spostamenti a parole

Il comando:

word , consente lo spostamento di una “parola” o stringa di caratteri e, dunque, il movimento

viene effettuato in maniera automatica nella riga successiva. Allo stesso modo il comando:

è identico a “w”. In questo caso, però, la “parola” è delimitata solo da spazi, TAB e fine
riga.

60
8.5.5 Spostamenti a righe

Vi permette lo spostamento anche tramite righe in un file di testo. I comandi:

con il consueto uso, opzionale, di un contatore servono a questo scopo. Il cursore si spsoterà,
in generale, sul primo carattere diverso dallo SPAZIO e dal TAB presente sulla riga in questione.

8.5.6 Spostamenti a pagine

Per lo spostamento a pagine si usa la combinazione sintattica:

CTRL - *

che consente lo spostamento verso la fine o verso l’inizio del file a pagina intera di testo o a
mezze pagine .
In sintesi:

Combinazione Uso
CTRL-F (forward) avanti di una pagina intera
CTRL-B (backward) indietro di una pagina intera
CTRL-D (down) avanti di mezza pagina
CTRL-U (up) indietro di mezza pagina

In questo caso l’uso di un contatore non ha lo stesso significato delle precedenti sintassi usate
fin qui. Un contatore che precede le prime due combinazioni descritte indica di quante pagine
ci si deve spostare. Il contatore che precede le ultime due combinazioni nell’ordine rappresenta
il numero di righe di cui si deve spostare il cursore con il corrente e la prossima occorrenza di
combinazione tastiera che non specifichi contatore.

61
8.5.7 Spostamenti ad inizio e fine documento ed ad un numero di riga specificata

Questo genere di spostamento implica l’uso del comando:

G
In carattere maiuscolo, significa letteralmente go . In questo modo ci si sposta all’inizio della
riga richiesta. Ad esempio: Volendo spostarsi alla riga 578 di un documento, impartiremo il
comando:
578G
Sarà dunque facile spostarsi all’inizio del documento usando il comando:
1G
Al contrario useremo questa sintassi:
$G
In questo caso indicheremo a Vi lo spostamento a fine documento.
Nel caso volessimo conoscere il numero della riga sulla quale stiamo lavorando, useremo la
combinazione CTRL-G . Vi ci riporterà in basso della nostra schermata:
"documento" [Modified] line 3 of 3 --100%-- col 2
Nel nostro esempio, la riga in questione è la numero 3. Ci possiamo rendre conto che il
metodo per la visualizzazione del numero di riga, cosı̀ implementato, non è pratico per chi,
ad esempio, volesse conoscere il numero di linea molto spesso. É allora possibile editare la
configurazione dell’editor per implementare questa funzionalità. In modalità comandi:
:set number
o, in maniera concisa:
:se nu
seguito da un RETURN . Per tornare alla configurazione “classica” useremo il comando:
:set nonumber
o, ancora una volta, sinteticamente:
:se non

62
8.5.8 Ricercare nel testo: stringhe

Vi consente di effettuare la ricerca di stringhe di testo. Il “classico” comando per la ricerca è:

Appena viene premuto il suddetto tasto il cursore si porta sull’ultima riga dello schermo e
l’utente sarà invitato ad inserire la stringa ricercata. Termineremo la redazione della nostra
stringa con un RETURN .
Vi appare in questo modo, in funzione di ricerca:

pippo
pluto
paperino
~
~
~
/pluto

Troveremo il cursore direttamente su ”pluto“, alla fine della ricerca.

Ricordiamo una piccola eccezione alla regola di VI che impedisce di usare comandi seguiti
da un RETURN in modalità comandi. Nel nostro caso specifico, sarà sempre necessario usare
il RETURN ogni volta che terminiamo una stringa in modalità ricerca, cosa ovviamente non
necessaria usando altri comandi presenti in Vi.
Un esempio , può essere l’usodi una stringa con caratteri nella nostra stringa di ricerca:

/Steve Jobs

L’editor cercherà una stringa seguita da uno spazio e da un’altra stringa, tutti e tre sulla
stessa riga. La ricerca è, al solito, case sensitive e continua automaticamente dall’inizio fino al
raggiungimento del punto di partenza. Se dopo aver effettuato uan riceca su tutto il file, fino
al ritorno al punto corrente, la stringa non è stata trovata. Vi lo segnalerà in questo modo:

E486: Pattern not found: parola_cercata

63
 Una volta impostata la ricerca, la stringa ricercata rimane memorizzata nel corso dell’intera
sessione di lavoro. Non sarà dunque necessario reimpostare la ricerca ogni qualvolta si vuole
ricominciare la ricerca della stessa stringa: basterà a questo scopo impartire il comando:

Sulla stessa linea, il comando:

Next, ha la stessa funzione di “n”, next, ma la ricerca si svolgerà, in questo caso, in inversamente
al senso del documento. Una volta arrivati ad inizio documento, la ricerca ricomincierà dal fondo
dello stesso.
Con il comando:

abbiamo già detto che la ricerca va dal punto corrente verso la fine del documento. Volendo,
però, iniziare la ricerca nell’altra direzione, possiamo usare il comando:

al posto del ’/’. Una volta impostate la ricerca con il punto interrogativo il significato dei
comandi “n” e “N” sarà invertito: “n” cercherà la prossima occorrenza all’indietro, “N” in
avanti.
La ricerca è, al solito, case sensitive . É possibile, in questo caso, richiedere una ricerca che
non sia case sensitive usando il comando:

:set ignorecase<RETURN>

Al contrario, volendo ripristinare il case sensitive :

:set noignorecase<RETURN>

64
8.6 I comandi Vi di cancellazione
8.6.1 Cancellazione di caratteri

Il comando:

cancella il carattere in trattamento da parte del cursore. È possibile anche cancellare più
caratteri facendo precedere “x” con il numero di caratteri da cancellare.
Del tipo:

3x

Nell’esempio: ...visulaeditor → ...ualeditor

Il cursore, trovandosi sulla “v” di visualeditor , il comando 3x porterà alla cancellazione della
stringa “vis”. Al termine dell’operazione il cursore si troverà sulla “u” della stringa risultante.
Ricordiamo che il comando:

canacella il carattere alla sinistra del cursore, e come “x” può essere preceduto da un contatore.

8.6.2 Cancellazione parole, righe e altre unità di testo

Il comando:

sta per delete e si compone di una seconda parte che definisce un comando di movimento. “d”
realizza la cancellazione della parte di testo che va dalla posizione corrente del cursore fino alla
posizione che il cursore andrebbe ad assumere con il comando di movimento impostato.
Ad esempio:
La catena di caratteri:

...uno due tre quattro

_

usando il comando:

65
3w

effettuerà uno spostamento in questo modo:

...uno due tre quattro

_

Volendo cancellare la parte di testo definita dallo spostamento, il comando sarà:

3dw

e il testo risultante sarà:

... due tre quattro

_

Se il carattere numerico viene omesso nel comando in questione, Vi lo intenderà come un

comando di tipo unitario.
Con “d” la cancellazione dei caratteri può continuare anche nelle righe seguenti o precedenti.
Ad esempio: Sul testo seguente:

uno due tred

tre quattro cinque sei

se il cursore si trova sulla “d” di “due”, il comando:

2dw

produrra l’effetto seguente:

uno
tre quattro cinque sei

Sullo stesso testo :

uno due tred

tre quattro cinque sei

66
il comando:
3dw
avremo:
uno quattro cinque sei
I comandi di movimento classicamente associati al comando di cancellazione sono in genere:
w, W
b, B
t
f
oppure i comandi di ricerca di tipo pattern:
/
?

8.6.3 Cancellazione righe intere

La cancellazione di righe intere avviene con il comando:

dd
la posizione del cursore è del tutto indifferente. Se il comando è preceduto da contatore, sul
genere:
5dd
allora verranno cancellate completamente la riga corrente e in seguito le sequenti pari a 5.

8.6.4 Cancellazione della parte finale di una riga

Ciò avviene con il comando:

D
In questo modo verrà eliminata la parte di riga che va dal carattere trattato dal cursore sino al
termine della riga. Alla fine dell’operazione il cursore rimarrà sull’ultimo carattere della riga o
all’inizio della riga in caso tutti i caratteri della riga siano stati cancellati.

67
8.6.5 Ripristino righe cancellate

Vi conserva dei registri numerici ; una specie di cache che contiene le parti di testo cancellata
dall’utente. In questo modo Vi, tramite il comando:

oppure

La memorizzazione temporanea nei registri numerici non viene alterata dai comandi di sposta-
mento; ciò significa che non solo una riga appena cancellata può essere ripristinata, ma ciò può
essere fatto in un punto diverso da quello dove le righe si trovavano originariamente.
Il comando “p” stampa le righe appena cancellate sotto la riga corrente, mentre il comando
“P” le stampa al di sopra. Nel caso di questi comandi, la funzione contatore classico non esiste.
Al contrario possono essere ripetuti n volte, del tipo:

pppppppp

68
Parte V

I processi
9 Gestione dei processi
I processi su Unix vengono gestiti da una serie di comandi specifici e permettono di interagire
con le applicazioni o i demoni lanciati sulla macchina.

9.1 Visualizzare i processi: ps e top

• ps - permette di visualizzare lo stato istantaneo dei processi in corso:

olivio@mistral:~$ ps
PID TT STAT TIME COMMAND
288 p1 S 0:00.17 -bash
395 p1 S 0:00.02 su
olivio@mistral:~$

• top - è un’utilità di sistema interattiva che permette -similmente a ps- la visualizzazione

dei processi, pur essendo nettamente più potente data la sua capacità di aggiornamento
istantaneo.

Processes: 54 total, 2 running, 52 sleeping... 164 threads

Load Avg: 0.37, 0.18, 0.11 CPU usage: 4.7% user, 4.7% sys, 90.7% idle
SharedLibs: num = 166, resident = 43.5M code, 6.57M data, 16.1M LinkEdit
MemRegions: num = 5193, resident = 89.5M + 14.1M private, 99.9M shared
PhysMem: 113M wired, 166M active, 250M inactive, 530M used, 1005M free
VM: 5.19G + 129M 31632(1) pageins, 0(0) pageouts

PID COMMAND %CPU TIME #TH #PRTS #MREGS RPRVT RSHRD RSIZE VSIZE
410 top 6.8% 0:00.56 1 18 20 720K 860K 1.16M 26.9M
406 TextEdit 0.0% 0:01.98 2 103 127 2.34M 8.50M 6.57M 220M

69
 401 lookupd 0.0% 0:00.02 2 34 36 372K 1.05M 968K 28.1M
395 bash 0.0% 0:00.01 1 14 17 216K 1.23M 796K 27.1M
394 su 0.0% 0:00.01 1 18 44 172K 1.31M 2.00M 27.2M
358 mdimport 0.0% 0:00.85 4 65 96 1.35M 4.50M 3.35M 65.1M

9.2 Lancio dei processi

• nice - permette di passare in parametro la priorità di un processo al suo lancio.

• renice - la priorità del processo viene ri-passata in parametro ad un processo già attivo.

La gestione dei processi in Unix o comunemente scheduler organizza l’esecuzione dei processi in
base ad un certo livello di priorità. Tale priorità viene calcolata dal sistema in base al tipo di
processo, al suo comportamento e ad una variabile additiva che in questo tutorial chiameremo
nice .
I valori correnti di priorità e NICE per i processi possono essere visualizzati con il comando
ps con l’opzione -l (si veda la sezione dedicata al comando). Purtroppo non c’è uniformità sulla
gamma di valori per queste due variabili. La priorità potrebbe per esempio essere un intero di
due cifre variabile tra 0 e 39 o tra -20 e 20. L’unica certezza è che più alta è la priorità piú
lentamente viene eseguito il processo. Inoltre la variabile nice viene in qualche modo sommata
nel calcolo della priorità, per cui priorità e NICE elevati implicano esecuzione piú lenta del
processo.
Ad esempio:

$ nice gcc titti.c &

Quando viene creato un nuovo processo, alla variabile NICE viene assegnato un valore inter-
medio (20 nel caso di gamma 0/39 o 0 nel caso -20/20) a meno che l’utente non richieda una
variazione con il comando nice.
Ad esempio: Se si desidera semplicemente ridurre il peso di un comando sul sistema si
preceda il comando con un nice senza alcuna specificazione numerica mentre se si desidera far
girare un processo alla minima priorità si potranno dare i comandi

70
$ nice -20 gcc titti.c & # Bourne shell
%nice +20 gcc titti.c & # C shell

9.3 Interruzione dei processi: kill

Il comando kill termina forzatamente un processo.

olivio@mistral:~$ ps
PID TT STAT TIME COMMAND
288 p1 S 0:00.17 -bash
395 p1 S 0:00.03 su
421 p1 S+ 0:00.01 nano
424 p2 S 0:00.03 -bash
olivio@mistral:~$ sudo kill 421
Password:
olivio@mistral:~$ ps
PID TT STAT TIME COMMAND
288 p1 S 0:00.17 -bash
395 p1 S+ 0:00.03 su
424 p2 S 0:00.03 -bash
olivio@mistral:~$

In questo caso osserviamo la terminazione del processo nano con PID 421. Con un secondo ps
osserviamo l’assenza di nano tra i processi attivi.

9.4 Pianificazione dei processi: at, atq, atrm

Per pianificare i processi esistono tre comandi principali:

• at - lancia il comando alla data indicata.

• atq - visualizza la lista dei lavori in attesa di esecuzione.

• atrm - cancella un lavoro in attesa di esecuzione.

71
Ad esempio:
Supponiamo di voler eseguire una lista di comandi in un momento preciso della giornata.
Scriveremo questi comandi in un documento di testo chiamato ad esempio “Programmazione”.

date >Stato.txt
who >>Stato.txt
ps >>Stato.txt

A questo punto dalla nostra shell:

Diamo i diritti di esecuzione al documento “Programmazione”.

olivio@mistral:~$ chmod +x Programmazione

Usiamo il comando at per pianificare la sua esecuzione.

olivio@mistral:~$ at 0815 <Programmazione

job 1 at Thu Nov 2 08:15:00 2006

Controlliamo l’effettiva pianificazione del documento con il comando atq.

olivio@mistral:~$ atq
1 Thu Nov 2 08:15:00 2006
olivio@mistral:~$

Con il comando at assegnamo alle 8:15 l’esecuzione dello script Programmazione. Il risultato
sarà:

olivio@mistral:~$ atq
1 Thu Nov 2 08:15:00 2006
olivio@mistral:~$ date
Thu Nov 2 08:315:00 CET 2006
olivio@mistral:~$ cat Stato.txt
Thu Nov 2 08:315:00 CET 2006
olivio console Nov 1 19:16
olivio ttyp1 Nov 1 21:17
olivio ttyp2 Nov 1 22:37

72
 PID TT STAT TIME COMMAND
288 p1 S 0:00.17 -bash
395 p1 S+ 0:00.04 su
470 p2 S 0:00.02 -bash
493 p2 S+ 0:00.00 -bash
olivio@mistral:~$ atq
olivio@mistral:~$

Ossrviamo che alla data specificata il comando è stato eseguito e che rieseguendo il comando
atq non viene più mostrato alcun lavoro da eseguire.

9.5 Pianificazione dei processi avanzata

• batch - esegue i comandi quando il carico del processore è inferiore a un valore limite.

• crontab - pianifica i comandi ripetitivi gestiti dal programma cron.

Un esempio con crontab:

Per effettuare una programmazione ci serve un documento di programmazione cron per -ad
esempio- due comandi ripetitivi. Chiameremo questo documento ProgrammazioneCron.

* * * * * date >>/home/olivio/Cronometro.txt
30 12 1 1 * who

In questo caso eseguiamo ogni minuto il comando date con registrazione del risultato di esecu-
zione in un documento testo Cronometro.txt. Al trentesimo minuto della dodicesima ora del
primo giorno di ogni primo mese dell’anno vogliamo che venga eseguito questo comando.

olivio@mistral:~$ crontab ProgrammazioneCron

olivio@mistral:~$ crontab -l
* * * * * date >>/home/olivio/Cronometro.txt
30 12 1 1 * who
olivio@mistral:~$ cat Cronometro.txt
Su 25 Aug 2006, 08:56:01 (UTC+0200)

73
Su 25 Aug 2006, 08:57:01 (UTC+0200)
Su 25 Aug 2006, 08:58:01 (UTC+0200)
Su 25 Aug 2006, 08:59:01 (UTC+0200)
olivio@mistral:~$

Osserviamo come il documento Cronometro elenchi ogni minuto il risultato voluto.

9.6 Esecuzione in background

In tutti gli esempi visti finora l’utente dava un comando (anche composto da una pipeline) e
la shell restituiva il controllo all’utente solo al termine dell’esecuzione del comando richiesto o
comunque solo dopo la sua interruzione definitiva.
Unix è un OS multitasking, e come tale offre un semplice mezzo per eseguire processi
in“background” cioè in modo che pur continuando ad eseguire, non impediscano all’utente di
lanciare altri comandi (magari anche questi in background).
Ad esempio. Volendo compilare il documento titti.c :

$ gcc titti.c

Dato in questo modo (in foreground) il controllo della shell tornerà all’utente solo al termine
della compilazione. Per ottenere l’esecuzione in background basta terminare il comando in
questo modo’:

$ gcc titti.c &

3482
$

Appena dato il comando, viene stampato un numero ed il controllo torna immediatamente

all’utente. Il numero è il PID del processo generato. Lo si può anche accertare richiedendo lo
stato dei processi con il comando ps:

74
$ ps
PID TT STAT TIME COMMAND
3354 00 S 0:13 -ksh (ksh)
3475 00 S 0:00 gcc titti.c
3482 00 R 0:00 ps

75
Parte VI

Gestire gli accounts

10 I comandi id, groups e finger
• id - visualizza le informazioni sull’account attivo. Ad esempio:

olivio@mistral:/$ id
uid=501(olivio) gid=501(olivio) groups=501(olivio), 81(appserveradm),
79(appserverusr), 80(admin)

• groups - allo stesso modo groups visualizza i gruppi ai quali appartiene l’utilizzatore
attivo.

olivio@mistral:/$ groups
olivio appserveradm appserverusr admin

• finger - visualizzerà le informazioni disponibili sull’utilizzatore.

olivio@mistral:/$ finger
Login Name TTY Idle Login Time Office Phone
olivio olivio *con 10:52 Sun 08:12
olivio olivio p1 Sun 18:09
olivio olivio p2 10 Sun 10:14
olivio olivio p3 2:02 Sun 10:23

11 Il documento passwd
Il documento passwd (collocato in /etc/passwd) si occupa di gestire e di recuperare utilizzatori
e gruppi di entità presenti sul sistema. Questo documento, presente su tutti i sistemi Unix,
non ha alcune effetto su Mac OS X. Chi non sia interessato al suo utilizzo può passare diret-
tamente alla sezione successiva dove descriveremo la gestione delle sue caratteristiche tramite
altre metodologie. passwd appare in questo modo:

76
nobody:*:-2:-2:Unprivileged User:/:/usr/bin/false
root:*:0:0:System Administrator:/var/root:/bin/sh
daemon:*:1:1:System Services:/var/root:/usr/bin/false
uucp:*:4:4:Unix to Unix Copy Protocol:/var/spool/uucp:/usr/sbin/uucico
lp:*:26:26:Printing Services:/var/spool/cups:/usr/bin/false

Ciascuna linea corrisponde ad un utilizzatore descritta ciascuna da sette campi separati da

’:’ :

1. login (in chiaro)

2. password (criptata)

3. numero d’utilizzatore (UID)

4. numero di gruppo (GID)

5. descrizione

6. radice per l’utente

7. shell

11.1 Gestire gli utilizzatori

Previa utilizzazione del comando :

passwd

che ci permette di cambiare la password di un utilizzatore, i comandi principali per gestire

gli utenti che hanno accesso al sistema sono :

• useradd - creazione di un utente, della sua directory principale (con autorizzazione) e

copia dei documenti di configurazione in questa cartella.

• userdel - cancella un utente

• usermod - modifica delle caratteristiche di un utente

Infine il comando pwck verifica infine la coerenza dei documenti /etc/passwd e /etc/shadow

77
11.2 Gestione dei gruppi
I gruppi vengono gestiti attraverso tre principali comandi:

• groupadd - crea un gruppo

• groupdel - cancella un gruppo

• groupmod - modifica le caratteristiche di un gruppo

Infine il comando grpck verifica la coerenza dei cocumenti /etc/passwd e /etc/shadow

Esempio:

root@mistral:/home/olivio# groupeadd fisica

root@mistral:/home/olivio# useradd -g fisica fermi
root@mistral:/home/olivio# passwd fermi
Enter new UNIX password:
Retype new UNIX passowrd:
passwd : the password has succesfully changed
root@mistral:/home/olivio#

In questo esempio nel nostro documento passwd sono state aggiunte queste linee:

fermi:x:1001:1001::/home/fermi:/bin/sh

In /etc/shadow :

fermi:$1$OiUYxLOq$97N3L1zEHtnjalbwceUyl0:13384:0:99999:7:::

In /etc/group :

physiciens:x:1001:fermi

In /etc/gshadow :

physiciens:!::fermi

78
12 Mac OS senza passwd ?
Come già precisato, Mac OS, pur includendo un documento passwd, questo non è sfruttato dal
sistema se non quando si è in modalità “single user“. Se si vogliono sfruttare queste funzionalità
bisognerà accedere al database NetInfo, un “repository” delle informazioni della local directory.
La maniera più semplice di aggiungere un utente o un gruppo al proprio sistema Mac OS è
l’utilizzo del comando niload:

% sudo niload passwd . <<EOF

? mariano:*:701:20::0:0:Olivio Mariano:/Users/mariano:/bin/tcsh
? EOF

Dopo aver creato il nuovo utente (in questo caso mariano), sarà necessario settare la pas-
sword. In questo caso useremo il comando ditto per creare la cartella home e settare i privilegi
correttamente:

% sudo passwd mariano

Changing password for mariano.
New password: ********
Retype new password: ********

E successivamente:

% sudo ditto -rsrc \

/System/Library/User\ Template/English.lproj \
/Users/mariano

Cambieremo poi i privlegi sulla cartella dell’utente appena creato:

% sudo chown -R mariano:staff /Users/mariano

13 La sicurezza del sistema

Unix affida ad ogni file o cartella informazioni relative al suo proprietario e ai privilegi di
accesso. Il proprietario è definito come colui che può cambiare i privilegi intesi in Unix come:

79
 • read (r–) - Per un documento, il privilegio “lettura” permette di leggere il contenuto del
documento. Nel caso di una cartella ne permette l’esplorazione.

• write (-w-) - Per un documento, il privilegio “scrittura” permette di modificare il contenu-

to del documento. Nel caso di una cartella il privilegio di scrittura permette di alterarne
il contenuto aggiungendo o elimindando documenti o sottocartelle.

• execute (–x) - Per un documento il privilegio “esegui” permette la sua esecuzione se

si tratta di un programma o di uno script. Questo privilegio è dunque irrilevante per
i documenti non eseguibili. Nel caso di una cartella il privilegio “esegui” permette di
eseguire i file legati a quella specifica cartella. In questo caso il privilegio di esecuzione
limita i due privilegi di lettura scrittura

Quando si hanno tutti e tre i privilegi di accesso la sigla sarà “rwx” e via via per le varie
combinazioni delle tre lettere. Unix permette anche che gli utenti vengano definiti in gruppi, in
modo da rendere la gestione dei privilegi più semplice e immediata. Le entità presenti nell’uso
dei privilegi di accesso sono dunque:

• Proprietario - Il proprietario (owner) è quasi sempre l’utente che ha creato il file. Quasi
tutti i documenti e cartelle nella propria Home Directory avranno come proprietario
l’utente loggato in quel momento.

• Gruppo - Gli utenti admin su Mac OS X sono membri di gruppi chiamati “admin” e
“wheel”, mentre il super-utente è membro del gruppi chiamati admin e staff. Quasi tutti
i documenti e le cartelle sono assegnati a uno di questi tre gruppi.

• Altri - Altri (Others) si riferisce a tutti quegli utenti che non sono nè utenti nè fanno
parte di alcun gruppo.

Le autorizzazioni sui documenti si potranno poi visualizzare usando il comando ls -l

olivio@mistral:~/Sites$ ls -l
total 8
drwxr-xr-x 5 olivio olivio 170 Jul 3 12:53 images
-rw-r--r-- 1 olivio olivio 5754 Jul 3 12:53 index.html
olivio@mistral:~/Sites$

80
 Osserveremo la presenza di dieci caratteri nella prima colonna:

• Carattere 1: Otterremo :

1. - : è un documento ordinario
2. d : è una directory
3. l : si tratta di un alias simbolico
4. s : si tratta di un documento speciale

• Carattere 2,3,4 : Autorizzazioni per il proprietario del documento

• Carattere 5,6,7 : Autorizzazioni per i membri del gruppo

• Carattere 8,9,10 : Autorizzazioni per tutti gli altri utilizzatori

Il proprietario e il gruppo del proprietario saranno visualizzati rispettivamente nella terza

e quarta colonna. Esempio:

% ls -l /etc/passwd

dovrebbe dare questo tipo di output:

-rw-r--r-- 1 root wheel 722 Jul 14 2002 /etc/passwd

Nel nostro esempio:

• (rw-) questi tre caratteri descrivono i privilegi relativi al suo possessore. Nel nostro caso
potrà dunque leggere e scrivere il file ma non eseguirlo.

• (r–) questi caratteri descrivono i privilegi per tutti gli utenti appartenenti allo stesso
gruppo del proprietario. Nel nostro caso possibilità di lettura ma non di scrittura nè di
esecuzione.

• (r–) i restanti caratteri descrivono i privilegi per tutti gli altri utenti. Nel nostro caso
lettura ma non scrittura nè esecuzione.

81
13.1 chmod, chown, chgrp, umask : modificare i privilegi
Il comando che ci permette di cambiare i privilegi è chmod . Il comando chmod richede che gli
venga specificato il nuovo privilegio da assegnare e il documento o cartella al quale assegnarlo.
Per settare il privilegio è necessario che si usi la notazione indicata “rwx” per specificare il
tipo di privilegio e la cosidetta “ugo notation” per specificare dove è necessario applicarlo.
Per definire il tipo di cambiamento voluto è necessario usare il segno “+” per aggiungere un
privilegio, il segno “-” per rimuovere un privilegio e il segno “=” per assegnare il privilegio
direttamente. Ad esempio, volendo cambiare i privilegi al documento .shrc nella nostra cartella
personale possiamo usare questa stringa:

% chmod g=rw- ~/.shrc

In questo esempio stiamo specificando un privilegio di lettura e scrittura per il gruppo senza
possibilità di esecuzione. Possiamo combinare privilegi multipli nei nostri comandi separando
ogni operazione con una virgola, ovviamente non usando alcuno spazio. Ad esempio:

% chmod u=rwx,go=r-x lollo

setterà i privilegi “rwx” per il proprietario del documento “lollo”, mentre assegnerà al
gruppo privilegi “r-x” . I comandi chown , chgrp usano la stessa sintassi che chmod e servono
rispettivamente per cambiare il proprietario e il gruppo. Il comando umask ci servirà per
scegliere i privilegi di default di un documento alla sua creazione.

Esempi con chmod :

olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$ chmod +x projet.java
olivio@mistral:~$ ls -l projet.java
-rwxr-xr-x 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$ chmod -x projet.java
olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$

82
In questo caso aggiungiamo i privilegi di esecuzione al documento projet.java e successivamente
annulliamo questa modifica.

olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$ chmod 777 projet.java
olivio@mistral:~$ ls -l projet.java
-rwxrwxrwx 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$ chmod 644 projet.java
olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$

Configurazione in rwx per il proprietario, il gruppo e tutti gli altri utilizzatori del documento
projet.java. In questo caso osserviamo che i diritti vengono espressi su questa forma:

rwxrwxrwx = 777 (4+2+1 4+2+1 4+2+1)

Esempi con chown :

olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$ sudo chown guest projet.java
Password:
olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 guest olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$ sudo chown olivio projet.java
olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$

Modifica del proprietario olivio verso guest e inverso.

olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java

83
olivio@mistral:~$ sudo chown guest:staff projet.java
olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 guest staff 3751 May 8 14:37 projet.java
olivio@mistral:~$ sudo chown olivio:olivio projet.java
olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$

Modifica del proprietario e del gruppo verso l’utente guest e il gruppo staff e inverso.

olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$ sudo chgrp staff projet.java
olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio staff 3751 May 8 14:37 projet.java
olivio@mistral:~$ sudo chgrp olivio projet.java
olivio@mistral:~$ ls -l projet.java
-rw-r--r-- 1 olivio olivio 3751 May 8 14:37 projet.java
olivio@mistral:~$

Modifica del gruppo verso staff sul documento projet,java e inverso.

13.2 Lo sticky bit

Lo sticky bit può essere applicato a cartelle o eseguibili.

• cartelle / documenti - limita i diritti di calcellazione di un documento o di un documento

al suo solo proprietario anche se le autorizzazioni sono in rwx per il gruppo e gli altri
utenti.

• eseguibili - permette di conservare in memoria questo eseguibile per accellerarne una

nuova esecuzione.

Per rendere effettivo lo sticky bit viene utilizzato il comando chmod. Osserveremo che dopo
il carattere dedicato ai privilegi, vi sarà il carattere t al posto del classico x per identificare la
sua presenza.

84
 olivio@mistral:~/Sites$ ls -l
total 8
drwxr-xr-x 5 olivio olivio 170 Jul 3 12:53 images
-rw-r--r-- 1 olivio olivio 5754 Jul 3 12:53 index.html
olivio@mistral:~/Sites$ chmod 1777 images/
olivio@mistral:~/Sites$ ls -l
total 8
drwxrwxrwt 5 olivio olivio 170 Jul 3 12:53 images
-rw-r--r-- 1 olivio olivio 5754 Jul 3 12:53 index.html
olivio@mistral:~/Sites$ cd images/
olivio@mistral:~/Sites/images$ su guest
Password:
guest@mistral:~/Sites/images$ ls -l
total 12
-rw-r--r-- 1 olivio olivio 2326 Jul 3 12:53 apache_pb.gif
-rw-r--r-- 1 olivio olivio 2829 Jul 3 12:53 macosxlogo.gif
-rw-r--r-- 1 olivio olivio 3698 Jul 3 12:53 web_share.gif
guest@mistral:~/Sites/images$ rm -f apache_pb.gif
rm: Operation not permitted.

In questo caso utilizziamo il comando chmod 1777 su una cartella inserendo lo sticky bit e
le autorizzazioni in “controllo totale”. Sarà poi impossibile all’utilizzatore guest di eliminare il
documento per il quale le autorizzazioni lo permettono; questo fino a quando lo sticky bit sarà
presente.

13.3 Come proteggere il proprio Mac PPC: open-firmware

Anche usando tutti questi accorgimenti vi domanderete per quale motivo Mac OS X è conside-
rato un sistema operativo estremamente sicuro, se ,avendo Mac OS 9 installato o con il semplice
utilizzo del disco di avvio si OS X, chiunque può accedere ai vostri documenti partendo, attra-
verso il tasto opzione, dalla partizione di Mac OS Classic o addirittura resettare le password
con il cd di Mac OS X. Apple ha posto rimedio a questo inconveniente con l’ultima release

85
del firmware (4.1.7 o 4.1.8), disponibile per i modelli di ultima generazione di Mac. Attraverso
questo aggiornamento è possibile specificare una password per l’OpenFirmware.

Attenzione! Apple non supporta questa funzionalità, (come viene specificato nel TIL
n◦ 106292). In effetti, il solo modo per eliminare questa protezione, è di portare il
proprio Mac presso un centro di assistenza autorizzato fuori qualunque tipo di ga-
ranzia (anche AppleCare). Anche il reset della PRAM (opzione+command+P+R)
non risolverebbe il problema.

La protezione tramite password si effettua secondo tre metodi diversi:

• Modalità sicurezza assoluta (full)- che chiede la password ad ogni avvio, prima della scelta
della partizione di boot.

• Modalità sicurezza normale (command) - che permette di partire senza alcuna password
sulla partizione scelta, senza permettere alcun altro coman- do a livello di firmware (quindi
alcuna possibilità di cambiare la partizione di boot senza la password)

• Modalità di non-sicurezza (none)- che non chiede alcuna password (è la modalità di
default)

Consiglio personalmente la modalità “command” che vi permette un reboot della macchina

in caso di problemi, senza aver bisogno di specificare una password ogni volta all’avvio, ma che
impedisce ai non-amministratori di cambiare la partizione di avvio. In effetti, sotto Mac OS X,
gli amministratori possono sempre selezionare una partizione di avvio senza sapere quale sia la
password dell’OpenFirmware. Ecco la procedura da adottare per modificare i propri parametri
Open-Firmware:

1. Partire sotto OpenFirmware- Per avviare con OpenFirmware, spegnete la vostra macchi-
na, successivamente riaccendetela tenendo premuto option+command+O+F. Vi ritrover-
te di lı̀ a poco in modalità linea di comando con una tastiera di tipo QWERTY.

2. Specificare la password- Scrivete il comando password e scrivete due volte consecutiva-

mente la password.

86
 3. Specificare la modalità di sicurezza- Scrivete il comando:

setenv security-mode full

per passare in modalità full

setenv security-mode command

per passare in modalità command

o ancora

setenv security-mode none

per disattivare tutti i tipi di protezione. Basterà registrare e riavviare per verificare le
modifiche effettuate. Scrivete il comando:

reset-all

87
Parte VII

Le shells
La shell è il programma più importante in un sistema Unix. La shell è l’interfaccia con il sistema
Unix, una sorta di traduttore che interpreta i comandi dell’utente e li invia al kernel. Possiamo
definire la shell in questo modo:

• La shell è un tipo di programma chiamato interpreter. Un interprete opera in maniera

motlo semplice: accetta il comando, lo interpreta, lo esegue e successivamente attende
il prossimo comando. La shell visualizza il prompt lasciando intendere che attende il
prossimo comando.

• La shell è il programma che il kernel fa partire per primo, e in quanto tale è un processo
come lo può essere qualunque applicazione installata sulla macchina in questione. La
particolarità di tutto ciò sta nel fatto che il kenel può eseguire lo stesso programma
(dunque anche la stessa shell) per ogni utente loggato.

• Di fatto su ciascun sistema Unix è possibile aver installati diversi tipi di interpreti (quindi
diverse modalità di esecuzione di un comando). Tra questi ricordiamo sh, bash(ora default
su Mac OS X), csh, tcsh, zsh. Questi interpreti vengono denominati comunemente shells
in ambiente Unix. Fondamentalmente tutte le shell fanno lo stesso identico lavoro (magari
con diversa sintassi) ma alcune sono più evolute di altre, in sostanza perchè sono state
compilate per estendere le capacità delle shells più anziane.

Qualunque sia la shell utilizzata è importante ricordare che tutte le shells sono “case sensiti-
ve” e quindi non ci possiamo permettere di usare un comando con lettere maiuscole o minuscole
a nostro piacimento. LS,ls, Ls. LS sono quattro comandi diversi sia che si usi sh, csh, tcsh o
bash.

14 Convenzioni e utilizzo
Come già detto esistono diversi tipi di shells:

88
 • sh (Bourne shell)

• bash (Bourne again shell)

• csh (C shell)

• ksh (Korn shell)

• ...

Usualmente in Mac OS X la shell di default è bash (da Mac OS 10.2 in poi). Per ciascuna
shell esiste un documento di configurazione comune a tutti gli utilizzatori ,generalmente presente
in /etc, modificabile dall’amministratore del sistema e utilizzato ogni volta che la shell è lanciata.
Ogni shell di Mac OS X può essere lanciata in modalità diverse. A seconda dei casi, una
shell è lanciata automaticamente in una modalità piuttosto che in un’altra. Di per sé, quando
accediamo al terminale, la shell è lanciata in modo login . Ma questo stato può variare quando,
ad esempio, accediamo al terminale tramite la finestra di login:

>console

Queste considerazioni, ci torneranno utili nella sezione di personalizzazione della shell ; esiste la
possibilità di un documento di configurazione, per ognuna shell, per ciscun utilizzatore, presente
alla radice del repertorio di base dell’utente, modificabile dall’utente stesso e utilizzato dopo il
documento di configurazione comune. Ma vedremo questo più avanti.

14.1 Variabili
Un variabile è caratterizzata da un nome e un valore all’interno della shell. Per “settare”
una variabile è utilzzato il comando set. Scrivendo semplicemente “set” nel nostro terminale
otterremo una lista delle variabili settate di default nella nostra shel, su questa forma:

olivio@mistral:/$ set
BASH=/bin/bash
BASH_VERSION=’2.05b.0(1)-release’
...

Per designare il valore di una variabile si utilizza il suo nome preceduto dal carattere $

89
olivio@mistral:/$ echo HOSTNAME
HOSTNAME
olivio@mistral:/$ echo $HOSTNAME
cable-xx.xx.xx.xx.coditel.net
olivio@mistral:/$

echo HOSTNAME → HOST N AM E − nomevariabile

echo $ HOSTNAME → cable − xx.xx.xx.xx.coditel.net − valorevariabile

Per configurare la variabile, scriveremo il suo nome seguito da un = e del suo valore (senza
spazio).

olivio@mistral:/$ TOTO=1500
olivio@mistral:/$ echo $TOTO
1500
olivio@mistral:/$

Alcune delle variabili più conosciute:

• HOME : stabilisce la home dell’utente (dinamica)

• LOGNAME : Login dell’utente in sessione (dinamica)

• PATH : percorso realtivo delle applicazioni lanciate (separate da più “:” )

• PS1 : prompt

• PWD : cartella corrente (dinamica)

• SHELL : nome della shell corrente (dinamica)

• * * : cartella di base dell’utente (dinamica)

90
14.2 Le espressioni regolari o caratteri “joker”
Le espressioni regolari (in inglese regular expression , termine poi spesso aabbreviato in regexp
regex o RE ) sono una sintassi attraverso la quale si possono rappresentare insiemi di strin-
ghe. Gli insiemi caratterizzabili con espressioni regolari sono anche detti linguaggi regolari (e
coincidono con quelli generabili dalle grammatiche regolari e riconoscibili dagli automi a stati
finiti).
Di fatto la nostra shell Unix si comporta come un “automa” quando bisogna indicarle gruppi
di documenti o cartelle. Questa tecnica tramite espressioni regolari si rivela molto potente anche
in ambiti più vasti.
In Unix la sintassi base delle espressioni regolari è ora definita obsoleta dal POSIX, ma
resta ancora molto usata a causa della compatibilità con gli anziani sistemi Unix. La maggior
parte delle utility che usano le espressioni regolari (grep è una di queste) usano in ogni caso il
sistema Unix di default. In ogni sintassi, la maggior parte dei caratteri sono considerati come
letterali : una “a” corrisponde ad “a”, la catena di caratteri “bc” trova sempre bc ... Questa
corrispondenza non è rispettata per alcuni caratteri detti “meta”:

• . - Trova ogni singolo carattere.

• [ ]
- Trova un singolo carattere contenuto nelle parentesi. Ad esempio, [abc] trova o una “a”,
“b”, o “c”.

• [a-z]
- è un intervallo e trova ogni lettere minuscola dell’alfabeto. Possono esserci casi misti:
[abcq-z] trova a, b, c, q, r, s, t, u, v, w, x, y, z, esattamente come [a-cq-z]. Il carattere ’-’ è
letterale solo se è primo o ultimo carattere nelle parentesi: [abc-] o [-abc]. Per trovare un
carattere ’[’ o ’]’, il modo più semplice è metterli primi all’interno delle parentesi: [][ab]
trova ’]’, ’[’, ’a’ o ’b’.

• [^]
- Trova ogni singolo carattere non incluso nelle parentesi. Ad esempio,

[^abc ]

91
 trova ogni carattere diverso da “a”, “b”, o “c”.

[^a-z]

trova ogni singolo carattere che non sia una lettera minuscola. Come sopra, questi due
metodi possono essere usati insieme.

• $
- Corrisponde alla fine di una riga (o ad una riga, quando usato in modalità multilinea)

• ^
- Corrisponde all’inizio di una riga (o ad una riga, quando usato in modalità multilinea)

• \( \)
- Definisce una “sottoespressione marcata”. Ciò che è incluso nell’espressione, può essere
richiamato in seguito.

• \n
- Dove n è una cifra da 1 a 9; trova ciò che la nesima sottoespressione ha trovato. Tale
costrutto è teoricamente irregolare e non è stato adottato nella sintassi estesa delle regexp.

• *
- Un’espressione costituita da un singolo carattere seguito da “*”, trova zero o più copie
di tale espressione. Ad esempio, “[xyz]*” trova “”, “x”, “y”, “zx”, “zyx”, e cosı̀ via. Ad
esempio:

\n*

Dove n è una cifra da 1 a 9, trova zero o più iterazioni di ciò che è la nesima sottoespressione
ha trovato. Ad esempio:

\(a.\)c\1*

trova “abcab” e “abcaba” ma non “abcac”. Un’espressione racchiusa tra

92
 ’’\(’’ e ’’\)’’

seguita da “*” non è valida. In alcuni casi, trova zero o più ripetizioni della stringa che
l’espressione racchiusa ha trovato. In altri casi, trova ciò che l’espressione racchiusa ha
trovato, seguita da un letterale “*”.

• \{x,y\}
- Trova l’ultimo “blocco” almeno x volte e non più di y volte. Ad esempio,

a\{3,5\}

trova “aaa”, “aaaa” o “aaaaa”.

Alcuni esempi:

.atto

trova ogni stringa di cinque caratteri come gatto, matto o patto

[gm]atto
trova gatto e matto
[^p]atto
trova tutte le combinazioni dell’espressione “.atto” tranne patto
^[gm]atto
trova gatto e matto ma solo all’inizio di una riga
[gm]atto$
trova gatto e matto ma solo alla fine di una riga
E’ importante, dunque, che nello scrivere i comandi se ne conoscano anche i limiti. Come
già detto, questo tipo di caratteri sono sempre riconosciuti dalla shell dovunque appaiano
nella command line, anche se non preceduti da uno spazio. Proprio per questo è importante
non usare questo tipo di caratteri come nome dei documenti con cui si lavora. Diventerebbe
estremamente difficile “combattere” con il terminale affinché capisca che un particolare meta
character fa parte del nome di un file e non è una direttiva di comando.

93
14.3 Pipes
Il carattere detto pipe | tra due comandi permette di eseguire il primo comando inviando il
suo risultato di esecuzione (come parametro di entrata) al secondo.

ls | sort

La lista dei documenti della cartella su cui si sta lavorando è inviata al comando sort per una
selezione in ordine alfabetico e successiva visualizzazione.

14.4 Redirezione di uscite / entrate

La tecnica di redirezione può:
• redirigere i risultati in uscita verso un documento con distruzione di quest’ultimo usando
il carattere “>” piazzato tra il comando e il nome del documento.

• redirigere i risultati in uscita verso un documento in aggiunta alla fine del documento
usanto i caratteri “>>” tra il comando e il nome del documento.

• Tramite il carattere “<” si ottengono i dati richiesti “verso la tastiera” del il comando a
partire dal contenuto del documento.

olivio@mistral:~$ date >uscita.txt

olivio@mistral:~$ who >>uscita.txt
olivio@mistral:~$

In questo caso salviamo i risultati del comando date nel documento uscita.txt. Nel secondo
invece aggiungiamo i risultati del comando who alla fine del documento uscita.txt.
Ossevando poi il contenuto del documento uscita.txt tramite il comando cat, osserveremo
che l’operazione di redirezione è stata effettuata correttamente :

olivio@mistral:~$ cat uscita.txt

Tue Oct 31 13:51:12 CET 2006
olivio console Oct 31 08:21
olivio ttyp1 Oct 31 13:37
olivio@mistral:~$

94
14.5 Alcuni esempi sull’uso delle convenzioni
• Il carattere speciale per eccellenza è lo spazio. Interpretare lo spazio come nel sistema
operativo grafico porta sotto il terminale sempre ad un errore, specie nell’indicare una
directory o un file che ne contengono parecchi. Scrivere:

% cd nuova_cartella

difficilmente porterà nella directory nuova cartella. Per far interpretare al terminale il
comando corretto è necessario scrivere:

% cd ’’nuova cartella’’

oppure

% cd nuova\ cartella

• barra verticale(| ): reindirizzamento, reinstradamento (piping); di solito si usa per “in-

stradare” l’output di un comando verso l’input di un altro comando. Per esempio:

# ps -ax

mostra una lista di processi attivi

# ps -ax | grep netinfo

ps viene eseguito esclusivamente in funzione di netinfo. In pratica filtra ps in modo che

venga eseguito in funzione di netinfo stampandolo a video.

• maggiore(): ha la stessa funzione della barra verticale ma il reinstradamento viene effet-

tuato verso un file.
Scrivere

# ps -ax >lista.txt

non mostrerà nulla a video poichè l’output viene trascritto nel file lista.txt nella directory
corrente.

95
14.6 Il comando test
Il comando test serve per la comparazione di espressioni. Questo può ritornare spesso utile
nell’uso quotidiano della shell o quando vengono utilizzati determinate strutture di iterazione
o comando , che vedremo più avanti in questo tutorial. Elenchiamo qui di seguito con che
modalità è necessario usare il comando e aggiungiamo alcuni esempi di utilizzo.

• Operatori sui documenti / cartelle:

Operatore −
-d E E cartella
-e E E esiste
-r E E leggibile
-s E E di taglia non nulla
-w E E può essere modificato / scritto
-x E eseguibile
... ...

• Operatori di comparazione tra due espressioni di tipo “catena di caratteri”:

Operatore −
E catena di caratteri non vuota
E1 = E2 E1 uguale a E2
E1 =! E2 E1 diverso da E2

• Operatori di comparazione su espressioni numeriche:

96
 Operatore −
E catena di caratteri non vuota
E1 -eq E2 E1 uguale a E2
E1 -ne E2 E1 diverso da E2
E1 -ge E2 E1 più grande o uguale a E2
E1 -gt E2 E1 strettamente più grande che E2
E1 -le E2 E1 più piccolo o uguale a E2
E1 -lt E2 E1 strettamente più piccolo che E2

• Operatori booleani :

Operatore −
(E) E è vero
!E E è falso
E1 -a E2 E1 e E2
E1 -o E2 E1 o E2

Qualche esempio:

• Test di uguaglianza e test di differenza tra variabile e costante numerica:

olivio@mistral:~/Scripts$ var1=1000
olivio@mistral:~/Scripts$ test $var1 -eq 1000
olivio@mistral:~/Scripts$ echo $?
0
olivio@mistral:~/Scripts$ test $var1 -gt 1000
olivio@mistral:~/Scripts$ echo $?
1
olivio@mistral:~/Scripts$

• Test di esistenza di documenti:

97
 olivio@mistral:~/Scripts$ test -e /etc/group
olivio@mistral:~/Scripts$ echo $?
0
olivio@mistral:~/Scripts$ test -e /etc/groupp
olivio@mistral:~/Scripts$ echo $?
1
olivio@mistral:~/Scripts$

• Test di leggibilità dei documenti:

olivio@mistral:~/Scripts$ test -r /etc/group

olivio@mistral:~/Scripts$ echo $?
0
olivio@mistral:~/Scripts$ test -r /etc/gshadow
olivio@mistral:~/Scripts$ echo $?
1
olivio@mistral:~/Scripts$

• Test di accesso in scrittuta dei documenti:

olivio@mistral:~/Scripts$ test -w ~/documento.txt

olivio@mistral:~/Scripts$ echo $?
0
olivio@mistral:~/Scripts$ test -w /etc/passwd
olivio@mistral:~/Scripts$ echo $?
1
olivio@mistral:~/Scripts$

15 Scripts shell
Uno script shell è un documento contenente dei comandi in linguaggio shell (documento testo
reso eseguibile eseguendo il comando chmod +x script shell, descritto in altra sezione in questo
tutorial).
La sintassi da rispettare nella redazione degli script é:

98
 • # - per effettuare un commento.

• per usare le variabili : var=valore oppure var=”valore” se questo valore comporta degli
spazi.

• read - per leggere una variabile da tastiera.

• echo - per visualizzare una variabile.

• per recuperare degli elementi dalla linea di comando si usano i codici 0,1, 2,3, ... nell’ordine
di scrittura includendo il nome del comando usato.

• per recuperare la lista completa degli elementi si usa $*.

• per recuperare il numero di elementi si userà $#.

Esiste, poi, un codice espresso tramite $? che permette il recupero del risultato di esecuzione
dell’ultimo comando. Il risultato booleano “0” alla fine del comando ci indica un’esecuzione
senza anomalie e con uscita valida.

olivio@mistral:~$ who
olivio console Oct 31 08:21
olivio ttyp1 Oct 31 13:55
olivio@mistral:~$ echo $?
0
olivio@mistral:~$

Osserveremo un errore di esecuzione in questo caso:

olivio@mistral:~$ rm /etc/
rm: /etc/: is a directory
olivio@mistral:~$ echo $?
1
olivio@mistral:~$

Il risultato al contrario del nostro primo who è 1. Dunque errore di esecuzione.

99
15.1 Istruzioni di strutturazione, if, case, for, while
Le istruzioni di strutturazione sono fondamentali non solo negli ambienti Unix; sono una parte
vitale della storia informatica. Nel nostro terminale questo genere di istruzioni sono utilizzate
nativamente (come si può capire dalle origini C del terminale). Detti anche conditional state-
ments , questi sono delle richieste fatte all’elaboratore per effettuare un’esecuzione basata su
una precisa condizione. In questo paragrafo ne vedremo le diverse forme seguite da esempi.

• l’istruzione if si struttura come di seguito :

if
comando
then
...
else
...
fi

Quando la shell trova un if (dichiarata come parola riservata) attende un dato di compa-
razione (ad esempio x = 0) e valuta la condizione. Se la condizione è vera, la struttura
blocca e esegue le istruzioni sotto la parola chiave then . In caso contrario sceglie le
istruzioni sotto la parola chiave else .
Esempio :

if ls | grep $1 > /dev/null;

then echo ’’$1 esiste’’;
else echo ’’$1 non esiste’’;
fi

Queste istruzioni indirizzano la lista dei documenti della cartella corrente verso grep alla
ricerca del nome del documento in parametro. Avremo la visualizzazione di uno dei due

100
 messaggi a seconda del risultato di grep (che in questo caso sarà 0 se trovato, non-0 se
inesistente).
Proviamo ad usarlo ora:

olivio@mistral:~$ touch finale.txt

olivio@mistral:~$ ScriptIF finale.txt
finale.txt esiste
olivio@mistral:~$ rm -f finale.txt
olivio@mistral:~$ ScriptIF finale.txt
finale.txt non esiste
olivio@mistral:~$

• l’istruzione case si struttura come di seguito :

case variabile in
v1 | v2 | ... | vn)
...;;
w1 | w2 | ... | wn)
...;;
esac

L’istruzione case si differenzia dalla precedente istruzione poichè permette di scegliere tra
più di due blocchi di codice. Ciò è dettato dal fatto che l’espressione condizionale è di
tipo ordinale e quindi si potranno seguire tante strade differenti quanti sono i valori del
tipo ordinale.
Esempio:

echo ’’un numero tra 0 e 9 prego’’

read numero
case $numero in
0|3|6|9)

101
 echo ’’$numero divisibile per 3’’;;
*)
echo ’’$numero non divisibile per 3’’;;
esac

Il funzionamento è semplice: il valore letto da tastiera (compreso tra 0 e 9) viene assegnato

ad una variabile chiamata numero . In funzione di questa variabile viene visualizzato uno
o l’altro messaggio.

olivio@mistral:~$ ./Scriptcase
un numero tra 0 e 9 prego
3
3 divisibile per 3
olivio@mistral:~$ ./Scriptcase
un numero tra 0 e 9 prego
5
5 non divisibile per 3
olivio@mistral:~$

In questo caso la shell risponde correttamente: 3 divisibile per se stesso, 5 non divisibile
per 3.

• l’istruzione for si struttura come di seguito :

for
variabile
in
lista
do
...
done

102
 for è un’istruzione di tipo ciclico come anche while . Sono delle strutture che si diffe-
renziano non poco per quanto riguarda sintassi e logica di esecuzione. L’istruzione for
richiede la specificazione del numero di ripetizioni da effettuare. L’istruzione for richiede
la specificazione del numero di ripetizioni da effettuare. for assegna inizialmente al conta-
tore il valore specificato ed esegue il blocco di istruzioni incrementando o decrementando
il valore del contatore fino a raggiungere il valore indicato per la fine delle iterazioni.
Esempio:

rm -f $2
for file in $1
do
head -n $3 $file >> $2
done

In questo caso effettuiamo una cancellazione del documento corrispondente al secondo

parametro per tutti i documenti corrispondenti al primo parametro (joker in questo ca-
so). Estraiamo in seguito il numero di linee corrispondente al terzo parametro (uso del
comando head) e aggiungiamo in coda al documento nominato dal secondo parametro.

olivio@mistral:~/Scripts$ ./Scriptfor ’’*’’ Scriptcase 2

olivio@mistral:~/Scripts$ cat Scriptcase
rm -f $2
for file in $1
olivio@mistral:~/Scripts$

• l’istruzione while si struttura come di seguito :

while
comando
do
...
done

103
 Il ciclo while si differenzia dal ciclo for per il tipo di espressione di controllo e per la
valutazione della stessa che avviene all’inizio di ogni iterazione. L’espressione di uscita dal
trattamento dell’instruzione comando deve essere di tipo booleano e l’esecuzione del codice
prosegue fintanto che l’espressione è verificata, ovvero restituisce true . L’esecuzione del
codice termina quando l’uscita del comando assume valore false .
Esempio:

while ls | grep $1 > /dev/null

do
echo ’’ $1 esiste’’
sleep 5
done

Nell’esempio presentato visualizziamo a schermo un messaggio ogni 5 secondi fino a

quando il documento passato in parametro è esistente.

olivio@mistral:~/Scripts$ ./Scriptwhile Scriptfor

Scriptfor esiste
Scriptfor esiste
Scriptfor esiste
olivio@mistral:~/Scripts$

In pratica lo script si ferma unicamente quando non troverà il documento passato in parametro
“Scriptfor”. Nell’esempio abbiamo soppresso il documento da un altro terminale e abbiamo
ottenuto la disattivazione del nostro script.

104
Parte VIII

Installazione delle applicazioni

Per l’installazione delle applicazioni o delle componenti di sistema esistono diversi metodi:

• il sistema “tarball” alla base dei documenti .tar compressi.

• i documenti di pacchetti .rpm specifici alle distribuzioni RedHat e Fedora.

• i documenti di pacchetti .deb specifici alle distribuzioni Debian e Ubuntu.

16 I tarballs : pacchetti GNU

I documenti tarball sono degli archivi compressi .tar e .gzip e contengono fondamentalmente:

• eseguibili

• biblioteche

• documenti di configurazione

• documentazione

• documenti di dati

• esempi

In definitiva questo genere di pacchetto non ha una procedura standard per l’installazione ed
è quasi sempre necessario consultare i documenti ottenuti subito dopo la decompressione. Di
fatto i pacchetti GNU standarizzano questa procedura rendendo la vita più facile all’utilizza-
tore inesperto. Sette passi, generalmente, sono necessari per una corretta installazione di un
pacchetto GNU:

• recupero del tarball

• decompressione con l’utilità gzip

105
 • restaurazione delle componenti tar

• apertura di una shell sulla radice della cartella di restaurazione del passo 3

• esecuzione dello script di configurazione configure

• compilazione, usando il comando make

• installazione, usando il comando make install

In alcuni casi la compilazione è un passaggio obbligato. Si rende quindi necessaria l’uti-

lizzazione di un compilatore possibilmente specifico e di biblioteche altrettanto specifiche. É
dunque possbile incappare in dipendenze tra i diversi pacchetti, compilatori e biblioteche dei
diversi prodotti già installati.

A titolo di esempio descriviamo l’installazione delle librerie Mesa OpenGL versione 6.5 :
Nel nostro esempio abbiamo tre documenti principali:

1. MesaDemos-6.5.tar.gz

2. MesaGLUT-6.5.tar.gz

3. MesaLib-6.5.tar.gz

Effettuiamo l’operazione di unzipping:

olivio@mistral:~/OpenGL$ ls
MesaDemos-6.5.1.tar.gz MesaGLUT-6.5.1.tar.gz MesaLib-6.5.1.tar.gz
olivio@mistral:~/OpenGL$ gzip -d *.gz
olivio@mistral:~/OpenGL$ ls
MesaDemos-6.5.1.tar MesaGLUT-6.5.1.tar MesaLib-6.5.1.tar
olivio@mistral:~/OpenGL$

Successivamente l’untar dei pacchetti ottenuti:

olivio@mistral:~/OpenGL$ tar xf MesaLib-6.5.1.tar

olivio@mistral:~/OpenGL$ tar xf MesaGLUT-6.5.1.tar
olivio@mistral:~/OpenGL$ tar xf MesaDemos-6.5.1.tar

106
olivio@mistral:~/OpenGL$ ls -l
total 30892
drwxr-xr-x 16 olivio olivio 544 Nov 5 22:23 Mesa-6.5.1
-rw-r--r-- 1 olivio olivio 4372480 Nov 5 22:12 MesaDemos-6.5.1.tar
-rw-r--r-- 1 olivio olivio 2682880 Nov 5 22:13 MesaGLUT-6.5.1.tar
-rw-r--r-- 1 olivio olivio 24576000 Nov 5 22:14 MesaLib-6.5.1.tar
olivio@mistral:~/OpenGL$

Il pacchetto apparirà ora in questo modo:

olivio@mistral:~/OpenGL$ cd Mesa-6.5.1/
olivio@mistral:~/OpenGL/Mesa-6.5.1$ ls
Makefile Makefile.mgw bin descrip.mms include progs vms
Makefile.DJ Makefile.orig configs docs mms-config. src windows
olivio@mistral:~/OpenGL/Mesa-6.5.1$

Osserveremo l’assenza di uno script configure e la presenza di un documento Makefile

necessario all’utilizzo del comando make.

olivio@mistral:~/OpenGL/Mesa-6.5.1$ make

Il risultato sarà il seguente:

Please choose a configuration from the following list:

aix
aix-64
aix-64-static
aix-gcc
aix-static
beos
darwin
darwin-static
darwin-static-x86ppc
darwin-x86ppc
diffs

107
...
Then type ’make <config>’ (ex: ’make linux-x86’)
(ignore the following error message)
make: *** [configs/current] Error 1
olivio@mistral:~/OpenGL/Mesa-6.5.1$

É dunque possibile l’installazione e la compilazione del pacchetto MESA per diverse piatta-
forme. Nel nostro caso sceglieremo darwin-x86ppc. La compilazione occuperà a pieno schermo
il nostro terminale effettuando tutte le tappe necessarie. Questa operazione potrà prolungarsi
per più di qualche minuto a seconda della complessità del pacchetto.

olivio@mistral:~/OpenGL/Mesa-6.5.1$ make darwin-x86ppc

(cd configs && rm -f current && ln -s darwin-x86ppc current)
make default
Making sources for darwin
mkdir ../lib
...

Conclusasi l’operazione di compilazione, finalizzeremo quest’ultima con l’utilizzo del coman-

do make install . In particolare quest’ultima operazione risponde a delle domande specifiche,
del tipo: dove installare le biblioteche di Mesa compilate ? Dove installare i documenti include
di Mesa ? E anche a domande specifiche alla distribuzione.
Il vantaggio dei tarballs è principalmente quello di possedere un processo di installazione
identico sull’insieme delle piattaforme. Il documento tarball, poi, è generalmente sempre lo
stesso per tutte le piattagorme supportate.

108
Parte IX

Unix e le reti
17 Il TCP/IP
Quando ci vogliamo collegare con il nostro terminale o con la nostra GUI a qualunque servizio
di rete, stabiliamo un collegamento a livello di applicazione. Questo livello è detto di trasporto.
A questo livello il protocollo TCP mette in coda i messaggi delle applicazioni (le applicazioni
che accedono ai servizi di rete) e li trasmette sotto forma di pacchetti. A livello di rete il
protocollo IP decide dove instradare i pacchetti per trasmettere effettivamente i messaggi da
un computer all’altro. Il settaggio di questi due protocolli TCP e IP avviene, nel terminale,
tramite una serie di comandi specifici. Vediamo quali.

17.1 Consultazione
• ifconfig - permette di consultare la configurazione ip attuale. La risposta a un tale
comando è del genere:

olivio@mistral:/$ ifconfig en0

en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500
ether 00:00:00:00:00:00
media: autoselect status: inactive
supported media: autoselect 10baseT/UTP <half-duplex>
10baseT/UTP <full-duplex>
10baseT/UTP <full-duplex,hw-loopback>
10baseT/UTP <full-duplex,flow-control>
100baseTX <half-duplex> 100baseTX <full-duplex>
100baseTX <full-duplex,hw-loopback>
100baseTX <full-duplex,flow-control>
1000baseT <full-duplex> 1000baseT <full-duplex,hw-loopback>
1000baseT <full-duplex,flow-control> none
olivio@mistral:/$

109
 Nell’esempio abbiamo chiesto quale sia la configurazione dell’interfaccia en0 attuale. Ov-
viamente diverse interfacce sono presenti su ogni macchina; di default ifconfig mostra a
schermo tutte le interfacce se non ne viene specificata una in argomento. In questo caso
osserveremo anche la presenza di un’interfaccia lo0 detta interfaccia di loopback e che ci
permette di visionare il circuito al quale il nostro indirizzo ip è associato.

olivio@mistral:/$ ifconfig lo0

lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384
inet6 ::1 prefixlen 128
inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1
inet 127.0.0.1 netmask 0xff000000
olivio@mistral:/$

• hostname - ci permette di consultare il nome della macchina sulla quale stiamo operando.

olivio@mistral:/$ hostname
mistral.local
olivio@mistral:/$

17.2 Test di connettività

• ping - invia dei pacchetti di dati all’indirizzo o dominio specificato per controllarne la
connettività con la propria macchina.

olivio@mistral:/$ ping free.fr

PING free.fr (212.27.48.10): 56 data bytes
64 bytes from 212.27.48.10: icmp_seq=0 ttl=119 time=50.591 ms
64 bytes from 212.27.48.10: icmp_seq=1 ttl=119 time=50.646 ms
64 bytes from 212.27.48.10: icmp_seq=2 ttl=119 time=51.034 ms
64 bytes from 212.27.48.10: icmp_seq=3 ttl=119 time=50.794 ms
64 bytes from 212.27.48.10: icmp_seq=4 ttl=119 time=51.045 ms
^C
--- free.fr ping statistics ---

110
 5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max/stddev = 50.591/50.822/51.045/0.190 ms
olivio@mistral:/$

Il comando visualizzerà a schermo le statistiche di invio specificando la quantità di pac-

chetti inviati / ricevuti. In questo caso stiamo effettuando l’operazione di ping sull’indi-
rizzo free.fr.

• nslookup - permette di inviare delle richieste sul server DNS comfigurato. Per testare ad
esempio il server DNS:

olivio@mistral:/$ nslookup
> powerserver
Server: 192.168.1.1
Address: 192.168.1.1#53

18 SSH
SSH è l’acronimo di Secure Shell ed è un protocollo che permette di inviare comandi sicuri e
criptati a un’altra macchina sulla rete. Generalmente è molto utile e potente quando si vuole
controllare una macchina a distanza proprio come se l’utente in questione ci stesse davanti. La
sintassi per il suo utilizzo é:

ssh -l username server

dove il campo username è il nome dell’amministratore sulla macchina remota e server

l’indirizzo ip del server. Esempio :

ssh -l admin 10.0.1.2

Se ci stiamo connettendo per la prima volta al server il terminale ci chiederà se siamo

pronti a ricevere l’autenticazione RSA fingerprint e successivamente la nostra password di
amministratore sulla macchina remota:

111
olivio@mistral:~$ ssh -l olivio 192.168.2.1
The authenticity of host ’192.168.2.1 (192.168.2.1)’ can’t be established.
RSA key fingerprint is 74:ea:09:04:46:e5:8f:50:26:93:9c:38:d9:61:d2:e6.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added ’192.168.2.1’ (RSA) to the list of known hosts.
Password:
Last login: Thu Jan 8 18:00:36 1970 from 192.168.2.3
Welcome to Darwin!
stp25-1-82-226-151-135:~ olivio$

Se vogliamo inviare alla macchina remota un singolo comando senza dover effettuare tutta
la procedura di logging in e logging out possiamo usare il comando come da esempio:

$ ssh -l admin server1.company.com rm /Users/admin/Documents/report

In questo caso stiamo eliminando un documento sulla macchina remota. Un’altra sintassi
dello stesso comando può essere:

$ ssh -l admin@server1.company.com "rm /Users/admin/Documents/report"

18.1 Sdoppiare i terminali : screen

Screen è una utility compresa in diverse distribuzioni Unix-like (Mac OS X tra queste) e si
dimostra efficace e potente se utilizzata correttamente. Il suo uso può essere efficiente per
chi raramente lavora direttamente sulla propria macchina che dunque funge da terminale la
maggior parte del tempo (usando ssh o altri protocolli). Alcune volte si ha quindi la necessità
di riprendere una sessione da più macchine senza perdere il lavoro compiuto fino ad allora. Il
comando screen ci permetterà di riprendere il lavoro da dove lo si è lasciato senza dover uscire
dai programmi usati o, ad esempio, senza dover perdere il contenuto di una sessione IRC al
cambiamento di macchina.
Screen gestisce diverse consoles virtuali. Permette, una volta lanciata una console, di crearne
diverse altre nella stessa, di passare da una all’altra con facilità, di nominarle secondo le proprie
esigenze.

112
 La funzionalità più interessante è quella di poter distaccare una sessione lasciandola nello
stato corrente e poterla riattaccare in seguito.
Utilizzare screen è abbastanza intuitivo. Per inizializzare una sessione multipla sarà neces-
sario lanciare il gestore di screen attraverso il comando:

[olivio@mistral] olivio $ screen -l

Il risultato del comando non sarà altro che uno schermo vuoto. In realtà screen è attivo e
operante. Per creare un nuovo terminale digiteremo:
CTRL+A c (c sta per create).
Anche in questo caso niente di straordinario apparirà sullo schermo. Al fine di permettervi
di vedere qualcosa di concreto provate a digitare il comando ls. In questo caso stiamo chiedendo
il listaggio della directory corrente nel terminale numero due.
A questo punto digitiamo CTRL+A [space]. Questa combinazione ci farà passare al termi-
nale successivo (in questo caso il numero 1). Ci ritroveremo di fronte al nostro primo terminale
completamente indipendente dal terminale numero due creato in precedenza. Volendo ripassa-
re al terminale precedente useremo la combinazione CTRL+A [DELSPACE]. In questo modo
sarà facile passare da un terminale all’altro. Non da ultimo eviteremo di aprire più finestre e di
creare piu processi futili . Ogni terminale creato avrà un numero e sarà possibile il passaggio da
un terminale all’altro usando il comando CTRL+A [numero del terminale]. Nel nostro esempio
usando la combinazione CTRL+A 1 o CTRL+A 2 passeremo dal terminale 1 al terminale 2 a
seconda delle esigenze.
Quando la nostra utility screen sarà attiva potremo distaccarla e lasciarla nello stato voluto.
La combinazione da usare sarà CTRL+A d (d sta per detach). Questa combinazione dovrebbe
mostravi il contenuto del terminale nel quale avete lanciato screen e fare apparire un messaggio
del genere confermandovi l’operazione:

[olivio@mistral] olivio $ screen -l

[detached]
[olivio@mistral] olivio $

La nostra sessione è dunque distaccata. Osservando i processi attivi ci renderemo conto che
quelli in esecuzione nella shell virtuale non sono stati terminati. Ad esempio:

113
olivio 5359 0.0 0.8 2964 1364 ? S 13:34 0:00 SCREEN -l
olivio 5360 0.0 1.0 3080 1672 pts/14 S 13:34 0:00 _ /bin/bash
olivio 5374 1.6 1.0 3460 1680 pts/14 S 13:36 0:00 | _ mutt
olivio 5365 0.0 1.0 3072 1644 pts/15 S 13:34 0:00 _ /bin/bash

Conosceremo l’esistenza di un comando screen attivo digitando:

[olivio@mistral] olivio $ screen -ls

There is a screen on:

5359.pts-7.mistral (Detached)
1 Socket in /var/run/screen/S-olivio.

[olivio@mistral] olivio $

In questo caso osserveremo l’esistenza di uno screen attivo (ma distaccato). Per poterlo
riattivare useremo il comando:

screen -dR

magicamente ritroveremo il contenuto del terminale distaccato poco tempo fa.

Per terminare il terminale creato useremo il comando CTRL+A K (maiuscolo) oppure
potremo anche semplicemente effettuare un logout (CTRL+D).
Ora provando a connettersi su una macchina lanciate un qualsiasi comando o applicazio-
ne. Distaccatevi. Riconnettetevi su questa macchina da un altro terminale e riattaccatevi al
terminale appena abbandonato.

18.2 Sicurezza in remoto con PAM

I sistemisti che effettuano manutenzione su dei laboratori informatici probabilmente usano l’u-
tilità “Directory Access” (la trovate in /Applications/Utilities/Directory Access) per effettuare
l’autenticazione su protocollo LDAP o Active Directory.

Questo tipo di approccio può essere sbagliato e pericoloso, poiché sul nostro Mac OS X sshd
permette di default l’accesso basandosi su un’ autenticazione effettuata

114
dalla configurazione di Directory Access.
Se Directory Access è configurato, ad esempio, sulla Active Directory tutti gli utenti con un
valido account sulla Active Directory potrebbero effettuare un login SSH sul nostro computer.

Come fare allora ad avere accesso al nostro servizio di SSH senza avere più utenti che lo
usino ? Tanto per cominciare diciamo che Mac OS X - dalla versione 10. 2- usa un’ architettura
modulare di autenticazione chiamata PAM.
PAM ( (Pluggable Authentication Modules ) gestisce ogni tipo di autenticazione sulla nostra
macchina come peraltro i cambiamenti di password o le autorizzazioni sui file. Le applicazioni,
in questo modo, invece di implementare tutto ciò nel loro codice fanno affidamento su dei moduli
PAM configurati dall’amministratore della macchina. Per esempio, se vogliamo effettuare un’
autenticazione LDAP usando PAM avremo bisogno di usare il modulo

pam_ldap

Questo modulo conosce tutto il necessario sulla autenticazione di ldap; le applicazioni che
usando ldap fanno quindi affidamento su questo modulo che gestirà gli account per esse. Mac
OS X integra un modulo chiamato

pam_securityserver

che serve per autenticare ogni servizio presente nella Directory Access. Tra questi anche SSH. Il
servizio SSH (sshd) è compatibile PAM e usa un modulo specifico che troveremo nella directoy

/etc/pam.d/sshd

L’editor di testo nano ci sarà di aiuto:

nano /etc/pam.d/sshd

il documento di configurazione apparirà in questo modo :

# login: auth account password session

auth required pam_nologin.so
auth sufficient pam_securityserver.so
auth sufficient pam_unix.so

115
auth required pam_deny.so
account required pam_permit.so
password required pam_deny.so
session required pam_permit.so

Focalizziamoci sui diversi moduli di autenticazione (dunque tutti quelli comincianti per
auth). PAM consulterà tutti questi moduli nell’ordine; si fermerà unicamente a seconda della
parola nella seconda colonna del documento (required o sufficent) oppure nel caso il modulo
abbia successo o fallisca.

• pam_login
É abbastanza semplice. Avrà sempre successo se l’esistenza di /etc/nologin sarà verificata
(può essere utile per evitare dei login durante la manutenzione del sistema)

• pam_securityserver
Se fallisce questo modulo PAM procederà a

pam_unix

il quale usa delle convenzioni di autenticazione Mac OS X like.

Per evitare dunque questo potenziale pericolo di intrusione mettiamo in commento questa
linea aggiungendo un # all’inizio.

# auth sufficient pam_securityserver.so

in questo modo gli amministratori di sistema avranno ancora accesso al protocollo SSH in
locale grazie alla linea pam-unix, ma gli altri utenti avranno l’accesso negato.

19 Samba
Samba è un protocollo (detto anche smb ) che permette la condivisione di file e stampanti e
di ottenere interoperabilità tra Linux, Unix, Mac OS X e Windows. Si tratta di un software
che può girare su piattaforme che non siano Microsoft Windows, per esempio, UNIX, Linux,
Mac OS X e altri sistemi operativi. Quando correttamente configurato, permette di interagire

116
con client o server Microsoft Windows come se fosse un file e print server Microsoft agendo da
Primary Domain Controller (PDC) o come Backup Domain Controller, può inoltre prendere
parte ad un dominio Active Directory.

19.1 Componenti Samba

Samba è composto da una serie di demoni e programmi che permettono il suo uso e la sua
configurazione:

• smbd - demone che permette l’implementazione della condivisione di documenti e di

stampanti.

• nmbd - demone che permette l’implementazione dei servizi Netbios (protocollo TCP/IP)
e l’ “Esploratore di risorse ” WINS

• smbclient - è un client di accesso a servers di documenti e di stampanti LAN Manager.

• testparm - programma di test di configurazione di Samba

• testprns - programma di test delle stampanti

• smbstatus - mostra a schermo le connessioni in corso

• nmblookup - programma di accesso al servizio di nomi Netbios et acquisizione del nome

“Maste Browser”

• smb passwd - programma di cambio delle password su un server LAN Manager

19.2 Configurazione
Principalmente Samba si basa su un documento di configurazione smb.conf presente nella car-
tella etc. Il documento Samba si presenta sotto la forma di diverse linee che si possono mettere
in commento o attivare a seconda delle esigenze.

• - Commento

• ; - Linea attiva

117
 Questo nella sezione contraddistinta da apposita linea di demarcazione:

#======================= Global Settings =======================

[global]

## Browsing/Identification ###
....

In questa sezione definiremo:

• Nome del dominio o del workgroup costituito

• Descrizione del server

• security = user per l’uso degli account di server Unix

Nella sezione home definiremo l’accesso alle cartelle di base degli utilizzatori.

[homes]
comment = Repertoires de base
browseable = yes
valid users = %S
writable = yes
create mask = 0644
directory mask = 0755

19.3 Sintassi del documento smb.conf

Per verificare la sintassi e la correttezza del documento smb.conf utilizzeremo il comando
testparm:

olivio@mistral:~$ testparm
Load smb config files from /private/etc/smb.conf
Processing section "[homes]"
Processing section "[printers]"

118
Loaded services file OK.
Invalid combination of parameters for service homes.
Invalid combination of parameters for service printers.
Server role: ROLE_STANDALONE
Press enter to see a dump of your service definitions

Di default il comando visualizzerà anche la configurazione di Samba:

# Global parameters
[global]
dos charset = 437
unix charset = UTF-8-MAC
display charset = UTF-8-MAC
server string = mistral
auth methods = guest, opendirectory
passdb backend = opendirectorysam, guest
guest account = unknown
defer sharing violations = No
os level = 8
brlm = Yes
printer admin = @admin, @staff
vfs objects = darwin_acls

[homes]
comment = User Home Directories
read only = No
browseable = No

[printers]
path = /tmp
printable = Yes
browseable = No
olivio@mistral:~$

119
19.4 Lan manager e Smb
Il comando:

mount -t smbfs

ci permetterà il mounting delle risorse condivise di un server Lan Manager all’interno del
sistema.
Esistono dei problemi di accesso alle risorse condivise sui server Windows NT, 2000 ou
2003 se questi esigono il trasferimento delle informazioni di login. Sarà necessario in questo
caso usare delle strategie specifiche per attivare / disattivare / configurare le entrate relative a
questi aspetti in:

• Parametri Windows

• Parametri di sicurezza

• Strategie locali

• Opzioni di sicurezza

Tutto questo sia a livello locale sul server considerato sia a livello di dominio.

120
A Attributi dei metadati
Attributo Descrizione
kMDItemAttributeChangeDate Data e ora dell’ultimo cambiamento al metadata.
kMDItemAudiences Il pubblico verso il quale il file è orientato
kMDItemAuthors L’autore del documento
kMDItemCity L’origine del documento
kMDItemComment Commenti
kMDItemContactKeywords Contatti associati al documento
kMDItemContentCreationDate La data di creazione
kMDItemContentModificationDate Data dell’ultima modifica effettuata
kMDItemContentType Tipo di documento. com.adobe.pdf per i PDF
kMDItemContributors I ”partecipanti” al documento
kMDItemCopyright Copyright
kMDItemCountry Paese di origine del documento
kMDItemCoverage Collocazione geografica
kMDItemCreator L’applicazione che ha creato il documento
kMDItemDescription Descrizione del documento
kMDItemDueDate Data del documento rappresentato
kMDItemDurationSeconds Durata (in secondi) del documento
kMDItemEmailAddresses Indirizzi e-mail associati
kMDItemEncodingApplications Il nome dell’applicazione che ha codificato il documento
kMDItemFinderComment Commenti Finder del documento
kMDItemFonts I fonts usati nel documento
kMDItemHeadline Sinossi del documento
kMDItemInstantMessageAddresses Nicknames associati al documento
kMDItemInstructions Instruzioni speciali associate al documento
kMDItemKeywords Parole chiave
kMDItemKind Tipo di documento
kMDItemLanguages Lingua
kMDItemLastUsedDate Data e ora di ultima apertura del documento
kMDItemNumberOfPages Numero di pagine

121
 Attributo Descrizione
kMDItemOrganizations Organizzazione creatrice
kMDItemPageHeight Larghezza in punti del documento
kMDItemPageWidth Altezza in punti del documento
kMDItemPhoneNumbers Numeri di telefono associati al documento
kMDItemProjects Nome dei progetti associati al documento
kMDItemPublishers Editore del documento
kMDItemRecipients Recipiente del documento
kMDItemRights Link sui diritti del documento
kMDItemSecurityMethod Crittografia usata dal documento
kMDItemStarRating Valutazione (in un doc iTunes sono le ”stelle”)
kMDItemStateOrProvince Stato o provincia di origine
kMDItemTitle Titolo
kMDItemVersion Versione
kMDItemWhereFroms Provenienza del documento (e-mail o numeri di telefono)

122