[people/stevee/network.git] / src / functions / functions.wireless-networks

#!/bin/bash
###############################################################################
#                                                                             #
# IPFire.org - A linux based firewall                                         #
# Copyright (C) 2017  IPFire Network Development Team                         #
#                                                                             #
# 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/>.       #
#                                                                             #
###############################################################################

WIRELESS_NETWORK_CONFIG_SETTINGS="ENCRYPTION_MODE KEY PRIORITY SSID"

WIRELESS_NETWORKS_VALID_ENCRYPTION_MODES="WPA2-PSK"

cli_wireless_network() {
	case "${1}" in
		new)
			wireless_network_new "${@:2}"
			;;
		destroy)
			wireless_network_destroy "${@:2}"
			;;
		*)
			local ssid="${1}"
			local key="${2//-/_}"
			shift

			if ! wireless_network_exists "${ssid}"; then
				error "No such wireless network: ${ssid}"
				return ${EXIT_ERROR}
			fi

			case "${key}" in
				encryption_mode|key|priority)
					wireless_network_${key} "${ssid}" "$@"
					;;
				show)
					wireless_network_show "${ssid}"
					exit $?
					;;
				*)
					error "Unrecognized argument: ${key}"
					exit ${EXIT_ERROR}
					;;
			esac
			;;
	esac
}

