[people/ms/network.git] / src / bash-completion / network

#!/bin/bash
###############################################################################
#                                                                             #
# IPFire.org - A linux based firewall                                         #
# Copyright (C) 2014 Michael Tremer                                           #
#                                                                             #
# 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/>.       #
#                                                                             #
###############################################################################
# network(8) completion

_network_find_on_cmdline () {
	local word subcommand c=0
	while [ ${c} -lt ${cword} ]; do
		word="${words[c]}"
		for subcommand in ${1}; do
			if [ "${subcommand}" = "${word}" ]; then
				echo "${subcommand}"
				return
			fi
		done
		((c++))
	done
}

_network_complete_hooks() {
	local type="${1}"

	COMPREPLY=( $(compgen -W "$(network raw list-hooks "${type}")" -- "${cur}") )
}

_network_complete_ports() {
	COMPREPLY=( $(compgen -W "$(network raw list-ports)" -- "${cur}") )
}

_network_complete_zones() {
	COMPREPLY=( $(compgen -W "$(network raw list-zones)" -- "${cur}") )
}

_network_color() {
	local words=( $@ )

	local commands="set reset"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi
}

_network_description() {
	local words=( $@ )

	local commands="edit show"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi
}
_network_device() {
	local words=( $@ )

	local commands="list $(network raw list-devices)"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	local args="${words[@]:1}"
	case "${cmd}" in
		list)
			return 0
			;;
		*)
			_network_device_subcommand ${args}
			;;
	esac
}

_network_device_subcommand() {
	local words=( $@ )

	local commands="discover identify monitor status unlock ussd"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	case "${cmd}" in
		ussd)
			# TODO
			;;
	esac
}

_network_dhcpd() {
	local proto="${1}"
	shift

	local words=( $@ )

	local commands="edit reload restart show start stop subnet"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	local args="${words[@]:1}"
	case "${cmd}" in
		subnet)
			_network_dhcpd_subnet "${proto}" ${args}
			;;
	esac
}

_network_dhcpd_subnet() {
	local proto="${1}"
	shift

	local words=( $@ )

	local commands="new remove show $(network raw list-dhcpd-subnets "${proto}")"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	local subnet="${words[0]}"
	local args="${words[@]:1}"
	case "${cmd}" in
		new)
			: # TODO
			;;
		remove)
			: # TODO
			;;
		[0-9]*)
			_network_dhcpd_subnet_subcommand "${proto}" "${subnet}" ${args}
			;;
	esac
}

_network_dhcpd_subnet_subcommand() {
	local proto="${1}"
	local subnet="${2}"
	shift 2

	local words=( $@ )

	local commands="edit options range show"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	local args="${words[@]:1}"
	case "${cmd}" in
		edit)
			: # TODO
			;;
		options)
			_network_dhcpd_subnet_subcommand_options "${proto}" "${subnet}" ${args}
			;;
		range)
			_network_dhcpd_subnet_subcommand_range "${proto}" "${subnet}" ${args}
			;;
	esac
}

_network_dhcpd_subnet_subcommand_options() {
	local proto="${1}"
	local subnet="${2}"
	shift 2

	local options option
	for option in $(network raw list-dhcpd-subnet-options "${proto}"); do
		options="${options} ${option}="
	done

	COMPREPLY=( $(compgen -W "${options}" -- "${cur}") )
}

_network_dhcpd_subnet_subcommand_range() {
	local proto="${1}"
	local subnet="${2}"
	shift 2

	local words=( $@ )

	local commands="new remove"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	case "${cmd}" in
		new)
			COMPREPLY=( $(compgen -W "--end= --start=" -- "${cur}") )
			;;
		remove)
			COMPREPLY=( $(compgen -W "$(network raw list-dhcpd-ranges-of-subnet "${proto}" "${subnet}")" \
				-- "${cur}") )
			;;
	esac
}

_network_dns_server() {
	local words=( $@ )

	local commands="add list remove update"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	case "${cmd}" in
		remove)
			COMPREPLY=( $(compgen -W "$(network raw list-dns-servers)" \
				-- "${cur}") )
			;;
	esac
}

_network_port() {
	local words=( $@ )

	local commands="new destroy $(network raw list-ports)"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	local args="${words[@]:1}"
	case "${cmd}" in
		new)
			_network_complete_hooks "port"
			;;
		destroy)
			_network_complete_ports
			;;
		*)
			local args="${words[@]:1}"
			_network_port_subcommand ${args}
			;;
	esac
}

_network_port_subcommand() {
	local words=( $@ )

	local commands="color create description down edit identify remove status up"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	local args="${words[@]:1}"
	case "${cmd}" in
		color)
			_network_color ${args}
			;;
		description)
			_network_description ${args}
			;;
	esac

}

_network_route() {
	local words=( $@ )

	local commands="static"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	case "${cmd}" in
		static)
			local args="${words[@]}"
			_network_route_static ${args}
			;;
	esac

}

