Test-Security

14 Giugno 2007 3 commenti

————————————————————————————————————————————————————
————————————————————————————————————————————————————
nmap -P0 83.211.145.43

Starting Nmap 4.20 ( http://insecure.org ) at 2007-06-13 18:58 CEST
Interesting ports on ip-145-43.sn2.eutelia.it (83.211.145.43):
Not shown: 1696 filtered ports
PORT STATE SERVICE
113/tcp closed auth

Nmap finished: 1 IP address (1 host up) scanned in 419.897 seconds
————————————————————————————————————————————————————
————————————————————————————————————————————————————

nmap -P0 83.211.147.193

Starting Nmap 4.20 ( http://insecure.org ) at 2007-06-13 18:57 CEST
All 1697 scanned ports on ip-147-193.sn2.eutelia.it (83.211.147.193) are filtered

Nmap finished: 1 IP address (1 host up) scanned in 341.950 seconds

————————————————————————-
——————————————————————————————————————–
nmap -A -T4 -P0 83.211.145.43
Starting Nmap 4.20 ( http://insecure.org ) at 2007-06-14 10:51 CEST
Warning: OS detection for 83.211.145.43 will be MUCH less reliable because we did not find at least 1 open and 1 closed TCP port
Interesting ports on ip-145-43.sn2.eutelia.it (83.211.145.43):
Not shown: 1696 filtered ports
PORT STATE SERVICE VERSION
113/tcp closed auth
Device type: firewall
Running: IPCop Linux 2.4.X
OS details: Ipcop V1.4.11 firewall (Linux 2.4.31)

OS and Service detection performed. Please report any incorrect results at http://insecure.org/nmap/submit/ .
Nmap finished: 1 IP address (1 host up) scanned in 39.467 seconds

———————————————————————–
———————————————————————–
nmap -A -T4 -P0 83.211.147.193
Starting Nmap 4.20 ( http://insecure.org ) at 2007-06-14 10:52 CEST
Interesting ports on ip-147-193.sn2.eutelia.it (83.211.147.193):
Not shown: 1694 filtered ports
PORT STATE SERVICE VERSION
23/tcp open telnet ActionTec DSL router
53/tcp open domain
80/tcp open http?
1 service unrecognized despite returning data. If you know the service/version, please submit the following fingerprint at http://www.insecure.org/cgi-bin/servicefp-submit.cgi :
SF-Port80-TCP:V=4.20%I=7%D=6/14%Time=46710206%P=i586-mandriva-linux-gnu%r(
SF:GetRequest,31B,”HTTP/1.1x20200x20OKrnServer:x20Virata-EmWeb/R5_3_
SF:2rnContent-Type:x20text/htmlrnExpires:x20Thu,x2001x20Janx20197
SF:0×2000:00:00x20GMTrnCache-Control:x20no-cachernPragma:x20no-cac
SF:hernrnnnnnx20n
SF:x20nx20nx20nx20nnnnn”)%r(HTTPO
SF:ptions,5E,”HTTP/1.1x20200x20OKrnServer:x20Virata-EmWeb/R5_3_2rn
SF:Content-Length:x200rnAllow:x20HEAD,x20GET,x20OPTIONSrnrn”)%r(
SF:RTSPRequest,5D,”HTTP/1.1x20400x20Badx20RequestrnServer:x20Virata
SF:-EmWeb/R5_3_2rnContent-Length:x200rnrn400x20Badx20Requestrn”
SF:)%r(FourOhFourRequest,46,”HTTP/1.1x20404x20Notx20FoundrnServer:x
SF:20Virata-EmWeb/R5_3_2rnrn404x20Notx20Foundrn”)%r(Help,4A,”HTTP/
SF:1.1x20400x20Badx20RequestrnServer:x20Virata-EmWeb/R5_3_2rnrn
SF:400x20Badx20Requestrn”)%r(SSLSessionReq,4A,”HTTP/1.1x20400x20Bad
SF:x20RequestrnServer:x20Virata-EmWeb/R5_3_2rnrn400x20Badx20Requ
SF:estrn”)%r(SMBProgNeg,4A,”HTTP/1.1x20400x20Badx20RequestrnServer
SF::x20Virata-EmWeb/R5_3_2rnrn400x20Badx20Requestrn”)%r(LPDString
SF:,4A,”HTTP/1.1x20400x20Badx20RequestrnServer:x20Virata-EmWeb/R5_3
SF:_2rnrn400x20Badx20Requestrn”)%r(NessusTPv10,4A,”HTTP/1.1×2040
SF:0x20Badx20RequestrnServer:x20Virata-EmWeb/R5_3_2rnrn400x20Bad
SF:x20Requestrn”);
Service Info: Device: broadband router

Service detection performed. Please report any incorrect results at http://insecure.org/nmap/submit/ .
Nmap finished: 1 IP address (1 host up) scanned in 91.494 seconds
Riferimenti: Test-Security

urpmi.mandriva 2007.1 spring

18 Maggio 2007 4 commenti

###############################################################
# Mandriva Spring Mae89 #
# #
# Ho scritto questo script solo per scopo #
# personale/didattico, pertanto non mi assumo nessuna #
# sponsabilità dei danni causati da esso. #
# eseguendolo dichiari di assumerti tutte le responsabilità. #
###############################################################
#!/bin/bash
(echo “###############################################################
# Mandriva Spring #
# by Mae89 #
# #
# Ho scritto questo script solo per scopo #
# personale/didattico, pertanto non mi assumo nessuna #
# sponsabilità dei danni causati da esso. #
# eseguendolo dichiari di assumerti tutte le responsabilità. #
###############################################################”
echo “”
echo “”
echo “Clicca s per continuare o n per uscire”
read cane
if [ $cane == "s" ]; then
echo “è stata avviata l’installazione di questo script”
(
echo “Rimuovo possibili settaggi di urmpi, imposto gli indirizzi per Mandriva Sring”
urpmi.removemedia -a

urpmi.addmedia main ftp://bo.mirror.garr.it/mirrors/Mandrake/official/2007.1/i586/media/main/release with media_info/hdlist.cz
urpmi.addmedia –update main_updates ftp://bo.mirror.garr.it/mirrors/Mandrake/official/2007.1/i586/media/main/updates with media_info/hdlist.cz
urpmi.addmedia main_backports ftp://bo.mirror.garr.it/mirrors/Mandrake/official/2007.1/i586/media/main/backports with media_info/hdlist.cz
urpmi.addmedia contrib ftp://bo.mirror.garr.it/mirrors/Mandrake/official/2007.1/i586/media/contrib/release with media_info/hdlist.cz
urpmi.addmedia –update contrib_updates ftp://bo.mirror.garr.it/mirrors/Mandrake/official/2007.1/i586/media/contrib/updates with media_info/hdlist.cz
urpmi.addmedia contrib_backports ftp://bo.mirror.garr.it/mirrors/Mandrake/official/2007.1/i586/media/contrib/backports with media_info/hdlist.cz
urpmi.addmedia non-free ftp://bo.mirror.garr.it/mirrors/Mandrake/official/2007.1/i586/media/non-free/release with media_info/hdlist.cz
urpmi.addmedia –update non-free_updates ftp://bo.mirror.garr.it/mirrors/Mandrake/official/2007.1/i586/media/non-free/updates with media_info/hdlist.cz
urpmi.addmedia plf-free_backports ftp://ftp.free.fr/pub/Distributions_Linux/plf/mandriva/2007.1/free/backports/binary/i586/ with hdlist.cz
urpmi.addmedia plf-nonfree_backports ftp://ftp.free.fr/pub/Distributions_Linux/plf/mandriva/2007.1/non-free/backports/binary/i586/ with hdlist.cz
urpmi.addmedia plf-free ftp://ftp.free.fr/pub/Distributions_Linux/plf/mandriva/2007.1/free/release/binary/i586/ with hdlist.cz
urpmi.addmedia plf-nonfree ftp://ftp.free.fr/pub/Distributions_Linux/plf/mandriva/2007.1/non-free/release/binary/i586/ with hdlist.cz
#
#
#Pacchetti importanti
#
#
#
echo “Installo pacchetti indispensabili per la configurazione”
urpmi –force timidity-patch-freepats-20040611-3mdv2007.1.noarch
urpmi –force timidity-patch-gravis-1.0-24mdv2007.1.noarch
urpmi –force classpathx-jaf-1.1.1-2.2mdv2007.1.i586
urpmi –force geronimo-jaf-1.0.2-api-1.0-3.6mdv2007.1.i586
urpmi –force glibc-devel-2.4-8mdv2007.1.i586
urpmi –force uClibc-devel-0.9.28.1-1mdv2007.1.i586
urpmi –force libstdc++6-devel-4.1.2-1mdv2007.1.i586
urpmi –force libstdc++5-devel-3.3.6-3mdk.i586
urpmi –force gcc-4.1.2-1mdv2007.1.i586
urpmi –force gcc3.3-3.3.6-3mdk.i586
#
#programmi
#
#
echo “Installo i programmi”
urpmi –force unrar
urpmi –force audacious-timidity
urpmi –force mandvd
urpmi –force ksmoothdock
urpmi –force kdeutils-superkaramba
urpmi –force kdeutils-karamba
urpmi –force scummvm
urpmi –force amsn
urpmi –force tuxguitar
urpmi –force mozilla-firefox-it
urpmi –force mozilla-thunderbird-it
urpmi –force gxine
urpmi –force openoffice.org-l10n-it
urpmi –force mc
urpmi –force xterm
urpmi –force samba
urpmi –force k3b
urpmi –force rpmdrake
urpmi –force old_rpmdrake
urpmi –force wget
urpmi –force fontconfig
urpmi –force freetype2
urpmi –force freetype2-devel
urpmi –force bison
urpmi –force flex
urpmi –force libjpeg
urpmi –force libjpeg-devel
urpmi –force libpng
urpmi –force libpng-devel
urpmi –force win32-codecs
urpmi –force real-codecs
urpmi –force zlib zlib-devel
urpmi –force xorg-x11-devel
urpmi –force Mesa Mesa-devel
urpmi –force freeglut freeglut-devel
urpmi –force SDL SDL-devel
urpmi –force kpdf
#
#
#Scarico rpm dal sito e installo
#
#
echo “Scarico e Installo i plugin”
wget http://xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.xx/ComixCursors-0.4.3-1.noarch.rpm
rpm -i ComixCursors-0.4.3-1.noarch.rpm
wget http://xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.xx/flash-plugin-9.0.31.0-release.i386.rpm
rpm -i flash-plugin-9.0.31.0-release.i386.rpm
wget http://xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.xx/2re-1_5_0_09-1.2007mcnl.i586.rpm
rpm -i j2re-1_5_0_09-1.2007mcnl.i586.rpm
#
#
#Elimino file superflui post installazione
#
#
echo “Elimino file superflui”
rm –force ComixCursors-0.4.3-1.noarch.rpm
rm –force flash-plugin-9.0.31.0-release.i386.rpm
rm –force j2re-1_5_0_09-1.2007mcnl.i586.rpm
echo “InstallazioneConfigurazione conclusa con successo”
)
else
echo “Hai deciso di non installare questo script”
fi
)

Riferimenti: urpmi.mandriva 2007.1 spring

ShElL Avanzato

12 Maggio 2007 4 commenti

[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]
44. Bash: programmazione

La programmazione con la shell Bash implica la realizzazione di file script. Alcune istruzioni sono particolarmente utili nella realizzazione di questi programmi, anche se non sono necessariamente utilizzabili solo in questa circostanza.
44.1 Caratteristiche di uno script

Nei sistemi Unix esiste una convenzione attraverso la quale si automatizza l’esecuzione dei file script. Prima di tutto, uno script è un normalissimo file di testo contenente una serie di istruzioni che possono essere eseguite attraverso un interprete. Per eseguire uno script occorre quindi avviare il programma interprete e informarlo di quale script questo deve eseguire. Per esempio, il comando

$ bash pippo

avvia l’eseguibile bash come interprete dello script pippo. Per evitare questa trafila, si può dichiarare all’inizio del file script il programma che deve occuparsi di interpretarlo. Per questo si usa la sintassi seguente:

#!

Quindi, si attribuisce a questo file il permesso in esecuzione. Quando si tenta di avviare questo file come se si trattasse di un programma, il sistema avvia in realtà l’interprete.

Perché tutto possa funzionare, è necessario che il programma indicato nella prima riga dello script sia raggiungibile così come è stato indicato, cioè sia provvisto del percorso necessario. Per esempio, nel caso di uno script per la shell Bash (/bin/bash), la prima riga sarà la seguente:

#!/bin/bash

Il motivo per il quale si utilizza il simbolo # iniziale, è quello di permettere ancora l’utilizzo dello script nel modo normale, come argomento del programma interprete: rappresentando un commento non interferisce con il resto delle istruzioni.
44.1.1 Commenti

Come appena accennato, il simbolo # introduce un commento che termina alla fine della riga, cioè qualcosa che non ha alcun valore per l’interprete.
44.2 Strutture

Per la formulazione di comandi complessi si possono usare le tipiche strutture di controllo e di iterazione dei linguaggi di programmazione più comuni. Queste strutture sono particolarmente indicate per la preparazione di script di shell, ma possono essere usate anche nella riga di comando di una shell interattiva.

È importante ricordare che il punto e virgola singolo (;) viene utilizzato per indicare un punto di separazione e può essere rimpiazzato da uno o più codici di interruzione di riga.
44.2.1 for

Il comando for esegue una scansione di elementi e in corrispondenza di questi esegue una lista di comandi.

for [ in ...] ; do ; done

for [in ...]
do

done

L’elenco di parole che segue in viene espanso, generando una lista di elementi. La variabile indicata dopo for viene posta, di volta in volta, al valore di ciascun elemento di questa lista, e la lista di comandi che segue do viene eseguita ogni volta. Se in (e il suo argomento) viene omesso, il comando for esegue la lista di comandi (do) una volta per ogni parametro posizionale esistente ($1, $1,…). In pratica è come se fosse stato usato: in $@.

Il valore restituito da for è quello dell’ultimo comando eseguito all’interno della lista do, oppure zero se nessun comando è stato eseguito.

Esempi

L’esempio seguente mostra uno script che, una volta eseguito, emette in sequenza gli argomenti che gli sono stati forniti.

#!/bin/bash
for i in $*
do
echo $i
done

L’esempio seguente mostra uno script un po’ più complicato che si occupa di archiviare ogni file e directory indicati come argomenti.

#!/bin/bash
ELENCO_DA_ARCHIVIARE=$*
for DA_ARCHIVIARE in $ELENCO_DA_ARCHIVIARE
do
tar czvf ${DA_ARCHIVIARE}.tgz $DA_ARCHIVIARE
done

44.2.2 select

Il comando select permette all’utente di effettuare una scelta inserendo un valore attraverso la tastiera. select è stato ereditato dalla shell Korn.

select [ in ...] ; do ; done

select [in ...]
do

done

L’elenco di parole che segue la in viene espanso, generando una lista di elementi. L’insieme delle parole espanse viene emesso attraverso lo standard error, ognuna preceduta da un numero. Se in (e il suo argomento) viene omesso, vengono utilizzati i parametri posizionali ($1, $2,…). In pratica è come se fosse stato usato in $@.

Dopo l’emissione dell’elenco, viene mostrato l’invito contenuto nella variabile PS3 e viene letta una riga dallo standard input. Se la riga consiste del numero corrispondente a una delle parole mostrate, allora il valore della variabile indicata dopo select viene posto a quella parola (cioè quella parola viene assegnata alla variabile). Se la riga è vuota (probabilmente è stato premuto soltanto [Invio]), l’elenco e l’invito vengono emessi nuovamente. Se viene letto il carattere ([Ctrl+d]), il comando termina. Qualsiasi altro valore letto fa sì che la variabile sia posta al valore della stringa nulla. La riga letta viene salvata nella variabile REPLY. La lista di comandi che segue do viene eseguita dopo ciascuna selezione fino a che non viene incontrato un comando break o return.

Il valore restituito da select è quello dell’ultimo comando eseguito all’interno della lista do, oppure zero se nessun comando è stato eseguito.

Esempi

L’esempio seguente mostra uno script che fa apparire un menu composto dagli argomenti fornitigli; a ogni selezione mostra quello selezionato.

#!/bin/bash
select i in $*
do
echo “hai selezionato $i premendo $REPLY”
echo “”
echo “premi Ctrl+c per terminare”
done

44.2.3 case

Il comando case permette di eseguire una scelta nell’esecuzione di varie liste di comandi. La scelta viene fatta confrontando una parola (di solito una variabile) con una serie di modelli. Se viene trovata una corrispondenza con uno dei modelli, la lista di comandi relativa viene eseguita.

case in [ [ | ]… ) ;; ]… esac

case in
[ [ | ]… ) ;; ]

esac

La parola che segue case viene espansa e quindi confrontata con ognuno dei modelli, usando le stesse regole dell’espansione di percorso (i nomi dei file). La barra verticale (|) viene usata per separare i modelli quando questi rappresentano possibilità diverse di un’unica scelta.

Quando viene trovata una corrispondenza, viene eseguita la lista di comandi corrispondente. Dopo il primo confronto riuscito, non ne vengono controllati altri dei successivi.

Il valore restituito è zero se nessun modello combacia. Altrimenti, è lo stesso valore restituito dall’ultimo comando eseguito, contenuto all’interno della lista.

Esempi

L’esempio seguente mostra uno script che fa apparire un messaggio diverso a seconda dell’argomento fornitogli.

#!/bin/bash
case $1 in
-a | -A | –alpha) echo “alpha” ;;
-b) echo “bravo” ;;
-c) echo “charlie” ;;
esac

