Archivi tag: bash

Visualizzare data ed ora di un comando nel file history

Qualche tempo fa, mentre lavoravo per il progetto PIT di Selex Communications, è sorta la necessità di appurare quale degli n-NOC avesse lanciato un reboot su uno dei router di una sala operativa. Poichè l’history non riportava alcuna informazione sulla data e sull’ora di esecuzione del comando, non è stato possibile individuare con certezza il responsabile, quindi la questione si è risolta con un nulla di fatto.

Alla luce di ciò, ho deciso di scrivere questa breve guida in cui viene descritta la procedura per aggiungere il datetime al file history nell’ambito dei sistemi basati su Debian.

bash

Per prima cosa è necessario editare il file nascosto .bashrc presente nella home dell’utente:

nightfly@nightbox:~$ sudo nano .bashrc

e successivamente aggiungere la seguente direttiva:

HISTTIMEFORMAT="%d/%m/%y %T "

In particolare, ogni comando presente nel file history verrà proceduto da giorno (%d), mese (%m), anno (%y) ed ora (%T) (nel formato hh:mm:ss) di esecuzione dello stesso.

Subito dopo esserci riloggati alla macchina digitiamo il comando:

nightfly@nightbox:~$ history

il cui output sarà simile al seguente:

 1995  12/06/11 11:49:57 history
 1996  12/06/11 11:49:57 exit
 1997  12/06/11 11:26:49 history
 1998  12/06/11 11:50:17 sudo nano .bashrc
 1999  12/06/11 11:53:13 history

Ovviamente tale operazione non è retroattiva, nel senso che tutti i comandi precedenti alla modifica del file .bashrc avranno come datetime quello della modifica stessa.

A presto.

Script bash per l’aggiornamento delle blacklist utilizzate da squidGuard

L’accoppiata squid + squidGuard rappresenta un’ottima soluzione per l’implementazione di un sistema dedicato al content filtering. Infatti, basta scaricare le blacklist aggiornate di squidGuard per avere un un filtraggio dei contenuti Web efficace ed efficiente.

 

squidguard

 

A tal proposito, ho pensato di realizzare uno scrip bash per l’aggiornamento automatico di tali blacklist. Ecco il codice:

#!/bin/bash

logfile=/var/log/squidguardupdate.log

ROOT_UID=0

if [ "$UID" -ne "$ROOT_UID" ];then

        ERRORE1="Errore 1: Devi essere root per eseguire lo scrip"
        echo $ERRORE1
        echo "$(date) $ERRORE1" >> $logfile

        exit 1

fi

wget http://squidguard.mesd.k12.or.us/blacklists.tgz

tar -xvf blacklists.tgz

cd blacklists/

cp -R * /var/lib/squidguard/db

squidGuard -d -C all

chown proxy:proxy -R /var/lib/squidguard/db

squid -k reconfigure

cd ..

rm blacklists.tgz

exit 0

Tale scrip non fa altro che scaricare le blacklist mediante wget, compilarle ed aggiornare la configurazione di squid.

Per ulteriori chierimenti contattatemi.

A presto.

Script bash per verificare la raggiungibilità dei Domain Controller

Supponiamo che nella vostra rete venga utilizzato Squid come proxy, sul quale è stata abilitata l’autenticazione NTLM. In questo modo, mediante Active Direcetory ed ai Domain Controller di casa Microsoft, sarà possibile fare in modo che, in base ai gruppi di appartenenza, i vari utenti della LAN possano visualizzare soltanto alcune tipologie di siti.

Però, occorre precisare che Squid, di per sè, non è in grado di gestire alcun tipo di content filtering, ma per fare ciò è necessario utilizzare alcuni add-on, quali DansGuardian o squidGuard.

Saranno proprio questi ultimi, mediante delle query ldap dirette al Domain Controller, a suddividere l’utenza in base ai siti che può visitare.

Nel caso in cui il primo Domain Controller di riferimento non sia più raggiungibile, si potrebbe operare direttamente sul file hosts, posizionato nella directory /etc, in modo da modificare il contenuto della entry relativa all’hostname del DC (ad esempio ldap.vostrodominio.org), associandolo all’indirizzo IP dell’altro Domain Controller.


bash.jpg

 

 

Il seguente scrip serve proprio a mettere in pratica quanto appena detto:

#!/bin/bash

DC1=192.168.1.1

DC2=192.168.1.2

destinatario=<vostroindirizzo>@<vistrodominio.org>

logfile=/var/log/ping.log

count_1=0

count_2=0

tmp=/var/log/tmp.log

var=`cat $tmp`

while [ $count_1 -lt 2 ]

do