_network_route_static() {
	local words=( $@ )

	local commands="add list remove reload"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	case "${cmd}" in
		add)
			if [[ "${cur}" = -* ]]; then
				COMPREPLY=( $(compgen -W "--blackhole --gateway= --mtu= \
					--prohibit --unreachable" -- "${cur}") )
			fi
			;;
		list)
			# TODO auto-complete options like --protocol here
			COMPREPLY=( $(compgen -W "--protocol=" -- "${cur}") )
			;;
	esac
}

_network_settings() {
	local words=( $@ )

	local key keys
	for key in $(network raw list-settings); do
		keys="${keys} ${key}="
	done
	COMPREPLY=( $(compgen -W "${keys}" -- "${cur}") )
}

_network_vpn() {
	local words=( $@ )

	local commands="ipsec security-policies"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		ipsec)
			_network_vpn_ipsec ${args}
			;;
		security-policies)
			_network_vpn_security_policies ${args}
			;;
		esac
}

_network_vpn_ipsec() {
	local words=( $@ )

	local commands="connection"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		connection)
			_network_vpn_ipsec_connection ${args}
			;;
		esac
}

_network_vpn_ipsec_connection() {
	local words=( $@ )

	local commands="destroy new $(network raw list-ipsec-connections)"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		destroy)
			:
			;;
		new)
			:
			;;
		*)
			if network raw ipsec-connection-exists ${cmd}; then
				_network_vpn_ipsec_connection_subcommands ${cmd} ${args}
			fi
			;;
		esac
}

_network_vpn_ipsec_connection_subcommands() {
	local connection=${1}
	shift
	local words=( $@ )

	local commands="authentication down inactivity-timeout local mode peer remote security-policy show up"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		authentication)
			_network_vpn_ipsec_connection_subcommands_authentication ${connection} ${args}
			;;
		local)
			_network_vpn_ipsec_connection_subcommands_local_remote ${connection} "local" ${args}
			;;
		mode)
			_network_vpn_ipsec_connection_subcommands_mode ${args}
			;;
		remote)
			_network_vpn_ipsec_connection_subcommands_local_remote ${connection} "remote" ${args}
			;;
		security-policy)
			_network_vpn_ipsec_connection_subcommands_security_policy ${args}
			;;
		esac
}

_network_vpn_ipsec_connection_subcommands_authentication() {
	local connection=${1}
	shift
	local words=( $@ )

	local commands="mode pre-shared-key"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		mode)
			_network_vpn_ipsec_connection_subcommands_authentication_mode ${connection} ${args}
			;;
			esac
}

_network_vpn_ipsec_connection_subcommands_local_remote() {
	local connection=${1}
	local type=${2}
	shift 2
	local words=( $@ )

	local commands="id prefix"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		prefix)
			_network_vpn_ipsec_connection_subcommands_prefix "${connection}" "${type}" ${args}
			;;
			esac
}

_network_vpn_ipsec_connection_subcommands_prefix() {
	:
}

_network_vpn_ipsec_connection_subcommands_authentication_mode() {
	local connection=${1}
	shift
	local words=( $@ )

	local commands="PSK"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi
}

_network_vpn_ipsec_connection_subcommands_mode() {
	local words=( $@ )

	local commands="gre-transport tunnel vti"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi
}

_network_vpn_ipsec_connection_subcommands_security_policy() {
	local words=( $@ )

	local commands="$(network raw list-vpn-security-policies-all)"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi
}

_network_vpn_security_policies() {
	local words=( $@ )

	local commands="destroy new $(network raw list-vpn-security-policies-all)"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		destroy)
			:
			;;
		new)
			:
			;;
		*)
			if network raw vpn-security-policy-exists ${cmd}; then
				_network_vpn_security_policies_subcommands ${cmd} ${args}
			fi
			;;
		esac
}

_network_vpn_security_policies_subcommands() {
	local policy=${1}
	shift
	local words=( $@ )

	local commands="cipher compression group-type integrity key-exchange lifetime pfs show"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		cipher)
			_network_vpn_security_policies_subcommands_cipher ${policy} ${args}
			;;
		compression)
			_network_vpn_security_policies_subcommands_compression ${policy} ${args}
			;;
		group-type)
			_network_vpn_security_policies_subcommands_group_type ${policy} ${args}
			;;
		integrity)
			_network_vpn_security_policies_subcommands_integrity ${policy} ${args}
			;;
		key-exchange)
			_network_vpn_security_policies_subcommands_key_exchange ${policy} ${args}
			;;
		pfs)
			_network_vpn_security_policies_subcommands_pfs ${policy} ${args}
			;;
		esac
}

_network_vpn_security_policies_subcommands_cipher() {
	:
}

_network_vpn_security_policies_subcommands_compression() {
	:
}

_network_vpn_security_policies_subcommands_group_type() {
	:
}

_network_vpn_security_policies_subcommands_integrity() {
	:
}

_network_vpn_security_policies_subcommands_key_exchange() {
	:
}

_network_vpn_security_policies_subcommands_pfs() {
	:
}

