# bootcd-run.lib
# vim: set filetype=sh :

#     version: $Version: $
#   copyright: Bernd Schumacher <bernd.schumacher@hpe.com> (2001-2020)
#     license: GNU General Public License, version 2
#     comment: use ANSW to change the next point from external
# description: To understand what to do with this library you can download
#              the test programs with wget
#

# info [--ignore_silent] <msg>
info()
{
  if [ "$1" = "--ignore_silent" ]; then
    shift
    ia_logerr "$@"
  else
    [ "${ia_use_silent:-}" ] && ia_log "$@" || ia_logerr "$@"
  fi
}

log()
{
  ia_log "$@"
}

warn()
{
  if [ $# -gt 0 ]; then
    if [ "$yes" ]; then
      A="i"
      ia_logerr "$(/bin/echo -e "--- WARNING ---\n$*\n$A ($yes)")"
    else
      A="$(ia_ask "$(/bin/echo -e "--- WARNING ---\n$*")" "" "" \
        "--- (e)xit (i)gnore --- " "^(e|i)$")"
      if [ "$A" = "e" ]; then
        exit 1
      fi
    fi
  fi
}

# err [--code <exit-code>] "text"
err()
{
  local code

  code="1"
  if [ "$1" = "--code" ]; then
    code=$2
    shift 2
  fi

  ia_logerr "--- FATAL ERROR ---"
  ia_logerr "$@"
  exit $code
}

# example:
#   fun() { ... RETURN_ERR="this is an error"; return <X>; ... }
#   ia_add "fun; RETURN_CODE=\$?"
#   ia_nocheck && ia_add "chk_RETURN_ERR"
chk_RETURN_ERR()
{
  if [ "${RETURN_ERR:-}" ]; then
    err --code "${RETURN_CODE:-1}" "$RETURN_ERR"
  fi
}

dbglog()
{
  dbg "$@"
  ia_log "$*"
}

# create_host_keys <DIR>
#   if ssh_host_key, ssh_host_rsa or ... exists in <DIR>
#   then recreate it.
create_host_keys()
{
  eval "$ia_init"
  # Now only ssh versions which support Option -t are supported
  ia_add "dbg \"create_host_keys start\""

  F=ssh_host_key
  if [ -f $1/$F ]; then
    ia_add "rm -f $1/$F $1/$F.pub"
    ia_add "ssh-keygen -b 1024 -f $1/$F -N '' -t rsa1 2>&1 | log"
  fi

  F=ssh_host_rsa_key
  if [ -f $1/$F ]; then
    ia_add "rm -f $1/$F $1/$F.pub"
    ia_add "ssh-keygen -b 1024 -f $1/$F -N '' -t rsa 2>&1 | log"
  fi

  F=ssh_host_dsa_key
  if [ -f $1/$F ]; then
    ia_add "rm -f $1/$F $1/$F.pub"
    ia_add "ssh-keygen -b 1024 -f $1/$F -N '' -t dsa 2>&1 | log"
  fi
  ia -c
}

# function: mk_empty_dir -- create directory
# get: $1 -- directory
#      $2 -- permissions (optional)
mk_empty_dir()
{
  local dir
  local message
  local perm
  local A

  dir=$1
  [ $# -ge 2 ] && perm=$2
  message="Directory \"$dir\" exist's, and will be removed"

  A=""
  if [ "$yes" ]; then
    log "$message"
    A="y"
  else
    A="$(ia_ask "$message" "" "y" "(Y/n) " "^(y|n)$")"
  fi

  if [ "$A" = "y" ]; then
    rm -rf $dir
  else
    err "directory \"$dir\" must not exist."
  fi
}


# function: check_tools -- check if tools exist
#           use ./ to search in local directory
# get: $1..$n -- tools
check_tools()
{
  while [ $# -gt 0 ]; do
    echo -n >&2 " check for \"$1\" ..."
    if [ "$(echo $1 |cut -c1-2)" = "./" ]; then
      [ ! -f "$1" ] && err "Can't find file \"$1\"!"
    else
      [ ! "$(which $1)" ] && err "Can't find tool \"$1\" in PATH!"
    fi
    echo >&2 "ok"
    shift
  done
}

# function: prepare_chroot <workdir> [-i]
# globals: IAHEAD
prepare_chroot()
{
  local p i ion itype selinuxmp
  eval "$ia_init"
  p="PATH=/usr/sbin:/usr/bin:/sbin:/bin"
  local workdir="$1"
  # if possible use --bind to prevent error in chroot: "Device <X> not
  # initialized in udev database even after waiting 10000000 microseconds"
  # run:tmpfs is needed for lvm
  for i in dev:devtmpfs proc:proc sys:sysfs sys/firmware/efi/efivars:efivarfs dev/pts:devpts run:tmpfs; do
    ion="$(echo "$i" | cut -d: -f1)"
    itype="$(echo "$i" | cut -d: -f2)"
    if [ "$(grep "\<$itype$" /proc/filesystems)" ]; then
      [ "$(mount | grep "on /$ion type $itype ")" ] && \
        ia_add "mount --bind /$ion $workdir/$ion" || \
        ia_add "mount -t $itype $itype $workdir/$ion"
    fi
  done
  ia_add "$p chroot $workdir sh -c \"[ -f /etc/mtab ] && mv /etc/mtab /etc/mtab.bootcd || rm -f /etc/mtab.bootcd\""
  ia_add "$p chroot $workdir sh -c \"grep -v -e \\\"^sunrpc\>\\\" -e \\\"^rootfs\>\\\" /proc/mounts >/etc/mtab\""

  # we need selinux mounted to install openssh_server without
  # error "chage: Permission denied."
  selinuxmp="$(sed -E -n -e "s|^selinuxfs\s+(\S+).*$|\1|p" /proc/mounts)"
  if [ "$selinuxmp" ]; then
    ia_add "mkdir -p $workdir$selinuxmp"
    ia_add "mount -t selinuxfs none $workdir$selinuxmp"
  fi
  ia -c
}

# umount_recursive mountdpoint
umount_recursive()
{
  local r n lazy
  while :; do
    r="$(mount | sed -E -n -e "s|.* on ($1/\S+) .*|\1|p" | head -1)"
    [  "$r" ] && umount_recursive "$r" || break
  done

  # umount $1, try max n+1 times
  n=3
  while [ $n -gt 0 ]; do
    [ $n -ge 2 ] && lazy="" || lazy="--lazy"
    umount $lazy $1 >/dev/null 2>&1 # ignore errors first tries
    [ "$(mount | grep " on $1 ")" ] || break
    n=$((n - 1))
    sleep 1
    [ $n -ne 0 ] || umount $lazy $1 # show errors on last try
  done
}

# unprepare_chroot <workdir> [-i]
# globals IAHEAD
unprepare_chroot()
{
  local p i selinuxmp
  eval "$ia_init"
  p="PATH=/usr/sbin:/usr/bin:/sbin:/bin"
  local workdir="$1"

  ia_add "$p chroot $workdir sh -c \"[ -f /etc/mtab.bootcd ] && mv /etc/mtab.bootcd /etc/mtab || rm -f /etc/mtab\""
  selinuxmp="$(sed -E -n -e "s|^selinuxfs\s+(\S+).*$|\1|p" /proc/mounts)"
  if [ "$selinuxmp" ]; then
    ia_add "umount_recursive $workdir$selinuxmp"
  fi
  for i in run dev/pts sys proc dev; do
    ia_add "umount_recursive $workdir/$i"
  done
  ia -c
}

trapfunc()
{
  ia_log "trap CMD=<$CMD>"
  trap "" 0 2 # Ignore Traps
  if [ "$CMD" = "iso" ]; then
    cleanup_iso
  elif [ "$CMD" = "disk" ]; then
    info "trap ignored"
  fi
}

cleanup_iso()
{
  info "--- Cleanup ---"

  # Be sure that VAR and CHANGES have no spaces
  # to not accidently remove anything (for example VAR="/ /var")
  if ! isoneword "$VAR"; then
    echo "Error in VAR <$VAR>" >&2
    exit 1
  fi

  if ! isoneword "$CHANGES"; then
    echo "Error in CHANGES <$CHANGES>" >&2
    exit 1
  fi

  rm -f "$VAR/cdimage"
  rm -rf "$VAR/input_dir"
  rm -rf "$VAR/compressed_dir"
  rm -rf "$VAR/nocompress_dir"
  umount "$VAR/mnt" 2>/dev/null
  [ -d $VAR/mnt ] && rmdir "$VAR/mnt"

  # do not use "rm -r $VAR"
  rm -rf "$CHANGES"
  [ -d $VAR -a ! -f $VAR/cdimage.iso ] && rmdir "$VAR" 2>/dev/null || :
}

split_args()
{
  local i
  local ret
  ret=""
  for i in "$@"; do
    ret="$ret \"$(/bin/echo -E "$i" | ia_easy_backslash)\""
  done
  /bin/echo -E "$ret" | sed "s/^ //"
}
#. /usr/share/shellia/ia
#fun() { echo "fun #=$# 1=<$1> 2=<$2> 3=<$3>"; }
#eval "$ia_init"
#ia_add "fun $(split_args "$@")"
#ia
## call with sh ./bootcd-run.lib "a \" a" "b"
## to get fun #=2 1=<a " a> 2=<b> 3=<>