1if [ ! "$_COMMON_SUBR" ]; then _COMMON_SUBR=1 2# 3# Copyright (c) 2012 Ron McDowell 4# Copyright (c) 2012-2014 Devin Teske 5# All rights reserved. 6# 7# Redistribution and use in source and binary forms, with or without 8# modification, are permitted provided that the following conditions 9# are met: 10# 1. Redistributions of source code must retain the above copyright 11# notice, this list of conditions and the following disclaimer. 12# 2. Redistributions in binary form must reproduce the above copyright 13# notice, this list of conditions and the following disclaimer in the 14# documentation and/or other materials provided with the distribution. 15# 16# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26# SUCH DAMAGE. 27# 28# $FreeBSD$ 29# 30############################################################ CONFIGURATION 31 32# 33# Default file descriptors to link to stdout/stderr for passthru allowing 34# redirection within a sub-shell to bypass directly to the terminal. 35# 36: ${TERMINAL_STDOUT_PASSTHRU:=3}} 37: ${TERMINAL_STDERR_PASSTHRU:=4}} 38 39############################################################ GLOBALS 40 41# 42# Program name 43# 44pgm="${0##*/}" 45 46# 47# Program arguments 48# 49ARGC="$#" 50ARGV="$@" 51 52# 53# Global exit status variables 54# 55SUCCESS=0 56FAILURE=1 57 58# 59# Operating environment details 60# 61export UNAME_S="$( uname -s )" # Operating System (i.e. FreeBSD) 62export UNAME_P="$( uname -p )" # Processor Architecture (i.e. i386) 63export UNAME_M="$( uname -m )" # Machine platform (i.e. i386) 64export UNAME_R="$( uname -r )" # Release Level (i.e. X.Y-RELEASE) 65 66# 67# Default behavior is to call f_debug_init() automatically when loaded. 68# 69: ${DEBUG_SELF_INITIALIZE=1} 70 71# 72# Default behavior of f_debug_init() is to truncate $debugFile (set to NULL to 73# disable truncating the debug file when initializing). To get child processes 74# to append to the same log file, export this variarable (with a NULL value) 75# and also export debugFile with the desired value. 76# 77: ${DEBUG_INITIALIZE_FILE=1} 78 79# 80# Define standard optstring arguments that should be supported by all programs 81# using this include (unless DEBUG_SELF_INITIALIZE is set to NULL to prevent 82# f_debug_init() from autamatically processing "$@" for the below arguments): 83# 84# d Sets $debug to 1 85# D: Sets $debugFile to $OPTARG 86# 87GETOPTS_STDARGS="dD:" 88 89# 90# The getopts builtin will return 1 either when the end of "$@" or the first 91# invalid flag is reached. This makes it impossible to determine if you've 92# processed all the arguments or simply have hit an invalid flag. In the cases 93# where we want to tolerate invalid flags (f_debug_init() for example), the 94# following variable can be appended to your optstring argument to getopts, 95# preventing it from prematurely returning 1 before the end of the arguments. 96# 97# NOTE: This assumes that all unknown flags are argument-less. 98# 99GETOPTS_ALLFLAGS="abcdefghijklmnopqrstuvwxyz" 100GETOPTS_ALLFLAGS="${GETOPTS_ALLFLAGS}ABCDEFGHIJKLMNOPQRSTUVWXYZ" 101GETOPTS_ALLFLAGS="${GETOPTS_ALLFLAGS}0123456789" 102 103# 104# When we get included, f_debug_init() will fire (unless $DEBUG_SELF_INITIALIZE 105# is set to disable automatic initialization) and process "$@" for a few global 106# options such as `-d' and/or `-D file'. However, if your program takes custom 107# flags that take arguments, this automatic processing may fail unexpectedly. 108# 109# The solution to this problem is to pre-define (before including this file) 110# the following variable (which defaults to NULL) to indicate that there are 111# extra flags that should be considered when performing automatic processing of 112# globally persistent flags. 113# 114: ${GETOPTS_EXTRA:=} 115 116############################################################ FUNCTIONS 117 118# f_dprintf $format [$arguments ...] 119# 120# Sensible debug function. Override in ~/.bsdconfigrc if desired. 121# See /usr/share/examples/bsdconfig/bsdconfigrc for example. 122# 123# If $debug is set and non-NULL, prints DEBUG info using printf(1) syntax: 124# + To $debugFile, if set and non-NULL 125# + To standard output if $debugFile is either NULL or unset 126# + To both if $debugFile begins with a single plus-sign (`+') 127# 128f_dprintf() 129{ 130 [ "$debug" ] || return $SUCCESS 131 local fmt="$1"; shift 132 case "$debugFile" in ""|+*) 133 printf "DEBUG: $fmt${fmt:+\n}" "$@" >&${TERMINAL_STDOUT_PASSTHRU:-1} 134 esac 135 [ "${debugFile#+}" ] && 136 printf "DEBUG: $fmt${fmt:+\n}" "$@" >> "${debugFile#+}" 137 return $SUCCESS 138} 139 140# f_debug_init 141# 142# Initialize debugging. Truncates $debugFile to zero bytes if set. 143# 144f_debug_init() 145{ 146 # 147 # Process stored command-line arguments 148 # 149 set -- $ARGV 150 local OPTIND OPTARG flag 151 f_dprintf "f_debug_init: ARGV=[%s] GETOPTS_STDARGS=[%s]" \ 152 "$ARGV" "$GETOPTS_STDARGS" 153 while getopts "$GETOPTS_STDARGS$GETOPTS_EXTRA$GETOPTS_ALLFLAGS" flag \ 154 > /dev/null; do 155 case "$flag" in 156 d) debug=1 ;; 157 D) debugFile="$OPTARG" ;; 158 esac 159 done 160 shift $(( $OPTIND - 1 )) 161 f_dprintf "f_debug_init: debug=[%s] debugFile=[%s]" \ 162 "$debug" "$debugFile" 163 164 # 165 # Automagically enable debugging if debugFile is set (and non-NULL) 166 # 167 [ "$debugFile" ] && { [ "${debug+set}" ] || debug=1; } 168 169 # 170 # Make debugging persistant if set 171 # 172 [ "$debug" ] && export debug 173 [ "$debugFile" ] && export debugFile 174 175 # 176 # Truncate debug file unless requested otherwise. Note that we will 177 # trim a leading plus (`+') from the value of debugFile to support 178 # persistant meaning that f_dprintf() should print both to standard 179 # output and $debugFile (minus the leading plus, of course). 180 # 181 local _debug_file="${debugFile#+}" 182 if [ "$_debug_file" -a "$DEBUG_INITIALIZE_FILE" ]; then 183 if ( umask 022 && :> "$_debug_file" ); then 184 f_dprintf "Successfully initialized debugFile \`%s'" \ 185 "$_debug_file" 186 f_isset debug || debug=1 # turn debugging on if not set 187 else 188 unset debugFile 189 f_dprintf "Unable to initialize debugFile \`%s'" \ 190 "$_debug_file" 191 fi 192 fi 193} 194 195# f_err $format [$arguments ...] 196# 197# Print a message to stderr (fd=2). 198# 199f_err() 200{ 201 printf "$@" >&2 202} 203 204# f_quietly $command [$arguments ...] 205# 206# Run a command quietly (quell any output to stdout or stderr) 207# 208f_quietly() 209{ 210 "$@" > /dev/null 2>&1 211} 212 213# f_have $anything ... 214# 215# A wrapper to the `type' built-in. Returns true if argument is a valid shell 216# built-in, keyword, or externally-tracked binary, otherwise false. 217# 218f_have() 219{ 220 f_quietly type "$@" 221} 222 223# setvar $var_to_set [$value] 224# 225# Implement setvar for shells unlike FreeBSD sh(1). 226# 227if ! f_have setvar; then 228setvar() 229{ 230 [ $# -gt 0 ] || return $SUCCESS 231 local __setvar_var_to_set="$1" __setvar_right="$2" __setvar_left= 232 case $# in 233 1) unset "$__setvar_var_to_set" 234 return $? ;; 235 2) : fall through ;; 236 *) f_err "setvar: too many arguments\n" 237 return $FAILURE 238 esac 239 case "$__setvar_var_to_set" in *[!0-9A-Za-z_]*) 240 f_err "setvar: %s: bad variable name\n" "$__setvar_var_to_set" 241 return 2 242 esac 243 while case "$__setvar_r" in *\'*) : ;; *) false ; esac 244 do 245 __setvar_left="$__setvar_left${__setvar_right%%\'*}'\\''" 246 __setvar_right="${__setvar_right#*\'}" 247 done 248 __setvar_left="$__setvar_left${__setvar_right#*\'}" 249 eval "$__setvar_var_to_set='$__setvar_left'" 250} 251fi 252 253# f_which $anything [$var_to_set] 254# 255# A fast built-in replacement for syntaxes such as foo=$( which bar ). In a 256# comparison of 10,000 runs of this function versus which, this function 257# completed in under 3 seconds, while `which' took almost a full minute. 258# 259# If $var_to_set is missing or NULL, output is (like which) to standard out. 260# Returns success if a match was found, failure otherwise. 261# 262f_which() 263{ 264 local __name="$1" __var_to_set="$2" 265 case "$__name" in */*|'') return $FAILURE; esac 266 local __p __exec IFS=":" __found= 267 for __p in $PATH; do 268 __exec="$__p/$__name" 269 [ -f "$__exec" -a -x "$__exec" ] && __found=1 break 270 done 271 if [ "$__found" ]; then 272 if [ "$__var_to_set" ]; then 273 setvar "$__var_to_set" "$__exec" 274 else 275 echo "$__exec" 276 fi 277 return $SUCCESS 278 fi 279 return $FAILURE 280} 281 282# f_getvar $var_to_get [$var_to_set] 283# 284# Utility function designed to go along with the already-builtin setvar. 285# Allows clean variable name indirection without forking or sub-shells. 286# 287# Returns error status if the requested variable ($var_to_get) is not set. 288# 289# If $var_to_set is missing or NULL, the value of $var_to_get is printed to 290# standard output for capturing in a sub-shell (which is less-recommended 291# because of performance degredation; for example, when called in a loop). 292# 293f_getvar() 294{ 295 local __var_to_get="$1" __var_to_set="$2" 296 [ "$__var_to_set" ] || local value 297 eval [ \"\${$__var_to_get+set}\" ] 298 local __retval=$? 299 eval ${__var_to_set:-value}=\"\${$__var_to_get}\" 300 eval f_dprintf '"f_getvar: var=[%s] value=[%s] r=%u"' \ 301 \"\$__var_to_get\" \"\$${__var_to_set:-value}\" \$__retval 302 [ "$__var_to_set" ] || { [ "$value" ] && echo "$value"; } 303 return $__retval 304} 305 306# f_isset $var 307# 308# Check if variable $var is set. Returns success if variable is set, otherwise 309# returns failure. 310# 311f_isset() 312{ 313 eval [ \"\${${1%%[$IFS]*}+set}\" ] 314} 315 316# f_die [$status [$format [$arguments ...]]] 317# 318# Abruptly terminate due to an error optionally displaying a message in a 319# dialog box using printf(1) syntax. 320# 321f_die() 322{ 323 local status=$FAILURE 324 325 # If there is at least one argument, take it as the status 326 if [ $# -gt 0 ]; then 327 status=$1 328 shift 1 # status 329 fi 330 331 # If there are still arguments left, pass them to f_show_msg 332 [ $# -gt 0 ] && f_show_msg "$@" 333 334 # Optionally call f_clean_up() function if it exists 335 f_have f_clean_up && f_clean_up 336 337 exit $status 338} 339 340# f_interrupt 341# 342# Interrupt handler. 343# 344f_interrupt() 345{ 346 exec 2>&1 # fix sh(1) bug where stderr gets lost within async-trap 347 f_die 348} 349 350# f_show_info $format [$arguments ...] 351# 352# Display a message in a dialog infobox using printf(1) syntax. 353# 354f_show_info() 355{ 356 local msg 357 msg=$( printf "$@" ) 358 359 # 360 # Use f_dialog_infobox from dialog.subr if possible, otherwise fall 361 # back to dialog(1) (without options, making it obvious when using 362 # un-aided system dialog). 363 # 364 if f_have f_dialog_info; then 365 f_dialog_info "$msg" 366 else 367 dialog --infobox "$msg" 0 0 368 fi 369} 370 371# f_show_msg $format [$arguments ...] 372# 373# Display a message in a dialog box using printf(1) syntax. 374# 375f_show_msg() 376{ 377 local msg 378 msg=$( printf "$@" ) 379 380 # 381 # Use f_dialog_msgbox from dialog.subr if possible, otherwise fall 382 # back to dialog(1) (without options, making it obvious when using 383 # un-aided system dialog). 384 # 385 if f_have f_dialog_msgbox; then 386 f_dialog_msgbox "$msg" 387 else 388 dialog --msgbox "$msg" 0 0 389 fi 390} 391 392# f_show_err $format [$arguments ...] 393# 394# Display a message in a dialog box with ``Error'' i18n title (overridden by 395# setting msg_error) using printf(1) syntax. 396# 397f_show_err() 398{ 399 local msg 400 msg=$( printf "$@" ) 401 402 : ${msg:=${msg_an_unknown_error_occurred:-An unknown error occurred}} 403 404 if [ "$_DIALOG_SUBR" ]; then 405 f_dialog_title "${msg_error:-Error}" 406 f_dialog_msgbox "$msg" 407 f_dialog_title_restore 408 else 409 dialog --title "${msg_error:-Error}" --msgbox "$msg" 0 0 410 fi 411 return $SUCCESS 412} 413 414# f_yesno $format [$arguments ...] 415# 416# Display a message in a dialog yes/no box using printf(1) syntax. 417# 418f_yesno() 419{ 420 local msg 421 msg=$( printf "$@" ) 422 423 # 424 # Use f_dialog_yesno from dialog.subr if possible, otherwise fall 425 # back to dialog(1) (without options, making it obvious when using 426 # un-aided system dialog). 427 # 428 if f_have f_dialog_yesno; then 429 f_dialog_yesno "$msg" 430 else 431 dialog --yesno "$msg" 0 0 432 fi 433} 434 435# f_noyes $format [$arguments ...] 436# 437# Display a message in a dialog yes/no box using printf(1) syntax. 438# NOTE: THis is just like the f_yesno function except "No" is default. 439# 440f_noyes() 441{ 442 local msg 443 msg=$( printf "$@" ) 444 445 # 446 # Use f_dialog_noyes from dialog.subr if possible, otherwise fall 447 # back to dialog(1) (without options, making it obvious when using 448 # un-aided system dialog). 449 # 450 if f_have f_dialog_noyes; then 451 f_dialog_noyes "$msg" 452 else 453 dialog --defaultno --yesno "$msg" 0 0 454 fi 455} 456 457# f_show_help $file 458# 459# Display a language help-file. Automatically takes $LANG and $LC_ALL into 460# consideration when displaying $file (suffix ".$LC_ALL" or ".$LANG" will 461# automatically be added prior to loading the language help-file). 462# 463# If a language has been requested by setting either $LANG or $LC_ALL in the 464# environment and the language-specific help-file does not exist we will fall 465# back to $file without-suffix. 466# 467# If the language help-file does not exist, an error is displayed instead. 468# 469f_show_help() 470{ 471 local file="$1" 472 local lang="${LANG:-$LC_ALL}" 473 474 [ -f "$file.$lang" ] && file="$file.$lang" 475 476 # 477 # Use f_dialog_textbox from dialog.subr if possible, otherwise fall 478 # back to dialog(1) (without options, making it obvious when using 479 # un-aided system dialog). 480 # 481 if f_have f_dialog_textbox; then 482 f_dialog_textbox "$file" 483 else 484 dialog --msgbox "$( cat "$file" 2>&1 )" 0 0 485 fi 486} 487 488# f_include $file 489# 490# Include a shell subroutine file. 491# 492# If the subroutine file exists but returns error status during loading, exit 493# is called and execution is prematurely terminated with the same error status. 494# 495f_include() 496{ 497 local file="$1" 498 f_dprintf "f_include: file=[%s]" "$file" 499 . "$file" || exit $? 500} 501 502# f_include_lang $file 503# 504# Include a language file. Automatically takes $LANG and $LC_ALL into 505# consideration when including $file (suffix ".$LC_ALL" or ".$LANG" will 506# automatically by added prior to loading the language file). 507# 508# No error is produced if (a) a language has been requested (by setting either 509# $LANG or $LC_ALL in the environment) and (b) the language file does not 510# exist -- in which case we will fall back to loading $file without-suffix. 511# 512# If the language file exists but returns error status during loading, exit 513# is called and execution is prematurely terminated with the same error status. 514# 515f_include_lang() 516{ 517 local file="$1" 518 local lang="${LANG:-$LC_ALL}" 519 520 f_dprintf "f_include_lang: file=[%s] lang=[%s]" "$file" "$lang" 521 if [ -f "$file.$lang" ]; then 522 . "$file.$lang" || exit $? 523 else 524 . "$file" || exit $? 525 fi 526} 527 528# f_usage $file [$key1 $value1 ...] 529# 530# Display USAGE file with optional pre-processor macro definitions. The first 531# argument is the template file containing the usage text to be displayed. If 532# $LANG or $LC_ALL (in order of preference, respectively) is set, ".encoding" 533# will automatically be appended as a suffix to the provided $file pathname. 534# 535# When processing $file, output begins at the first line containing that is 536# (a) not a comment, (b) not empty, and (c) is not pure-whitespace. All lines 537# appearing after this first-line are output, including (a) comments (b) empty 538# lines, and (c) lines that are purely whitespace-only. 539# 540# If additional arguments appear after $file, substitutions are made while 541# printing the contents of the USAGE file. The pre-processor macro syntax is in 542# the style of autoconf(1), for example: 543# 544# f_usage $file "FOO" "BAR" 545# 546# Will cause instances of "@FOO@" appearing in $file to be replaced with the 547# text "BAR" before being printed to the screen. 548# 549# This function is a two-parter. Below is the awk(1) portion of the function, 550# afterward is the sh(1) function which utilizes the below awk script. 551# 552f_usage_awk=' 553BEGIN { found = 0 } 554{ 555 if ( !found && $0 ~ /^[[:space:]]*($|#)/ ) next 556 found = 1 557 print 558} 559' 560f_usage() 561{ 562 local file="$1" 563 local lang="${LANG:-$LC_ALL}" 564 565 f_dprintf "f_usage: file=[%s] lang=[%s]" "$file" "$lang" 566 567 shift 1 # file 568 569 local usage 570 if [ -f "$file.$lang" ]; then 571 usage=$( awk "$f_usage_awk" "$file.$lang" ) || exit $FAILURE 572 else 573 usage=$( awk "$f_usage_awk" "$file" ) || exit $FAILURE 574 fi 575 576 while [ $# -gt 0 ]; do 577 local key="$1" 578 export value="$2" 579 usage=$( echo "$usage" | awk \ 580 "{ gsub(/@$key@/, ENVIRON[\"value\"]); print }" ) 581 shift 2 582 done 583 584 f_err "%s\n" "$usage" 585 586 exit $FAILURE 587} 588 589# f_index_file $keyword [$var_to_set] 590# 591# Process all INDEX files known to bsdconfig and return the path to first file 592# containing a menu_selection line with a keyword portion matching $keyword. 593# 594# If $LANG or $LC_ALL (in order of preference, respectively) is set, 595# "INDEX.encoding" files will be searched first. 596# 597# If no file is found, error status is returned along with the NULL string. 598# 599# If $var_to_set is NULL or missing, output is printed to stdout (which is less 600# recommended due to performance degradation; in a loop for example). 601# 602# This function is a two-parter. Below is the awk(1) portion of the function, 603# afterward is the sh(1) function which utilizes the below awk script. 604# 605f_index_file_awk=' 606# Variables that should be defined on the invocation line: 607# -v keyword="keyword" 608BEGIN { found = 0 } 609( $0 ~ "^menu_selection=\"" keyword "\\|" ) { 610 print FILENAME 611 found++ 612 exit 613} 614END { exit ! found } 615' 616f_index_file() 617{ 618 local __keyword="$1" __var_to_set="$2" 619 local __lang="${LANG:-$LC_ALL}" 620 local __indexes="$BSDCFG_LIBE${BSDCFG_LIBE:+/}*/INDEX" 621 622 f_dprintf "f_index_file: keyword=[%s] lang=[%s]" "$__keyword" "$__lang" 623 624 if [ "$__lang" ]; then 625 if [ "$__var_to_set" ]; then 626 eval "$__var_to_set"='"$( awk -v keyword="$__keyword" \ 627 "$f_index_file_awk" $__indexes.$__lang 628 )"' && return $SUCCESS 629 else 630 awk -v keyword="$__keyword" "$f_index_file_awk" \ 631 $__indexes.$__lang && return $SUCCESS 632 fi 633 # No match, fall-thru to non-i18n sources 634 fi 635 if [ "$__var_to_set" ]; then 636 eval "$__var_to_set"='"$( awk -v keyword="$__keyword" \ 637 "$f_index_file_awk" $__indexes )"' && return $SUCCESS 638 else 639 awk -v keyword="$__keyword" "$f_index_file_awk" $__indexes && 640 return $SUCCESS 641 fi 642 643 # No match? Fall-thru to `local' libexec sources (add-on modules) 644 645 [ "$BSDCFG_LOCAL_LIBE" ] || return $FAILURE 646 __indexes="$BSDCFG_LOCAL_LIBE/*/INDEX" 647 if [ "$__lang" ]; then 648 if [ "$__var_to_set" ]; then 649 eval "$__var_to_set"='"$( awk -v keyword="$__keyword" \ 650 "$f_index_file_awk" $__indexes.$__lang 651 )"' && return $SUCCESS 652 else 653 awk -v keyword="$__keyword" "$f_index_file_awk" \ 654 $__indexes.$__lang && return $SUCCESS 655 fi 656 # No match, fall-thru to non-i18n sources 657 fi 658 if [ "$__var_to_set" ]; then 659 eval "$__var_to_set"='$( awk -v keyword="$__keyword" \ 660 "$f_index_file_awk" $__indexes )"' 661 else 662 awk -v keyword="$__keyword" "$f_index_file_awk" $__indexes 663 fi 664} 665 666# f_index_menusel_keyword $indexfile $pgm [$var_to_set] 667# 668# Process $indexfile and return only the keyword portion of the menu_selection 669# line with a command portion matching $pgm. 670# 671# This function is for internationalization (i18n) mapping of the on-disk 672# scriptname ($pgm) into the localized language (given language-specific 673# $indexfile). If $LANG or $LC_ALL (in orderder of preference, respectively) is 674# set, ".encoding" will automatically be appended as a suffix to the provided 675# $indexfile pathname. 676# 677# If, within $indexfile, multiple $menu_selection values map to $pgm, only the 678# first one will be returned. If no mapping can be made, the NULL string is 679# returned. 680# 681# If $indexfile does not exist, error status is returned with NULL. 682# 683# If $var_to_set is NULL or missing, output is printed to stdout (which is less 684# recommended due to performance degradation; in a loop for example). 685# 686# This function is a two-parter. Below is the awk(1) portion of the function, 687# afterward is the sh(1) function which utilizes the below awk script. 688# 689f_index_menusel_keyword_awk=' 690# Variables that should be defined on the invocation line: 691# -v pgm="program_name" 692# 693BEGIN { 694 prefix = "menu_selection=\"" 695 plen = length(prefix) 696 found = 0 697} 698{ 699 if (!match($0, "^" prefix ".*\\|.*\"")) next 700 701 keyword = command = substr($0, plen + 1, RLENGTH - plen - 1) 702 sub(/^.*\|/, "", command) 703 sub(/\|.*$/, "", keyword) 704 705 if ( command == pgm ) 706 { 707 print keyword 708 found++ 709 exit 710 } 711} 712END { exit ! found } 713' 714f_index_menusel_keyword() 715{ 716 local __indexfile="$1" __pgm="$2" __var_to_set="$3" 717 local __lang="${LANG:-$LC_ALL}" __file="$__indexfile" 718 719 [ -f "$__indexfile.$__lang" ] && __file="$__indexfile.$__lang" 720 f_dprintf "f_index_menusel_keyword: index=[%s] pgm=[%s] lang=[%s]" \ 721 "$__file" "$__pgm" "$__lang" 722 723 if [ "$__var_to_set" ]; then 724 setvar "$__var_to_set" "$( awk \ 725 -v pgm="$__pgm" "$f_index_menusel_keyword_awk" "$__file" 726 )" 727 else 728 awk -v pgm="$__pgm" "$f_index_menusel_keyword_awk" "$__file" 729 fi 730} 731 732# f_index_menusel_command $indexfile $keyword [$var_to_set] 733# 734# Process $indexfile and return only the command portion of the menu_selection 735# line with a keyword portion matching $keyword. 736# 737# This function is for mapping [possibly international] keywords into the 738# command to be executed. If $LANG or $LC_ALL (order of preference) is set, 739# ".encoding" will automatically be appended as a suffix to the provided 740# $indexfile pathname. 741# 742# If, within $indexfile, multiple $menu_selection values map to $keyword, only 743# the first one will be returned. If no mapping can be made, the NULL string is 744# returned. 745# 746# If $indexfile doesn't exist, error status is returned with NULL. 747# 748# If $var_to_set is NULL or missing, output is printed to stdout (which is less 749# recommended due to performance degradation; in a loop for example). 750# 751# This function is a two-parter. Below is the awk(1) portion of the function, 752# afterward is the sh(1) function which utilizes the below awk script. 753# 754f_index_menusel_command_awk=' 755# Variables that should be defined on the invocation line: 756# -v key="keyword" 757# 758BEGIN { 759 prefix = "menu_selection=\"" 760 plen = length(prefix) 761 found = 0 762} 763{ 764 if (!match($0, "^" prefix ".*\\|.*\"")) next 765 766 keyword = command = substr($0, plen + 1, RLENGTH - plen - 1) 767 sub(/^.*\|/, "", command) 768 sub(/\|.*$/, "", keyword) 769 770 if ( keyword == key ) 771 { 772 print command 773 found++ 774 exit 775 } 776} 777END { exit ! found } 778' 779f_index_menusel_command() 780{ 781 local __indexfile="$1" __keyword="$2" __var_to_set="$3" __command 782 local __lang="${LANG:-$LC_ALL}" __file="$__indexfile" 783 784 [ -f "$__indexfile.$__lang" ] && __file="$__indexfile.$__lang" 785 f_dprintf "f_index_menusel_command: index=[%s] key=[%s] lang=[%s]" \ 786 "$__file" "$__keyword" "$__lang" 787 788 [ -f "$__file" ] || return $FAILURE 789 __command=$( awk -v key="$__keyword" \ 790 "$f_index_menusel_command_awk" "$__file" ) || return $FAILURE 791 792 # 793 # If the command pathname is not fully qualified fix-up/force to be 794 # relative to the $indexfile directory. 795 # 796 case "$__command" in 797 /*) : already fully qualified ;; 798 *) 799 local __indexdir="${__indexfile%/*}" 800 [ "$__indexdir" != "$__indexfile" ] || __indexdir="." 801 __command="$__indexdir/$__command" 802 esac 803 804 if [ "$__var_to_set" ]; then 805 setvar "$__var_to_set" "$__command" 806 else 807 echo "$__command" 808 fi 809} 810 811# f_running_as_init 812# 813# Returns true if running as init(1). 814# 815f_running_as_init() 816{ 817 # 818 # When a custom init(8) performs an exec(3) to invoke a shell script, 819 # PID 1 becomes sh(1) and $PPID is set to 1 in the executed script. 820 # 821 [ ${PPID:-0} -eq 1 ] # Return status 822} 823 824# f_mounted $local_directory 825# f_mounted -b $device 826# 827# Return success if a filesystem is mounted on a particular directory. If `-b' 828# is present, instead check that the block device (or a partition thereof) is 829# mounted. 830# 831f_mounted() 832{ 833 local OPTIND OPTARG flag use_device= 834 while getopts b flag; do 835 case "$flag" in 836 b) use_device=1 ;; 837 esac 838 done 839 shift $(( $OPTIND - 1 )) 840 if [ "$use_device" ]; then 841 local device="$1" 842 mount | grep -Eq \ 843 "^$device([[:space:]]|p[0-9]|s[0-9]|\.nop|\.eli)" 844 else 845 [ -d "$dir" ] || return $FAILURE 846 mount | grep -Eq " on $dir \([^)]+\)$" 847 fi 848 # Return status is that of last grep(1) 849} 850 851# f_eval_catch [-de] [-k $var_to_set] $funcname $utility \ 852# $format [$arguments ...] 853# 854# Silently evaluate a command in a sub-shell and test for error. If debugging 855# is enabled a copy of the command and its output is sent to debug (either 856# stdout or file depending on environment). If an error occurs, output of the 857# command is displayed in a dialog(1) msgbox using the [above] f_show_err() 858# function (unless optional `-d' flag is given, then no dialog). 859# 860# The $funcname argument is sent to debugging while the $utility argument is 861# used in the title of the dialog box. The command that is executed as well as 862# sent to debugging with $funcname is the product of the printf(1) syntax 863# produced by $format with optional $arguments. 864# 865# The following options are supported: 866# 867# -d Do not use dialog(1). 868# -e Produce error text from failed command on stderr. 869# -k var Save output from the command in var. 870# 871# Example 1: 872# 873# debug=1 874# f_eval_catch myfunc echo 'echo "%s"' "Hello, World!" 875# 876# Produces the following debug output: 877# 878# DEBUG: myfunc: echo "Hello, World!" 879# DEBUG: myfunc: retval=0 <output below> 880# Hello, World! 881# 882# Example 2: 883# 884# debug=1 885# f_eval_catch -k contents myfunc cat 'cat "%s"' /some/file 886# # dialog(1) Error ``cat: /some/file: No such file or directory'' 887# # contents=[cat: /some/file: No such file or directory] 888# 889# Produces the following debug output: 890# 891# DEBUG: myfunc: cat "/some/file" 892# DEBUG: myfunc: retval=1 <output below> 893# cat: /some/file: No such file or directory 894# 895# Example 3: 896# 897# debug=1 898# echo 123 | f_eval_catch myfunc rev rev 899# 900# Produces the following debug output: 901# 902# DEBUG: myfunc: rev 903# DEBUG: myfunc: retval=0 <output below> 904# 321 905# 906# Example 4: 907# 908# debug=1 909# f_eval_catch myfunc true true 910# 911# Produces the following debug output: 912# 913# DEBUG: myfunc: true 914# DEBUG: myfunc: retval=0 <no output> 915# 916# Example 5: 917# 918# f_eval_catch -de myfunc ls 'ls "%s"' /some/dir 919# # Output on stderr ``ls: /some/dir: No such file or directory'' 920# 921# Example 6: 922# 923# f_eval_catch -dek contents myfunc ls 'ls "%s"' /etc 924# # Output from `ls' sent to stderr and also saved in $contents 925# 926f_eval_catch() 927{ 928 local __no_dialog= __show_err= __var_to_set= 929 930 # 931 # Process local function arguments 932 # 933 local OPTIND OPTARG __flag 934 while getopts "dek:" __flag > /dev/null; do 935 case "$__flag" in 936 d) __no_dialog=1 ;; 937 e) __show_err=1 ;; 938 k) __var_to_set="$OPTARG" ;; 939 esac 940 done 941 shift $(( $OPTIND - 1 )) 942 943 local __funcname="$1" __utility="$2"; shift 2 944 local __cmd __output __retval 945 946 __cmd=$( printf -- "$@" ) 947 f_dprintf "%s: %s" "$__funcname" "$__cmd" # Log command *before* eval 948 __output=$( exec 2>&1; eval "$__cmd" ) 949 __retval=$? 950 if [ "$__output" ]; then 951 [ "$__show_err" ] && echo "$__output" >&2 952 f_dprintf "%s: retval=%i <output below>\n%s" "$__funcname" \ 953 $__retval "$__output" 954 else 955 f_dprintf "%s: retval=%i <no output>" "$__funcname" $__retval 956 fi 957 958 ! [ "$__no_dialog" -o "$nonInteractive" -o $__retval -eq $SUCCESS ] && 959 msg_error="${msg_error:-Error}${__utility:+: $__utility}" \ 960 f_show_err "%s" "$__output" 961 # NB: f_show_err will handle NULL output appropriately 962 963 [ "$__var_to_set" ] && setvar "$__var_to_set" "$__output" 964 965 return $__retval 966} 967 968# f_count $var_to_set arguments ... 969# 970# Sets $var_to_set to the number of arguments minus one (the effective number 971# of arguments following $var_to_set). 972# 973# Example: 974# f_count count dog house # count=[2] 975# 976f_count() 977{ 978 setvar "$1" $(( $# - 1 )) 979} 980 981# f_count_ifs $var_to_set string ... 982# 983# Sets $var_to_set to the number of words (split by the internal field 984# separator, IFS) following $var_to_set. 985# 986# Example 1: 987# 988# string="word1 word2 word3" 989# f_count_ifs count "$string" # count=[3] 990# f_count_ifs count $string # count=[3] 991# 992# Example 2: 993# 994# IFS=. f_count_ifs count www.freebsd.org # count=[3] 995# 996# NB: Make sure to use double-quotes if you are using a custom value for IFS 997# and you don't want the current value to effect the result. See example 3. 998# 999# Example 3: 1000# 1001# string="a-b c-d" 1002# IFS=- f_count_ifs count "$string" # count=[3] 1003# IFS=- f_count_ifs count $string # count=[4] 1004# 1005f_count_ifs() 1006{ 1007 local __var_to_set="$1" 1008 shift 1 1009 set -- $* 1010 setvar "$__var_to_set" $# 1011} 1012 1013############################################################ MAIN 1014 1015# 1016# Trap signals so we can recover gracefully 1017# 1018trap 'f_interrupt' SIGINT 1019trap 'f_die' SIGTERM SIGPIPE SIGXCPU SIGXFSZ \ 1020 SIGFPE SIGTRAP SIGABRT SIGSEGV 1021trap '' SIGALRM SIGPROF SIGUSR1 SIGUSR2 SIGHUP SIGVTALRM 1022 1023# 1024# Clone terminal stdout/stderr so we can redirect to it from within sub-shells 1025# 1026eval exec $TERMINAL_STDOUT_PASSTHRU\>\&1 1027eval exec $TERMINAL_STDERR_PASSTHRU\>\&2 1028 1029# 1030# Self-initialize unless requested otherwise 1031# 1032f_dprintf "%s: DEBUG_SELF_INITIALIZE=[%s]" \ 1033 dialog.subr "$DEBUG_SELF_INITIALIZE" 1034case "$DEBUG_SELF_INITIALIZE" in 1035""|0|[Nn][Oo]|[Oo][Ff][Ff]|[Ff][Aa][Ll][Ss][Ee]) : do nothing ;; 1036*) f_debug_init 1037esac 1038 1039# 1040# Log our operating environment for debugging purposes 1041# 1042f_dprintf "UNAME_S=[%s] UNAME_P=[%s] UNAME_R=[%s]" \ 1043 "$UNAME_S" "$UNAME_P" "$UNAME_R" 1044 1045f_dprintf "%s: Successfully loaded." common.subr 1046 1047fi # ! $_COMMON_SUBR 1048