ISC DHCPD lässt sich nicht starten

Dany

Well-Known Member
Hallo,

beim Neustart von meinen Rechner startet der dhcp Server nicht mit. Wenn ich das Skript per Hand ausführe erhalte ich folgende Fehlermeldung:

Code:
/usr/local/etc/rc.d/isc-dhcpd.sh start
Starting dhcpd.
Internet Systems Consortium DHCP Server V3.0.1rc14
Copyright 2004 Internet Systems Consortium.
All rights reserved.
For info, please visit http://www.isc.org/sw/dhcp/
Wrote 0 leases to leases file.
Listening on BPF/xl0/00:01:02:f6:d7:6c/10.0.0.0/24
Sending on   BPF/xl0/00:01:02:f6:d7:6c/10.0.0.0/24
Sending on   Socket/fallback/fallback-net
There's already a DHCP server running.

Es läuft aber kein anderer DHCP Server an diesen Server und in diesen Netzwerk.

Der Auszug aus der rc.conf sieht wie folgt aus.

Code:
dhcpd_enable="YES"
# dhcpd_flags="-q -early_chroot"
dhcpd_flags=" -d -f "
dhcpd_conf="/usr/local/etc/dhcpd.conf"
dhcpd_ifaces="xl0"
dhcpd_umask="022"
dhcpd_chuser_enable="YES"
dhcpd_withuser="dhcpd"
dhcpd_withgroup="dhcpd"
dhcpd_chroot_enable="YES"
dhcpd_rootdir="/var/db/dhcpd"
dhcpd_withumask="022"

Mein dhcpd.conf hat folgenden Inhalt:

Code:
option domain-name "intern";
option domain-name-servers 10.0.0.55;
option subnet-mask 255.255.255.0;

default-lease-time 600;
max-lease-time 7200;
authoritative;
ddns-update-style none;
log-facility local7;

subnet 10.0.0.0 netmask 255.255.255.0 {
  range 10.0.0.160 10.0.0.170;
  option routers 10.0.0.1;
  option broadcast-address 10.0.0.155;
  option netbios-name-servers 10.0.0.155;
  option ntp-servers 10.0.0.155;
}

Wenn ich den Befehl "/usr/local/sbin/dhcpd" auf der Shell ausführe, dann wird der dhcp Server gestartet.

Über das run Skript im rc.d Verzeichnis wird er nicht gestartet.

Run-Script:

Code:
. /etc/rc.subr

name=dhcpd
paranoia=YES                            # compiled in paranoia?
jail=YES                                # compiled in jail?

# override these variables in /etc/rc.conf
dhcpd_enable=${dhcpd_enable:-"NO"}
dhcpd_flags=${dhcpd_flags:-} # -q -early_chroot         # command option(s)
dhcpd_conf=${dhcpd_conf:-/usr/local/etc/${name}.conf}   # configuration file
dhcpd_ifaces=${dhcpd_ifaces:-}                          # ethernet interface(s)
dhcpd_withumask=${dhcpd_withumask:-022}                 # file creation mask

dhcpd_chuser_enable=${dhcpd_chuser_enable:-"YES"}       # runs w/o privileges?
dhcpd_withuser=${dhcpd_withuser:-${name}}               # user name to run as
dhcpd_withgroup=${dhcpd_withgroup:-${name}}             # group name to run as

dhcpd_chroot_enable=${dhcpd_chroot_enable:-"NO"}        # runs chrooted?
dhcpd_rootdir=${dhcpd_rootdir:-/var/db/${name}}         # directory to run in

# untested
dhcpd_jail_enable=${dhcpd_jail_enable:-"NO"}            # runs imprisoned?
dhcpd_hostname=${dhcpd_hostname:-}                      # jail hostname
dhcpd_ipaddress=${dhcpd_ipaddress:-}                    # jail ip address

safe_run ()     # rc command [args...]
{
        local _rc

        _rc=$1
        shift

        if [ "${_rc}" -eq 0 ]; then
                debug safe_run: "$@"
                "$@" || _rc=1
        else
                warn safe_run: "$@"
        fi
        return ${_rc}
}

precious ()     # entry...
{
        local _entry _rc

        _rc=0
        for _entry; do
                # do nothing if /var/run or /var/db
                echo ${_entry} | egrep -q '^//*(var//*(run|db)/*)?$' || _rc=1
        done
        debug precious: "$@" rc=${_rc}
        return ${_rc}
}

