662 lines
22 KiB
Bash
Executable file
662 lines
22 KiB
Bash
Executable file
#!/bin/sh
|
|
#
|
|
# bkctld is a shell script to create and manage a backup server which will
|
|
# handle the backup of many servers (clients).
|
|
#
|
|
# Author: Victor Laborie <vlaborie@evolix.fr>
|
|
# Contributor: Benoît Série <bserie@evolix.fr>, Gregory Colpart <reg@evolix.fr>, Romain Dessort <rdessort@evolix.fr>, Tristan Pilat <tpilat@evolix.fr>
|
|
# Licence: AGPLv3
|
|
#
|
|
|
|
set -u
|
|
|
|
usage(){
|
|
cat <<EOF
|
|
Usage: $0 <subcommand> [options]
|
|
Subcommands:
|
|
init <jailname> Init jail <jailname>
|
|
update <jailname>|all Update jail <jailname> or all
|
|
remove <jailname>|all Remove jail <jailname> or all
|
|
start <jailname>|all Start jail <jailname> or all
|
|
stop <jailname>|all Stop jail <jailname> or all
|
|
reload <jailname>|all Reload jail <jailname> or all
|
|
restart <jailname>|all Restart jail <jailname> or all
|
|
sync <jailname>|all Sync jail <jailname> or all to another node
|
|
status [<jailname>] Print status of <jailname> (default all jail)
|
|
key <jailname> [<keyfile>] Set or get ssh pubic key of <jailname>
|
|
port <jailname> [<port>|auto] Set or get ssh port of <jailname>
|
|
ip <jailname> [<ip>|all] Set or get allowed(s) ip(s) of <jailname>
|
|
inc Make incremental inc of all jails
|
|
rm Remove old incremtal inc of all jails
|
|
check Run check on jails (NRPE output)
|
|
stats Make and display stats on jails (size, lastconn)
|
|
|
|
EOF
|
|
}
|
|
|
|
## logging functions
|
|
|
|
debug() {
|
|
msg="${1:-$(cat /dev/stdin)}"
|
|
if [ "${LOGLEVEL}" -ge 7 ]; then
|
|
echo "${msg}"
|
|
logger -t bkctld -p daemon.debug "${msg}"
|
|
fi
|
|
}
|
|
|
|
info() {
|
|
msg="${1:-$(cat /dev/stdin)}"
|
|
if [ "${LOGLEVEL}" -ge 6 ]; then
|
|
tty -s && echo "${msg}"
|
|
logger -t bkctld -p daemon.info "${msg}"
|
|
fi
|
|
}
|
|
|
|
notice() {
|
|
msg="${1:-$(cat /dev/stdin)}"
|
|
tty -s && echo "${msg}"
|
|
[ "${LOGLEVEL}" -ge 5 ] && logger -t bkctld -p daemon.notice "${msg}"
|
|
}
|
|
|
|
warning() {
|
|
msg="${1:-$(cat /dev/stdin)}"
|
|
tty -s && echo "WARNING : ${msg}" >&2
|
|
if [ "${LOGLEVEL}" -ge 4 ]; then
|
|
tty -s || echo "WARNING : ${msg}" >&2
|
|
logger -t bkctld -p daemon.warning "${msg}"
|
|
fi
|
|
}
|
|
|
|
error() {
|
|
msg="${1:-$(cat /dev/stdin)}"
|
|
tty -s && echo "ERROR : ${msg}" >&2
|
|
if [ "${LOGLEVEL}" -ge 5 ]; then
|
|
tty -s || echo "ERROR : ${msg}" >&2
|
|
logger -t bkctld -p daemon.error "${msg}"
|
|
fi
|
|
exit 1
|
|
}
|
|
|
|
## check functions
|
|
|
|
check_jail() {
|
|
jail="${1}"
|
|
[ -d "${JAILDIR}/${jail}" ] && return 0
|
|
return 1
|
|
}
|
|
|
|
check_jail_on() {
|
|
jail="${1}"
|
|
return=1
|
|
if [ -f "${JAILDIR}/${jail}/${SSHD_PID}" ]; then
|
|
pid=$(cat "${JAILDIR}/${jail}/${SSHD_PID}")
|
|
ps -p "${pid}" > /dev/null && return=0
|
|
fi
|
|
if [ "${return}" -eq 1 ]; then
|
|
rm -f "${JAILDIR}/${jail}/${SSHD_PID}"
|
|
grep -q "${JAILDIR}/${jail}/proc" /proc/mounts && umount --lazy "${JAILDIR}/${jail}/proc/"
|
|
grep -q "${JAILDIR}/${jail}/dev" /proc/mounts && umount --lazy --recursive "${JAILDIR}/${jail}/dev"
|
|
fi
|
|
return "${return}"
|
|
}
|
|
|
|
## get functions : get info on jail
|
|
|
|
get_port() {
|
|
jail="${1}"
|
|
port=$(grep -E "Port [0-9]+" "${JAILDIR}/${jail}/${SSHD_CONFIG}"|grep -oE "[0-9]+")
|
|
echo "${port}"
|
|
}
|
|
|
|
get_key() {
|
|
jail="${1}"
|
|
if [ -f "${JAILDIR}/${jail}/${AUTHORIZED_KEYS}" ]; then
|
|
cat "${JAILDIR}/${jail}/${AUTHORIZED_KEYS}"
|
|
fi
|
|
}
|
|
|
|
get_ip() {
|
|
jail="${1}"
|
|
grep -E "^AllowUsers" "${JAILDIR}/$jail/${SSHD_CONFIG}"|grep -Eo "root@[^ ]+"| while read allow; do
|
|
echo "${allow}"|cut -d'@' -f2
|
|
done
|
|
}
|
|
|
|
get_inc() {
|
|
jail="${1}"
|
|
inc="0"
|
|
if [ -f "${CONFDIR}/${jail}" ]; then
|
|
day=$(grep -c "day" "${CONFDIR}/${jail}")
|
|
month=$(grep -c "month" "${CONFDIR}/${jail}")
|
|
inc="${day}/${month}"
|
|
fi
|
|
echo "${inc}"
|
|
}
|
|
|
|
## set functions : set info on jail
|
|
|
|
set_port() {
|
|
jail="${1}"
|
|
port="${2}"
|
|
if [ "${port}" = "auto" ]; then
|
|
port=$(grep -h Port "${JAILDIR}"/*/"${SSHD_CONFIG}" 2>/dev/null | grep -Eo "[0-9]+" | sort -n | tail -1)
|
|
port=$((port+1))
|
|
[ "${port}" -le 1 ] && port=2222
|
|
fi
|
|
sed -i "s/^Port .*/Port ${port}/" "${JAILDIR}/$jail/${SSHD_CONFIG}"
|
|
set_firewall "${jail}"
|
|
}
|
|
|
|
set_key() {
|
|
jail="${1}"
|
|
keyfile="${2}"
|
|
[ -e "${keyfile}" ] || error "Keyfile ${keyfile} dosen't exist !"
|
|
cat "${keyfile}" > "${JAILDIR}/${jail}/${AUTHORIZED_KEYS}"
|
|
chmod 600 "${JAILDIR}/${jail}/${AUTHORIZED_KEYS}"
|
|
}
|
|
|
|
set_ip() {
|
|
jail="${1}"
|
|
ip="${2}"
|
|
if [ "${ip}" = "all" ] || [ "${ip}" = "0.0.0.0/0" ]; then
|
|
ips="0.0.0.0/0"
|
|
else
|
|
ips=$(get_ip "${jail}")
|
|
ips=$(echo "${ips}" "${ip}"|xargs -n1|grep -v "0.0.0.0/0"|sort|uniq)
|
|
fi
|
|
allow="AllowUsers"
|
|
for ip in $ips; do
|
|
allow="${allow} root@${ip}"
|
|
done
|
|
sed -i "s~^AllowUsers .*~${allow}~" "${JAILDIR}/$jail/${SSHD_CONFIG}"
|
|
set_firewall "${jail}"
|
|
}
|
|
|
|
set_firewall() {
|
|
jail="${1}"
|
|
if [ -n "${FIREWALL_RULES}" ]; then
|
|
if [ -f "${FIREWALL_RULES}" ]; then
|
|
sed -i "/#${jail}$/d" "${FIREWALL_RULES}"
|
|
fi
|
|
if ( check_jail "${jail}" ); then
|
|
port=$(get_port "${jail}")
|
|
for ip in $(get_ip "${jail}"); do
|
|
echo "/sbin/iptables -A INPUT -p tcp --sport 1024: --dport ${port} -s ${ip} -j ACCEPT #${jail}" >> "${FIREWALL_RULES}"
|
|
done
|
|
if [ -f /etc/init.d/minifirewall ]; then
|
|
/etc/init.d/minifirewall restart >/dev/null
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
## mk_jail function : create or update a jail
|
|
|
|
mk_jail() {
|
|
jail="${1}"
|
|
passwd="${TPLDIR}/passwd"
|
|
shadow="${TPLDIR}/shadow"
|
|
group="${TPLDIR}/group"
|
|
sshrc="${TPLDIR}/sshrc"
|
|
[ -f "${LOCALTPLDIR}/passwd" ] && passwd="${LOCALTPLDIR}/passwd"
|
|
[ -f "${LOCALTPLDIR}/shadow" ] && shadow="${LOCALTPLDIR}/shadow"
|
|
[ -f "${LOCALTPLDIR}/group" ] && group="${LOCALTPLDIR}/group"
|
|
[ -f "${LOCALTPLDIR}/sshrc" ] && group="${LOCALTPLDIR}/sshrc"
|
|
umask 077
|
|
|
|
info "1 - Creating the chroot"
|
|
cd "${JAILDIR}/${jail}"
|
|
rm -rf bin lib lib64 run usr var/run etc/ssh/*key
|
|
mkdir -p dev proc
|
|
mkdir -p usr/bin usr/sbin usr/lib usr/lib/x86_64-linux-gnu usr/lib/openssh usr/lib64
|
|
mkdir -p etc/ssh var/log run/sshd
|
|
mkdir -p root/.ssh var/backup -m 0700
|
|
ln -s usr/bin bin
|
|
ln -s usr/lib lib
|
|
ln -s usr/lib64 lib64
|
|
ln -st var ../run
|
|
touch var/log/lastlog var/log/wtmp run/utmp
|
|
|
|
info "2 - Copying essential files"
|
|
[ -f /etc/ssh/ssh_host_rsa_key ] && cp /etc/ssh/ssh_host_rsa_key etc/ssh
|
|
[ -f /etc/ssh/ssh_host_ecdsa_key ] && cp /etc/ssh/ssh_host_ecdsa_key etc/ssh
|
|
[ -f /etc/ssh/ssh_host_ed25519_key ] && cp /etc/ssh/ssh_host_ed25519_key etc/ssh
|
|
cp "${passwd}" etc
|
|
cp "${shadow}" etc
|
|
cp "${group}" etc
|
|
cp "${sshrc}" etc/ssh
|
|
|
|
info "3 - Copying binaries"
|
|
cp -f /lib/ld-linux.so.2 lib 2>/dev/null || cp -f /lib64/ld-linux-x86-64.so.2 lib64
|
|
cp /lib/x86_64-linux-gnu/libnss* lib/x86_64-linux-gnu
|
|
|
|
for dbin in /bin/sh /bin/ls /bin/mkdir /bin/cat /bin/rm /bin/sed /usr/bin/rsync /usr/bin/lastlog /usr/bin/touch /usr/sbin/sshd /usr/lib/openssh/sftp-server; do
|
|
cp -f "${dbin}" "${JAILDIR}/${jail}/${dbin}";
|
|
for lib in $(ldd "${dbin}" | grep -Eo "/.*so.[0-9\.]+"); do
|
|
cp -p "${lib}" "${JAILDIR}/${jail}/${lib}"
|
|
done
|
|
done
|
|
}
|
|
|
|
## sub functions : functions call by subcommand
|
|
|
|
sub_init() {
|
|
jail="${1}"
|
|
sshd_config="${TPLDIR}/sshd_config"
|
|
inctpl="${TPLDIR}/inc.tpl"
|
|
[ -f "${LOCALTPLDIR}/sshd_config" ] && sshd_config="${LOCALTPLDIR}/sshd_config"
|
|
[ -f "${LOCALTPLDIR}/inc.tpl" ] && inctpl="${LOCALTPLDIR}/inc.tpl"
|
|
check_jail "${jail}" && error "${jail} : trying to create existant jail"
|
|
|
|
rootdir=$(dirname "${JAILDIR}")
|
|
rootdir_inode=$(stat --format=%i "${rootdir}")
|
|
jaildir_inode=$(stat --format=%i "${JAILDIR}")
|
|
if [ "${rootdir_inode}" -eq 256 ] || [ "${jaildir_inode}" -eq 256 ]; then
|
|
/sbin/btrfs subvolume create "${JAILDIR}/${jail}"
|
|
else
|
|
mkdir -p "${JAILDIR}/${jail}"
|
|
fi
|
|
mk_jail "${jail}"
|
|
info "4 - Copie default sshd_config"
|
|
install -m 0640 "${sshd_config}" "${JAILDIR}/${jail}/${SSHD_CONFIG}"
|
|
info "5 - Set usable sshd port"
|
|
set_port "${jail}" auto
|
|
info "6 - Copie default inc configuration"
|
|
install -m 0640 "${inctpl}" "${CONFDIR}/${jail}"
|
|
notice "${jail} : created jail"
|
|
}
|
|
|
|
sub_update() {
|
|
jail="${1}"
|
|
check_jail "${jail}" || error "${jail} : trying to update inexistant jail"
|
|
check_jail_on "${jail}" && sub_stop "${jail}"
|
|
|
|
mk_jail "${jail}"
|
|
notice "${jail} : updated jail"
|
|
}
|
|
|
|
sub_remove() {
|
|
jail="${1}"
|
|
check_jail "${jail}" || error "${jail} : trying to remove inexistant jail"
|
|
|
|
check_jail_on "${jail}" && sub_stop "${jail}"
|
|
|
|
rm -f "${CONFDIR}/${jail}"
|
|
jail_inode=$(stat --format=%i "${JAILDIR}/${jail}")
|
|
if [ "${jail_inode}" -eq 256 ]; then
|
|
/sbin/btrfs subvolume delete "${JAILDIR}/${jail}" | debug
|
|
else
|
|
rm -rf "${JAILDIR}/${jail}" | debug
|
|
fi
|
|
if [ -d "${INCDIR}/${jail}" ]; then
|
|
incs=$(ls "${INCDIR}/${jail}")
|
|
for inc in ${incs}; do
|
|
inc_inode=$(stat --format=%i "${INCDIR}/${jail}/${inc}")
|
|
if [ "${inc_inode}" -eq 256 ]; then
|
|
/sbin/btrfs subvolume delete "${INCDIR}/${jail}/${inc}" | debug
|
|
else
|
|
warning "You need to purge ${INCDIR}/${jail}/${inc} manually !"
|
|
fi
|
|
done
|
|
rmdir --ignore-fail-on-non-empty "${INCDIR}/${jail}" | debug
|
|
fi
|
|
set_firewall "${jail}"
|
|
notice "${jail} : deleted jail"
|
|
}
|
|
|
|
sub_start() {
|
|
jail="${1}"
|
|
check_jail "${jail}" || error "${jail} : trying to start inexistant jail"
|
|
check_jail_on "${jail}" && error "${jail} : trying to start already running jail"
|
|
|
|
cd "${JAILDIR}/${jail}"
|
|
grep -q "${JAILDIR}/${jail}/proc" /proc/mounts || mount -t proc "proc-${jail}" proc
|
|
grep -q "${JAILDIR}/${jail}/dev" /proc/mounts || mount -nt tmpfs "dev-${jail}" dev
|
|
[ -e "dev/console" ] || mknod -m 622 dev/console c 5 1
|
|
[ -e "dev/null" ] || mknod -m 666 dev/null c 1 3
|
|
[ -e "dev/zero" ] || mknod -m 666 dev/zero c 1 5
|
|
[ -e "dev/ptmx" ] || mknod -m 666 dev/ptmx c 5 2
|
|
[ -e "dev/tty" ] || mknod -m 666 dev/tty c 5 0
|
|
[ -e "dev/random" ] || mknod -m 444 dev/random c 1 8
|
|
[ -e "dev/urandom" ] || mknod -m 444 dev/urandom c 1 9
|
|
chown root:tty dev/console dev/ptmx dev/tty
|
|
ln -fs proc/self/fd dev/fd
|
|
ln -fs proc/self/fd/0 dev/stdin
|
|
ln -fs proc/self/fd/1 dev/stdout
|
|
ln -fs proc/self/fd/2 dev/stderr
|
|
ln -fs proc/kcore dev/core
|
|
mkdir -p dev/pts
|
|
mkdir -p dev/shm
|
|
grep -q "${JAILDIR}/${jail}/dev/pts" /proc/mounts || mount -t devpts -o gid=4,mode=620 none dev/pts
|
|
grep -q "${JAILDIR}/${jail}/dev/shm" /proc/mounts || mount -t tmpfs none dev/shm
|
|
chroot "${JAILDIR}/${jail}" /usr/sbin/sshd -E /var/log/authlog || error "${jail} : error on starting sshd"
|
|
pid=$(cat "${JAILDIR}/${jail}/${SSHD_PID}")
|
|
notice "${jail} was started [${pid}]"
|
|
}
|
|
|
|
sub_stop() {
|
|
jail="${1}"
|
|
check_jail "${jail}" || error "${jail} : trying to stop inexistant jail"
|
|
check_jail_on "${jail}" || error "${jail} : trying to stop not running jail"
|
|
|
|
pid=$(cat "${JAILDIR}/${jail}/${SSHD_PID}")
|
|
for conn in $(ps --ppid "${pid}" -o pid=); do
|
|
kill "${conn}"
|
|
done
|
|
kill "${pid}" && notice "${jail} was stopped [${pid}]"
|
|
umount --lazy --recursive "${JAILDIR}/${jail}/dev"
|
|
umount --lazy "${JAILDIR}/${jail}/proc/"
|
|
}
|
|
|
|
sub_reload() {
|
|
jail="${1}"
|
|
check_jail "${jail}" || error "${jail} : trying to reload inexistant jail"
|
|
check_jail_on "${jail}" || error "${jail} : trying to reload not running jail"
|
|
|
|
pid=$(cat "${JAILDIR}/${jail}/${SSHD_PID}")
|
|
|
|
kill -HUP "${pid}" && notice "${jail} was reloaded [${pid}]"
|
|
}
|
|
|
|
sub_status() {
|
|
jail="${1}"
|
|
check_jail "${jail}" || error "${jail} : inexistant jail ! Use '$0 status' for list all"
|
|
|
|
inc=$(get_inc "${jail}")
|
|
if ( check_jail_on "${jail}" ); then
|
|
status="ON "
|
|
else
|
|
status="OFF"
|
|
fi
|
|
port=$(get_port "${jail}")
|
|
ip=$(get_ip "${jail}"|xargs|tr -s ' ' ',')
|
|
echo "${jail} ${status} ${port} ${inc} ${ip}" | awk '{ printf("%- 30s %- 10s %- 10s %- 10s %- 40s\n", $1, $2, $3, $4, $5); }'
|
|
}
|
|
|
|
sub_params() {
|
|
jail="${1}"
|
|
params="${2}"
|
|
option="${3}"
|
|
check_jail "${jail}" || error "${jail} : inexistant jail'"
|
|
|
|
if [ -z "${option}" ]; then
|
|
"get_${params}" "${jail}"
|
|
else
|
|
"set_${params}" "${jail}" "${option}"
|
|
check_jail_on "${jail}" && sub_reload "${jail}"
|
|
notice "${jail} : update ${params} => ${option}"
|
|
fi
|
|
}
|
|
|
|
sub_sync() {
|
|
jail="${1}"
|
|
check_jail "${jail}" || error "${jail} : trying to sync inexistant jail"
|
|
|
|
[ -n "${NODE}" ] || error "Sync need config of \$NODE in /etc/default/bkctld !"
|
|
|
|
jail="${1}"
|
|
ssh "${NODE}" bkctld init "${jail}" | debug
|
|
rsync -a "${JAILDIR}/${jail}/" "${NODE}:${JAILDIR}/${jail}/" --exclude proc/* --exclude sys/* --exclude dev/* --exclude run --exclude var/backup/*
|
|
rsync -a "${CONFDIR}/${jail}" "${NODE}:${CONFDIR}/${jail}"
|
|
if ( check_jail_on "${jail}" ); then
|
|
ssh "${NODE}" bkctld start "${jail}" | debug
|
|
fi
|
|
if [ -n "${FIREWALL_RULES}" ]; then
|
|
rsync -a "${FIREWALL_RULES}" "${NODE}:${FIREWALL_RULES}"
|
|
ssh "${NODE}" /etc/init.d/minifirewall restart | debug
|
|
fi
|
|
}
|
|
|
|
sub_inc() {
|
|
date=$(date +"%Y-%m-%d-%H")
|
|
jails=$(ls "${JAILDIR}")
|
|
for jail in ${jails}; do
|
|
inc="${INCDIR}/${jail}/${date}"
|
|
mkdir -p "${INCDIR}/${jail}"
|
|
if [ ! -d "${inc}" ]; then
|
|
start=$(date +"%H:%M:%S")
|
|
jail_inode=$(stat --format=%i "${JAILDIR}/${jail}")
|
|
if [ "$jail_inode" -eq 256 ]; then
|
|
/sbin/btrfs subvolume snapshot -r "${JAILDIR}/${jail}" "${inc}" | debug
|
|
else
|
|
cp -alx "${JAILDIR}/${jail}/" "${inc}" | debug
|
|
fi
|
|
end=$(date +"%H:%M:%S")
|
|
notice "${jail} : made ${date} inc [${start}/${end}]"
|
|
else
|
|
warning "${jail} : trying to made already existant inc"
|
|
fi
|
|
done
|
|
}
|
|
|
|
sub_rm() {
|
|
empty="/tmp/bkctld-${$}-$(date +%N))"
|
|
mkdir "${empty}"
|
|
pidfile="/var/run/bkctld-rm.pid"
|
|
if [ -f "${pidfile}" ]; then
|
|
pid=$(cat "${pidfile}")
|
|
ps -u "${pid}" >/dev/null
|
|
if [ "${?}" -eq 0 ]; then
|
|
kill -9 "${pid}"
|
|
warning "${0} rm always run (PID ${pid}), killed by ${$} !"
|
|
fi
|
|
rm "${pidfile}"
|
|
fi
|
|
echo "${$}" > "${pidfile}"
|
|
jails=$(ls "${JAILDIR}")
|
|
for jail in ${jails}; do
|
|
incs=$(ls "${INCDIR}/${jail}")
|
|
if [ -f "${CONFDIR}/${jail}" ]; then
|
|
keepfile="${CONFDIR}/.keep-${jail}"
|
|
while read j; do
|
|
date=$( echo "${j}" | cut -d. -f1 )
|
|
before=$( echo "${j}" | cut -d. -f2 )
|
|
date -d "$(date "${date}") ${before}" "+%Y-%m-%d"
|
|
done < "${CONFDIR}/${jail}" > "${keepfile}"
|
|
for j in $(echo "${incs}" | grep -v -f "${keepfile}"); do
|
|
start=$(date +"%H:%M:%S")
|
|
inc_inode=$(stat --format=%i "${INCDIR}/${jail}/${j}")
|
|
if [ "${inc_inode}" -eq 256 ]; then
|
|
/sbin/btrfs subvolume delete "${INCDIR}/${jail}/${j}" | debug
|
|
else
|
|
cd "${INCDIR}/${jail}"
|
|
rsync -a --delete "${empty}/" "${j}/"
|
|
rmdir "${j}"
|
|
fi
|
|
end=$(date +"%H:%M:%S")
|
|
notice "${jail} : deleted ${j} inc [${start}/${end}]"
|
|
done
|
|
fi
|
|
done
|
|
rmdir "${empty}"
|
|
rm "${pidfile}"
|
|
}
|
|
|
|
sub_check() {
|
|
cur_time=$(date "+%s")
|
|
return=0
|
|
nb_crit=0
|
|
nb_warn=0
|
|
nb_ok=0
|
|
nb_unkn=0
|
|
output=""
|
|
|
|
if [ -b "${BACKUP_DISK}" ]; then
|
|
cryptsetup isLuks "${BACKUP_DISK}"
|
|
if [ "$?" -eq 0 ]; then
|
|
if [ ! -b '/dev/mapper/backup' ]; then
|
|
echo "Luks disk ${BACKUP_DISK} is not mounted !\n"
|
|
echo "cryptsetup luksOpen ${BACKUP_DISK} backup"
|
|
exit 2
|
|
fi
|
|
BACKUP_DISK='/dev/mapper/backup'
|
|
fi
|
|
grep -qE "^${BACKUP_DISK} " /etc/mtab
|
|
if [ "$?" -ne 0 ]; then
|
|
echo "Backup disk ${BACKUP_DISK} is not mounted !\n"
|
|
echo "mount ${BACKUP_DISK} /backup"
|
|
exit 2
|
|
fi
|
|
fi
|
|
|
|
jails=$(ls "${JAILDIR}")
|
|
for jail in ${jails}; do
|
|
if [ -f "${JAILDIR}/${jail}/var/log/lastlog" ]; then
|
|
last_conn=$(stat --format=%Y "${JAILDIR}/${jail}/var/log/lastlog")
|
|
date_diff=$(( (cur_time - last_conn) / (60*60) ))
|
|
if [ "${date_diff}" -gt "${CRITICAL}" ]; then
|
|
nb_crit=$((nb_crit + 1))
|
|
output="${output}CRITICAL - ${jail} - ${date_diff} hours\n"
|
|
[ "${return}" -le 2 ] && return=2
|
|
elif [ "${date_diff}" -gt "${WARNING}" ]; then
|
|
nb_warn=$((nb_warn + 1))
|
|
output="${output}WARNING - ${jail} - ${date_diff} hours\n"
|
|
[ "${return}" -le 1 ] && return=1
|
|
else
|
|
nb_ok=$((nb_ok + 1))
|
|
output="${output}OK - ${jail} - ${date_diff} hours\n"
|
|
fi
|
|
else
|
|
nb_unkn=$((nb_unkn + 1))
|
|
output="${output}UNKNOWN - ${jail} doesn't have lastlog !\n"
|
|
[ "${return}" -le 3 ] && return=3
|
|
fi
|
|
done
|
|
|
|
[ "${return}" -ge 0 ] && header="OK"
|
|
[ "${return}" -ge 1 ] && header="WARNING"
|
|
[ "${return}" -ge 2 ] && header="CRITICAL"
|
|
[ "${return}" -ge 3 ] && header="UNKNOW"
|
|
|
|
printf "%s - %s UNK / %s CRIT / %s WARN / %s OK\n\n" "${header}" "${nb_unkn}" "${nb_crit}" "${nb_warn}" "${nb_ok}"
|
|
|
|
printf "${output}" | grep -E "^UNKNOW"
|
|
printf "${output}" | grep -E "^CRITICAL"
|
|
printf "${output}" | grep -E "^WARNING"
|
|
printf "${output}" | grep -E "^OK"
|
|
|
|
exit "${return}"
|
|
}
|
|
|
|
sub_stats() {
|
|
lsof "${IDX_FILE}" >/dev/null 2>&1 || nohup sh -s -- <<EOF >/dev/null 2>&1 &
|
|
ionice -c3 "${DUC}" index -d "${IDX_FILE}" "${JAILDIR}"
|
|
touch "${INDEX_DIR}/.lastrun.duc"
|
|
EOF
|
|
[ ! -f "${INDEX_DIR}/.lastrun.duc" ] && notice "First run of DUC always in progress ..." && exit 0
|
|
[ ! -f ${IDX_FILE} ] && error "Index file do not exits !"
|
|
printf "Last update of index file : "
|
|
stat --format=%Y "${INDEX_DIR}/.lastrun.duc" | xargs -i -n1 date -R -d "@{}"
|
|
echo "<jail> <size> <incs> <lastconn>" | awk '{ printf("%- 30s %- 10s %- 10s %- 15s\n", $1, $2, $3, $4); }'
|
|
duc_output=$(mktemp)
|
|
stat_output=$(mktemp)
|
|
incs_output=$(mktemp)
|
|
trap "rm ${duc_output} ${incs_output} ${stat_output}" 0
|
|
"${DUC}" ls -d "${IDX_FILE}" "${JAILDIR}" > "${duc_output}"
|
|
awk '{ print $2 }' "${duc_output}" | while read jail; do
|
|
stat --format=%Y "/backup/jails/${jail}/var/log/lastlog" | xargs -i -n1 date -d "@{}" "+%d-%m-%Y" >> "${stat_output}"
|
|
get_inc "${jail}" >> "${incs_output}"
|
|
done
|
|
paste "${duc_output}" "${incs_output}" "${stat_output}" | awk '{ printf("%- 30s %- 10s %- 10s %- 15s\n", $2, $1, $3, $4); }'
|
|
}
|
|
|
|
## main function : check usage and valid params
|
|
|
|
main() {
|
|
[ "$(id -u)" -ne 0 ] && error "You need to be root to run ${0} !"
|
|
|
|
[ -f /etc/default/bkctld ] && . /etc/default/bkctld
|
|
CONFDIR="${CONFDIR:-/etc/evobackup}"
|
|
BACKUP_DISK="${BACKUP_DISK:-}"
|
|
JAILDIR="${JAILDIR:-/backup/jails}"
|
|
INCDIR="${INCDIR:-/backup/incs}"
|
|
TPLDIR="${TPLDIR:-/usr/share/bkctld}"
|
|
INDEX_DIR="${INDEX_DIR:-/backup/index}"
|
|
IDX_FILE="${IDX_FILE:-${INDEX_DIR}/bkctld-jails.idx}"
|
|
LOCALTPLDIR="${LOCALTPLDIR:-/usr/local/share/bkctld}"
|
|
SSHD_PID="${SSHD_PID:-/run/sshd.pid}"
|
|
SSHD_CONFIG="${SSHD_CONFIG:-/etc/ssh/sshd_config}"
|
|
AUTHORIZED_KEYS="${AUTHORIZED_KEYS:-/root/.ssh/authorized_keys}"
|
|
FIREWALL_RULES="${FIREWALL_RULES:-}"
|
|
LOGLEVEL="${LOGLEVEL:-6}"
|
|
CRITICAL="${CRITICAL:-48}"
|
|
WARNING="${WARNING:-24}"
|
|
DUC=$(command -v duc-nox||command -v duc)
|
|
mkdir -p "${CONFDIR}" "${JAILDIR}" "${INCDIR}" "${INDEX_DIR}"
|
|
subcommand="${1:-}"
|
|
jail="${2:-}"
|
|
option="${3:-}"
|
|
case "${subcommand}" in
|
|
"" | "-h" | "--help")
|
|
usage
|
|
;;
|
|
"inc" | "rm" | "check" | "stats")
|
|
"sub_${subcommand}"
|
|
;;
|
|
"init")
|
|
if [ -n "${jail}" ]; then
|
|
"sub_${subcommand}" "${jail}"
|
|
else
|
|
usage
|
|
fi
|
|
;;
|
|
"key" | "port" | "ip")
|
|
if [ -n "${jail}" ]; then
|
|
sub_params "${jail}" "${subcommand}" "${option}"
|
|
else
|
|
usage
|
|
fi
|
|
;;
|
|
"start" | "stop" | "reload" | "restart" | "sync" | "update" | "remove")
|
|
if [ -n "${jail}" ]; then
|
|
if [ "${jail}" = "all" ]; then
|
|
jails=$(ls "${JAILDIR}")
|
|
for jail in ${jails}; do
|
|
case "${subcommand}" in
|
|
"start")
|
|
check_jail_on "${jail}" || "sub_${subcommand}" "${jail}"
|
|
;;
|
|
"stop" | "reload")
|
|
check_jail_on "${jail}" && "sub_${subcommand}" "${jail}"
|
|
;;
|
|
"restart")
|
|
check_jail_on "${jail}" && sub_stop "${jail}"
|
|
sub_start "${jail}"
|
|
;;
|
|
*)
|
|
"sub_${subcommand}" "${jail}"
|
|
;;
|
|
esac
|
|
done
|
|
else
|
|
if [ "${subcommand}" != "restart" ]; then
|
|
"sub_${subcommand}" "${jail}"
|
|
else
|
|
check_jail_on "${jail}" && sub_stop "${jail}"
|
|
sub_start "${jail}"
|
|
fi
|
|
fi
|
|
else
|
|
usage
|
|
fi
|
|
;;
|
|
"status")
|
|
if [ -z "${jail}" ]; then
|
|
jails=$(ls "${JAILDIR}")
|
|
for jail in ${jails}; do
|
|
"sub_${subcommand}" "${jail}"
|
|
done
|
|
else
|
|
"sub_${subcommand}" "${jail}"
|
|
fi
|
|
;;
|
|
*)
|
|
shift
|
|
warning "'${subcommand}' is not a known subcommand." && usage
|
|
exit 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
main "${@}"
|