Come si può notare, per selezionare alpha si possono utilizzare tre opzioni diverse.

44.2.4 if

Il comando if permette di eseguire liste di comandi differenti, in funzione di una o più condizioni, espresse anch’esse in forma di lista di comandi.

if ; then
;
[ elif ; then
; ]…
[ else ; ]
fi

if
then

[elif
then
]

[else
]
fi

Inizialmente viene eseguita la lista che segue if che costituisce la condizione. Se il valore restituito da questa lista è zero (cioè Vero), allora viene eseguita la lista seguente then e il comando termina. Altrimenti viene eseguita ogni elif in sequenza, fino a che ne viene trovata una la cui condizione si verifica. Se nessuna condizione si verifica, viene eseguita la lista che segue else, sempre che esista.

Il valore restituito è quello dell’ultimo comando eseguito, oppure zero se non ne è stato eseguito alcuno.

Esempi

L’esempio seguente mostra uno script che fa apparire un messaggio di avvertimento se non è stato utilizzato alcun argomento, altrimenti si limita a visualizzarli.

#!/bin/bash
if [ $# = 0 ]
then
echo “devi fornire almeno un argomento”
else
echo $*
fi

L’esempio seguente mostra uno script attraverso il quale si tenta di creare una directory e se l’operazione fallisce viene emessa una segnalazione di errore.

#!/bin/bash
if ! mkdir deposito
then
echo “Non è stato possibile creare la directory “deposito”"
else
echo “È stata creata la directory “deposito”"
fi

44.2.5 while

Il comando while permette di eseguire un gruppo di comandi in modo ripetitivo mentre una certa condizione continua a dare il risultato Vero.

while ; do ; done

while
do

done

Il comando while esegue ripetitivamente la lista che segue do finché la lista che rappresenta la condizione continua a restituire il valore zero (Vero).

Il valore restituito dal comando è lo stesso di quello della lista che segue do, oppure zero se la condizione non si è mai verificata.

Esempi

#!/bin/bash
RISPOSTA=”continua”
while [ $RISPOSTA != "fine" ]
do
echo “usa la parola fine per terminare”
read RISPOSTA
done

All’interno dei comandi composti si utilizzano spesso delle condizioni racchiuse tra parentesi quadre. L’uso delle parentesi quadre è una forma abbreviata del comando interno test.

44.2.6 until

Il comando until permette di eseguire un gruppo di comandi in modo ripetitivo mentre una certa condizione continua a dare il risultato Falso.

until ; do ; done

until
do

done

Il comando until è analogo a while, cambia solo l’interpretazione della lista che rappresenta la condizione nel senso che il risultato di questa viene invertito (negazione logica).
44.2.7 Funzioni

Attraverso le funzioni è possibile dare un nome a un gruppo di liste di comandi, in modo da poterlo richiamare come si fa per un comando interno normale. Sotto questo aspetto, le funzioni vengono impiegate normalmente all’interno di file script.

[ function ] () { … ; }

[function] () {

}

Le funzioni vengono eseguite nel contesto della shell corrente e quindi non vengono attivati nuovi processi per la loro interpretazione (ciò al contrario di quanto capita quando viene avviata l’interpretazione di un nuovo script).

Il gruppo di liste viene eseguito ogni volta che il nome della funzione è utilizzato come comando. Il valore restituito dalla funzione è quello dell’ultimo comando a essere eseguito all’interno di questa.

Quando viene eseguita una funzione, i parametri posizionali contengono gli argomenti di questa funzione e anche $# restituisce un nuovo valore di conseguenza. $0 continua a restituire il valore precedente, di solito il nome dello script.

All’interno della funzione possono essere dichiarate delle variabili locali attraverso il comando interno local.

È possibile utilizzare il comando interno return per concludere anticipatamente l’esecuzione della funzione. Al termine dell’esecuzione della funzione, i parametri posizionali riprendono il loro contenuto precedente e l’esecuzione dello script riprende dal comando seguente alla chiamata della funzione.

Le funzioni possono essere esportate e rese disponibili a una subshell utilizzando il comando interno export.

Esempi

L’esempio seguente mostra uno script che prima dichiara una funzione denominata messaggio e subito dopo l’esegue semplicemente nominandola come un qualsiasi comando.

#!/bin/bash
messaggio () {
echo “ciao,”
echo “bella giornata vero?”
}

messaggio

Nell’esempio seguente, una funzione si occupa di emettere il riepilogo della sintassi per l’uso di un ipotetico script.

function sintassi () {
echo “al
{-latex [-letter -a4] | -html | -txt [-letter -a4] } [-check]”
echo “”
echo “-latex esegue la conversione in latex;”
echo “-html esegue la conversione in html;”
echo “-txt esegue la conversione in testo normale;”
echo “-check esegue il controllo sintattico SGML;”
echo ” -a4 genera un documento in formato A4;”
echo ” -letter genera un documento in formato Lettera.”
}

Nell’esempio seguente, si utilizza il comando return per fare in modo che l’esecuzione della funzione termini in un punto determinato restituendo un valore stabilito. Lo scopo dello script è quello di verificare che esista il file pippo nella directory /var/log/packages/.

#!/bin/bash
function verifica() {
if [ -e "/var/log/packages/$1" ]
then
return 0
else
return 1
fi
}

if verifica pippo
then
echo “il pacchetto pippo esiste”
else
echo “il pacchetto pippo non esiste”
fi

44.3 Espressioni aritmetiche

La shell consente di risolvere delle espressioni aritmetiche in certe circostanze. Il calcolo avviene su interi di tipo long (secondo il linguaggio C) senza controllo dell’overflow, anche se la divisione per zero viene intercettata e segnalata come errore.

Oltre alle espressioni puramente aritmetiche si possono anche risolvere espressioni logiche e binarie, anche se l’utilizzo di queste ultime non è indicato.

La tabella 44.1 riporta l’elenco degli operatori aritmetici disponibili.

Operatore e operandi Descrizione
+ Non ha alcun effetto.
- Inverte il segno dell’operando.
+ Somma i due operandi.
– Sottrae dal primo il secondo operando.
* Moltiplica i due operandi.
/ Divide il primo operando per il secondo.
% Modulo: il resto della divisione tra il primo e il secondo operando.
= Assegna alla variabile il valore alla destra.
+= = +
-= = –
*= = *
/= = /
%= = %

Tabella 44.1: Operatori aritmetici della shell Bash.

Le variabili di shell possono essere utilizzate come operandi; l’espansione di parametri e variabili avviene prima della risoluzione delle espressioni. Quando una variabile o un parametro vengono utilizzati all’interno di un’espressione, vengono convertiti in interi. Una variabile di shell non ha bisogno di essere convertita.

La forma generale per esprimere un numero è quella seguente:

[#]n

In tal modo si può specificare la base di numerazione in modo esplicito (va da un minimo di 2 a un massimo di 64). Se non viene espressa, si intende base 10.

Per le cifre numeriche superiori al numero 9, si utilizzano le lettere minuscole, le lettere maiuscole, il simbolo _ e infine @, in questo ordine. Se la base di numerazione è inferiore o uguale a 36, non conta più la differenza tra lettere maiuscole e minuscole dal momento che non esiste la necessità di rappresentare un numero elevato di cifre.

Una costante che inizia con uno zero viene interpretata come un numero ottale, mentre se inizia per 0x o 0X si considera rappresentare un numero esadecimale.

Gli operatori sono valutati in ordine di precedenza. Le sottoespressioni tra parentesi sono risolte prima.
44.4 Riferimenti particolari alle variabili

L’espansione normale delle variabili è già stata vista nella sezione 42.3.4, ma la shell Bash offre in particolare dei modi alternativi, derivati dalla shell Korn, utili particolarmente per la programmazione.

Le parentesi graffe usate negli schemi sintattici delle sezioni seguenti, fanno parte delle espressioni, come si può osservare dagli esempi.
44.4.1 Segnalazione di errore

${:?}

${:?}

Definisce un messaggio, rappresentato dalla parola, da emettere attraverso lo standard error nel caso il parametro o la variabile non siano stati definiti o siano pari alla stringa nulla.

Esempi

Si suppone che la variabile Nessuno non sia stata definita o sia pari alla stringa nulla.

$ echo “${Nessuno:?Variabile non definita}”[Invio]

bash: Nessuno: Variabile non definita

44.4.2 Valore predefinito

${:-}

${:-}

Definisce un valore predefinito, corrispondente alla parola indicata, nel caso che il parametro o la variabile non siano definiti o siano pari alla stringa nulla.

Esempi

$ echo “${99:-ciao}”[Invio]

ciao

44.4.3 Rimpiazzo

${:+}

${:+}

Definisce un valore alternativo, corrispondente alla parola indicata, nel caso che il parametro o la variabile siano definiti e siano diversi dalla stringa nulla.

Esempi

$ Pippo=”"[Invio]

$ echo “${Pippo:+pappa}”[Invio]

Il risultato è una riga vuota.

$ Pippo=”ciao”[Invio]

$ echo “${Pippo:+pappa}”[Invio]

pappa

44.4.4 Lunghezza del contenuto

Questo tipo di sostituzione riguarda solo la shell Bash.

${#}

${#}

Corrisponde alla lunghezza in caratteri del valore contenuto all’interno del parametro o della variabile. Se però si tratta del parametro * o @ il valore è pari al numero dei parametri posizionali presenti.

Esempi

$ Pippo=”ciao”[Invio]

$ echo “${#Pippo}”[Invio]

4

44.4.5 Valore predefinito con assegnamento

${:=}

Assegna alla variabile il valore indicato dalla parola, nel caso che la variabile non sia definita o sia pari alla stringa nulla. In pratica, rispetto alla sintassi ${:-} si ottiene in più l’assegnamento della variabile.
44.5 Array

Oltre alle variabili scalari normali, si possono utilizzare degli array dinamici a una sola dimensione. Con questo tipo di array non è necessario stabilire la dimensione: basta assegnare un valore in una posizione qualunque e l’array viene creato. Per esempio,

elenco[3]=”Quarto elemento”

crea un array contenente solo l’elemento corrispondente all’indice 3, il quale a sua volta, contiene la frase «Quarto elemento».

Gli array della shell Bash hanno base 0, cioè il primo elemento si raggiunge con l’indice 0 (ecco perché nell’esempio, la frase parla di un quarto elemento).

È possibile creare un array anche usando il comando interno declare o local con l’opzione -a.

È possibile assegnare tutti i valori degli elementi di un array in un colpo solo. Si utilizza la notazione seguente:

=( … )

I valori indicati tra parentesi, a loro volta, possono essere espressi nella forma seguente (le parentesi quadre fanno parte dell’istruzione).

[]= |

La sintassi chiarisce che è possibile sia indicare esplicitamente l’indice dell’elemento da assegnare, sia farne a meno e quindi lasciare che sia semplicemente la posizione dei valori a stabilire il rispettivo elemento che dovrà contenerli.
44.5.1 Espansione con gli array

Per fare riferimento al contenuto di una cella di un array si utilizza la notazione seguente (le parentesi quadre fanno parte dell’istruzione).

${[]}

Se si legge un array come se fosse una variabile scalare normale, si ottiene il contenuto del primo elemento (zero). Per esempio, $pippo[0] è esattamente uguale a $pippo.

È possibile espandere gli elementi di un array tutti contemporaneamente. Per questo si utilizza il simbolo *, oppure @, al posto dell’indice. Se si utilizza l’asterisco si ottiene una sola parola, mentre utilizzando il simbolo @ si ottiene una parola per ogni elemento dell’array.
44.5.2 Lettura della dimensione

Per ottenere la dimensione di un array si utilizza una delle due notazioni seguenti (le parentesi quadre fanno parte dell’istruzione).

${#[*]}

${#[@]}

44.5.3 Eliminazione

Come nel caso delle variabili scalari, il comando unset permette di eliminare un array. Se però si fa riferimento a un particolare elemento di questo, si elimina solo l’elemento, senza annullare l’intero array.

—————————

Appunti Linux 1999.09.21 — Copyright © 1997-1999 Daniele Giacomini — daniele @ pluto.linux.it
[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]
Riferimenti: ShElL avanzato

ShElL

5 Maggio 2007 Commenti chiusi

La shell e’ il migliore alleato nell’uso di un sistema GNU/Linux! Se si sceglie di usare la linea di comando, avremo spesso a che fare con espressioni che coinvolgono l’uso della redirezione, delle pipe e della concatenazione dei comandi. Utilizzare la shell risulta piu’ rapido dell’utilizzare una qualsiasi interfaccia grafica, e si presenta percio’ indispensabile nell’uso produttivo di GNU/Linux. Quella che segue e’ una guida sintetica all’utilizzo della shell. La guida e’ stata suddivisa in tre parti per motivi di praticita’. Buona lettura.
——————–Programmazione con la Shell———————

————————-Sommario parte 1—————————
La shell Bash
I file di configurazione
Cenni sulle variabili
Cenni sui commenti
La variabile PATH
I prompts
Il file storico
Le variabili della posta
Varie
Gli alias
I permessi sui file

—————————La shell Bash——————————
Bash e’ un acronimo di Bourne Again SHell, si tratta di una shell compatibile con la shell Bourne, che e’ stata una delle shell piu’ usate in ambiente Unix alla quale aggiunge alcune migliorie mutuate anche dalle altre shell Unix. E’ in grado quindi di eseguire script scritti per la Bourne shell, mettendo a disposizione al contempo costrutti e comandi piu’ complessi non presenti nella Bourne shell originale. Non ultimo punto a suo favore consiste nel fatto di essere la shell predefinita di quasi la totalita’ delle distribuzioni Linux e di conseguenza la piu’ usata. Per chi non lo sapesse, la shell e’ un programma che agisce da intermediario tra l’utente e il kernel, in pratica si occupa di tradurre i comandi dell’utente e li passa al kernel per l’esecuzione. Il suo nome significa conchiglia perche’ appunto racchiude la sua perla, il kernel. Come quasi tutto il software scritto per il sistema operativo Linux e’ altamente configurabile.

———————I file di configurazione————————-
La shell puo’ usare cinque files di configurazione, ma spesso nelle varie distribuzioni non vengono usati tutti, d’altra parte vedremo che non e’ difficile crearsene di propri. I file sono:
/etc/profile
/etc/bashrc
~/.bash_profile
~/.bashrc
~/.bash_logout
Fondamentalmente possiamo dividerli in due gruppi: file globali e file locali, cioe’ quelli che contengono direttive di configurazione valide per tutti gli utenti, sono quelli che si trovano sotto la directory /etc, e quelli che contengono direttive di configurazione valide solo per l’utente che possiede la cartella nella directory /home che li contiene. Infatti nell’elenco sono preceduti da un carattere tilde (~ che nei sistemi Unix e’ un collegamento breve alla directory base dell’utente), e preceduti da un punto che li rende “invisibili” al comando ls senza l’argomento -a.
Se non dovessero essere presenti tutti nel sistema, non preoccupatevi, non tutti sono necessari, inoltre quelli necessari li creeremo in seguito.
Cominciamo a esaminarli uno ad uno:
/etc/profile
E’ il file di configurazione globale che determina le variabili di ambiente e i programmi da eseguire per ogni utente che manda in esecuzione la shell. Per fare un paragone con il mondo Dos potrebbe essere qualcosa di molto simile al file autoexec.bat.
/etc/bashrc
E’ un file di configurazione globale molto simile al precedente, per questo motivo spesso non e’ usato, contiene alias (collegamenti brevi a comandi molto lunghi li vedremo in seguito), e pezzi di codice nel linguaggio di scripting della shell che devono essere eseguiti alla partenza della shell. Tutto puo’ essere spostato senza problema nel file /etc/profile.
~/.bash_profile
E’ un file di configurazione locale che contiene direttive di configurazione e variabili di ambiente specifiche dell’utente al quale appartiene la directory /home in cui si trova. Il file viene letto ed eseguito successivamente a quelli globali e’ modifica o sovrascrive variabili che riguardano esclusivamente l’utente.
~/.bashrc
E’ un file di configurazione locale che contiene direttive di configurazione come gli alias, o funzioni definite dall’utente. Il file viene letto ed eseguito successivamente a quelli globali, gli alias o le funzioni saranno specifici dell’utente e non influenzeranno nessun altro utente. E’ il corrispondente locale di /etc/bashrc.
~/bash_logout
E’ un file di configurazione locale che contiene comandi da eseguire quando l’utente esce dalla shell. I comandi influenzano solo l’utente che possiede la cartella /home nella quale si trova.

———————Cenni sulle variabili————————–
Il metodo piu’ usato per archiviare temporeneamente uno o piu’ valori consiste nell’usare le variabili, cioe’ usare un’area di memoria del computer assegnandogli un nome a cui si possa far riferimento in seguito per recuperare il valore assegnato, si puo’ pensare a una variabile come una scatola chiamata per esempio mia_scatola, se noi mettiamo nella scatola una palla possiamo dire che il valore della variabile e’ rappresentato dall’elemento palla. Approfondiremo in seguito le variabili e il loro uso nello scrivere codice eseguibile dalla bash, per ora per la configurazione ci interessano solo due accezioni del termine cioe’ le variabili di ambiente (environmental) e le variabili locali (local). Le variabili di ambiente sono quelle variabili create autonomamente dal sistema operativo e normalmente sono definite nel file /etc/profile , come per esempio SHELL, PS1, PS2, ecc. saranno discusse piu’ avanti. Le variabili locali sono quelle variabili definite dall’utente e sono generalmente definite nel file ~/.bashrc che si trova come abbiamo visto nella /home dell’utente del quale possono influenzare l’ambiente. La definizione di una variabile avviene in un modo intuitivo e elementare. Consta di tre parti: il nome della variabile seguito dall’operatore di assegnamento “=” ,e il valore da assegnare, cioe’:nome_variabile=valore_variabile
Riutilizzando il paragone della scatola si potrebbe dire quindi che il valore della variabile mia_scatola=palla. Ponete attenzione al fatto che non ci sono spazi vuoti tra i componenti dell’assegnazione. Una volta definita la variabile la possiamo rendere disponibile ai programmi che l’utente usa con il comando export, cioe’:
export nome_variabile
Per accedere al valore di una variabile cioe’ per recuperarne il valore dobbiamo far precedere al nome variabile il suffisso “$”. Per esempio per conoscere il valore della variabile SHELL possiamo digitare il comando:
echo $SHELL che produrra’ una stampa a video /bin/bash
In parole povere il nome_variabile sara’ espanso nel valore_variabile quando il primo e’ preceduto dal simbolo “$”. Ritorneremo in seguito su come manipolare una variabile, ma fin da ora appare chiaro che comprenderlo e’ essenziale perche’ tutti i file di configurazione del sistema sono scritte nel linguaggio della shell Bash.

——————–Cenni sui commenti——————————-
Se mentre editi un file di configurazione ti trovi davanti a una linea di codice dagli effetti dubbi invece di cancellarla puoi commentarla. Commentare e’ l’azione di “rimuovere” una o piu’ linee dall’esecuzione dello script facendo precedere la linea da commentare dal carattere “#” senza cancellare. Chiaramente si puo’ usare il carattere “#” anche per inserire commenti che migliorino la leggibilita’ dello script, e che ci ricordino in seguito checosa abbiamo scritto.
Per esempio:
echo “sono un testo di prova”
#questo e’ un commento esplicativo
#qui sotto c’e’ un comando commentato che non verra’ eseguito
#echo “sono un testo che non verra’ visto”
La comodita’ del commento rispetto alla cancellazione e che la linea puo’ essere ripristinata immediatamente.

——————-La variabile PATH——————————–
La prima variabile da configurare e’ la variabile PATH che definisce le directory a cui possiamo accedere da qualsiasi punto del filesystem. Per esempio potremmo avere un programma nella directory /bin chiamato mio_prog, se la directory /bin e’ presente nella variabile PATH possiamo lanciare il programma da qualsiasi posizione nel filesystem, altrimenti saremmo costretti o a digitare l’intero percorso /bin/mio_prog oppure portarci nella directory digitando prima cd /bin e successivamente ./mio_prog. Il punto e la barra traversa (slash) che precedono il nome del programma dicono alla shell di cercare di eseguire quel file se ci sono i permessi adatti. La variabile PATH e’ definita in /etc/profile e ha una sintassi leggermente diversa dal normale, ogni percorso di directory alla destra dell’operatore di assegnazione “=” e separata dal carattere “:” ,esempio: PATH=/bin:/usr/bin:/usr/local/bin export PATH rendera’ possibile mandare in esecuzione da qualsiasi punto del filesystem tutti gli eseguibili che si trovano nelle cartelle dichiarate nella variabile PATH. Se noi volessimo aggiungere altri valori alla variabile PATH potremmo digitare semplicemente:
PATH=$PATH:/usr/games export PATH che aggiungera’ al valore gia’ esistente della variabile PATH il nostro nuovo valore, infatti il nome variabile preceduto dal simbolo “$” verra’ espanso con il contenuto originale della variabile cioe’ /bin:/usr/bin:/usr/local/bin che diventera’ /bin:/usr/bin:/usr/local/bin:/usr/games. Si puo’ modificare il proprio path inserendo il comando precedente in ~/.bash_profile.

———————–I prompts———————————–
Il prompt non e’ altro che il sistema in attesa di input dall’utente, la sua forma classica e’:
nome_utente@nome_computer:[#,$]
un prompt generico in questo momento poterbbe apparire come root@poldo:~#
e mi sta’ dicendo che sono l’utente “root” sulla macchina “poldo” e mi trovo nella mia home directory “~”, se fossi stato un semplice utente al posto del “#” ci sarebbe stato probabilmente un “$”. Dico probabilmente perche’ quello che vediamo riflette i valori della variabile PS1 definita nel file /etc/profile che e’ di proprieta’ dell’utente root, se noi volessimo un prompt diverso potremmo ridefinire la variabile PS1 nel file ~/.bash_profile. Questa variabile accetta dei valori predefiniti che sono ottenuti facendo seguire alla barra rovesciata (backslash) dei caratteri speciali che sono:
t l’ora corrente nel formato HH:MM:SS
d la data in formato esteso es. “Tue May 18″
n un carattere di nuova linea
s il nome della shell
w la directory corrente
W il percorso completo alla directory corrente
u il nome dell’utente
h il nome della macchina
# il numero del processo associato al comando in esecuzione
! la posizione numerica nel file storico dei comandi
$ se l’UID e’ 0 mostraun “#”, altrimenti ub “$”
Quindi inserendo opportunamente questi caratteri possiamo modificare l’aspetto del nostro prompt. Se assegno alla variabile PS1 i seguenti valori: PS1=”[u@h W]$” il mio prompt mi apparira’ cosi’:
[root@poldo /root]#
se modifico la variable cosi’: PS1=”[t s]$ ”
il mio prompt mi apparira’ cosi’:
[12:18:24 bash]#
Oltre a questi caratteri speciali la variabile PS1 puo’ contenere anche comandi per esempio se volessi far apparire la versione del kernel:
PS1=”`uname -r` $ ”
il mio prompt mi apparira’ cosi’:
2.4.17#
Attenti all’uso delle virgolette (che avranno un paragrafo tutto per loro), ho usato il carattere “`” non le classiche virgolette “‘”, chiamato backticks o virgolette rovescie, ottenute con AltGr+virgoletta semplice. La variable PS2 determina l’aspetto del prompt secondario e viene visualizzato quando si digitano comandi incompleti. Questo succede quando abbiamo a che fare con comandi molto lunghi, possiamo digitare il comando su piu’ linee facendo precedere il comando invio da una barra rovesciata (backslash), a quel punto la shell capira’ che non abbiamo terminato e ci presentera’ il prompt secondario che significa che sta attendendo successivi comandi. Se per sempio vogliamo vedere come si presenta il prompt secondario nella nostra shell possiamo digitare
root@poldo:#if [ -f /etc/profile ]; then
poi premiamo invio e ci accorgeremo di avere un prompt diverso il mio e’:
>
in questo caso non abbiamo dovuto far precedere l’invio da una barra rovescia perche’ la shell riconosce i suoi costrutti di programmazione, volendo si potrebbe digitare un semplice echo $PS2 per ottenere direttamente il valore della variabile. Tutto quello che e’ stato detto per PS1 vale in linea di massima per PS2.

——————Il file storico————————————-
La shell e’ in grado di ricordare i comandi immessi dall’utente che normalmente sono salvati nel file ~/.bash_history e possono essere richiamati premendo i tasti freccia in su’ e freccia in giu’, questo comportamento puo’ essere modificato configurando le variabili:
HISTSIZE
HISTFILE
HISTFILESIZE
E’ da ricordare che per abitudine le variabili di ambiente vengono indicate usando lettere maiuscole a differenza dele locali per cui si usano le minuscole. Queste variabili sono definite in /etc/profile ma possono essere sovrascritte in ~/.bash_profile.
HISTSIZE
Vero il numero massimo dei comandi da memorizzare nel file storico normalmente il valore preimpostato e’ 500.
HISTFILE
Indica il file che deve essere usato per contenere i comandi digitati normalmente il valore preimpostato e’ ~/.bash_history, puo’ anche non essere impostato, lo storico si limitera’ alla sessione di lavoro corrente, puo’ essere rediretto con una pipe su /dev/null (vedremo in seguito).
HISTFILESIZE
Determina la grandezza fisica massima che puo’ avere il file dello storico.
Se volessimo cancellare tutto lo storico impartiremo il comando:
pinco-pallino@poldo:~$ history -c

——————Le variabili della posta—————————-
La shell ha le seguenti variabli che influenzano le funzioni di posta
MAIL
MAILCHECK
MAILPATH
MAIL_WARNING
Queste variabili sono normalmente definite nel file /etc/profile ma possono essere sovrascritte nel file ~/.bash_profile .
MAIL
Quando un messaggio di posta arriva all’utente, il suo contenuto e’ scritto su di un file, questo file e’ definito dalla variabile MAIL che normalmente contiene il valore /var/spool/mail/nome_utente . Si puo’cosi’ indicare alla shell il file da controllare per l’arrivo di nuovi messaggi.
MAILCHECK
Questa variabile definisce l’intervallo di tempo che deve trascorrere prima che la casella di posta locale venga controllata. Il valore preimpostato e’ 60 che significa che la shell controllera’ la directory ogni minuto.
MAILPATH
Questa variabile definisce il percorso per raggiungere le directory di posta normalmente contiene il valore /var/spool/mail . Puo’ essere usata anche per personalizzare il messaggio che notifica l’arrivo della nuova posta, esempio:
MAILPATH=’/var/spool/mail/nome_utente “Hai posta….!”‘
MAIL_WARNING
Se questa variabile e’ definita, la shell vi informera’ con un messaggio, se state leggendo un messaggio gia’ letto in precedenza. Visto l’uso ormai consolidato dei client di posta come pine, mutt, o altri grafici questa variabile e’ ormai poco usata.

——————————-Varie——————————–
Ci sono direttive e variabili che non sempre sono usate, di seguito brevemente le piu’ frequenti.
set -o notify
ci informa che un programma che avevamo avviato in background, facendo cioe’ seguire il nome comando dal carattere “&”, e’ terminato stampando il messaggio [1]1+ Done nome_comando
Puo’ essere usata in /etc/profile oppure in ~/.bash_profile.
TMOUT
Questa variabile specifica quanto tempo la shell attendera’ per l’inserimento del nome utente o della password al login.
TMOUT=60
attendera’ un minuto prima di reinizializzare il login.
set -o noclobber
Questa direttiva impedira’ la redirezione dell’output su di un file gia’ esistente. Per aggirare questa limitazione il carattere di redirezione dovra’ essere seguito da un carattere di pipe (approfondito in seguito).
Esempio:
root@poldo:#echo “testo di prova” >| ~/.test_file
si evita in questo modo la sovrascrittura accidentale di un file.
Puo’ essere usata in /etc/profile oppure in ~/.bash_profile, per revocare la direttiva possiamo usare il comando:
unset +o noclobber

———————-Gli alias————————————-
Gli alias si possono definire come comandi “accorciati”. Se vogliamo chiamare un comando lungo in maniera piu’ mnemonica possiamo assegnarlo ad un alias. Se per esempio volessimo evitare di digitare ogni volta il comando:
ls -aF –color
potremmo assegnarlo nel file /etc/bashrc oppure ~/.bashrc nel seguente modo:
alias ls=’ls -aF –color’
Notare ancora una volta l’uso delle virolette rovescie. Possiamo definire quanti alias ci servono senza limiti.

——————–I permessi sui file—————————–
Una delle molte cose che differenzia un sistema Unix da windows sono i permessi e il concetto di appartenenza di un file. Ogni file nello Unix e’ di proprieta’ di un utente e di un gruppo. Gli utenti possiedono i file creati da loro stessi, e quelli attribuiti all’utente dall’utente root con il comando “chown”. Il gruppo di un file viene dedotto dal sistema in base al gruppo di appartenenza dell’utente, visto che un utente puo’ appartenere a piu’ gruppi puo’ cambiare gruppo di appartenenza a un file con il comando “chgrp”. Si puo’ sapere a che gruppo appartenga un utente usando il comando “groups”.
chown [nome_utente] [nome_file]
chgrp [nome_gruppo] [nome_file]
groups [nome_utente]
I permessi definiscono chi puo’ fare qualcosa, e che cosa puo’ essere fatto con un file. Sono divisi in quattro gruppi, i primi tre di uso frequente, il quarto di uso meno frequente e piu’ complesso, per cui ci limiteremo a una sua descrizione meno approfondita. Il permesso sui gruppi definisce che cosa un utente appartenente a quel gruppo puo’ fare con il file, l’universale quello che un utente non appartenente al gruppo puo’ fare. Ogni sezione della terna utente-gruppo-altri e’ composto da tre bits che quindi generano tre stati di settato/non_settato, i campi indicano:
lettura -il file puo’ essere letto in caso di directory e’ possibile
dare il comando ls nella directory viene indicato dal
carattere “r”.
scrittura -il file puo’ essere scritto in caso di directory e’ possibile
creare o cancellare i file all’interno viene indicato dal
carattere “w”.
esecuzione -il file puo’ essere mandato in esecuzione in caso di
directory e’ possibile usare il comando cd /nome_directory
viene indicato dal carattere “x”.
La rappresentazione numerica dei permessi non e’ molto difficile. Le tre categorie utente-gruppo-altri, che contengono ciascuna tre permessi, vengono considerate come una sequenza di tre cifre in formato ottale. Ogni cifra ottale corrisponde a tre cifre in binario (base 2), che sono sequenze di uno e di zero, quindi abbiamo tre gruppi di tre cifre che ci permettono di settare tutti i permessi. Dunque ogni cifra ottale ci restituisce tre cifre binarie, per esempio la cifra ottale 6 corrisponde al numero binario 110 che quindi imposta a 1 il permesso di lettura, a 1 il permesso di scrittura e a 0 quello di esecuzione.
Vi riporto per comodita’ la tabella:
base 8 (ottale) base 2 (binario)
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111
Come appare piu’ chiaro un numero ottale ha il corrispondente binario che puo’ essere interpretato come una terna di valori booleani. Ci possiamo ricavare un’altra tabella:
permesso numero binario
r 4 100
w 2 010
x 1 001
Dunque per determinare il numero totale da specificare per ogni elemento della terna utente-gruppo-altri bastera’ sommare i valori relativi.
Ultimo esempio:
proprietario rx 4+1=5
gruppo r 4
altri r 4
544 ovvero 101 100 100
digitando
chmod 544 nome_file
gli attribuiremo i seguenti permessi:
r-xr–r–
E’ possibile impostare, ma solo per gli eseguibili e le directory anche i bit di suid e sgid che vengono usati per modificare il comportamento standard dei permessi, ma possono causare problemi di sicurezza e meritano una discussione approfondita che va al di la’ delle intenzioni di questa mini guida.
———————————————————————————————————————————————————–
———————————————————————————————————————————————————–
Utilizzate la shell Cap.2 PDF Stampa E-mail
Scritto da Patrizio
martedì 12 dicembre 2006
Seconda parte della mini-guida dedicata all’utilizzo della shell Bash
——————-Programmazione con la Shell——————-

————————Sommario parte 2————————-
Introduzione alla programmazione in ambiente shell Bash
Il primo programma
Il secondo programma
Ancora commenti
Ancora variabili
Strutture di controllo
Il costrutto if
Il ciclo while
Il ciclo until
Il costrutto for
Il costrutto case
Le virgolette
Le operazioni con i numeri

——Introduzione alla programmazione in ambiente shell Bash——–
Come tutte le shell disponibili in Linux la shell Bash non solamente permette all’utente di digitare i comandi, ma include nell’eseguibile un vero e proprio mini linguaggio di programmazione, permettendoci di codificare script, cioe’ piu’ o meno brevi sequenze di istruzioni, da qui la definizione di linguaggio di scripting. Molti dei programmi che normalmente si utilizzano in Linux sono script di shell, quindi per comprendere il loro funzionamento ed eventualmente modificarli, e’ indispensabile conoscere le basi del linguaggio e la sua sintassi. Prima di iniziare e’ opportuno rimarcare la differenza tra linguaggi di scripting e linguaggi compilati. Generalmente i programmi compilati sono molto piu’ veloci e potenti dei programmi di scripting, ma altrettanto spesso questa velocita’ e potenza non giustifica la complessita’ e il tempo necessario per lo sviluppo. Un programma compilato viene generato da un file di testo denominato sorgente, che viene appunto processato da un compilatore che lo traduce in linguaggio macchina restituendoci un eseguibile binario (non piu’ un semplice file di testo ascii quindi), questo eseguibile dipende pesantemente dalla piattaforma su cui e’ stato compilato e non e’ eseguibile su altre piattaforme, esempio per tutti il linguaggio C. Una via di mezzo e’ rappresentata dai linguaggi semi-compilati come il Java in cui si ha solo una precompilazione del sorgente di testo, che viene processato per ottenete il bytecode un file binario che verra’ eseguito dall’interprete Java installato sul sistema. Un classico linguaggio interpretato, oltre allo shell scripting ovvio, e’ l’html in cui il sorgente e’ e rimane un semplice file di testo, e’ l’interprete incorporato nel browser che si occupa di tradurre i caratteri o le sequenze di caratteri speciali nelle opportune istruzioni di visualizzazione. I programmi interpretati sono dunque piu’ lenti, vista la necessaria interpretazione “al volo” ma sono facilmente e velocemente modificabili, e sono ottimi per le piccole applicazioni. Altri esempi di linguaggi interpretati sotto GNU/Linux sono il Perl, il Lisp, il Tcl, ecc…
Per scrivere semplici programmi interpretabili dalla shell e’ richiesta la conoscenza di almeno i principali comandi di Gnu/Linux, e la capacita’ di usare un editor di testo, meglio se non visuale come emacs, vim, nano, o pico; ma anche kate, gedit o xedit svolgono egregiamente il loro compito, fate voi. E’ anche buona abitudine non provare i propri script come utente root per evitare spiacevoli danni a file di sistema.

——————–Il primo programma——————————
Per non infrangere la tradizione cominceremo con un programma che stampa a video l’ignobile frase “Ciao mondo”. Quindi aprite un editor di testo e scrivete:
#!/bin/bash
echo “Ciao mondo”
la prima riga avvisa Linux che vogliamo che tutto cio’ che segue sia passato all’interprete bash, che in questo caso si trova nella directory /bin ma che puo’ trovarsi in un posizione non standard che possiamo indicare sotto forma di percorso. Il prossimo passo sara’ salvare lo script col nome di ciao.sh, successivamente dovremo renderlo eseguibile settando i dovuti permessi, quindi:
root@poldo:#chmod 700 ./ciao.sh
io lo sto facendo da root ma voi entrate nel sistema come utente.
Una volta settati i permessi possiamo avviare il nostro programma semplicemente digitando:
root@poldo:#./ciao.sh
Il vostro primo programma vi salutera’, e tutto questo ci servira’ a ricordare la sequenza, scrittura-salvataggio-permessi, che sta’ alla base di tutto. Cosa ha fatto il programma? Ha semplicemente stampato a video la scritta Ciao mondo, ma come ha fatto? Ha semplicemente usato un comando di shell, il comando “echo” che prende un argomento e lo stampa a video. Un argomento e’ qualsiasi stringa o numero che segue il comando, in questo caso la stringa “Ciao mondo” e’ l’argomento passato al comando “echo”. Quando noi dalla shell digitiamo il comando ls /var/log passiamo al comando “ls” l’argomento “/var/log”. Lo stesso effetto del nostro programma, vista la sua semplicita’ era ottenibile da shell digitando:
root@poldo:#echo “Ciao mondo”
ma era solo a scopo didattico.

——————–Il secondo programma————————–
Scriveremo un programma un tantino piu’ utile, spostera’ tutti i file della directory corrente dentro una cartella che creeremo, cancellera’ la directory creata e i file al suo interno, e alla fine la ricreera’. Tutto cio’ sarebbe possibile da shell digitando i seguenti comandi:
mkdir trash
mv * trash
rm -rf trash
mkdir trash
ma noi metteremo tutti i comandi in un file di shell, quindi apriamo l’editor e digitiamo :
#!/bin/bash
mkdir trash
mv * trash
rm -rf trash
mkdir trash
echo “file cancellati e directory ricreata con successo”
Salviamolo con il nome di test.sh, diamogli i permessi con il chmod 700, ed eseguiamolo digitando ./test.sh .
Quindi anche se siamo agli inizi se dobbiamo compiere azioni ripetitive consideriamo la possibilita’ di scriverci un file di shell.

—————————-Ancora commenti————————-
Abbiamo visto precedentemente che i commenti vengono ottenuti facendo precedere come primo carattere della linea il simbolo “#”, l’unica eccezione e’ rappresentata dall’invocazione dell’interprete nella prima riga di ogni script cioe’ la sequenza #!/bin/bash . Fate uso dei commenti il codice sara’ piu’ chiaro per voi e per gli altri.

—————————–Ancora variabili———————–
Abbiamo gia’ detto che le variabili sono fondamentalmente “scatole” che contengono valori. Avremo bisogno spesso di crearci variabili per motivi diversi, per memorizzare un valore immesso dall’utente, per effettuare calcoli o per memorizzare stringhe. Per fare un esempio pratico aprite il vostro editor e create un file di shell che contenga le seguenti righe:
#!/bin/bash
x=12
echo “Il valore della variabile x=$x”
Salvatelo dategli i giusti permessi ed eseguitelo.
Quello che abbiamo fatto e’ stato assegnare alla variabile x il valore di 12, notate ancora una volta che non ci deve essere spazio tra i termini, il valore della variabile puo’ essere recuperato anteponendo il suffisso “$” al nome della variabile. Le variabili possono essere sovrascritte e conterranno il valore dell’ultima assegnazione, per esempio
#!/bin/bash
x=12
echo “Il primo valore della variabile x=$x”
x=”a”
echo “Il secondo valore della variabile x=$x”

———————–Strutture di controllo——————-
Le strutture di controllo permettono ai nostri programmi di prendere delle “decisioni”, di essere molto piu’ compatti ed eleganti, e sopratutto di gestire gli eventuali errori. Quello che abbiamo fatto finora e’ fornire all’interprete una serie di istruzioni da eseguire. Se noi per esempio creiamo un file di shell chiamato test1.sh che contenga i seguenti comandi:
#!/bin/bash
cp /etc/miofile .
echo “Copiato.”
Il programma copierebbe il file /etc/miofile nella directory corrente e stamperebbe a video la stringa “Copiato.”. Il programma funzionera’ ad una condizione, che esista un file chiamato miofile nella directory /etc, altrimenti otterremmo dalla shell una risposta del tipo:
root@poldo:#./test1.sh
cp: /etc/miofile: No such file or directory
“Copiato.”
Possiamo osservare che c’e’ un problema, non e’ sicuro che tutti quelli che eseguono questo programma abbiano il file miofile nella directory /etc, sarebbe meglio se il programma controllasse l’esistenza di /etc/miofile prima di provare a copiarlo. Scrivendo il procedimento logico in pseudo-codice poteremmo dire:
SE /etc/miofile esiste, ALLORA
copia /etc/miofile nella directory corrente
e stampa a video il messaggio “Copiato.”
ALTRIMENTI
stampa a video il messaggio “il file non esiste”
Come e’ possibile ottenere un risultato come questo in un programma di shell? Semplice usando le strutture, o i costrutti, di controllo che la bash ci mette a disposizione, cioe’: if, while, until, for e case. Ogni struttura di controllo necessita di un comando di apertura e uno di chiusura, un po’ come i tag in html. Per esempio la struttura di controllo “if” comincia appunto con “if” e termina con “fi”. Le strutture di controllo sono funzioni incluse nella shell nativamente, quindi a differenza di quanto fatto finora non facciamo uso di comandi esterni. Cominciamo ad esaminarle.

———————-Il costrutto if—————————
if … else … elif …fi
Uno dei costrutti piu’ usati e’ “if” che ci permette di modificare il flusso del programma al verificarsi di una condizione. Per usare il costrutto “if” dobbiamo usare il comando di test che puo’ essere sottinteso dall’uso delle parentesi, in pratica possiamo riscrivere il codice di prima cosi’:
#!/bin/bash
if test -f /etc/miofile
then
# il file esiste quindi lo copio e stampo il messaggio
cp /etc/mia_var .
echo “Copiato.”
else
# il file non esiste quindi stampo il messaggio e esco
echo “il file non esiste”
exit
fi
Notare che la tabulazione non e’ obbligatoria ma rende il codice piu’ leggibile, aiutando a separare i blocchi di istruzioni. Salviamo il programma con il nome di test2.sh, diamogli i giusti permessi ed eseguiamolo con il solito ./test2.sh. La parola chiave test che controlla se il file esiste, puo essere sostituita dalle parentesi quadre, facendo attenzione a lasciare uno spazio prima degli argomenti, notare anche il punto e virgola che separa le istruzioni. Tutto quello che si trova dopo il punto e virgola viene interpretato come si trovasse su una riga a se’ stante.
Esempio:
if [ -f /etc/miofile ]; then
I controlli che la shell ci permette di fare su di un file sono i seguenti:
-d controlla se il file e’ una directory
-e controlla se il file esiste
-f controlla se il file e’ un file regolare
-g controlla se il file ha il bit SGID settato
-r controlla se il file e’ leggibile dall’utente che esegue lo script
-s controlla se la dimensione del file non e’ 0
-u controlla il file ha il bit SUID settato
-w controlla se il file e’ scrivibile
Il costrutto “else” viene usato per indicare al programma l’azione da compiere se la condizione non e’ soddisfatta. C’e’ anche il costrutto “elif” che e’ la somma dei costrutti “else” e “if” che permette di evitare un susseguirsi di “if” quando si vogliono testare piu’ condizioni. Quando si vuole testare una variabile e’ buona norma includerla dentro doppie virgolette, affinche’ venga espansa correttamente.
Esempio:
if [ "$mia_variabile" -eq 5 ]; then

———————Il ciclo while—————————-
while … do … done
Il costrutto “while” viene definito un costrutto ciclico. Fondamentalmente il suo significato in inglese ci descrive cosa fa’, infatti il significato e’ “mentre”. Potremmo semplificare in pseudo-codice dicendo:
MENTRE la condizione da testare e’ vera
FAI un compito
FINO A CHE la condizione di partenza non e’ piu’ vera.
Esempio:
#!/bin/bash
x=0; # assegnoall variabile x il valore 0
while [ "$x" -le 10 ]; do
echo “Il valore di x: $x”
# incremento ad ogni ciclo il valore di x di una unita’
x=$(expr $x + 1)
done
Possiamo vedere che abbiamo usato il comando test nella sua forma contratta, con le parentesi quadre per controllare lo stato della variabile x e sapere se era minore o uguale a 10, e mentre questo valore aumentava in virtu’ dei comandi della linea 6, finche’ non si raggiuge il valore 10, viene stampato il valore attuale.
Come per i files ci sono test predefiniti per i numeri:
x -eq y Vero se x e’ equivalente a y
x -ne y Vero se x non e’ equivalente y
x -gt y Vero se x e’ maggiore y
x -lt y Vero se x minore y
x -ge y Vero se e’ maggiore o equivalente
x -le y Vero se minore o equivalente
Mentre per confrontare le stringhe di caratteri abbiamo:
x = y Vero se x e’ uguale y
x != y Vero se x non e’ uguale a y
-n x Vero se x non e’ nullo o vuoto
-z x Vero se x e’ nullo o vuoto
Riprendendo l’esempio appena fatto un altro dubbio vi potrebbe venire
osservando la riga
x=$(expr $x + 1)
Abbiamo detto che incrementa di un unita’ la variabile x, ma dobbiamo chiarire cosa significa $(…). Questo e’ un modo per dire all’interprete della shell che vogliamo sia eseguito il comando “expr”, e vogliamo che il risultato sia assegnato alla variabile x. Ogni comando tra le parentesi verra’ eseguito.
Esempio:
#!/bin/bash
io=$(whoami)
echo “io sono $me.”
Provatelo e capirete meglio, potremmo anche riscriverlo in forma breve come:
#!/bin/bash
echo “io sono $(whoami).”
In seguito vedremo un’altro metodo per assegnare ad una variabile il risultato di un comando.

———————–Il ciclo until—————————
until … do … done
Fondamentalmente simile al precedente invece che “mentre” il costrutto ciclera’ “fino a che” la condizione e’ vera. Mettete in esecuzione l’esempio e capirete la sottile differenza osservando il numero dei cicli.
#!/bin/bash
x=0
until [ "$x" -ge 10 ]; then
echo “Current value of x: $x”
x=$(expr $x + 1)
done

———————-Il costrutto for—————————
for … in … do … done
Il costrutto for e’ usato fondamentalmente per ripetere un dato comando un certo numero di volte. Per esempio volendo stampare dieci punti potremmo scrivere un file di shell cosi’:
#!/bin/bash
echo -n “Incomincio a stampare ”
for mia_var in 1 2 3 4 5 6 7 8 9 10; do
echo -n “.”
echo ” finito.”
done
L’opzione -n passata al comando “echo” prima dell’argomento fa si’ che il comando non emetta il carattere di nuova linea (/n o newline) che farebbe andare a capo. La variabile mia_var conterra’ di volta in volta i valori da 1 a 10, stampando un punto per ogni valore. Per chiarire possiamo provare un altro script:
#!/bin/bash
for x in piero paolo stefano; do
echo “Il valore della variabile x : $x”
done
Vedrete che verra’ stampato di volta in volta il valore della variabile. Per fare un’esempio piu’ utile aggiungeremo il suffisso .txt a tutti i file nella directory corrente.
#!/bin/bash
for file_presenti in *; do
echo “Aggiungo .txt al file $file_presenti…”
mv $file_presenti $file_presenti.txt
done
Il carattere “*” e’ un carattere jolly che si espande in “tutto nella directory corrente”, il comando “mv” e’ usato per rinominare il file.

———————Il costrutto case————————–
case … in … done
Il costrutto “case” e’ molto simile al costrutto “if”, fondamentalmente viene usato per testare una condizione contro valori noti senza usare svariati “if”.
Un esempio chiarira’:
#!/bin/bash
x=5 # assegno a x il valore 5
# incomincio a testare x
case $x in
0) echo “Il valore di x: 0.”
;;
5) echo “Il valore di x: 5.”
;;
9) echo “Il valore di x: 9.”
;;
*) echo “Valore sconosciuto”
esac
Il costrutto “case” testera’ il valore di x contro tre valori noti, prima controllera’ se il valore e’ 0, successivamente se e’ 5, al termine se il valore e’ 9. Se nessuna delle condizioni si avverera’ verra’ eseguita la il blocco di codice della condizione “*” che abbiamo visto essere espansa come “qualsiasi valore”. Ogni blocco di codice che segue una condizione deve essere terminato con la sequenza di caratteri “;;”. Usando il ciclo “if” avremmo dovuto scrivere:
#!/bin/bash
x=5 # assegno a x il valore 5
if [ "$x" -eq 0 ]; then
echo “Il valore di x: 0.”
elif [ "$x" -eq 5 ]; then
echo “Il valore di x: 5.”
elif [ "$x" -eq 9 ]; then
echo “Il valore di x: 9.”
else
echo “Valore sconosciuto”
fi
Il costrutto e’ sicuramente meno leggibile.

————————Le virgolette—————————–
Le virgolette sono molto importante nello shell scripting, ci sono tre tipi di virgolette ed ognuno ha un significato diverso per l’interprete della shell.
” virgoletta doppia
‘ virgoletta semplice
` virgoletta invertita
Le virgolette DOPPIE sono usate spesso per impostare un valore stringa e per preservare gli spazi nelle stringhe.
Esempio:
x=”stringa con quattro parole”
la variabile conservera’ la stringa come un valore singolo, cioe’ una stringa formata da caratteri e da spazi, in sintesi un solo argomento. Applichiamo quanto detto ai comandi, se noi digitassimo:
mkdir ciao mondo
ls -F
avremmo:
ciao/ mondo/
cioe’ avremmo creato due directory distinte perche’ il comando tratterebbe quello che lo segue come due argomenti diversi. Ma se invece digitiamo:
mkdir “ciao mondo”
ls -F
avremmo:
ciao/ ciao mondo/ mondo/
cioe’ il comando interpreterebbe la stringa come un unico argomento. Usate con le variabili ne espandono il valore contenuto.
Le virgolette SEMPLICI si usano quasi sempre con le variabili, infatti una variabile inclusa in virgolette semplici, al contrario delle doppie, non verra’ espansa nel corrispondente valore.
Un esempio:
#!/bin/bash
x=5
# uso le doppie virgolette
echo “Usando le doppie virgolette x : $x”
# uso le virgolette semplici
echo ‘Usando le virgolette semplici x : $x’
Anche le virgolette semplici fanno si’ che i termini inclusi vengano considerati un argomento singolo.
Le virgolette ROVESCIATE sono completamente diverse dalle precedenti due.
Ricordate uno degli esempi precedenti quando scrivemmo :
x=$(expr $x + 1)
grazie alle virgolette rovesciate possiamo riscriverlo cosi’:
x=`expr $x + 1`
in pratica come avevamo gia’ visto assegnamo il risultato di un comando o di una pipe di comandi ad una variabile.

——————-Le operazioni con i numeri———————
La shell Bash ci permette, come abbiamo gia’ visto, di eseguire espressioni aritmetiche. Si possono effettuare operazioni in due modi, uno l’abbiamo gia’ incontrato ed e’:
x=`expr $x + 1`
l’altro e inserire l’espressione da valutare tra doppie parentesi, attenzione doppie non singole come nell’esempio di prima, e cioe’:
x=$(($x+1))
possiamo verificare con:
#!/bin/bash
x=8
y=4
z=$(($x + $y))
echo “La somma di $x + $y = $z”
Gli operatori aritmetici messi a disposizione sono:
Addizione +
Sottrazione -
Moltiplicazione *
Divisione /
Resto o Modulo %
Sono le principali operazioni, tranne resto o modulo che restiuisce appunto il resto di una divisione.
Esempio:
#!/bin/bash
x=5
y=3
somma=$(($x + $y))
sottrazione=$(($x – $y))
moltiplicazione=$(($x * $y))
divisione=$(($x / $y))
modulo=$(($x % $y))
echo “Somma: $somma”
echo “Sottrazione: $sottrazione”
echo “Moltiplicazione: $moltiplicazione”
echo “Divisione: $divisione”
echo “Modulo: $modulo”
————————————————————————————————————————————————————
————————————————————————————————————————————————————
Utilizzate la shell Cap.3 PDF Stampa E-mail
Scritto da Patrizio
martedì 12 dicembre 2006
Terza parte della mini-guida dedicata all’utilizzo della shell Bash
———————–Programmazione con la Shell——————-

—————————Sommario parte 3————————–
Input dall’utente
Le funzioni
Intercettare i segnali di sistema
I costrutti AND e OR
Gli argomenti
Le redirezioni e le pipe
Files temporanei
Valori di ritorno
Conclusioni

————————Input dall’utente—————————–
Vedremo ora come leggere i valori immessi dall’utente per usarli nei nostri programmi, useremo per questo il comando “read” che e’ un comando interno della shell che copiera’ l’input dell’utente in una variabile.
Esempio:
#!/bin/bash
# programma che prende l’input dall’utente e lo saluta
echo -n “Inserisci il tuo nome: ”
read nome_utente
echo “Ciao $nome_utente !”
Il comando “read” apettera’ che l’utente immetta qualcosa e prema ENTER o INVIO, e aspettera’ all’infinito che venga premuto il tasto INVIO. Se l’utente non immette nulla e preme INVIO read sara’ eseguito ugualmente e il programma continuera’ con l’istruzione successiva. Cominciamo a controllare dunque che l’utente immetta qualcosa:
#!/bin/bash
# programma che prende l’input dall’utente e lo saluta
echo -n “Inserisci il tuo nome: ”
read nome_utente
#controlliamo se l’utente ha immesso qualcosa
if [ -z "$nome_utente" ]; then
echo “Non hai digitato nulla!”
exit
fi
echo “Hello $nome_utente !”

————————–Le funzioni———————————
Le funzioni rendono la programazione meno ripetitiva e piu semplice, ci permettono di suddividere il programma che dobbiamo scrivere in tanti piccoli sottoprogrammi, per essere stringati una funzione e’ un pezzo di codice che accetta o no valori in entrata, compie delle azioni, e puo’ emettere dei risultati siano essi semplici valori booleani di ritorno o dati piu’ complessi.
Esempio di funzione semplice:
#!/bin/bash
#dichiariamo la funzione ciao()
ciao()
{
echo “Sono nella funzione ciao()”
}
echo “Sto per chiamare la funzione ciao()…”
# chiamata della funzione ciao()
ciao
echo “Sono uscito dalla funzione ciao()”
Mandando in esecuzione questo pezzo di codice, ci accorgiamo che l’unica cosa che fa’ e’ stampare un messaggio, ovviamente le funzioni possono fare cose molto piu’ complesse, ma questo ci serve per osservarne la struttura. La stampa a video del messaggio contenuto nella dichiarazione di funzione e’ avvenuta quando abbiamo richiamato la funzione, dopo averla precedentemente dichiarata. Infatti la bash quando incontra la linea che richiama la funzione ciao va’ a ritroso, perche’ per usare una funzione bisogna averla dichiarata in precedenza, cercando il nome funzione seguito da due parentesi tonde oppure la parola chiave function che noi non abbiamo usato perche’ facoltativa.
Volendo avremmo potuto scrivere:
function ciao()
{
echo “Sono nella funzione ciao()”
}
La dichiarazione di funzioni quindi consta della parola chiave “function” che e’ facoltativa, del nome che assegniamo alla funzione seguito da apertura di parentesi tonda, e successiva chiusura, per leggibilita’ un ritorno a capo, una apertura di parentesi graffe, il blocco di codice che la compone, la chiusura delle parentesi graffe.
function nome_funzione()
{ #inizio blocco che verra’ eseguito
istruzioni
} #fine blocco che verra’ eseguito
Tutto quello che si trova tra le parentesi graffe, dichiarazione di variabili, espressioni complesse, ecc. si definisce di ambito locale, cioe’ i valori sono definiti e hanno un senso solo all’interno di essa. Se chiamiamo una funzione prima di averla definita otterremmo in risposta un messaggio di errore “command not found”, quindi e’ buona norma mettere le dichiarazioni di funzione raggruppate in testa al nostro script.
Facciamo un esempio piu’ completo:
#!/bin/bash
# admin.sh un tool stupidino
# function nuovo_utente() la funzione che crea un nuovo utente
# la dichiariamo in cima allo script prima della chiamata
nuovo_utente()
{
echo “Stai per aggiungere un nuovo utente…”
sleep 2 #semplicemente sospende per due secondi l’esecuzione
adduser #manda in esecuzione il comando di shell “adduser”
}
#iniziamo lo script
echo “1. Aggiungi un utente”
echo “2. Esci”
echo “Digita la scelta: ”
read scelta
case $scelta in
1) nuovo_utente #se il confronto e’ positivo chiamiamo nuovo_utente
;;
*) exit #in tutti gli altri casi terminiamo col predefinito
;;
esac
Per eseguire questo script bisogna entrare nel sistema con l’account di root, essendo il comando “adduser” eseguibile solo da root.

——————-Intercettare i segnali di sistema—————–
L’argomento e’ un po’ complesso ma lo accenniamo. E’ possibile grazie al comando di shell “trap” intercettare i segnali si sistema. Se noi durante l’esecuzione di uno script o di un comando premiamo la combinazione di tasti Ctrl+c, mandiamo allo script un segnale di interrupt che fara’ terminare l’esecuzione. Possiamo intercettare le principali chiamate e far continuare l’esecuzione del nostro programma, usando appunto il comando “trap”, per conoscere i segnali che puo’ gestire digitate trap -l, la sua sintassi e’:
trap azione segnale
L’azione e’ tutto cio’ che vogliamo accada se il segnale di interrupt viene chiamato. I segnali possono essere indicati sia in forma numerica, sia in forma letterale, nel secondo caso si devono omettere le prime tre lettere, generalmente “SIG”, per esempio se volessimo intercettare il segnale di interrupt “SIGINT” (codice numerico 2) dovremmo usare la stringa “INT”.
Esempio:
#!/bin/bash
# usiamo il comando trap
# catturiamo la sequenza di tasti Ctrl-c ed eseguiamo la funzione spiacente
trap spiacente INT
# la funzione spiacente stampa semplicemente un messaggio
spiacente()
{
echo “Spiacente, non puoi farlo”
sleep 3
}
# contiamo alla rovescia da 10 a 1
for i in 10 9 8 7 6 5 4 3 2 1; do
echo “mancano $i secondi ”
sleep 1
done
echo “…finito”
Adesso salviamo, rendiamo eseguibile, avviamolo, e mentre lo script conta proviamo a premere Ctrl+c, normalmente l’esecuzione si sarebbe interrotta, ma in questo caso il segnale di interrupt e’ stato intercettato da “trap” che invece di uscire ha richiamato la funzione spiacente(). Se si vuole semplicemente far ignorare al programma il segnale di interrupt basta passargli al posto dell’azione due virgolette semplici vuote ” ” ” , se vogliamo annullare l’effetto del comando “trap” dobbiamo resettarlo passandogli un trattino ” – “.
trap ” INT
trap – INT
Il reset riportera’ la sequenza di tasti alla sua normale funzione.

——————-I costrutti AND e OR————————–
Abbiamo gia’ parlato delle strutture di controllo (“if…elif..ecc”), ma abbiamo un paio di cosette da aggiungere: le direttive AND, generalmente indicata con la sequenza di caratteri “&&”, e la direttiva OR, indicata con “||” (doppio pipe il carattere sopra “”).
La sintassi della direttiva AND e’:
prima_condizione && seconda_condizione
La direttiva AND controlla prima la condizione a sinistra, se restituisce vero, controlla quella di destra, se ambedue sono soddisfatte continua con l’esecuzione del codice successivo. In pseudo-codice potremmo scrivere:
SE la prima condizione e’ vera E la seconda condizione e’ vera ALLORA…
Esempio:
#!/bin/bash
x=5
y=10
if [ "$x" -eq 5 ] && [ "$y" -eq 10 ]; then
echo “Entrambe le condizioni sono vere”
else
echo “Le condizioni non sono vere”
fi
Cambiate il valore di x in 12 e vedete cosa succede.
Il costrutto OR non si comporta molto differentemente, testa se la prima condizione e se e’ falsa passa alla seconda, se almeno questa e’ vera esegue i comandi, altrimenti passa ai comandi successivi.
In pseudo-codice:
SE la prima condizione e’ vera OPPURE la seconda condizione e’ vera ALLORA…
Esempio:
#!/bin/bash
x=3
y=2
if [ "$x" -eq 5 ] || [ "$y" -eq 2 ]; then
echo “Una delle condizioni e’ vera”
else
echo “Nessuna delle condizioni e’ vera”
fi
Questi costrutti servono spesso per evitare l’annidarsi di piu’ istruzioni “if”, anche se resta possibile farlo, il primo esempio sarebbe stato:
#!/bin/bash
x=5
y=10
if [ "$x" -eq 5 ]; then
if [ "$y" -eq 10 ]; then
echo “Entrambe le condizioni sono vere”
else
echo “Nessuna condizione e’ vera”
fi
fi

————————Gli argomenti————————
Avrete notato che la maggior parte dei comandi Linux non si limita ad eseguire un compito in maniera autonoma, ma spesso richiede delle informazioni extra che l’utente deve fornirgli, se la chiamata del comando e’ incompleta ci appare spesso il messaggio che ci suggerisce l’uso appropriato. Il comando “more” che serve a visualizzare un file, se digitato da solo produrra’ un messaggio che ci informa sul suo uso. Il comando si aspetta degli argomenti, cioe’ dei valori immessi dall’utente. Ora dobbiamo sapere che la shell utilizza delle variabili speciali per tenere in memoria questi valori.
Queste sono le variabili speciali utilizzate:
$# Contiene il numero dei parametri passati
$1-$n Contiene il valore singolo dei parametri ordinati per immissione (1-9)
$? Contiene il valore di uscita dell’ultimo comando
$0 Contiene il nome del programma
$* Contiene tutti i parametri ordinati per immissione ($1 $2 …).
“$@” Contiene tutti i parametri ordinati per immissione inclusi in doppie
virgolette (“$1″ “$2″ …).
Esempio:
#!/bin/bash
# script per visualizzare il primo argomento
# prima controlliamo se ci sono argomenti
if [ "$#" -ne 1 ]; then
echo “uso: $0 argomento ”
fi
echo “L’argomento pasato e’ $1″
Chiamatelo prima senza argomento e poi facendo seguire un numero o una stringa al comando e verificate cosa succede.

———————Le redirezioni e le pipe——————-
Normalmente quando eseguiamo un comando il suo risultato viene stampato a video. Per esempio il comando:
echo “Ciao mondo”
stampa la stringa “Ciao mondo”, perche’ lo ‘standard output’ del programma e’ la console. Ci sono tre canali predefiniti per i comandi in Linux, lo ‘standard input’, lo ‘standard output’ e lo ‘standard error’, spesso il secondo e il terzo coincidono per permetterci di vedere gli errori generati, ma altrettanto spesso gli errori, e quindi lo ‘standard error vengono rediretti su di un file di log. La redirezione ci permette di modificare i comportamenti standard del programma, i suoi operatori sono:
> redirige lo standard output su di un file sovrascrivendo i dati
>> redirige lo standard output su di un file appendendo alla fine i dati
Esempio
echo “Ciao mondo”> mio.file
cat mio.file
stampera’:
“Ciao mondo”
echo “mi appendero’ al file” >> mio.file
cat mio.file
stampera’:
“Ciao mondo”
“mi appendero’ al file”
Le pipe permettono di passare a un comando come argomento il risultato di un altro comando, possiamo cosi’ concatenare piu’ comandi per ottenere quello che vogliamo. Per iniziare concateneremo il risultato del comando “cat”, che tra le altre funzioni e’ utile per leggere un file, al comando grep, che ci restituisce le righe di un file che corrispondono ad un criterio di ricerca. Se volessimo trovare nel file /etc/passwd la riga che si riferisce all’utente “carognone” presente nel mio sistema potremmo digitare:
cat /etc/passwd | grep carognone
il risultato sarebbe
carognone:x:1002:100:users,,,:/home/carognone:/bin/bash
Il comando cat “passa” il contenuto del file al comando “grep” che esegue la ricerca e ci restituisce il risultato sullo standard output.
Possiamo concatenare pipe e redirezioni:
cat /etc/passwd | grep carognone > mio.file
non apparira’ nulla perche’ lo indirizziamo sul file, leggiamo il file
cat mio.file
il risultato:
carognone:x:1002:100:users,,,:/home/carognone:/bin/bash

————————Files temporanei———————–
Spesso ci servira’ creare dei file temporanei su cu scrivere dei valori, o conservarli tra una chiamata ed un’altra dello script. La cosa importante da tenere a mente e’ che no possiamo rischiare di sovrascrivere file esistenti. Per fare questo ci serviamo della sequenza di caratteri “$$” che possiamo usare come prefisso o postfisso al nome del file.
Esempio:
creiamo un file
touch mio_file
controlliamo
ls
risultato:
mio_file
usiamo il postfisso
touch mio_file.$$
controlliamo
ls
risultato:
mio_file mio_file.689

——————–Valori di ritorno————————–
Molti programmi restiuiscono valori di ritorno che ci informano sul risultato della loro esecuzione, se consultiamo la pagina man di “grep” leggeremo che il programma restituisce uno 0 se non riesce a trovare nulla, altrimenti un 1. Il perche’ dovremmo interessarci del valore di uscita di un programma ci sara’ chiaro con un esempio. Se noi volessimo sapere se un utente esiste nel sistema potremmo controlare con grep se e’ presente nel file /etc/passwd :
grep “asino” /etc/passwd
ora dato che “asino” non e’ un utente della mia macchina il risultato sara’ un prompt vuoto. Sarebbe opportuno avere un messaggio che ci avvisi che non e’ stato trovato nulla, quindi useremo la variabile speciale “$?” che contiene il valore di uscita del comando eseguito:
#!/bin/bash
# greppiamo per cercare l’utente
#e redirigiamo l’uscita su /dev/null un file che e’ paragonabile a un cestino
#in modo che non appaia nulla
grep “asino” /etc/passwd > /dev/null 2>&1
# controlliamo il suo valore di ritorno
if [ "$?" -eq 0 ]; then
echo “Utente trovato”
exit
else
echo “Utente non trovato”
fi
Questo e’ valido per i comandi della shell, ma come facciamo ad avere dei valori di ritorno dai nostri script? Semplice il comando exit accetta un argomento, che puo’ essere un numero da restituire. Normalmente 1 significa che c’e’ stato un errore, 0 che tutto e’ andato bene.
Esempio:
#!/bin/bash
if [ -f "/etc/passwd" ]; then
echo “Il file di password esiste”
exit 0
else
echo “Il file di password non esiste”
exit 1
fi
Usando i valori di ritorno possiamo passare dei valori ad altri script, che si comporteranno di conseguenza. Anche le funzioni possono avere dei valori di ritorno, grazie al comando “return”, che accetta un argomento numerico, il suo uso e’ simile al comando “exit” visto in precedenza.
Esempio:
controlla_passwd()
{
if [ -f "/etc/passwd" ]; then
echo “Il file di password esiste”
#faccio restituire il valore 0
return 0
else
#faccio restituire il valore 1
echo “Il file di password non esiste”
return 1
fi
}
# metto in una variabile il valore di uscita
mia_var=controlla_passwd
#controlliamo il valore testando il contenuto della vaiabile
if [ "$mia_var" -eq 0 ]; then
echo “Il file esiste”
exit 0
else
echo “Il file non esiste”
exit 1
fi

—————————Conclusioni————————-
Quanto detto illustra solo la minima parte delle potenzialita’ dello shell scripting e quindi dell’uso della shell. Sta a voi adesso sperimentare. Buona produttivita’ con GNU/Linux… E ricordate: Usate la Shell!
—————————————————————-
Riferimenti: ShElL

SCHEDE ATI/DRIVER/BERYL EASY URPMY GUIDA

18 Marzo 2007 7 commenti

RIFERIMENTI MEDIAGRAFICI

http://mcz06.wordpress.com/2006/11/27/beryl-svn-insieme-a-compiz-quinn/

http://www.mandrakeitalia.org/modules/wfsection/article.php?articleid=206

http://www.mandrakeitalia.org/modules/wfsection/article.php?page=1&articleid=192

Prima aggiungiamo queste righe da root

per 32 bit

urpmi.addmedia 2007Main ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/i586/media/main/release/ with media_info/hdlist.cz
urpmi.addmedia –update 2007MainBP ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/i586/media/main/backports/ with media_info/hdlist.cz
urpmi.addmedia –update 2007MainUp ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/i586/media/main/updates/ with media_info/hdlist.cz
urpmi.addmedia 2007Contrib ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/i586/media/contrib/release/ with media_info/hdlist.cz
urpmi.addmedia –update 2007ContribBP ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/i586/media/contrib/backports/ with media_info/hdlist.cz
urpmi.addmedia –update 2007ContribUp ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/i586/media/contrib/updates/ with media_info/hdlist.cz

per 64 bit

urpmi.addmedia 2007Main ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/x86_64/media/main/release/ with media_info/hdlist.cz
urpmi.addmedia –update 2007MainBP ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/x86_64/media/main/backports/ with media_info/hdlist.cz
urpmi.addmedia –update 2007MainUp ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/x86_64/media/main/updates/ with media_info/hdlist.cz
urpmi.addmedia 2007Contrib ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/x86_64/media/contrib/release/ with media_info/hdlist.cz
urpmi.addmedia –update 2007ContribBP ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/x86_64/media/contrib/backports/ with media_info/hdlist.cz
urpmi.addmedia –update 2007ContribUp ftp://ftp.free.fr/mirrors/ftp.mandrake-linux.com/Mandrakelinux/official/2007.0/x86_64/media/contrib/updates/ with media_info/hdlist.cz

———————————————–
piu’ questi pe 32 e 64 bit
———————————————-
urpmi.addmedia 2007Main ftp://ftp.proxad.net/pub/Distributions_Linux/Mandrake/official/2007.0/i586/media/main/release/ with media_info/hdlist.cz
urpmi.addmedia 2007Contrib ftp://ftp.proxad.net/pub/Distributions_Linux/Mandrake/official/2007.0/i586/media/contrib/release/ with media_info/hdlist.cz
urpmi.addmedia –update 2007PlfFree ftp://ftp.cica.es/mirrors/Linux/plf/mandrake/2007.0/free/release/binary/i586 with hdlist.cz
urpmi.addmedia –update 2007PlfNonFree ftp://ftp.cica.es/mirrors/Linux/plf/mandrake/2007.0/non-free/release/binary/i586 with hdlist.cz
———————————————————————————-
———————————————

Procedura:

0.0) urpmi.update -a

0.1) urpmi kernel-source-2.6.17.5mdv

0.2) urpmi ati

0.3) aticonfig –initial –input=/etc/X11/xorg.conf

Disabilitamo Composite

Uno dei principali problemi dei driver Ati è che al momento è incompatibile con la direttiva Composite che di solito viene settata di default[/b].
Occorre aprire come root il file /etc/X11/xorg.conf e modificare il file da così (inpratica,aggiung solo asterisco davanti ad option composite):

Section “Extensions”
# Option “Composite”
EndSection

1) urpmi cgwd

2) nel menu di scelta che compare selezionare “beryl” al posto di compiz-quinn (selezionando compiz-quinn si può far riferimento a un’altra guida – basta cercarla attraverso la parola chiave “cgwd”)