lsmod ()        # user group file...
{
        local _entry _user _group _rc

        _user=$1 _group=$2
        shift 2

        _rc=0
        for _entry; do
                ls -ld ${_entry} 2> /dev/null |
                awk -v u=${_user} -v g=${_group} '{
                    exit ((u && $3 != u) || (g && $4 != g))
                }' || _rc=1
        done
        debug lsmod: "$@" rc=${_rc}
        return ${_rc}
}

safe_chmog ()   # entry...
{
        local _entry _user _group _usergroup _rc

        _user=${dhcpd_withuser}
        _group=${dhcpd_withgroup}

        _rc=0
        if [ -n "${_user}" -o -n "${_group}" ]; then
                _usergroup=${_user}${_group:+:${_group}}
                for _entry; do
                        if [ -d ${_entry} ] && mounted ${_entry}; then
                                continue
                        fi
                        if [ -e ${_entry} ] &&
                           ! precious ${_entry} &&
                           ! lsmod ${_user} ${_group} ${_entry} &&
                           ! safe_run ${_rc} chown ${_usergroup} ${_entry}; then
                                warn "unable to change permissions of ${_entry}"
                                _rc=1
                        fi
                done
        fi
        return ${_rc}
}

safe_mkdir ()   # dir...
{
        local _dir _rc

        _rc=0
        for _dir; do
                if [ ! -d ${_dir} ] &&
                   ! precious ${_dir} &&
                   ! safe_run ${_rc} mkdir -p ${_dir}; then
                        err 1 "unable to create directory ${_dir}"
                        _rc=1
                fi
        done
        safe_run ${_rc} safe_chmog "$@" || _rc=1
        return ${_rc}
}

