config/functions

   1 # utility functions for ctdb event scripts
   2
   3 PATH=/bin:/usr/bin:/usr/sbin:/sbin:$PATH
   4
   5 #######################################
   6 # pull in a system config file, if any
   7 loadconfig() {
   8
   9     if [ -z "$1" ] ; then
  10         foo="${service_config:-${service_name}}"
  11         if [ -n "$foo" ] ; then
  12             loadconfig "$foo"
  13         fi
  14     elif [ "$1" != "ctdb" ] ; then
  15         loadconfig "ctdb"
  16     fi
  17
  18
  19     if [ -f /etc/sysconfig/$1 ]; then
  20         . /etc/sysconfig/$1
  21     elif [ -f /etc/default/$1 ]; then
  22         . /etc/default/$1
  23     elif [ -f $CTDB_BASE/sysconfig/$1 ]; then
  24         . $CTDB_BASE/sysconfig/$1
  25     fi
  26 }
  27
  28 ##############################################################
  29 # determine on what type of system (init style) we are running
  30 detect_init_style() {
  31     # only do detection if not already set:
  32     test "x$CTDB_INIT_STYLE" != "x" && return
  33
  34     if [ -x /sbin/startproc ]; then
  35         CTDB_INIT_STYLE="suse"
  36     elif [ -x /sbin/start-stop-daemon ]; then
  37         CTDB_INIT_STYLE="debian"
  38     else
  39         CTDB_INIT_STYLE="redhat"
  40     fi
  41 }
  42
  43 ######################################################
  44 # simulate /sbin/service on platforms that don't have it
  45 service() {
  46   _service_name="$1"
  47   _op="$2"
  48
  49   # do nothing, when no service was specified
  50   [ -z "$_service_name" ] && return
  51
  52   if [ -x /sbin/service ]; then
  53       /sbin/service "$_service_name" "$_op"
  54   elif [ -x /etc/init.d/$_service_name ]; then
  55       /etc/init.d/$_service_name "$_op"
  56   elif [ -x /etc/rc.d/init.d/$_service_name ]; then
  57       /etc/rc.d/init.d/$_service_name "$_op"
  58   fi
  59 }
  60
  61 ######################################################
  62 # simulate /sbin/service (niced) on platforms that don't have it
  63 nice_service() {
  64   _service_name="$1"
  65   _op="$2"
  66
  67   # do nothing, when no service was specified
  68   [ -z "$_service_name" ] && return
  69
  70   if [ -x /sbin/service ]; then
  71       nice /sbin/service "$_service_name" "$_op"
  72   elif [ -x /etc/init.d/$_service_name ]; then
  73       nice /etc/init.d/$_service_name "$_op"
  74   elif [ -x /etc/rc.d/init.d/$_service_name ]; then
  75       nice /etc/rc.d/init.d/$_service_name "$_op"
  76   fi
  77 }
  78
  79 ######################################################
  80 # wait for a command to return a zero exit status
  81 # usage: ctdb_wait_command SERVICE_NAME <command>
  82 ######################################################
  83 ctdb_wait_command() {
  84   service_name="$1"
  85   wait_cmd="$2"
  86   [ -z "$wait_cmd" ] && return;
  87   all_ok=0
  88   echo "Waiting for service $service_name to start"
  89   while [ $all_ok -eq 0 ]; do
  90           $wait_cmd > /dev/null 2>&1 && all_ok=1
  91           ctdb status > /dev/null 2>&1 || {
  92                 echo "ctdb daemon has died. Exiting wait for $service_name"
  93                 exit 1
  94           }
  95           [ $all_ok -eq 1 ] || sleep 1
  96   done
  97   echo "Local service $service_name is up"
  98 }
  99
 100
 101 ######################################################
 102 # wait for a set of tcp ports
 103 # usage: ctdb_wait_tcp_ports SERVICE_NAME <ports...>
 104 ######################################################
 105 ctdb_wait_tcp_ports() {
 106   service_name="$1"
 107   shift
 108   wait_ports="$*"
 109   [ -z "$wait_ports" ] && return;
 110   all_ok=0
 111   echo "Waiting for tcp service $service_name to start"
 112   while [ $all_ok -eq 0 ]; do
 113           all_ok=1
 114           for p in $wait_ports; do
 115               if [ -x /usr/bin/netcat ]; then
 116                   /usr/bin/netcat -z 127.0.0.1 $p > /dev/null || all_ok=0
 117               elif [ -x /usr/bin/nc ]; then
 118                   /usr/bin/nc -z 127.0.0.1 $p > /dev/null || all_ok=0
 119               elif [ -x /usr/bin/netstat ]; then
 120                   (netstat -a -n | egrep "0.0.0.0:$p[[:space:]]*LISTEN" > /dev/null) || all_ok=0
 121               elif [ -x /bin/netstat ]; then
 122                   (netstat -a -n | egrep "0.0.0.0:$p[[:space:]]*LISTEN" > /dev/null) || all_ok=0
 123               else
 124                   echo "No tool to check tcp ports availabe. can not check in ctdb_wait_tcp_ports"
 125                   return 127
 126               fi
 127           done
 128           [ $all_ok -eq 1 ] || sleep 1
 129           ctdb status > /dev/null 2>&1 || {
 130                 echo "ctdb daemon has died. Exiting tcp wait $service_name"
 131                 return 1
 132           }
 133   done
 134   echo "Local tcp services for $service_name are up"
 135 }
 136
 137
 138 ######################################################
 139 # check that a rpc server is registered with portmap
 140 # and responding to requests
 141 # usage: ctdb_check_rpc SERVICE_NAME PROGNUM VERSION
 142 ######################################################
 143 ctdb_check_rpc() {
 144     progname="$1"
 145     prognum="$2"
 146     version="$3"
 147     rpcinfo -u localhost $prognum $version > /dev/null || {
 148             echo "ERROR: $progname not responding to rpc requests"
 149             exit 1
 150     }
 151 }
 152
 153 ######################################################
 154 # check a set of directories is available
 155 # return 1 on a missing directory
 156 # usage: ctdb_check_directories_probe SERVICE_NAME <directories...>
 157 ######################################################
 158 ctdb_check_directories_probe() {
 159     while IFS="" read d ; do
 160         case "$d" in
 161             *%*)
 162                 continue
 163                 ;;
 164             *)
 165                 [ -d "${d}/." ] || return 1
 166         esac
 167     done
 168 }
 169
 170 ######################################################
 171 # check a set of directories is available
 172 # usage: ctdb_check_directories SERVICE_NAME <directories...>
 173 ######################################################
 174 ctdb_check_directories() {
 175     n="${1:-${service_name}}"
 176     ctdb_check_directories_probe || {
 177         echo "ERROR: $n directory \"$d\" not available"
 178         exit 1
 179     }
 180 }
 181
 182 ######################################################
 183 # check a set of tcp ports
 184 # usage: ctdb_check_tcp_ports <ports...>
 185 ######################################################
 186 ctdb_check_tcp_ports() {
 187
 188     for p ; do
 189         if ! netstat -a -t -n | grep -q "0\.0\.0\.0:$p .*LISTEN" ; then
 190             if ! netstat -a -t -n | grep -q ":::$p .*LISTEN" ; then
 191                 echo "ERROR: $service_name tcp port $p is not responding"
 192                 return 1
 193             fi
 194         fi
 195     done
 196 }
 197
 198 ######################################################
 199 # check a unix socket
 200 # usage: ctdb_check_unix_socket SERVICE_NAME <socket_path>
 201 ######################################################
 202 ctdb_check_unix_socket() {
 203     socket_path="$1"
 204     [ -z "$socket_path" ] && return
 205
 206     if ! netstat --unix -a -n | grep -q "^unix.*LISTEN.*${socket_path}$"; then
 207         echo "ERROR: $service_name socket $socket_path not found"
 208         return 1
 209     fi
 210 }
 211
 212 ######################################################
 213 # check a command returns zero status
 214 # usage: ctdb_check_command SERVICE_NAME <command>
 215 ######################################################
 216 ctdb_check_command() {
 217   service_name="$1"
 218   wait_cmd="$2"
 219   [ -z "$wait_cmd" ] && return;
 220   $wait_cmd > /dev/null 2>&1 || {
 221       echo "ERROR: $service_name - $wait_cmd returned error"
 222       exit 1
 223   }
 224 }
 225
 226 ################################################
 227 # kill off any TCP connections with the given IP
 228 ################################################
 229 kill_tcp_connections() {
 230     _IP="$1"
 231     _failed=0
 232
 233     _killcount=0
 234     connfile="$CTDB_BASE/state/connections.$_IP"
 235     netstat -tn |egrep "^tcp.*[[:space:]]+$_IP:.*ESTABLISHED" | awk '{print $4" "$5}' > $connfile
 236     netstat -tn |egrep "^tcp.*[[:space:]]+::ffff:$_IP:.*ESTABLISHED" | awk '{print $4" "$5}' >> $connfile
 237
 238     while read dest src; do
 239         srcip=`echo $src | sed -e "s/:[^:]*$//"`
 240         srcport=`echo $src | sed -e "s/^.*://"`
 241         destip=`echo $dest | sed -e "s/:[^:]*$//"`
 242         destport=`echo $dest | sed -e "s/^.*://"`
 243         echo "Killing TCP connection $srcip:$srcport $destip:$destport"
 244         ctdb killtcp $srcip:$srcport $destip:$destport >/dev/null 2>&1 || _failed=1
 245         case $destport in
 246           # we only do one-way killtcp for CIFS
 247           139|445) : ;;
 248           # for all others we do 2-way
 249           *)
 250                 ctdb killtcp $destip:$destport $srcip:$srcport >/dev/null 2>&1 || _failed=1
 251                 ;;
 252         esac
 253         _killcount=`expr $_killcount + 1`
 254      done < $connfile
 255     /bin/rm -f $connfile
 256
 257     [ $_failed = 0 ] || {
 258         echo "Failed to send killtcp control"
 259         return;
 260     }
 261     [ $_killcount -gt 0 ] || {
 262         return;
 263     }
 264     _count=0
 265     while netstat -tn |egrep "^tcp.*[[:space:]]+$_IP:.*ESTABLISHED" > /dev/null; do
 266         sleep 1
 267         _count=`expr $_count + 1`
 268         [ $_count -gt 3 ] && {
 269             echo "Timed out killing tcp connections for IP $_IP"
 270             return;
 271         }
 272     done
 273     echo "killed $_killcount TCP connections to released IP $_IP"
 274 }
 275
 276 ##################################################################
 277 # kill off the local end for any TCP connections with the given IP
 278 ##################################################################
 279 kill_tcp_connections_local_only() {
 280     _IP="$1"
 281     _failed=0
 282
 283     _killcount=0
 284     connfile="$CTDB_BASE/state/connections.$_IP"
 285     netstat -tn |egrep "^tcp.*[[:space:]]+$_IP:.*ESTABLISHED" | awk '{print $4" "$5}' > $connfile
 286     netstat -tn |egrep "^tcp.*[[:space:]]+::ffff:$_IP:.*ESTABLISHED" | awk '{print $4" "$5}' >> $connfile
 287
 288     while read dest src; do
 289         srcip=`echo $src | sed -e "s/:[^:]*$//"`
 290         srcport=`echo $src | sed -e "s/^.*://"`
 291         destip=`echo $dest | sed -e "s/:[^:]*$//"`
 292         destport=`echo $dest | sed -e "s/^.*://"`
 293         echo "Killing TCP connection $srcip:$srcport $destip:$destport"
 294         ctdb killtcp $srcip:$srcport $destip:$destport >/dev/null 2>&1 || _failed=1
 295         _killcount=`expr $_killcount + 1`
 296      done < $connfile
 297     /bin/rm -f $connfile
 298
 299     [ $_failed = 0 ] || {
 300         echo "Failed to send killtcp control"
 301         return;
 302     }
 303     [ $_killcount -gt 0 ] || {
 304         return;
 305     }
 306     _count=0
 307     while netstat -tn |egrep "^tcp.*[[:space:]]+$_IP:.*ESTABLISHED" > /dev/null; do
 308         sleep 1
 309         _count=`expr $_count + 1`
 310         [ $_count -gt 3 ] && {
 311             echo "Timed out killing tcp connections for IP $_IP"
 312             return;
 313         }
 314     done
 315     echo "killed $_killcount TCP connections to released IP $_IP"
 316 }
 317
 318 ##################################################################
 319 # tickle any TCP connections with the given IP
 320 ##################################################################
 321 tickle_tcp_connections() {
 322     _IP="$1"
 323     _failed=0
 324
 325     _killcount=0
 326     connfile="$CTDB_BASE/state/connections.$_IP"
 327     netstat -tn |egrep "^tcp.*[[:space:]]+$_IP:.*ESTABLISHED" | awk '{print $4" "$5}' > $connfile
 328     netstat -tn |egrep "^tcp.*[[:space:]]+::ffff:$_IP:.*ESTABLISHED" | awk '{print $4" "$5}' >> $connfile
 329
 330     while read dest src; do
 331         srcip=`echo $src | sed -e "s/:[^:]*$//"`
 332         srcport=`echo $src | sed -e "s/^.*://"`
 333         destip=`echo $dest | sed -e "s/:[^:]*$//"`
 334         destport=`echo $dest | sed -e "s/^.*://"`
 335         echo "Tickle TCP connection $srcip:$srcport $destip:$destport"
 336         ctdb tickle $srcip:$srcport $destip:$destport >/dev/null 2>&1 || _failed=1
 337         echo "Tickle TCP connection $destip:$destport $srcip:$srcport"
 338         ctdb tickle $destip:$destport $srcip:$srcport >/dev/null 2>&1 || _failed=1
 339      done < $connfile
 340     /bin/rm -f $connfile
 341
 342     [ $_failed = 0 ] || {
 343         echo "Failed to send tickle control"
 344         return;
 345     }
 346 }
 347
 348 ########################################################
 349 # start/stop the nfs service on different platforms
 350 ########################################################
 351 startstop_nfs() {
 352         PLATFORM="unknown"
 353         [ -x /etc/init.d/nfsserver ] && {
 354                 PLATFORM="sles"
 355         }
 356         [ -x /etc/init.d/nfslock ] && {
 357                 PLATFORM="rhel"
 358         }
 359
 360         case $PLATFORM in
 361         sles)
 362                 case $1 in
 363                 start)
 364                         service nfsserver start
 365                         ;;
 366                 stop)
 367                         service nfsserver stop > /dev/null 2>&1
 368                         ;;
 369                 restart)
 370                         service nfsserver restart
 371                         ;;
 372                 esac
 373                 ;;
 374         rhel)
 375                 case $1 in
 376                 start)
 377                         service nfslock start
 378                         service nfs start
 379                         ;;
 380                 stop)
 381                         service nfs stop > /dev/null 2>&1
 382                         service nfslock stop > /dev/null 2>&1
 383                         ;;
 384                 restart)
 385                         service nfslock restart
 386                         service nfs restart
 387                         ;;
 388                 esac
 389                 ;;
 390         *)
 391                 echo "Unknown platform. NFS is not supported with ctdb"
 392                 exit 1
 393                 ;;
 394         esac
 395 }
 396
 397 ########################################################
 398 # start/stop the nfs lockmanager service on different platforms
 399 ########################################################
 400 startstop_nfslock() {
 401         PLATFORM="unknown"
 402         [ -x /etc/init.d/nfsserver ] && {
 403                 PLATFORM="sles"
 404         }
 405         [ -x /etc/init.d/nfslock ] && {
 406                 PLATFORM="rhel"
 407         }
 408
 409         case $PLATFORM in
 410         sles)
 411                 # for sles there is no service for lockmanager
 412                 # so we instead just shutdown/restart nfs
 413                 case $1 in
 414                 start)
 415                         service nfsserver start
 416                         ;;
 417                 stop)
 418                         service nfsserver stop > /dev/null 2>&1
 419                         ;;
 420                 esac
 421                 ;;
 422         rhel)
 423                 case $1 in
 424                 start)
 425                         service nfslock start
 426                         ;;
 427                 stop)
 428                         service nfslock stop > /dev/null 2>&1
 429                         ;;
 430                 esac
 431                 ;;
 432         *)
 433                 echo "Unknown platform. NFS locking is not supported with ctdb"
 434                 exit 1
 435                 ;;
 436         esac
 437 }
 438
 439 # better use delete_ip_from_iface() together with add_ip_to_iface
 440 # remove_ip should be removed in future
 441 remove_ip() {
 442         local _ip_maskbits=$1
 443         local _iface=$2
 444         local _ip=`echo "$_ip_maskbits" | cut -d '/' -f1`
 445         local _maskbits=`echo "$_ip_maskbits" | cut -d '/' -f2`
 446
 447         delete_ip_from_iface "$_iface" "$_ip" "$_maskbits"
 448         return $?
 449 }
 450
 451 add_ip_to_iface()
 452 {
 453         local _iface=$1
 454         local _ip=$2
 455         local _maskbits=$3
 456         local _state_dir="$CTDB_BASE/state/interface_modify"
 457         local _lockfile="$_state_dir/$_iface.flock"
 458         local _readd_base="$_state_dir/$_iface.readd.d"
 459
 460         mkdir -p $_state_dir || {
 461                 ret=$?
 462                 echo "Failed to mkdir -p $_state_dir - $ret"
 463                 return $ret
 464         }
 465
 466         test -f $_lockfile || {
 467                 touch $_lockfile
 468         }
 469
 470         flock --timeout 30 $_lockfile $CTDB_BASE/interface_modify.sh add "$_iface" "$_ip" "$_maskbits" "$_readd_base"
 471         return $?
 472 }
 473
 474 delete_ip_from_iface()
 475 {
 476         local _iface=$1
 477         local _ip=$2
 478         local _maskbits=$3
 479         local _state_dir="$CTDB_BASE/state/interface_modify"
 480         local _lockfile="$_state_dir/$_iface.flock"
 481         local _readd_base="$_state_dir/$_iface.readd.d"
 482
 483         mkdir -p $_state_dir || {
 484                 ret=$?
 485                 echo "Failed to mkdir -p $_state_dir - $ret"
 486                 return $ret
 487         }
 488
 489         test -f $_lockfile || {
 490                 touch $_lockfile
 491         }
 492
 493         flock --timeout 30 $_lockfile $CTDB_BASE/interface_modify.sh delete "$_iface" "$_ip" "$_maskbits" "$_readd_base"
 494         return $?
 495 }
 496
 497 setup_iface_ip_readd_script()
 498 {
 499         local _iface=$1
 500         local _ip=$2
 501         local _maskbits=$3
 502         local _readd_script=$4
 503         local _state_dir="$CTDB_BASE/state/interface_modify"
 504         local _lockfile="$_state_dir/$_iface.flock"
 505         local _readd_base="$_state_dir/$_iface.readd.d"
 506
 507         mkdir -p $_state_dir || {
 508                 ret=$?
 509                 echo "Failed to mkdir -p $_state_dir - $ret"
 510                 return $ret
 511         }
 512
 513         test -f $_lockfile || {
 514                 touch $_lockfile
 515         }
 516
 517         flock --timeout 30 $_lockfile $CTDB_BASE/interface_modify.sh readd_script "$_iface" "$_ip" "$_maskbits" "$_readd_base" "$_readd_script"
 518         return $?
 519 }
 520
 521 ########################################################
 522 # some simple logic for counting events - per eventscript
 523 # usage: ctdb_counter_init
 524 #        ctdb_counter_incr
 525 #        ctdb_check_counter_limit <limit>
 526 # ctdb_check_counter_limit succeeds when count >= <limit>
 527 ########################################################
 528 _ctdb_counter_common () {
 529     _counter_file="$ctdb_fail_dir/$service_name"
 530     mkdir -p "${_counter_file%/*}" # dirname
 531 }
 532 ctdb_counter_init () {
 533     _ctdb_counter_common
 534
 535     >"$_counter_file"
 536 }
 537 ctdb_counter_incr () {
 538     _ctdb_counter_common
 539
 540     # unary counting!
 541     echo -n 1 >> "$_counter_file"
 542 }
 543 ctdb_check_counter_limit () {
 544     _ctdb_counter_common
 545
 546     _limit="${1:-${service_fail_limit}}"
 547     _quiet="$2"
 548
 549     # unary counting!
 550     _size=$(stat -c "%s" "$_counter_file" 2>/dev/null || echo 0)
 551     if [ $_size -ge $_limit ] ; then
 552         echo "ERROR: more than $_limit consecutive failures for $service_name, marking cluster unhealthy"
 553         exit 1
 554     elif [ $_size -gt 0 -a -z "$_quiet" ] ; then
 555         echo "WARNING: less than $_limit consecutive failures ($_size) for $service_name, not unhealthy yet"
 556     fi
 557 }
 558 ########################################################
 559
 560 ctdb_spool_dir="/var/spool/ctdb"
 561 ctdb_status_dir="$ctdb_spool_dir/status"
 562 ctdb_fail_dir="$ctdb_spool_dir/failcount"
 563 ctdb_active_dir="$ctdb_spool_dir/active"
 564
 565 log_status_cat ()
 566 {
 567     echo "node is \"$1\", \"${script_name}\" reports problem: $(cat $2)"
 568 }
 569
 570 ctdb_checkstatus ()
 571 {
 572     if [ -r "$ctdb_status_dir/$script_name/unhealthy" ] ; then
 573         log_status_cat "unhealthy" "$ctdb_status_dir/$script_name/unhealthy"
 574         return 1
 575     elif [ -r "$ctdb_status_dir/$script_name/banned" ] ; then
 576         log_status_cat "banned" "$ctdb_status_dir/$script_name/banned"
 577         return 2
 578     else
 579         return 0
 580     fi
 581 }
 582
 583 ctdb_setstatus ()
 584 {
 585     d="$ctdb_status_dir/$script_name"
 586     case "$1" in
 587         unhealthy|banned)
 588             mkdir -p "$d"
 589             cat "$2" >"$d/$1"
 590             ;;
 591         *)
 592             for i in "banned" "unhealthy" ; do
 593                 rm -f "$d/$i"
 594             done
 595             ;;
 596     esac
 597 }
 598
 599 ctdb_service_needs_reconfigure ()
 600 {
 601     [ -e "$ctdb_status_dir/$service_name/reconfigure" ]
 602 }
 603
 604 ctdb_service_set_reconfigure ()
 605 {
 606     d="$ctdb_status_dir/$service_name"
 607     mkdir -p "$d"
 608     >"$d/reconfigure"
 609 }
 610
 611 ctdb_service_unset_reconfigure ()
 612 {
 613     rm -f "$ctdb_status_dir/$service_name/reconfigure"
 614 }
 615
 616 ctdb_service_reconfigure ()
 617 {
 618     if [ -n "$service_reconfigure" ] ; then
 619         eval $service_reconfigure
 620     else
 621         service "$service_name" restart
 622     fi
 623     ctdb_service_unset_reconfigure
 624     ctdb_counter_init
 625 }
 626
 627 ctdb_compat_managed_service ()
 628 {
 629     if [ "$1" = "yes" ] ; then
 630         t="$t $2 "
 631     fi
 632 }
 633
 634 is_ctdb_managed_service ()
 635 {
 636     t=" $CTDB_MANAGED_SERVICES "
 637
 638     ctdb_compat_managed_service "$CTDB_MANAGES_VSFTPD"   "vsftpd"
 639     ctdb_compat_managed_service "$CTDB_MANAGES_SAMBA"    "samba"
 640     ctdb_compat_managed_service "$CTDB_MANAGES_SCP"      "scp"
 641     ctdb_compat_managed_service "$CTDB_MANAGES_WINDBIND" "windbind"
 642     ctdb_compat_managed_service "$CTDB_MANAGES_HTTPD"    "httpd"
 643     ctdb_compat_managed_service "$CTDB_MANAGES_ISCSI"    "iscsi"
 644     ctdb_compat_managed_service "$CTDB_MANAGES_CLAMD"    "clamd"
 645     ctdb_compat_managed_service "$CTDB_MANAGES_NFS"      "nfs"
 646
 647     # Returns 0 if "<space>$service_name<space>" appears in $t
 648     [ "${t#* ${service_name} }" != "${t}" ]
 649 }
 650
 651 ctdb_start_stop_service ()
 652 {
 653     _active="$ctdb_active_dir/$service_name"
 654
 655     if is_ctdb_managed_service ; then
 656         if ! [ -e "$_active" ] ; then
 657             echo "Starting service $service_name"
 658             ctdb_service_start || exit $?
 659             mkdir -p "$ctdb_active_dir"
 660             touch "$_active"
 661             exit 0
 662         fi
 663     elif ! is_ctdb_managed_service ; then
 664         if [ -e "$_active" ] ; then
 665             echo "Stopping service $service_name"
 666             ctdb_service_stop || exit $?
 667             rm -f "$_active"
 668         fi
 669         exit 0
 670     fi
 671 }
 672
 673 ctdb_service_start ()
 674 {
 675     if [ -n "$service_start" ] ; then
 676         eval $service_start
 677     else
 678         service "$service_name" start
 679     fi
 680     ctdb_counter_init
 681 }
 682
 683 ctdb_service_stop ()
 684 {
 685     if [ -n "$service_stop" ] ; then
 686         eval $service_stop
 687     else
 688         service "$service_name" stop
 689     fi
 690 }
 691
 692 ctdb_standard_event_handler ()
 693 {
 694     case "$1" in
 695         status)
 696             ctdb_checkstatus
 697             exit
 698             ;;
 699         setstatus)
 700             shift
 701             ctdb_setstatus "$@"
 702             exit
 703             ;;
 704     esac
 705 }
 706
 707 ipv4_host_addr_to_net_addr()
 708 {
 709         local HOST=$1
 710         local MASKBITS=$2
 711
 712         local HOST0=$(echo $HOST | awk -F . '{print $4}')
 713         local HOST1=$(echo $HOST | awk -F . '{print $3}')
 714         local HOST2=$(echo $HOST | awk -F . '{print $2}')
 715         local HOST3=$(echo $HOST | awk -F . '{print $1}')
 716
 717         local HOST_NUM=$(( $HOST0 + $HOST1 * 256 + $HOST2 * (256 ** 2) + $HOST3 * (256 ** 3) ))
 718
 719         local MASK_NUM=$(( ( (2**32 - 1) * (2**(32 - $MASKBITS)) ) & (2**32 - 1) ))
 720
 721         local NET_NUM=$(( $HOST_NUM & $MASK_NUM))
 722
 723         local NET0=$(( $NET_NUM & 255 ))
 724         local NET1=$(( ($NET_NUM & (255 * 256)) / 256 ))
 725         local NET2=$(( ($NET_NUM & (255 * 256**2)) / 256**2 ))
 726         local NET3=$(( ($NET_NUM & (255 * 256**3)) / 256**3 ))
 727
 728         echo "$NET3.$NET2.$NET1.$NET0"
 729 }
 730
 731 ipv4_maskbits_to_net_mask()
 732 {
 733         local MASKBITS=$1
 734
 735         local MASK_NUM=$(( ( (2**32 - 1) * (2**(32 - $MASKBITS)) ) & (2**32 - 1) ))
 736
 737         local MASK0=$(( $MASK_NUM & 255 ))
 738         local MASK1=$(( ($MASK_NUM & (255 * 256)) / 256 ))
 739         local MASK2=$(( ($MASK_NUM & (255 * 256**2)) / 256**2 ))
 740         local MASK3=$(( ($MASK_NUM & (255 * 256**3)) / 256**3 ))
 741
 742         echo "$MASK3.$MASK2.$MASK1.$MASK0"
 743 }
 744
 745 ipv4_is_valid_addr()
 746 {
 747         local ADDR=$1
 748         local fail=0
 749
 750         local N=`echo $ADDR | sed -e 's/[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*//'`
 751         test -n "$N" && fail=1
 752
 753         local ADDR0=$(echo $ADDR | awk -F . '{print $4}')
 754         local ADDR1=$(echo $ADDR | awk -F . '{print $3}')
 755         local ADDR2=$(echo $ADDR | awk -F . '{print $2}')
 756         local ADDR3=$(echo $ADDR | awk -F . '{print $1}')
 757
 758         test "$ADDR0" -gt 255 && fail=1
 759         test "$ADDR1" -gt 255 && fail=1
 760         test "$ADDR2" -gt 255 && fail=1
 761         test "$ADDR3" -gt 255 && fail=1
 762
 763         test x"$fail" != x"0" && {
 764                 #echo "IPv4: '$ADDR' is not a valid address"
 765                 return 1;
 766         }
 767
 768         return 0;
 769 }
 770
 771 # iptables doesn't like being re-entered, so flock-wrap it.
 772 iptables()
 773 {
 774         flock -w 30 /var/ctdb/iptables-ctdb.flock /sbin/iptables "$@"
 775 }
 776
 777 ########################################################
 778 # load a site local config file
 779 ########################################################
 780
 781 [ -x $CTDB_BASE/rc.local ] && {
 782         . $CTDB_BASE/rc.local
 783 }
 784
 785 [ -d $CTDB_BASE/rc.local.d ] && {
 786         for i in $CTDB_BASE/rc.local.d/* ; do
 787                 [ -x "$i" ] && . "$i"
 788         done
 789 }
 790
 791 script_name="${0##*/}"       # basename
 792 service_name="$script_name"  # default is just the script name
 793 service_fail_limit=1