Remove support for Rapid Spanning Tree Protocol

[network.git] / src / functions / functions.stp

#!/bin/bash
###############################################################################
#                                                                             #
# IPFire.org - A linux based firewall                                         #
# Copyright (C) 2010  Michael Tremer & Christian Schmidt                      #
#                                                                             #
# 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 3 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/>.       #
#                                                                             #
###############################################################################

stp_enable() {
	local bridge=${1}
	assert isset bridge

	# Tell the kernel to enable STP.
	print 1 > ${SYS_CLASS_NET}/${bridge}/bridge/stp_state
}

stp_disable() {
	local bridge=${1}
	assert isset bridge

	# Tell the kernel to disable STP.
	print 0 > ${SYS_CLASS_NET}/${bridge}/bridge/stp_state
}

stp_is_enabled() {
	local bridge=${1}
	assert isset bridge

	local state=$(__device_get_file ${bridge} bridge/stp_state)

	case "${state}" in
		0)
			return ${EXIT_FALSE}
			;;
		*)
			return ${EXIT_TRUE}
			;;
	esac
}

stp_bridge_get_id() {
	local bridge=${1}
	assert isset bridge

	__device_get_file ${bridge} "bridge/bridge_id"

	return $?
}

stp_bridge_get_forward_delay() {
	local bridge=${1}
	assert isset bridge

	local output=$(__device_get_file ${bridge} bridge/forward_delay)
	__stp_div_100 ${output}

	return ${EXIT_OK}
}

stp_bridge_set_forward_delay() {
	local bridge=${1}
	assert isset bridge

	local fdelay=${2}
	assert isinteger fdelay

	# The smallest value that may be set is 2.
	if [ ${fdelay} -lt 2 ]; then
		fdelay=2
	fi

	# Check if the setting we want is already set.
	local current_fdelay=$(stp_bridge_get_forward_delay ${bridge})
	[ ${fdelay} -eq ${current_fdelay} ] && return ${EXIT_OK}

	# Set the new value.
	log DEBUG "Setting forward delay on bridge '${bridge}' from '${current_fdelay}' to '${fdelay}'"
	fwrite "${SYS_CLASS_NET}/${bridge}/bridge/forward_delay" "$(( ${fdelay} * 100 ))"

	return ${EXIT_OK}
}

stp_bridge_get_hello_time() {
	local bridge=${1}
	assert isset bridge

	local ht=$(__device_get_file ${bridge} bridge/hello_time)
	__stp_div_100 ${ht}

	return ${EXIT_OK}
}

stp_bridge_set_hello_time() {
	local bridge=${1}
	assert isset bridge

	local hello=${2}
	assert isinteger hello

	# Check if the setting we want is already set.
	local current_hello=$(stp_bridge_get_hello_time ${bridge})
	[ ${hello} -eq ${current_hello} ] && return ${EXIT_OK}

	# Set the new value.
	log INFO "Changing hello time for '${bridge}': ${current_hello} --> ${hello}"
	print "$(( ${hello} * 100 ))" > ${SYS_CLASS_NET}/${bridge}/bridge/hellow_time

	return ${EXIT_OK}
}

stp_bridge_get_max_age() {
	local bridge=${1}
	assert isset bridge

	local maxage=$(__device_get_file ${bridge} "bridge/max_age")
	__stp_div_100 ${maxage}

	return ${EXIT_OK}
}

stp_bridge_set_max_age() {
	local bridge=${1}
	assert isset bridge

	local maxage=${2}
	assert isinteger maxage

	# Check if the setting we want is already set.
	local current_maxage=$(stp_bridge_get_max_age ${bridge})
	[ ${maxage} -eq ${current_maxage} ] && return ${EXIT_OK}

	# Set the new value.
	log INFO "Changing max age for '${bridge}': ${current_maxage} --> ${maxage}"
	print "$(( ${maxage} * 100 ))" > ${SYS_CLASS_NET}/${bridge}/bridge/max_age

	return ${EXIT_OK}
}

stp_bridge_get_priority() {
	local bridge=${1}
	assert isset bridge

	__device_get_file ${bridge} "bridge/priority"
	return ${EXIT_OK}
}

