[mirror_frr.git] / tools / quagga

#!/bin/bash
#
### BEGIN INIT INFO
# Provides: quagga
# Required-Start: $local_fs $network $remote_fs $syslog
# Required-Stop: $local_fs $network $remote_fs $syslog
# Default-Start:  2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: start and stop the Quagga routing suite
# Description: Quagga is a routing suite for IP routing protocols like
#              BGP, OSPF, RIP and others. This script contols the main
#              daemon "quagga" as well as the individual protocol daemons.
### END INIT INFO
#

PATH=/bin:/usr/bin:/sbin:/usr/sbin
D_PATH=/usr/lib/quagga
C_PATH=/etc/quagga
V_PATH=/var/run/quagga

# Local Daemon selection may be done by using /etc/quagga/daemons.
# See /usr/share/doc/quagga/README.Debian.gz for further information.
# Keep zebra first and do not list watchquagga!
DAEMONS="zebra bgpd ripd ripngd ospfd ospf6d isisd babeld pimd"
MAX_INSTANCES=5
RELOAD_SCRIPT=/usr/lib/quagga/quagga-reload.py

. /lib/lsb/init-functions

if [ -f /usr/lib/quagga/ssd ]; then
    SSD=/usr/lib/quagga/ssd
else
    SSD=`which start-stop-daemon`
fi

# Print the name of the pidfile.
pidfile()
{
    echo "$V_PATH/$1.pid"
}

# Print the name of the vtysh.
vtyfile()
{
    echo "$V_PATH/$1.vty"
}

# Check if daemon is started by using the pidfile.
started()
{
        [ ! -e `pidfile $1` ] && return 3
       if [ -n "$2" ] && [ "$2" == "log" ]; then
           status_of_proc -p `pidfile $1` $1 $1 && return 0 || return $?
       else
          kill -0 `cat \`pidfile $1\`` 2> /dev/null || return 1
          return 0
        fi
}

# Loads the config via vtysh -b if configured to do so.
vtysh_b ()
{
        # Rember, that all variables have been incremented by 1 in convert_daemon_prios()
        if [ "$vtysh_enable" = 2 -a -f $C_PATH/Quagga.conf ]; then
                /usr/bin/vtysh -b -n
        fi
}

# Check if the daemon is activated and if its executable and config files
# are in place.
# params:       daemon name
# returns:      0=ok, 1=error
check_daemon()
{
        # If the integrated config file is used the others are not checked.
        if [ -r "$C_PATH/Quagga.conf" ]; then
          return 0
        fi

        # vtysh_enable has no config file nor binary so skip check.
        # (Not sure why vtysh_enable is in this list but does not hurt)
        if [ $1 != "watchquagga" -a $1 != "vtysh_enable" ]; then
          # check for daemon binary
          if [ ! -x "$D_PATH/$1" ]; then return 1; fi

          # check for config file
          if [ -n "$2" ]; then
           if [ ! -r "$C_PATH/$1-$2.conf" ]; then
                touch "$C_PATH/$1-$2.conf"
                chown quagga:quagga "$C_PATH/$1-$2.conf"
           fi
          elif [ ! -r "$C_PATH/$1.conf" ]; then
            touch "$C_PATH/$1.conf"
            chown quagga:quagga "$C_PATH/$1.conf"
          fi
        fi
        return 0
}

# Starts the server if it's not alrady running according to the pid file.
# The Quagga daemons creates the pidfile when starting.
start()
{
       ulimit -n $MAX_FDS
        if [ "$1" = "watchquagga" ]; then

           # We may need to restart watchquagga if new daemons are added and/or
           # removed
           if started "$1" ; then
               stop watchquagga
           else
               # Echo only once. watchquagga is printed in the stop above
               echo -n " $1"
           fi

           if [ -e /var/run/quagga/watchquagga.started ] ; then
             rm /var/run/quagga/watchquagga.started
           fi
            ${SSD} \
                --start \
                --pidfile=`pidfile $1` \
                --exec "$D_PATH/$1" \
                -- \
                "${watchquagga_options[@]}"
            for i in `seq 1 10`;
            do
              if [ -e /var/run/quagga/watchquagga.started ] ; then
		  break
              else
                  sleep 1
              fi
            done
        elif [ -n "$2" ]; then
          echo -n " $1-$2"
           if ! check_daemon $1 $2 ; then
              echo -n " (binary does not exist)"
              return;
          fi

           ${SSD} \
               --start \
               --pidfile=`pidfile $1-$2` \
               --exec "$D_PATH/$1" \
               -- \
               `eval echo "$""$1""_options"` -n "$2"
        else
           echo -n " $1"
            if ! check_daemon $1; then
               echo -n " (binary does not exist)"
               return;
           fi

           ${SSD} \
               --start \
               --pidfile=`pidfile $1` \
               --exec "$D_PATH/$1" \
               -- \
               `eval echo "$""$1""_options"`
        fi
}

