xorriso-dd-target

#!/bin/sh

# Copyright (c) 2019 - 2020
# Nio Wiklund alias sudodus <nio dot wiklund at gmail dot com>
# Thomas Schmitt <scdbackup@gmx.net>
# Provided under GPL version 2 or later.

# All names of variables and functions begin by "xdt_" in order to facilitate
# the re-use of this code by inclusion or forking and expansion.
# Before using most of the functions it is necessary to run
#   xdt_init ; xdt_reset_job 
# The only function which may be run earlier is xdt_set_lang_c .
# The function xtd_main gets run by the code at the end of this file
# if $no_xorriso_dd_target_run is empty. It implements what xdt_print_usage
# announces.

xdt_print_version() {
  echo "xorriso-dd-target , version 1.5.3 , 2020.02.12.195952"
}


## This obtrusive setting shall make the script safe against exotic locales.
## Supposed to stabilize grep expression interpretation and error messages.
## It is optional but highly advisable.
xdt_set_lang_c() {
  export LANG=C
  export LC_ALL=C
  return 0
}

## This function has to be called before any real work can be done.
xdt_init() {
  # Check whether we are on GNU/Linux
  if uname -s | grep -v '^Linux' >/dev/null
  then
    echo "This program is entirely specialized on Linux kernel device names." >&2
    echo "Found to be on: '$(uname -s)'" >&2
    return 2
  fi

  # Accept sudo-executable commands only in well known directories.
  # (Listed with increasing priority.)
  xdt_lsblk_cmd=
  xdt_dd_cmd=
  xdt_umount_cmd=
  if test "$(whoami)" = "root"
  then
    xdt_sudo_x_dir_list="/usr/bin /bin /usr/sbin /sbin"
  else
    xdt_sudo_x_dir_list="/usr/sbin /sbin /usr/bin /bin"
  fi
  for xdt_i in $xdt_sudo_x_dir_list
  do
    if test -x "$xdt_i"/lsblk
    then
      xdt_lsblk_cmd="$xdt_i"/lsblk
    fi
    if test -x "$xdt_i"/dd
    then
      xdt_dd_cmd="$xdt_i"/dd
    fi
    if test -x "$xdt_i"/umount
    then
      xdt_umount_cmd="$xdt_i"/umount
    fi
  done
  if test -z "$xdt_lsblk_cmd"
  then
    echo "No executable program lsblk found in: $xdt_sudo_x_dir_list" >&2
    return 5
  fi
  return 0
}

