#
# Shorewall 4.5 -- /usr/share/shorewall/lib.common.
#
#     (c) 2010-2014 - Tom Eastep (teastep@shorewall.net)
#
#	Complete documentation is available at http://shorewall.net
#
#       This program is part of Shorewall.
#
#	This program is free software; you can redistribute it and/or modify
#	it under the terms of the GNU General Public License as published by the
#       Free Software Foundation, either version 2 of the license or, at your
#       option, any later version.
#
#	This program is distributed in the hope that it will be useful,
#	but WITHOUT ANY WARRANTY; without even the implied warranty of
#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#	GNU General Public License for more details.
#
#	You should have received a copy of the GNU General Public License
#	along with this program; if not, see <http://www.gnu.org/licenses/>.
#
# The purpose of this library is to hold those functions used by both the CLI and by the
# generated firewall scripts. To avoid versioning issues, it is copied into generated
# scripts rather than loaded at run-time.
#
#########################################################################################
#
# Issue a message and stop
#
startup_error() # $* = Error Message
{
    echo "   ERROR: $@: Firewall state not changed" >&2

    if [ $LOG_VERBOSITY -ge 0 ]; then
        timestamp="$(date +'%_b %d %T') "
        echo "${timestamp}  ERROR: $@" >> $STARTUP_LOG
    fi

    case $COMMAND in
        start)
	    logger -p kern.err "ERROR:$g_product start failed:Firewall state not changed"
	    ;;
	restart)
	    logger -p kern.err "ERROR:$g_product restart failed:Firewall state not changed"
	    ;;
	restore)
	    logger -p kern.err "ERROR:$g_product restore failed:Firewall state not changed"
	    ;;
    esac

    if [ $LOG_VERBOSITY -ge 0 ]; then
        timestamp="$(date +'%_b %d %T') "

	case $COMMAND in
	    start)
		echo "${timestamp}  ERROR:$g_product start failed:Firewall state not changed" >> $STARTUP_LOG
		;;
	    restart)
		echo "${timestamp}  ERROR:$g_product restart failed:Firewall state not changed" >> $STARTUP_LOG
		;;
	    restore)
		echo "${timestamp}  ERROR:$g_product restore failed:Firewall state not changed" >> $STARTUP_LOG
		;;
	esac
    fi

    mutex_off
    kill $$
    exit 2
}

#
# Get the Shorewall version of the passed script
#
get_script_version() { # $1 = script
    local temp
    local version
    local ifs
    local digits
    local verbosity

    verbosity="$VERBOSITY"
    VERBOSITY=0

    temp=$( $SHOREWALL_SHELL $1 version | tail -n 1 | sed 's/-.*//' )

    if [ -z "$temp" ]; then
	version=0
    else
	ifs=$IFS
	IFS=.
	temp=$(echo $temp)
	IFS=$ifs
	digits=0

	for temp in $temp; do
	    version=${version}$(printf '%02d' $temp)
	    digits=$(($digits + 1))
	    [ $digits -eq 3 ] && break
	done
    fi

    echo $version

    VERBOSITY="$verbosity"
}

#
# Do required exports or create the required option string and run the passed script using
# $SHOREWALL_SHELL
#
run_it() {
    local script
    local options
    local version

    export VARDIR

    script=$1
    shift

    version=$(get_script_version $script)

    if [ $version -lt 040408 ]; then
	#
	# Old script that doesn't understand 4.4.8 script options
	#
	export RESTOREFILE
	export VERBOSITY
	export NOROUTES=$g_noroutes
	export PURGE=$g_purge
	export TIMESTAMP=$g_timestamp
	export RECOVERING=$g_recovering

	case "$g_program" in
	    *-lite)
		#
		# Shorewall Lite
		#
		export LOGFORMAT
		export IPTABLES
		;;
	esac
    else
	#
	# 4.4.8 or later -- no additional exports required
	#
	if [ x$1 = xtrace -o x$1 = xdebug ]; then
	    options="$1 -"
	    shift;
	else
	    options='-'
	fi

	[ -n "$g_noroutes" ]   && options=${options}n
	[ -n "$g_timestamp" ]  && options=${options}t
	[ -n "$g_purge" ]      && options=${options}p
	[ -n "$g_recovering" ] && options=${options}r

	options="${options}V $VERBOSITY"

	[ -n "$RESTOREFILE" ] && options="${options} -R $RESTOREFILE"
    fi

    $SHOREWALL_SHELL $script $options $@
}

