Ceci n'est pas une pipe

Se avete perso il controllo della situazione licenze Windows oppure avete ereditato un cliente che ha messo tutte le licenze OEM in un cassetto senza applicare gli appositi sticker sui rispettivi PC, questo tool gratuito e competamente open source fa al caso vostro: si chiama Magical Jelly Bean Keyfinder ed è una semplicissima applicazione che trova e mostra le product key di tutti i prodotti Microsoft e di gran parte del software di terze parti installato sul PC. Non richiede installazione ed è – come dicevo – completamente open source.

Trovate tutto a questo indirizzo: http://www.magicaljellybean.com/keyfinder/

La suite di manipolazione delle immagini bitmap ImageMagick mette a disposizione un tool da linea di comando in grado di farci risparmiare un sacco di tempo. Supponiamo infatti di volere mettere online un certo numero di fotografie per creare una photogallery o un catalogo di prodotti. Ogni immagine deve essere debitamente ridimensionata e compressa a 72dpi, un lavoro che può richiedere da qualche decina di secondi a qualche minuto per ogni singola fotografia, dipende tutto dal grado di esperienza di chi tiene in mano il mouse. Anche nella migliore delle ipotesi,  si tratta di un sacco di tempo, specie se le fotografie da lavorare sono centinaia.

Se però avete a disposizione una qualsiasi distribuzione Linux, non dovete fare altro che sfruttare appieno la potenza del comando mogrify, uno dei tool più utili messi a disposizione da ImageMagick.

È sufficiente copiare le immagini da ridimensionare in una nuova directory:

mkdir thumbs
cp -r *.jpg thumbs

Questa operazione è importante perché mogrify trasforma il file senza conservare il file ‘originale. Ora, se vogliamo ridimensionare tutte le immagini contenute nella directory thumbs in maniera tale che non superino mai le dimensioni di 500×500 pixel, lanciamo il comando:

cd thumbs
mogrify -resize 500x500 *.jpg

Et… voilà!

Sarà capitato anche a voi – di avere una musica in testa… – di dover ripristinare un certo numero di utenti Samba dopo l’upgrade di un server o la migrazione da un server ad un altro. Ho trovato un vecchio script che fa tutto il lavoro sporco caricando da un file di testo l’elenco degli utenti da ricreare con le relative password.

Il suo funzionamento è semplicissimo: si tratta in poche parole di una manciata di righe di bash che automatizzano l’interazione con il comando smbpasswd.

Lo script si compone di un primo eseguibile che ammette la sintassi seguente:

multi_smbpasswd.sh -o [add/del] -f [nome del file]

In pratica, per ricreare tutti gli utenti di Samba elencati nel file di configurazione utenti.conf:

multi_smbpasswd.sh -o add -f utenti.conf

Per eliminare tutti gli utenti di Samba elencati nel file di configurazione utenti.conf:

multi_smbpasswd.sh -o del -f utenti.conf

Ecco il codice di multi_smbpasswd.sh:

#!/bin/bash
##########################################################
## This script is here to make adding/subtracting users ##
## to the smbpasswd file easyer etc.                    ##
##########################################################
 
NO_ARGS=2
E_OPTERROR=65
 
operation=0
    # 1 = add
    # 2 = del
    # 0 = error.
fillel=0
    # 1 = good file and file location.
    # 0 = error
 
#########################################################
## Parameters:                                         ##
## -o [options] = The operation to preform. Options are##
##         as follows:                                 ##
##         add = add users to the system               ##
##         del = delete users from the system.         ##
## -f [file_location] = The file that the user names   ##
##           are stored in. must provide               ##
##           the compleate location of the             ##
##           file.                                     ##
#########################################################
 
#protect outselfs from passing nothing to the script.
if [ "$#" -eq "$NO_ARGS" ]
then  #script needs at least 3 options passed to it, otherwise error out and do nothing.
  echo "Usage: $0 -[switch] [option/file_location]"
  exit $E_OPTERROR
fi
 