echo "Pinging DC1..."

if ping -c 1 $DC1

then

if grep -q "$DC2" "/etc/hosts"

then

/bin/sed -i 's/192.168.1.2/192.168.1.1/g' /etc/hosts

echo "0" > $tmp

exit 0

else

exit 0

fi

else

let count_1=count_1+1

if [ $count_1 -eq 1 ]

then

echo "$(date) Primary Domain Controller Unreachable, trying again..." >> $logfile

else

echo "$(date) Primary Domain Controller Unreachable, trying to switch over DC2..." >> $logfile

if [ "$var" = "0" ]

then

echo "$(date) Primary Domain Controller Unreachable, trying to switch over DC2." | mail -iv -s "Alert: DC1 unreachable" $destinatario;

echo "1" > $tmp

fi

fi

fi
done

if [ $count_1 -eq 2 ]

then

while [ $count_2 -lt 2 ]

do

echo "Pinging DC2..."

if ping -c 1 $DC2

then

/bin/sed -i 's/192.168.1.1/192.168.1.2/g' /etc/hosts

exit 0

else

let count_2=count_2+1

if [ $count_2 -eq 1 ]

then

echo "$(date) Secondary Domain Controller Unreachable, trying again..." >> $logfile

else

echo "$(date) Unable To Contact Any Domain Controller" >> $logfile

if [ "$var" = "1" ]

then

echo "$(date) Unable To Contact Any Domain Controller." | mail -iv -s "Alert: DC1 and DC2 unreachable" $destinatario;

echo "2" > $tmp

fi

fi

fi

done

fi

exit 0

Rendiamo eseguibile lo scrip appena creato:

nightfly@nightbox:~$ sudo chmod +x ping.sh

Creiamo infine una entry per crontab, schedulando l’esecuzione di tale scrip ogni minuto:

* * * * *   root     ping.sh > /dev/null 2>&1

Ovviamente, nel caso in cui abbiate bisogno di alcuni chiarimenti sul codice, non esitate a contattarmi.

A presto.

Partizionare e formattare un disco da bash

Recentemente ho stotituito l’HD di share sulla mia linux box con uno più capiente. A tal proposito ho dovuto dapprima partizionare e successivamente formattare il nuovo hard disk. Vediamo come.

Per prima cosa ho individuato il nome periferica assegnato dal sistema operativo al disco rigido, semplicemente lanciando un ls nella directory /dev (il nuovo hard disk è stato riconosciuto come sdb).

Ora, conoscendo il nome della periferica, posso procedere con la partizione della stessa utilizzando il tool fdisk, il cui usage è il seguente:

nightfly@nightbox:/dev$ fdisk

Usage:
fdisk [options] <disk>    change partition table
fdisk [options] -l <disk> list partition table(s)
fdisk -s <partition>      give partition size(s) in blocks

Options:
-b <size>                      sector size (512, 1024, 2048 or 4096)
-c                                    switch off DOS-compatible mode
-h                                    print help
-u <size>                      give sizes in sectors instead of cylinders
-v                                    print version
-C <number>               specify the number of cylinders
-H <number>               specify the number of heads
-S <number>               specify the number of sectors per track

Digitiamo dunque:

nightfly@nightbox:/dev$ sudo fdisk /dev/sdb

Visualizziamo il menù di fdisk digitando m ed in seguito digitiamo w che sta per write table to disk and exit

A partizionamento avvenuto possiamo procedere con la formattazione del disco rigido, utilizzando il tool mkfs:

 nightfly@nightbox:/dev$ mkfs
 Uso: mkfs [-V] [-t tipofs] [opzioni-fs] dispositivo [dimensione]

Da questa breve descrizione è facile intuire che il comando da lanciare sarà il seguente:

nightfly@nightbox:/dev$ sudo mkfs -t ext3 /dev/sdb

dove ext3 è il tipo di filesystem scelto.

Editiamo, infine, il file fstab presente nella directory /etc semplicemente digitando:

nightfly@nightbox:/dev$ sudo nano /etc/fstab

Tale file avrà un aspetto simile al seguente:

# /etc/fstab: static file system information.
 #
 # Use 'blkid -o value -s UUID' to print the universally unique identifier
 # for a device; this may be used with UUID= as a more robust way to name
 # devices that works even if disks are added and removed. See fstab(5).
 #
 # <file system> <mount point>   <type>  <options>                     <dump>  <pass>
 proc            /proc           proc    nodev,noexec,nosuid                            0               0
 /dev/sda       /              ext3    errors=remount-ro                                0               1
 # swap was on /dev/sda5 during installation
 UUID=xxx        none            swap    sw                                                      0               0
 /dev/fd0        /media/floppy0  auto    rw,user,noauto,exec,utf8     0               0