xdt_print_usage() {
  echo "usage:  $0 [options] [device_name [device_name ...]]"
  echo
  echo "Looks on GNU/Linux for USB and Memory Card devices and evaluates"
  echo "whether the found devices are plausible targets for image copying."
  echo "If no device names and no -list_all are given, then a plain list of"
  echo "advisable device names is printed to stdout. One per line."
  echo "Device names must not begin by '-' and must be single words. They must"
  echo "not begin by '/dev/'. E.g. 'sdc' is valid, '/dev/sdc' is not valid."
  echo "If device names are given, then they get listed with advice shown."
  echo "If one of the given device names gets not advised, the exit value is 1."
  echo
  echo "The option -plug_test can determine the desired target device by"
  echo "inquiring the system with unplugged device and then with plugged one."
  echo
  echo "Only if option -DO_WRITE is given and -list_all is not, and if exactly"
  echo "one advisable device is listed, it really gets overwritten by the"
  echo "file content of the given -image_file. In this case the exit value"
  echo "is zero if writing succeeded, non-zero else."
  echo "Option -dummy prevents this kind of real action and rather shows the"
  echo "unmount and write commands on stdout."
  echo
  echo "Options:"
  echo " -plug_test         Find the target device by asking the user to press"
  echo "                    Enter when the desired target is _not_ plugged in,"
  echo "                    to then plug it in, and to press Enter again."
  echo "                    This overrides device names and option -list_all."
  echo "                    The found device is then shown with advice, vendor,"
  echo "                    and model. Option -DO_WRITE is obeyed if given."
  echo " -list_all          Print list of all found devices with advice, vendor"
  echo "                    and model. One per line. Ignore any device names."
  echo "                    Ignore -DO_WRITE."
  echo " -list_long         With each line printed by -list_all or a submitted"
  echo "                    device name, let lsblk print info which led to the"
  echo "                    shown reasons."
  echo " -with_vendor_model Print vendor and model with each submitted device"
  echo "                    name."
  echo " -max_size n[M|G|T] Set upper byte size limit for advisable devices."
  echo "                    Plain numbers get rounded down to full millions."
  echo "                    Suffix: M = million, G = billion, T = trillion."
  echo "                    Be generous to avoid problems with GB < GiB."
  echo " -min_size n[M|G|T] Set lower byte size limit for advisable devices."
  echo "                    After processing like with -max_size, one million"
  echo "                    gets added to the size limit."
  echo " -look_for_iso      Demand presence of an ISO 9660 filesystem. If so,"
  echo "                    any further filesystem type is acceptable on that"
  echo "                    device. Else only ISO 9660 and VFAT are accepted."
  echo " -with_sudo         Run '$xdt_lsblk_cmd -o FSTYPE' by sudo."
  echo "                    If no filesystems are detected and the program"
  echo "                    has no superuser power, the device is not advised."
  echo "                    If -DO_WRITE is given, run umount and dd by sudo." 
  echo " -trust_lsblk_udev  Suppress the reason no_fs_while_not_su- if lsblk"
  echo "                    is linked with libudev.so. In this case it is"
  echo "                    likely that lsblk can retrieve FSTYPE even if"
  echo "                    run by a non-priviledged user."
  echo " -image_file PATH   Set the path of the image file which shall be"
  echo "                    written to a device. Its size will be set as"
  echo "                    -min_size."
  echo " -DO_WRITE          Write the given -image_file to the one advisable"
  echo "                    device that is found. If more than one such device"
  echo "                    is found, then they get listed but no writing"
  echo "                    happens. In this case, re-run with one of the"
  echo "                    advised device names to get a real write run."
  echo " -no_pacifier       Do not use dd options to print progress messages"
  echo "                    and to perform synchronized output."
  echo " -dummy             Report the -DO_WRITE actions but do not perform"
  echo "                    them."
  echo " -dummy_force       If a single device name is given, do a run of"
  echo "                    -dummy -DO_WRITE even against the advice of"
  echo "                    this program. This probably shows you ways to"
  echo "                    shoot your own foot."
  echo " -version           Print version text and then end the program."
  echo " -help              Print this text to stdout and then end the program."
  echo "Examples:"
  echo " $0 -with_sudo -list_all"
  echo " $0 sdc"
  echo " $0 -with_sudo -image_file debian-live-10.0.0-amd64-xfce.iso -DO_WRITE -dummy"
  echo " $0 -with_sudo -image_file debian-live-10.0.0-amd64-xfce.iso -DO_WRITE -plug_test"
  echo
  return 0
}

# Roughly convert human readable sizes and plain numbers to 1 / million
xdt_round_down_div_million() {
  sed \
    -e 's/^[0-9][0-9][0-9][0-9][0-9][0-9]$/0/' \
    -e 's/^[0-9][0-9][0-9][0-9][0-9]$/0/' \
    -e 's/^[0-9][0-9][0-9][0-9]$/0/' \
    -e 's/^[0-9][0-9][0-9]$/0/' \
    -e 's/^[0-9][0-9]$/0/' \
    -e 's/^[0-9]$/0/' \
    -e 's/\.[0-9]*//' \
    -e 's/[0-9][0-9][0-9][0-9][0-9][0-9]$//' \
    -e 's/[Mm]$//' \
    -e 's/[Gg]$/000/' \
    -e 's/[Tt]$/000000/' 
  return 0
}

## Check for harmless name or number in program argument
xdt_check_parameter() {
  if test "X$2" = "Xdevice_name"
  then
    if echo "X$1" | grep '[^A-Za-z0-9_/-]' >/dev/null
    then
      echo "SORRY: Given device name contains unexpected character. Ok: [A-za-z0-9_/-]" >&2
      return 12
    elif echo "X$1" | grep '^X-' >/dev/null
    then
      echo "SORRY: Given device name begins by '-' character." >&2
      return 15
    fi
  elif test "X$2" = "Ximage_file"
  then
    if echo "X$1" | grep '[$`[*?<>|&!{\]' >/dev/null
    then
      echo "SORRY: Given image file name contains unexpected character. Not ok: "'[$`[*?<>|&!{\]' >&2
      return 15
    elif echo "X$1" | grep '^X[-(]' >/dev/null
    then
      echo "SORRY: Given image file name begins by problematic character. Not ok: "'[-(]' >&2
      return 15
    fi
  else
    if echo "X$1" | grep -v '^X[0-9][0-9]*[0-9MGTmgt]$' >/dev/null
    then
      echo "SORRY: Number for $2 too short or bad character. Ok: [0-9][0-9MGTmgt]" >&2
      return 14
    fi
  fi
  return 0
}

