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

Da Guide@Debianizzati.Org.
Versione del 22 nov 2013 alle 14:50 di S3v (discussione | contributi) (+ 1.0.22)
Vai alla navigazione Vai alla ricerca
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 come:

  • Connessioni di rete
  • Video
  • Sottosistema APT
  • Mount/umount di periferiche

Lo script crea due file:

log.data
contiene le informazioni in formato testo
log_data.{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 60K 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

# Path dei comandi dello script
PATH=/bin:/sbin:/usr/bin:/usr/sbin

# Nome del file di log in base alla data corrente
log="log_`date +%d%b_%H%M%S`"

# Inizializzazione di complog e stat_log
# complog contiene il nome del file compresso di log
# stat_log contiene un intero che indica se il file di log è stato creato
complog=""
stat_log=0

# I file creati saranno leggibili e scrivibili da tutti
umask 0111

# Nome utente
utente=`who -s | head -n1 | cut -f1 -d ' '`


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

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

# Funzione che stampa alcune avvertenze sullo script
function _avvertenze {
  local risp
  echo "
-- 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 contenente l'output di questo script
-- Verrà creato un file in formato compresso da inviare al forum"
  echo -n "Continuare [S/n]? "
  read risp
  case $risp in
    ""|[Ss])
      ;;
    *)
      _exit
  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
  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 -o -f $log.zip -o -f $log.bz2 -o -f $log.tgz ]; then
    echo -en "\nEsiste già un file $log, $log.zip, $log.bz2 o $log.tgz nella directory corrente.\nSovrascivere [S/n]? "
    read risp
    case $risp in
      ""|[Ss])
        rm -f $log $log.zip $log.bz2 $log.tgz
        ;;
      *)
        _exit
    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
  local chunkfile pastelink
 
  # 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, l'output d'errore viene soppresso
    pastelink="$(pastebinit -a '' -b $paste_url -i $chunkfile 2>/dev/null)"
     
      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 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 "File compresso creato correttamente nella directory corrente."
}

# Funzione richiamata in caso di errore nella creazione del file compresso
function _compress_err {
  echo "Errore nella creazione del file compresso."
}

# 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 "Sta per essere creato un file compresso..."
      sleep 1
      if [ -f /bin/bzip2 ]; then
        bzip2 -k9 $log && _compress_ok $log.bz2 || _compress_err $log.bz2
        complog="$log.bz2"
      elif [ -f /usr/bin/zip ]; then
        zip $log.zip $log && _compress_ok $log.zip || _compress_err $log.zip
        complog="$log.zip" 
      else
        tar czf $log.tgz $log && _compress_ok $log.tgz || _compress_err $log.tgz
        complog="$log.tgz"
      fi
      ;;
    *)
      echo "Non è stato creato un file compresso."
  esac
}

# --------------------------------------------------------------------------
# Funzione di stampa menù e selezione del problema
# --------------------------------------------------------------------------

function _scelta {
  local num
 
  clear
  _intro
  echo "
Selezionare il tipo di problema per il quale verrà generato il file di log
[1] Problemi relativi alle connessioni di rete
[2] Problemi video
[3] Problemi di gestione dei pacchetti (APT)
[4] Problemi di mount/umount
[0] Uscita"
 
  while true; do
   echo -n "Scegliere il numero corrispondente: "
   read num
     case $num in
       1)
         _wait
         _rete
         break
         ;;
       2)
         _wait
         _video
         break
         ;;
       3)
	 _wait
	 _apt
	 break
	 ;;
       4)
	 _wait
	 _mount
	 break
	 ;;
       0)
         _exit
         ;;
       *)
         tput cuu1 # in alto di una riga
         tput ed # cancella fino alla fine dello schermo
     esac
  done
}

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

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

}

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

# 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 {
 echo "
******************************************
$1
******************************************" >> $log
}

# 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
}