_network_zone() {
	local words=( $@ )

	local commands="new destroy $(network raw list-zones)"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi


	local args="${words[@]:1}"
	case "${cmd}" in
		new)
			_network_zone_new ${args}
			;;
		destroy)
			_network_complete_zones
			;;
		*)
			local zone="${cmd}"
			local args="${words[@]:1}"
			_network_zone_subcommand "${zone}" ${args}
			;;
	esac
}

_network_zone_new() {
	local words=( $@ )
	local cmd=${words[@]:0:1}

	# Suggest useful zone names
	if [[ -z "${cmd}" ]]; then
		local commands="$(network raw list-next-free-zones)"
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )

	# If a valid zone name was entered, we can move on
	elif network raw zone-name-is-valid ${cmd}; then
		local args="${words[@]:1}"
		_network_complete_hooks zone ${args}
	fi

	return 0
}

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

	local words=( $@ )

	local commands="color config description disable down edit enable identify port rename status up"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	local args="${words[@]:1}"
	case "${cmd}" in
		config)
			_network_zone_subcommand_config "${zone}" ${args}
			;;
		port)
			_network_zone_subcommand_port "${zone}" ${args}
			;;
		color)
			_network_color ${args}
			;;
		description)
			_network_description ${args}
			;;
	esac
}

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

	local words=( $@ )

	local commands="destroy list new $(network raw list-zone-config-hids ${zone})"

	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	local args="${words[@]:1}"
	case "${cmd}" in
		new)
			_network_complete_hooks "config"
			;;
		destroy)
			_network_zone_subcommand_config_destroy ${zone} ${args}
			;;
		*)
			if network raw zone-config-id-is-valid ${zone} ${cmd} || network raw zone-config-hid-is-valid ${zone} ${cmd}; then
				_network_zone_subcommand_config_subcommand ${zone} ${args}
			fi
			;;
	esac
}

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

	local words=( $@ )

	local commands="edit"

	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi
}

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

	local words=( $@ )

	local commands="$(network raw list-zone-config-ids ${zone})"

	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi
}

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

	local words=( $@ )

	local commands="attach detach $(network raw list-ports-of-zone "${zone}")"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	case "${cmd}" in
		attach)
			COMPREPLY=( $(compgen -W "$(network raw list-free-ports "${zone}")" \
				-- "${cur}") )
			;;
		detach)
			COMPREPLY=( $(compgen -W "$(network raw list-ports-of-zone "${zone}")" \
				-- "${cur}") )
			;;
		*)
			local port="${cmd}"
			local args="${words[@]:1}"
			_network_zone_subcommand_port_subcommand "${zone}" "${port}" ${args}
			;;
	esac
}

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

	local words=( $@ )

	local commands="edit"
	local cmd="$(_network_find_on_cmdline "${commands}")"
	if [[ -z "${cmd}" ]]; then
		COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
		return 0
	fi

	case "${cmd}" in
		edit)
			# TODO auto-complete the zone-port hook
			;;
	esac
}

_network() {
	local cur prev words cword
	_init_completion || return

	local cmd i
	for (( i=1; i < ${#words[@]} - 1; i++ )); do
		[[ "${words[i]}" = -* ]] && continue
		cmd="${words[i]}" && break
	done

	if [[ -z "${cmd}" ]]; then
		case "${cur}" in
			-*)
				COMPREPLY=( $(compgen -W "--debug" -- "${cur}") )
				;;
			*)
				COMPREPLY=( $(compgen -W "device dhcpv4 dhcpv6 dns-server \
					help hostname port reset route settings status vpn zone" \
					-- "${cur}") )
				;;
		esac

		return 0
	fi

	local args="${words[@]:i+1}"
	case "${cmd}" in
		device)
			_network_device ${args}
			;;
		dhcpv[64])
			_network_dhcpd "${cmd/dhcpv/ipv}" ${args}
			;;
		dns-server)
			_network_dns_server ${args}
			;;
		port)
			_network_port ${args}
			;;
		route)
			_network_route ${args}
			;;
		settings)
			_network_settings ${args}
			;;
		start|stop|status)
			# start, stop and status optionally take a zone
			_network_complete_zones
			;;
		vpn)
			_network_vpn ${args}
			;;
		zone)
			_network_zone ${args}
			;;
	esac
} && complete -F _network network
Commit	Line	Data
bae37360 MT	1	#!/bin/bash
	2	###############################################################################
	3	# #
	4	# IPFire.org - A linux based firewall #
	5	# Copyright (C) 2014 Michael Tremer #
	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	# network(8) completion
	22
1c6a4e30	23	_network_find_on_cmdline () {
bae37360 MT	24	local word subcommand c=0
	25	while [ ${c} -lt ${cword} ]; do
	26	word="${words[c]}"
	27	for subcommand in ${1}; do
	28	if [ "${subcommand}" = "${word}" ]; then
	29	echo "${subcommand}"
	30	return
	31	fi
	32	done
	33	((c++))
	34	done
	35	}
	36
1c6a4e30	37	_network_complete_hooks() {
bae37360 MT	38	local type="${1}"
	39
	40	COMPREPLY=( $(compgen -W "$(network raw list-hooks "${type}")" -- "${cur}") )
	41	}
	42
