Ceci n'est pas une pipe

Attenzione! Questo è soltanto l’aggiornamento di un post pubblicato mesi fa, la cui lettura raccomando vivamente prima di procedere oltre, a meno che non si conosca già sufficientemente l’argomento. Clicca qui per accedere al vecchio post.

Fatta questa piccola – ma doverosa – premessa, ecco le istruzioni per compilare il nuovo kernel 2.6.25 per l’attuale stable release di Debian GNU/Linux (nome in codice: Etch).

Per prima cosa è necessario scaricare i sorgenti del nuovo kernel Linux 2.6.25:

# apt-get -t etch-backports install linux-source-2.6.25

Poi procediamo come di consueto:

1. Spostiamoci nella directory dove sono collocati i nuovi sorgenti e scompattiamoli:
   # cd /usr/src
# tar xjf linux-2.6.25.tar.bz2
# ln -s linux-2.6.25 linux
# cd /usr/src/linux
2. Resettiamo (opzionale) tutti i parametri di compilazione e rivediamoli per maggiore sicurezza:
   # make clean && make mrproper
# cp /boot/config-`uname -r` ./.config
# make menuconfig
3. Compiliamo i sorgenti e prepariamo i pacchetti .deb:
   # make-kpkg clean
# fakeroot make-kpkg --initrd --append-to-version=-tetragono kernel_image kernel_headers
4. Installiamo i pacchetti .deb:
   # cd ..
# dpkg -i linux-image-2.6.25-tetragono_2.6.25-tetragono-10.00.Custom_i386.deb
# dpkg -i linux-headers-2.6.25-tetragono_2.6.25-tetragono-10.00.Custom_i386.deb

Ed ecco il kernel installato e perfettamente funzionante:

That’s all, folks

Premetto che questo non vuole essere un tutorial esaustivo, ma solo una sorta di manabile – ma ve li ricordate i manabili? – utile soprattutto per chi vuole provare a ricompilare da sé un pacchetto Debian e non ha il tempo di approfondire la teoria.

Per prima cosa è necessario installare i pacchetti fondamentali per questo tipo di operazione:

# apt-get install devscripts build-essential

Poi vanno scaricati i sorgenti del pacchetto che vogliamo ricompilare:

# apt-get source nome_pacchetto

Attenzione! Il pacchetto verrà scaricato nella directory corrente!

Il nome del pacchetto lo si può ricavare facilmente greppando l’output di dpkg:

# dpkg -l | grep -i openoffice

Nell’esempio abbiamo effettuato una ricerca per trovare il nome corretto del pacchetto openoffice.org.

Ora dobbiamo procedere alla generazione delle dipendenze:

# apt-get build-dep nome_pacchetto

Dritta! Nella directory debian si trovano alcuni script e file di configurazione che potrebbero richiedere modifiche specifiche, magari proprio quelle per cui si è deciso di ricompilare il pacchetto. Tra questi i più importanti sono rules (opzioni di compilazione) e changelog (il nome dovrebbe essere autoesplicativo).

Per ricompilare il pacchetto:

# cd nome_pacchetto
# debuild -us -uc

Una volta terminatala compilazione, troverete i pacchetti .deb nella directory superiore, pronti per l’installazione:

# cd ..
# dpkg -i *.deb

Per maggiore chiarezza vediamo un esempio concreto:

# apt-get source mysql-server-5.0
# apt-get build-dep mysql-server-5.0
# cd mysql-dfsg-5.0-5.0.32
# debuild -us -uc
# cd ..
# dpkg -i *.deb

Have a lot of fun!

Pubblico qui una tip di poche, pochissime parole per una persona che mi ha chiesto come si possano cambiare ricorsivamente i permessi di tutto il contenuto di una directory in maniera corretta e – soprattutto – indolore. Posto che vogliamo assegnare ai file permessi 644 e alle directory 755 – come sempre andrebbe fatto – è sufficiente spostarsi nella directory in questione e lanciare i comandi che seguono:

find . -type f -print0 | xargs -0 chmod 644

find . -type d -print0 | xargs -0 chmod 755

Altro non serve…

RightLoad è un programma gratuito per Microsoft Windows che aggiunge al menù contestuale alcune funzionalità molto interessanti: cliccando con il tasto destro sull’icona di un file è possibile avviarne il trasferimento FTP ad uno dei server preimpostati mediante l’apposita interfaccia di amministrazione.

Il software offre molte possibilità di configurazione:

• Estensioni ASCII. Quando si sceglie “Auto” come modalità di trasferimento di default, tutti i file che hanno come estensione una di quelle elencate verranno trasferiti appunto in modalità “ascii”, mentre per tutti gli altri tipi di file verranno trasferiti in modalità “binary”.

• Master Password. Grazie alla master password è possibile impostare una password che verrà utilizzata per effettuare il crittaggio delle informazioni di login al server, in maniera tale che queste non possano essere “sniffate” da eventuali malintenzionati.

• Aggiornamenti automatici. Rightload verifica automaticamente la disponibilità di aggiornamenti collegandosi ai server del team che ne sta curando lo sviluppo.

• Trasferimenti SFTP e HTTP. Nella sezione “Server Type” è possibile scegliere se utilizzare una normale sessione FTP o (scelta da me vivamente consigliata) una sessione SFTP (ovvero FTP via SSH). È inoltre possibile trasferire i file anche mediante upload HTTP.

Per qualsiasi altra informazione, trovate tutto sul sito Internet ufficiale del progetto (http://www.rightload.org).

Postfix è considerato da tempo uno tra i migliori MTA in circolazione. Scritto inizialmente da Wietse Zweitze Venema e rilasciato sotto IBM Public License, Postfix può vantare una solidità ed una facilità di interazione introvabili in altri demoni di posta SMTP.

La scelta di distribuire le sue funzionalità su diversi demoni – ognuno dei quali svolge una funzione specifica – e l’attribuzione di diritti minimi di esecuzione ad ognuno di essi, garantisce che un eventuale bug o exploit non possa compromettere l’intero MTA. Un solo processo deve essere eseguito con privilegi di root, tutti gli altri hanno diritti minimi e spesso un file di configurazione proprio.

Questa distribuzione di compiti si traduce anche nella disponibilità di diversi strumenti specificamente dedicati a svolgere funzioni di monitoraggio e di amministrazione dei processi generati da Postfix. Alcuni di questi strumenti sono parte integrante di Postfix, mentre altri costituiscono elementi accessori – spesso sviluppati da terze parti – che interagiscono con esso a vari livelli.

Il monitoraggio delle code di posta, ad esempio, può avvenire mediante il programma `mailq`:

# mailq
-Queue ID- --Size-- ----Arrival Time---- -Sender/Recipient-------
6CC39230001* 1389 Wed Jun 25 01:17:51 5tanya.wuhc@msa.hinet.net
test@dominio.it

Rimando i newbie al solito `man mailq` per le informazioni principali su come funziona il programma. Quello che segue è invece un esempio di come si possa utilizzare al meglio `mailq` per rimuovere la posta bloccata dallo spool locale:

# exim -Mg `mailq | grep frozen | awk '{ print $3 }'`

Il normale utilizzo di `mailq` può essere ostacolato dalla presenza di code di posta molto voluminose. In questi casi è bene ricorrere allo script `qshape` per avere una quadro chiaro su cosa abbia determinato l’accumulo di messaggi e quando sia accaduto:

$ qshape -s deferred | head
T 5 10 20 40 80 160 320 640 1280 1280+
TOTAL 1250 0 1 2 4 5 22 34 118 242 822
spammer123.com 462 0 1 0 1 1 3 7 15 53 381
zzfinder.com 64 0 0 0 0 0 1 0 0 4 59
socket4you.biz 53 0 0 0 0 0 0 0 0 0 53
junglex.com 36 0 0 0 0 0 1 3 7 15 10
myemessage.com 36 0 0 0 0 0 0 0 0 0 36
stock911.us 35 0 0 0 0 0 0 0 0 0 35
linuxassistance.it 33 0 0 0 0 0 0 0 0 0 33
agliardi.biz 29 0 0 0 0 0 0 0 0 3 26

Qui si vede come ci siano 1250 messaggi in coda per i quali è stato fatto almeno un tentativo di spedizione (deferred), di cui 462 sono indirizzati al dominio spammer123.com. Delle email inviate a questo dominio 1 è in coda per un periodo di tempo compreso fra 5 e 10 minuti, mentre 381 sono in attesa da più di 1280 minuti.

Il comando che segue serve invece per visualizzare le statistiche legate al numero di destinatari delle mail presenti nella coda “active” di Postfix:

qshape active | less

In questo modo siamo in grado di individuare in ogni momento eventuali “colli di bottiglia”, ovvero invii di posta elettronica anomali che si accumulano nella coda di Postfix degradandone nettamente le prestazioni. Una volta individuati simili processi, li si può debellare con l’ausilio del comando `postsuper`:

postsuper [-psv] [-c directory_file_conf] [-d][-h][-H][-r] [id_coda] [directory_coda]

Per eliminare, ad esempio, il messaggio con ID di coda 6CC39230001 (ovvero quello riportato nell’esempio fatto sopra) è sufficiente lanciare il comando:

# postsuper -d 6CC39230001

Se invece, a vostro rischio e pericolo, volete svuotare completamente le code di posta, potete sempre ricorrere al seguente comando:

# postsuper -d ALL deferred

Ma se mai doveste perdere messaggi di posta elettronica a causa dell’utilizzo di questo secondo esempio, non ve la prendete con me.

Ci sono script che dovresti sempre avere a portata di mano, perché finisce che ne hai bisogno nei momenti e nelle occasioni più impensabili. Questa function in PHP, ad esempio, mi ha risparmiato in molti casi un’inutile perdita di tempo: passandole come argomento una stringa che corrisponde al percorso completo da scandire, la function scan_directory_recursively restituisce un array contenente la struttura completa della directory specificata.

È possibile indicare, come secondo argomento opzionale, una estensione o una porzione di testo che non dovrà necessariamente comparire nel nome del file. Si tratta in pratica di un filtro per escludere una certa classe di risultati.

Ad esempio:

$dirs=scan_directory_recursively('/home/ivan/Tempo');

restituisce un array di tutte le directory e i file contenuti in /home/ivan/Tempo, mentre:

$dirs=scan_directory_recursively('/home/ivan/Tempo','.php');

restituisce un array di tutte le directory e i file contenuti in /home/ivan/Tempo ad eccezione dei file con estensione .php!

Non è opera mia, per questo motivo chiedo a chiunque ne faccia uso nei propri progetti di non rimuovere i riferimenti a lixlpixel, il sito Internet da cui provengono.

Ecco la function:

< ?php
// ------------ lixlpixel recursive PHP functions -------------
// scan_directory_recursively( directory to scan, filter )
// expects path to directory and optional an extension to filter
// of course PHP has to have the permissions to read the directory
// you specify and all files and folders inside this directory
// ------------------------------------------------------------

// to use this function to get all files and directories in an array, write:
// $filestructure = scan_directory_recursively('path/to/directory');

// to use this function to scan a directory and filter the results, write:
// $fileselection = scan_directory_recursively('directory', 'extension');

function scan_directory_recursively($directory, $filter=FALSE)
{
    // if the path has a slash at the end we remove it here
    if(substr($directory,-1) == '/')
    {
        $directory = substr($directory,0,-1);
    }

    // if the path is not valid or is not a directory ...
    if(!file_exists($directory) || !is_dir($directory))
    {
        // ... we return false and exit the function
        return FALSE;

    // ... else if the path is readable
    }elseif(is_readable($directory))
    {
        // we open the directory
        $directory_list = opendir($directory);

        // and scan through the items inside
        while (FALSE !== ($file = readdir($directory_list)))
        {
            // if the filepointer is not the current directory
            // or the parent directory
            if($file != '.' && $file != '..')
            {
                // we build the new path to scan
                $path = $directory.'/'.$file;

                // if the path is readable
                if(is_readable($path))
                {
                    // we split the new path by directories
                    $subdirectories = explode('/',$path);

                    // if the new path is a directory
                    if(is_dir($path))
                    {
                        // add the directory details to the file list
                        $directory_tree[] = array(
                            'path'    => $path,
                            'name'    => end($subdirectories),
                            'kind'    => 'directory',

                            // we scan the new path by calling this function
                            'content' => scan_directory_recursively($path, $filter));

                    // if the new path is a file
                    }elseif(is_file($path))
                    {
                        // get the file extension by taking everything after the last dot
                        $extension = end(explode('.',end($subdirectories)));

                        // if there is no filter set or the filter is set and matches
                        if($filter === FALSE || $filter == $extension)
                        {
                            // add the file details to the file list
                            $directory_tree[] = array(
                                'path'      => $path,
                                'name'      => end($subdirectories),
                                'extension' => $extension,
                                'size'      => filesize($path),
                                'kind'      => 'file');
                        }
                    }
                }
            }
        }
        // close the directory
        closedir($directory_list); 

        // return file list
        return $directory_tree;

    // if the path is not readable ...
    }else{
        // ... we return false
        return FALSE;
    }
}
// ------------------------------------------------------------

?>

Per comodità vostra, ma anche mia, aggiungo qui una versione priva di commenti e pronta per il download:

• recursive_directory_scan.php.gz

Non mi stancherò mai di ripetere che con la release stabile di Debian si può fare tutto, ma proprio tutto quello che si fa normalmente con qualsiasi altra distribuzione meno conservativa. Per l’utilizzo quotidiano, per lo svolgimento delle proprie attività professionali o anche soltanto per il gioco, gran parte degli utenti Linux sembra preferire distribuzioni molto poco orientate alla sicurezza e alla stabilità solo per il fatto che queste vengono costantemente aggiornate all’ultimissima versione di ogni software.

Ho già descritto in un altro post come si possa trarre beneficio dal sistema dei backports per aggiornare i proprio programmi preferiti ad una versione più recente di quella inserita nel ramo stabile di Debian.

Debian Etch è però pronta ad accontentare anche ogni nostra naturale tentazione di veder girare le killer application di Microsoft sulla nostra Linux box. Prendiamo, ad esempio, il caso dell’odiatissimo e amatissimo browser web Internet Explorer. Per vederlo girare sulla nostra Debian Etch ci sono almeno due validissime soluzioni:

1. la suite Crossover Linux (alias: CXLinux) di CodeWeavers
2. lo script IEs4Linux di Sérgio Luís Lopes Júnior

La prima soluzione è a pagamento, ma costa davvero un’inezia rispetto a quanto offre:

CrossOver Linux allows you to install many popular Windows productivity applications, plugins and games in Linux, without needing a Microsoft Operating System license. CrossOver includes an easy to use, single click interface, which makes installing a Windows application simple and fast. Once installed, your application integrate seamlessly with your Gnome or KDE environment. Just click and run your application, exactly as you would in Windows, but with the full freedom of Linux.

CrossOver Linux lets you use many Windows plugins directly from your Linux browser. Plugins work on any x86 based Linux distribution and will integrate with most browsers including Firefox 1.x, Netscape 6.x, Konqueror, Mozilla, and Opera. CrossOver also integrates with Gnome and KDE to let you transparently open any Word, Excel or PowerPoint file. But even better, you can open these attachment types directly from any mail client.

Lo devo ammettere, nutro un affetto particolare per CXLinux, perché da molti anni gira sulle mia Linux box (un tempo si chiamava Crossover Office, alias: CXOffice) e mi dà spesso enormi soddisfazioni.

La seconda soluzione non è però affatto da sottovalutare: proprio come CXLinux, lo script IEs4Linux sfrutta `wine` per simulare le funzionalità di un sistema di casa Redmond e ci fa girare sopra un buon numero di applicazioni.

Ecco come installare IEs4Linux su Debian Etch:

1. scaricare e installare (come root) le dipendenze minime:
   # apt-get install wine cabextract binfmt-support
2. scaricare (come utente normale) l’ultima versione dello script di installazione:
   ~ wget http://www.tatanka.com.br/ies4linux/downloads/ies4linux-latest.tar.gz
3. estrarlo con il consueto comando `tar`:
   ~ tar xvfz ies4linux-latest.tar.gz
4. spostarsi nella directory così creata:
   ~ cd ies4linux-*
5. lanciare lo script:
   ~ ./ies4linux

A questo punto il gioco è fatto! Verrà mostrata una gui dove è possibile selezionare alcuni semplici parametri da passare allo script di installazione. Consiglio di selezionare solo le versioni 6.0, 5.5 e 5.0 di Internet Explorer: anche se nella opzioni avanzate viene data la possibilità di installare la versione 7.0, si tratta di una beta ancora molto instabile e sconsigliata dallo stesso Sérgio.

Raccomando a chiunque abbia tratto beneficio dalla script realizzato da Sérgio Luís Lopes Júnior di versare il giusto obolo, basta anche un solo euro con PayPal. Ecco l’indirizzo dove trovare maggiori informazioni su come contribuire al suo bel progetto:

http://www.tatanka.com.br/ies4linux/page/Contribute

PHP è un buon linguaggio di programmazione, se lo si giudica con i parametri abbastanza empirici del grado di diffusione e della mole di function che integra. Si dimostra però spesso sorprendentemente flessibile anche per affrontare scenari di programmazione molto più complessi del semplice embedding di script in una pagina web.

Durante un recente scambio di opinioni con un matematico appassionato di Open Source si è presentato il problema di creare funzioni anonime e – qui sta il punto – di farlo all’interno di una classe PHP. Tralascio lo sproloquio teorico che mi sono dovuto sorbire sul lambda calcolo e le funzioni anonime e mi limito a riportare qui un passaggio della definizione che ne dà WikiPedia. Cito testualmente:

Il lambda calcolo è un sistema di riscrittura definito formalmente dal matematico Alonzo Church. È stato sviluppato per analizzare formalmente le definizioni di funzioni, le loro applicazioni ed è uno strumento interessante per studiare anche fenomeni di ricorsione. In quanto sistema di riscrittura, esso dà una descrizione dei termini ben formati, che sono le sequenze di simboli riconosciute dal sistema e in grado di essere riscritti da esso. Il lambda calcolo, infatti, definisce un insieme di regole di riscrittura che determinano in maniera precisa come i termini stessi possano essere riscritti. In questo modo, il processo di riscrittura diventa un vero e proprio calcolo.

E ancora (disponibile solo in inglese):

Anonymous functions can be used to contain functionality that need not be named and possibly for short-term use. Some notable examples include closures and currying. [...]
Closures are functions evaluated in an environment containing bound variables. The following example binds the variable “threshold” in an anonymous function that compares the input to the threshold. [...]
Currying is transforming a function from multiple inputs to fewer inputs (in this case integer division).

Anche se ufficialmente non esiste in PHP un vero e proprio metodo per gestire le funzioni anonime, si può facilmente ottenere qualcosa di simile in almeno due modi:

1. chiamando una variabile col nome di una funzione:
   $foo = "phpinfo";
$foo();
2. inizializzando una variabile con l’istruzione `create_function`:
   $sum = create_function('$a, $b','return $a + $b;');
echo $sum(1,2);

Nel primo caso stiamo creando soltanto un link alla funzione. Nel secondo, invece, assegniamo la funzione alla variabile proprio mentre la creiamo. Provare per credere: si tratta di un aspetto insolito e per certi versi divertente del PHP, ma scoraggio chiunque ad adottare una soluzione simile in ambienti di produzione in cui non si vogliano perdere di vista praticità e facilità di lettura del codice.

Se vogliamo ricavare al volo informazioni su cosa stia facendo il nostro database MySQL senza dover per forza ricorrere a interfacce grafiche o applicazioni web, la linea di comando ci viene come sempre in aiuto. Oltre al solito `show processlist` – che però va lanciato dall’interfaccia testuale di mysql – ecco due stringe semplici ma indispensabili per il corretto monitoraggio del demone mysqld da shell:

1. ricava informazioni in sintesi sullo stato del db:
   mysqladmin -u root -p -i 5 status
2. ricava informazioni specifiche sullo stato del db:
   mysqladmin -u root -p -i 5 extended-status -r | grep Com_select
   In questo caso abbiamo estratto il numero di select in corso. Cambiando il grep si possono ricavare oltre 200 differenti informazioni!

Attenzione! In entrambi i casi verrà richiesta l’immissione della password dell’utente `root` di MySQL.

Quando si scrivono applicazioni per il web in PHP capita spessissimo di dovere trattare i dati contenuti in un file di testo. Il metodo migliore per acquisire dati di questo tipo è senz’altro la funzione `file`, che restituisce appunto un array contenente tutte le righe del file di testo.

Capita però altrettanto spesso di avere a che fare con script PHP datati o realizzati per girare in situazioni anomale, come ad esempio server embedded che mettono a disposizione un range limitato di funzioni PHP, oppure ancora di script che elaborano le righe del testo nel momento stesso in cui lo generano.

In questi casi si può ricorrere a una sintassi meno immediata ma altrettanto efficace, ricorrendo alla funzione `explode` e alla costante di sistema PHP_EOL.

Ecco un semplice esempio:

< ?php

$txtMessage = <<<EOD
RIGA #1
RIGA #2
RIGA #3
RIGA #4
EOD;

$aLines = explode(PHP_EOL, $txtMessage);

echo "<table border=\"1\">\n" .PHP_EOL;

foreach ($aLines as $strLine)
{
  echo "<tr>\n".PHP_EOL."<td>\n".$strLine."</td>\n".PHP_EOL."</tr>\n".PHP_EOL;
}

echo "\n" .PHP_EOL;

?>

Il risultato sarà il seguente:

La costante PHP_EOL equivale al carattere di end of line del sistema operativo su cui stiamo elaborando lo script: ricorrere a questa costante non migliora soltanto la leggibilità del nostro programma, ma anche la sua portabilità.