# Stampa la data corrente nel file di log
function _data {
  echo "Log creato il `date +%d\ %B\ %Y\ alle\ %H:%M`" >> $log
}

# Funzione che stampa un messaggio che indica i file creati e poi termina lo script
function _exit {
  if [ $stat_log -eq 1 ]; then
    echo -e "\nFile contenente il log dello script: \033[01m$log\033[0m"
  else
    echo -e "\nNon è stato creato un file di log"
  fi
  
  if [ "$complog" == "" ]; then
    echo "Non è stato creato un file compresso del log"
  else
    echo -e "File compresso da allegare alla discussione sul forum: \033[01m$complog\033[0m"
  fi
  
  echo -e "Script terminato.\n"
  exit 0
}

# --------------------------------------------------------------------------
# Funzioni relative a ciascun problema selezionato
# --------------------------------------------------------------------------

# Informazioni comuni a tutti i tipi di problema
function _common {
  _data
  _dmi_decode
  _comando "/bin/uname -a"
  _file "/etc/debian_version"
  _de_wm
  _file "/etc/X11/default-display-manager"
  _comando "su -c /usr/bin/groups $utente"
  _file "/var/log/syslog"
  _comando "/bin/dmesg -l err"
  _comando "/bin/dmesg -l warn"
  _comando "/bin/lsmod"
  _comando "/usr/bin/lspci -knn"
  _comando "/usr/bin/lsusb"
  _file "/etc/apt/sources.list"
  _dir "/etc/apt/sources.list.d/"
  _comando "/sbin/fdisk -l"
  _file "/etc/fstab"
  _comando "/bin/mount"
  _comando "/bin/df"
  _comando "/usr/bin/apt-cache policy"
  _comando "/usr/bin/apt-cache stats"
  _comando "/usr/bin/apt-get check"
  _firmware
}

# Funzione relative ai problemi di rete
function _rete  {
  _common
  _file "/etc/network/interfaces"
  _file "/etc/hosts"
  _comando "/sbin/ifconfig"
  _comando "/sbin/ifconfig -a"
  _comando "/bin/ping -c3 8.8.8.8" #DNS di Google 8.8.8.8
  _comando "/bin/ip addr"
  _comando "/bin/ip route list"
  _comando "/sbin/iwconfig"
  _comando "/sbin/iwlist scan"
  _comando "/sbin/route -n"
  _pack "resolvconf"
  _file "/etc/resolv.conf"
  _pack "DHCP"
  _file "/etc/dhclient.conf"
  _demone "/usr/sbin/NetworkManager" "Network Manager"
  _demone "/usr/sbin/wicd" "Wicd"
}

# Funzione relative a problemi video
function _video {
  _common
  _file "/etc/X11/xorg.conf"
  _dir "/etc/X11/xorg.conf.d/"
  _file "/var/log/Xorg.0.log"
  _pack "nouveau"
  _pack "nvidia"
  _pack "mesa"
}

# Funzione relativa alla gestione dei pacchetti attraverso il sistema APT
function _apt {
  _common
  _comando "/usr/bin/dpkg --print-architecture"
  _comando "/usr/bin/apt-get -s update"
  _comando "/usr/bin/apt-get -s -y upgrade"
  _comando "/usr/bin/apt-get -s -y dist-upgrade"
  _comando "/usr/bin/apt-get -s -y -f install"
  _comando "/usr/bin/apt-get -s -y autoremove"
  _comando "/usr/bin/apt-config dump"
  _file "/etc/apt/apt.conf"
  _dir "/etc/apt/apt.conf.d/"
  _file "/etc/apt/preferences"
  _dir "/etc/apt/preferences.d/"
}

# Funzione relativa a problemi di mount/umount
function _mount {
  _common
  _comando "/usr/bin/udisks --dump"
  _pack "usbmount"
}
# --------------------------------------------------------------------------
# Funzioni utilizzate per tipo di problema (generiche)
# --------------------------------------------------------------------------

