Creazione automatica di un file di log per inviare quesiti al forum

Versioni Compatibili Tutte le versioni supportate di Debian

Introduzione

Questo script permette la creazione di un file contenente informazioni utili che è possibile portare a conoscenza del forum per tentare di risolvere insieme i problemi più comuni.

Lo script crea due file:

log.txt

contiene le informazioni in formato testo

log.{txt.bz2,zip,tgz}

il file precedente ma in formato compresso. Può essere allegato ad una discussione sul forum

Attraverso lo script è anche possibile inviare il file direttamente a paste.debian.net per poterlo condividere pubblicamente.

In questo caso il file non potrà superare la grandezza complessiva di 320K circa (diviso in parti della dimensione massima di 80K circa) e le informazioni saranno disponibili a chiunque per una settimana.

Prima di effettuare l'invio, lo script chiede un esplicito consenso all'utente.
Per usufruire del servizio offerto da paste.debian.net è necessaria l'installazione del pacchetto pastebinit:

# apt-get install pastebinit

Nota Lo script è liberamente modificabile. Per ogni segnalazione, informazione o suggerimento fare riferimento a questa discussione sul forum.

Utilizzo

1. Copiare il codice dello script in un file di testo. Il nome del file può essere scelto liberamente.
2. Dare i permessi di esecuzione al file appena creato. Supponendo che si chiami nomefile:

   $ chmod +x nomefile

3. Eseguire lo script con i permessi di root:

   # ./nomefile

   il comando precedente presuppone che sia eseguito nella stessa directory in cui risiede lo script.
   L'esecuzione con i permessi di root si rende necessaria poiché alcuni comandi devono essere eseguiti necessariamente come utente privilegiato.
4. Leggere le informazioni a video.

Script

#!/bin/bash

# Nome del file di log
log="log.txt"

# --------------------------------------------------------------------------
# Funzioni iniziali
# --------------------------------------------------------------------------

# Funzione che stampa il messaggio introduttivo
function _intro {
 cat <<TESTO
*********************************************************************************
*  www.debianizzati.org                                                         *
*                                                                               * 
*  Script che crea un log utile alla risoluzione dei problemi più comuni        *
*  Versione 1.0.5                                                               * 
*                                                                               * 
*********************************************************************************
TESTO
}

# Funzione che stampa alcune avvertenze sullo script
function _avvertenze {
 local risp
 cat <<TESTO
-- Lo script richiede i permessi di root per essere eseguito
-- Per inviare il log su paste.debian.net è necessario il pacchetto 'pastebinit'
-- L'invio del log a paste.debian.net avverrà solo dopo esplicito consenso
-- Verrà creato un file (log.txt) contenente l'output di questo script
-- Verrà creato un file in formato compresso da inviare al forum
TESTO
 echo -n "Continuare [S/n]? "
 read risp
 case $risp in
  ""|[Ss])
       ;;
  *)
       echo -e "Uscita\n"
       exit 1
       ;;
 esac
}

# Funzione che esegue un check preliminare
function _check {
if [[ $EUID -ne 0 ]]; then # Lo script viene lanciato da root?
 echo "Lo script deve essere lanciato da root"
 exit 1
fi 

# Se esiste già un file di log con lo stesso nome oppure
# file compressi con lo stesso nome di quelli che verranno
# creati, lo script chiede se cancellarli o meno 
local risp
if [ -f ./log.txt -o -f ./log.zip -o -f ./log.txt.bz2 -o -f ./log.tgz ]; then
 echo -n "Esiste già un file log.txt, log.zip, log.txt.bz2 o log.tgz nella directory corrente. Sovrascivere [S/n]? "
 read risp
 case $risp in
   ""|[Ss])
       rm -f $log log.zip log.txt.bz2 log.tgz
       ;;
   *) 
       exit 1
       ;;
 esac
fi
}