3) installare tutte le dipendenze e sottodipendenze richieste automaticamente dai comandi precedenti

4) digitare “urpmi beryl-manager” e installare anche le 2 dipendenze che richiede

5) modificare il file /etc/sysconfig/compositing-wm in questo modo:

COMPOSITING_WM_START=yes

# if COMPOSITING_WM is not empty, it overrides the default compositing window manager (which is compiz)
COMPOSITING_WM=/usr/bin/beryl

# if COMPOSITING_WM_ARGS is not empty, it overrides the default arguments for the compositing window manager
COMPOSITING_WM_ARGS=”–indirect-rendering –replace”

# if COMPOSITING_WINDOW_DECORATOR is not empty, it overrides the default window decorator, the specified program will be run after compositing window manager
COMPOSITING_WINDOW_DECORATOR=/usr/bin/emerald

a questo punto andate sul pannello di MCC (se usate mandriva) ed alla sezione hardware, sciegliete 3D. Installate i pacchetti che chiede (se lo fa) e impostate gli effetti 3d su XGL.
RIAVVIATE X…E CHE LA MERAVIGLIA VI SI PRESENTI!!
Riferimenti: SCHEDE ATI/DRIVER/BERYL EASY URPMY GUIDA

AUDIO EDITOR OVER LINUX

