src/functions/functions.util

   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
  22 # A simple print statement
  23 print() {
  24         local fmt=${1}; shift
  25
  26         printf -- "${fmt}\n" "$@"
  27 }
  28
  29 # The args() function takes a number of arguments like
  30 #   var1="abc d" var2="abc" var3="abcd e"
  31 # and splits them into several arguments, devided by newline
  32 args() {
  33         echo "$@" | xargs printf "%s\n"
  34 }
  35
  36 unquote() {
  37         local var="$@"
  38
  39         if [ "${var:0:1}" = "\"" ]; then
  40                 var=${var:1}
  41         fi
  42
  43         local last=$(( ${#var} - 1 ))
  44         if [ ${last} -ge 0 ] && [ "${var:${last}:1}" = "\"" ]; then
  45                 var=${var:0:${last}}
  46         fi
  47
  48         print "${var}"
  49 }
  50
  51 quote() {
  52         print "\"%s\"" "$@"
  53 }
  54
  55 strip() {
  56         local value="$@"
  57
  58         # remove leading whitespace characters
  59         value="${value#"${value%%[![:space:]]*}"}"
  60
  61         # remove trailing whitespace characters
  62         value="${value%"${value##*[![:space:]]}"}"
  63
  64         print "${value}"
  65 }
  66
  67 # Print a pretty error message
  68 error() {
  69         echo -e " ${CLR_RED_B}ERROR${CLR_RESET}  : $@" >&2
  70 }
  71
  72 error_log() {
  73         log ERROR "$@"
  74 }
  75
  76 # Print a pretty warn message
  77 warning() {
  78         echo -e " ${CLR_YELLOW_B}WARNING${CLR_RESET}: $@" >&2
  79 }
  80
  81 warning_log() {
  82         log WARNING "$@"
  83 }
  84
  85 # The next three functions are kept for backwards
  86 # compatibility. The need to be dropped at some time.
  87 listsort() {
  88         list_sort $@
  89 }
  90
  91 listmatch() {
  92         list_match $@
  93 }
  94
  95 listlength() {
  96         list_length $@
  97 }
  98
  99 # Speedup function to avoid a call of the basename binary
 100 basename() {
 101         echo "${1##*/}"
 102 }
 103
 104 format() {
 105         local key=${1}
 106         assert isset key
 107
 108         local format=${2}
 109         assert isset format
 110
 111         shift 2
 112
 113         printf -v "${key}" "${format}" "$@"
 114 }
 115
 116 format_time() {
 117         local s=${1}
 118         local ret m
 119
 120         local units="s m h"
 121
 122         local unit
 123         for unit in ${units}; do
 124                 m=$(( ${s} % 60 ))
 125                 s=$(( ${s} / 60 ))
 126
 127                 if [ ${m} -gt 0 ]; then
 128                         ret="${m}${unit} ${ret}"
 129                 fi
 130         done
 131
 132         # Remove whitespace
 133         echo ${ret}
 134 }
 135
 136 assign() {
 137         local key=${1}
 138         assert isset key
 139         shift
 140
 141         format "${key}" "%s" "$@"
 142 }
 143
 144 fread() {
 145         local file=${1}
 146         assert isset file
 147
 148         [ -r "${file}" ] || return ${EXIT_ERROR}
 149
 150         print "$(<${file})"
 151 }
 152
 153 fwrite() {
 154         local file=${1}
 155         assert isset file
 156         shift
 157
 158         if [ ! -w "${file}" ]; then
 159                 log ERROR "${file}: No such file"
 160                 return ${EXIT_ERROR}
 161         fi
 162
 163         print "%s" "$@" >> ${file} 2>/dev/null
 164 }
 165
 166 make_parent_dir() {
 167         local path="${1}"
 168
 169         local dirname="$(dirname "${path}")"
 170         mkdir -p "${dirname}"
 171 }
 172
 173 enabled() {
 174         local param=${1}
 175
 176         list_match "${!param}" yes on true 1
 177 }
 178
 179 mac_generate() {
 180         local b="$(random 12)"
 181
 182         # Remove multicast bit
 183         # and set address is software assigned
 184         local first_byte=$(( 0x${b:0:2} & 0xfe ))
 185         first_byte=$(( ${first_byte} | 0x02 ))
 186
 187         local output
 188         printf -v output "%02x" "${first_byte}"
 189
 190         output="${output}:${b:2:2}:${b:4:2}:${b:6:2}:${b:8:2}:${b:10:2}"
 191
 192         # Check if output is valid
 193         assert mac_is_valid "${output}"
 194
 195         echo "${output}"
 196 }
 197
 198 mac_format() {
 199         local mac=${1}
 200         assert isset mac
 201
 202         # Remove all colons and make the rest lowercase.
 203         mac=${mac//:/}
 204         mac=${mac,,}
 205
 206         local output
 207         if [ "${#mac}" = "12" ]; then
 208                 # Add colons (:) to mac address
 209                 output=${mac:0:2}
 210                 local i
 211                 for i in 2 4 6 8 10; do
 212                         output="${output}:${mac:${i}:2}"
 213                 done
 214         else
 215                 output=${mac}
 216         fi
 217
 218         assert mac_is_valid ${output}
 219
 220         print "${output}"
 221 }
 222
 223 mac_is_valid() {
 224         local mac=${1}
 225
 226         [[ ${mac} =~ ^([0-9a-f]{2}\:){5}[0-9a-f]{2}$ ]]
 227 }
 228
 229 uuid() {
 230         echo $(</proc/sys/kernel/random/uuid)
 231 }
 232
 233 rand() {
 234         local uuid="$(uuid)"
 235         echo "${uuid//-/}"
 236 }
 237
 238 random() {
 239         local length="${1:-8}"
 240
 241         local random
 242         while [ ${#random} -lt ${length} ]; do
 243                 random="${random}$(rand)"
 244         done
 245
 246         echo "${random:0:${length}}"
 247 }
 248
 249 isset() {
 250         local var=${1}
 251
 252         [ -n "${!var}" ]
 253 }
 254
 255 isoneof() {
 256         local var=${!1}
 257         shift
 258
 259         list_match "${var}" "$@"
 260 }
 261
 262 isbool() {
 263         local var=${1}
 264
 265         isoneof ${var} 0 1 no yes on off
 266 }
 267
 268 isinteger() {
 269         local var=${!1}
 270
 271         [[ ${var} =~ ^[0-9]+$ ]]
 272 }
 273
 274 ismac() {
 275         local mac=${!1}
 276
 277         mac_is_valid ${mac}
 278 }
 279
 280 isipaddress() {
 281         local addr=${!1}
 282
 283         ip_is_valid ${addr}
 284 }
 285
 286 backtrace() {
 287         local start=1
 288
 289         echo # Empty line
 290         error_log "Backtrace (most recent call in first line):"
 291
 292         local i source
 293         for i in $(seq ${start} ${#BASH_SOURCE[*]}); do
 294                 [ -z "${FUNCNAME[${i}]}" ] && continue
 295
 296                 # Print called binary with arguments.
 297                 if [ "${FUNCNAME[${i}]}" == "main" ]; then
 298                         local args="$(list_reverse ${BASH_ARGV[*]})"
 299                         printf -v source "%20s" "$0"
 300                         error_log "  ${source} ${args}"
 301                         continue
 302                 fi
 303
 304                 source=${BASH_SOURCE[$(( ${i} + 1 ))]}
 305                 error_log "  $(printf "%20s" "'${FUNCNAME[${i}]}'") called from ${source:-<shell>}:${BASH_LINENO[${i}]}"
 306         done
 307 }
 308
 309 assert() {
 310         local assertion="$@"
 311
 312         if ! ${assertion}; then
 313                 error_log "Assertion '${assertion}' failed."
 314                 backtrace
 315                 exit ${EXIT_ERROR_ASSERT}
 316         fi
 317
 318         return ${EXIT_OK}
 319 }
 320
 321 # This function checks, if the given argument is an assert error
 322 # exit code. If this is the case, the script will halt immediately.
 323 assert_check_retval() {
 324         local ret=${1}
 325
 326         if [ ${ret} -eq ${EXIT_ERROR_ASSERT} ]; then
 327                 exit ${EXIT_ERROR_ASSERT}
 328         fi
 329
 330         return ${ret}
 331 }
 332
 333 # This function executes the given command and inverses the return code
 334 not() {
 335         local command="$@"
 336
 337         ${command} && return ${EXIT_FALSE} || return ${EXIT_TRUE}
 338 }
 339
 340 exec_cmd() {
 341         local cmd=$@
 342
 343         log DEBUG "Running command: ${cmd}"
 344
 345         DEBUG=${DEBUG} \
 346         LOG_DISABLE_STDOUT="${LOG_DISABLE_STDOUT}" \
 347         LOG_FACILITY="${LOG_FACILITY}" \
 348                 ${SHELL} ${cmd}
 349         local ret=$?
 350
 351         #log DEBUG "Returned with code '${ret}'"
 352
 353         if [ ${ret} -eq ${EXIT_ERROR_ASSERT} ]; then
 354                 error_log "Stopping parent process due to assertion error in child process: ${cmd}"
 355                 exit ${EXIT_ERROR_ASSERT}
 356         fi
 357
 358         return ${ret}
 359 }
 360
 361 cmd() {
 362         local cmd=$@
 363
 364         log DEBUG "Running command: ${cmd}"
 365
 366         ${cmd}
 367         local ret=$?
 368
 369         log DEBUG "Returned with code '${ret}'"
 370
 371         return ${ret}
 372 }
 373
 374 cmd_quiet() {
 375         cmd $@ &>/dev/null
 376 }
 377
 378 cmd_exec() {
 379         local cmd=$@
 380
 381         log DEBUG "Exec'ing command: ${cmd}"
 382
 383         exec ${cmd}
 384
 385         log ERROR "Could not exec-ute: ${cmd}"
 386         exit ${EXIT_ERROR}
 387 }
 388
 389 cmd_not_implemented() {
 390         assert false "not implemented"
 391 }
 392
 393 # Runs a command in a clean environment so that no confidential information
 394 # is leaked to any untrusted commands.
 395 cmd_clean_environment() {
 396         local cmd=$@
 397
 398         log DEBUG "Running command in a clean environment: ${cmd}"
 399         env -i -- ${cmd}
 400         local ret=${?}
 401
 402         log DEBUG "Returned with code '${ret}'"
 403         return ${ret}
 404 }
 405
 406 # Executes the given command in background
 407 cmd_background() {
 408         cmd_quiet $@ &
 409 }
 410
 411 # Prints the PID of the process that was started last
 412 cmd_background_get_pid() {
 413         print "${!}"
 414 }
 415
 416 cmd_background_result() {
 417         local pids=$@
 418
 419         wait ${pids}
 420 }
 421
 422 # Increase security of the read command
 423 read() {
 424         builtin read -r $@
 425 }
 426
 427 seq() {
 428         if [ $# -eq 2 ]; then
 429                 eval echo {${1}..${2}}
 430         elif [ $# -eq 3 ]; then
 431                 eval echo {${1}..${3}..${2}}
 432         fi
 433 }
 434
 435 which() {
 436         type -P $@
 437 }
 438
 439 # Prints the number of seconds since epoch.
 440 timestamp() {
 441         date -u "+%s"
 442 }
 443
 444 beautify_time() {
 445         local value=${1}
 446
 447         local unit
 448         local limit
 449         for unit in s m h d w; do
 450                 case "${unit}" in
 451                         s|m|h)
 452                                 limit=60
 453                                 ;;
 454                         d)
 455                                 limit=24
 456                                 ;;
 457                         w)
 458                                 limit=7
 459                                 ;;
 460                 esac
 461
 462                 [ ${value} -lt ${limit} ] && break
 463
 464                 value=$(( ${value} / ${limit} ))
 465         done
 466
 467         echo "${value}${unit}"
 468 }
 469
 470 beautify_bytes() {
 471         local value=${1}
 472
 473         local unit
 474         local limit=1024
 475         for unit in B k M G T; do
 476                 [ ${value} -lt ${limit} ] && break
 477                 value=$(( ${value} / ${limit} ))
 478         done
 479
 480         echo "${value}${unit}"
 481 }
 482
 483 module_load() {
 484         local module=${1}
 485
 486         if ! grep -q "^${module}" /proc/modules; then
 487                 log DEBUG "Loading module '${module}'."
 488                 modprobe ${module}
 489         fi
 490 }
 491
 492 binary_exists() {
 493         local binary=${1}
 494
 495         if [ -n "$(type -p ${binary})" ]; then
 496                 return ${EXIT_OK}
 497         fi
 498
 499         return ${EXIT_ERROR}
 500 }
 501
 502 function_exists() {
 503         local function="${1}"
 504
 505         if [ "$(type -t "${function}")" = "function" ]; then
 506                 return ${EXIT_TRUE}
 507         fi
 508
 509         return ${EXIT_FALSE}
 510 }
 511
 512 process_kill() {
 513         local process=${1}
 514
 515         if ! isinteger process; then
 516                 process=$(pidof ${process})
 517         fi
 518
 519         local pid
 520         local sig
 521         for pid in ${process}; do
 522                 for sig in 15 9; do
 523                         [ -d "/proc/${pid}" ] || break
 524
 525                         kill -${sig} ${pid}
 526                         sleep 1
 527                 done
 528         done
 529 }
 530
 531 dec() {
 532         local hex=${1}
 533
 534         if [ "${hex:0:2}" != "0x" ]; then
 535                 hex="0x${hex}"
 536         fi
 537
 538         printf "%d\n" "${hex}"
 539 }
 540
 541 chr() {
 542         local char="${1}"
 543
 544         [ ${char} -lt 256 ] || return ${EXIT_ERROR}
 545
 546         printf "\\$(( ${char} / 64 * 100 + ${char} % 64 / 8 * 10 + ${char} % 8 ))\n"
 547 }
 548
 549 ord() {
 550         LC_CTYPE="C" printf "%d\n" "'${1}"
 551 }
 552
 553 hex() {
 554         printf "%X\n" "${1}"
 555 }
 556
 557 network_is_running() {
 558         # Check, if the network service is running.
 559         service_is_active network
 560 }
 561
 562 contains_spaces() {
 563         local var="$@"
 564
 565         # Eliminate spaces.
 566         local var2=${var// /}
 567
 568         if [ ${#var} -ne ${#var2} ]; then
 569                 return ${EXIT_TRUE}
 570         fi
 571
 572         return ${EXIT_FALSE}
 573 }
 574
 575 string_split() {
 576         local string="$@"
 577
 578         local pos=0
 579         while [ ${pos} -lt ${#string} ]; do
 580                 print "${string:${pos}:1}"
 581                 pos=$(( ${pos} + 1 ))
 582         done
 583
 584         return ${EXIT_OK}
 585 }
 586
 587 string_reverse() {
 588         local string="$@"
 589
 590         local output
 591         local pos=0
 592         while [ ${pos} -lt ${#string} ]; do
 593                 output="${string:${pos}:1}${output}"
 594                 pos=$(( ${pos} + 1 ))
 595         done
 596
 597         print "${output}"
 598         return ${EXIT_OK}
 599 }
 600
 601 dec2bin() {
 602         local number="${1}"
 603
 604         local output
 605
 606         local i div
 607         for i in 7 6 5 4 3 2 1; do
 608                 div=$(( 2 ** ${i} ))
 609
 610                 if [ $(( ${number} / ${div} )) -eq 1 ]; then
 611                         output="${output}1"
 612                 else
 613                         output="${output}0"
 614                 fi
 615                 number="$(( ${number} % ${div} ))"
 616         done
 617
 618         if [ $(( ${number} % 2 )) -eq 1 ]; then
 619                 output="${output}1"
 620         else
 621                 output="${output}0"
 622         fi
 623
 624         print "${output}"
 625 }
 626
 627 bin2dec() {
 628         local string="${1}"
 629         local number=0
 630
 631         local pos=0 char
 632         while [ ${pos} -lt ${#string} ]; do
 633                 char="${string:${pos}:1}"
 634                 pos=$(( ${pos} + 1 ))
 635
 636                 number=$(( ${number} << 1 ))
 637
 638                 case "${char}" in
 639                         0) ;;
 640                         1)
 641                                 number=$(( ${number} + 1 ))
 642                                 ;;
 643                         *)
 644                                 assert false "Invalid character: ${char}"
 645                                 ;;
 646                 esac
 647         done
 648
 649         print "${number}"
 650         return ${EXIT_OK}
 651 }
 652
 653 char2bin() {
 654         local dec="$(ord "${1}")"
 655
 656         dec2bin "${dec}"
 657 }
 658
 659 bin2char() {
 660         local dec="$(bin2dec "$@")"
 661
 662         chr "${dec}"
 663 }
 664
 665 bin2hex() {
 666         local dec="$(bin2dec "$@")"
 667
 668         dec2hex "${dec}"
 669 }
 670
 671 hex2bin() {
 672         local dec="$(hex2dec "$@")"
 673
 674         dec2bin "${dec}"
 675 }
 676
 677 hex2dec() {
 678         local hex="${1}"
 679
 680         # Prepend 0x if necessary.
 681         [ "${hex:0:2}" = "0x" ] || hex="0x${hex}"
 682
 683         printf "%d\n" "${hex}"
 684 }
 685
 686 dec2hex() {
 687         printf "%02x\n" "${1}"
 688 }