# -*-Shell-script-*-
#
# functions This file contains functions to be used by most or all
# shell scripts in the /etc/init.d directory.
#
TEXTDOMAIN=initscripts
TEXTDOMAINDIR=/etc/locale
LOCPATH=/etc/locale
export TEXTDOMAINDIR LOCPATH
TMP=/tmp
TMPDIR=/tmp
export TMP TMPDIR
# Make sure umask is sane
umask 022
# Set up a default search path.
PATH="/sbin:/usr/sbin:/bin:/usr/bin"
export PATH
[ -z "${CONSOLETYPE:-}" ] && CONSOLETYPE="`/sbin/consoletype`"
# Get a sane screen width
[ -z "${COLUMNS:-}" ] && COLUMNS=80
function load_i18_settings() {
if [ -f /etc/sysconfig/i18n -a -z "$NOLOCALE" ]; then
. /etc/sysconfig/i18n
if [ "$CONSOLETYPE" != "pty" ]; then
[ "$CONSOLE_NOT_LOCALIZED" = "yes" ] && GP_LANG=C
[ "$CONSOLE_NOT_LOCALIZED" = "yes" ] && GP_LANGUAGE=C
fi
if [ -z "$GP_LANG" ]; then
[ -n "$LC_CTYPE" ] && GP_LANG=$LC_CTYPE || GP_LANG=$LC_MESSAGES
fi
if [ -z "$GP_LANGUAGE" ]; then
[ -n "$LANGUAGE" ] && GP_LANGUAGE=$LANGUAGE || GP_LANGUAGE=$GP_LANG
fi
fi
}
function reset_i18_settings() {
local CONSOLE_NOT_LOCALIZED=yes
LC_ALL=C
load_i18_settings
}
load_i18_settings
# Read in our configuration
if [ -z "${BOOTUP:-}" ]; then
if [ -f /etc/sysconfig/init ]; then
. /etc/sysconfig/init
else
# This all seem confusing? Look in /etc/sysconfig/init,
# or in /usr/share/doc/initscripts-*/sysconfig.txt
BOOTUP=color
RES_COL=60
MOVE_TO_COL="echo -en \\033[${RES_COL}G"
SETCOLOR_SUCCESS="echo -en \\033[1;32m"
SETCOLOR_FAILURE="echo -en \\033[1;31m"
SETCOLOR_WARNING="echo -en \\033[1;33m"
SETCOLOR_NORMAL="echo -en \\033[0;39m"
LOGLEVEL=1
fi
if [ "$CONSOLETYPE" = "serial" ]; then
BOOTUP=serial
MOVE_TO_COL=
SETCOLOR_SUCCESS=
SETCOLOR_FAILURE=
SETCOLOR_WARNING=
SETCOLOR_NORMAL=
fi
fi
if [ "${BOOTUP:-}" != "verbose" ]; then
INITLOG_ARGS="-q"
else
INITLOG_ARGS=
fi
gprintf() {
if [ -x /bin/gettext -a -n "$1" ]; then
if [ -n "$GP_LANG" ]; then
local TEXT=`LC_ALL=$GP_LANG LANGUAGE=$GP_LANGUAGE gettext -e --domain=$TEXTDOMAIN -- "$1"`
else
local TEXT=`gettext -e --domain=$TEXTDOMAIN -- "$1"`
fi
else
local TEXT=$1
fi
[ "${1#*\\n}" ] || TEXT="$TEXT\n"
shift
printf -- "$TEXT" "$@"
}
# Frontend to gprintf (support up to 4 %s in format string)
# returns the message transleted in GPRINTF_MSG and
# the resting parms in GPRINTF_REST
# This simplifies a lot the call of functions like action,
# now with i18n support
gprintf_msg_rest() {
case "$1" in
*%s*%s*%s*%s*)
GPRINTF_MSG=$(gprintf "$1" "$2" "$3" "$4" "$5")
shift 5;;
*%s*%s*%s*)
GPRINTF_MSG=$(gprintf "$1" "$2" "$3" "$4")
shift 4;;
*%s*%s*)
GPRINTF_MSG=$(gprintf "$1" "$2" "$3")
shift 3;;
*%s*)
GPRINTF_MSG=$(gprintf "$1" "$2")
shift 2;;
*)
GPRINTF_MSG=$(gprintf "$1")
shift;;
esac
GPRINTF_REST="$@"
}
# Check if $pid (could be plural) are running with
# the same root as this script
inmyroot() {
local i r
for i in $* ; do
[ "/proc/$i/root" -ef "/proc/$$/root" ] && r="$r $i"
done
echo "$r"
}
# Interpret escape sequences in an fstab entry
fstab_decode_str() {
fstab-decode echo "$1"
}
# Check if $pid (could be plural) are running
checkpid() {
local i
for i in $* ; do
[ -d "/proc/$i" ] && return 0
done
return 1
}
__readlink() {
ls -bl "$@" 2>/dev/null| awk '{ print $NF }'
}
__fgrep() {
s=$1
f=$2
while read line; do
if strstr "$line" "$s"; then
echo $line
return 0
fi
done < $f
return 1
}
# __umount_loop awk_program fstab_file first_msg retry_msg umount_args
# awk_program should process fstab_file and return a list of fstab-encoded
# paths; it doesn't have to handle comments in fstab_file.
__umount_loop() {
local remaining sig=
local retry=3 count
remaining=$(LC_ALL=C awk "/^#/ {next} $1" "$2" | sort -r)
while [ -n "$remaining" -a "$retry" -gt 0 ]; do
if [ "$retry" -eq 3 ]; then
action "$3" fstab-decode umount $5 $remaining
else
action "$4" fstab-decode umount $5 $remaining
fi
count=4
remaining=$(LC_ALL=C awk "/^#/ {next} $1" "$2" | sort -r)
while [ "$count" -gt 0 ]; do
[ -z "$remaining" ] && break
count=$(($count-1))
usleep 500000
remaining=$(LC_ALL=C awk "/^#/ {next} $1" "$2" | sort -r)
done
[ -z "$remaining" ] && break
fstab-decode /sbin/fuser -k -m $sig $remaining >/dev/null
sleep 3
retry=$(($retry -1))
sig=-9
done
}
# Similar to __umount loop above, specialized for loopback devices
__umount_loopback_loop() {
local remaining devremaining sig=
local retry=3
remaining=$(awk '$1 ~ /^\/dev\/loop/ && $2 != "/" {print $2}' /proc/mounts)
devremaining=$(awk '$1 ~ /^\/dev\/loop/ && $2 != "/" {print $1}' /proc/mounts)
while [ -n "$remaining" -a "$retry" -gt 0 ]; do
if [ "$retry" -eq 3 ]; then
action "Unmounting loopback filesystems: " \
fstab-decode umount $remaining
else
action "Unmounting loopback filesystems (retry):" \
fstab-decode umount $remaining
fi
for dev in $devremaining ; do
losetup $dev > /dev/null 2>&1 && \
action "Detaching loopback device %s: " $dev \
losetup -d $dev
done
remaining=$(awk '$1 ~ /^\/dev\/loop/ && $2 != "/" {print $2}' /proc/mounts)
devremaining=$(awk '$1 ~ /^\/dev\/loop/ && $2 != "/" {print $1}' /proc/mounts)
[ -z "$remaining" ] && break
fstab-decode /sbin/fuser -k -m $sig $remaining >/dev/null
sleep 3
retry=$(($retry -1))
sig=-9
done
}
# __proc_pids {program} [pidfile]
# Set $pid to pids from /var/run* for {program}. $pid should be declared
# local in the caller.
# Returns LSB exit code for the 'status' action.
__pids_var_run() {
local base=${1##*/}
local pid_file=${2:-/var/run/$base.pid}
pid=
if [ -f "$pid_file" ] ; then
local line p
read line < "$pid_file"
for p in $line ; do
[ -z "${p//[0-9]/}" -a -d "/proc/$p" ] && pid="$pid $p"
done
if [ -n "$pid" ]; then
return 0
fi
return 1 # "Program is dead and /var/run pid file exists"
fi
return 3 # "Program is not running"
}
# Output PIDs of matching processes, found using pidof
__pids_pidof() {
pidof -c -o $$ -o $PPID -o %PPID -x "$1" || \
pidof -c -o $$ -o $PPID -o %PPID -x "${1##*/}"
}
# A function to start a program.
daemon() {
# Test syntax.
local gotbase= force= nicelevel corelimit
local pid base= user= nice= bg= pid_file=
nicelevel=0
while [ "$1" != "${1##[-+]}" ]; do
case $1 in
'') gprintf "%s: Usage: daemon [+/-nicelevel] {program}\n" $0
return 1;;
--check)
base=$2
gotbase="yes"
shift 2
;;
--check=?*)
base=${1#--check=}
gotbase="yes"
shift
;;
--user)
user=$2
shift 2
;;
--user=?*)
user=${1#--user=}
shift
;;
--pidfile)
pid_file=$2
shift 2
;;
--pidfile=?*)
pid_file=${1#--pidfile=}
shift
;;
--force)
force="force"
shift
;;
[-+][0-9]*)
nice="nice -n $1"
shift
;;
*) gprintf "%s: Usage: daemon [+/-nicelevel] {program}\n" $0
return 1;;
esac
done
# Save basename.
[ -z "$gotbase" ] && base=${1##*/}
# See if it's already running. Look *only* at the pid file.
__pids_var_run "$base" "$pid_file"
[ -n "$pid" -a -z "$force" ] && return
# make sure it doesn't core dump anywhere unless requested
corelimit="ulimit -S -c ${DAEMON_COREFILE_LIMIT:-0}"
# if they set NICELEVEL in /etc/sysconfig/foo, honor it
[ -n "${NICELEVEL:-}" ] && nice="nice -n $NICELEVEL"
# Echo daemon
[ "${BOOTUP:-}" = "verbose" -a -z "${LSB:-}" ] && echo -n " $base"
# libsafe support
if [ -r /etc/sysconfig/system ] && grep -q '^LIBSAFE=yes$' /etc/sysconfig/system && [ -r /lib/libsafe.so.2 ]; then
LD_PRELOAD=/lib/libsafe.so.2
export LD_PRELOAD
fi
# And start it up.
if [ -z "$user" ]; then
$nice /bin/bash -c "$corelimit >/dev/null 2>&1 ; $*"
else
$nice su -s /bin/bash - $user -c "$corelimit >/dev/null 2>&1 ; $*"
fi
rc=$?
[ $rc = 0 ] && success "%s startup" $base || failure "%s startup" $base
unset LD_PRELOAD
return $rc
}
# A function to stop a program.
killproc() {
local RC killlevel= base pid pid_file= delay
RC=0; delay=3
# Test syntax.
if [ "$#" -eq 0 ]; then
gprintf "Usage: killproc [-p pidfile] [ -d delay] {program} [-signal]"
return 1
fi
if [ "$1" = "-p" ]; then
pid_file=$2
shift 2
fi
if [ "$1" = "-d" ]; then
delay=$2
shift 2
fi
# check for second arg to be kill level
[ -n "${2:-}" ] && killlevel=$2
# Save basename.
base=${1##*/}
# Find pid.
__pids_var_run "$1" "$pid_file"
if [ -z "$pid_file" -a -z "$pid" ]; then
pid="$(__pids_pidof "$1")"
fi
# Avoid killing processes not running in the same root
[ -n "$pid" ] && pid="`inmyroot $pid`"
# Kill it.
if [ -n "$pid" ] ; then
[ "$BOOTUP" = "verbose" -a -z "${LSB:-}" ] && echo -n "$base "
if [ -z "$killlevel" ] ; then
if checkpid $pid 2>&1; then
# TERM first, then KILL if not dead
kill -TERM $pid >/dev/null 2>&1
usleep 100000
if checkpid $pid && sleep 1 &&
checkpid $pid && sleep $delay &&
checkpid $pid ; then
kill -KILL $pid >/dev/null 2>&1
usleep 100000
fi
fi
checkpid $pid
RC=$?
[ "$RC" -eq 0 ] && failure "%s shutdown" $base || success "%s shutdown" $base
RC=$((! $RC))
# use specified level only
else
if checkpid $pid; then
kill $killlevel $pid >/dev/null 2>&1
RC=$?
[ "$RC" -eq 0 ] && success "%s %s" $base $killlevel || failure "%s %s" $base $killlevel
elif [ -n "${LSB:-}" ]; then
RC=7 # Program is not running
fi
fi
else
if [ -n "${LSB:-}" -a -n "$killlevel" ]; then
RC=7 # Program is not running
else
failure "%s shutdown" $base
RC=0
fi
fi
# Remove pid file if any.
if [ -z "$killlevel" ]; then
rm -f "${pid_file:-/var/run/$base.pid}"
fi
return $RC
}
# A function to find the pid of a program. Looks *only* at the pidfile
pidfileofproc() {
local pid
# Test syntax.
if [ "$#" -eq 0 ] ; then
gprintf "Usage: pidfileofproc {program}\n"
return 1
fi
__pids_var_run "$1"
[ -n "$pid" ] && echo $pid
return 0
}
# A function to find the pid of a program.
pidofproc() {
local RC pid pid_file=
# Test syntax.
if [ "$#" = 0 ]; then
gprintf "Usage: pidofproc [-p pidfile] {program}\n"
return 1
fi
if [ "$1" = "-p" ]; then
pid_file=$2
shift 2
fi
fail_code=3 # "Program is not running"
# First try "/var/run/*.pid" files
__pids_var_run "$1" "$pid_file"
RC=$?
if [ -n "$pid" ]; then
echo $pid
return 0
fi
[ -n "$pid_file" ] && return $RC
__pids_pidof "$1" || return $RC
}
status() {
local base pid pid_file=
# Test syntax.
if [ "$#" = 0 ] ; then
gprintf "Usage: status [-p pidfile] {program}\n"
return 1
fi
if [ "$1" = "-p" ]; then
pid_file=$2
shift 2
fi
base=${1##*/}
# First try "pidof"
pid="$(__pids_pidof "$1")"
if [ -n "$pid" ]; then
gprintf "%s (pid %s) is running...\n" ${base} "$pid"
return 0
fi
# Next try "/var/run/*.pid" files
__pids_var_run "$1" "$pid_file"
case "$?" in
0)
gprintf "%s (pid %s) is running...\n" ${base} "$pid"
return 0
;;
1)
gprintf "%s dead but pid file exists\n" ${base}
return 1
;;
esac
# See if /var/lock/subsys/${base} exists
if [ -f /var/lock/subsys/${base} ]; then
gprintf "%s dead but subsys locked\n" ${base}
return 2
fi
gprintf "%s is stopped\n" ${base}
return 3
}
echo_success() {
[ "$BOOTUP" = "color" ] && $MOVE_TO_COL
echo -n "["
[ "$BOOTUP" = "color" ] && $SETCOLOR_SUCCESS
gprintf " OK "
[ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
echo -n "]"
echo -ne "\r"
return 0
}
echo_failure() {
[ "$BOOTUP" = "color" ] && $MOVE_TO_COL
echo -n "["
[ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
gprintf "FAILED"
[ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
echo -n "]"
echo -ne "\r"
return 1
}
echo_passed() {
[ "$BOOTUP" = "color" ] && $MOVE_TO_COL
echo -n "["
[ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
gprintf "PASSED"
[ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
echo -n "]"
echo -ne "\r"
return 1
}
echo_warning() {
[ "$BOOTUP" = "color" ] && $MOVE_TO_COL
echo -n "["
[ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
gprintf "WARNING"
[ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
echo -n "]"
echo -ne "\r"
return 1
}
# Log that something succeeded
success() {
gprintf_msg_rest "$@"
#if [ -z "${IN_INITLOG:-}" ]; then
# initlog $INITLOG_ARGS -n $0 -s "$GPRINTF_MSG" -e 1
#fi
[ "$BOOTUP" != "verbose" -a -z "${LSB:-}" ] && echo_success
return 0
}
# Log that something failed
failure() {
local rc=$?
gprintf_msg_rest "$@"
#if [ -z "${IN_INITLOG:-}" ]; then
# initlog $INITLOG_ARGS -n $0 -s "$GPRINTF_MSG" -e 2
#fi
[ "$BOOTUP" != "verbose" -a -z "${LSB:-}" ] && echo_failure
return $rc
}
# Log that something passed, but may have had errors. Useful for fsck
passed() {
local rc=$?
gprintf_msg_rest "$@"
#if [ -z "${IN_INITLOG:-}" ]; then
# initlog $INITLOG_ARGS -n $0 -s "$GPRINTF_MSG" -e 1
#fi
[ "$BOOTUP" != "verbose" -a -z "${LSB:-}" ] && echo_passed
return $rc
}
# Log a warning
warning() {
local rc=$?
gprintf_msg_rest "$@"
#if [ -z "${IN_INITLOG:-}" ]; then
# initlog $INITLOG_ARGS -n $0 -s "$1" -e 1
#fi
[ "$BOOTUP" != "verbose" -a -z "${LSB:-}" ] && echo_warning
return $rc
}
# Run some action. Log its output.
action() {
local rc
gprintf_msg_rest "$@"
echo -n "$GPRINTF_MSG "
# libsafe support
if [ -r /etc/sysconfig/system ] && grep -q '^LIBSAFE=yes$' /etc/sysconfig/system && [ -r /lib/libsafe.so.2 ]; then
LD_PRELOAD=/lib/libsafe.so.2
export LD_PRELOAD
fi
$GPRINTF_REST && success "$GPRINTF_MSG" || failure "$GPRINTF_MSG"
rc=$?
echo
unset LD_PRELOAD
return $rc
}
# returns OK if $1 contains $2
strstr() {
[ "${1#*$2*}" = "$1" ] && return 1
return 0
}
# Confirm whether we really want to run this service
confirm() {
gprintf "Start service %s (Y)es/(N)o/(C)ontinue? [Y] \n" $1
local YES=`gprintf "yY"`
local NOT=`gprintf "nN"`
local CNT=`gprintf "cC"`
read answer
if strstr "$YES" "$answer" || [ "$answer" = "" ] ; then
return 0
elif strstr "$CNT" "$answer" ; then
return 2
elif strstr "$NOT" "$answer" ; then
return 1
fi
confirm $*
}
initsplash() {
# splash is initialized before udev, /dev/fb0 has to be created manually
if [ -e /sys/class/graphics/fb0 ] && [ ! -e /dev/fb0 ]; then
mknod /dev/fb0 c 29 0
fi
[[ -f /etc/sysconfig/bootsplash ]] && source /etc/sysconfig/bootsplash
[[ -n $SPLASH ]] && splash_rc=$SPLASH
[[ -n $THEME ]] && theme=$THEME
[[ -x /sbin/splash.sh ]] || splash_rc=no
if [[ -e /proc/splash ]]; then
grep -q off /proc/splash && splash_rc=no
else
splash_rc=no
fi
splash_cfg=/etc/bootsplash/
[[ $splash_rc != "no" && $splash_rc != "No" && $splash_rc != "NO" ]] && export splash_rc=yes
[[ -d $splash_cfg/themes ]] || splash_rc=
if [[ $splash_rc = "yes" && -n $theme ]];then
[[ ! -d $splash_cfg/themes/$theme ]] && theme=Mandrakelinux
res=`fbresolution`
tmpval=$LOGO_CONSOLE
if [ -f /etc/bootsplash/themes/$theme/config/bootsplash-$res.cfg ]; then
function box() { true; } # ignore box descriptions in the config file
. /etc/bootsplash/themes/$theme/config/bootsplash-$res.cfg
fi
if [[ $tmpval != "theme" ]];then
LOGO_CONSOLE=$tmpval
fi
fi
if [[ -z "$1" ]]; then
set `/sbin/runlevel`
runlevel=$2
previous=$1
else
runlevel=$1
previous=N
fi
nbservices=0
#
# for small dir, it is faster than echo /etc/rc$runlevel.d/* | wc -w
#
for i in /etc/rc$runlevel.d/*
do
a=$[nbservices++]
done
for i in /etc/rc$runlevel.d/*.rpm*
do
a=$[nbservices--]
done
a=$[nbservices++]
# this is the number of step in rc.sysinit, could be ajusted
[[ "$previous" = "N" ]] && nbservices=$(($nbservices+7)) && progress=6
export nbservices res theme progress_enable progress text_x text_y text_color text_size splash_rc LOGO_CONSOLE
}
rc_splash() {
[[ "$splash_rc" = "yes" ]] || return
if [[ -n "$2" ]]; then
progress=$2
else
a=$[progress++]
fi
# "OUTPUT_CHARSET=UTF-8" not needed, as it is forced in splash.sh itself
LANGUAGE=$LANGUAGE LC_ALL=$LC_CTYPE /sbin/splash.sh "$1"
}
#
# This function finds the encoding of the current locale (it can
# be overwritten by a "CHARSET" variable if needed); the call
# to "locale charmap" should return the proper value; in case it
# fails, a guess from the locale name is done.
# this function is also defined in setsysfont script
# if you change it here change it there too, to have the same behaviour
#
get_locale_encoding() {
CHARSET=${CHARSET=`LC_ALL=$GP_LANG locale charmap 2> /dev/null`}
case "$CHARSET" in
ANSI_X3.4-1968)
# this means that the locale has not been
# correctly initialized; we will look at the
# locale naming and use the known
# default values for various languages
case "${LC_ALL}${LC_CTYPE}${LANG}" in
# the locale tells it is in UTF-8, or it is a language
# we know must be in UTF-8 by default
*.utf8*|*.UTF-8*| \
am*|an*|ar*|as*|az*|bn*|cy*|eo*|fa*|gn*|gu*|he*|hi*|hy*| \
id*|ka*|kn*|ku*|ky*|lo*|m*|ne*|om*|pa*|ph*|se*|sr*|st*| \
ta*|te*|tg*|ti*|tk*|tl*|tt*|ug*|ur*|uz*|vi*|xh*|y*)
CHARSET="UTF-8" ;;
esac
;;
esac
echo "$CHARSET"
}
# resolve a device node to its major:minor numbers in decimal or hex
get_numeric_dev() {
(
fmt="%d:%d"
if [ "$1" == "hex" ]; then
fmt="%x:%x"
fi
ls -lH "$2" | awk '{ sub(/,/, "", $5); printf("'"$fmt"'", $5, $6); }'
) 2>/dev/null
}
# find the working name for a running dm device with the same table as one
# that dmraid would create
resolve_dm_name() {
(
name="$1"
line=$(/sbin/dmraid -ay -t --ignorelocking | \
egrep -iv "no block devices found|No RAID disks" | \
awk -F ':' "{ if (\$1 ~ /^$name$/) { print \$2; }}")
for x in $line ; do
if [[ "$x" =~ ^/dev/ ]] ; then
majmin=$(get_numeric_dev dec $x)
line=$(echo "$line" | sed -e "s,$x\( \|$\),$majmin\1,g")
fi
done
line=$(echo "$line" | sed -e 's/^[ \t]*//' -e 's/[ \t]*$//' \
-e 's/ core [12] [[:digit:]]\+ / core [12] [[:digit:]]\\+ /')
/sbin/dmsetup table | \
sed -n -e "s/.*\(no block devices found\|No devices found\).*//" \
-e "s/\(^[^:]\+\): $line\( \+$\|$\)/\1/p"
) 2>/dev/null
}
# Check whether file $1 is a backup or rpm-generated file and should be ignored
is_ignored_file() {
case "$1" in
*~ | *.bak | *.orig | *.rpmnew | *.rpmorig | *.rpmsave)
return 0
;;
esac
return 1
}
# A sed expression to filter out the files that is_ignored_file recognizes
__sed_discard_ignored_files='/\(~\|\.bak\|\.orig\|\.rpmnew\|\.rpmorig\|\.rpmsave\)$/d'