### Assessing arguments and setting up the job

# Settings
xdt_reset_job() {
  xdt_list_all=
  xdt_do_list_long=
  xdt_show_reasons=
  xdt_look_for_iso=
  xdt_devs=
  xdt_devs_named=
  xdt_max_size=
  xdt_with_vendor_model=
  xdt_with_sudo=
  xdt_image_file=
  xdt_do_write=
  xdt_dummy_run=
  xdt_dummy_force=
  xdt_no_pacifier=
  xdt_do_plug_test=
  xdt_trust_lsblk_udev=

  # Status
  xdt_sudo_cmd=
  xdt_have_su_power=
  xdt_end_after_setup=
  xdt_dev_end=
  xdt_dd_bs="bs=1M"
  xdt_dd_silent=

  return 0
}

## Predict superuser power. Possibly enable sudo with lsblk -o FSTYPE and dd.
## Also predict whether lsblk -o FSTYPE will bring results as non-root.
xdt_predict_su_power() {
  if test "$(whoami)" = "root"
  then
    xdt_have_su_power=y
  elif test -n "$xdt_with_sudo"
  then
    echo "Testing sudo to possibly get password prompting done now:" >&2
    if sudo "$xdt_lsblk_cmd" -h >/dev/null
    then
      echo "sudo $xdt_lsblk_cmd seems ok." >&2
      echo >&2
      xdt_sudo_cmd=sudo
      xdt_have_su_power=y
    else
      echo "FAILURE: Cannot execute program $xdt_lsblk_cmd by sudo" >&2
      return 11
    fi
  fi

  # lsblk linked with libudev.so usually can obtain filesystem info
  # without superuser powers.
  if test -n "$xdt_trust_lsblk_udev"
  then
    if ldd "$xdt_lsblk_cmd" | grep '\blibudev\.so' >/dev/null
    then
      xdt_lsblk_fs_wo_su=y
    fi
  fi
  return 0
}

## Sets xdt_variables according to its arguments
xdt_arg_interpreter() {
  xdt_next_is=
  for xdt_i in "$@"
  do
    # The next_is option parameter readers get programmed by the -options
    if test "$xdt_next_is" = "max_size"
    then
      xdt_check_parameter "$xdt_i" -max_size || return "$?"
      xdt_max_size="$(echo "$xdt_i" | xdt_round_down_div_million)"
      xdt_next_is=
    elif test "$xdt_next_is" = "min_size"
    then
      xdt_check_parameter "$xdt_i" -min_size || return "$?"
      xdt_min_size="$(echo "$xdt_i" | xdt_round_down_div_million)"
      xdt_min_size="$(expr $xdt_min_size + 1)"
      xdt_next_is=
    elif test "$xdt_next_is" = "image_file"
    then
      xdt_check_parameter "$xdt_i" image_file || return "$?"
      xdt_image_file="$xdt_i"
      xdt_min_size="$(stat -c '%s' "$xdt_i" \
                          | xdt_round_down_div_million)"
      if test -z "$xdt_min_size"
      then
        echo "FAILURE: Cannot obtain size of -image_file '$xdt_i'" >&2
        return 13
      else
        xdt_min_size="$(expr $xdt_min_size + 1)"
      fi
      xdt_next_is=
    elif test "X$xdt_i" = "X-list_all"
    then
      xdt_list_all=y
      xdt_with_vendor_model=y
      xdt_show_reasons=y
    elif test "X$xdt_i" = "X-list_long"
    then
      xdt_do_list_long=y
    elif test "X$xdt_i" = "X-plug_test"
    then
      xdt_do_plug_test=y
    elif test "X$xdt_i" = "X-max_size"
    then
      xdt_next_is="max_size"
    elif test "X$xdt_i" = "X-min_size"
    then
      xdt_next_is="min_size"
    elif test "X$xdt_i" = "X-with_vendor_model"
    then
      xdt_with_vendor_model=y
    elif test "X$xdt_i" = "X-look_for_iso"
    then
      xdt_look_for_iso=y
    elif test "X$xdt_i" = "X-trust_lsblk_udev"
    then
      xdt_trust_lsblk_udev=y
    elif test "X$xdt_i" = "X-with_sudo"
    then
      xdt_with_sudo=y
    elif test "X$xdt_i" = "X-image_file"
    then
      xdt_next_is="image_file"
    elif test "X$xdt_i" = "X-dummy"
    then
      xdt_dummy_run=y
    elif test "X$xdt_i" = "X-dummy_force"
    then
      xdt_dummy_run=y
      xdt_do_write=y
      xdt_dummy_force=y
    elif test "X$xdt_i" = "X-DO_WRITE"
    then
      xdt_do_write=y
    elif test "X$xdt_i" = "X-no_pacifier"
    then
      xdt_no_pacifier=y
    elif test "X$xdt_i" = "X-version"
    then
      xdt_print_version
      xdt_end_after_setup=y
      return 0
    elif test "X$xdt_i" = "X-help"
    then
      xdt_print_usage
      xdt_end_after_setup=y
      return 0
    elif echo "X$xdt_i" | grep -v '^X-' >/dev/null
    then
      xdt_check_parameter "$xdt_i" device_name || return "$?"
      xdt_devs_named=y
      xdt_devs="$xdt_devs $xdt_i"
      xdt_show_reasons=y
    else
      echo "$0 : Unknown option: '$xdt_i'" >&2
      echo >&2
      echo "For a help text run: $0 -help" >&2
      return 16
    fi
  done
  xdt_predict_su_power || return "$?"
  # Prepare for using dd pacifier if desired and available
  # Prepare for using silent dd with GPT backup erasure if available
  xdt_dd_bs="bs=1M"
  xdt_dd_silent=
  if test -n "$xdt_dd_cmd"
  then
    if test -z "$xdt_no_pacifier" && \
       "$xdt_dd_cmd" if=/dev/zero of=/dev/null count=1 \
                     bs=1M status=progress oflag=dsync 2>/dev/null
    then
      xdt_dd_bs="bs=1M status=progress oflag=dsync"
    fi
    if "$xdt_dd_cmd" if=/dev/zero of=/dev/null count=1 bs=512 status=none \
                     2>/dev/null
    then
      xdt_dd_silent="status=none"
    fi
  fi
  return 0
}