#
# Message to stderr
#
error_message() # $* = Error Message
{
   echo "   $@" >&2
}

#
# Undo the effect of 'split()'
#
join()
{
    local f
    local o
    o=

    for f in $* ; do
        o="${o:+$o:}$f"
    done

    echo $o
}

#
# Return the number of elements in a list
#
list_count() # $* = list
{
    return $#
}

#
# Split a colon-separated list into a space-separated list
#
split() {
    local ifs
    ifs=$IFS
    IFS=:
    echo $*
    IFS=$ifs
}

#
# Search a list looking for a match -- returns zero if a match found
# 1 otherwise
#
list_search() # $1 = element to search for , $2-$n = list
{
    local e
    e=$1

    while [ $# -gt 1 ]; do
	shift
	[ "x$e" = "x$1" ] && return 0
    done

    return 1
}

#
# Suppress all output for a command
#
qt()
{
    "$@" >/dev/null 2>&1
}

#
# Suppress all output and input - mainly for preventing leaked file descriptors
# to avoid SELinux denials
#
qtnoin()
{
    "$@" </dev/null >/dev/null 2>&1
}

qt1()
{
    local status

    while [ 1 ]; do
	"$@" </dev/null >/dev/null 2>&1
	status=$?
	[ $status -ne 4 ] && return $status
    done
}

#
# Determine if Shorewall[6] is "running"
#
product_is_started() {
    qt1 $g_tool -L shorewall -n
}

shorewall_is_started() {
    qt1 $IPTABLES -L shorewall -n
}

shorewall6_is_started() {
    qt1 $IP6TABLES -L shorewall -n
}

#
# Echos the fully-qualified name of the calling shell program
#
my_pathname() {
    local pwd
    pwd=$PWD
    cd $(dirname $0)
    echo $PWD/$(basename $0)
    cd $pwd
}

#
# Source a user exit file if it exists
#
run_user_exit() # $1 = file name
{
    local user_exit
    user_exit=$(find_file $1)

    if [ -f $user_exit ]; then
	progress_message "Processing $user_exit ..."
	. $user_exit
    fi
}

#
# Load a Kernel Module -- assumes that the variable 'moduledirectories' contains
#                         a space-separated list of directories to search for
#                         the module and that 'moduleloader' contains the
#                         module loader command.
#
loadmodule() # $1 = module name, $2 - * arguments
{
    local modulename
    modulename=$1
    local modulefile
    local suffix

    if [ -d /sys/module/ ]; then
	if ! list_search $modulename $DONT_LOAD; then
	    if [ ! -d /sys/module/$modulename ]; then
		shift

		for suffix in $MODULE_SUFFIX ; do
		    for directory in $moduledirectories; do
			modulefile=$directory/${modulename}.${suffix}

			if [ -f $modulefile ]; then
			    case $moduleloader in
				insmod)
				    insmod $modulefile $*
				    ;;
				*)
				    modprobe $modulename $*
				    ;;
			    esac
			    break 2
			fi
		    done
		done
	    fi
	fi
    elif ! list_search $modulename $DONT_LOAD $MODULES; then
	shift

	for suffix in $MODULE_SUFFIX ; do
	    for directory in $moduledirectories; do
		modulefile=$directory/${modulename}.${suffix}

		if [ -f $modulefile ]; then
		    case $moduleloader in
			insmod)
			    insmod $modulefile $*
			    ;;
			*)
			    modprobe $modulename $*
			    ;;
		    esac
		    break 2
		fi
	    done
	done
    fi
}