stp_bridge_set_priority() {
	local bridge=${1}
	assert isset bridge

	local priority=${2}
	assert isinteger priority

	# Check if the setting we want is already set.
	local current_priority=$(stp_bridge_get_priority ${bridge})
	[ ${priority} -eq ${current_priority} ] && return ${EXIT_OK}

	# Set the new value.
	log INFO "Changing priority for '${bridge}': ${current_priority} --> ${priority}"
	print "${priority}" > ${SYS_CLASS_NET}/${bridge}/bridge/priority

	return ${EXIT_OK}
}

stp_bridge_get_designated_root() {
	local bridge=${1}
	assert isset bridge

	local output

	output=$(__device_get_file ${bridge} bridge/root_id)
	output=${output:6}

	# Print output (lowercase).
	print "${output,,}"

	if isset output; then
		return ${EXIT_OK}
	else
		return ${EXIT_ERROR}
	fi
}

stp_bridge_get_root_path_cost() {
	local bridge=${1}
	assert isset bridge

	__device_get_file ${bridge} bridge/root_path_cost
}

stp_bridge_get_root_port_id() {
	local bridge=${1}
	assert isset bridge

	__device_get_file ${bridge} bridge/root_port_id
}

stp_bridge_get_root_port() {
	local bridge=${1}
	assert isset bridge

	local id=$(stp_bridge_get_root_port_id ${bridge})

	local member member_id
	for member in $(bridge_get_members ${bridge}); do
		member_id=$(stp_port_get_id ${bridge} ${member})

		if [ "${id}" = "${member_id}" ]; then
			print "${member}"
			return ${EXIT_OK}
		fi
	done

	return ${EXIT_ERROR}
}

stp_bridge_is_root() {
	local bridge=${1}
	assert isset bridge

	local root_path_cost=$(stp_bridge_get_root_path_cost ${bridge})

	if [ "${root_path_cost}" = "0" ]; then
		return ${EXIT_TRUE}
	fi

	return ${EXIT_FALSE}
}

stp_bridge_get_topology_change_count() {
	local bridge=${1}
	assert isset bridge

	__device_get_file ${bridge} bridge/topology_change
}

stp_bridge_get_topology_change_timer() {
	local bridge=${1}
	assert isset bridge

	__device_get_file ${bridge} bridge/topology_change_timer
}

stp_bridge_get_topology_change_detected() {
	local bridge=${1}
	assert isset bridge

	local change

	change=$(__device_get_file ${bridge} bridge/topology_change_detected)

	if enabled change; then
		print "yes"
		return ${EXIT_TRUE}
	else
		print "no"
		return ${EXIT_FALSE}
	fi
}

stp_port_get_state() {
	local bridge=${1}
	assert isset bridge

	local port=${2}
	assert isset port

	local state=$(__device_get_file ${bridge} brif/${port}/state)

	case "${state}" in
		0)
			print "DISABLED"
			;;
		1)
			print "LISTENING"
			;;
		2)
			print "LEARNING"
			;;
		3)
			print "FORWARDING"
			;;
		4)
			print "BLOCKING"
			;;
		*)
			return ${EXIT_ERROR}
			;;
	esac

	return ${EXIT_OK}
}

stp_port_get_id() {
	local bridge=${1}
	assert isset bridge

	local port=${2}
	assert isset port

	dec $(__device_get_file ${bridge} "brif/${port}/port_no")
	return ${EXIT_OK}
}

stp_port_get_cost() {
	local bridge=${1}
	assert isset bridge

	local port=${2}
	assert isset port

	__device_get_file ${bridge} brif/${port}/path_cost
}

stp_port_set_cost() {
	assert [ $# -eq 3 ]

	local bridge="${1}"
	local port="${2}"
	local cost="${3}"

	local old_cost="$(stp_port_get_cost "${bridge}" "${port}")"
	if [ "${cost}" = "${old_cost}" ]; then
		return ${EXIT_OK}
	fi

	log DEBUG "Setting STP path costs of port '${port}' (bridge '${bridge}') to '${cost}'"

	__device_set_file "${bridge}" "brif/${port}/path_cost" "${cost}"
}

stp_port_get_designated_root() {
	local bridge=${1}
	assert isset bridge

	local port=${2}
	assert isset port

	local output=$(__device_get_file ${bridge} brif/${port}/designated_root)

	if isset output; then
		mac_format ${output:5}
		return ${EXIT_OK}
	fi

	return ${EXIT_ERROR}
}

__stp_div_100() {
	local val=${1}

	local split=$((${#val} - 2))
	val="${val:0:${split}}.${val:${split}:2}"

	# Round the output.
	print "%.0f" "${val}"
}