3 Marzo 2007 5 commenti


http://www.mozarb.com/audionix/

Contrariamente a quanto si dice in giro, esiste una quantità notevole di programmi per GNU/Linux che hanno a che fare con la produzione musicale e la manipolazione di dati audio.In questa sezione vedremo come sia possibile un uso molto produttivo di GNU/Linux per applicazioni audio e musicali.

Tradizionalmente, le piattaforme privilegiate in questi campi erano (e sono ancora) le macchine apple (quindi Mac OS) e solo recentemente le macchine wintel (Windows). Esistono vari software professionali per queste piattaforme, dal costo di svariate centinaia di euro (come Logic, Cubase, Cakewalk, etc…). Spesso in una situazione di Home studio si utilizzano software di questo tipo abbinati ad hardware anch’essi semi-professionali (schede audio multi I/O) o professionali. Meno frequentemente capita che chi utilizza questi programmi ne abbia regolarmente acquistato la licenza d’uso, quindi un eventuale paragone con GNU/Linux è bene che tenga conto anche di questa circostanza.

La piattaforma GNU/Linux invece, essendo libera, non è legata ad un particolare hardware (non solo i386 ma anche PPC, Alpha, etc…) e nella maggioranza dei casi prevede un accordo di licenza per l’uso del software che mira a favorirne la copia e la diffusione piuttosto che ad impedirla.

