rc.d/init.d/functions

   1 # functions     This file contains functions to be used by most or all
   2 #               shell scripts in the /etc/init.d directory.
   3 #
   4 # $Id: functions,v 1.72 2002/06/13 13:06:13 grabba Exp $
   5 #
   6 # Author:       Miquel van Smoorenburg, <miquels@drinkel.nl.mugnet.org>
   7 # Hacked by:    Greg Galloway and Marc Ewing
   8 # Modified for PLD by:
   9 #               Marek Obuchowicz <elephant@pld.org.pl>
  10 #               Arkadiusz Mi¶kiewicz <misiek@pld.org.pl>
  11 #               Micha³ Kochanowicz <mkochano@pld.org.pl>
  12
  13 # First set up a default search path.
  14 export PATH="/sbin:/usr/sbin:/bin:/usr/bin:/usr/X11R6/bin"
  15
  16 # Set defaults
  17 INIT_COL=67
  18
  19 # Source configuration if available - may override default values
  20 [ -r /etc/sysconfig/system ] && . /etc/sysconfig/system
  21
  22 [ -z "$COLUMNS" ] && COLUMNS=80
  23
  24 # Colors workaround
  25 termput()
  26 {
  27         if [ ! -d /usr/share/terminfo ] || \
  28              [ ! -x /usr/bin/tput -a ! -x /bin/tput ]; then
  29                 case "$1" in
  30                   hpa)
  31                         echo -ne "\033[$(($2+1))G"
  32                         ;;
  33                   cuu*)
  34                         echo -ne "\033[${2}A"
  35                         ;;
  36                   el)
  37                         echo -ne "\033[0K"
  38                         ;;
  39                   setaf)
  40                         is_yes "$COLOR_INIT" && echo -ne "\033[0;3${2}m"
  41                         ;;
  42                   op)
  43                         termput setaf 9
  44                         ;;
  45                   esac
  46         else
  47                 # check if we are on proper terminal
  48                 tput longname > /dev/null 2>&1 /dev/null || return
  49
  50                 case "$1" in
  51                   hpa | cuu* | el)
  52                         tput "$@"
  53                         ;;
  54                   setaf)
  55                         is_yes "$COLOR_INIT" && tput "$@"
  56                         ;;
  57                   op)
  58                         tput setaf 9
  59                         ;;
  60                  esac
  61         fi
  62 }
  63
  64 # printf equivalent
  65 printf_()
  66 {
  67         typeset text m
  68         text="$1" ;
  69         shift ;
  70         if [ $# -gt 0 ]; then
  71                 m="$1";
  72                 shift;
  73                 while [ $# -gt 0 ]; do
  74                         m="$m\",\"$1" ;
  75                         shift ;
  76                 done
  77         fi
  78         awk "BEGIN {printf \"$text\", \"$m\"; }"
  79 }
  80
  81 # National language support function
  82 nls()
  83 {
  84         typeset msg_echo old_nls_domain text message
  85         msg_echo='\n'
  86         old_nls_domain="$NLS_DOMAIN"
  87         # parse command line
  88         # don't use -o instead || here - this will broke ksh --misiek
  89         while [ "$1" != "${1##-}" ] || [ "$1" != "${1##+}" ]; do
  90                 case "$1" in
  91                         --nls-domain)
  92                                 shift
  93                                 NLS_DOMAIN="$1"
  94                                 shift
  95                                 ;;
  96                         -n)
  97                                 msg_echo=''
  98                                 shift
  99                                 ;;
 100                 esac
 101         done
 102         message="$1"
 103         shift
 104         # empty message, so we return --misiek
 105         if [ -z "$message" ]; then
 106                 NLS_DOMAIN="$old_nls_domain"
 107                 echo -en "$msg_echo"
 108                 return
 109         fi
 110
 111         if [ -x /bin/gettext -o -x /usr/bin/gettext ]; then
 112                 text=$(TEXTDOMAINDIR="/etc/sysconfig/locale" gettext -e --domain="${NLS_DOMAIN:-rc-scripts}" "$message")
 113                 printf_ "$text" "$@"
 114         else
 115                 printf_ "$message" "$@"
 116         fi
 117
 118         echo -en "$msg_echo"
 119         NLS_DOMAIN="$old_nls_domain"
 120 }
 121
 122 msg_network_down()
 123 {
 124         nls "ERROR: Networking is down. %s can't be run." "$1"
 125 }
 126
 127 msg_starting()
 128 {
 129         show "Starting %s service" "$1"
 130 }
 131
 132 msg_already_running()
 133 {
 134         nls "%s service is already running." "$1"
 135 }
 136
 137 msg_stopping()
 138 {
 139         show "Stopping %s service" "$1"
 140 }
 141
 142 msg_not_running()
 143 {
 144         nls "%s service is not running." "$1"
 145 }
 146
 147 msg_reloading()
 148 {
 149         show "Reloading %s service" "$1"
 150 }
 151
 152 msg_usage()
 153 {
 154         nls "Usage: %s" "$*"
 155 }
 156
 157 # Some functions to handle PLD-style messages
 158 show()
 159 {
 160         typeset text
 161         text=$(nls "$@")
 162         echo -n "$text"
 163         awk "BEGIN { for (j=length(\"$text\"); j<$INIT_COL; j++) printf \".\" }"
 164 }
 165
 166 # Displays message in square brackests ("[ DONE ]"). Takes two arguments.
 167 # First is the text to display, second is color number to use (argument to
 168 # tput setaf). If second argument is not given, default (2, green) will be
 169 # used).
 170 progress()
 171 {
 172         typeset COLOR
 173         if [ -n "$2" ]; then COLOR="$2"; else COLOR="2"; fi
 174         deltext
 175         echo -n "$(termput setaf 6)[$(termput setaf "$COLOR") $(nls --nls-domain rc-scripts "$1") $(termput setaf 6)]$(termput op)"
 176 }
 177
 178 busy()
 179 {
 180         progress "BUSY" 5
 181 }
 182
 183 ok()
 184 {
 185         progress "DONE"
 186         echo
 187 }
 188
 189 started()
 190 {
 191         progress "WORK"
 192         echo
 193 }
 194
 195 fail()
 196 {
 197         progress "FAIL" 1
 198         echo
 199         return 1
 200 }
 201
 202 died()
 203 {
 204         progress "DIED" 1
 205         echo
 206         return 1
 207 }
 208
 209 deltext()
 210 {
 211         termput hpa $INIT_COL
 212 }
 213
 214 # Usage run_cmd Message command_to_run
 215 run_cmd()
 216 {
 217         typeset exit_code errors message force_err
 218         typeset -i force_err=0
 219         typeset -i exit_code=0
 220         case "$1" in
 221                 -a)
 222                         force_err=1
 223                         shift
 224                         ;;
 225         esac
 226         message=$1
 227         show "$message"; busy
 228         shift
 229         if errors=$(HOME=/tmp TMPDIR=/tmp initlog -c "$*" 2>&1); then
 230                 ok
 231                 log_success "$1 $message"
 232         else
 233                 fail
 234                 log_failed "$1 $message"
 235                 exit_code=1
 236         fi
 237         [ -n "$errors" ] && [ $exit_code -eq 1 -o $force_err -eq 1 ] && echo "$errors"
 238         return $exit_code
 239 }
 240
 241 # A function to start a program (now it's usefull on read-only filesystem too)
 242 daemon()
 243 {
 244         typeset errors="" prog=""
 245         typeset -i exit_code=0
 246         [ -z "$DEFAULT_SERVICE_RUN_NICE_LEVEL" ] && DEFAULT_SERVICE_RUN_NICE_LEVEL=0
 247         # Test syntax. Don't use -o instead || here - this will broke ksh --misiek
 248         while [ "$1" != "${1##-}" ] || [ "$1" != "${1##+}" ]; do
 249                 case $1 in
 250                 '')     msg_usage " daemon [--user user] [+/-nicelevel] {program}"
 251                         return 1
 252                         ;;
 253                 --check)
 254                         # for compatibility with redhat/mandrake
 255                         nls "warning: --check option is ignored!"
 256                         shift
 257                         shift
 258                         ;;
 259                 --user)
 260                         shift
 261                         [ "$1" != "root" ] && prog="/bin/su $1 -c \""
 262                         shift
 263                         ;;
 264                 -*|+*) SERVICE_RUN_NICE_LEVEL=$1
 265                         shift;;
 266                 esac
 267         done
 268         # If command to execute ends with quotation mark, add remaining
 269         # arguments and close quotation.
 270         if [ "$prog" != "${prog%\"}" ]; then
 271                 prog="$prog $*\""
 272         else
 273                 prog="$prog $*"
 274         fi
 275
 276         # make sure it doesn't core dump anywhere; while this could mask
 277         # problems with the daemon, it also closes some security problems
 278         ulimit -c 0
 279
 280         # Make sure daemons will be able to fork.
 281         # Limits are set via pam_limits.
 282         if [ -n "$KSH_VERSION" ]; then
 283                 ulimit -p unlimited
 284         elif [ -n "$ZSH_VERSION" ]; then
 285                 ulimit -u unlimited
 286         elif [ -n "$BASH_VERSION" ]; then
 287                 ulimit -u unlimited
 288 #       elif [ -n "`$SH -c 'echo ${.sh.version}' 2>/dev/null`" ]; then
 289         fi
 290
 291         # And start it up.
 292         busy
 293         if errors=$(HOME=/tmp TMPDIR=/tmp nice -n ${SERVICE_RUN_NICE_LEVEL:-$DEFAULT_SERVICE_RUN_NICE_LEVEL} initlog -c "$prog" 2>&1); then
 294                 log_success "$1 startup"
 295                 ok
 296         else
 297                 exit_code=1
 298                 fail
 299                 log_failed "$1 startup"
 300                 [ -n "$errors" ] && echo "$errors"
 301         fi
 302         return $exit_code
 303 }
 304
 305 # A function to stop a program.
 306 killproc()
 307 {
 308         typeset notset killlevel base pid
 309         # Test syntax.
 310         if [ $# = 0 ]; then
 311                 msg_usage " killproc {program} [signal]"
 312                 return 1
 313         fi
 314
 315         busy
 316
 317         typeset -i notset=0
 318         # check for second arg to be kill level
 319         if [ -n "$2" ] ; then
 320                 killlevel=$2
 321         else
 322                 notset=1
 323                 killlevel="-9"
 324         fi
 325
 326         # Save basename.
 327         base=$(basename $1)
 328
 329         # Find pid.
 330         pid=$(pidofproc $base)
 331
 332         # Kill it.
 333         if [ -n "$pid" ] ; then
 334                 if [ "$notset" = "1" ] ; then
 335                         if ps h $pid>/dev/null 2>&1; then
 336                                 # TERM first, then KILL if not dead
 337                                 kill -TERM $pid >/dev/null 2>&1
 338                                 usleep 100000
 339                                 if ps h $pid >/dev/null 2>&1 ; then
 340                                         sleep 1
 341                                         if ps h $pid >/dev/null 2>&1 ; then
 342                                                 sleep 3
 343                                                 if ps h $pid >/dev/null 2>&1 ; then
 344                                                         kill -KILL $pid >/dev/null 2>&1
 345                                                 fi
 346                                         fi
 347                                 fi
 348                                 if (ps h $pid >/dev/null 2>&1); then
 349                                    fail
 350                                    log_failed "$1 shutdown"
 351                                 else
 352                                    ok
 353                                    log_success "$1 shutdown"
 354                                 fi
 355                         else
 356                                 died
 357                                 log_failed "$1 shutdown"
 358                         fi
 359                 # use specified level only
 360                 else
 361                         if ps h $pid >/dev/null 2>&1; then
 362                                 if (kill $killlevel $pid); then
 363                                    ok
 364                                    log_success "$1 got $killlevel"
 365                                 else
 366                                    fail
 367                                    log_failed "$1 didn't get $killlevel"
 368                                 fi
 369                         else
 370                                 died
 371                                 log_failed "$1 shutdown"
 372                         fi
 373                 fi
 374         else
 375                 died
 376                 log_failed "$1 shutdown"
 377         fi
 378
 379         # Remove pid file if any.
 380         if [ "$notset" = "1" ]; then
 381                 rm -f /var/run/$base.pid
 382         fi
 383 }
 384
 385 # A function to find the pid of a program.
 386 pidofproc()
 387 {
 388         typeset pid
 389         # Test syntax.
 390         if [ $# = 0 ] ; then
 391                 msg_usage " pidofproc {program}"
 392                 return 1
 393         fi
 394
 395         # First try "/var/run/*.pid" files
 396         if [ -f /var/run/$1.pid ] ; then
 397                 pid=$(head -1 /var/run/$1.pid)
 398                 if [ -n "$pid" ] ; then
 399                         echo $pid
 400                         return 0
 401                 fi
 402         fi
 403
 404         # Next try "pidof"
 405         pid=$(pidof -o $$ -o $PPID -o %PPID -x $1)
 406         if [ -n "$pid" ] ; then
 407                 echo $pid
 408                 return 0
 409         fi
 410
 411         # Finally try to extract it from ps
 412         ps ax | awk 'BEGIN { prog=ARGV[1]; ARGC=1 }
 413                            { if ((prog == $5) || (("(" prog ")") == $5) ||
 414                              (("[" prog "]") == $5) ||
 415                            ((prog ":") == $5)) { print $1 ; exit 0 } }' $1
 416 }
 417
 418 status()
 419 {
 420         # Test syntax.
 421         if [ $# = 0 ] ; then
 422                 msg_usage " status {subsys} [{daemon}]"
 423                 return 1
 424         fi
 425
 426         subsys=$1
 427         daemon=${2:-$subsys}
 428
 429         # First try "pidof"
 430         pid=$(pidof -o $$ -o $PPID -o %PPID -x $daemon)
 431         if [ -n "$pid" ] ; then
 432                 nls "%s (pid %s) is running..." "$daemon" "$pid"
 433                 return 0
 434         else
 435                 pid=`ps ax | awk 'BEGIN { prog=ARGV[1]; ARGC=1 }
 436                            { if ((prog == $5) || (("(" prog ")") == $5) ||
 437                              (("[" prog "]") == $5) ||
 438                            ((prog ":") == $5)) { print $1 ; exit 0 } }' $1`
 439                 if [ "$pid" != "" ] ; then
 440                         nls "%s (pid %s) is running..." "$daemon" "$pid"
 441                         return 0
 442                 fi
 443         fi
 444
 445         # Next try "/var/run/*.pid" files
 446         if [ -f /var/run/$daemon.pid ] ; then
 447                 pid=$(head -1 /var/run/$1.pid)
 448                 if [ -n "$pid" ] ; then
 449                         nls "%s dead but pid file exists" "$1"
 450                         return 1
 451                 fi
 452         fi
 453         # See if /var/lock/subsys/$subsys exists
 454         if [ -f /var/lock/subsys/$subsys ]; then
 455                 nls "%s dead but subsys locked" "$daemon"
 456                 return 2
 457         fi
 458         nls "%s is stopped" "$subsys"
 459         return 3
 460 }
 461
 462 # Confirm whether we really want to run this service
 463 confirm() {
 464         typeset answer
 465         nls -n "Start service %s (Y)es/(N)o/(C)ontinue? [Y] " "$1"
 466         read answer
 467         case $answer in
 468                 y|Y|t|T|j|J|"")
 469                         return 0
 470                 ;;
 471                 c|C|k|K|w|W)
 472                         return 2
 473                 ;;
 474                 n|N)
 475                         return 1
 476                 ;;
 477                 *)
 478                         confirm $1
 479                         return $?
 480                 ;;
 481         esac
 482 }
 483
 484 is_yes()
 485 {
 486         # Test syntax
 487         if [ $# = 0 ] ; then
 488                 msg_usage " is_yes {value}"
 489                 return 2
 490         fi
 491
 492         # Check value
 493         case "$1" in
 494                 yes|Yes|YES|true|True|TRUE|on|On|ON|Y|y|1)
 495                         # true returns zero
 496                         return 0
 497                 ;;
 498                 *)
 499                         # false returns one
 500                         return 1
 501                 ;;
 502         esac
 503 }
 504
 505 is_no()
 506 {
 507         # Test syntax
 508         if [ $# = 0 ] ; then
 509                 msg_usage " is_no {value}"
 510                 return 2
 511         fi
 512
 513         case "$1" in
 514                 no|No|NO|false|False|FALSE|off|Off|OFF|N|n|0)
 515                         # true returns zero
 516                         return 0
 517                         ;;
 518                 *)
 519                         # false returns one
 520                         return 1
 521                 ;;
 522         esac
 523 }
 524
 525 # module is needed (ie. is requested, is available and isn't loaded already)
 526 is_module()
 527 {
 528         # module name without .o at end
 529         if ! (lsmod | grep -q "$1"); then
 530                 if (ls -R /lib/modules/$(uname -r)/ 2> /dev/null | grep -q "${1}.o"); then
 531                         # true
 532                         return 0
 533                 fi
 534         fi
 535         # false
 536         return 1
 537 }
 538
 539 _modprobe()
 540 {
 541         typeset parsed single die args foo result
 542         parsed=no
 543         while is_no "$parsed" ; do
 544                 case "$1" in
 545                         "single")
 546                                 single=yes
 547                                 shift
 548                                 ;;
 549                         "die")
 550                                 die=yes
 551                                 shift
 552                                 ;;
 553                         -*)
 554                                 args="$args $1"
 555                                 shift
 556                                 ;;
 557                         *)
 558                                 parsed=yes
 559                                 ;;
 560                 esac
 561         done
 562         if is_yes "${single}" ; then
 563                 foo="$@"
 564                 show "Loading %s kernel module(s)" "$foo"
 565                 busy
 566         fi
 567         if [ -x /sbin/modprobe ] ; then
 568                 /sbin/modprobe -s $args "$@"
 569                 result=$?
 570         else
 571                 deltext ; fail
 572                 result=1
 573         fi
 574         if is_yes "${single}" ; then
 575                 deltext
 576                 if [ $result == "0" ] ; then
 577                         is_yes "$single" && ok
 578                 else
 579                         fail
 580                         if is_yes "$die" ; then
 581                                 nls "Could not load %s kernel module(s)" "$@"
 582                                 exit 1
 583                         fi
 584                 fi
 585         fi
 586 }
 587
 588 log_success ()
 589 {
 590         initlog -n $0 -s "$1 $2" -e 1
 591 }
 592
 593 log_failed ()
 594 {
 595         initlog -n $0 -s "$1 $2" -e 2
 596 }
 597
 598 # RedHat/Mandrake specific functions
 599 action () { STRING=$1; shift; run_cmd "$STRING" "$*"; }
 600 success () { return 0; }
 601 failure () { return 1; }
 602
 603 # TO BE REMOVED SOON. --misiek
 604 msg_Network_Down () { msg_network_down "$*"; }
 605 msg_Already_Running () { msg_already_running "$*"; }
 606 msg_Not_Running () { msg_not_running "$*"; }
 607 msg_Usage () { msg_usage "$*"; }
 608
 609 # This must be last line !
 610 # vi:syntax=sh:tw=78:ts=8:sw=4