#
# Reload the Modules
#
reload_kernel_modules() {

    local save_modules_dir
    save_modules_dir=$MODULESDIR
    local directory
    local moduledirectories
    moduledirectories=
    local moduleloader
    moduleloader=modprobe
    local uname

    if ! qt mywhich modprobe; then
	moduleloader=insmod
    fi

    [ -n "${MODULE_SUFFIX:=ko ko.gz o o.gz gz}" ]

    [ -z "$MODULESDIR" ] && \
	uname=$(uname -r) && \
	MODULESDIR=/lib/modules/$uname/kernel/net/ipv${g_family}/netfilter:/lib/modules/$uname/kernel/net/netfilter:/lib/modules/$uname/kernel/net/sched:/lib/modules/$uname/extra:/lib/modules/$uname/extra/ipset

    [ -d /sys/module/ ] || MODULES=$(lsmod | cut -d ' ' -f1)

    for directory in $(split $MODULESDIR); do
	[ -d $directory ] && moduledirectories="$moduledirectories $directory"
    done

    [ -n "$moduledirectories" ] && while read command; do
	eval $command
    done

    MODULESDIR=$save_modules_dir
}

#
# Load kernel modules required for Shorewall
#
load_kernel_modules() # $1 = Yes, if we are to save moduleinfo in $VARDIR
{
    local save_modules_dir
    save_modules_dir=$MODULESDIR
    local directory
    local moduledirectories
    moduledirectories=
    local moduleloader
    moduleloader=modprobe
    local savemoduleinfo
    savemoduleinfo=${1:-Yes} # So old compiled scripts still work
    local uname

    if ! qt mywhich modprobe; then
	moduleloader=insmod
    fi

    [ -n "${MODULE_SUFFIX:=o gz ko o.gz ko.gz}" ]

    [ -z "$MODULESDIR" ] && \
	uname=$(uname -r) && \
	MODULESDIR=/lib/modules/$uname/kernel/net/ipv${g_family}/netfilter:/lib/modules/$uname/kernel/net/netfilter:/lib/modules/$uname/kernel/net/sched:/lib/modules/$uname/extra:/lib/modules/$uname/extra/ipset

    for directory in $(split $MODULESDIR); do
	[ -d $directory ] && moduledirectories="$moduledirectories $directory"
    done

    [ -n "$LOAD_HELPERS_ONLY" ] && modules=$(find_file helpers) || modules=$(find_file modules)

    if [ -f $modules -a -n "$moduledirectories" ]; then
	[ -d /sys/module/ ] || MODULES=$(lsmod | cut -d ' ' -f1)
	progress_message "Loading Modules..."
	. $modules
	if [ $savemoduleinfo = Yes ]; then
	    [ -d ${VARDIR} ] || mkdir -p ${VARDIR}
	    echo MODULESDIR="$MODULESDIR" > ${VARDIR}/.modulesdir
	    cp -f $modules ${VARDIR}/.modules
	fi
    elif [ $savemoduleinfo = Yes ]; then
	[ -d ${VARDIR} ] || mkdir -p ${VARDIR}
	> ${VARDIR}/.modulesdir
	> ${VARDIR}/.modules
    fi

    MODULESDIR=$save_modules_dir
}

#
#  Note: The following set of IP address manipulation functions have anomalous
#        behavior when the shell only supports 32-bit signed arithmetic and
#        the IP address is 128.0.0.0 or 128.0.0.1.
#

LEFTSHIFT='<<'

#
# Convert an IP address in dot quad format to an integer
#
decodeaddr() {
    local x
    local temp
    temp=0
    local ifs
    ifs=$IFS

    IFS=.

    for x in $1; do
	temp=$(( $(( $temp $LEFTSHIFT 8 )) | $x ))
    done

    echo $temp

    IFS=$ifs
}

#
# convert an integer to dot quad format
#
encodeaddr() {
    addr=$1
    local x
    local y
    y=$(($addr & 255))

    for x in 1 2 3 ; do
	addr=$(($addr >> 8))
	y=$(($addr & 255)).$y
    done

    echo $y
}

