360 lines
9.5 KiB
Bash
360 lines
9.5 KiB
Bash
#!/bin/sh
|
|
#
|
|
# ipset Start and stop ipset firewall sets
|
|
#
|
|
# config: /etc/sysconfig/ipset-config
|
|
|
|
IPSET_BIN=/usr/sbin/ipset
|
|
IPSET_CONFIG=/etc/sysconfig/ipset-config
|
|
IPSET_DATA_COMPAT=/etc/sysconfig/ipset
|
|
IPSET_DATA_COMPAT_BACKUP=${IPSET_DATA_COMPAT}.save
|
|
IPSET_DATA_DIR=/etc/sysconfig/ipset.d
|
|
IPSET_DATA_DIR_BACKUP=${IPSET_DATA_DIR}.save
|
|
IPSET_DATA_SAVED_FLAG=${IPSET_DATA_DIR}/.saved
|
|
IPSET_LOCK=/run/ipset.lock
|
|
IPSET_RUN=/run/ipset.run
|
|
CLEAN_FILES=""
|
|
|
|
trap "rm -rf \${CLEAN_FILES}" EXIT
|
|
|
|
info() {
|
|
echo "ipset: ${*}" >&2
|
|
}
|
|
|
|
warn() {
|
|
echo "<4>ipset: ${*}" >&2
|
|
}
|
|
|
|
err() {
|
|
echo "<3>ipset: ${*}" >&2
|
|
}
|
|
|
|
[ -x ${IPSET_BIN} ] || { err "Cannot execute ${IPSET_BIN}"; exit 1; }
|
|
|
|
# Source ipset configuration
|
|
# shellcheck source=ipset-config
|
|
[ -f ${IPSET_CONFIG} ] && . ${IPSET_CONFIG}
|
|
|
|
set -f
|
|
|
|
lock() {
|
|
CLEAN_FILES="${CLEAN_FILES} ${IPSET_LOCK}"
|
|
until mkdir ${IPSET_LOCK} 2>/dev/null; do :; done
|
|
}
|
|
|
|
save() {
|
|
fail=0
|
|
|
|
# Make backups of existing configuration first, if any
|
|
[ -d ${IPSET_DATA_DIR} ] && mv -Tf ${IPSET_DATA_DIR} ${IPSET_DATA_DIR_BACKUP}
|
|
[ -f ${IPSET_DATA_COMPAT} ] && mv -Tf ${IPSET_DATA_COMPAT} ${IPSET_DATA_COMPAT_BACKUP}
|
|
|
|
rm -f ${IPSET_DATA_SAVED_FLAG}
|
|
|
|
# Save each set in a separate file
|
|
mkdir -p ${IPSET_DATA_DIR}
|
|
chmod 0700 ${IPSET_DATA_DIR}
|
|
IFS="
|
|
"
|
|
for set in $(${IPSET_BIN} list -n -t); do
|
|
# Empty name allowed, use ".set" as suffix. 'ipset save' doesn't
|
|
# quote set names with spaces: if we have a space in the name,
|
|
# work around this by quoting it ourselves in the output.
|
|
# shellcheck disable=SC2003 # No POSIX equivalent to expr index
|
|
if expr index "${set}" " " >/dev/null; then
|
|
:> "${IPSET_DATA_DIR}/${set}.set"
|
|
for line in $(${IPSET_BIN} save "${set}"); do
|
|
create=0
|
|
echo "${line}" | grep -q "^create " && create=1
|
|
if [ $create -eq 1 ]; then
|
|
line=${line#create *}
|
|
else
|
|
line=${line#add *}
|
|
fi
|
|
line=${line#${set} *}
|
|
set="$(echo "${set}" | sed 's/"/\\"/g')"
|
|
if [ $create -eq 1 ]; then
|
|
echo "create \"${set}\" ${line}" >> "${IPSET_DATA_DIR}/${set}.set"
|
|
else
|
|
echo "add \"${set}\" ${line}" >> "${IPSET_DATA_DIR}/${set}.set"
|
|
fi
|
|
done
|
|
else
|
|
${IPSET_BIN} save "${set}" > "${IPSET_DATA_DIR}/${set}.set" || fail=1
|
|
fi
|
|
[ -f "${IPSET_DATA_DIR}/${set}.set" ] && chmod 600 "${IPSET_DATA_DIR}/${set}.set"
|
|
[ $fail -eq 1 ] && err "Cannot save set ${set}" && unset IFS && return 1
|
|
done
|
|
touch ${IPSET_DATA_SAVED_FLAG} || { unset IFS; return 1; }
|
|
unset IFS
|
|
|
|
# Done: remove backups
|
|
rm -rf ${IPSET_DATA_DIR_BACKUP}
|
|
rm -rf ${IPSET_DATA_COMPAT_BACKUP}
|
|
|
|
return 0
|
|
}
|
|
|
|
# Generate a grep regexp matching abbreviated command forms. E.g., for create:
|
|
# \(c\|cr\|cre\|crea\|creat\|create\)
|
|
cmd_short_expr() {
|
|
out=
|
|
cmd_len=1
|
|
while [ "${cmd_len}" -le "${#1}" ]; do
|
|
[ -z "${out}" ] && out='\(' || out="${out}"'\|'
|
|
# shellcheck disable=SC2003 # No POSIX equivalent to expr substr
|
|
out="${out}$(expr substr "${1}" 1 "${cmd_len}")"
|
|
cmd_len=$((cmd_len + 1))
|
|
done
|
|
echo "${out}"'\)'
|
|
}
|
|
|
|
ipset_restore() {
|
|
file="${1}"
|
|
|
|
retfile="$(mktemp -q /tmp/ipset.XXXXXX)"
|
|
CLEAN_FILES="${CLEAN_FILES} ${retfile}"
|
|
|
|
# If restore fails due to invalid lines, remove them and retry
|
|
while ! restore_err="$( (${IPSET_BIN} -f "${file}" -! restore 2>&1; echo $? >"${retfile}") | head -n1; exit "$(cat "${retfile}")" )"; do
|
|
warn "${restore_err}"
|
|
case ${restore_err#*: } in
|
|
"No command specified"*)
|
|
line="$(grep -m1 -n "^${restore_err##* }" "${file}")"
|
|
line="${line%:*}"
|
|
;;
|
|
"Missing second mandatory argument to command "*)
|
|
cmd="${restore_err##* }"
|
|
cmd_expr="$(cmd_short_expr "${cmd}")"
|
|
line="$(grep -n '^'"${cmd_expr}" "${file}" | grep -m1 -v '^[0-9]\+\:'"${cmd_expr}"'[[:blank:]]\+[^[:blank:]]\+[[:blank:]]\+[^[:blank:]]\+')"
|
|
line="${line%:*}"
|
|
;;
|
|
"Missing mandatory argument to command "*)
|
|
cmd="${restore_err##* }"
|
|
cmd_expr="$(cmd_short_expr "${cmd}")"
|
|
line="$(grep -n '^'"${cmd_expr}" "${file}" | grep -m1 -v '^[0-9]\+\:'"${cmd_expr}"'[[:blank:]]\+[^[:blank:]]\+')"
|
|
line="${line%:*}"
|
|
;;
|
|
"Command "*"is invalid in restore mode"*)
|
|
restore_err_cmd="${restore_err#*: }"
|
|
restore_err_cmd="${restore_err_cmd#*\`}"
|
|
restore_err_cmd="${restore_err_cmd%%\'*}"
|
|
cmd="${restore_err_cmd##* }"
|
|
cmd_expr="$(cmd_short_expr "${cmd}")"
|
|
line="$(grep -m1 -ne '^'"${cmd_expr}"'[[:blank:]]\+' -e '^'"${restore_err_cmd}"'$' "${file}")"
|
|
line="${line%:*}"
|
|
;;
|
|
"Error in line "*)
|
|
line="${restore_err%: *}"
|
|
line="${line##* }"
|
|
;;
|
|
*)
|
|
rm "${retfile}"
|
|
CLEAN_FILES="${CLEAN_FILES%* ${retfile}}"
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
[ -z "${line}" ] && return 1
|
|
|
|
warn "Skipped invalid entry: $(sed "${line}q;d" "${file}")"
|
|
sed -i -e "${line}d" "${file}"
|
|
|
|
[ -s "${file}" ] || return 1
|
|
done
|
|
|
|
rm "${retfile}"
|
|
CLEAN_FILES="${CLEAN_FILES%* ${retfile}}"
|
|
}
|
|
|
|
load() {
|
|
if [ -f ${IPSET_DATA_SAVED_FLAG} ]; then
|
|
# If we have a cleanly saved directory with all sets, we can
|
|
# delete any left-overs and use it
|
|
rm -rf ${IPSET_DATA_DIR_BACKUP}
|
|
rm -f ${IPSET_DATA_COMPAT_BACKUP}
|
|
else
|
|
# If sets weren't cleanly saved, restore from backups
|
|
[ -d ${IPSET_DATA_DIR_BACKUP} ] && rm -rf ${IPSET_DATA_DIR} && mv -Tf ${IPSET_DATA_DIR_BACKUP} ${IPSET_DATA_DIR}
|
|
[ -f ${IPSET_DATA_COMPAT_BACKUP} ] && rm -f ${IPSET_DATA_COMPAT} && mv -Tf ${IPSET_DATA_COMPAT_BACKUP} ${IPSET_DATA_COMPAT}
|
|
fi
|
|
|
|
if [ ! -d ${IPSET_DATA_DIR} ] && [ ! -f ${IPSET_DATA_COMPAT} ]; then
|
|
info "No existing configuration available, none loaded"
|
|
touch ${IPSET_RUN}
|
|
return
|
|
fi
|
|
|
|
# Merge all sets into temporary file
|
|
merged="$(mktemp -q /tmp/ipset.XXXXXX)"
|
|
CLEAN_FILES="${CLEAN_FILES} ${merged}"
|
|
chmod 600 "${merged}"
|
|
set +f
|
|
if [ -d ${IPSET_DATA_DIR} ]; then
|
|
# Copy create commands from each saved set first, then the rest:
|
|
# list:set entries depend on other sets, so make sure they all
|
|
# get created first
|
|
for f in "${IPSET_DATA_DIR}"/*; do
|
|
[ "${f}" = "${IPSET_DATA_DIR}/*" ] && break
|
|
[ -f "${f}" ] || continue
|
|
grep '^c' "${f}" >> "${merged}"
|
|
done
|
|
for f in "${IPSET_DATA_DIR}"/*; do
|
|
[ "${f}" = "${IPSET_DATA_DIR}/*" ] && break
|
|
[ -f "${f}" ] || continue
|
|
grep -v '^c' "${f}" >> "${merged}"
|
|
done
|
|
fi
|
|
set -f
|
|
[ -f ${IPSET_DATA_COMPAT} ] && cat ${IPSET_DATA_COMPAT} >> "${merged}"
|
|
|
|
# Drop sets that aren't in saved data, mark conflicts with existing sets
|
|
conflicts=""
|
|
IFS="
|
|
"
|
|
for set in $(${IPSET_BIN} list -n -t); do
|
|
grep -q "^create ${set} " "${merged}" && conflicts="${conflicts}|${set}" && continue
|
|
|
|
# We can't destroy the set if it's in use, flush it instead
|
|
if ! ${IPSET_BIN} destroy "${set}" 2>/dev/null; then
|
|
${IPSET_BIN} flush "${set}"
|
|
fi
|
|
done
|
|
unset IFS
|
|
conflicts="${conflicts#|*}"
|
|
|
|
# Common case: if we have no conflicts, just restore in one shot
|
|
if [ -z "${conflicts}" ]; then
|
|
if ! ipset_restore "${merged}"; then
|
|
err "Failed to restore configured sets"
|
|
exit 1
|
|
fi
|
|
rm "${merged}"
|
|
CLEAN_FILES="${CLEAN_FILES%* ${merged}}"
|
|
touch ${IPSET_RUN}
|
|
return
|
|
fi
|
|
|
|
# Find a salt for md5sum that makes names of saved sets unique
|
|
salt=0
|
|
while true; do
|
|
unique=1
|
|
IFS="
|
|
"
|
|
for set in $(${IPSET_BIN} list -n -t); do
|
|
if grep -q "^create $(echo "${salt}${set}" | md5sum | head -c31) " "${merged}"; then
|
|
unique=0
|
|
break
|
|
fi
|
|
done
|
|
unset IFS
|
|
[ ${unique} -eq 1 ] && break
|
|
salt=$((salt + 1))
|
|
done
|
|
|
|
# Add sets, mangling names for conflicting sets
|
|
mangled="$(mktemp -q /tmp/ipset.XXXXXX)"
|
|
CLEAN_FILES="${CLEAN_FILES} ${mangled}"
|
|
chmod 600 "${mangled}"
|
|
|
|
cat "${merged}" > "${mangled}"
|
|
IFS='|'
|
|
for set in ${conflicts}; do
|
|
new_name=$(echo "${salt}${set}" | md5sum | head -c31)
|
|
echo "s/^(add|create) $set /\1 $new_name /"
|
|
done | sed -i -r -f - "${mangled}"
|
|
unset IFS
|
|
if ! ipset_restore "${mangled}"; then
|
|
err "Failed to restore configured sets"
|
|
exit 1
|
|
fi
|
|
|
|
rm "${mangled}"
|
|
CLEAN_FILES="${CLEAN_FILES%* ${mangled}}"
|
|
|
|
# Swap and delete old sets
|
|
IFS='|'
|
|
for set in ${conflicts}; do
|
|
mangled="$(echo "${salt}${set}" | md5sum | head -c31)"
|
|
if ! ${IPSET_BIN} swap "${set}" "${mangled}" 2>/dev/null; then
|
|
# This fails if set types are different: try to destroy
|
|
# existing set
|
|
if ! ${IPSET_BIN} destroy "${set}" 2>/dev/null; then
|
|
# Conflicting set is in use, we can only warn
|
|
# and flush the existing set
|
|
err "Cannot load set \"${set}\", set with same name and conflicting type in use"
|
|
${IPSET_BIN} flush "${set}"
|
|
${IPSET_BIN} destroy "${mangled}"
|
|
else
|
|
${IPSET_BIN} rename "${mangled}" "${set}"
|
|
fi
|
|
else
|
|
${IPSET_BIN} destroy "${mangled}"
|
|
fi
|
|
done
|
|
unset IFS
|
|
|
|
rm "${merged}"
|
|
CLEAN_FILES="${CLEAN_FILES%* ${merged}}"
|
|
touch ${IPSET_RUN}
|
|
}
|
|
|
|
cleanup() {
|
|
${IPSET_BIN} flush || err "Failed to flush sets"
|
|
|
|
# Try to destroy all sets at once. This will fail if some are in use,
|
|
# destroy all the other ones in that case
|
|
${IPSET_BIN} destroy 2>/dev/null && return
|
|
IFS="
|
|
"
|
|
for set in $(${IPSET_BIN} list -n -t); do
|
|
if ! ${IPSET_BIN} destroy "${set}"; then
|
|
err "Failed to destroy set ${set}"
|
|
fi
|
|
done
|
|
unset IFS
|
|
}
|
|
|
|
stop() {
|
|
[ -f ${IPSET_RUN} ] || { info "Not running"; return 0; }
|
|
[ "${IPSET_SAVE_ON_STOP}" = "yes" ] && { save || err "Failed to save sets"; }
|
|
|
|
# Nothing to stop if the ip_set module is not loaded
|
|
lsmod | grep -q "^ip_set " || { info "Not running"; rm ${IPSET_RUN}; return 0; }
|
|
|
|
# If the xt_set module is in use, then iptables is using ipset, so
|
|
# refuse to stop the service
|
|
if mod="$(lsmod | grep ^xt_set)"; then
|
|
if [ "$(echo "${mod}" | tr -s ' ' | cut -d' ' -f3)" != "0" ]; then
|
|
err "Current iptables configuration requires ipset" && return 1
|
|
fi
|
|
fi
|
|
|
|
cleanup
|
|
|
|
rm ${IPSET_RUN}
|
|
return 0
|
|
}
|
|
|
|
lock
|
|
case "$1" in
|
|
start)
|
|
load
|
|
;;
|
|
stop)
|
|
stop
|
|
;;
|
|
reload)
|
|
cleanup
|
|
load
|
|
;;
|
|
save)
|
|
save
|
|
;;
|
|
*)
|
|
info "Usage: $0 {start|stop|reload|save}"
|
|
exit 1
|
|
esac
|
|
|
|
exit $?
|