Guide@Debianizzati.Org

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

Pagina Discussione

Creazione automatica di un file di log per inviare quesiti al forum (visualizza wikitesto)

Versione delle 08:22, 17 ott 2021

47 616 byte aggiunti ,  17 ott 2021
m
versione 1.0.73 - correzione bug funzione _hide
(v1.0.1 + varie)
m (versione 1.0.73 - correzione bug funzione _hide)
 
(206 versioni intermedie di 6 utenti non mostrate)
Riga 1: Riga 1:
{{Versioni compatibili}}
<!--
NOTA DI COMMENTO RELATIVA A OGNI NUOVO RILASCIO DI DEBIAN:
 
* modificare il codename nella riga "#ifeq" sottostante con quello della nuova stable, dopo aver aggiornato questa guida.
* In caso contrario sarà mostrato un messaggio di avvertenza al posto del template "Versioni compatibili".
* Il codename *deve* essere scritto tutto minuscolo (per esempio: jessie).
* Modificare anche lo script in formato base64 in: https://guide.debianizzati.org/index.php/Aiuto:LogScript (leggere lì le istruzioni, basta lanciare un comando)
 
-->
{{#ifeq: {{Codename|stable|IN_TEMPLATE}} | bullseye |
  {{Versioni compatibili}} |
  {{Cautionbox | [[Guide@Debianizzati.Org:Passaggio_alla_stable_-_pagine_da_aggiornare | Script non ancora aggiornato]] in seguito al rilascio di Debian {{Codename|Stable}}, pertanto le informazioni restituite riguardo la provenienza dei pacchetti installati nel sistema potrebbero non essere accurate. }}
}} <br/>
 
