###############
# global vars #
###############

# Asume server uses 4th available IP in subnet
# # and default interface name

CFG_DIR="/etc/natfree.d"
HOOKS_BASEDIR="/usr/lib/natfree"

#############
# functions #
#############

die(){
        TYPE="ERROR"
        if [ "$#" -gt 1 ] ; then
                TYPE="$1"
                shift
        fi
        printf "${TYPE}: " >&2
        while [ "$1" ] ; do
                echo "$1" >&2
                shift
        done
        echo "" >&2

        exit 1
}

get_gw_iface(){
	# prints first default route iface name
	LANG=C ip -4 route list 0/0 |head -1 |cut -d ' ' -f 5
}


# load config
for f in $(ls -1 "$CFG_DIR" |grep "\.cfg$" |sort) ; do . $CFG_DIR/$f ; done

get_interface_list(){
	LANG=C ip a |sed -ne "/^[[:digit:]]\+:/{s%^[[:digit:]]\+:[[:blank:]]\+%%;s%:.*$%%;s%@.*$%%;p}"
}

test_iface(){
	get_interface_list | grep -qFx "$1" || return 1
	return 0
}

get_var_value(){
	NEW_VAL="$1"
	DEF_VAL="$2"
	if [ -z "$DEF_VAL" ] ; then
		echo "$1"
		return
	fi
	[ "$1" ] || NEW_VAL="$DEF_VAL"
	[ "$NEW_VAL" ] || die "Invalid default value"
	echo "$NEW_VAL"
}

get_client_iface(){
	get_var_value "$1" "$NF_DEF_CLIENT_IFACE"
}

get_srv_aliases(){
	get_var_value "$1" "$NF_DEF_SRV_ALIASES"
}

get_virt_iface(){
	get_var_value "$1" "$NF_DEF_VIRT_IFACE"
}
	
get_phys_iface(){
	get_var_value "$1" "$NF_DEF_PHYS_IFACE"
}

get_ip_number(){

	IP0="$(echo "$1" |sed -e "s%^+%%")"
	get_var_value "$IP0" "$NF_DEF_IP_NUMBER"
}

get_client_mode(){
	cmode="$(echo "$1" |tr "[:upper:]" "[:lower:]")"
	get_var_value "$cmode" "$NF_DEF_MODE"
}

get_srv_net(){
	get_var_value "$1" "$NF_DEF_SRV_NET"

}

get_srv_addr(){
	get_var_value "$1" "$NF_DEF_SRV_ADDR"
}

test_virt_iface(){
	test_iface "$(get_virt_iface "$1")" || return 1
	return "...."
}

down_virt_iface(){
	VIRTUAL_IFACE="$(get_virt_iface "$1")"	# -> VIRT_IFACE_NAME
        test_iface "$VIRTUAL_IFACE" || die "Virtual interface not created"
	run_hooks "pre-down" "$VIRTUAL_IFACE" $(show_addr_virt_iface "$VIRTUAL_IFACE")
	ip link set "$VIRTUAL_IFACE" down
	run_hooks "post-down" "$VIRTUAL_IFACE" $(show_addr_virt_iface "$VIRTUAL_IFACE")
}

up_virt_iface(){
	VIRTUAL_IFACE="$(get_virt_iface "$1")"	# -> VIRT_IFACE_NAME
        test_iface "$VIRTUAL_IFACE" || die "Virtual interface not created"
	run_hooks "pre-up" "$VIRTUAL_IFACE" $(show_addr_virt_iface "$VIRTUAL_IFACE")
	ip link set "$VIRTUAL_IFACE" up
	run_hooks "post-up" "$VIRTUAL_IFACE" $(show_addr_virt_iface "$VIRTUAL_IFACE")
}

unset_virt_iface(){
	SRV_VIRT_IFACE="$(get_virt_iface "$1")"
	down_virt_iface "$SRV_VIRT_IFACE"
	# remove all addresses
	OLD_CIDR_LIST="$(show_addr_virt_iface "$SRV_VIRT_IFACE")"
	for OLD_CIDR in $OLD_CIDR_LIST; do
		ip addr del "$OLD_CIDR" dev "$SRV_VIRT_IFACE"
	done
}

