lib/functions

   1 #!/bin/sh - keep it for file(1) to get bourne shell script result
   2 # functions     This file contains functions to be used by most or all
   3 #               shell scripts in the /etc/rc.d/init.d directory.
   4 #
   5 #
   6 # Author:       Miquel van Smoorenburg, <miquels@drinkel.nl.mugnet.org>
   7 # Hacked by:    Greg Galloway and Marc Ewing
   8 # Modified for PLD Linux by:
   9 #               Marek Obuchowicz <elephant@pld-linux.org>
  10 #               Arkadiusz Miśkiewicz <misiek@pld-linux.org>
  11 #               Michał Kochanowicz <mkochano@pld-linux.org>
  12 #               Łukasz Pawelczyk <havner@pld-linux.org>
  13
  14 # First set up a default search path.
  15 export PATH="/sbin:/usr/sbin:/bin:/usr/bin"
  16
  17 # Set defaults
  18 if [ -z "$COLUMNS" -o -z "$LINES" ]; then
  19         _setterm() {
  20                 set -- $(stty size 2>/dev/null)
  21                 LINES=${LINES:-$1}
  22                 COLUMNS=${COLUMNS:-$2}
  23         }
  24         _setterm
  25         unset _setterm
  26 fi
  27 [ -z "$LINES" ] || [ "$LINES" -le 0 ] && LINES=40
  28 [ -z "$COLUMNS" ] || [ "$COLUMNS" -le 0 ] && COLUMNS=80
  29 export LINES COLUMNS
  30 INIT_COL=$((COLUMNS - 13))
  31
  32 # Set colors
  33 RED=1
  34 GREEN=2
  35 YELLOW=3
  36 BLUE=4
  37 MAGENTA=5
  38 CYAN=6
  39 WHITE=7
  40 NORMAL=15
  41 # Bold definition (second parameter to termput setaf)
  42 BOLD=1
  43 NOBOLD=0
  44 # Default colors
  45 CBRACKETS="$CYAN"       # brackets [ ] color
  46 CDONE="$GREEN"          # DONE and WORK color
  47 CBUSY="$MAGENTA"        # BUSY color
  48 CFAIL="$RED"            # FAIL and DIED color
  49 CPOWEREDBY="$CYAN"      # "Powered by" color
  50 CPLD="$GREEN"           # "PLD Linux Distribution" color
  51 CI="$RED"               # Capital I color (press I to enter interactive startup)
  52 CRESMAN="$GREEN"        # "Resource Manager" color
  53 CHARS=""                # Characters displayed on the beginning of show line
  54 CCHARS="$NORMAL"        # Color of these characters (look at /etc/sysconfig/init-colors.gentoo example)
  55
  56 # Source configuration if available - may override default values
  57 [ -r /etc/sysconfig/init-colors ] && . /etc/sysconfig/init-colors
  58 [ -r /etc/sysconfig/system ] && . /etc/sysconfig/system
  59 [ -r /etc/sysconfig/bootsplash ] && . /etc/sysconfig/bootsplash
  60
  61 # if initscript is invoked via bash, enable RedHat/Fedora compatibility
  62 # RC_FEDORA is "set" if enabled and "unset" when not, but it's "value" is always empty
  63 # this is useful for inline constructs
  64 if [ "${BASH_VERSION+set}" = "set" ]; then
  65         RC_LOGGING=yes
  66         FASTRC=no
  67         RC_FEDORA=
  68 else
  69         unset RC_FEDORA || :
  70 fi
  71
  72 if [ -z "$VSERVER" -o "$VSERVER" = "detect" ]; then
  73         {
  74                 while read _f _ctx; do
  75                         [ "$_f" = "VxID:" -o "$_f" = "s_context:" ] && break
  76                 done </proc/self/status
  77         } 2>/dev/null
  78         if [ -z "$_ctx" -o "$_ctx" = "0" ]; then
  79                 VSERVER=no
  80         else
  81                 VSERVER=yes
  82         fi
  83         unset _f _ctx
  84 fi
  85
  86 # VSERVER_ISOLATION_NET = isolation only inside of vserver guests
  87 if [ -z "$VSERVER_ISOLATION_NET" -o "$VSERVER_ISOLATION_NET" = "detect" ]; then
  88         VSERVER_ISOLATION_NET=no
  89         if [ "$VSERVER" = "yes" ]; then
  90                 if [ -f /proc/self/nsproxy ]; then
  91                         # older kernels
  92                         {
  93                                 while read _t _data; do
  94                                         [ "$_t" = "net:" ] && break
  95                                 done < /proc/self/nsproxy
  96                         } 2> /dev/null
  97                         if [ "${_data##*\(}" = "I)" ]; then
  98                                 VSERVER_ISOLATION_NET=yes
  99                         fi
 100                 elif [ -f /proc/self/ninfo ]; then
 101                         # newer kernels
 102                         {
 103                                 while read _t _data; do
 104                                         [ "$_t" = "NCaps:" ] && break
 105                                 done < /proc/self/ninfo
 106                         } 2> /dev/null
 107                         if [ "${_t}" = "NCaps:" ]; then
 108                                 VSERVER_ISOLATION_NET=yes
 109                         fi
 110                 else
 111                         # assume (very?) old kernel mode
 112                         VSERVER_ISOLATION_NET=yes
 113                 fi
 114                 unset _f _data
 115         fi
 116 fi
 117
 118 # we need to know in functions if we were called from a terminal
 119 if [ -z "$ISATTY" ]; then
 120         [ -t ] && ISATTY=yes || ISATTY=no
 121         export ISATTY
 122 fi
 123
 124 is_yes() {
 125         # Test syntax
 126         if [ $# = 0 ]; then
 127                 msg_usage " is_yes {value}"
 128                 return 2
 129         fi
 130
 131         # Check value
 132         case "$1" in
 133         yes|Yes|YES|true|True|TRUE|on|On|ON|Y|y|1)
 134                 # true returns zero
 135                 return 0
 136                 ;;
 137         *)
 138                 # false returns one
 139                 return 1
 140                 ;;
 141         esac
 142 }
 143
 144 is_no() {
 145         # Test syntax
 146         if [ $# = 0 ]; then
 147                 msg_usage " is_no {value}"
 148                 return 2
 149         fi
 150
 151         case "$1" in
 152         no|No|NO|false|False|FALSE|off|Off|OFF|N|n|0)
 153                 # true returns zero
 154                 return 0
 155                 ;;
 156         *)
 157                 # false returns one
 158                 return 1
 159                 ;;
 160         esac
 161 }
 162
 163 # checks if file is empty
 164 # empty lines and lines beginning with hash are ignored
 165 is_empty_file() {
 166         [ -s "$1" ] || return 0
 167         grep -vqE "^(#|[[:blank:]]*$)" "$1" && return 1 || return 0
 168 }
 169
 170 # returns OK if $1 contains $2
 171 strstr() {
 172         [ "${1#*$2*}" = "$1" ] && return 1
 173         return 0
 174 }
 175
 176 # Apply sysctl settings, including files in /etc/sysctl.d
 177 apply_sysctl() {
 178         if [ -x /lib/systemd/systemd-sysctl ]; then
 179                 /lib/systemd/systemd-sysctl
 180                 return
 181         fi
 182
 183         local file
 184         for file in /usr/lib/sysctl.d/*.conf; do
 185                 [ -f /run/sysctl.d/${file##*/} ] && continue
 186                 [ -f /etc/sysctl.d/${file##*/} ] && continue
 187                 test -f "$file" && sysctl -q -e -p "$file"
 188         done
 189         for file in /run/sysctl.d/*.conf; do
 190                 [ -f /etc/sysctl.d/${file##*/} ] && continue
 191                 test -f "$file" && sysctl -q -e -p "$file"
 192         done
 193         for file in /etc/sysctl.d/*.conf; do
 194                 test -f "$file" && sysctl -q -e -p "$file"
 195         done
 196         sysctl -q -e -p /etc/sysctl.conf
 197 }
 198
 199 if is_yes "$FASTRC" || is_yes "$IN_SHUTDOWN"; then
 200         RC_LOGGING=no
 201 fi
 202
 203 if is_no "$RC_LOGGING"; then
 204         initlog() {
 205                 RESULT=0
 206                 while [ "$1" != "${1##-}" ]; do
 207                         case $1 in
 208                         -c)
 209                                 shift
 210                                 $1
 211                                 RESULT=$?
 212                                 break
 213                                 ;;
 214                         *)
 215                                 shift
 216                                 ;;
 217                         esac
 218                 done
 219                 return $RESULT
 220         }
 221 fi
 222
 223 kernelver() {
 224         local _x _y _z v v1 old_IFS ver
 225         {
 226                 read _x _y v _z
 227                 old_IFS=$IFS
 228                 # strip _* or -* from versions like: "2.6.25_vanilla-1", "2.6.25-1"
 229                 IFS='_-'
 230                 set -- $v
 231                 v1=${1}
 232                 IFS='.'
 233                 set -- $v1
 234                 IFS=$old_IFS
 235
 236                 ver=${3}
 237                 while [ ${#ver} -lt 3 ]; do ver="0$ver"; done
 238                 ver="$2$ver"
 239                 while [ ${#ver} -lt 6 ]; do ver="0$ver"; done
 240                 ver="$1$ver"
 241                 while [ ${#ver} -lt 9 ]; do ver="0$ver"; done
 242                 echo $ver
 243         } < /proc/version
 244 }
 245
 246 kernelverser() {
 247         local _x _y _z v v1 old_IFS ver
 248         {
 249                 read _x _y v _z
 250                 old_IFS=$IFS
 251                 # strip _* or -* from versions like: "2.6.25_vanilla-1", "2.6.25-1"
 252                 IFS='_-'
 253                 set -- $v
 254                 v1=${1}
 255                 IFS='.'
 256                 set -- $v1
 257                 IFS=$old_IFS
 258                 ver=$2
 259                 while [ ${#ver} -lt 3 ]; do ver="0$ver"; done
 260                 ver="$1$ver"
 261                 while [ ${#ver} -lt 6 ]; do ver="0$ver"; done
 262                 echo $ver
 263         } </proc/version
 264 }
 265
 266 kernelvermser() {
 267         local _x _y _z v v1 old_IFS ver
 268         {
 269                 read _x _y v _z
 270                 old_IFS=$IFS
 271                 # strip _* or -* from versions like: "2.6.25_vanilla-1", "2.6.25-1"
 272                 IFS='_-'
 273                 set -- $v
 274                 v1=${1}
 275                 IFS='.'
 276                 set -- $v1
 277                 IFS=$old_IFS
 278                 ver="$1"
 279                 while [ ${#ver} -lt 3 ]; do ver="0$ver"; done
 280                 echo $ver
 281         } </proc/version
 282 }
 283
 284 # Colors workaround
 285 termput() {
 286         is_yes "$ISATTY" || return
 287
 288         if is_yes "$FASTRC" || is_no "$TPUT"; then
 289                 case "$1" in
 290                 hpa)
 291                         echo -ne "\033[$(($2+1))G"
 292                         ;;
 293                 cuu*)
 294                         echo -ne "\033[${2}A"
 295                         ;;
 296                 el)
 297                         echo -ne "\033[0K"
 298                         ;;
 299                 setaf)
 300                         local ISBOLD
 301                         if [ -n "$3" ]; then
 302                                 ISBOLD="$3"
 303                         else
 304                                 ISBOLD="$NOBOLD";
 305                         fi
 306                         is_yes "$COLOR_INIT" && echo -ne "\033[${ISBOLD};3${2}m"
 307                         ;;
 308                 op)
 309                         termput setaf $NORMAL
 310                         ;;
 311                 esac
 312         else
 313                 case "$1" in
 314                 hpa | cuu* | el)
 315                         tput "$@"
 316                         ;;
 317                 setaf)
 318                         if [ "$3" = "1" ]; then tput bold; else tput sgr0; fi
 319                         is_yes "$COLOR_INIT" && tput setaf "$2"
 320                         ;;
 321                 op)
 322                         termput setaf $NORMAL
 323                         ;;
 324                 esac
 325         fi
 326 }
 327
 328 if [ ! -x /bin/printf ]; then
 329         # printf equivalent
 330         # FIXME: buggy when single or double quotes in message!
 331         printf() {
 332                 local text m
 333                 text="$1"
 334                 shift
 335                 if [ $# -gt 0 ]; then
 336                         m="$1"
 337                         shift
 338                         while [ $# -gt 0 ]; do
 339                                 m="$m\",\"$1"
 340                                 shift
 341                         done
 342                 fi
 343                 awk "BEGIN {printf \"$text\", \"$m\"; }"
 344         }
 345 fi
 346
 347 # National language support function
 348 nls() {
 349         local msg_echo nls_domain text message
 350         msg_echo='\n'
 351         nls_domain="$NLS_DOMAIN"
 352         while [ "$1" != "${1##-}" ]; do
 353                 case "$1" in
 354                 --nls-domain)
 355                         shift
 356                         nls_domain="$1"
 357                         shift
 358                         ;;
 359                 -n)
 360                         msg_echo=''
 361                         shift
 362                         ;;
 363                 esac
 364         done
 365         message="$1"
 366         shift
 367
 368         # empty message, so we return --misiek
 369         if [ -z "$message" ]; then
 370                 echo -en "$msg_echo"
 371                 return
 372         fi
 373
 374         if is_yes "$GETTEXT"; then
 375                 message=$(TEXTDOMAINDIR="/etc/sysconfig/locale" gettext -e --domain="${nls_domain:-rc-scripts}" "$message")
 376         fi
 377
 378         printf "$message" "$@"
 379         echo -en "$msg_echo"
 380 }
 381
 382 rc_splash() {
 383         local action="$1"
 384
 385         if ! is_no "$BOOT_SPLASH" && ! is_yes "$VSERVER"; then
 386                 [ -x /bin/splash ] && /bin/splash "$action"
 387         fi
 388
 389         : $((progress++))
 390 }
 391
 392 msg_network_down() {
 393         nls "ERROR: Networking is down. %s can't be run." "$1" >&2
 394 }
 395
 396 msg_starting() {
 397         show "Starting %s service" "$1"
 398 }
 399
 400 msg_already_running() {
 401         nls "%s service is already running." "$1"
 402 }
 403
 404 msg_stopping() {
 405         show "Stopping %s service" "$1"
 406 }
 407
 408 msg_not_running() {
 409         nls "%s service is not running." "$1"
 410 }
 411
 412 msg_reloading() {
 413         show "Reloading %s service" "$1"
 414 }
 415
 416 msg_usage() {
 417         nls "Usage: %s" "$*"
 418 }
 419
 420 # Some functions to handle PLD Linux-style messages
 421 show() {
 422         local text len time
 423
 424         if is_yes "$RC_UPTIME"; then
 425                 time=$(awk '{printf("[%8.2f] ", $1)}' /proc/uptime)
 426         fi
 427
 428         if is_no "$FASTRC" && is_yes "$GETTEXT"; then
 429                 text=$time$(nls -n "$@")
 430         else
 431                 text=$time$(printf "$@")
 432         fi
 433         len=${#text}
 434         while [ $((len++)) -lt $INIT_COL ]; do
 435                 text="$text."
 436         done
 437         if [ -n "$CHARS" ]; then
 438                 termput setaf $CCHARS
 439                 echo -n "$CHARS"
 440                 termput op
 441         fi
 442         echo -n "$text"
 443 }
 444
 445 deltext() {
 446         termput hpa $INIT_COL
 447 }
 448
 449 # Displays message in square brackests ("[ DONE ]"). Takes two arguments.
 450 # First is the text to display, second is color number to use (argument to
 451 # tput setaf). If second argument is not given, default (2, green) will be
 452 # used).
 453 progress() {
 454         local COLOR
 455         if [ -n "$2" ]; then
 456                 COLOR="$2"
 457         else
 458                 COLOR="$CDONE"
 459         fi
 460         deltext
 461         echo -n "$(termput setaf $CBRACKETS)[$(termput setaf $COLOR) $(nls --nls-domain rc-scripts "$1") $(termput setaf $CBRACKETS)]$(termput op)"
 462 }
 463
 464 busy() {
 465         echo -n "$_busy"
 466 }
 467
 468 ok() {
 469         echo -ne "$_ok${RC_FEDORA+\\r}${RC_FEDORA-\\n}"
 470 }
 471
 472 started() {
 473         echo "$_started"
 474 }
 475
 476 fail() {
 477         echo -ne "$_fail${RC_FEDORA+\\r}${RC_FEDORA-\\n}"
 478         return 1
 479 }
 480
 481 died() {
 482         echo "$_died"
 483         return 1
 484 }
 485
 486 # Check if $pid (could be plural) are running
 487 checkpid() {
 488         while [ "$1" ]; do
 489                 [ -d "/proc/$1" ] && return 0
 490                 shift
 491         done
 492         return 1
 493 }
 494
 495 # - outside chroot get only those processes, which are outside chroot.
 496 # - inside chroot get only those processes, which are inside chroot.
 497 # - don't filter out pids which do not have corresponding running processes (process died etc)
 498 # (note: some processes like named are chrooted but run outside chroot)
 499 # - do nothing inside vserver
 500 filter_chroot() {
 501         # no pids, exit early
 502         [ $# -eq 0 ] && return
 503
 504         # filter by pid namespace if such dir exists for current process
 505         # we do filter in containers as stacked containers are possible with LXC
 506         if [ -d /proc/$$/ns ]; then
 507                 local pids
 508                 pids=$(filter_ns "$@") && set -- "$pids"
 509         fi
 510
 511         if is_yes "$VSERVER"; then
 512                 echo $@
 513                 return
 514         fi
 515
 516         if [ $# -lt 1 -o ! -d /proc/1 ]; then
 517                 echo $@
 518                 return
 519         fi
 520
 521         local root_dir good_pids="" good_add_pid
 522         for root_pid in $@; do
 523                 root_dir=$(resolvesymlink /proc/${root_pid}/root)
 524                 if [ -n "$root_dir" ]; then
 525                         good_add_pid=1
 526                         if [ -n "${SYSTEM_CHROOTS}" ]; then
 527                                 for r_dir in ${SYSTEM_CHROOTS}; do
 528                                         echo "$root_dir" | grep -q "^${r_dir}" && good_add_pid=0
 529                                 done
 530                         fi
 531                         [ "$good_add_pid" -eq 1 ] && good_pids="$good_pids $root_pid"
 532                 elif [ ! -d "/proc/$root_pid" ]; then
 533                         good_pids="$good_pids $root_pid"
 534                 fi
 535         done
 536         echo $good_pids
 537 }
 538
 539 # similar to filter_chroot, but filter based on /proc/PID/ns/pid value
 540 filter_ns() {
 541         local cur_ns=$(resolvesymlink /proc/$$/ns/pid)
 542         [ "$cur_ns" ] || return 1
 543
 544         local pid ns pids=""
 545         # add pids if it matches current pid namespace
 546         # we should add pids what do not exist (dead processes),
 547         # but not add pids whose namespace does not match
 548         # (processes belonging to different NS do exist in /proc)
 549         for pid in "$@"; do
 550                 if [ ! -d /proc/$pid ]; then
 551                         pids="$pids $pid"
 552                         continue
 553                 fi
 554                 ns=$(resolvesymlink /proc/$pid/ns/pid)
 555                 if [ "$ns" = "$cur_ns" ]; then
 556                         pids="$pids $pid"
 557                 fi
 558         done
 559         echo $pids
 560         return 0
 561 }
 562
 563 # Usage:
 564 # run_cmd Message command_to_run
 565 # run_cmd -a Message command_to_run
 566 # run_cmd --user "username" "Message" command_to_run
 567 run_cmd() {
 568         local force_err=0 exit_code=0 errors user
 569         while [ $# -gt 0 ]; do
 570                 case "$1" in
 571                 -a)
 572                         force_err=1
 573                         ;;
 574                 --user)
 575                         shift
 576                         user=$1
 577                         ;;
 578                 *)
 579                         break
 580                 esac
 581                 shift
 582         done
 583
 584         local message=$1; shift
 585         show "$message"; busy
 586
 587         if errors=$(
 588                 cd /
 589                 export HOME=/tmp TMPDIR=/tmp
 590                 if is_no "$RC_LOGGING"; then
 591                         ${user:+setuidgid -s $user} "$@" 2>&1
 592                 else
 593                         ${user:+setuidgid -s $user} initlog -c "$*" 2>&1
 594                 fi
 595                 ); then
 596                 ok
 597                 log_success "$1 $message"
 598         else
 599                 fail
 600                 log_failed "$1 $message"
 601                 exit_code=1
 602         fi
 603         [ -n "$errors" ] && [ $exit_code -eq 1 -o $force_err -eq 1 ] && echo "$errors"
 604         return $exit_code
 605 }
 606
 607 _daemon_set_ulimits() {
 608         local opt val ksh=${KSH_VERSION:+1}
 609         set -- ${SERVICE_LIMITS:-$DEFAULT_SERVICE_LIMITS}
 610         while [ $# -gt 0 ]; do
 611                 opt=$1
 612                 val=$2
 613                 if [ "$ksh" ]; then
 614                         case "$opt" in
 615                         -Hu)
 616                                 opt=-Hp
 617                         ;;
 618                         -Su)
 619                                 opt=-Sp
 620                         ;;
 621                         -u)
 622                                 opt=-p
 623                         ;;
 624                         esac
 625                 fi
 626                 ulimit $opt $val
 627                 shift 2
 628         done
 629 }
 630
 631 # inner function used by daemon().
 632 # do not call this directly, as it expects variables being inherited.
 633 # also it expects to be called from subshell as it exports env.
 634 # it expects options parsed by daemon() and command to be executed in "$@".
 635 _daemon_exec() {
 636         local prog=""
 637         umask ${SERVICE_UMASK:-$DEFAULT_SERVICE_UMASK};
 638         export USER=root HOME=/tmp TMPDIR=/tmp
 639
 640         nice=${nice:-$DEFAULT_SERVICE_RUN_NICE_LEVEL}
 641         nice=${nice:-0}
 642
 643         # make nice level absolute, not to be dependant of nice level of shell where service started
 644         nice=$(($nice - $(nice)))
 645
 646         if [ "$closefds" = 1 ]; then
 647                 exec 1>&-
 648                 exec 2>&-
 649                 exec 0<&-
 650         elif [ "$redirfds" = 1 ]; then
 651                 exec 1>/dev/null
 652                 exec 2>/dev/null
 653                 exec 0</dev/null
 654         else
 655                 exec 2>&1
 656                 exec 0</dev/null
 657         fi
 658
 659         if is_no "$RC_LOGGING"; then
 660                 prog=$1; shift
 661                 if [ ! -x $prog ]; then
 662                         logger -t rc-scripts -p daemon.debug "daemon: Searching PATH for $prog, consider using full path in initscript"
 663                         local a o=$IFS
 664                         IFS=:
 665                         for a in $PATH; do
 666                                 if [ -x $a/$prog ]; then
 667                                         prog=$a/$prog
 668                                         break
 669                                 fi
 670                         done
 671                         IFS=$o
 672                 fi
 673                 set -- "$prog" "$@"
 674
 675                 # use setsid to detach from terminal,
 676                 # NOTE: setsid needs to be "outer" program
 677                 # otherwise start-stop-daemon would capture the setsid pid not the actual program
 678
 679                 prog=$1; shift
 680                 /usr/bin/setsid \
 681                 /sbin/start-stop-daemon -q --start \
 682                         --nicelevel $nice \
 683                         ${pidfile:+--pidfile $pidfile} \
 684                         ${makepid:+--make-pidfile} \
 685                         ${user:+--chuid $user} \
 686                         ${chdir:+--chdir "$chdir"} \
 687                         ${fork:+--background} \
 688                         ${SERVICE_DROPCAPS:+--dropcap $SERVICE_DROPCAPS} \
 689                         --exec "$prog" \
 690                         -- "$@"
 691         else
 692                 if [ "$fork" = "1" ]; then
 693                         export PIDFILE="/dev/null"
 694                         if [ "$makepid" ] && [ "$pidfile" ]; then
 695                                 export PIDFILE="$pidfile"
 696                         fi
 697                         set -- /lib/rc-scripts/makepid "$@"
 698                         set -- /usr/bin/setsid "$@"
 699                 fi
 700                 if [ -n "$user" -a "$user" != "root" ]; then
 701                         set -- /bin/runuser -u "$user" -- "$@"
 702                 fi
 703
 704                 nice -n $nice initlog -c "$*" 2>&1 </dev/null
 705         fi
 706 }
 707
 708 # A function to start a program (now it's useful on read-only filesystem too)
 709 daemon() {
 710         local errors="" waitname="" waittime=0
 711         local exit_code=0
 712         local nice=$SERVICE_RUN_NICE_LEVEL
 713         local fork user closefds redirfds pidfile makepid chdir=/
 714
 715         while [ $# -gt 0 ]; do
 716                 case $1 in
 717                 '')
 718                 msg_usage " daemon [--check] [--user user] [--fork] [--chdir directory] [--closefds] [--redirfds] [--waitforname procname] [--waitfortime seconds] [--pidfile file] [--makepid] [+/-nicelevel] {program} <program args>"
 719                         return 2
 720                         ;;
 721                 --check)
 722                         # for compatibility with redhat/mandrake
 723                         nls "warning: --check option is ignored!"
 724                         shift
 725                         ;;
 726                 --user)
 727                         shift
 728                         user=$1
 729                         ;;
 730                 --fork)
 731                         fork=1
 732                         ;;
 733                 --chdir)
 734                         shift
 735                         chdir=$1
 736                         ;;
 737                 --closefds)
 738                         closefds=1
 739                         ;;
 740                 --redirfds)
 741                         redirfds=1
 742                         ;;
 743                 --waitforname)
 744                         shift
 745                         waitname="$1"
 746                         ;;
 747                 --waitfortime)
 748                         shift
 749                         waittime="$1"
 750                         ;;
 751                 --pidfile=?*)
 752                         pidfile="${1#--pidfile=}"
 753                         case "$pidfile" in /*);; *) pidfile="/var/run/$pidfile";; esac
 754                         ;;
 755                 --pidfile)
 756                         shift
 757                         pidfile="$1"
 758                         case "$pidfile" in /*);; *) pidfile="/var/run/$pidfile";; esac
 759                         ;;
 760                 --makepid)
 761                         makepid=1
 762                         # makepid implies fork
 763                         fork=1
 764                         ;;
 765                 -*|+*)
 766                         nice=$1
 767                         shift
 768                         break
 769                         ;;
 770                 *)
 771                         break
 772                         ;;
 773                 esac
 774                 shift
 775         done
 776
 777         _daemon_set_ulimits
 778
 779         [ -z "$DEFAULT_SERVICE_UMASK" ] && DEFAULT_SERVICE_UMASK=022
 780         [ -z "$DEFAULT_SERVICE_RUN_NICE_LEVEL" ] && DEFAULT_SERVICE_RUN_NICE_LEVEL=0
 781
 782         # And start it up.
 783         busy
 784         cd $chdir
 785         [ -n "$SERVICE_CPUSET" ] && is_yes "$CPUSETS" && echo $$ > "/dev/cpuset/${SERVICE_CPUSET}/tasks"
 786         if errors=$(_daemon_exec "$@"); then
 787                 # wait for process (or pidfile) to be created
 788                 if [ "$waittime" -gt 0 ]; then
 789                         # waitname can be empty, as if pidfile is in use, it is not relevant
 790                         waitproc "$waittime" "$waitname" "$pidfile"
 791                 fi
 792                 log_success "$1 startup"
 793                 ok
 794         else
 795                 exit_code=1
 796                 fail
 797                 log_failed "$1 startup"
 798                 [ -n "$errors" ] && echo >&2 "$errors"
 799         fi
 800         return $exit_code
 801 }
 802
 803 # wait (in seconds) for process (or pidfile) to be created
 804 # example: waitproc 30 httpd /var/run/httpd.pid
 805 waitproc() {
 806         local waittime=$1 procname=$2 pidfile=$3
 807         local pid
 808         local now=$(date +%s)
 809         local maxtime=$(($now + $waittime))
 810
 811         if [ -z "$procname" -a -z "$pidfile" ]; then
 812                 msg_usage "waitproc: procname or pidfile must be specified"
 813                 return 2
 814         fi
 815
 816         while [ "$(date +%s)" -lt "$maxtime" ]; do
 817                 pid=$(pidofproc "$procname" "$pidfile")
 818                 [ -n "$pid" ] && break
 819
 820                 # start-stop-daemon uses same delay
 821                 usleep 20000
 822         done
 823 }
 824
 825 # A function to stop a program.
 826 killproc() {
 827         local notset killlevel base pid pidfile result delay=3 try
 828         # Test syntax.
 829         if [ $# = 0 ]; then
 830                 msg_usage " killproc [--pidfile|-p PIDFILE] [-d DELAY] {program} [-SIGNAME]"
 831                 return 2
 832         fi
 833
 834         while [ "$1" != "${1##-}" ]; do
 835                 case $1 in
 836                 -d)
 837                         delay="$2"
 838                         shift 2
 839                         ;;
 840                 --pidfile|-p)
 841                         pidfile="$2"
 842                         case "$pidfile" in /*);; *) pidfile="/var/run/$pidfile";; esac
 843                         shift 2
 844                         ;;
 845                 --waitforname)
 846                         waitname="$2"
 847                         shift 2
 848                         ;;
 849                 --waitfortime)
 850                         waittime="$2"
 851                         shift 2
 852                         ;;
 853                 esac
 854         done
 855
 856         busy
 857
 858         local notset=0
 859         # check for second arg to be kill level
 860         if [ -n "$2" ]; then
 861                 killlevel=$2
 862         else
 863                 notset=1
 864         fi
 865
 866         # experimental start-stop-daemon based killing.
 867         # works only with pidfile
 868         if is_no "$RC_LOGGING" && [ "$pidfile" ]; then
 869                 local sig=${killlevel:--TERM} retry
 870                 # do not retry if signal is specified,
 871                 # as otherwise impossible to send HUP if process pid stays in pidfile.
 872                 # however, do retry if --waitfortime was specified
 873                 if [ "${killlevel+set}" = "set" ] && [ -z "$waittime" ]; then
 874                         # if we send HUP it's ok if process does not die
 875                         retry="--oknodo"
 876                 else
 877                         local waitretry
 878                         : ${waittime=10}
 879                         : ${waitretry=$(($waittime * 2))}
 880
 881                         # 1. kill with $sig, wait $delay
 882                         # 2. kill with $sig, wait $waittime
 883                         # 3. kill with KILL, wait $waitretry
 884                         retry="--retry ${sig#-}/${delay}/${sig#-}/${waittime}/KILL/${waitretry}"
 885                 fi
 886                 /sbin/start-stop-daemon -q --stop \
 887                         $retry \
 888                         ${waitname:+--name $waitname} \
 889                         -s ${sig#-} \
 890                         ${pidfile:+--pidfile $pidfile}
 891                 result=$?
 892                 if [ "$result" -eq 0 ]; then
 893                         ok
 894                 else
 895                         fail
 896                 fi
 897                 return $result
 898         fi
 899
 900
 901         # Save basename.
 902         base=${1##*/}
 903
 904         # Find pid.
 905         pid=$(pidofproc "$1" "$pidfile")
 906         [ -z "$pid" ] && pid=$(pidofproc "$base" "$pidfile")
 907
 908         # Kill it.
 909         if [ -n "$pid" -a "$pid" != "$$" ] && checkpid $pid 2>&1; then
 910                 if [ "$notset" = "1" ]; then
 911                         if checkpid $pid 2>&1; then
 912                                 # TERM first, then KILL if not dead
 913                                 kill -TERM $pid
 914                                 usleep 50000
 915
 916                                 try=0
 917                                 while [ $try -lt $delay ]; do
 918                                         checkpid $pid || break
 919                                         sleep 1
 920                                         try=$((try+1))
 921                                 done
 922                                 if checkpid $pid; then
 923                                         # XXX: SIGKILL is sent already on 4th second!
 924                                         # HARMFUL for example to mysqld (which is already workarounded)
 925                                         kill -KILL $pid
 926                                         usleep 50000
 927                                 fi
 928                         fi
 929                         checkpid $pid
 930                         result=$?
 931                         if [ "$result" -eq 0 ]; then
 932                                 fail
 933                                 log_failed "$1 shutdown"
 934                         else
 935                                 ok
 936                                 log_success "$1 shutdown"
 937                         fi
 938                         result=$(( ! $result ))
 939                 else
 940                         # use specified level only
 941                         if checkpid $pid > /dev/null 2>&1; then
 942                                 kill $killlevel $pid
 943                                 result=$?
 944                                 if [ "$result" -eq 0 ]; then
 945                                         ok
 946                                         log_success "$1 got $killlevel"
 947                                 else
 948                                         result=7
 949                                         fail
 950                                         log_failed "$1 didn't get $killlevel"
 951                                 fi
 952                         else
 953                                 result=7
 954                                 died
 955                                 log_failed "$1 shutdown"
 956                         fi
 957                 fi
 958         else
 959                 died
 960                 log_failed "$1 shutdown"
 961                 result=7
 962         fi
 963
 964         if [ -n "$waitname" -a -n "$waittime" ]; then
 965                 # Save basename.
 966                 base=${waitname##*/}
 967                 # Find pid.
 968                 pid=$(pidofproc "$waitname" "$pidfile")
 969                 [ -z "$pid" ] && pid=$(pidofproc "$base" "$pidfile")
 970                 i=0
 971                 while [ "$i" -lt "$waittime" ]; do
 972                         i=$(( i + 1 ))
 973                         checkpid $pid && sleep 1 || break
 974                 done
 975         fi
 976
 977         # Remove pid file if any.
 978         if [ "$notset" = "1" ]; then
 979                 rm -f /var/run/${base}.pid
 980         fi
 981
 982         return $result
 983 }
 984
 985 # A function to find the pid of a program.
 986 pidofproc() {
 987         local pid pidfile base=${1##*/}
 988         pidfile="$base.pid"
 989         [ -n "$2" ] && pidfile="$2"
 990
 991         # Test syntax.
 992         if [ $# = 0 ]; then
 993                 msg_usage " pidofproc {program}"
 994                 return 2
 995         fi
 996
 997         # First try pidfile or "/var/run/*.pid"
 998         case "$pidfile" in
 999                 /*)pidfile="${pidfile}";;
1000                 *) pidfile="/var/run/$pidfile";;
1001         esac
1002         if [ -f "${pidfile}" ]; then
1003                 local p
1004                 for p in $(< "${pidfile}"); do
1005                         [ -z "$(echo "$p" | awk '{gsub(/[0-9]/,"");print;}')" ] && pid="$pid $p"
1006                 done
1007         fi
1008
1009         # Next try "pidof" if pidfile is not specified
1010         if [ -z "$pid" ] && [ -z "$2" ]; then
1011                 pid=$(pidof -o $$ -o $PPID -o %PPID -x "$1")
1012         fi
1013
1014         pid=$(filter_chroot $pid)
1015         echo $pid
1016 }
1017
1018 # status [--pidfile PIDFILE] {subsys} [{daemon}]"
1019 status() {
1020         local pid subsys daemon cpuset_msg pidfile
1021         if [ "$1" = "--pidfile" -o "$1" = "-p" ]; then
1022                 pidfile=$2
1023                 case "$pidfile" in /*);; *) pidfile="/var/run/$pidfile";; esac
1024                 shift 2
1025         fi
1026
1027         subsys=$1
1028         daemon=${2:-$subsys}
1029
1030         # Test syntax.
1031         if [ $# = 0 ]; then
1032                 msg_usage " status [--pidfile PIDFILE] {subsys} [{daemon}]"
1033                 return 2
1034         fi
1035
1036         # if pidfile specified, pid must be there
1037         if [ "$pidfile" ]; then
1038                 [ -f "$pidfile" ] && read pid < $pidfile
1039                 # filter_chroot does not filter out dead pids, so this extra check, see t/status-pidfile.sh
1040                 if [ ! -d "/proc/$pid" ]; then
1041                         pid=
1042                 fi
1043         else
1044                 pid=$(pidof -o $$ -o $PPID -o %PPID -x $daemon)
1045         fi
1046         pid=$(filter_chroot $pid)
1047
1048         if [ "$pid" ]; then
1049                 cpuset_msg="..."
1050                 if [ -n "$SERVICE_CPUSET" ] && is_yes "$CPUSETS"; then
1051                         if grep -q "$pid" "/dev/cpuset/${SERVICE_CPUSET}/tasks"; then
1052                                 cpuset_msg=$(nls " in cpuset %s..." "$SERVICE_CPUSET")
1053                         else
1054                                 cpuset_msg=$(nls " outside of configured cpuset %s..." "$SERVICE_CPUSET")
1055                         fi
1056                 fi
1057                 nls "%s (pid %s) is running%s" "$daemon" "$pid" "$cpuset_msg"
1058                 return 0
1059         fi
1060
1061         # Next try "/var/run/*.pid" files; if pidfile is not set
1062         local base=${daemon##*/}
1063         if [ -z "$pidfile" -a -f /var/run/${base}.pid ]; then
1064                 read pid < /var/run/${base}.pid
1065                 pid=$(filter_chroot $pid)
1066                 if [ "$pid" ]; then
1067                         nls "%s dead but pid file (%s) exists" "$subsys" /var/run/${base}.pid
1068                         return 1
1069                 fi
1070         fi
1071
1072         # See if /var/lock/subsys/$subsys exists
1073         if [ -f /var/lock/subsys/$subsys ]; then
1074                 nls "daemon %s dead but subsys (%s) locked" "$daemon" "$subsys"
1075                 return 2
1076         fi
1077         nls "%s is stopped" "$subsys"
1078         return 3
1079 }
1080
1081 # Confirm whether we really want to run this service
1082 confirm() {
1083         local answer
1084         nls -n "Start service %s (Y)es/(N)o/(C)ontinue? [Y] " "$1"
1085         read answer
1086         case $answer in
1087         y|Y|t|T|j|J|"")
1088                 return 0
1089                 ;;
1090         c|C|k|K|w|W)
1091                 return 2
1092                 ;;
1093         n|N)
1094                 return 1
1095                 ;;
1096         *)
1097                 confirm $1
1098                 return $?
1099                 ;;
1100         esac
1101 }
1102
1103 # module is needed (ie. is requested, is available and isn't loaded already)
1104 is_module() {
1105         # module name without .o at end
1106         if ! lsmod | grep -q "$1"; then
1107                 if ls -1R /lib/modules/$(uname -r)/ 2> /dev/null | grep -q "^${1}.\(\|k\)o\(\|.gz\)"; then
1108                         # true
1109                         return 0
1110                 fi
1111         fi
1112         # false
1113         return 1
1114 }
1115
1116 _modprobe() {
1117         local parsed single die args foo result
1118         parsed=no
1119         while is_no "$parsed"; do
1120                 case "$1" in
1121                 "single")
1122                         single=yes
1123                         shift
1124                         ;;
1125                 "die")
1126                         die=yes
1127                         shift
1128                         ;;
1129                 -*)
1130                         args="$args $1"
1131                         shift
1132                         ;;
1133                 *)
1134                         parsed=yes
1135                         ;;
1136                 esac
1137         done
1138         if is_yes "${single}"; then
1139                 foo="$@"
1140                 show "Loading %s kernel module(s)" "$foo"
1141                 busy
1142         fi
1143         if [ -x /sbin/modprobe ]; then
1144                 /sbin/modprobe -s $args "$@"
1145                 result=$?
1146         else
1147                 deltext; fail
1148                 result=1
1149         fi
1150         if is_yes "${single}"; then
1151                 deltext
1152                 if [ $result = "0" ]; then
1153                         is_yes "$single" && ok
1154                 else
1155                         fail
1156                         if is_yes "$die"; then
1157                                 nls "Could not load %s kernel module(s)" "$@"
1158                                 exit 1
1159                         fi
1160                 fi
1161         fi
1162 }
1163
1164 if is_no "$RC_LOGGING"; then
1165         log_success() {
1166                 :
1167         }
1168
1169         log_failed() {
1170                 :
1171         }
1172 else
1173         log_success() {
1174                 initlog -n $0 -s "$1 $2" -e 1
1175         }
1176
1177         log_failed() {
1178                 initlog -n $0 -s "$1 $2" -e 2
1179         }
1180 fi
1181
1182 # Check if any flavor of portmapper is running
1183 check_portmapper() {
1184         if [ -x /usr/sbin/rpcinfo ]; then
1185                 if /usr/sbin/rpcinfo -p localhost >/dev/null 2>/dev/null; then
1186                         return 0
1187                 else
1188                         return 1
1189                 fi
1190         elif [ -z "$(pidof portmap)" -a -z "$(pidof rpcbind)" ]; then
1191                 return 1
1192         fi
1193         return 0
1194 }
1195
1196 # is_fsmounted fstype mntpoint
1197 # Check if filesystem fstype is mounted on mntpoint
1198 is_fsmounted() {
1199         local fstype=$1
1200         local mntpoint=$2
1201
1202         [ -n "$fstype" -a -n "$mntpoint" ] || return 1
1203
1204         if [ -r /proc/mounts ]; then
1205                 grep -qE "[[:blank:]]$mntpoint[[:blank:]]+$fstype[[:blank:]]" /proc/mounts
1206                 return $?
1207         else
1208                 if [ "$(stat -L -f -c %T $mntpoint 2>/dev/null)" = "$fstype" ]; then
1209                         return 0
1210                 else
1211                         return 1
1212                 fi
1213         fi
1214 }
1215
1216 # __umount_loop awk_program fstab_file first_msg retry_msg umount_args
1217 # awk_program should process fstab_file and return a list of fstab-encoded
1218 # paths; it doesn't have to handle comments in fstab_file.
1219 __umount_loop() {
1220         local remaining sig=
1221         local retry=3 count
1222
1223         remaining=$(LC_ALL=C awk "/^#/ {next} $1" "$2" | sort -r)
1224         while [ -n "$remaining" -a "$retry" -gt 0 ]; do
1225                 if [ "$retry" -eq 3 ]; then
1226                         run_cmd "$3" fstab-decode umount $5 $remaining
1227                 else
1228                         run_cmd "$4" fstab-decode umount $5 $remaining
1229                 fi
1230                 count=4
1231                 remaining=$(LC_ALL=C awk "/^#/ {next} $1" "$2" | sort -r)
1232                 while [ "$count" -gt 0 ]; do
1233                         [ -z "$remaining" ] && break
1234                         count=$(($count-1))
1235                         usleep 500000
1236                         remaining=$(LC_ALL=C awk "/^#/ {next} $1" "$2" | sort -r)
1237                 done
1238                 [ -z "$remaining" ] && break
1239                 fstab-decode /bin/fuser -k -m $sig $remaining >/dev/null
1240                 sleep 3
1241                 retry=$(($retry -1))
1242                 sig=-9
1243         done
1244 }
1245
1246 # Similar to __umount loop above, specialized for loopback devices
1247 __umount_loopback_loop() {
1248         local remaining devremaining sig=
1249         local retry=3
1250
1251         remaining=$(awk '$1 ~ /^\/dev\/loop/ && $2 != "/" {print $2}' /proc/mounts)
1252         devremaining=$(awk '$1 ~ /^\/dev\/loop/ && $2 != "/" {print $1}' /proc/mounts)
1253         while [ -n "$remaining" -a "$retry" -gt 0 ]; do
1254                 if [ "$retry" -eq 3 ]; then
1255                         run_cmd "Unmounting loopback filesystems: " \
1256                                 fstab-decode umount $remaining
1257                 else
1258                         run_cmd "Unmounting loopback filesystems (retry):" \
1259                                 fstab-decode umount $remaining
1260                 fi
1261                 for dev in $devremaining ; do
1262                         losetup $dev > /dev/null 2>&1 && \
1263                                 run_cmd "Detaching loopback device $dev: " \
1264                                 losetup -d $dev
1265                 done
1266                 remaining=$(awk '$1 ~ /^\/dev\/loop/ && $2 != "/" {print $2}' /proc/mounts)
1267                 devremaining=$(awk '$1 ~ /^\/dev\/loop/ && $2 != "/" {print $1}' /proc/mounts)
1268                 [ -z "$remaining" ] && break
1269                 fstab-decode /bin/fuser -k -m $sig $remaining >/dev/null
1270                 sleep 3
1271                 retry=$(($retry -1))
1272                 sig=-9
1273         done
1274 }
1275
1276 rc_cache_init() {
1277         # If we have cachefile, use it.
1278         # If we don't, create memory variables and try to save silently,
1279         local cachefile='/var/cache/rc-scripts/msg.cache'
1280
1281         local term
1282         if is_yes "$ISATTY"; then
1283                 term=$TERM
1284         else
1285                 term=dumb
1286         fi
1287
1288         # We create $check variable which is used to invalidate the cache.
1289         # The $check contains user locale and terminal.
1290         local check="$term.$LC_MESSAGES.$INIT_COL"
1291
1292         if [ -f "$cachefile" -a "$cachefile" -nt /etc/sysconfig/system -a "$cachefile" -nt /etc/sysconfig/init-colors ]; then
1293                 if . "$cachefile" 2>/dev/null; then
1294                         if [ "$check" = "$_check" ]; then
1295                                 return
1296                         fi
1297                 fi
1298         fi
1299
1300         # primitive caching
1301         _busy=$(progress "BUSY" "$CBUSY")
1302         _ok=$(progress "DONE")
1303         _started=$(progress "WORK")
1304         _fail=$(progress "FAIL" "$CFAIL")
1305         _died=$(progress "DIED" "$CFAIL")
1306
1307         # we don't use heredoc, as ksh attempts to create tempfile then
1308         (> "$cachefile" ) 2>/dev/null || return
1309         echo "_busy='$_busy';" >> "$cachefile"
1310         echo "_ok='$_ok';" >> "$cachefile"
1311         echo "_started='$_started';" >> "$cachefile"
1312         echo "_fail='$_fail';" >> "$cachefile"
1313         echo "_died='$_died';" >> "$cachefile"
1314         echo "_check='$check';" >> "$cachefile"
1315 }
1316
1317 rc_gettext_init() {
1318         if [ -z "$GETTEXT" ]; then
1319                 if [ -x /bin/gettext -o -x /usr/bin/gettext ]; then
1320                         GETTEXT=yes
1321                 else
1322                         GETTEXT=no
1323                 fi
1324         fi
1325
1326         if [ -z "$TPUT" ]; then
1327                 if [ -d /usr/share/terminfo ] && [ -x /usr/bin/tput -o -x /bin/tput ]; then
1328                         TPUT=yes
1329                         # check if we are on proper terminal
1330                         tput longname >/dev/null 2>&1 || TPUT=no
1331                 else
1332                         TPUT=no
1333                 fi
1334         fi
1335 }
1336
1337 use_upstart () {
1338         return 1
1339 }
1340 emit () {
1341         return 0
1342 }
1343 is_upstart_task() {
1344         return 1
1345 }
1346 is_upstart_running() {
1347         return 1
1348 }
1349 upstart_start() {
1350         return 1
1351 }
1352 upstart_stop() {
1353         return 1
1354 }
1355 upstart_reload() {
1356         return 0
1357 }
1358 upstart_status() {
1359         return 1
1360 }
1361 _upstart_controlled() {
1362         return 0
1363 }
1364 alias upstart_controlled='_upstart_controlled $0 "$@"'
1365
1366 rc_gettext_init
1367 rc_cache_init
1368
1369 #/*
1370 # * Local variables:
1371 # * mode: sh
1372 # * indent-tabs-mode: notnil
1373 # * End:
1374 # *
1375 # */