[people/stevee/network.git] / src / functions / functions.zone

#!/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/>.       #
#                                                                             #
###############################################################################

function zone_dir() {
	local zone=${1}

	echo "${NETWORK_ZONE_DIR}/zones/${zone}"
}

function zone_exists() {
	local zone=${1}
	assert isset zone

	[ -d "$(zone_dir ${zone})" ]
}

function zone_match() {
	local match

	local i
	for i in ${VALID_ZONES}; do
		match="${match}|${i}[0-9]{1,5}"
	done

	echo "${match:1:${#match}}"
}

function zone_name_is_valid() {
	local zone=${1}

	# Don't accept empty strings.
	[ -z "${zone}" ] && return ${EXIT_FALSE}

	[[ ${zone} =~ $(zone_match) ]]
}

function zone_is_local() {
	local zone=${1}

	[[ "${zone:0:${#ZONE_LOCAL}}" = "${ZONE_LOCAL}" ]]
}

function zone_is_nonlocal() {
	local zone=${1}

	[[ "${zone:0:${#ZONE_NONLOCAL}}" = "${ZONE_NONLOCAL}" ]]
}

function zone_get_hook() {
	local zone=${1}
	assert isset zone

	config_get_hook $(zone_dir ${zone})/settings
}

function zone_start() {
	# This function will bring up the zone
	# 'asynchronously' with help of systemd.

	local zone=${1}
	assert zone_exists ${zone}

	service_start "network@${zone}.service"
}

function zone_stop() {
	# This function will bring down the zone
	# 'asynchronously' with help of systemd.

	local zone=${1}
	assert zone_exists ${zone}

	service_stop "network@${zone}.service"
}

function zone_reload() {
	local zone="${1}"
	assert zone_exists "${zone}"

	service_reload "network@${zone}.service"
}

function zone_hotplug_event() {
	local zone="${1}"
	assert zone_exists "${zone}"

	# If the zone has already been started, we
	# will reload it so the current configuration
	# is re-applied.
	if zone_is_active "${zone}"; then
		zone_reload "${zone}"
		return ${?}

	# If the zone is still down, but in auto-start mode,
	# we will start it.
	elif zone_is_enabled "${zone}"; then
		zone_start "${zone}"
		return ${?}
	fi

	# Otherwise, nothing will be done.
	return ${EXIT_OK}
}

function zone_enable() {
	# This function will enable the zone
	# with help of systemd.

	local zone="${1}"
	assert zone_exists "${zone}"

	# Enable service for the zone
	service_enable "network@${zone}.service"
	local ret=$?

	if [ ${ret} -eq ${EXIT_OK} ]; then
		log INFO "Auto-start enabled for zone ${zone}"
		return ${EXIT_OK}
	fi

	log ERROR "Could not enable zone ${zone}: ${ret}"
	return ${ret}
}

function zone_disable() {
	# This function will disable the zone
	# with help of systemd.

	local zone="${1}"
	assert zone_exists "${zone}"

	# Disable service for the zone
	service_disable "network@${zone}.service"
	local ret=$?

	if [ ${ret} -eq ${EXIT_OK} ]; then
		log INFO "Auto-start disabled for zone ${zone}"
		return ${EXIT_OK}
	fi

	log ERROR "Could not disable zone ${zone}: ${ret}"
	return ${ret}
}

function zone_is_enabled() {
	local zone="${1}"
	assert isset zone

	# Ask systemd if the zone is enabled.
	if service_is_enabled "network@${zone}.service"; then
		return ${EXIT_TRUE}
	fi

	return ${EXIT_FALSE}
}

function zone_is_active() {
	local zone="${1}"
	assert isset zone

	if service_is_active "network@${zone}.service"; then
		return ${EXIT_TRUE}
	fi

	return ${EXIT_FALSE}
}

function zone_create() {
	local zone=${1}
	local hook=${2}
	shift 2

	if ! zone_name_is_valid ${zone}; then
		error "Zone name '${zone}' is not valid."
		return ${EXIT_ERROR}
	fi

	if zone_exists ${zone}; then
		error "Zone '${zone}' does already exist."
		return ${EXIT_ERROR}
	fi

	if ! hook_zone_exists ${hook}; then
		error "Hook '${hook}' does not exist."
		return ${EXIT_ERROR}
	fi

	mkdir -p $(zone_dir ${zone})

	# Create directories for configs and ports
	mkdir -p $(zone_dir ${zone})/{configs,ports}

	hook_zone_exec ${hook} create ${zone} $@
	local ret=$?

	# Maybe the zone create hook did not exit correctly.
	# If this is the case we remove the created zone immediately.
	if [ "${ret}" = "${EXIT_ERROR}" ]; then
		zone_remove_now ${zone}
		return ${EXIT_ERROR}
	fi

	# Automatically enable zone.
	zone_enable "${zone}"
}

function zone_edit() {
	local zone=${1}
	shift

	if ! zone_exists ${zone}; then
		error "Zone '${zone}' does not exist."
		return ${EXIT_ERROR}
	fi

	# Check if the zone is tagged for removal.
	if zone_has_remove_tag ${zone}; then
		error "You cannot edit a zone that is tagged for removal."
		return ${EXIT_ERROR}
	fi

	local hook=$(config_get_hook $(zone_dir ${zone})/settings)

	if [ -z "${hook}" ]; then
		error "Config file did not provide any hook."
		return ${EXIT_ERROR}
	fi

	if ! hook_zone_exists ${hook}; then
		error "Hook '${hook}' does not exist."
		return ${EXIT_ERROR}
	fi

	hook_zone_exec ${hook} edit ${zone} $@
}


function zone_remove() {
	local zone=${1}
	assert zone_exists ${zone}

	# Make the zone for removal.
	touch $(zone_dir ${zone})/.remove

	log INFO "Zone '${zone}' has been tagged for removal."
}

function zone_has_remove_tag() {
	local zone=${1}
	assert zone_exists ${zone}

	[ -e "$(zone_dir ${zone})/.remove" ]
}