## Obtain a blank separated list of top-level names which do not look like
## CD, floppy, RAM dev, or loop device.
xdt_collect_devices() {
  "$xdt_lsblk_cmd" -d -n -o NAME \
    | grep -v '^sr[0-9]' \
    | grep -v '^fd[0-9]' \
    | grep -v '^zram[0-9]' \
    | grep -v '^loop[0-9]' \
    | tr '\n\r' '  '
  return 0
}

## Let lsblk print extra info for the given devices
xdt_list_long() {
  if test -z "$xdt_do_list_long"
  then
    return 0
  fi
  $xdt_sudo_cmd "$xdt_lsblk_cmd" -o NAME,SIZE,FSTYPE,TRAN,LABEL \
                    /dev/"$1"
  echo
  return 0
}

## Trying to find the desired device by watching plug-in effects
xdt_plug_in_watcher() {
  # How long to wait for a first device to appear, how long to wait for more
  xdt_wait_span_0=10
  xdt_wait_span_1=5

  xdt_found_devices=
  echo >&2
  echo "Caused by option -plug_test: Attempt to find the desired device" >&2
  echo "by watching it appear after being plugged in." >&2
  echo >&2
  echo "Step 1:" >&2
  echo "Please make sure that the desired target device is plugged _out_ now." >&2
  echo "If it is currently plugged in, make sure to unmount all its fileystems" >&2
  echo "and then unplug it." >&2
  echo "Press the Enter key when ready." >&2
  read xdt_dummy
  xdt_old_device_list=' '$(xdt_collect_devices)' '

# <<< Mock-up to save USB socket wear-off by erasing items from old_device_list
# <<< Their presence in new_device_list will let them appear as fresh plugs
# xdt_old_device_list=' '$(echo -n $xdt_old_device_list | sed -e 's/sdc//')' '

  echo "Found and noted as _not_ desired: $xdt_old_device_list" >&2
  echo >&2
  echo "Step 2:" >&2
  echo "Please plug in the desired target device and then press the Enter key." >&2
  read xdt_dummy
  echo -n "Waiting up to $xdt_wait_span_0 seconds for a new device to be listed ..." >&2
  xdt_end_time="$(expr $(date +'%s') + "$xdt_wait_span_0")"
  while test $(date +'%s') -le "$xdt_end_time"
  do
    xdt_new_device_list=' '$(xdt_collect_devices)' '
    for xdt_i in $xdt_new_device_list
    do
      if echo "$xdt_old_device_list $xdt_found_devices " \
         | grep -F -v ' '"$xdt_i"' ' >/dev/null
      then
        echo " found: $xdt_i" >&2
        xdt_found_devices="$xdt_found_devices $xdt_i"
        xdt_end_time=$(expr $(date +'%s') + "$xdt_wait_span_1")
        echo -n "Now waiting $xdt_wait_span_1 seconds to let it settle ..." >&2
      fi
    done
    sleep 1
    echo -n '.' >&2
  done
  echo >&2
  if test -z "$xdt_found_devices"
  then
    echo "SORRY: No new candidate device was found." >&2
    return 8
  fi
  xdt_num=$(echo $xdt_found_devices | wc -w)
  if test "$xdt_num" -gt 1
  then
    echo "SORRY: More than one new candidate device appeared: $xdt_found_devices" >&2
    return 9
  fi
  echo "Found and noted as desired device: $xdt_found_devices" >&2
  if test -n "$xdt_devs"
  then
    echo "(-plug_test is overriding device list given by arguments: $xdt_devs )" >&2
  fi
  if test -n "$xdt_list_all"
  then
    echo "(-plug_test is overriding -list_all)" >&2
    xdt_list_all=
  fi
  xdt_devs_named=y
  xdt_with_vendor_model=y
  xdt_show_reasons=y
  xdt_devs=$(echo -n $xdt_found_devices)
  echo >&2

  return 0
}

