Upgrade Da Ubuntu Feisty a Gutsy

Ubuntu Gutsy è la prossima release della ormai famosa Ubuntu. Per chi, come me, non ha la pazienza di aspettare la fine di Ottobre per vedere l’uscita definitiva ecco una guida che mi permetterà di aggiornare la vostra distro preferita.

NOTA: Tanto per stare tranquilli fate un backup dei vostri file più importanti contenuti nella vostra home.

Pronti?

Cominciamo: Premiamo ALT-F2 ed inseriamo il comando “ gksu “update-manager -c -d” “

Nel prossimo passo dobbiamo cliccare su “Esegui avanzamento“

Spunterà adesso una finestra in cui verranno mostrati i pacchetti che andremo ad aggiornare

Aspettate pazientemente che l’aggiornamento abbia fine, rispondete alle eventuali domande che vi saranno poste,  e una volta riavviato il tutto godetevi le meraviglie del vostro nuovo pinguino

Script per backup remoto

Quando si ha la necessità di passare diversi files da un pc ad un altro con una certa frequenza (magari tra due pc di casa o da casa all’ufficio), può essere utile avere uno script che faccia tutto questo in modo rapido e senza dovere inserire ogni volta la password del computer remoto. Questo script accetta uno o più files o cartelle come parametro ma non accetta nomi che contengono spazi bianchi. Bisogna soltanto modificare le variabili definite all’inizio e installare il pacchetto expect sull’host locale.

 

$ sudo apt-get install expect

 

Inoltre bisogna anche avere il pacchetto openssh-server installato sull’host remoto dato che questo script fa uso di scp e, ovviamente, un utente valido.

Ecco il codice:

 

#!/bin/bash

 

############################################################

remote_user=”corrob” # utente sull’host remoto

remote_host=”192.168.0.4″ # host remoto

remote_path=”~/Desktop” # percorso sull’host remoto

pwd=”tua_password” # password dell’utente sull’host remoto

############################################################

 