== Introduzione ==
== Introduzione ==
Questo [[script]] permette la creazione di un file contenente informazioni utili che è possibile portare a conoscenza del [http://forum.debianizzati.org forum] per tentare di risolvere insieme i problemi più comuni di configurazione della propria rete.<br/>
Questo [[script]] permette la creazione di un file contenente informazioni utili che possono aiutare a comprendere meglio il proprio problema oppure che è possibile portare a conoscenza del [http://forum.debianizzati.org forum] per tentare di risolverlo insieme.<br/>
Le informazioni riguardano i seguenti tipi di problema:
* Connessioni di rete
* Video
* Avvio del sistema (boot)
* Audio (tramite lo script ALSA prelevabile [http://www.alsa-project.org/alsa-info.sh qui])
* Sottosistema di gestione dei pacchetti (APT)
* Mount/unmount di periferiche
* Touchpad
* Altro. Verranno inserite nel log solo informazioni generiche (già presenti nel log creato con tutte le tipologie di problema precedenti).
 
Lo script crea due file:
Lo script crea due file:
;log.txt:contiene le informazioni in formato testo
;log_''data'':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
;log_''data''.{xz,bz2,gz}:il file precedente ma in formato compresso. Può essere allegato ad una discussione sul forum


Attraverso lo script è anche possibile inviare direttamente il file a [http://paste.debian.net paste.debian.net]. In questo caso il file non può superare i 90K di grandezza e le informazioni saranno disponibili per una settimana.<br/>
Se si vuole, attraverso lo script è anche possibile inviare il file direttamente a [https://paste.debian.net paste.debian.net] per poterlo condividere pubblicamente, in questo caso il file non potrà superare la grandezza complessiva di 240K circa (diviso in parti della dimensione massima di 60K circa) e le informazioni saranno disponibili a chiunque per una settimana.<br/>
Per usufruire di questo servizio, è necessaria l'installazione del pacchetto <code>pastebinit</code>:
Prima di effettuare l'invio, lo script chiede un esplicito consenso all'utente.
<pre># apt-get install pastebinit</pre>


Per ogni informazione e/o suggerimento fare riferimento a [http://forum.debianizzati.org/viewtopic.php?f=13&t=45098 questa] discussione sul forum.
{{Box|Nota|Lo script è liberamente modificabile.<br/>Per ogni segnalazione, informazione o suggerimento fare riferimento a [http://forum.debianizzati.org/viewtopic.php?f{{=}}13&t{{=}}45098 questa] discussione sul forum.}}
 
== Pacchetti opzionali ==
Lo script utilizza alcuni comandi che potrebbero non essere installati di default sulla propria macchina. L'installazione di questi pacchetti è del tutto facoltativa e la loro assenza non pregiudica in alcun modo le funzionalità messe a disposizione dallo script.
;aptitude:Viene utilizzato per ricavare informazioni quali il gestore di sessione e i pacchetti non appartenenti alla [[release]] di Debian predefinita. Per installarlo:<pre># apt install aptitude</pre>
;pastebinit:Permette di usufruire del servizio offerto da paste.debian.net per la condivisione del testo. Per installarlo:<pre># apt install pastebinit</pre>
 
== Privacy dell'utente ==
Questo script raccoglie informazioni che potenzialmente potrebbero violare la privacy dell'utente che mette a disposizione '''pubblicamente''' il file di log generato (attraverso ''paste.debian.net'' oppure come allegato ad una discussione sul forum).
 
Il diritto alla privacy dell'utente che esegue lo script è sempre stato la priorità nel corso degli anni e molte informazioni personali sono già nascoste nel file di log generato. È però possibile che non tutto venga correttamente rilevato per sopravvenute modifiche all'output dei comandi o log di sistema o a personalizzazioni dell'utente.
 
Si raccomanda caldamente, prima di rendere pubblico il log, di leggere attentamente le informazioni raccolte dallo script; in particolare i messaggi dei log di sistema, i contenuti dei servizi di systemd (soprattutto se sono stati creati nuovi servizi o se si è provveduto a personalizzarne di esistenti) e il file ''/etc/fstab''.
 
Se si ravvisa la comparsa di informazioni sensibili, quali indirizzi IP pubblici, URL, nomi utente o di connessioni di rete, o comunque di qualunque dato ritenuto in violazione del proprio diritto alla privacy, non rendere pubblico il file di log raccolto e segnalare il problema nella [http://forum.debianizzati.org/viewtopic.php?f=13&t=45098 discussione apposita] o all'interno della pagina di discussione.


== Utilizzo ==
== Utilizzo ==
# Copiare il codice dello script in un file di testo. Il nome del file può essere scelto liberamente.
# Eseguire un upgrade del sistema, se possibile, in modo che le informazioni raccolte dallo script siano aggiornate.
# Dare i permessi di esecuzione al file appena creato. Supponendo che si chiami ''nomefile'':<pre>$ chmod +x nomefile</pre>
# Copiare manualmente il codice dello script in un file di testo all'interno di una directory a propria scelta. Il nome del file può essere scelto liberamente, ad esempio <code>scriptlog-debianizzati.org</code>. <br/> E assegnare i permessi di esecuzione al file appena creato; ad esempio, da terminale o emulatore di terminale:<pre>$ chmod a+x scriptlog-debianizzati.org</pre>'''In alternativa''', se si preferisce, è possibile eseguire il seguente comando:<pre>wget -qO- "http://guide.debianizzati.org/index.php?title=Aiuto:LogScript&action=edit"|awk '/=S=/{while(getline&&!index($0,"=F"))print}'|base64 -d|tar xz</pre>con cui verrà creato il file "scriptlog-debianizzati.org" all'interno della directory da cui è stato eseguito il precedente comando. In questo caso vengono automaticamente impostati i permessi di esecuzione per lo script.
# Eseguire lo script con i permessi di [[root]]:<pre># ./nomescript</pre>il comando precedente presuppone che sia eseguito nella stessa directory in cui risiede lo script.<br/>L'esecuzione con i permessi di root si rende necessaria poiché alcuni comandi devono essere eseguiti necessariamente come utente privilegiato.
# Eseguire da terminale (o emulatore di terminale) lo script con [[privilegi di amministrazione]]:<pre># ./scriptlog-debianizzati.org</pre>il comando precedente deve essere eseguito nella stessa directory in cui risiede lo script.<br/>L'utilizzo dei permessi di root è motivato dal fatto che alcuni comandi devono essere eseguiti necessariamente come utente privilegiato.
# Leggere le informazioni a video.
# Leggere le informazioni a video.


== Parametri dello script ==
Lo script accetta, in maniera facoltativa, alcuni parametri:
;--tipo={rete|video|boot|audio|apt|mount|touchpad|generico}:specifica il tipo di problema
;--nocompress:non crea il file compresso del file di log
;--nopaste:non invia il file di log a paste.debian.net
;--update:aggiorna lo script se esiste una versione recente
;--base64:crea un file contenente la codifica base64 dello script
;--debug:crea un file contenente le informazioni utili per il debug dello script
;--versione:visualizza la versione dello script
;--help:visualizza informazioni sull'utilizzo dei parametri
'''Esempi:'''
<pre>
# ./scriptlog-debianizzati.org --tipo=rete
# ./scriptlog-debianizzati.org --tipo=apt --nocompress --nopaste
# ./scriptlog-debianizzati.org --versione
# ./scriptlog-debianizzati.org --help
</pre>
<!-- commento (leggibile per chi modifica la pagina)
*IMPORTANTE*
Se si modifica lo script è *necessario* seguire le istruzioni alla pagina:
https://guide.debianizzati.org/index.php/Aiuto:LogScript
in modo da aggiornare l'archivio in formato Base64
-->
== Script ==
== Script ==
<pre>
<syntaxhighlight lang="bash">
#!/bin/bash
#! /bin/bash
 
# --------------------------------------------------------------------------
# Impostazioni
# --------------------------------------------------------------------------
 
# I file creati saranno leggibili e scrivibili da tutti
umask 0011
 
# Intercettazione Ctrl+C
trap _exit INT
 
# Abilitazione dell'opzione 'extdebug' necessaria per espandere ARGC in
# Bash 5 e versioni successive
shopt -s extdebug
 
# --------------------------------------------------------------------------
# Funzioni che sovrascrivono comandi
# --------------------------------------------------------------------------
 
# Rimpiazza echo ed echo -n, impedendo echo -e e le possibili combinazioni
# Sintassi accettata:
#  echo -n "testo"  # stampa senza a capo finale
#  echo "testo"    # stampa con a capo finale
#  echo            # stampa una riga vuota
function echo {
  if [ $# -gt 1 ] && [ "$1" = "-n" ]; then
    shift
    printf %s "$*"
  else
    printf %s\\n "$*"
  fi
}
 
# Sostituisce il comando 'cat' per controllare che al file di log
# venga inviato effettivamente il contenuto di un file di testo
function cat {
  if [ "$(file -bL $1)" = 'ASCII text' ]; then
    /bin/cat -- "$1"
  else
    echo "File non di testo"
  fi
}
 
# --------------------------------------------------------------------------
# Costanti
# --------------------------------------------------------------------------
 
# Versione script
readonly VERSIONE="1.0.73"
 
# Path e nome dello script
readonly PATH_NAME="$(readlink -f "${BASH_SOURCE[0]}")"
 
# Codename per oldoldstable, oldstable, stable e testing.
# Da modificare nei successivi rilasci di Debian
readonly OLDOLDSTABLE="stretch"
readonly OLDSTABLE="buster"
readonly STABLE="bullseye"
readonly TESTING="bookworm"
 
# Path dei comandi dello script
readonly PATH="/bin:/sbin:/usr/bin:/usr/sbin"
 
# Nome del file di log in base alla data corrente
readonly log="log_$(date '+%d%b_%H%M%S')"
 
# Nome del file di debug
readonly script_debug="/tmp/script_debug_$(date '+%d%b_%H%M%S')"
 
# File descriptor per il debug
FD=9
 
# URL remoto della pagina contenente lo script
readonly SCRIPTURL="http://guide.debianizzati.org/index.php?title=Creazione_automatica_di_un_file_di_log_per_inviare_quesiti_al_forum&action=edit"
 
# URL remoto della pagina contenente lo script codificato in base64
readonly SCRIPTURL_BASE64="http://guide.debianizzati.org/index.php?title=Aiuto:LogScript&action=edit"
 
# nome utente
utente=$(logname) &&
[ "$utente" != "root" ] || {
  # NOTA: "root" è permesso (solo) se scelto esplicitamente dall'utente
  tmputente2=$(getent passwd 1000 2> /dev/null | cut -d ":" -f 1) ||
      tmputente2=""
  echo -n "Inserisci il tuo nome utente"
  if [ -n "$tmputente2" ]; then
      echo -n " (lascia vuoto per \"$tmputente2\"): "
  else
      echo -n ": "
  fi
  read tmputente &&
  tmputente=${tmputente:-$tmputente2} &&
  # non può contenere: spazi, tabulazioni, nuove righe; né essere vuota
  [ -n "${tmputente##*[[:space:]]*}" ] &&
  # deve esistere in /etc/passwd (o equivalente)
  getent passwd "$tmputente" > /dev/null 2>&1 || {
    echo "Nome utente non valido o non esistente!" >&2
    exit 255
  }
  utente=$tmputente
  unset tmputente
  unset tmputente2
}
readonly utente
 
# nome host
readonly nomehost=$(hostname)
 
# Codici stile carattere
readonly ROSSO="\033[01;31m" # colore rosso e grassetto
readonly VERDE="\033[01;32m" # colore verde e grassetto
readonly BOLD="\033[01m"        # grassetto
readonly FINE="\033[0m"        # reset
 
# variabile che vale 1 se systemd è installato
[ "$(ps -o comm= -p 1)" = "systemd" ] && systemd=1 || systemd=0
readonly systemd
 
# --------------------------------------------------------------------------
# Sezione relativa ai parametri dello script
# --------------------------------------------------------------------------
 
# Funzione che segnala un errato utilizzo dei parametri e termina lo script
function _parm_err {
  echo "Parametri non validi" && _parm_uso
}
 
# Messaggio di errore se viene specificato più di un tipo di problema attraverso
# i parametri.
function _parm_tipo_err {
  echo "È possibile specificare un solo di tipo di problema" && _parm_uso
}
 
# Messaggio visualizzato nel caso in cui venga specificato lo stesso parametro
function _parm_rip_err {
  echo "È stato immesso lo stesso parametro" && _parm_uso
}
 
# Messaggio visualizzato nel caso in cui --help non sia l'unico parametro specificato
function _parm_uso_err {
  echo "Il parametro $1 non deve essere accompagnato da altri parametri" && _parm_uso
}
 
# Funzione che stampa informazioni sull'utilizzo dei parametri
function _parm_uso {
  printf %b "
Utilizzo dei parametri:
 
$BOLD--tipo={rete|video|boot|audio|apt|mount|touchpad|generico}$FINE
  utilizzato per specificare un solo tipo di problema.
  Es: --tipo=apt
 
$BOLD--nocompress$FINE
  non viene creato un file compresso del log
 
$BOLD--nopaste$FINE
  non viene inviato il log a paste.debian.net
 
$BOLD--update$FINE
  viene aggiornato lo script se è disponibile una nuova versione
 
$BOLD--base64$FINE
  viene creato un file con la codifica base64 dello script
 
$BOLD--debug$FINE
  crea un file contenente le informazioni utili per il debug dello script
 
$BOLD--versione$FINE
  visualizza la versione dello script in esecuzione
 
$BOLD--help$FINE
  visualizza queste informazioni
 
"  && exit
}
 
# Visualizza la versione corrente dello script
function _showvers {
  echo "$VERSIONE" && exit
}
 
# Inizializzazione di variabili. La variabile TIPO serve ad evitare ripetizioni
# nel passaggio del parametro tipo=blabla
NOCOMPRESS=0 NOPASTE=0 TIPO=0 TIPO_RETE=0 TIPO_APT=0 TIPO_VIDEO=0 TIPO_BOOT=0
TIPO_AUDIO=0 TIPO_MNT=0 TIPO_TOUCH=0 TIPO_COMM=0 UPDATE=0 BASE64=0
DEBUG=0
 
while [ $# -gt 0 ] ; do
  case "$1" in
    "--base64") [ "${BASH_ARGC[@]}" -gt 1 ] && _parm_uso_err "$1" || BASE64=1 ;;
    "--update") [ "${BASH_ARGC[@]}" -gt 1 ] && _parm_uso_err "$1" || UPDATE=1 ;;
    "--nocompress") [ "$NOCOMPRESS" -eq 1 ] && _parm_rip_err || NOCOMPRESS=1      ;;
    "--nopaste") [ "$NOPASTE" -eq 1 ] && _parm_rip_err || NOPASTE=1       ;;
    "--tipo=rete") [ "$TIPO" -eq 1 ] && _parm_tipo_err || TIPO=1 && TIPO_RETE=1  ;;
    "--tipo=apt") [ "$TIPO" -eq 1 ] && _parm_tipo_err || TIPO=1 && TIPO_APT=1  ;;
    "--tipo=video") [ "$TIPO" -eq 1 ] && _parm_tipo_err || TIPO=1 && TIPO_VIDEO=1 ;;
    "--tipo=boot") [ "$TIPO" -eq 1 ] && _parm_tipo_err || TIPO=1 && TIPO_BOOT=1  ;;
    "--tipo=audio") [ "$TIPO" -eq 1 ] && _parm_tipo_err || TIPO=1 && TIPO_AUDIO=1 ;;
    "--tipo=mount") [ "$TIPO" -eq 1 ] && _parm_tipo_err || TIPO=1 && TIPO_MNT=1  ;;
    "--tipo=touchpad") [ "$TIPO" -eq 1 ] && _parm_tipo_err || TIPO=1 && TIPO_TOUCH=1 ;;
    "--tipo=generico") [ "$TIPO" -eq 1 ] && _parm_tipo_err || TIPO=1 && TIPO_COMM=1  ;;
    "--debug") [ "${BASH_ARGC[@]}" -gt 1 ] && _parm_uso_err "$1" || DEBUG=1  ;;
    "--versione") [ "${BASH_ARGC[@]}" -gt 1 ] && _parm_uso_err "$1" || _showvers ;;
    "--help") [ "${BASH_ARGC[@]}" -gt 1 ] && _parm_uso_err "$1" || _parm_uso ;;
    *) _parm_err
  esac
  shift
done
 
# --------------------------------------------------------------------------
# Debug
# --------------------------------------------------------------------------
function _debug {
  [ "$DEBUG" -eq 1 ] && [ ! -e /proc/$$/fd/"$FD" ] &&
    {
    exec {FD}>"$script_debug"
    export BASH_XTRACEFD="$FD"
    set -x
    }
}


# Nome del file di log
function _close_debug {
log="log.txt"
  set +x
  exec {FD}>&-
}


# --------------------------------------------------------------------------
# --------------------------------------------------------------------------
Riga 31: Riga 321:
# Funzione che stampa il messaggio introduttivo
# Funzione che stampa il messaggio introduttivo
function _intro {
function _intro {
  echo "*********************************************************************************"
  echo "
echo "*  www.debianizzati.org                                                        *"
*********************************************************************************
echo "*                                                                              *"
*  www.debianizzati.org                                                        *
echo "*  Script che crea un log utile alla risoluzione di problemi relativi alla rete *"
*                                                                              *
echo "*  Versione 1.0.1                                                              *"
*  Script che crea un log utile alla risoluzione dei problemi più comuni        *
echo "*                                                                              *"
*  Versione $VERSIONE                                                              *
echo "*********************************************************************************"
*                                                                              *
*********************************************************************************"
}
}


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


# Funzione che esegue un check preliminare
# Funzione che esegue un check preliminare
function _check {
function _check {
if [[ $EUID -ne 0 ]]; then # Lo script viene lanciato da root?
  if [ $EUID -ne 0 ]; then # Lo script viene lanciato da root?
echo "Lo script deve essere lanciato da root"
    echo "Lo script deve essere lanciato da root" && _exit
  exit 1
  fi
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" ] || [ -f "${log}.xz" ] || [ -f "${log}.bz2" ] || [ -f "${log}.gz" ]; then
    echo $'\n'"Esiste già un file ${log}, ${log}.xz, ${log}.bz2 o ${log}.gz nella directory corrente."
    echo -n "Sovrascivere [S/n]? "
    read risp
    case "$risp" in
      ""|[Ss]) rm -f -- "$log" "${log}.xz" "${log}.bz2" "${log}.gz" > /dev/null 2>&1 ;;
      *)      exit 1
    esac
  fi
}
 
# --------------------------------------------------------------------------
# Funzioni per l'invio del log a paste.debian.net
# --------------------------------------------------------------------------
 
# Funzione per separare il log in parti per l'invio a paste.debian.net
function _split_and_send { 
  local paste_url='https://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'
 
  # termina la funzione se il log è più grande di chunk_size x 4 (numero di parti impostate)
  if [ "$(du -k "$log" | cut -f1)" -gt 240 ]; then
    echo "Log troppo grande per essere inviato a paste.debian.net"
    echo "Allegare il file compresso alla discussione sul forum."
    return 1
  fi
  # 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')/" "$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=$(find . -maxdepth 1 -type f -name "${chunk_prefix}.*" -printf x |
              wc -c)
  if [ "$chunk_num" = 1 ]; then
      echo $'\nIl log sarà inviato in un singolo file.'
  else
      echo $'\n'"Il log sarà inviato in ${chunk_num} parti."
  fi
  # invia al massimo 4 parti
  echo $'\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


# Se esiste già un file di log con lo stesso nome oppure
    # invia dati tramite pastebinit, l'output d'errore viene soppresso
# file compressi con lo stesso nome di quelli che verranno
    pastelink=$(pastebinit -a '' -b "$paste_url" -i "$chunkfile" 2>/dev/null)
# creati, lo script chiede se cancellarli o meno
   
local risp
      if [ $? = 0 ]; then
if [ -f ./log.txt -o -f ./log.zip -o -f ./log.txt.bz2 -o -f ./log.tgz ]; then
  # invio apparentemente riuscito (pastebinit exit status = 0)
echo -n "Esiste già un file log.txt, log.zip, log.txt.bz2 o log.tgz nella directory corrente. Sovrascivere [S/n]? "
     
  read risp
  # controlla URL restituita da pastebinit
  case $risp in
  case "$pastelink" in
  ""|[Ss])
  # verifica in caso di URL corretta
      rm -f $log log.zip log.txt.bz2 log.tgz
  "$paste_url"/[0-9]*)
      ;;
      echo ".. inviato ${chunkfile} all'indirizzo ${pastelink}"
  *)
      ;;
      exit 1
  # verifica in caso di URL non corretta
      ;;
  *)
  esac
      echo ".. ${paste_url} ha restituito una URL non valida (${pastelink}) per ${chunkfile}!"
fi
      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 le parti di log inviate
  for chunkfile in "./${chunk_prefix}."[0-9]*; do
    if [ -f "$chunkfile" ]; then
      rm -f -- "$chunkfile"
    fi
  done
   
  return $paste_exit_status
}
}


# --------------------------------------------------------------------------
# Funzione che invia il log a paste.debian.net
# Funzione che invia il log a paste.debian.net
# --------------------------------------------------------------------------
function _upload {
function _upload {
local pastelink
  # Nessun invio a paste.debian.net se viene scelto "--nopaste"
local risp
  [ "$NOPASTE" -eq 1 ] && return
# Pastebinit è installato?
 
if [ ! -f /usr/bin/pastebinit ]; then
  local risp
  echo -e "\nNon è possibile inviare il log a paste.debian.net\nIl pacchetto 'pastebinit' non è installato."
  # Pastebinit è installato?
  return 1
  if [ ! -f /usr/bin/pastebinit ]; then
fi
    echo $'\nNon è possibile inviare il log a paste.debian.net\nIl pacchetto "pastebinit" non è installato.'
# Invia il file log.txt a paste.debian.net
    return 1
echo -en "\nInviare il log a paste.debian.net [S/n]? "
  fi
read risp
  # Invia il file log.txt a paste.debian.net
case $risp in
  echo -n $'\nInviare il log a http://paste.debian.net [S/n]? '
  ""|[Ss])
  read risp
      # Questa variabile conterrà il link
  case "$risp" in
      pastelink="$(pastebinit -a "" -b http://paste.debian.net -i $log)"
    ""|[Ss])
      echo "Il log è visibile all'indirizzo '$pastelink'"
      _split_and_send
      ;;
      if [ $? = 0 ]; then
  *)
        echo $'\nIl log è stato inviato'
      ;;
      else
esac
        echo $'\nSi sono verificati errori nell\'invio del log!'
      fi
      ;;
    *)
      echo "Il log non è stato inviato"
  esac
}
}


# --------------------------------------------------------------------------
# --------------------------------------------------------------------------
Riga 117: Riga 484:
# --------------------------------------------------------------------------
# --------------------------------------------------------------------------


# Funzione richiamata in caso di corretta creazione del file compresso
# Funzioni richiamate in caso di corretta/scorretta creazione del file compresso
function _compress_ok {
function _compress_ok { echo "File compresso creato correttamente nella directory corrente."; }
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 "Errore nella creazione del file compresso."; }
function _compress_err {
echo -e "\nErrore nella creazione del file compresso $1."
}


# Funzione che crea il file compresso
# Funzione che crea il file compresso
# Prova a creare nell'ordine: un file .bz2, un file .zip o un file .tgz
# Prova a creare nell'ordine: un file .xz, un file .bz2 o un file .gz
function _compress {
function _compress {
local risp
  # La funzione termina se è stato utilizzato il parametro "--nocompress"
echo -en "\nCreare un file compresso [S/n]? "
  [ "$NOCOMPRESS" -eq 1 ] && return
read risp
 
case $risp in
  local risp
  ""|[Ss])
  echo -n $'\nCreare un file compresso [S/n]? '
      echo -e "\nSta per essere creato un file compresso..."
  read risp
      sleep 2
  case "$risp" in
      if [ -f /bin/bzip2 ]; then
    ""|[Ss])
         bzip2 -k9 $log && _compress_ok log.txt.bz2 || _compress_err log.txt.bz2
      echo "Sta per essere creato un file compresso..."
      elif [ -f /usr/bin/zip ]; then
      sleep 1
         zip log.zip $log && _compress_ok log.zip || _compress_err log.zip
      if [ "$(command -v xz)" ]; then
      else
         xz -e < "$log" > "${log}.xz" && _compress_ok || _compress_err
      tar czf log.tgz $log && _compress_ok log.tgz || _compress_err log.tgz
      elif [ "$(command -v bzip2)" ]; then
      fi
         bzip2 -9 < "$log" > "${log}.bz2" && _compress_ok || _compress_err
      ;;
      elif [ "$(command -v gzip)" ]; then
  *)
        gzip -9 < "$log" > "${log}.gz" && _compress_ok || _compress_err
      ;;
      else
esac
        echo "Impossibile effettuare la compressione!" >&2
      fi
      ;;
    *)
      echo "Non è stato creato un file compresso."
  esac
}
}


# --------------------------------------------------------------------------
# Funzione di stampa menù e selezione del problema
# --------------------------------------------------------------------------
function _scelta {
  # Problemi selezionati in base al parametro passato allo script
  [ "$TIPO_RETE"  -eq 1 ] && _wait && _header "rete"          && _rete  && return
  [ "$TIPO_VIDEO" -eq 1 ] && _wait && _header "video"          && _video  && return
  [ "$TIPO_BOOT"  -eq 1 ] && _wait && _header "boot"          && _boot  && return
  [ "$TIPO_AUDIO" -eq 1 ] && _wait && _header "audio"          && _audio  && return
  [ "$TIPO_APT"  -eq 1 ] && _wait && _header "APT"            && _apt    && return
  [ "$TIPO_MNT"  -eq 1 ] && _wait && _header "mount-unmount"  && _mount  && return
  [ "$TIPO_TOUCH" -eq 1 ] && _wait && _header "touchpad"      && _tpad  && return
  [ "$TIPO_COMM"  -eq 1 ] && _wait && _header "generico"      && _common && return
 
  # La funzione presenta un menù di scelta nel caso non sia stato passato alcun parametro
  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 boot
[4] Problemi audio
[5] Problemi di gestione dei pacchetti (APT)
[6] Problemi di mount/unmount
[7] Problemi di funzionamento del touchpad
[8] Altro tipo di problema
[0] Uscita"
  while true; do
    echo -n "Scegliere il numero corrispondente: "
    read num
    case "$num" in
        [1-8]) _wait  ;;& # ;;& -> va alla successiva occorrenza del carattere immesso
            1) _header "rete"          && _rete  ;;&
            2) _header "video"        && _video  ;;&
            3) _header "boot"          && _boot  ;;&
            4) _header "audio"        && _audio  ;;&
            5) _header "APT"          && _apt    ;;&
            6) _header "mount-unmount" && _mount  ;;&
            7) _header "touchpad"      && _tpad  ;;&
            8) _header "generico"      && _common ;;&
        [1-8]) break  ;; # Termina il ciclo 'while'
            0) _exit  ;; # È stato inserito '0' . Uscita dallo script
            *) # Tutti gli altri caratteri. Cancella l'input immesso e ripete la domanda
tput cuu1 # in alto di una riga
tput ed # cancella fino alla fine dello schermo
    esac
  done
}


# --------------------------------------------------------------------------
# --------------------------------------------------------------------------
Riga 158: Riga 576:
# --------------------------------------------------------------------------
# --------------------------------------------------------------------------


# Funzione che stampa due righe vuote
# Funzione che stampa solo parentesi e il nome del comando, prima di eseguirlo
function _spazi {
function _prompt {
  echo >> $log
  echo -n "[ ] $*"
  echo >> $log
}
 
# Funzione che stampa un pallino colorato in base al primo parametro
function _printdot {
  echo
  tput cuu1  # in alto di una riga
  tput cuf1 # a destra di uno spazio
  printf %b "$1•${FINE}\n" # stampa pallino e va a capo
}
}


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


# Funzione che stampa una pallino rosso in caso di comando privo di output
# Funzione che stampa una pallino rosso in caso di comando privo di output
function _error {
function _error { _printdot "${ROSSO}"; }
/bin/echo -e " $1" "\033[35G\033[01;31m•\033[0m"
 
# Funzione che stampa in grassetto gli argomenti
function _bold {
  printf %b "${BOLD}"
  echo -n "$*"
  printf %b\\n "${FINE}"
}
}


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


# Funzione che stampa un messaggio di attesa e aspetta 2 secondi
# Funzione che stampa un messaggio di attesa
function _wait {
function _wait {
echo -e "\nCreazione del log in corso. Attendere pochi secondi...\n"
  echo $'\nCreazione del log in corso...\n'
  sleep 2
}
 
# Intestazione del file di log
function _header {
echo "Tipo di problema: $1" >> "$log"
_data
  _lastupd
echo "Versione script: $VERSIONE" >> "$log"
}
 
# Stampa la data corrente nel file di log
function _data {
  echo "Log creato il: $(date '+%d %B %Y alle %H.%M')" >> "$log"
}
 
# Quota i caratteri specificati per le parole da nascondere con sed
# Es: abc.def -> abc\.def
function _sed_quote {
  # array di caratteri da quotare
  local quotearr=("." "/")
 
  local retstr="$1"
  for char in "${quotearr[@]}"; do
    retstr="${retstr//$char/\\$char}"
  done
  echo "$retstr"
}
}


# Funzione che nasconde nel log alcune informazioni sensibili
function _hide {


# --------------------------------------------------------------------------
# Sostituisce il nome utente e il nome host con 'nomeutente' e 'nomehost' se diversi da [dD]ebian
# Array che contiene la lista delle funzioni
# Inoltre non sostituisce l'utente "root", in quanto l'informazione potrebbe essere rilevante
# --------------------------------------------------------------------------
if [ "$utente" != "Debian" ] && [ "$utente" != "debian" ] && [ "$utente" != "root" ]; then
  sed -i -e "s/\\b${utente}\\b/*nomeutente*/g" "$log"
fi
if [ "$nomehost" != "Debian" ] && [ "$nomehost" != "debian" ]; then
  sed -i -e "s/\\b${nomehost}\\b/*nomehost*/g" "$log"
fi


# Questo array contiene tutte le funzioni utilizzate per il log
# Nasconde gli ESSID gestiti attraverso Network Manager
# dei comandi.
local var file mydir="/etc/NetworkManager/system-connections/"
# Per aggiungere una nuova funzione, inserire qui il suo nome e
# scriverne il codice in basso.


comandi=(
if [ -d "$mydir" ]; then # se esiste la directory /etc/NetworkManager/system-connections/ ...
_unamea
    for file in "$mydir"/*; do # ciclo attraverso il contenuto della directory
_version
      if [ -f "$file" ]; then # se l'elemento è un file...
_sources
          var=$(sed -n "s/ssid=//p" "$file") # ... var conterrà l'eventuale ESSID...
_lspci
          if [ -n "$var" ]; then # ... e se è diverso dalla stringa vuota...
_lsusb
            sed -i "s/${var}/\*script-removed\*/g" "$log" # ... lo nasconde nel file di log
_interfaces
          fi
_hosts
      fi
_ifconfig
    done
_ping
fi
_ip
_iwconfig
_iwlist
_route
_resolvconf
_resolvconf2
_firmware
_dhcp
_dhclient
_nm
_wicd
_lsmod
_iptables
_dmesg
)


# Nasconde nel log i nomi delle connessioni gestite da NetworkManager
sed -i -r "s/(NetworkManager.*keyfile.*((parsing)|(read connection))).*/\1 \*script-removed\*/" "$log"
sed -i -r "s/(NetworkManager.*keyfile: new connection.*system-connections\/)(.*)( \(.*,\").*(\"\))/\1\*script-removed\*\3\*script-removed\*\4/g" "$log"
sed -i -r "s/(NetworkManager.*policy: auto-activating connection ').*(')/\1\*script-removed\*\2/g" "$log"
sed -i -r "s/(NetworkManager.*Activation: starting connection ').*(')/\1\*script-removed\*\2/g" "$log"
sed -i -r "s/(NetworkManager.*policy: set ').*(')/\1\*script-removed\*\2/g" "$log"


# --------------------------------------------------------------------------
# Nasconde l'indirizzo MAC delle interfacce wireless
# Funzioni contenute nell'array
local interfaces macaddress line
# --------------------------------------------------------------------------
if [ -f /proc/net/wireless ]; then
  # array che contiene i nomi delle interfacce wireless
  mapfile -s 2 interfaces < <(awk -F'[: ]+' '{ print $2 }' /proc/net/wireless)


# comando 'uname -a'
  for i in "${interfaces[@]}"; do
function _unamea {
    # indirizzo MAC dell'interfaccia solo se questa ne ha uno
local var="uname -a"
    line="$(ip -br link show $i)"
nome_e_riga "$var"
    if [ "$(echo $line | wc -w)" -gt 3 ]; then
if [ -x /bin/uname ]; then
      macaddress="$(awk '{ print $3 }' <<< $line)"
  uname -a &>> $log && _ok "$var" || _error "$var"
      macaddress="$(_sed_quote $macaddress)"
else
      # l'indirizzo MAC viene nascosto nel file
  echo "Il comando uname non esiste" >> $log && _error "$var"
      sed -i 's/'$macaddress'/\*script-removed\*/g' "$log"
    fi
  done
  fi
  fi
}
}


# comando 'cat /etc/debian/version'
# Invia al log l'output del comando passato come primo parametro e
function _version {
# con i permessi utente
local var="/etc/debian_version"
function _su {
nome_e_riga "$var"
  echo "$(su -c "$1" $utente)" >> "$log"
if [ -f /etc/debian_version ]; then
}
   cat /etc/debian_version &>> $log && _ok "$var" || _error "$var"
 
  else
# Stabilisce la data dell'ultimo aggiornamento effettuato. Viene preso in
   echo "Il file /etc/debian_version non esiste" >> $log && _error "$var"
# considerazione il file /var/log/apt/history.log oppure il file /var/log/apt/history.log.1.gz
fi
function _lastupd {
  local convdate lastdate file=/var/log/apt/history.log
 
  if [ -f "$file" ]; then
    lastdate=$(sed -n '/^Start-Date/h ; $p' "$file" | cut -d ' ' -f 2)
    # se il file history.log non contiene la data dell'ultimo aggiornamento, viene utilizzato history.log.1.gz
    [ -z "$lastdate" ] && [ -f "${file}.1.gz" ] && lastdate=$(zcat "${file}.1.gz" | sed -n '/^Start-Date/h ; $p' | cut -d ' ' -f 2)
 
    # variabile che contiene la data in formato "giorno mese anno"
    convdate=$(date -d "$lastdate" '+%d %B %Y')
   
    echo $"Ultimo aggiornamento del sistema: ${convdate}" >> "$log"
  fi
}
 
# Funzione che effettua l'aggiornamento automatico dello script
function _self_update {
 
  echo -n "Aggiornare questo script [S/n]? "
  local risp
  read risp
  [ "$risp" != "" ] && [ "$risp" != "s" ] && [ "$risp" != "S" ] && _exit || echo "Aggiornamento in corso..."
 
  # Controlla l'esistenza di wget
  [ ! "$(command -v wget)" ] && echo "Impossibile eseguire l'aggiornamento. Installare il pacchetto wget." && _exit
 
  # Ricava la versione remota dello script
  local vers="$(wget -q -O- "$SCRIPTURL" | sed -n '/^readonly VERSIONE.*/{p;q}' | cut -d '"' -f2)"
  if [ "$vers" = "" ]; then
    echo "Connessione non riuscita" && _exit
  fi
 
  if [ "$vers" = "$VERSIONE" ]; then
    echo "Lo script è gia alla versione più recente"
   else
    echo -n "È disponibile una nuova versione dello script: " && _bold "$vers"
    echo -n "Procedere con l'aggiornamento [S/n]? "
    read risp
    case "$risp" in
      [Ss]|"")
          local tempfile="$(mktemp)" # viene creato un file temporaneo
          # lo script in formato base64 viene copiato nel file temporaneo
          wget -q -O- "$SCRIPTURL_BASE64" | sed -n "/^=S=/{n; :a /^==Fine/ ! {p; n; ba}}" | base64 -d | tar xz -O > "$tempfile"
          if [ ! -s "$tempfile" ]; then # Controlla se il file è vuoto
            echo "Connessione non riuscita"
          else
            cp "$tempfile" "$PATH_NAME"
            [ $? -eq 0 ] && echo "Aggiornamento effettuato" || echo "Aggiornamento fallito"
            #rm -f "$tempfile" # Rimuove il file temporaneo
          fi ;;
      *)
          echo "Non è stato eseguito alcun aggiornamento"
    esac
  fi
}
 
# funzione che crea un file con la codifica base64 dello script
# Da utilizzare in caso di aggiornamenti per modificare la pagina
# http://guide.debianizzati.org/index.php/Aiuto:LogScript
function _base64 {
   
   echo -n "Verrà creato un file con la codifica base64 di questo script. Continuare [S/n]? "
  local risp
  read risp
  [ "$risp" != "" ] && [ "$risp" != "s" ] && [ "$risp" != "S" ] && _exit ||
    local tempfile="$(mktemp)" # crea un file temporaneo
    tar cf - "${BASH_SOURCE[0]}" | gzip -9 | base64 > "$tempfile"
    if [ $? -eq 0 ]; then
      echo -n "Il file contenente la codifica base64 di questo script è " && _bold "$tempfile"
    else
      echo "Codifica non riuscita"
    fi
    # Modifica i permessi del file in modo che possa essere letto da tutti
    chmod 444 "$tempfile"
}
}


# comando 'dmesg'
# Funzione che stampa un messaggio che indica i file creati e poi termina lo script
function _dmesg {
function _exit {
local var="dmesg"
 
nome_e_riga "$var"
# se è stato effettuato un update o una codifica base64, stampa solo il messaggio finale
if [ -x /bin/dmesg ]; then
  if [ "$UPDATE" -eq 0 ] && [ "$BASE64" -eq 0 ]; then
  dmesg &>> $log && _ok "$var" || _error "$var"
    local complog=""
  else
 
  echo "Il comando $var non esiste" >> $log && _error "$var"
    if [ -f "$log" ]; then
fi
      echo -n $'\nFile contenente il log dello script: '
      _bold "$log"
    else
      echo $'\nNon è stato creato un file di log'
    fi
 
    if [ -f "${log}.xz" ]; then
      complog="${log}.xz"
    elif [ -f "${log}.bz2" ]; then
      complog="${log}.bz2"
    elif [ -f "${log}.gz" ]; then
      complog="${log}.gz"
    fi
 
    if [ -z "$complog" ]; then  
      echo "Non è stato creato un file compresso del log"
    else
      echo -n "File compresso da allegare alla discussione sul forum: "
      _bold "$complog"
    fi
 
    if [ -f "$script_debug" ]; then
      echo -n "File contenente l'output di debug: "
      _bold "$script_debug"
    fi
  fi
 
  echo $'Script terminato\n'
  _close_debug
 
  exit 0
}
}


# comando 'lsmod'
# --------------------------------------------------------------------------
function _lsmod {
# Funzioni relative a ciascun problema selezionato
local var="lsmod"
# --------------------------------------------------------------------------
nome_e_riga "$var"
 
if [ -x /bin/lsmod ]; then
# Informazioni comuni a tutti i tipi di problema
   lsmod &>> $log && _ok "$var" || _error "$var"
function _common {
else
  _dmi_decode
   echo "Il comando $var non esiste" >> $log && _error "$var"
  _comando "/bin/uname -a"
fi
  _file "/etc/debian_version"
  _de_wm
  _file "/etc/X11/default-display-manager"
  _comando "/usr/bin/groups" "su"
  _file "/var/log/syslog"
  _comando "/bin/systemctl --failed --no-pager"
  _comando "/bin/journalctl -x -b --no-pager -p err"
  _comando "/bin/journalctl -x -b --no-pager -p warning"
  _comando "/bin/journalctl -x -b --no-pager"
  _comando "/usr/bin/systemd-cgtop -b --iterations=5"
  _comando "/usr/bin/systemd-cgls -l"
  _comando "/usr/bin/systemd-delta"
  _comando "/bin/dmesg -l err"
  _comando "/bin/dmesg -l warn"
  _comando "/bin/lsmod"
  _comando "/usr/bin/lspci -knn"
  _comando "/usr/bin/lsusb"
  _comando "/sbin/fdisk -l"
  _comando "/sbin/blkid"
  _file "/etc/fstab"
  _dir "/etc/fstab.d/"
  _comando "/bin/findmnt"
  _comando "/bin/lsblk"
  _comando "/bin/df"
  _dir "/etc/modprobe.d/"
  _dir "/etc/modules-load.d/"
  _file "/etc/modules"
  _file "/etc/apt/sources.list"
  _dir "/etc/apt/sources.list.d/"
  _comando "/usr/bin/apt-cache policy"
  _comando "/usr/bin/apt-cache stats"
  _comando "/usr/bin/apt-mark showhold"
  _comando "/usr/bin/dpkg --audit"
   _comando "/usr/bin/dpkg -l"
  _comando "/usr/bin/apt-get check"
  _firmware
   _extpack
  _pack "linux-headers"
  _pack "linux-image"
  _comando "/usr/sbin/dkms status"
}
}


# comando 'lspci'
# Funzione relativa ai problemi di rete
function _lspci {
function _rete {
local var="lspci"
  _common
nome_e_riga "$var"
  _file "/etc/network/interfaces"
if [ -x /usr/bin/lspci ]; then
  _dir "/etc/network/interfaces.d/"
   lspci -knn &>> $log && _ok "$var" || _error "$var"
  _file "/etc/hosts"
else
  _comando "/sbin/ifconfig"
   echo "Il comando $var non esiste" >> $log && _error "$var"
  _comando "/sbin/ifconfig -a"
fi
  _comando "/sbin/ip -s -d link show"
  _comando "/usr/sbin/rfkill list all"
  _comando "/bin/ping -c3 -W5 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"
  _file "/etc/NetworkManager/NetworkManager.conf"
  _comando "/usr/bin/nmcli dev list"
  _comando "/usr/bin/nmcli device show"
  _demone "/usr/sbin/NetworkManager" "Network Manager"
  _demone "/usr/sbin/wicd" "Wicd"
}
}


# comando 'lsusb'
# Funzione relativa a problemi video
function _lsusb {
function _video {
local var="lsusb"
  _common
nome_e_riga "$var"
  _file "/etc/X11/xorg.conf"
if [ -x /usr/bin/lsusb ]; then
  _dir "/etc/X11/xorg.conf.d/"
   lsusb &>> $log && _ok "$var" || _error "$var"
  _file "/var/log/Xorg.0.log"
else
   _file "${utente}/.local/share/xorg/Xorg.0.log"
   echo "Il comando $var non esiste" >> $log && _error "$var"
  _pack "xserver-xorg"
fi
  _pack "nouveau"
  _pack "nvidia"
   _pack "mesa"
  _pack "fglrx"
  _pack "amdgpu"
}
}


# comando 'cat /etc/network/interfaces'
# Funzione relativa ai problemi di avvio del sistema
function _interfaces {
function _boot {
local var="/etc/newtork/interfaces"
  _common
nome_e_riga "$var"
  _file "/etc/default/grub"
if [ -f /etc/network/interfaces ]; then
  _file "/boot/grub/grub.cfg"
   ls -l  /etc/network/interfaces &>> $log || _error "$var"
  _dir "/etc/default/grub.d/"
   echo "" >> $log
   _dir "/etc/grub.d/"
   cat /etc/network/interfaces &>> $log && _ok "$var" || _error "$var"
   _file "/boot/grub/device.map"
else
   _comando "/usr/sbin/grub-mkdevicemap"
   echo "Il file $var non esiste" >> $log && _error "$var"
   _pack grub
fi
}
}


# comando 'cat /etc/hosts'
# Funzione relativa ai problemi audio. Scarica ed esegue lo script ALSA
function _hosts {
function _audio {
local var="/etc/hosts"
  _common
nome_e_riga "$var"
  _pack "alsa"
if [ -f /etc/hosts ]; then
  _nome_e_riga "dmesg | grep -C1 -E 'ALSA|HDA|HDMI|snd[_-]|sound|hda.codec|hda.intel'"
  cat /etc/hosts &>> $log && _ok "$var" || _error "$var"
  _prompt "ALSA dmesg"
else
  dmesg | grep -C1 -E 'ALSA|HDA|HDMI|snd[_-]|sound|hda.codec|hda.intel' >> "$log" && _ok || _error
  echo "Il file /etc/hosts" >> $log && _error "$var"
 
fi
  local risp alsaurl="http://www.alsa-project.org/alsa-info.sh"
 
  echo $'\nI log relativi ai problemi audio sono ricavati attraverso lo script di debug'
  echo "ALSA prelevabile all'indirizzo: ${alsaurl}"
  echo -n $'\nVerrà ora scaricato e eseguito lo script ALSA. Continuare [S/n]? '
  read risp
  case "$risp" in
    ""|[Ss])
  # wget esiste?
  if [ ! -f /usr/bin/wget ]; then
    echo "Impossibile scaricare lo script ALSA. Installare il pacchetto wget."
    return
  fi
  # Crea un file temporaneo in /tmp che conterrà lo script ALSA
      local tempfile=$(mktemp)
      # Scarica lo script ALSA
          _prompt "Download script ALSA"
  wget -q -O "$tempfile" "$alsaurl"
  # Se il download riesce...
  if [ $? -eq 0 ]; then
      _ok "Download script ALSA riuscito"
      # Imposta i permessi dello script scaricato
      chmod 777 "$tempfile"
      _nome_e_riga "Problemi audio"
      # rimuove il comando "dmesg" dallo script ALSA
      # perché non eseguibile da utente normale (il comando è
      # stato inserito a parte in questa funzione)
      sed -i "/^$(printf '\t')withdmesg/d" "$tempfile"
      # Esegue lo script ALSA
              _prompt "Esecuzione script ALSA"
      _su "$tempfile --stdout" && _ok || _error
  else
      _error "Download script ALSA fallito"
  fi
 
  # Rimuove il file temporaneo
  rm -- "$tempfile"
  ;;
    *)
  echo "Lo script ALSA non è stato ancora eseguito."
  echo "Avviare manualmente lo script prelevabile a questo indirizzo:"
  _bold "$alsaurl"
  echo "Lo script ALSA va eseguito con i permessi di normale utente."
  esac
 
}
}


# comandi 'ifconfig' e 'ifconfig -a'
# Funzione relativa alla gestione dei pacchetti attraverso il sistema APT
function _ifconfig {
function _apt {
local var="ifconfig"
  _common
nome_e_riga "$var"
  _comando "/usr/bin/dpkg --print-architecture"
if [ -x /sbin/ifconfig ]; then
  _comando "/usr/bin/dpkg --print-foreign-architectures"
   ifconfig &>> $log && _ok "$var" || _error "$var"
  _comando "/usr/bin/apt-get update"
   _spazi
   _comando "/usr/bin/apt-get -s -y upgrade"
   nome_e_riga "$var -a"
  _comando "/usr/bin/apt-get -s -y dist-upgrade"
   ifconfig -a &>> $log && _ok "$var -a" || _error "$var -a"
   _comando "/usr/bin/apt-get -s -y -f install"
else
   _comando "/usr/bin/apt-get -s -y autoremove"
   echo "Il comando $var non esiste" >> $log && _error "$var"
   _comando "/usr/bin/apt-config dump"
fi
  _file "/etc/apt/apt.conf"
  _dir "/etc/apt/apt.conf.d/"
   _file "/etc/apt/preferences"
  _dir "/etc/apt/preferences.d/"
}
}


# comando 'ping -c3 8.8.8.8'
# Funzione relativa a problemi di mount/unmount
function _ping {
function _mount {
local var="ping"
  _common
#Ping verso l'IP del DNS di Google 8.8.8.8
  _comando "/usr/bin/udisksctl dump"
local host="8.8.8.8"
   _pack "usbmount"
nome_e_riga "$var"
if [ -x /bin/ping ]; then
  ping -c3 $host &>> $log && _ok "$var" || _error "$var"
else
   echo "Il comando $var non esiste" >> $log && _error "$var"
fi
}
}


# comando 'iwconfig'
# Funzione relativa al funzionamento del touchpad
function _iwconfig {
function _tpad {
local var="iwconfig"
  _common
nome_e_riga "$var"
  _pack "xserver-xorg"
if [ -x /sbin/iwconfig ]; then
  _pack "touchpad"
   iwconfig &>> $log && _ok "$var" || _error "$var"
  _file "/etc/X11/xorg.conf"
else
   _dir "/etc/X11/xorg.conf.d/"
   echo "Il comando $var non esiste" >> $log && _error "$var"
  _file "/var/log/Xorg.0.log"
fi
   _comando "/usr/bin/synclient -l" "su"
}
}


# comando 'iwlist scan'
# --------------------------------------------------------------------------
function _iwlist {
# Funzioni utilizzate per tipo di problema (generiche)
local var="iwlist"
# --------------------------------------------------------------------------
  nome_e_riga "$var"
 
if [ -x /sbin/iwlist ]; then
# Funzione che invia il contenuto di un file al file di log
  iwlist scan &>> $log && _ok "$var scan" || _error "$var scan"
# La funzione va richiamata specificando il path completo del file che sarà assegnato a $1
else  
# Il contenuto dei file viene inviato inalterato al file di log. Se si ha necessità di
  echo "Il comando $var non esiste" >> $log && _error "$var"
# modificare questo comportamento, creare una entry nel ciclo "case"
fi
 
function _file {
    _nome_e_riga "$1"
    _prompt "$1"
    if [ -f "$1" ]; then
case "$1" in
            /etc/fstab)
                  # Nasconde username, password e dominio di mount CIFS
                  sed -e "s/\( cifs.*username *= *\)[^,]*/\1\*script-removed\*/" \
                      -e "s/\( cifs.*password *= *\)[^,]*/\1\*script-removed\*/" \
                      -e "s/\( cifs.*domain *= *\)[^,]*/\1\*script-removed\*/" "$1" &>> "$log" && _ok || _error ;;
    /etc/network/interfaces)
                  # Nasconde nel log gli ESSID e le password criptate contenute in /etc/network/interfaces
  sed -r "s/((wpa-ssid)|(wpa-psk)|(wpa-identity)|(wpa-password)|(wireless-key)).*/\1 \*script-removed\*/" "$1" &>> "$log" && _ok || _error ;;
    /var/log/syslog)
                  # se è installato systemd, il log viene ricavato da "journalctl -x"
                  if [ $systemd -eq 0 ]; then
      # se il file contiene la stringa "rsyslogd.*start" ...
      if [ "$(grep -sci '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 || _error
      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 || _error
_nome_e_riga "$1".1
                        _prompt "$1".1
sed -n 'H; /rsyslogd.*start$/h; ${g;p;}' "$1".1 >> "$log" && _ok || _error
      fi
  else _error # systemd è installato. I log vengono ricavati da "journalctl -x"
  fi ;;
    *)
  # per tutti i file non specificati sopra...
  cat "$1" &>> "$log" && _ok || _error
esac
    else
      echo "File \"$1\" non trovato" >> "$log" && _error
    fi
}
}


# comandi 'ip addrr list' e 'ip route list'
# Invia l'output di un comando al file di log
function _ip {
# La funzione va richiamata specificando il path completo del comando (con eventuali opzioni)
if [ -x /bin/ip ]; then
# che sarà assegnato a $1 . L'output dei comandi viene inviato interamente al file di log. Se
  nome_e_riga "ip addr list"
# si ha necessità di modificare gli output, creare una entry nel ciclo "case"
  ip addr list &>> $log && _ok "ip addr list" || _error "ip addr list"
# Es. _comando "/usr/bin/apt-get update"
  _spazi
#
  nome_e_riga "ip route list"
# Nel caso in cui il comando debba essere eseguito tramite 'su', richiamare la funzione con
  ip route list &>> $log && _ok "ip route list" || _error "ip route list"
# due parametri:
else
# $1 = il comando da eseguire attraverso 'su'
  echo "Il comando ip non esiste" >> $log && _error "ip"
# $2 = la stringa 'su'
fi
# Es. _comando "/usr/bin/groups" "su"
 
function _comando {
 
  local var=${1##*/} # var conterrà il comando ($1) con le opzioni ma privo del path
  local var2=${1%% *} # var2 conterrà il comando ($1) privo di eventuali opzioni ma con il path
  _nome_e_riga "$var"
  _prompt "$var"
 
  if [ -f "$var2" ]; then # il comando esiste?
      if [ $# -eq 2 ]; then # Se vi sono 2 parametri, viene chiamata la funzione "_su"
  case "$1" in
      "/usr/bin/synclient -l")
      # se $DISPLAY è vuota, usa :0 (default per il primo server X)
      _su "DISPLAY=${DISPLAY:-:0} $1" && _ok || _error ;;
      *)   
      _su "$1" && _ok || _error
  esac
      else # non viene utilizzato "su"
  case "$1" in
      # per "iwconfig" e "iwlist scan" gli ESSID non vengono inviati al log
      /sbin/iwconfig)
  (iwconfig | sed -e '/ESSID:/{/off\/any/! s/ESSID:.*/ESSID:"*script-removed*"/g}' -e '/^[ ]*IE: Unknown:.*/d') &>> "$log" && _ok || _error
  ;;
 
      "/sbin/iwlist scan")
  (iwlist scan | sed -e '/ESSID:.*/{/off\/any/! s/ESSID:.*/ESSID:"*script-removed*"/g}' -e '/^[ ]*IE: Unknown:.*/d') &>> "$log" && _ok || _error
  ;;
 
              # nasconde gli ESSID visualizzati da "nmcli dev list" (fino a Wheezy)
              # L'array PIPESTATUS mostra il codice d'uscita dei comandi della pipe. PIPESTATUS[0] è il codice d'uscita di "nmcli dev list" (0=successo)
              "/usr/bin/nmcli dev list")
                  nmcli dev list 2>/dev/null | sed -r "s/(^AP[[:digit:]]*\.SSID:[[:space:]]*).*/\1\*script removed\*/" >> "$log" && [ "${PIPESTATUS[0]}" -eq 0 ] && _ok || \
                      ( _error && echo "Comando valido solo per Wheezy" >> "$log" ) ;;
 
              # nasconde gli ESSID visualizzati da "nmcli device show" (da Jessie in poi)
              "/usr/bin/nmcli device show")
                  LANG=C nmcli device show 2>/dev/null | sed -r "s/(^AP[[:digit:]]*\.SSID:[[:space:]]*|GENERAL.CONNECTION:[[:space:]]*).*/\1\*script removed\*/" >> "$log" && [ "${PIPESTATUS[0]}" -eq 0 ] && _ok || \
                      ( _error && echo "Comando valido solo per Jessie e versioni superiori" >> "$log" ) ;;
 
              /bin/dmesg*)
  # Il comando viene eseguito solo se è non installato systemd
  [ $systemd -eq 0 ] && $1 &>> "$log" && _ok || _error ;;
 
              "/usr/sbin/grub-mkdevicemap")
  local devicemaptempfile="$(mktemp)" && \
  grub-mkdevicemap -m "$devicemaptempfile" && \
  if [ -f "$devicemaptempfile" ]; then cat "$devicemaptempfile" >> "$log"; fi && _ok || _error ;;
 
      # lista dei pacchetti con stato diverso da ii e rc, e quelli con errori
      "/usr/bin/dpkg -l")
                  echo "Elenco dei pacchetti installati con stato diverso da ii e rc, e con errori" >> "$log"
  echo >> "$log"
                  # il carattere vuoto dopo (ii|rc) prima dell'apice cattura eventuali errori,
                  # che sono presenti in terza posizione dell'output di "dpkg -l"
                  # (si noti che l'opzione "-v" inverte la selezione)
                  dpkg -l | grep -Ev '^(ii|rc) ' >> "$log" && _ok || _error ;;
 
      *)
  # per tutti gli altri comandi non specificati in precedenza, l'output del comando è inviato inalterato al log
  $1 &>> "$log" && _ok || _error
  esac  
      fi
  else
      echo "Comando \"${var2}\" non trovato" >> "$log" && _error
  fi
}
}


# comando 'route -n'
# Funzione che invia il contenuto dei file di una directory al file di log
function _route {
function _dir {
local var="route"
  _nome_e_riga "$1"
nome_e_riga "$var -n"
  _prompt "$1"
if [ -x /sbin/route ]; then
 
   route -n &>> $log && _ok "$var -n" || _error "$var -n"
  # Se la directory non esiste, stampa un output sul log ed esce.
else
  if [ ! -d "$1" ]; then
  echo "Il comando $var non esiste" >> $log && _error "$var"
    echo "La directory non esiste" >> "$log" && _error
fi
    return
  fi
 
  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 ] && [ "$numdir" -eq 1 ]; then
    echo "La directory non contiene file o directory" >> "$log" && _error
   else
    echo "La directory contiene ${numfile} file e $((numdir - 1)) directory" >> "$log" && _ok
    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"
        _prompt "$file"
        cat "$file" &>> "$log" && _ok || _error
      fi
    done
 
    # 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
  fi
}
}


# comando 'iptables -L'
# Funzione che elenca i pacchetti installati che contengono la parola
function _iptables {
# passata come parametro ($1)
local var="iptables"
 
nome_e_riga "$var"
function _pack {
if [ -x /sbin/iptables ]; then
  _nome_e_riga "Pacchetti che contengono \"$1\""
  iptables -L &>> $log && _ok "$var -L" || _error "$var -L"
  _prompt "Nomi di pacchetti con $1"
else  
 
  echo "Il comando $var non esiste" >> $log && _error "$var"
  # Variabile che contiene i pacchetti trovati
fi
  local packages=$(dpkg -l | grep -i "$1")
 
  if [ -z "$packages" ]; then
    echo "Nessun pacchetto installato" >> "$log" && _error
  else
    echo "$packages" >> "$log" && _ok
  fi
}
}


# comando 'cat /etc/resolv.conf'
# Funzione che verifica l'esistenza e l'esecuzione di alcuni demoni
function _resolvconf2 {
# Viene chiamata con due parametri:
local var="/etc/resolv.conf"
# $1 - percorso dell'eseguibile
nome_e_riga "$var"
# $2 - nome da visualizzare
if [ -f /etc/resolv.conf ]; then
# Se si vuol visualizzare la versione del demone, inserire il comando adatto
  ls -l /etc/resolv.conf &>> $log || _error "$var"
# all'interno del ciclo 'case', allo stesso modo specificare al suo interno
  echo "" >> $log
# anche il nome dello script d'avvio per fermare, avviare, etc il demone
  cat /etc/resolv.conf &>> $log && _ok "$var" || _error "$var"
 
else  
function _demone {
echo "Il file $var non esiste" >> $log && _error "$var"
 
fi
  # vers = versione del demone ; var = nome dello script d'avvio del demone
  local vers="" var=""
  _nome_e_riga "$2"
  _prompt "$2"
  if [ -f "$1" ]; then
    case "$1" in
/usr/sbin/NetworkManager)
                                  vers=$(NetworkManager --version)
                                  var="network-manager"
                                  ;;
/usr/sbin/wicd)
                                  vers=$(wicd -h | head -2 | tail -1)
                                  var="wicd"
                                  ;;
    esac
 
    echo "$2 è installato (versione "$vers")" >> "$log" && _ok
    invoke-rc.d "$var" status &>/dev/null
    [ $? -eq 0 ] && echo "$2 è in esecuzione" >> "$log" || echo "$2 non è in esecuzione" >> "$log"
  else
    echo "$2 non è installato" >> "$log" && _error
  fi
}
}


# esistenza del pacchetto 'resolvconf'
# --------------------------------------------------------------------------
function _resolvconf {
# Funzioni utilizzate per tipo di problema (particolari)
local var="resolvconf"
# --------------------------------------------------------------------------
nome_e_riga "$var"
 
if [ $(dpkg -l | grep -ci resolvconf) -eq 0 ]; then
# comando 'cat /sys/class/dmi/id/{sys_vendor,product_name,product_version,bios_version}'
  echo "Il pacchetto resolvconf non è installato" >> $log && _error "$var"
function _dmi_decode {
else
  local var="/sys/class/dmi/id/*"
  dpkg -l | grep -i resolvconf >> $log && _ok "$var"
  _nome_e_riga "$var"
fi
  _prompt "$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 || _error
  else
    echo "File /sys/class/dmi/id/sys_vendor non trovato" >> "$log" && _error
  fi
}
}


# esistenza di pacchetti contenenti firmware e firmware presente sulla macchina
# esistenza di pacchetti contenenti firmware e firmware presente sulla macchina
function _firmware {
function _firmware {
local var="Firmware"
  local i var="Firmware"
local i
  _prompt "$var"
nome_e_riga "$var"
  _nome_e_riga "$var"
dpkg -l | grep -i firmware >> $log && _ok "$var"
  dpkg -l | grep -i firmware >> "$log" && _ok || _error
# Array contenente tre directory
  echo >> "$log"
local firm_dir=(/usr/lib/firmware /usr/local/lib/firmware /lib/firmware)
 
  for ((i=0; i<${#firm_dir[@]}; i++)); do
  # Elenca i file contenuti nelle directory specificate
  if [ -d ${firm_dir[$i]} ]; then
  for i in "/usr/lib/firmware" "/usr/local/lib/firmware" "/lib/firmware" "/run/udev/firmware-missing"; do
    echo "Contenuto di ${firm_dir[$i]}" >> $log  
    if [ -d "$i" ]; then
    ls -al ${firm_dir[$i]} >> $log
      echo "Contenuto di ${i}" >> "$log"
  else
      ls -alR "$i" >> "$log"
    echo "${firm_dir[$i]} non esiste" >> $log
    else
  fi
      echo "${i} non trovata" >> "$log"
    fi
    echo >> "$log"
   done
   done
}
}


# esistenza di pacchetti riguardanti DHCP
# Stampa sullo standard output l'eseguibile associato a x-session-manager (il default)
function _dhcp {
function _x_session_manager {
local var="DHCP"
  update-alternatives --query "x-session-manager" |
nome_e_riga "$var"
    awk '$1 ~ /^Value:$/ { print $2; exit 0 }'
if [ $(dpkg -l | grep -ci dhcp) -eq 0 ]; then
}
  echo "Nessun pacchetto DHCP installato" >> $log && _error "$var"
 
else
# Stampa sullo standard output l'eseguibile associato a x-window-manager (il default)
   dpkg -l | grep -i dhcp >> $log && _ok "$var"
function _x_window_manager {
fi
   update-alternatives --query "x-window-manager" |
    awk '$1 ~ /^Value:$/ { print $2; exit 0 }'
}
}


# comando 'cat /etc/dhclient.conf'
# Stampa la lista dei pacchetti installati che soddisfano una data dipendenza
function _dhclient {
# con versione (del programma e in Debian) e archivio di provenienza
local var="/etc/dhclient.conf"
# Viene chiamata con un parametro:
nome_e_riga "$var"
# $1 - nome della dipendenza
if [ -f /etc/dhclient.conf ]; then
function _soddisfa {
   cat /etc/dhclient.conf &>> $log && _ok "$var" || _error "$var"
   echo "Installati (${1}):"
else
  aptitude search '?installed?provides('"$1"')' --disable-columns \
  echo "Il file /etc/dhclient.conf non esiste" >> $log && _error "$var"
    --display-format "- %p (versione: %v; archivio: %t)"
fi
}
}


# comando 'cat /etc/apt/sources.list'
# Restituisce un exit status di 0 solo se l'eseguibile con il nome scelto è in esecuzione da parte dell'utente ($utente)
function _sources {
# Viene chiamata con un parametro:
local var="/etc/apt/sources.list"
# $1 - comando di cui controllare l'esecuzione da parte di $utente
nome_e_riga "$var"
function _is_running {
if [ -f /etc/apt/sources.list ]; then
  local list_pids_user list_pids_bin pid pid2
   ls -l /etc/apt/sources.list &>> $log || _error "$var"
  list_pids_user=$(ps -U "$utente" -o pid) # lista di interi, separati da spazi, con i PID dei processi avviati da $utente
   echo "" >> $log
   list_pids_bin=$(pidof -- "$1")          # lista di interi, separati da spazi, con i PID dei processi del comando $1
  cat /etc/apt/sources.list &>> $log && _ok "$var" || _error "$var"
   for pid in $list_pids_user; do
  else
    for pid2 in $list_pids_bin; do
   echo "Il file $var non esiste" >> $log && _error "$var"
      if [ "$pid" = "$pid2" ]; then
fi
        return 0 # trovato
      fi
    done
  done
   return 1        # non trovato!
}
}


# esistenza di Network Manager
# Funzione che "cerca" di ricavare il nome e la versione del DE/WM utilizzato
function _nm {
function _de_wm {
local var="Network Manager"
  _nome_e_riga "Desktop Environment - Window Manager"
nome_e_riga "$var"
  _prompt "DE/WM"
if [ -n "$(dpkg -l | cut -d ' ' -f3 | egrep -i '^network-manager$')" ]; then
  {
   echo "Network Manager è installato (versione "$(NetworkManager --version)")" >> $log && _ok "$var"
    # impostazione di default
   invoke-rc.d network-manager status &>/dev/null
    echo -n $'Default:\n- x-session-manager: '
   if [ $? -eq 0 ]; then
    _x_session_manager
  echo "Network Manager è in esecuzione" >> $log
    echo -n "- x-window-manager: "
    _x_window_manager
    # installati
    if [ "$(command -v aptitude)" ]; then
      _soddisfa "x-session-manager"
      # _soddisfa "x-window-manager" # non essenziale e impiega già tanto
    fi
  } >> "$log"
  # in esecuzione
   echo -n "In esecuzione: " >> "$log"
  if _is_running "ksmserver"; then
    kf5-config -v 2>/dev/null >> "$log" ||                                                                # KDE5
    kde4-config -v 2>/dev/null >> "$log" && _ok || _error                                                  # KDE4
  elif _is_running "gnome-shell"; then gnome-shell --version >> "$log" && _ok || _error                    # GNOME Shell
   elif _is_running "xfdesktop"; then xfce4-about -V | head -n1 | cut -d ' ' -f2- >> "$log" && _ok || _error # Xfce4
   elif _is_running "openbox"; then
    if [ "$(_x_session_manager)" != "/usr/bin/openbox-session" ]; then
      echo -n "(altro x-session-manager) + " >> "$log"                                                     # Session manager (LXDE?) + Openbox
    fi
    openbox --version | head -n 1 >> "$log" && _ok || _error                                                # Openbox
   else
   else
  echo "Network Manager non è in esecuzione" >> $log
    echo "Sconosciuto" >> "$log" && _error                                                                  # NON TROVATO
   fi
   fi
  else
}
  echo "Network Manager non è installato" >> $log && _error "$var"
 
# Funzione che elenca i pacchetti non appartenenti alla release di default utilizzata
function _extpack {
 
local var="Pacchetti esterni"
_prompt "$var"
 
  # La funzione termina se aptitude non è installato
if [ ! "$(command -v aptitude)" ]; then
  _nome_e_riga "$var"
  echo "Aptitude non è installato" >> "$log" && _error
  return 1
fi
 
local riga indirizzo rel linea release=""
 
# variabile con il contenuto del file sources.list (solo righe che iniziano con deb
# e che contengono "main" )
local sourceslist="$(sed -e '/^deb /!d' -e '/.* main.*/!d' /etc/apt/sources.list)"
# variabile che contiene l'output del comando "apt-cache policy"
local aptcachepol="$(apt-cache policy)"
 
# ciclo sulle righe della variabile "sourceslist"
while read linea; do
 
    # variabile che contiene l'URL dell'archivio (es. http://ftp.it.debian.org/debian/)
    indirizzo="$(awk '{ print $2 }' <<< "$linea")"
 
    # sostituisce / con \/ (necessario per il successivo sed)
    indirizzo="$(_sed_quote "$indirizzo")"
 
    # release della riga corrente (es. wheezy o testing o sid)
    rel="$(awk '{ print $3 }' <<< "$linea")"
 
    # controlla che sia un nome di release valido
    if [ "$rel" = "oldstable" ] || [ "$rel" = "stable" ] || [ "$rel" = "testing" ] || [ "$rel" = "unstable" ] ||
      [ "$rel" = "$OLDSTABLE" ] || [ "$rel" = "$STABLE" ] || [ "$rel" = "$TESTING" ] || [ "$rel" = "sid" ] ||
      [ "$rel" = "oldoldstable" ] || [ "$rel" = "$OLDOLDSTABLE" ]; then
   
      # controlla che sia un repository di Debian
      # si basa sull'output di "apt-cache policy" e su o=Debian e l=Debian
      riga="$(echo "$aptcachepol" | sed -n '/'$indirizzo'*.*'$rel'\/main.*Packages$/ {N; /.*o=Debian,.*l=Debian,/p}')"
   
      # se è un archivio valido, aggiorna la variabile "release"
        if [ ! -z "$riga" ]; then
          if [ -z "$release" ]; then
              release="$rel"
          else
              release="$(printf %b "$release\n$rel")"
          fi
        fi
    fi
done <<< "$sourceslist"
 
# Lo script DEVE rilevare almeno una release. Se la variabile "release" è nulla, c'è un errore in "sources.list"
# oppure non è stato eseguito un aggiornamento della lista dei pacchetti (update)
# (vedere anche il modo in cui viene ricavata la variabile "release" in alto)
if [ -z "$release" ]; then
    _nome_e_riga "${var} all'archivio \"NON RILEVATO!\""
    echo "Release non rilevata. Repository errati oppure è necessaria una modifica dello script" >> "$log" && _error
    return 1
fi
 
# Rimuove eventuali duplicati (esistono repository doppi in sources.list)
release="$(echo "$release" | sort -u)"
# Numero di release trovate
local num=$(echo "$release" | wc -l)
 
# Se il numero di release è diverso da 1 (pinning?), la funzione termina
if [ "$num" -ne 1 ]; then
    _nome_e_riga "$var"
    echo "Sono presenti ${num} release in sources.list" >> "$log" && _error
    return
  fi
  fi
}
 
local pkg=""
 
# Se il numero di release è uguale a 1, la variabile pkg conterrà i pacchetti *non* facenti parte della release
case "$release" in
    "$OLDOLDSTABLE"|oldoldstable)
                    release="oldoldstable"
                    pkg=$(aptitude -F '%p %v %t' search '~S ~i !~Aoldoldstable') ;;
    "$OLDSTABLE"|oldstable)
                    release="oldstable"
                    pkg=$(aptitude -F '%p %v %t' search '~S ~i !~Aoldstable') ;;
    "$STABLE"|stable)
                    release="stable"
                    pkg=$(aptitude -F '%p %v %t' search '~S ~i !~Astable') ;;
    "$TESTING"|testing)
                    release="testing"
                    pkg=$(aptitude -F '%p %v %t' search '~S ~i !~Atesting') ;;
    sid|unstable) 
                    release="unstable"
                    pkg=$(aptitude -F '%p %v %t' search '~S ~i !~Aunstable') ;;
esac


# esistenza di Wicd
# Invia al log il contenuto di pkg (se esiste)
function _wicd {
  _nome_e_riga "${var} all'archivio \"${release}\""
local var="Wicd"
if [ -z "$pkg" ]; then
  nome_e_riga "$var"
   echo "Nessun pacchetto esterno installato" >> "$log" && _error
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
  else
  echo "Wicd non è installato" >> $log && _error "$var"
  if [ "$(command -v column)" ]; then
    echo "$pkg" | column -t >> "$log" && _ok
  else
    echo "$pkg" >> "$log" && _ok
  fi
  fi
  fi
}
}


# --------------------------------------------------------------------------
# --------------------------------------------------------------------------
# Main
# Main
# --------------------------------------------------------------------------
# --------------------------------------------------------------------------
clear
clear


_intro
_intro
_avvertenze
_check
_wait


# Ciclo sull'array di funzioni
if [ "$UPDATE" -eq 0 ] && [ "$BASE64" -eq 0 ]; then
for ((i=0; i<${#comandi[@]}; i++)); do
  _debug
${comandi[$i]}
  _avvertenze
_spazi
  _check
sleep 1
  _scelta
done
  _hide
echo -e "\nIl file $log è stato creato correttamente nella directory corrente."
  _upload
  _compress
elif [ "$UPDATE" -eq 1 ]; then
  _self_update
elif [ "$BASE64" -eq 1 ]; then
  _base64
fi


_upload
_exit
_compress
</syntaxhighlight>


# Permessi di lettura e scrittura per tutti
== Changelog ==
# poiché il file di log viene creato da root
<!-- Qui vanno inserite le spiegazioni di eventuali modifiche dello script (chi, cosa, quando). Ricordarsi di modificare la versione (variabile VERSIONE) all'interno del codice (la versione iniziale è 1.0.0) -->
chmod 666 $log
;1.0.73
 
:''Limitazione del [https://forum.debianizzati.org/viewtopic.php?p=225467#p225467 bug nella funzione _hide] in presenza di username e hostname che possono comparire all'interno di parole dei vari log. Esclusione della sostituzione per l'utente root.''
exit 0
:[[Utente:HAL 9000|HAL 9000]] ([[Discussioni utente:HAL 9000|discussioni]]) 08:22, 17 ott 2021 (UTC)
</pre>
;1.0.72
:''Aggiornamento per rilascio di Debian 11 ([[bullseye]])''
:''Ridotto l'output di "dpkg -l" ai soli pacchetti con stato diverso da "ii" e "rc" (ma includendo sempre quelli con errori)''
:[[Utente:HAL 9000|HAL 9000]] ([[Discussioni utente:HAL 9000|discussioni]]) 06:39, 22 ago 2021 (UTC)
;1.0.71
:''Aggiunti "apt-mark showhold" e "dpkg -l" (solo per pacchetti con stato != ii)''
:''Gestita la mancanza di column''
:''Corretto typo "OLDOLDSTABLE" -> "$OLDOLDSTABLE"''
:''Modifiche minori''
:[[Utente:S3v|S3v]] 08:54, 10 apr 2021 (UTC)
;1.0.70
:''Aggiunta oldoldstable''
:''Modifiche minori''
:[[Utente:S3v|S3v]] ([[Discussioni utente:S3v|discussioni]]) 21:08, 15 mar 2021 (UTC)
;1.0.69
:''http->https per paste.debian.net''
:''Sostituito "which" con "command -v"''
:''Aggiunto _pack "amdgpu"''
:''Aggiunta funzione per quotare stringhe prima di passarle a sed''
:''Rimosso comando "udisks --dump" (non più presente in Debian)''
:''Gestita la mancanza di aptitude''
:''Modifiche minori''
:[[Utente:S3v|S3v]] 13:21, 23 ott 2020 (CEST)
;1.0.68
:''Nascosti indirizzi MAC delle interfacce wireless''
:''Sovrascrittura del comando cat per evitare che al file di''
:''log venga inviato il contenuto di un file non di testo''
:''Impostata a 'on' l'opzione 'extdebug' per consentire l'espansione''
:''di ARGC per Bash >= 5''
:''Modifiche e correzioni minori''
:[[Utente:S3v|S3v]] 15:00, 23 mag 2020 (CEST)
;1.0.67
:''Aggiornamento per rilascio di Debian 10 ([[Buster]])''
:[[Utente:HAL 9000|HAL 9000]] 09:39, 7 lug 2019 (CEST)
;1.0.66
:''Aggiunto problema per avvio del sistema (boot)''
:''Aggiunta funzione _su (c'erano problemi con lo script ALSA)''
:''Aggiunte directory <code>/etc/fstab/</code>, <code>/etc/modprobe.d/</code>'',
:''<code>/etc/modules-load.d/</code>, <code>/etc/network/interfaces.d/</code> e il''
:''file <code>/etc/modules</code>''
:''dmesg dello script ALSA spostato nello script''
:''Modifiche e correzioni minori''
:[[Utente:S3v|S3v]] 10:37, 29 giu 2019 (CEST)
;1.0.65
:''Aggiunti "ip -s -d link show" e Xorg.0.log locale''
:''Nascosti username, password e dominio per montaggi cifs''
:''Modifiche e correzioni minori''
:[[Utente:S3v|S3v]] 20:49, 20 feb 2018 (CET)
;1.0.64
:''Aggiornamento per rilascio di Debian 9 ([[Stretch]])''
:[[Utente:HAL 9000|HAL 9000]] 10:46, 18 giu 2017 (CEST)
;1.0.63
:''Debug come parametro''
:''KDE5 tra i DE rilevati''
:[[Utente:S3v|S3v]] 22:38, 19 mag 2017 (CEST)
;1.0.62
:''Inserito debug''
:''Inserita funzione _printdot (per evitare ripetizioni)''
:''Modifiche minori''
:[[Utente:S3v|S3v]] 17:41, 26 feb 2017 (CET)
;1.0.61
:''Aggiunta funzione _header() (intestazione del file di log)''
:''Aggiunto parametro "--versione"''
:''Modifiche e correzioni minori''
:[[Utente:S3v|S3v]] 13:53, 10 dic 2016 (CET)
;1.0.60
:''Elenco ricorsivo delle directory contenenti firmware''
:''Nascosti (altri) ID di connessioni gestite da NM''
:[[Utente:S3v|S3v]] 20:53, 6 dic 2016 (CET)
;1.0.59
:''Modificata funzione _hide() per nascondere completamente hostname contenuto nel''
:''nome utente (e viceversa)''
:[[Utente:S3v|S3v]] 21:33, 11 nov 2016 (CET)
;1.0.58
:''Rimossa precedente istruzione e modificata regexp per far funzionare la ricerca di''
:''pacchetti esterni sia su stable che su testing''
:''Modifiche minori''
:[[Utente:S3v|S3v]] 16:44, 10 lug 2016 (CEST)
;1.0.57
:''Istruzione per rimuovere eventuale slash alla fine dell'URL in "sources.list"''
:''Aggiunti comandi "systemd-cgtop -b --iterations=5", "systemd-cgls" e "systemd-delta" a problemi comuni''
:[[Utente:S3v|S3v]] 21:27, 9 lug 2016 (CEST)
;1.0.56
:''Rimosse dal file interfaces anche le chiavi relative a wep e a wpa-enterprise''
:[[Utente:metaldaze|metaldaze]] 12:54, 04 feb 2016 (CET)
;1.0.55
:''Opzioni per aggiornare lo script o crearne una codifica base64''
:''Corretti ESSID in "nmcli device show" non nascosti''
:''Rimozione duplicati in "release" (pacchetti esterni)''
:[[Utente:S3v|S3v]] 21:26, 15 giu 2015 (CEST)
;1.0.54
:''Correzioni minori legate alla compressione xz; semplificata lettura nome utente in caso di errori con logname''
:[[Utente:HAL 9000|HAL 9000]] 18:41, 31 mag 2015 (CEST)
;1.0.53
:''Vengono rimosse dalla variabile "release" (pacchetti esterni) le linee duplicate''
:[[Utente:S3v|S3v]] 18:22, 30 mag 2015 (CEST)
;1.0.52
:''Aggiunta compressione xz, se disponibile, con ripiego su bzip2 oppure gzip''
:[[Utente:HAL 9000|HAL 9000]] 22:15, 17 mag 2015 (CEST)
;1.0.51
:''Aggiunti comandi "systemctl --failed", "journal -x -b --no-pager [-p [err, warning]]",''
:''"blkid", "lsblk", "dpkg --audit"''
:''"/var/log/syslog" e "dmesg" solo se non è installato systemd''
:''Aggiunta variabile globale "oldstable" e aggiornate "testing" e "stable"''
:''Modifiche minori''
:[[Utente:HAL 9000|HAL 9000]] e [[Utente:S3v|S3v]] 17:12, 4 mag 2015 (CEST)
;1.0.50
:''Rivista la funzione _extpack (repository Debian''
:''in base al comando "apt-cache policy")''
:[[Utente:S3v|S3v]] 22:37, 22 dic 2014 (CET)
;1.0.49
:''Aggiunti trap INT e "dpkg --print-foreign-architectures"''
:''Spostato "dkms status" nei comandi generali''
:[[Utente:S3v|S3v]] 21:19, 20 dic 2014 (CET)
;1.0.48
:''Corretta la ricerca per i pacchetti esterni''
:''Aggiunto _pack "linux-image"''
:[[Utente:S3v|S3v]] 20:16, 19 nov 2014 (CET)
;1.0.47
:''Inseriti "nmcli dev list" (per Wheezy) e "nmcli device show" (per Jessie e superiori)''
:''Inserito "udisksctl dump"''
:[[Utente:S3v|S3v]] 15:55, 5 nov 2014 (CET)


== Changelog ==
(Prosegue nella pagina di [[Discussione:Creazione automatica di un file di log per inviare quesiti al forum|discussione]]).
<!-- 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.1'''
''Corretta la funzione "dmesg" che svuotava il buffer e non produceva output
:[[Utente:S3v|S3v]] 12:22, 14 apr 2013 (CEST)


{{Autori
{{Autori
HAL 9000
3 581

contributi

Estratto da "https://guide.debianizzati.org/index.php/Speciale:DiffMobile/32172...44531"