# Funzione che invia il contenuto di un file al file di log
# La funzione va richiamata specificando il path completo del file che sarà assegnato a $1
# Il contenuto dei file viene inviato inalterato al file di log. Se si ha necessità di modificare
# questo comportamento, creare una entry nel ciclo "case"

function _file {
    nome_e_riga $1
    if [ -f $1 ]; then
      case $1 in
	/etc/network/interfaces)
		      sed -r "s/((wpa-ssid)|(wpa-psk)).*/\1 \*script-removed\*/" $1 &>> $log && _ok $1 || _error $1
		      ;;
	/var/log/syslog)
		      # se il file contiene la stringa "rsyslogd.*start" ...
		      if [ `egrep -s1ci "rsyslogd.*start$" $1` -ne 0 ]; then
			# ... estrae da syslog tutto il contenuto dall'ultima occorrenza della stringa alla fine del file
			sed -n 'H; /rsyslogd.*start$/h; ${g;p;}' $1 >> $log && _ok $1 || _error $1
		      else
			# se syslog non contiene quella stringa, allora si effettuerà la stessa operazione su syslog.1 ($1.1)
			# in questo caso l'intero contenuto del file syslog viene inviato al log
			cat $1 &>> $log && _ok $1 || _error $1
			nome_e_riga $1.1
			sed -n 'H; /rsyslogd.*start$/h; ${g;p;}' $1.1 >> $log && _ok $1.1 || _error $1.1
		      fi
		      ;;
	*)
		      # per tutti i file non specificati sopra...
		      cat $1 &>> $log && _ok $1 || _error $1
      esac
    else
      echo "File $1 non trovato" >> $log && _error $1
    fi
}

# Invia l'output di un comando al file di log
# La funzione va richiamata specificando il path completo del comando (con eventuali opzioni)
# che sarà assegnato a $1 . L'output dei comandi viene inviato interamente al file di log. Se
# si ha necessità di modificare gli output, creare una entry nel ciclo "case"

function _comando {

  # Il comando è eseguito tramite su?
  if [ "${1:0:2}" == "su" ];then
    
    # variabile "comando" priva del nome utente, di su -c e del path
    local comando1="${1% *}" # comando1 conterrà $1 senza nome utente
    local comando="${comando1##*/}" # comando conterrà solo il nome del comando

    nome_e_riga "$comando"
    
    # nell'output viene sostituito il vero nome utente con "nomeutente"
    $1 | sed "s/$utente/nomeutente/g" &>> $log && _ok "$comando" || _error "$comando"
    return # Funzione _comando terminata
  fi
 
  local var=${1##*/} #var conterrà il comando con le opzioni ma privo del path
  local var2=${1%% *} #var2 conterrà il comando privo di eventuali opzioni ma con il path
  nome_e_riga "$var"
  if [ -f "$var2" ]; then
  
    # per "iwconfig" e "iwlist scan" gli ESSID non vengono inviati al log
    case $var2 in
      /sbin/iwconfig)
	    (iwconfig | sed -e '/ESSID:/{/off\/any/! s/ESSID:.*/ESSID:"*script-removed*"/g}' -e '/^[ ]*IE: Unknown:.*/d') &>> $log && _ok "$var" || _error "$var"
	    ;;
      /sbin/iwlist)
	    (iwlist scan | sed -e '/ESSID:.*/{/off\/any/! s/ESSID:.*/ESSID:"*script-removed*"/g}' -e '/^[ ]*IE: Unknown:.*/d') &>> $log && _ok "$var" || _error "$var"
	    ;;
      *)
	    # per tutti gli altri comandi non specificati sopra...
	    $1 &>> $log && _ok "$var" || _error "$var"
    esac
  else
     echo "Comando $var2 non trovato" >> $log && _error "$var"
  fi
}