# Stop the daemon given in the parameter, printing its name to the terminal.
stop()
{
    local inst

    if [ -n "$2" ]; then
       inst="$1-$2"
    else
       inst="$1"
    fi

    if ! started "$inst" ; then
        echo -n " ($inst)"
        return 0
    else
        PIDFILE=`pidfile $inst`
        PID=`cat $PIDFILE 2>/dev/null`
        ${SSD} --stop --quiet --retry=TERM/30/KILL/5 --oknodo --pidfile "$PIDFILE" --exec "$D_PATH/$1"
        #
        #       Now we have to wait until $DAEMON has _really_ stopped.
        #
        if test -n "$PID" && kill -0 $PID 2>/dev/null; then
            echo -n " (waiting) ."
            cnt=0
            while kill -0 $PID 2>/dev/null; do
                cnt=`expr $cnt + 1`
                if [ $cnt -gt 60 ]; then
                    # Waited 120 secs now, fail.
                    echo -n "Failed.. "
                    break
                fi
                sleep 2
                echo -n "."
                done
            fi
        echo -n " $inst"
        rm -f `pidfile $inst`
        rm -f `vtyfile $inst`
    fi
}

# Converts values from /etc/quagga/daemons to all-numeric values.
convert_daemon_prios()
{
        for name in $DAEMONS zebra vtysh_enable watchquagga_enable; do
          # First, assign the value set by the user to $value
          eval value=\${${name}:0:3}

          # Daemon not activated or entry missing?
          if [ "$value" = "no" -o "$value" = "" ]; then value=0; fi

          # These strings parsed for backwards compatibility.
          if [ "$value" = "yes"  -o  "$value" = "true" ]; then
            value=1;
          fi

          # Zebra is threatened special. It must be between 0=off and the first
      # user assigned value "1" so we increase all other enabled daemons' values.
          if [ "$name" != "zebra" -a "$value" -gt 0 ]; then value=`expr "$value" + 1`; fi

          # If e.g. name is zebra then we set "zebra=yes".
          eval $name=$value
        done
}

# Starts watchquagga for all wanted daemons.
start_watchquagga()
{
    local daemon_name
    local daemon_prio
    local found_one
    local daemon_inst

    # Start the monitor daemon only if desired.
    if [ 0 -eq "$watchquagga_enable" ]; then
        return
    fi

    # Check variable type
    if ! declare -p watchquagga_options | grep -q '^declare \-a'; then
      echo
      echo "ERROR: The variable watchquagga_options from /etc/quagga/debian.cnf must be a BASH array!"
      echo "ERROR: Please convert config file and restart!"
      exit 1
    fi

    # Which daemons have been started?
    found_one=0
    for daemon_name in $DAEMONS; do
        eval daemon_prio=\$$daemon_name
        if [ "$daemon_prio" -gt 0 ]; then
           eval "daemon_inst=\${${daemon_name}_instances//,/ }"
          if [ -n "$daemon_inst" ]; then
             for inst in ${daemon_inst}; do
                 eval "inst_disable=\${${daemon_name}_${inst}}"
                 if [ -z ${inst_disable} ] || [ ${inst_disable} != 0 ]; then
                     if check_daemon $daemon_name $inst; then
                         watchquagga_options+=("${daemon_name}-${inst}")
                     fi
                 fi
             done
          else
              if check_daemon $daemon_name; then
                  watchquagga_options+=($daemon_name)
              fi
           fi
           found_one=1
        fi
    done

    # Start if at least one daemon is activated.
    if [ $found_one -eq 1 ]; then
      echo -n "Starting Quagga monitor daemon:"
      start watchquagga
      echo "."
    fi
}

# Stopps watchquagga.
stop_watchquagga()
{
    echo -n "Stopping Quagga monitor daemon:"
    stop watchquagga
    echo "."
}

