[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() {
	if wireless_network_exists "${1}"; then
		local ssid="${1}"
		local key="${2}"
		key=${key//-/_}
		shift 2

		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
	else
		local action=${1}
		shift

		case "${action}" in
			new)
				wireless_network_new "$@"
				;;
			destroy)
				wireless_network_destroy "$@"
				;;
			""|*)
				if [ -n "${action}" ]; then
					error "Unrecognized argument: '${action}'"
				fi
				exit ${EXIT_ERROR}
				;;
		esac
	fi
}

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