## Evaluation of available devices and suitability
xdt_list_devices() {
  if test -n "$xdt_list_all"
  then
    xdt_devs=
  fi
  if test -z "$xdt_devs"
  then
    # Obtain list of top-level names which do not look like CD, floppy, RAM dev
    xdt_devs=$(xdt_collect_devices)
  fi

  xdt_not_advised=0
  for xdt_name in $xdt_devs
  do
    # Collect reasons
    xdt_yucky=
    xdt_reasons=
    xdt_good_trans=
    xdt_good_fs=
    xdt_bad_trans=
    xdt_bad_fs=

    # Unwanted device name patterns
    if (echo "$xdt_name" | grep '^sd[a-z][1-9]' >/dev/null) \
       || (echo "$xdt_name" | grep '^mmcblk.*p[0-9]' >/dev/null) \
       || (echo "$xdt_name" | grep '^nvme.*p[0-9]' >/dev/null)
    then
      xdt_yucky=y
      xdt_reasons="${xdt_reasons}looks_like_disk_partition- "
    elif echo "$xdt_name" | grep '^sr[0-9]' >/dev/null
    then
      xdt_yucky=y
      xdt_reasons="${xdt_reasons}looks_like_cd_drive- "
    elif echo "$xdt_name" | grep '^fd[0-9]' >/dev/null
    then
      xdt_yucky=y
      xdt_reasons="${xdt_reasons}looks_like_floppy- "
    elif echo "$xdt_name" | grep '^loop[0-9]' >/dev/null
    then
      xdt_yucky=y
      xdt_reasons="${xdt_reasons}looks_like_loopdev- "
    elif echo "$xdt_name" | grep '^zram[0-9]' >/dev/null
    then
      xdt_yucky=y
      xdt_reasons="${xdt_reasons}looks_like_ramdev- "
    fi

    # >>> recognize the device from which Debian Live booted

    # Connection type. Normally by lsblk TRAN, but in case of mmcblk artificial.
    if echo "$xdt_name" | grep '^mmcblk[0-9]' >/dev/null
    then
      xdt_transports="mmcblk"
    elif echo "$xdt_name" | grep -F "/" >/dev/null
    then
      xdt_transports=not_an_expected_name
      xdt_reasons="${xdt_reasons}name_with_slash- "
    else
      xdt_transports=$("$xdt_lsblk_cmd" -n -o TRAN /dev/"$xdt_name")
    fi
    for xdt_trans in $xdt_transports
    do
      if test "$xdt_trans" = "usb" || test "$xdt_trans" = "mmcblk"
      then
        xdt_good_trans="${xdt_trans}+"
      elif test -n "$xdt_trans"
      then
        xdt_bad_trans="$xdt_trans"
        xdt_yucky=y
        if test "$xdt_transports" = "not_an_expected_name"
        then
          xdt_dummy=dummy
        else
          if echo "$xdt_reasons" | grep -F -v "not_usb" >/dev/null
          then
            xdt_reasons="${xdt_reasons}not_usb- "
          fi
        fi
      fi
    done
    if test -z "$xdt_good_trans" && test -z "$xdt_bad_trans"
    then
      xdt_yucky=y
      xdt_reasons="${xdt_reasons}no_bus_info- "
    elif test -z "$xdt_bad_trans"
    then
      xdt_reasons="${xdt_reasons}$xdt_good_trans "
    fi

    # Wanted or unwanted filesystem types
    xdt_fstypes=$($xdt_sudo_cmd "$xdt_lsblk_cmd" -n -o FSTYPE \
                      /dev/"$xdt_name")
    if test "$?" -gt 0
    then
      xdt_fstypes="lsblk_fstype_error"
    fi
    # Get overview of filesystems
    xdt_has_iso=
    xdt_has_vfat=
    xdt_has_other=
    for xdt_fstype in $xdt_fstypes
    do
      if test "$xdt_fstype" = "iso9660"
      then
        xdt_has_iso=y
        if echo "$xdt_good_fs" | grep -F -v "has_$xdt_fstype" >/dev/null
        then
          xdt_good_fs="${xdt_good_fs}has_${xdt_fstype}+ "
        fi
      elif test "$xdt_fstype" = "vfat"
      then
        xdt_has_vfat=y
        if echo "$xdt_good_fs" | grep -F -v "has_$xdt_fstype" >/dev/null
        then
          xdt_good_fs="${xdt_good_fs}has_${xdt_fstype}+ "
        fi
      elif test -n "$xdt_fstype"
      then
        xdt_has_other=y
        if echo "$xdt_bad_fs" | grep -F -v "has_$xdt_fstype" >/dev/null
        then
          xdt_bad_fs="${xdt_bad_fs}has_${xdt_fstype}- "
        fi
      fi
    done
    # Decide whether the found filesystems look dispensible enough
    xdt_reasons="${xdt_reasons}${xdt_good_fs}${xdt_bad_fs}"
    if test "${xdt_bad_fs}${xdt_good_fs}" = "" \
       && test -z "$xdt_have_su_power" && test -z "$xdt_lsblk_fs_wo_su"
    then
      xdt_yucky=y
      xdt_reasons="${xdt_reasons}no_fs_while_not_su- "
    elif test -n "$xdt_look_for_iso"
    then
      if test -n "$xdt_has_iso"
      then
        xdt_reasons="${xdt_reasons}look_for_iso++ "
      else
        xdt_yucky=y
        xdt_reasons="${xdt_reasons}no_iso9660- "
      fi
    elif test -n "$xdt_has_other"
    then
      xdt_yucky=y
    fi
  
    # Optional tests for size
    if test -n "$xdt_max_size" || test -n "$xdt_min_size"
    then
      xdt_dev_bytes=$("$xdt_lsblk_cmd" -n -b -o SIZE /dev/"$xdt_name" | head -1)
      xdt_size=$(echo "$xdt_dev_bytes" | xdt_round_down_div_million)
      if test -z "$xdt_size"
      then
        xdt_yucky=y
        xdt_reasons="${xdt_reasons}lsblk_no_size- "
      fi
    fi
    if test -n "$xdt_max_size" && test -n "$xdt_size"
    then
      if test "$xdt_size" -gt "$xdt_max_size"
      then
        xdt_yucky=y
        xdt_reasons="${xdt_reasons}size_too_large- "
      fi
    fi
    if test -n "$xdt_min_size" && test -n "$xdt_size"
    then
      if test "$xdt_size" -lt "$xdt_min_size"
      then
        xdt_yucky=y
        xdt_reasons="${xdt_reasons}size_too_small- "
      fi
    fi
  
    # Now decide overall and report
    xdt_descr=
    if test -n "$xdt_with_vendor_model"
    then
      xdt_descr=": "$("$xdt_lsblk_cmd" -n -o VENDOR,MODEL \
                          /dev/"$xdt_name" | tr '\n\r' '  ' | tr -s ' ')
    fi
    if test -n "$xdt_yucky"
    then
      if test -n "$xdt_show_reasons"
      then
        echo "$xdt_name : NO  : $xdt_reasons$xdt_descr"
        xdt_list_long "$xdt_name"
      fi
      xdt_not_advised=1
    else
      if test -n "$xdt_show_reasons"
      then
        echo "$xdt_name : YES : $xdt_reasons$xdt_descr"
        xdt_list_long "$xdt_name"
      else
        echo "$xdt_name"
      fi
    fi
  done
  return 0;
}

