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