# --------------------------------------------------------------------------
# Funzione per separare il log in parti per l'invio a paste.debian.net 
# --------------------------------------------------------------------------
function _split_and_send {
  local chunk_prefix='pastebin'
  local chunk_num=1

  # dimensione massima del singolo file da inviare a http://paste.debian.net
  local chunk_size='80k'

  # rinomina parti di log preesistenti (se ve ne sono) 
  # scarta i messaggi di errore (se presenti)
  rename "s/$chunk_prefix/old-$chunk_prefix-$(date +%s)/g" $chunk_prefix.* > /dev/null 2>&1 

  # dividi il file di log in parti di $chunk_size bytes senza spezzare le linee
  # scarta i messaggi di errore (se presenti) per log di dimensione superiore a 10 parti
  # (max 10 parti con l'opzione -a)
  split -a 1 -d -C $chunk_size $log $chunk_prefix. > /dev/null 2>&1
  
  # comunica il numero di parti inviate
  chunk_num=$( ls -1 $chunk_prefix.* | wc -l )
  if [ $chunk_num = 1 ]; 
    then
      echo -e "\nIl log sarà inviato in un singolo file."
    else
      echo -e "\nIl log sarà inviato in $chunk_num parti."
  fi
  
  # invia al massimo 4 parti a http://paste.debian.net
  echo -e "\nIl log è consultabile ai seguenti indirizzi:"
  for  chunkfile in $chunk_prefix.{0..3}; do
    if [ -f $chunkfile ]; then 
      pastelink="$(pastebinit -a "" -b http://paste.debian.net -i $chunkfile)"
      echo "   $pastelink"
    fi
  done

  # cancella i parti di log inviati
  # scarta i messaggi di errore (se presenti)
  rm $chunk_prefix.{0..9} > /dev/null 2>&1
  
  return 0
}

# --------------------------------------------------------------------------
# Funzione che invia il log a paste.debian.net
# --------------------------------------------------------------------------
function _upload {
 local pastelink
 local risp
 # Pastebinit è installato?
 if [ ! -f /usr/bin/pastebinit ]; then
  echo -e "\nNon è possibile inviare il log a paste.debian.net\nIl pacchetto 'pastebinit' non è installato."
  return 1
 fi
 # Invia il file log.txt a paste.debian.net
 echo -en "\nInviare il log a paste.debian.net [S/n]? "
 read risp
 case $risp in
  ""|[Ss])
      _split_and_send
       ;;
  *)
       echo "Il log non è stato inviato"
       ;;
 esac
}

# --------------------------------------------------------------------------
# Funzioni di creazione del file compresso e messaggi di successo/fallimento
# --------------------------------------------------------------------------

# Funzione richiamata in caso di corretta creazione del file compresso
function _compress_ok {
 echo "Il file compresso $1 è stato creato correttamente nella directory corrente."
 echo -e "Allegare questo file alla discussione sul forum.\n"
 # Imposta i permessi di lettura-scrittura sul file per tutti gli utenti
 chmod 666 $1
}

# Funzione richiamata in caso di errore nella creazione del file compresso
function _compress_err {
 echo -e "\nErrore nella creazione del file compresso $1."
}

# Funzione che crea il file compresso
# Prova a creare nell'ordine: un file .bz2, un file .zip o un file .tgz
function _compress {
 local risp
 echo -en "\nCreare un file compresso [S/n]? "
 read risp
 case $risp in
  ""|[Ss])
       echo -e "\nSta per essere creato un file compresso..."
       sleep 2
       if [ -f /bin/bzip2 ]; then
        bzip2 -k9 $log && _compress_ok log.txt.bz2 || _compress_err log.txt.bz2
       elif [ -f /usr/bin/zip ]; then
        zip log.zip $log && _compress_ok log.zip || _compress_err log.zip
       else
       tar czf log.tgz $log && _compress_ok log.tgz || _compress_err log.tgz
       fi
       ;;
  *)
       ;;
 esac
}


# --------------------------------------------------------------------------
# Funzioni varie
# --------------------------------------------------------------------------

# Funzione che stampa due righe vuote
function _spazi {
 echo >> $log
 echo >> $log
}

# Funzione che stampa un pallino di colore verde in caso di comando con output
function _ok {
 /bin/echo -e "  $1" "\033[35G\033[01;32m•\033[0m"
}

# Funzione che stampa una pallino rosso in caso di comando privo di output
function _error {
 /bin/echo -e "  $1" "\033[35G\033[01;31m•\033[0m"
}

# Funzione che invia nel file di log due righe tra le quali
# viene visualizzato il nome del comando ( passato come primo
# parametro della funzione -> $1 )
function nome_e_riga {
 cat <<FINE >> $log 
******************************************
$1
******************************************
FINE
}

