DocumentațieD.2. /lib/lsb/init-functions
# / Bin / sh
#################################################################### ######################
#
# Începeți /lib/lsb/init-funtions
#
# Descriere: Funcții de control al nivelului de rulare
#
# / Bin / sh
#################################################################### ######################
#
# Începeți /lib/lsb/init-funtions
#
# Descriere: Funcții de control al nivelului de rulare
#
# Autori
#
# Actualizați
#
# Versiune
#
# Note
#
#
#
#
# Autori
#
# Actualizați
#
# Versiune
#
# Note
#
#
#
#
#################################################################### ######################
## Configurare de mediu
# Configurați valorile implicite pentru mediul umask 022
export PATH="/bin:/usr/bin:/sbin:/usr/sbin"
## Setați comenzile de culoare, utilizate prin echo
# Vă rugăm să consultați `man console_codes pentru mai multe informații
# în secțiunea „ECMA-48 Set Graphics Rendition”.
#
# Avertisment: când treceți de la un font de 8 biți la un font de 9 biți,
# consola Linux va reinterpreta caracterele aldine (1;) la
#################################################################### ######################
## Configurare de mediu
# Configurați valorile implicite pentru mediul umask 022
export PATH="/bin:/usr/bin:/sbin:/usr/sbin"
## Setați comenzile de culoare, utilizate prin echo
# Vă rugăm să consultați `man console_codes pentru mai multe informații
# în secțiunea „ECMA-48 Set Graphics Rendition”.
#
# Avertisment: când treceți de la un font de 8 biți la un font de 9 biți,
# consola Linux va reinterpreta caracterele aldine (1;) la
# primele 256 de glife ale fontului pe 9 biți. Asta face
# nu afectează consolele framebuffer
NORMAL="\\033[0;39m" # Consolă standard gri SUCCESS="\\033[1;32m" # Succesul este verde WARNING="\\033[1;33m" # Avertismentele sunt galbene FAILURE="\\ 033[1;31m" # Eșecurile sunt roșii INFO="\\033[1;36m" # Informația este cyan deschis BRACKET="\\033[1;34m" # Parantezele sunt albastre
# Folosiți un prefix colorat BMPREFIX=" "
SUCCESS_PREFIX="${SUCCESS} * ${NORMAL} " FAILURE_PREFIX="${FAILURE}*****${NORMAL} " WARNING_PREFIX="${WARNING} *** ${NORMAL} " SKIP_PREFIX="${ INFO} S ${NORMAL}"
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=/run/bootlog KILLDELAY=3 SCRIPT_STAT="0"
# Setați orice variabile de mediu specificate de utilizator, de exemplu HEADLESS [ -r /etc/sysconfig/rc.site ] && . /etc/sysconfig/rc.site
## Dimensiunile ecranului
# Găsiți dimensiunea actuală a ecranului dacă [ -z "${COLUMNS}" ]; atunci
COLUMNS=$(dimensiunea stty) COLUMNS=${COLUMNS##* }
fi
# Când utilizați conexiuni la distanță, cum ar fi un port serial, stty size returnează 0 dacă [ "${COLUMNS}" = "0" ]; atunci
COLONNE=80
fi
## Măsurători pentru mesajele de rezultat de poziționare COL=$((${COLUMNS} - 8))
WCOL=$((${COL} - 2))
## Setați comenzile de poziție a cursorului, utilizate prin echo SET_COL="\\033[${COL}G" # la $COL char SET_WCOL="\\033[${WCOL}G" # la $WCOL char CURS_UP= "\\033[1A\\033[0G" # Cu o linie în sus, la al 0-lea caracter CURS_ZERO="\\033[0G"
#################################################################### ##############################
# start_daemon() #
# Utilizare: start_daemon [-f] [-n nicelevel] [-p pidfile] calea [args...] #
# #
# Scop: Acesta rulează programul specificat ca demon #
# #
# Intrări: -f: (forță) rulează programul chiar dacă acesta rulează deja. #
# -n nicelevel: specificați un nivel frumos. Vezi „om drăguț(1)”. #
# -p pidfile: utilizați fișierul specificat pentru a determina PID-urile. #
# nume cale: calea completă către programul specificat #
# argumente: argumente suplimentare transmise programului (nume cale) #
# #
# Valori returnate (așa cum sunt definite de codurile de ieșire LSB): #
# 0 - programul rulează sau serviciul este OK #
# 1 - eroare generică sau nespecificată #
# 2 - argument(e) invalid sau excesiv(e) #
# 5 - programul nu este instalat #
#################################################################### ##############################
start_daemon()
{
local force="" local nice="0" local pidfile="" local pidlist="" local retval=""
# Procesați argumentele în timp ce sunt adevărate
do
cazul „${1}” în
-f)
forța="1" schimbarea 1
;;
pe)
nice="${2}" tura 2
;;
-p)
pidfile="${2}" tura 2
;;
-*)
returnați 2
;;
făcut
*)
ESAC
program="${1}" pauză
;;
# Verificați dacă există un program valid
dacă [ ! -e „${program}” ]; apoi întoarce 5; fi
# A executa
dacă [ -z "${force}" ]; atunci
dacă [ -z "${pidfile}" ]; atunci
# Determinați pid-ul prin descoperire pidlist=`pidofproc "${1}"` retval="${?}"
altfel
# Fișierul PID conține PID-urile necesare
# Rețineți că prin cerința LSB, calea trebuie să fie dată către pidofproc,
# cu toate acestea, nu este utilizat de implementarea sau standardul actual. pidlist=`pidofproc -p "${pidfile}" "${1}"`
retval="${?}"
fi
# Returnează NUMAI o valoare
# Este responsabilitatea scriptului de pornire (sau a funcțiilor de distribuție).
# pentru a înregistra mesajele! cazul „${retval}” în
0)
# Programul rulează deja corect, acesta este a
# început cu succes. întoarce 0
;;
1)
# Programul nu rulează, dar există un fișier pid nevalid
# eliminați fișierul pid și continuați rm -f „${pidfile}”
;;
3)
# Programul nu rulează și nu există niciun fișier pid
# nu faceți nimic aici, lăsați start_deamon să continue.
;;
*)
ESAC
fi
# Altele returnate de valorile de stare nu vor fi interpretate
# și returnat ca o eroare nespecificată. întoarce 1
;;
# Începeți!
frumos -n „${nice}” „${@}”
}
#################################################################### ##############################
# killproc() #
# Utilizare: killproc [-p pidfile] calea [semnal] #
# #
# Scop: Trimiteți semnale de control către procesele care rulează #
# #
# Intrări: -p pidfile, folosește fișierul pid specificat #
# calea, calea către programul specificat #
# semnal, trimite acest semnal către calea #
# #
# Valori returnate (așa cum sunt definite de codurile de ieșire LSB): #
# 0 - programul (nume cale) s-a oprit/este deja oprit sau un #
# | programul care rulează a fost trimis specificat | semnal și | oprit | # | |
# | cu succes | # | |||
# | 1 | - eroare generică sau nespecificată | # | ||
# | 2 | - argumente invalide sau excesive | # | ||
# | 5 | - programul nu este instalat | # | ||
# | 7 | - programul nu rulează și a fost semnal | furnizat | # |
#################################################################### ##############################
killproc()
{
local pidfile program local prefix local program local
local signal="-TERM" local fallback="-KILL" local nosig
local pidlist local retval local pid
local delay="30" local piddead local dtime
# Procesează argumentele cât timp sunt adevărate; do
cazul „${1}” în
-p)
pidfile="${2}" tura 2
;;
*)
program="${1}"
dacă [-n „${2}” ]; apoi semnal="${2}" fallback=""
altfel
nosig=1
fi
# Eroare la argumentele suplimentare dacă [ -n "${3}" ]; atunci
returnați 2
altfel
rupe
făcut
fi
;;
ESAC
# Verificați dacă există un program valid
dacă [ ! -e „${program}” ]; apoi întoarce 5; fi
# Verificați un semnal valid check_signal „${signal}”
dacă [ "${?}" -ne "0" ]; apoi întoarce 2; fi
# Obțineți o listă de pid-uri
dacă [ -z "${pidfile}" ]; atunci
# determinați pid-ul prin descoperire pidlist=`pidofproc "${1}"` retval="${?}"
altfel
# Fișierul PID conține PID-urile necesare
# Rețineți că prin cerința LSB, calea trebuie să fie dată către pidofproc,
# cu toate acestea, nu este utilizat de implementarea sau standardul actual. pidlist=`pidofproc -p "${pidfile}" "${1}"`
retval="${?}"
fi
# Returnează NUMAI o valoare
# Este responsabilitatea scriptului de pornire (sau a funcțiilor de distribuție).
# pentru a înregistra mesajele! cazul „${retval}” în
0)
# Programul rulează corect
# Nu faceți nimic aici, lăsați killproc să continue.
;;
1)
# Programul nu rulează, dar există un fișier pid nevalid
# Eliminați fișierul pid. rm -f „${pidfile}”
# Acesta este un succes numai dacă nu a fost transmis niciun semnal. if [ -n "${nosig}" ]; atunci
returnați 0
altfel
returnați 7
fi
;;
3)
# Programul nu rulează și nu există niciun fișier pid
# Acesta este un succes numai dacă nu a fost transmis niciun semnal. if [ -n "${nosig}" ]; atunci
returnați 0
altfel
returnați 7
fi
;;
*)
ESAC
# Altele returnate de valorile de stare nu vor fi interpretate
# și returnat ca o eroare nespecificată. întoarce 1
;;
# Efectuați diferite acțiuni pentru semnalele de ieșire și semnalele de control check_sig_type „${signal}”
dacă [ "${?}" -eq "0" ]; apoi # Signal este folosit pentru a termina programul
# Cont pentru lista pid goală (fișierul pid încă există și nr
# semnal a fost dat)
if [ "${pidlist}" != "" ]; atunci
# Omorâți lista de pid-uri pentru pid în ${pidlist}; do
kill -0 "${pid}" 2> /dev/null if [ "${?}" -ne "0" ]; atunci
# Procesul este mort, continuă cu următorul și presupune că totul este bine, continuă
altfel
ucideți „${signal}” „${pid}” 2> /dev/null
# Așteptați până la ${delay}/10 secunde pentru ca „${pid}” să
# se încheie în 10 de secundă
while [ "${delay}" -ne "0" ]; do
kill -0 "${pid}" 2> /dev/null || piddead="1" if [ "${piddead}" = "1" ]; apoi rupe; fi somn 0.1
delay="$(( ${delay} - 1 ))"
făcut
# Dacă este setată o alternativă, iar programul încă rulează, atunci
# utilizați alternativa
if [-n "${fallback}" -a "${piddead}" != "1" ]; apoi ucideți „${fallback}” „${pid}” 2> /dev/null
Dormi 1
# Verificați din nou și eșuați dacă încă rulați kill -0 "${pid}" 2> /dev/null && return 1
fi
fi
făcut
fi
# Verificați și eliminați fișierele PID învechite. dacă [ -z "${pidfile}" ]; atunci
# Găsiți numele de bază al programului $
prefix=`echo „${program}” | sed 's/[^/]*$//'` progname=`echo "${program}" | sed "s@${prefix}@@"`
if [ -e "/var/run/${progname}.pid" ]; atunci
rm -f "/var/run/${progname}.pid" 2> /dev/null
fi
altfel
if [ -e "${pidfile}" ]; apoi rm -f "${pidfile}" 2> /dev/null; fi
fi
# Pentru semnalele care nu se așteaptă ca un program să iasă, pur și simplu
# lasă-l pe kill să-și facă treaba și evaluează rentabilitatea kill pentru valoare
else# check_sig_type - semnalul nu este folosit pentru a termina programul pentru pid în ${pidlist}; do
ucide „${signal}” „${pid}”
dacă [ "${?}" -ne "0" ]; apoi întoarce 1; fi
făcut
fi
}
#################################################################### ##############################
# pidofproc() #
# Utilizare: pidofproc [-p pidfile] calea #
# #
# Scop: Această funcție returnează unul sau mai multe coduri pentru un anumit demon #
# #
# Intrări: -p pidfile, utilizați fișierul pid specificat în loc de pidof #
# nume cale, cale către programul specificat #
# #
# Valori returnate (așa cum sunt definite de codurile de stare LSB): #
# 0 - Succes (PID la stdout) #
# 1 - Programul este mort, fișierul PID încă există (ieșire PID-uri rămase) #
# 3 - Programul nu rulează (fără ieșire) #
#################################################################### ##############################
pidofroc()
{
local pidfile local program local prefix local progname local pidlist local lpids
local exitstatus="0"
# Procesează argumentele cât timp sunt adevărate; do
cazul „${1}” în
-p)
pidfile="${2}" tura 2
;;
*)
program="${1}"
dacă [ -n „${2}” ]; atunci
# Prea multe argumente
# Deoarece aceasta este starea, returnați returnarea necunoscută 4
altfel
rupe
făcut
fi
;;
ESAC
# Dacă nu este specificat un fișier PID, încercați să găsiți unul. dacă [ -z "${pidfile}" ]; atunci
# Obțineți numele de bază al programului
prefix=`echo „${program}” | sed 's/[^/]*$//'` if [ -z "${prefix}" ]; atunci
program="${program}" altcineva
progname=`echo „${program}” | sed "s@${prefix}@@"`
fi
# Dacă există un fișier PID cu acest nume, presupunem că acesta este. if [ -e "/var/run/${progname}.pid" ]; atunci
pidfile="/var/run/${progname}.pid"
fi
fi
# Dacă un fișier PID este setat și există, utilizați-l.
if [ -n "${pidfile}" -a -e "${pidfile}" ]; atunci
# Utilizați valoarea din prima linie a pidfile pidlist=`/bin/head -n1 "${pidfile}"`
# Acesta poate fi scris opțional ca „sed 1q” pentru a înlocui „head -n1”
# ar trebui LFS să mute /bin/head în /usr/bin/head
altfel
# Utilizați pidof
pidlist=`pidof "${program}"`
fi
# Aflați dacă toate PID-urile listate rulează. pentru pid în ${pidlist}; do
kill -0 ${pid} 2> /dev/null
dacă ["${?}" -eq "0" ]; apoi lpids="${lpids}${pid} "
altfel
exitstatus="1"
fi
făcut
dacă [-z "${lpids}" -a ! -f „${pidfile}” ]; apoi întoarce 3
altfel
ecou „${lpids}”
returnează „${exitstatus}”
fi
}
#################################################################### ##############################
# statusproc() #
# Utilizare: statusproc [-p pidfile] calea #
# #
# Scop: Această funcție imprimă starea unui anumit demon în stdout #
# #
# Intrări: -p pidfile, utilizați fișierul pid specificat în loc de pidof #
# nume cale, cale către programul specificat #
# #
# Valori returnate: #
# 0 - Stare imprimată #
# 1 - Eroare de intrare. Demonul de verificat nu a fost specificat. #
#################################################################### ##############################
statusproc()
{
local pidfile local pidlist
dacă [ "${#}" = "0" ]; atunci
echo „Utilizare: statusproc [-p pidfle] {program}” exit 1
fi
# Procesează argumentele cât timp sunt adevărate; do
cazul „${1}” în
-p)
pidfile="${2}" tura 2
;;
*)
dacă [ -n „${2}” ]; atunci
echo „Prea multe argumente” return 1
altfel
rupe
făcut
fi
;;
ESAC
if [ -n "${pidfile}" ]; apoi pidlist=`pidofproc -p "${pidfile}" $@`
altfel
pidlist=`pidofproc $@`
fi
# Tăiați spațiile libere finale
pidlist=`echo „${pidlist}” | sed -r 's/ +$//'` base="${1##*/}"
if [ -n "${pidlist}" ]; atunci
/bin/echo -e „${INFO}${base} rulează cu Procesul” \ „ID(e) ${pidlist}.${NORMAL}”
altfel
if [ -n "${base}" -a -e "/var/run/${base}.pid" ]; atunci
/bin/echo -e "${WARNING}${1} nu rulează, dar" \ "/var/run/${base}.pid există.${NORMAL}"
altfel
if [ -n "${pidfile}" -a -e "${pidfile}" ]; atunci
/bin/echo -e "${WARNING}${1} nu rulează" \ "dar ${pidfile} există.${NORMAL}"
altfel
/bin/echo -e „${INFO}${1} nu rulează.${NORMAL}”
fi
fi
fi
}
#################################################################### ##############################
# timespec() #
# #
# Scop: O funcție de utilitate internă pentru a formata o marca temporală #
# un fișier jurnal de pornire. Setează variabila STAMP. #
# #
# Valoarea returnată: neutilizată #
#################################################################### ##############################
timespec()
{
STAMP="$(echo `data +"%b %d %T %:z"` `nume gazdă`) " returnează 0
}
#################################################################### ##############################
# log_success_msg() #
# Utilizare: log_success_msg [„mesaj”] #
# #
# Scop: Imprimați un mesaj de stare de succes pe ecran și #
# un fișier jurnal de pornire. #
# #
# Intrări: $@ - Mesaj #
# #
# Valori returnate: neutilizat #
#################################################################### ##############################
log_success_msg()
{
/bin/echo -n -e „${BMPREFIX}${@}”
/bin/echo -e „${CURS_ZERO}${SUCCESS_PREFIX}${SET_COL}${SUCCESS_SUFFIX}”
# Eliminați caracterele neprintabile din fișierul jurnal logmessage=`echo „${@}” | sed 's/\\\033[^a-zA-Z]*.//g'`
timespec
/bin/echo -e „${STAMP} ${logmessage} OK” >> ${BOOTLOG}
returnați 0
}
log_success_msg2()
{
/bin/echo -n -e „${BMPREFIX}${@}”
/bin/echo -e „${CURS_ZERO}${SUCCESS_PREFIX}${SET_COL}${SUCCESS_SUFFIX}” echo „OK” >> ${BOOTLOG}
returnați 0
}
#################################################################### ##############################
# log_failure_msg() #
# Utilizare: log_failure_msg [„mesaj”] #
# #
# Scop: Imprimați un mesaj de stare de eroare pe ecran și #
# un fișier jurnal de pornire. #
# #
# Intrări: $@ - Mesaj #
# #
# Valori returnate: neutilizat #
#################################################################### ##############################
log_failure_msg()
{
/bin/echo -n -e „${BMPREFIX}${@}”
/bin/echo -e „${CURS_ZERO}${FAILURE_PREFIX}${SET_COL}${FAILURE_SUFFIX}”
# Eliminați caracterele care nu pot fi imprimate din specificația de timp a fișierului jurnal
logmessage=`echo „${@}” | sed 's/\\\033[^a-zA-Z]*.//g'`
/bin/echo -e „${STAMP} ${logmessage} FAIL” >> ${BOOTLOG}
returnați 0
}
log_failure_msg2()
{
/bin/echo -n -e „${BMPREFIX}${@}”
/bin/echo -e „${CURS_ZERO}${FAILURE_PREFIX}${SET_COL}${FAILURE_SUFFIX}” echo „FAIL” >> ${BOOTLOG}
returnați 0
}
#################################################################### ##############################
# log_warning_msg() #
# Utilizare: log_warning_msg [„mesaj”] #
# #
# Scop: Imprimați un mesaj de stare de avertizare pe ecran și #
# un fișier jurnal de pornire. #
# #
# Valori returnate: neutilizat #
#################################################################### ##############################
log_warning_msg()
{
/bin/echo -n -e „${BMPREFIX}${@}”
/bin/echo -e „${CURS_ZERO}${WARNING_PREFIX}${SET_COL}${WARNING_SUFFIX}”
# Eliminați caracterele neprintabile din fișierul jurnal logmessage=`echo „${@}” | sed 's/\\\033[^a-zA-Z]*.//g'` timespec
/bin/echo -e „${STAMP} ${logmessage} WARN” >> ${BOOTLOG}
returnați 0
}
log_skip_msg()
{
/bin/echo -n -e „${BMPREFIX}${@}”
/bin/echo -e „${CURS_ZERO}${SKIP_PREFIX}${SET_COL}${SKIP_SUFFIX}”
# Eliminați caracterele neprintabile din fișierul jurnal logmessage=`echo „${@}” | sed 's/\\\033[^a-zA-Z]*.//g'`
/bin/echo „SKIP” >> ${BOOTLOG}
returnați 0
}
#################################################################### ##############################
# log_info_msg() #
# Utilizare: mesajul log_info_msg #
# #
# Scop: Imprimați un mesaj de informare pe ecran și #
# un fișier jurnal de pornire. Nu tipărește un caracter de linie nouă. #
# #
# Valori returnate: neutilizat #
#################################################################### ##############################
log_info_msg()
{
/bin/echo -n -e „${BMPREFIX}${@}”
# Eliminați caracterele neprintabile din fișierul jurnal logmessage=`echo „${@}” | sed 's/\\\033[^a-zA-Z]*.//g'` timespec
/bin/echo -n -e „${STAMP} ${logmessage}” >> ${BOOTLOG}
returnați 0
}
log_info_msg2()
{
/bin/echo -n -e „${@}”
# Eliminați caracterele neprintabile din fișierul jurnal logmessage=`echo „${@}” | sed 's/\\\033[^a-zA-Z]*.//g'`
/bin/echo -n -e „${logmessage}” >> ${BOOTLOG}
returnați 0
}
#################################################################### ##############################
# evaluate_retval() #
# Utilizare: Evaluați o valoare de returnare și imprimați succesul sau eșecul după caz #
# #
# Scop: Funcție comodă pentru a termina un mesaj informativ #
# #
# Valori returnate: neutilizat #
#################################################################### ##############################
evaluate_retval()
{
local error_value="${?}"
dacă [ ${error_value} = 0 ]; apoi log_success_msg2
altfel
log_failure_msg2
fi
}
#################################################################### ##############################
# check_signal() #
# Utilizare: check_signal [ -{signal} | {semnal} ] #
# #
# Scop: Verificați dacă există un semnal valid. Acest lucru nu este definit de niciun proiect LSB, #
# cu toate acestea, este necesar să se verifice semnalele pentru a determina dacă #
# semnalele alese sunt argumente nevalide pentru celelalte funcții. #
# #
# Intrări: acceptă o singură valoare de șir sub forma sau -{semnal} sau {semnal} #
# #
# Valori returnate: #
# 0 - Succes (semnalul este valid #
# 1 - Semnalul nu este valid #
#################################################################### ##############################
check_signal()
{
valsig local
# Adăugați gestionarea erorilor pentru semnale nevalide
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"
ecou „${valsig}” | grep -- " ${1} " > /dev/null if [ "${?}" -eq "0" ]; atunci
returnați 0
altfel
returnați 1
fi
}
#################################################################### ##############################
# check_sig_type() #
# Utilizare: check_signal [ -{signal} | {semnal} ] #
# #
# Scop: Verificați dacă semnalul este un semnal de terminare a programului sau un semnal de control #
# Acest lucru nu este definit de nicio schiță LSB, totuși, este necesar să #
# verificați semnalele pentru a determina dacă sunt destinate să încheie un #
# program sau pur și simplu pentru a-l controla. #
# #
# Intrări: acceptă o singură valoare de șir sub forma sau -{semnal} sau {semnal} #
# #
# Valori returnate: #
# 0 - Semnalul este folosit pentru terminarea programului #
# 1 - Semnalul este folosit pentru controlul programului #
#################################################################### ##############################
check_sig_type()
{
valsig local
# Lista semnalelor de terminare (limitată la articolele utilizate în general) valsig="-ALRM -INT -KILL -TERM -PWR -STOP -ABRT -QUIT -2 -3 -6 -9 -14 -15"
ecou „${valsig}” | grep -- " ${1} " > /dev/null if [ "${?}" -eq "0" ]; atunci
returnați 0
altfel
returnați 1
fi
}
#################################################################### ##############################
# wait_for_user() #
# #
# Scop: așteptați ca utilizatorul să răspundă dacă nu este un sistem fără cap #
# #
#################################################################### ##############################
wait_for_user()
{
# Așteptați utilizatorul în mod implicit
[ "${HEADLESS=0}" = "0" ] && citește ENTER
returnați 0
}
#################################################################### ##############################
# este adevarat() #
# #
# Scop: Utilitate pentru a testa dacă o variabilă este adevărată | da | 1 #
# #
#################################################################### ##############################
este adevarat()
{
[ "$1" = "1" ] || [ "$1" = "da" ] || [ "$1" = "adevărat" ] || [ "$1" = "y" ] || [ "$1" = "t" ]
}
# Încheiați /lib/lsb/init-functions
returnați 0
altfel
returnați 1
fi
}
#################################################################### ##############################
# wait_for_user() #
# #
# Scop: așteptați ca utilizatorul să răspundă dacă nu este un sistem fără cap #
# #
#################################################################### ##############################
wait_for_user()
{
# Așteptați utilizatorul în mod implicit
[ "${HEADLESS=0}" = "0" ] && citește ENTER
returnați 0
}
#################################################################### ##############################
# este adevarat() #
# #
# Scop: Utilitate pentru a testa dacă o variabilă este adevărată | da | 1 #
# #
#################################################################### ##############################
este adevarat()
{
[ "$1" = "1" ] || [ "$1" = "da" ] || [ "$1" = "adevărat" ] || [ "$1" = "y" ] || [ "$1" = "t" ]
}
# Încheiați /lib/lsb/init-functions
: Gerard Beekmans - [e-mail protejat] DJ Lucas - [e-mail protejat]
: Bruce Dubbs - [e-mail protejat]
: Gerard Beekmans - [e-mail protejat] DJ Lucas - [e-mail protejat]
: Bruce Dubbs - [e-mail protejat]
: LFS 7.0
: LFS 7.0
mountvirtfs
mountvirtfs
S
S