1c6a4e30	43	_network_complete_ports() {
bae37360 MT	44	COMPREPLY=( $(compgen -W "$(network raw list-ports)" -- "${cur}") )
	45	}
	46
1c6a4e30	47	_network_complete_zones() {
bae37360 MT	48	COMPREPLY=( $(compgen -W "$(network raw list-zones)" -- "${cur}") )
	49	}
	50
b7fbb0cd JS	51	_network_color() {
	52	local words=( $@ )
	53
	54	local commands="set reset"
	55	local cmd="$(_network_find_on_cmdline "${commands}")"
	56	if [[ -z "${cmd}" ]]; then
	57	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	58	return 0
	59	fi
	60	}
	61
9d3ac4e4 JS	62	_network_description() {
	63	local words=( $@ )
	64
	65	local commands="edit show"
	66	local cmd="$(_network_find_on_cmdline "${commands}")"
	67	if [[ -z "${cmd}" ]]; then
	68	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	69	return 0
	70	fi
	71	}
1c6a4e30	72	_network_device() {
bae37360 MT	73	local words=( $@ )
	74
	75	local commands="list $(network raw list-devices)"
	76	local cmd="$(_network_find_on_cmdline "${commands}")"
	77	if [[ -z "${cmd}" ]]; then
	78	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	79	return 0
	80	fi
	81
	82	local args="${words[@]:1}"
	83	case "${cmd}" in
	84	list)
	85	return 0
	86	;;
	87	*)
	88	_network_device_subcommand ${args}
	89	;;
	90	esac
	91	}
	92
1c6a4e30	93	_network_device_subcommand() {
bae37360 MT	94	local words=( $@ )
bae37360 MT	95
f5ee091e	96	local commands="discover identify monitor status unlock ussd"
bae37360	97	local cmd="$(_network_find_on_cmdline "${commands}")"
bae37360	98	if [[ -z "${cmd}" ]]; then
8d1d2745	99	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
bae37360 MT	100	return 0
bae37360 MT	101	fi
b7fbb0cd	102
bae37360 MT	103	case "${cmd}" in
	104	ussd)
	105	# TODO
	106	;;
	107	esac
	108	}
	109
1c6a4e30	110	_network_dhcpd() {
cc02f6be MT	111	local proto="${1}"
	112	shift
	113
	114	local words=( $@ )
	115
	116	local commands="edit reload restart show start stop subnet"
	117	local cmd="$(_network_find_on_cmdline "${commands}")"
	118	if [[ -z "${cmd}" ]]; then
	119	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	120	return 0
	121	fi
	122
	123	local args="${words[@]:1}"
	124	case "${cmd}" in
	125	subnet)
	126	_network_dhcpd_subnet "${proto}" ${args}
	127	;;
	128	esac
	129	}
	130
1c6a4e30	131	_network_dhcpd_subnet() {
cc02f6be MT	132	local proto="${1}"
	133	shift
	134
	135	local words=( $@ )
	136
	137	local commands="new remove show $(network raw list-dhcpd-subnets "${proto}")"
	138	local cmd="$(_network_find_on_cmdline "${commands}")"
	139	if [[ -z "${cmd}" ]]; then
	140	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	141	return 0
	142	fi
	143
	144	local subnet="${words[0]}"
	145	local args="${words[@]:1}"
	146	case "${cmd}" in
	147	new)
	148	: # TODO
	149	;;
	150	remove)
	151	: # TODO
	152	;;
	153	[0-9]*)
	154	_network_dhcpd_subnet_subcommand "${proto}" "${subnet}" ${args}
	155	;;
	156	esac
	157	}
	158
1c6a4e30	159	_network_dhcpd_subnet_subcommand() {
cc02f6be MT	160	local proto="${1}"
	161	local subnet="${2}"
	162	shift 2
	163
	164	local words=( $@ )
	165
	166	local commands="edit options range show"
	167	local cmd="$(_network_find_on_cmdline "${commands}")"
	168	if [[ -z "${cmd}" ]]; then
	169	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	170	return 0
	171	fi
	172
	173	local args="${words[@]:1}"
	174	case "${cmd}" in
	175	edit)
	176	: # TODO
	177	;;
	178	options)
	179	_network_dhcpd_subnet_subcommand_options "${proto}" "${subnet}" ${args}
	180	;;
	181	range)
	182	_network_dhcpd_subnet_subcommand_range "${proto}" "${subnet}" ${args}
	183	;;
	184	esac
	185	}
	186
1c6a4e30	187	_network_dhcpd_subnet_subcommand_options() {
cc02f6be MT	188	local proto="${1}"
	189	local subnet="${2}"
	190	shift 2
	191
	192	local options option
	193	for option in $(network raw list-dhcpd-subnet-options "${proto}"); do
	194	options="${options} ${option}="
	195	done
	196
	197	COMPREPLY=( $(compgen -W "${options}" -- "${cur}") )
	198	}
	199