addr_virt_iface(){
	SRV_VIRT_IFACE="$(get_virt_iface "$1")"
	SRV_CIDR="$2"
	unset_virt_iface "$SRV_VIRT_IFACE"
	
	ip addr add "$SRV_CIDR" dev "$SRV_VIRT_IFACE"
	up_virt_iface "$SRV_VIRT_IFACE"
}

show_virt_iface(){
	VIRTUAL_IFACE="$(get_virt_iface "$1")"	# -> VIRT_IFACE_NAME
        test_iface "$VIRTUAL_IFACE" || die "Virtual interface not created"
	LANG=C ip a show dev "$VIRTUAL_IFACE" |sed -e "s%^[[:digit:]]\+:[[:blank:]]*%%"
}

show_addr_virt_iface(){
	VIRTUAL_IFACE="$(get_virt_iface "$1")"	# -> VIRT_IFACE_NAME
	[ "$VIRTUAL_IFACE" ] || return 0
	test_iface "$VIRTUAL_IFACE" || return 0
	LANG=C ip a show dev "$VIRTUAL_IFACE" |sed -ne  "/^[[:blank:]]*inet[[:blank:]]/{s%^[[:blank:]]*%%;p}" |cut -d " " -f2
}

create_virt_iface(){
	# create virtual interface over physical interface
	# currently supports macvtap mode bridge for ethernet and
	# mac80211 Multiple Virtual Interface (vif) for WiFi interfaces
	# parameters:
	VIRTUAL_IFACE="$(get_virt_iface "$1")"	# -> VIRT_IFACE_NAME
	PHYSICAL_IFACE="$(get_phys_iface "$2")"	# -> PHYS_IFACE

	run_hooks "pre-create" "$VIRTUAL_IFACE" ""
	if [ -e "/sys/class/net/$PHYSICAL_IFACE/wireless" ] ; then
		# wireless mode. Use mac80211 vif
		iw dev "$PHYSICAL_IFACE" interface add "$VIRTUAL_IFACE" type station
	else
		# wired connection. Use macvlan 
		ip link add "$VIRTUAL_IFACE" link "$PHYSICAL_IFACE" type macvlan mode bridge
	fi

	run_hooks "post-create" "$VIRTUAL_IFACE" $(show_addr_virt_iface "$VIRTUAL_IFACE")
}

delete_virt_iface(){
	# delete virtual interface over physical interface
	# parameters:
	VIRTUAL_IFACE="$(get_virt_iface "$1")"	# -> VIRT_IFACE_NAME
	PHYSICAL_IFACE="$(get_phys_iface "$2")"	# -> PHYS_IFACE
	down_virt_iface "$VIRTUAL_IFACE"
	ip link del "$VIRTUAL_IFACE"
}

get_domain(){
	# get search domain from resolv.conf
	# remove "dot" at beginning of string 
	# this also discards a simple dot as search domain (as some providers do!)
	sed -ne "/^[[:blank:]]*search/{s%^.*[[:blank:]]%%;s%^\.%%;p}" /etc/resolv.conf
}

get_iface_cidr(){
	# prints IP/NETMASK from specified interface
	# parameters:
	IFACE_NAME="$1"
	LANG=C ip addr show "$IFACE_NAME" |sed -ne "/[[:blank:]]*inet[[:blank:]]/{s%^.*inet[[:blank:]]%%;s%[[:blank:]].*$%%;p}"
}

bin2byte(){
	# convert binary byte to decimal format
	# parameters:
	BBYTE="$1"
	printf "$(echo "obase=10;ibase=2;$BBYTE" |bc)"
}

byte2bin(){
	# convert decimal byte to binary and pad with 8 0's
	# parameters:
	DBYTE="$1"
	printf "%08d" "$(echo "obase=2;$DBYTE" |bc)"
}

get_firstbits(){
	# extract first n bits from a 32 bits binary number
	# parameters:
	BNUM="$1"	# -> 32 bits binary number
	n=$2		# -> number of bits

	N=$((32 - $n))
	echo "$BNUM" |sed -e "s%[[:digit:]]\{$N\}$%%"
}