# This function will remove the given zone
# RIGHT NOW. Use zone_remove to remove it
# at the next status change.
function zone_remove_now() {
	local zone=${1}
	assert zone_exists ${zone}

	log INFO "Removing zone '${zone}' right now."

	# Force the zone down.
	zone_is_up ${zone} && zone_set_down ${zone}

	# Disable zone.
	zone_disable "${zone}"

	rm -rf $(zone_dir ${zone})
}

function zone_up() {
	local zone=${1}
	shift

	if ! zone_exists ${zone}; then
		error "Zone '${zone}' does not exist."
		return ${EXIT_ERROR}
	fi

	# Check if a zone has got the remove tag.
	if zone_has_remove_tag ${zone}; then
		error "Cannot bring up any zone which is to be removed."
		return ${EXIT_ERROR}
	fi

	local hook=$(config_get_hook $(zone_dir ${zone})/settings)

	if [ -z "${hook}" ]; then
		error "Config file did not provide any hook."
		return ${EXIT_ERROR}
	fi

	if ! hook_zone_exists ${hook}; then
		error "Hook '${hook}' does not exist."
		return ${EXIT_ERROR}
	fi

	zone_db ${zone} starting

	hook_zone_exec ${hook} up ${zone} $@

	zone_db ${zone} started
}

function zone_down() {
	local zone=${1}
	shift

	if ! zone_exists ${zone}; then
		error "Zone '${zone}' does not exist."
		return ${EXIT_ERROR}
	fi

	local hook=$(config_get_hook $(zone_dir ${zone})/settings)

	if [ -z "${hook}" ]; then
		error "Config file did not provide any hook."
		return ${EXIT_ERROR}
	fi

	if ! hook_zone_exists ${hook}; then
		error "Hook '${hook}' does not exist."
		return ${EXIT_ERROR}
	fi

	zone_db ${zone} stopping

	hook_zone_exec ${hook} down ${zone} $@

	zone_db ${zone} stopped

	# Remove the zone, if it has got a remove tag.
	if zone_has_remove_tag ${zone}; then
		zone_remove_now ${zone}
	fi
}

function zone_status() {
	local zone=${1}
	shift

	if ! zone_exists ${zone}; then
		error "Zone '${zone}' does not exist."
		return ${EXIT_ERROR}
	fi

	local hook=$(config_get_hook $(zone_dir ${zone})/settings)

	if [ -z "${hook}" ]; then
		error "Config file did not provide any hook."
		return ${EXIT_ERROR}
	fi

	if ! hook_zone_exists ${hook}; then
		error "Hook '${hook}' does not exist."
		return ${EXIT_ERROR}
	fi

	hook_zone_exec ${hook} status ${zone} $@

	# Show that the zone it to be removed soon.
	if zone_has_remove_tag ${zone}; then
		warning "This zone is tagged for removal."
	fi
}

function zone_port() {
	local zone=${1}
	local action=${2}
	shift 2

	assert isset zone
	assert isset action
	assert zone_exists ${zone}

	case "${action}" in
		add|edit|remove)
			zone_port_${action} ${zone} $@
			;;
		*)
			error "Unrecognized argument: ${action}"
			cli_usage root-zone-port-subcommands
			exit ${EXIT_ERROR}
			;;		
	esac
}

function zone_port_add() {
	local zone="${1}"
	assert isset zone

	local port="${2}"
	assert isset port

	shift 2

	# Check if the port actually exists.
	if ! port_exists "${port}"; then
		error "Cannot add port '${port}' which does not exist"
		return ${EXIT_ERROR}
	fi

	# Check if the port is already connected to this or any other zone.
	local z
	for z in $(zones_get_all); do
		if zone_has_port "${z}" "${port}"; then
			error "Port '${port}' is already assigned to zone '${z}'"
			return ${EXIT_ERROR}
		fi
	done

	local hook=$(zone_get_hook "${zone}")
	assert isset hook

	hook_zone_exec "${hook}" "port_add" "${zone}" "${port}" "$@"
}

function zone_port_edit() {
	local zone="${1}"
	assert isset zone

	local port="${2}"
	assert isset port

	shift 2

	# Check if the port actually exists.
	if ! port_exists "${port}"; then
		error "Port '${port}' does not exist"
		return ${EXIT_ERROR}
	fi

	# Check if the zone actually has this port.
	if ! zone_has_port "${zone}" "${port}"; then
		error "Port '${port}' is not attached to zone '${zone}'"
		return ${EXIT_ERROR}
	fi

	local hook=$(zone_get_hook "${zone}")
	assert isset hook

	hook_zone_exec "${hook}" "port_edit" "${zone}" "${port}" "$@"
}

function zone_port_remove() {
	local zone="${1}"
	assert isset zone

	local port="${2}"
	assert isset port

	shift 2

	# Check if the zone actually has this port.
	if ! zone_has_port "${zone}" "${port}"; then
		error "Port '${port}' is not attached to zone '${zone}'"
		return ${EXIT_ERROR}
	fi

	local hook=$(zone_get_hook "${zone}")
	assert isset hook

	hook_zone_exec "${hook}" "port_remove" "${zone}" "${port}" "$@"
}