1c6a4e30	200	_network_dhcpd_subnet_subcommand_range() {
cc02f6be MT	201	local proto="${1}"
	202	local subnet="${2}"
	203	shift 2
	204
	205	local words=( $@ )
	206
	207	local commands="new remove"
	208	local cmd="$(_network_find_on_cmdline "${commands}")"
	209	if [[ -z "${cmd}" ]]; then
	210	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	211	return 0
	212	fi
	213
	214	case "${cmd}" in
	215	new)
	216	COMPREPLY=( $(compgen -W "--end= --start=" -- "${cur}") )
	217	;;
	218	remove)
	219	COMPREPLY=( $(compgen -W "$(network raw list-dhcpd-ranges-of-subnet "${proto}" "${subnet}")" \
	220	-- "${cur}") )
	221	;;
	222	esac
	223	}
	224
1c6a4e30	225	_network_dns_server() {
8d1d2745 MT	226	local words=( $@ )
	227
	228	local commands="add list remove update"
	229	local cmd="$(_network_find_on_cmdline "${commands}")"
	230	if [[ -z "${cmd}" ]]; then
	231	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	232	return 0
	233	fi
	234
	235	case "${cmd}" in
	236	remove)
	237	COMPREPLY=( $(compgen -W "$(network raw list-dns-servers)" \
	238	-- "${cur}") )
	239	;;
	240	esac
	241	}
	242
1c6a4e30	243	_network_port() {
bae37360 MT	244	local words=( $@ )
	245
	246	local commands="new destroy $(network raw list-ports)"
	247	local cmd="$(_network_find_on_cmdline "${commands}")"
	248	if [[ -z "${cmd}" ]]; then
	249	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	250	return 0
	251	fi
	252
	253	local args="${words[@]:1}"
	254	case "${cmd}" in
	255	new)
	256	_network_complete_hooks "port"
	257	;;
	258	destroy)
	259	_network_complete_ports
	260	;;
	261	*)
	262	local args="${words[@]:1}"
	263	_network_port_subcommand ${args}
	264	;;
	265	esac
	266	}
	267
1c6a4e30	268	_network_port_subcommand() {
bae37360 MT	269	local words=( $@ )
bae37360 MT	270
9d3ac4e4	271	local commands="color create description down edit identify remove status up"
bae37360 MT	272	local cmd="$(_network_find_on_cmdline "${commands}")"
	273	if [[ -z "${cmd}" ]]; then
	274	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	275	return 0
	276	fi
b7fbb0cd JS	277
	278	local args="${words[@]:1}"
	279	case "${cmd}" in
	280	color)
	281	_network_color ${args}
	282	;;
9d3ac4e4 JS	283	description)
	284	_network_description ${args}
	285	;;
b7fbb0cd JS	286	esac
b7fbb0cd JS	287
bae37360 MT	288	}
bae37360 MT	289
1c6a4e30	290	_network_route() {
8d1d2745 MT	291	local words=( $@ )
8d1d2745 MT	292
240367ba JS	293	local commands="static"
	294	local cmd="$(_network_find_on_cmdline "${commands}")"
	295	if [[ -z "${cmd}" ]]; then
	296	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	297	return 0
	298	fi
	299
	300	case "${cmd}" in
	301	static)
	302	local args="${words[@]}"
	303	_network_route_static ${args}
	304	;;
	305	esac
	306
	307	}
	308
	309	_network_route_static() {
	310	local words=( $@ )
	311
86c225b8	312	local commands="add list remove reload"
8d1d2745 MT	313	local cmd="$(_network_find_on_cmdline "${commands}")"
	314	if [[ -z "${cmd}" ]]; then
	315	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	316	return 0
	317	fi
	318
	319	case "${cmd}" in
	320	add)
	321	if [[ "${cur}" = -* ]]; then
	322	COMPREPLY=( $(compgen -W "--blackhole --gateway= --mtu= \
	323	--prohibit --unreachable" -- "${cur}") )
	324	fi
	325	;;
	326	list)
	327	# TODO auto-complete options like --protocol here
	328	COMPREPLY=( $(compgen -W "--protocol=" -- "${cur}") )
	329	;;
	330	esac
	331	}
	332
1c6a4e30	333	_network_settings() {
bae37360 MT	334	local words=( $@ )
	335
	336	local key keys
	337	for key in $(network raw list-settings); do
	338	keys="${keys} ${key}="
	339	done
	340	COMPREPLY=( $(compgen -W "${keys}" -- "${cur}") )
	341	}
	342
93097eca JS	343	_network_vpn() {
	344	local words=( $@ )
	345
98699861	346	local commands="ipsec security-policies"
93097eca JS	347	local cmd="$(_network_find_on_cmdline "${commands}")"
	348	if [[ -z "${cmd}" ]]; then
	349	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	350	return 0
	351	fi
	352
	353
	354	local args="${words[@]:1}"
	355	case "${cmd}" in
	356	ipsec)
	357	_network_vpn_ipsec ${args}
	358	;;
98699861 JS	359	security-policies)
	360	_network_vpn_security_policies ${args}
	361	;;
