Documentazione<Precedenti | Contenuti | Succ.>
D.2. /lib/lsb/funzioni-init
# / Bin / sh
################################################# ######################
#
# Inizia /lib/lsb/init-funtions
#
# Descrizione: Funzioni di controllo del livello di esecuzione
#
# / Bin / sh
################################################# ######################
#
# Inizia /lib/lsb/init-funtions
#
# Descrizione: Funzioni di controllo del livello di esecuzione
#
# Autori
#
# Aggiornare
#
# Versione
#
# Note
#
#
#
#
# Autori
#
# Aggiornare
#
# Versione
#
# Note
#
#
#
#
################################################# ######################
## Configurazione ambientale
# Imposta i valori predefiniti per l'ambiente umask 022
export PATH="/bin:/usr/bin:/sbin:/usr/sbin"
## Imposta i comandi del colore, usati tramite echo
# Si prega di consultare `man console_codes per maggiori informazioni
# nella sezione "ECMA-48 Imposta resa grafica"
#
# Avvertenza: quando si passa da un font a 8 bit a uno a 9 bit,
# la console Linux reinterpreterà il grassetto (1;) per
################################################# ######################
## Configurazione ambientale
# Imposta i valori predefiniti per l'ambiente umask 022
export PATH="/bin:/usr/bin:/sbin:/usr/sbin"
## Imposta i comandi del colore, usati tramite echo
# Si prega di consultare `man console_codes per maggiori informazioni
# nella sezione "ECMA-48 Imposta resa grafica"
#
# Avvertenza: quando si passa da un font a 8 bit a uno a 9 bit,
# la console Linux reinterpreterà il grassetto (1;) per
# i primi 256 glifi del carattere a 9 bit. questo sì
# non influisce sulle console framebuffer
NORMAL="\\033[0;39m" # Console standard grigio SUCCESS="\\033[1;32m" # Il successo è verde WARNING="\\033[1;33m" # Gli avvisi sono gialli FAILURE="\\ 033[1;31m" # I guasti sono rossi INFO="\\033[1;36m" # Le informazioni sono ciano chiaro BRACKET="\\033[1;34m" # Le parentesi sono blu
# Usa un prefisso colorato BMPREFIX=" "
SUCCESS_PREFIX="${SUCCESS} * ${NORMAL} " FAILURE_PREFIX="${FAILURE}*****${NORMAL} " WARNING_PREFIX="${WARNING} *** ${NORMAL} " SKIP_PREFIX="${ INFO} S ${NORMALE}"
SUCCESS_SUFFIX="${BRACKET}[${SUCCESS} OK ${BRACKET}]${NORMAL}" FAILURE_SUFFIX="${BRACKET}[${FAILURE} FAIL ${BRACKET}]${NORMAL}" WARNING_SUFFIX="$ {BRACKET}[${WARNING} WARN ${BRACKET}]${NORMAL}" SKIP_SUFFIX="${BRACKET}[${INFO} SKIP ${BRACKET}]${NORMAL}"
BOOTLOG=/esegui/bootlog KILLDELAY=3 SCRIPT_STAT="0"
# Imposta qualsiasi variabile di ambiente specificata dall'utente, ad esempio HEADLESS [ -r /etc/sysconfig/rc.site ] && . /etc/sysconfig/rc.site
## Dimensioni dello schermo
# Trova la dimensione attuale dello schermo if [ -z "${COLUMNS}" ]; poi
COLONNE=$(dimensione stty) COLONNE=${COLUMNS##* }
fi
# Quando si utilizzano connessioni remote, come una porta seriale, stty size restituisce 0 if [ "${COLUMNS}" = "0" ]; poi
COLONNE=80
fi
## Misurazioni per i messaggi di risultato di posizionamento COL=$((${COLUMNS} - 8))
VCOL=$((${COL} - 2))
## Imposta i comandi di posizione del cursore, usati tramite echo SET_COL="\\033[${COL}G" # al carattere $COL SET_WCOL="\\033[${WCOL}G" # al carattere $WCOL CURS_UP= "\\033[1A\\033[0G" # Su di una riga, allo 0esimo carattere CURS_ZERO="\\033[0G"
################################################ ##############################
# inizio_daemon() #
# Utilizzo: start_daemon [-f] [-n nicelevel] [-p pidfile] percorso [args...] #
# #
# Scopo: esegue il programma specificato come demone #
# #
# Input: -f: (forza) esegue il programma anche se è già in esecuzione. #
# -n nicelevel: specifica un bel livello. Vedi 'uomo simpatico (1)'. #
# -p pidfile: usa il file specificato per determinare i PID. #
# percorso: il percorso completo del programma specificato #
# args: argomenti aggiuntivi passati al programma (percorso) #
# #
# Valori restituiti (come definiti dai codici di uscita LSB): #
# 0 - il programma è in esecuzione o il servizio è OK #
# 1 - errore generico o non specificato #
# 2 - argomenti non validi o eccessivi #
# 5 - il programma non è installato #
################################################ ##############################
inizio_daemon()
{
local force="" local nice="0" local pidfile="" local pidlist="" local retval=""
# Elabora gli argomenti mentre è vero
do
caso "${1}" in
-F)
forza="1" spostamento 1
;;
-N)
bello="${2}" turno 2
;;
-P)
pidfile="${2}" shift 2
;;
- *)
ritorna 2
;;
fatto
*)
che C
programma="${1}" pausa
;;
# Verifica la presenza di un programma valido
Se [ ! -e "${programma}" ]; quindi restituire 5; fi
# Eseguire
if [ -z "${forza}" ]; poi
if [ -z "${filepid}" ]; poi
# Determina il pid tramite discovery pidlist=`pidofproc "${1}"` retval="${?}"
altro
# Il file PID contiene i PID necessari
# Nota che per requisito LSB, il percorso deve essere fornito a pidofproc,
# tuttavia, non viene utilizzato dall'implementazione o dallo standard corrente. pidlist=`pidofproc -p "${pidfile}" "${1}"`
retval="${?}"
fi
# Restituisce SOLO un valore
# È responsabilità dello script di init (o delle funzioni della distribuzione)
# per registrare i messaggi! caso "${retval}" in
0)
# Il programma è già in esecuzione correttamente, questo è un
# avvio riuscito. ritorno 0
;;
1)
# Il programma non è in esecuzione, ma esiste un file pid non valido
# rimuove il file pid e continua rm -f "${pidfile}"
;;
3)
# Il programma non è in esecuzione e non esiste alcun file pid
# non fare nulla qui, lascia che start_deamon continui.
;;
*)
che C
fi
# Gli altri come restituiti dai valori di stato non devono essere interpretati
# e restituito come errore non specificato. ritorno 1
;;
# Inizia!
bello -n "${bello}" "${@}"
}
################################################ ##############################
#killproc() #
# Utilizzo: killproc [-p pidfile] percorso [segnale] #
# #
# Scopo: inviare segnali di controllo ai processi in esecuzione #
# #
# Input: -p pidfile, usa il pidfile specificato #
# percorso, percorso del programma specificato #
# segnale, invia questo segnale al percorso #
# #
# Valori restituiti (come definiti dai codici di uscita LSB): #
# 0 - il programma (percorso) si è fermato/è già stato fermato o un #
# | programma in esecuzione è stato inviato specificato | segnale e | fermato | # | |
# | avere ottimi risultati di | # | |||
# | 1 | - errore generico o non specificato | # | ||
# | 2 | - argomenti non validi o eccessivi | # | ||
# | 5 | - il programma non è installato | # | ||
# | 7 | - il programma non è in esecuzione e c'è stato un segnale | in dotazione | # |
################################################ ##############################
killproc()
{
file pid locale programma locale prefisso locale programma locale
local signal="-TERM" local fallback="-KILL" local nosig
pidlist locale retval locale pid locale
local delay="30" local piddead local dtime
# Elabora gli argomenti mentre è vero; fare
caso "${1}" in
-P)
pidfile="${2}" shift 2
;;
*)
programma="${1}"
if [-n "${2}" ]; quindi signal="${2}" fallback=""
altro
naso=1
fi
# Errore su argomenti aggiuntivi if [ -n "${3}" ]; poi
ritorna 2
altro
rompere
fatto
fi
;;
che C
# Verifica la presenza di un programma valido
Se [ ! -e "${programma}" ]; quindi restituire 5; fi
# Verifica la presenza di un segnale valido check_signal "${signal}"
if [ "${?}" -ne "0" ]; quindi restituire 2; fi
# Ottieni un elenco di pid
if [ -z "${filepid}" ]; poi
# determina il pid tramite discovery pidlist=`pidofproc "${1}"` retval="${?}"
altro
# Il file PID contiene i PID necessari
# Nota che per requisito LSB, il percorso deve essere fornito a pidofproc,
# tuttavia, non viene utilizzato dall'implementazione o dallo standard corrente. pidlist=`pidofproc -p "${pidfile}" "${1}"`
retval="${?}"
fi
# Restituisce SOLO un valore
# È responsabilità dello script di init (o delle funzioni della distribuzione)
# per registrare i messaggi! caso "${retval}" in
0)
# Il programma funziona correttamente
# Non fare nulla qui, lascia che killproc continui.
;;
1)
# Il programma non è in esecuzione, ma esiste un file pid non valido
# Rimuovi il file pid. rm -f "${pidfile}"
# Questo è un successo solo se non è stato passato alcun segnale. if [ -n "${nosig}" ]; poi
ritorna 0
altro
ritorna 7
fi
;;
3)
# Il programma non è in esecuzione e non esiste alcun file pid
# Questo è un successo solo se non è stato passato alcun segnale. if [ -n "${nosig}" ]; poi
ritorna 0
altro
ritorna 7
fi
;;
*)
che C
# Gli altri come restituiti dai valori di stato non devono essere interpretati
# e restituito come errore non specificato. ritorno 1
;;
# Esegui diverse azioni per i segnali di uscita e i segnali di controllo check_sig_type "${signal}"
if [ "${?}" -eq "0" ]; quindi # Signal viene utilizzato per terminare il programma
# Account per pidlist vuota (il file pid esiste ancora e no
# segnale è stato dato)
if [ "${pidlist}" != "" ]; poi
# Elimina l'elenco dei pid per pid in ${pidlist}; fare
kill -0 "${pid}" 2> /dev/null if [ "${?}" -ne "0" ]; poi
# Il processo è morto, continua con il prossimo e presumi che tutto vada bene continua
altro
kill "${segnale}" "${pid}" 2> /dev/null
# Attendi fino a ${delay}/10 secondi per "${pid}" per
# termina in decimi di secondo
while [ "${ritardo}" -ne "0" ]; fare
kill -0 "${pid}" 2> /dev/null || piddead="1" if [ "${piddead}" = "1" ]; poi rompere; fi dormi 0.1
ritardo="$(( ${ritardo} - 1 ))"
fatto
# Se è impostato un fallback e il programma è ancora in esecuzione, allora
# usa il fallback
if [-n "${fallback}" -a "${piddead}" != "1" ]; quindi kill "${fallback}" "${pid}" 2> /dev/null
dormi 1
# Ricontrolla e fallisce se è ancora in esecuzione kill -0 "${pid}" 2> /dev/null && return 1
fi
fi
fatto
fi
# Cerca e rimuovi i file PID non aggiornati. if [ -z "${filepid}" ]; poi
# Trova il nome di base di $programma
prefisso=`echo "${programma}" | sed 's/[^/]*$//'` nomeprog=`echo "${programma}" | sed "s@${prefisso}@@"`
if [ -e "/var/run/${nomeprogramma}.pid" ]; poi
rm -f "/var/run/${nomeprogramma}.pid" 2> /dev/null
fi
altro
if [ -e "${filepid}" ]; quindi rm -f "${pidfile}" 2> /dev/null; fi
fi
# Per i segnali che non prevedono l'uscita di un programma, semplicemente
# lascia che kill faccia il suo lavoro e valuta il valore di ritorno di kill
else# check_sig_type - il segnale non viene utilizzato per terminare il programma per pid in ${pidlist}; fare
uccidi "${segnale}" "${pid}"
if [ "${?}" -ne "0" ]; quindi restituire 1; fi
fatto
fi
}
################################################ ##############################
#pidofproc() #
# Utilizzo: pidofproc [-p pidfile] percorso #
# #
# Scopo: questa funzione restituisce uno o più pid per un particolare demone #
# #
# Input: -p pidfile, usa il pidfile specificato invece di pidof #
# percorso, percorso del programma specificato #
# #
# Valori restituiti (come definiti dai codici di stato LSB): #
# 0 - Successo (da PID a stdout) #
# 1 - Il programma è morto, il file PID esiste ancora (output PID rimanente) #
# 3 - Il programma non è in esecuzione (nessun output) #
################################################ ##############################
pidofproc()
{
file pid locale programma locale prefisso locale nome programma locale elenco pid locale lpids locale
stato uscita locale = "0"
# Elabora gli argomenti mentre è vero; fare
caso "${1}" in
-P)
pidfile="${2}" shift 2
;;
*)
programma="${1}"
if [ -n "${2}" ]; poi
# Molti argomenti
# Poiché questo è lo stato, restituisce un ritorno sconosciuto 4
altro
rompere
fatto
fi
;;
che C
# Se un file PID non è specificato, prova a trovarne uno. if [ -z "${filepid}" ]; poi
# Ottieni il nome di base del programma
prefisso=`echo "${programma}" | sed 's/[^/]*$//'` if [ -z "${prefisso}" ]; poi
nomeprogramma="${programma}" altro
nomeprogramma=`echo "${programma}" | sed "s@${prefisso}@@"`
fi
# Se esiste un file PID con quel nome, supponi che sia quello. if [ -e "/var/run/${nomeprogramma}.pid" ]; poi
pidfile="/var/run/${nomeprogramma}.pid"
fi
fi
# Se un file PID è impostato ed esiste, utilizzalo.
if [ -n "${filepid}" -a -e "${file pid}" ]; poi
# Usa il valore nella prima riga del pidfile pidlist=`/bin/head -n1 "${pidfile}"`
# Questo può essere opzionalmente scritto come 'sed 1q' per sostituire 'head -n1'
# dovrebbe LFS spostare /bin/head in /usr/bin/head
altro
# Usa pidof
pidlist=`pidof "${programma}"`
fi
# Capire se tutti i PID elencati sono in esecuzione. per pid in ${pidlist}; fare
kill -0 ${pid} 2> /dev/null
if ["${?}" -eq "0" ]; quindi lpids="${lpids}${pid} "
altro
exitstatus="1"
fi
fatto
if [-z "${lpids}" -a ! -f "${filepid}" ]; poi ritorna 3
altro
echo "${lpids}"
restituisce "${exitstatus}"
fi
}
################################################ ##############################
# statoproc() #
# Utilizzo: statusproc [-p pidfile] percorso #
# #
# Scopo: questa funzione stampa lo stato di un particolare demone su stdout #
# #
# Input: -p pidfile, usa il pidfile specificato invece di pidof #
# percorso, percorso del programma specificato #
# #
# Valori restituiti: #
# 0 - Stato stampato #
# 1 - Errore di input. Il demone da controllare non è stato specificato. #
################################################ ##############################
statusproc()
{
pidfile locale pidlist locale
if [ "${#}" = "0" ]; poi
echo "Utilizzo: statusproc [-p pidfle] {programma}" exit 1
fi
# Elabora gli argomenti mentre è vero; fare
caso "${1}" in
-P)
pidfile="${2}" shift 2
;;
*)
if [ -n "${2}" ]; poi
echo "Troppi argomenti" return 1
altro
rompere
fatto
fi
;;
che C
if [ -n "${filepid}" ]; then pidlist=`pidofproc -p "${pidfile}" $@`
altro
pidlist=`pidofproc $@`
fi
# Taglia gli spazi vuoti finali
pidlist=`echo "${pidlist}" | sed -r 's/ +$//'` base="${1##*/}"
if [ -n "${pidlist}" ]; poi
/bin/echo -e "${INFO}${base} è in esecuzione con Process" \ "ID(s) ${pidlist}.${NORMAL}"
altro
if [ -n "${base}" -a -e "/var/run/${base}.pid" ]; poi
/bin/echo -e "${WARNING}${1} non è in esecuzione ma" \ "/var/run/${base}.pid esiste.${NORMAL}"
altro
if [ -n "${filepid}" -a -e "${file pid}" ]; poi
/bin/echo -e "${WARNING}${1} non è in esecuzione" \ "ma ${pidfile} esiste.${NORMAL}"
altro
/bin/echo -e "${INFO}${1} non è in esecuzione.${NORMAL}"
fi
fi
fi
}
################################################ ##############################
# specifica temporale() #
# #
# Scopo: una funzione di utilità interna per formattare un timestamp #
# un file di registro di avvio. Imposta la variabile STAMP. #
# #
# Valore restituito: Non utilizzato #
################################################ ##############################
tempistica()
{
STAMP="$(echo `date +"%b %d %T %:z"` `hostname`) " return 0
}
################################################ ##############################
# log_success_msg() #
# Utilizzo: log_success_msg ["messaggio"] #
# #
# Scopo: stampare un messaggio di stato riuscito sullo schermo e #
# un file di registro di avvio. #
# #
# Input: $@ - Messaggio #
# #
# Valori restituiti: Non utilizzato #
################################################ ##############################
log_success_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${SUCCESS_PREFIX}${SET_COL}${SUCCESS_SUFFIX}"
# Elimina i caratteri non stampabili dal file di registro logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g'`
tempistica
/bin/echo -e "${STAMP} ${messaggio di log} OK" >> ${BOOTLOG}
ritorna 0
}
log_success_msg2()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${SUCCESS_PREFIX}${SET_COL}${SUCCESS_SUFFIX}" echo " OK" >> ${BOOTLOG}
ritorna 0
}
################################################ ##############################
# log_failure_msg() #
# Utilizzo: log_failure_msg ["messaggio"] #
# #
# Scopo: stampare un messaggio di stato di errore sullo schermo e #
# un file di registro di avvio. #
# #
# Input: $@ - Messaggio #
# #
# Valori restituiti: Non utilizzato #
################################################ ##############################
log_failure_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${FAILURE_PREFIX}${SET_COL}${FAILURE_SUFFIX}"
# Elimina i caratteri non stampabili dal file di registro timespec
logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g'`
/bin/echo -e "${STAMP} ${messaggio di log} NON RIUSCITO" >> ${BOOTLOG}
ritorna 0
}
log_failure_msg2()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${FAILURE_PREFIX}${SET_COL}${FAILURE_SUFFIX}" echo "FAIL" >> ${BOOTLOG}
ritorna 0
}
################################################ ##############################
# log_avviso_msg() #
# Utilizzo: log_warning_msg ["messaggio"] #
# #
# Scopo: stampare un messaggio di stato di avviso sullo schermo e #
# un file di registro di avvio. #
# #
# Valori restituiti: Non utilizzato #
################################################ ##############################
log_warning_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${WARNING_PREFIX}${SET_COL}${WARNING_SUFFIX}"
# Elimina i caratteri non stampabili dal file di registro logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g'`
/bin/echo -e "${STAMP} ${messaggio di log} WARN" >> ${BOOTLOG}
ritorna 0
}
log_skip_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${SKIP_PREFIX}${SET_COL}${SKIP_SUFFIX}"
# Elimina i caratteri non stampabili dal file di registro logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g'`
/bin/echo "SALTA" >> ${BOOTLOG}
ritorna 0
}
################################################ ##############################
# log_info_msg() #
# Utilizzo: log_info_msg messaggio #
# #
# Scopo: stampare un messaggio informativo sullo schermo e #
# un file di registro di avvio. Non stampa un carattere di nuova riga finale. #
# #
# Valori restituiti: Non utilizzato #
################################################ ##############################
log_info_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
# Elimina i caratteri non stampabili dal file di registro logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g'`
/bin/echo -n -e "${STAMP} ${messaggio di log}" >> ${BOOTLOG}
ritorna 0
}
log_info_msg2()
{
/bin/echo -n -e "${@}"
# Elimina i caratteri non stampabili dal file di registro logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g'`
/bin/echo -n -e "${messaggio di log}" >> ${BOOTLOG}
ritorna 0
}
################################################ ##############################
# valuta_retval() #
# Utilizzo: valutare un valore restituito e stampare il successo o l'errore come appropriato #
# #
# Scopo: Funzione di comodità per terminare un messaggio informativo #
# #
# Valori restituiti: Non utilizzato #
################################################ ##############################
valuta_retval()
{
locale error_value="${?}"
if [ ${valore_errore} = 0 ]; quindi log_success_msg2
altro
log_failure_msg2
fi
}
################################################ ##############################
# segnale_di_controllo() #
# Utilizzo: check_signal [ -{segnale} | {segnale} ] #
# #
# Scopo: verificare la presenza di un segnale valido. Questo non è definito da nessuna bozza LSB, #
# tuttavia, è necessario controllare i segnali per determinare se il #
# segnali scelti sono argomenti non validi per le altre funzioni. #
# #
# Input: accetta un singolo valore di stringa nella forma o -{segnale} o {segnale} #
# #
# Valori restituiti: #
# 0 - Successo (il segnale è valido #
# 1 - Segnale non valido #
################################################ ##############################
controllo_segnale()
{
valsig . locale
# Aggiungi la gestione degli errori per i segnali non validi
valsig="-ALRM -HUP -INT -KILL -PIPE -POLL -PROF -TERM -USR1 -USR2" valsig="${valsig} -VTALRM -STKFLT -PWR -WINCH -CHLD -URG -TSTP -TTIN" valsig= "${valsig} -TTOU -STOP -CONT -ABRT -FPE -ILL -QUIT -SEGV -TRAP" valsig="${valsig} -SYS -EMT -BUS -XCPU -XFSZ -0 -1 -2 -3 - 4 -5 -6 -8 -9"
valsig="${valsig} -11 -13 -14 -15"
echo "${valsig}" | grep -- " ${1} " > /dev/null if [ "${?}" -eq "0" ]; poi
ritorna 0
altro
ritorna 1
fi
}
################################################ ##############################
# controlla_tipo_sig() #
# Utilizzo: check_signal [ -{segnale} | {segnale} ] #
# #
# Scopo: verificare se il segnale è un segnale di fine programma o un segnale di controllo #
# Questo non è definito da nessuna bozza LSB, tuttavia, è necessario #
# controlla i segnali per determinare se sono destinati a terminare un #
# programma o semplicemente per controllarlo. #
# #
# Input: accetta un singolo valore di stringa nella forma o -{segnale} o {segnale} #
# #
# Valori restituiti: #
# 0 - Il segnale viene utilizzato per la terminazione del programma #
# 1 - Il segnale viene utilizzato per il controllo del programma #
################################################ ##############################
check_sig_type()
{
valsig . locale
# L'elenco dei segnali di terminazione (limitato agli elementi generalmente utilizzati) valsig="-ALRM -INT -KILL -TERM -PWR -STOP -ABRT -QUIT -2 -3 -6 -9 -14 -15"
echo "${valsig}" | grep -- " ${1} " > /dev/null if [ "${?}" -eq "0" ]; poi
ritorna 0
altro
ritorna 1
fi
}
################################################ ##############################
# aspetta_per_utente() #
# #
# Scopo: attendere che l'utente risponda se non è un sistema headless #
# #
################################################ ##############################
attendi_per_utente()
{
# Attendi l'utente per impostazione predefinita
[ "${HEADLESS=0}" = "0" ] && leggi INVIO
ritorna 0
}
################################################ ##############################
# è vero() #
# #
# Scopo: Utility per verificare se una variabile è vera | si | 1 #
# #
################################################ ##############################
è vero()
{
[ "$1" = "1" ] || [ "$1" = "sì" ] || [ "$1" = "vero" ] || [ "$1" = "y" ] || [ "$1" = "t" ]
}
# Fine /lib/lsb/init-functions
ritorna 0
altro
ritorna 1
fi
}
################################################ ##############################
# aspetta_per_utente() #
# #
# Scopo: attendere che l'utente risponda se non è un sistema headless #
# #
################################################ ##############################
attendi_per_utente()
{
# Attendi l'utente per impostazione predefinita
[ "${HEADLESS=0}" = "0" ] && leggi INVIO
ritorna 0
}
################################################ ##############################
# è vero() #
# #
# Scopo: Utility per verificare se una variabile è vera | si | 1 #
# #
################################################ ##############################
è vero()
{
[ "$1" = "1" ] || [ "$1" = "sì" ] || [ "$1" = "vero" ] || [ "$1" = "y" ] || [ "$1" = "t" ]
}
# Fine /lib/lsb/init-functions
:Gerard Beekmans- [email protected] DJ Lucas- [email protected]
:Bruce Dubbs- [email protected]
:Gerard Beekmans- [email protected] DJ Lucas- [email protected]
:Bruce Dubbs- [email protected]
:LFS 7.0
:LFS 7.0
mountvirtfs
mountvirtfs
S
S