zone: accept also hids in zone_config()

[people/ms/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/>.       #
#                                                                             #
###############################################################################

zone_dir() {
	local zone=${1}

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

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

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

zone_match() {
	local match

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

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

zone_name_is_valid() {
	local zone=${1}

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

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

zone_is_local() {
	local zone=${1}

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

zone_is_nonlocal() {
	local zone=${1}

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

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

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

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"
}

zone_start_auto() {
	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}
}

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"
}

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

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

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

	hotplug_assert_in_hotplug_event

	zone_cmd "hotplug" "${zone}"
}

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}
}

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}
}

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}
}

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

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

	return ${EXIT_FALSE}
}

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

	zone_is_enabled "${zone}" || zone_is_active "${zone}"
}

zone_cmd() {
	local cmd="${1}"
	local port="${2}"
	shift 2

	assert isset cmd
	assert isset zone

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

	hook_exec zone "${hook}" "${cmd}" "${zone}" $@
}

zone_new() {
	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}" "new" "${zone}" $@
	local ret=$?

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

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

	# Bring up the zone immediately after
	zone_start "${zone}"
}

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_destroy_tag ${zone}; then
		error "You cannot edit a zone that is tagged for removal."
		return ${EXIT_ERROR}
	fi

	local hook="$(zone_get_hook "${zone}")"
	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} $@
}

zone_rename() {
	assert [ $# -eq 2 ]

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

	assert zone_exists "${zone}"
	assert not zone_has_destroy_tag "${zone}"
	assert not zone_exists "${name}"

	# The zone must be shut down before, is then renamed and
	# potentially brought up again

	# Save if the zone is running right now
	zone_is_active "${zone}"
	local zone_was_active="${?}"

	# Save if the zone is enabled (i.e. auto-start)
	zone_is_enabled "${zone}"
	local zone_was_enabled="${?}"

	# Stop the zone
	zone_stop "${zone}"

	# Disable the zone
	zone_disable "${zone}"

	# Rename the configuration files
	mv -f "$(zone_dir "${zone}")" "$(zone_dir "${name}")"

	# Enable the zone if it was enabled before
	[ ${zone_was_enabled} -eq ${EXIT_TRUE} ] && zone_enable "${name}"

	# Start the zone if it was up before
	[ ${zone_was_active} -eq ${EXIT_TRUE} ] && zone_start "${name}"

	log INFO "Zone ${zone} was renamed to ${name}"
	return ${EXIT_OK}
}


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

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

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

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

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

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

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

	# Force the zone down.
	zone_is_active "${zone}" && zone_stop "${zone}"

	# Disable zone.
	zone_disable "${zone}"

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

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_destroy_tag ${zone}; then
		error "Cannot bring up any zone which is to be removed."
		return ${EXIT_ERROR}
	fi

	local hook="$(zone_get_hook "${zone}")"
	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

	# Execute all triggers after the zone got up
	triggers_execute_all "up" ZONE="${zone}"
}

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

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

	local hook="$(zone_get_hook "${zone}")"
	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

	# Execute all triggers after the zone went down
	triggers_execute_all "down" ZONE="${zone}"

	# Remove the zone, if it has got a remove tag.
	if zone_has_destroy_tag "${zone}"; then
		zone_destroy_now "${zone}"
	fi
}

zone_status() {
	local zone="${1}"
	assert isset zone
	shift

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

	local hook="$(zone_get_hook "${zone}")"
	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_destroy_tag ${zone}; then
		warning "This zone is tagged for removal."
	fi
}

zone_identify() {
	assert [ $# -ge 1 ]

	local zone="${1}"
	shift

	assert zone_exists "${zone}"

	log INFO "Identifying zone ${zone}"
	local pids

	local pid
	local port
	for port in $(zone_get_ports "${zone}"); do
		# Identify all the ports
		port_identify "${port}" --background $@

		# Save the PIDs of the subprocesses
		list_append pids "$(cmd_background_get_pid)"
	done

	# Wait until all port_identfy processes have finished
	for pid in ${pids}; do
		cmd_background_result "${pid}"
	done

	return ${EXIT_OK}
}

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
}

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}
}

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}" ]
}

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

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

	case "${cmd}" in
		new)
			zone_config_new "${zone}" "$@"
			;;
		destroy)
			# usually ${1} is a valid hid
			local hid=${1}
			shift 1

			# We convert the hid into an id
			local id=$(zone_config_convert_hid_to_id ${zone} ${hid})

			# If id isset the hid is valid and we can go on with the id
			if isset id; then
				 zone_config_destroy "${zone}" "${id}" "$@"

			# If we can't get a valid hid we check if we got a valid id
			else
				if zone_config_id_is_valid ${zone} ${hid}; then
					zone_config_destroy "${zone}" ${hid} "$@"
				else
					log ERROR "${id} is not a valid id or hid"
				fi
			fi
			;;
		list)
			zone_config_list "${zone}" "$@"
			;;
		*)
			# usually ${1} is a valid hid
			local hid=${cmd}
			local cmd=${1}
			shift 1

			local id=$(zone_config_convert_hid_to_id ${zone} ${hid})

			# If id isset the hid is valid and we can go on with the id
			if isset id && [[ ${cmd} == "edit" ]]; then
				 zone_config_edit "${zone}" "${id}" "$@"

			# If we didn't get a valid hid we check if we got a valid id
			else
				if zone_config_id_is_valid ${zone} ${id} && [[ ${cmd} == "edit" ]]; then
					shift 1
					zone_config_edit "${zone}" "${id}" "$@"
				else
					# in ${hid} is saved the command after network zone ${zone} config
					error "Unrecognized argument: ${hid}"
					cli_usage root-zone-config-subcommands
					exit ${EXIT_ERROR}
				fi
			fi
			;;
	esac
}

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}" "$@"
}

