wireless-ap: Check that secret has the correct length and no invalid characters
[people/ms/network.git] / src / functions / functions.util
CommitLineData
1848564d
MT
1#!/bin/bash
2###############################################################################
3# #
4# IPFire.org - A linux based firewall #
5# Copyright (C) 2010 Michael Tremer & Christian Schmidt #
6# #
7# This program is free software: you can redistribute it and/or modify #
8# it under the terms of the GNU General Public License as published by #
9# the Free Software Foundation, either version 3 of the License, or #
10# (at your option) any later version. #
11# #
12# This program is distributed in the hope that it will be useful, #
13# but WITHOUT ANY WARRANTY; without even the implied warranty of #
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
15# GNU General Public License for more details. #
16# #
17# You should have received a copy of the GNU General Public License #
18# along with this program. If not, see <http://www.gnu.org/licenses/>. #
19# #
20###############################################################################
21
97cb552e 22# A simple print statement
1c6a4e30 23print() {
acc9efd5
MT
24 local fmt=${1}; shift
25
40e3553f 26 printf -- "${fmt}\n" "$@"
97cb552e
MT
27}
28
67baa452
MT
29print_indent() {
30 local i=${1}
31 shift
32
33 while (( i-- )); do
34 printf "\t"
35 done
36
37 print "%s" "$@"
38}
39
cb965348
MT
40# The args() function takes a number of arguments like
41# var1="abc d" var2="abc" var3="abcd e"
42# and splits them into several arguments, devided by newline
1c6a4e30 43args() {
cb965348
MT
44 echo "$@" | xargs printf "%s\n"
45}
46
1c6a4e30 47unquote() {
04854c77
MT
48 local var="$@"
49
50 if [ "${var:0:1}" = "\"" ]; then
51 var=${var:1}
52 fi
53
54 local last=$(( ${#var} - 1 ))
55 if [ ${last} -ge 0 ] && [ "${var:${last}:1}" = "\"" ]; then
56 var=${var:0:${last}}
57 fi
58
59 print "${var}"
60}
61
1c6a4e30 62quote() {
04854c77
MT
63 print "\"%s\"" "$@"
64}
65
1c6a4e30 66strip() {
fe52c5e0
MT
67 local value="$@"
68
69 # remove leading whitespace characters
70 value="${value#"${value%%[![:space:]]*}"}"
71
72 # remove trailing whitespace characters
73 value="${value%"${value##*[![:space:]]}"}"
74
75 print "${value}"
76}
77
1848564d 78# Print a pretty error message
1c6a4e30 79error() {
fcbf6823 80 echo -e " ${CLR_RED_B}ERROR${CLR_RESET} : $@" >&2
1848564d
MT
81}
82
1c6a4e30 83error_log() {
1b7a1578
MT
84 log ERROR "$@"
85}
86
1848564d 87# Print a pretty warn message
1c6a4e30 88warning() {
fcbf6823 89 echo -e " ${CLR_YELLOW_B}WARNING${CLR_RESET}: $@" >&2
1848564d
MT
90}
91
1c6a4e30 92warning_log() {
1b7a1578
MT
93 log WARNING "$@"
94}
95
1848564d 96# Speedup function to avoid a call of the basename binary
1c6a4e30 97basename() {
1848564d
MT
98 echo "${1##*/}"
99}
100
1c6a4e30 101format() {
e5651e17
MT
102 local key=${1}
103 assert isset key
104
105 local format=${2}
106 assert isset format
107
108 shift 2
109
110 printf -v "${key}" "${format}" "$@"
111}
112
d13929d4
MT
113format_time() {
114 local s=${1}
115 local ret m
116
117 local units="s m h"
118
119 local unit
120 for unit in ${units}; do
121 m=$(( ${s} % 60 ))
122 s=$(( ${s} / 60 ))
123
124 if [ ${m} -gt 0 ]; then
125 ret="${m}${unit} ${ret}"
126 fi
127 done
128
129 # Remove whitespace
130 echo ${ret}
131}
132
b383499d
MT
133parse_time() {
134 local ret=0
135
136 local arg
2212045f 137 for arg in "$@"; do
b383499d
MT
138 local unit
139
140 case "${arg}" in
141 *h|*m|*s)
142 # Store unit
143 unit="${arg: -1}"
144
145 # Remove unit
146 arg="${arg:0:-1}"
147 ;;
148 esac
149
150 if ! isinteger arg; then
151 return ${EXIT_ERROR}
152 fi
153
154 # Convert hours and minutes into seconds
155 case "${unit}" in
156 h)
157 arg=$(( ${arg} * 3600 ))
158 ;;
159 m)
160 arg=$(( ${arg} * 60 ))
161 ;;
162 esac
163
164 # Add up everything
165 ret=$(( ${ret} + ${arg} ))
166 done
167
168 print "${ret}"
169}
170
1c6a4e30 171assign() {
b79ad79b
MT
172 local key=${1}
173 assert isset key
174 shift
175
e5651e17 176 format "${key}" "%s" "$@"
b79ad79b
MT
177}
178
1c6a4e30 179fread() {
b79ad79b
MT
180 local file=${1}
181 assert isset file
182
183 [ -r "${file}" ] || return ${EXIT_ERROR}
184
185 print "$(<${file})"
186}
187
1c6a4e30 188fwrite() {
b79ad79b
MT
189 local file=${1}
190 assert isset file
191 shift
192
644d3bb8
MT
193 if ! print "%s" "$@" > ${file} 2>/dev/null; then
194 error "Could not write to file: ${file}"
195 return ${EXIT_ERROR}
196 fi
197
198 return ${EXIT_OK}
199}
200
201fappend() {
202 local file=${1}
203 assert isset file
204 shift
205
e1947a76 206 if [ -e "${file}" ] && [ ! -w "${file}" ]; then
8d4e0d52
MT
207 log ERROR "${file}: No such file"
208 return ${EXIT_ERROR}
209 fi
210
211 print "%s" "$@" >> ${file} 2>/dev/null
b79ad79b
MT
212}
213
fa33d830
MT
214file_delete() {
215 local file=${1}
216
217 unlink "${file}" 2>/dev/null
218}
219
e1947a76
MT
220file_exists() {
221 local file=${1}
222
223 [ -e "${file}" ] && return ${EXIT_TRUE} || return ${EXIT_FALSE}
224}
225
226file_is_newer_than() {
227 local file1="${1}"
228 local file2="${2}"
229
230 local age1=$(file_get_age "${file1}")
231 local age2=$(file_get_age "${file2}")
232
233 if [ ${age1} -gt ${age2} ]; then
234 return ${EXIT_TRUE}
235 else
236 return ${EXIT_FALSE}
237 fi
238}
239
240file_get_age() {
241 local file="${1}"
242
243 if [ -e "${file}" ]; then
244 stat --format="%Y" "${file}"
245 return $?
246 fi
247
248 return ${EXIT_ERROR}
249}
250
7c91c167
MT
251file_to_log() {
252 local level="${1}"
253 assert isset level
254
255 local file="${2}"
256 assert file_exists "${file}"
257
258 local line
259 while read line; do
260 log "${level}" "${line}"
261 done < "${file}"
262}
263
04c27fe9
MT
264make_directory() {
265 local path="${1}"
266
72848301
MT
267 # Exit silently when directory already exists
268 if [ -d "${path}" ]; then
269 return ${EXIT_OK}
270 fi
271
39aae674
MT
272 if ! mkdir -p "${path}"; then
273 log ERROR "Could not create directory ${path}"
274 return ${EXIT_ERROR}
275 fi
276
277 log DEBUG "Created directory ${path}"
278 return ${EXIT_OK}
04c27fe9
MT
279}
280
46954be3 281make_parent_directory() {
c041b631
MT
282 local path="${1}"
283
04c27fe9 284 make_directory "$(dirname "${path}")"
c041b631
MT
285}
286
1c6a4e30 287enabled() {
1848564d
MT
288 local param=${1}
289
e726ef8d 290 list_match "${!param}" yes on true 1
1848564d
MT
291}
292
0842edcc
MT
293disabled() {
294 local param="${1}"
295
296 list_match "${!param}" no off false 0
297}
298
1c6a4e30 299mac_generate() {
fb1416c6
MT
300 local b="$(random 12)"
301
302 # Remove multicast bit
303 # and set address is software assigned
304 local first_byte=$(( 0x${b:0:2} & 0xfe ))
305 first_byte=$(( ${first_byte} | 0x02 ))
1848564d
MT
306
307 local output
fb1416c6 308 printf -v output "%02x" "${first_byte}"
790b7ec9 309
fb1416c6 310 output="${output}:${b:2:2}:${b:4:2}:${b:6:2}:${b:8:2}:${b:10:2}"
1848564d
MT
311
312 # Check if output is valid
fb1416c6 313 assert mac_is_valid "${output}"
1848564d 314
790b7ec9 315 echo "${output}"
1848564d
MT
316}
317
1c6a4e30 318mac_format() {
18b43372 319 local mac=${1}
48bc31eb 320 assert isset mac
18b43372 321
48bc31eb
MT
322 # Remove all colons and make the rest lowercase.
323 mac=${mac//:/}
324 mac=${mac,,}
18b43372 325
48bc31eb 326 local output
18b43372
MT
327 if [ "${#mac}" = "12" ]; then
328 # Add colons (:) to mac address
329 output=${mac:0:2}
330 local i
331 for i in 2 4 6 8 10; do
332 output="${output}:${mac:${i}:2}"
333 done
48bc31eb
MT
334 else
335 output=${mac}
18b43372
MT
336 fi
337
338 assert mac_is_valid ${output}
339
48bc31eb 340 print "${output}"
18b43372
MT
341}
342
1c6a4e30 343mac_is_valid() {
1848564d
MT
344 local mac=${1}
345
346 [[ ${mac} =~ ^([0-9a-f]{2}\:){5}[0-9a-f]{2}$ ]]
347}
348
01ff07e9
MT
349# Converts the given string to lowercase and returns true if it is a valid FQDN
350fqdn_is_valid() {
351 local fqdn="${1}"
352
353 if grep -qP "^(?!:\/\/)(?=.{1,255}$)((.{1,63}\.){1,127}(?![0-9]*$)[a-z0-9-]+\.?)$" <<< "${fqdn,,}"; then
354 return ${EXIT_TRUE}
355 fi
356
357 return ${EXIT_FALSE}
358}
359
1c6a4e30 360uuid() {
de543653 361 echo $(</proc/sys/kernel/random/uuid)
1848564d
MT
362}
363
a24cff8f
JS
364abs() {
365 local val=${1}
366
367 if [ ${val} -lt 0 ]; then
368 (( val *= -1 ))
369 fi
370
371 echo ${val}
372}
373
fb1416c6
MT
374rand() {
375 local uuid="$(uuid)"
376 echo "${uuid//-/}"
377}
378
379random() {
380 local length="${1:-8}"
381
382 local random
383 while [ ${#random} -lt ${length} ]; do
384 random="${random}$(rand)"
385 done
386
387 echo "${random:0:${length}}"
388}
389
1c6a4e30 390isset() {
1848564d
MT
391 local var=${1}
392
393 [ -n "${!var}" ]
394}
395
1c6a4e30 396isoneof() {
1848564d
MT
397 local var=${!1}
398 shift
399
e726ef8d 400 list_match "${var}" "$@"
1848564d
MT
401}
402
1c6a4e30 403isbool() {
1848564d
MT
404 local var=${1}
405
ec6afbdd 406 isoneof ${var} 0 1 no yes on off true false
1848564d
MT
407}
408
1c6a4e30 409isinteger() {
1848564d
MT
410 local var=${!1}
411
412 [[ ${var} =~ ^[0-9]+$ ]]
413}
414
1c6a4e30 415ismac() {
1848564d
MT
416 local mac=${!1}
417
418 mac_is_valid ${mac}
419}
420
1c6a4e30 421isipaddress() {
fef4edaf
MT
422 local addr=${!1}
423
424 ip_is_valid ${addr}
425}
426
48a64768
JS
427mtu_is_valid() {
428 local proto=${1}
429 local mtu=${2}
430
431 case ${proto} in
ef53293c 432 ethernet|ipv4)
48a64768
JS
433 [ ${mtu} -ge 576 ] && [ ${mtu} -le 9000 ]
434 ;;
435 ipv6)
436 [ ${mtu} -ge 1280 ] && [ ${mtu} -le 9000 ]
437 ;;
438 *)
439 error "${proto} is not a valid proto"
440 return ${EXIT_ERROR}
441 ;;
442 esac
443}
444
1c6a4e30 445backtrace() {
711ffac1
MT
446 local start=1
447
448 echo # Empty line
449 error_log "Backtrace (most recent call in first line):"
450
04608623 451 local i source
711ffac1
MT
452 for i in $(seq ${start} ${#BASH_SOURCE[*]}); do
453 [ -z "${FUNCNAME[${i}]}" ] && continue
6396ccab
MT
454
455 # Print called binary with arguments.
456 if [ "${FUNCNAME[${i}]}" == "main" ]; then
457 local args="$(list_reverse ${BASH_ARGV[*]})"
458 printf -v source "%20s" "$0"
459 error_log " ${source} ${args}"
460 continue
461 fi
711ffac1 462
04608623
MT
463 source=${BASH_SOURCE[$(( ${i} + 1 ))]}
464 error_log " $(printf "%20s" "'${FUNCNAME[${i}]}'") called from ${source:-<shell>}:${BASH_LINENO[${i}]}"
711ffac1
MT
465 done
466}
467
1c6a4e30 468assert() {
1848564d
MT
469 local assertion="$@"
470
471 if ! ${assertion}; then
4c670d7c 472 error_log "Assertion '${assertion}' failed."
711ffac1 473 backtrace
cfbe0802 474 exit ${EXIT_ERROR_ASSERT}
1848564d
MT
475 fi
476
477 return ${EXIT_OK}
478}
cad8bd85 479
b0b2f995
MT
480# This function checks, if the given argument is an assert error
481# exit code. If this is the case, the script will halt immediately.
1c6a4e30 482assert_check_retval() {
b0b2f995
MT
483 local ret=${1}
484
485 if [ ${ret} -eq ${EXIT_ERROR_ASSERT} ]; then
486 exit ${EXIT_ERROR_ASSERT}
487 fi
488
489 return ${ret}
490}
491
2bb20bbd
SS
492# This function executes the given command and inverses the return code
493not() {
494 local command="$@"
495
496 ${command} && return ${EXIT_FALSE} || return ${EXIT_TRUE}
497}
498
1c6a4e30 499exec_cmd() {
711ffac1
MT
500 local cmd=$@
501
502 log DEBUG "Running command: ${cmd}"
503
b816e04b 504 DEBUG=${DEBUG} \
8c63fa13
MT
505 LOG_DISABLE_STDOUT="${LOG_DISABLE_STDOUT}" \
506 LOG_FACILITY="${LOG_FACILITY}" \
b816e04b 507 ${SHELL} ${cmd}
711ffac1
MT
508 local ret=$?
509
510 #log DEBUG "Returned with code '${ret}'"
511
512 if [ ${ret} -eq ${EXIT_ERROR_ASSERT} ]; then
513 error_log "Stopping parent process due to assertion error in child process: ${cmd}"
514 exit ${EXIT_ERROR_ASSERT}
515 fi
516
517 return ${ret}
518}
519
1c6a4e30 520cmd() {
b816e04b
MT
521 local cmd=$@
522
523 log DEBUG "Running command: ${cmd}"
524
4b75fc83
MT
525 env -i -- \
526 HOME="${HOME}" \
527 PATH="${PATH}" \
528 TERM="${TERM}" \
529 ${cmd}
530 local ret=$?
b816e04b 531
4b75fc83
MT
532 case "${ret}" in
533 ${EXIT_OK})
534 return ${EXIT_OK}
535 ;;
536 *)
537 log DEBUG "Returned with code '${ret}'"
538 return ${ret}
539 ;;
540 esac
b816e04b
MT
541}
542
1c6a4e30 543cmd_quiet() {
2212045f 544 cmd "$@" &>/dev/null
3efecbb3
MT
545}
546
1c6a4e30 547cmd_exec() {
85f35e51 548 local cmd=( "$@" )
f80ce052
MT
549
550 log DEBUG "Exec'ing command: ${cmd}"
551
85f35e51 552 exec "${cmd[@]}"
f80ce052
MT
553
554 log ERROR "Could not exec-ute: ${cmd}"
555 exit ${EXIT_ERROR}
556}
557
1c6a4e30 558cmd_not_implemented() {
2181765d
MT
559 assert false "not implemented"
560}
561
f5ee091e
MT
562# Executes the given command in background
563cmd_background() {
2212045f 564 cmd_quiet "$@" &
f5ee091e
MT
565}
566
567# Prints the PID of the process that was started last
568cmd_background_get_pid() {
569 print "${!}"
570}
571
572cmd_background_result() {
573 local pids=$@
574
575 wait ${pids}
576}
577
b8026986 578# Increase security of the read command
1c6a4e30 579read() {
2212045f 580 builtin read -r "$@"
b8026986
MT
581}
582
1c6a4e30 583seq() {
3efecbb3
MT
584 if [ $# -eq 2 ]; then
585 eval echo {${1}..${2}}
586 elif [ $# -eq 3 ]; then
587 eval echo {${1}..${3}..${2}}
588 fi
589}
590
de72bd91
MT
591range() {
592 eval echo {0..$(( ${1} - 1 ))}
593}
594
595count() {
596 local i=0
597
598 while read; do
599 ((i++))
600 done
601
602 echo ${i}
603}
604
1c6a4e30 605which() {
2212045f 606 type -P "$@"
76e6cd51
MT
607}
608
fe52c5e0 609# Prints the number of seconds since epoch.
1c6a4e30 610timestamp() {
fe52c5e0
MT
611 date -u "+%s"
612}
613
1c6a4e30 614beautify_time() {
d82cf370
MT
615 local value=${1}
616
617 local unit
618 local limit
619 for unit in s m h d w; do
620 case "${unit}" in
621 s|m|h)
622 limit=60
623 ;;
624 d)
625 limit=24
626 ;;
627 w)
628 limit=7
629 ;;
630 esac
631
632 [ ${value} -lt ${limit} ] && break
633
634 value=$(( ${value} / ${limit} ))
635 done
636
637 echo "${value}${unit}"
638}
711ffac1 639
1c6a4e30 640beautify_bytes() {
711ffac1
MT
641 local value=${1}
642
643 local unit
644 local limit=1024
645 for unit in B k M G T; do
646 [ ${value} -lt ${limit} ] && break
647 value=$(( ${value} / ${limit} ))
648 done
649
650 echo "${value}${unit}"
651}
943e3f7e 652
1c6a4e30 653module_load() {
943e3f7e
MT
654 local module=${1}
655
dd891ec4
MT
656 # Do nothing if the module is already loaded
657 if [ -d "/sys/module/${module//-/_}" ]; then
658 return ${EXIT_OK}
943e3f7e 659 fi
dd891ec4
MT
660
661 log DEBUG "Loading kernel module ${module}"
662 modprobe "${module}"
943e3f7e 663}
6b3f9c85 664
1c6a4e30 665binary_exists() {
6b3f9c85
MT
666 local binary=${1}
667
668 if [ -n "$(type -p ${binary})" ]; then
669 return ${EXIT_OK}
670 fi
671
672 return ${EXIT_ERROR}
673}
d76f5107 674
1c6a4e30 675function_exists() {
1e6f187e
MT
676 local function="${1}"
677
678 if [ "$(type -t "${function}")" = "function" ]; then
679 return ${EXIT_TRUE}
680 fi
681
682 return ${EXIT_FALSE}
683}
684
1c6a4e30 685process_kill() {
d76f5107
MT
686 local process=${1}
687
688 if ! isinteger process; then
689 process=$(pidof ${process})
690 fi
691
692 local pid
693 local sig
694 for pid in ${process}; do
695 for sig in 15 9; do
696 [ -d "/proc/${pid}" ] || break
697
698 kill -${sig} ${pid}
699 sleep 1
700 done
701 done
702}
feb76eaf 703
1c6a4e30 704dec() {
feb76eaf
MT
705 local hex=${1}
706
707 if [ "${hex:0:2}" != "0x" ]; then
708 hex="0x${hex}"
709 fi
710
711 printf "%d\n" "${hex}"
712}
3a7fef62 713
1c6a4e30 714chr() {
5cf0edf9
MT
715 local char="${1}"
716
717 [ ${char} -lt 256 ] || return ${EXIT_ERROR}
718
719 printf "\\$(( ${char} / 64 * 100 + ${char} % 64 / 8 * 10 + ${char} % 8 ))\n"
720}
721
1c6a4e30 722ord() {
5cf0edf9
MT
723 LC_CTYPE="C" printf "%d\n" "'${1}"
724}
725
1c6a4e30 726hex() {
5cf0edf9
MT
727 printf "%X\n" "${1}"
728}
729
1c6a4e30 730network_is_running() {
3a7fef62
MT
731 # Check, if the network service is running.
732 service_is_active network
733}
f80ce052 734
1c6a4e30 735contains_spaces() {
f80ce052
MT
736 local var="$@"
737
738 # Eliminate spaces.
739 local var2=${var// /}
740
741 if [ ${#var} -ne ${#var2} ]; then
742 return ${EXIT_TRUE}
743 fi
744
745 return ${EXIT_FALSE}
0d645497
MT
746}
747
d695b280
MT
748contains_non_ascii_characters() {
749 local value="$@"
750
751 # Strip away all ASCII characters
752 local non_ascii="${value//[[:ascii:]]/}"
753
754 if isset non_ascii; then
755 return ${EXIT_TRUE}
756 fi
757
758 return ${EXIT_FALSE}
759}
760
0d645497
MT
761string_match() {
762 local match=${1}
763 local string=${2}
764
765 [[ ${string} =~ ${match} ]] && return ${EXIT_TRUE} || return ${EXIT_FALSE}
f80ce052 766}
5cf0edf9 767
1c6a4e30 768string_split() {
5cf0edf9
MT
769 local string="$@"
770
771 local pos=0
772 while [ ${pos} -lt ${#string} ]; do
773 print "${string:${pos}:1}"
774 pos=$(( ${pos} + 1 ))
775 done
776
777 return ${EXIT_OK}
778}
779
1c6a4e30 780string_reverse() {
5cf0edf9
MT
781 local string="$@"
782
783 local output
784 local pos=0
785 while [ ${pos} -lt ${#string} ]; do
786 output="${string:${pos}:1}${output}"
787 pos=$(( ${pos} + 1 ))
788 done
789
790 print "${output}"
791 return ${EXIT_OK}
792}
793
1c6a4e30 794dec2bin() {
5cf0edf9
MT
795 local number="${1}"
796
797 local output
798
799 local i div
800 for i in 7 6 5 4 3 2 1; do
801 div=$(( 2 ** ${i} ))
802
803 if [ $(( ${number} / ${div} )) -eq 1 ]; then
804 output="${output}1"
805 else
806 output="${output}0"
807 fi
808 number="$(( ${number} % ${div} ))"
809 done
810
811 if [ $(( ${number} % 2 )) -eq 1 ]; then
812 output="${output}1"
813 else
814 output="${output}0"
815 fi
816
817 print "${output}"
818}
819
1c6a4e30 820bin2dec() {
5cf0edf9
MT
821 local string="${1}"
822 local number=0
823
824 local pos=0 char
825 while [ ${pos} -lt ${#string} ]; do
826 char="${string:${pos}:1}"
827 pos=$(( ${pos} + 1 ))
828
829 number=$(( ${number} << 1 ))
830
831 case "${char}" in
832 0) ;;
833 1)
834 number=$(( ${number} + 1 ))
835 ;;
836 *)
837 assert false "Invalid character: ${char}"
838 ;;
839 esac
840 done
841
842 print "${number}"
843 return ${EXIT_OK}
844}
845
1c6a4e30 846char2bin() {
5cf0edf9
MT
847 local dec="$(ord "${1}")"
848
849 dec2bin "${dec}"
850}
851
1c6a4e30 852bin2char() {
5cf0edf9
MT
853 local dec="$(bin2dec "$@")"
854
855 chr "${dec}"
856}
857
1c6a4e30 858bin2hex() {
5cf0edf9
MT
859 local dec="$(bin2dec "$@")"
860
861 dec2hex "${dec}"
862}
863
1c6a4e30 864hex2bin() {
5cf0edf9
MT
865 local dec="$(hex2dec "$@")"
866
867 dec2bin "${dec}"
868}
869
1c6a4e30 870hex2dec() {
5cf0edf9
MT
871 local hex="${1}"
872
873 # Prepend 0x if necessary.
874 [ "${hex:0:2}" = "0x" ] || hex="0x${hex}"
875
876 printf "%d\n" "${hex}"
877}
878
1c6a4e30 879dec2hex() {
5cf0edf9
MT
880 printf "%02x\n" "${1}"
881}
a95d16fc 882
10b53c87 883# This function just copy config files
a95d16fc 884copy() {
a95d16fc
JS
885 assert [ $# -eq 2 ]
886
887 local src=${1}
888 local dst=${2}
889
287c2e60
MT
890 # Check if we can read from the source
891 if [ ! -r "${src}" ]; then
892 log ERROR "Cannot read ${src}"
893 return ${EXIT_ERROR}
894 fi
895
a95d16fc 896 # Check if ${dst} is a directory
1fade616 897 if [ -d "${dst}" ]; then
9c802e1d 898 log ERROR "${dst} is a directory"
a95d16fc
JS
899 return ${EXIT_ERROR}
900 fi
901
2012c1b6
MT
902 # Create destination directory if it doesn't exist, yet
903 if ! make_parent_directory "${dst}"; then
904 return ${EXIT_ERROR}
905 fi
906
a95d16fc
JS
907 if ! fread "${src}" > "${dst}"; then
908 log ERROR "Could not copy data from ${src} to ${dst}"
909 return ${EXIT_ERROR}
910 fi
911}
a8d8d2c5
JS
912
913normalize() {
914 local string="$@"
915
916 tr -sc [:alnum:] "-" < <(printf "%s" "${string,,}")
917}
4ad5981f
MT
918
919get_driver_from_path() {
920 local path="${1}"
921
922 if file_exists "${path}"; then
923 # Resolve symlink
924 local driver="$(readlink "${path}")"
925
926 # Print module name
927 basename "${driver}"
928 return ${EXIT_OK}
929 fi
930
931 return ${EXIT_ERROR}
932}