# Funzione che invia il contenuto dei file di una directory al file di log
function _dir {
  nome_e_riga "$1"

  # Se la directory non esiste, stampa un output sul log ed esce.
  if [ ! -d "$1" ]; then
    echo "La directory non esiste" >> $log && _error "$1"
    return
  fi

  # Variabili locali
  local file
  # numfile contiene il numero di file contenuti nella directory. Solo primo livello.
  local numfile=`find "$1" -maxdepth 1 -type f | wc -l`
  # numdir contiene il numero di sottodirectory contenute nella directory. Solo primo livello.
  local numdir=`find "$1" -maxdepth 1 -type d | wc -l`

  if [ $numfile -eq 0 -a $numdir -eq 1 ]; then
    echo "La directory non contiene file o directory" >> $log && _error "$1"
    return
  else
    echo "La directory contiene $numfile file e $((numdir-1)) directory" >> $log
    ls -al "$1" >> $log
    # invia al log il contenuto dei file della directory
    for file in "$1"*; do
      if [ -f "$file" ]; then
        nome_e_riga "$file"
        cat $file &>> $log && _ok $file || _error $file
      fi
    done
  fi
  
  # Funzione che invia al log il contenuto dei file presenti nelle sottodirectory
  # I due cicli for sono separati per permettere l'output di un file subito dopo
  # la directory a cui appartiene

  for file in "$1"*; do
    if [ -d "$file" ]; then
       _dir "$file/"
    fi
  done
}

# Funzione che elenca i pacchetti installati in base alla parola
# passata come parametro ($1)

function _pack {
  nome_e_riga "$1"
  if [ $(dpkg -l | grep -s1ci "$1") -eq 0 ]; then
    echo "Nessun pacchetto installato" >> $log && _error "$1"
  else
    dpkg -l | grep -i "$1" >> $log && _ok "$1"
  fi
}

# Funzione che verifica l'esistenza e l'esecuzione di alcuni demoni
# Viene chiamata con due parametri:
# $1 - persorso dell'eseguibile
# $2 - nome da visualizzare
# Se si vuol visualizzare la versione del demone, inserire il comando adatto
# all'interno del ciclo 'case'

function _demone {
  local vers=""
  nome_e_riga "$2"
  if [ -f $1 ]; then
    case $1 in
	/usr/sbin/NetworkManager)
				vers=`NetworkManager --version`
				;;
	/usr/sbin/wicd)
				vers=`wicd -h | head -2 | tail -1`
				;;
	*)
    esac
    
    echo "$2 è installato (versione "$vers")" >> $log && _ok "$2"
    invoke-rc.d $1 status &>/dev/null
    if [ $? -eq 0 ]; then
      echo "$2 è in esecuzione" >> $log
    else
      echo "$2 non è in esecuzione" >> $log
    fi
  else
    echo "$2 non è installato" >> $log && _error "$2"
  fi
}

# --------------------------------------------------------------------------
# Funzioni utilizzate per tipo di problema (particolari)
# --------------------------------------------------------------------------

# 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
}

# esistenza di pacchetti contenenti firmware e firmware presente sulla macchina
function _firmware {
  local i var="Firmware"
  nome_e_riga "$var"
  dpkg -l | grep -i firmware >> $log && _ok "$var"
  echo "" >> $log

  # Elenca il contenuto dei file contenuti nelle directory specificate
  for i in "/usr/lib/firmware" "/usr/local/lib/firmware" "/lib/firmware" "/run/udev/firmware-missing"; do
    if [ -d $i ]; then
      echo "Contenuto di $i" >> $log
      ls -al $i >> $log
    else
      echo "$i non trovata" >> $log
    fi
    echo "" >> $log
  done
}

# Funzione che <<cerca>> di ricavare il nome e la versione del DE/WM utilizzato
function _de_wm {
  nome_e_riga "Desktop Environment - Window Manager"
  if false; then :
  elif [ -f /usr/bin/kde4-config -a "`pgrep ksmserver`" != "" ]; then kde4-config --version >> $log && _ok "DE/WM" || _error "DE/WM"; return # KDE 4
  else
    echo "Sconosciuto" >> $log && _error "DE/WM"
  fi
}

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

