Topolinux 11 - Vecchiomago

Editoriale
Bentrovati!
Quanto tempo è passato dall’ultimo numero? Moltissimo e per la
precisione sette mesi! Sono veramente tanti rispetto alla partenza
del progetto in cui le uscite avevano frequenza quasi bimestrale.
Direi che vi stiamo facendo penare le nuove uscite ma abbiamo
dalla nostra parte alcune scusanti, concedetecelo ;)
Era nostra intenzione far uscire il nuovo numero in contemporanea con la nuova veste del portale ma quest’ultimo ci sta portando via veramente più tempo del previsto e quindi per non lasciarvi
a corto di lettura e per fare un piccolo regalo natalizio abbiamo
infine deciso di pubblicare il nuovo numero sul vecchio portale e
rimandarvi a Gennaio per il nuovo vestito, vi assicuro che non ve
ne pentirete.
Prima di parlarvi del numero 11 dell’ezine, vorrei ricordarvi che
TopoLinux è in continua ricerca di persone volenterose che contribuiscano alla sua crescita.Quindi se hai scritto qualche articolo,
una pillola e vuoi vederla pubblicata quì tra le nostre pagine non
esitare ti aspettiamo!
Bene, presentate le scusanti e rinnovato l’invito direi che è il caso
di dare una panoramica di cosa troverete tra le pagine dell’ultimo numero segnalando che ai vecchi articolisti si sono affiancati
Luca Gambetta e Marco Magnatti che ringrazio.
Proseguono il loro viaggio su questo numero il tutorial su Inkscape e la rubrica echo $feedback che stando a quanto arrivato in
redazione hanno riscosso un discreto successo tra i nostri lettori,
cosa che ovviamente ci fa molto ma molto piacere.
Finalmente superati i problemi logistici siamo riusciti a pubblicare
l’ultima parte del tutorial dedicato agli attacchi DDos quindi ora
riprendete i vecchi numeri e leggete la serie tutta di un fiato.
Vi sveleremo anche come far parlare Amarok e come accedere ai
dati di un sistema che non riesce ad avviarsi.
Putroppo per problemi di studio e lavoro dobbiamo sospendere
temporanemanete il corso di Shell Script che comunque riprenderà dal prossimo numero.
Penso ora di avervi detto proprio tutto e forse di essermi anche
dilungato un po’ troppo.
Vi saluto con un augurio di Felicissimo Natale da parte di tutta la
redazione di TopoLinux!
Ringraziamenti
Fabiana per il nome dell’e-zine;
Rockaffé per tutti i suggerimenti dati;
MakPaolo per il supporto con i CSS;
AngelinoAnt per il supporto hack phpBB;
ed in particolare tutti i membri dello staff!
Numeri arretrati
I numeri arretrati dell’e-zine sono disponibili
per il download sul sito e
consultabili on-line nella sezione ‘Arretrati’
Sito Web
http://www.topolinux.org
Forum
http://forum.topolinux.org
Newsletter
Per rimanere sempre informati
su tutte le attività riguardanti l’e-zine,
è possibile iscriversi sul sito
nella sezione ‘Newsletter’
Lettere alla redazione
[email protected]
Direttore:
Lemoeb ([email protected])
Redattore:
Neon ([email protected])
Correttore di bozza:
Rolly
Giornalisti freelance:
Stonedz
JoErNano
Collaboratori esterni:
Gil (OpenSourceMania.it)
Versione elettronica curata da:
DnDVault ([email protected])
Klaudia ([email protected])
Lemoeb
Copertina:
Klaudia ([email protected])
Copyright (c) 2007 Topolinux
è garantito il permesso di copiare, distribuire e/o modificare
questo documento seguendo i termini della Licenza per
Documentazione Libera GNU, Versione 1.1 o ogni versione
successiva pubblicata dalla Free Software Foundation; con le
Sezioni Non Modificabili Sommario e Lettere alla Redazione, con i Testi
Copertina “Topolinux l’ezine italiano completamente dedicato al Pinguino”.
Una copia della licenza è acclusa nella sezione intitolata “GNU FDL”.
SO MM A RI O
Recensioni
Recensione di KDE 4 Beta 1................................................................................pag.
4
Sistema
Installazione e configurazione di Tomcat 5.5..........................................................pag.
11
Accedere ai dati di un sistema che non si avvia..................................................pag.
18
Ambiente desktop
Inkscape - Parte 2....................................................................................................pag.
21
Connettersi ad internet con un cellulare Bluetooth................................................pag.
26
Sicurezza
DDos Attacco e Difesa - Terza ed ultima parte..................................................pag.
29
Pillole
Amarok Parla!..........................................................................................................pag.
35
Echo $feedback
La rubrica che stampa a schermo i vostri consigli.............................................pag.
36
Recensioni
KDE 4 Beta 1
Nota iniziale
strato che permette alla propria applicazione di
“vivere” non cambierà, a parte la correzione dei
bug. Da adesso in poi, quindi, non sarà più tempo di giocare, si farà sul serio!
Questo articolo è stato scritto da Luca ‘Ziabice’
Gambetta, e pubblicato sul famosissimo blog
“Pollycoke”, che ha accettato la pubblicazione
su Topolinux. Tutto lo Staff di Topolinux ringrazia pubblicamente Felipe e Luca per la loro disponibilità. Potete trovare l’articolo originale al
seguente indirizzo: http://pollycoke.word-
Nonostante il freeze sono venute fuori diverse
novità, tra le quali la più succosa per me è quella
del supporto al compositing in KWin. Volevo verificare come questo fosse stato integrato nel sistema e devo dire che non sono rimasto deluso,
non c’è nessun cubo o finestra che “wobbla”, ma
tutto il resto, come vedremo, è “alive’n’kickin”.
Vi anticipo subito che già da adesso KDE 4 ha
tutte le carte in regola per fare un gran figurone.
In particolare la responsività del sistema e la velocità nell’avvio delle applicazioni mi ha favorevolmente colpito. Togliersi lo sfizio
press.com/2007/08/06/recensione-di-kde4-beta-1/
Pane al pane…
Mi tolgo subito il sassolino dalla scarpa: i programmatori di KDE hanno completamente sbagliato il piano di rilascio per KDE 4. Inutile dargli
torto, per carità (anche Vista è arrivato con anni
di ritardo), il progetto è complesso, ma chiamare
questo rilascio “beta 1″ è a dir poco controproducente, dato che crea aspettative inevitabilmente
destinate ad essere disattese. E’ una alfa e non
ci piove, prendetela quindi per quello che è: una
collezione di software altamente immaturo che
crasha ogni tre per due.
Inizialmente la prova doveva basarsi sul Live
CD “ufficioso” che potete trovare qui: http://
home.kde.org/~binner/kde-four-live/ .
Dopo il classico test effettuato usando una macchina virtuale eseguita in VirtualBox ho deciso
che era meglio usare una macchina reale. Purtroppo tutti i tentativi di boot del CD con la mia
workstation sono falliti e dato che non mi faccio
mancare nulla, ho deciso di compilare dai sorgenti un sistema minimale. La prova su strada
è stata effettuata su una distro Arch Linux aggiornata all’ultimo rilascio, che gira sul seguente
hardware:
• Athlon 64 3000+ (2ghz su socket 754)
• 1 GB Ram
• NVIDIA GeForce FX5700LE con 256 MB
RAM
• 1 HD SATA da 200 GB
• 2 HD PATA da 120 in RAID 1 su controller 3ware
Il sistema appena avviato
• Kernel 2.6.22 (ricompilato ed ottimizzato
per il sistema in uso)
…e vino al vino
“Cambiare tutto per non cambiare niente“: mai
motto fu più calzante! Lo scopo di questa release è quella di presentare al grande pubblico le
librerie stabilizzate (occhio non ancora completamente stabili), ossia le fondamenta sulle quali
costruire tutto il resto del sistema. Perciò da qui
in avanti ogni programmatore saprà che il sub-
• XOrg 7.2
• Driver NVIDIA 100.14.11
• GCC 4.2.1
• GLibc 2.6
Il sistema è stato installato nella directory /opt/
kde4. E’ stata usata la libreria Qt 4.3.0 fornita
Recensioni
nel repository “community”, installata con:
Primo impatto
pacman -S qt4
Fin da subito mi ha colpito molto la responsività del sistema: se è vero che le azioni portano
ad un crash dell’applicazione, nel poco di tempo
che questa funziona lo fa in modo rapido e reattivo, come ci si aspetterebbe da un Desktop Environment nuovo di pacca. Sarebbe poco onesto non ammettere che gran parte del merito va
attribuito alle librerie Qt4, una base solidissima
su cui impostare il sistema. Anche la resa grafica ne ha tratto beneficio, con caratteri definiti, finalmente poche cornici e grafica vettoriale dove
possibile. L’aspetto base è molto “flat”, aspetto
questo che ho molto gradito, ma la tinta ghiaccio
è un po’ troppo chiara.
Tutte le altre dipendenze erano già soddisfatte
in quanto sulla macchina è già presente KDE
3.5.7. Lo scopo della prova era vedere come si
comportasse un sistema base in un ambiente
“sterile”: perciò ho compilato in prima istanza
solo i pacchetti:
strigi-0.5.4 (messo in /usr/local)
kdelibs-3.92.0
kdepimlibs-3.92.0
kdebase-3.92.0
kdegraphics-3.92.0
La compilazione è molto semplice, davvero il
passaggio a CMake si fa sentire, rendendo il
processo chiaro ed alla portata praticamente di
chiunque (figata la percentuale di avanzamento nella compilazione). Inutile dire che in caso
di dubbi ci sono delle pagine apposite sul sito
ufficiale (http://techbase.kde.org/Getting_
Started/Build/KDE4_Alpha_1). Per farla breve
con la compilazione, dopo aver settato delle variabili di ambiente, per ogni pacchetto ho eseguito:
tar jxvf nomepacchetto.tar.bz2
cd nomepacchetto
Un assaggio dello stile utilizzato nei pannelli di
configurazione (in questo caso di KWrite). Tutto reso
molto vivo dalle belle icone e dai colori di Oxygen
mkdir build
cd build
cmake -DCMAKE_INSTALL_
PREFIX=/opt/kde4 ..
Si nota subito la presenza del “vecchio” Kicker
(che verrà sostituito da Plasma) sul quale tra
l’altro non girava la systray, rendendo le applet
normali finestre. Anche Plasma è a dieta: in questo rilascio non sono presenti componenti oltre
al classico orologio, che peraltro non funziona
correttamente. Nota personale: odio il modo in
cui Plasma si attiva, ossia il fatto che se sposto
il mouse in alto a sinistra si srotola il pannellino di controllo coi componenti. Lo trovo molto
poco funzionale e troppo invasivo, preferirei di
gran lunga una discreta applet nella systray per
controllare il tutto o una genialata (tipo click del
tastro centrale sul desktop o la pressione degli
inutili tasti Windows).
make
make install
Al termine della compilazione ho creato un utente con il quale eseguire i test di utilizzo, in un
ambiente che potrei definire “sterile”: ho infatti
rimosso tutte le variabili d’ambiente e path che
permettessero al sistema di riconoscere applicazioni preesistenti sulla macchina. Nella compilazione ho escluso il supporto a Soprano e di
conseguenza a Nepomuk, quindi niente desktop
semantico, come pure niente supporto per poppler-qt4 perchè mi avrebbe incasinato un po’ la
distro e di conseguenza niente supporto per i
PDF e i PS in Okular. Tanto sarebbe andato in
crash, fidatevi… ;)
Il fatto di avere compilato pochi sorgenti mi ha
permesso di rendermi subito conto di una cosa:
ci sono poche applicazioni, ma il sistema base
è dannatamente complesso e renderlo usabile
Recensioni
e configurabile sarà una vera sfida. C’è davvero
da perdersi tra i menu di configurazione, uno per
ogni applicazione, tutti resi più o meno semplici.
L’analisi del core ridotto mi permette allo stesso
tempo di focalizzarmi su quei componenti che
tutti useremo spesso anche senza esserne coscienti: basti pensare ad esempio che l’editor di
testo è la parte fondante anche di Kdevelop o di
Quanta. E proprio da qui voglio partire…
opzioni, ma quelle che vi servono per un editing al volo sono tutte lì nella toolbar. Davvero
bella la funzione di ricerca inline: basta premere
CTRL+F e appaiono nella statusbar i controlli
per effettuare una ricerca i cui risultati si aggiornano mano a mano che si scrive, in una maniera
simile a Firefox.
Cercando il pelo nell’uovo mi lasciano un po’
perplesse le icone: quella per l’azione “Open” è
davvero poco intellegibile, “Close” proprio fuori
contesto. Impostando la dimensione delle icone
a 64×64 la situazione migliora, ma non di molto (per farlo andate sulla toolbar, premete il tasto destro e selezionate la voce nel menu “Icon
Size”). In generale ho notato che le icone nella
loro versione a media risoluzione (22×22) sono
poco chiare, mentre danno il meglio di se a partire da 32×32 pixel.
L’editor di testo, uno solo: KWrite
L’editor di testo di default è adesso KWrite, che
raggruppa in un’unica applicazione KWrite, Kate
e KEdit già presenti in KDE 3. Il nome non vi inganni: è Kate aggiornato ed è davvero ben fatto.
Veloce, pieno di funzionalità e semplicissimo da
utilizzare. Interessante il fatto che vada bene sia
per un programmatore che per l’editing estemporaneo.
I problemi delle icone Oxygen risolti aumentando la
risoluzione
Scrivendo l’articolo con tale editor ho notato un
KWrite alle prese col codice sorgente PHP. piccolo degradamento delle performance al creIn particolare si nota l’evidenziazione dei blocchi di scere del testo. Spero che sia un problema pascodice con diversi colori seggero che verrà risolto quanto prima.
Il visualizzatore di
immagini: Gwenview
Come potete vedere dallo screenshot, quando
si edita del codice sorgente viene automaticamente fatto il folding ed utilizzato il colore per
evidenziare i blocchi di codice. Va fatto un plauso all’usabilità: nei menu ci sono un milione di
Nonostante non sia presente nel menu “Graphi-
La schermata iniziale di Gwenview
La ricerca inline di KWrite
Recensioni
cs”, il visualizzatore di immagini predefinito in
KDE 4 è Gwenview.
in due parti differenti). La cosa simpatica è che
quello che fate in una finestra si riflette nell’altra:
ad esempio se aprite Midnight Commander in
una tab che poi suddividete e staccate, mentre
muovete il cursore in una finestra potrete vedere
accadere la stessa cosa nell’altra, come se fosse uno specchio.
Ancora da rifinire in quanto ad usabilità (la barra sinistra di navigazione tra le directory grida
vendetta), brilla per la sua velocità. Si avvia in
un attimo ed in un attimo ti permette di navigare tra la tua collezione di immagini. Strano che
non mostri le preview delle immagini JPEG con
tag EXIF, spero che sia un mio errore in fase di
compilazione. Durante le prove non è mai andato in crash e per un software riscritto da zero
non può che essere un buon segno. Okular
L’occhio che tutto vede, purtroppo l’ho compilato senza il supporto per i file PDF e PS e quindi
è un po’ orbo, ma quel che c’è rende l’idea (sì
lo so è poco serio fare una recensione in questa
maniera, ma non volevo incasinare la distro, abbiate pazienza).
La split view di Konsole
Mi manca un po’ l’opzione (che sapevo sarebbe
stata implementata) di una finestra stile Yakauke
(ossia come la console di Quake), che apparisse dall’alto (o basso, destra, sinistra, of course)
col solo magico tocco di un tasto. Peccato, ma
spero la implementino. Mi piace come è stato
implementato il cambio dell’aspetto del terminale, con una live preview del cambiamento delle
impostazioni che rende bene l’idea. Attivando la
voce del menu “Settings” -> “Edit Current Profile” e selezionando la tab “Appearance”, verrete innanzitutto salutati da un simpatico effetto
grafico (simpatico solo le prime due o tre volte,
beninteso) in cui vedrete i vari stili grafici materializzarsi nel selettore e passandoci su
vedrete la finestra del
terminale sottostante
cambiare al volo.
Okular che visualizza una immagine. Sembra buona,
ma la mia Kiki è addestrata ad azzannare nelle parti
basse e a deridere la vittima dandogli del
“ciucciababbano”
E’ il “visualizzatore di tutti i formati file supportati
al mondo” di KDE 4, ossia l’applicazione che dovrebbe aprirsi nel 90% dei vostri click su un file.
Anche qui grande velocità nell’avvio, ma un pelino meno velocità nell’apertura dei file. Ho testato con diversi file CHM ed è risultato molto lento
nell’apertura, ma poi veloce nella navigazione.
La qualità del rendering dei caratteri non mi ha
convinto. Attendiamo sviluppi.
Idem per il font di
caratteri. Non so se
l’effetto “a comparsa”
verrà esteso anche
ad altri controlli, ma
va secondo me ponderato bene, dato che
potrebbe
generare
disturbo se usato su
Il terminale: Konsole
Ahhhh… il terminale, compagno di tante avventure! Per me è uno dei componenti fondamentali
del sistema ed è pure uno di quelli che ha subito
tanti interventi. Tra i più evidenti c’è la possibilità di suddividere la visualizzazione in verticale o orizzontale (ossia vedete la stessa finestra
Configurazione di Konsole
Recensioni
larga scala. Ho notato una non eccelsa velocità
di rendering del testo, speriamo bene per la versione finale…
Il file manager: Dolphin
Conosciuto ai più come “il file manager che fa
solo il file manager” o dai tignosi come “Abbiamo berciato anni contro Nautilus ed ora dovrei
dire che un clone di Nautilus era proprio quello
che ci voleva?”, nella sua attuale incarnazione
non delude, anzi cresce sempre meglio. E’ una
scheggia e perciò ho usato un suo degno rivale
per fare una prova alla pari, buttando nella mischia Thunar incluso in XFce 4.4.
Dolphin, dopo qualche personalizzazione all’interfaccia
Riportando il pupo alla sua forma base, ma lasciando attivo il pannello informazioni (sulla destra) verremo omaggiati di un elegante effetto
grafico all’avvio della preview dei file: passando
col mouse su un file infatti l’immagine cambierà con un effetto morfing allargandosi o restringendosi in modo fluido, molto bello e funzionale,
peccato che però non venga eseguito se ho un
file selezionato e passo col mouse sopra un altro file nell’elenco.
Odiosa invece la navigazione “in punta di click”:
se si clicca una volta sola viene automaticamente lanciata l’applicazione associata al tipo MIME
del file. In un attimo mentre navigavo in una directory con dei file musicali e delle immagini m’è
partito il player mp3 e Gwenview, intasandomi lo
schermo. C’è chi sostiene che il singolo click sia
più usabile, ma a me lascia un po’ perplesso. Il
guaio è che non ho trovato il modo per impostare il comportamento “a doppio click”.
Ad ogni modo nel suo utilizzo Dolphin è piacevole ed intuitivo, ma soffre di un degrado di performance non appena i file diventano un po’ di
più o la visuale viene impostata su “Columns”.
Dacci il proibito!
L’interfaccia grafica
Separati alla nascita: Dolphin (sopra) e Thunar (sotto)
Se guardate gli screenshot delle schermate iniziali dei due programmi penserete come me che
siano stati separati alla nascita: Thunar sembra
più brutto perchè non ho settato nessuno stile
Gtk, ma con le icone Tango fa comunque la sua
figura. Se d’acchito l’interfaccia è ben pulita, basta qualche click maligno nel sottomenu “View”
-> “Panels”, per trasformarla nel mostro che potete vedere in figura.
Adesso vi aspettereste fighi screenshot col tema
Oxygen, con me che tesso lodi e sbrodolo un po’
a destra e a manca. Invece vi sbagliate, perchè
ciò che sto per mostrarvi è molto meglio e molto
più arcano.
Nel pannello di controllo non ve n’è traccia, perchè per attivarlo bisogna usare tutte le arti magiche che solo un nerd possiede. Portate il mouse
sulla decorazione superiore della finestra e premete il tasto destro, selezionate “Configure Win
Recensioni
dow Behavior”, selezionate “Desktop Effects”. A
questo punto spuntate “Enable Desktop Effects”
e poi pigiate “Apply” e la pornografia è servita!
Anche KDE4 ha exposé
Dove i poteri arcani risiedono
Il selettore di applicazioni (attivabile con ALT+Tab):
trasparenze e fading a go go!
Il bello è che tutto è stato implementato in maniera ultramodulare, permettendo un controllo
fine su tutti gli effetti, proprio come avviene in
Compiz. Certo è ancora acerbo, ma sapere di
Subito dopo l’attivazione degli effetti vengono attivati
dei plugin minimi: ombre e offuscamento delle finestre
in secondo piano
Per magia compariranno le ombre sotto le finestre e quelle in secondo piano si scuriranno.
Portando il mouse nell’angolo in altro a destra
partirà l’effetto “à la Exposè” per scegliere tra
le finestre attive. Ed è solo l’inizio! Tutto l’ambiente desktop si avvantaggerà delle possibilità
di compositing.
Una caratteristica davvero interessante è che è
possibile scegliere quale motore di composizione si vuole, se OpenGL o XRender. Il che vuole
dire che anche un PC senza una scheda grafica
con driver ultimo grido può avvantaggiarsi delle
funzionalità aggiuntive (appena saranno implementate, ovviamente).
Ecco cosa si ottiene premendo “Advanced Options...”
nel dialogo “Enable desktop effects”.
Recensioni
averlo built-in è la marcia in più di KDE 4 rispetto
alla concorrenza. No, per adesso non ci sono
cubi, ma c’è tutto quello che è utile nell’uso quotidiano e non è per niente invasivo.
Nota stonata (ma non credo potesse essere altrimenti per un primo rilascio) un certo degrado
delle performance, penso che sia dovuto alla
mancata ottimizzazione per le applicazioni che
generano parecchi aggiornamenti dello schermo. Mentre scrivevo questa recensione con
KWrite ad esempio era evidente la perdita di
frame. La lunga strada verso la vittoria
Conclusioni
Ne è valsa la pena? Sì, ne è valsa la pena. Non
sono purtroppo nello stato di inebetimento da
release spaccamascella, ma so che quando mi
sveglierò dalla camera criogenica in cui mi porrò
per arrivare fresco ad ottobre (ottobre? ma chi
ci crede, facciamo fine novembre, va) troverò il
mio desktop environment dei sogni pronto a cullarmi nel mio lavoro quotidiano. Vedo tutti i pezzi, qualcuno è al proprio posto, mentre lo spazio
vuoto lo immagino riempito con la materia di cui
sono fatti i sogni.
Novembre, accendo il PC e parte “Your Ex-Lover Is Dead” degli Stars mentre le pareti intorno
a me scompaiono ed io mi libro in cielo arrivando
presso la sede del prossimo GUADEC, plano e
faccio il gesto dell’ombrello ai convenuti, mentre
grido “usabilitatemi questo!”. Poi torno a casa e
resto ore a giocare con l’orologio al Plasma, la
pistola al Plasma, i Plasmon, il BFG-9000, a plasmare mondi e benedire Aaron Seigo…
Luca ‘Zia Bice’
Gambetta
10
Sistema
Installazione e configurazione di
Tomcat 5.5
U
na guida basilare ma completa per l’installazione e la configurazione del sever
web Apache Tomcat 5.5, con alcuni preziosi suggerimenti per facilitarsi la vita. Può non
essere del tutto esaustiva, ma dovrebbe essere
più che sufficiente per comprendere il funzionamento del web server, considerando che le
informazioni reperibili in rete sono spesso frammentarie.
Il sottoscritto ha installato il server su Ubuntu linux, quindi alcuni parametri o directory possono
differire rispetto ad altri sistemi. In generale cercherò di specificare sempre quali sono le cose
dipendenti dal tipo di sistema in uso.
innanzitutto che la jvm di default in uso nel sistema sia quella che volete voi, ossia quella relativa
a JRE versione 5.0 (o 1.5, che dir si voglia) che
avete installato: potete trovare la procedura qui
per i sistemi Ubuntu. Su windows non dovrebbero esserci problemi, visto che nell’installazione
base non è prevista una virtual machine. Gli altri
si arrangino, almeno per ora.
Configurare la variabile d’ambiente $JAVA_
HOME, corrispondente al path in cui è installata
la virtual machine:
cd ~
nano .bashrc
Richiede un minimo di familiarità con java.
E aggiungete in fondo al file la riga:
Installazione
export JAVA_HOME=<path_in_
cui_avete_installato_la_jvm>
Ovviamente, scaricate e installate Java JDK, dal
sito della sun o dai repository della vostra distribuzione. Vi consiglio caldamente l’ultima versione, che al momento è la 5.0 (quella successiva
alla 1.4, per intendersi), per non avere problemi
di compatibilità con le ultime specifiche di servlet e JSP.
Un esempio di path può essere /usr/lib/jvm/java1.5.0-sun-1.5.0.06, ma questo varia a seconda
della distribuzione e della versione di java.
Scaricate Tomcat dal sito ufficiale (tomcat5.5
download page). Attualmente la versione più recente è la 5.5.17, è importante scaricare questa
in quanto corregge molti dei bug (ma non tutti…)
della versione 5.0. In generale, è bene tenere il
server sempre aggiornato alla versione più recente.
Altrimenti potete installare la versione fornita
con la vostra distribuzione, se disponibile; in
ogni caso non ve lo consiglio, in quanto le versioni presenti sui repository tendono ad essere
poco aggiornate. Nel secondo caso, tipicamente
il server viene installato in /usr/share/tomcat5,
vi consiglio di usare la stessa directory anche
se lo installate scaricandolo dal sito di Apache.
D’ora in poi faremo riferimento al percorso di installazione con $CATALINA_HOME, qualunque
esso sia.
Assicurarsi di stare utilizzando la virtual machine
giusta; è possibile che sul sistema ve ne sia più
di una installata. Per stare tranquilli, assicuratevi
Creiamo la variabile d’ambiente $CLASSPATH
che servirà per compilare file .java, e in particolare le servlet per tomcat. Il classpath indica alla
jvm dove andare a cercare le definizioni di classe necessarie alla compilazione. Nuovamente:
cd ~
nano .bashrc
E aggiungiamo
export CLASSPATH=.:./:$CATALINA_
HOME/common/lib/jsp-api.
jar:$CATALINA_HOME/common/
lib/servlet-api.jar
Dove $CATALINA_HOME è la directory in cui
è installato tomcat. Ovviamente, perchè quanto
riportato funzioni, dovete sostituire a $CATALINA_HOME il percorso di installazione, o, ancora
meglio, creare proprio tale variabile con procedimento analogo (aggiungere ”export CATALINA_HOME=<path…>”). NB: il classpath nell’esempio comprende quattro percorsi distinti,
separati da ”:”. I due archivi .jar contengono le
varie classi necessarie per servlet e jsp: bisogna
quindi far sapere, tramite il classpath, alla jvm
dove andare a cercarle, altrimenti le vostre serv11
Sistema
let non compileranno mai… Utile anche inserire
”.” nel classpath, così da poter compilare ogni
file nella sua stessa directory (la jvm cerca anche lì le definizioni necessarie), così come ”./”,
necessario per cercare nelle sottocartelle (eventuali package).
Nota: se usate un IDE, come Eclipse ad esempio, per lo sviluppo delle vostre applicazioni, non
avete bisogno di impostare il classpath, in quanto, di solito, è l’IDE stesso a richiedervi di configurare, tra le sue opzioni, i path di tutte le librerie
necessarie alla compilazione.
Estraete il contenuto dell’archivio apachetomcat-5.5.17.tar.gz che avete scaricato. Dentro la cartella bin, estraete il contenuto dell’archivio jsvc.tar.gz in jsvc. Si tratta dell’applicazione
che useremo per avviare/fermare tomcat; prima
però dobbiamo compilarla. A questo punto:
# siamo ancora dentro
la cartella bin
cd jsvc
autoconf
./configure
make
# spostiamo il file generato
dentro la cartella bin
cp jsvc ..
Rinominate l’archivio che avete scaricato ed
estratto (apache-tomcat-5.5.17 e non jsvc!), ad
esempio, in ”tomcat5.5”, e spostate la cartella in
”/usr/share/”, o dove meglio credete.
Apache fornisce anche uno script di avvio basilare, che però non funziona così com’è… Lo
script in questione è ./bin/jsvc/native/Tomcat5.
sh. Semplicemente usate quello che è riportato
nel riquadro 1, che ho modificato a partire da
quello fornito col server. Ovviamente, modificate i parametri che non corrispondono alla vostra
configurazione.
Potete usare questo script per avviare tomcat
in automatico (ve lo sconsiglio) come servizio di
sistema; ad esempio, mettendo questo script in
/usr/bin e creando un altro script “tomcat-start.
sh”, che aggiungerete agli script di avvio automatico della vostra macchina, che lo invochi con
l’opzione start; in ogni caso, seguite la procedura corretta per la vostra distribuzione. Per i
sistemi Ubuntu, la trovate qui.
Volendo si può aggiungere allo script un caso
“restart” che fermi e riavvii il server sfruttando il
codice già esistente.
Risorse correlate:
Tomcat setup: http://tomcat.apache.org/
tomcat-5.5-doc/setup.html
L’installazione termina qui, il server dovrebbe
già funzionare, ma siamo solo all’inizio… Per
vedere se tutto è ok, avviamo tomcat; se avete
installato dai repository:
cd /etc/init.d/
sudo ./tomcat5 start
# in generale,la sintassi è ./tomcat5
start|stop|restart
Oppure possiamo ottenere lo stesso risultato
semplicemente riavviando il computer…
Se invece avete installato scaricando dal sito
di apache, usate lo script che vi ho fornito. Nel
browser, andiamo a http://localhost:8080,
e dovremmo vedere la home page di default di
tomcat. La porta di default potrebbe essere 8180
se avete installato il server dai repository Ubuntu
(tratteremo nella sezione seguente come cambiare la porta di default).
Suggerimento: può risultare comodo assegnarsi
permessi di scrittura sui file contenuti in webapps
e in conf. Se avete installato dai repository, tali
file e cartelle sono di proprietà dell’utente root.
Altrimenti, sono di proprietà del vostro utente,
dal momento che avete semplicemente estratto un archivio… In questo caso ovviamente i
permessi di scrittura li avete già, ma non è una
buona pratica lasciare il vostro utente standard
come proprietario di tutta l’installazione. Il metodo migliore consiste nel creare un nuovo gruppo
di utenti (ad esempio, developers), aggiungere il
proprio account utente a tale gruppo, assegnare
i file in webapps e in conf a tale gruppo e concedere permessi di scrittura sui file agli utenti del
gruppo, impostando (o lasciando) l’utente root
come proprietario. Nel riquadro 2 sono riportati i
comandi necessari a realizzare quanto descritto
per la cartella webapps; ripetere gli ultimi due
comandi per la cartella conf.
Attenzione: se avete installato il server dai repository Ubuntu, alcune cartelle e alcuni file dentro
conf e dentro webapps sono dei collegamenti!
Le cartelle a cui puntano NON saranno influenzate dal comando chown, quindi dovrete seguire
12
Sistema
#!/bin/sh
##############################################################################
#
#
Copyright 2004 The Apache Software Foundation.
#
#
Licensed under the Apache License, Version 2.0 (the “License”);
#
you may not use this file except in compliance with the License.
#
You may obtain a copy of the License at
#
#
http://www.apache.org/licenses/LICENSE-2.0
#
#
Unless required by applicable law or agreed to in writing, software
#
distributed under the License is distributed on an “AS IS” BASIS,
#
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
See the License for the specific language governing permissions and
#
limitations under the License.
##############################################################################
#
# Small shell script to show how to start/stop Tomcat using jsvc
# Adapt the following lines to your configuration
JAVA_HOME=/usr/lib/jvm/java-1.5.0-sun-1.5.0.06
# se avete già definito CATALINA_HOME in .bash_rc potete commentare la riga seguente
CATALINA_HOME=/usr/share/tomcat5.5
DAEMON_HOME=$CATALINA_HOME/bin
TOMCAT_USER=tomcat5
# for multi instances adapt those lines.
TMP_DIR=/var/tmp
PID_FILE=/var/run/jsvc.pid
CATALINA_BASE=$CATALINA_HOME
CATALINA_OPTS=”-Djava.endorsed.dirs=$CATALINA_HOME/common/endorsed”
# ho commentato queste righe (presenti nel file originale) perchè aggiungo il classpath e gli archivi
# .jar direttamente ai paramentri di avvio
# di jsvc nel caso “start” (vedi sotto, dopo l’opzione -cp)
# CLASSPATH=\
# $JAVA_HOME/lib/tools.jar:\
# $CATALINA_HOME/bin/commons-daemon.jar:\
# $CATALINA_HOME/bin/bootstrap.jar
case “$1” in
start)
# Start Tomcat
echo “Starting Apache Tomcat 5 using Java from $JAVA_HOME...”
$DAEMON_HOME/jsvc -user $TOMCAT_USER -home $JAVA_HOME -Dcatalina.home=$CATALINA_HOME \
-Dcatalina.base=$CATALINA_BASE \
-Djava.io.tmpdir=$TMP_DIR \
-wait 10 \
-pidfile $PID_FILE \
-outfile $CATALINA_HOME/logs/catalina.out \
-errfile ‘&1’ \
$CATALINA_OPTS \
-cp $CLASSPATH:$CATALINA_HOME/bin/bootstrap.jar:$JAVA_HOME/lib/tools.jar:$CATALINA_HOME/bin/commonsdaemon.jar: \
org.apache.catalina.startup.Bootstrap
#
# To get a verbose JVM
#-verbose \
# To get a debug of jsvc.
#-debug \
echo “Done.”
exit $?
;;
stop)
# Stop Tomcat
echo “Stopping Apache Tomcat 5...”
$DAEMON_HOME/jsvc -stop -pidfile $PID_FILE org.apache.catalina.startup.Bootstrap
echo “Done.”
exit $?
;;
*)
echo “Usage tomcat.sh start|stop”
exit 1;;
esac
Riquadro 1
13
Sistema
#crea il gruppo:
sudo addgroup developers
#aggiungersi al gruppo:
sudo nano /etc/group
#cercare il nome del gruppo, e aggiungere il proprio utente alla lista, ad esempio:
# ...
# developers:x:1001:nome_utente
# ...
#assegnare utente root e gruppo developers ai file in webapps:
cd $CATALINA_HOME
sudo chown -R root:developers webapps
#concedere permessi di scrittura al gruppo:
sudo chmod -R g+w webapps
Riquadro 2
i link e ripetere la procedura nelle cartelle effettive (di solito in /etc/tomcat5, mi pare). Avere permessi di scrittura risulta utile in fase di sviluppo,
sia per fare il deploy dell’applicazione (dovete
copiare i file in webapps), sia per, eventualmente, compilare in loco i file .java.
Cambiare la porta di default del server
Nota: attenzione, quanto appena detto vale per
una installazione del server pensata per “pubblicare” il vostro lavoro. Se in fase di sviluppo
utilizzate Eclipse (ve lo consiglio caldamente),
non avrete quasi mai bisogno di toccare la vostra installazione del server, perchè sarà Eclipse stesso ad avviare tomcat usando la directory
del vostro progetto come root del webserver,
facendo automaticamente il deploy della vostra
applicazione, senza dover spostare i file nella
cartella di installazione del server. Vedremo la
cosa più in dettaglio nella sezione finale dedicata ad Eclipse.
port=”8180” minProcessors=”5”
maxProcessors=”75”
Configurazione
Abbiamo installato tomcat, adesso dobbiamo
capire come funziona. In $CATALINA_HOME vi
sono varie cartelle; tra queste:
webapps/: contiene le web application! è la cartella dove andremo a mettere le applicazioni che
creeremo. Notare bene che questa cartella non
funziona come la “root” di un tipico webserver
(www o htdocs, ad esempio, per apache). Ogni
web application va attentamente configurata tramite appositi file .xml, argomento che tratteremo
in seguito nella sezione “deployment”.
conf/: contiene file di configurazione per il server e le web applicatin pubblicate.
Iniziamo con un po’ di configurazione di base:
Installazione da repository Ubuntu: nella cartella
conf/ aprite il file server.xml e trovate le seguenti
righe:
<Connector className=”org.apache.
coyote.tomcat5.CoyoteConnector”
enableLookups=”true”
acceptCount=”10” debug=”0”
connectionTimeout=”20000”
useURIValidationHack=”false” />
Modificate l’attributo “port” cambiando il valore
da 8180 a quello che preferite. Se tomcat è l’unico server web che avete installato, può convenire usare la porta 80, così da non doverla specificare nel browser. Installazione tramite archivio
scaricato: il file è lo stesso, le righe da modificare sono leggermente diverse… non chiedetemi
perchè…
<Connector port=”8080”
maxHttpHeaderSize=”8192”
maxThreads=”150” minSpareThreads=”25”
maxSpareThreads=”75”
enableLookups=”false” redirectPort=”8443”
acceptCount=”100”
connectionTimeout=”20000”
disableUploadTimeout=”true” />
Anche qui, modificate l’attributo “port”.
Abilitare l’invoker servlet
L’invoker servlet, se attivata, permette di accedere alle web application sul server senza doverne fare il deployment, ovvero senza bisogno di
definirne il context path e senza dover scrivere il
file web.xml (ne parleremo in dettaglio nella sezione seguente). Personalmente comunque ne
sconsiglio l’utilizzo, si avranno problemi di portabilità. Per attivare l’invoker servlet, aprite il file
14
Sistema
conf/web.xml, e decommentate quanto segue:
<servlet>
<servlet-name>invoker</servlet-name>
<servlet-class>
org.apache.catalina.
servlets.InvokerServlet
</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
Struttura di una web application: vediamo ora
come deve essere organizzata la nostra applicazione. Per semplicità, facciamo riferimento
alla figura:
E decommentate, nello stesso file (un po’ di righe più in basso), anche il mapping relativo all’invoker servlet:
<servlet-mapping>
<servlet-name>invoker</servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
Aggiungere amministratori per il tomcat
manager
“Tomcat manager” è un’applicazione, accessibile dalla pagina iniziale di tomcat, che permette di monitorare e gestire le web application in
esecuzione, e inoltre di fare il deploy automatico
degli archivi .war.
Per aggiungere un utente che possa utilizzare
il manager, aprire il file conf/tomcat-users.xml e
aggiungere quanto segue:
<tomcat-users>
...
<role rolename=”manager”/>
<user username=”user” password=”password”
roles=”tomcat,manager”/>
...
</tomcat-users>
Deployment delle web application
Per “deployment” di una web application si intende in sostanza la sua pubblicazione. Per
poter essere pubblicata e risultare accessibile,
un’applicazione deve essere conforme ad un
certo “standard”.
Collocamento della web application: innanzitutto, le nostre web application, costituite da
servlet e/o pagine jsp, devono essere collocate
nella cartella webapps. Conviene porre ciascuna web application in una diversa sottocartella
di webapps. Per esempio, creiamo un’applicazione di prova, che collocheremo in webapps/
prova.
Fondamentale è WEB-INF: questa cartella
DEVE avere questo nome ed essere collocata
proprio qui. Dentro di essa troviamo:
1. il file web.xml, il descrittore di deployment
dell’applicazione, che definisce le modalità di
accesso all’applicazione ed eventuali parametri
iniziali. Ne parleremo in dettaglio fra poco.
2. la cartella classes: anche questa cartella è necessaria, e deve contenere le servlet compilate.
Se una delle classi appartiene ad un package,
bisogna collocarla in sottocartelle che rispecchino la struttura del package. Ad esempio, se
TestServlet appartiene al package MyTest, allora TestServlet.class andrà collocata in classes/
MyTest.
3. la cartella src: opzionale, può essere comoda
per tenere il sorgente dell’applicazione durante
lo sviluppo
4. la cartella lib: non in figura, anch’essa opzionale, può contenere file o archivi java condivisi
dall’applicazione.
Nella cartella principale vengono poi collocate le
pagine jsp che eventualmente fanno parte dell’applicazione. Il file welcome.html (o .jsp, .htm
o altro) viene caricato di default se nel browser
viene richiesto solo il context-path dell’applicazione, cioè con una richiesta del tipo http://
localhost:8080/context-path. Se tale file
non c’è, viene cercato un index.html|htm|jsp; se
anche questo manca, viene visualizzata la pagina di errore 404…
15
Sistema
Context path della web application: collocare la web application, con tutta la sua struttura, in webapps non è sufficiente per renderla
accessibile. Per rendere accessibili le nostre
servlet e pagine JSP, bisogna definire correttamente il context path dell’applicazione. Riprendiamo l’esempio precedente: abbiamo messo i
nostri file in webapps/prova. Andiamo allora in
$CATALINA_HOME/conf/{Server Name}/{Host
Name}, dove di solito {Server Name} è “Catalina” e {Host Name} è “localhost”. Creiamo un file
prove.xml, nel quale definiremo il Context della
web application, e in particolare l’attributo che ci
serve, il path:
<servlet> <servlet-name>ProvaServlet</
servlet-name>
<Context path=”/prova” docBase=”/
usr/share/tomcat5/webapps/prova”
reloadable=”true”>
</Context>
Ricordiamo ancora che il context-path NON
deve essere per forza “verosimile”.
L’attributo path rappresenterà la directory (o
percorso) di root della nostra applicazione. Notare che si tratta di un path “virtuale”, non deve
per forza trovare riscontro nella struttura delle
directory dell’applicazione, anche se è comodo
usare nomi simili per non confondersi. Al posto
di ”/prova”, avremmo potuto usare ”/test/prova1”.
Riprenderemo il discorso nel prossimo paragrafo, quando parleremo del descrittore di deployment. La docBase indica la posizione dei file nel
filesystem. L’attributo reloadable, messo a true,
indica al server di ricaricare l’applicazione se
ci sono delle modifiche, senza dover riavviare
tomcat. Vi sono molti alti parametri configurabili,
per maggiori dettagli, fare riferimento al sito di
Apache Tomcat: http://tomcat.apache.org/
tomcat-5.5-doc/config/context.html
Descrittore di deployment: web.xml: questo
file, da collocare in WEB-INF, mappa ciascuna
servlet della web application in una url. Vediamo
un esempio di base, con i parametri fondamentali:
<?xml version=”1.0” encoding=”ISO-8859-1”?>
<web-app xmlns=”http://java.
sun.com/xml/ns/j2ee”
xmlns:xsi=”http://www.
w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://java.
sun.com/xml/ns/j2ee http://java.sun.
com/xml/ns/j2ee/web-app_2_4.xsd”
version=”2.4”>
<display-name>Applicazione
di prova</display-name>
<servlet-class>TestServlet</servlet-class>
<init-param>
<paramname>ParametroProva</param-name>
<paramvalue>Ciao</param-value>
</init-param>
</servlet>
<servlet-mapping> <servletname>ProvaServlet</servletname> <url-pattern>/Test</urlpattern> </servlet-mapping>
</web-app>
Tra le proprietà elencate in web.xml, fondamentale è l’url-pattern associato alla servlet; esso
rappresenta l’url tramite il quale la servlet sarà
accessibile, relativamente al context-path. Analogamente a quest’ultimo, nemmeno l’url-pattern
deve necessariamente essere verosimile.
Gli url complessivi per accedere alle servlet
sono SEMPRE del tipo http://server:porta/
context-path/url-pattern.
Per accedere alle pagine JSP: http://server:
porta/context-path/percorso/nome-file.
jsp, dove percorso è, stavolta, il path vero rela-
tivo alla root della web application. In sostanza, i
file Jsp rimangono accessibili normalmente, non
vanno mappati come le servlet.
Nel nostro esempio, per accedere alla servlet “TestServlet.class”, dovremmo andare a
http://localhost:8080/prova/Test.
Per accedere all’index.jsp della figura, ci basterebbe andare a http://localhost:8080/prova/index.jsp. Se mettessimo index.jsp in una
sottocartella, ad esempio “pages”, allora andremmo a http://localhost:8080/prova/pages/index.jsp.
Al posto di ”/Test”, come url-pattern, avremmo
potuto usarne uno del tutto “inverosimile”, ad
esempio ”/servlet/prova/pippo/miotest” e non
avrebbe fatto alcuna differenza, basta che l’url
inserita nel browser corrisponda a quella complessiva che avete mappato. Può sembrare una
cosa strana, ma è invece ben congeniata: su
tomcat, solo quello che rendete esplicitamente
pubblico è accessibile agli utenti, mentre sui tra16
Sistema
dizionali server web, normalmente, tutto il contenuto di una cartella pubblica è accessibile.
Cambiare la pagina di default e di errore 404:
è possibile specificare, nel file web.xml, la pagina di default per la web-application e la pagina
che viene visualizzata quando si verifica un errore http 404, cioè un “not-found”. Per fare questo,
aggiungete quanto segue in web.xml (annidato
dentro l’elemento web-app, ovviamente):
<welcome-file-list>
<welcome-file>home.jsp</welcome-file>
</welcome-file-list>
<error-page>
<error-code>404</error-code>
<location>/error404.html</location>
</error-page>
Uso dell’invoker servlet per il deployment:
questa procedura può velocizzare il deployment
delle applicazioni, cosa che può tornare utile in
fase di sviluppo o di test, ma è in generale una
soluzione che può generare problemi di portabilità. Se l’invoker servlet è attivo, è possibile fare
il deployment di un’applicazione semplicemente
collocando le servlet e le classi compilate (.class)
in webapps/ROOT/WEB-INF/classes. Non c’è
bisogno nè del file web.xml nè di definire il context path dal momento che questi sono già definiti per l’invoker servlet e per la default servlet
(vedere conf/web.xml). Una servlet così pubblicata è accessibile a http://localhost:8080/
servlet/NomeClasseServlet, dove NomeClasseServlet è il nome della classe a cui si vuole
accedere, e “servlet” non è nient’altro che l’url
pattern associato all’invoker servlet. Ad esempio, riprendendo il caso precedente, se mettessimo la nostra TestServlet.class in ROOT/WEBINF/classes, questa sarebbe accessibile come
http://localhost:8080/servlet/TestServlet.
Eclipse & Tomcat
Per chi non lo conoscesse, Eclipse è un IDE
avanzato per lo sviluppo di applicazioni Java e,
grazie ai sempre più numerosi plugin, C/C++,
PHP…. e quello che più ci interessa, ossia applicazioni J2EE. Potete scaricare Eclipse da
http://www.eclipse.org/downloads/.
menti, potete scaricare una versione essenziale
dell’IDE, di circa 33 MB, comprendente solo il
supporto per lo sviluppo in Java (e altri plugin,
tipo JUnit), e aggiungere successivamente i
plugin che desiderate, recuperandoli attraverso
l’update manager di Eclipse. Questa seconda
soluzione può essere più lunga, ma avrete un
IDE più leggero e veloce a caricarsi. Per fare
questo, andate alla pagina di download generale
di Eclipse, dove trovate tutte le versioni disponibili, selezionate la build più recente e scorrete la
pagina fino alla voce “Platform Runtime Binary”.
Qui selezionate la versione che volete (quella
per linux). Di seguito tratteremo come aggiungere i plugin per applicazioni J2EE.
Aggiungere plugin J2EE: dal menu di Eclipse,
scegliere “Help”→“Software Updates”→“Find
and Install”. Spuntate la casella “Web Tools
Platform Updates” e proseguite. A questo punto, sotto “Web Tools Platform”, selezionate tutte
le componenti. Questo vi fornirà il supporto per
creare progetti J2EE, servlet e pagine jsp. Per lo
sviluppo di applicazioni J2EE, trovate un bellissimo tutorial qui. Non aggiungo altro, leggetevi
il tutorial, spiega tutto!
Debug: Eclipse vi permette anche di avviare il
server in modalità Debug, per controllare cosa
non va nelle vostre applicazioni. Per avviare
la modalità debug, nel tab “Servers” (ne parla
il tutorial accessibile dal link che ho messo nel
paragrafo precedente) cliccate col tasto destro
sul server tomcat, e selezionate “Debug” (se il
server è fermo) o “Restart”→“Debug” (se è già in
esecuzione). Aspettate che la procedura di avvio sia completa, fissate i “break point” facendo
doppio clic a sinistra delle linee di codice che volete monitorare, e aprite/ricaricate l’applicazione
sul browser. Automaticamente Eclipse passerà
alla “Debug Perspective”, che vi permetterà di
visualizzare il valore di tutte le variabili esistenti al momento dell’esecuzione di ciascuno dei
breakpoint.
Di default, vi viene proposto di scaricare Eclipse
SDK, che consiste di circa 110 MB, e include vari
plugin, tutorial, esempi, documentazione. Altri-
Marco Magnatti
17
Sistema
Accedere ai dati di un sistema che non
si avvia
Prologo
- “Sono quattro anni che utilizzi Debian, è mai
possibile che non ti è MAI venuto in mente di
ottimizzare le prestazioni grafiche della tua macchina installando gli appositi driver?”
- “E che ci devo fare coi driver? Non uso Linux
per giocare.”
- “Non sai cosa ti perdi.”
- “A dire la verità non saprei neanche da che
punto incominciare....”
- “Appunto!”
- “Io non lo voglio un desktop con effetti grafici
tridimensionali canterini! A me va benissimo il
mio GNOME, nero su grigio così come mamma
l’ha fatto.”
- “Scansafatiche!”
Come Accedere al Sistema in
caso di Morte Apparente
Quando, dopo aver lavorato ore e ore per configurare un particolare aspetto della propria macchina, all’avvio ti trovi di fronte a una schermata
nera, brutta, immobile e che non ti permette il
classico Ctrl+Alt+F(1-12) per accedere a una
shell, è normale sentirti salire la bile.
Nonostante la prima reazione sia sbattere i pugni sulla tastiera tu, intrepido TopoLinaro, non
devi fare altro che aprire il terzo cassetto della
scrivania, agguantare il “medikit” incastrato con
cautela tra il cacciavite a stella e il martello tedesco da 800 grammi e prepararti psicologicamente per risolvere il problema cum grano salis.
Medikit
Strumenti necessari:
1.1 CD di una distribuzione Linux a scelta
che permetta l’installazione del sistema
in modalità testuale.
Introduzione
A volte mi trovo a discutere con Lemoeb. Quella
volta ci trovavamo ad Aprilia 2, sotto il sole cocente tipico dell’Agosto nell’Agro Pontino.
IMPORTANTE La distribuzione deve
essere stata compilata per l’architettura del processore della macchina su cui
risiede il sistema Linux da riesumare.
Io personalmente uso Slackware per processori a 32 bit e Slamd per processori a
64 bit.
C’è chi dopo pranzo schiaccia un pisolino e c’è
chi si fa una chiacchierata sulle OpenGL, sui driver delle schede grafiche, sull’esistenzialismo o
sulla teoria dell’eliocentrismo dell’universo.
Quello che più mi da fastidio è che ha ragione:
non ho mai avuto voglia di stare a smanettare
per poter sfruttare al pieno le capacità della mia
scheda video.
Qualche giorno fa, forse per colpa di qualche
strano fenomeno astronomico, ho deciso che
avrei provato a installare i drivers per la mia nVidia GeForce. Ho seguito tutti i passi riportati nella guida Installare NVidia su Debian comparsa
sul mitico TopoLinux anno 1 numero 1.
Lo giuro, li ho seguiti tutti. Al riavvio però mi si è
presentato davanti uno schermo completamente nero.
Veniamo dunque allo scopo di questo articolo.
2. Un minimo di esperienza con i comandi
shell.
Preparazione
Per prima cosa devi avviare la macchina usando il CD della distribuzione Linux che hai scelto.
Devi naturalmente aver impostato l’opzione che
permette l’avvio della macchina da CD attraverso la configurazione del BIOS.
Successivamente devi seguire le istruzioni fornite dalla procedura di avvio di installazione della
suddetta distribuzione fino al punto in cui ci ti
presenta davanti una bella shell da cui poter impartire dei comandi alla macchina.
Come già specificato, personalmente consiglio
di usare una Slackware perché le uniche due
18
Sistema
istruzioni da seguire sono l’impostazione della
lingua da utilizzare durante l’installazione e della
lingua della tastiera con cui stiamo lavorando.
Quasi istantaneamente, poi, compare il login
che effettueremo da root e eccoti la tua tanto
agognata shell!
A questo punto ti devi ricordare quale partizione
di quale Hard Disk contiene i dati del sistema
Linux da riesumare. Qualora ti fosse difficile ricordare, un bel
/dev/sda4
20105347+
10736
83
13238
Linux
Partition table entries are
not in disk order
Nel mio caso si tratta del primo disco SCSI e
il sistema Linux da riesumare si trova dentro la
partizione /dev/sda4 (come da figura).
Procedura
•
Crea una cartella
fdisk /dev/hdX
Dove X può essere a, b, c, ecc a seconda se si
tratti del primo, del secondo, del terzo, ecc Hard
Disk IDE. Nel caso di Hard Disk SCSI invece la
sintassi diventa
Al riavvio del PC la cartella verrà cancellata.
fdisk /dev/sdX
Per maggiori informazioni sugli Hard Disk ti rimando all’articolo Partizionare i Dischi anno 3
numero 3 di TopoLinux.
Dopo aver lanciato fdisk, ti si presenta una
schermata di questo tipo:
DebianBox-B:/home/joe# fdisk /dev/sda
The number of cylinders for
this disk is set to 24321.
There is nothing wrong with that,
but this is larger than 1024,
and could in certain setups
cause problems with:
2) booting and partitioning
software from other OSs
(e.g., DOS FDISK, OS/2 FDISK)
Command (m for help):
A questo punto digita p e premi INVIO:
Command (m for help): p
Disk /dev/sda: 200.0 GB, 200049647616 bytes
255 heads, 63 sectors/track, 24321 cylinders
Units = cylinders of 16065
* 512 = 8225280 bytes
/dev/sda1
4506201
82
•
mount /dev/sda4 /mnt/joernano
•
Montaci dentro la partizione contenente il
sistema Linux da riesumare
Usa il chroot sulla cartella
chroot /mnt/joernano
Il comando chroot serve per impostare come
directory root (la directory / ovvero quella da cui
partono le varie /etc, /usr, /var, ecc.) la cartella
specificata dopo il comando.
Il comando chroot è estremamente utile perché,
cambiando la directory root utilizzata, permette di avere a portata di mano tutti i comandi e i
programmi che si trovano installati sul sistema
Linux montato nella cartella /mnt/joernano.
Potrai perciò facilmente accedere ai file che devi
modificare per risolvere il tuo problema.
1) software that runs at boot time
(e.g., old versions of LILO)
Device Boot
Start
Blocks
Id System
mkdir /mnt/joernano
End
1
561
Linux swap / Solaris
/dev/sda2
81722655
*
6
562
10735
FAT16
/dev/sda3
89024197+
13239
HPFS/NTFS
24321
7
Semplificando, nel mio caso stavo riesumando
una Debian e dovevo andare a modificare il file
di configurazione di Xorg. Senza usare chroot
avrei dovuto usare il percorso /mnt/joernano/etc/X11/xorg.conf per accedere a xorg.
conf. Usando il chroot: impostando come root (/)
la cartella /mnt/joernano vi accedevo direttamente attraverso il percorso /etc/X11/xorg.
conf.
N.B. Qualora il comando chroot dovesse dare il
seguente errore:
chroot: cannot execute /bin/
bash: No such file or directory
Molto probabilmente vuol dire che la distribuzione che stai usando non contiene pacchetti compilati per l’architettura del processore della tua
macchina. Usando una distribuzione corretta il
suddetto errore non dovrebbe comparire.
19
Sistema
Conclusione
In questo articolo non ho spiegato come riesumare un sistema che non si avvia: sarebbe stato
impossibile trattare ogni singolo caso e ipotizzare
per ognuno una soluzione. Mi sono invece limitato
a illustrare una semplice procedura per accedere ai dati di un sistema operativo che non si avvia.
La soluzione al problema dipende per prima
cosa dal problema in se. Non sono Wolf, non
risolvo problemi.
Ti offro solo un metodo che ti possa aiutare nel
risparmiare i soldi che spenderesti per ogni tastiera rotta in preda alla rabbia.
Usalo con saggezza.
JoErNano
20
Ambiente Desktop
Inkscape - Parte 2
S
alve a tutti maniaci del vettoriale! Vi siete
esercitati un po’ in questo mese di pausa?
Bene, perché oggi inizieremo il primo progetto
“complesso” di questa serie di tutorial: creare
una serie di pulsanti per il nostro sito.
Perché chiamiamo questo un “progetto”? Semplice: perché in questa lunga serie di tutorial su
Inkscape, ci concentreremo ogni volta su un
progetto specifico e cercando di raggiungere il
nostro risultato impareremo tecniche e trucchi di
questo meraviglioso programma.
L’ultimissima puntata del tutorial, poi, conterrà
una serie di “Tavole di riferimento” complete di
scorciatoie e trucchi, che potrete stampare e
tenere a portata di mano per facilitare il vostro
lavoro.
Scopo del progetto: creare una serie di pulsanti per il web utilizzando la grafica vettoriale.
Durata: circa un’ora
Livello: facile
Requisiti: conoscenza di base dell’interfaccia di
Inkscape e tanta tanta pazienza...
Passo 1: impostiamo la pagina
Come in ogni programma di grafica che si rispetti, anche Inkscape ci permette di definire
alcune proprietà della pagina su cui lavoreremo.
Iniziamo quindi premendo MAIUSC-CTRL-D o
andando nel menù File -> Proprietà del documento e decidiamo quale sarà la dimensione dei
tasti che creeremo.
Una mano qui e l’altra là
Prima di iniziare il nostro progetto sarà bene
spendere due parole sulla “filosofia” che sta dietro all’interfaccia di Inkscape.
Inkscape, infatti, è progettato per permettere di
lavorare tenendo sempre una mano sul mouse
e l’altra sulla tastiera: ogni pulsante ha la sua
combinazione di tasti. I tasti della barra degli
strumenti, ad esempio, sono tutte attivabili velocemente usando:
1. seleziona e trasforma oggetti (F1)
2. modifica nodi del tracciato o maniglie di
controllo (F2)
3. ingrandisci o rimpicciolisci (F3)
4. rettangoli e quadrati (F4)
5. cerchi ellissi e archi (F5)
6. stelle e poligoni (*)
7. spirali (F9)
e così via. D’ora in poi utilizzeremo spesso queste scorciatoie per velocizzare il nostro lavoro.
Progetto 1: pulsanti per il web
La finestra che abbiamo davanti ci permette di
definire molte cose.
Innanzitutto troviamo l’unità di misura predefinita per questo disegno. Lasciamola pure su “px”
cioè “pixel”. Segue il colore di sfondo della pagina. I colori in Inkscape sono sempre espressi
con 4 numeri esadecimali. Sì avete capito bene
quattro e non tre: i primi tre numeri esadecimali
(come sul web) indicano i valori di rosso verde e
blu, l’ultimo la trasparenza, dove 00 è completamente trasparente e FF è completamente opaco.
Lasciamo pure il colore di sfondo su trasparente
e spostiamoci poco sotto.
21
Ambiente Desktop
Nella sezione Formato possiamo scegliere tra
una serie di dimensioni predefinite o specificare le nostre. Inseriamo come dimensioni 190 px
per la larghezza e 45 per l’altezza, tralasciando il resto. In questa sezione c’è anche un tasto molto interessante “Adatta la pagina della
selezione” (dovrebbe essere “alla selezione”...
avvertiremo i traduttori italiani). Questo tasto ridimensiona automaticamente la pagina in base
agli oggetti selezionati nella finestra di disegno.
Ora non ne abbiamo bisogno, ma tenetelo a
mente perché ci torneremo alla fine del progetto.
Nella sezione Bordo possiamo scegliere se visualizzare i bordi e l’ombra della pagina: sono impostazioni che influiscono solo sulla finestra di disegno
e non vengono mai trasferite nel disegno stesso.
Scegliete quindi ciò che più vi piace.
Passo 2: la forma base
Ora premiamo F1 per passare allo strumento
“seleziona e trasforma oggetti” e mantenendo selezionato il nostro rettangolo inseriamo 0
come valore per x e y nella barra di controllo.
Avete capito cosa abbiamo fatto?
Dopo aver dato delle misure precise al rettangolo abbiamo detto a Inkscape di posizionarlo nel
punto 0,0 del foglio, così ora siamo sicuri che il
rettangolo in questione sia grande esattamente
come la pagina e sia tutto contenuto in essa.
Passo 3: bordi in 3D
Ora viene la parte più difficile: creare l’effetto tridimensionale.
Mantenendo selezionato il rettangolo premiamo
il pulsante “crea e modifica i gradienti” (CTRL-F1
ma potrebbe non funzionare su KDE) e tracciamo una linea obliqua sopra al rettangolo, come
mostrato qui sotto
Stiamo creando una serie di pulsanti, quindi
avranno tutti lo stesso sfondo e la stessa forma.
Passiamo quindi a creare la forma base comune
a tutti i pulsanti.
Spostiamoci nella finestra di disegno e attiviamo la forma “rettangoli” (F4), poi clicchiamo e trasciniamo per creare un rettangolo
che sia il più possibile grande come la pagina
Per dare le misure esatte al rettangolo useremo le caselle numeriche nella barra di controllo
dello strumento rettangolo. Impostiamo come
larghezza 190, come altezza 45 e come arrotondamento (Rx e Ry) 10. Controlliamo di non
aver impostato un bordo e nel caso eliminiamolo
cliccando col tasto destro sul colore del bordo
(nell’angolo in basso a sinistra della finestra,
accanto alla lettera “S:”) e scegliendo “Rimuovi
contorno”.
Poi premiamo il pulsante Modifica nella barra di
controllo di questo strumento.
Abbiamo appena aperto la finestra di modifica di
un gradiente.
Come primo colore scegliamo il bianco, poi premiamo sulla tendina sopra ai pulsanti “aggiungi
passaggio” e “rimuovi passaggio” e selezioniamo il secondo colore.
Come secondo colore scegliamo il nero. Mi raccomando: verificate che i colori siano completamente opachi, cioè che l’ultima casella numerica
sia impostata a 255
22
Ambiente Desktop
Ora torniamo allo strumento di selezione (F1) e
premiamo CTRL-D oppure il tasto
DUE VOLTE per creare due duplicati di questo rettangolo.
Uno dei due duplicati muoviamolo fuori del foglio
da qualche parte, perché per ora non ci servirà,
poi selezioniamo l’altro.
mendo entrambi i tasti selezionati nella figura
qui sotto
È il momento di scegliere il colore che daremo
ai nostri pulsanti.
Se avessimo fretta potremmo premere su uno
dei colori che vedete in basso sotto alla finestra
di disegno per assegnarlo al rettangolo selezionato, ma non abbiamo fretta, quindi clicchiamo
sul rettangolo col tasto destro del mouse e scegliamo “Riempimento e contorni” per impostarlo
a mano.
Nella sezione “Riempimento” premiamo il pulsante “colore unico” e impostiamo nella casella RGBA
il valore 3771c8ff per ottenere un bell’azzurro.
Prima di chiudere questa finestra spostiamoci
nella casella “Sfocatura” ed inseriamo 20
Ciò che abbiamo ottenuto è un rettangolo che
da un colore pieno al centro sfuma verso i bordi, lasciando intravedere il colore del rettangolo
sottostante (il gradiente nero-bianco) e dando
quindi l’impressione della tridimensionalità.
Però c’è un problema: la sfumatura continua anche oltre ai bordi della pagina e non è bella da
vedere.
Per evitare che questo accada useremo uno
strumento assai potente ma poco conosciuto di
Inkscape: il fissaggio (o “clipping” in inglese)
Il fissaggio funziona un po’ come una mascherina
di cartone ritagliata: selezionando più oggetti e impostando il fissaggio, tutto ciò che non rientra nell’area dell’oggetto più in alto diventerà invisibile.
Se non avete capito non preoccupatevi con la
pratica vi sarà tutto più chiaro...
Ora verifichiamo di avere ancora lo strumento
“seleziona e trasforma oggetti” e nella barra ci
controllo assegniamo i valori 185 a W (larghezza) e 40 a H (altezza).
Sì avete capito bene: stiamo ridimensionando
questo rettangolo colorato.
Prendete il duplicato del rettangolo che avevate spostato fuori dal disegno e tanto per essere
chiari dategli un colore assurdo come ad esempio fuxia, poi centratelo sulla pagina usando “Allinea e distribuisce oggetti”
Dovreste ottenere qualcosa come in questa figura: il rettangolo fuxia è sopra a tutti gli altri
e si intravede solo la sfumatura del rettangolo
sottostante.
Per centrarlo sulla pagina useremo lo strumento
“Allinea e distribuisce oggetti” (MAIUSC-CTRLA), impostando “relativo a” su “pagina” e pre23
Ambiente Desktop
Ora premete CTRL-A (seleziona tutto) e dal
menù Oggetto scegliete Fissaggio -> imposta.
MAGIA!
Avete capito cosa è successo? Tutto quello che
era fuori dal rettangolo fuxia, cioè i bordi sfumati che uscivano dal disegno, è stato nascosto.
Siccome stiamo lavorando in vettoriale è ancora
possibile modificare la sfumatura, il colore e tutto il resto, abbiamo solo impostato una sorta di
mascherina che nasconde tutto ciò che non era
compreso nel rettangolo fuxia.
Ora abbiamo davvero un tasto 3d, non ci resta
che aggiungere qualche icona e i testi dei nostri
pulsanti e lo faremo utilizzando i livelli.
Passo 4: I livelli
Se avete già usato The Gimp o un programma
di grafica simile, saprete già cosa sono i livelli.
Se non lo sapete vi basterà pensare ai livelli
come a fogli trasparenti appoggiati l’uno sull’altro: mentre disegnate su un livello tutto ciò che è
sugli altri livelli non viene toccato, ma ovviamente ciò che sta su un livello inferiore viene coperto
dal disegno di quello superiore.
Anche Inkscape possiede i livelli. Se guardate in basso a sinistra nella vostra finestra, infatti, vedrete scritto “Livello 1”: è il
nome di default del primo livello di Inkscape.
Prima di creare altri livelli diamogli un nome più significativo: andiamo nel menù Livello, scegliamo
“rinomina livello” e diamo come nome “pulsante.
Poi premiamo il tasto a forma di lucchetto a
fianco del nome per bloccare il livello, in questo
modo eviteremo di danneggiare questo piccolo
capolavoro che è il nostro pulsante 3d.
Ora possiamo creare un nuovo livello (Livello ->
Aggiungi livello) e dargli come nome... “download”
Selezioniamo lo strumento “Crea e modifica gli
oggetti testuali” (F8) e impostiamo nella bara di
controllo il font Sans, dimensione 18, grassetto.
Poi clicchiamo sull’area del pulsante e inseriamo il testo “DOWNLOAD”, quindi rendiamolo di colore bianco cliccando sul colore bianco nella barra dei colori in basso.
Per ora non preoccupiamoci troppo del posizionamento e pensiamo piuttosto all’icona per questo tasto “download”.
Per nostra fortuna il sito http://openclipart.org possiede una enorme collezione di
immagini vettoriali liberamente riutilizzabili.
Per questa icona abbiamo scelto l’immagine di
Selanit rilasciata sotto Public Domain e disponibile a questo indirizzo: http://openclipart.
org/Xiph/files/Selanit/3298
Salviamola sul nostro disco ed apriamola con
Inkscape (si aprirà una nuova finestra). Questa
immagine è composta, ovviamente, da molti
“pezzi”. Prima di copiarla e incollarla nel nostro disegno, quindi, selezioniamo tutto (CTRLA) e raggruppiamo tutto premendo il tasto
“Raggruppa gli oggetti selezionati” (CTRL-G)
Quindi con il solito CTRL-C e CTRL-V incolliamo l’immagine nel nostro disegno. Per ridimensionarla mantenendo le proporzioni prendiamo
la freccia diagonale in alto a destra e tenendo
premuto CTRL ingrandiamo l’immagine fino ad
ottenere qualcosa di simile alla figura qui sotto
poi correggiamo il testo spostandolo come più
ci piace e allineandolo verticalmente al centro
con lo strumento di allineamento richiamabile
con CTRL-A.
Ora blocchiamo il livello e nascondiamolo
premendo sull’occhio a fianco del lucchetto.
Poi creiamone un altro chiamato “guestbook”
e utilizzando le stesse tecniche e l’immagine di
Ausis disponibile all’indirizzo: http://openclipart.org/Xiph/files/Ausis/1557 creiamo un
pulsante come questo:
Passo 5: Pulsanti a volontà
Possiamo andare avanti creando altri pulsanti
24
Ambiente Desktop
per il nostro sito. Personalmente ho provato a
creare pulsanti utilizzando queste immagini (tutte rilasciate come Public Domain):
•
Pulsante “Contatti” http://openclipart.
org/media/files/ernes/4251 - Nessun bisogno di raggruppare prima di copiare, ho
ruotato l’immagine un poco
Alla fine salviamo l’immagine vettoriale con
CTRL-S o dal menù File in modo da mantenere
una copia di lavoro in caso dovessimo fare altri
pulsanti.
Conclusione
•
Pulsante “Notizie” http://openclipart.
org/SOMbanners/tags/noticias - Nessun
bisogno di raggruppare prima di copiare
•
Pulsante
In questa puntata abbiamo visto come impostare le Proprietà del documento, come utilizzare la
barra di controllo degli strumenti per dare valori
numerici precisi alle nostre forme, come allineare e raggruppare gli oggetti e come utilizzare i
livelli.
Nessun bisogno di raggruppare, ho ruotato
l’immagine. Vi prego di notare l’ombra del
pennello che si adatterà perfettamente alla
superficie del tasto.
Abbiamo inoltre creato il nostro primo gradiente e abbiamo utilizzato il Fissaggio, una tecnica
poco conosciuta ma estremamente potente, soprattutto se usata in congiunzione con la sfumatura di una forma.
•
Galleria http://openclipart.
org/Xiph/files/valessiobrito/3713
-
Pulsante Links http://openclipart.org/
media/files/barretr/2942 - Nessun bisogno di raggruppare
Passo 6: Esportare in PNG
Quando avremo finito di creare tutti i nostri pulsanti ci rimarranno due ultimi passaggi da fare:
ridimensionare la pagina in modo che comprenda ogni elemento del disegno e creare le immagini PNG finali che useremo nel sito (visto che le
immagini SVG sono poco supportate dai browser)
Ma soprattutto abbiamo usato Inkscape e lo
abbiamo usato tanto, e siccome l’esercizio e la
pratica portano l’uomo alla perfezione, mi raccomando: continuate ad esercitarvi!
Cosa vi aspetta nel prossimo tutorial? Non sono
ancora sicuro... forse un incredibile progetto basato su cloni, spirali e arabeschi, forse la realizzazione di un logo a mano libera utilizzando i
tracciati...
... curiosi? Beh non vi resta che aspettare la
prossima puntata :-)
Per ridimensionare la pagina facciamo così:
. sblocchiamo tutti i livelli
2. andiamo su Modifica -> Seleziona tutto in
ogni livello
3. apriamo la finestra delle Proprietà del documento (MAIUSC-CTRL-D) e premiamo il pulsante che avevamo visto all’inizio, quello con
la scritta “Adatta la pagina della selezione”
A questo punto non resta che rendere visibile un livello per volta (mantenendo ovviamente il livello “pulsante” sempre visibile), premere
MAIUSC-CTRL-E, selezionare “Pagina” (e non
“Disegno”!) e scegliere un nome per ciascuna
PNG che vogliamo creare.
Come tutte le finestre in Inkscape, anche quella
dell’esportazione del disegno non ci impedisce
di continuare a lavorare nelle altre, quindi possiamo nascondere e rendere visibili i vari livelli
senza doverla riaprire ogni volta per esportare
la nuova PNG.
CoD
25
Ambiente Desktop
Connettersi ad Internet con un cellulare
Bluetooth
I
n questa guida spiegherò brevemente come
connettersi ad internet utilizzando un cellulare GPRS/UMTS connesso via Bluetooth alla
nostra adorata Linux Box.
Il primo passo è procurarsi l’indirizzo fisico del
nostro cellulare, quindi lanciamo un bel
hcitool scan
per scoprirlo. Otterremo un output simile a questo “00:19:2D:12:30:FF Luca”, il primo risultato
è l’indirizzo fisico del cellulare, il secondo è il
nome assegnato. Io, con fantasia estrema, ho
chiamato “Luca” il mio cellulare. Annotiamoci il
numero da qualche parte, ci servirà tra un attimo. Come root (quindi utilizzando sudo con
*buntu e su con le altre distro), editiamo il file
/etc/bluetooth/rfcomm.conf con il nostro editor
preferito, e inseriamo queste righe:
Lasciamo provider come nome della connessione e proseguiamo.
rfcomm0 {
# Questo serve per indicare al nostro
# computer di assegnare un device al
# cellulare all’avvio
bind yes;
# Questo è l’indirizzo fisico di
# prima
device 00:19:2D:12:30:FF
# Questo è il canale per la
# connessione
channel 1;
# Questa è la descrizione arbitraria
# del dispositivo. Puoi anche
# lasciarlo vuoto.
comment “Nokia N70″;
}
A questo punto è necessario riavviare il servizio Bluetooth, con molte distro è sufficiente un
/etc/init.d/bluetooth restart lanciato come root,
se siamo troppo pigri per farlo basta riavviare.
Il prossimo passo è impostare i dati per la connessione vera e propria. Lanciamo come root
pppconfig, e selezioniamo la voce create, la prima.
Selezioniamo con dynamic come tipo di DNS
(con spazio si seleziona la voce), quindi premiamo invio per passare al passo successivo
Bisogna ora selezionare “PAP” come metodo di
autenticazione, quindi proseguiamo.
26
Ambiente Desktop
In questo passaggio bisogna specificare la propria volontà di inserire manualmente il dispositivo con il quale effettuare il collegamento, quindi
rispondiamo no alla proposta di usare il rilevamento automatico.
A questo punto si deve inserire il nome utente
per la connessione, che per la maggior parte degli operatori telefonici è ininfluente, tanto ci fanno pagare lo stesso :D quindi inseriamo qualsiasi cosa e proseguiamo.
Ora specifichiamo il device /dev/rfcomm0 e andiamo avanti.
Apparirà una schermata riepilogativa, salviamo
la configurazione premendo Finished
Stesso discorso per la password, qualsiasi cosa
scriviate va bene. Lasciamo il valore di default
come velocità della porta e proseguiamo. Anche
in questo passo lasciamo l’opzione predefinita,
cioè “Tone” e andiamo avanti.
Ecco, adesso bisogna inserire il numero da comporre per la connessione. Nei cellulari Nokia (e
se non sbaglio anche Sony-Ericsson) bisogna
inserire *99# per indicare l’intenzione di usare
il GRPS/UMTS. Per le altre marche sarà sufficiente una breve ricerca su internet per scoprire
il numero adatto.
Infine una schermata ci dà alcune informazioni
tecniche che possiamo tranquillamente ignorare
e proseguire. Usciamo allora da pppconfig premendo Quit.
A questo punto, se tutto è andato a buon fine,
basterà lanciare pon per iniziare la connessione
27
Ambiente Desktop
e poff per disconnettersi. Ah, fate bene attenzione alle tariffe per la navigazione web, sono davvero alte. L’anno scorso avevo attivato “Internet
GPRS in libertà” della Vodafone, che a fronte
della spesa di 20 euro per l’attivazione forniva
500 Mb di traffico (upload compreso) da utilizzare in 30 giorni, il traffico extra si paga normalmente 0.6 cent/Kb. Perché aggiungo questo?
Per quello che è successo dopo. La promozione
doveva scadere il 5 settembre, se non sbaglio.
Ebbene, il 5 settembre alle 3 del pomeriggio mi
connetto, gironzolo un po’ per il web e quindi
mi disconnetto. In serata controllo il traffico disponibile: 0,74 euro, ultimo addebito poco più di
40 euro. Cosa?! E la promozione?! Come mi ha
risposto una simpatica (?) signorina del 190, era
finita a mezzogiorno e dieci, perché io l’avevo
attivata a mezzogiorno e 10. Ovviamente dell’ora della scadenza non si faceva menzione da
nessuna parte. E io non ho mai più rivisto i miei
40 euro. State in guardia.
28
Sicurezza
DDos Attacco & Difesa
Terza ed ultima parte
Attacchi d’amplificazione
Tecniche di attacchi DDoS
Non tutti hanno a disposizione una quantità di
banda tale da poter, con un attacco flooding,
mettere in ginocchio grandi colossi come Yahoo!
o AOL, quindi già da tempo sono state messe a
punto delle tecniche che richiedono un numero minore di pacchetti rispetto al SYN Flooding
per esaurire le risorse di un sistema. Le tecniche
usate vengono chiamate Smurf e Fraggle e si
basano entrambe su una rete amplificatrice.
Obiettivo primario di un attaccante è quello di
non esporsi direttamente, dato che per le forze
dell’ordine sarebbe semplice risalire ai computer utilizzati per l’attacco vista l’enorme mole di
traffico generato. Inoltre c’è la necessità di “reclutare” computer (slave agent) per eseguire
l’attacco distribuito.
Smurf
Lo smurfing sfrutta un broadcast ping, ovvero un
pacchetto ICMP spedito all’indirizzo di broadcast
di una rete per generare un flusso di ping di ritorno veramente pericoloso. Esso si basa sulla
cattiva configurazione della rete amplificatrice
che risponde ad un ping effettuato all’indirizzo
di broadcast. L’attaccante modifica il campo mittente dei pacchetti che trasmette con l’indirizzo
IP della vittima usando lo spoofing e comincia a
spedire quanti più pacchetti può verso l’indirizzo di broadcast della rete amplificatrice. Questi
verranno inoltrati a tutti gli host attivi che invieranno pacchetti di risposta echi ICMP alla vittima, generando un traffico notevole. Per fare un
esempio ipotizziamo che l’attaccante abbia un
modem analogico e riesca a generare 33,600
Kbit di traffico al secondo. Ha a disposizione una
(o più) reti amplificatrici con 100 host. Il traffico
che la vittima riceve è circa 100 volte maggiore
di quello che genera l’attaccante, cioè 3,36 Mbit
al secondo.
Fraggle
Questo tipo di attacco utilizza la stessa tecnica
dello smurf ma utilizza pacchetti UDP anziché
ICMP. Se l’host attaccato è configurato, alla ricezione di un pacchetto UDP risponde con un
altro pacchetto UDP “echo reply”. Nel caso in
cui, invece, l’host non sia configurato, risponde
con un pacchetto “unreachable”. Il vantaggio del
Fraggle è che indipendentemente dalla configurazione dell’host, genera in ogni caso traffico, e
funziona anche nelle reti che non permettono il
ping broadcast.
Ottenere il controllo di una rete
Il primo passo da seguire è individuare una rete
di computer vulnerabile e ottenerne il controllo.
Per far ciò è possibile sfruttare le potenzialità di
numerosi software, quali worms, virus, troyan,
rootkit , il cui compito è quello di fornire il controllo remoto della macchina e fornire backdoor
utili all’attaccante per poter installare programmi
ad hoc.
Questo tipo di attacchi sono noti con il nome di
semi-automatici. In alcuni casi la comunicazione
tra i software avviene in modo diretto: l’indirizzo
dell’handler (macchina che svolge da server) è
inserito nel codice che viene successivamente
installato sullo slave. Ogni slave riferisce la propria disponibilità all’handler che salva l’indirizzo
IP su un file per le future comunicazioni.
Ovviamente quest’approccio non è dei più convenienti, poiché la scoperta di una macchina
porta all’esposizione di un’intera rete, inoltre
handler e slave restando in ascolto di connessioni e quindi sono facilmente identificabili da
scanner di rete.
In altri casi la comunicazione avviene in modo
indiretto: recenti attacchi forniscono un esempio
d’uso di reti IRC per la comunicazione tra handler e slave. Quello di IRC è solo un esempio di
come un attaccante può utilizzare servizi legittimi per scopo che non lo sono.
Nel caso la comunicazione avvenga in modo
indiretto, c’è sempre la possibilità per l’attaccante di essere scoperto. Per questo motivo si
usa una variante chiamata attacchi automatici.
La data, la durata e l’indirizzo della vittima sono
pre-programmati nel codice del software usato.
In questo modo si evita la comunicazione tra
29
Sicurezza
l’attaccante e le macchine che fanno da slave
agent. Inoltre, essendo un processo automatizzato, un attaccante è capace di compromettere
ed installare tool su un singolo host in meno di 5
secondi. In altre parole, migliaia di host possono
essere infettati in meno di un’ora.
La propagazione del codice maligno può avvenire in svariati modi:
• Origine singola: il codice risiede su uno
o più server centrali. Dopo l’infiltrazione,
il codice è spedito tramite meccanismi di
file transfer. Il worm li0n opera in questo
modo.
• Propagazione con Back-chaining: il codice viene scaricato inizialmente dalla
macchina infettata per prima. Di volta in
volta la nuova macchina infettata diventa la sorgente di propagazione. In questo
modo si evita che con la scoperta della
macchina sorgente si blocchi l’infezione
dell’intera rete. I worm Ramen e Morris
hanno usato questa tecnica di propagazione.
• Propagazione autonoma: le istruzioni di
attacco sono introdotte nell’host bersaglio direttamente in fase di exploit. Code
Red , Wharol Worm e la maggior parte
dei virus basati su e-mail utilizza questa
tecnica.
Soluzioni
Prevenzione e protezione
Possiamo distinguere due sottocategorie di protezione: meccanismi di protezione del sistema e
meccanismi di protezione del protocollo.
Meccanismi di protezione del sistema
Sono quelli volti ad aumentare il livello generale
di sicurezza del sistema, puntando l’attenzione
sugli accessi illegittimi al sistema, alla rimozione
dei bug del software, al costante aggiornamento del sistema e all’identificazione di eventuali
software maligni. Altri esempi di meccanismi di
difesa del sistema includono:
La storia insegna che non esiste una macchina
protetta al 100%, ma facendo un buon lavoro è
sicuramente possibile ridurre frequenza e forza
degli attacchi DDoS.
Meccanismi di protezione del protocollo
Sono quelli rivolti alla risoluzione del problema
della cattiva progettazione del protocollo di comunicazione. Molti protocolli contengono operazioni che risultano essere di poco costo per il
client ma dispendiose per il server. In questi casi
iniziando una larga serie di richieste simultanee
le risorse tendono ad esaurirsi facilmente.
Esempi classici sono gli attacchi TCP SYN, gli
attacchi a server d’autenticazione e gli attacchi
basati sulla malformazione del pacchetto IP.
Firewall
I firewall furono il primo passo verso il miglioramento della sicurezza. Il principio fondamentale
è quello di limitare la disponibilità di connessioni
TCP e UDP. Per fare ciò si limita l’accesso a
determinate porte e si generano lunghi log di sistema dove si trovano le informazione su tutte le
connessioni accettate e non accettate.
Negli ultimi anni è in via di sviluppo un nuovo
tipo di firewall: stateful inspection firewall. Un
firewall di questo tipo controlla l’header di un
pacchetto e prende decisioni basate su un set di
regole. La decisione di bloccare o consentire un
accesso è applicata a tutti i pacchetti seguenti
della sessione (una sessione è definita da una
sorgente, una destinazione, un protocollo e un
timer). Il corrente scopo è quello di sviluppare
uno scanner che sia capace di lavorare in tempo
reale ed applicare politiche di sicurezza bastate
su contenuti,sorgente,destinazione e porta dell’applicazione; essenzialmente distinguere buoni e cattivi pacchetti ispezionando in profondità
il pacchetto stesso. Purtroppo oggi questo tipo
di ispezione risulta ancora inefficiente poiché
spesso analizzare un pacchetto richiede molto
tempo e rallenta troppo lo smistamento dei pacchetti.
Esempi possono essere:
• accesso monitorizzato
• puzzle auction
• virus scanner
• proxy servers
• sistemi con supporto per le capability
• sistemi client-ligitimacy-based
Sviluppare un sistema di sicurezza del protocollo può rendere la vittima totalmente immune agli
attacchi basati su exploit del protocollo. Natural30
Sicurezza
mente questi approcci sono compatibili e complementari a tutti gli altri.
un indirizzo non usato.
Cercare di prevenire la possibilità di un attacco
DDoS risulta essere spesso una mossa risolutiva che però non sempre è facile mettere in pratica. La prevenzione si basa essenzialmente sulla modifica della configurazione di sistema per
eliminare ogni possibilità di attacco DDoS.
Per fare il backtracing di un attacco DoS bisogna innanzitutto vedere se il prefisso sorgente
dell’attacco è nascosto. Se non è nascosto si
può procedere tramite:
BackTracing dell’attacco DoS
• Utilizzo delle routing table
• Utilizzo dell'Internet Routing Registry
(IRR)
Metodi di intercettazione
I metodi principali per l’intercettazione di un attacco DoS sono 3: controllare l’uso della CPU,
controllare l’uso della banda, e la creazione di
ACLs (Access List). Tramite un monitoraggio
costante dell’uso della CPU, ci si può accorgere
se il computer è impegnato ad eseguire operazioni che nella norma non richiedono una tale
percentuale d’uso della CPU; questo è possibile, ad esempio, se il pc è vittima di una serie di
richieste di operazioni che hanno priorità sull’uso
della CPU e rischiando di mandare in starvation
processi importanti per il corretto funzionamento, ma che hanno priorità minore sull’accesso
alla CPU rispetto ai processi che la stanno occupando.
Tramite l’utilizzo di un NetFlow è possibile monitorare la quantità di traffico di rete in modo
da evitare che, in presenza di elevati pacchetti
magari in seguito ad un attacco SYN Flood, le
risorse di rete della vittima non riescano più a
svolgere il loro normale lavoro perché impegnate a rispondere a richieste di connessione.
Utilizzando poi un ACL (Access List) è possibile
non solo monitorare il tipo di pacchetti in uscita, in modo da potersi accorgere dell’attacco in
corso, ma anche del tipo di tale attacco, come
ad esempio un elevato invio di pacchetti di tipo
ICMP_REPLY, sono di risposta ad un’elevata
richiesta di pacchetti ICMP_REQUEST, e ciò
denota un attacco ICMP Ping Flood.
I datagrammi ICMP (Internet Control Message
Protocol) vengono spesso utilizzati per attacchi
DoS, in quanto servono per segnalare eventi
speciali come la non raggiungibilità di un host,
una redirezione di traffico, un controllo di congestione o la raggiungibilità di un host della rete.
Il vantaggio nell’utilizzo di un ACL è la possibilità
di redirezionare il traffico in ingresso proveniente da host che stanno inondando la vittima di richieste, verso un “Blackhole Router”, cioè verso
• Contattando direttamente la sorgente
dell'attacco
Se l'IP sorgente dell'attacco è nascosto, si procede tramite i seguenti metodi:
• Operando un trace dei pacchetti attraverso la rete
• Rintracciare l'ISP da cui passano i pacchetti dell'attacco
• Continuando il trace descritto nei primi
due punti fino ad arrivare all'IP sorgente
Nel primo caso, è molto semplice rintracciare la
sorgente dell'attacco semplicemente controllando le routing table interne per trovare l'IP da cui
proviene l'attacco, ma nella maggior parte degli
attacchi vengono utilizzati dei proxy che permettono di “nascondere” l'IP da cui l'attacco proviene; in tal caso si procede con l'interrogare le
routing table dei router da cui l'attacco proviene,
e tale operazione va eseguita in modo ricorsivo
fino ad arrivare alla sorgente dell'attacco, continuando di volta in volta il backtracing sull'IP del
router trovato da quello eseguito in precedenza.
In tal modo si arriva a rintracciare l'IP e il MAC
address del pc attaccante, ma, come spesso accade, questa non è un’operazione semplice da
effettuare, a causa dei notevoli redirezionamenti da parte di chi attacca, e controllare di volta
in volta le routing table di tutti i router utilizzati
nell'attacco può rivelarsi una operazione molto
costosa.
Difesa proattiva
Analizziamo ora le principali difese contro i Denial of Service.
Difesa basata sul filtraggio dei pacchetti
Questo tipo di difesa è stato uno dei primi proposti contro gli attacchi DoS, e consiste nell’inserire dei filtri degli IP di ingresso in tutti i punti
31
Sicurezza
di accesso della rete che si vuole proteggere.
Questo permette di prevenire che eventuali attaccanti inseriscano IP arbitrari nei pacchetti
coinvolti nell’attacco e inoltre riduce i tipi di attacchi che possono essere lanciati nei confronti
della rete in questione.
Tale tecnica è stata utilizzata per diversi anni,
ma col passare del tempo è divenuta sempre
più inefficace, poiché adesso attacchi DoS vengono lanciati su larga scala con un elevato numero di hosts e l’IP sorgente di tale attacco non
è mai visibile ai router di ingresso della rete sotto attacco.
Metodi di difesa contro Ping Flood Attack
La dimensione di un pacchetto ping, specificata
dal livello IP, è di 64KB. L’attacco si basa proprio
sulla dimensione di 64KB, infatti, alcuni sistemi
possono andare in crash o in reboot in presenza
di pacchetti di dimensione maggiore ai 64KB.
L’host attaccato è costretto a rispondere a numerose richieste ICMP ECHO_REQUEST con
messaggi di risposta ICMP ECHO_REPLY. Una
possibile soluzione consiste nel far sì che l’host
sotto attacco ignori le richieste ICMP di dimensioni maggiori ai 64KB. Fortunatamente questo
tipo di attacco ha successo solo se tra l’host attaccante e la vittima dell’attacco c’è una banda
sufficiente a mandare una notevole quantità di
richieste ICMP.
Metodi di difesa contro SYN Flood Attack
Come descritto in precedenza, l’attacco SYN
Flood consiste nel chiedere di instaurare connessioni ad un host vittima con hosts che non
esistono, lasciando così la vittima con una lunga
coda di connessioni in attesa dell’instaurazione.
Generalmente, l’attaccante nasconde il proprio
IP, sostituendolo con IP inesistenti, e la vittima
si ritrova in attesa di instaurare una connessione
da un host che in realtà non esiste.
Il Flood Attack è uno degli attacchi più diffusi nella tipologia DoS, ed è anche da cui è più
complesso e difficile difendersi.
Innanzitutto bisogna avere un’ottima architettura della rete da difendere, in cui tutto il traffico in
ingresso e uscita viene fatto passare attraverso
un firewall (questa architettura dovrebbe essere
applicata comunque in qualsiasi rete) che monitori il traffico.
Per difendersi in tempo contro i SYN Flood attack, è necessario che sia presente nella rete
una macchina con un monitor di rete in grado
di rilevare attacchi che agiscono ad un basso
livello di rete.
Si può anche impostare un limite al traffico ICMP
che può essere presente in una rete in un certo
intervallo di tempo.
Esistono diverse tipologie di procedure da attuare in caso di SYN Flood attack, basate a livello
dell’host attaccato e a livello di firewall. A livello
host, le procedure da seguire sono 2: la prima
prevede di diminuire il valore del timeout dello
stato SYN-RECEVEID, che generalmente è posto a 75 secondi. Diminuendo questo valore, si
riduce il numero delle connessioni instaurate a
metà, e quindi anche la durata dell’attacco. E’
anche vero però che un valore di timeout troppo
basso rischierebbe di non instaurare connessioni legittime che provengono da host con una
bassa velocità di connessione. La seconda procedura da seguire a livello di host, prevede di
incrementare la coda delle connessioni da accettare in modo da non intasarla in caso di attacco; questo dipende sopratutto dalle risorse che
l’host ha a disposizione per aumentare lo spazio
destinato alla coda.
Infine si può evitare che dalla propria rete partano attacchi smurf diretti verso altre reti, impostando i router in modo che non inoltrino verso
l’esterno pacchetti che hanno un indirizzo sorgente non presente nella sottorete gestita dal
router.
A livello firewall, è necessaria la presenza di
un gateway che agisca a livello di circuito, che
bypassi tutte le richieste di connessioni. Quando
arriva una richiesta di connessione, il pacchetto
SYN non arriva direttamente all’host indicato nel
pacchetto, ma al gateway e sarà esso a rispon-
Metodi di difesa contro Smurf Attack
Le difese possibili contro tali attacchi sono di
configurare il sistema sotto attacco in modo che
non risponda a datagrammi ICMP diretti in broadcast verso una sottorete. Molti sistemi operativi
permettono di abilitare o disabilitare la possibilità da parte dell’host di rispondere in broadcast
ad ICMP ECHO_REQUEST, inoltre si possono
impostare i router della propria rete in modo che
non siano usati per attaccare altre reti, bloccando il traffico IP in broadcast.
32
Sicurezza
dere a tale richiesta con un SYN+ACK; quando
riceve la risposta, il gateway fungerà da relay,
e si occuperà di instaurare la connessione con
l’host interessato della sua rete. Il problema di
tale scelta è che a sua volta il gateway potrà
essere oggetto di eventuali attacchi e quindi
dovrà essere in grado di gestirli; inoltre ci saranno dei ritardi introdotti nella comunicazione
dal gateway. Questo problema è uno dei punti
di debolezza riscontrato in tutte le reti in cui è
presente un firewall.
Una soluzione proposta per risolvere il problema
dei ritardi introdotti dai gateway nella comunicazione, è quella dei “gateway semi-trasparenti”.
Quando arriva una richiesta di connessione, il
gateway la lascia passare verso l’host interessato, aspettando il SYN+ACK di risposta. Una volta
passato, il gateway entra in azione generando il
necessario ACK per la chiusura del Three-WayHandshake e mandandola verso l’host della sua
rete a cui è stata richiesta la connessione. Se la
connessione in questione era legittima, il client
invia il suo ACK che viene raccolto e scartato
dal gateway in quanto la connessione per il server è stata già stabilita. In caso di un attacco,
l’ACK da parte del client esterno alla rete non
arriverà mai, e dopo il periodo di timeout della
connessione, il gateway avvierà la procedura
di fine connessione con l’host server della sua
rete. Il vantaggio dei “gateway semi-trasparenti”
è, come detto prima, il fatto che non vengono
introdotti dei ritardi.
Un ultima soluzione proposta è quella basata
sulla classificazione degli indirizzi IP sorgenti. Il
tool che permette di applicare questa procedura
si chiama Synkill e deve operare sulla macchina
incaricata di monitorare il traffico di rete. Monitorando il traffico, il Synkill classifica gli indirizzi IP
esterni nel seguente modo:
cedure del TWH e quella di fine connessione.
Il Synkill, presenta purtroppo due debolezze:
la prima, comune anche ai metodi prima menzionati, è quella di chiudere connessioni che in
realtà sono legittime provenienti da IP giudicati
inizialmente come new. Il secondo punto di debolezza del Synkill viene alla luce quando gli
IP da cui provengono gli attacchi non sono mai
ripetuti; in questo caso il database degli IP interno al Synkill non può essere utilizzato, o è
del tutto inutile, in quanto gli indirizzi IP da cui
arriva l'attacco sono sempre differenti da quelli
precedenti.
Purtroppo le normali tecniche di difesa usate per
gli attacchi DoS , non sono ugualmente efficaci
per i DDoS. La differenza risiede principalmente
nella differenza nel numero di host coinvolti e
nella mole di traffico generato.
Qui di seguito sono spiegate alcune tra le possibili soluzioni. Alcune pensate per contrastare un
particolare tipo di attacco DDoS come ad esempio un attacco verso web server. Altri approcci
invece tentano di risolvere il problema in modo
più generico.
Lo scopo di questa tassonomia è di aiutare a
capire non solo quali siano i metodi per evitare
un DDoS, ma anche scoprire come combinarli
assieme per risolvere il problema.
Rilevamento e reazione
Se la prevenzione e la protezione hanno fallito, l’unico modo per contrastare un attacco è
tentare di limitarne i danni. Per far ciò c’è bisogno di scoprire l’attacco e di rispondere ad
esso. L’obiettivo dell’identificazione dell’attacco
è quello di scoprire il più presto possibile ogni
tentativo di DDoS e di avere un basso livello di
falsi positivi.
• indirizzi affidabili (good)
Un attacco può essere scoperto attraverso Rilevazione di anomalie, Hybrid detection, Pattern
detection e Third-party detection.
• indirizzi potenzialmente sospetti (new)
Rilevazione di anomalie
• indirizzi sicuramente sospetti (bad)
Questi tipi di meccanismi si basano su un modello d’andatura normale, come ad esempio un
modello del normale traffico di rete o del normale carico di sistema. Lo stato corrente del sistema è paragonato periodicamente con i modelli
per determinare anomalie.
• indirizzi sconosciuti (null)
Quando il Synkill riceve richieste di connessioni
da indirizzi IP che rientrano nella sua categoria
di sicuramente sospetti, ha 2 possibilità di azione: avviare direttamente la procedura di fine
connessione verso l'host attaccante, oppure instaurarla e poi chiuderla tramite le apposite pro-
Il vantaggio di questo approccio rispetto ad altri,
33
Sicurezza
è che è anche attacchi di tipo non classificato
possono essere scoperti. Tuttavia questo meccanismo ha bisogno di attenzione su due problemi:
1. Livelli di tolleranza: le anomalie sono
smascherate in quando lo stato corrente
del sistema differisce dai modelli per un
certo livello. Un livello di tolleranza troppo basso può portare a troppi falsi positivi, mentre un livello troppo alto riduce la
sensibilità del meccanismo.
2. Aggiornamento dei modelli: sistemi e comunicazioni si evolvono col passare del
tempo e i modelli hanno bisogno di essere aggiornati per riflettere questo cambiamento. Solitamente i modelli si auto-aggiornano usando le statistiche generate
quando non è stato trovato nessun attacco. Questo approccio però rende il
meccanismo vulnerabile ad un eventuale
continuo aumentare degli attacchi che
possono ingannare i modelli ed evitare la
rilevazione di attacchi.
Pattern Attack Detection
Questo tipo di meccanismo memorizza le “parti-
colarità” (signatures) di un attacco ben conosciuto in un database. Ogni comunicazione è analizzata e comparata con le entries del database
per scoprire un’occorrenza dell’attacco DDoS.
Occasionalmente il database viene aggiornato
con nuove signatures.
L’ovvio lato negativo di questo approccio è che
può scoprire solo attacchi ben conosciuti. Poche
volte aiuta a scoprire un nuovo tipo di attacco ,
magari perché si tratta di una piccola variazione
di uno ben noto. Dall’altra parte, però, non vi è
la presenza di falsi positivi (o comunque la percentuale è molto bassa).
Hybrid Attack Detection
Questa strategia combina le caratteristiche del
Pattern Attack Detection e quella delle Rilevazione di Anomalie, usando i dati degli attacchi
scoperti con la Rilevazione di Anomalie per aggiornare il database delle signatures. Questo è
uno dei metodi più usati.
Third-party Attack Detection
La rilevazione è affidata ad un processo esterno che si fa carico di spedire un messaggio per
segnalare la presenza di una attacco un corso
usando una tecnica di traceback.
PinetoLUG
34
Pillole
Pillole
AmaroK parla!
In questa pillolina parlerò di AmaroK Espeak.
Cos’è? È un micro script che permette di interfacciare AmaroK con espeak, che è un sintetizzatore vocale. Il risultato? AmaroK ci dice che
canzone stiamo ascoltando! L’idea (e la realizzazione dello script) è di Pete Jewell, io ho semplicemente tradotto le due frasette fisse (”Welcome to AmaroK Espeak” e “You are listening
to:”) e cambiato la voce utilizzata da espeak,
mettendo quella italiana.
In AmaroK lo script bisogna installarlo e attivarlo: Strumenti/Gestore script/Installa script, selezionare il file appena scaricato e confermare.
Individuare nella cartellina “Generale” amarokEspeak e abilitarlo con “Esegui”. Fatto. Ora provate a riprodurre una canzone, o a mettere in
pausa e riprendere quella corrente. Soddisfatti?
P.S.: provate con una canzone in inglese…
Tuttoeniente
Che logo elaborato, eh? L’ho fatto io…
Ecco come utilizzare questo prodigio della tecnica.
Per prima cosa bisogna installare espeak, se
non è già presente nel sistema, in Ubuntu basta
un classico
apt-get install espeak
Per le distribuzioni per cui non fossero disponibili
i pacchetti precompilati, è sufficiente andare sul
sito ufficiale del progetto e scaricare i sorgenti.
Fatto questo, si può provare se funziona con
espeak -v it ‘Ciao, sono
espeak, e sono installato!’
Da notare l’opzione ‘-v it’ che specifica di utilizzare la voce italiana, anche se nulla vieta di usare
quella tedesca, francese, spagnola, portoghese,
ungherese, finlandese, ecc., basta sostituire it
con la sigla della lingua desiderata (per esempio
de, fr, es, pt, hu, fi, ecc.)
Passiamo quindi al download dello script: lo trovate qui. Consiglio a chi non avesse una connessione veloce di scaricarlo da un amico, sono
761 byte. :D
35
Echo $feedback
La rubrica che stampa a schermo i vostri
consigli sul php
B
envenuti a echo $feedback; la rubrica di Topolinux dedicata a voi, professionisti del php, e ai
codici che vorrete spedirci. Qui, in queste poche pagine, discuteremo dei vostri trucchi, delle
vostre soluzioni, analizzeremo gli script che ci manderete e produrremo qualcosa di stabile,
sicuro e adatto per l’uso in produzione.
Per cui scrivete a cod [AT] topolinux.org!
I vostri codici
Iniziamo con un piccolo script segnalatomi da tuttoeniente: si tratta di una funzioncina veloce per
calcolare il tempo di generazione di una pagina.
<?php
function getmytime(){
list($usec, $sec) = explode(‘ ‘, microtime());
return ((float) $usec + (float) $sec);
}
?>
Questa funzione sarà di sicuro utile a chi vorrà fare un po’ di “benchmarking” sul proprio sito.
Il secondo codice che vi proponiamo ci arriva da Alessio Di Fazio (slux83 @ gmail.com) ed è un
codice per la generazione del cosiddetto CAPTCHA. Per chi non lo sapesse il CAPTCHA è quella
immagine contenente caratteri alfanumerici da ricopiare in una form. Serve ad evitare che programmi automatici quali i bot spammers o altri si registrino sui nostri forum o sui nostri guestbook
inviando poi messaggi decisamente indesiderati.
Il codice è un pochino lungo ma vale la pena di essere letto: è ben commentato e indentato, come
nella migliore tradizione :)
<?
/*
* Copyright (c) 2007 by Alessio Di Fazio a.k.a. Slux
* Captcha: a captcha image generator anti-spammers.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*
* Contacts:
* ----------------------------------------* Skype:
slux-slack
* E-Mail: [email protected]
* Website: http://www.capponcino.it/alessio
*/
36
Echo $feedback
/**
* How to use:
* <img src=”captcha.php” title=”click the image to choose another value”
* alt=”captcha error”
* onclick=”javascript:this.src = ‘captcha.php?refresh=’ + Math.random();” />
*
* To include this script into your blog/guestbook or something else, you have
* to save the $text number (line 103) for example into the user session and
* control the value inserted through a form with the session value. If these
* are equals, the user isn’t a spammer!
*/
// Config
$CONFIG[ ‘width’ ]
= 180;
$CONFIG[ ‘height’ ]
= 80;
/*
* the fonts dir contain all *.ttf files named font0.ttf, font1.ttf, ...
*/
$CONFIG[ ‘font_folder’ ] = “fonts”;
//don’t type slashes
/*
* font files (how many fonts u have?)
* example: 4 = font0.ttf, font1.ttf, font2.ttf, font3.ttf
*/
$CONFIG[ ‘font_numbers’ ] = 4;
/**
* Float random function
*
* @param $intMin
* @param $intMax
* @param $intDecimals
*/
function fprand($intMin, $intMax, $intDecimals)
{
if($intDecimals)
{
$intPowerTen = pow(10, $intDecimals);
return rand($intMin * $intPowerTen, $intMax * $intPowerTen) / $intPowerTen;
}
else
return rand($intMin,$intMax);
}
function rgb_grayscale( $rgb
{
$color[ ‘r’ ] = 0.299
$color[ ‘g’ ] = 0.299
$color[ ‘b’ ] = 0.299
return $color;
}
)
* $rgb[ ‘r’ ] + 0.587 * $rgb[ ‘g’ ] + 0.114 * $rgb[ ‘b’ ];
* $rgb[ ‘r’ ] + 0.587 * $rgb[ ‘g’ ] + 0.114 * $rgb[ ‘b’ ];
* $rgb[ ‘r’ ] + 0.587 * $rgb[ ‘g’ ] + 0.114 * $rgb[ ‘b’ ];
function rgb_complementary( $rgb )
{
$color[ ‘r’ ] = 255 - $rgb[ ‘r’ ];
$color[ ‘g’ ] = 255 - $rgb[ ‘g’ ];
$color[ ‘b’ ] = 255 - $rgb[ ‘b’ ];
return $color;
}
function rgb_rand( $min=0, $max=255 )
{
$color[ ‘r’ ] = rand( $min, $max );
$color[ ‘g’ ] = rand( $min, $max );
37
Echo $feedback
}
$color[ ‘b’ ] = rand( $min, $max );
return $color;
function rgb_create( $r=0, $g=0, $b=0 )
{
$color[ ‘r’ ] = $r;
$color[ ‘g’ ] = $g;
$color[ ‘b’ ] = $b;
return $color;
}
function rgb_merge( $lhs, $rhs
{
$color[ ‘r’ ] = ( $lhs[
$color[ ‘g’ ] = ( $lhs[
$color[ ‘b’ ] = ( $lhs[
return $color;
}
)
‘r’ ] + $rhs[ ‘r’ ] ) >> 1;
‘g’ ] + $rhs[ ‘g’ ] ) >> 1;
‘b’ ] + $rhs[ ‘b’ ] ) >> 1;
/* Rand number */
$text = fprand(0, 999, rand(1, 3));
// Creates a simple image
$image = imagecreate($CONFIG[ ‘width’ ], $CONFIG[ ‘height’ ]);
// Create random colors
$rgb = array();
$rgb[ ‘background’ ] = rgb_rand( 0, 255 );
$rgb[ ‘foreground’ ] = rgb_grayscale( rgb_complementary( $rgb[ ‘background’ ] ) );
if ( $rgb[ ‘foreground’ ][ ‘r’ ] > 127 )
{
$inicio = -127;
$rgb[ ‘foreground’ ] = rgb_merge( $rgb[ ‘foreground’ ], rgb_create( 255, 255, 255 ) );
$rgb[ ‘shadow’ ] = rgb_merge( rgb_complementary( $rgb[
‘foreground’ ] ), rgb_create( 0, 0, 0 ) );
}
else
{
$inicio = 0;
$rgb[ ‘foreground’ ] = rgb_merge( $rgb[ ‘foreground’ ], rgb_create( 0, 0, 0 ) );
$rgb[ ‘shadow’ ] = rgb_merge( rgb_complementary( $rgb[
‘foreground’ ] ), rgb_create( 255, 255, 255 ) );
}
// Allocate color resources
$color = array();
foreach($rgb as $name => $value)
{
$color[$name] = imagecolorallocate( $image, $value[ ‘r’ ], $value[ ‘g’ ], $value[ ‘b’ ] );
}
// Draw background
imagefilledrectangle( $image, 0, 0, 120, 30, $color[ ‘background’ ] );
// Write some random text on background
for ( $i = 0; $i < rand( 20, 40 ); $i++ )
{
$x = rand( 0, $CONFIG[ ‘width’ ] );
$y = rand( 0, $CONFIG[ ‘height’ ] );
$f = rand( 0, 5 );
$c = rgb_grayscale( rgb_rand( 127 - $inicio, 254 - $inicio ) );
imagefttext ( $image, rand(7,14), rand(0, 170), $x, $x, imagecolorallocate(
$image, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255)), “$CONFIG[font_folder]/
font”.rand(0, $CONFIG[‘font_numbers’]-1).”.ttf”, rand(99999, 113000));
}
// Write the captcha text with shadow (improves the human vision in some cases)
38
Echo $feedback
$font_fg = “$CONFIG[font_folder]/font”.rand(0, $CONFIG[‘font_numbers’]-1).”.ttf”;
// text rotation angle
$rotation = rand(-6,8);
imagefttext( $image, 26, $rotation, 12, 52, $color[ ‘shadow’ ], $font_fg, $text);
imagefttext( $image, 26, $rotation, 10, 50, $color[ ‘foreground’ ], $font_fg, $text);
imagefttext( $image, 11, 0, 5, 76, $color[ ‘foreground’ ],
“$CONFIG[font_folder]/text.ttf”, “Click me to change!”);
// Returns the image
header( ‘Content-type: image/png’ );
imagepng( $image );
// Free resources
foreach($color as $name => $value)
{
imagecolordeallocate( $image, $value );
}
imagedestroy( $image );
?>
L’approfondimento di questa settimana
Questa settimana oltre alle email dei nostri lettori discuteremo di un argomento teorico che non
mancherà di interessare chi si occupa di database: la Normalizzazione dei dati.
La Normalizzazione
In un database si può memorizzare quasi qualsiasi cosa... il problema poi è estrarre quello che serve. Molto spesso infatti si vedono database caotici e pieni di informazioni a volte poco omogenee
tra loro che sono affetti da tremende “anomalie”, ovvero che non si comportano come dovrebbero
quando si cerca di modificare, aggiungere o eliminare un dato. Non parliamo poi di quei database
che ci mettono addirittura dei minuti per recuperare le informazioni richieste!
La fase cosiddetta di Normalizzazione è una fase molto delicata del lavoro e consiste nell’applicare
un modello di dati teorico (una delle Forme Normali dei database) che permetta di evitare tutti questi problemi che potrebbero verificarsi quando agiremo in qualche maniera sul nostro database.
Le forme normali sono 7: la prima, la seconda e la terza forma normale si usano quasi sempre,
mentre le altre (la quarta, la quinta, la forma normale Boyce-Codd e la forma normale dominio-chiave) sono piuttosto teoriche e le tralasceremo in questo breve articolo.
La Prima Forma Normale
Perché una tabella sia considerata in Prima Forma Normale deve rispondere ai seguenti requisiti:
1. ogni cella deve contenere un valore “atomico”. Un dato per ogni cella. Niente insieme di dati
in array o altre cose simili
2. ogni colonna deve avere un nome unico
3. la tabella deve avere una chiave primaria che identifica in maniera univoca le righe
4. due righe non possono essere identiche
5. non sono ammessi gruppi ripetuti di dati
Il punto 1 mette fuori gioco molte tabelle che utilizzano campi di testo per memorizzare valori separati da virgole o altri dati simili. Per esperienza so che il modo migliore per memorizzare gruppi di
dati mantenendo la prima forma normale è usare semplici sequenze di 0 e 1 in cui ogni posizione
rappresenti un valore. Ad esempio: in un sistema di utenti e gruppi, per memorizzare l’appartenenza di un utente a certi gruppi si può usare un sistema come quello mostrato nella figura qui sotto
39
Echo $feedback
Il punto 5 va sicuramente spiegato meglio: immaginate una tabella “Libri” in cui archiviare tutti i libri
della vostra casa e strutturata così:
Tabella Libri
id
Autore
Titolo
Editore
Linus Torvalds
Io amo Topolinux
Topolinux
1
2
Bill Gates
Tutti pazzi per la BSOD
Redmond press
Ci saranno sicuramente più libri che avranno lo stesso editore: bene questo significa che la vostra
tabella non è in prima forma normale.
Perché questo è importante? Perché i database relazionali sono stati progettati per gestire le relazioni tra i dati e per combattere il più possibile le anomalie che i vecchi database non-relazionali
avevano. Se ad esempio scoprissimo che il nome corretto per un editore non è “Topolinux” ma “Topolinux edizioni”, dovremmo modificare ogni riga in cui compare questo nome, senza contare che
questo sistema è assai ridondante e quindi mangia spazio e velocità di elaborazione.
Il trucco sta nel creare una seconda tabella chiamata “Editori” e contenente solo due colonne: una
chiave primaria e il nome dell’editore. Nella colonna Editore della tabella libri archivieremo solo un
puntatore (il valore della chiave primaria relativa a quell’editore nella tabella editori) ed in questo
modo avremo una tabella in Prima Forma Normale, veloce, non ridondante e aggiornabile in qualunque momento senza troppo sforzo:
Tabella Libri
id
Autore
Linus Torvalds
1
2
Bill Gates
Titolo
Io amo Topolinux
Tutti pazzi per la BSOD
Editore
1
3
Tabella Editori
id
Editore
Topolinux edizioni
1
2
Mondadori
3
Redmond press
La Seconda Forma Normale
A volte si rende necessario creare delle chiavi primarie che usino più colonne: quando questo succede la Seconda Forma Normale può essere d’aiuto nella modellazione dei dati. Una tabella che
ha una sola chiave primaria ed è in Prima Forma Normale è di sicuro anche in Seconda Forma
Normale, mentre se avete una chiave primaria “spalmata” su più colonne dovrete fare un attimo
mente locale.
I requisiti per la Seconda Forma Normale sono:
1. la tabella deve essere in Prima Forma Normale
2. nessuna colonna deve dipendere da parte della chiave
Prendiamo ancora la nostra tabella Libri, ma questa volta immaginiamo di avere più edizioni dello
stesso volume, editi però da diverse case editrici. Negli esempi precedenti per identificare ogni
riga usavamo una chiave primaria numerica memorizzata nella colonna “id”; qui invece potremmo
decidere che la chiave primaria per identificare un libro sia l’insieme delle colonne “Titolo”, “Autore”
ed “Editore”, perché di sicuro non avremo in casa due libri che abbiano tutte e tre queste colonne
uguali.
40
Echo $feedback
Stiamo usando, quindi, una chiave primaria su più colonne.
Tabella Libri
Autore
Titolo
Editore
Scaffale
Luogo di nascita autore
Linus Torvalds Io amo Topolinux
1
1
Helsinki
Linus Torvalds Io amo Topolinux
2
1
Helsinki
Tutti pazzi per la
Bill Gates
3
1
Seattle
BSOD
Come vedete un libro è stato pubblicato da due case editrici differenti, ma... che mi dite della colonna “Luogo di nascita dell’autore”? Essa dipende dall’autore, certo, ma non dall’editore del libro né
dal suo titolo: lo stesso autore può aver scritto più libri e quindi avremmo dati ripetuti nella nostra
tabella e questo potrebbe causare anomalie. Abbiamo quindi una colonna che dipende da una parte di chiave primaria, ma non dalla chiave intera (autore + titolo + editore)
Come fare a risolvere questo pasticcio che potrebbe causare anomalie di inserimento ed eliminazione? Creando, anche qui, una nuova tabella Autori contenente un codice che identifichi l’autore,
una colonna “Nome” dell’autore e una “Luogo di nascita” dell’autore. Nella tabella Libri, poi, salveremo solo il codice dell’autore e così non avremo colonne che fanno riferimento solo ad una parte
della chiave primaria
Autore
1
1
2
id
1
2
Tabella Libri
Titolo
Io amo Topolinux
Io amo Topolinux
Tutti pazzi per la BSOD
Autore
Linus Torvalds
Bill Gates
Editore
1
2
3
Scaffale
1
1
1
Tabella Autori
Luogo di nascita dell’autore
Helsinki
Seattle
La Terza Forma Normale
Se riuscirete a portare i dati in Terza Forma Normale potrete dormire sonni abbastanza tranquilli,
sicuri che il vostro db sia, almeno in teoria ordinato e pulito. Le regole perché una tabella sia considerata in Terza Forma Normale sono:
1. la tabella deve essere in Seconda Forma Normale
2. non devono esserci dipendenze transitive
Ma cosa è una dipendenza transitiva? è quella cosa che accade quando una colonna dipende da
un’altra colonna invece che dalla chiave primaria.
Immaginiamo ancora la nostra tabella Libri, ma per semplificare diciamo che abbiamo una sola
chiave primaria, come all’inizio. Siccome però siamo incredibilmente gentili e abbiamo prestato un
sacco di libri, abbiamo deciso di tenere traccia dei prestiti:
id
1
2
Tabella Libri
Autore
Titolo
Editore
Prestato a
Linus TorvalIo amo Topolinux 1
Bill Gates
ds
Tutti pazzi per la
Bill Gates
3
BSOD
Indirizzo
Redmond - Via le mani
dal codice n. 1
La colonna “Prestato a” conterrà quindi il nome della persona a cui abbiamo prestato il libro, mentre
la colonna “indirizzo” conterrà l’indirizzo della persona in questione... ebbene: non siamo in Terza
Forma Normale. Perché? Perché abbiamo una dipendenza transitiva, ovvero: la colonna “indirizzo”
dipende dalla colonna “prestato a” che dipende a sua volta dalla chiave primaria. Occorre pensare
in termini teorici: non tutte le colonne della tabella riguardano il libro o sono legate in qualche modo
ad esso e il libro è il soggetto della nostra tabella, quindi abbiamo un’anomalia: dobbiamo rimuo41
Echo $feedback
vere la colonna indirizzo. Anche qui la cosa più semplice da fare e togliere i dati che non c’entrano
con il libro e metterli in un’altra tabella.
id
1
2
Autore
Linus Torvalds
Bill Gates
id
1
Nome
Bill Gates
Tabella Libri
Titolo
Io amo Topolinux
Tutti pazzi per la BSOD
Editore
1
3
Prestato a
1
Tabella Prestiti
Indirizzo
Redmond - Via le mani dal codice n. 1
Conclusione
Normalizzare le proprie tabelle può essere un percorso lento e noioso e a volte si può arrivare a
chiedersi quale sia il senso di alcune regole che sulle prime appaiono abbastanza oscure. Ma le
tabelle sono come i palazzi: fino a un certo peso reggono, poi scricchiolano... e crollano. Quando
le tabelle iniziano ad avere 10.000 record o più ci si rende conto di quanto sia utile averle portate
in Terza Forma Normale: le anomalie di aggiunta, modifica ed eliminazione sono frequentissime e
spesso interventi multipli di vari utenti portano il database ad un livello di entropia inimmaginabile.
Con una tabella in Terza Forma Normale, invece, persino la modifica della struttura del database
o il passaggio ad un altro formato non fanno paura: i dati si incastrano alla perfezione ma sono comunque sempre separati e trattabili con tranquillità.
Anche questo mese siamo arrivati alla fine della nostra rubrica. Di cosa parleremo il mese prossimo? Ma dei vostri codici è ovvio: scrivete scrivete scrivete!
... e se volete discutere degli argomenti di questo mese, venite a trovarci sul nostro forum: http://
forum.topolinux.org/
<?php
echo “Arrivederci al prossimo numero!”;
?>
CoD
42
GNU FDL
GNU Free Documentation License
Version 1.2, November 2002
Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
0. PREAMBLE
The purpose of this License is to make a manual, textbook, or other functional and useful document
“free” in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or noncommercially.
Secondarily, this License preserves for the author and publisher a way to get credit for their work,
while not being considered responsible for modifications made by others.
This License is a kind of “copyleft”, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a
copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same
freedoms that the software does. But this License is not limited to software manuals; it can be used
for any textual work, regardless of subject matter or
whether it is published as a printed book. We recommend this License principally for works whose
purpose is instruction or reference.
1. APPLICABILITY AND DEFINITIONS
This License applies to any manual or other work, in any medium, that contains a notice placed
by the copyright holder saying it can be distributed under the terms of this License. Such a notice
grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions
stated herein. The “Document”, below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as “you”. You accept the license if you copy, modify or distribute
the work in a way requiring permission under copyright law.
A “Modified Version” of the Document means any work containing the Document or a portion of it,
either copied verbatim, or with modifications and/or translated into another language.
A “Secondary Section” is a named appendix or a front-matter section of the Document that deals
exclusively with the relationship of the publishers or authors of the Document to the Document’s
overall subject (or to related matters) and contains nothing that could fall directly within that overall
subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may
not explain any mathematics.) The relationship could be a matter of historical connection with the
subject or with related matters, or of legal, commercial, philosophical, ethical or political position
regarding them.
The “Invariant Sections” are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License.
43
GNU FDL
If a section does not fit the above definition of Secondary then it is not allowed to be designated as
Invariant. The Document may contain zero Invariant Sections. If the Document does not identify
any Invariant Sections then there are none.
The “Cover Texts” are certain short passages of text that are listed, as Front-Cover Texts or BackCover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.
A “Transparent” copy of the Document means a machine-readable copy, represented in a format
whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or
(for drawings) some widely available drawing editor, and that is suitable for input to text formatters
or for automatic translation to a variety of formats suitable for input to text formatters. A copy made
in an otherwise Transparent file format whose markup, or absence of markup, has been arranged
to thwart or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount of text. A copy that is not
“Transparent” is called “Opaque”.
Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo
input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that
can be read and edited only by
proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.
The “Title Page” means, for a printed book, the title page itself, plus such following pages as are
needed to hold, legibly, the material this License requires to appear in the title page. For works in
formats which do not have any title page as such, “Title Page” means the text near the most prominent appearance of the work’s title, preceding the beginning of the body of the text.
A section “Entitled XYZ” means a named subunit of the Document whose title either is precisely
XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here
XYZ stands for a specific section name mentioned below, such as “Acknowledgements”, “Dedications”, “Endorsements”, or “History”.) To “Preserve the Title” of such a section when you modify the
Document means that it remains a section “Entitled XYZ” according to this definition.
The Document may include Warranty Disclaimers next to the notice which states that this License
applies to the Document. These Warranty Disclaimers are considered to be included by reference
in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.
2. VERBATIM COPYING
You may copy and distribute the Document in any medium, either commercially or noncommercially,
provided that this License, the copyright notices, and the license notice saying this License applies
to the Document are reproduced in all copies, and that you add no other conditions whatsoever to
those of this License. You may not use
technical measures to obstruct or control the reading or further copying of the copies you make or
distribute. However, you may accept compensation in exchange for copies. If you distribute a large
enough number of copies you must also follow the conditions in section 3.
44
GNU FDL
You may also lend copies, under the same conditions stated above, and you may publicly display
copies.
3. COPYING IN QUANTITY
If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document’s license notice requires Cover Texts, you
must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover
Texts on the front cover, and Back-Cover Texts on
the back cover. Both covers must also clearly and legibly identify you as the publisher of these
copies. The front cover must present the full title with all words of the title equally prominent and
visible. You may add other material on the covers in addition.
Copying with changes limited to the covers, as long as they preserve the title of the Document and
satisfy these conditions, can be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you should put the first ones
listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you must
either include a machine-readable Transparent copy along with each Opaque copy, or state in or
with each Opaque copy a computer-network location from which the general network-using public
has access to download using public-standard network protocols a complete Transparent copy of
the Document, free of added material.
If you use the latter option, you must take reasonably prudent steps, when you begin distribution of
Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the
stated location until at least one year after the last time you distribute an Opaque copy (directly or
through your agents or retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version
of the Document.
4. MODIFICATIONS
You may copy and distribute a Modified Version of the Document under the conditions of sections 2
and 3 above, provided that you release the Modified Version under precisely this License, with the
Modified Version filling the role of the Document, thus licensing distribution
and modification of the Modified Version to whoever possesses a copy of it. In addition, you must
do these things in the Modified Version:
A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and
from those of previous versions (which should, if there were any, be listed in the History section of
the Document). You may use the same title as a previous version if the original publisher of that
version gives permission.
B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of
the modifications in the Modified Version, together with at least five of the principal authors of the
Document (all of its principal authors, if it has fewer than five), unless they release you from this
requirement.
C. State on the Title page the name of the publisher of the Modified Version, as the publisher.
D. Preserve all the copyright notices of the Document.
E. Add an appropriate copyright notice for your modifications adjacent to the other copyright noti45
GNU FDL
ces.
F. Include, immediately after the copyright notices, a license notice giving the public permission
to use the Modified Version under the terms of this License, in the form shown in the Addendum
below.
G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given
in the Document’s license notice.
H. Include an unaltered copy of this License.
I. Preserve the section Entitled “History”, Preserve its Title, and add to it an item stating at least
the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If
there is no section Entitled “History” in the Document, create one stating the title, year, authors,
and publisher of the Document as given on its Title Page, then add an item describing the Modified
Version as stated in the previous sentence.
J. Preserve the network location, if any, given in the Document for public access to a Transparent
copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the “History” section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original
publisher of the version it refers to gives permission.
K. For any section Entitled “Acknowledgements” or “Dedications”, Preserve the Title of the section,
and preserve in the section all the substance and tone of each of the contributor acknowledgements
and/or dedications given therein.
L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles.
Section numbers or the equivalent are not considered part of the section titles.
M. Delete any section Entitled “Endorsements”. Such a section may not be included in the Modified
Version.
N. Do not retitle any existing section to be Entitled “Endorsements” or to conflict in title with any
Invariant Section.
O. Preserve any Warranty Disclaimers.
If the Modified Version includes new front-matter sections or appendices that qualify as Secondary
Sections and contain no material copied from the Document, you may at your option designate
some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections
in the Modified Version’s license notice.
These titles must be distinct from any other section titles.
You may add a section Entitled “Endorsements”, provided it contains nothing but endorsements of
your Modified Version by various parties--for example, statements of peer review or that the text
has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one
passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover,
previously added by you or by arrangement made by the same entity you are acting on behalf of,
you may not add another; but you may replace the old one, on explicit permission from the previous
publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to use their
names for publicity for or to assert or imply endorsement of any Modified Version.
46
GNU FDL
5. COMBINING DOCUMENTS
You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination
all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty
Disclaimers.
The combined work need only contain one copy of this License, and multiple identical Invariant
Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same
name but different contents, make the title of each such section unique by adding at the end of it, in
parentheses, the name of the original author or publisher of that section if known, or else a unique
number.
Make the same adjustment to the section titles in the list of Invariant Sections in the license notice
of the combined work.
In the combination, you must combine any sections Entitled “History” in the various original documents, forming one section Entitled “History”; likewise combine any sections Entitled “Acknowledgements”, and any sections Entitled “Dedications”. You must delete all sections Entitled “Endorsements”.
6. COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other documents released under this
License, and replace the individual copies of this License in the various documents with a single
copy that is included in the collection, provided that you follow the rules of this License for verbatim
copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually under this
License, provided you insert a copy of this License into the extracted document, and follow this
License in all other respects regarding verbatim copying of that document.
7. AGGREGATION WITH INDEPENDENT WORKS
A compilation of the Document or its derivatives with other separate and independent documents or
works, in or on a volume of a storage or distribution medium, is called an “aggregate” if the copyright
resulting from the compilation is not used to limit the legal rights of the compilation’s users beyond
what the individual works permit.
When the Document is included in an aggregate, this License does not apply to the other works in
the aggregate which are not themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the
Document is less than one half of the entire aggregate, the Document’s Cover Texts may be placed
on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if
the Document is in electronic form.
Otherwise they must appear on printed covers that bracket the whole aggregate.
8. TRANSLATION
Translation is considered a kind of modification, so you may distribute translations of the Document
under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections
in addition to the original versions of these Invariant Sections. You may include a translation of
this License, and all the license notices in the Document, and any Warranty Disclaimers, provided
that you also include the original English version of this License and the original versions of those
notices and disclaimers. In case of a disagreement between the translation and the original version
47
GNU FDL
of this License or a notice or disclaimer, the original version will prevail.
If a section in the Document is Entitled “Acknowledgements”, “Dedications”, or “History”, the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.
9. TERMINATION
You may not copy, modify, sublicense, or distribute the Document except as expressly provided
for under this License. Any other attempt to copy, modify, sublicense or distribute the Document
is void, and will automatically terminate your rights under this License. However, parties who have
received copies, or rights, from you under this License will not have their licenses terminated so
long as such parties remain in full compliance.
10. FUTURE REVISIONS OF THIS LICENSE
The Free Software Foundation may publish new, revised versions of the GNU Free Documentation
License from time to time. Such new versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns. See
http://www.gnu.org/copyleft/. Each version of the License is given a distinguishing version number.
If the Document specifies that a particular numbered version of this License “or any later version”
applies to it, you have the option of following the terms and conditions either of that specified version
or of any later version that has been published (not as a draft) by the Free Software Foundation. If
the Document does not specify a version number of this License, you may choose any version ever
published (not as a draft) by the Free Software Foundation.
ADDENDUM: How to use this License for your documents
To use this License in a document you have written, include a copy of the License in the document
and put the following copyright and license notices just after the title page:
Copyright (c)
YEAR
YOUR NAME.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2
or any later version published by the Free Software Foundation;
with no Invariant Sections, no FrontCover Texts, and no Back-Cover Texts.
A copy of the license is included in the section entitled “GNU
Free Documentation License”.
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the “with...Texts.”
line with this:
with the Invariant Sections being LIST THEIR TITLES, with the
Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
If you have Invariant Sections without Cover Texts, or some other combination of the three, merge
those two alternatives to suit the situation.
If your document contains nontrivial examples of program code, we recommend releasing these
examples in parallel under your choice of free software license, such as the GNU General Public
License, to permit their use in free software.
48