[people/stevee/network.git] / network

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

# Parse the command line
while [ $# -gt 0 ]; do
	case "${1}" in
		-d|--debug)
			DEBUG=1
			;;
		*)
			action=${1}
			;;
	esac
	shift
	[ -n "${action}" ] && break
done

. /usr/lib/network/functions

function cli_config() {
	if cli_help_requested $@; then
		cli_show_man network-config
		exit ${EXIT_OK}
	fi

	if [ -n "${1}" ]; then
		config_set $@
		network_config_write
	else
		network_config_print
	fi
}

function cli_device() {
	if cli_help_requested $@; then
		cli_show_man network-device
		exit ${EXIT_OK}
	fi

	local device=${1}
	local action=${2}
	shift 2

	if ! isset device; then
		cli_show_man network-device
		return ${EXIT_ERROR}
	fi

	assert device_exists ${device}

	case "${action}" in
		discover)
			cli_device_discover ${device} $@
			;;
		status)
			cli_device_status ${device}
			;;
		unlock)
			cli_device_serial_unlock ${device} $@
			;;
		*)
			cli_show_man network-device
			;;
	esac

	return ${EXIT_OK}
}

function cli_device_status() {
	local device=${1}
	assert device_exists ${device}

	# Disable debugging output here.
	local log_disable_stdout=${LOG_DISABLE_STDOUT}
	LOG_DISABLE_STDOUT="true"

	# Save the type of the device for later.
	local type=$(device_get_type ${device})

	cli_headline 1 "Device status: ${device}"
	cli_print_fmt1 1 "Name"		"${device}"

	# Handle serial devices.
	if [ "${type}" = "serial" ]; then
		cli_device_status_serial ${device}
		return $?
	fi

	# Print the device status.
	device_is_up ${device} &>/dev/null
	local status=$?

	case "${status}" in
		${EXIT_TRUE})
			status="${COLOUR_GREEN}UP${COLOUR_NORMAL}"
			;;
		${EXIT_FALSE})
			status="${COLOUR_RED}DOWN${COLOUR_NORMAL}"
			;;
	esac

	cli_print_fmt1 1 "Status"	"${status}"
	cli_print_fmt1 1 "Type"		"${type}"
	cli_print_fmt1 1 "Address"	"$(device_get_address ${device})"
	cli_space

	# Print the link speed for ethernet devices.
	if device_is_up ${device} &>/dev/null; then
		case "${type}" in
			ethernet)
				cli_print_fmt1 1 "Link" \
					"$(device_get_speed ${device}) MBit/s $(device_get_duplex ${device}) duplex"
				;;
		esac
	fi

	cli_print_fmt1 1 "MTU"		"$(device_get_mtu ${device})"
	cli_space

	# Print device statistics.
	cli_device_stats 2 ${device}

	# Print some more information.
	device_has_carrier ${device} &>/dev/null
	cli_print_fmt1 1 "Has carrier?"	"$(cli_print_bool $?)"

	device_is_promisc ${device} &>/dev/null
	cli_print_fmt1 1 "Promisc"	"$(cli_print_bool $?)"
	cli_space

	# Print all virtual devices.
	local virtuals=$(device_get_virtuals ${device})
	if [ -n "${virtuals}" ]; then
		cli_headline 2 "Virtual devices"

		local virtual
		for virtual in ${virtuals}; do
			cli_print 2 "* %-6s - %s" "${virtual}" "$(device_get_address ${virtual})"
		done
		cli_space
	fi

	# Reset the logging level.
	LOG_DISABLE_STDOUT=${log_disable_stdout}
}

function cli_device_status_serial() {
	local device=${1}
	assert device_is_serial ${device}

	serial_is_locked ${device} &>/dev/null
	local locked=$?

	cli_print_fmt1 1 "Locked" "$(cli_print_bool ${locked})"
	cli_space

	# Cannot go on when the device is locked.
	[ ${locked} -eq ${EXIT_TRUE} ] && return ${EXIT_OK}

	cli_print_fmt1 1 "Manufacturer" \
		"$(modem_get_manufacturer ${device})"
	cli_print_fmt1 1 "Model" \
		"$(modem_get_model ${device})"
	cli_print_fmt1 1 "Software version" \
		"$(modem_get_software_version ${device})"

	if modem_is_mobile ${device}; then
		cli_print_fmt1 1 "IMEI" \
			"$(modem_get_device_imei ${device})"
		cli_space

		cli_headline 2 "Network status"
		modem_sim_status ${device} &>/dev/null
		local sim_status_code=$?

		local sim_status="unknown"
		case "${sim_status_code}" in
			${EXIT_SIM_READY})
				sim_status="SIM ready"
				;;
			${EXIT_SIM_PIN})
				sim_status="PIN locked"
				;;
			${EXIT_SIM_PUK})
				sim_status="PUK locked"
				;;
		esac
		cli_print_fmt1 2 "SIM status" "${sim_status}"

		if [ ${sim_status_code} -eq ${EXIT_SIM_READY} ]; then
			cli_print_fmt1 2 "IMSI" \
				"$(modem_get_sim_imsi ${device})"
			cli_print_fmt1 2 "Operator" \
				"$(modem_get_network_operator ${device})"
			cli_print_fmt1 2 "Mode" \
				"$(modem_get_network_mode ${device})"
			cli_print_fmt1 2 "Signal quality" \
				"$(modem_get_signal_quality ${device}) dBm"

			local ber=$(modem_get_bit_error_rate ${device})
			isset ber || ber="unknown"
			cli_print_fmt1 2 "Bit Error Rate" "${ber}"
		fi
	fi
	cli_space
}