#
# Netmask from CIDR
#
ip_netmask() {
    local vlsm
    vlsm=${1#*/}

    [ $vlsm -eq 0 ] && echo 0 || echo $(( -1 $LEFTSHIFT $(( 32 - $vlsm )) ))
}

#
# Network address from CIDR
#
ip_network() {
    local decodedaddr
    decodedaddr=$(decodeaddr ${1%/*})
    local netmask
    netmask=$(ip_netmask $1)

    echo $(encodeaddr $(($decodedaddr & $netmask)))
}

#
# The following hack is supplied to compensate for the fact that many of
# the popular light-weight Bourne shell derivatives don't support XOR ("^").
#
ip_broadcast() {
    local x
    x=$(( 32 - ${1#*/} ))

    [ $x -eq 32 ] && echo -1 || echo $(( $(( 1 $LEFTSHIFT $x )) - 1 ))
}

#
# Calculate broadcast address from CIDR
#
broadcastaddress() {
    local decodedaddr
    decodedaddr=$(decodeaddr ${1%/*})
    local netmask
    netmask=$(ip_netmask $1)
    local broadcast
    broadcast=$(ip_broadcast $1)

    echo $(encodeaddr $(( $(($decodedaddr & $netmask)) | $broadcast )))
}

#
# Test for network membership
#
in_network() # $1 = IP address, $2 = CIDR network
{
    local netmask
    netmask=$(ip_netmask $2)
    #
    # Use string comparison to work around a broken BusyBox ash in OpenWRT
    #
    test $(( $(decodeaddr $1) & $netmask)) = $(( $(decodeaddr ${2%/*}) & $netmask ))
}

#
# Query NetFilter about the existence of a filter chain
#
chain_exists() # $1 = chain name
{
    qt1 $g_tool -L $1 -n
}

#
# Find the interface with the passed MAC address
#

find_interface_by_mac() {
    local mac
    mac=$1
    local first
    local second
    local rest
    local dev

    $IP link list | while read first second rest; do
	case $first in
	    *:)
                dev=$second
		;;
	    *)
	        if [ "$second" = $mac ]; then
		    echo ${dev%:}
		    return
		fi
	esac
    done
}

#
# Find interface address--returns the first IP address assigned to the passed
# device
#
find_first_interface_address() # $1 = interface
{
    if [ $g_family -eq 4 ]; then
	#
	# get the line of output containing the first IP address
	#
	addr=$(${IP:-ip} -f inet addr show $1 2> /dev/null | grep 'inet .* global' | head -n1)
	#
	# If there wasn't one, bail out now
	#
	[ -n "$addr" ] || startup_error "Can't determine the IP address of $1"
	#
	# Strip off the trailing VLSM mask (or the peer IP in case of a P-t-P link)
	# along with everything else on the line
	#
	echo $addr | sed 's/\s*inet //;s/\/.*//;s/ peer.*//'
    else
	#
	# get the line of output containing the first IP address
	#
	addr=$(${IP:-ip} -f inet6 addr show dev $1 2> /dev/null | grep -F 'inet6 ' | grep -vF 'scope link' | head -n1)
	#
	# If there wasn't one, bail out now
	#
	[ -n "$addr" ] || startup_error "Can't determine the IPv6 address of $1"
	#
	# Strip off the trailing VLSM mask (or the peer IP in case of a P-t-P link)
	# along with everything else on the line
	#
	echo $addr | sed 's/\s*inet6 //;s/\/.*//;s/ peer.*//'
    fi
}

find_first_interface_address_if_any() # $1 = interface
{
    if [ $g_family -eq 4 ]; then
	#
	# get the line of output containing the first IP address
	#
	addr=$(${IP:-ip} -f inet addr show $1 2> /dev/null | grep 'inet .* global' | head -n1)
	#
	# Strip off the trailing VLSM mask (or the peer IP in case of a P-t-P link)
	# along with everything else on the line
	#
	[ -n "$addr" ] && echo $addr | sed 's/\s*inet //;s/\/.*//;s/ peer.*//' || echo 0.0.0.0
    else
	#
	# get the line of output containing the first IP address
	#
	addr=$(${IP:-ip} -f inet6 addr show dev $1 2> /dev/null | grep -F 'inet6 ' | grep -vF 'scope link' | head -n1)
	#
	# Strip off the trailing VLSM mask (or the peer IP in case of a P-t-P link)
	# along with everything else on the line
	#
	[ -n "$addr" ] && echo $addr | sed 's/\s*inet6 //;s/\/.*//;s/ peer.*//' || echo ::
    fi
}

#
# Internal version of 'which'
#
mywhich() {
    local dir

    for dir in $(split $PATH); do
	if [ -x $dir/$1 ]; then
	    echo $dir/$1
	    return 0
	fi
    done

    return 2
}

#
# Find a File -- For relative file name, look in each ${CONFIG_PATH} then ${CONFDIR}
#
find_file()
{
    local saveifs
    saveifs=
    local directory

    case $1 in
	/*)
	    echo $1
	    ;;
	*)
	    for directory in $(split $CONFIG_PATH); do
		if [ -f $directory/$1 ]; then
		    echo $directory/$1
		    return
		fi
	    done

	    if [ -n "$g_shorewalldir" ]; then
		echo ${g_shorewalldir}/$1
	    else
		echo ${g_confdir}/$1
	    fi
	    ;;
    esac
}

#
# Set the Shorewall state
#
set_state () # $1 = state
{
    if [ $# -gt 1 ]; then
	echo "$1 ($(date)) from $2" > ${VARDIR}/state
    else
	echo "$1 ($(date))" > ${VARDIR}/state
    fi
}

#
# Perform variable substitution on the passed argument and echo the result
#
expand() # $@ = contents of variable which may be the name of another variable
{
    eval echo \"$@\"
}

#
# Function for including one file into another
#
INCLUDE() {
    . $(find_file $(expand $@))
}

# Function to truncate a string -- It uses 'cut -b -<n>'
# rather than ${v:first:last} because light-weight shells like ash and
# dash do not support that form of expansion.
#

truncate() # $1 = length
{
    cut -b -${1}
}

#
# Call this function to assert mutual exclusion with Shorewall. If you invoke the
# /sbin/shorewall program while holding mutual exclusion, you should pass "nolock" as
# the first argument. Example "shorewall nolock refresh"
#
# This function uses the lockfile utility from procmail if it exists.
# Otherwise, it uses a somewhat race-prone algorithm to attempt to simulate the
# behavior of lockfile.
#
mutex_on()
{
    local try
    try=0
    local lockf
    lockf=${LOCKFILE:=${VARDIR}/lock}
    local lockpid

    MUTEX_TIMEOUT=${MUTEX_TIMEOUT:-60}

    if [ $MUTEX_TIMEOUT -gt 0 ]; then

	[ -d ${VARDIR} ] || mkdir -p ${VARDIR}

	if [ -f $lockf ]; then
	    lockpid=`cat ${lockf} 2> /dev/null`
	    if [ -z "$lockpid" -o $lockpid = 0 ]; then
		rm -f ${lockf}
		error_message "WARNING: Stale lockfile ${lockf} removed"
	    elif [ $lockpid -eq $$ ]; then
                return 0
	    elif ! qt ps p ${lockpid}; then
		rm -f ${lockf}
		error_message "WARNING: Stale lockfile ${lockf} from pid ${lockpid} removed"
	    fi
	fi

	if qt mywhich lockfile; then
	    lockfile -${MUTEX_TIMEOUT} -r1 ${lockf}
	    chmod u+w ${lockf}
	    echo $$ > ${lockf}
	    chmod u-w ${lockf}
	else
	    while [ -f ${lockf} -a ${try} -lt ${MUTEX_TIMEOUT} ] ; do
		sleep 1
		try=$((${try} + 1))
	    done

	    if  [ ${try} -lt ${MUTEX_TIMEOUT} ] ; then
	        # Create the lockfile
		echo $$ > ${lockf}
	    else
		echo "Giving up on lock file ${lockf}" >&2
	    fi
	fi
    fi
}

#
# Call this function to release mutual exclusion
#
mutex_off()
{
    rm -f ${LOCKFILE:=${VARDIR}/lock}
}