while getopts o:f: Option
do
  case "$Option" in
    o)
      #check the option and fill the operation var.
      if [ "$OPTARG" == "add" ]
      then
        #we are going to add the users.
        operation=1
      elif [ "$OPTARG" == "del" ]
      then
        #we are deleting the users.
        operation=2
      else
        #error out, cause they didn't pass the right option.
        operation=0
        echo "Invaild operation option!"
        exit $E_OPTERROR
      fi
    ;;
    f)
      #check the option to see if the file exsists and that it is none zero.
      if [ -f "$OPTARG" ]
      then
        if [ -s "$OPTARG" ]
        then
          filel=1
          filelocation="$OPTARG"
        else
          filel=0
         echo "File is of zero length! You need to have a list of users in the file!"
          exit $E_OPTERROR
        fi
      else
        filel=0
       echo "File isn't there! You must provide a valid file location!"
        exit $E_OPTERROR
      fi
    ;;
    *)
      break
    ;;
  esac
 
done
shift $(($OPTIND - 1))
 
if [ $operation == 1 ]
then
  #we are adding the users.
  for i in $(cat "$filelocation")
  do
    username=$(echo "$i" | cut -d':' -f1)
    password=$(echo "$i" | cut -d':' -f2)
    #create a new unix user before smbpasswd
    useradd $username
    smb-passwd-add $username $password
  done
elif [ $operation == 2 ]
then
  #we are deleting the users out of the system.
  for i in $(cat "$filelocation")
  do
    username=$(echo "$i" | cut -d':' -f1)
    #remove the unix user before smbpasswd
    userdel $username
    smbpasswd -x $username
  done
fi
 
exit 0

Non è tutto però. Perché possa funzionare lo script richiama una procedura esterna altrettanto semplice che si occupa di immettere i valori prelevati dal file di configurazione nello standard input di smbpasswd. Ecco il codice dello script smb-passwd-add:

#!/usr/bin/expect --
# wrapper to make passwd(1) be non-interactive
# username is passed as 1st arg, passwd as 2nd
# Executable only by root
 
set password [lindex $argv 1]
spawn /usr/bin/smbpasswd -a [lindex $argv 0]
expect "password:"
send "$password\r"
expect "password:"
send "$password\r"
expect eof

Attenzione!!! Come avete notato questo secondo script si basa su expect, che va quindi installato se volete che funzioni.

Infine, ecco un esempio del file utenti.conf:

utente1:wfwiourfhowirf
utente2:eiuewhifuhwef
utente3:dkjfwskfjhwekj
utente4:woeifjwoerifffj


L’originale si trova a questo indirizzo:

http://www.programmingforums.org/thread6522.html

Ho aggiunto solo un paio di righe per una sommaria sincronizzazione tra utenti Samba e utenti unix.

Spero vi possa servire!

Ecco un vero argomento scacciafiga (*): la sintassi corretta dei link mailto, ovvero quei particolari link che richiamano il nostro client di posta elettronica preferito e lo “costringono” a generare una nuova email per un certo destinatario, con un certo oggetto e pure – volendo – un certo testo predefinito.

I link mailto hanno una sintassi di base molto, molto semplice:

<a href=”mailto:info@example.com?subject=subject&cc=cc@example.com”>mail link</a>

Gli argomenti che possono essere passati ad un link mailto sono i seguenti:

Alcuni esempi

Link mailto semplice:

<a href="mailto:info@example.com">clicca qui</a>

Link mailto con oggetto:

<a href="mailto:info@example.com?subject=Test%20di%20invio">clicca qui</a>

Link mailto con destinatari multipli:

<a href="mailto:info@example.com,email@example.com">clicca qui</a>

Link mailto con CC:

<a href="mailto:info@example.com?cc=email2@example.com">clicca qui</a>

Link mailto con proposta di corpo del messaggio su più righe e BCC:

<a href="mailto:info@example.com?bcc=mail2@example.com&body=Spettabile%20Azienda,%0Ale%20scrivo%20in%20merito%20a%20">clicca qui</a>

Per chi non ha dimestichezza con queste cose, ricordate che i parametri vanno passati inserendo un punto di domanda immediatamente dopo l’indirizzo email del destinatario e che i parametri vanno conoctenati con il simbolo &.

Happy mailing!

(*) per l’Urbe e la regione Lazio: scacciafica