function cli_device_discover() {
	local device=${1}
	shift

	local device_type=$(device_get_type ${device})
	if [ "${device_type}" != "real" ]; then
		return ${EXIT_OK}
	fi

	local raw

	while [ $# -gt 0 ]; do
		case "${1}" in
			--raw)
				raw=1
				;;
		esac
		shift
	done

	local up
	device_is_up ${device} && up=1
	device_set_up ${device}

	enabled raw || echo "${device}"

	local hook
	local out
	local ret
	for hook in $(hook_zone_get_all); do
		out=$(hook_zone_exec ${hook} discover ${device})
		ret=$?

		[ ${ret} -eq ${DISCOVER_NOT_SUPPORTED} ] && continue

		if enabled raw; then
			case "${ret}" in
				${DISCOVER_OK})
					echo "${hook}: OK"
					local line
					while read line; do
						echo "${hook}: ${line}"
					done <<<"${out}"
					;;

				${DISCOVER_ERROR})
					echo "${hook}: FAILED"
					;;
			esac
		else
			case "${ret}" in
				${DISCOVER_OK})
					echo "  ${hook} was successful."
					local line
					while read line; do
						echo "  ${line}"
					done <<<"${out}"
					;;

				${DISCOVER_ERROR})
					echo "  ${hook} failed."
					;;
			esac
		fi
	done

	echo # New line

	[ "${up}" = "1" ] || device_set_down ${device}
}

function cli_device_serial_unlock() {
	if cli_help_requested $@; then
		cli_show_man network-device
		exit ${EXIT_OK}
	fi

	local device=${1}
	assert isset device

	if ! device_is_serial ${device}; then
		error "${device} is not a serial device."
		error "Unlocking is only supported for serial devices."
		exit ${EXIT_ERROR}
	fi

	# Read the current state of the SIM card.
	modem_sim_status ${device} &>/dev/null
	local sim_status_code=$?

	# If the SIM card is already unlocked, we don't need to do anything.
	if [ ${sim_status_code} -eq ${EXIT_SIM_READY} ]; then
		print "The SIM card is already unlocked."
		exit ${EXIT_OK}

	# If the SIM card is in an unknown state, we cannot do anything.
	elif [ ${sim_status_code} -eq ${EXIT_SIM_UNKNOWN} ]; then
		error "The SIM card is in an unknown state."
		exit ${EXIT_ERROR}
	fi

	# Ask for the code.
	local code=${2}
	local require_new_pin="false"
	local new_pin

	while ! isinteger code; do
		local message
		case "${sim_status_code}" in
			${EXIT_SIM_PIN})
				message="Please enter PIN:"
				;;
			${EXIT_SIM_PUK})
				message="Please enter PUK:"
				require_new_pin="true"
				;;
		esac
		assert isset message

		echo -n "${message} "
		read -s code
		echo # Print newline.

		if enabled require_new_pin; then
			local i new_pin2
			for i in 0 1; do
				case "${i}" in
					0)
						message="Please enter a new PIN code:"
						;;
					1)
						message="Please confirm the new PIN code:"
						;;
				esac

				echo -n "${message} "
				read -s new_pin2
				echo # Print newline.

				if [ -n "${new_pin}" ]; then
					if [ "${new_pin}" != "${new_pin2}" ]; then
						error "The entered PIN codes did not match."
						exit ${EXIT_ERROR}
					fi
				else
					new_pin=${new_pin2}
				fi
			done
		fi
	done

	# Trying to unlock the SIM card.
	modem_sim_unlock ${device} ${code} ${new_pin}

	exit $?
}

function cli_hostname() {
	if cli_help_requested $@; then
		cli_show_man network
		exit ${EXIT_OK}
	fi

	local hostname=${1}

	if [ -n "${hostname}" ]; then
		config_hostname ${hostname}
		log INFO "Hostname was set to '${hostname}'."
		log INFO "Changes do only take affect after reboot."
		exit ${EXIT_OK}
	fi

	echo "$(config_hostname)"
	exit ${EXIT_OK}
}