Aggiungiamo la seguente stringa:

/dev/sdb       /media/disk     ext3    rw,user,noauto,nosuid,utf8     0               0

Dove /media/disk sarà il punto di mount del nostro hard disk (per i sistemi *buntu tale dir viene creata automaticamete), ext3 è il tipo di partizione presente all’interno del disco rigido, le opzioni rw,user,noauto,nosuid,utf8 indicano rispettivamente che si può accedere al disco sia in lettura che in scrittura (rw), che la partizione è montabile anche da un utente che non ha privilegi di root (user), che la partizione non deve essere montata al boot della macchina (noauto), che i bit del suid non vengono presi in considerazione (nosuid) e che il charset da utilizzare è utf8. Ovviamente queste non sono le uniche opzioni disponibili, per maggiori dettagli vi rimando al man di fstab.

Bene, digitiamo:

root@nightbox:~# mount /media/disk

e finalmente potremo usare il nostro nuovo HD. Bye.

Script per il backup automatico di un sito Web

Sulla falsariga dello scrip per il backup automatico di un database, ho deciso di crearne uno che effettua periodicamente il backup di un sito Web (un pò come avviene con gli hosting provider).

Ecco il codice:

#!/bin/bash

datasito=$(date +"%d_%b_%y")

montaggiosito=$(mount | grep /media/disk)

#File di log
FILELOG=/var/log/backupmiosito

ROOT_UID=0

if [ "$UID" -ne "$ROOT_UID" ];then

ERRORE1="Errore 1: Devi essere root per eseguire lo scrip"
echo $ERRORE1
echo "$(date) $ERRORE1" >> $FILELOG

exit 1

fi

if [ ! -n "$montaggiosito"  ]; then

mount /media/disk

fi

if [ ! -d /media/disk/backup/miosito ]; then

cd /media/disk

mkdir /media/disk/backup/miosito

fi

cd /media/disk/backup/miosito

mkdir backup_$datasito

cp -r /var/www/miosito /media/disk/backup/miosito/backup_$datasito

exit 0

Come potete notare, tale scrip si differenzia da quello per il backup del database sono nelle ultime righe (e per qualche nome assegnato alle variabili). Nella fattispecie, il comando cp -r /var/www/miosito /media/disk/backup/miosito/backup_$datasito non fa altro che copiare tutto il contenuto della directory /var/www/miosito (comprese le sottodirectory, grazie alla flag -r) in /media/disk/backup/miosito/backup_$datasito.

Rendo eseguibile lo scrip, digitando sudo chmod +x backupsito e successivamente lo copio nella cartella /usr/bin mediante il comando sudo cp /backupsito /usr/bin.

Ora, tale scrip può essere eseguito ad intervalli di tempo regolari, semplicemente inserendo la seguente istruzione nel file crontab presente nella directory /etc:

0 21   * * *   root    backupsito > /dev/null 2>&1

ed il gioco è fatto.

See ya.

Script Bash per l’invio tramite SMS dei risultati delle partite

Vi è mai capitato di aver giocato una o più schedine e di non poter controllare i risultati aggiornati perchè ci si trova fuori casa? Ebbene, questo è lo scrip che fa per voi. Basta avere a disposizione una macchina Linux ed un numero Vodafone abilitato alla ricezione degli MMS.

pallone.jpg

 

Per prima cosa andiamo ad individuare quali software sono necessari per il corretto funzionamento dello scrip:

1) Lynx, ovvero un browser testuale. Per installarlo basta digitare il comando (su Kubuntu 9.04)

sudo apt-get install lynx

2) MoioSMS, ovvero un client da linea di comando che ci permette di inviare gratuitamente MMS verso i numeri Vodafone. Per installarlo occorre aggiornare la lista dei repository aggiungendo la seguente stringa al file /etc/apt/sources.list

deb http://www.moioli.net/files/repository ubuntu beta

e successivamente lanciando il comando

sudo apt-get update

Bene, una volta completata l’installazione dei software sopra elencati possiamo procedere con la creazione di una nuova directory, che nella fattispecie chiameremo partite, all’interno della quale salvare tutti i file necessari al nostro scrip. Digitiamo quindi:

mkdir partite

dopo esserci posizionati sulla nostra home.

Adesso creiamo il file controlla_partite, all’interno del quale andremo ad inserire il nome di una o più squadre impegnate nei match di nostro interesse.

touch controlla partite

Apriamo il file in scrittura usando un editor di testo ed aggiungiamo ad esempio la stringa AS Roma. Salviamo e chiudiamo il file. Di seguito è presente un esempio del contenuto relativo al file controlla_partite:

Juventus

As Roma

Lazio

Creiamo il file di log che chiameremo matchlog in cui verranno salvati tutti gli eventuali errori generati durante l’esecuzione del nostro scrip. Tale file dovrà essere posizionato all’interno della dir /var/log:

sudo touch /var/log/matchlog

Ora creiamo un altro file chiamato match all’interno del quale andremo ad inserire il seguente codice:

#!/bin/bash

#File di log
FILELOG=/var/log/matchlog

#Numero di Telefono a cui inviare
NUMERO=<numero di cell al quale inviare gli MMS>

#Account MMS
ACCOUNT="Vodafonemms"

ROOT_UID=0 #necessario per MoioSMS e per scrivere nella cartella /var/log

#Controllo che lo scrip venga eseguito da root

if [ "$UID" -ne "$ROOT_UID" ];then

ERRORE1="Errore 1: Devi essere root per eseguire lo scrip"
echo $ERRORE1
echo "$(date) $ERRORE1" >> $FILELOG

exit 1

fi

if [ -s controlla_partite ];then

lynx -dump www.livescore.com > risultati.txt

while read line
do
cat risultati.txt | grep "${line}" >>  cambiamenti;
sed -i 's/[[0-9a-zA-Z.]*]//g' cambiamenti; #rimuovo i marcatori generati da lynx         
done < controlla_partite

if [ -s cambiamenti ];then

sed -i 's/  */ /g' cambiamenti; #sostituisco gli spazi multipli con un unico spazio

cut -d" " -f 3- cambiamenti > cambiamenti_temp;

if [ -f cambiamenti_temp ];then

sed -i 's/^[ t]*//g' cambiamenti_temp; #elimino gli spazi vuoti ad inizio riga

if [ -f cambiamenti_backup ];then

#confronto i due file e salvo le differenza all'interno di notifica

diff cambiamenti_temp cambiamenti_backup > notifica

else

touch cambiamenti_backup;
cp cambiamenti_temp cambiamenti_backup
rm cambiamenti

exit 1

fi

else

ERRORE3="Errore 3: Il file cambiamenti_temp non esiste."
echo $ERRORE3
echo "$(date) $ERRORE3" >> $FILELOG

exit 1

fi

else

if [ -f cambiamenti ];then

rm cambiamenti #nel caso in cui cambiamenti sia vuoto

else

ERRORE2="Errore 2: Il file cambiamenti non esiste. Controlla i permessi"
echo $ERRORE2
echo "$(date) $ERRORE2" >> $FILELOG

fi

exit 1

fi

#se il file notifica esiste e non risulta vuoto, ovvero ci sono differenze

if [ -s notifica  ];then

#aggiorno il file di backup usato per il confronto
cp cambiamenti_temp cambiamenti_backup

#individuo i parametri da inviare con l'SMS

TESTOSMS=$(cat cambiamenti)

ESITO=$(sms $NUMERO "$TESTOSMS" $ACCOUNT) #invio le informazioni

#ora posso rimuovere il file notifica in quanto il messaggio risulta inviato


rm notifica


#elimino il file cambiamenti in quanto il messaggio risulta inviato


rm cambiamenti

else

rm notifica
rm cambiamenti
fi

else

if [ -f cambiamenti_temp ];then

rm cambiamenti_temp;

fi

if [ -f cambiamenti_backup ];then

rm cambiamenti_backup;

fi

exit 1

fi

exit 0

Come potete notare lo scrip è ampiamente commentato, quindi vi sarà certamente possibile capirne il senso. Ho inoltre inserito parecchi controlli (aumentando inevitabilmente le righe di codice) per evitare comportanenti inaspettati.

Digitiamo, inoltre, il comando:

sudo chmod +x match

per rendere eseguibile il nostro file.

Non ci resta che mandare in esecuzione lo scrip ogni 5 minuti in modo che venga effettuato un monitoraggio costante delle partite. Per fare ciò basta aggiungere la seguente regola a cron, editando il file /etc/crontab:

*/5  *    * * *   root    cd /home/nightfly/partite && ./match > /dev/null 2>&1

A presto.

PS: ovviamente lo scrip non è immune da eventuali errori o miglioramenti, nel caso in cui ne individuaste qualcuno non esitate a contattarmi.

PPS: se non volete controllare l’esito di alcun match rimuovete il file controlla_partite oppure svuotatelo completamente mediante il comando:

sudo cat /dev/null > controlla_partite

e successivamente, per verificare che il file sia effettivamente vuoto basta digitare:

stat -c %s controlla_partite