lfs-book/bootscripts/contrib/lsb-v3/lsb/manage-functions

#!/bin/bash
# Begin /lib/lsb/manage-functions

# /lib/lsb/manage-functions contains the functions used by 
# /lib/lsb/install_initd and /lib/lsb/remove_initd as well as additional helper
# functions for use in programs that would provide functionality similar to
# the RedHat chkconfig utility, for instance.

# source the confif file
. /etc/lsb/lsb-config

# Define all arrays at script start to avoid scope issues
# scriptlist is a list of valid scripts used as an index
declare -a scriptlist
# fullheaders is a complete set of valid LSB headers, stored in memory for 
# each indexed script, to avoid multiple disk reads
declare -a fullheaders

###############################################################################
# get_headers() - Obtains a valid list of scripts contained in ${rcbase} and  #
#                 inserts the name of the script into the scriptlist[] array  #
#                 for use by all other functions.  Additionally, it inserts   #
#                 the entire LSB header information from each script into a   #
#                 second array, fullheaders[], so that diskreads need only be #
#                 done once                                                   #
#                 Returns no value, but populates the variable ${scriptcount} #
#                 and the arrays ${scriptlist} and ${fullheaders} for use     #
#                 with other functions in this script.  This function is      #
#                 called unconditionally at the end of this scrip and is      #
#                 provided as a function only for the case that it needs to   #
#                 be called again after other operations.                     #
###############################################################################
get_headers()
{
    echo -n "Retrieving script information from disk..."
    count=1
    for file in $(find -P /etc/init.d -xdev -perm -u=x | sed -n 2~1p \
                      | sed "s@/etc/init.d/rc@@")
    do
        # determine if script is an LSB compliant script
        grep "### BEGIN INIT INFO" $file > /dev/null
        if test $? -gt "0"
        then
            # this is not a valid script and is ignored
            # skip the rest of the loop
            continue
        fi
        # determine basename using only bash (is basename a builtin?)
        filename=$(echo "${file}" | sed "s@${rcbase}/@@")
        # assign it to an array possition
        scriptlist["${count}"]="${filename}"
        # find the begining of the init info for the script
        begin=$(grep -n "### BEGIN INIT INFO" "${file}" | cut -d: -f1)
        # find the end of the init info for the script
        end=$(grep -n "### END INIT INFO" "${file}" | cut -d: -f1)
        # we'll use the difference between the values in the tail command
        diff=$(( ${end} - ${begin} ))
        # assign the entire LSB header information as a single string to the
        # fullheaders[] array
        fullheaders["${count}"]=$(head -n "${end}" "${file}" \
                                    | tail -n "${diff}")
        count=$(( ${count} + 1 ))
        unset begin
        unset end
        unset diff
        unset filename
    done
    # a number or array elements would be a nice regular variable assignment
    scriptcount="${#scriptlist[@]}"
    unset count
    echo -e "Completed!"
}

###############################################################################
# print_headers() - Presents a formatted list of all LSB compliant script     #
#                   headers to stdout preceeded by script name for use in     #
#                   other scripts                                             #
###############################################################################
print_headers()
{
    get_headers
    count=1
    while test "${count}" -lt "${scriptcount}"
    do
        echo "${scriptlist[$count]}"
        echo "============================================================="
        echo "${fullheaders[$count]}"
        echo ""
        echo ""
        count="$(( ${count} + 1 ))"
    done
}

###############################################################################
# get_index() - Determines the array index of the specified script            #
###############################################################################

get_index()
{
    filename=$(echo "${1}" | sed "s@${rcbase}/@@")
    count=1
    while test "${count}" -lt "${scriptcount}"
    do
        echo "${scriptlist[${count}]}" | grep "${filename}" > /dev/null
        if test "${?}" -ne "0"
        then
            count=$(( ${count} + 1 ))
            continue
        else
            break
        fi
    done
    if test "${filename}" == "${scriptlist[${count}]}"
    then
        echo "${count}"
    else
        echo "${1} is not a valid LSB init script."
        exit 1
    fi
    unset filename
    unset count
}

###############################################################################
# get_lsb_value() - Obtains the LSB Value of $1 for index of script ($2).     #
###############################################################################
get_lsb_value()
{
    # Probably need some error checking in here
    echo "${fullheaders[${2}]}" | \
        grep "^# ${1}" | \
        sed -e "s@# ${1}:@@" \
            -e "s/^[ \t]*//"
}

