rc.d/init.d/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/init.d directory.
   4 #
   5 # $Id$
   6 #
   7 # Author:       Miquel van Smoorenburg, <miquels@drinkel.nl.mugnet.org>
   8 # Hacked by:    Greg Galloway and Marc Ewing
   9 # Modified for PLD Linux by:
  10 #               Marek Obuchowicz <elephant@pld-linux.org>
  11 #               Arkadiusz Miśkiewicz <misiek@pld-linux.org>
  12 #               Michał Kochanowicz <mkochano@pld-linux.org>
  13 #               Łukasz Pawelczyk <havner@pld-linux.org>
  14
  15 # First set up a default search path.
  16 export PATH="/sbin:/usr/sbin:/bin:/usr/bin"
  17
  18 # Set defaults
  19 if [ -z "$COLUMNS" -o -z "$LINES" ]; then
  20         _setterm() {
  21                 set -- $(stty size 2>/dev/null)
  22                 LINES=${LINES:-$1}
  23                 COLUMNS=${COLUMNS:-$2}
  24         }
  25         _setterm
  26         unset _setterm
  27 fi
  28 [ -z "$COLUMNS" ] && 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 [ -z "$VSERVER" -o "$VSERVER" = "detect" ]; then
  62         {
  63                 while read _f _ctx; do
  64                         [ "$_f" = "VxID:" -o "$_f" = "s_context:" ] && break
  65                 done </proc/self/status
  66         } 2>/dev/null
  67         if [ -z "$_ctx" -o "$_ctx" = "0" ]; then
  68                 VSERVER=no
  69         else
  70                 VSERVER=yes
  71         fi
  72         unset _f _ctx
  73 fi
  74
  75 # we need to know in functions if we were called from a terminal
  76 if [ -z "$ISATTY" ]; then
  77         [ -t ] && ISATTY=yes || ISATTY=no
  78         export ISATTY
  79 fi
  80
  81 is_yes() {
  82         # Test syntax
  83         if [ $# = 0 ]; then
  84                 msg_usage " is_yes {value}"
  85                 return 2
  86         fi
  87
  88         # Check value
  89         case "$1" in
  90         yes|Yes|YES|true|True|TRUE|on|On|ON|Y|y|1)
  91                 # true returns zero
  92                 return 0
  93                 ;;
  94         *)
  95                 # false returns one
  96                 return 1
  97                 ;;
  98         esac
  99 }
 100
 101 is_no() {
 102         # Test syntax
 103         if [ $# = 0 ]; then
 104                 msg_usage " is_no {value}"
 105                 return 2
 106         fi
 107
 108         case "$1" in
 109         no|No|NO|false|False|FALSE|off|Off|OFF|N|n|0)
 110                 # true returns zero
 111                 return 0
 112                 ;;
 113         *)
 114                 # false returns one
 115                 return 1
 116                 ;;
 117         esac
 118 }
 119
 120 # checks if file is empty
 121 # empty lines and lines beginning with hash are ignored
 122 is_empty_file() {
 123         [ -s "$1" ] || return 0
 124         egrep -vq "^(#|[[:blank:]]*$)" "$1" && return 1 || return 0
 125 }
 126
 127 # returns OK if $1 contains $2
 128 strstr() {
 129         local a=$2
 130         [ "${1#*$a*}" = "$1" ] && return 1
 131         return 0
 132 }
 133
 134 if is_yes "$FASTRC" || is_yes "$IN_SHUTDOWN"; then
 135         RC_LOGGING=no
 136 fi
 137
 138 if is_no "$RC_LOGGING"; then
 139         initlog() {
 140                 RESULT=0
 141                 while [ "$1" != "${1##-}" ]; do
 142                         case $1 in
 143                         -c)
 144                                 shift
 145                                 $1
 146                                 RESULT=$?
 147                                 break
 148                                 ;;
 149                         *)
 150                                 shift
 151                                 ;;
 152                         esac
 153                 done
 154                 return $RESULT
 155         }
 156 fi
 157
 158 kernelver() {
 159         typeset _x _y _z v old_IFS ver
 160         {
 161                 read _x _y v _z
 162                 old_IFS=$IFS
 163                 IFS='.'
 164                 set -- $v
 165                 IFS=$old_IFS
 166
 167                 # strip _* or -* from versions like: "2.6.25_vanilla-1", "2.6.25-1"
 168                 ver=${3%%[-_]*}
 169
 170                 while [ ${#ver} -lt 3 ]; do ver="0$ver"; done
 171                 ver="$2$ver"
 172                 while [ ${#ver} -lt 6 ]; do ver="0$ver"; done
 173                 ver="$1$ver"
 174                 while [ ${#ver} -lt 9 ]; do ver="0$ver"; done
 175                 echo $ver
 176         } < /proc/version
 177 }
 178
 179 kernelverser() {
 180         typeset _x _y _z v old_IFS ver
 181         {
 182                 read _x _y v _z
 183                 old_IFS=$IFS
 184                 IFS='.'
 185                 set -- $v
 186                 IFS=$old_IFS
 187                 ver=$2
 188                 while [ ${#ver} -lt 3 ]; do ver="0$ver"; done
 189                 ver="$1$ver"
 190                 while [ ${#ver} -lt 6 ]; do ver="0$ver"; done
 191                 echo $ver
 192         } </proc/version
 193 }
 194
 195 kernelvermser() {
 196         typeset _x _y _z v old_IFS ver
 197         {
 198                 read _x _y v _z
 199                 old_IFS=$IFS
 200                 IFS='.'
 201                 set -- $v
 202                 IFS=$old_IFS
 203                 ver="$1$ver"
 204                 while [ ${#ver} -lt 3 ]; do ver="0$ver"; done
 205                 echo $ver
 206         } </proc/version
 207 }
 208
 209 # Colors workaround
 210 termput() {
 211         is_yes "$ISATTY" || return
 212
 213         if is_yes "$FASTRC" || is_no "$TPUT"; then
 214                 case "$1" in
 215                 hpa)
 216                         echo -ne "\033[$(($2+1))G"
 217                         ;;
 218                 cuu*)
 219                         echo -ne "\033[${2}A"
 220                         ;;
 221                 el)
 222                         echo -ne "\033[0K"
 223                         ;;
 224                 setaf)
 225                         typeset ISBOLD
 226                         if [ -n "$3" ]; then
 227                                 ISBOLD="$3"
 228                         else
 229                                 ISBOLD="$NOBOLD";
 230                         fi
 231                         is_yes "$COLOR_INIT" && echo -ne "\033[${ISBOLD};3${2}m"
 232                         ;;
 233                 op)
 234                         termput setaf $NORMAL
 235                         ;;
 236                 esac
 237         else
 238                 case "$1" in
 239                 hpa | cuu* | el)
 240                         tput "$@"
 241                         ;;
 242                 setaf)
 243                         if [ "$3" = "1" ]; then tput bold; else tput sgr0; fi
 244                         is_yes "$COLOR_INIT" && tput setaf "$2"
 245                         ;;
 246                 op)
 247                         termput setaf $NORMAL
 248                         ;;
 249                 esac
 250         fi
 251 }
 252
 253 if [ ! -x /bin/printf ]; then
 254         # printf equivalent
 255         # FIXME: buggy when single or double quotes in message!
 256         printf() {
 257                 typeset text m
 258                 text="$1"
 259                 shift
 260                 if [ $# -gt 0 ]; then
 261                         m="$1"
 262                         shift
 263                         while [ $# -gt 0 ]; do
 264                                 m="$m\",\"$1"
 265                                 shift
 266                         done
 267                 fi
 268                 awk "BEGIN {printf \"$text\", \"$m\"; }"
 269         }
 270 fi
 271
 272 # National language support function
 273 nls() {
 274         typeset msg_echo nls_domain text message
 275         msg_echo='\n'
 276         nls_domain="$NLS_DOMAIN"
 277         while [ "$1" != "${1##-}" ]; do
 278                 case "$1" in
 279                 --nls-domain)
 280                         shift
 281                         nls_domain="$1"
 282                         shift
 283                         ;;
 284                 -n)
 285                         msg_echo=''
 286                         shift
 287                         ;;
 288                 esac
 289         done
 290         message="$1"
 291         shift
 292
 293         # empty message, so we return --misiek
 294         if [ -z "$message" ]; then
 295                 echo -en "$msg_echo"
 296                 return
 297         fi
 298
 299         if is_yes "$GETTEXT"; then
 300                 message=$(TEXTDOMAINDIR="/etc/sysconfig/locale" gettext -e --domain="${nls_domain:-rc-scripts}" "$message")
 301         fi
 302
 303         printf "$message" "$@"
 304         echo -en "$msg_echo"
 305 }
 306
 307 rc_splash() {
 308         typeset action
 309
 310         action="$1"
 311
 312         if ! is_no "$BOOT_SPLASH" && ! is_yes "$VSERVER"; then
 313                 [ -x /bin/splash ] && /bin/splash "$action"
 314         fi
 315
 316         : $((progress++))
 317 }
 318
 319 msg_network_down() {
 320         nls "ERROR: Networking is down. %s can't be run." "$1" >&2
 321 }
 322
 323 msg_starting() {
 324         show "Starting %s service" "$1"
 325 }
 326
 327 msg_already_running() {
 328         nls "%s service is already running." "$1"
 329 }
 330
 331 msg_stopping() {
 332         show "Stopping %s service" "$1"
 333 }
 334
 335 msg_not_running() {
 336         nls "%s service is not running." "$1"
 337 }
 338
 339 msg_reloading() {
 340         show "Reloading %s service" "$1"
 341 }
 342
 343 msg_usage() {
 344         nls "Usage: %s" "$*"
 345 }
 346
 347 # Some functions to handle PLD Linux-style messages
 348 show() {
 349         typeset text
 350         typeset -i len
 351
 352         if is_no "$FASTRC" && is_yes "$GETTEXT"; then
 353                 text=$(nls -n "$@")
 354         else
 355                 text=$(printf "$@")
 356         fi
 357         len=${#text}
 358         while [ $((len++)) -lt $INIT_COL ]; do
 359                 text="$text."
 360         done
 361         if [ -n "$CHARS" ]; then
 362                 termput setaf $CCHARS
 363                 echo -n "$CHARS"
 364                 termput op
 365         fi
 366         echo -n "$text"
 367 }
 368
 369 deltext() {
 370         termput hpa $INIT_COL
 371 }
 372
 373 # Displays message in square brackests ("[ DONE ]"). Takes two arguments.
 374 # First is the text to display, second is color number to use (argument to
 375 # tput setaf). If second argument is not given, default (2, green) will be
 376 # used).
 377 progress() {
 378         typeset COLOR
 379         if [ -n "$2" ]; then COLOR="$2"; else COLOR="$CDONE"; fi
 380         deltext
 381         echo -n "$(termput setaf $CBRACKETS)[$(termput setaf $COLOR) $(nls --nls-domain rc-scripts "$1") $(termput setaf $CBRACKETS)]$(termput op)"
 382 }
 383
 384 busy() {
 385         echo -n "$_busy"
 386 }
 387
 388 ok() {
 389         echo "$_ok"
 390 }
 391
 392 started() {
 393         echo "$_started"
 394 }
 395
 396 fail() {
 397         echo "$_fail"
 398         return 1
 399 }
 400
 401 died() {
 402         echo "$_died"
 403         return 1
 404 }
 405
 406 # Check if $pid (could be plural) are running
 407 checkpid() {
 408         while [ "$1" ]; do
 409                 [ -d "/proc/$1" ] && return 0
 410                 shift
 411         done
 412         return 1
 413 }
 414
 415 # - outside chroot get only those processes, which are outside chroot.
 416 # - inside chroot get only those processes, which are inside chroot.
 417 # - don't filter out pids which do not have corresponding running processes (process died etc)
 418 # (note: some processes like named are chrooted but run outside chroot)
 419 # - do nothing inside vserver
 420 filter_chroot() {
 421         if is_yes "$VSERVER"; then
 422                 echo $@
 423                 return
 424         fi
 425         if [ $# -lt 1 -o ! -d /proc/1 ]; then
 426                 echo $@
 427                 return
 428         fi
 429         local root_dir good_pids="" good_add_pid
 430         for root_pid in $@; do
 431                 root_dir=$(resolvesymlink /proc/${root_pid}/root)
 432                 if [ -n "$root_dir" ]; then
 433                         good_add_pid=1
 434                         if [ -n "${SYSTEM_CHROOTS}" ]; then
 435                                 for r_dir in ${SYSTEM_CHROOTS}; do
 436                                         echo "$root_dir" | grep -q "^${r_dir}" && good_add_pid=0
 437                                 done
 438                         fi
 439                         [ "$good_add_pid" -eq 1 ] && good_pids="$good_pids $root_pid"
 440                 elif [ ! -d "/proc/$root_pid" ]; then
 441                         good_pids="$good_pids $root_pid"
 442                 fi
 443         done
 444         echo $good_pids
 445 }
 446
 447 # Usage run_cmd Message command_to_run
 448 run_cmd() {
 449         typeset exit_code errors message force_err
 450         typeset -i force_err=0
 451         typeset -i exit_code=0
 452         case "$1" in
 453         -a)
 454                 force_err=1
 455                 shift
 456                 ;;
 457         esac
 458         message=$1
 459         show "$message"; busy
 460         shift
 461         cd /
 462         if errors=$(
 463                 export HOME=/tmp TMPDIR=/tmp
 464                 if is_no "$RC_LOGGING"; then
 465                         "$@" 2>&1
 466                 else
 467                         initlog -c "$*" 2>&1
 468                 fi
 469                 ); then
 470                 ok
 471                 log_success "$1 $message"
 472         else
 473                 fail
 474                 log_failed "$1 $message"
 475                 exit_code=1
 476         fi
 477         [ -n "$errors" ] && [ $exit_code -eq 1 -o $force_err -eq 1 ] && echo "$errors"
 478         return $exit_code
 479 }
 480
 481 _daemon_set_ulimits() {
 482         local opt val ksh=${KSH_VERSION:+1}
 483         set -- ${SERVICE_LIMITS:-$DEFAULT_SERVICE_LIMITS}
 484         while [ $# -gt 0 ]; do
 485                 opt=$1
 486                 val=$2
 487                 if [ "$ksh" ]; then
 488                         case "$opt" in
 489                         -Hu)
 490                                 opt=-Hp
 491                         ;;
 492                         -Su)
 493                                 opt=-Sp
 494                         ;;
 495                         -u)
 496                                 opt=-p
 497                         ;;
 498                         esac
 499                 fi
 500                 ulimit $opt $val
 501                 shift 2
 502         done
 503 }
 504
 505 # A function to start a program (now it's useful on read-only filesystem too)
 506 daemon() {
 507         typeset errors="" prog="" end="" waitname="" waittime=""
 508         typeset -i exit_code=0
 509         local nice=$SERVICE_RUN_NICE_LEVEL
 510         local fork user closefds pidfile makepid chdir=/
 511
 512         while [ $# -gt 0 ]; do
 513                 case $1 in
 514                 '')
 515                 msg_usage " daemon [--check] [--user user] [--fork] [--chdir directory] [--closefds] [--waitforname procname] [--waitfortime seconds] [--pidfile file] [--makepid] [+/-nicelevel] {program} <program args>"
 516                         return 2
 517                         ;;
 518                 --check)
 519                         # for compatibility with redhat/mandrake
 520                         nls "warning: --check option is ignored!"
 521                         shift
 522                         ;;
 523                 --user)
 524                         shift
 525                         [ "$1" != "root" ] && prog="/bin/su $1 -s /bin/sh -c \""
 526                         user=$1
 527                         ;;
 528                 --fork)
 529                         fork=1
 530                         prog="/usr/bin/setsid sh -c \""
 531                         end='&'
 532                         ;;
 533                 --chdir)
 534                         shift
 535                         chdir=$1
 536                         ;;
 537                 --closefds)
 538                         closefds=1
 539                         ;;
 540                 --waitforname)
 541                         shift
 542                         waitname="$1"
 543                         ;;
 544                 --waitfortime)
 545                         shift
 546                         waittime="$1"
 547                         ;;
 548                 --pidfile)
 549                         shift
 550                         pidfile="$1"
 551                         [[ "$pidfile" != /* ]] && pidfile="/var/run/$pidfile"
 552                         ;;
 553                 --makepid)
 554                         makepid=1
 555                         ;;
 556                 -*|+*)
 557                         nice=$1
 558                         shift
 559                         break
 560                         ;;
 561                 *)
 562                         break
 563                         ;;
 564                 esac
 565                 shift
 566         done
 567         # If command to execute ends with quotation mark, add remaining
 568         # arguments and close quotation.
 569         if [ "$prog" != "${prog%\"}" ]; then
 570                 prog="$prog $*$end\""
 571         else
 572                 prog="$prog $*$end"
 573         fi
 574
 575         _daemon_set_ulimits
 576
 577         [ -z "$DEFAULT_SERVICE_UMASK" ] && DEFAULT_SERVICE_UMASK=022
 578         [ -z "$DEFAULT_SERVICE_RUN_NICE_LEVEL" ] && DEFAULT_SERVICE_RUN_NICE_LEVEL=0
 579
 580         # And start it up.
 581         busy
 582         cd $chdir
 583         [ -n "$SERVICE_CPUSET" ] && is_yes "$CPUSETS" && echo $$ > "/dev/cpuset/${SERVICE_CPUSET}/tasks"
 584         if errors=$(
 585                 umask ${SERVICE_UMASK:-$DEFAULT_SERVICE_UMASK};
 586                 export USER=root HOME=/tmp TMPDIR=/tmp
 587                 nice=${nice:-$DEFAULT_SERVICE_RUN_NICE_LEVEL}
 588                 nice=${nice:-0}
 589
 590                 if [ "$closefds" = 1 ]; then
 591                         exec 1>&-
 592                         exec 2>&-
 593                         exec 0>&-
 594                 else
 595                         exec 2>&1
 596                 fi
 597
 598                 if is_no "$RC_LOGGING"; then
 599                         prog=$1; shift
 600                         if [ ! -x $prog ]; then
 601                                 logger -t rc-scripts -p daemon.debug "daemon: Searching PATH for $prog, consider using full path in initscript"
 602                                 local a o=$IFS
 603                                 IFS=:
 604                                 for a in $PATH; do
 605                                         if [ -x $a/$prog ]; then
 606                                                 prog=$a/$prog
 607                                                 break
 608                                         fi
 609                                 done
 610                                 IFS=$o
 611                         fi
 612                         /sbin/start-stop-daemon -q --start \
 613                                 --nicelevel $nice \
 614                                 ${pidfile:+--pidfile $pidfile} \
 615                                 ${makepid:+--make-pidfile} \
 616                                 ${user:+--chuid $user} \
 617                                 ${chdir:+--chdir "$chdir"} \
 618                                 ${fork:+--background} \
 619                                 ${waitname:+--name $waitname} \
 620                                 --exec "$prog" \
 621                                 -- ${1:+"$@"}
 622                 else
 623                         nice -n $nice initlog -c "$prog" 2>&1
 624                 fi
 625                 ); then
 626
 627                 if [ -n "$waitname" -a -n "$waittime" ]; then
 628                         # Save basename.
 629                         base=${waitname##*/}
 630                         # Find pid.
 631                         pid=$(pidofproc "$waitname" "$pidfile")
 632                         [ -z "$pid" ] && pid=$(pidofproc "$base" "$pidfile")
 633                         i=0
 634                         while [ "$i" -lt "$waittime" ]; do
 635                                 i=$((i + 1))
 636                                 checkpid $pid && sleep 1 || break
 637                         done
 638                 fi
 639                 log_success "$1 startup"
 640                 ok
 641         else
 642                 exit_code=1
 643                 fail
 644                 log_failed "$1 startup"
 645                 [ -n "$errors" ] && echo >&2 "$errors"
 646         fi
 647         return $exit_code
 648 }
 649
 650 # A function to stop a program.
 651 killproc() {
 652         typeset notset killlevel base pid pidfile result
 653         # Test syntax.
 654         if [ $# = 0 ]; then
 655                 msg_usage " killproc [--pidfile PIDFILE] {program} [-SIGNAME]"
 656                 return 2
 657         fi
 658
 659         while [ "$1" != "${1##-}" ]; do
 660                 case $1 in
 661                 --pidfile)
 662                         pidfile="$2"
 663                         [[ "$pidfile" != /* ]] && pidfile="/var/run/$pidfile"
 664                         shift 2
 665                         ;;
 666                 --waitforname)
 667                         waitname="$2"
 668                         shift 2
 669                         ;;
 670                 --waitfortime)
 671                         waittime="$2"
 672                         shift 2
 673                         ;;
 674                 esac
 675         done
 676
 677         busy
 678
 679         typeset -i notset=0
 680         # check for second arg to be kill level
 681         if [ -n "$2" ]; then
 682                 killlevel=$2
 683         else
 684                 notset=1
 685                 killlevel="-KILL"
 686         fi
 687
 688         # experimental start-stop-daemon based killing.
 689         # works only with pidfile
 690         if is_no "$RC_LOGGING" && [ "$pidfile" ]; then
 691                 local sig=${killlevel:--TERM}
 692                 /sbin/start-stop-daemon --stop \
 693                         --retry ${sig#-}/10/${sig#-}/60/KILL/10 \
 694                         -s ${sig#-} \
 695                         ${pidfile:+--pidfile $pidfile}
 696                 result=$?
 697                 if [ "$result" -eq 0 ]; then
 698                         ok
 699                 else
 700                         fail
 701                 fi
 702                 return $result
 703         fi
 704
 705
 706         # Save basename.
 707         base=${1##*/}
 708
 709         # Find pid.
 710         pid=$(pidofproc "$1" "$pidfile")
 711         [ -z "$pid" ] && pid=$(pidofproc "$base" "$pidfile")
 712
 713         # Kill it.
 714         if [ -n "$pid" -a "$pid" != "$$" ] && checkpid $pid 2>&1; then
 715                 if [ "$notset" = "1" ]; then
 716                         if checkpid $pid 2>&1; then
 717                                 # TERM first, then KILL if not dead
 718                                 kill -TERM $pid
 719                                 usleep 100000
 720                                 if checkpid $pid && sleep 1 &&
 721                                         checkpid $pid && sleep 3 &&
 722                                         checkpid $pid; then
 723                                         # XXX: SIGKILL is sent already on 4th second!
 724                                         # HARMFUL for example to mysqld (which is already workarounded)
 725                                         kill -KILL $pid
 726                                         usleep 100000
 727                                 fi
 728                         fi
 729                         checkpid $pid
 730                         result=$?
 731                         if [ "$result" -eq 0 ]; then
 732                                 fail
 733                                 log_failed "$1 shutdown"
 734                         else
 735                                 ok
 736                                 log_success "$1 shutdown"
 737                         fi
 738                         result=$(( ! $result ))
 739                 else
 740                         # use specified level only
 741                         if checkpid $pid > /dev/null 2>&1; then
 742                                 kill $killlevel $pid
 743                                 result=$?
 744                                 if [ "$result" -eq 0 ]; then
 745                                         ok
 746                                         log_success "$1 got $killlevel"
 747                                 else
 748                                         result=7
 749                                         fail
 750                                         log_failed "$1 didn't get $killlevel"
 751                                 fi
 752                         else
 753                                 result=7
 754                                 died
 755                                 log_failed "$1 shutdown"
 756                         fi
 757                 fi
 758         else
 759                 died
 760                 log_failed "$1 shutdown"
 761                 result=7
 762         fi
 763
 764         if [ -n "$waitname" -a -n "$waittime" ]; then
 765                 # Save basename.
 766                 base=${waitname##*/}
 767                 # Find pid.
 768                 pid=$(pidofproc "$waitname" "$pidfile")
 769                 [ -z "$pid" ] && pid=$(pidofproc "$base" "$pidfile")
 770                 i=0
 771                 while [ "$i" -lt "$waittime" ]; do
 772                         i=$(( i + 1 ))
 773                         checkpid $pid && sleep 1 || break
 774                 done
 775         fi
 776
 777         # Remove pid file if any.
 778         if [ "$notset" = "1" ]; then
 779                 rm -f /var/run/${base}.pid
 780         fi
 781
 782         return $result
 783 }
 784
 785 # A function to find the pid of a program.
 786 pidofproc() {
 787         typeset pid pidfile base=${1##*/}
 788         pidfile="$base.pid"
 789         [ -n "$2" ] && pidfile="$2"
 790
 791         # Test syntax.
 792         if [ $# = 0 ]; then
 793                 msg_usage " pidofproc {program}"
 794                 return 2
 795         fi
 796
 797         # First try pidfile or "/var/run/*.pid"
 798         if [[ "$pidfile" = /* ]]; then
 799                 pidfile="${pidfile}"
 800         else
 801                 pidfile="/var/run/${pidfile}";
 802         fi
 803         if [ -f "${pidfile}" ]; then
 804                 typeset p pid
 805                 pid=
 806                 for p in $(< "${pidfile}"); do
 807                         [ -z "$(echo "$p" | awk '{gsub(/[0-9]/,"");print;}')" ] && pid="$pid $p"
 808                 done
 809         fi
 810
 811         # Next try "pidof"
 812         [ -z "$pid" ] && pidof -o $$ -o $PPID -o %PPID -x "$1"
 813         pid=$(filter_chroot "$pid")
 814         echo $pid
 815 }
 816
 817 status() {
 818         typeset pid subsys daemon cpuset_msg pidfile
 819         if [ "$1" = "--pidfile" ]; then
 820                 pidfile=$2
 821                 [[ "$pidfile" != /* ]] && pidfile="/var/run/$pidfile"
 822                 shift 2
 823         fi
 824
 825         subsys=$1
 826         daemon=${2:-$subsys}
 827
 828         # Test syntax.
 829         if [ $# = 0 ]; then
 830                 msg_usage " status [--pidfile PIDFILE] {subsys} [{daemon}]"
 831                 return 2
 832         fi
 833
 834         # if pidfile specified, pid must be there
 835         if [ "$pidfile" -a -f "$pidfile" ]; then
 836                 read pid < $pidfile
 837         else
 838                 pid=$(pidof -o $$ -o $PPID -o %PPID -x $daemon)
 839         fi
 840         pid=$(filter_chroot "$pid")
 841
 842         if [ "$pid" ]; then
 843                 cpuset_msg="..."
 844                 if [ -n "$SERVICE_CPUSET" ] && is_yes "$CPUSETS" ]; then
 845                         if $(grep -q "$pid" "/dev/cpuset/${SERVICE_CPUSET}/tasks"); then
 846                                 cpuset_msg=$(nls " in cpuset %s..." "$SERVICE_CPUSET")
 847                         else
 848                                 cpuset_msg=$(nls " outside of configured cpuset %s..." "$SERVICE_CPUSET")
 849                         fi
 850                 fi
 851                 nls "%s (pid %s) is running%s" "$daemon" "$pid" "$cpuset_msg"
 852                 return 0
 853         fi
 854
 855         # Next try "/var/run/*.pid" files
 856         local base=${daemon##*/}
 857         if [ -f /var/run/${base}.pid ]; then
 858                 read pid < /var/run/${base}.pid
 859                 pid=$(filter_chroot "$pid")
 860                 if [ "$pid" != "" ]; then
 861                         nls "%s dead but pid file exists" "$subsys"
 862                         return 1
 863                 fi
 864         fi
 865
 866         # See if /var/lock/subsys/$subsys exists
 867         if [ -f /var/lock/subsys/$subsys ]; then
 868                 nls "%s dead but subsys locked" "$subsys"
 869                 return 2
 870         fi
 871         nls "%s is stopped" "$subsys"
 872         return 3
 873 }
 874
 875 # Confirm whether we really want to run this service
 876 confirm() {
 877         typeset answer
 878         nls -n "Start service %s (Y)es/(N)o/(C)ontinue? [Y] " "$1"
 879         read answer
 880         case $answer in
 881         y|Y|t|T|j|J|"")
 882                 return 0
 883                 ;;
 884         c|C|k|K|w|W)
 885                 return 2
 886                 ;;
 887         n|N)
 888                 return 1
 889                 ;;
 890         *)
 891                 confirm $1
 892                 return $?
 893                 ;;
 894         esac
 895 }
 896
 897 # module is needed (ie. is requested, is available and isn't loaded already)
 898 is_module() {
 899         # module name without .o at end
 900         if ! lsmod | grep -q "$1"; then
 901                 if ls -R /lib/modules/$(uname -r)/ 2> /dev/null | grep -q "${1}.\(\|k\)o\(\|.gz\)"; then
 902                         # true
 903                         return 0
 904                 fi
 905         fi
 906         # false
 907         return 1
 908 }
 909
 910 _modprobe() {
 911         typeset parsed single die args foo result
 912         parsed=no
 913         while is_no "$parsed"; do
 914                 case "$1" in
 915                 "single")
 916                         single=yes
 917                         shift
 918                         ;;
 919                 "die")
 920                         die=yes
 921                         shift
 922                         ;;
 923                 -*)
 924                         args="$args $1"
 925                         shift
 926                         ;;
 927                 *)
 928                         parsed=yes
 929                         ;;
 930                 esac
 931         done
 932         if is_yes "${single}"; then
 933                 foo="$@"
 934                 show "Loading %s kernel module(s)" "$foo"
 935                 busy
 936         fi
 937         if [ -x /sbin/modprobe ]; then
 938                 /sbin/modprobe -s $args "$@"
 939                 result=$?
 940         else
 941                 deltext; fail
 942                 result=1
 943         fi
 944         if is_yes "${single}"; then
 945                 deltext
 946                 if [ $result = "0" ]; then
 947                         is_yes "$single" && ok
 948                 else
 949                         fail
 950                         if is_yes "$die"; then
 951                                 nls "Could not load %s kernel module(s)" "$@"
 952                                 exit 1
 953                         fi
 954                 fi
 955         fi
 956 }
 957
 958 if is_no "$RC_LOGGING"; then
 959         log_success() {
 960                 :
 961         }
 962
 963         log_failed() {
 964                 :
 965         }
 966 else
 967         log_success() {
 968                 initlog -n $0 -s "$1 $2" -e 1
 969         }
 970
 971         log_failed() {
 972                 initlog -n $0 -s "$1 $2" -e 2
 973         }
 974 fi
 975
 976 # Check if any flavor of portmapper is running
 977 check_portmapper() {
 978         typeset RPCINFO
 979
 980         if [ -x /usr/sbin/rpcinfo ]; then
 981                 if /usr/sbin/rpcinfo -p localhost >/dev/null 2>/dev/null; then
 982                         return 0
 983                 else
 984                         return 1
 985                 fi
 986         elif [ -x /sbin/pidof ]; then
 987                 [ -z "$(/sbin/pidof portmap)" -a \
 988                         -z "$(/sbin/pidof rpcbind)" ] && return 1
 989         fi
 990         return 0
 991 }
 992
 993 rc_cache_init() {
 994         # If we have cachefile, use it.
 995         # If we don't, create memory variables and try to save silently,
 996         local cachefile='/var/cache/rc-scripts/msg.cache'
 997
 998         local term
 999         if is_yes "$ISATTY"; then
1000                 term=$TERM
1001         else
1002                 term=dumb
1003         fi
1004
1005         # We create $check variable which is used to invalidate the cache.
1006         # The $check contains user locale and terminal.
1007         local check="$term.$LC_MESSAGES.$INIT_COL"
1008
1009         if [ -f "$cachefile" -a "$cachefile" -nt /etc/sysconfig/system -a "$cachefile" -nt /etc/sysconfig/init-colors ]; then
1010                 if . "$cachefile" 2>/dev/null; then
1011                         if [ "$check" = "$_check" ]; then
1012                                 return
1013                         fi
1014                 fi
1015         fi
1016
1017         # primitive caching
1018         _busy=$(progress "BUSY" "$CBUSY")
1019         _ok=$(progress "DONE")
1020         _started=$(progress "WORK")
1021         _fail=$(progress "FAIL" "$CFAIL")
1022         _died=$(progress "DIED" "$CFAIL")
1023
1024         # we don't use heredoc, as ksh attempts to create tempfile then
1025         (> "$cachefile" ) 2>/dev/null || return
1026         echo "_busy='$_busy';" >> "$cachefile"
1027         echo "_ok='$_ok';" >> "$cachefile"
1028         echo "_started='$_started';" >> "$cachefile"
1029         echo "_fail='$_fail';" >> "$cachefile"
1030         echo "_died='$_died';" >> "$cachefile"
1031         echo "_check='$check';" >> "$cachefile"
1032 }
1033
1034 rc_gettext_init() {
1035         if [ -z "$GETTEXT" ]; then
1036                 if [ -x /bin/gettext -o -x /usr/bin/gettext ]; then
1037                         GETTEXT=yes
1038                 else
1039                         GETTEXT=no
1040                 fi
1041         fi
1042
1043         if [ -z "$TPUT" ]; then
1044                 if [ -d /usr/share/terminfo ] && [ -x /usr/bin/tput -o -x /bin/tput ]; then
1045                         TPUT=yes
1046                         # check if we are on proper terminal
1047                         tput longname >/dev/null 2>&1 || TPUT=no
1048                 else
1049                         TPUT=no
1050                 fi
1051         fi
1052 }
1053
1054 rc_gettext_init
1055 rc_cache_init
1056
1057 #/*
1058 # * Local variables:
1059 # * mode: sh
1060 # * indent-tabs-mode: notnil
1061 # * End:
1062 # *
1063 # */