function cli_port() {
	if cli_help_requested $@; then
		cli_show_man network-port
		exit ${EXIT_OK}
	fi

	local action
	local port

	if port_exists ${1}; then
		port=${1}
		action=${2}
		shift 2

		# Action aliases
		case "${action}" in
			start)
				action="up"
				;;
			stop)
				action="down"
				;;
			show)
				action="status"
				;;
		esac

		case "${action}" in
			edit|up|down|status)
				port_${action} ${port} $@
				;;
			*)
				error "Unrecognized argument: ${action}"
				exit ${EXIT_ERROR}
				;;
		esac
	else
		action=${1}
		shift

		case "${action}" in
			create|destroy)
				port_${action} $@
				;;
			*)
				error "Unrecognized argument: ${action}"
				exit ${EXIT_ERROR}
				;;
		esac
	fi
}

function cli_zone() {
	if cli_help_requested $@; then
		cli_show_man network-zone
		exit ${EXIT_OK}
	fi

	local action
	local zone

	if zone_name_is_valid ${1}; then
		zone=${1}
		action=${2}
		shift 2

		# Action aliases
		case "${action}" in
			start)
				action="up"
				;;
			stop)
				action="down"
				;;
			show)
				action="status"
				;;
		esac

		case "${action}" in
			config|down|edit|port|status|up)
				zone_${action} ${zone} $@
				;;
			*)
				error "Unrecognized argument: ${action}"
				cli_show_man network-zone
				exit ${EXIT_ERROR}
				;;
		esac
	else
		action=${1}
		shift

		case "${action}" in
			create)
				zone_${action} $@
				;;
			remove)
				cli_zone_remove $@
				;;
			list-hooks)
				cli_list_hooks zone $@
				;;
			""|*)
				if [ -n "${action}" ]; then
					error "Unrecognized argument: '${action}'"
					echo
				fi

				cli_show_man network-zone
				exit ${EXIT_ERROR}
				;;
		esac
	fi
}

# Removes a zone either immediately, if it is currently down,
# or adds a tag that the removal will be done when the zone
# is brought down the next time.
function cli_zone_remove() {
	if cli_help_requested $@; then
		cli_show_man network-zone
		exit ${EXIT_OK}
	fi

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

	if zone_is_up ${zone}; then
		echo "Zone '${zone}' is up and will be removed when it goes down the next time."
		zone_remove ${zone}
	else
		echo "Removing zone '${zone}' now..."
		zone_remove_now ${zone}
	fi

	exit ${EXIT_OK}
}