clear

_intro
_avvertenze
_check
_scelta
_upload
_compress

# Se il file di log esiste, stat_log=1
if [ -f $log ]; then
  stat_log=1
fi

_exit

Changelog

1.0.22
create funzioni _exit, _data, _common (output per tutti i tipi di problema),
_apt (problemi con i pacchetti), _mount (problemi di mount/umount), _de_wm
(cerca di stabilire il DE/WM) e _demone (esistenza e versione di un demone)
cancellate le funzioni _altro (rinominata in _common), _nm e _wicd (inglobate in _demone),
_syslog (inglobata in _file), _iwconfig e _iwlist (inglobate in _comando)
output per ricavare il DM da /etc/X11/default-display-manager
tolto l'array da _firmware e "resolvconf in _pack"
nome del log on base alla data corrente e variabile "utente" (nome utente != root)
Modificata _comando per contemplare il comando "su"
modifiche minori
S3v 15:50, 22 nov 2013 (CET)
1.0.21
Modificata la funzione _file: essid e psk presenti in /etc/network/interfaces non vengono più riportati nel log
Metaldaze 18:34, 1 nov 2013 (CET)
1.0.20
Creata la funzione _pack per inviare al log i pacchetti installati in base ad una parola
Rimossa _dhcp, la sua funzione è stata inglobata in _pack
Invio al log dei pacchetti nVidia attraverso _pack
Invio al log dei pacchetti nouveau attraverso _pack
Invio al log dei pacchetti mesa attraverso _pack
S3v 20:01, 5 ott 2013 (CEST)
1.0.19
Funzione _dir - contemplato il caso di directory inesistente
S3v 14:42, 4 ott 2013 (CEST)
1.0.18
Creata la funzione _dir che invia al log il contenuto dei file di una directory
Modificate le funzioni _ok e _error per consentire lunghezze dell'output maggiori
Aggiunto in output il contenuto di xorg.conf, xorg.conf.d/ e sources.list.d/
S3v 13:59, 4 ott 2013 (CEST)
1.0.17
Aggiunta la funzione _video - Problemi video
S3v 13:31, 3 ott 2013 (CEST)
1.0.16
Aggiunta directory /run/udev/firmware-missing alla funzione _firmware
S3v 17:25, 26 ago 2013 (CEST)
1.0.15
Tolta la funzione _spazi (inutilizzata)
Soppresso l'output di errore di pastebinit
Modificate _iwconfig e _iwlist per mostrare ESSID=off/any
S3v 11:34, 21 giu 2013 (CEST)
1.0.14
Voce del menù per la risoluzione dei problemi di rete (funzione _rete)
Creata funzione _altro
_resolvconf inglobata in _comando
Introdotto il comando dmesg per filtrare errori e warning separatamente
S3v 20:49, 7 giu 2013 (CEST)
1.0.13
Reinserita la funzione _syslog per prelevare l'ultimo output utile solo da syslog o, eventualmente,
da syslog.1 e syslog
S3v 16:07, 1 giu 2013 (CEST)
1.0.12
Inserito il path di default
Sostituito il comando cat con echo nei messaggi a video
Inserito un menù di scelta e rimosso l'array delle funzioni
Inserite due funzioni per inviare al log un file o un output generico
lspci -knn
Rimossa _dmesg (l'ouput è fornito da syslog)
S3v 15:25, 23 mag 2013 (CEST)
1.0.11
Modificata la funzione _wicd
S3v 00:57, 15 mag 2013 (CEST)
1.0.10
Tolta la funzione iptables per motivi di sicurezza
Impostata una maschera di default per i file creati dallo script
Modifiche minori
S3v 11:19, 14 mag 2013 (CEST)
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