## Puts list of mounted (sub-)devices of $1 into $mounted_devs
xdt_list_mounted_of() {
  xdt_partitions=$("$xdt_lsblk_cmd" -l -n -p -o NAME /dev/"$1" \
                       | grep -v '^'/dev/"$1"'$' \
                       | tr '\n\r' '  ')
  xdt_mounted_devs=
  for xdt_i in /dev/"$1" $xdt_partitions
  do
    # Show the found mount lines and add their device paths to list
    xdt_mount_line=$(mount | grep '^'"$xdt_i"' ')
    if test -n "$xdt_mount_line"
    then
      echo "  $xdt_mount_line"
      xdt_mounted_devs="$xdt_mounted_devs $xdt_i"
    fi
  done
  return 0
}

## Unmount xdt_mounted_devs (maybe filled by xdt_list_mounted_of)
## $1 : base device name
xdt_unmount() {
  if test -z "$xdt_mounted_devs"
  then
    return 0
  fi

  for xdt_i in $xdt_mounted_devs
  do
    if test -n "$xdt_dummy_run"
    then
      echo "  $xdt_sudo_cmd $xdt_umount_cmd $xdt_i"
    elif $xdt_sudo_cmd "$xdt_umount_cmd" "$xdt_i"
    then
      echo "Unmounted: $xdt_i"
    else
      echo "FAILURE: Non-zero exit value with:  $xdt_sudo_cmd $xdt_umount_cmd $xdt_i" >&2
      return 7
    fi
  done

  # Check again if any mount points still exist
  if test -z "$xdt_dummy_run"
  then
    xdt_list_mounted_of "$1"
    if test -n "$xdt_mounted_devs"
    then
      echo "FAILURE: $xdt_sudo_cmd $xdt_umount_cmd could not remove all mounts: $xdt_mounted_devs" >&2
      return 7
    fi
  fi
  return 0
}

