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 parse_time() {
 137         local ret=0
 138
 139         local arg
 140         for arg in $@; do
 141                 local unit
 142
 143                 case "${arg}" in
 144                         *h|*m|*s)
 145                                 # Store unit
 146                                 unit="${arg: -1}"
 147
 148                                 # Remove unit
 149                                 arg="${arg:0:-1}"
 150                                 ;;
 151                 esac
 152
 153                 if ! isinteger arg; then
 154                         return ${EXIT_ERROR}
 155                 fi
 156
 157                 # Convert hours and minutes into seconds
 158                 case "${unit}" in
 159                         h)
 160                                 arg=$(( ${arg} * 3600 ))
 161                                 ;;
 162                         m)
 163                                 arg=$(( ${arg} * 60 ))
 164                                 ;;
 165                 esac
 166
 167                 # Add up everything
 168                 ret=$(( ${ret} + ${arg} ))
 169         done
 170
 171         print "${ret}"
 172 }
 173
 174 assign() {
 175         local key=${1}
 176         assert isset key
 177         shift
 178
 179         format "${key}" "%s" "$@"
 180 }
 181
 182 fread() {
 183         local file=${1}
 184         assert isset file
 185
 186         [ -r "${file}" ] || return ${EXIT_ERROR}
 187
 188         print "$(<${file})"
 189 }
 190
 191 fwrite() {
 192         local file=${1}
 193         assert isset file
 194         shift
 195
 196         if [ ! -w "${file}" ]; then
 197                 log ERROR "${file}: No such file"
 198                 return ${EXIT_ERROR}
 199         fi
 200
 201         print "%s" "$@" >> ${file} 2>/dev/null
 202 }
 203
 204 make_parent_dir() {
 205         local path="${1}"
 206
 207         local dirname="$(dirname "${path}")"
 208         mkdir -p "${dirname}"
 209 }
 210
 211 enabled() {
 212         local param=${1}
 213
 214         list_match "${!param}" yes on true 1
 215 }
 216
 217 mac_generate() {
 218         local b="$(random 12)"
 219
 220         # Remove multicast bit
 221         # and set address is software assigned
 222         local first_byte=$(( 0x${b:0:2} & 0xfe ))
 223         first_byte=$(( ${first_byte} | 0x02 ))
 224
 225         local output
 226         printf -v output "%02x" "${first_byte}"
 227
 228         output="${output}:${b:2:2}:${b:4:2}:${b:6:2}:${b:8:2}:${b:10:2}"
 229
 230         # Check if output is valid
 231         assert mac_is_valid "${output}"
 232
 233         echo "${output}"
 234 }
 235
 236 mac_format() {
 237         local mac=${1}
 238         assert isset mac
 239
 240         # Remove all colons and make the rest lowercase.
 241         mac=${mac//:/}
 242         mac=${mac,,}
 243
 244         local output
 245         if [ "${#mac}" = "12" ]; then
 246                 # Add colons (:) to mac address
 247                 output=${mac:0:2}
 248                 local i
 249                 for i in 2 4 6 8 10; do
 250                         output="${output}:${mac:${i}:2}"
 251                 done
 252         else
 253                 output=${mac}
 254         fi
 255
 256         assert mac_is_valid ${output}
 257
 258         print "${output}"
 259 }
 260
 261 mac_is_valid() {
 262         local mac=${1}
 263
 264         [[ ${mac} =~ ^([0-9a-f]{2}\:){5}[0-9a-f]{2}$ ]]
 265 }
 266
 267 uuid() {
 268         echo $(</proc/sys/kernel/random/uuid)
 269 }
 270
 271 abs() {
 272         local val=${1}
 273
 274         if [ ${val} -lt 0 ]; then
 275                 (( val *= -1 ))
 276         fi
 277
 278         echo ${val}
 279 }
 280
 281 rand() {
 282         local uuid="$(uuid)"
 283         echo "${uuid//-/}"
 284 }
 285
 286 random() {
 287         local length="${1:-8}"
 288
 289         local random
 290         while [ ${#random} -lt ${length} ]; do
 291                 random="${random}$(rand)"
 292         done
 293
 294         echo "${random:0:${length}}"
 295 }
 296
 297 isset() {
 298         local var=${1}
 299
 300         [ -n "${!var}" ]
 301 }
 302
 303 isoneof() {
 304         local var=${!1}
 305         shift
 306
 307         list_match "${var}" "$@"
 308 }
 309
 310 isbool() {
 311         local var=${1}
 312
 313         isoneof ${var} 0 1 no yes on off
 314 }
 315
 316 isinteger() {
 317         local var=${!1}
 318
 319         [[ ${var} =~ ^[0-9]+$ ]]
 320 }
 321
 322 ismac() {
 323         local mac=${!1}
 324
 325         mac_is_valid ${mac}
 326 }
 327
 328 isipaddress() {
 329         local addr=${!1}
 330
 331         ip_is_valid ${addr}
 332 }
 333
 334 mtu_is_valid() {
 335         local proto=${1}
 336         local mtu=${2}
 337
 338         case ${proto} in
 339                 ipv4)
 340                         [ ${mtu} -ge 576 ] && [ ${mtu} -le 9000 ]
 341                         ;;
 342                 ipv6)
 343                         [ ${mtu} -ge 1280 ] && [ ${mtu} -le 9000 ]
 344                         ;;
 345                 *)
 346                         error "${proto} is not a valid proto"
 347                         return ${EXIT_ERROR}
 348                         ;;
 349         esac
 350 }
 351
 352 backtrace() {
 353         local start=1
 354
 355         echo # Empty line
 356         error_log "Backtrace (most recent call in first line):"
 357
 358         local i source
 359         for i in $(seq ${start} ${#BASH_SOURCE[*]}); do
 360                 [ -z "${FUNCNAME[${i}]}" ] && continue
 361
 362                 # Print called binary with arguments.
 363                 if [ "${FUNCNAME[${i}]}" == "main" ]; then
 364                         local args="$(list_reverse ${BASH_ARGV[*]})"
 365                         printf -v source "%20s" "$0"
 366                         error_log "  ${source} ${args}"
 367                         continue
 368                 fi
 369
 370                 source=${BASH_SOURCE[$(( ${i} + 1 ))]}
 371                 error_log "  $(printf "%20s" "'${FUNCNAME[${i}]}'") called from ${source:-<shell>}:${BASH_LINENO[${i}]}"
 372         done
 373 }
 374
 375 assert() {
 376         local assertion="$@"
 377
 378         if ! ${assertion}; then
 379                 error_log "Assertion '${assertion}' failed."
 380                 backtrace
 381                 exit ${EXIT_ERROR_ASSERT}
 382         fi
 383
 384         return ${EXIT_OK}
 385 }
 386
 387 # This function checks, if the given argument is an assert error
 388 # exit code. If this is the case, the script will halt immediately.
 389 assert_check_retval() {
 390         local ret=${1}
 391
 392         if [ ${ret} -eq ${EXIT_ERROR_ASSERT} ]; then
 393                 exit ${EXIT_ERROR_ASSERT}
 394         fi
 395
 396         return ${ret}
 397 }
 398
 399 # This function executes the given command and inverses the return code
 400 not() {
 401         local command="$@"
 402
 403         ${command} && return ${EXIT_FALSE} || return ${EXIT_TRUE}
 404 }
 405
 406 exec_cmd() {
 407         local cmd=$@
 408
 409         log DEBUG "Running command: ${cmd}"
 410
 411         DEBUG=${DEBUG} \
 412         LOG_DISABLE_STDOUT="${LOG_DISABLE_STDOUT}" \
 413         LOG_FACILITY="${LOG_FACILITY}" \
 414                 ${SHELL} ${cmd}
 415         local ret=$?
 416
 417         #log DEBUG "Returned with code '${ret}'"
 418
 419         if [ ${ret} -eq ${EXIT_ERROR_ASSERT} ]; then
 420                 error_log "Stopping parent process due to assertion error in child process: ${cmd}"
 421                 exit ${EXIT_ERROR_ASSERT}
 422         fi
 423
 424         return ${ret}
 425 }
 426
 427 cmd() {
 428         local cmd=$@
 429
 430         log DEBUG "Running command: ${cmd}"
 431
 432         ${cmd}
 433         local ret=$?
 434
 435         log DEBUG "Returned with code '${ret}'"
 436
 437         return ${ret}
 438 }
 439
 440 cmd_quiet() {
 441         cmd $@ &>/dev/null
 442 }
 443
 444 cmd_exec() {
 445         local cmd=$@
 446
 447         log DEBUG "Exec'ing command: ${cmd}"
 448
 449         exec ${cmd}
 450
 451         log ERROR "Could not exec-ute: ${cmd}"
 452         exit ${EXIT_ERROR}
 453 }
 454
 455 cmd_not_implemented() {
 456         assert false "not implemented"
 457 }
 458
 459 # Runs a command in a clean environment so that no confidential information
 460 # is leaked to any untrusted commands.
 461 cmd_clean_environment() {
 462         local cmd=$@
 463
 464         log DEBUG "Running command in a clean environment: ${cmd}"
 465         env -i -- ${cmd}
 466         local ret=${?}
 467
 468         log DEBUG "Returned with code '${ret}'"
 469         return ${ret}
 470 }
 471
 472 # Executes the given command in background
 473 cmd_background() {
 474         cmd_quiet $@ &
 475 }
 476
 477 # Prints the PID of the process that was started last
 478 cmd_background_get_pid() {
 479         print "${!}"
 480 }
 481
 482 cmd_background_result() {
 483         local pids=$@
 484
 485         wait ${pids}
 486 }
 487
 488 # Increase security of the read command
 489 read() {
 490         builtin read -r $@
 491 }
 492
 493 seq() {
 494         if [ $# -eq 2 ]; then
 495                 eval echo {${1}..${2}}
 496         elif [ $# -eq 3 ]; then
 497                 eval echo {${1}..${3}..${2}}
 498         fi
 499 }
 500
 501 range() {
 502         eval echo {0..$(( ${1} - 1 ))}
 503 }
 504
 505 count() {
 506         local i=0
 507
 508         while read; do
 509                 ((i++))
 510         done
 511
 512         echo ${i}
 513 }
 514
 515 which() {
 516         type -P $@
 517 }
 518
 519 # Prints the number of seconds since epoch.
 520 timestamp() {
 521         date -u "+%s"
 522 }
 523
 524 beautify_time() {
 525         local value=${1}
 526
 527         local unit
 528         local limit
 529         for unit in s m h d w; do
 530                 case "${unit}" in
 531                         s|m|h)
 532                                 limit=60
 533                                 ;;
 534                         d)
 535                                 limit=24
 536                                 ;;
 537                         w)
 538                                 limit=7
 539                                 ;;
 540                 esac
 541
 542                 [ ${value} -lt ${limit} ] && break
 543
 544                 value=$(( ${value} / ${limit} ))
 545         done
 546
 547         echo "${value}${unit}"
 548 }
 549
 550 beautify_bytes() {
 551         local value=${1}
 552
 553         local unit
 554         local limit=1024
 555         for unit in B k M G T; do
 556                 [ ${value} -lt ${limit} ] && break
 557                 value=$(( ${value} / ${limit} ))
 558         done
 559
 560         echo "${value}${unit}"
 561 }
 562
 563 module_load() {
 564         local module=${1}
 565
 566         if ! grep -q "^${module}" /proc/modules; then
 567                 log DEBUG "Loading module '${module}'."
 568                 modprobe ${module}
 569         fi
 570 }
 571
 572 binary_exists() {
 573         local binary=${1}
 574
 575         if [ -n "$(type -p ${binary})" ]; then
 576                 return ${EXIT_OK}
 577         fi
 578
 579         return ${EXIT_ERROR}
 580 }
 581
 582 function_exists() {
 583         local function="${1}"
 584
 585         if [ "$(type -t "${function}")" = "function" ]; then
 586                 return ${EXIT_TRUE}
 587         fi
 588
 589         return ${EXIT_FALSE}
 590 }
 591
 592 process_kill() {
 593         local process=${1}
 594
 595         if ! isinteger process; then
 596                 process=$(pidof ${process})
 597         fi
 598
 599         local pid
 600         local sig
 601         for pid in ${process}; do
 602                 for sig in 15 9; do
 603                         [ -d "/proc/${pid}" ] || break
 604
 605                         kill -${sig} ${pid}
 606                         sleep 1
 607                 done
 608         done
 609 }
 610
 611 dec() {
 612         local hex=${1}
 613
 614         if [ "${hex:0:2}" != "0x" ]; then
 615                 hex="0x${hex}"
 616         fi
 617
 618         printf "%d\n" "${hex}"
 619 }
 620
 621 chr() {
 622         local char="${1}"
 623
 624         [ ${char} -lt 256 ] || return ${EXIT_ERROR}
 625
 626         printf "\\$(( ${char} / 64 * 100 + ${char} % 64 / 8 * 10 + ${char} % 8 ))\n"
 627 }
 628
 629 ord() {
 630         LC_CTYPE="C" printf "%d\n" "'${1}"
 631 }
 632
 633 hex() {
 634         printf "%X\n" "${1}"
 635 }
 636
 637 network_is_running() {
 638         # Check, if the network service is running.
 639         service_is_active network
 640 }
 641
 642 contains_spaces() {
 643         local var="$@"
 644
 645         # Eliminate spaces.
 646         local var2=${var// /}
 647
 648         if [ ${#var} -ne ${#var2} ]; then
 649                 return ${EXIT_TRUE}
 650         fi
 651
 652         return ${EXIT_FALSE}
 653 }
 654
 655 string_split() {
 656         local string="$@"
 657
 658         local pos=0
 659         while [ ${pos} -lt ${#string} ]; do
 660                 print "${string:${pos}:1}"
 661                 pos=$(( ${pos} + 1 ))
 662         done
 663
 664         return ${EXIT_OK}
 665 }
 666
 667 string_reverse() {
 668         local string="$@"
 669
 670         local output
 671         local pos=0
 672         while [ ${pos} -lt ${#string} ]; do
 673                 output="${string:${pos}:1}${output}"
 674                 pos=$(( ${pos} + 1 ))
 675         done
 676
 677         print "${output}"
 678         return ${EXIT_OK}
 679 }
 680
 681 dec2bin() {
 682         local number="${1}"
 683
 684         local output
 685
 686         local i div
 687         for i in 7 6 5 4 3 2 1; do
 688                 div=$(( 2 ** ${i} ))
 689
 690                 if [ $(( ${number} / ${div} )) -eq 1 ]; then
 691                         output="${output}1"
 692                 else
 693                         output="${output}0"
 694                 fi
 695                 number="$(( ${number} % ${div} ))"
 696         done
 697
 698         if [ $(( ${number} % 2 )) -eq 1 ]; then
 699                 output="${output}1"
 700         else
 701                 output="${output}0"
 702         fi
 703
 704         print "${output}"
 705 }
 706
 707 bin2dec() {
 708         local string="${1}"
 709         local number=0
 710
 711         local pos=0 char
 712         while [ ${pos} -lt ${#string} ]; do
 713                 char="${string:${pos}:1}"
 714                 pos=$(( ${pos} + 1 ))
 715
 716                 number=$(( ${number} << 1 ))
 717
 718                 case "${char}" in
 719                         0) ;;
 720                         1)
 721                                 number=$(( ${number} + 1 ))
 722                                 ;;
 723                         *)
 724                                 assert false "Invalid character: ${char}"
 725                                 ;;
 726                 esac
 727         done
 728
 729         print "${number}"
 730         return ${EXIT_OK}
 731 }
 732
 733 char2bin() {
 734         local dec="$(ord "${1}")"
 735
 736         dec2bin "${dec}"
 737 }
 738
 739 bin2char() {
 740         local dec="$(bin2dec "$@")"
 741
 742         chr "${dec}"
 743 }
 744
 745 bin2hex() {
 746         local dec="$(bin2dec "$@")"
 747
 748         dec2hex "${dec}"
 749 }
 750
 751 hex2bin() {
 752         local dec="$(hex2dec "$@")"
 753
 754         dec2bin "${dec}"
 755 }
 756
 757 hex2dec() {
 758         local hex="${1}"
 759
 760         # Prepend 0x if necessary.
 761         [ "${hex:0:2}" = "0x" ] || hex="0x${hex}"
 762
 763         printf "%d\n" "${hex}"
 764 }
 765
 766 dec2hex() {
 767         printf "%02x\n" "${1}"
 768 }