path: root/functions

#!/bin/bash
# initscripts functions
#

# width:

STAT_COL=80
if [[ ! -t 1 ]]; then
    USECOLOR=""
elif [[ -t 0 ]]; then
    # stty will fail when stdin isn't a terminal
    STAT_COL="$(/bin/stty size)"
    # stty gives "rows cols"; strip the rows number, we just want columns
    STAT_COL="${STAT_COL##* }"
elif /bin/tput cols &>/dev/null; then
    # is /usr/share/terminfo already mounted, and TERM recognized?
    STAT_COL=$(/bin/tput cols)
fi
if ((STAT_COL==0)); then
    # if output was 0 (serial console), set default width to 80
    STAT_COL=80
    USECOLOR=""
fi

# we use 13 characters for our own stuff
STAT_COL=$(($STAT_COL - 13))

# disable colors on broken terminals
TERM_COLORS="$(/bin/tput colors 2>/dev/null)"
if (($? != 3)); then
    case $TERM_COLORS in
	*[!0-9]*) USECOLOR="";;
	[0-7])    USECOLOR="";;
	'')       USECOLOR="";;
    esac
fi
unset TERM_COLORS

# clear the TZ envvar, so daemons always respect /etc/localtime
unset TZ

# sanitize the locale settins
unset LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY \
      LC_MESSAGES LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE \
      LC_MEASUREMENT LC_IDENTIFICATION LC_ALL
if [[ $DAEMON_LOCALE =~ yes|YES && -n $LOCALE ]]; then
	export LANG="${LOCALE}"
else
	export LANG=C
fi

# colors:
if [[ $USECOLOR = YES || $USECOLOR = yes ]]; then
	C_MAIN="\033[1;37;40m"      # main text

	C_OTHER="\033[1;34;40m"     # prefix & brackets
	C_SEPARATOR="\033[1;30;40m" # separator

	C_BUSY="\033[0;36;40m"      # busy
	C_FAIL="\033[1;31;40m"      # failed
	C_DONE="\033[1;37;40m"      # completed
	C_BKGD="\033[1;35;40m"      # backgrounded

	C_H1="\033[1;37;40m"        # highlight text 1
	C_H2="\033[1;36;40m"        # highlight text 2

	C_CLEAR="\033[1;0m"
fi

if [[ -t 1 ]]; then
	SAVE_POSITION="\033[s"
	RESTORE_POSITION="\033[u"
	DEL_TEXT="\033[$(($STAT_COL+4))G"
else
	SAVE_POSITION=""
	RESTORE_POSITION=""
	DEL_TEXT=""
fi

# prefixes:

PREFIX_REG="::"
PREFIX_HL=" >"

# functions:

deltext() {
	printf "${DEL_TEXT}"
}

printhl() {
	printf "${C_OTHER}${PREFIX_HL} ${C_H1}${1}${C_CLEAR} \n"
}

printsep() {
	printf "\n${C_SEPARATOR}   ------------------------------\n"
}

stat_bkgd() {
	printf "${C_OTHER}${PREFIX_REG} ${C_MAIN}${1}${C_CLEAR} "
	deltext
	printf "   ${C_OTHER}[${C_BKGD}BKGD${C_OTHER}]${C_CLEAR} "
}

stat_busy() {
	printf "${C_OTHER}${PREFIX_REG} ${C_MAIN}${1}${C_CLEAR} "
	printf "${SAVE_POSITION}"
	deltext
	printf "   ${C_OTHER}[${C_BUSY}BUSY${C_OTHER}]${C_CLEAR} "
}

stat_append() {
	printf "${RESTORE_POSITION}"
	printf -- "${C_MAIN}${1}${C_CLEAR}"
	printf "${SAVE_POSITION}"
}

stat_done() {
	deltext
	printf "   ${C_OTHER}[${C_DONE}DONE${C_OTHER}]${C_CLEAR} \n"
}

stat_fail() {
	deltext
	printf "   ${C_OTHER}[${C_FAIL}FAIL${C_OTHER}]${C_CLEAR} \n"
}

stat_die() {
	stat_fail
	exit ${1:-1}
}

status() {
	stat_busy "$1"
	shift
	if "$@" >/dev/null 2>&1; then
		stat_done
		return 0
	fi
	stat_fail
	return 1
}