function cli_list_hooks() {
	local type=${1}
	shift

	if cli_help_requested $@; then
		cli_show_man network-zone
		exit ${EXIT_OK}
	fi

	local hook_dir=$(hook_dir ${type})
	local hook

	for hook in ${hook_dir}/*; do
		hook=$(basename ${hook})
		if hook_exists ${type} ${hook}; then
			echo "${hook}"
		fi
	done | sort -u
}

function cli_start() {
	if cli_help_requested $@; then
		cli_show_man network
		exit ${EXIT_OK}
	fi

	local zones=$(zones_get $@)

	local zone
	for zone in ${zones}; do
		zone_start ${zone} &
	done

	wait # until everything is settled
}

function cli_stop() {
	if cli_help_requested $@; then
		cli_show_man network
		exit ${EXIT_OK}
	fi

	local zones=$(zones_get $@)

	local zone
	for zone in ${zones}; do
		zone_stop ${zone} &
	done

	wait # until everything is settled
}

function cli_restart() {
	if cli_help_requested $@; then
		cli_show_man network
		exit ${EXIT_OK}
	fi

	cli_stop $@

	# Give the system some time to calm down
	sleep ${TIMEOUT_RESTART}

	cli_start $@
}

function cli_status() {
	if cli_help_requested $@; then
		cli_show_man network
		exit ${EXIT_OK}
	fi

	# When dumping status information, the debug
	# mode clutters the console which is not what we want.
	# Logging on the console is disabled for a short time.
	local log_disable_stdout=${LOG_DISABLE_STDOUT}
	LOG_DISABLE_STDOUT="true"

	local zones=$(zones_get $@)

	local zone
	for zone in ${zones}; do
		zone_status ${zone}
	done

	# Reset logging.
	LOG_DISABLE_STDOUT=${log_disable_stdout}
}

function cli_reset() {
	if cli_help_requested $@; then
		cli_show_man network
		exit ${EXIT_OK}
	fi

	warning_log "Will reset the whole network configuration!!!"

	# Force mode is disabled by default
	local force=0

	while [ $# -gt 0 ]; do
		case "${1}" in
			--force|-f)
				force=1
				;;
		esac
		shift
	done

	# If we are not running in force mode, we ask the user if he does know
	# what he is doing.
	if ! enabled force; then
		if ! cli_yesno "Do you really want to reset the whole network configuration?"; then
			exit ${EXIT_ERROR}
		fi
	fi

	local zone
	for zone in $(zones_get --all); do
		zone_remove ${zone}
	done

	local port
	for port in $(ports_get --all); do
		port_remove ${port}
	done

	# Flush all DNS servers.
	dns_server_flush

	# Re-run the initialization functions
	init_run

	exit ${EXIT_OK}
}

# Help function: will show the default man page to the user.
# Optionally, there are two arguments taken, the type of hook
# and which hook should be shown.
function cli_help() {
	local type=${1}
	local what=${2}

	# Remove unknown types.
	if ! listmatch ${type} zone port config; then
		type=""
	fi

	# If no arguments were given, we will show the default page.
	if [ -z "${type}" ]; then
		cli_show_man network
		return ${EXIT_OK}
	fi

	if ! hook_exists ${type} ${what}; then
		error "Hook of type '${type}' and name '${what}' could not be found."
		exit "${EXIT_ERROR}"
	fi

	hook_exec ${type} ${what} help
}

function cli_dns() {
	if cli_help_requested $@; then
		cli_show_man network-dns
		exit ${EXIT_OK}
	fi

	# Get the command.
	local cmd=${1}; shift
	if [ -z "${cmd}" ]; then
		cli_show_man network-dns
		exit ${EXIT_ERROR}
	fi

	# Get the new server to process (if any).
	local server=${1}
	local priority=${2}

	case "${cmd}" in
		list)
			__dns_server_println "SERVER" "PRIORITY"
			dns_server_list
			exit ${EXIT_OK}
			;;
		add)
			log INFO "Adding new DNS server: ${server}"
			dns_server_add ${server} ${priority}
			;;
		remove)
			log INFO "Removing DNS server: ${server}"
			dns_server_remove ${server} ${priority}
			;;
		update)
			# Just run the update afterwards.
			;;
		*)
			error "No such command: ${cmd}"
			exit ${EXIT_ERROR}
	esac

	# Update the local DNS configuration after changes have been made.
	dns_generate_resolvconf
	radvd_update

	exit ${EXIT_OK}
}

# Process the given action
case "${action}" in
	init)
		init_run
		;;

	config|hostname|port|device|zone|start|stop|restart|status|reset|dns)
		cli_${action} $@
		;;

	""|help|--help|-h)
		cli_help $@
		;;

	*)
		error "Invalid command given: ${action}"
		cli_usage "network help"
		exit ${EXIT_CONF_ERROR}
		;;
esac

exit ${EXIT_OK}
Commit	Line	Data
5b20e43a MT	1	#!/bin/bash
	2	###############################################################################
	3	# #
	4	# IPFire.org - A linux based firewall #
1848564d	5	# Copyright (C) 2010 Michael Tremer & Christian Schmidt #
5b20e43a MT	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
1848564d MT	22	# Parse the command line
	23	while [ $# -gt 0 ]; do
	24	case "${1}" in
	25	-d\|--debug)
	26	DEBUG=1
5b20e43a	27	;;
1848564d MT	28	*)
1848564d MT	29	action=${1}
5b20e43a	30	;;
5b20e43a	31	esac
5b20e43a	32	shift
1848564d	33	[ -n "${action}" ] && break
5b20e43a MT	34	done
5b20e43a MT	35
3647b19f MT	36	. /usr/lib/network/functions
3647b19f MT	37
9111eb72 MT	38	function cli_config() {
	39	if cli_help_requested $@; then
	40	cli_show_man network-config
	41	exit ${EXIT_OK}
	42	fi
	43
	44	if [ -n "${1}" ]; then
	45	config_set $@
	46	network_config_write
	47	else
	48	network_config_print
	49	fi
	50	}
	51
	52	function cli_device() {
6c74a64c MT	53	if cli_help_requested $@; then
	54	cli_show_man network-device
	55	exit ${EXIT_OK}
	56	fi
	57
9111eb72 MT	58	local device=${1}
	59	local action=${2}
	60	shift 2
	61
ec63256a MT	62	if ! isset device; then
ec63256a MT	63	cli_show_man network-device
9111eb72 MT	64	return ${EXIT_ERROR}
	65	fi
	66
ec63256a MT	67	assert device_exists ${device}
ec63256a MT	68
9111eb72 MT	69	case "${action}" in
9111eb72 MT	70	discover)
9111eb72 MT	71	cli_device_discover ${device} $@
9111eb72 MT	72	;;
ec63256a MT	73	status)
ec63256a MT	74	cli_device_status ${device}
9111eb72	75	;;
6c74a64c MT	76	unlock)
	77	cli_device_serial_unlock ${device} $@
	78	;;
9111eb72 MT	79	*)
	80	cli_show_man network-device
	81	;;
	82	esac
ec63256a MT	83
	84	return ${EXIT_OK}
	85	}
	86
	87	function cli_device_status() {
	88	local device=${1}
	89	assert device_exists ${device}
	90
6c74a64c MT	91	# Disable debugging output here.
	92	local log_disable_stdout=${LOG_DISABLE_STDOUT}
	93	LOG_DISABLE_STDOUT="true"
	94
ec63256a MT	95	# Save the type of the device for later.
	96	local type=$(device_get_type ${device})
	97
	98	cli_headline 1 "Device status: ${device}"
	99	cli_print_fmt1 1 "Name" "${device}"
	100
6c74a64c MT	101	# Handle serial devices.
	102	if [ "${type}" = "serial" ]; then
	103	cli_device_status_serial ${device}
	104	return $?
	105	fi
	106
ec63256a MT	107	# Print the device status.
	108	device_is_up ${device} &>/dev/null
	109	local status=$?
	110
	111	case "${status}" in
	112	${EXIT_TRUE})
	113	status="${COLOUR_GREEN}UP${COLOUR_NORMAL}"
	114	;;
	115	${EXIT_FALSE})
	116	status="${COLOUR_RED}DOWN${COLOUR_NORMAL}"
	117	;;
	118	esac
	119
	120	cli_print_fmt1 1 "Status" "${status}"
	121	cli_print_fmt1 1 "Type" "${type}"
	122	cli_print_fmt1 1 "Address" "$(device_get_address ${device})"
	123	cli_space
	124
	125	# Print the link speed for ethernet devices.
245dffc9 MT	126	if device_is_up ${device} &>/dev/null; then
	127	case "${type}" in
	128	ethernet)
	129	cli_print_fmt1 1 "Link" \
	130	"$(device_get_speed ${device}) MBit/s $(device_get_duplex ${device}) duplex"
	131	;;
	132	esac
	133	fi
ec63256a MT	134
	135	cli_print_fmt1 1 "MTU" "$(device_get_mtu ${device})"
	136	cli_space
	137
3cb2fc42 MT	138	# Print device statistics.
3cb2fc42 MT	139	cli_device_stats 2 ${device}
ec63256a MT	140
	141	# Print some more information.
	142	device_has_carrier ${device} &>/dev/null
	143	cli_print_fmt1 1 "Has carrier?" "$(cli_print_bool $?)"
	144
	145	device_is_promisc ${device} &>/dev/null
	146	cli_print_fmt1 1 "Promisc" "$(cli_print_bool $?)"
	147	cli_space
	148
	149	# Print all virtual devices.
	150	local virtuals=$(device_get_virtuals ${device})
	151	if [ -n "${virtuals}" ]; then
	152	cli_headline 2 "Virtual devices"
	153
	154	local virtual
	155	for virtual in ${virtuals}; do
	156	cli_print 2 "* %-6s - %s" "${virtual}" "$(device_get_address ${virtual})"
	157	done
	158	cli_space
	159	fi
	160
6c74a64c MT	161	# Reset the logging level.
	162	LOG_DISABLE_STDOUT=${log_disable_stdout}
	163	}
	164
	165	function cli_device_status_serial() {
	166	local device=${1}
	167	assert device_is_serial ${device}
	168
	169	serial_is_locked ${device} &>/dev/null
	170	local locked=$?
	171
	172	cli_print_fmt1 1 "Locked" "$(cli_print_bool ${locked})"
	173	cli_space
	174
	175	# Cannot go on when the device is locked.
	176	[ ${locked} -eq ${EXIT_TRUE} ] && return ${EXIT_OK}
	177
	178	cli_print_fmt1 1 "Manufacturer" \
	179	"$(modem_get_manufacturer ${device})"
	180	cli_print_fmt1 1 "Model" \
	181	"$(modem_get_model ${device})"
	182	cli_print_fmt1 1 "Software version" \
	183	"$(modem_get_software_version ${device})"
	184
	185	if modem_is_mobile ${device}; then
	186	cli_print_fmt1 1 "IMEI" \
	187	"$(modem_get_device_imei ${device})"
	188	cli_space
	189
	190	cli_headline 2 "Network status"
	191	modem_sim_status ${device} &>/dev/null
	192	local sim_status_code=$?
	193
	194	local sim_status="unknown"
	195	case "${sim_status_code}" in
	196	${EXIT_SIM_READY})
	197	sim_status="SIM ready"
	198	;;
	199	${EXIT_SIM_PIN})
	200	sim_status="PIN locked"
	201	;;
	202	${EXIT_SIM_PUK})
	203	sim_status="PUK locked"
	204	;;
	205	esac
	206	cli_print_fmt1 2 "SIM status" "${sim_status}"
	207
	208	if [ ${sim_status_code} -eq ${EXIT_SIM_READY} ]; then
	209	cli_print_fmt1 2 "IMSI" \
	210	"$(modem_get_sim_imsi ${device})"
	211	cli_print_fmt1 2 "Operator" \
	212	"$(modem_get_network_operator ${device})"
	213	cli_print_fmt1 2 "Mode" \
	214	"$(modem_get_network_mode ${device})"
	215	cli_print_fmt1 2 "Signal quality" \
	216	"$(modem_get_signal_quality ${device}) dBm"
	217
	218	local ber=$(modem_get_bit_error_rate ${device})
	219	isset ber \|\| ber="unknown"
	220	cli_print_fmt1 2 "Bit Error Rate" "${ber}"
	221	fi
	222	fi
	223	cli_space
9111eb72 MT	224	}
	225
	226	function cli_device_discover() {
	227	local device=${1}
	228	shift
	229
	230	local device_type=$(device_get_type ${device})
	231	if [ "${device_type}" != "real" ]; then
	232	return ${EXIT_OK}
	233	fi
	234
	235	local raw
	236
	237	while [ $# -gt 0 ]; do
	238	case "${1}" in
	239	--raw)
	240	raw=1
	241	;;
	242	esac
	243	shift
	244	done
	245
	246	local up
	247	device_is_up ${device} && up=1
	248	device_set_up ${device}
	249
	250	enabled raw \|\| echo "${device}"
	251
	252	local hook
	253	local out
	254	local ret
	255	for hook in $(hook_zone_get_all); do
	256	out=$(hook_zone_exec ${hook} discover ${device})
	257	ret=$?
	258
	259	[ ${ret} -eq ${DISCOVER_NOT_SUPPORTED} ] && continue
	260
	261	if enabled raw; then
	262	case "${ret}" in
	263	${DISCOVER_OK})
	264	echo "${hook}: OK"
	265	local line
	266	while read line; do
	267	echo "${hook}: ${line}"
	268	done <<<"${out}"
	269	;;
	270
	271	${DISCOVER_ERROR})
	272	echo "${hook}: FAILED"
	273	;;
	274	esac
	275	else
	276	case "${ret}" in
	277	${DISCOVER_OK})
	278	echo " ${hook} was successful."
	279	local line
	280	while read line; do
	281	echo " ${line}"
	282	done <<<"${out}"
	283	;;
	284
	285	${DISCOVER_ERROR})
	286	echo " ${hook} failed."
	287	;;
288	esac
289	fi
290	done
291
292	echo # New line
293
294	[ "${up}" = "1" ] \|\| device_set_down ${device}
295	}
296
6c74a64c MT	297	function cli_device_serial_unlock() {
	298	if cli_help_requested $@; then
	299	cli_show_man network-device
	300	exit ${EXIT_OK}
	301	fi
	302
	303	local device=${1}
	304	assert isset device
	305
	306	if ! device_is_serial ${device}; then
	307	error "${device} is not a serial device."
	308	error "Unlocking is only supported for serial devices."
	309	exit ${EXIT_ERROR}
	310	fi
	311
	312	# Read the current state of the SIM card.
	313	modem_sim_status ${device} &>/dev/null
	314	local sim_status_code=$?
	315
	316	# If the SIM card is already unlocked, we don't need to do anything.
	317	if [ ${sim_status_code} -eq ${EXIT_SIM_READY} ]; then
	318	print "The SIM card is already unlocked."
	319	exit ${EXIT_OK}
	320
	321	# If the SIM card is in an unknown state, we cannot do anything.
	322	elif [ ${sim_status_code} -eq ${EXIT_SIM_UNKNOWN} ]; then
	323	error "The SIM card is in an unknown state."
	324	exit ${EXIT_ERROR}
	325	fi
	326
	327	# Ask for the code.
	328	local code=${2}
	329	local require_new_pin="false"
	330	local new_pin
	331
	332	while ! isinteger code; do
	333	local message
	334	case "${sim_status_code}" in
	335	${EXIT_SIM_PIN})
	336	message="Please enter PIN:"
	337	;;
	338	${EXIT_SIM_PUK})
	339	message="Please enter PUK:"
	340	require_new_pin="true"
	341	;;
	342	esac
	343	assert isset message
	344
	345	echo -n "${message} "
	346	read -s code
	347	echo # Print newline.
	348
	349	if enabled require_new_pin; then
	350	local i new_pin2
	351	for i in 0 1; do
	352	case "${i}" in
	353	0)
	354	message="Please enter a new PIN code:"
	355	;;
	356	1)
	357	message="Please confirm the new PIN code:"
	358	;;
	359	esac
	360
361	echo -n "${message} "
362	read -s new_pin2
363	echo # Print newline.
364
365	if [ -n "${new_pin}" ]; then
366	if [ "${new_pin}" != "${new_pin2}" ]; then
367	error "The entered PIN codes did not match."
368	exit ${EXIT_ERROR}
369	fi
370	else
371	new_pin=${new_pin2}
372	fi
373	done
374	fi
375	done
376
377	# Trying to unlock the SIM card.
378	modem_sim_unlock ${device} ${code} ${new_pin}
379
380	exit $?
381	}
382
9111eb72 MT	383	function cli_hostname() {
	384	if cli_help_requested $@; then
	385	cli_show_man network
	386	exit ${EXIT_OK}
	387	fi
	388
	389	local hostname=${1}
	390
	391	if [ -n "${hostname}" ]; then
	392	config_hostname ${hostname}
	393	log INFO "Hostname was set to '${hostname}'."
	394	log INFO "Changes do only take affect after reboot."
	395	exit ${EXIT_OK}
	396	fi
	397
	398	echo "$(config_hostname)"
	399	exit ${EXIT_OK}
	400	}
	401
	402	function cli_port() {
	403	if cli_help_requested $@; then
	404	cli_show_man network-port
	405	exit ${EXIT_OK}
	406	fi
	407
	408	local action
	409	local port
	410
	411	if port_exists ${1}; then
	412	port=${1}
	413	action=${2}
	414	shift 2
	415
	416	# Action aliases
	417	case "${action}" in
	418	start)
	419	action="up"
	420	;;
	421	stop)
	422	action="down"
	423	;;
	424	show)
	425	action="status"
	426	;;
	427	esac
	428
	429	case "${action}" in
	430	edit\|up\|down\|status)
	431	port_${action} ${port} $@
	432	;;
	433	*)
	434	error "Unrecognized argument: ${action}"
	435	exit ${EXIT_ERROR}
	436	;;
	437	esac
	438	else
	439	action=${1}
	440	shift
	441
	442	case "${action}" in
	443	create\|destroy)
	444	port_${action} $@
	445	;;
	446	*)
447	error "Unrecognized argument: ${action}"
448	exit ${EXIT_ERROR}
449	;;
450	esac
451	fi
452	}
453
454	function cli_zone() {
455	if cli_help_requested $@; then
456	cli_show_man network-zone
457	exit ${EXIT_OK}
458	fi
459
460	local action
461	local zone
462
463	if zone_name_is_valid ${1}; then
464	zone=${1}
465	action=${2}
466	shift 2
467
468	# Action aliases
469	case "${action}" in
470	start)
471	action="up"
472	;;
473	stop)
474	action="down"
475	;;
476	show)
477	action="status"
478	;;
479	esac
480
481	case "${action}" in
482	config\|down\|edit\|port\|status\|up)
483	zone_${action} ${zone} $@
484	;;
485	*)
486	error "Unrecognized argument: ${action}"
487	cli_show_man network-zone
488	exit ${EXIT_ERROR}
489	;;
490	esac
491	else
492	action=${1}
493	shift
494
495	case "${action}" in
496	create)
497	zone_${action} $@
498	;;
499	remove)
500	cli_zone_remove $@
501	;;
502	list-hooks)
503	cli_list_hooks zone $@
504	;;
505	""\|*)
506	if [ -n "${action}" ]; then
507	error "Unrecognized argument: '${action}'"
508	echo
509	fi
510
511	cli_show_man network-zone
512	exit ${EXIT_ERROR}
513	;;
514	esac
515	fi
516	}
517
518	# Removes a zone either immediately, if it is currently down,
519	# or adds a tag that the removal will be done when the zone
520	# is brought down the next time.
521	function cli_zone_remove() {
522	if cli_help_requested $@; then
523	cli_show_man network-zone
524	exit ${EXIT_OK}
525	fi
526
527	local zone=${1}
528	assert zone_exists ${zone}
529
530	if zone_is_up ${zone}; then
531	echo "Zone '${zone}' is up and will be removed when it goes down the next time."
532	zone_remove ${zone}
533	else
534	echo "Removing zone '${zone}' now..."
535	zone_remove_now ${zone}
536	fi
537
538	exit ${EXIT_OK}
539	}
540
541	function cli_list_hooks() {
542	local type=${1}
543	shift
544
545	if cli_help_requested $@; then
546	cli_show_man network-zone
547	exit ${EXIT_OK}
548	fi
549
550	local hook_dir=$(hook_dir ${type})
551	local hook
552
553	for hook in ${hook_dir}/*; do
554	hook=$(basename ${hook})
555	if hook_exists ${type} ${hook}; then
556	echo "${hook}"
557	fi
558	done \| sort -u
559	}
560
561	function cli_start() {
562	if cli_help_requested $@; then
563	cli_show_man network
564	exit ${EXIT_OK}
565	fi
566
567	local zones=$(zones_get $@)
568
569	local zone
570	for zone in ${zones}; do
571	zone_start ${zone} &
572	done
573
574	wait # until everything is settled
575	}
576
577	function cli_stop() {
578	if cli_help_requested $@; then
579	cli_show_man network
580	exit ${EXIT_OK}
581	fi
582
583	local zones=$(zones_get $@)
584
585	local zone
586	for zone in ${zones}; do
587	zone_stop ${zone} &
588	done
589
590	wait # until everything is settled
591	}
592
593	function cli_restart() {
594	if cli_help_requested $@; then
595	cli_show_man network
596	exit ${EXIT_OK}
597	fi
598
599	cli_stop $@
600
601	# Give the system some time to calm down
602	sleep ${TIMEOUT_RESTART}
603
604	cli_start $@
605	}
606
607	function cli_status() {
608	if cli_help_requested $@; then
609	cli_show_man network
610	exit ${EXIT_OK}
611	fi
612
613	# When dumping status information, the debug
614	# mode clutters the console which is not what we want.
615	# Logging on the console is disabled for a short time.
616	local log_disable_stdout=${LOG_DISABLE_STDOUT}
617	LOG_DISABLE_STDOUT="true"
618
619	local zones=$(zones_get $@)
620
621	local zone
622	for zone in ${zones}; do
623	zone_status ${zone}
624	done
625
626	# Reset logging.
627	LOG_DISABLE_STDOUT=${log_disable_stdout}
628	}
629
630	function cli_reset() {
631	if cli_help_requested $@; then
632	cli_show_man network
633	exit ${EXIT_OK}
634	fi
635
636	warning_log "Will reset the whole network configuration!!!"
637
638	# Force mode is disabled by default
639	local force=0
640
641	while [ $# -gt 0 ]; do
642	case "${1}" in
643	--force\|-f)
644	force=1
645	;;
646	esac
647	shift
648	done
649
650	# If we are not running in force mode, we ask the user if he does know
651	# what he is doing.
652	if ! enabled force; then
653	if ! cli_yesno "Do you really want to reset the whole network configuration?"; then
654	exit ${EXIT_ERROR}
655	fi
656	fi
657
658	local zone
659	for zone in $(zones_get --all); do
660	zone_remove ${zone}
661	done
662
663	local port
664	for port in $(ports_get --all); do
665	port_remove ${port}
666	done
667
acc9efd5 MT	668	# Flush all DNS servers.
	669	dns_server_flush
	670
9111eb72 MT	671	# Re-run the initialization functions
	672	init_run
	673
	674	exit ${EXIT_OK}
	675	}
	676
85afd775 MT	677	# Help function: will show the default man page to the user.
	678	# Optionally, there are two arguments taken, the type of hook
	679	# and which hook should be shown.
	680	function cli_help() {
	681	local type=${1}
	682	local what=${2}
	683
	684	# Remove unknown types.
	685	if ! listmatch ${type} zone port config; then
	686	type=""
	687	fi
	688
	689	# If no arguments were given, we will show the default page.
	690	if [ -z "${type}" ]; then
	691	cli_show_man network
	692	return ${EXIT_OK}
	693	fi
	694
	695	if ! hook_exists ${type} ${what}; then
	696	error "Hook of type '${type}' and name '${what}' could not be found."
	697	exit "${EXIT_ERROR}"
	698	fi
	699
	700	hook_exec ${type} ${what} help
	701	}
	702
acc9efd5 MT	703	function cli_dns() {
	704	if cli_help_requested $@; then
	705	cli_show_man network-dns
	706	exit ${EXIT_OK}
	707	fi
	708
	709	# Get the command.
	710	local cmd=${1}; shift
	711	if [ -z "${cmd}" ]; then
	712	cli_show_man network-dns
	713	exit ${EXIT_ERROR}
	714	fi
	715
6f923dac MT	716	# Get the new server to process (if any).
	717	local server=${1}
	718	local priority=${2}
	719
acc9efd5 MT	720	case "${cmd}" in
	721	list)
	722	__dns_server_println "SERVER" "PRIORITY"
	723	dns_server_list
e5efaa6b	724	exit ${EXIT_OK}
acc9efd5 MT	725	;;
acc9efd5 MT	726	add)
6f923dac MT	727	log INFO "Adding new DNS server: ${server}"
6f923dac MT	728	dns_server_add ${server} ${priority}
acc9efd5 MT	729	;;
acc9efd5 MT	730	remove)
6f923dac MT	731	log INFO "Removing DNS server: ${server}"
6f923dac MT	732	dns_server_remove ${server} ${priority}
acc9efd5 MT	733	;;
	734	update)
	735	# Just run the update afterwards.
	736	;;
	737	*)
	738	error "No such command: ${cmd}"
	739	exit ${EXIT_ERROR}
	740	esac
	741
	742	# Update the local DNS configuration after changes have been made.
	743	dns_generate_resolvconf
6f923dac	744	radvd_update
acc9efd5 MT	745
	746	exit ${EXIT_OK}
	747	}
	748
1848564d MT	749	# Process the given action
1848564d MT	750	case "${action}" in
b8357295 MT	751	init)
	752	init_run
	753	;;
	754
acc9efd5	755	config\|hostname\|port\|device\|zone\|start\|stop\|restart\|status\|reset\|dns)
0a79ea02	756	cli_${action} $@
1848564d MT	757	;;
1848564d MT	758
fe4555b5	759	""\|help\|--help\|-h)
85afd775	760	cli_help $@
1848564d	761	;;
fe4555b5	762
1848564d	763	*)
fe4555b5	764	error "Invalid command given: ${action}"
de28a630	765	cli_usage "network help"
1848564d	766	exit ${EXIT_CONF_ERROR}
fe4555b5	767	;;
1848564d	768	esac
85afd775 MT	769
85afd775 MT	770	exit ${EXIT_OK}