if [ $# -lt 1 ]

then

    echo “Usage: $0 richiede almeno un file come argomento”

    exit

fi

for i in $*

do

    if [ -d $i ]

    then

        par=-r

    elif [ -f $i ]

    then

        par=”"

    else

        echo “$i: No such file or directory”

        continue

    fi

expect -c “spawn /usr/bin/scp $par $i $remote_user@$remote_host:$remote_path” -c ‘expect *password*’ -c “send — $pwd\r” -c ‘expect “*100%*\r”‘ -c expect -c ‘wait’ 2> /dev/null

done

 

Una volta copiato il contenuto incollatelo in un file in /usr/src e date a tutti i permessi di lettura ed esecuzione.

$ sudo chmod 555 /usr/bin/nomescript

 

Io l’ho chiamato mybackup. Adesso configurate le 4 variabili all’inizio dello script in modo da contattare il vostro host remoto per il backup.

Infine utilizzate lo script in questo modo:

 

$ mybackup file1 file2 file3

Nota: è necessario avere effettuato l’accesso in ssh all’host remoto almeno una volta altrimenti vi verrà chiesto di autenticare l’host e lo script non funzionerà. Assicuratevi perciò di avere la chiave nel file ~/.ssh/know_hosts.

Semplice generatore di password in php

Avete bisogno di una funzioncina veloce che generi delle password casuali? Bene eccola servita :

<?php
function genPass($length = 8) //max length = 32 characters
{
return substr(md5(uniqid(rand(), true)), 0, $length);
}
?>

Ecco dei semplici casi di utilizzo :

<?php
echo genPass(); //default length = 8 characters

echo "<br><br>";

echo genPass(12); //length = 12 characters
?>

Creare un proprio certificato per SSL

SSL (Secure Socket Layer) è un protocollo di comunicazione cifrato e utilizza una tecnica di cifratura chiamata crittografia a chiave pubblica. Oltre a cifrare una connessione, la crittografia a chiava pubblica consente a un client di autenticare il server. Questo grazie ad un certificato firmato da terze parti (solitamente è un’organizzazione indipendente) che verifica se il proprietario del server è effettivamente chi dice di essere. Se non possedete un certificato firmato da terze parti, i clients che contatteranno il vostro server riceveranno un avviso che li informerà riguardo il vostro certificato non visionato da un’autorità riconosciuta. Per evitare questo inconveniente dovrete pagare e far firmare la vostra CSR (Certificate Signing Request) da una CA (Certification Authority). Le due più importanti sono Verisign e Thawte.

Questa procedura consente di creare facilmente un proprio certificato non firmato da terze parti:

 

Per prima cosa installiamo le librerie necessarie

$ sudo apt-get update && sudo apt-get install openssl

 

Adesso passiamo a root

$ su

 

Installiamo una chiave privata supponendo di trovarci nella cartella confSSL sotto la root del webserver e dando per scontato che il modulo SSL sia già incluso in Apache (se usate Apache2.0 è già incluso di default e dovete solo caricarlo)

# openssl genrsa 1024 > miachiave.key

 

Adesso convalidiamo la chiave creata sopra generando una CSR

# openssl req -new -key miachiave.key -out convalida.csr

 

Infine creiamo il certificato vero e proprio firmando la CSR con la chiave privata

# openssl req -x509 -key miachiave.key -in convalida.csr – out certificato.crts

 

E’ molto importante che i file appena creati possano essere letti soltanto dall’utente root.

Una volta generato il certificato possiamo utilizzarlo per i nostri hosts virtuali che utilizzano https (secure http) inserendo le seguenti direttive in ogni VirtualHost che ascolta sulla porta 443 (la porta di default):

SSLCertificateKeyFile confSSL/miachiave.key

SSLCertificateFile confSSL/certificato.crts

Se impostate all’esterno dei container VirtualHost, queste direttive consentono di utilizzare il nostro certificato per tutti gli hosts virtuali che utilizzano SSL. Essi devono però specificare questa direttiva all’interno del proprio ambito:

SSLEngine On

Non è possibile specificare questa direttiva nella configurazione generale del server. Per imporre l’utilizzo di SSL in una directory utilizzate questa direttiva all’interno dei container <Directory>

SSLRequireSSL

Change Desktop Manager

Chi usa Compiz fusion avrà notato che, a differenza di Beryl, non c’è la possibilità di passare a metacity con un clic, bensì bisogna aprire un terminale e lanciare il comando “metacity –replace &”.Questo semplice script in bash controlla quale desktop manager è in esecuzione (tra compiz e metacity) sostituendolo con quello non in esecuzione.

#!/bin/bash

gestore=`ps -e | grep metacity | awk {‘print $4′}`
if [ $gestore == "metacity" ]
then
compiz –replace -v &

else
metacity –replace &
fi

 

Se usate un altro decoratore di finestre come emerald, basterà cambiare la riga

compiz –replace -v &

in

compiz –replace -v -c emerald &

Al posto di emerald potete mettere qualsiasi altro decoratore di finestre.

 

Una volta copiato lo script incollatelo in un file che metterete in /usr/bin. Rendetelo eseguibile con chmod 555 /usr/bin/nomedelloscript

e create un link simbolico sul desktop con ln -s /usr/bin/nomedelloscript ~/Desktop.

Adesso con un semplice doppio clic passerete da compiz a metacity e viceversa senza preoccuparvi di quale dei due sia in esecuzione.

“Open command here” su Ubuntu

“Open command here” è un piccolo tool messo a disposizione da microsoft che aggiunge la voce “Open Command Window Here” (Apri la finestra dei comandi qui) al menù contestuale per le cartelle di window. Senza l’utilizzo di questa utility, bisognava aprire il prompt dei comandi
e poi raggiungere tramite i comandi DOS (cd, cd.., cd nome-cartella) la cartella da noi desiderata. Invece grazie a questa piccola utility basterà cliccare con il tasto destro sulla cartella che vorremo raggiungere via shell, e cliccare su “Open Command Here” per aprire il prompt dei comandi già “puntante” a questa cartella.

Per avere in Ubuntu un tool del genere si deve creare uno script bash è metterlo all’interno della cartella :

/home/<nome-utente>/.gnome2/nautilus-scripts

Ecco il codice da inserire :

#!/bin/sh
for d in $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS; do
if [ -d $d ]; then
cd $d
gnome-terminal
exit
fi
done
gnome-terminal

Date un nome allo script, ad esempio “Open shell here.sh” e salvate il tutto (riavviate l’interfaccia). Quando ora cliccate con il tasto destro su una cartella vi apparirà una nuova voce “script->nome_script” che avrà l’effetto di aprire una shell con il percorso già settato per quella cartella.

Eclipse & PHP Developers

La nota società Eclipse ha finalmente reso disponibile la versione 1.0 del “Eclipse PHP Development Tools (PDT) project “. Eclipse PDT è un set di strumenti e framework che “migliorano” la vita a chi sviluppa in PhP.

Dal sito ufficiale..

Project Principles:

• Intuitive and easy to learn
• Seamless integration with the Web Tools project
• Adherence to Eclipse standards
• Extensibility
• Continuous support of PHP developments

Io personalmente continuo ad usare Zend Studio…e voi che editor usate?!

Compilare il kernel su ubuntu feisty

Esistono diversi modi per ricompilare un kernel. La procedura descritta di seguito illustra come ricompilare un kernel su ubuntu feisty 7.04 in pochi passi. Verrà usato il kernel 2.6.22 ma è possibile usare qualsiasi altra versione del kernel con eventuale patch. Inoltre consiglio di non eseguire nessuna operazione da utente root; per questo motivo aggiungeremo l’utente che vogliamo usare al gruppo src.

Per prima cosa aggiornate la lista dei pacchetti e installate i pacchetti necessari alla compilazione.

$ sudo apt-get update

$ sudo apt-get install build-essential kernel-package libncurses5-dev fakeroot wget bzip2

Al posto di tuonomeutente aggiungete l’utente che volete usare per la compilazione. Quest’ultimo sarà aggiunto al gruppo src.

$ sudo adduser tuonomeutente src

Effettuate un logout e rieffettuate il login. Fino ad allora non farete effettivamente parte del gruppo src. Dopodicchè controllate con il comando groups se fate parte del gruppo.

Spostatevi nella directory /usr/src e scaricate l’archivio del nuovo kernel; in questo caso useremo il 2.6.22.

$ cd /usr/src

$ wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.22.tar.bz2

Scompattate l’archivio del kernel e create un link simbolico alla nuova cartella.

$ tar xjf linux-2.6.22.tar.bz2

$ ln -s linux-2.6.22 linux

Spostatevi nella directory dei sorgenti e fate una copia della configurazione del kernel. Quest’ultima tornerà utile se non vogliamo rischiare di commettere errori ed avere kernel panic al riavvio.

$ cd /usr/src/linux; cp /boot/config-`uname -r` .config

Configurate il kernel con il tool menuconfig. Questo è il passo più delicato. Intanto caricate il file di configurazione salvato in precedenza selezionando la voce “Load an Alternate Configuration File” e scegliendo “.config”. Se è la prima volta che ricompilate il kernel, sarebbe meglio esaminare con attenzione tutti i moduli con i relativi help, includendo soltanto i moduli strettamente necessari per il vostro hardware; otterrete così un kernel più snello e di conseguenza più performante.

$ make menuconfig

Dopo avere scelto i moduli da includere salvate la configurazione e uscite da menuconfig. Prima di procedere con la compilazione pulite i sorgenti con il comando seguente.

$ make-kpkg clean

Adesso iniziamo la compilazione. Questo processo potrebbe impiegare molto tempo, a seconda del vostro hardware e del numero di moduli inclusi in fase di configurazione. Il comando fakeroot serve a simulare un ambiente root.

$ fakeroot make-kpkg –initrd –append-to-version=-custom kernel_image kernel_headers

Da sottolineare che dopo “–append-to-version=” è possibile scrivere qualsiasi stringa che aiuti ad identificare il nuovo kernel ma deve iniziare sempre con un meno (-) e non deve contenere spazi bianchi.

Esempio: –append-to-version=-mio_kernel

Tornate alla directory /usr/src e controllate se sono stati generati i due pacchetti .deb.

$ cd /usr/src; ls -l

Passate a root, installate i pacchetti generati dalla compilazione e riavviate il sistema

$ su

# dpkg -i linux-image-2.6.22-custom_2.6.22-custom-10.00.Custom_i386.deb

# dpkg -i linux-headers-2.6.22-custom_2.6.22-custom-10.00.Custom_i386.deb

# reboot

Il vostro kernel verrà visto automaticamente da grub. In caso contrario vi bastarà dare il seguente comando

$ sudo update-grub

Al riavvio verificate la versione del kernel

$ uname -r

Se tutto è andato a buon fine dovreste avere un output simile a questo: 2.6.22-mio_kernel

Ho scritto questa miniguida perchè in rete c’è tanta di quella documentazione da far confondere le idee, soprattutto per chi usa il pinguino da poco. Spero di essere stato di aiuto a qualcuno. Ciao e alla prossima.

 

 

Costruisci abstract

Chi gestisce un sito dinamico, spesso ha l’esigenza di visualizzare in una pagina un elenco di news con il classico link o bottone “…continua” che rimanda al testo completo della news.

Di solito la piccola porzione di testo visualizzata viene troncata ad un numero predefinito di caratteri per uniformare il testo di tutte le news, e molto spesso la conseguenza di quest’azione è che l’ultima parola viene troncata.

Esempio

Una news limitata a 70 caratteri tronca l’ultima parola

Lore ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonu (…continua)

 

Questa piccola funzione scritta in php accetta come argomenti il testo che vogliamo utilizzare e il numero massimo di caratteri da visualizzare.

Se contando le parole del testo questo dovesse eccedere il numero di caratteri massimo impostati, la funzione visualizza l’ultima parola per intero, rendendo molto più gradevole la visualizzazione di tutte le news.

Esempio

Una news che fa uso della funzione

 

Lore ipsum dolor sit amet, consectetuer adipiscing elit, sed diam (…continua)

 

function costruisciabstract($testo,$numerocaratteri)
{
    if (strlen($testo)<=$numerocaratteri)
    {
        return nl2br($testo);
    }
    $conta=$numerocaratteri;
    while ($conta>=0)
    {
        if (substr($testo,$conta-1,1)==" ")
        {
            $testo1=substr($testo,0,$conta-1);
            return nl2br($testo1);
            $conta=-1;
        }
        else
        {
            $conta--;
        }
    }
    return nl2br($testo1);
}

Spero di essere stato chiaro nella spiegazione. In caso di dubbi o suggerimenti non esitare a contattarmi.