#  usage : in_array( $needle, $haystack )
# return : 0 - found
#          1 - not found
# Copied from makepkg
in_array() {
    [[ $2 ]] || return 1
    local needle=$1; shift
    local item
    for item in "$@"; do
	[[ ${item#@} = $needle ]] && return 0
    done
    return 1 # Not Found
}

# daemons:

add_daemon() {
	[[ -d /var/run/daemons ]] || /bin/mkdir -p /var/run/daemons
	> /var/run/daemons/"$1"
}

rm_daemon() {
	/bin/rm -f /var/run/daemons/"$1"
}

ck_daemon() {
	[[ ! -f /var/run/daemons/$1 ]]
}

have_daemon() {
    [[ -x /etc/rc.d/$1 ]]
}

start_daemon() {
    have_daemon "$1" && /etc/rc.d/"$1" start
}

ck_depends() {
    for daemon in "$@"; do
	ck_daemon "$daemon" && start_daemon "$daemon"
    done
}

start_daemon_bkgd() {
	stat_bkgd "Starting $1"
	have_daemon "$1" && (start_daemon "$1") &>/dev/null &
}

stop_daemon() {
	have_daemon "$1" && /etc/rc.d/"$1" stop
}

# Status functions
status_started() {
  deltext
  echo -ne "$C_OTHER[${C_STRT}STARTED$C_OTHER]$C_CLEAR "
}

status_stopped() {
  deltext
  echo -ne "$C_OTHER[${C_STRT}STOPPED$C_OTHER]$C_CLEAR "
}

ck_status() {
  if ! ck_daemon "$1"; then
    status_started
  else
    status_stopped
  fi
}

kill_everything() {
    # $1 = where we are being called from.
    # This is used to determine which hooks to run.
    # Find daemons NOT in the DAEMONS array. Shut these down first
    for daemon in /var/run/daemons/*; do
        [[ -f $daemon ]] || continue
        daemon=${daemon##*/}
	in_array "$daemon" "${DAEMONS[@]}" || stop_daemon "$daemon"
    done

    # Shutdown daemons in reverse order
    for ((i=${#DAEMONS[@]}-1; i>=0; i--)); do
	[[ ${DAEMONS[$i]:0:1} = '!' ]] && continue
	ck_daemon ${DAEMONS[$i]#@} || stop_daemon ${DAEMONS[$i]#@}
    done

	# Terminate all processes
    stat_busy "Sending SIGTERM To Processes"
    run_hook "$1_prekillall"
    /sbin/killall5 -15 &> /dev/null
    /bin/sleep 5
    stat_done

    stat_busy "Sending SIGKILL To Processes"
    /sbin/killall5 -9 &> /dev/null
    /bin/sleep 1
    stat_done

    run_hook "$1_postkillall"
}

activate_vgs() {
    [[ $USELVM =~ yes|YES && -x /sbin/lvm && -d /sys/block ]] || return
    # Kernel 2.6.x, LVM2 groups
    /sbin/modprobe -q dm-mod 2>/dev/null
    stat_busy "Activating LVM2 groups"
    if /sbin/vgchange --sysinit -a y >/dev/null; then
	stat_done
    else
	stat_fail
     fi
}

# Arch cryptsetup packages traditionally contained the binaries
#  /usr/sbin/cryptsetup
#  /sbin/cryptsetup.static
# By default, initscripts used the /sbin/cryptsetup.static.
# Newer packages will only have /sbin/cryptsetup and no static binary
# This ensures maximal compatibility with the old and new layout
for CS in /sbin/cryptsetup /usr/sbin/cryptsetup \
    /sbin/cryptsetup.static ''; do
    [[ -x $CS ]] && break
done

read_crypttab() {
    # $1 = function to call with the split out line from the crypttab
    local line nspo failed=0
    while read line; do
        [[ $line && ${line:0:1} != '#' ]] || continue
        eval nspo=("${line%#*}")
        $1 "${nspo[0]}" "${nspo[1]}" "${nspo[2]}" "${nspo[@]:3}" || failed=1
    done < /etc/crypttab
    return $failed
}

###############################
# Custom hooks in initscripts #
###############################
# Hooks can be used to include custom code in various places in the rc.* scripts
#
# Define a hook function in a functions.d file using:
#  function_name() {
#    ...
#  }
#  add_hook hook_name function_name
# It is allowed to register several hook functions for the same hook
# Is is also allowed to register the same hook function for several hooks
#
# Currently, the following hooks exist:
# sysinit_start: at the beginning of rc.sysinit
# multi_start: at the beginning of rc.multi
# single_start: at the beginning of rc.single
# shutdown_start: at the beginning of rc.shutdown
# sysinit_end: at the end of rc.sysinit
# multi_end: at the end of rc.multi
# single_end: at the end of rc.single
# sysinit_udevlaunched: after udev has been launched in rc.sysinit
# single_udevlaunched: after udev has been launched in rc.single
# sysinit_udevsettled: after uevents have settled in rc.sysinit
# single_udevsettled: after uevents have settled in rc.single
# sysinit_premount: before local filesystems are mounted, but after root is mounted read-write in rc.sysinit
# shutdown_prekillall: before all processes are being killed in rc.shutdown
# single_prekillall: before all processes are being killed in rc.single
# shutdown_postkillall: after all processes have been killed in rc.shutdown
# single_postkillall: after all processes have been killed in rc.single
# shutdown_poweroff: directly before powering off in rc.shutdown
#
# Declare add_hook and run_hook as read-only to prevent overwriting them.
# Too bad we cannot do the same thing with hook_funcs

declare -A hook_funcs

add_hook() {
	[[ $1 && $2 ]] || return 1
	hook_funcs["$1"]+=" $2"
}

run_hook() {
    [[ $1 ]] || return 1
    local func
    for func in ${hook_funcs["$1"]}; do
	"${func}"
    done
}

declare -r add_hook run_hook

# Function for setting console font if required
set_consolefont() {
    [[ $CONSOLEFONT ]] || return 0
    stat_busy "Loading Console Font: $CONSOLEFONT"
    #CONSOLEMAP in UTF-8 shouldn't be used
    [[ $CONSOLEMAP && ${LOCALE,,} =~ utf ]] && CONSOLEMAP=""
    for i in /dev/tty[0-9]*; do
	/usr/bin/setfont ${CONSOLEMAP:+-m ${CONSOLEMAP}} \
	    $CONSOLEFONT -C ${i} >/dev/null 2>&1
    done
    if (($? != 0)); then
	stat_fail
    elif [[ $CONSOLEMAP ]]; then
	cat <<"EOF" >>/etc/profile.d/locale.sh
if [ "$CONSOLE" = "" -a "$TERM" = "linux" -a -t 1 ]; then printf "\033(K"; fi

EOF
	stat_done
    fi
}

# Source additional functions at the end to allow overrides
for f in /etc/rc.d/functions.d/*; do
  [[ -e $f ]] && . "$f"
done

# End of file
# vim: set ft=sh sw=2 ts=2 et: