#!/bin/sh
# Copyright:
#   (c) 2026, Thomas Goirand <zigo@debian.org>
# License: Apache 2.0, see LICENSE.txt for details.
#
# Generates the network configuration of an OpenStack node:
# /etc/network/interfaces, the FRR configuration (frr.conf, the daemons
# file) and the related udev / systemd / modprobe.d bits, from the same
# --static-iface grammar that build-openstack-debian-image uses. The
# output paths are overridable, which makes the script usable both as
# the backend of build-openstack-debian-image (write into a chroot
# mount) and standalone (reconfigure the current node, used by
# openstack-cluster-installer-common), and unit-testable (write into a
# temporary directory).

set -e

usage () {
	echo "Usage: odi-gen-net-config [options]
Options are:
 --static-iface type=<normal,bond,bondvlan,bondvlanbridge,bgp,ovsbridge,forcebrexmac>,iface0=eth0[,iface1=eth1][,addr=<CIDR>:<gw>][,addr6=<v6-CIDR>][,gw6=<gw>][,vlannum=85][,bridgename=br85][,ovsbr=br-ex][,ovsbridgename=br-ovs0][,vmnet_addr=<CIDR>][,vmnet_iface0=eth0][,vmnet_iface1=eth1][,vmnet_vlan=85][,asnum=<ASNUM>][,addbgpi=<IP>][,ovnvrf=<VRF_ID>][,dns=<IP>:<IP>][,dns-search=<domain>][,mtu=9000][,extra_ovs=yes][,ovsifaces=yes][,brexmacaddr=<MACADDR>][,forcefrr=yes][,forcefrrnic1=eth0][,forcefrrnic2=eth1][,forcefrrvlan=85][,ipv6-accept-ra=<0|1|2>][,router-id=<dotted-quad>] (can be specified multiple times; see odi-gen-net-config(8) for the full grammar)
 --root <dir> prefix prepended to relative output paths (default: /, ie: reconfigure the current node)
 --eni-path <path> path of the interfaces file (default: etc/network/interfaces, relative to --root; an absolute path is used as-is)
 --frr-path <path> path of the frr.conf file (default: etc/frr/frr.conf)
 --frr-daemons-path <path> path of the frr daemons file (default: etc/frr/daemons)
 --udev-rules-dir <dir> directory for the persistent-net udev rules (default: etc/udev/rules.d)
 --systemd-network-dir <dir> directory for the persistent-net .link files (default: etc/systemd/network)
 --modprobe-dir <dir> directory for the bonding modprobe config (default: etc/modprobe.d)
 --release <release> the Debian release name, when generating for old releases syntax (default: guessed from the /etc/os-release of the target system, ie: under --root)
 -h, --help this help
"
}

ROOT="/"
RELEASE=""
ENI_PATH=""
FRR_PATH=""
FRR_DAEMONS_PATH=""
UDEV_RULES_DIR=""
SYSTEMD_NETWORK_DIR=""
MODPROBE_DIR=""
STATIC_ETH=""
OVNVRF_ID=""

for i in $@ ; do
	case "${1}" in
	"--static-iface")
		if [ -z "${2}" ] ; then
			echo "No IP specified"
			usage
			exit 1
		fi
		if [ -z "${STATIC_ETH}" ] ; then
			STATIC_ETH=${2}
		else
			STATIC_ETH="${STATIC_ETH} ${2}"
		fi
		shift
		shift
	;;
	"--root")
		if [ -z "${2}" ] ; then
			echo "No root directory specified"
			usage
			exit 1
		fi
		ROOT=${2}
		shift
		shift
	;;
	"--release")
		if [ -z "${2}" ] ; then
			echo "No release specified"
			usage
			exit 1
		fi
		RELEASE=${2}
		shift
		shift
	;;
	"--eni-path")
		if [ -z "${2}" ] ; then
			echo "No path specified for --eni-path"
			usage
			exit 1
		fi
		ENI_PATH=${2}
		shift
		shift
	;;
	"--frr-path")
		if [ -z "${2}" ] ; then
			echo "No path specified for --frr-path"
			usage
			exit 1
		fi
		FRR_PATH=${2}
		shift
		shift
	;;
	"--frr-daemons-path")
		if [ -z "${2}" ] ; then
			echo "No path specified for --frr-daemons-path"
			usage
			exit 1
		fi
		FRR_DAEMONS_PATH=${2}
		shift
		shift
	;;
	"--udev-rules-dir")
		if [ -z "${2}" ] ; then
			echo "No directory specified for --udev-rules-dir"
			usage
			exit 1
		fi
		UDEV_RULES_DIR=${2}
		shift
		shift
	;;
	"--systemd-network-dir")
		if [ -z "${2}" ] ; then
			echo "No directory specified for --systemd-network-dir"
			usage
			exit 1
		fi
		SYSTEMD_NETWORK_DIR=${2}
		shift
		shift
	;;
	"--modprobe-dir")
		if [ -z "${2}" ] ; then
			echo "No directory specified for --modprobe-dir"
			usage
			exit 1
		fi
		MODPROBE_DIR=${2}
		shift
		shift
	;;
	"-h"|"--help")
		usage
		exit 0
	;;
	*)
		if [ -n "${1}" ] ; then
			echo "Unrecognized option: ${1}"
			usage
			exit 1
		fi
	;;
	esac
done

# An absolute path given to one of the output flags is used as-is;
# a relative path (or the default) is resolved against --root.
resolve_path () {
	case "${1}" in
	/*)
		echo "${1}"
	;;
	*)
		echo "${ROOT%/}/${1}"
	;;
	esac
}

ENI=$(resolve_path "${ENI_PATH:-etc/network/interfaces}")
FRR_CONF=$(resolve_path "${FRR_PATH:-etc/frr/frr.conf}")
FRR_DAEMONS=$(resolve_path "${FRR_DAEMONS_PATH:-etc/frr/daemons}")
UDEV_RULES=$(resolve_path "${UDEV_RULES_DIR:-etc/udev/rules.d}")
SYSTEMD_NETWORK=$(resolve_path "${SYSTEMD_NETWORK_DIR:-etc/systemd/network}")
MODPROBE=$(resolve_path "${MODPROBE_DIR:-etc/modprobe.d}")

# Without --release, guess the Debian release of the target system
# from its /etc/os-release (the current node, as --root defaults to
# /). Sourcing happens in a subshell so only the codename escapes.
if [ -z "${RELEASE}" ] ; then
	if [ -r ${ROOT%/}/etc/os-release ] ; then
		RELEASE=$(. ${ROOT%/}/etc/os-release && echo ${VERSION_CODENAME})
	fi
fi

mkdir -p $(dirname ${ENI})

FORCE_FRR=no
if echo "${STATIC_ETH}" | grep -q forcefrr ; then
	FORCE_FRR=yes
fi

# Full IPv6 address grammar: 8 groups, at most one "::" compression, and
# the embedded IPv4 forms.
V6_REGEX='^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$'

HAS_BGP_TO_THE_HOST=no
BGP_IP_LIST=""
BGP_IP6_LIST=""
BGP_IFACE_LIST=""
BGP_ASNUM=""
ROUTER_ID_V6=""

add_to_bgp_iface_list () {
	local NOT_IN IFACE_NAME
	IFACE_NAME=${1}

	if [ -z "${BGP_IFACE_LIST}" ] ; then
		BGP_IFACE_LIST=${IFACE_NAME}
		return
	fi

	# Check if the iface is there already
	NOT_IN=yes
	for i in $(echo "${BGP_IFACE_LIST}" | tr ',' ' ') ; do
		if [ "${i}" = "${IFACE_NAME}" ] ; then
			return
		fi
	done
	BGP_IFACE_LIST="${BGP_IFACE_LIST},${IFACE_NAME}"
}

# First, always add the loopback
echo "# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

# The loopback network interface
auto lo
iface lo inet loopback
" > ${ENI}
if [ -n "${STATIC_ETH}" ] ; then
	BOND_NUMBER=0
	for i in ${STATIC_ETH} ; do
		SE_TYPE=""
		SE_IFACE0=""
		SE_IFACE1=""
		SE_ADDR=""
		SE_GW=""
		SE_ADDR6=""
		SE_GW6=""
		SE_ACCEPT_RA=""
		SE_ROUTER_ID=""
		SE_VLANNUM=""
		SE_BRNAME=""
		SE_DNS=""
		SE_DNSSEARCH=""
		SE_MTU=""
		SE_OVSBR=""
		SE_VMNET_ADDR=""
		SE_VMNET_VLAN=""
		SE_VMNET_IFACE1=""
		SE_VMNET_IFACE2=""
		SE_EXTRA_OVS="no"
		SE_OVSBRIDGE_NAME=""
		SE_USE_OVS_IFACES="no"
		SE_ASNUM=""
		SE_OVNVRF=""
		SE_ADD_BGP_IP=""
		SE_BREXMACADDR=""
		FORCE_FRR=""
		FORCE_FRRNIC1=""
		FORCE_FRRNIC2=""
		FORCE_FRRVLAN=""
		ETH_PARAMS=$(echo ${i} | tr , " ")
		for ETH_PARAM in ${ETH_PARAMS} ; do
			ETH_PDIR=$(echo ${ETH_PARAM} | cut -d= -f1)
			ETH_PVAL=$(echo ${ETH_PARAM} | cut -d= -f2)
			case "${ETH_PDIR}" in
			"type")
				SE_TYPE=${ETH_PVAL}
			;;
			"iface0")
				SE_IFACE0=${ETH_PVAL}
			;;
			"iface1")
				SE_IFACE1=${ETH_PVAL}
			;;
			"addr")
				SE_ADDR=$( echo ${ETH_PVAL} | cut -d: -f1)
				SE_GW=$( echo ${ETH_PVAL} | cut -d: -f2)
			;;
			"addr6")
				SE_ADDR6=${ETH_PVAL}
			;;
			"gw6")
				SE_GW6=${ETH_PVAL}
			;;
			"ipv6-accept-ra")
				SE_ACCEPT_RA=${ETH_PVAL}
			;;
			"router-id")
				SE_ROUTER_ID=${ETH_PVAL}
			;;
			"vlannum")
				SE_VLANNUM=${ETH_PVAL}
			;;
			"bridgename")
				SE_BRNAME=${ETH_PVAL}
			;;
			"dns")
				SE_DNS=${ETH_PVAL}
				SE_ALL_NS=$(echo ${SE_DNS} | tr : " ")
			;;
			"dns-search")
				SE_DNSSEARCH=${ETH_PVAL}
			;;
			"mtu")
				SE_MTU=${ETH_PVAL}
			;;
			"ovsbr")
				SE_OVSBR=${ETH_PVAL}
			;;
			"vmnet_addr")
				SE_VMNET_ADDR=${ETH_PVAL}
			;;
			"vmnet_vlan")
				SE_VMNET_VLAN=${ETH_PVAL}
			;;
			"vmnet_iface0")
				SE_VMNET_IFACE0=${ETH_PVAL}
			;;
			"vmnet_iface1")
				SE_VMNET_IFACE1=${ETH_PVAL}
			;;
			"extra_ovs")
				SE_EXTRA_OVS="yes"
			;;
			"ovsbridgename")
				SE_OVSBRIDGE_NAME=${ETH_PVAL}
			;;
			"ovsifaces")
				if [ "${ETH_PVAL}" = "yes" ] ; then
					SE_USE_OVS_IFACES="yes"
				fi
			;;
			"asnum")
				SE_ASNUM=${ETH_PVAL}
			;;
			"ovnvrf")
				SE_OVNVRF=${ETH_PVAL}
			;;
			"addbgpi")
				SE_ADD_BGP_IP=${ETH_PVAL}
			;;
			"brexmacaddr")
				SE_BREXMACADDR=${ETH_PVAL}
			;;
			"forcefrr")
				FORCE_FRR=${ETH_PVAL}
			;;
			"forcefrrnic1")
				FORCE_FRRNIC1=${ETH_PVAL}
			;;
			"forcefrrnic2")
				FORCE_FRRNIC2=${ETH_PVAL}
			;;
			"forcefrrvlan")
				FORCE_FRRVLAN=${ETH_PVAL}
			;;
			*)
				echo "Unrecognized parameter"
			;;
			esac
		done
		if [ -n "${SE_ADDR}" ] ; then
			IFACE_ADDR=$(echo ${SE_ADDR} | cut -d/ -f1)
			IFACE_NETWORK=$(ipcalc ${SE_ADDR} | grep '^Network:' | awk '{print $2}' | cut -d/ -f1)
			IFACE_BROADCAST=$(ipcalc ${SE_ADDR} | grep '^Broadcast:' | awk '{print $2}')
			IFACE_NETMASK=$(ipcalc ${SE_ADDR} | grep '^Netmask:' | awk '{print $2}')
		fi
		# IPv6 checks. BGP router ID is derived from the low 32 bits of the
		# IPv6 address (ie: the last two 16-bit groups of the fully expanded
		# form), as BGP router IDs are always a 32 bit dotted quad, even on
		# IPv6 only nodes, and FRR is unable to derive one from IPv6.
		IFACE_ROUTER_ID_V6=""
		if [ -n "${SE_ADDR6}" ] ; then
			SE_ADDR6_ADDR=$(echo ${SE_ADDR6} | cut -d/ -f1)
			SE_ADDR6_LEN=$(echo ${SE_ADDR6} | cut -d/ -f2)
			if [ -z "${SE_ADDR6_ADDR}" ] || [ -z "${SE_ADDR6_LEN}" ] || [ -n "$(echo ${SE_ADDR6} | cut -d/ -f3)" ] ; then
				echo "Invalid addr6=${SE_ADDR6}: must be <IPv6-address>/<prefix-length>"
				exit 1
			fi
			case ${SE_ADDR6_LEN} in
			12[0-8]|1[01][0-9]|[0-9]|[1-9][0-9]) ;;
			*)
				echo "Invalid addr6=${SE_ADDR6}: prefix length must be between 0 and 128"
				exit 1
			;;
			esac
			if ! echo ${SE_ADDR6_ADDR} | grep -qE "${V6_REGEX}" ; then
				echo "Invalid addr6=${SE_ADDR6_ADDR}: not an IPv6 address"
				exit 1
			fi
			# Zone identifiers match the above, but cannot be written in
			# interfaces(5), so reject them explicitly.
			if echo ${SE_ADDR6_ADDR} | grep -q '%' ; then
				echo "Invalid addr6=${SE_ADDR6_ADDR}: zone identifiers are not supported"
				exit 1
			fi
			if [ -z "${SE_ACCEPT_RA}" ] ; then
				SE_ACCEPT_RA=2
			fi
			case ${SE_ACCEPT_RA} in
			0|1|2) ;;
			*)
				echo "Invalid ipv6-accept-ra=${SE_ACCEPT_RA}: must be 0, 1 or 2"
				exit 1
			;;
			esac
		fi
		# The explicit router-id wins over the one derived from the
		# low 32 bits of addr6=, and is validated whether the setup is
		# dual-stack or IPv4-only (a BGP router ID is always a 32 bit
		# dotted quad, and FRR cannot derive one from IPv6).
		if [ -n "${SE_ROUTER_ID}" ] ; then
			if ! echo ${SE_ROUTER_ID} | grep -qE '^([0-9]{1,3}\.){3}[0-9]{1,3}$' ; then
				echo "Invalid router-id=${SE_ROUTER_ID}: must be a dotted quad"
				exit 1
			fi
			if [ "${SE_ROUTER_ID}" = "0.0.0.0" ] ; then
				echo "Invalid router-id=${SE_ROUTER_ID}: must not be 0.0.0.0"
				exit 1
			fi
			for ROUTER_ID_OCTET in $(echo ${SE_ROUTER_ID} | tr . ' ') ; do
				if [ "${ROUTER_ID_OCTET}" -gt 255 ] ; then
					echo "Invalid router-id=${SE_ROUTER_ID}: octets must be below 256"
					exit 1
				fi
			done
			IFACE_ROUTER_ID_V6=${SE_ROUTER_ID}
		elif [ -n "${SE_ADDR6}" ] ; then
			SE_ADDR6_ADDR=$(echo ${SE_ADDR6} | cut -d/ -f1)
			case ${SE_ADDR6_ADDR} in
			*::*)
				V6_TAIL=$(echo ${SE_ADDR6_ADDR} | sed 's/^.*:://')
				;;
			*)
				V6_TAIL=${SE_ADDR6_ADDR}
				;;
			esac
			GROUP_HIGH=$(echo ${V6_TAIL} | awk -F: 'NF>1{print $(NF-1)}')
			GROUP_LOW=$(echo ${V6_TAIL} | awk -F: '{print $NF}')
			[ -n "${GROUP_HIGH}" ] || GROUP_HIGH=0
			[ -n "${GROUP_LOW}" ] || GROUP_LOW=0
			GROUP_HIGH_DEC=$(printf '%d' 0x${GROUP_HIGH})
			GROUP_LOW_DEC=$(printf '%d' 0x${GROUP_LOW})
			IFACE_ROUTER_ID_V6="$(( ${GROUP_HIGH_DEC} / 256 )).$(( ${GROUP_HIGH_DEC} % 256 )).$(( ${GROUP_LOW_DEC} / 256 )).$(( ${GROUP_LOW_DEC} % 256 ))"
			if [ "${IFACE_ROUTER_ID_V6}" = "0.0.0.0" ] ; then
				echo "Invalid addr6=${SE_ADDR6}: derives a 0.0.0.0 router ID, please set router-id= explicitly"
				exit 1
			fi
		fi
		if [ -n "${IFACE_ROUTER_ID_V6}" ] && [ -z "${ROUTER_ID_V6}" ] ; then
			ROUTER_ID_V6=${IFACE_ROUTER_ID_V6}
		fi
		if [ -n "${SE_GW6}" ] ; then
			if [ -z "${SE_ADDR6}" ] ; then
				echo "Invalid gw6=${SE_GW6}: gw6= requires addr6= to be set"
				exit 1
			fi
			if ! echo ${SE_GW6} | grep -qE "${V6_REGEX}" ; then
				echo "Invalid gw6=${SE_GW6}: not an IPv6 address"
				exit 1
			fi
			if echo ${SE_GW6} | grep -q '%' ; then
				echo "Invalid gw6=${SE_GW6}: zone identifiers are not supported"
				exit 1
			fi
		fi
		# Make sure that each network config carries at least one address,
		# and fail fast if it doesn't. The ovsbridge type is address-less
		# by design, and type=bgp puts addresses on loopback, which
		# addbgpi= can also provide without addr=.
		case ${SE_TYPE} in
		"ovsbridge")
		;;
		"bgp")
			if [ -z "${SE_ADDR}" ] && [ -z "${SE_ADDR6}" ] && [ -z "${SE_ADD_BGP_IP}" ] ; then
				echo "ERROR: --static-iface type=bgp requires addr=, addr6= or addbgpi= to be set"
				exit 1
			fi
		;;
		*)
			if [ -z "${SE_ADDR}" ] && [ -z "${SE_ADDR6}" ] ; then
				echo "ERROR: --static-iface type=${SE_TYPE} requires either addr= or addr6= to be set"
				exit 1
			fi
		;;
		esac
		if [ -n "${SE_VMNET_ADDR}" ] ; then
			VMNET_IFACE_ADDR=$(echo ${SE_VMNET_ADDR} | cut -d/ -f1)
			VMNET_IFACE_NETWORK=$(ipcalc ${SE_VMNET_ADDR} | grep '^Network:' | awk '{print $2}' | cut -d/ -f1)
			VMNET_IFACE_BROADCAST=$(ipcalc ${SE_VMNET_ADDR} | grep '^Broadcast:' | awk '{print $2}')
			VMNET_IFACE_NETMASK=$(ipcalc ${SE_VMNET_ADDR} | grep '^Netmask:' | awk '{print $2}')
		fi

		case "${SE_TYPE}" in
		"bgp")
			HAS_BGP_TO_THE_HOST=yes

			# Check if size of the network iface name + num of VLAN is greater than 16.
			# If so, we have to rename the card. Annoying, but necessary, because the
			# kernel doesn't allow more than 16 chars per card, and we've seen that some
			# NICs have names of up to 14 chars, which, together with the VLAN name
			# (ie: <cardname>.<vlan-num>) is greater than 16 chars, and then fais.
			if [ -n "${SE_VLANNUM}" ] ; then
				NUM_CHAR_NIC=$(echo "${SE_IFACE0}" | wc -c)
				NUM_CHAR_VLAN=$(echo "${SE_VLANNUM}" | wc -c)
				NUM_CHAR_NIC_PLUS_VLAN=$(( ${NUM_CHAR_NIC} + ${NUM_CHAR_VLAN} ))
				if [ "${NUM_CHAR_NIC_PLUS_VLAN}" -gt 16 ] ; then
					# As a trick, we just rename the cards as lan0 and lan1.
					# Note that this implementation only works with systemd,
					# for older systems, some udev rules must be implemented
					# instead of the systemd.link (see man systemd.link).
					MAC_ADDR=$(ip link show dev ${SE_IFACE0} | grep 'link/ether' | awk '{print $2}')
					if [ "${RELEASE}" = "wheezy" ] || [ "${RELEASE}" = "stretch" ] || [ "${RELEASE}" = "buster" ] ; then
						mkdir -p ${UDEV_RULES}
						echo "SUBSYSTEM==\"net\", ACTION==\"add\", DRIVERS==\"?*\", ATTR{address}==\"${MAC_ADDR}\", ATTR{dev_id}==\"0x0\", ATTR{type}==\"1\", NAME=\"lan0\"
" >${UDEV_RULES}/70-persistent-net-lan0.rules
					else
						mkdir -p ${SYSTEMD_NETWORK}
						# First, we get the MAC address of the card.
						echo "[Match]
MACAddress=${MAC_ADDR}

[Link]
Name=lan0
" >${SYSTEMD_NETWORK}/10-persistent-net-lan0.link
					fi
					SE_IFACE0=lan0

					# Do the same renaming hack with the 2nd NIC if it exists.
					if [ -n "${SE_IFACE1}" ] ; then
						MAC_ADDR=$(ip link show dev ${SE_IFACE1} | grep 'link/ether' | awk '{print $2}')
						if [ "${RELEASE}" = "wheezy" ] || [ "${RELEASE}" = "stretch" ] || [ "${RELEASE}" = "buster" ] ; then
							echo "SUBSYSTEM==\"net\", ACTION==\"add\", DRIVERS==\"?*\", ATTR{address}==\"${MAC_ADDR}\", ATTR{dev_id}==\"0x0\", ATTR{type}==\"1\", NAME=\"lan1\"
" >${UDEV_RULES}/70-persistent-net-lan1.rules
						else
							echo "[Match]
MACAddress=${MAC_ADDR}

[Link]
Name=lan1
" >${SYSTEMD_NETWORK}/10-persistent-net-lan1.link
						fi
						SE_IFACE1=lan1
					fi
				fi
			fi

			if [ -z "${BGP_ASNUM}" ] && [ -n "${SE_ASNUM}" ] ; then
				BGP_ASNUM=${SE_ASNUM}
			fi

			# The OVN chassis router VRF ID is a cluster-wide setting:
			# all --static-iface specs must agree on it.
			if [ -n "${SE_OVNVRF}" ] ; then
				if ! echo "${SE_OVNVRF}" | grep -qE '^[0-9]+$' || [ "${SE_OVNVRF}" -lt 1 ] || [ "${SE_OVNVRF}" -gt 4294967295 ] ; then
					echo "ERROR: ovnvrf=<VRF_ID> must be an integer between 1 and 4294967295"
					exit 1
				fi
				if [ -z "${OVNVRF_ID}" ] ; then
					OVNVRF_ID=${SE_OVNVRF}
				else
					if [ "${OVNVRF_ID}" != "${SE_OVNVRF}" ] ; then
						echo "ERROR: conflicting ovnvrf=<VRF_ID> values in --static-iface: ${OVNVRF_ID} and ${SE_OVNVRF}"
						exit 1
					fi
				fi
			fi

			# Manage a list of IP addresses added to the BGP config in FRR
			if [ -n "${BGP_IP_LIST}" ] ; then
				BGP_IP_LIST="${BGP_IP_LIST},"
			fi
			BGP_IP_LIST="${BGP_IP_LIST}${SE_ADDR}"

			if [ -n "${SE_ADD_BGP_IP}" ] ; then
				BGP_IP_LIST="${BGP_IP_LIST},${SE_ADD_BGP_IP}"
			fi

			if [ -n "${SE_ADDR6}" ] ; then
				if [ -n "${BGP_IP6_LIST}" ] ; then
					BGP_IP6_LIST="${BGP_IP6_LIST},"
				fi
				BGP_IP6_LIST="${BGP_IP6_LIST}${SE_ADDR6}"
			fi

			echo "auto ${SE_IFACE0}">> ${ENI}
			echo "iface ${SE_IFACE0} inet manual">> ${ENI}
			echo "	metric 4278198272">> ${ENI}
			if [ "${SE_MTU}" ] ; then
				echo "	mtu ${SE_MTU}" >> ${ENI}
			fi
			echo "" >>${ENI}
			if [ -n "${SE_VLANNUM}" ] ; then
				echo "auto ${SE_IFACE0}.${SE_VLANNUM}">> ${ENI}
				echo "iface ${SE_IFACE0}.${SE_VLANNUM} inet manual">> ${ENI}
				if [ "${SE_MTU}" ] ; then
					echo "	mtu ${SE_MTU}" >> ${ENI}
				fi
				echo "" >>${ENI}
				add_to_bgp_iface_list ${SE_IFACE0}.${SE_VLANNUM}
			else
				add_to_bgp_iface_list ${SE_IFACE0}
			fi

			if [ -n "${SE_IFACE1}" ] ; then
				echo "auto ${SE_IFACE1}">> ${ENI}
				echo "iface ${SE_IFACE1} inet manual">> ${ENI}
				echo "	metric 4278198272">> ${ENI}
				if [ "${SE_MTU}" ] ; then
					echo "	mtu ${SE_MTU}" >> ${ENI}
				fi
				echo "" >>${ENI}
				if [ -n "${SE_VLANNUM}" ] ; then
					echo "auto ${SE_IFACE1}.${SE_VLANNUM}">> ${ENI}
					echo "iface ${SE_IFACE1}.${SE_VLANNUM} inet manual">> ${ENI}
					if [ "${SE_MTU}" ] ; then
						echo "	mtu ${SE_MTU}" >> ${ENI}
					fi
					echo "" >>${ENI}
					add_to_bgp_iface_list ${SE_IFACE1}.${SE_VLANNUM}
				else
					add_to_bgp_iface_list ${SE_IFACE1}
				fi
			fi

			# Add the br-ex interface
			if [ -n "${SE_OVSBR}" ] ; then
				echo "auto br-ex" >> ${ENI}
				echo "iface br-ex inet manual" >> ${ENI}
				echo "	ovs_type OVSBridge" >> ${ENI}
				echo "	ovs_ports lo" >> ${ENI}
				echo "" >> ${ENI}
			fi
		;;
		"ovsbridge")
			echo "auto ${SE_OVSBRIDGE_NAME}" >> ${ENI}
			echo "iface ${SE_OVSBRIDGE_NAME} inet manual" >> ${ENI}
			echo "	ovs_type OVSBridge" >> ${ENI}
			echo "	ovs_ports ${SE_IFACE0}" >> ${ENI}
			echo "	up ovs-vsctl add-port ${SE_OVSBRIDGE_NAME} ${SE_IFACE0} || true" >> ${ENI}
			echo "	up ip link set ${SE_IFACE0} up" >> ${ENI}
			echo "" >> ${ENI}
		;;
		"normal")
			if [ "${FORCE_FRR}" = "yes" ] ; then
				ROUTER_ID=${SE_ADDR}
				BGP_ASNUM=${SE_ASNUM}
				BGP_IFACE_LIST=${SE_IFACE0}
			fi
			if [ -n "${SE_VLANNUM}" ] ; then
				echo "auto ${SE_IFACE0}" >> ${ENI}
				echo "iface ${SE_IFACE0} inet manual" >> ${ENI}
				echo "" >> ${ENI}
				echo "auto ${SE_IFACE0}.${SE_VLANNUM}" >> ${ENI}
				if [ -n "${SE_ADDR}" ] ; then
					echo "iface ${SE_IFACE0}.${SE_VLANNUM} inet static" >> ${ENI}
					echo "	address ${IFACE_ADDR}" >> ${ENI}
					echo "	network ${IFACE_NETWORK}" >> ${ENI}
					echo "	netmask ${IFACE_NETMASK}" >> ${ENI}
					echo "	broadcast ${IFACE_BROADCAST}" >> ${ENI}
					if [ "${SE_MTU}" ] ; then
						echo "	mtu ${SE_MTU}" >> ${ENI}
					fi
					if [ -n "${SE_DNS}" ] ; then
						echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
					fi
					if [ -n "${SE_DNSSEARCH}" ] ; then
						echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
					fi
					if [ -n "${SE_GW}" ] ; then
						echo "  gateway ${SE_GW}" >> ${ENI}
					fi
					echo "" >> ${ENI}
				fi
				if [ -n "${SE_ADDR6}" ] ; then
					echo "iface ${SE_IFACE0}.${SE_VLANNUM} inet6 static" >> ${ENI}
					echo "	address ${SE_ADDR6}" >> ${ENI}
					echo "	accept_ra ${SE_ACCEPT_RA}" >> ${ENI}
					if [ -n "${SE_GW6}" ] ; then
						echo "	gateway ${SE_GW6}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNS}" ] ; then
						echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNSSEARCH}" ] ; then
						echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ "${SE_MTU}" ] ; then
						echo "	mtu ${SE_MTU}" >> ${ENI}
					fi
					echo "" >> ${ENI}
				fi

				if [ -n "${SE_OVSBR}" ] ; then
					INTERFACE=${SE_OVSBR}
					echo "# Interface ${SE_OVSBR}" >> ${ENI}
					echo "auto ${SE_OVSBR}" >> ${ENI}
					echo "iface ${SE_OVSBR} inet manual" >> ${ENI}
					echo "	ovs_type OVSBridge" >> ${ENI}
					echo "	ovs_ports ${SE_IFACE0}" >> ${ENI}
					echo "	up ovs-vsctl add-port ${SE_OVSBR} ${SE_IFACE0} || true" >> ${ENI}
					echo "" >> ${ENI}
				fi
			else
				if [ -n "${SE_VMNET_ADDR}" ] ; then
					echo "auto ${SE_IFACE0}" >> ${ENI}
					if [ -n "${SE_ADDR}" ] ; then
						echo "iface ${SE_IFACE0} inet static" >> ${ENI}
						echo "	address ${IFACE_ADDR}" >> ${ENI}
						echo "	network ${IFACE_NETWORK}" >> ${ENI}
						echo "	netmask ${IFACE_NETMASK}" >> ${ENI}
						echo "	broadcast ${IFACE_BROADCAST}" >> ${ENI}
						if [ "${SE_MTU}" ] ; then
							echo "	mtu ${SE_MTU}" >> ${ENI}
						fi
						if [ -n "${SE_DNS}" ] ; then
							echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
						fi
						if [ -n "${SE_DNSSEARCH}" ] ; then
							echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
						fi
						if [ -n "${SE_GW}" ] ; then
							echo "	gateway ${SE_GW}" >> ${ENI}
						fi
						echo "" >> ${ENI}
					fi
					if [ -n "${SE_ADDR6}" ] ; then
						echo "iface ${SE_IFACE0} inet6 static" >> ${ENI}
						echo "	address ${SE_ADDR6}" >> ${ENI}
						echo "	accept_ra ${SE_ACCEPT_RA}" >> ${ENI}
						if [ -n "${SE_GW6}" ] ; then
							echo "	gateway ${SE_GW6}" >> ${ENI}
						fi
						if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNS}" ] ; then
							echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
						fi
						if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNSSEARCH}" ] ; then
							echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
						fi
						if [ -z "${SE_ADDR}" ] && [ "${SE_MTU}" ] ; then
							echo "	mtu ${SE_MTU}" >> ${ENI}
						fi
						echo "" >> ${ENI}
					fi

					echo "auto ${SE_VMNET_IFACE0}" >> ${ENI}
					echo "iface ${SE_VMNET_IFACE0} inet static" >> ${ENI}
					echo "	address ${VMNET_IFACE_ADDR}" >> ${ENI}
					echo "	network ${VMNET_IFACE_NETWORK}" >> ${ENI}
					echo "	netmask ${VMNET_IFACE_NETMASK}" >> ${ENI}
					echo "	broadcast ${VMNET_IFACE_BROADCAST}" >> ${ENI}
					if [ "${SE_MTU}" ] ; then
						echo "	mtu ${SE_MTU}" >> ${ENI}
					fi
					echo "" >> ${ENI}

				else
					if [ -n "${SE_OVSBR}" ] ; then
						INTERFACE=${SE_OVSBR}
						echo "# Interface ${SE_OVSBR}" >> ${ENI}
						echo "auto ${SE_OVSBR}" >> ${ENI}
					else
						INTERFACE=${SE_IFACE0}
						echo "# Interface ${INTERFACE}" >> ${ENI}
						echo "allow-hotplug ${INTERFACE}" >> ${ENI}
					fi
					if [ -n "${SE_ADDR}" ] ; then
						echo "iface ${INTERFACE} inet static" >> ${ENI}
						if [ -n "${SE_OVSBR}" ] ; then
							echo "	ovs_type OVSBridge" >> ${ENI}
							echo "	ovs_ports ${SE_IFACE0}" >> ${ENI}
						fi
						echo "	address ${IFACE_ADDR}" >> ${ENI}
						echo "	network ${IFACE_NETWORK}" >> ${ENI}
						echo "	netmask ${IFACE_NETMASK}" >> ${ENI}
						echo "	broadcast ${IFACE_BROADCAST}" >> ${ENI}
						if [ -n "${SE_GW}" ] ; then
							echo "	gateway ${SE_GW}" >> ${ENI}
						fi
						if [ "${SE_MTU}" ] ; then
							echo "	mtu ${SE_MTU}" >> ${ENI}
						fi
						if [ -n "${SE_DNS}" ] ; then
							echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
						fi
						if [ -n "${SE_DNSSEARCH}" ] ; then
							echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
						fi
						echo "" >> ${ENI}
					fi
					if [ -n "${SE_ADDR6}" ] ; then
						echo "iface ${INTERFACE} inet6 static" >> ${ENI}
						if [ -z "${SE_ADDR}" ] && [ -n "${SE_OVSBR}" ] ; then
							echo "	ovs_type OVSBridge" >> ${ENI}
							echo "	ovs_ports ${SE_IFACE0}" >> ${ENI}
						fi
						echo "	address ${SE_ADDR6}" >> ${ENI}
						echo "	accept_ra ${SE_ACCEPT_RA}" >> ${ENI}
						if [ -n "${SE_GW6}" ] ; then
							echo "	gateway ${SE_GW6}" >> ${ENI}
						fi
						if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNS}" ] ; then
							echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
						fi
						if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNSSEARCH}" ] ; then
							echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
						fi
						if [ -z "${SE_ADDR}" ] && [ "${SE_MTU}" ] ; then
							echo "	mtu ${SE_MTU}" >> ${ENI}
						fi
						echo "" >> ${ENI}
					fi
					if [ -n "${SE_OVSBR}" ] ; then
						echo "allow-${SE_OVSBR} ${SE_IFACE0}" >> ${ENI}
						echo "iface ${SE_IFACE0} inet manual" >> ${ENI}
						echo "	ovs_bridge ${SE_OVSBR}" >> ${ENI}
						echo "	ovs_type OVSPort" >> ${ENI}
						echo "" >> ${ENI}
					fi
				fi
			fi
			if [ "${FORCE_FRR}" = "yes" ] ; then
				if [ -n "${FORCE_FRRNIC1}" ] ; then
					if [ "${SE_IFACE0}" != "${FORCE_FRRNIC1}" ] ; then
						echo "auto ${FORCE_FRRNIC1}" >> ${ENI}
						echo "iface ${FORCE_FRRNIC1} inet manual" >> ${ENI}
						echo "	metric 4278198272">> ${ENI}
						echo "" >> ${ENI}
					fi
					echo "auto ${FORCE_FRRNIC1}.${FORCE_FRRVLAN}">> ${ENI}
					echo "iface ${FORCE_FRRNIC1}.${FORCE_FRRVLAN} inet manual">> ${ENI}
					if [ "${SE_MTU}" ] ; then
						echo "	mtu ${SE_MTU}" >> ${ENI}
					fi
					echo "" >>${ENI}
					add_to_bgp_iface_list ${FORCE_FRRNIC1}.${FORCE_FRRVLAN}
				fi

				if [ -n "${FORCE_FRRNIC2}" ] ; then
					echo "auto ${FORCE_FRRNIC2}" >> ${ENI}
					echo "iface ${FORCE_FRRNIC2} inet manual" >> ${ENI}
					echo "	metric 4278198272">> ${ENI}
					echo "" >> ${ENI}

					echo "auto ${FORCE_FRRNIC2}.${FORCE_FRRVLAN}">> ${ENI}
					echo "iface ${FORCE_FRRNIC2}.${FORCE_FRRVLAN} inet manual">> ${ENI}
					if [ "${SE_MTU}" ] ; then
						echo "	mtu ${SE_MTU}" >> ${ENI}
					fi
					echo "" >>${ENI}
					add_to_bgp_iface_list ${FORCE_FRRNIC2}.${FORCE_FRRVLAN}
				fi
			fi
		;;
		# type=forcebrexmac,iface0=eth0,brexmacaddr=fa:16:3e:cd:fb:0f
		# This type of network setup is when running OpenStack within
		# OpenStack VMs for testing (ie: CI) purpose. In this mode,
		# OpenStack would otherwise block the bridge MAC addr.
		"forcebrexmac")
			if [ -z "${SE_OVSBR}" ] ; then
				echo "Invalid forcebrexmac setup: ovsbr=<bridge-name> is required"
				exit 1
			fi
			echo "auto ${SE_IFACE0}" >> ${ENI}
			echo "iface ${SE_IFACE0} inet manual" >> ${ENI}
			echo "" >> ${ENI}
			echo "auto ${SE_OVSBR}" >> ${ENI}
			if [ -n "${SE_ADDR}" ] ; then
				echo "iface ${SE_OVSBR} inet static" >> ${ENI}
				echo "	ovs_type OVSBridge" >> ${ENI}
				echo "	ovs_ports ${SE_IFACE0}" >> ${ENI}
				echo "	address ${IFACE_ADDR}" >> ${ENI}
				echo "	network ${IFACE_NETWORK}" >> ${ENI}
				echo "	netmask ${IFACE_NETMASK}" >> ${ENI}
				echo "	broadcast ${IFACE_BROADCAST}" >> ${ENI}
				if [ -n "${SE_GW}" ] ; then
					echo "	gateway ${SE_GW}" >> ${ENI}
				fi
				if [ "${SE_MTU}" ] ; then
					echo "	mtu ${SE_MTU}" >> ${ENI}
				fi
				if [ -n "${SE_DNS}" ] ; then
					echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
				fi
				if [ -n "${SE_DNSSEARCH}" ] ; then
					echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
				fi
				echo "" >> ${ENI}
			fi
			if [ -n "${SE_ADDR6}" ] ; then
				echo "iface ${SE_OVSBR} inet6 static" >> ${ENI}
				if [ -z "${SE_ADDR}" ] ; then
					echo "	ovs_type OVSBridge" >> ${ENI}
					echo "	ovs_ports ${SE_IFACE0}" >> ${ENI}
				fi
				echo "	address ${SE_ADDR6}" >> ${ENI}
				echo "	accept_ra ${SE_ACCEPT_RA}" >> ${ENI}
				if [ -n "${SE_GW6}" ] ; then
					echo "	gateway ${SE_GW6}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNS}" ] ; then
					echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNSSEARCH}" ] ; then
					echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ "${SE_MTU}" ] ; then
					echo "	mtu ${SE_MTU}" >> ${ENI}
				fi
				echo "" >> ${ENI}
			fi
			echo "	up ovs-vsctl add-port ${SE_OVSBR} ${SE_IFACE0} || true" >> ${ENI}
			echo "	up ovs-vsctl set bridge ${SE_OVSBR} other-config:hwaddr=${SE_BREXMACADDR} || true" >> ${ENI}
		;;
		"bond")
			INTERFACE=bond${BOND_NUMBER}
			BOND_NUMBER=$(( ${BOND_NUMBER} + 1 ))
			if [ "${RELEASE}" = "wheezy" ] || [ "${RELEASE}" = "stretch" ] || [ "${RELEASE}" = "buster" ] ; then
				# Iface 0
				echo "# Interface ${SE_IFACE0}" >> ${ENI}
				echo "auto ${SE_IFACE0}" >> ${ENI}
				echo "iface ${SE_IFACE0} inet manual" >> ${ENI}
				echo "	bond-master ${INTERFACE}" >> ${ENI}
				echo "" >> ${ENI}
				# Iface 1
				echo "# Interface ${SE_IFACE1}" >> ${ENI}
				echo "auto ${SE_IFACE1}" >> ${ENI}
				echo "iface ${SE_IFACE1} inet manual" >> ${ENI}
				echo "	bond-master ${INTERFACE}" >> ${ENI}
				echo "" >> ${ENI}
			fi

			# Bridge
			echo "# Interface ${INTERFACE}" >> ${ENI}
			echo "auto ${INTERFACE}" >> ${ENI}
			if [ -n "${SE_ADDR}" ] ; then
				echo "iface ${INTERFACE} inet static" >> ${ENI}
				echo "	address ${IFACE_ADDR}" >> ${ENI}
				echo "	network ${IFACE_NETWORK}" >> ${ENI}
				echo "	netmask ${IFACE_NETMASK}" >> ${ENI}
				echo "	broadcast ${IFACE_BROADCAST}" >> ${ENI}
				if [ -n "${SE_GW}" ] ; then
					echo "	gateway ${SE_GW}" >> ${ENI}
				fi
				if [ "${SE_MTU}" ] ; then
					echo "	mtu ${SE_MTU}" >> ${ENI}
				fi
				if [ -n "${SE_DNS}" ] ; then
					echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
				fi
				if [ -n "${SE_DNSSEARCH}" ] ; then
					echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
				fi
				echo "	bond-mode 802.3ad" >> ${ENI}
				echo "	bond-miimon 100" >> ${ENI}
				echo "	bond-lacp-rate 1" >> ${ENI}
				echo "	bond-slaves ${SE_IFACE0} ${SE_IFACE1}" >> ${ENI}
				echo "	bond_xmit_hash_policy layer3+4" >> ${ENI}
				echo "" >> ${ENI}
			fi
			if [ -n "${SE_ADDR6}" ] ; then
				echo "iface ${INTERFACE} inet6 static" >> ${ENI}
				if [ -z "${SE_ADDR}" ] ; then
					echo "	bond-mode 802.3ad" >> ${ENI}
					echo "	bond-miimon 100" >> ${ENI}
					echo "	bond-lacp-rate 1" >> ${ENI}
					echo "	bond-slaves ${SE_IFACE0} ${SE_IFACE1}" >> ${ENI}
					echo "	bond_xmit_hash_policy layer3+4" >> ${ENI}
				fi
				echo "	address ${SE_ADDR6}" >> ${ENI}
				echo "	accept_ra ${SE_ACCEPT_RA}" >> ${ENI}
				if [ -n "${SE_GW6}" ] ; then
					echo "	gateway ${SE_GW6}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNS}" ] ; then
					echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNSSEARCH}" ] ; then
					echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ "${SE_MTU}" ] ; then
					echo "	mtu ${SE_MTU}" >> ${ENI}
				fi
				echo "" >> ${ENI}
			fi
		;;
		"bondvlan")
			INTERFACE=bond${BOND_NUMBER}
			BOND_NUMBER=$(( ${BOND_NUMBER} + 1 ))
			if [ -z "${SE_OVSBR}" ] ; then
				SE_OVSBR=br-ex
			fi
			if [ "${SE_USE_OVS_IFACES}" = "yes" ] ; then
				# Iface 0
				echo "# Interface ${SE_IFACE0}" >> ${ENI}
				echo "allow-${INTERFACE} ${SE_IFACE0}" >> ${ENI}
				echo "iface ${SE_IFACE0} inet manual" >> ${ENI}
				echo "	ovs_type OVSPort" >> ${ENI}
				echo "	ovs_bonds ${INTERFACE}" >> ${ENI}
				if [ -n "${SE_MTU}" ] ; then
					echo "	up /bin/ip link set mtu ${SE_MTU} dev ${SE_IFACE0}" >> ${ENI}
				fi
				echo "" >> ${ENI}

				# Iface 1
				echo "# Interface ${SE_IFACE1}" >> ${ENI}
				echo "allow-${INTERFACE} ${SE_IFACE1}" >> ${ENI}
				echo "iface ${SE_IFACE1} inet manual" >> ${ENI}
				echo "	ovs_type OVSPort" >> ${ENI}
				echo "	ovs_bonds ${INTERFACE}" >> ${ENI}
				if [ -n "${SE_MTU}" ] ; then
					echo "	up /bin/ip link set mtu ${SE_MTU} dev ${SE_IFACE1}" >> ${ENI}
				fi
				echo >> ${ENI}

				# Ze bond
				echo "# Interface ${INTERFACE}" >> ${ENI}
				echo "auto ${INTERFACE}" >> ${ENI}
				echo "allow-${SE_OVSBR} ${INTERFACE}" >> ${ENI}
				echo "iface ${INTERFACE} inet manual" >> ${ENI}
				echo "	ovs_bridge ${SE_OVSBR}" >> ${ENI}
				echo "	ovs_type OVSBond" >> ${ENI}
				echo "	ovs_bonds ${SE_IFACE0} ${SE_IFACE1}" >> ${ENI}
				echo "	ovs_options bond_mode=balance-tcp lacp=active other_config:lacp-time=fast" >> ${ENI}
				if [ -n "${SE_MTU}" ] ; then
					echo "	ovs_mtu ${SE_MTU}" >> ${ENI}
				fi
				echo "	up ifup ${SE_IFACE0}" >> ${ENI}
				echo "	up ifup ${SE_IFACE1}" >> ${ENI}
				if [ -n "${SE_MTU}" ] ; then
					echo "	up ovs-vsctl set Interface \${IFACE} mtu_request=${SE_MTU}" >> ${ENI}
					echo "	up /bin/sleep 1 ; /bin/ip link set mtu ${SE_MTU} dev ${INTERFACE}" >> ${ENI}
				fi
				echo "" >> ${ENI}

				# First VLAN (and maybe unique?)
				echo "# Interface vlan${SE_VLANNUM}" >> ${ENI}
				echo "auto vlan${SE_VLANNUM}" >> ${ENI}
				echo "allow-${SE_OVSBR} vlan${SE_VLANNUM}" >> ${ENI}
				if [ -n "${SE_ADDR}" ] ; then
					echo "iface vlan${SE_VLANNUM} inet static" >> ${ENI}
					echo "	ovs_type OVSIntPort" >> ${ENI}
					echo "	ovs_bridge ${SE_OVSBR}" >> ${ENI}
					echo "	ovs_options tag=${SE_VLANNUM}" >> ${ENI}
					echo "	ovs_extra set interface \${IFACE} external-ids:iface-id=\$(hostname -s)-\${IFACE}-vif" >> ${ENI}
					if [ -n "${SE_MTU}" ] ; then
						echo "	ovs_mtu ${SE_MTU}" >> ${ENI}
					fi
					echo "	address ${IFACE_ADDR}" >> ${ENI}
					echo "	network ${IFACE_NETWORK}" >> ${ENI}
					echo "	netmask ${IFACE_NETMASK}" >> ${ENI}
					echo "	broadcast ${IFACE_BROADCAST}" >> ${ENI}
					if [ -n "${SE_GW}" ] ; then
						echo "	gateway ${SE_GW}" >> ${ENI}
					fi
					echo "" >> ${ENI}
				fi
				if [ -n "${SE_ADDR6}" ] ; then
					echo "iface vlan${SE_VLANNUM} inet6 static" >> ${ENI}
					if [ -z "${SE_ADDR}" ] ; then
						echo "	ovs_type OVSIntPort" >> ${ENI}
						echo "	ovs_bridge ${SE_OVSBR}" >> ${ENI}
						echo "	ovs_options tag=${SE_VLANNUM}" >> ${ENI}
						echo "	ovs_extra set interface \${IFACE} external-ids:iface-id=\$(hostname -s)-\${IFACE}-vif" >> ${ENI}
						if [ -n "${SE_MTU}" ] ; then
							echo "	ovs_mtu ${SE_MTU}" >> ${ENI}
						fi
					fi
					echo "	address ${SE_ADDR6}" >> ${ENI}
					echo "	accept_ra ${SE_ACCEPT_RA}" >> ${ENI}
					if [ -n "${SE_GW6}" ] ; then
						echo "	gateway ${SE_GW6}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNS}" ] ; then
						echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNSSEARCH}" ] ; then
						echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ "${SE_MTU}" ] ; then
						echo "	mtu ${SE_MTU}" >> ${ENI}
					fi
					echo "" >> ${ENI}
				fi

				# The VLAN for vxlan traffic, if present
				if [ -n "${SE_VMNET_ADDR}" ] ; then
					echo "# Interface vlan${SE_VMNET_VLAN}" >> ${ENI}
					echo "auto vlan${SE_VMNET_VLAN}" >> ${ENI}
					echo "allow-${SE_OVSBR} vlan${SE_VMNET_VLAN}" >> ${ENI}
					echo "iface vlan${SE_VMNET_VLAN} inet static" >> ${ENI}
					echo "	ovs_type OVSIntPort" >> ${ENI}
					echo "	ovs_bridge ${SE_OVSBR}" >> ${ENI}
					echo "	ovs_options tag=${SE_VMNET_VLAN}" >> ${ENI}
					echo "	vs_extra set interface \${IFACE} external-ids:iface-id=\$(hostname -s)-\${IFACE}-vif" >> ${ENI}
					if [ -n "${SE_MTU}" ] ; then
						echo "	ovs_mtu ${SE_MTU}" >> ${ENI}
					fi
					echo "	address ${VMNET_IFACE_ADDR}" >> ${ENI}
					echo "	network ${VMNET_IFACE_NETWORK}" >> ${ENI}
					echo "	netmask ${VMNET_IFACE_NETMASK}" >> ${ENI}
					echo "	broadcast ${VMNET_IFACE_BROADCAST}" >> ${ENI}
				fi
				echo "" >> ${ENI}

				echo "auto ${SE_OVSBR}" >> ${ENI}
				echo "iface ${SE_OVSBR} inet manual" >> ${ENI}
				echo "	ovs_type OVSBridge" >> ${ENI}
				if [ -z "${SE_VMNET_ADDR}" ] ; then
					echo "	ovs_ports bond0 vlan${SE_VLANNUM}" >> ${ENI}
				else
					echo "	ovs_ports bond0 vlan${SE_VLANNUM} vlan${SE_VMNET_VLAN}" >> ${ENI}
				fi
				if [ -n "${SE_MTU}" ] ; then
					echo "	ovs_mtu ${SE_MTU}" >> ${ENI}
				fi
				echo "" >> ${ENI}
			else
				if [ "${RELEASE}" = "wheezy" ] || [ "${RELEASE}" = "stretch" ] || [ "${RELEASE}" = "buster" ] ; then
					# Iface 0
					echo "# Interface ${SE_IFACE0}" >> ${ENI}
					echo "auto ${SE_IFACE0}" >> ${ENI}
					echo "iface ${SE_IFACE0} inet manual" >> ${ENI}
					echo "	bond-master ${INTERFACE}" >> ${ENI}
					echo "" >> ${ENI}
					# Iface 1
					echo "# Interface ${SE_IFACE1}" >> ${ENI}
					echo "auto ${SE_IFACE1}" >> ${ENI}
					echo "iface ${SE_IFACE1} inet manual" >> ${ENI}
					echo "	bond-master ${INTERFACE}" >> ${ENI}
					echo "" >> ${ENI}
				fi

				# Bonding interface
				echo "# Interface ${INTERFACE}" >> ${ENI}
				echo "auto ${INTERFACE}" >> ${ENI}
				echo "iface ${INTERFACE} inet manual" >> ${ENI}
				if [ -n "${SE_DNS}" ] ; then
					echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
				fi
				if [ -n "${SE_DNSSEARCH}" ] ; then
					echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
				fi
				echo "	bond-mode 802.3ad" >> ${ENI}
				echo "	bond-miimon 100" >> ${ENI}
				echo "	bond-lacp-rate 1" >> ${ENI}
				echo "	bond-slaves ${SE_IFACE0} ${SE_IFACE1}" >> ${ENI}
				echo "	bond_xmit_hash_policy layer3+4" >> ${ENI}
				if [ "${SE_EXTRA_OVS}" = "yes" ] ; then
					echo "	up ifup ${SE_OVSBR}" >> ${ENI}
				fi
				if [ -n "${SE_MTU}" ] ; then
					echo "	mtu 9000" >> ${ENI}
				fi
				echo "" >> ${ENI}

				# a vlan device using the bond interface
				echo "# Interface vlan${SE_VLANNUM}" >> ${ENI}
				echo "auto vlan${SE_VLANNUM}" >> ${ENI}
				if [ -n "${SE_ADDR}" ] ; then
					echo "iface vlan${SE_VLANNUM} inet static" >> ${ENI}
					echo "	vlan-raw-device ${INTERFACE}" >> ${ENI}
					echo "	pre-up ip link set up dev ${SE_IFACE0}" >> ${ENI}
					echo "	pre-up ip link set up dev ${SE_IFACE1}" >> ${ENI}
					echo "	address ${IFACE_ADDR}" >> ${ENI}
					echo "	network ${IFACE_NETWORK}" >> ${ENI}
					echo "	netmask ${IFACE_NETMASK}" >> ${ENI}
					echo "	broadcast ${IFACE_BROADCAST}" >> ${ENI}
					if [ -n "${SE_GW}" ] ; then
						echo "	gateway ${SE_GW}" >> ${ENI}
					fi
					if [ -n "${SE_MTU}" ] ; then
						echo "	mtu 9000" >> ${ENI}
					fi
					echo "" >>${ENI}
				fi
				if [ -n "${SE_ADDR6}" ] ; then
					echo "iface vlan${SE_VLANNUM} inet6 static" >> ${ENI}
					if [ -z "${SE_ADDR}" ] ; then
						echo "	vlan-raw-device ${INTERFACE}" >> ${ENI}
						echo "	pre-up ip link set up dev ${SE_IFACE0}" >> ${ENI}
						echo "	pre-up ip link set up dev ${SE_IFACE1}" >> ${ENI}
					fi
					echo "	address ${SE_ADDR6}" >> ${ENI}
					echo "	accept_ra ${SE_ACCEPT_RA}" >> ${ENI}
					if [ -n "${SE_GW6}" ] ; then
						echo "	gateway ${SE_GW6}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNS}" ] ; then
						echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNSSEARCH}" ] ; then
						echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
					fi
					if [ -z "${SE_ADDR}" ] && [ -n "${SE_MTU}" ] ; then
						echo "	mtu 9000" >> ${ENI}
					fi
					echo "" >>${ENI}
				fi


				if [ -n "${SE_VMNET_ADDR}" ] ; then
					echo "# Interface vlan${SE_VMNET_VLAN}" >> ${ENI}
					echo "auto vlan${SE_VMNET_VLAN}" >> ${ENI}
					echo "iface vlan${SE_VMNET_VLAN} inet static" >> ${ENI}
					echo "	vlan-raw-device ${INTERFACE}" >> ${ENI}
					echo "	pre-up ip link set up dev ${SE_IFACE0}" >> ${ENI}
					echo "	pre-up ip link set up dev ${SE_IFACE1}" >> ${ENI}
					echo "	address ${VMNET_IFACE_ADDR}" >> ${ENI}
					echo "	network ${VMNET_IFACE_NETWORK}" >> ${ENI}
					echo "	netmask ${VMNET_IFACE_NETMASK}" >> ${ENI}
					echo "	broadcast ${VMNET_IFACE_BROADCAST}" >> ${ENI}
					if [ -n "${SE_MTU}" ] ; then
						echo "	mtu 9000" >> ${ENI}
					fi
					echo "" >>${ENI}

				fi
				if [ "${SE_EXTRA_OVS}" = "yes" ] ; then
					echo "auto ${SE_OVSBR}" >> ${ENI}
					echo "iface ${SE_OVSBR} inet manual" >> ${ENI}
					echo "	ovs_type OVSBridge" >> ${ENI}
					echo "	ovs_ports ${INTERFACE}" >> ${ENI}
					echo "	up ovs-vsctl add-port ${SE_OVSBR} ${INTERFACE} || true" >> ${ENI}
					echo "" >> ${ENI}
				fi
			fi
		;;
		"bondvlanbridge")
			INTERFACE=bond${BOND_NUMBER}
			BOND_NUMBER=$(( ${BOND_NUMBER} + 1 ))
			if [ "${RELEASE}" = "wheezy" ] || [ "${RELEASE}" = "stretch" ] || [ "${RELEASE}" = "buster" ] ; then
				# Iface 0
				echo "# Interface ${SE_IFACE0}" >> ${ENI}
				echo "auto ${SE_IFACE0}" >> ${ENI}
				echo "iface ${SE_IFACE0} inet manual" >> ${ENI}
				echo "	bond-master ${INTERFACE}" >> ${ENI}
				echo "" >> ${ENI}
				# Iface 1
				echo "# Interface ${SE_IFACE1}" >> ${ENI}
				echo "auto ${SE_IFACE1}" >> ${ENI}
				echo "iface ${SE_IFACE1} inet manual" >> ${ENI}
				echo "	bond-master ${INTERFACE}" >> ${ENI}
				echo "" >> ${ENI}
			fi

			# Bond iface
			echo "# Interface ${INTERFACE}" >> ${ENI}
			echo "auto ${INTERFACE}" >> ${ENI}
			echo "iface ${INTERFACE} inet manual" >> ${ENI}
			echo "	bond-mode 802.3ad" >> ${ENI}
			echo "	bond-miimon 100" >> ${ENI}
			echo "	bond-lacp-rate 1" >> ${ENI}
			echo "	bond-slaves ${SE_IFACE0} ${SE_IFACE1}" >> ${ENI}
			echo "	bond_xmit_hash_policy layer3+4" >> ${ENI}
			if [ -n "${SE_MTU}" ] ; then
				echo "	mtu 9000" >> ${ENI}
			fi
			echo "" >> ${ENI}
			# Vlan
			echo "# Interface vlan${SE_VLANNUM}" >> ${ENI}
			echo "auto vlan${SE_VLANNUM}" >> ${ENI}
			echo "iface vlan${SE_VLANNUM} inet manual" >> ${ENI}
			echo "	vlan-raw-device ${INTERFACE}" >> ${ENI}
			if [ -n "${SE_MTU}" ] ; then
				echo "	mtu 9000" >> ${ENI}
			fi
			echo "" >> ${ENI}
			# Bridge
			echo "# Interface ${SE_BRNAME}" >> ${ENI}
			echo "auto ${SE_BRNAME}" >> ${ENI}
			if [ -n "${SE_ADDR}" ] ; then
				echo "iface ${SE_BRNAME} inet static" >> ${ENI}
				echo "	bridge_ports vlan${SE_VLANNUM}" >> ${ENI}
				echo "	bridge_maxwait 0" >> ${ENI}
				echo "  pre-up ip link set up dev ${SE_IFACE0}" >> ${ENI}
				echo "  pre-up ip link set up dev ${SE_IFACE1}" >> ${ENI}
				echo "	address ${IFACE_ADDR}" >> ${ENI}
				echo "	network ${IFACE_NETWORK}" >> ${ENI}
				echo "	netmask ${IFACE_NETMASK}" >> ${ENI}
				echo "	broadcast ${IFACE_BROADCAST}" >> ${ENI}
				if [ -n "${SE_GW}" ] ; then
					echo "	gateway ${SE_GW}" >> ${ENI}
				fi
				if [ -n "${SE_DNS}" ] ; then
					echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
				fi
				if [ -n "${SE_DNSSEARCH}" ] ; then
					echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
				fi
				if [ -n "${SE_MTU}" ] ; then
					echo "	mtu 9000" >> ${ENI}
				fi
				echo "" >> ${ENI}
			fi
			if [ -n "${SE_ADDR6}" ] ; then
				echo "iface ${SE_BRNAME} inet6 static" >> ${ENI}
				if [ -z "${SE_ADDR}" ] ; then
					echo "	bridge_ports vlan${SE_VLANNUM}" >> ${ENI}
					echo "	bridge_maxwait 0" >> ${ENI}
					echo "  pre-up ip link set up dev ${SE_IFACE0}" >> ${ENI}
					echo "  pre-up ip link set up dev ${SE_IFACE1}" >> ${ENI}
				fi
				echo "	address ${SE_ADDR6}" >> ${ENI}
				echo "	accept_ra ${SE_ACCEPT_RA}" >> ${ENI}
				if [ -n "${SE_GW6}" ] ; then
					echo "	gateway ${SE_GW6}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNS}" ] ; then
					echo "	dns-nameservers ${SE_ALL_NS}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ -n "${SE_DNSSEARCH}" ] ; then
					echo "	dns-search ${SE_DNSSEARCH}" >> ${ENI}
				fi
				if [ -z "${SE_ADDR}" ] && [ -n "${SE_MTU}" ] ; then
					echo "	mtu 9000" >> ${ENI}
				fi
				echo "" >> ${ENI}
			fi
		;;
		esac
	done
	# Also include /etc/network/interfaces.d
	echo '
# Set this one last, so that cloud-init or user can
# override defaults.
source /etc/network/interfaces.d/*
' >> ${ENI}

	if echo "${STATIC_ETH}" | grep -q bond ; then
		mkdir -p ${MODPROBE}
		echo "options bonding mode=4 lacp_rate=1 xmit_hash_policy=layer3+4" >${MODPROBE}/bonding.conf
	fi
else
# If no --static-iface param is set, then DHCP by default
	echo "# The normal eth0
allow-hotplug eth0
iface eth0 inet dhcp

# Additional interfaces, just in case we're using
# multiple networks
allow-hotplug eth1
iface eth1 inet dhcp

allow-hotplug eth2
iface eth2 inet dhcp

# Set this one last, so that cloud-init or user can
# override defaults.
source /etc/network/interfaces.d/*
" >> ${ENI}
fi

if [ "${HAS_BGP_TO_THE_HOST}" = "yes" ] || [ "${FORCE_FRR}" = "yes" ] ; then
	mkdir -p $(dirname ${FRR_CONF}) $(dirname ${FRR_DAEMONS})
	# Ensure the BGP daemon will run
	sed -i 's/bgpd=.*/bgpd=yes/' ${FRR_DAEMONS}

	echo "log syslog informational

!
service integrated-vtysh-config
!
log syslog informational
!
zebra nexthop-group keep 1
!
	int lo" >>${FRR_CONF}
	for i in $(echo ${BGP_IP_LIST} | tr ',' ' ') ; do
		LOIPTOADD=$(echo ${i} | cut -d/ -f1)
		echo " ip address ${LOIPTOADD}/32" >>${FRR_CONF}
	done
	for i in $(echo ${BGP_IP6_LIST} | tr ',' ' ') ; do
		LOIP6TOADD=$(echo ${i} | cut -d/ -f1)
		echo " ipv6 address ${LOIP6TOADD}/128" >>${FRR_CONF}
	done
	echo "!" >>${FRR_CONF}

	if [ -z "${ROUTER_ID}" ] ; then
		if [ "${HAS_BGP_TO_THE_HOST}" = "yes" ] && [ "${FORCE_FRR}" != "yes" ] ; then
			ROUTER_ID=$(echo ${BGP_IP_LIST} | cut -d, -f1 | cut -d/ -f1)
		fi
		# IPv6 only setup: fall back on the ID derived from the IPv6 address
		if [ -z "${ROUTER_ID}" ] ; then
			ROUTER_ID=${ROUTER_ID_V6}
		fi
	fi
	if [ -z "${ROUTER_ID}" ] ; then
		echo "Unable to determine a BGP router ID: please set router-id=<dotted-quad> or addr6=<IPv6-CIDR> in --static-iface."
		exit 1
	fi

	echo "router bgp ${BGP_ASNUM}
 bgp router-id ${ROUTER_ID}
 bgp bestpath as-path multipath-relax
 bgp bestpath compare-routerid
 neighbor pg-leaf peer-group
 neighbor pg-leaf remote-as external
 neighbor pg-leaf capability extended-nexthop" >>${FRR_CONF}
	for i in $(echo ${BGP_IFACE_LIST} | tr ',' ' ') ; do
		echo " neighbor ${i} interface peer-group pg-leaf" >>${FRR_CONF}
	done
	echo " !
 address-family ipv4 unicast
  redistribute connected route-map map-redistribute
  neighbor pg-leaf soft-reconfiguration inbound
  neighbor pg-leaf route-map map-leaf-in in
  neighbor pg-leaf route-map map-leaf-out out
 exit-address-family
 !
 address-family ipv6 unicast
  redistribute connected route-map map-redistribute
  neighbor pg-leaf activate
  neighbor pg-leaf soft-reconfiguration inbound
  neighbor pg-leaf route-map map-leaf-in in
  neighbor pg-leaf route-map map-leaf-out out
 exit-address-family
!
route-map map-redistribute permit 10
 match interface lo
!
route-map map-leaf-out permit 10
 match interface lo
!
" >>${FRR_CONF}

	if [ "${FORCE_FRR}" = "yes" ] ; then
		# In case of force-frr, do not accept routes from neighboring switch.
		# We want all to go through the L2 connected interface.
		if [ -n "${BGP_IP6_LIST}" ] ; then
			echo "ip prefix-list default seq 5 permit 0.0.0.0/0
!
ipv6 prefix-list default seq 5 permit ::/0
!
route-map map-leaf-in permit 10
 match ip address prefix-list default
!
route-map map-leaf-in permit 20
 match ipv6 address prefix-list default
!
route-map map-leaf-in deny 30
!
" >>${FRR_CONF}
		else
			echo "ip prefix-list default seq 5 permit 0.0.0.0/0
!
route-map map-leaf-in permit 10
 match ip address prefix-list default
!
route-map map-leaf-in deny 20
!
" >>${FRR_CONF}
		fi
	else
		if [ -n "${BGP_IP6_LIST}" ] ; then
			# With IPv6, the route-map needs per-family match clauses, as
			# both address-families use it, and "set src" must match each
			# family's source address.
			echo "ip prefix-list all seq 5 permit 0.0.0.0/0 le 32
!
ipv6 prefix-list all seq 5 permit ::/0 le 128
!
route-map map-leaf-in permit 10
 match ip address prefix-list all" >>${FRR_CONF}
			source_ip=$(echo ${BGP_IP_LIST} | cut -f1 -d, | cut -f1 -d/)
			if [ -n "${source_ip}" ] ; then
				echo " set src ${source_ip}" >>${FRR_CONF}
			fi
			source_ip6=$(echo ${BGP_IP6_LIST} | cut -f1 -d, | cut -f1 -d/)
			echo "!
route-map map-leaf-in permit 20
 match ipv6 address prefix-list all
 set src ${source_ip6}
!
" >>${FRR_CONF}
		else
			echo "route-map map-leaf-in permit 10" >>${FRR_CONF}
			source_ip=$(echo ${BGP_IP_LIST} | cut -f1 -d, | cut -f1 -d/)
			if [ -n "${source_ip}" ] ; then
				echo " set src ${source_ip}" >>${FRR_CONF}
			fi
			echo "!
" >>${FRR_CONF}
		fi
	fi

	if [ -n "${OVNVRF_ID}" ] ; then
		# Static BGP instance for the OVN chassis router VRF fabric
		# session, mirroring what the neutron-ovn-agent's bgp
		# extension used to render. The VRF device itself is created
		# by ovn-controller's route exchange (dynamic-routing-vrf-id
		# on the chassis router, matching this <VRF_ID>), the BGP
		# bridge (br-ex) is enslaved to it by the agent, and FRR
		# then peers unnumbered over it. The default-table instance
		# above remains as the fallback transport while the VRF
		# device doesn't exist (boot window, ovn-controller stop).
		echo "router bgp ${BGP_ASNUM} vrf ovnvrf${OVNVRF_ID}
 bgp router-id ${ROUTER_ID}
 no bgp ebgp-requires-policy
 neighbor PG-VRF${OVNVRF_ID} peer-group
 neighbor PG-VRF${OVNVRF_ID} remote-as external
 neighbor PG-VRF${OVNVRF_ID} capability extended-nexthop
 neighbor br-ex interface peer-group PG-VRF${OVNVRF_ID}
 !
 address-family ipv4 unicast
  redistribute kernel
  redistribute connected
  redistribute table ${OVNVRF_ID}
  redistribute table-direct ${OVNVRF_ID}
  neighbor PG-VRF${OVNVRF_ID} activate
  neighbor PG-VRF${OVNVRF_ID} soft-reconfiguration inbound
 exit-address-family
 !
  address-family ipv6 unicast
   redistribute kernel
   neighbor PG-VRF${OVNVRF_ID} activate
   neighbor PG-VRF${OVNVRF_ID} soft-reconfiguration inbound
  exit-address-family
exit
!
" >>${FRR_CONF}
	fi
fi