Questo la rende una piattaforma molto appetibile per qualsiasi tipo di applicazione, e di conseguenza anche per le applicazioni audio/MIDI. Un ulteriore punto a favore di GNU/Linux è dato dall’estrema affidabilità del sistema (affidabilità comprovata a livello mondiale da numerose aziende del settore IT) che deriva dalla alta qualità del codice che lo compone.

La via più semplice per il successo

Se non hai ancora installato GNU/Linux sul tuo computer, ti consiglio di farlo al più presto (ovviamente), e se puoi scegliere ti consiglio, se vuoi lavorare con l’audio e il MIDI in GNU/Linux, di usare una RedHat 9.0 o fedora core2, che puoi scaricare ad esempio da linuxiso. Questo perchè esiste una università statunitense (quella di stanford) che fornisce tutta una serie di applicazioni già compilate e pronte ad essere installate su quella distribuzione.

Si tratta del progetto Planet CCRMA at home, progetto del “Stanford University Center for Computer Research in Music and Acoustics” che mira a creare un ambiente distribuito che metta a disposizione degli utenti tutto ciò che serve per creare in modo semplice una workstation audio/musicale con GNU/Linux.

Ecco, in sintesi, cosa ci viene offerto da PLanet CCRMA at home:

? Un kernel recente con patch preemptive e low-latency (che altrimenti sarebbe da scaricare, patchare, configurare e compilare, con tutti il tempo ed i problemi che questo comporta)

