Creazione automatica di un file di log per inviare quesiti al forum: differenze tra le versioni

Da Guide@Debianizzati.Org.
Vai alla navigazione Vai alla ricerca
Riga 773: Riga 773:
== Changelog ==
== Changelog ==
<!-- Qui vanno inserite le spiegazioni di eventuali modifiche dello script (chi, cosa, quando). Ricordarsi di modificare la versione all'interno del codice (la versione iniziale è 1.0.0) -->
<!-- Qui vanno inserite le spiegazioni di eventuali modifiche dello script (chi, cosa, quando). Ricordarsi di modificare la versione all'interno del codice (la versione iniziale è 1.0.0) -->
;1.0.9
:''Aggiunta funzionalità per aggiungere i log di sistema (/var/log/syslog e /var/log/syslog.1)
:[[Utente:Aki|Aki]] 14:20 3 mag 2013 (CEST);
;1.0.8
;1.0.8
:''Integrazione funzionalità upload per supportare la verifica della ricezione da parte di http://paste.debian.net
:''Integrazione funzionalità upload per supportare la verifica della ricezione da parte di http://paste.debian.net

Versione delle 12:20, 3 mag 2013

Debian-swirl.png 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
Info.png 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.9                                                               *
*                                                                               *
*********************************************************************************
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 paste_url='http://paste.debian.net'
  local chunk_prefix='pastebin'
  local chunk_num=1
  local paste_exit_status=0
  
  # dimensione massima del singolo file da inviare 
  local chunk_size='60k'
  
  # 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
  echo -e "\nIl log è consultabile ai seguenti indirizzi:"
  for  chunkfile in $chunk_prefix.{0..3}; do
  
    # verifica l'esistenza del file da inviare
    if [ -f $chunkfile ]; then

	# invia dati tramite pastebinit
	pastelink="$(pastebinit -a '' -b $paste_url -i $chunkfile)"
		
	if [ $? = 0 ]; then
	    # invio apparentemente riuscito (pastebinit exit status = 0)
	    
	    # controlla URL restituita da pastebinit
	    case $pastelink in 
		# verifica in caso di url corretta
		"$paste_url"/[0-9]*) 
		    echo ".. inviato $chunkfile all'indirizzo $pastelink" 
		    ;; 
		# verifica in caso di url non corretta
		*)
		    echo ".. $paste_url ha restituito una URL non valida ($pastelink) per $chunkfile!"
		    paste_exit_status=1
		    ;;
	    esac
    
	  else
	    # Invio fallito (pastebinit exit status = 1)
	    echo ".. non riuscito invio $chunkfile"
	    paste_exit_status=1
	fi
	
    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 $paste_exit_status
}

# --------------------------------------------------------------------------
# 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 http://paste.debian.net [S/n]? "
  read risp
  case $risp in
    ""|[Ss])
      _split_and_send 
      if [ $? == 0 ]; then
	  echo -e "\nIl log è stato inviato" 
      else
	  echo -e "\nSi sono verificati errori nell'invio del log!"
      fi
    ;;
    *)
      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=(
  _dmi_decode
  _unamea
  _version
  _dmesg
  _syslog
  _syslog_1
  _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 'cat /sys/class/dmi/id/{sys_vendor,product_name,product_version,bios_version}'
function _dmi_decode {
  local var="/sys/class/dmi/id/*"
  nome_e_riga "$var"
  if [ -f /sys/class/dmi/id/sys_vendor ]; then
    echo 'Produttore:' $(cat /sys/class/dmi/id/sys_vendor)      &>> $log
    echo 'Prodotto:  ' $(cat /sys/class/dmi/id/product_name)    &>> $log
    echo 'Versione:  ' $(cat /sys/class/dmi/id/product_version) &>> $log
    echo 'BIOS vers.:' $(cat /sys/class/dmi/id/bios_version)    &>> $log && _ok "$var" || _error "$var"
  else
    echo "File /sys/class/dmi/id/sys_vendor non trovato" >> $log && _error "$var"
  fi
}

# 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 'cat /var/log/syslog'
function _syslog {
  local var="/var/log/syslog"
  nome_e_riga "$var"
  if [ -f /var/log/syslog ]; then
    cat /var/log/syslog &>> $log && _ok "$var" || _error "$var"
  else
    echo "Il file /var/log/syslog non trovato" >> $log && _error "$var"
  fi
}

# comando 'cat /var/log/syslog.1'
function _syslog_1 {
  local var="/var/log/syslog.1"
  nome_e_riga "$var"
  if [ -f /var/log/syslog.1 ]; then
    cat /var/log/syslog.1 &>> $log && _ok "$var" || _error "$var"
  else
    echo "Il file /var/log/syslog.1 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/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
}

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

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

# 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.9
Aggiunta funzionalità per aggiungere i log di sistema (/var/log/syslog e /var/log/syslog.1)
Aki 14:20 3 mag 2013 (CEST);
1.0.8
Integrazione funzionalità upload per supportare la verifica della ricezione da parte di http://paste.debian.net
Revisione messaggistica in caso di fallito invio a http://paste.debian.net
Aki 12:40 2 mag 2013 (CEST);
1.0.7
Aggiunta funzionalità per identificazione produttore e modello del computer secondo lo standard SMBIOS/DMI
Aggiunta rimozione valore ESSID dall'output del comando iwconfig
Aggiunto controllo esito invio log verso http://paste.debian.net (in caso di falito invio)
Anticipazione ed unificazione nell'ordine del codice sorgente delle sezioni relative al controllo del sistema apt
Aki 13:40 27 apr 2013 (CEST);

1.0.6

Aggiunta funzionalità per verifiche sullo stato del gestiore dei pacchetti (comandi apt-cache policy, apt-cache status)
Aki 10:39 26 apr 2013 (CEST)
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) Swirl-auth20.png Debianized 20%
Estesa da:
Verificata da:

Verificare ed estendere la guida | Cos'è una guida Debianized

Estratto da "https://guide.debianizzati.org/index.php?title=Creazione_automatica_di_un_file_di_log_per_inviare_quesiti_al_forum&oldid=32321"