Ci sono tutorial tanto semplici quanto  intramontabili, veri e propri ever green del bravo informatico che muove i primi passi nel magico mondo dell’amministrazione di sistema. Quelle che seguono sono semplici istruzioni che permettono di reimpostare data, ora e timezone su un server Linux. Li metto a disposizione di un cliente che me ne ha fatto richiesta proprio questa mattina. Onore al merito: gli originali di questi tutorial elementari ma utilissimi si trovano qui e qui.

Reimpostare la data

Per reimpostare solo la data su un server Linux è sufficiente accedere alla linea di comando come root e digitare quanto segue:

# date +%Y%m%d -s "20090217"

Reimpostare l’ora

Per reimpostare solo l’ora su un server Linux è sufficiente accedere alla linea di comando come root e digitare quanto segue:

# date +%T -s "11:12:00"

Reimpostare data e ora

Per reimpostare data e ora su un server Linux è sufficiente accedere alla linea di comando come root e digitare quanto segue:

# date -s "16 FEB 2009 11:12:00"

Reimpostare la Time Zone (soluzione A)

Se state utilizzando Fedora, RHEL o CentOS Linux digitate quanto segue:

# redhat-config-date

Oppure lanciate ‘setup’ e scegliete “Timezone configuration”:

Reimpostare la Time Zone (soluzione B)

Se utilizzate un’altra distribuzione o se – indipendentemente dalla distribuzione che utilizzate – vi sentite sufficientemente self-confident con Linux da mettere mano ai file di configurazione, procedere come segue:

1) spostatevi in /etc/

# cd /etc

2) create un link simbolico al file che contiene la timezone prescelta

# ln -sf /usr/share/zoneinfo/CET localtime

Reimpostare la Time Zone (soluzione C)

È sempre possibile utilizzare le variabili ambientali per ottenere il cambio della timezone:

$ export TZ=Europe/Rome


In questo caso, le impostazioni saranno valide per tutta la sessione ma saranno perse al primo reboot, a meno che non si aggiunga la stessa istruzione nei file di configurazione che gestitsono le variabili ambientali personalizzate, ma non è una scelta che io mi senta di consigliare, meglio a quel punto utilizzare la soluzione A o la soluzione B.

Questo è uno di quegli argomenti che – pur essendo triti e ritriti – capita spesso di dover affrontare e discutere a fondo, specialmente quando si comincia a lavorare con un nuovo team. Mi riferisco alle procedure automatiche di sincronizzazione scp tra i file e/o le directory di due server UNIX/Linux.

La logica è semplice e l’implementazione richiede meno di un minuto. Ma… ma ci sono tanti aspetti secondari che consigliano l’adozione di questo tipo di approccio solo in particolari casi. Uno fra tutti è la voragine di sicurezza che comporta la completa apertura a chiunque fornisca la chiave privata. Insomma, è tardi e rischio di spiegarmi male, vediamo il caso concreto e le poche istruzioni richieste per realizzare il tutto.

Supponiamo di avere due server (A.test.com e B.test.com) e di voler mantenere una copia esatta della directory /root/test effettuando un `scp` ogni notte da A.test.com a B.test.com.

1. Generare la coppia di chiavi privata/pubblica sul server locale  A.test.com:

ssh-keygen -t rsa

Quando viene richiesta la password, non inserire nulla: in questo modo la sessione di `scp` potrà avvenire senza alcuna richiesta di autenticazione. Se la chiave privata finisce nelle mani sbagliate, però, il server è definitivamente compromesso. Per questo una soluzione di questo tipo va bene solo in una intranet, tra un server main ed uno di backup, ad esempio. E in ogni caso è una soluzione da adottare solo per server a cui accede il minor numero di utenti possibile.

2. Copiare la chiave pubblica sul server remoto B.test.com

scp ~/.ssh/id_rsa.pub root@B.test.com:~

3. Aggiungere la chiave copiata alle trusted keydel server remoto B.test.com
Accedere al server remoto e appendere la chiave come segue:

cat ~/id_rsa.pub >> ~/.ssh/authorized_keys