get_lastbits(){
	# extract last n bits from a 32 bits binary number
	# parameters:
	BNUM="$1"	# -> 32 bits binary number
	n=$2		# -> number of bits

	N=$((32 - $n))
	echo "$BNUM" |sed -e "s%^[[:digit:]]\{$N\}%%"
}

get_byte(){
	# get nth byte of a 32 bits binary number (from left to right, 1 is the first byte)
	# parameters:
	BNUM="$1"	# -> 32 bits binary number
	n=$2		# -> byte number
	if [ $n -gt 1 ] ; then
		# remove first (n-1)*8 bits
		N=$(( ($n-1)*8))
		BNUM="$(echo "$BNUM" |sed -e "s%^[[:digit:]]\{$N\}%%")"
	fi
	if [ $n -lt 4 ] ; then
		# remove last (4-n)*8 bits
		N=$(( (4-$n)*8 ))
		BNUM="$(echo "$BNUM" |sed -e "s%[[:digit:]]\{$N\}$%%")"
	fi
	echo "$BNUM"
}

ip2bin(){
	# convert decimal dot separated IP address to 32 bits binary format
	# parameters:
	DOT_IP="$1"
	for b in $(echo "$DOT_IP" |tr "." " ") ; do
		byte2bin "$b"
	done
}

bin2ip(){
	# convert 32 bits binary IP to decimal dot separated form
	# parameters:
	BIN_IP="$1"
	DOT_IP=""
	n=1
	while [ $n -le 4 ] ; do
		BIN_BYTE="$(get_byte "$BIN_IP" $n)"
		DOT_IP="${DOT_IP}.$(bin2byte "$BIN_BYTE")"
		n=$(($n + 1))
	done
	printf "${DOT_IP#.}"
}


get_srv_cidr(){
	# receives a CIDR ip/mask parameter of any host in subnet
	# and returns the nth ip in the related subnet
	# parameters:
	CIDR="$1" 	# IP/MASK
	IP_NUMBER="$(get_ip_number "$2")"  # -> subnet IP position
	# separate IP / MASK & calculate HOST_NUMBITS
	IP="${CIDR%/*}"
	MASK="${CIDR#*/}"
	HOST_NUMBITS=$((32 - $MASK))
	# verify subnet max number of hosts
	MAX_HOST="$(echo "2^${HOST_NUMBITS} - 1" |bc)"

	# check for negative IP_NUMBER
	if echo "x$IP_NUMBER" |grep -q "^x-" ; then
		# negative, so redefine IP_NUMBER to MAX_HOSTS + (-NUMBER)
		IP_NUMBER=$((1 + $MAX_HOST + $IP_NUMBER))
	fi
	[ $IP_NUMBER -ge 1 ] || die "Insufficient number of hosts in subnet"
	[ $IP_NUMBER -le $MAX_HOST ] || die "Insufficient number of hosts in subnet"
		
	# convert IP to binary
	BIN_IP="$(ip2bin "$IP")"

	# preserve subnet part in binary form
	BIN_NET="$(get_firstbits "$BIN_IP" $MASK)"

	# convert host number to binary and pad with required 0's 
	BIN_HOST_RAW="$(echo "obase=2;$IP_NUMBER" |bc)"
	BIN_HOST="$(printf "%0${HOST_NUMBITS}d" "$BIN_HOST_RAW")"

	# concatenate to get binary server IP and convert to dot separated format
	BIN_SRV_IP="${BIN_NET}${BIN_HOST}"
	printf "$(bin2ip "$BIN_SRV_IP")/$MASK\n"
}

get_srv_ip(){
	# this function is a wrapper of get_srv_cidr to parse only IP address
	# 
	# parameters:
	CIDR="$1" 	# IP/MASK
	IP_NUMBER="$2"  # -> subnet IP position
	get_srv_cidr "$CIDR" "$IP_NUMBER" |sed -e "s%/.*$%%" 
}

get_network_cidr(){
	CIDR="$1"
	# separate IP / MASK & calculate HOST_NUMBITS
	IP="${CIDR%/*}"
	MASK="${CIDR#*/}"
	HOST_NUMBITS=$((32 - $MASK))
	
	BIN_IP="$(ip2bin "$IP")"
	BIN_NET="$(get_firstbits "$BIN_IP" "$MASK")"
	BIN_HOSTS="$(printf "%0${HOST_NUMBITS}d")"
	printf "$(bin2ip "$BIN_NET$BIN_HOSTS")/$MASK\n"
}