zone_config_new() {
	local zone="${1}"
	shift

	# Create a new configuration, but exit when that was
	# not successful.
	zone_config_cmd "new" "${zone}" "$@" || return ${?}

	# If the config could be created, we will try to bring
	# it up if the zone is up, too.
	if zone_is_up "${zone}"; then
		zone_configs_up "${zone}"
	fi
}

zone_config_destroy() {
	zone_config_cmd "destroy" "$@"
}

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

zone_config_list() {
	# This function list in an nice way all configs of a zone
	local zone=${1}
	assert isset zone

	# Print a nice header
	local format="%-3s %-20s"
	print "${format}" "ID" "HOOK"

	local config
	local hook
	local id

	# Print for all config:
	# id and hook
	# TODO: Add hids here
	for config in $(zone_configs_list "${zone}"); do
		id=${config##*.}
		hook=$(zone_config_get_hook "${zone}" "${config}")
		assert isset hook
		print "${format}" "${id}" "${hook}"
	done
}

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

# Returns a list of all used ids for a zone
zone_config_list_ids() {
	assert [ $# -eq 1 ]

	local zone=${1}
	local config
	local ids

	for config in $(zone_configs_list ${zone}); do
		list_append ids "$(config_get_id_from_config ${config})"
	done

	echo ${ids}
}

# List all hids of a zone
zone_config_list_hids() {
	assert [ $# -eq 1 ]

	local zone=${1}

	local config
	for config in $(zone_configs_list ${zone}); do
		zone_config_get_hid "${zone}" "${config}"
	done
}

# get the hid from a given config
zone_config_get_hid() {
	assert [ $# -eq 2 ]

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

	local hook="$(zone_config_get_hook "${zone}" "${config}")"

	hook_exec "config" "${hook}" "hid" "${zone}" "${config}"
}

# Checks if a hid is valid for a given zone
zone_config_hid_is_valid() {
	assert [ $# -eq 2]

	local zone=${1}
	local hid=${2}

	local _hid
	for _hid in $(zone_config_list_hids "${zone}"); do
		if [[ ${_hid} = ${hid} ]]; then
			return ${EXIT_TRUE}
		fi
	done

	return ${EXIT_FALSE}
}

# This function converts a hid to a id
zone_config_convert_hid_to_id() {
	assert [ $# -eq 2 ]

	local zone=${1}
	local hid=${2}

	local config
	for config in $(zone_configs_list ${zone}); do
		# Get hook from config
		local hook="$(zone_config_get_hook "${zone}" "${config}")"

		if [[ "$(hook_exec "config" "${hook}" "hid" "${zone}" "${config}")" == "${hid}" ]]; then
			config_get_id_from_config "${config}"
			return ${EXIT_TRUE}
		fi
	done

	return ${EXIT_FALSE}
}

zone_show() {
	local zone=${1}

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

zones_show() {
	local zone

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

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

		echo "${zone}"
	done
}

zones_get_next_free() {
	# This function return the next free zones.
	# Example net0 upl0 upl1 are configured so the next free zones are:
	# net1 upl2
	local i
	local zone_name
	for zone_name in ${VALID_ZONES}; do
		i=0

		while true; do
			local zone="${zone_name}${i}"
			if ! zone_exists ${zone}; then
				echo "${zone}"
				break
			fi
			i=$(( i + 1 ))
		done
	done
}

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

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

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
}

zone_ports_list() {
	local zone=${1}

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

		echo $(basename ${port})
	done
}

zone_port_attach() {
	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 attach 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 attached to zone '${z}'"
			return ${EXIT_ERROR}
		fi
	done

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

	# Make the port briefly flash if supported
	if device_exists ${port}; then
		port_identify "${port}" --background
	fi

	hook_zone_exec "${hook}" "port_attach" "${zone}" "${port}" "$@"
	local ret="${?}"

	case "${ret}" in
		${EXIT_OK})
			log INFO "${port} has been attached to ${zone}"

			# Automatically connect the port
			zone_port_start "${zone}" "${port}"
			;;
		*)
			log CRITICAL "${port} could not be attached to ${zone}"
			;;
	esac

	return ${ret}
}

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}" "$@"
}

zone_port_detach() {
	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

	# Make the port briefly flash if supported
	port_identify "${port}" --background

	hook_zone_exec "${hook}" "port_detach" "${zone}" "${port}" "$@"
	local ret="${?}"

	case "${ret}" in
		${EXIT_OK})
			log INFO "${port} has been detached from ${zone}"

			# Bring down the port if needed
			zone_port_stop "${zone}" "${port}"
			;;
		*)
			log CRITICAL "${port} could not be detached from ${zone}"
			;;
	esac

	return ${ret}
}