93097eca JS	362	esac
	363	}
	364
	365	_network_vpn_ipsec() {
	366	local words=( $@ )
	367
	368	local commands="connection"
	369	local cmd="$(_network_find_on_cmdline "${commands}")"
	370	if [[ -z "${cmd}" ]]; then
	371	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	372	return 0
	373	fi
	374
	375
	376	local args="${words[@]:1}"
	377	case "${cmd}" in
	378	connection)
	379	_network_vpn_ipsec_connection ${args}
	380	;;
	381	esac
	382	}
	383
	384	_network_vpn_ipsec_connection() {
	385	local words=( $@ )
	386
	387	local commands="destroy new $(network raw list-ipsec-connections)"
	388	local cmd="$(_network_find_on_cmdline "${commands}")"
	389	if [[ -z "${cmd}" ]]; then
	390	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	391	return 0
	392	fi
	393
	394
	395	local args="${words[@]:1}"
	396	case "${cmd}" in
	397	destroy)
	398	:
	399	;;
	400	new)
	401	:
	402	;;
	403	*)
	404	if network raw ipsec-connection-exists ${cmd}; then
	405	_network_vpn_ipsec_connection_subcommands ${cmd} ${args}
	406	fi
	407	;;
	408	esac
	409	}
	410
	411	_network_vpn_ipsec_connection_subcommands() {
	412	local connection=${1}
	413	shift
	414	local words=( $@ )
	415
3d6f0365	416	local commands="authentication down inactivity-timeout local mode peer remote security-policy show up"
93097eca JS	417	local cmd="$(_network_find_on_cmdline "${commands}")"
	418	if [[ -z "${cmd}" ]]; then
	419	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	420	return 0
	421	fi
	422
	423
	424	local args="${words[@]:1}"
	425	case "${cmd}" in
	426	authentication)
	427	_network_vpn_ipsec_connection_subcommands_authentication ${connection} ${args}
	428	;;
	429	local)
	430	_network_vpn_ipsec_connection_subcommands_local_remote ${connection} "local" ${args}
	431	;;
	432	mode)
	433	_network_vpn_ipsec_connection_subcommands_mode ${args}
	434	;;
	435	remote)
faf53925	436	_network_vpn_ipsec_connection_subcommands_local_remote ${connection} "remote" ${args}
93097eca JS	437	;;
	438	security-policy)
	439	_network_vpn_ipsec_connection_subcommands_security_policy ${args}
	440	;;
	441	esac
	442	}
	443
	444	_network_vpn_ipsec_connection_subcommands_authentication() {
	445	local connection=${1}
	446	shift
	447	local words=( $@ )
	448
6fe4b2fd	449	local commands="mode pre-shared-key"
93097eca JS	450	local cmd="$(_network_find_on_cmdline "${commands}")"
	451	if [[ -z "${cmd}" ]]; then
	452	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	453	return 0
	454	fi
	455
	456
	457	local args="${words[@]:1}"
	458	case "${cmd}" in
	459	mode)
	460	_network_vpn_ipsec_connection_subcommands_authentication_mode ${connection} ${args}
	461	;;
	462	esac
	463	}
	464
	465	_network_vpn_ipsec_connection_subcommands_local_remote() {
	466	local connection=${1}
	467	local type=${2}
	468	shift 2
	469	local words=( $@ )
	470
	471	local commands="id prefix"
	472	local cmd="$(_network_find_on_cmdline "${commands}")"
	473	if [[ -z "${cmd}" ]]; then
	474	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	475	return 0
	476	fi
	477
	478
	479	local args="${words[@]:1}"
	480	case "${cmd}" in
	481	prefix)
	482	_network_vpn_ipsec_connection_subcommands_prefix "${connection}" "${type}" ${args}
	483	;;
	484	esac
	485	}
	486
	487	_network_vpn_ipsec_connection_subcommands_prefix() {
	488	:
	489	}
	490
	491	_network_vpn_ipsec_connection_subcommands_authentication_mode() {
	492	local connection=${1}
	493	shift
	494	local words=( $@ )
	495
	496	local commands="PSK"
	497	local cmd="$(_network_find_on_cmdline "${commands}")"
	498	if [[ -z "${cmd}" ]]; then
	499	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	500	return 0
	501	fi
	502	}
	503
	504	_network_vpn_ipsec_connection_subcommands_mode() {
	505	local words=( $@ )
	506
	507	local commands="gre-transport tunnel vti"
	508	local cmd="$(_network_find_on_cmdline "${commands}")"
	509	if [[ -z "${cmd}" ]]; then
	510	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	511	return 0
	512	fi
	513	}