## Does the work of unmounting and dd-ing
## $1 : image file path
## $2 : base device name
xdt_write_image() {

  if test -z "$xdt_umount_cmd"
  then
    echo "No executable program umount found in: $xdt_sudo_x_dir_list" >&2
    return 6
  fi
  echo "Looking for mount points of $2:"
  xdt_mounted_devs=
  xdt_list_mounted_of "$2"

  if test -n "$xdt_dummy_force"
  then
    echo "AGAINST THE ADVICE BY THIS PROGRAM, a daring user could do:"
    xdt_dummy_run=y
  elif test -n "$xdt_dummy_run"
  then
    echo "Would do if not -dummy:"
  fi

  xdt_unmount "$2" || return "$?"

  if test -z "$xdt_dd_cmd"
  then
    echo "No executable program dd found in: $xdt_sudo_x_dir_list" >&2
    return 6
  fi

  # Erase possible GPT backup table at end of device
  # if expr can properly divide device size by 512
  xdt_dev_bytes=$("$xdt_lsblk_cmd" -n -b -o SIZE /dev/"${2}" | head -1)
  if test -n "$xdt_dev_bytes"
  then
    xdt_dev_end=$(expr "$xdt_dev_bytes" / 512 2>/dev/null)
    if test "$(expr "$xdt_dev_end" '*' 512 2>/dev/null)" = "$xdt_dev_bytes"
    then
      xdt_dev_end=$(expr "$xdt_dev_end" - 1)
    else
      xdt_dev_end=
    fi
  fi
  xdt_gpt_erase_line="$xdt_sudo_cmd $xdt_dd_cmd if=/dev/zero of=/dev/'${2}' bs=512 seek='$xdt_dev_end' count=1 $xdt_dd_silent"

  xdt_copy_line="$xdt_sudo_cmd $xdt_dd_cmd if='${1}' of=/dev/'${2}' $xdt_dd_bs ; sync"
  if test -n "$xdt_dummy_run"
  then
    if test -n "$xdt_dev_end"
    then
      echo "  $xdt_gpt_erase_line"
    fi
    echo "  $xdt_copy_line"
  else
    echo "Performing:"
    if test -n "$xdt_dev_end"
    then
      echo "  $xdt_gpt_erase_line"
      $xdt_sudo_cmd "$xdt_dd_cmd" if=/dev/zero of=/dev/"${2}" bs=512 seek="$xdt_dev_end" count=1 $xdt_dd_silent
    fi
    echo "  $xdt_copy_line"
    $xdt_sudo_cmd "$xdt_dd_cmd" if="${1}" of=/dev/"${2}" $xdt_dd_bs
    xdt_ret="$?"
    sync
    if test "$xdt_ret" -ne 0
    then
      echo "FAILURE: $xdt_sudo_cmd $xdt_dd_cmd was not successful" >&2
      return 18
    fi
  fi

  if test -n "$xdt_dummy_force"
  then
    echo "BE SMART. BE CAUTIOUS. BEWARE."
  fi
  return 0
}