zone_port_cmd() {
	local cmd="${1}"
	assert isset cmd

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

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

	shift 3

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

	# Dispatch command to hook
	hook_zone_exec "${hook}" "${cmd}" "${zone}" "${port}" $@
}

zone_port_create() {
	zone_port_cmd "port_create" $@
}

zone_port_remove() {
	zone_port_cmd "port_remove" $@
}

zone_port_up() {
	zone_port_cmd "port_up" $@
}

zone_port_down() {
	zone_port_cmd "port_down" $@
}

# The next two functions automagically bring up and down
# port that are attached to a bridge or similar.
# The problem that is tried to overcome here is that there
# are ports which exist all the time (like ethernet ports)
# and therefore do not dispatch a hotplug event when
# port_create is called.

zone_port_start() {
	local zone="${1}"
	local port="${2}"

	if zone_is_active "${zone}"; then
		if device_exists "${port}"; then
			zone_port_up "${zone}" "${port}"
			return ${?}
		else
			zone_port_create "${zone}" "${port}"
			return ${?}
		fi
	fi

	return ${EXIT_OK}
}

zone_port_stop() {
	local zone="${1}"
	local port="${2}"

	# Shut down the port if necessary
	if zone_is_active "${zone}" && port_is_up "${port}"; then
		zone_port_down "${zone}" "${port}"
	fi

	# Remove the port
	zone_port_remove "${zone}" "${port}"
}

zone_port_status() {
	zone_port_cmd "port_status" $@
}