514
515	_network_vpn_ipsec_connection_subcommands_security_policy() {
516	local words=( $@ )
517
518	local commands="$(network raw list-vpn-security-policies-all)"
519	local cmd="$(_network_find_on_cmdline "${commands}")"
520	if [[ -z "${cmd}" ]]; then
521	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
522	return 0
523	fi
524	}
525
98699861 JS	526	_network_vpn_security_policies() {
	527	local words=( $@ )
	528
	529	local commands="destroy new $(network raw list-vpn-security-policies-all)"
	530	local cmd="$(_network_find_on_cmdline "${commands}")"
	531	if [[ -z "${cmd}" ]]; then
	532	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	533	return 0
	534	fi
	535
	536
	537	local args="${words[@]:1}"
	538	case "${cmd}" in
	539	destroy)
	540	:
	541	;;
	542	new)
	543	:
	544	;;
	545	*)
	546	if network raw vpn-security-policy-exists ${cmd}; then
	547	_network_vpn_security_policies_subcommands ${cmd} ${args}
	548	fi
	549	;;
	550	esac
	551	}
	552
	553	_network_vpn_security_policies_subcommands() {
	554	local policy=${1}
	555	shift
	556	local words=( $@ )
	557
	558	local commands="cipher compression group-type integrity key-exchange lifetime pfs show"
	559	local cmd="$(_network_find_on_cmdline "${commands}")"
	560	if [[ -z "${cmd}" ]]; then
	561	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	562	return 0
	563	fi
	564
	565
	566	local args="${words[@]:1}"
	567	case "${cmd}" in
	568	cipher)
	569	_network_vpn_security_policies_subcommands_cipher ${policy} ${args}
	570	;;
	571	compression)
	572	_network_vpn_security_policies_subcommands_compression ${policy} ${args}
	573	;;
	574	group-type)
	575	_network_vpn_security_policies_subcommands_group_type ${policy} ${args}
	576	;;
	577	integrity)
	578	_network_vpn_security_policies_subcommands_integrity ${policy} ${args}
	579	;;
	580	key-exchange)
	581	_network_vpn_security_policies_subcommands_key_exchange ${policy} ${args}
	582	;;
	583	pfs)
	584	_network_vpn_security_policies_subcommands_pfs ${policy} ${args}
	585	;;
	586	esac
	587	}
	588
	589	_network_vpn_security_policies_subcommands_cipher() {
590	:
591	}
592
593	_network_vpn_security_policies_subcommands_compression() {
594	:
595	}
596
597	_network_vpn_security_policies_subcommands_group_type() {
598	:
599	}
600
601	_network_vpn_security_policies_subcommands_integrity() {
602	:
603	}
604
605	_network_vpn_security_policies_subcommands_key_exchange() {
606	:
607	}
608
609	_network_vpn_security_policies_subcommands_pfs() {
610	:
611	}
612
1c6a4e30	613	_network_zone() {
bae37360 MT	614	local words=( $@ )
	615
	616	local commands="new destroy $(network raw list-zones)"
	617	local cmd="$(_network_find_on_cmdline "${commands}")"
	618	if [[ -z "${cmd}" ]]; then
	619	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	620	return 0
	621	fi
	622
1ca5fe9f	623
bae37360 MT	624	local args="${words[@]:1}"
	625	case "${cmd}" in
	626	new)
1ca5fe9f	627	_network_zone_new ${args}
bae37360 MT	628	;;
	629	destroy)
	630	_network_complete_zones
	631	;;
	632	*)
	633	local zone="${cmd}"
	634	local args="${words[@]:1}"
	635	_network_zone_subcommand "${zone}" ${args}
	636	;;
	637	esac
	638	}
	639
1ca5fe9f JS	640	_network_zone_new() {
	641	local words=( $@ )
	642	local cmd=${words[@]:0:1}
	643
	644	# Suggest useful zone names
	645	if [[ -z "${cmd}" ]]; then
	646	local commands="$(network raw list-next-free-zones)"
	647	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	648
	649	# If a valid zone name was entered, we can move on
	650	elif network raw zone-name-is-valid ${cmd}; then
	651	local args="${words[@]:1}"
	652	_network_complete_hooks zone ${args}
	653	fi
	654
	655	return 0
	656	}
	657
1c6a4e30	658	_network_zone_subcommand() {
bae37360 MT	659	local zone="${1}"
	660	shift
	661
	662	local words=( $@ )
	663
9d3ac4e4	664	local commands="color config description disable down edit enable identify port rename status up"
bae37360 MT	665	local cmd="$(_network_find_on_cmdline "${commands}")"
	666	if [[ -z "${cmd}" ]]; then
	667	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	668	return 0
	669	fi
b7fbb0cd	670
bae37360 MT	671	local args="${words[@]:1}"
	672	case "${cmd}" in
	673	config)
2a6b2397	674	_network_zone_subcommand_config "${zone}" ${args}
bae37360 MT	675	;;
	676	port)
	677	_network_zone_subcommand_port "${zone}" ${args}
	678	;;
b7fbb0cd JS	679	color)
	680	_network_color ${args}
	681	;;
9d3ac4e4 JS	682	description)
	683	_network_description ${args}
	684	;;
bae37360 MT	685	esac
	686	}
	687
2a6b2397 MT	688	_network_zone_subcommand_config() {
	689	local zone="${1}"
	690	shift
	691
	692	local words=( $@ )
	693
c8aafc4e	694	local commands="destroy list new $(network raw list-zone-config-hids ${zone})"
cbf7473c	695
2a6b2397 MT	696	local cmd="$(_network_find_on_cmdline "${commands}")"
	697	if [[ -z "${cmd}" ]]; then
	698	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	699	return 0
	700	fi
	701
cbf7473c	702	local args="${words[@]:1}"
2a6b2397 MT	703	case "${cmd}" in
	704	new)
	705	_network_complete_hooks "config"
	706	;;
