Creazione automatica di un file di log per inviare quesiti al forum
Vai alla navigazione
Vai alla ricerca
|
Avvertimento Script non ancora aggiornato in seguito al rilascio di Debian bookworm, pertanto le informazioni restituite riguardo la provenienza dei pacchetti installati nel sistema potrebbero non essere accurate. |
Introduzione
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 forum per tentare di risolverlo insieme.
Le informazioni riguardano i seguenti tipi di problema:
- Connessioni di rete
- Video
- Avvio del sistema (boot)
- Audio (tramite lo script ALSA prelevabile 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:
- log_data
- contiene le informazioni in formato testo
- log_data.{xz,bz2,gz}
- il file precedente ma in formato compresso. Può essere allegato ad una discussione sul forum
Se si vuole, 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 240K 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.
|
Nota Lo script è liberamente modificabile. Per ogni segnalazione, informazione o suggerimento fare riferimento a 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:
# apt install aptitude
- pastebinit
- Permette di usufruire del servizio offerto da paste.debian.net per la condivisione del testo. Per installarlo:
# apt install pastebinit
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 discussione apposita o all'interno della pagina di discussione.
Utilizzo
- Eseguire un upgrade del sistema, se possibile, in modo che le informazioni raccolte dallo script siano aggiornate.
- 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
scriptlog-debianizzati.org.
E assegnare i permessi di esecuzione al file appena creato; ad esempio, da terminale o emulatore di terminale:$ chmod a+x scriptlog-debianizzati.org
In alternativa, se si preferisce, è possibile eseguire il seguente comando:wget -qO- "http://guide.debianizzati.org/index.php?title=Aiuto:LogScript&action=edit"|awk '/=S=/{while(getline&&!index($0,"=F"))print}'|base64 -d|tar xzcon 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 da terminale (o emulatore di terminale) lo script con privilegi di amministrazione:
# ./scriptlog-debianizzati.org
il comando precedente deve essere eseguito nella stessa directory in cui risiede lo script.
L'utilizzo dei permessi di root è motivato dal fatto che alcuni comandi devono essere eseguiti necessariamente come utente privilegiato. - 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:
# ./scriptlog-debianizzati.org --tipo=rete # ./scriptlog-debianizzati.org --tipo=apt --nocompress --nopaste # ./scriptlog-debianizzati.org --versione # ./scriptlog-debianizzati.org --help
Script
#! /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
}
}
function _close_debug {
set +x
exec {FD}>&-
}
# --------------------------------------------------------------------------
# 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 $VERSIONE *
* *
*********************************************************************************"
}
# 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 || risp="ERROR"
# Se non viene premuto "s" o "S" o [Invio], lo script termina
[ -z "$risp" ] || [ "$risp" = "s" ] || [ "$risp" = "S" ] || _exit
}
# 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" ] || [ -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
# 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 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
function _upload {
# Nessun invio a paste.debian.net se viene scelto "--nopaste"
[ "$NOPASTE" -eq 1 ] && return
local risp
# Pastebinit è installato?
if [ ! -f /usr/bin/pastebinit ]; then
echo $'\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 -n $'\nInviare il log a http://paste.debian.net [S/n]? '
read risp
case "$risp" in
""|[Ss])
_split_and_send
if [ $? = 0 ]; then
echo $'\nIl log è stato inviato'
else
echo $'\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
# --------------------------------------------------------------------------
# Funzioni richiamate in caso di corretta/scorretta creazione del file compresso
function _compress_ok { echo "File compresso creato correttamente nella directory corrente."; }
function _compress_err { echo "Errore nella creazione del file compresso."; }
# Funzione che crea il file compresso
# Prova a creare nell'ordine: un file .xz, un file .bz2 o un file .gz
function _compress {
# La funzione termina se è stato utilizzato il parametro "--nocompress"
[ "$NOCOMPRESS" -eq 1 ] && return
local risp
echo -n $'\nCreare un file compresso [S/n]? '
read risp
case "$risp" in
""|[Ss])
echo "Sta per essere creato un file compresso..."
sleep 1
if [ "$(command -v xz)" ]; then
xz -e < "$log" > "${log}.xz" && _compress_ok || _compress_err
elif [ "$(command -v bzip2)" ]; then
bzip2 -9 < "$log" > "${log}.bz2" && _compress_ok || _compress_err
elif [ "$(command -v gzip)" ]; then
gzip -9 < "$log" > "${log}.gz" && _compress_ok || _compress_err
else
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
}
# --------------------------------------------------------------------------
# Funzioni varie
# --------------------------------------------------------------------------
# Funzione che stampa solo parentesi e il nome del comando, prima di eseguirlo
function _prompt {
echo -n "[ ] $*"
}
# 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
function _ok { _printdot "${VERDE}"; }
# Funzione che stampa una pallino rosso in caso di comando privo di output
function _error { _printdot "${ROSSO}"; }
# 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 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
function _wait {
echo $'\nCreazione del log in corso...\n'
}
# 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
# 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
# Nasconde gli ESSID gestiti attraverso Network Manager
local var file mydir="/etc/NetworkManager/system-connections/"
if [ -d "$mydir" ]; then # se esiste la directory /etc/NetworkManager/system-connections/ ...
for file in "$mydir"/*; do # ciclo attraverso il contenuto della directory
if [ -f "$file" ]; then # se l'elemento è un file...
var=$(sed -n "s/ssid=//p" "$file") # ... var conterrà l'eventuale ESSID...
if [ -n "$var" ]; then # ... e se è diverso dalla stringa vuota...
sed -i "s/${var}/\*script-removed\*/g" "$log" # ... lo nasconde nel file di log
fi
fi
done
fi
# 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
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)
for i in "${interfaces[@]}"; do
# indirizzo MAC dell'interfaccia solo se questa ne ha uno
line="$(ip -br link show $i)"
if [ "$(echo $line | wc -w)" -gt 3 ]; then
macaddress="$(awk '{ print $3 }' <<< $line)"
macaddress="$(_sed_quote $macaddress)"
# l'indirizzo MAC viene nascosto nel file
sed -i 's/'$macaddress'/\*script-removed\*/g' "$log"
fi
done
fi
}
# Invia al log l'output del comando passato come primo parametro e
# con i permessi utente
function _su {
echo "$(su -c "$1" $utente)" >> "$log"
}
# Stabilisce la data dell'ultimo aggiornamento effettuato. Viene preso in
# considerazione il file /var/log/apt/history.log oppure il file /var/log/apt/history.log.1.gz
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"
}
# Funzione che stampa un messaggio che indica i file creati e poi termina lo script
function _exit {
# se è stato effettuato un update o una codifica base64, stampa solo il messaggio finale
if [ "$UPDATE" -eq 0 ] && [ "$BASE64" -eq 0 ]; then
local complog=""
if [ -f "$log" ]; then
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
}
# --------------------------------------------------------------------------
# Funzioni relative a ciascun problema selezionato
# --------------------------------------------------------------------------
# Informazioni comuni a tutti i tipi di problema
function _common {
_dmi_decode
_comando "/bin/uname -a"
_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"
}
# Funzione relativa ai problemi di rete
function _rete {
_common
_file "/etc/network/interfaces"
_dir "/etc/network/interfaces.d/"
_file "/etc/hosts"
_comando "/sbin/ifconfig"
_comando "/sbin/ifconfig -a"
_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"
}
# Funzione relativa a problemi video
function _video {
_common
_file "/etc/X11/xorg.conf"
_dir "/etc/X11/xorg.conf.d/"
_file "/var/log/Xorg.0.log"
_file "${utente}/.local/share/xorg/Xorg.0.log"
_pack "xserver-xorg"
_pack "nouveau"
_pack "nvidia"
_pack "mesa"
_pack "fglrx"
_pack "amdgpu"
}
# Funzione relativa ai problemi di avvio del sistema
function _boot {
_common
_file "/etc/default/grub"
_file "/boot/grub/grub.cfg"
_dir "/etc/default/grub.d/"
_dir "/etc/grub.d/"
_file "/boot/grub/device.map"
_comando "/usr/sbin/grub-mkdevicemap"
_pack grub
}
# Funzione relativa ai problemi audio. Scarica ed esegue lo script ALSA
function _audio {
_common
_pack "alsa"
_nome_e_riga "dmesg | grep -C1 -E 'ALSA|HDA|HDMI|snd[_-]|sound|hda.codec|hda.intel'"
_prompt "ALSA dmesg"
dmesg | grep -C1 -E 'ALSA|HDA|HDMI|snd[_-]|sound|hda.codec|hda.intel' >> "$log" && _ok || _error
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
}
# Funzione relativa alla gestione dei pacchetti attraverso il sistema APT
function _apt {
_common
_comando "/usr/bin/dpkg --print-architecture"
_comando "/usr/bin/dpkg --print-foreign-architectures"
_comando "/usr/bin/apt-get 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/unmount
function _mount {
_common
_comando "/usr/bin/udisksctl dump"
_pack "usbmount"
}
# Funzione relativa al funzionamento del touchpad
function _tpad {
_common
_pack "xserver-xorg"
_pack "touchpad"
_file "/etc/X11/xorg.conf"
_dir "/etc/X11/xorg.conf.d/"
_file "/var/log/Xorg.0.log"
_comando "/usr/bin/synclient -l" "su"
}
# --------------------------------------------------------------------------
# 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"
_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
}
# 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"
# Es. _comando "/usr/bin/apt-get update"
#
# Nel caso in cui il comando debba essere eseguito tramite 'su', richiamare la funzione con
# due parametri:
# $1 = il comando da eseguire attraverso 'su'
# $2 = la stringa 'su'
# 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
}
# Funzione che invia il contenuto dei file di una directory al file di log
function _dir {
_nome_e_riga "$1"
_prompt "$1"
# Se la directory non esiste, stampa un output sul log ed esce.
if [ ! -d "$1" ]; then
echo "La directory non esiste" >> "$log" && _error
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
}
# Funzione che elenca i pacchetti installati che contengono la parola
# passata come parametro ($1)
function _pack {
_nome_e_riga "Pacchetti che contengono \"$1\""
_prompt "Nomi di pacchetti con $1"
# Variabile che contiene i pacchetti trovati
local packages=$(dpkg -l | grep -i "$1")
if [ -z "$packages" ]; then
echo "Nessun pacchetto installato" >> "$log" && _error
else
echo "$packages" >> "$log" && _ok
fi
}
# Funzione che verifica l'esistenza e l'esecuzione di alcuni demoni
# Viene chiamata con due parametri:
# $1 - percorso dell'eseguibile
# $2 - nome da visualizzare
# Se si vuol visualizzare la versione del demone, inserire il comando adatto
# all'interno del ciclo 'case', allo stesso modo specificare al suo interno
# anche il nome dello script d'avvio per fermare, avviare, etc il demone
function _demone {
# 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
}
# --------------------------------------------------------------------------
# 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"
_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
function _firmware {
local i var="Firmware"
_prompt "$var"
_nome_e_riga "$var"
dpkg -l | grep -i firmware >> "$log" && _ok || _error
echo >> "$log"
# Elenca i 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 -alR "$i" >> "$log"
else
echo "${i} non trovata" >> "$log"
fi
echo >> "$log"
done
}
# Stampa sullo standard output l'eseguibile associato a x-session-manager (il default)
function _x_session_manager {
update-alternatives --query "x-session-manager" |
awk '$1 ~ /^Value:$/ { print $2; exit 0 }'
}
# Stampa sullo standard output l'eseguibile associato a x-window-manager (il default)
function _x_window_manager {
update-alternatives --query "x-window-manager" |
awk '$1 ~ /^Value:$/ { print $2; exit 0 }'
}
# Stampa la lista dei pacchetti installati che soddisfano una data dipendenza
# con versione (del programma e in Debian) e archivio di provenienza
# Viene chiamata con un parametro:
# $1 - nome della dipendenza
function _soddisfa {
echo "Installati (${1}):"
aptitude search '?installed?provides('"$1"')' --disable-columns \
--display-format "- %p (versione: %v; archivio: %t)"
}
# Restituisce un exit status di 0 solo se l'eseguibile con il nome scelto è in esecuzione da parte dell'utente ($utente)
# Viene chiamata con un parametro:
# $1 - comando di cui controllare l'esecuzione da parte di $utente
function _is_running {
local list_pids_user list_pids_bin pid pid2
list_pids_user=$(ps -U "$utente" -o pid) # lista di interi, separati da spazi, con i PID dei processi avviati da $utente
list_pids_bin=$(pidof -- "$1") # lista di interi, separati da spazi, con i PID dei processi del comando $1
for pid in $list_pids_user; do
for pid2 in $list_pids_bin; do
if [ "$pid" = "$pid2" ]; then
return 0 # trovato
fi
done
done
return 1 # non trovato!
}
# Funzione che "cerca" di ricavare il nome e la versione del DE/WM utilizzato
function _de_wm {
_nome_e_riga "Desktop Environment - Window Manager"
_prompt "DE/WM"
{
# impostazione di default
echo -n $'Default:\n- x-session-manager: '
_x_session_manager
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
echo "Sconosciuto" >> "$log" && _error # NON TROVATO
fi
}
# 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
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
# Invia al log il contenuto di pkg (se esiste)
_nome_e_riga "${var} all'archivio \"${release}\""
if [ -z "$pkg" ]; then
echo "Nessun pacchetto esterno installato" >> "$log" && _error
else
if [ "$(command -v column)" ]; then
echo "$pkg" | column -t >> "$log" && _ok
else
echo "$pkg" >> "$log" && _ok
fi
fi
}
# --------------------------------------------------------------------------
# Main
# --------------------------------------------------------------------------
clear
_intro
if [ "$UPDATE" -eq 0 ] && [ "$BASE64" -eq 0 ]; then
_debug
_avvertenze
_check
_scelta
_hide
_upload
_compress
elif [ "$UPDATE" -eq 1 ]; then
_self_update
elif [ "$BASE64" -eq 1 ]; then
_base64
fi
_exit
Changelog
- 1.0.73
- Limitazione del 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.
- HAL 9000 (discussioni) 08:22, 17 ott 2021 (UTC)
- 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)
- 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
- S3v 08:54, 10 apr 2021 (UTC)
- 1.0.70
- Aggiunta oldoldstable
- Modifiche minori
- 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
- 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
- S3v 15:00, 23 mag 2020 (CEST)
- 1.0.67
- Aggiornamento per rilascio di Debian 10 (Buster)
- 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
/etc/fstab/,/etc/modprobe.d/, /etc/modules-load.d/,/etc/network/interfaces.d/e il- file
/etc/modules - dmesg dello script ALSA spostato nello script
- Modifiche e correzioni minori
- 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
- S3v 20:49, 20 feb 2018 (CET)
- 1.0.64
- Aggiornamento per rilascio di Debian 9 (Stretch)
- HAL 9000 10:46, 18 giu 2017 (CEST)
- 1.0.63
- Debug come parametro
- KDE5 tra i DE rilevati
- S3v 22:38, 19 mag 2017 (CEST)
- 1.0.62
- Inserito debug
- Inserita funzione _printdot (per evitare ripetizioni)
- Modifiche minori
- 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
- S3v 13:53, 10 dic 2016 (CET)
- 1.0.60
- Elenco ricorsivo delle directory contenenti firmware
- Nascosti (altri) ID di connessioni gestite da NM
- S3v 20:53, 6 dic 2016 (CET)
- 1.0.59
- Modificata funzione _hide() per nascondere completamente hostname contenuto nel
- nome utente (e viceversa)
- 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
- 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
- S3v 21:27, 9 lug 2016 (CEST)
- 1.0.56
- Rimosse dal file interfaces anche le chiavi relative a wep e a wpa-enterprise
- 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)
- 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
- HAL 9000 18:41, 31 mag 2015 (CEST)
- 1.0.53
- Vengono rimosse dalla variabile "release" (pacchetti esterni) le linee duplicate
- S3v 18:22, 30 mag 2015 (CEST)
- 1.0.52
- Aggiunta compressione xz, se disponibile, con ripiego su bzip2 oppure gzip
- 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
- HAL 9000 e S3v 17:12, 4 mag 2015 (CEST)
- 1.0.50
- Rivista la funzione _extpack (repository Debian
- in base al comando "apt-cache policy")
- S3v 22:37, 22 dic 2014 (CET)
- 1.0.49
- Aggiunti trap INT e "dpkg --print-foreign-architectures"
- Spostato "dkms status" nei comandi generali
- S3v 21:19, 20 dic 2014 (CET)
- 1.0.48
- Corretta la ricerca per i pacchetti esterni
- Aggiunto _pack "linux-image"
- 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"
- S3v 15:55, 5 nov 2014 (CET)
(Prosegue nella pagina di discussione).
| Guida scritta da: S3v 23:38, 13 apr 2013 (CEST) |  Debianized 20%
|
| Estesa da: | |
| Verificata da: | |
|
Verificare ed estendere la guida | Cos'è una guida Debianized | |