get_srv_cart_ip(){
	CIDR="$1"
	CART_N="$2" # CONTROLLED_CLASSROOM
	MAX_CART="$3"
	# TODO custom ip
	CART_N=$(( $CART_N < 1 ? 1 : $CART_N ))
	CART_N=$(( $CART_N > $MAX_CART ? $MAX_CART : $CART_N ))
	I=$(( $MAX_CART - $CART_N + 1 ))
	get_srv_cidr "$CIDR" "$I" |sed -e "s%/.*$%%" 
}

run_hooks(){
	# Prepare environment and run hooks scripts
	# in a similar way to run-parts. Execution bit is required for hooks scripts 
	# ENVIRONMENT VARIABLES:
	# 	NATFREE_HOOK    : Name of the hook (pre-up, post-up, pre-down, post-dow, pre-create, post-create)
	# 	NATFREE_IFACE   : Name of natfree interface
	# 	NATFREE_ADDRESS : CIDR (IP/MASK) space separated list of natfree addresses (if any)
	#
	# parameters:
	NATFREE_HOOK="$1"
	shift
	NATFREE_IFACE="$1"
	shift
	NATFREE_ADDRESS="$@"
	export NATFREE_HOOK NATFREE_IFACE NATFREE_ADDRESS
	HOOKS_DIR="${HOOKS_BASEDIR}/${NATFREE_HOOK}.d"
	if [ -d "$HOOKS_DIR" ] ; then
		for f in $(ls -1 "$HOOKS_DIR" |sort) ; do
			HOOK_FILE="${HOOKS_DIR}/${f}"
			if [ -x "$HOOK_FILE" ] ; then
				$HOOK_FILE || true
			fi
		done
	fi
	unset NATFREE_HOOK NATFREE_IFACE NATFREE_ADDRESS
	return 0
}

print_host(){
	# prints single line in etc/hosts format for an IP and hostname
	# parameters:
	IP="$1"
	HOST="$2"
	printf "${IP}\t${H}\n"
}

delete_hosts_file(){
	HOSTS_BASE_FILE="$1"
	HOSTS_FILE="/etc/hosts.d/${HOSTS_BASE_FILE}.hosts"
	rm -f "$HOSTS_FILE"
}

write_hosts_file(){
	# the first parameter is the base name of the file to generate without extension
	# second parameter is in the form 
	# IP:alias_list_comma_separated[:optional_domain_name_list]
	HOSTS_BASE_FILE="$1"
	shift
	HOSTS_FILE="/etc/hosts.d/${HOSTS_BASE_FILE}.hosts"
        echo "# BEGIN ${HOSTS_BASE_FILE} IPs" > "$HOSTS_FILE"
        generate_hosts "$1" >> "$HOSTS_FILE"
        echo "# END ${HOSTS_BASE_FILE} IPs" >> "$HOSTS_FILE"
}

generate_hosts(){
	# prints list of pairs "IP hostname" in etc/hosts format
	# the function can receive many parameters in the form:
	# IP:alias_list_comma_separated[:optional_domain_name_list]
	while [ "$1" ] ; do
		# extract parameters
		DOMAIN_LIST=""
		IP="${1%%:*}"
		ALIAS_LIST="${1#*:}"
		if echo "$ALIAS_LIST" | grep -q ":" ; then
			DOMAIN_LIST="${ALIAS_LIST#*:}"
			ALIAS_LIST="${ALIAS_LIST%:*}"
		fi
		for H in $(echo "$ALIAS_LIST" | tr "," " ") ; do
			print_host "$IP" "$H"
			for D in $(echo "$DOMAIN_LIST" | tr "," " ") ; do
				print_host "$IP" "${H}.${D}"
			done
		done
		shift
	done
}

test_available_ip(){
	# Returns 0 if the IP is available or 1 if it is unreachable.
	# Parameters:
	ping -c 1 -w 1 "$1" > /dev/null 2>&1
	if [ $? -eq 0 ]; then
		return 1
	else
		return 0
	fi
}