zone_ports_cmd() {
	local cmd="${1}"
	assert isset cmd

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

	shift 2

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

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

zone_ports_create() {
	zone_ports_cmd "port_create" $@
}

zone_ports_remove() {
	zone_ports_cmd "port_remove" $@
}

zone_ports_up() {
	zone_ports_cmd "port_up" $@
}

zone_ports_down() {
	zone_ports_cmd "port_down" $@
}

zone_ports_status() {
	zone_ports_cmd "port_status" $@
}

zone_configs_cmd() {
	assert [ $# -ge 2 ]

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

	assert zone_exists "${zone}"

	local config
	for config in $(zone_configs_list "${zone}"); do
		local config_hook="$(zone_config_get_hook "${zone}" "${config}")"
		assert isset config_hook

		hook_config_exec "${config_hook}" "${cmd}" "${zone}" "${config}" $@
	done
}

zone_configs_up() {
	zone_configs_cmd "up" $@
}

zone_configs_down() {
	zone_configs_cmd "down" $@
}

zone_configs_status() {
	zone_configs_cmd "status" $@
}

zone_configs_list() {
	local zone=${1}

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

		basename ${config}
	done
}

zone_config_get_new_id() {
	# This functions returns the next free id for a zone

	assert [ $# -eq 1 ]
	local zone=${1}

	local zone_path=$(zone_dir ${zone})
	local i=0

	while true; do
		if [ ! -f ${zone_path}/configs/*.${i} ]; then
			echo "${i}"
			return ${EXIT_OK}
		fi
		(( i++ ))
	done
}

zone_config_get_hook() {
	assert [ $# -eq 2 ]

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

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

	local HOOK
	zone_config_settings_read "${zone}" "${config}" \
		--ignore-superfluous-settings HOOK

	print "${HOOK}"
}

zone_config_hook_is_configured() {
	# Checks if a zone has already at least one config with the given hook.
	# Returns True when yes and False when no

	assert [ $# -eq 2 ]
	local zone=${1}
	local hook=${2}

	local config
	for config in $(zone_configs_list "${zone}"); do
		local config_hook="$(zone_config_get_hook "${zone}" "${config}")"
		assert isset config_hook
		if [[ ${hook} == ${config_hook} ]]; then
			return ${EXIT_TRUE}
		fi

	done

	# If we get here the zone has no config with the given hook
	return ${EXIT_FALSE}
}

zone_config_id_is_valid() {
	# This function checks if a given id is valid for a zone
	# Return True when yes and false when no

	assert [ $# -eq 2 ]
	local zone=${1}
	local id=${2}

	local zone_path=$(zone_dir ${zone})

	[ -f ${zone_path}/configs/*.${id} ];
}

# This function checks if a given hid is valid for a zone
# Return True when yes and false when no
zone_config_hid_is_valid() {
	assert [ $# -eq 2 ]
	local zone=${1}
	local hid=${2}

	local _hid
	for _hid in $(zone_config_list_hids ${zone}); do
		if [[ ${_hid} == ${hid} ]]; then
			return ${EXIT_TRUE}
		fi
	done

	return ${EXIT_FALSE}
}

zone_config_get_hook_from_id() {
	# Returns the hook for a given id
	assert [ $# -eq 2 ]
	local zone=${1}
	local id=${2}

	local config
	for config in $(zone_configs_list "${zone}"); do
		if [[ ${config} == *.${id} ]]; then
			local config_hook="$(zone_config_get_hook "${zone}" "${config}")"
			assert isset config_hook
			print "${config_hook}"
			return "${EXIT_OK}"
		fi
	done

	# If we get here the zone has no config with the given id
	return ${EXIT_ERROR}
}

zone_has_ip() {
	device_has_ip $@
}

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

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

zone_is_up() {
	local zone=${1}

	device_is_up ${zone}
}

zone_is_down() {
	! zone_is_up $@
}

zone_get_supported_port_hooks() {
	local zone=${1}

	local hook=$(zone_get_hook ${zone})

	hook_zone_ports_get_all ${hook}
}

zone_get_supported_config_hooks() {
	hook_config_get_all
}

zone_file() {
	local zone=${1}

	assert isset zone

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

zone_settings_read() {
	local zone=${1}
	assert isset zone
	shift

	local args
	if [ $# -eq 0 ] && [ -n "${HOOK_SETTINGS}" ]; then
		list_append args ${HOOK_SETTINGS}
	else
		list_append args $@
	fi

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

	settings_read "$(zone_file "${zone}")" ${args}

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

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

	local args
	if function_exists "hook_check_settings"; then
		list_append args "--check=\"hook_check_settings\""
	fi
	list_append args ${HOOK_SETTINGS}

	settings_write "$(zone_file ${zone})" ${args}
}

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}
	)
}

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

	assert isset zone
	assert isset key

	(
		zone_settings_read "${zone}" "${key}" \
			--ignore-superfluous-settings

		echo "${!key}"
	)
}

zone_config_settings_read() {
	assert [ $# -ge 2 ]

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

	local args
	if [ $# -eq 0 ] && [ -n "${HOOK_CONFIG_SETTINGS}" ]; then
		list_append args ${HOOK_CONFIG_SETTINGS}
	else
		list_append args $@
	fi

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

zone_config_settings_write() {
	assert [ $# -ge 2 ]

	local zone="${1}"
	local hook="${2}"
	local id=${3}

	if ! isset id; then
		id=$(zone_config_get_new_id ${zone})
		log DEBUG "ID for the config is: ${id}"
	fi

	local args
	if function_exists "hook_check_config_settings"; then
		list_append args "--check=\"hook_check_config_settings\""
	fi
	list_append args ${HOOK_CONFIG_SETTINGS}

	local path="$(zone_dir "${zone}")/configs/${hook}.${id}"
	settings_write "${path}" ${args}
}

zone_config_settings_destroy() {
	# This function deletes the config file for a given zone and config
	assert [ $# -ge 2 ]
	local zone="${1}"
	local config="${2}"

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

	# Check if path is valid
	if [ ! -f ${path} ]; then
		log ERROR "Path: '${path}' is not valid"
		return ${EXIT_ERROR}
	fi

	log DEBUG "Deleting config file ${path}"
	rm -f "${path}"

}
zone_port_settings_read() {
	assert [ $# -ge 2 ]

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

	local args
	if [ $# -eq 0 ] && [ -n "${HOOK_PORT_SETTINGS}" ]; then
		list_append args ${HOOK_PORT_SETTINGS}
	else
		list_append args $@
	fi

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

zone_port_settings_write() {
	assert [ $# -ge 2 ]

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

	local args
	if function_exists "hook_check_port_settings"; then
		list_append args "--check=\"hook_check_port_settings\""
	fi
	list_append args ${HOOK_PORT_SETTINGS}

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

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

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

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

zone_get_color() {
	# This function return the color of a zone
	assert [ $# -eq 1 ]

	local name=${1}
	color_read "zone" ${name}
}

zone_get_description_title() {
	assert [ $# -eq 1 ]

	local name=${1}
	description_title_read $(description_format_filename "zone" "${name}")
}