? Driver ALSA recenti (spesso versioni CVS)

? Una ottima raccolta di programmi audio e MIDI costantemente aggiornati.

? Una buona raccolta di programmi per la riproduzione e la modifica di video DV, mpeg, etc…

Agnula: un’altra via per l’illuminazione….

Altro progetto estremamente interessante mirato a creare una distribuzione completa e libera per usi audio/musicali (questa volta basata su Debian ) è AGNULA – A GNU Linux Audio Distribution.

Questo progetto è stato il primo progetto open source finanziato dalla comunità europea, e dopo due anni di sviluppo, ha già prodotto tre ottimi risultati:

? DeMuDi, la distribuzione vera e propria;

? Demudi 1.2.0 capace di far girare tutto il sistema operativo e le applicazioni senza dover installare nulla sull’hard disk – ento dimostrativo delle capacità di questa distribuzione, e un tool eccezionale da portarsi sempre in tasca ;)

? Agnula libre music, Un database di musica liberamente scaricabile e coperta da licenze open;

La distribuzione offre a livello di kernel gli stessi vantaggi di PLanetCCRMA, ALSA e jack propriamente configurati ed installati, ed un gran numero di applicazioni, oltre alle migliaia già normalmente disponibili per debian.

il mitico Dave Phillips si è occupato di scrivere moltissima chiara documentazione, consistente in tutorial (in inglese, per ora) che guidano l’utente in questo affascinante mondo .

Nonostante Agnula sia partita dopo PlanetCCRMA, ha raggiunto un buonissimo livello, e mi sento decisamente di consigliarla (il live cd poi è fantastico!). D’altronde, lo scopo finale di Agnula è a medio/lungo termine:

Total World Domination!

Ecco una categorizzazione di massima delle applicazioni musicali per GNU/Linux; non prendere questa come una categorizzazione imprescindibile, piuttosto se vuoi una panoramica più estesa dai un’occhiata al Sito di Dave Phillips:

? Players

Programmi usati per ascoltare musica, dal normale formato wav e aiff fino a ogg-vorbis e mp3

?Editor audio

Programmi usati per registrare, mixare, manipolare, aggiungere effetti, etc… all’audio digitale (vedi più avanti per conoscere le differenze tra audio e MIDI).

? Editor MIDI

Programmi usati per registrare e manipolare dati MIDI (vedi più avanti per conoscere le differenze tra audio e MIDI), spesso denominati anche sequencer.

? Editor multitraccia

Programmi usati per registrare audio in modo multitraccia, cioè con la possibilità di sovraincidere tracce audio a tracce audio precedentemente registrate.

? Sintetizzatori software (soft-synths)

Programmi che sintetizzano suoni via software. Spesso sono emulatori di sintetizzatori analogici, con oscillatori, inviluppi, filtri etc…spesso è possibile pilotarli via MIDI

? Trackers

I cosiddetti “trackers” sono software che permettono di utilizzare il computer come un campionatore: si caricano dei campioni di strumenti e si organizzano in “pattern” di varie tracce, che a loro volta vengono organizzati in una “song”.

Costituiscono un compromesso tra il carattere vettoriale del MIDI e il suono realistico dei .wav. Sono usatissimi per produrre musica house e dance.

? Notazione

Applicazioni che producono come output spartiti stampabili di qualità professionale e spesso anche file MIDI, a partire da file di testo scritti con una determinata sintassi.

? Utilities

Convertitori di formati audio, convertitori MIDI–>wave, encoder/decoder di mp3 e ogg, e programmi di utilità varia.

Audio digitale e MIDI: due approcci differenti

Le applicazioni audio e MIDI per Linux sono un discreto numero, e ci permettono di creare, manipolare, trasformare in vario modo dati audio e MIDI. Innanzitutto bisogna capire la distinzione tra questi due tipi di dato che possiamo genericamente definire “musicale”.

? Il MIDI o Musical Instrument Digital Interface, è un Protocollo di comunicazione tra strumenti musicali adottato ormai come standard da tutti i produttori di strumenti e hardware musicale. Se possiedi una tastiera elettronica, probabilmente avrà delle porte MIDI (tipicamente IN, OUT e THRU). Queste porte servono per collegare tra loro strumenti (ad esempio una tastiera, un computer, un sintetizzatore, un campionatore, etc…) in modo da farli comunicare. La comunicazione avviene con messaggi che specificano la nota da suonare (il pitch), l’intensità con cui deve essere suonata, per quanto tempo, etc…

Per questo parlo di un carattere “Vettoriale” del MIDI, in quanto il dato salvato contiene l’informazione in forma di “spartito”, cioè contiene informazioni circa le note che compongono la musica e non contiene affatto dati audio grezzi.

? L’Audio digitale, ossia quello che per intenderci è contenuto nei CD musicali, al contrario del MIDI non contiene alcuna informazione sul contenuto musicale in quanto tale della musica (o audio in genere) che rappresenta, ma ne è solo una trasposizione digitale, come per esempio l’audiocassetta ne era una trasposizione analogica.

Il catturare questo tipo di dato audio viene detto “campionare”, e i dati catturati vengono detti “campioni” (samples, in inglese). Il tipo di file che contiene questo tipo di dati è normalmente un file .wav, ma ci sono moltissimi altri formati di file audio.

Detto questo, è evidente ad esempio che una performance al pianoforte possa essere registrata in due modi: o con un sequencer MIDI (registrando cioè la sequenza di tasti che vengono premuti sulla tastiera) oppure registrando direttamente l’audio.

Nel primo caso, essendo il MIDI un formato vettoriale, potremo ad esempio spostare una nota suonata troppo presto o troppo tardi, cambiarne la durata, cambiare il tempo del brano senza cambiare l’intonazione, cambiare lo strumento con cui la performance viene suonata, etc…

Nel secondo caso, invece non avremo questo tipo di controllo sulle singole note ma dovremmo trattare l’intera performance come ua sorta di “fotografia” del suonato, alla quale potremo applicare effetti (riverbero, delay, equalizzatore, etc,,) ma avremo perso molta parte del controllo sul contenuto “musicale” della performance.

Da questo si evince anche come il MIDI sia lo strumento principe dei tastieristi, essendo le tastiere le periferiche MIDI per eccellenza. Esistono anche altri tipi di controller MIDI, ma sono meno diffusi e/o poco utilizzati.

Il MIDI è molto comodo, ma per alcune cose è assolutamente inutile: ad esempio per registrare una parte di chitarra o una parte vocale.

Players

(KDE) Amarok