function zone_get_ports() {
	local zone=${1}

	assert isset zone

	local port
	for port in $(zone_dir ${zone})/ports/*; do
		port=$(basename ${port})

		if port_exists ${port}; then
			echo "${port}"
		fi
	done
}

function zone_get_ports_num() {
	local zone="${1}"
	assert isset zone

	local counter=0
	local port
	for port in $(zone_dir "${zone}")/ports/*; do
		port="$(basename "${port}")"

		if port_exists "${port}"; then
			counter=$(( ${counter} + 1 ))
		fi
	done

	echo "${counter}"
	return ${EXIT_OK}
}

function zone_has_port() {
	# Check, if the given port is configured
	# in this zone.

	local zone=${1}
	local port=${2}
	shift 2

	assert isset zone
	assert isset port

	[ -e "$(zone_dir ${zone})/ports/${port}" ]
}

function zone_config() {
	local zone="${1}"
	local cmd="${2}"
	shift 2

	assert isset zone
	assert isset cmd
	assert zone_exists "${zone}"

	case "${cmd}" in
		create)
			zone_config_create "${zone}" "$@"
			;;
		edit)
			zone_config_edit "${zone}" "$@"
			;;
		remove)
			zone_config_remove "${zone}" "$@"
			;;
		*)
			error "Unrecognized argument: ${cmd}"
			cli_usage root-zone-config-subcommands
			exit ${EXIT_ERROR}
			;;
	esac
}

function zone_config_cmd() {
	assert [ $# -gt 2 ]

	local cmd="${1}"
	local zone="${2}"
	shift 2

	local hook="$(zone_get_hook "${zone}")"
	assert isset hook

	hook_zone_exec "${hook}" "config_${cmd}" "${zone}" "$@"
}

function zone_config_create() {
	zone_config_cmd "create" "$@"
}

function zone_config_edit() {
	zone_config_cmd "edit" "$@"
}

function zone_config_remove() {
	zone_config_cmd "remove" "$@"
}

function zone_config_show() {
	zone_config_cmd "show" "$@"
}

function zone_show() {
	local zone=${1}

	echo "${zone}"
	echo "  Type: $(zone_get_hook ${zone})"
	echo
}

function zones_show() {
	local zone

	for zone in $(zones_get $@); do
		zone_show ${zone}
	done
}

function zones_get_all() {
	local zone
	for zone in $(zone_dir)/*; do
		zone=$(basename ${zone})
		zone_exists ${zone} || continue

		echo "${zone}"
	done
}

function zones_get_local() {
	local zone
	for zone in $(zones_get_all); do
		zone_is_local ${zone} && echo "${zone}"
	done
}

function zones_get_nonlocal() {
	local zone
	for zone in $(zones_get_all); do
		zone_is_nonlocal ${zone} && echo "${zone}"
	done
}

function zones_get() {
	local local=1
	local remote=1

	local zones

	while [ $# -gt 0 ]; do
		case "${1}" in
			--local-only)
				local=1
				remote=0
				;;
			--remote-only)
				local=0
				remote=1
				;;
			--all)
				local=1
				remote=1
				;;
			*)
				if zone_name_is_valid ${1}; then
					zones="${zones} ${1}"
				else			
					warning "Unrecognized argument '${1}'"
				fi
				;;
		esac
		shift
	done

	if [ -n "${zones}" ]; then
		local zone
		for zone in ${zones}; do
			zone_exists ${zone} && echo "${zone}"
		done
		exit ${EXIT_OK}
	fi

	if [ ${local} -eq 1 ] && [ ${remote} -eq 1 ]; then
		zones_get_all
	elif [ ${local} -eq 1 ]; then
		zones_get_local
	elif [ ${remote} -eq 1 ]; then
		zones_get_nonlocal
	fi
}

function zone_ports_list() {
	local zone=${1}

	local port
	for port in $(zone_dir ${zone})/ports/*; do
		[ -e "${port}" ] || continue

		echo $(basename ${port})
	done
}

function zone_ports_cmd() {
	local cmd=${1}
	local zone=${2}
	shift 2

	assert isset cmd
	assert isset zone

	assert zone_exists ${zone}

	local hook=$(zone_get_hook ${zone})

	local port
	for port in $(zone_get_ports ${zone}); do
		hook_zone_exec ${hook} ${cmd} ${zone} ${port} $@
	done
}

function zone_ports_up() {
	zone_ports_cmd port_up $@
}

function zone_ports_down() {
	zone_ports_cmd port_down $@
}

function zone_ports_status() {
	zone_ports_cmd port_status $@
}

function zone_configs_cmd() {
	assert [ $# -gt 2 ]

	local cmd="${1}"
	local zone="${2}"
	shift 2

	assert zone_exists "${zone}"

	local config
	for config in $(zone_get_configs "${zone}"); do
		hook_config_exec "${config}" "${cmd}" "${zone}" $@
	done
}

function zone_configs_up() {
	zone_configs_cmd "up" $@
}

function zone_configs_down() {
	zone_configs_cmd "down" $@
}

function zone_configs_status() {
	zone_configs_cmd "status" $@
}

function zone_configs_list() {
	local zone=${1}

	local config
	for config in $(zone_dir ${zone})/configs/*; do
		[ -e "${config}" ] || continue

		basename ${config}
	done
}

function zone_has_ip() {
	device_has_ip $@
}

function zone_db() {
	local zone=${1}
	local action=${2}
	shift 2

	case "${action}" in
		starting|started|stopping|stopped)
			db_connection_update ${zone} ${action}
			;;
	esac
}

function zone_is_up() {
	local zone=${1}

	device_is_up ${zone}
}

function zone_is_down() {
	! zone_is_up $@
}

function zone_get_supported_port_hooks() {
	local zone=${1}

	local hook=$(zone_get_hook ${zone})

	hook_zone_ports_get_all ${hook}
}

function zone_get_supported_config_hooks() {
	hook_config_get_all
}

function zone_file() {
	local zone=${1}

	assert isset zone

	echo "$(zone_dir ${zone})/settings"
}

function zone_settings_read() {
	local zone=${1}

	assert isset zone

	# Save the HOOK variable.
	local hook="${HOOK}"

	settings_read $(zone_file ${zone})

	# Restore hook.
	HOOK="${hook}"
}

function zone_settings_write() {
	local zone=${1}

	assert isset zone

	settings_write $(zone_file ${zone}) ${HOOK_SETTINGS}
}

function zone_settings_set() {
	local zone=${1}
	shift
	local args="$@"

	assert isset zone

	(
		zone_settings_read ${zone}

		for arg in ${args}; do
			eval "${arg}"
		done
	
		zone_settings_write ${zone}
	)
}

function zone_settings_get() {
	local zone=${1}
	local key=${2}

	assert isset zone
	assert isset key

	(
		zone_settings_read ${zone}

		echo "${!key}"
	)
}

function zone_config_settings_read() {
	assert [ $# -gt 2 ]

	local zone="${1}"
	local config="${2}"
	shift 2

	local path="$(zone_dir "${zone}")/configs/${config}"
	settings_read "${path}" "$@"
}

function zone_config_settings_write() {
	assert [ $# -gt 2 ]

	local zone="${1}"
	local config="${2}"
	shift 2

	local path="$(zone_dir "${zone}")/configs/${config}"
	settings_write "${path}" "$@"
}

function zone_port_settings_read() {
	assert [ $# -gt 2 ]

	local zone="${1}"
	local port="${2}"
	shift 2

	local path="$(zone_dir "${zone}")/ports/${port}"
	settings_read "${path}" "$@"
}

function zone_port_settings_write() {
	assert [ $# -gt 2 ]

	local zone="${1}"
	local port="${2}"
	shift 2

	local path="$(zone_dir "${zone}")/ports/${port}"
	settings_write "${path}" "$@"
}

function zone_port_settings_remove() {
	assert [ $# -eq 2 ]

	local zone="${1}"
	local port="${2}"

	local path="$(zone_dir "${zone}")/ports/${port}"
	settings_remove "${path}"
}
Commit	Line	Data
1848564d MT	1	#!/bin/bash
	2	###############################################################################
	3	# #
	4	# IPFire.org - A linux based firewall #
	5	# Copyright (C) 2010 Michael Tremer & Christian Schmidt #
	6	# #
	7	# This program is free software: you can redistribute it and/or modify #
	8	# it under the terms of the GNU General Public License as published by #
	9	# the Free Software Foundation, either version 3 of the License, or #
	10	# (at your option) any later version. #
	11	# #
	12	# This program is distributed in the hope that it will be useful, #
	13	# but WITHOUT ANY WARRANTY; without even the implied warranty of #
	14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
	15	# GNU General Public License for more details. #
	16	# #
	17	# You should have received a copy of the GNU General Public License #
	18	# along with this program. If not, see <http://www.gnu.org/licenses/>. #
	19	# #
	20	###############################################################################
	21
	22	function zone_dir() {
	23	local zone=${1}
	24
d2a21d01	25	echo "${NETWORK_ZONE_DIR}/zones/${zone}"
1848564d MT	26	}
	27
	28	function zone_exists() {
	29	local zone=${1}
711ffac1 MT	30	assert isset zone
711ffac1 MT	31
1848564d MT	32	[ -d "$(zone_dir ${zone})" ]
	33	}
	34
	35	function zone_match() {
	36	local match
	37
	38	local i
	39	for i in ${VALID_ZONES}; do
	40	match="${match}\|${i}[0-9]{1,5}"
	41	done
	42
	43	echo "${match:1:${#match}}"
	44	}
	45
	46	function zone_name_is_valid() {
	47	local zone=${1}
4fedddef MT	48
	49	# Don't accept empty strings.
	50	[ -z "${zone}" ] && return ${EXIT_FALSE}
711ffac1	51
1848564d MT	52	[[ ${zone} =~ $(zone_match) ]]
	53	}
	54
	55	function zone_is_local() {
	56	local zone=${1}
	57
7de0637a	58	[[ "${zone:0:${#ZONE_LOCAL}}" = "${ZONE_LOCAL}" ]]
5e42d659 MT	59	}
	60
	61	function zone_is_nonlocal() {
	62	local zone=${1}
	63
7de0637a	64	[[ "${zone:0:${#ZONE_NONLOCAL}}" = "${ZONE_NONLOCAL}" ]]
1848564d MT	65	}
	66
	67	function zone_get_hook() {
	68	local zone=${1}
711ffac1 MT	69	assert isset zone
711ffac1 MT	70
1848564d MT	71	config_get_hook $(zone_dir ${zone})/settings
	72	}
	73
5bb2429a MT	74	function zone_start() {
	75	# This function will bring up the zone
	76	# 'asynchronously' with help of systemd.
	77
	78	local zone=${1}
	79	assert zone_exists ${zone}
	80
1d08b9b3	81	service_start "network@${zone}.service"
5bb2429a MT	82	}
	83
	84	function zone_stop() {
	85	# This function will bring down the zone
	86	# 'asynchronously' with help of systemd.
	87
	88	local zone=${1}
	89	assert zone_exists ${zone}
	90
1d08b9b3	91	service_stop "network@${zone}.service"
5bb2429a MT	92	}
5bb2429a MT	93
e6fd23fd MT	94	function zone_reload() {
	95	local zone="${1}"
	96	assert zone_exists "${zone}"
	97
	98	service_reload "network@${zone}.service"
	99	}
	100
fb8c7c92 MT	101	function zone_hotplug_event() {
	102	local zone="${1}"
	103	assert zone_exists "${zone}"
	104
	105	# If the zone has already been started, we
	106	# will reload it so the current configuration
	107	# is re-applied.
	108	if zone_is_active "${zone}"; then
	109	zone_reload "${zone}"
	110	return ${?}
	111
	112	# If the zone is still down, but in auto-start mode,
	113	# we will start it.
	114	elif zone_is_enabled "${zone}"; then
	115	zone_start "${zone}"
	116	return ${?}
	117	fi
	118
	119	# Otherwise, nothing will be done.
	120	return ${EXIT_OK}
	121	}
	122
5c5b8e36 SS	123	function zone_enable() {
	124	# This function will enable the zone
	125	# with help of systemd.
	126
	127	local zone="${1}"
	128	assert zone_exists "${zone}"
	129
	130	# Enable service for the zone
	131	service_enable "network@${zone}.service"
	132	local ret=$?
	133
	134	if [ ${ret} -eq ${EXIT_OK} ]; then
	135	log INFO "Auto-start enabled for zone ${zone}"
	136	return ${EXIT_OK}
	137	fi
	138
	139	log ERROR "Could not enable zone ${zone}: ${ret}"
	140	return ${ret}
	141	}
	142
	143	function zone_disable() {
	144	# This function will disable the zone
	145	# with help of systemd.
	146
	147	local zone="${1}"
	148	assert zone_exists "${zone}"
	149
	150	# Disable service for the zone
	151	service_disable "network@${zone}.service"
	152	local ret=$?
	153
	154	if [ ${ret} -eq ${EXIT_OK} ]; then
	155	log INFO "Auto-start disabled for zone ${zone}"
	156	return ${EXIT_OK}
	157	fi
	158
	159	log ERROR "Could not disable zone ${zone}: ${ret}"
	160	return ${ret}
	161	}
	162
	163	function zone_is_enabled() {
	164	local zone="${1}"
	165	assert isset zone
	166
	167	# Ask systemd if the zone is enabled.
	168	if service_is_enabled "network@${zone}.service"; then
	169	return ${EXIT_TRUE}
	170	fi
	171
	172	return ${EXIT_FALSE}
	173	}
	174
e6fd23fd MT	175	function zone_is_active() {
	176	local zone="${1}"
	177	assert isset zone
	178
	179	if service_is_active "network@${zone}.service"; then
	180	return ${EXIT_TRUE}
	181	fi
	182
	183	return ${EXIT_FALSE}
	184	}
	185
1848564d MT	186	function zone_create() {
	187	local zone=${1}
	188	local hook=${2}
	189	shift 2
	190
	191	if ! zone_name_is_valid ${zone}; then
	192	error "Zone name '${zone}' is not valid."
	193	return ${EXIT_ERROR}
	194	fi
	195
	196	if zone_exists ${zone}; then
	197	error "Zone '${zone}' does already exist."
	198	return ${EXIT_ERROR}
	199	fi
	200
d61a01d4	201	if ! hook_zone_exists ${hook}; then
1848564d MT	202	error "Hook '${hook}' does not exist."
	203	return ${EXIT_ERROR}
	204	fi
	205
	206	mkdir -p $(zone_dir ${zone})
	207
a5ebb169 MT	208	# Create directories for configs and ports
a5ebb169 MT	209	mkdir -p $(zone_dir ${zone})/{configs,ports}
943e3f7e	210
d61a01d4	211	hook_zone_exec ${hook} create ${zone} $@
1848564d MT	212	local ret=$?
	213
	214	# Maybe the zone create hook did not exit correctly.
	215	# If this is the case we remove the created zone immediately.
	216	if [ "${ret}" = "${EXIT_ERROR}" ]; then
69ace22b	217	zone_remove_now ${zone}
5c5b8e36	218	return ${EXIT_ERROR}
1848564d	219	fi
5c5b8e36 SS	220
	221	# Automatically enable zone.
	222	zone_enable "${zone}"
1848564d MT	223	}
	224
	225	function zone_edit() {
	226	local zone=${1}
	227	shift
	228
	229	if ! zone_exists ${zone}; then
	230	error "Zone '${zone}' does not exist."
	231	return ${EXIT_ERROR}
	232	fi
	233
69ace22b MT	234	# Check if the zone is tagged for removal.
	235	if zone_has_remove_tag ${zone}; then
	236	error "You cannot edit a zone that is tagged for removal."
	237	return ${EXIT_ERROR}
	238	fi
	239
1848564d MT	240	local hook=$(config_get_hook $(zone_dir ${zone})/settings)
	241
	242	if [ -z "${hook}" ]; then
	243	error "Config file did not provide any hook."
	244	return ${EXIT_ERROR}
	245	fi
	246
d61a01d4	247	if ! hook_zone_exists ${hook}; then
1848564d MT	248	error "Hook '${hook}' does not exist."
	249	return ${EXIT_ERROR}
	250	fi
	251
d61a01d4	252	hook_zone_exec ${hook} edit ${zone} $@
1848564d MT	253	}
1848564d MT	254
69ace22b	255
1848564d MT	256	function zone_remove() {
1848564d MT	257	local zone=${1}
69ace22b	258	assert zone_exists ${zone}
1848564d	259
69ace22b MT	260	# Make the zone for removal.
	261	touch $(zone_dir ${zone})/.remove
	262
	263	log INFO "Zone '${zone}' has been tagged for removal."
	264	}
	265
	266	function zone_has_remove_tag() {
	267	local zone=${1}
	268	assert zone_exists ${zone}
	269
	270	[ -e "$(zone_dir ${zone})/.remove" ]
	271	}
	272
	273	# This function will remove the given zone
	274	# RIGHT NOW. Use zone_remove to remove it
	275	# at the next status change.
	276	function zone_remove_now() {
	277	local zone=${1}
	278	assert zone_exists ${zone}
	279
	280	log INFO "Removing zone '${zone}' right now."
1848564d	281
69ace22b MT	282	# Force the zone down.
69ace22b MT	283	zone_is_up ${zone} && zone_set_down ${zone}
1848564d	284
5c5b8e36 SS	285	# Disable zone.
	286	zone_disable "${zone}"
	287
1848564d MT	288	rm -rf $(zone_dir ${zone})
	289	}
	290
	291	function zone_up() {
	292	local zone=${1}
	293	shift
	294
	295	if ! zone_exists ${zone}; then
	296	error "Zone '${zone}' does not exist."
	297	return ${EXIT_ERROR}
	298	fi
	299
69ace22b MT	300	# Check if a zone has got the remove tag.
	301	if zone_has_remove_tag ${zone}; then
	302	error "Cannot bring up any zone which is to be removed."
	303	return ${EXIT_ERROR}
	304	fi
	305
1848564d MT	306	local hook=$(config_get_hook $(zone_dir ${zone})/settings)
	307
	308	if [ -z "${hook}" ]; then
	309	error "Config file did not provide any hook."
	310	return ${EXIT_ERROR}
	311	fi
	312
d61a01d4	313	if ! hook_zone_exists ${hook}; then
1848564d MT	314	error "Hook '${hook}' does not exist."
	315	return ${EXIT_ERROR}
	316	fi
	317
059469a8 MT	318	zone_db ${zone} starting
059469a8 MT	319
d61a01d4 MT	320	hook_zone_exec ${hook} up ${zone} $@
d61a01d4 MT	321
059469a8	322	zone_db ${zone} started
1848564d MT	323	}
	324
	325	function zone_down() {
	326	local zone=${1}
	327	shift
	328
	329	if ! zone_exists ${zone}; then
	330	error "Zone '${zone}' does not exist."
	331	return ${EXIT_ERROR}
	332	fi
	333
	334	local hook=$(config_get_hook $(zone_dir ${zone})/settings)
	335
	336	if [ -z "${hook}" ]; then
	337	error "Config file did not provide any hook."
	338	return ${EXIT_ERROR}
	339	fi
	340
d61a01d4	341	if ! hook_zone_exists ${hook}; then
1848564d MT	342	error "Hook '${hook}' does not exist."
	343	return ${EXIT_ERROR}
	344	fi
	345
059469a8 MT	346	zone_db ${zone} stopping
059469a8 MT	347
d61a01d4	348	hook_zone_exec ${hook} down ${zone} $@
059469a8 MT	349
059469a8 MT	350	zone_db ${zone} stopped
69ace22b MT	351
	352	# Remove the zone, if it has got a remove tag.
	353	if zone_has_remove_tag ${zone}; then
	354	zone_remove_now ${zone}
	355	fi
1848564d MT	356	}
	357
	358	function zone_status() {
	359	local zone=${1}
	360	shift
	361
	362	if ! zone_exists ${zone}; then
	363	error "Zone '${zone}' does not exist."
	364	return ${EXIT_ERROR}
	365	fi
	366
	367	local hook=$(config_get_hook $(zone_dir ${zone})/settings)
	368
	369	if [ -z "${hook}" ]; then
	370	error "Config file did not provide any hook."
	371	return ${EXIT_ERROR}
	372	fi
	373
d61a01d4	374	if ! hook_zone_exists ${hook}; then
1848564d MT	375	error "Hook '${hook}' does not exist."
	376	return ${EXIT_ERROR}
	377	fi
	378
d61a01d4	379	hook_zone_exec ${hook} status ${zone} $@
69ace22b MT	380
	381	# Show that the zone it to be removed soon.
	382	if zone_has_remove_tag ${zone}; then
	383	warning "This zone is tagged for removal."
	384	fi
1848564d MT	385	}
1848564d MT	386
711ffac1 MT	387	function zone_port() {
	388	local zone=${1}
	389	local action=${2}
	390	shift 2
	391
	392	assert isset zone
	393	assert isset action
	394	assert zone_exists ${zone}
	395
	396	case "${action}" in
828eb94a	397	add\|edit\|remove)
943e3f7e MT	398	zone_port_${action} ${zone} $@
	399	;;
	400	*)
	401	error "Unrecognized argument: ${action}"
	402	cli_usage root-zone-port-subcommands
	403	exit ${EXIT_ERROR}
	404	;;
	405	esac
711ffac1 MT	406	}
	407
	408	function zone_port_add() {
828eb94a	409	local zone="${1}"
711ffac1 MT	410	assert isset zone
711ffac1 MT	411
828eb94a MT	412	local port="${2}"
	413	assert isset port
	414
	415	shift 2
711ffac1	416
828eb94a MT	417	# Check if the port actually exists.
	418	if ! port_exists "${port}"; then
	419	error "Cannot add port '${port}' which does not exist"
	420	return ${EXIT_ERROR}
	421	fi
	422
	423	# Check if the port is already connected to this or any other zone.
	424	local z
	425	for z in $(zones_get_all); do
	426	if zone_has_port "${z}" "${port}"; then
	427	error "Port '${port}' is already assigned to zone '${z}'"
	428	return ${EXIT_ERROR}
	429	fi
	430	done
	431
	432	local hook=$(zone_get_hook "${zone}")
711ffac1 MT	433	assert isset hook
711ffac1 MT	434
828eb94a	435	hook_zone_exec "${hook}" "port_add" "${zone}" "${port}" "$@"
711ffac1 MT	436	}
	437
	438	function zone_port_edit() {
828eb94a MT	439	local zone="${1}"
828eb94a MT	440	assert isset zone
711ffac1	441
828eb94a MT	442	local port="${2}"
828eb94a MT	443	assert isset port
711ffac1	444
828eb94a	445	shift 2
711ffac1	446
828eb94a MT	447	# Check if the port actually exists.
	448	if ! port_exists "${port}"; then
	449	error "Port '${port}' does not exist"
	450	return ${EXIT_ERROR}
	451	fi
711ffac1	452
828eb94a MT	453	# Check if the zone actually has this port.
	454	if ! zone_has_port "${zone}" "${port}"; then
	455	error "Port '${port}' is not attached to zone '${zone}'"
	456	return ${EXIT_ERROR}
	457	fi
711ffac1	458
828eb94a MT	459	local hook=$(zone_get_hook "${zone}")
828eb94a MT	460	assert isset hook
711ffac1	461
828eb94a	462	hook_zone_exec "${hook}" "port_edit" "${zone}" "${port}" "$@"
711ffac1 MT	463	}
711ffac1 MT	464
828eb94a MT	465	function zone_port_remove() {
	466	local zone="${1}"
	467	assert isset zone
	468
	469	local port="${2}"
	470	assert isset port
	471
	472	shift 2
	473
	474	# Check if the zone actually has this port.
	475	if ! zone_has_port "${zone}" "${port}"; then
	476	error "Port '${port}' is not attached to zone '${zone}'"
	477	return ${EXIT_ERROR}
	478	fi
	479
	480	local hook=$(zone_get_hook "${zone}")
	481	assert isset hook
711ffac1	482
828eb94a	483	hook_zone_exec "${hook}" "port_remove" "${zone}" "${port}" "$@"
711ffac1 MT	484	}
	485
	486	function zone_get_ports() {
	487	local zone=${1}
	488
	489	assert isset zone
	490
	491	local port
943e3f7e	492	for port in $(zone_dir ${zone})/ports/*; do
711ffac1	493	port=$(basename ${port})
711ffac1 MT	494
	495	if port_exists ${port}; then
	496	echo "${port}"
	497	fi
	498	done
	499	}
	500
529141df MT	501	function zone_get_ports_num() {
	502	local zone="${1}"
	503	assert isset zone
	504
	505	local counter=0
	506	local port
	507	for port in $(zone_dir "${zone}")/ports/*; do
	508	port="$(basename "${port}")"
	509
	510	if port_exists "${port}"; then
	511	counter=$(( ${counter} + 1 ))
	512	fi
	513	done
	514
	515	echo "${counter}"
	516	return ${EXIT_OK}
	517	}
	518
3a7fef62 MT	519	function zone_has_port() {
	520	# Check, if the given port is configured
	521	# in this zone.
	522
	523	local zone=${1}
	524	local port=${2}
	525	shift 2
	526
	527	assert isset zone
	528	assert isset port
	529
	530	[ -e "$(zone_dir ${zone})/ports/${port}" ]
	531	}
	532
1848564d	533	function zone_config() {
ea699552 MT	534	local zone="${1}"
ea699552 MT	535	local cmd="${2}"
a5ebb169 MT	536	shift 2
	537
	538	assert isset zone
ea699552 MT	539	assert isset cmd
ea699552 MT	540	assert zone_exists "${zone}"
a5ebb169	541
ea699552 MT	542	case "${cmd}" in
	543	create)
	544	zone_config_create "${zone}" "$@"
a5ebb169	545	;;
ea699552 MT	546	edit)
	547	zone_config_edit "${zone}" "$@"
	548	;;
	549	remove)
	550	zone_config_remove "${zone}" "$@"
a5ebb169 MT	551	;;
a5ebb169 MT	552	*)
ea699552	553	error "Unrecognized argument: ${cmd}"
a5ebb169 MT	554	cli_usage root-zone-config-subcommands
	555	exit ${EXIT_ERROR}
	556	;;
	557	esac
	558	}
	559
ea699552 MT	560	function zone_config_cmd() {
ea699552 MT	561	assert [ $# -gt 2 ]
a5ebb169	562
ea699552 MT	563	local cmd="${1}"
	564	local zone="${2}"
	565	shift 2
	566
	567	local hook="$(zone_get_hook "${zone}")"
a5ebb169 MT	568	assert isset hook
a5ebb169 MT	569
ea699552 MT	570	hook_zone_exec "${hook}" "config_${cmd}" "${zone}" "$@"
	571	}
	572
	573	function zone_config_create() {
	574	zone_config_cmd "create" "$@"
	575	}
	576
	577	function zone_config_edit() {
	578	zone_config_cmd "edit" "$@"
	579	}
	580
	581	function zone_config_remove() {
	582	zone_config_cmd "remove" "$@"
	583	}
	584
	585	function zone_config_show() {
	586	zone_config_cmd "show" "$@"
a5ebb169 MT	587	}
a5ebb169 MT	588
1848564d MT	589	function zone_show() {
	590	local zone=${1}
	591
	592	echo "${zone}"
	593	echo " Type: $(zone_get_hook ${zone})"
	594	echo
	595	}
	596
	597	function zones_show() {
	598	local zone
	599
	600	for zone in $(zones_get $@); do
	601	zone_show ${zone}
	602	done
	603	}
	604
	605	function zones_get_all() {
	606	local zone
d61a01d4	607	for zone in $(zone_dir)/*; do
1848564d MT	608	zone=$(basename ${zone})
	609	zone_exists ${zone} \|\| continue
	610
	611	echo "${zone}"
03170817	612	done
1848564d MT	613	}
	614
	615	function zones_get_local() {
	616	local zone
	617	for zone in $(zones_get_all); do
	618	zone_is_local ${zone} && echo "${zone}"
	619	done
	620	}
	621
	622	function zones_get_nonlocal() {
	623	local zone
	624	for zone in $(zones_get_all); do
5e42d659	625	zone_is_nonlocal ${zone} && echo "${zone}"
1848564d MT	626	done
	627	}
	628
	629	function zones_get() {
	630	local local=1
	631	local remote=1
	632
	633	local zones
	634
	635	while [ $# -gt 0 ]; do
	636	case "${1}" in
	637	--local-only)
	638	local=1
	639	remote=0
	640	;;
	641	--remote-only)
	642	local=0
	643	remote=1
	644	;;
	645	--all)
	646	local=1
	647	remote=1
	648	;;
	649	*)
	650	if zone_name_is_valid ${1}; then
	651	zones="${zones} ${1}"
	652	else
	653	warning "Unrecognized argument '${1}'"
	654	fi
	655	;;
	656	esac
	657	shift
	658	done
	659
	660	if [ -n "${zones}" ]; then
	661	local zone
	662	for zone in ${zones}; do
	663	zone_exists ${zone} && echo "${zone}"
	664	done
	665	exit ${EXIT_OK}
	666	fi
	667
	668	if [ ${local} -eq 1 ] && [ ${remote} -eq 1 ]; then
	669	zones_get_all
	670	elif [ ${local} -eq 1 ]; then
	671	zones_get_local
	672	elif [ ${remote} -eq 1 ]; then
	673	zones_get_nonlocal
	674	fi
	675	}
	676
	677	function zone_ports_list() {
	678	local zone=${1}
	679
	680	local port
a5ebb169	681	for port in $(zone_dir ${zone})/ports/*; do
1848564d MT	682	[ -e "${port}" ] \|\| continue
	683
	684	echo $(basename ${port})
03170817	685	done
1848564d MT	686	}
	687
	688	function zone_ports_cmd() {
	689	local cmd=${1}
	690	local zone=${2}
	691	shift 2
	692
711ffac1 MT	693	assert isset cmd
711ffac1 MT	694	assert isset zone
1848564d	695
711ffac1	696	assert zone_exists ${zone}
1848564d	697
711ffac1 MT	698	local hook=$(zone_get_hook ${zone})
	699
	700	local port
	701	for port in $(zone_get_ports ${zone}); do
711ffac1	702	hook_zone_exec ${hook} ${cmd} ${zone} ${port} $@
1848564d MT	703	done
	704	}
	705
	706	function zone_ports_up() {
711ffac1	707	zone_ports_cmd port_up $@
1848564d MT	708	}
	709
	710	function zone_ports_down() {
711ffac1 MT	711	zone_ports_cmd port_down $@
	712	}
	713
	714	function zone_ports_status() {
	715	zone_ports_cmd port_status $@
1848564d MT	716	}
1848564d MT	717
1848564d	718	function zone_configs_cmd() {
ea699552 MT	719	assert [ $# -gt 2 ]
	720
	721	local cmd="${1}"
	722	local zone="${2}"
1848564d MT	723	shift 2
1848564d MT	724
ea699552	725	assert zone_exists "${zone}"
1848564d	726
1848564d	727	local config
ea699552 MT	728	for config in $(zone_get_configs "${zone}"); do
ea699552 MT	729	hook_config_exec "${config}" "${cmd}" "${zone}" $@
1848564d MT	730	done
	731	}
	732
	733	function zone_configs_up() {
ea699552	734	zone_configs_cmd "up" $@
1848564d MT	735	}
	736
	737	function zone_configs_down() {
ea699552	738	zone_configs_cmd "down" $@
1848564d MT	739	}
1848564d MT	740
a5ebb169	741	function zone_configs_status() {
ea699552 MT	742	zone_configs_cmd "status" $@
	743	}
	744
	745	function zone_configs_list() {
	746	local zone=${1}
	747
	748	local config
	749	for config in $(zone_dir ${zone})/configs/*; do
	750	[ -e "${config}" ] \|\| continue
	751
	752	basename ${config}
	753	done
a5ebb169 MT	754	}
a5ebb169 MT	755
38f61548 MT	756	function zone_has_ip() {
38f61548 MT	757	device_has_ip $@
4231f419 MT	758	}
4231f419 MT	759
059469a8 MT	760	function zone_db() {
	761	local zone=${1}
	762	local action=${2}
	763	shift 2
	764
	765	case "${action}" in
	766	starting\|started\|stopping\|stopped)
	767	db_connection_update ${zone} ${action}
	768	;;
	769	esac
	770	}
5e42d659 MT	771
	772	function zone_is_up() {
	773	local zone=${1}
	774
	775	device_is_up ${zone}
	776	}
	777
	778	function zone_is_down() {
	779	! zone_is_up $@
	780	}
711ffac1	781
a5ebb169	782	function zone_get_supported_port_hooks() {
711ffac1 MT	783	local zone=${1}
	784
	785	local hook=$(zone_get_hook ${zone})
	786
	787	hook_zone_ports_get_all ${hook}
	788	}
	789
a5ebb169	790	function zone_get_supported_config_hooks() {
ea699552	791	hook_config_get_all
a5ebb169 MT	792	}
a5ebb169 MT	793
711ffac1 MT	794	function zone_file() {
	795	local zone=${1}
	796
	797	assert isset zone
	798
	799	echo "$(zone_dir ${zone})/settings"
	800	}
	801
e9df08ad	802	function zone_settings_read() {
711ffac1 MT	803	local zone=${1}
	804
	805	assert isset zone
	806
bfd6c282 MT	807	# Save the HOOK variable.
	808	local hook="${HOOK}"
	809
e9df08ad	810	settings_read $(zone_file ${zone})
bfd6c282 MT	811
	812	# Restore hook.
	813	HOOK="${hook}"
711ffac1 MT	814	}
711ffac1 MT	815
e9df08ad	816	function zone_settings_write() {
711ffac1 MT	817	local zone=${1}
	818
	819	assert isset zone
	820
e9df08ad	821	settings_write $(zone_file ${zone}) ${HOOK_SETTINGS}
711ffac1 MT	822	}
711ffac1 MT	823
e9df08ad	824	function zone_settings_set() {
711ffac1 MT	825	local zone=${1}
	826	shift
	827	local args="$@"
	828
	829	assert isset zone
	830
	831	(
e9df08ad	832	zone_settings_read ${zone}
711ffac1 MT	833
	834	for arg in ${args}; do
	835	eval "${arg}"
	836	done
	837
e9df08ad	838	zone_settings_write ${zone}
711ffac1 MT	839	)
711ffac1 MT	840	}
6b3f9c85	841
e9df08ad	842	function zone_settings_get() {
6b3f9c85 MT	843	local zone=${1}
	844	local key=${2}
	845
	846	assert isset zone
	847	assert isset key
	848
	849	(
e9df08ad	850	zone_settings_read ${zone}
6b3f9c85 MT	851
	852	echo "${!key}"
	853	)
	854	}
e9df08ad MT	855
	856	function zone_config_settings_read() {
	857	assert [ $# -gt 2 ]
	858
	859	local zone="${1}"
	860	local config="${2}"
	861	shift 2
	862
	863	local path="$(zone_dir "${zone}")/configs/${config}"
	864	settings_read "${path}" "$@"
	865	}
	866
	867	function zone_config_settings_write() {
	868	assert [ $# -gt 2 ]
	869
	870	local zone="${1}"
	871	local config="${2}"
	872	shift 2
	873
	874	local path="$(zone_dir "${zone}")/configs/${config}"
	875	settings_write "${path}" "$@"
	876	}
	877
	878	function zone_port_settings_read() {
	879	assert [ $# -gt 2 ]
	880
	881	local zone="${1}"
	882	local port="${2}"
	883	shift 2
	884
	885	local path="$(zone_dir "${zone}")/ports/${port}"
	886	settings_read "${path}" "$@"
	887	}
	888
	889	function zone_port_settings_write() {
	890	assert [ $# -gt 2 ]
	891
	892	local zone="${1}"
	893	local port="${2}"
	894	shift 2
	895
	896	local path="$(zone_dir "${zone}")/ports/${port}"
	897	settings_write "${path}" "$@"
	898	}
	899
	900	function zone_port_settings_remove() {
	901	assert [ $# -eq 2 ]
	902
	903	local zone="${1}"
	904	local port="${2}"
	905
	906	local path="$(zone_dir "${zone}")/ports/${port}"
	907	settings_remove "${path}"
	908	}