cbf7473c JS	707	destroy)
	708	_network_zone_subcommand_config_destroy ${zone} ${args}
	709	;;
cbf7473c	710	*)
c8aafc4e	711	if network raw zone-config-id-is-valid ${zone} ${cmd} \|\| network raw zone-config-hid-is-valid ${zone} ${cmd}; then
cbf7473c JS	712	_network_zone_subcommand_config_subcommand ${zone} ${args}
	713	fi
	714	;;
2a6b2397 MT	715	esac
	716	}
	717
cbf7473c JS	718	_network_zone_subcommand_config_subcommand() {
	719	local zone="${1}"
	720	shift
	721
	722	local words=( $@ )
	723
	724	local commands="edit"
	725
	726	local cmd="$(_network_find_on_cmdline "${commands}")"
	727	if [[ -z "${cmd}" ]]; then
	728	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	729	return 0
	730	fi
	731	}
	732
	733	_network_zone_subcommand_config_destroy() {
	734	local zone="${1}"
	735	shift
	736
	737	local words=( $@ )
	738
	739	local commands="$(network raw list-zone-config-ids ${zone})"
	740
	741	local cmd="$(_network_find_on_cmdline "${commands}")"
	742	if [[ -z "${cmd}" ]]; then
	743	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	744	return 0
	745	fi
	746	}
	747
1c6a4e30	748	_network_zone_subcommand_port() {
bae37360 MT	749	local zone="${1}"
	750	shift
	751
	752	local words=( $@ )
	753
	754	local commands="attach detach $(network raw list-ports-of-zone "${zone}")"
	755	local cmd="$(_network_find_on_cmdline "${commands}")"
	756	if [[ -z "${cmd}" ]]; then
	757	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	758	return 0
	759	fi
	760
	761	case "${cmd}" in
	762	attach)
	763	COMPREPLY=( $(compgen -W "$(network raw list-free-ports "${zone}")" \
	764	-- "${cur}") )
	765	;;
	766	detach)
	767	COMPREPLY=( $(compgen -W "$(network raw list-ports-of-zone "${zone}")" \
	768	-- "${cur}") )
	769	;;
	770	*)
	771	local port="${cmd}"
	772	local args="${words[@]:1}"
	773	_network_zone_subcommand_port_subcommand "${zone}" "${port}" ${args}
	774	;;
	775	esac
	776	}
	777
1c6a4e30	778	_network_zone_subcommand_port_subcommand() {
bae37360 MT	779	local zone="${1}"
	780	local port="${2}"
	781	shift 2
	782
	783	local words=( $@ )
	784
	785	local commands="edit"
	786	local cmd="$(_network_find_on_cmdline "${commands}")"
	787	if [[ -z "${cmd}" ]]; then
	788	COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
	789	return 0
	790	fi
	791
	792	case "${cmd}" in
	793	edit)
	794	# TODO auto-complete the zone-port hook
	795	;;
	796	esac
	797	}
	798
1c6a4e30	799	_network() {
bae37360 MT	800	local cur prev words cword
	801	_init_completion \|\| return
	802
	803	local cmd i
	804	for (( i=1; i < ${#words[@]} - 1; i++ )); do
	805	[[ "${words[i]}" = -* ]] && continue
	806	cmd="${words[i]}" && break
	807	done
	808
	809	if [[ -z "${cmd}" ]]; then
	810	case "${cur}" in
	811	-*)
	812	COMPREPLY=( $(compgen -W "--debug" -- "${cur}") )
	813	;;
	814	*)
cc02f6be	815	COMPREPLY=( $(compgen -W "device dhcpv4 dhcpv6 dns-server \
93097eca	816	help hostname port reset route settings status vpn zone" \
cc02f6be	817	-- "${cur}") )
bae37360 MT	818	;;
	819	esac
	820
	821	return 0
	822	fi
	823
	824	local args="${words[@]:i+1}"
	825	case "${cmd}" in
	826	device)
	827	_network_device ${args}
	828	;;
cc02f6be MT	829	dhcpv[64])
	830	_network_dhcpd "${cmd/dhcpv/ipv}" ${args}
	831	;;
8d1d2745 MT	832	dns-server)
	833	_network_dns_server ${args}
	834	;;
bae37360 MT	835	port)
	836	_network_port ${args}
	837	;;
8d1d2745 MT	838	route)
	839	_network_route ${args}
	840	;;
bae37360 MT	841	settings)
	842	_network_settings ${args}
	843	;;
	844	start\|stop\|status)
	845	# start, stop and status optionally take a zone
	846	_network_complete_zones
	847	;;
93097eca JS	848	vpn)
	849	_network_vpn ${args}
	850	;;
bae37360 MT	851	zone)
	852	_network_zone ${args}
	853	;;
	854	esac
	855	} && complete -F _network network