AmaroK (http://amarok.kde.org/) è il lettore audio di KDE. E’ dotato di molte caratteristiche, è potente e facile da usare..

Molto simile ad Itunes di Apple ma sembra avere qualche marcia in più,

Il navigatore per contesti è caratterizzato da un database compilato istantaneamente (SQLite) e che fornisce statistiche sulle tue playlist costantemente aggiornate. Inoltre, il navigatore per contesti può anche visualizzare le immagini delle copertine degli album e i testi relativi. Caricare le playlist salvate nel navigatore è facile come premere un tasto.

Oltre che aRts, amaroK supporta i server sonori GStreamer, NMM e xine che lo rendono il lettore audio più avanzato disponibile per KDE.

Inoltre è:

*

integrato con K3B per la masterizzazionedei cd

*

ha un eqalizzatore 10 bande

*

scarica gli artwork dell’album usando gli Amazon services
*

tradotto in 35 lingue
*

supporta la connessione con Ipod Apple

La guida dice: AmaroK è compatto, sexy, geniale.

(KDE) Juk
uK è un jukebox, un modificatore di tag e un gestore di raccolte di musica.

(GNOME) Rythmbox
Rhythmbox http://www.rhythmbox.org/ è una applicazione integrata per la gestione della musica sul proprio sistema GNU/Linux, ispirato da iTunes di Apple. Con pochi passaggi è possibile catalogare in modo automatico tutti i file musicali memorizzati sull’ hard-disk, suddividendoli per autore e genere. Offre inoltre strumenti per la riproduzione dei brani, il che lo rende uno strumento completo e comodissimo.

XMMS

Semplicemente: il clone *nix

Editor audio

Rezound

Rezound (http://rezound.sourceforge.net/) è forse il mio editor audio preferito per linux, ed è anche attualmente (Sett. 2003) l’unico che supporta il server audio low-latency jack.

E’ un editor giovane ma già pieno di funzioni e caratteristiche interssanti. Quando acquisirà il supporto ai plugin LADSPA sarà di certo uno dei migliori editor audio per linux. Possiede tutto quello che ci si aspetta da un editor audio professionale, a partire da un discreto numero di operazioni di editing (Cut, Copy, Paste, Copy to new, Delete, Crop, Insert, Replace, Overwrite, Mix, Paste to new, etc…), un buon numero di tipi di file supportati (wave, aiff, NeXT, IRCAM, raw, ogg, mp3) ed alcuni effetti e filtri.

La vera forza di rezound è il suo supporto per il server jack, che lo rende un ottimo strumento per registrare l’output proveniente da altri programmi ed editarlo contemporaneamente senza dover chiudere/stoppare il server jack.

Sweep

Sweep è un altro editor molto potente e facile da usare. Supporta tra l’altro le selezioni multiple e lo “scrubbing”.

Sicuramente sweep è uno dei migliori editor audio per GNU/Linux, e supporta egregiamente i plugin LADSPA. Altra funzione comoda è il play di un campione in “loop”, ossia la possibilità di far suonare un campione in modo ciclico (quando viene raggiunta la fine si ricomincia dall’inizio) anche sulla sola zona selezionata.

Un software che non può mancare nel nostro toolkit!

Audacity

Audacity è un editor audio semplice da usare e potente, ed è inoltre disponibile non solo per GNU/Linux ma anche per Windows e MacOS, fatto che lo rende forse l’unico editor audio multi-piattaforma. E’ disponibile per il download sul suo sito su sourceforge.

Anche audacity supporta le più comuni operazioni di editing taglia, copia e incolla, ed inoltre ha un supporto basico per il multitraccia e supporta i plugin LADSPA (Linux Audio Developers Simple Plugin Architecture), tramite i quali si possono aggiungere interessanti effetti ai file audio.

Ecco cosa ne dicono sul sito: “Audacity è un editor audio libero. E’ possibile registrare suoni, riprodurre, importare e esportare file WAV, AIFF, MP3 e altro. Usalo per modificare i tuoi file di suono usando Taglia, copia e incolla (con ripetizioni inlimitate Undo), mixare le tue traccie, o applicare effetti alle tue registrazioni. Ha un mdoficatore di amplitudine integrato, un spectrogramma personalizzabile e una finestra per l’analisi di frequenza. Gli effetti integrati includono Bass Boost, Wahwah, la rimozione del rumore, e supporta inoltre gli effetti VST tramite plug-in. ”

Snd

Snd è un editor audio molto potente, a dispetto del suo look scarno ed essenziale. E’ stato scritto da Bill Schottstaedt e puoi fare una visita alla sua Home Page, dove troverai il software stesso scaricabile in forma sorgente e in forma binaria (rpm) e il manuale (molto dettagliato e preciso) – probabilmente esiste già un pacchetto per la tua distribuzione, prima di scaricarlo direttamente dal suo sito verifica di non averlo già installato.

Questo software consente le più comuni operazioni di modifica dei file audio come taglia, copia e incolla, una funzione “mix” molto comoda che permette di mixare pezzi di file audio tra loro potendo decidere il punto di mixaggio in modo preciso.

Editor Midi

Muse

Muse (http://muse.seh.de/) è uno dei sequencer più promettenti della scena GNU/Linux. Utilizza il toolkit grafico QT (lo stesso del KDE) e offre moltissme delle funzioni di editing che ci si aspetta da un sequencer professionale.

Con questo programma è possibile creare arrangiamenti MIDI complessi ed utilizzare a pieno le possibilità offerte dal layer MIDI dei driver ALSA, quindi porte MIDI multiple (sia esterne che virtuali come ad esempio i Soft-synth), supporto per il server audio low-latency jack, import/export di standard midifiles, etc…

Naturalmente con Muse è possibile registrare performance MIDI suonate su una tastiera esterna, il che lo rende un ottimo tool per i tastieristi.

Incorpora inoltre alcuni soft synth come fluidsynth, che permette di caricare un soundfont (estensione .sf2) e di utilizzare quindi il PC come se fosse un expander o un campionatore esterno (risparmiandoci però di comprarne uno!!)

Benché muse non sia ancora giunto alla versione 1.0 (al momento siamo alla 0.6.1 – settembre 2003), e nonostante manchino alcune funzioni di quantizzazione, come sequencer MIDI si può forse considerare il migliore attualmente disponibile per linux, e il fatto che gestisca anche l’audio (anche se ad un livello baslilare), ne fa un ottimo candidato a sostituire cubase, logic, sonar e altri blasonati software commerciali.

La distanza che lo separa da questi sequencer più “maturi” è ancora abbastanza grande, ma se consideriamo che può essere usato in combinazione con jack e i tanti ottimi soft-synth disponibili, nella migliore tradizione di riusabilità e flessibilità UN*X, la distanza comincia a sembrare più piccola.

Seq24

Seq24 (http://www.filter24.org/seq24/) è un sequencer giovane ma già molto promettente. Adotta la filosofia tipica di UNIX “less is more”, ovvero “fai poche cose ma falle bene”.
Infatti è un programma dedicato esclusivamente al sequencing MIDI, ed ha poche ma chiare funzioni. L’interfaccia è abbastanza spartana ma piacevole, ed è pensato per un uso soprattutto live, ma si comporta bene anche in situazioni “studio”. Sicuramente non è un sequencer che possa rivaleggiare con i “giganti” commerciali, ma nella sua semplicità offre un comodo ambiente di editing MIDI, senza troppi fronzoli ma con già tutte le feature di base che ci si aspetta da un sequencer.
Ha ancora alcuni limiti di usabilità (ad esempio per l’inserimento di un program change, che deve essere “disegnato” come un controller), ma è un sequencer di tutto rispetto, soprattutto per chi vuole lavorare con loop MIDI.
Il concetto di base di seq24 è di avere una serie di “pattern” da poter attivare/disattivare a piacimento, ognuno con i suoi parametri di canale midi, dispositivo midi, etc… Tali pattern possono poi essere organizzati tramite la finestra song editor in una performance più articolata.
Supporta pienamente l’ALSA sequencer ed è quindi in grado di dialogare via midi con una molteplicità di dispositivi sia esterni che software.
La nuova versione 0.6.0 include anche un supporto preliminare a jack_transport, che permette di usaer seq24 in sincronia software con altri client del server audio JACK.
L’unico editor che fornisce è il piano roll, che consente di editare gli eventi midi registrandoli o disegnandoli con la matita, e include un editor di controller MIDI molto intuitivo.

Rosegarden
Rosegarden (http://all-day-breakfast.com/rosegarden/) è un altro sequencer per linux dalle ottime caratteristiche.
Supporta le tracce audio, ALSA e jack, ha un eccellente supporto per vari sintetizzatori e permette di crearsi uno “studio virtuale” organizzando i propri strumenti MIDI in banchi dei quali è possibile editare i nomi degli strumenti, i controller, le modalità di selezione dei banchi, etc…
Supporta inoltre un gran numero di formati di import/export, tra i quali spiccano csound e lilypond (oltre al classico midifile). Questo ne fa un editor capace di generare spartiti per la stampa di grande qualità e anche spartiti per il famoso linguaggio di sintesi csound.
Tramite i plugin LADSPA è possibile applicare effetti alle tracce audio.
Bisogna dire che rosegarden contiene forse il miglior editor “score” (spartito) visuale per linux al momento. Per chi scrive la musica su pentagramma questo è un grosso aiuto, non presente negli altri sequencer, e potrebbe costituire il motivo di una scelta a favore di rosegarden.
Ha anche una gestione invidiabile dello “studio”, ovvero del setup MIDI (che a volte può diventare anche molto complesso) delle periferiche, alle quali è possibile assegnare banchi di suoni con nomi “human readable” invece dei soliti numeri di program change.
Personalmente preferisco muse come sequencer, perchè nel mio setup si è dimostrato più stabile. Ma rosegarden ha delle caratteristiche aggiuntive molto interessanti, ed è sicuramente un progetto da tenere d’occhio.
Una lettura consigliata a chi decidesse di provare rosegarden è sicuramente il “Rosegarden Tutorial”, molto ben fatto e completo, anche se ancora in fase di redazione.

Jazz++

Jazz++ (http://www.jazzware.com/) è uno dei primi sequencer apparsi per GNU/Linux.
Si tratta di un ottimo software, disponibile anche per windows (a mia conoscenza è anche uno dei migliori, se non l’unico con licenza libera), che purtroppo da qualche anno non viene più sviluppato attivamente.
Questo è un vero peccato perché è un ottimo sequencer MIDI con tante caratteristiche interessanti come ad esempio:

? Un browser di accordi ? Generatore di ritmi casuali ? Generatore di melodie casuali ? Generatore di arpeggi

Utilizza la vecchia interfaccia OSS per la gestione delle periferiche MIDI, e questo a mio avviso è il punto più dolente, perché i driver ALSA hanno un design molto migliore e più flessibile. Ciononostante, jazz permette di modificare moltissimi parametri MIDI in un midifile, anche in modo semi-automatico (ad esempio la velocity e i controller)
E’ stato recensito in un articolo di Linuxfocus che trovate Cliccando qui

Editor Multitraccia

Ardour

Dal sito:
Ardour is a multichannel hard disk recorder (HDR) and digital audio workstation (DAW). It is capable of simultaneous recording 24 or more channels of 32 bit audio at 48kHz. Ardour is intended to function as a “professional” HDR system, replacing dedicated hardware solutions such as the Mackie HDR, the Tascam 2424 and more traditional tape systems like the Alesis ADAT series. It is also intended to provide the same or better functionality as proprietary software DAWs such as ProTools, Samplitude, Logic Audio, Nuendo and Cubase VST/SX (we acknowledge these and all other names as trademarks of their respective owners). It supports MIDI Machine Control, and so can be controlled from any MMC controller, such as the Mackie Digital 8 Bus mixer and many other modern digital mixers.
Si può ben dire che ardour (http://ardour.sourceforge.net) sia la “punta di diamante” delle applicazioni audio per GNU/linux. E’ ancora in fase beta, ma il suo sviluppo è costante e frenetico, e presto avremo una versione stabile.
Si tratta di un software professionale di Hard Disk recording, capace di trasformare il tuo PC in uno studio di registrazione preofessionale (hardware permettendo).
Una buona introduzione (in inglese) ad ardour ce la fornisce Dave Phillips in un articolo su linux journal: http://www.linuxjournal.com/article/7796.
Ardour è pensato per lo studio professionale, ed ha moltissime caratteristiche interessanti quali l’automazione dei volumi e dei pan, l’automazione dei parametri dei plugin, la risoluzione interna a 32 bit, la possibilità di creare tracce con un numero arbitrario di canali, il fatto che utilizza editing non distruttivo, la possibilità di eseguire degli “snapshot” delle sessioni su cui si lavora, etc….
Un ringraziamento a Paul Davis, la mente che sta dietro al progetto e che ha contribuito moltissimo allo sviluppo di altri software chiave per l’audio in GNU/Linux come il server low-latency jack

Wired
Wired è un nuovo software che aspira essere il sistema professionale per la composizione musicale su piattaforma GNU-Linux
Caratteristiche di Wired: supporta illimitate tracce in registrazione e playback introduce un nuovo sistema a Plugin per virtual instruments ed effetti legge cd in formato AKAI importa file audio in 18 differenti formati
I seguenti strumenti sono già stati sviluppati per Wired:
? Loop sampler, con time-stretching ? Beatbox con un nuovo concetto di editing, per creare complessi e realistici pattern di batteria ? MIDI controlled sampler, che può leggere cd AKAI e files audio ? Filtri High-pass, Low-pass e Notch ? Compressore/Limiter ? Delay
Links: http://bloodshed.net/wired/

Ecasound
Ecasound (http://www.eca.cx) è un programma a linea di comando per il “multitrack audio processing”, ossia permette di registrare, riprodurre, mixare e aggiungere effetti in multitraccia in tempo reale.
Ad esempio, questa linea di comando:ecasound -c -b:256 -r -f:16,2,44100 -a:1 -i monitor-track.wav -o /dev/dsp -a:2 -i /dev/dsp -o new-track.wav
Permette di registrare il file “new-track.wav” mentre si ascolta il file “monitor-track.wav”. In seguito è possibile mixare i due (o più) file insieme in questo modo:ecasound -c -a:1 -i monitor-track.wav -a:2 -i new-track.wav -a:all -o /dev/dsp
Ecasound supporta un gran numero di formati di file audio, gli effetti LADSPA ed ha un gran numero di opzioni da linea di comando (man ecasound per saperne di più). Ad esempio, un comando molto comodo che mi sono trovato ad utilizzare in varie occasioni è il seguente:ecasound -i /dev/dsp -o file.mp3
che, come è intuibile, consente di registrare direttamente in formato compresso mp3 (a patto di avere un encoder adeguato), con conseguente risparmio di spazio su Hard Disk

SoftSynth

ZynAddSubFx

ZynAddSubFx (http://zynaddsubfx.sf.net) di Nasca Octavian Paul è uno dei sintetizzatori virtuali più potenti per Linux, e produce suoni veramente eccezionali. Come si può (non facilmente) intuire dal nome, questo synth ha la possibilità di utilizzare sintesi additiva e sottrattiva, ed ha inoltre un banco di effetti incorporato.
Molti parametri sono gestibili e controllabili via MIDI e l’uscita audio prevede anche l’uso del server jack, cosa che lo rende molto appetibile per essere usato in contemporanea ad altri programmi (ad esempio il sequencer muse) e di poter catturare l’audio prodotto ad esempio in una traccia audio del sequencer.
Questa configurazione viene utilizzata ad esempio da Mathias Lundgren, un “linux-audio enthusiast” che si è prefisso lo scopo di creare un intero album utilizzando solamente linux e free software. Nella sua home page (http://www.helgo.net/gavel/linuxmusic) puoi leggere come ha usato questi software, scaricare alcuni premix (per renderti conto della qualità sonora di ZynAddSubFx) e anche le patch usate per creare quei suoni.
ZynAddSubFx è un software abbastanza complesso e sarebbe difficile descrivere completamente le sue caratteristiche qui, comunque riporto una (parziale) traduzione delle “features”:

? sintetizzatore realtime ? polifonico e multitimbrico ? capacità microtonali ? 2 motori di sintesi: ADsyn che implementa la sintesi additiva sommando voci ognuna delle quali con filtri, inviluppi, LFO, morphing, modulatori, risonatori, etc… SUBsyn un modulo più semplice che permette la creazione di suoni sottraendo armonici a rumore bianco. ? Gli strumenti possono essere organizzati in kits ? Effetti: Reverb, Echo, Chorus/Flange, Phaser,AlienWah, Distorsion e EQ ? Gli effetti possono essere usati come effetti di sistema o in insert sulla singola parte ? filtri fino a 60dB/ottava ? Molti settaggi hanno un parametro di casualità che permette la creazione di suoni interessanti in cui una nota non è mai uguale alla precedente. ? supporto MIDI e server audio JACK ? Tastiera virtuale ? Licenza GPL ? molte altre…

Insomma, direi un software quasi “indispensabile”… ;)

ALSA modular synth

Alsa Modular Synth del Dr. Mathias Nagorni è un altro synth virtuale molto potente per linux. A differenza di ZynAddSubFX, Alsa Modular Synth (ams) adotta un approccio modulare, dove l’utente può creare il proprio synth virtuale a partire da moduli come oscillatori (VCO), amplificatori (VCA), inviluppi (ENV), filtri (VCF), etc…
Questo lo rende una piattaforma di sperimentazione molto avanzata, e permette la creazione di suoni molto interessanti nonché l’emulazione di sintetizzatori del passato (es. moog).
ams ha una implementazione MIDI molto completa, e permette con grande facilità di assegnare controller MIDI (ad esempio gli slider di una tastiera o di un controller MIDI) a tutti i parametri dei moduli, consentendo in questo modo una gestione “realtime” di tali parametri.
Altro grossissimo punto a favore di questo splendido synth è la sua completa integrazione con i plugin LADSPA, che possono essere inseriti anch’essi come moduli e pilotati nei loro parametri via MIDI con la medesima facilità.
Si possono traovare maggiori dettagli nella Documentazione, molto dettagliata, e in un “Quick Toot” dedicato proprio ad ALSA modular synth.
Un altro software caldamente consigliato ;)

Fluid Synth (e qsynth)

Fluidsynth (http://www.fluidsynth.org) non è propriamente un sintetizzatore virtuale, o meglio è un sintetizzatore virtuale che utilizza la sintesi wavetable. In particolare, fluidsynth utilizza i soundfonts per generare il suono.
Supporta l’ALSA sequencer e il server audio jack, quindi può essere usato in abbinamento ad un sequencer (o anche semplicemente “suonato” con una tastiera MIDI) e svolgere la funzione di “campionatore virtuale”.
In rete si trovano già moltissimi soundfonts, da quelli specifici per uno strumento fino ai soundfont General MIDI, molto utili per eseguire midifile codificati rispettando questo standard. Inoltre, è possibile creare i propri soundfonts con l’editor swami (http://swami.sourceforge.net), che permette un controllo dettagliato di ogni parametro relativo allo strumento, conformemente alle specifiche del formato soundfont.
Nonostante fluidsynth sia un software piuttosto giovane ed ancora in fase di sviluppo, è già usabile con profitto e promette molto bene per il futuro.
Esiste inoltre una comoda interfaccia grafica (o GUI, Graphical User Interface) per fluidsynth chiamata Qsynth (nell’immagine), che permette di variare alcuni parametri come il volume, il riverbero, etc.. con comodi potenziometri virtuali.

Trackers

Soundtracker
Soundtracker di Michael Krause (www.soundtracker.org), è certamente uno dei tracker più maturi e stabili per GNU/Linux. E’ un eccellente tool di creazione di loop e di canzoni pattern-based, ed offre un modo molto veloce e creativo di “mettere insieme” pezzi di audio digitale per formare basi, loop, song, etc…
Include inoltre un editor audio abbastanza scarno ma efficace, la possibilità di esportare il modulo creato in un file audio .wav, ed è pienamente compatibile con il diffuso standard XM (fast tracker II).
Per una introduzione all’uso dei tracker, links a siti di campioni etc.. si veda united-trackers.org.

Hydrogen
Hydrogen (http://www.hydrogen-music.org/) non è propriamente un tracker ma più che altro una drum machine molto ben fatta. L’ho messo in questa sezione perchè a me risulta utilissimo in combinazione con soundtracker in quanto permette di realizzare molto velocemente loop di batteria stereo con molti parametri configurabili, volume, panpot e campione di ogni strumento, volume generale e funzioni di swing, umanizzazione e di esportazione in wav.
Inoltre è un progetto molto intressante costantemente aggiornato dai suoi sviluppatori, e fa molto ben sperare per il futuro: include già il supporto per il server audio low latency jack e per il MIDI input.
Ha un’interfaccia grafica gradevole (cosa non comunissima nei programmi linux ;) e molto intuitiva e permette di generare anche song piuttosto complesse. In conclusione, un software caldissimamente consigliato.
Oltre a questo, hydrogen è un progetto italiano. Grazie al principale autore, Comix e anche a tutti gli altri, per tenere alta la nostra bandiera nella nobile arte della scrittura e della condivisione di software di qualità.

Notazione

Noteedit

Noteedit (http://rnvs.informatik.tu-chemnitz.de/~jan/noteedit/noteedit.html) è un programma di notazione musicale molto capace, ed è costantemente sviluppato dal suo autore principale, Joerg Anders, che aggiunge spesso nuove caratteristiche e correzioni di bug.
Ha moltissime caratteristiche che lo rendono comodissimo da usare, ad esempio, oltre alla possibilità di inserire le note con il mouse, è possibile inserirle direttamente da una tastiera MIDI opportunamente configurata, selezionando la durata delle note con la tastiera del computer.
Inoltre noteedit può esportare in vari formati di file per la stampa: lilypond, MusiXTeX, PMX, e il suo formato nativo è compatibile con mup (vedi sotto). Altro pregio è la completa implementazione MIDI di noteedit che consente, oltre all’ascolto immediato tramite un expander esterno o un softsynth, l’esportazione in midifile, facendone anche un buon sequencer.
un programma caldamente consigliato a chiunque debba scrivere musica.

Mup
Mup (http://www.arkkra.com/) è un programma di notazione musicale completo, che può competere con giganti quali finale, ma ahimè non è software libero.
Può essere scaricato e provato gratuitamente, ma l’output che produrrà conterrà una scritta sullo sfondo che indica che il software non è stato registrato.
Il costo è abbastanza contenuto: 29 $, e se paragonato al costo altri software commerciali di notazione musicale, è di certo uno dei più bassi.
Questo software ha delle caratteristiche molto avanzate, è piccolo, veloce e può essere usato in abbinamento con il succitato noteedit, che consente di inserire le note in modo grafico anziché in un file di testo (con una sintassi peraltro abbastanza semplice e veloce da imparare).
Supporta praticamente ogni costrutto della notazione musicale, fino a 40 righi, fino a 3 voci indipendenti per rigo, Liriche, Accordi per chitarra in formato “grid”, etc…
Inoltre l’output che produce è di altissima qualità e non necessita di una installazione di TeX.
Potete leggere una recensione online di Mup fatta da Bob Van Der Poel Cliccando qui.

Utilities
Tuneroid

Tuneroid (http://www.uid0.sk/zyzstar/?tuneroid) è un accordatore cromatico per tutti gli strumenti. Consente di accordare lo strumento collegando un microfono o lo strumento stesso alla scheda audio.
E’ anche abbastanza configurabile: si può modificare la sensibilità dell’accordatore per ottenere una risposta ottimale, ed è inoltre possibile utilizzare una frequenza base diversa da quella standard (440 Hz).

Solfege
GNU Solfege (http://solfege.sourceforge.net/) è un bellissimo programma di ear-training, utilissimo per i musicisti. Serve, per chi non lo sapesse, ad “addestrare l’orecchio” proponendo degli esercizi ai quali lo “studente” deve rispondere. Prevede anche le statistiche in modo da poter tener traccia dei miglioramenti fatti.

Ecco i tipi di esercizi che prevede:

? accordi ? accordi-voicing ? intervalli armonici ? intervalli cantati ? intervalli melodici ? identificazione scala ? accordi di nona per nome ? dettato ? identificazione tono ? comparazione intervalli ? canta accordo ? ritmo ? bpm ? progressione armonica dettata

Timidity++
Timidity++ (http://www.goice.co.jp/member/mo/timidity/) è un renderizzatore di file MIDI in file audio: in pratica legge un file MIDI e lo trasforma in un file audio (utilizzando i soundfonts o le patch gravis come strumenti). E’ un software utilissimo che, se abbinato ai soundfonts (ne puoi trovare centinaia su http://www.hammersound.net), fornisce le funzionalità di un modulo sonoro esterno senza doverne acquistare uno.
Può anche essere utilizzato in modalità server, ossia come sintetizzatore in realtime, e invece che generare un file audio, invia l’uscita alla scheda e suona in tempo reale.
un esempio di comando per renderizzare un midi in un wav:timidity -Ow file.mid

Un esempio di funzionamento in modalità server ALSA:timidity -iA -B2,8

Sox
Sox (http://sox.sourceforge.net/) è un convertitore di file audio, dei quali conosce moltissimi formati, e si può ben dire che è, al pari di ImageMagik per le immagini, il “coltellino svizzero” (insieme ad ecasound) della manipolazione audio su Linux.
Inoltre il fatto di avere un’interfaccia CLI (command line interface) permette di usarlo in batch, cioè di creare degli script che convertono ad esempio intere directory con un solo comando. Permette inoltre l’applicazione di effetti di base (fade in/out, filtri, equalizzazioni, reverberi, chorus etc…)

Lame
Lame (Lame Ain’t an Mp3 Encoder) è di certo il più famoso encoder di mp3 (forse anche uno dei primi) ed è disponibile in forma sorgente presso il sito lame.sourceforge.net.
Spesso le distribuzioni non lo includono per problemi di brevetto riguardanti l’algoritmo di codifica mp3 che non è libero. Nel mondo linux infatti si preferisce la codifica Ogg/Vorbis, che tra l’altro offre un migliore rapporto di qualità.

SSH TUNNEL VNC

2 Marzo 2007 1 commento

http://forum.wininizio.it/index.php?showtopic=29492
Riferimenti: SSH TUNNEL VNC

Aiuto Per Franco

2 Marzo 2007 4 commenti

Ciao Caro Franco, se ti server una mano, scrivi pure i tui dubbi qui, spero di esserti di aiuto.
Riferimenti: per franco

SCHEDA WIRELESS SU UN LAPTOP CON ARCHLINUX

25 Febbraio 2007 1 commento

SCHEDA WIRELESS SU UN LAPTOP CON ARCHLINUX
La scheda wireless interna è una Pro Intel 2200BG, la parte sotto descritta riguarda una Archlinux sia con kernel ricompilato (2.6.15.2) sia non ricompilato e quindi con kernel che fa già parte di Arclinux. Utilizzando un kernel ricompilato, al momento della configurazione di questo
NON selezionare nessun dispositivo wireless.
Avremo bisogno di 3 files:
Ieee80211

http://ieee80211.sourceforge.net/

Ipw2200

http://ipw2200.sourceforge.net/

firmware v3.0

http://ipw2200.sourceforge.net/firmware.php

- Con kernel NON ricompilato e quindi usando quello di default:
Scompattare:
ieee80211-1.1.14.tgz
tar zxvf ieee80211-1.1.14.tgz
. remove-old (inserire anche il punto, se fa delle domande rispondere con y)
make (se fa delle domande rispondere con y)
make install
Se la procedura fallisse ripeterla.
Scompattare:
ipw2200-1.1.3.tgz
tar zxvf ipw2200-1.1.3.tgz
. remove-old (inserire anche il punto, se fa delle domande rispondere con y)
make (se fa delle domande rispondere con y)
make install
Se la procedura fallisse ripeterla.
Infine scompattare ipw2200-firmware-3.0.tgz e copiare i 4 files presenti in /lib/firmware (se non esiste, creare la directory da utente root)
tar zxvf ipw2200-firmware-3.0.tgz
depmod -a
modprobe ipw2200
iwconfig
A questo punto dovreste trovare la scheda wireless eth2 o wlan0, od altro nuovo device.
Sotto Archlinux andare in /etc/ ed editare il file rc.conf
Se avete più connessioni su router wireless assegnare un dhcp alla scheda di rete oppure assegnargli un indirizzo fisso.
eth2=”dhcp”
INTERFACES=(lo eth2)
ROUTES=(!gateway) (Se la scheda avrà un ip fisso, cancellare il punto interrogativo “!”)

- Con kernel ricompilato:
All’interno del kernel non selezionare nessun dispositivo wireless sotto network e
Scompattare:
ieee80211-1.1.14.tgz
tar zxvf ieee80211-1.1.14.tgz
. remove-old (inserire anche il punto, se fa delle domande rispondere con y)
make (se fa delle domande rispondere con y)
make install
Se la procedura fallisse ripeterla.
Scompattare:
tar zxvf ipw2200-1.1.3.tgz
. remove-old (inserire anche il punto, se fa delle domande rispondere con y)
make (se fa delle domande rispondere con y)
make install
Se la procedura fallisse ripeterla.
Infine scompattare ipw2200-firmware-3.0.tgz e copiare i 4 files presenti in /lib/firmware (se non esiste, creare la directory da utente root)
tar zxvf ipw2200-fw-3.0.tgz
depmod -a
modprobe ipw2200
iwconfig
Se la scheda wireless trovata sarà eth2 il gioco è fatto.
Sotto Archlinux in /etc/rc.conf, scegliere se la scheda dovrà ottenere un indirizzo ip automaticamente in dhcp, oppure se dovete specificarlo voi.
Nel mio caso /etc/rc.conf è configurato così:
eth2=”dhcp”
INTERFACES=(lo eth2)
ROUTES=(!gateway) (Se la scheda avrà un ip fisso, cancellare il punto interrogativo “!”)
Nelle altre distribuzioni linux la gestione dei files per la rete è diversa, quindi controllate bene.

E adesso navighiamo con il wireless. Vediamo come farlo manualmente ed anche con il programma grafico KiFiManager.

- Manualmente:

iwlist eth2 scanning (Troverà ad esempio 2 server wireless, dove solo la seconda è criptata, quindi per connettervi avremo bisogno della password)
Cell 02 – Address: 00:14:BF:00:10:04
ESSID:”dsaw”
Protocol:IEEE 802.11bg
Mode:Master
Channel:1
Encryption key:on
Bit Rates:54 Mb/s
Extra: Rates (Mb/s): 1 2 5.5 6 9 11 12 18 24 36 48 54
Extra: Last beacon: 500ms ago

Cell 03 – Address: 00:13:10:0C:D7:4A
ESSID:”linksys”
Protocol:IEEE 802.11b
Mode:Master
Channel:6
Encryption key:off
Bit Rates:11 Mb/s
Extra: Rates (Mb/s): 1 2 5.5 11
Quality:37 Signal level:0 Noise level:0
Extra: Last beacon: 168ms ago

iwlist eth2 frequency (trova la frequenza di 6 canali)
eth2 11 channels in total; available frequencies :
Channel 01 : 2.412 GHz
Channel 02 : 2.417 GHz
Channel 03 : 2.422 GHz
Channel 04 : 2.427 GHz
Channel 05 : 2.432 GHz
Channel 06 : 2.437 GHz
Channel 07 : 2.442 GHz
Channel 08 : 2.447 GHz
Channel 09 : 2.452 GHz
Channel 10 : 2.457 GHz
Channel 11 : 2.462 GHz
Current Channel=1

Connettiamoci al server di rete chiamato linksys che non è criptata (non sempre servono la frequenza, il mode ed il canale):
iwconfig eth2 essid linksys channel 6 mode auto freq 2.437G ap 00:13:10:0C:D7:4A
cd /etc/rc.d && ./network restart (su Archlinux riavviamo la rete, in altre distro si fa diversamente. Se da errore o se la scheda non acquisisce l’indirizzo ip in dhcp vuol dire che non c’è segnale in quel momento o che avete inserito un dato sbagliato).
ifconfig eth2 (date un ifconfig per vedere se la scheda eth2 ha un inidirizzo ip, altrimenti ridare il comando sopra)

Connettiamoci al server di rete chiamato dsaw che è criptato (ho inserito 2 stringhe di esempio, va bene usare l’una o l’altra).
iwconfig eth2 essid dsaw key restricted 5693FFC5FF
oppure
iwconfig eth2 mode auto essid dsaw freq 2.412G channel 1 key restricted 5693FFC5FF ap 00:14:BF:00:10:04
cd /etc/rc.d && ./network restart (su Archlinux riavviamo la rete, in altre distro si fa diversamente. Se da errore o se la scheda non acquisisce l’indirizzo ip in dhcp vuol dire che non c’è segnale in quel momento o che avete inserito un dato sbagliato).
ifconfig eth2 (date un ifconfig per vedere se la scheda eth2 ha un inidirizzo ip, altrimenti ridare il comando sopra)

Riferimenti: SCHEDA WIRELESS SU UN LAPTOP CON ARCHLINUX

XGL

20 Febbraio 2007 6 commenti

http://mandrivausers.org/index.php?showtopic=31369

have the full features Xgl from mandriva :

1.configure the club_club repositorie (go on mirror finder to do that), then :

Code:
urpmi gnome-desktop gnome-panel gnome-control-center mdk-check-update-gnome gnome-themes-extras gnome-session gnome-menus gnome-audio-extra gnome-common GConf2
and some other. Some rpms have wrong or none gpg keys, it is not very importante here. install them, all. Add some other rpm if you want to be sure Gnome is entirely functionnal.

1.5 Open one time gnome and verify it works fine[you could create a new user if you want (to test first time)]

2.configure the Xgl mandriva repositorie

Code:
urpmi.addmedia Xgl-mdv http://people.mandriva.com/~vguardiola/xgl/ with hdlist.cz

3.install xgl.

Code:
urpmi compiz-xgl-compat xgl-cvs-060225-0.0.1-2 xorg-xgl-compat-2006-1.0-1 libcairo-xgl-compat-1.0.2-1 libdrm-xgl-compat-2.0-1 libglitz-xgl-compat-0.5.4-1 libsvg-cairo-xgl-compat-0.1.6-1 libsvg-xgl-compat-0.1.4-1 mesa-xgl-compat-2006-1.0-1

4. stop X and dm. in root :

Code:
service dm stop

5. start Gnome in Xgl, in simple user (!! user !! not root), just :

Code:
startxgl

that s all

Xgl comes with full features pre-configured ! no need to configure nothing (not like other distro). Click on little ‘desktop manager’ on right bottom bar and turn the desktop. (or crtl+alt+mouse clicks !). Move windows : they are .. funies … Open a video, it is work ! open other 3d applx (as a game -nexuiz not fullscreen?- or blender) : works fine !!! (so, we have the most beautifull xgl configuration out-of-the-box). And configure with a very good startxgl on mandriva, as our startgnome or stratkde, to launch desktop entirely rootless -without dm-)

yeah mandriva rox.
but.. you wan,t now, have kde with Xgl ?
hehehe.. simple edit the lanuch’script and change the order. Open startxgl script and place this one in : DISPLAY=:1 startkde & (turn off DISPLAY=:1 startgnome & with an # before). but Xgl is construct for gnome, not for kde. So launch kde risks bugs…

Xgl ? we want ? we have !

6. turn off desktop session ? not need ‘quit’ option menu. Please use Ctrl+Alt+backspace.

*************************************************************************************

I’ve found that there is realised rpm’s for Mandriva: http://people.mandriva.com/~vguardiola/xgl/
I’ve tasted it. XGL IS GREAT!!!
But i have some problems with the keyboard and mouse.I can’t use the scroll of the mouse.I can’t use the num pad of the keyboard and i can’t change the input language of the keyboard. Did somebody know where is the conf file and how to setup the mouse and the keyboard to make them work?
Here is how to install it:
Riferimenti: XGL