# Funzione che stampa un messaggio di attesa e aspetta 2 secondi
function _wait {
 echo -e "\nCreazione del log in corso. Attendere pochi secondi...\n"
 sleep 2
}


# --------------------------------------------------------------------------
# Array che contiene la lista delle funzioni
# --------------------------------------------------------------------------

# Questo array contiene tutte le funzioni utilizzate per il log
# dei comandi. 
# Per aggiungere una nuova funzione, inserire qui il suo nome e 
# scriverne il codice in basso.

comandi=(
_unamea
_version
_dmesg
_lsmod
_lspci
_lsusb
_fdisk
_fstab
_mount
_df
_xorg_log
_sources
_apt_cache
_apt_get_check
_interfaces
_hosts
_ifconfig
_ping
_ip
_iwconfig
_iwlist
_route
_resolvconf
_resolvconf2
_firmware
_dhcp
_dhclient
_nm
_wicd
_iptables
)


# --------------------------------------------------------------------------
# Funzioni contenute nell'array
# --------------------------------------------------------------------------

# comando 'uname -a'
function _unamea {
 local var="uname -a"
 nome_e_riga "$var"
 if [ -x /bin/uname ]; then
  /bin/uname -a &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/debian/version'
function _version {
 local var="/etc/debian_version"
 nome_e_riga "$var"
 if [ -f /etc/debian_version ]; then
  cat /etc/debian_version &>> $log && _ok "$var" || _error "$var"
 else
  echo "Il file /etc/debian_version non trovato" >> $log && _error "$var"
 fi
}

# comando 'dmesg'
function _dmesg {
 local var="dmesg"
 nome_e_riga "$var"
 if [ -x /bin/dmesg ]; then
  /bin/dmesg &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'lsmod'
function _lsmod {
 local var="lsmod"
 nome_e_riga "$var"
 if [ -x /bin/lsmod ]; then
  /bin/lsmod &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'lspci'
function _lspci {
 local var="lspci"
 nome_e_riga "$var"
 if [ -x /usr/bin/lspci ]; then
  /usr/bin/lspci -knn &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'lsusb'
function _lsusb {
 local var="lsusb"
 nome_e_riga "$var"
 if [ -x /usr/bin/lsusb ]; then
  /usr/bin/lsusb &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'fdisk'
function _fdisk {
 local var="fdisk -l"
 nome_e_riga "$var"
 if [ -x /sbin/fdisk ]; then
  /sbin/fdisk -l &>> $log && _ok "$var" || _error "$var"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# file /etc/fstab 
function _fstab {
 local var="/etc/fstab"
 nome_e_riga "$var"
 if [ -f /etc/fstab ]; then
  cat /etc/fstab &>> $log && _ok "$var" || _error "$var"
 else
  echo "Il file $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'mount'
function _mount {
 local var="mount"
 nome_e_riga "$var"
 if [ -x /bin/mount ]; then
  /bin/mount &>> $log && _ok "$var" || _error "$var"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'df'
function _df {
 local var="df -h"
 nome_e_riga "$var"
 if [ -x /bin/df ]; then
  /bin/df -h &>> $log && _ok "$var" || _error "$var"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# log del server X
function _xorg_log {
 local var="/var/log/Xorg.0.log"
 nome_e_riga "$var"
 if [ -f /var/log/Xorg.0.log ]; then
  cat /var/log/Xorg.0.log &>> $log && _ok "$var" || _error "$var"
 else
  echo "File $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/network/interfaces'
function _interfaces {
 local var="/etc/newtork/interfaces"
 nome_e_riga "$var"
 if [ -f /etc/network/interfaces ]; then
  ls -l  /etc/network/interfaces &>> $log || _error "$var"
  echo "" >> $log
  cat /etc/network/interfaces &>> $log && _ok "$var" || _error "$var"
 else
  echo "File $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/hosts'
function _hosts {
 local var="/etc/hosts"
 nome_e_riga "$var"
 if [ -f /etc/hosts ]; then
  cat /etc/hosts &>> $log && _ok "$var" || _error "$var"
 else
  echo "File /etc/hosts non trovato" >> $log && _error "$var"
 fi
}

# comandi 'ifconfig' e 'ifconfig -a'
function _ifconfig {
 local var="ifconfig"
 nome_e_riga "$var"
 if [ -x /sbin/ifconfig ]; then
  /sbin/ifconfig &>> $log && _ok "$var" || _error "$var"
  _spazi
  nome_e_riga "$var -a"
  ifconfig -a &>> $log && _ok "$var -a" || _error "$var -a"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'ping -c3 8.8.8.8'
function _ping {
 local var="ping"
 #Ping verso l'IP del DNS di Google 8.8.8.8
 local host="8.8.8.8"
 nome_e_riga "$var"
 if [ -x /bin/ping ]; then
  /bin/ping -c3 $host &>> $log && _ok "$var" || _error "$var"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'iwconfig'
function _iwconfig {
 local var="iwconfig"
 nome_e_riga "$var"
 if [ -x /sbin/iwconfig ]; then
  /sbin/iwconfig &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'iwlist scan'
function _iwlist {
 local var="iwlist"
 local tmpfile=$(/bin/tempfile)
 nome_e_riga "$var"
 if [ -x /sbin/iwlist ]; then 
    /sbin/iwlist scan > $tmpfile 2>&1
    if [ $? = 0 ]; then
      _ok "$var scan" 
      /bin/sed -e 's/ESSID:.*/ESSID:"*script-removed*"/g' -e '/^[ ]*IE: Unknown:.*/d' $tmpfile &>> $log 
    else
      _error "$var scan"
    fi    
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
 rm $tmpfile
}

# comandi 'ip addrr list' e 'ip route list'
function _ip {
 if [ -x /bin/ip ]; then
  nome_e_riga "ip addr list"
  /bin/ip addr list &>> $log && _ok "ip addr list" || _error "ip addr list"
  _spazi
  nome_e_riga "ip route list"
  /bin/ip route list &>> $log && _ok "ip route list" || _error "ip route list"
 else 
  echo "Comando ip non trovato" >> $log && _error "ip"
 fi
}

# comando 'route -n'
function _route {
 local var="route"
 nome_e_riga "$var -n"
 if [ -x /sbin/route ]; then
  /sbin/route -n &>> $log && _ok "$var -n" || _error "$var -n"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'iptables -L'
function _iptables {
 local var="iptables"
 nome_e_riga "$var"
 if [ -x /sbin/iptables ]; then
  /sbin/iptables -L &>> $log && _ok "$var -L" || _error "$var -L"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/resolv.conf'
function _resolvconf2 {
 local var="/etc/resolv.conf"
 nome_e_riga "$var"
 if [ -f /etc/resolv.conf ]; then
  ls -l /etc/resolv.conf &>> $log || _error "$var"
  echo "" >> $log
  cat /etc/resolv.conf &>> $log && _ok "$var" || _error "$var"
 else 
 echo "File $var non trovato" >> $log && _error "$var"
 fi
}

# esistenza del pacchetto 'resolvconf'
function _resolvconf {
 local var="resolvconf"
 nome_e_riga "$var"
 if [ $(dpkg -l | grep -ci resolvconf) -eq 0 ]; then
  echo "Il pacchetto resolvconf non è installato" >> $log && _error "$var"
 else
  dpkg -l | grep -i resolvconf >> $log && _ok "$var"
 fi
}

# esistenza di pacchetti contenenti firmware e firmware presente sulla macchina
function _firmware {
 local var="Firmware"
 local i
 nome_e_riga "$var"
 dpkg -l | grep -i firmware >> $log && _ok "$var"
 # Array contenente tre directory
 local firm_dir=(/usr/lib/firmware /usr/local/lib/firmware /lib/firmware)
  for ((i=0; i<${#firm_dir[@]}; i++)); do
   if [ -d ${firm_dir[$i]} ]; then
    echo "Contenuto di ${firm_dir[$i]}" >> $log 
    ls -al ${firm_dir[$i]} >> $log
   else
    echo "${firm_dir[$i]} non trovato" >> $log
   fi
  done
}

# esistenza di pacchetti riguardanti DHCP
function _dhcp {
 local var="DHCP"
 nome_e_riga "$var"
 if [ $(dpkg -l | grep -ci dhcp) -eq 0 ]; then
  echo "Nessun pacchetto DHCP installato" >> $log && _error "$var"
 else
  dpkg -l | grep -i dhcp >> $log && _ok "$var"
 fi
}

# comando 'cat /etc/dhclient.conf'
function _dhclient {
 local var="/etc/dhclient.conf"
 nome_e_riga "$var"
 if [ -f /etc/dhclient.conf ]; then
  cat /etc/dhclient.conf &>> $log && _ok "$var" || _error "$var"
 else
  echo "File /etc/dhclient.conf non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/apt/sources.list'
function _sources {
 local var="/etc/apt/sources.list"
 nome_e_riga "$var"
 if [ -f /etc/apt/sources.list ]; then
  ls -l /etc/apt/sources.list &>> $log || _error "$var"
  echo "" >> $log
  cat /etc/apt/sources.list &>> $log && _ok "$var" || _error "$var"
 else 
  echo "File $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'apt_cache'
function _apt_cache {
 local var="apt-cache policy"
 nome_e_riga "$var"
 if [ -x /usr/bin/apt-cache ]; then
   /usr/bin/apt-cache policy &>> $log && _ok "$var" || _error "$var"
   _spazi
   var="apt-cache stats"
   nome_e_riga "$var"
   /usr/bin/apt-cache stats &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'apt_get_check'
function _apt_get_check {
 local var="apt-get check"
 nome_e_riga "$var"
 if [ -x /usr/bin/apt-get ]; then
   /usr/bin/apt-get check &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# esistenza di Network Manager
function _nm {
 local var="Network Manager"
 nome_e_riga "$var"
 if [ -n "$(dpkg -l | cut -d ' ' -f3 | egrep -i '^network-manager$')" ]; then
  echo "Network Manager è installato (versione "$(NetworkManager --version)")" >> $log && _ok "$var"
  invoke-rc.d network-manager status &>/dev/null
  if [ $? -eq 0 ]; then
   echo "Network Manager è in esecuzione" >> $log
  else
   echo "Network Manager non è in esecuzione" >> $log  
  fi
 else
  echo "Network Manager non è installato" >> $log && _error "$var"
 fi
}

# esistenza di Wicd
function _wicd {
 local var="Wicd"
 nome_e_riga "$var"
 if [ -n "$(dpkg -l | grep -i 'wicd')" ]; then
  echo "Wicd è installato" >> $log && _ok "$var"
  if [ -n "$(invoke-rc.d wicd status | grep "is running")" ]; then
   echo "Wicd è in esecuzione" >> $log
  else
   echo "Wicd non è in esecuzione" >> $log  
  fi
 else
  echo "Wicd non è installato" >> $log && _error "$var"
 fi
}


# --------------------------------------------------------------------------
# Main
# --------------------------------------------------------------------------

clear

_intro
_avvertenze
_check
_wait

# Ciclo sull'array di funzioni
for ((i=0; i<${#comandi[@]}; i++)); do
 ${comandi[$i]}
 _spazi
 sleep 1
done
echo -e "\nIl file $log è stato creato correttamente nella directory corrente."

_upload
_compress

# Permessi di lettura e scrittura per tutti
# poiché il file di log viene creato da root
chmod 666 $log

exit 0

Changelog

1.0.5

Aggiunta funzionalità frammentazione log per invio a http://paste.debian.net

Aggiunta funzionalità per verifiche sullo stato dei dischi (comandi fdisk -l , mount, df -h)

Aggiunta funzionalità per verifica del file /etc/fstab

Apportate alcune variazioni ai messaggi diagnostici

Collegamento con la guida su Come formulare quesiti tecnici al forum

Aki 13:30 25 apr 2013 (CEST)

1.0.4

Tolto qualche echo e inserito un messaggio di mancato invio log a p.d.n

S3v 18:15, 20 apr 2013 (CEST)

1.0.3

Aggiunta rimozione valore ESSID dalla scansione delle reti wireless

Aki 20:34 14 apr 2013 (CEST)

1.0.2

Aggiunta avvertenza su esplicito consenso all'invio verso paste.debian.net

S3v 14:56, 14 apr 2013 (CEST)

1.0.1

Corretta la funzione "dmesg" che svuotava il buffer e non produceva output

S3v 12:22, 14 apr 2013 (CEST)

---

Guida scritta da: S3v 23:38, 13 apr 2013 (CEST)	Debianized 20%
Estesa da:
Verificata da:
Verificare ed estendere la guida | Cos'è una guida Debianized