DokumentationD.2. /lib/lsb/init-functions
# / Bin / sh
################################################ ######################
#
# Beginnen Sie mit /lib/lsb/init-funtions
#
# Beschreibung: Run-Level-Steuerungsfunktionen
#
# / Bin / sh
################################################ ######################
#
# Beginnen Sie mit /lib/lsb/init-funtions
#
# Beschreibung: Run-Level-Steuerungsfunktionen
#
# Autoren
#
# Aktualisieren
#
# Ausführung
#
# Hinweise
#
#
#
#
# Autoren
#
# Aktualisieren
#
# Ausführung
#
# Hinweise
#
#
#
#
################################################ ######################
## Umwelteinrichtung
# Richten Sie Standardwerte für die Umgebung umask 022 ein
export PATH="/bin:/usr/bin:/sbin:/usr/sbin"
## Farbbefehle festlegen, verwendet über Echo
# Weitere Informationen finden Sie unter „man console_codes“.
# im Abschnitt „ECMA-48 Set Graphics Rendition“.
#
# Warnung: Beim Wechsel von einer 8-Bit- zu einer 9-Bit-Schriftart
# Die Linux-Konsole interpretiert das fettgedruckte (1;) neu in
################################################ ######################
## Umwelteinrichtung
# Richten Sie Standardwerte für die Umgebung umask 022 ein
export PATH="/bin:/usr/bin:/sbin:/usr/sbin"
## Farbbefehle festlegen, verwendet über Echo
# Weitere Informationen finden Sie unter „man console_codes“.
# im Abschnitt „ECMA-48 Set Graphics Rendition“.
#
# Warnung: Beim Wechsel von einer 8-Bit- zu einer 9-Bit-Schriftart
# Die Linux-Konsole interpretiert das fettgedruckte (1;) neu in
# die oberen 256 Glyphen der 9-Bit-Schriftart. Das macht
# wirkt sich nicht auf Framebuffer-Konsolen aus
NORMAL="\\033[0;39m" # Standardkonsole grau SUCCESS="\\033[1;32m" # Erfolg ist grün WARNING="\\033[1;33m" # Warnungen sind gelb FAILURE="\\ 033[1;31m" # Fehler sind rot INFO="\\033[1;36m" # Informationen sind hellcyan BRACKET="\\033[1;34m" # Klammern sind blau
# Verwenden Sie ein farbiges Präfix 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} WARNUNG ${BRACKET}]${NORMAL}" SKIP_SUFFIX="${BRACKET}[${INFO} ÜBERSPRINGEN ${BRACKET}]${NORMAL}"
BOOTLOG=/run/bootlog KILLDELAY=3 SCRIPT_STAT="0"
# Legen Sie alle vom Benutzer angegebenen Umgebungsvariablen fest, z. B. HEADLESS [ -r /etc/sysconfig/rc.site ] && . /etc/sysconfig/rc.site
## Bildschirmabmessungen
# Aktuelle Bildschirmgröße ermitteln if [ -z "${COLUMNS}" ]; Dann
COLUMNS=$(stty size) COLUMNS=${COLUMNS##* }
fi
# Bei Verwendung von Remote-Verbindungen, z. B. einem seriellen Port, gibt stty size 0 zurück, wenn [ "${COLUMNS}" = "0" ]; Dann
SPALTEN=80
fi
## Messungen zur Positionierung von Ergebnismeldungen COL=$((${COLUMNS} - 8))
WCOL=$((${COL} - 2))
## Cursorpositionsbefehle festlegen, verwendet über echo SET_COL="\\033[${COL}G" # am $COL char SET_WCOL="\\033[${WCOL}G" # am $WCOL char CURS_UP= "\\033[1A\\033[0G" # Eine Zeile nach oben, am 0. Zeichen CURS_ZERO="\\033[0G"
############################################### #############################
# start_daemon() #
# Verwendung: start_daemon [-f] [-n nicelevel] [-p pidfile] Pfadname [Argumente...] #
# #
# Zweck: Dadurch wird das angegebene Programm als Daemon ausgeführt #
# #
# Eingaben: -f: (erzwingen), das Programm auszuführen, auch wenn es bereits läuft. #
# -n nicelevel: Geben Sie ein nettes Level an. Siehe „man nice(1)“. #
# -p PID-Datei: Verwenden Sie die angegebene Datei, um PIDs zu ermitteln. #
# Pfadname: der vollständige Pfad zum angegebenen Programm #
# args: zusätzliche Argumente, die an das Programm übergeben werden (Pfadname) #
# #
# Rückgabewerte (wie durch LSB-Exit-Codes definiert): #
# 0 - Programm läuft oder Dienst ist in Ordnung #
# 1 – allgemeiner oder nicht spezifizierter Fehler #
# 2 – ungültige oder übermäßige Argumente #
# 5 - Programm ist nicht installiert #
############################################### #############################
start_daemon()
{
local force="" local nice="0" local pidfile="" local pidlist="" local retval=""
# Argumente verarbeiten, solange sie wahr sind
do
Fall „${1}“ in
-F)
force="1" Verschiebung 1
;;
an)
nice="${2}" Schicht 2
;;
-P)
pidfile="${2}" Schicht 2
;;
-*)
2 zurückgeben
;;
erledigt
*)
esac
program="${1}" Pause
;;
# Suchen Sie nach einem gültigen Programm
Wenn [ ! -e "${Programm}" ]; dann 5 zurückgeben; fi
# Ausführen
if [ -z "${force}" ]; Dann
if [ -z "${pidfile}" ]; Dann
# Bestimmen Sie die PID durch Entdeckung pidlist=`pidofproc "${1}"` retval="${?}"
sonst
# Die PID-Datei enthält die benötigten PIDs
# Beachten Sie, dass gemäß der LSB-Anforderung der Pfad an pidofproc übergeben werden muss.
# wird jedoch von der aktuellen Implementierung oder dem aktuellen Standard nicht verwendet. pidlist=`pidofproc -p "${pidfile}" "${1}"`
retval="${?}"
fi
# NUR einen Wert zurückgeben
# Es liegt in der Verantwortung des Init-Skripts (oder der Funktionen der Distribution).
# um Nachrichten zu protokollieren! Fall „${retval}“ in
0)
# Programm läuft bereits korrekt, das ist ein
#erfolgreicher Start. 0 zurückgeben
;;
1)
# Programm läuft nicht, aber es ist eine ungültige PID-Datei vorhanden
# PID-Datei entfernen und fortfahren rm -f "${pidfile}"
;;
3)
# Programm läuft nicht und es existiert keine PID-Datei
# Hier nichts tun, start_deamon fortfahren lassen.
;;
*)
esac
fi
# Andere von Statuswerten zurückgegebene Werte dürfen nicht interpretiert werden
# und als nicht spezifizierter Fehler zurückgegeben. Rückkehr 1
;;
# Mach den Anfang!
nice -n "${nice}" "${@}"
}
############################################### #############################
# killproc() #
# Verwendung: killproc [-p pidfile] Pfadname [signal] #
# #
# Zweck: Steuersignale an laufende Prozesse senden #
# #
# Eingaben: -p pidfile, verwendet die angegebene pidfile #
# Pfadname, Pfadname zum angegebenen Programm #
# Signal, sende dieses Signal an Pfadname #
# #
# Rückgabewerte (wie durch LSB-Exit-Codes definiert): #
# 0 - Programm (Pfadname) wurde gestoppt/ist bereits gestoppt oder ein #
# | laufendes Programm gesendet wurde angegeben | Signal und | gestoppt | # | |
# | erfolgreich | # | |||
# | 1 | – allgemeiner oder nicht spezifizierter Fehler | # | ||
# | 2 | - ungültige oder übermäßige Argumente | # | ||
# | 5 | - Programm ist nicht installiert | # | ||
# | 7 | - Programm läuft nicht und es ertönte ein Signal | geliefert | # |
############################################### #############################
killproc()
{
lokale PID-Datei, lokales Programm, lokales Präfix, lokaler Programmname
local signal="-TERM" local fallback="-KILL" lokales Nosig
lokale PID-Liste, lokaler Retval, lokale PID
Local Delay="30" Local Piddead Local Dtime
# Argumente verarbeiten, während true; Tun
Fall „${1}“ in
-P)
pidfile="${2}" Schicht 2
;;
*)
Programm="${1}"
if [-n "${2}" ]; then signal="${2}" fallback=""
sonst
nosig=1
fi
# Fehler bei zusätzlichen Argumenten if [ -n "${3}" ]; Dann
2 zurückgeben
sonst
brechen
erledigt
fi
;;
esac
# Suchen Sie nach einem gültigen Programm
Wenn [ ! -e "${Programm}" ]; dann 5 zurückgeben; fi
# Auf ein gültiges Signal prüfen check_signal "${signal}"
if [ "${?}" -ne "0" ]; dann 2 zurückgeben; fi
# Holen Sie sich eine Liste der PIDs
if [ -z "${pidfile}" ]; Dann
# Bestimmen Sie die PID durch Entdeckung pidlist=`pidofproc "${1}"` retval="${?}"
sonst
# Die PID-Datei enthält die benötigten PIDs
# Beachten Sie, dass gemäß der LSB-Anforderung der Pfad an pidofproc übergeben werden muss.
# wird jedoch von der aktuellen Implementierung oder dem aktuellen Standard nicht verwendet. pidlist=`pidofproc -p "${pidfile}" "${1}"`
retval="${?}"
fi
# NUR einen Wert zurückgeben
# Es liegt in der Verantwortung des Init-Skripts (oder der Funktionen der Distribution).
# um Nachrichten zu protokollieren! Fall „${retval}“ in
0)
# Programm läuft korrekt
# Tun Sie hier nichts, lassen Sie killproc weitermachen.
;;
1)
# Programm läuft nicht, aber es ist eine ungültige PID-Datei vorhanden
# Entfernen Sie die PID-Datei. rm -f "${pidfile}"
# Dies ist nur dann ein Erfolg, wenn kein Signal übergeben wurde. if [ -n "${nosig}" ]; Dann
0 zurückgeben
sonst
7 zurückgeben
fi
;;
3)
# Programm läuft nicht und es existiert keine PID-Datei
# Dies ist nur dann ein Erfolg, wenn kein Signal übergeben wurde. if [ -n "${nosig}" ]; Dann
0 zurückgeben
sonst
7 zurückgeben
fi
;;
*)
esac
# Andere von Statuswerten zurückgegebene Werte dürfen nicht interpretiert werden
# und als nicht spezifizierter Fehler zurückgegeben. Rückkehr 1
;;
# Verschiedene Aktionen für Ausgangssignale und Steuersignale ausführen check_sig_type "${signal}"
if [ "${?}" -eq "0" ]; dann wird das #-Signal verwendet, um das Programm zu beenden
# Konto für leere PID-Liste (PID-Datei existiert noch und Nr
# Signal wurde gegeben)
if [ "${pidlist}" != "" ]; Dann
# Töte die Liste der PIDs für PID in ${pidlist}; Tun
kill -0 "${pid}" 2> /dev/null if [ "${?}" -ne "0" ]; Dann
# Prozess ist tot, fahren Sie mit dem nächsten Schritt fort und gehen Sie davon aus, dass alles in Ordnung ist. Fahren Sie fort
sonst
kill „${signal}“ „${pid}“ 2> /dev/null
# Warten Sie bis zu ${delay}/10 Sekunden auf „${pid}“.
# in Zehntelsekunden beenden
while [ "${delay}" -ne "0" ]; Tun
kill -0 "${pid}" 2> /dev/null || piddead="1" if [ "${piddead}" = "1" ]; dann brechen; fi Schlaf 0.1
Verzögerung="$(( ${delay} - 1 ))"
erledigt
# Wenn ein Fallback eingestellt ist und das Programm noch läuft, dann
# Verwenden Sie den Fallback
if [-n "${fallback}" -a "${piddead}" != "1" ]; dann töte „${fallback}“ „${pid}“ 2> /dev/null
Schlaf 1
# Überprüfen Sie es erneut und schlagen Sie fehl, wenn kill -0 "${pid}" 2> /dev/null && return 1 immer noch ausgeführt wird
fi
fi
erledigt
fi
# Suchen Sie nach veralteten PID-Dateien und entfernen Sie diese. if [ -z "${pidfile}" ]; Dann
# Finden Sie den Basisnamen von $program
prefix=`echo „${program}“ | sed 's/[^/]*$//'` progname=`echo "${program}" | sed "s@${prefix}@@"`
if [ -e "/var/run/${progname}.pid" ]; Dann
rm -f "/var/run/${progname}.pid" 2> /dev/null
fi
sonst
if [ -e "${pidfile}" ]; then rm -f "${pidfile}" 2> /dev/null; fi
fi
# Für Signale, die nicht erwarten, dass ein Programm beendet wird, einfach
# Lassen Sie kill seinen Job machen und bewerten Sie den Ertrag von kill nach seinem Wert
else# check_sig_type – Signal wird nicht zum Beenden des Programms für PID in ${pidlist} verwendet; Tun
töte „${signal}“ „${pid}“
if [ "${?}" -ne "0" ]; dann 1 zurückgeben; fi
erledigt
fi
}
############################################### #############################
# pidofproc() #
# Verwendung: pidofproc [-p pidfile] Pfadname #
# #
# Zweck: Diese Funktion gibt eine oder mehrere PID(s) für einen bestimmten Daemon zurück #
# #
# Eingaben: -p PID-Datei, verwenden Sie die angegebene PID-Datei anstelle von PIDOF #
# Pfadname, Pfad zum angegebenen Programm #
# #
# Rückgabewerte (wie durch LSB-Statuscodes definiert): #
# 0 – Erfolg (PIDs auf Standardausgabe) #
# 1 – Programm ist tot, PID-Datei existiert noch (verbleibende PID-Ausgabe) #
# 3 - Programm läuft nicht (keine Ausgabe) #
############################################### #############################
pidofproc()
{
lokale PID-Datei, lokales Programm, lokales Präfix, lokaler Programmname, lokale PID-Liste, lokale Lpids
lokaler Exitstatus="0"
# Argumente verarbeiten, während true; Tun
Fall „${1}“ in
-P)
pidfile="${2}" Schicht 2
;;
*)
Programm="${1}"
if [ -n "${2}" ]; Dann
# Zu viele Argumente
# Da dies der Status ist, gebe unbekannte Rückgabe 4 zurück
sonst
brechen
erledigt
fi
;;
esac
# Wenn keine PID-Datei angegeben ist, versuchen Sie, eine zu finden. if [ -z "${pidfile}" ]; Dann
# Holen Sie sich den Basisnamen des Programms
prefix=`echo „${program}“ | sed 's/[^/]*$//'` if [ -z "${prefix}" ]; Dann
progname="${program}" sonst
progname=`echo „${program}“ | sed "s@${prefix}@@"`
fi
# Wenn eine PID-Datei mit diesem Namen existiert, gehen Sie davon aus, dass es sich um eine solche handelt. if [ -e "/var/run/${progname}.pid" ]; Dann
pidfile="/var/run/${progname}.pid"
fi
fi
# Wenn eine PID-Datei festgelegt ist und existiert, verwenden Sie sie.
if [ -n "${pidfile}" -a -e "${pidfile}" ]; Dann
# Verwenden Sie den Wert in der ersten Zeile der PID-Datei pidlist=`/bin/head -n1 "${pidfile}"`
# Dies kann optional als „sed 1q“ geschrieben werden, um „head -n1“ zu ersetzen.
# sollte LFS /bin/head nach /usr/bin/head verschieben
sonst
# Verwenden Sie pidof
pidlist=`pidof „${program}“`
fi
# Finden Sie heraus, ob alle aufgelisteten PIDs ausgeführt werden. für pid in ${pidlist}; Tun
kill -0 ${pid} 2> /dev/null
if ["${?}" -eq "0" ]; then lpids="${lpids}${pid} "
sonst
Exitstatus="1"
fi
erledigt
if [-z "${lpids}" -a ! -f "${pidfile}" ]; dann gebe 3 zurück
sonst
echo „${lpids}“
gebe „${exitstatus}“ zurück
fi
}
############################################### #############################
# statusproc() #
# Verwendung: statusproc [-p pidfile] Pfadname #
# #
# Zweck: Diese Funktion gibt den Status eines bestimmten Daemons auf stdout aus #
# #
# Eingaben: -p PID-Datei, verwenden Sie die angegebene PID-Datei anstelle von PIDOF #
# Pfadname, Pfad zum angegebenen Programm #
# #
# Rückgabewerte: #
# 0 - Status gedruckt #
# 1 – Eingabefehler. Der zu überprüfende Daemon wurde nicht angegeben. #
############################################### #############################
statusproc()
{
lokale PID-Datei, lokale PID-Liste
if [ "${#}" = "0" ]; Dann
echo „Verwendung: statusproc [-p pidfle] {Programm}“ Exit 1
fi
# Argumente verarbeiten, während true; Tun
Fall „${1}“ in
-P)
pidfile="${2}" Schicht 2
;;
*)
if [ -n "${2}" ]; Dann
echo „Zu viele Argumente“ gibt 1 zurück
sonst
brechen
erledigt
fi
;;
esac
if [ -n "${pidfile}" ]; dann pidlist=`pidofproc -p "${pidfile}" $@`
sonst
pidlist=`pidofproc $@`
fi
# Nachgestellte Leerzeichen kürzen
pidlist=`echo „${pidlist}“ | sed -r 's/ +$//'` base="${1##*/}"
if [ -n "${pidlist}" ]; Dann
/bin/echo -e „${INFO}${base} läuft mit Prozess“ \ „ID(s) ${pidlist}.${NORMAL}“
sonst
if [ -n "${base}" -a -e "/var/run/${base}.pid" ]; Dann
/bin/echo -e „${WARNING}${1} läuft nicht, aber“ \ „/var/run/${base}.pid existiert.${NORMAL}“
sonst
if [ -n "${pidfile}" -a -e "${pidfile}" ]; Dann
/bin/echo -e „${WARNING}${1} läuft nicht“ \ „aber ${pidfile} existiert.${NORMAL}“
sonst
/bin/echo -e „${INFO}${1} läuft nicht.${NORMAL}“
fi
fi
fi
}
############################################### #############################
# timespec() #
# #
# Zweck: Eine interne Hilfsfunktion zum Formatieren eines Zeitstempels #
# eine Boot-Protokolldatei. Legt die STAMP-Variable fest. #
# #
# Rückgabewert: Nicht verwendet #
############################################### #############################
Zeitangabe()
{
STAMP="$(echo `date +"%b %d %T %:z"` `hostname`) " gibt 0 zurück
}
############################################### #############################
# log_success_msg() #
# Verwendung: log_success_msg ["message"] #
# #
# Zweck: Eine erfolgreiche Statusmeldung auf dem Bildschirm ausgeben und #
# eine Boot-Protokolldatei. #
# #
# Eingaben: $@ - Nachricht #
# #
# Rückgabewerte: Nicht verwendet #
############################################### #############################
log_success_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${SUCCESS_PREFIX}${SET_COL}${SUCCESS_SUFFIX}"
# Nicht druckbare Zeichen aus der Protokolldatei entfernen logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g''
Zeitangabe
/bin/echo -e "${STAMP} ${logmessage} OK" >> ${BOOTLOG}
0 zurückgeben
}
log_success_msg2()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${SUCCESS_PREFIX}${SET_COL}${SUCCESS_SUFFIX}" echo " OK" >> ${BOOTLOG}
0 zurückgeben
}
############################################### #############################
# log_failure_msg() #
# Verwendung: log_failure_msg ["message"] #
# #
# Zweck: Eine Fehlerstatusmeldung auf dem Bildschirm ausgeben und #
# eine Boot-Protokolldatei. #
# #
# Eingaben: $@ - Nachricht #
# #
# Rückgabewerte: Nicht verwendet #
############################################### #############################
log_failure_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${FAILURE_PREFIX}${SET_COL}${FAILURE_SUFFIX}"
# Nicht druckbare Zeichen aus der Zeitangabe der Protokolldatei entfernen
logmessage=`echo „${@}“ | sed 's/\\\033[^a-zA-Z]*.//g''
/bin/echo -e "${STAMP} ${logmessage} FAIL" >> ${BOOTLOG}
0 zurückgeben
}
log_failure_msg2()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${FAILURE_PREFIX}${SET_COL}${FAILURE_SUFFIX}" echo "FAIL" >> ${BOOTLOG}
0 zurückgeben
}
############################################### #############################
# log_warning_msg() #
# Verwendung: log_warning_msg ["message"] #
# #
# Zweck: Eine Warnmeldung auf dem Bildschirm ausgeben und #
# eine Boot-Protokolldatei. #
# #
# Rückgabewerte: Nicht verwendet #
############################################### #############################
log_warning_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${WARNING_PREFIX}${SET_COL}${WARNING_SUFFIX}"
# Nicht druckbare Zeichen aus der Protokolldatei entfernen logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g'` timespec
/bin/echo -e "${STAMP} ${logmessage} WARN" >> ${BOOTLOG}
0 zurückgeben
}
log_skip_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
/bin/echo -e "${CURS_ZERO}${SKIP_PREFIX}${SET_COL}${SKIP_SUFFIX}"
# Nicht druckbare Zeichen aus der Protokolldatei entfernen logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g''
/bin/echo "SKIP" >> ${BOOTLOG}
0 zurückgeben
}
############################################### #############################
# log_info_msg() #
# Verwendung: log_info_msg message #
# #
# Zweck: Eine Informationsmeldung auf dem Bildschirm ausgeben und #
# eine Boot-Protokolldatei. Druckt kein nachgestelltes Zeilenumbruchzeichen. #
# #
# Rückgabewerte: Nicht verwendet #
############################################### #############################
log_info_msg()
{
/bin/echo -n -e "${BMPREFIX}${@}"
# Nicht druckbare Zeichen aus der Protokolldatei entfernen logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g'` timespec
/bin/echo -n -e "${STAMP} ${logmessage}" >> ${BOOTLOG}
0 zurückgeben
}
log_info_msg2()
{
/bin/echo -n -e "${@}"
# Nicht druckbare Zeichen aus der Protokolldatei entfernen logmessage=`echo "${@}" | sed 's/\\\033[^a-zA-Z]*.//g''
/bin/echo -n -e "${logmessage}" >> ${BOOTLOG}
0 zurückgeben
}
############################################### #############################
# evaluieren_retval() #
# Verwendung: Werten Sie einen Rückgabewert aus und geben Sie je nach Bedarf „Erfolg“ oder „Fehler“ aus.
# #
# Zweck: Komfortfunktion zum Beenden einer Info-Nachricht #
# #
# Rückgabewerte: Nicht verwendet #
############################################### #############################
evaluieren_retval()
{
local error_value="${?}"
if [ ${error_value} = 0 ]; dann log_success_msg2
sonst
log_failure_msg2
fi
}
############################################### #############################
# check_signal() #
# Verwendung: check_signal [ -{signal} | {signal} ] #
# #
# Zweck: Auf ein gültiges Signal prüfen. Dies ist in keinem LSB-Entwurf definiert, #
# Es ist jedoch erforderlich, die Signale zu überprüfen, um festzustellen, ob #
# ausgewählte Signale sind ungültige Argumente für die anderen Funktionen. #
# #
# Eingaben: Akzeptiert einen einzelnen Zeichenfolgenwert in der Form oder -{signal} oder {signal} #
# #
# Rückgabewerte: #
# 0 - Erfolg (Signal ist gültig #
# 1 – Signal ist ungültig #
############################################### #############################
check_signal()
{
lokales Valsig
# Fehlerbehandlung für ungültige Signale hinzufügen
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" ]; Dann
0 zurückgeben
sonst
1 zurückgeben
fi
}
############################################### #############################
# check_sig_type() #
# Verwendung: check_signal [ -{signal} | {signal} ] #
# #
# Zweck: Prüfen, ob es sich bei dem Signal um ein Programmbeendigungssignal oder ein Steuersignal handelt #
# Dies ist in keinem LSB-Entwurf definiert, es ist jedoch erforderlich, #
# Überprüfen Sie die Signale, um festzustellen, ob sie dazu gedacht sind, ein # zu beenden.
# programmieren oder einfach steuern. #
# #
# Eingaben: Akzeptiert einen einzelnen Zeichenfolgenwert in der Form oder -{signal} oder {signal} #
# #
# Rückgabewerte: #
# 0 - Signal wird zum Programmabbruch verwendet #
# 1 - Signal wird zur Programmsteuerung verwendet #
############################################### #############################
check_sig_type()
{
lokales Valsig
# Die Liste der Beendigungssignale (beschränkt auf allgemein verwendete Elemente) valsig="-ALRM -INT -KILL -TERM -PWR -STOP -ABRT -QUIT -2 -3 -6 -9 -14 -15"
echo „${valsig}“ | grep -- " ${1} " > /dev/null if [ "${?}" -eq "0" ]; Dann
0 zurückgeben
sonst
1 zurückgeben
fi
}
############################################### #############################
# wait_for_user() #
# #
# Zweck: Auf die Antwort des Benutzers warten, wenn es sich nicht um ein Headless-System handelt #
# #
############################################### #############################
wait_for_user()
{
# Standardmäßig auf den Benutzer warten
[ "${HEADLESS=0}" = "0" ] && lesen ENTER
0 zurückgeben
}
############################################### #############################
# ist wahr() #
# #
# Zweck: Dienstprogramm zum Testen, ob eine Variable wahr ist | ja | 1 #
# #
############################################### #############################
ist wahr()
{
[ "$1" = "1" ] || [ "$1" = "ja" ] || [ "$1" = "true" ] || [ "$1" = "y" ] || [ "$1" = "t" ]
}
# /lib/lsb/init-functions beenden
0 zurückgeben
sonst
1 zurückgeben
fi
}
############################################### #############################
# wait_for_user() #
# #
# Zweck: Auf die Antwort des Benutzers warten, wenn es sich nicht um ein Headless-System handelt #
# #
############################################### #############################
wait_for_user()
{
# Standardmäßig auf den Benutzer warten
[ "${HEADLESS=0}" = "0" ] && lesen ENTER
0 zurückgeben
}
############################################### #############################
# ist wahr() #
# #
# Zweck: Dienstprogramm zum Testen, ob eine Variable wahr ist | ja | 1 #
# #
############################################### #############################
ist wahr()
{
[ "$1" = "1" ] || [ "$1" = "ja" ] || [ "$1" = "true" ] || [ "$1" = "y" ] || [ "$1" = "t" ]
}
# /lib/lsb/init-functions beenden
: Gerard Beekmans - [E-Mail geschützt] DJ Lucas - [E-Mail geschützt]
: Bruce Dubbs - [E-Mail geschützt]
: Gerard Beekmans - [E-Mail geschützt] DJ Lucas - [E-Mail geschützt]
: Bruce Dubbs - [E-Mail geschützt]
: LFS 7.0
: LFS 7.0
mountvirtfs
mountvirtfs
S
S