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

# XXX overwritten some lines below
function zone_config() {
	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} config ${zone} $@
}

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

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

	# Aliases
	case "${action}" in
		del|delete|remove)
			action="rem"
			;;
	esac

	case "${action}" in
		create|edit|rem)
			zone_config_${action} ${zone} $@
			;;
		*)
			error "Unrecognized argument: ${action}"
			cli_usage root-zone-config-subcommands
			exit ${EXIT_ERROR}
			;;
	esac
}

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

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

	hook_zone_exec "${hook}" "config_create" "${zone}" "$@"
}

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_list() {
	local zone=${1}

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

		basename ${config}
	done
}

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

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

	local hook_config
	local config
	for config in $(zone_configs_list ${zone}); do
		hook_config=$(config_get_hook $(zone_dir ${zone})/configs/${config})

		hook_zone_config_exec ${hook_zone} ${hook_config} ${cmd} ${zone} ${config} $@
	done
}

function zone_configs_up() {
	zone_configs_cmd up $@
}

function zone_configs_down() {
	zone_configs_cmd down $@
}

function zone_configs_status() {
	zone_configs_cmd config_status $@
}

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

	local hook=$(zone_get_hook ${zone})

	hook_zone_configs_get_all ${hook}
}

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