Nel caso in cui la directory ~/.ssh/authorized_keys non esistesse, significa che non è mai stata generata alcuna coppia di chiavi per il server remoto. Lanciare il comando “ssh-keygen -t rsa”. Per sicurezza, è bene assicurarsi che solo l’utente proprietario della chiave vi possa accedere:

chmod 600 ~/.ssh/authorized_keys

4. Test di accesso senza password da A.test.com a B.test.com

ssh root@B.test.com

L’accesso avviene ora senza la richiesta di alcuna password.

5. Mettere in cron l’istruzione scp

scp -r /root/test/* root@B.test.com:/root/test/

Non serve altro…

Rispondo qui ad una richiesta di aiuto che ho ricevuto la scorsa settimana e a cui non ho sino ad ora avuto il tempo di rispondere. Mi viene richiesto un consiglio su uno script in bash che processa una serie di directory e ne crea temporaneamente altre in /tmp. Senza scendere nei dettagli del caso specifico, per generare automaticamente liste o array di directory ci viene in aiuto la brace expansion. Si tratta di un particolare meccanismo di bash con cui è possibile generare elenchi arbitrari di nomi di file o directory. In questo senso è simile alla pathname expansion, anche se quest’ultima è vincolata all’esistenza del file e/o della directory in questione, mentre con brace expansion questo limite non è previsto.

La sintassi delle brace expansion è molto semplice e prevede che vengano elencate tra parentesi graffe stringa che verranno sostituite nella medesima posizione all’interno stringa principale, generando così le varianti che ci servono. Come sempre, un esempio pratico vale più di mille spiegazioni:

a{b,c,d}e

si espande in:

• abe
• ace
• ade

La brace expansion ha priorità su tutte le altre expansion e deve contenete parentesi graffe di apertura e chiusura e almeno un separatore (virgola).

Ecco dunque la riga di codice mancante allo script di cui sopra:

/bin/mkdir /tmp/{dir_main,dir_all,dir_tmp_1,dir_tmp_2,dir_tmp_3}

Mi è capitato spesso di dover mettere mano a server UNIX/Linux con una gestione dei VirtualHost di Apache compromessa da anni di utilizzo incontrollato del server da parte di amministratori di sistema non proprio ordinati. Il risultato di solito è un grande numero di utenti con home directory strutturate in maniera differente l’una dall’altra.

In particolare, in un caso recente mi sono ritrovato un centinaio di utenti dei quali una certa parte aveva la DocumentRoot nella propria home directory, altri invece ce l’avevano sotto /var/www/users/, cosa che io raccomando in quanto evita di avere problemi con SUEXEC nelle versioni di Apache precompilate.

Per sistemare una situazione così caotica ho deciso di mettere tutto correttamente sotto /var/www/users/ e mi si è presentata la necessità di creare automaticamente le directory mancanti e i relativi link simbolici alle varie home directory. L’ho fatto con un semplicissimo script in bash, che pubblico qui nel caso possa essere utile anche a qualcun altro. Ci ho messo anche un po’ di output per rendere il codice chiaro anche a chi è alle prima armi con la bash.

Attenzione! Alla riga 18 viene fatta la copia di un fast-cgi presente nella directory /var/www/users/ivan/. Ovvio che dovete sostituire ivan con il nome di un utente presente sul vostro server.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#!/bin/bash
 
echo "Inizializzazione script..."
 
for i in $( ls /home/ ); do
  echo "  Sto processando '$i'"
  if [ -L /home/$i/public_html ]; then
    echo "    Il link simbolico /home/$i/public_html esiste gia' ... salto!"
  else
    echo "    Il link simbolico /home/$i/public_html non esiste: provo a crearlo ... "
    if [ -d /var/www/users/$i ]; then
      echo "La directory /var/www/users/$i esiste, non mi resta che linkarla ... "
      /bin/ln -s /var/www/users/$i /home/$i/public_html
    else
      echo "    La directory /var/www/users/$i NON esiste, ora la creo ... "
      /bin/mkdir /var/www/users/$i
      echo "    Copio il FAST-CGI ... "
      /bin/cp /var/www/users/ivan/fast-cgi /var/www/users/$i/
      echo "    Sistemo i permessi per la directory creata ... "
      /bin/chown -R $i:$i /var/www/users/$i
      /bin/chmod 700 /var/www/users/$i
      echo "    Creo il link simbolico ... "
      /bin/ln -s /var/www/users/$i /home/$i/public_html
    fi
  fi
done

Fino a qualche anno fa, installando Windows XP era pratica diffusa scegliere  di formattare la partizione principale con il filesystem di tipo FAT32. Questo principalmente per motivi di accessibilità dei dati anche da sistemi operativi obsoleti (Windows 98) o “alternativi” (per Linux l’accesso in lettura e scrittura alle partizioni NTFS è stato introdotto con un certo ritardo, per ovvie ragioni).

Capita ancora oggi di trovare vecchie workstation con filesystem FAT32. Decaduta ogni ragionevole motivazione per conservare questo tipo di scelta, in questi casi io consiglio di effettuare la conversione da FAT32 a NTFS, dal momento che si tratta di un’operazione sicura, collaudata e che porta benefici indubbi sul piano operativo, primo fra tutti la possibilità di gestire volumi di dimensioni superiori ai 32GB (limite massimo per FAT32).

L’operazione di conversione è estremamente semplice. È sufficiente aprire una finestra di DOS e impartire il seguente comando:

Convert X: /FS:NTFS /V /NoSecurity

• X: corrisponde all’unità per cui vogliamo effettuare la conversione (ad esempio: C:)
• /V indica di visualizzare i dettagli di ogni operazione (verbose mode)
• /NoSecurity permette di non limitare l’accesso ai file convertiti in NTFS

Verrà richiesto il nome del volume per cui effettuare la conversione. Se il volume non ha nome, date invio senza inserire nulla. Il resto avviene in maniera pressoché automatica. Ecco un esempio dei semplici step attraverso cui passare:

Conversione Partizione Win XP (C)
Il file system è di tipo FAT32.
Inserire l'etichetta di volume corrente per l'unità C:: Win XP
Impossibile eseguire la conversione. Il volume è utilizzato
da un altro processo. Smontare il volume per eseguire
la conversione. TUTTI GLI HANDLE APERTI NEL VOLUME
CESSERANNO IN QUESTO MODO DI ESSERE VALIDI.
Forzare lo smontaggio su questo volume? (Sì/No)

Rispondere Sì (S) a quest’ultima domanda. Il sistema vi avviserà del fatto che è smontare il volume perché in uso e chiederà se si vuole programmare l’operazione al successivo riavvio. Anche in questo caso, rispondere affermativamente e riavviare la macchina.

Come dicevo, l’operazione è estremamente sicura e collaudata, ma – come si dice oltre oceano – “shit happens”, quindi consiglio di effettuare un backup preliminare nel caso in cui, ad esempio, vi tagliassero la luce proprio mentre state effettuando la conversione del filesystem.

In questo post descrivo con la massima sinteticità e senza alcuna pretesa di completezza come si possa realizzare un RAID 1 (software) durante l’installazione di Debian Etch e come si configuri correttamente il LVM.

Su una delle mie workstation ho due hard disk identici da 320GB. Ho deciso di installarci l’ennesima Debian Etch e di mettere i due dischi in RAID. Ho avviato l’installazione e in un paio di minuti sono arrivato allo step in cui vanno effettuati i settaggi per il partizionamento dei dischi. Trattandosi di dischi S-ATA, il debian-installer me li ha riconosciuti come segue:

• SCSI1 (0,0,0) (sda)
• SCSI2 (0,0,0) (sdb)

Lo stesso discorso vale comunque anche per dischi IDE, in quel caso il debian-installer li vederebbe così:

• IDE1 (hda)
• IDE2 (hdc)

A questo punto ho creato una prima partizione di booting, di dimensioni minime (solo 512MB):

1. selezionare il primo disco SCSI1
2. scegliere come metodo di partizionamento “Manuale”
3. selezionare la voce “SPAZIO LIBERO” sotto SCSI1
4. scegliere “Crea una nuova partizione”
5. selezionare “Inizio” come posizione della nuova partizione
6. selezionare “Primaria” come tipo della nuova partizione
7. inserire 512M come dimensione della nuova partizione
8. scegliere “Volume fisico per il RAID” come modo d’uso della nuova partizione
9. scegliere “Preparazione di questa partizione completata”

Poi ho creato la partizione destinata a contenere il filesystem vero e proprio:

1. selezionare il primo disco SCSI1
2. scegliere come metodo di partizionamento “Manuale”
3. selezionare la voce “SPAZIO LIBERO” sotto SCSI1
4. scegliere “Crea una nuova partizione”
5. selezionare “Inizio” come posizione della nuova partizione
6. selezionare “Primaria” come tipo della nuova partizione
7. inserire 95% come dimensione della nuova partizione
8. scegliere “Volume fisico per il RAID” come modo d’uso della nuova partizione
9. scegliere “Preparazione di questa partizione completata”

Perché al punto 7 ho scelto di utilizzare solo il 95% del disco? Semplicemente perché, nel caso io debba sostituire uno dei due dischi, non avrò mai la certezza assoluta che il nuovo disco abbia esattamente lo stesso numero di cilindri etc. rispetto al disco originale, nemmeno se lo compero della stessa marca e dello stesso taglio. Ho bisogno quindi di un gap di tolleranza per mettermi al sicuro da possibili perdite di dati o inconsistenze durante la ricostruzione dei volumi. Certo, si spreca dello spazio che non verrà mai utilizzato, ma con dischi di queste dimensioni ce lo possiamo pure permettere.

Ora è necessario ripetere le operazioni appena descritte anche per il secondo disco (SCSI2) assicurandoci di avere effettuato esattamente le stesse scelte fatte per il primo.

Fatto questo, possiamo configurare il RAID 1 software. Per prima cosa creiamo il device multidisk destinato a contenere la partizione di boot:

1. scegliere “Configurare il RAID software”
2. confermare “Scrivere i cambiamenti sui dispositivi…”
3. scegliere “Creare un device multidisk (MD)”
4. selezionare “RAID1″ come tipo di device multidisk
5. confermare “2″ come numero di device attivi per l’array RAID1
6. confermare “0″ come numero di device “spare”
7. abilitare solo /dev/sda1 e /dev/sdb1 come device attivi
8. scegliere “Terminare”

Poi creiamo il device multidisk destinato a contenere il filesystem vero e proprio:

1. scegliere “Configurare il RAID software”
2. confermare “Scrivere i cambiamenti sui dispositivi…”
3. scegliere “Creare un device multidisk (MD)”
4. selezionare “RAID1″ come tipo di device multidisk
5. confermare “2″ come numero di device attivi per l’array RAID1
6. confermare “0″ come numero di device “spare”
7. abilitare solo /dev/sda2 e /dev/sdb2 come device attivi
8. scegliere “Terminare”

Ora possiamo passare alla creazione dei volumi logici. Per prima cosa creo il volume destinato a fare da swap del sistema:

1. scegliere “Configurare il Logical Volume Manager”
2. confermare “Scrivere le modifiche sui dischi e …”
3. scegliere “Creare i gruppi di volumi”
4. scrivere “VG00″ come nome del gruppo di volumi
5. abilitare solo /dev/md/1 come device per il nuovo gruppo di volumi
6. scegliere “Creare un volume logico”
7. selezionare il gruppo di volumi “VG00″
8. scrivere “swap” come nome del volume logico
9. scrivere “4GB” come dimensione del volume logico (almeno il doppio della RAM)

Poi creo il volume destinato al filesystem vero e proprio:

1. scegliere “Creare un volume logico”
2. selezionare il gruppo di volumi “VG00″
3. scrivere “filesys” come nome del volume logico
4. confermare il valore massimo disponibile proposto come dimensione del volume logico
5. scegliere “Terminare”

A questo punto posso creare le partizioni:

1. selezionare il n° 1 sotto “LVM VG VG00 LV filesys”
2. creare la partizione normalmente (scegliendo “Ext3″ come modo d’uso e “/” come mount point)
3. scegliere “Terminare”
4. selezionare il n° 1 sotto “LVM VG VG00 LV swap”
5. creare la partizione di swap normalmente (scegliendo “swap area” come modo d’uso)
6. confermare “Scrivere le modifiche sui dischi e …”

Fatto questo, è sufficiente procedere con l’installazione di Debian come di consueto.