safe_rmdir ()   # dir...
{
        local _dir _rc

        _rc=0
        for _dir; do
                if [ -d ${_dir} ] &&
                   ! precious ${_dir} &&
                   ! mounted ${_dir}; then
                        if safe_run ${_rc} rmdir ${_dir}; then
                                safe_run ${_rc} safe_rmdir ${_dir%/*} || _rc=1
                        else
                                warn "unable to remove directory ${_dir}"
                                rc=1
                        fi
                fi
        done
        return ${_rc}
}

safe_touch ()   # file...
{
        local _file _rc

        _rc=0
        for _file; do
                if [ ! -e ${_file} ] &&
                   ! safe_run ${_rc} touch ${_file}; then
                        err 1 "unable to create file ${_file}"
                        _rc=1
                fi
        done
        safe_run ${_rc} safe_chmog "$@" || _rc=1
        return ${_rc}
}

safe_remove ()  # file...
{
        local _file _rc

        _rc=0
        for _file; do
                if [ -f ${_file} ] &&
                   ! safe_run ${_rc} rm -f ${_file}; then
                        warn "unable to remove file ${_file}"
                        _rc=1
                fi
        done
        return ${_rc}
}

safe_copy ()    # src dst
{
        local _src _dst _rc

        _src=$1 _dst=$2

        _rc=0
        if ! safe_run ${_rc} safe_remove ${_dst} ||
           ! safe_run ${_rc} cp -p ${_src} ${_dst}; then
                err 1 "unable to copy file ${_src} to ${_dst}"
                _rc=1
        fi
        safe_run ${_rc} safe_chmog ${_dst} || _rc=1
        return ${_rc}
}

mounted ()      # dir...
{
        local _rc

        _rc=1
        mount -t devfs | awk '
            BEGIN { n = ARGC; ARGC = 2 }
            { for (i = 2; i != n; i++) if ($3 == ARGV[i]) exit 1 }
        ' - "$@" || _rc=0
        debug mounted: "$@" rc=${_rc}
        return ${_rc}
}

safe_mount ()   # dir
{
        local _dir _rc

        _dir=$1

        _rc=0
        if ! mounted ${_dir} &&
           ! safe_run ${_rc} mount -t devfs devfs ${_dir}; then
                err 1 "unable to mount ${_dir}"
                _rc=1
        fi
        return ${_rc}
}

safe_umount ()  # dir
{
        local _dir _rc

        _dir=$1

        _rc=0
        if mounted ${_dir} &&
           ! safe_run ${_rc} umount ${_dir}; then
                warn "unable to unmount ${_dir}"
                _rc=1
        fi
        return ${_rc}
}

safe_useradd ()
{
        local _user _group _home _shell _gecos

        _user=$1 _group=$2 _gecos=${3:-"& daemon"}
        _home=${4:-/nonexistent} _shell=${5:-/sbin/nologin}

        if [ -n "${_group}" ]; then
                if pw group show ${_group} 2>/dev/null; then
                        echo "You already have a group \"${_group}\"," \
                             "so I will use it."
                elif pw groupadd ${_group} -h -; then
                        echo "Added group \"${_group}\"."
                else
                        echo "Adding group \"${_group}\" failed..."
                        echo "Please create it, and try again."
                        exit 1
                fi
        fi
        if [ -n "${_user}" ]; then
                if pw user show ${_user} 2>/dev/null; then
                        echo "You already have a user \"${_user}\"," \
                             "so I will use it."
                elif pw useradd ${_user} -g ${_group} -h - \
                        -d ${_home} -s ${_shell} -c "${_gecos}"; then
                        echo "Added user \"${_user}\"."
                else
                        echo "Adding user \"${_user}\" failed..."
                        echo "Please create it, and try again."
                        exit 1
                fi
        fi
}

check_chuser ()
{
        if checkyesno paranoia; then
                if checkyesno dhcpd_chuser_enable &&
                   [ -z "${dhcpd_withuser}" -a -z "${dhcpd_withgroup}" ]; then
                        err 1 "one of dhcpd_withuser and dhcpd_withgroup" \
                              "must be set if dhcpd_chuser_enable is enabled"
                fi
        else
                if checkyesno dhcpd_chuser_enable; then
                        warn "dhcpd_chuser_enable disabled -- not compiled in"
                        dhcpd_chuser_enable=NO
                fi
        fi
}

check_jail ()
{
        if checkyesno paranoia && checkyesno jail; then
                if checkyesno dhcpd_jail_enable &&
                   ! checkyesno dhcpd_chroot_enable; then
                        warn "dhcpd_chroot_enable implied by dhcpd_jail_enable"
                        dhcpd_chroot_enable=YES
                fi
                if checkyesno dhcpd_jail_enable &&
                   [ -n "${dhcpd_hostname}" -a -z "${dhcpd_ipaddress}" ] ||
                   [ -z "${dhcpd_hostname}" -a -n "${dhcpd_ipaddress}" ]; then
                        err 1 "both dhcpd_hostname and dhcpd_ipaddress" \
                              "must be set if dhcpd_jail_enable is enabled"
                fi
        else
                if checkyesno dhcpd_jail_enable; then
                        warn "dhcpd_jail_enable disabled -- not compiled in"
                        dhcpd_jail_enable=NO
                fi
        fi
}

check_chroot ()
{
        if checkyesno paranoia; then
                if checkyesno dhcpd_chroot_enable &&
                   [ -z "${dhcpd_rootdir}" ]; then
                        err 1 "dhcpd_rootdir" \
                              "must be set if dhcpd_chroot_enable is enabled"
                fi
        else
                if checkyesno dhcpd_chroot_enable; then
                        warn "dhcpd_chroot_enable disabled -- not compiled in"
                        dhcpd_chroot_enable=NO
                fi
        fi
}

rcvar_chuser ()
{
        if checkyesno paranoia && checkyesno dhcpd_chuser_enable; then
                dhcpd_piddir=${__dhcpd_piddir}/${name}
                dhcpd_leasesdir=${__dhcpd_leasesdir}/${name}
        else
                dhcpd_withuser= dhcpd_withgroup=
        fi
}

rcvar_jail ()
{
        if ! checkyesno paranoia || ! checkyesno jail ||
           ! checkyesno dhcpd_jail_enable; then
                dhcpd_hostname= dhcpd_ipaddress=
        fi
}

rcvar_chroot ()
{
        if ! checkyesno paranoia || ! checkyesno dhcpd_chroot_enable; then
                dhcpd_rootdir=
        fi
}

rcvar_pidnleases ()
{
        if ! checkyesno dhcpd_chuser_enable; then
                dhcpd_piddir=${__dhcpd_piddir}
                dhcpd_leasesdir=${__dhcpd_leasesdir}
        fi
        dhcpd_pidfile=${dhcpd_piddir}/${name}.pid
        dhcpd_leasesfile=${dhcpd_leasesdir}/${name}.leases
        dhcpd_conffile=${dhcpd_conf}    # for convenience only
        dhcpd_confdir=$(dirname ${dhcpd_conffile})
}

rcvar_rooted ()
{
        _dhcpd_rootdir=${dhcpd_rootdir}
        _dhcpd_devdir=${dhcpd_rootdir}/dev
        _dhcpd_confdir=${dhcpd_rootdir}${dhcpd_confdir}
        _dhcpd_piddir=${dhcpd_rootdir}${dhcpd_piddir}
        _dhcpd_leasesdir=${dhcpd_rootdir}${dhcpd_leasesdir}
        _dhcpd_conffile=${dhcpd_rootdir}${dhcpd_conffile}
        _dhcpd_pidfile=${dhcpd_rootdir}${dhcpd_pidfile}
        _dhcpd_leasesfile=${dhcpd_rootdir}${dhcpd_leasesfile}
}

setup_compat ()
{
        local dhcpd_rcconf

        # suck in old configuration file and variables
        #
        dhcpd_rcconf=${dhcpd_confdir}/rc.isc-dhcpd.conf

        if [ -f ${dhcpd_rcconf} ]; then
                warn "${dhcpd_rcconf} is obsolete, use /etc/rc.conf and/or" \
                     "/etc/rc.conf.d/${name} instead."
                . ${dhcpd_rcconf}

                if [ -n "${dhcpd_options}" -a -z "${rc_flags}" ]; then
                        warn "dhcpd_options is obsolete," \
                             "use dhcpd_flags instead."
                        rc_flags=${dhcpd_options}
                fi
        fi
}

setup_umask ()
{
        if [ -n "${dhcpd_withumask}" ]; then
                umask ${dhcpd_withumask}
        fi
}

setup_chroot ()
{
        if checkyesno paranoia && checkyesno dhcpd_chroot_enable; then
                safe_mkdir ${_dhcpd_rootdir} ${_dhcpd_devdir} ${_dhcpd_confdir}
                safe_mount ${_dhcpd_devdir}
                safe_copy ${dhcpd_conffile} ${_dhcpd_conffile}
        fi
}

setup_chuser ()
{
        if checkyesno paranoia && {
           checkyesno dhcpd_chuser_enable || checkyesno dhcpd_chroot_enable
        }; then
                safe_mkdir ${_dhcpd_piddir} ${_dhcpd_leasesdir}
        fi
}

setup_leases ()
{
        safe_touch ${_dhcpd_leasesfile}
}

setup_flags ()
{
        if [ -n "${dhcpd_conf}" ]; then
                rc_flags="${rc_flags} -cf ${dhcpd_conf}"
        fi
        if [ -n "${dhcpd_leasesfile}" ]; then
                rc_flags="${rc_flags} -lf ${dhcpd_leasesfile}"
        fi
        if [ -n "${dhcpd_pidfile}" ]; then
                rc_flags="${rc_flags} -pf ${dhcpd_pidfile}"
        fi
        if [ -n "${dhcpd_withuser}" ]; then
                rc_flags="${rc_flags} -user ${dhcpd_withuser}"
        fi
        if [ -n "${dhcpd_withgroup}" ]; then
                rc_flags="${rc_flags} -group ${dhcpd_withgroup}"
        fi
        if [ -n "${dhcpd_rootdir}" ]; then
                rc_flags="${rc_flags} -chroot ${dhcpd_rootdir}"
        fi
        if [ -n "${dhcpd_hostname}" -a -n "${dhcpd_ipaddress}" ]; then
                rc_flags="${rc_flags} -jail ${dhcpd_hostname} ${dhcpd_ipaddress}"
        fi
        rc_flags="${rc_flags} ${dhcpd_ifaces}"
}

cleanup_chroot ()
{
        if checkyesno paranoia && checkyesno dhcpd_chroot_enable; then
                safe_umount ${_dhcpd_devdir}
        fi
}

dhcpd_stop ()
{
        if sh $0 forcestatus; then
                sh $0 forcestop
        fi
}

remove_pid ()
{
        if [ -e ${_dhcpd_pidfile} ]; then
                warn "${_dhcpd_pidfile} still exists! -- removing anyway"
        fi
        safe_remove ${_dhcpd_pidfile}
}

remove_leases ()
{
        if [ -s ${_dhcpd_leasesfile} ]; then
                warn "${_dhcpd_leasesfile} not empty -- not removed --" \
                     "futher warning messages expected, don't care."
        else
                safe_remove ${_dhcpd_leasesfile} ${_dhcpd_leasesfile}~
        fi
}

remove_chuser ()
{
        if checkyesno paranoia && {
           checkyesno dhcpd_chuser_enable || checkyesno dhcpd_chroot_enable
        }; then
                safe_rmdir ${_dhcpd_piddir} ${_dhcpd_leasesdir}
        fi
}

remove_chroot ()
{
        if checkyesno paranoia && checkyesno dhcpd_chroot_enable; then
                safe_remove ${_dhcpd_conffile}
                safe_umount ${_dhcpd_devdir}
                safe_rmdir ${_dhcpd_confdir} ${_dhcpd_devdir} ${_dhcpd_rootdir}
        fi
}

dhcpd_check ()
{
        check_chuser
        check_jail
        check_chroot
}

dhcpd_rcvar ()
{
        rcvar_chuser
        rcvar_jail
        rcvar_chroot
        rcvar_pidnleases
        rcvar_rooted
}

dhcpd_precmd ()
{
        setup_compat
        setup_umask
        setup_chroot
        setup_chuser
        setup_leases
        setup_flags
}

dhcpd_postcmd ()
{
        cleanup_chroot
}

dhcpd_install ()
{
        if checkyesno paranoia; then
                safe_useradd "${dhcpd_withuser}" "${dhcpd_withgroup}" \
                             "DHCP Daemon"
        fi
}

_dhcpd_uninstall ()     # user group root
{
        local _user _group _root

        _user=$1 _group=$2 _root=$3

        if [ -n "${_user}" -o -n "${_group}" ]; then
                dhcpd_chuser_enable=YES
                dhcpd_withuser=${_user}
                dhcpd_withgroup=${_group}
        else
                dhcpd_chuser_enable=NO
        fi
        if [ -n "${_root}" ]; then
                dhcpd_chroot_enable=YES
                dhcpd_rootdir=${_root}
        else
                dhcpd_chroot_enable=NO
        fi
        dhcpd_check
        dhcpd_rcvar
        dhcpd_uninstall
}

dhcpd_uninstall ()
{
        if checkyesno __dhcpd_uninstall; then
                dhcpd_stop
                remove_pid
                remove_leases
                remove_chuser
                remove_chroot
        else
                local _user _group _root

                __dhcpd_uninstall=YES

                _user=${dhcpd_withuser}
                _group=${dhcpd_withgroup}
                _root=${dhcpd_rootdir}

                _dhcpd_uninstall "" "" ""

                if checkyesno paranoia; then
                        if [ -n "${_user}" -o -n "${_group}" ]; then
                                _dhcpd_uninstall "${_user}" "${_group}" ""
                        fi
                        if [ -n "${_root}" ]; then
                                _dhcpd_uninstall "" "" "${_root}"
                        fi
                        if [ -n "${_user}" -o -n "${_group}" ] &&
                           [ -n "${_root}" ]; then
                                _dhcpd_uninstall "${_user}" "${_group}" "${_root}"
                        fi
                fi
        fi
}

rcvar=$(set_rcvar)
load_rc_config ${name}

__dhcpd_uninstall="NO"                  # internal use only
__dhcpd_piddir=/var/run                 # pid file directory
__dhcpd_leasesdir=/var/db               # leases file directory
# __dhcpd_rootdir=/var/db/${name}       # root directory

dhcpd_check
dhcpd_rcvar

command=/usr/local/sbin/${name}
pidfile=${_dhcpd_pidfile}
required_files=${dhcpd_conf}
start_precmd=${name}_precmd
stop_postcmd=${name}_postcmd
install_cmd=dhcpd_install
uninstall_cmd=dhcpd_uninstall
extra_commands="install uninstall"

run_rc_command "$1"

Wo liegt der Fehler?

Danke Daniel
 
Gute Frage, lass doch mal chroot weg, bei mir tut das. Musst du evtl. spezielle Vorkehrungen in /var/db/dhcpd treffen?
 
Hallo,

ich habe jetzt eine weiter IP Adresse in rc.conf hinterlegt und jetzt bindet der Server diese Adresse und es läuft alles.

Danke Daniel
 
Back
Top