## Inspects the result of listing, decides whether writing is advisable,
## and starts the write run
xdt_decide_writing()
{
  xdt_with_vendor_model=
  xdt_show_reasons=
  xdt_candidates=$(xdt_list_devices | tr '\n\r' '  ')
  xdt_num_cand=$(echo $xdt_candidates | wc -w)
  xdt_num_devs=$(echo $xdt_devs| wc -w)
  if test -n "$xdt_dummy_force" && test "$xdt_num_devs" -ne 1
  then
    echo "SORRY: Refusing -dummy_force with not exactly one device given." >&2
    return 10
  fi
  if test -n "$xdt_dummy_force" && test -n "$xdt_dummy_run" \
     && test "$xdt_num_cand" -ne 1 
  then
    # -dummy_force in a situation where the program would normally refuse
    echo
    echo "Overriding any advice because of -dummy_force"
    xdt_candidates="$xdt_devs"
    xdt_num_cand=1
  elif test -n "$xdt_dummy_force"
  then
    # Downgrade -dummy_force to -dummy in order to avoid the ugly warning
    xdt_dummy_force=
    xdt_dummy_run=y
  fi
  if test "$xdt_num_cand" -eq 1
  then
    if test -n "$xdt_image_file"
    then
      if test -n "$xdt_do_plug_test"
      then
        echo >&2
        echo "Step 3:" >&2
        if test -n "$xdt_dummy_run"
        then
          echo "This would be the last chance to abort. Enter the word 'yes' to see -dummy report." >&2
        else
          echo "Last chance to abort. Enter the word 'yes' to start REAL WRITING." >&2
        fi
        read xdt_dummy
        if test "X$xdt_dummy" = "Xyes" || test "X$xdt_dummy" = "X'yes'" \
           || test "X$xdt_dummy" = 'X"yes"'
        then
          xdt_dummy=dummy
        else
          echo "WRITE RUN PREVENTED by user input '$xdt_dummy'." >&2
          return 17  
        fi
      fi
      xdt_write_image "$xdt_image_file" $xdt_candidates || return "$?"
    else
      xdt_candidates=$(echo $xdt_candidates)
      if test -n "$xdt_dummy_run"
      then
        echo "Would simulate writing to /dev/$xdt_candidates if an -image_file were given."
      else
        echo "Would write to /dev/$xdt_candidates if an -image_file were given."
      fi
      return 0
    fi
  elif test "$xdt_num_cand" -gt 1
  then
    echo "WILL NOT WRITE ! More than one candidate found for target device:" >&2
    xdt_show_reasons=y
    xdt_with_vendor_model=y
    xdt_devs="$xdt_candidates"
    xdt_list_devices >&2
    echo "HINT: Unplug the unwanted devices from the machine," >&2
    echo "      or work with option -plug_test," >&2
    echo "      or add the desired name out of {$(echo $xdt_candidates | sed -e 's/ /,/g')} as additional argument." >&2
    return 3
  else
    if test -n "$xdt_devs_named"
    then
      echo "NO CANDIDATE FOR TARGET DEVICE AMONG THE GIVEN NAMES !" >&2
    else
      echo "NO CANDIDATE FOR TARGET DEVICE FOUND !" >&2
    fi
    echo "Overall available devices:" >&2
    xdt_list_all=y
    xdt_list_long=
    xdt_show_reasons=y
    xdt_with_vendor_model=y
    xdt_list_devices >&2
    return 4
  fi
  return 0
}

## The main function which runs the others in standalone mode
xdt_main()
{
  xdt_set_lang_c
  xdt_init || return "$?"
  
  xdt_reset_job
  xdt_arg_interpreter "$@" || return "$?"
  if test -n "$xdt_end_after_setup"
  then
    return 0
  fi
  
  if test -n "$xdt_do_plug_test"
  then
    xdt_plug_in_watcher || return "$?"
  fi
  
  xdt_list_devices || return "$?"

  if test -z "$xdt_list_all" && test -n "$xdt_do_write"
  then
    xdt_decide_writing || return "$?"
  fi
  
  if test -n "$xdt_devs_named"
  then
    return $xdt_not_advised
  fi
  return 0
}

if test -z "$no_xorriso_dd_target_run"
then
  xdt_main "$@" || exit "$?"
fi