# Stops all daemons that have a lower level of priority than the given.
# (technically if daemon_prio >= wanted_prio)
stop_prio()
{
        local wanted_prio
        local daemon_prio
        local daemon_list
        local daemon_inst
       local inst

        if [ -n "$2" ] && [[ "$2" =~ (.*)-(.*) ]]; then
          daemon=${BASH_REMATCH[1]}
          inst=${BASH_REMATCH[2]}
        else
          daemon="$2"
        fi

        wanted_prio=$1
        daemon_list=${daemon:-$DAEMONS}

        echo -n "Stopping Quagga daemons (prio:$wanted_prio):"

        for prio_i in `seq 10 -1 $wanted_prio`; do
            for daemon_name in $daemon_list; do
               eval daemon_prio=\${${daemon_name}:0:3}
               daemon_inst=""
                if [ $daemon_prio -eq $prio_i ]; then
                  eval "daemon_inst=\${${daemon_name}_instances//,/ }"
                  if [ -n "$daemon_inst" ]; then
                          for i in ${daemon_inst}; do
                               if [ -n "$inst" ] && [ "$i" == "$inst" ]; then
                                   stop "$daemon_name" "$inst"
                               elif [ x"$inst"  == x ]; then
                                   stop "$daemon_name" "$i"
                               fi
                          done
                   else
                      stop "$daemon_name"
                   fi
                fi
            done
        done

        echo "."
       if [ -z "$inst" ]; then
       # Now stop other daemons that're prowling, coz the daemons file changed
           echo -n "Stopping other quagga daemons"
            if [ -n "$daemon" ]; then
               eval "file_list_suffix="$V_PATH"/"$daemon*""
           else
               eval "file_list_suffix="$V_PATH/*""
           fi
            for pidfile in $file_list_suffix.pid; do
               PID=`cat $pidfile 2>/dev/null`
               ${SSD} --stop --quiet --oknodo --pidfile "$pidfile"
               echo -n "."
               rm -rf "$pidfile"
            done
            echo "."

           echo -n "Removing remaining .vty files"
           for vtyfile in $file_list_suffix.vty; do
               rm -rf "$vtyfile"
           done
            echo "."
       fi
}

# Starts all daemons that have a higher level of priority than the given.
# (technically if daemon_prio <= wanted_prio)
start_prio()
{
        local wanted_prio
        local daemon_prio
        local daemon_list
       local daemon_name
       local daemon_inst
       local inst

        if [ -n "$2" ] && [[ "$2" =~ (.*)-(.*) ]]; then
          daemon=${BASH_REMATCH[1]}
          inst=${BASH_REMATCH[2]}
        else
          daemon="$2"
        fi

        wanted_prio=$1
        daemon_list=${daemon:-$DAEMONS}

        echo -n "Starting Quagga daemons (prio:$wanted_prio):"

        for prio_i in `seq 1 $wanted_prio`; do
            for daemon_name in $daemon_list; do
               eval daemon_prio=\$${daemon_name}
               daemon_inst=""
                if [ $daemon_prio -eq $prio_i ]; then
                  eval "daemon_inst=\${${daemon_name}_instances//,/ }"
                  if [ -n "$daemon_inst" ]; then
                       if [ `echo "$daemon_inst" | wc -w` -gt ${MAX_INSTANCES} ]; then
                           echo "Max instances supported is ${MAX_INSTANCES}. Aborting"
                           exit 1
                       fi
                      # Check if we're starting again by switching from single instance
                      # to MI version
                      if started "$daemon_name"; then
                          PIDFILE=`pidfile $daemon_name`
                          ${SSD} \
                              --stop --quiet --oknodo \
                              --pidfile "$PIDFILE" \
                              --exec "$D_PATH/$daemon_name"

                          rm -f `pidfile $1`
                          rm -f `vtyfile $1`
                      fi

                      for i in ${daemon_inst}; do
                          if [ -n "$inst" ] && [ "$i" == "$inst" ]; then
                              start "$daemon_name" "$inst"
                          elif [ x"$inst" == x ]; then
                              start "$daemon_name" "$i"
                          fi
                      done
                  else
                      # Check if we're starting again by switching from
                      # single instance to MI version
                      eval "file_list_suffix="$V_PATH"/"$daemon_name-*""
                      for pidfile in $file_list_suffix.pid; do
                          ${SSD} --stop --quiet --oknodo --pidfile "$pidfile"
                          echo -n "."
                          rm -rf "$pidfile"
                      done
                      for vtyfile in $file_list_suffix.vty; do
                          rm -rf "$vtyfile"
                      done

                      start "$daemon_name"
                  fi
                fi
            done
        done
        echo "."
}

check_status()
{
    local daemon_name
    local daemon_prio
    local daemon_inst
    local failed_status=0

    if [ -n "$1" ] && [[ "$1" =~ (.*)-(.*) ]]; then
       daemon=${BASH_REMATCH[1]}
       inst=${BASH_REMATCH[2]}
    else
       daemon="$1"
    fi

    daemon_list=${daemon:-$DAEMONS}

    # Which daemons have been started?
    for daemon_name in $daemon_list; do
        eval daemon_prio=\$$daemon_name
        if [ "$daemon_prio" -gt 0 ]; then
           eval "daemon_inst=\${${daemon_name}_instances//,/ }"
           if [ -n "$daemon_inst" ]; then
              for i in ${daemon_inst}; do
                 if [ -n "$inst" -a "$inst" = "$i" ]; then
                      started "$1" "log" || failed_status=$?
                 elif [ -z "$inst" ]; then
                      started "$daemon_name-$i" "log" || failed_status=$?
                 fi
              done
           else
               started "$daemon_name" "log" || failed_status=$?
           fi
        fi
    done

    # All daemons that need to have been started are up and running
    return $failed_status
}

#########################################################
#               Main program                            #
#########################################################

# Config broken but script must exit silently.
[ ! -r "$C_PATH/daemons" ] && exit 0

# Load configuration
. "$C_PATH/daemons"
. "$C_PATH/debian.conf"

# Read configuration variable file if it is present
[ -r /etc/default/quagga ] && . /etc/default/quagga

MAX_INSTANCES=${MAX_INSTANCES:=5}

# Set priority of un-startable daemons to 'no' and substitute 'yes' to '0'
convert_daemon_prios

if [ ! -d $V_PATH ]; then
    echo "Creating $V_PATH"
    mkdir -p $V_PATH
    chown quagga:quagga $V_PATH
    chmod 755 /$V_PATH
fi

if [ -n "$3" ] && [ "$3" != "all" ]; then
   dmn="$2"-"$3"
elif [ -n "$2" ] && [ "$2" != "all" ]; then
   dmn="$2"
fi

case "$1" in
    start)
        # Try to load this necessary (at least for 2.6) module.
        if [ -d /lib/modules/`uname -r` ] ; then
          echo "Loading capability module if not yet done."
          set +e; LC_ALL=C modprobe -a capability 2>&1 | egrep -v "(not found|Can't locate)"; set -e
        fi

        # Start all daemons
        cd $C_PATH/
        if [ "$2" != "watchquagga" ]; then
          start_prio 10 $dmn
        fi
        start_watchquagga
        vtysh_b
        ;;

    1|2|3|4|5|6|7|8|9|10)
        # Stop/start daemons for the appropriate priority level
        stop_prio $1
        start_prio $1
        vtysh_b
        ;;

    stop|0)
        # Stop all daemons at level '0' or 'stop'
        stop_watchquagga
        if [ "$dmn" != "watchquagga" ]; then
         [ -n "${dmn}" ] && eval "${dmn/-/_}=0"
          stop_prio 0 $dmn
        fi

        if [ -z "$dmn" -o "$dmn" = "zebra" ]; then
          echo "Removing all routes made by zebra."
          ip route flush proto zebra
       else
         [ -n "$dmn" ] && eval "${dmn/-/_}=0"
         start_watchquagga
        fi
        ;;

    reload)
       # Just apply the commands that have changed, no restart necessary
       [ ! -x "$RELOAD_SCRIPT" ] && echo "quagga-reload script not available" && exit 0
       NEW_CONFIG_FILE="${2:-$C_PATH/Quagga.conf}"
       [ ! -r $NEW_CONFIG_FILE ] && echo "Unable to read new configuration file $NEW_CONFIG_FILE" && exit 1
       echo "Applying only incremental changes to running configuration from Quagga.conf"
       "$RELOAD_SCRIPT" --reload /etc/quagga/Quagga.conf
       exit $?
       ;;

    status)
        check_status $dmn
        exit $?
        ;;

    restart|force-reload)
        $0 stop $dmn
        sleep 1
        $0 start $dmn
        ;;

    *)
        echo "Usage: /etc/init.d/quagga {start|stop|status|reload|restart|force-reload|<priority>} [daemon]"
        echo "       E.g. '/etc/init.d/quagga 5' would start all daemons with a prio 1-5."
       echo "       reload applies only modifications from the running config to all daemons."
       echo "       reload neither restarts starts any daemon nor starts any new ones."
        echo "       Read /usr/share/doc/quagga/README.Debian for details."
        exit 1
        ;;
esac

echo "Exiting from the script"
exit 0
Commit	Line	Data
df44cf00	1	#!/bin/bash
651415bd DS	2	#
	3	### BEGIN INIT INFO
	4	# Provides: quagga
	5	# Required-Start: $local_fs $network $remote_fs $syslog
	6	# Required-Stop: $local_fs $network $remote_fs $syslog
	7	# Default-Start: 2 3 4 5
	8	# Default-Stop: 0 1 6
	9	# Short-Description: start and stop the Quagga routing suite
	10	# Description: Quagga is a routing suite for IP routing protocols like
	11	# BGP, OSPF, RIP and others. This script contols the main
	12	# daemon "quagga" as well as the individual protocol daemons.
	13	### END INIT INFO
	14	#
df44cf00	15
651415bd DS	16	PATH=/bin:/usr/bin:/sbin:/usr/sbin
	17	D_PATH=/usr/lib/quagga
	18	C_PATH=/etc/quagga
	19	V_PATH=/var/run/quagga
	20
	21	# Local Daemon selection may be done by using /etc/quagga/daemons.
	22	# See /usr/share/doc/quagga/README.Debian.gz for further information.
	23	# Keep zebra first and do not list watchquagga!
11364de5	24	DAEMONS="zebra bgpd ripd ripngd ospfd ospf6d isisd babeld pimd"
651415bd DS	25	MAX_INSTANCES=5
	26	RELOAD_SCRIPT=/usr/lib/quagga/quagga-reload.py
	27
	28	. /lib/lsb/init-functions
	29
d84fd25b DS	30	if [ -f /usr/lib/quagga/ssd ]; then
	31	SSD=/usr/lib/quagga/ssd
	32	else
	33	SSD=`which start-stop-daemon`
	34	fi
	35
651415bd DS	36	# Print the name of the pidfile.
	37	pidfile()
	38	{
	39	echo "$V_PATH/$1.pid"
	40	}
	41
	42	# Print the name of the vtysh.
	43	vtyfile()
	44	{
	45	echo "$V_PATH/$1.vty"
	46	}
	47
	48	# Check if daemon is started by using the pidfile.
	49	started()
	50	{
	51	[ ! -e `pidfile $1` ] && return 3
	52	if [ -n "$2" ] && [ "$2" == "log" ]; then
	53	status_of_proc -p `pidfile $1` $1 $1 && return 0 \|\| return $?
	54	else
	55	kill -0 `cat \`pidfile $1\`` 2> /dev/null \|\| return 1
	56	return 0
	57	fi
	58	}
	59
	60	# Loads the config via vtysh -b if configured to do so.
	61	vtysh_b ()
	62	{
	63	# Rember, that all variables have been incremented by 1 in convert_daemon_prios()
	64	if [ "$vtysh_enable" = 2 -a -f $C_PATH/Quagga.conf ]; then
	65	/usr/bin/vtysh -b -n
	66	fi
	67	}
	68
	69	# Check if the daemon is activated and if its executable and config files
	70	# are in place.
	71	# params: daemon name
	72	# returns: 0=ok, 1=error
	73	check_daemon()
	74	{
	75	# If the integrated config file is used the others are not checked.
	76	if [ -r "$C_PATH/Quagga.conf" ]; then
	77	return 0
	78	fi
	79
	80	# vtysh_enable has no config file nor binary so skip check.
	81	# (Not sure why vtysh_enable is in this list but does not hurt)
	82	if [ $1 != "watchquagga" -a $1 != "vtysh_enable" ]; then
	83	# check for daemon binary
	84	if [ ! -x "$D_PATH/$1" ]; then return 1; fi
	85
	86	# check for config file
	87	if [ -n "$2" ]; then
	88	if [ ! -r "$C_PATH/$1-$2.conf" ]; then
	89	touch "$C_PATH/$1-$2.conf"
	90	chown quagga:quagga "$C_PATH/$1-$2.conf"
	91	fi
	92	elif [ ! -r "$C_PATH/$1.conf" ]; then
	93	touch "$C_PATH/$1.conf"
	94	chown quagga:quagga "$C_PATH/$1.conf"
	95	fi
	96	fi
	97	return 0
	98	}
	99
100	# Starts the server if it's not alrady running according to the pid file.
101	# The Quagga daemons creates the pidfile when starting.
102	start()
df44cf00	103	{
651415bd DS	104	ulimit -n $MAX_FDS
651415bd DS	105	if [ "$1" = "watchquagga" ]; then
df44cf00	106
651415bd DS	107	# We may need to restart watchquagga if new daemons are added and/or
	108	# removed
	109	if started "$1" ; then
	110	stop watchquagga
	111	else
	112	# Echo only once. watchquagga is printed in the stop above
	113	echo -n " $1"
	114	fi
df44cf00	115
207e0d7a DS	116	if [ -e /var/run/quagga/watchquagga.started ] ; then
	117	rm /var/run/quagga/watchquagga.started
	118	fi
d84fd25b	119	${SSD} \
651415bd DS	120	--start \
	121	--pidfile=`pidfile $1` \
	122	--exec "$D_PATH/$1" \
	123	-- \
	124	"${watchquagga_options[@]}"
207e0d7a DS	125	for i in `seq 1 10`;
	126	do
	127	if [ -e /var/run/quagga/watchquagga.started ] ; then
	128	break
	129	else
	130	sleep 1
	131	fi
	132	done
651415bd DS	133	elif [ -n "$2" ]; then
	134	echo -n " $1-$2"
	135	if ! check_daemon $1 $2 ; then
	136	echo -n " (binary does not exist)"
	137	return;
	138	fi
	139
d84fd25b	140	${SSD} \
651415bd DS	141	--start \
	142	--pidfile=`pidfile $1-$2` \
	143	--exec "$D_PATH/$1" \
	144	-- \
	145	`eval echo "$""$1""_options"` -n "$2"
	146	else
	147	echo -n " $1"
	148	if ! check_daemon $1; then
	149	echo -n " (binary does not exist)"
	150	return;
	151	fi
	152
d84fd25b	153	${SSD} \
651415bd DS	154	--start \
	155	--pidfile=`pidfile $1` \
	156	--exec "$D_PATH/$1" \
	157	-- \
	158	`eval echo "$""$1""_options"`
	159	fi
	160	}
	161
	162	# Stop the daemon given in the parameter, printing its name to the terminal.
	163	stop()
	164	{
	165	local inst
	166
	167	if [ -n "$2" ]; then
	168	inst="$1-$2"
	169	else
	170	inst="$1"
df44cf00	171	fi
df44cf00	172
651415bd DS	173	if ! started "$inst" ; then
	174	echo -n " ($inst)"
	175	return 0
	176	else
	177	PIDFILE=`pidfile $inst`
	178	PID=`cat $PIDFILE 2>/dev/null`
d84fd25b	179	${SSD} --stop --quiet --retry=TERM/30/KILL/5 --oknodo --pidfile "$PIDFILE" --exec "$D_PATH/$1"
651415bd DS	180	#
	181	# Now we have to wait until $DAEMON has _really_ stopped.
	182	#
	183	if test -n "$PID" && kill -0 $PID 2>/dev/null; then
	184	echo -n " (waiting) ."
	185	cnt=0
	186	while kill -0 $PID 2>/dev/null; do
	187	cnt=`expr $cnt + 1`
	188	if [ $cnt -gt 60 ]; then
	189	# Waited 120 secs now, fail.
	190	echo -n "Failed.. "
	191	break
	192	fi
	193	sleep 2
	194	echo -n "."
	195	done
	196	fi
	197	echo -n " $inst"
	198	rm -f `pidfile $inst`
	199	rm -f `vtyfile $inst`
df44cf00	200	fi
	201	}
	202
651415bd DS	203	# Converts values from /etc/quagga/daemons to all-numeric values.
651415bd DS	204	convert_daemon_prios()
df44cf00	205	{
651415bd DS	206	for name in $DAEMONS zebra vtysh_enable watchquagga_enable; do
	207	# First, assign the value set by the user to $value
	208	eval value=\${${name}:0:3}
	209
	210	# Daemon not activated or entry missing?
	211	if [ "$value" = "no" -o "$value" = "" ]; then value=0; fi
	212
	213	# These strings parsed for backwards compatibility.
	214	if [ "$value" = "yes" -o "$value" = "true" ]; then
	215	value=1;
	216	fi
	217
	218	# Zebra is threatened special. It must be between 0=off and the first
	219	# user assigned value "1" so we increase all other enabled daemons' values.
	220	if [ "$name" != "zebra" -a "$value" -gt 0 ]; then value=`expr "$value" + 1`; fi
	221
	222	# If e.g. name is zebra then we set "zebra=yes".
	223	eval $name=$value
	224	done
df44cf00	225	}
df44cf00	226
651415bd DS	227	# Starts watchquagga for all wanted daemons.
651415bd DS	228	start_watchquagga()
df44cf00	229	{
651415bd DS	230	local daemon_name
	231	local daemon_prio
	232	local found_one
	233	local daemon_inst
	234
	235	# Start the monitor daemon only if desired.
	236	if [ 0 -eq "$watchquagga_enable" ]; then
	237	return
	238	fi
	239
	240	# Check variable type
	241	if ! declare -p watchquagga_options \| grep -q '^declare \-a'; then
	242	echo
	243	echo "ERROR: The variable watchquagga_options from /etc/quagga/debian.cnf must be a BASH array!"
	244	echo "ERROR: Please convert config file and restart!"
	245	exit 1
	246	fi
	247
	248	# Which daemons have been started?
	249	found_one=0
	250	for daemon_name in $DAEMONS; do
	251	eval daemon_prio=\$$daemon_name
	252	if [ "$daemon_prio" -gt 0 ]; then
	253	eval "daemon_inst=\${${daemon_name}_instances//,/ }"
	254	if [ -n "$daemon_inst" ]; then
	255	for inst in ${daemon_inst}; do
	256	eval "inst_disable=\${${daemon_name}_${inst}}"
	257	if [ -z ${inst_disable} ] \|\| [ ${inst_disable} != 0 ]; then
	258	if check_daemon $daemon_name $inst; then
	259	watchquagga_options+=("${daemon_name}-${inst}")
	260	fi
	261	fi
	262	done
	263	else
	264	if check_daemon $daemon_name; then
	265	watchquagga_options+=($daemon_name)
	266	fi
	267	fi
	268	found_one=1
	269	fi
	270	done
	271
	272	# Start if at least one daemon is activated.
	273	if [ $found_one -eq 1 ]; then
	274	echo -n "Starting Quagga monitor daemon:"
	275	start watchquagga
	276	echo "."
	277	fi
df44cf00	278	}
df44cf00	279
651415bd DS	280	# Stopps watchquagga.
651415bd DS	281	stop_watchquagga()
df44cf00	282	{
651415bd DS	283	echo -n "Stopping Quagga monitor daemon:"
	284	stop watchquagga
	285	echo "."
	286	}
	287
	288	# Stops all daemons that have a lower level of priority than the given.
	289	# (technically if daemon_prio >= wanted_prio)
	290	stop_prio()
	291	{
	292	local wanted_prio
	293	local daemon_prio
	294	local daemon_list
	295	local daemon_inst
	296	local inst
	297
	298	if [ -n "$2" ] && [[ "$2" =~ (.)-(.) ]]; then
	299	daemon=${BASH_REMATCH[1]}
	300	inst=${BASH_REMATCH[2]}
	301	else
	302	daemon="$2"
	303	fi
	304
	305	wanted_prio=$1
	306	daemon_list=${daemon:-$DAEMONS}
	307
	308	echo -n "Stopping Quagga daemons (prio:$wanted_prio):"
	309
	310	for prio_i in `seq 10 -1 $wanted_prio`; do
	311	for daemon_name in $daemon_list; do
	312	eval daemon_prio=\${${daemon_name}:0:3}
	313	daemon_inst=""
	314	if [ $daemon_prio -eq $prio_i ]; then
	315	eval "daemon_inst=\${${daemon_name}_instances//,/ }"
	316	if [ -n "$daemon_inst" ]; then
	317	for i in ${daemon_inst}; do
	318	if [ -n "$inst" ] && [ "$i" == "$inst" ]; then
	319	stop "$daemon_name" "$inst"
	320	elif [ x"$inst" == x ]; then
	321	stop "$daemon_name" "$i"
	322	fi
	323	done
	324	else
	325	stop "$daemon_name"
	326	fi
	327	fi
	328	done
	329	done
	330
	331	echo "."
	332	if [ -z "$inst" ]; then
	333	# Now stop other daemons that're prowling, coz the daemons file changed
	334	echo -n "Stopping other quagga daemons"
	335	if [ -n "$daemon" ]; then
	336	eval "file_list_suffix="$V_PATH"/"$daemon*""
	337	else
	338	eval "file_list_suffix="$V_PATH/*""
	339	fi
	340	for pidfile in $file_list_suffix.pid; do
	341	PID=`cat $pidfile 2>/dev/null`
d84fd25b	342	${SSD} --stop --quiet --oknodo --pidfile "$pidfile"
651415bd DS	343	echo -n "."
	344	rm -rf "$pidfile"
	345	done
	346	echo "."
	347
	348	echo -n "Removing remaining .vty files"
	349	for vtyfile in $file_list_suffix.vty; do
	350	rm -rf "$vtyfile"
	351	done
	352	echo "."
	353	fi
	354	}
	355
	356	# Starts all daemons that have a higher level of priority than the given.
	357	# (technically if daemon_prio <= wanted_prio)
	358	start_prio()
	359	{
	360	local wanted_prio
	361	local daemon_prio
	362	local daemon_list
	363	local daemon_name
	364	local daemon_inst
	365	local inst
	366
	367	if [ -n "$2" ] && [[ "$2" =~ (.)-(.) ]]; then
	368	daemon=${BASH_REMATCH[1]}
	369	inst=${BASH_REMATCH[2]}
	370	else
	371	daemon="$2"
	372	fi
	373
	374	wanted_prio=$1
	375	daemon_list=${daemon:-$DAEMONS}
	376
	377	echo -n "Starting Quagga daemons (prio:$wanted_prio):"
	378
	379	for prio_i in `seq 1 $wanted_prio`; do
	380	for daemon_name in $daemon_list; do
	381	eval daemon_prio=\$${daemon_name}
	382	daemon_inst=""
	383	if [ $daemon_prio -eq $prio_i ]; then
	384	eval "daemon_inst=\${${daemon_name}_instances//,/ }"
	385	if [ -n "$daemon_inst" ]; then
	386	if [ `echo "$daemon_inst" \| wc -w` -gt ${MAX_INSTANCES} ]; then
	387	echo "Max instances supported is ${MAX_INSTANCES}. Aborting"
	388	exit 1
	389	fi
	390	# Check if we're starting again by switching from single instance
	391	# to MI version
	392	if started "$daemon_name"; then
	393	PIDFILE=`pidfile $daemon_name`
d84fd25b	394	${SSD} \
651415bd DS	395	--stop --quiet --oknodo \
	396	--pidfile "$PIDFILE" \
	397	--exec "$D_PATH/$daemon_name"
	398
	399	rm -f `pidfile $1`
	400	rm -f `vtyfile $1`
	401	fi
	402
	403	for i in ${daemon_inst}; do
	404	if [ -n "$inst" ] && [ "$i" == "$inst" ]; then
	405	start "$daemon_name" "$inst"
	406	elif [ x"$inst" == x ]; then
	407	start "$daemon_name" "$i"
	408	fi
	409	done
	410	else
	411	# Check if we're starting again by switching from
	412	# single instance to MI version
	413	eval "file_list_suffix="$V_PATH"/"$daemon_name-*""
	414	for pidfile in $file_list_suffix.pid; do
d84fd25b	415	${SSD} --stop --quiet --oknodo --pidfile "$pidfile"
651415bd DS	416	echo -n "."
	417	rm -rf "$pidfile"
	418	done
	419	for vtyfile in $file_list_suffix.vty; do
	420	rm -rf "$vtyfile"
	421	done
	422
	423	start "$daemon_name"
	424	fi
	425	fi
	426	done
	427	done
	428	echo "."
df44cf00	429	}
df44cf00	430
651415bd	431	check_status()
df44cf00	432	{
651415bd DS	433	local daemon_name
	434	local daemon_prio
	435	local daemon_inst
	436	local failed_status=0
	437
	438	if [ -n "$1" ] && [[ "$1" =~ (.)-(.) ]]; then
	439	daemon=${BASH_REMATCH[1]}
	440	inst=${BASH_REMATCH[2]}
	441	else
	442	daemon="$1"
	443	fi
	444
	445	daemon_list=${daemon:-$DAEMONS}
	446
	447	# Which daemons have been started?
	448	for daemon_name in $daemon_list; do
	449	eval daemon_prio=\$$daemon_name
	450	if [ "$daemon_prio" -gt 0 ]; then
	451	eval "daemon_inst=\${${daemon_name}_instances//,/ }"
	452	if [ -n "$daemon_inst" ]; then
	453	for i in ${daemon_inst}; do
	454	if [ -n "$inst" -a "$inst" = "$i" ]; then
	455	started "$1" "log" \|\| failed_status=$?
	456	elif [ -z "$inst" ]; then
	457	started "$daemon_name-$i" "log" \|\| failed_status=$?
	458	fi
	459	done
	460	else
	461	started "$daemon_name" "log" \|\| failed_status=$?
	462	fi
	463	fi
	464	done
	465
	466	# All daemons that need to have been started are up and running
	467	return $failed_status
df44cf00	468	}
df44cf00	469
651415bd DS	470	#########################################################
	471	# Main program #
	472	#########################################################
	473
	474	# Config broken but script must exit silently.
	475	[ ! -r "$C_PATH/daemons" ] && exit 0
	476
	477	# Load configuration
	478	. "$C_PATH/daemons"
	479	. "$C_PATH/debian.conf"
	480
	481	# Read configuration variable file if it is present
	482	[ -r /etc/default/quagga ] && . /etc/default/quagga
	483
	484	MAX_INSTANCES=${MAX_INSTANCES:=5}
	485
	486	# Set priority of un-startable daemons to 'no' and substitute 'yes' to '0'
	487	convert_daemon_prios
	488
	489	if [ ! -d $V_PATH ]; then
	490	echo "Creating $V_PATH"
	491	mkdir -p $V_PATH
	492	chown quagga:quagga $V_PATH
	493	chmod 755 /$V_PATH
	494	fi
	495
	496	if [ -n "$3" ] && [ "$3" != "all" ]; then
	497	dmn="$2"-"$3"
	498	elif [ -n "$2" ] && [ "$2" != "all" ]; then
	499	dmn="$2"
	500	fi
	501
df44cf00	502	case "$1" in
651415bd DS	503	start)
	504	# Try to load this necessary (at least for 2.6) module.
	505	if [ -d /lib/modules/`uname -r` ] ; then
	506	echo "Loading capability module if not yet done."
	507	set +e; LC_ALL=C modprobe -a capability 2>&1 \| egrep -v "(not found\|Can't locate)"; set -e
	508	fi
	509
	510	# Start all daemons
	511	cd $C_PATH/
	512	if [ "$2" != "watchquagga" ]; then
	513	start_prio 10 $dmn
	514	fi
651415bd	515	start_watchquagga
207e0d7a	516	vtysh_b
651415bd DS	517	;;
	518
	519	1\|2\|3\|4\|5\|6\|7\|8\|9\|10)
	520	# Stop/start daemons for the appropriate priority level
	521	stop_prio $1
	522	start_prio $1
	523	vtysh_b
	524	;;
	525
	526	stop\|0)
	527	# Stop all daemons at level '0' or 'stop'
	528	stop_watchquagga
	529	if [ "$dmn" != "watchquagga" ]; then
	530	[ -n "${dmn}" ] && eval "${dmn/-/_}=0"
	531	stop_prio 0 $dmn
	532	fi
	533
	534	if [ -z "$dmn" -o "$dmn" = "zebra" ]; then
	535	echo "Removing all routes made by zebra."
	536	ip route flush proto zebra
	537	else
	538	[ -n "$dmn" ] && eval "${dmn/-/_}=0"
	539	start_watchquagga
	540	fi
	541	;;
	542
	543	reload)
	544	# Just apply the commands that have changed, no restart necessary
	545	[ ! -x "$RELOAD_SCRIPT" ] && echo "quagga-reload script not available" && exit 0
	546	NEW_CONFIG_FILE="${2:-$C_PATH/Quagga.conf}"
	547	[ ! -r $NEW_CONFIG_FILE ] && echo "Unable to read new configuration file $NEW_CONFIG_FILE" && exit 1
	548	echo "Applying only incremental changes to running configuration from Quagga.conf"
	549	"$RELOAD_SCRIPT" --reload /etc/quagga/Quagga.conf
	550	exit $?
	551	;;
	552
	553	status)
	554	check_status $dmn
	555	exit $?
	556	;;
	557
	558	restart\|force-reload)
	559	$0 stop $dmn
	560	sleep 1
	561	$0 start $dmn
	562	;;
	563
	564	*)
	565	echo "Usage: /etc/init.d/quagga {start\|stop\|status\|reload\|restart\|force-reload\|<priority>} [daemon]"
	566	echo " E.g. '/etc/init.d/quagga 5' would start all daemons with a prio 1-5."
	567	echo " reload applies only modifications from the running config to all daemons."
	568	echo " reload neither restarts starts any daemon nor starts any new ones."
	569	echo " Read /usr/share/doc/quagga/README.Debian for details."
	570	exit 1
	571	;;
df44cf00	572	esac
df44cf00	573
651415bd	574	echo "Exiting from the script"
df44cf00	575	exit 0