###############################################################################
# convert_lsb_required() - Converts LSB defined facilities (facility names    #
#                          begining with a '$' character) into script names   #
#                          for required start/stop                            #
###############################################################################
convert_lsb_required()
{
    local count=0
    local provides=""
    local reqfacility=""
    local reqprovideslist=""

    for reqfacility in $@
    do
        # find the requires and it's index and then find the script name 
        # from the index.  Since this is required, exit if it is not found
        ## If reqfacility is already in script name format, nothing needs to
        ## be done, just echo it back out.  I can't think of an easy way to
        ## do this right now, the scriptname will be the same as the provides
        ## anyway, so just let it fly for now...it'll be correct, it just 
        ## takes an extra couple of commands to get the same result.
        ## Besides, this will do some extra sanity checking in case somebody
        ## writes a script that isn't named the same as provides, though this
        ## isn't LSB compliant.  Additionally, these same comments apply to
        ## the convert_lsb_should() fucntion below.
        count=0
        while test ${count} -lt ${scriptcount}
        do
            count=$(( $count + 1 ))
            provides="$( get_lsb_value Provides ${count} )"
            if test "${provides}" = "${reqfacility}"
            then
                 reqprovideslist="${reqprovideslist} ${scriptlist[$count]}"
                 break
            fi
            if test ${count} -eq ${scriptcount}; then
                # If we've never broken out of the while loop, then this is an
                # unrecoverable error since it is a required item.  Exit now!
                echo "Error: unable to locate required facility ${reqfacility}!"
                exit 5
            fi
        done
    done
    echo "${reqprovideslist}" | sed -e "s/^[ \t]*//" -e "s/^[ \t]*//"
}

###############################################################################
# convert_lsb_should() - Converts LSB defined facilities (facility names      #
#                        begining with a '$' character) into script names for #
#                        should start/stop                                    #
###############################################################################

convert_lsb_should()
{
    local count=0
    local provides=""
    local optfacility=""
    local optprovideslist=""

    for optfacility in $@
    do
        # find the should and it's index and then find the script name 
        # from the index.  Since this is not an error, simply warn if it
        # is not found.
        count=0
        while test ${count} -lt ${scriptcount}
        do
            count=$(( $count + 1 ))
            provides="$( get_lsb_value Provides ${count} )"
            if test "${provides}" = "${optfacility}"
            then
                 optprovideslist="${optprovideslist} ${scriptlist[$count]}"
                 break
            fi
            # No need to error or warn on should items, and it's messy if so!
        done
    done
    echo "${optprovideslist}" | sed -e "s/^[ \t]*//" -e "s/[ \t]*$//"
}

get_headers

###############################################################################
# get_lsb_required_value() - Additional function to simplify repetitive tasks #
#                            Obtains the LSB Value of $1 for index of script  #
#                            ($2) and immediately converts LSB defined        #
#                            facilities (beginning with a '$' character) to a #
#                            script name.  If the script is not found, then   #
#                            the function exits with an error as per          #
#                            convert_lsb_required.                            #
###############################################################################
get_lsb_required_value()
{
    local reqval
    # Probably need some error checking in here
    reqval=`echo "${fullheaders[${2}]}" | \
        grep "^# ${1}" | \
        sed -e "s@# ${1}:@@" \
            -e "s/^[ \t]*//"`

    # If $reqval contains a '$' charcter, then convert it to a script name
    echo "${reqval}" | grep "\\$" 2>&1 > /dev/null
    if test "${?}" -eq "0"
    then
        reqval=`convert_lsb_required "${reqval}"`
    fi
    echo "${reqval}"
}

###############################################################################
# get_lsb_should_value() - Additional function to simplify repetitive tasks   #
#                          Obtains the LSB Value of $1 for index of script    #
#                          ($2) and immediately converts LSB defined          #
#                          facilities (beginning with a '$' character) to a   #
#                          script name.  If the script is not found, the      #
#                          value is removed from the list as it is optional.  #
###############################################################################
get_lsb_should_value()
{
    local optval
    local listitem
    local optitem
    # Probably need some error checking in here
    optval=`echo "${fullheaders[${2}]}" | \
        grep "^# ${1}" | \
        sed -e "s@# ${1}:@@" \
            -e "s/^[ \t]*//"`

    # If $optval contains a '$' charcter, then convert it to a script name
    echo "${optval}" | grep "\\$" 2>&1 > /dev/null
    if test "${?}" -eq "0"
    then
        optval=`convert_lsb_should "${optval}"`
        # if we still have a "$" character, then it's not found and it should
        # be removed from the list (and it's trailing space if one exists)
        # since it is optional
        echo "${optval}" | grep "\\$" 2>&1 > /dev/null
        if test "${?}" -eq "0"
        then
            # Remove the value
            for listitem in ${optval} 
            do
                echo "${listitem}" | grep "\\$"
                if test "${?}" -eq "0"
                then
                    optval=`echo "${optval}" | sed -e 's@${listitem} @@' \
                                                   -e 's@${listitem}@@' | \
                                sed -e "s@# ${1}:@@" \
                                    -e "s/^[ \t]*//"`
                fi
            done
        fi    
    fi
    # If a should start value does not have a script associted with it, then
    # remove it (or it and trailing space) from the list
    for optitem in ${otpval}
    do
        grep "${optitem}" "${statedir}/enabled-scripts" 2>&1 > /dev/null
        if test "${?}" -ne "0"
        then
            optval=`echo "${optval}" | sed -e 's@${otpitem} @@' \
                                           -e 's@${optitem}@@' | \
                        sed -e "s@# ${1}:@@" \
                            -e "s/^[ \t]*//"`
        fi
    done        

    echo "${optval}"
}

# End /lib/lsb/manage-functions