# This function writes all values to a via ${ssid} specificated wireless network configuration file
wireless_network_write_config() {
	assert [ $# -ge 1 ]

	local ssid="${1}"

	local ssid_hash="$(wireless_network_hash "${ssid}")"
	assert isset ssid_hash

	if ! wireless_network_exists "${ssid}"; then
		log ERROR "No such wireless network: '${ssid}'"
		return ${EXIT_ERROR}
	fi

	local path="${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}/settings"

	if ! settings_write "${path}" ${WIRELESS_NETWORK_CONFIG_SETTINGS}; then
		log ERROR "Could not write configuration settings for wireless network ${ssid}"
		return ${EXIT_ERROR}
	fi

	# When we get here the writing of the config file was successful
	return ${EXIT_OK}
}

# This funtion writes the value for one key to a via ${ssid} specificated
# wireless network configuration file
wireless_network_write_config_key() {
	assert [ $# -ge 3 ]

	local ssid="${1}"
	local key="${2}"
	shift 2

	local value="$@"

	if ! wireless_network_exists "${ssid}"; then
		log ERROR "No such wireless network: ${ssid}"
		return ${EXIT_ERROR}
	fi

	log DEBUG "Set '${key}' to new value '${value}' in wireless network '${ssid}'"

	local ${WIRELESS_NETWORK_CONFIG_SETTINGS}

	# Read the config settings
	if ! wireless_network_read_config "${ssid}"; then
		return ${EXIT_ERROR}
	fi

	# Set the key to a new value
	assign "${key}" "${value}"

	if ! wireless_network_write_config "${ssid}"; then
		return ${EXIT_ERROR}
	fi

	return ${EXIT_OK}
}

# Reads one or more keys out of a settings file or all if no key is provided.
wireless_network_read_config() {
	assert [ $# -ge 1 ]

	local ssid="${1}"
	shift 1

	local ssid_hash="$(wireless_network_hash "${ssid}")"
	assert isset ssid_hash

	if ! wireless_network_exists "${ssid}"; then
		log ERROR "No such wireless network : ${ssid}"
		return ${EXIT_ERROR}
	fi

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

	local path="${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}/settings"

	if ! settings_read "${path}" ${args}; then
		log ERROR "Could not read settings for wireless network ${ssid}"
		return ${EXIT_ERROR}
	fi
}

# This function checks if a wireless network exists
# Returns True when yes and false when not
wireless_network_exists() {
	assert [ $# -eq 1 ]

	local ssid="${1}"
	local ssid_hash="$(wireless_network_hash "${ssid}")"
	assert isset ssid_hash

	local path="${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}"

	# We cannot use wireless_network_read_config here beacuse we would end in a loop
	local SSID

	local path_settings="${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}/settings"

	if ! settings_read "${path_settings}" SSID; then
		return ${EXIT_FALSE}
	fi

	assert isset SSID

	if [ -d "${path}" ] && [[ "${ssid}" = "${SSID}" ]]; then
		return ${EXIT_TRUE}
	else
		return ${EXIT_FALSE}
	fi
}

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

	local string="${1}"

	local hash=$(echo -n "${string}" | md5sum )
	hash=${hash%%  -}

	local path="${NETWORK_WIRELESS_NETWORKS_DIR}/*${hash}"

	if [ -d "${path}" ]; then
		basename "${path}"
	else
		local normalized=$(normalize "${string}")
		normalized=${normalized%-}
		echo "${normalized}-${hash}"
	fi
}

wireless_network_new() {
	if [ $# -gt 1 ]; then
		error "Too many arguments"
		return ${EXIT_ERROR}
	fi

	local ssid="${1}"
	if ! isset ssid; then
		error "Please provide a SSID"
		return ${EXIT_ERROR}
	fi

	local ssid_hash="$(wireless_network_hash "${ssid}")"
	assert isset ssid_hash

	# Check for duplicates
	if wireless_network_exists "${ssid}"; then
		error "The wireless network ${ssid} already exists"
		return ${EXIT_ERROR}
	fi

	log DEBUG "Creating wireless network '${ssid}'"

	if ! mkdir -p "${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}"; then
		log ERROR "Could not create config directory for wireless network ${ssid}"
		return ${EXIT_ERROR}
	fi

	# When the ssid is not set in the settings file we cannot write it because wireless_network_exists fails
	echo "SSID=\"${ssid}\"" >>"${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}/settings"

	local ${WIRELESS_NETWORK_CONFIG_SETTINGS}
	SSID="${ssid}"
	PRIORITY=500

	if ! wireless_network_write_config "${ssid}"; then
		log ERROR "Could not write new config file"
		return ${EXIT_ERROR}
	fi
}

# Function that deletes based on the passed parameters
# one ore more wireless networks
wireless_network_destroy() {
	local ssid
	for ssid in "$@"; do
		local ssid_hash="$(wireless_network_hash "${ssid}")"
		assert isset ssid_hash

		if ! wireless_network_exists "${ssid}"; then
			log ERROR "The wireless network ${ssid} does not exist."
			continue
		fi

		log DEBUG "Deleting wireless network ${ssid}"

		if ! rm -rf "${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}"; then
			log ERROR "Deleting the wireless network ${ssid} was not sucessful"
			return ${EXIT_ERROR}
		fi
	done
}

wireless_network_encryption_mode() {
	if [ ! $# -eq 2 ]; then
		log ERROR "Not enough arguments"
		return ${EXIT_ERROR}
	fi
	local ssid="${1}"
	local mode="${2}"

	if ! isoneof mode ${WIRELESS_NETWORKS_VALID_ENCRYPTION_MODES}; then
		log ERROR "Encryption mode '${mode}' is invalid"
		return ${EXIT_ERROR}
	fi

	if ! wireless_network_write_config_key "${ssid}" "ENCRYPTION_MODE" ${mode^^}; then
		log ERROR "Could not write configuration settings"
		return ${EXIT_ERROR}
	fi
}

wireless_network_key() {
	if [ ! $# -eq 2 ]; then
		log ERROR "Not enough arguments"
		return ${EXIT_ERROR}
	fi
	local ssid="${1}"
	local key="${2}"

	if ! wireless_network_write_config_key "${ssid}" "KEY" "${key}"; then
		log ERROR "Could not write configuration settings"
		return ${EXIT_ERROR}
	fi
}

wireless_network_priority() {
	if [ ! $# -eq 2 ]; then
		log ERROR "Not enough arguments"
		return ${EXIT_ERROR}
	fi
	local ssid="${1}"
	local priority=${2}

	if ! isinteger priority && [ ! ${priority} -ge 0 ]; then
		log ERROR "The priority must be an integer greater or eqal zero"
		return ${EXIT_ERROR}
	fi

	if ! wireless_network_write_config_key "${ssid}" "PRIORITY" "${priority}"; then
		log ERROR "Could not write configuration settings"
		return ${EXIT_ERROR}
	fi
}
Commit	Line	Data
49958b8c MT	1	#!/bin/bash
	2	###############################################################################
	3	# #
	4	# IPFire.org - A linux based firewall #
	5	# Copyright (C) 2017 IPFire Network Development Team #
	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	WIRELESS_NETWORK_CONFIG_SETTINGS="ENCRYPTION_MODE KEY PRIORITY SSID"
	23
	24	WIRELESS_NETWORKS_VALID_ENCRYPTION_MODES="WPA2-PSK"
	25
	26	cli_wireless_network() {
479b2273 MT	27	case "${1}" in
	28	new)
	29	wireless_network_new "${@:2}"
	30	;;
	31	destroy)
	32	wireless_network_destroy "${@:2}"
	33	;;
	34	*)
	35	local ssid="${1}"
	36	local key="${2//-/_}"
	37	shift
49958b8c	38
479b2273 MT	39	if ! wireless_network_exists "${ssid}"; then
	40	error "No such wireless network: ${ssid}"
	41	return ${EXIT_ERROR}
	42	fi
49958b8c	43
479b2273 MT	44	case "${key}" in
	45	encryption_mode\|key\|priority)
	46	wireless_network_${key} "${ssid}" "$@"
	47	;;
	48	show)
	49	wireless_network_show "${ssid}"
	50	exit $?
	51	;;
	52	*)
	53	error "Unrecognized argument: ${key}"
	54	exit ${EXIT_ERROR}
	55	;;
	56	esac
	57	;;
	58	esac
49958b8c MT	59	}
	60
	61	# This function writes all values to a via ${ssid} specificated wireless network configuration file
	62	wireless_network_write_config() {
	63	assert [ $# -ge 1 ]
	64
	65	local ssid="${1}"
	66
	67	local ssid_hash="$(wireless_network_hash "${ssid}")"
	68	assert isset ssid_hash
	69
	70	if ! wireless_network_exists "${ssid}"; then
	71	log ERROR "No such wireless network: '${ssid}'"
	72	return ${EXIT_ERROR}
	73	fi
	74
	75	local path="${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}/settings"
	76
	77	if ! settings_write "${path}" ${WIRELESS_NETWORK_CONFIG_SETTINGS}; then
	78	log ERROR "Could not write configuration settings for wireless network ${ssid}"
	79	return ${EXIT_ERROR}
	80	fi
	81
	82	# When we get here the writing of the config file was successful
	83	return ${EXIT_OK}
	84	}
	85
	86	# This funtion writes the value for one key to a via ${ssid} specificated
	87	# wireless network configuration file
	88	wireless_network_write_config_key() {
	89	assert [ $# -ge 3 ]
	90
	91	local ssid="${1}"
	92	local key="${2}"
	93	shift 2
	94
	95	local value="$@"
	96
	97	if ! wireless_network_exists "${ssid}"; then
	98	log ERROR "No such wireless network: ${ssid}"
	99	return ${EXIT_ERROR}
	100	fi
	101
	102	log DEBUG "Set '${key}' to new value '${value}' in wireless network '${ssid}'"
	103
	104	local ${WIRELESS_NETWORK_CONFIG_SETTINGS}
	105
	106	# Read the config settings
	107	if ! wireless_network_read_config "${ssid}"; then
	108	return ${EXIT_ERROR}
	109	fi
	110
	111	# Set the key to a new value
	112	assign "${key}" "${value}"
	113
	114	if ! wireless_network_write_config "${ssid}"; then
	115	return ${EXIT_ERROR}
	116	fi
	117
	118	return ${EXIT_OK}
	119	}
	120
	121	# Reads one or more keys out of a settings file or all if no key is provided.
	122	wireless_network_read_config() {
123	assert [ $# -ge 1 ]
124
125	local ssid="${1}"
126	shift 1
127
128	local ssid_hash="$(wireless_network_hash "${ssid}")"
129	assert isset ssid_hash
130
131	if ! wireless_network_exists "${ssid}"; then
132	log ERROR "No such wireless network : ${ssid}"
133	return ${EXIT_ERROR}
134	fi
135
136	local args
137	if [ $# -eq 0 ] && [ -n "${WIRELESS_NETWORK_CONFIG_SETTINGS}" ]; then
138	list_append args ${WIRELESS_NETWORK_CONFIG_SETTINGS}
139	else
140	list_append args "$@"
141	fi
142
143	local path="${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}/settings"
144
145	if ! settings_read "${path}" ${args}; then
146	log ERROR "Could not read settings for wireless network ${ssid}"
147	return ${EXIT_ERROR}
148	fi
149	}
150
151	# This function checks if a wireless network exists
152	# Returns True when yes and false when not
153	wireless_network_exists() {
154	assert [ $# -eq 1 ]
155
156	local ssid="${1}"
157	local ssid_hash="$(wireless_network_hash "${ssid}")"
158	assert isset ssid_hash
159
160	local path="${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}"
161
162	# We cannot use wireless_network_read_config here beacuse we would end in a loop
163	local SSID
164
165	local path_settings="${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}/settings"
166
167	if ! settings_read "${path_settings}" SSID; then
168	return ${EXIT_FALSE}
169	fi
170
171	assert isset SSID
172
173	if [ -d "${path}" ] && [[ "${ssid}" = "${SSID}" ]]; then
174	return ${EXIT_TRUE}
175	else
176	return ${EXIT_FALSE}
177	fi
178	}
179
180	wireless_network_hash() {
181	assert [ $# -eq 1 ]
182
183	local string="${1}"
184
185	local hash=$(echo -n "${string}" \| md5sum )
186	hash=${hash%% -}
187
188	local path="${NETWORK_WIRELESS_NETWORKS_DIR}/*${hash}"
189
190	if [ -d "${path}" ]; then
191	basename "${path}"
192	else
193	local normalized=$(normalize "${string}")
194	normalized=${normalized%-}
195	echo "${normalized}-${hash}"
196	fi
197	}
198
199	wireless_network_new() {
200	if [ $# -gt 1 ]; then
201	error "Too many arguments"
202	return ${EXIT_ERROR}
203	fi
204
205	local ssid="${1}"
206	if ! isset ssid; then
207	error "Please provide a SSID"
208	return ${EXIT_ERROR}
209	fi
210
211	local ssid_hash="$(wireless_network_hash "${ssid}")"
212	assert isset ssid_hash
213
214	# Check for duplicates
215	if wireless_network_exists "${ssid}"; then
216	error "The wireless network ${ssid} already exists"
217	return ${EXIT_ERROR}
218	fi
219
220	log DEBUG "Creating wireless network '${ssid}'"
221
222	if ! mkdir -p "${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}"; then
223	log ERROR "Could not create config directory for wireless network ${ssid}"
224	return ${EXIT_ERROR}
225	fi
226
227	# When the ssid is not set in the settings file we cannot write it because wireless_network_exists fails
228	echo "SSID=\"${ssid}\"" >>"${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}/settings"
229
230	local ${WIRELESS_NETWORK_CONFIG_SETTINGS}
231	SSID="${ssid}"
232	PRIORITY=500
233
234	if ! wireless_network_write_config "${ssid}"; then
235	log ERROR "Could not write new config file"
236	return ${EXIT_ERROR}
237	fi
238	}
239
240	# Function that deletes based on the passed parameters
241	# one ore more wireless networks
242	wireless_network_destroy() {
243	local ssid
244	for ssid in "$@"; do
245	local ssid_hash="$(wireless_network_hash "${ssid}")"
246	assert isset ssid_hash
247
248	if ! wireless_network_exists "${ssid}"; then
249	log ERROR "The wireless network ${ssid} does not exist."
250	continue
251	fi
252
253	log DEBUG "Deleting wireless network ${ssid}"
254
255	if ! rm -rf "${NETWORK_WIRELESS_NETWORKS_DIR}/${ssid_hash}"; then
256	log ERROR "Deleting the wireless network ${ssid} was not sucessful"
257	return ${EXIT_ERROR}
258	fi
259	done
260	}
261
262	wireless_network_encryption_mode() {
263	if [ ! $# -eq 2 ]; then
264	log ERROR "Not enough arguments"
265	return ${EXIT_ERROR}
266	fi
267	local ssid="${1}"
268	local mode="${2}"
269
270	if ! isoneof mode ${WIRELESS_NETWORKS_VALID_ENCRYPTION_MODES}; then
271	log ERROR "Encryption mode '${mode}' is invalid"
272	return ${EXIT_ERROR}
273	fi
274
275	if ! wireless_network_write_config_key "${ssid}" "ENCRYPTION_MODE" ${mode^^}; then
276	log ERROR "Could not write configuration settings"
277	return ${EXIT_ERROR}
278	fi
279	}
280
281	wireless_network_key() {
282	if [ ! $# -eq 2 ]; then
283	log ERROR "Not enough arguments"
284	return ${EXIT_ERROR}
285	fi
286	local ssid="${1}"
287	local key="${2}"
288
289	if ! wireless_network_write_config_key "${ssid}" "KEY" "${key}"; then
290	log ERROR "Could not write configuration settings"
291	return ${EXIT_ERROR}
292	fi
293	}
294
295	wireless_network_priority() {
296	if [ ! $# -eq 2 ]; then
297	log ERROR "Not enough arguments"
298	return ${EXIT_ERROR}
299	fi
300	local ssid="${1}"
301	local priority=${2}
302
303	if ! isinteger priority && [ ! ${priority} -ge 0 ]; then
304	log ERROR "The priority must be an integer greater or eqal zero"
305	return ${EXIT_ERROR}
306	fi
307
308	if ! wireless_network_write_config_key "${ssid}" "PRIORITY" "${priority}"; then
309	log ERROR "Could not write configuration settings"
310	return ${EXIT_ERROR}
311	fi
312	}