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