# vim: set filetype=sh :
#        file: /usr/share/bootcd/bootcdmk2diskconf.lib
#   copyright: Bernd Schumacher <bernd.schumacher@hpe.com> (2001-2020)
#     license: GNU General Public License, version 3
# description: bootcdmk2diskconf.lib - functions needed by bootcd scripts


# label2dev <label>
label2dev()
{
  # ignore if LABEL does not exist
  mount -vnf LABEL=$1 2>/dev/null | # -> /ram1/dev/sda1 on /mnt/boot type ext3 (rw)
    gawk '{print $1}' | # -> /ram1/dev/sda1
    sed "s|/ram[^/]*||" # /dev/sda1
}

# function: labelsed -- remove labels by real devices
# get: stdin -- stream
labelsed()
{
  local T T1 L j i
  T="$(cat)"
  dbg "labelsed INPUT=<$T>"
  L="$(echo "$T" | sed -n "s/.*LABEL=\([^:[:space:]]\+\).*/\1/p" | sort -n)"
  for i in $L; do
    dbg "labelsed search for label <$i>"
    j="$(echo "$RILABEL" | grep ":$i$" | gawk -F: '{print $1}')"
    dbg "labelsed found <$j>"
    T1="$(echo "$T" | sed -e "s|LABEL=$i:|$j:|" -e "s|LABEL=$i$|$j|")"
    T="$T1"
  done
  dbg "labelsed OUTPUT=<$T>"
  echo "$T"
}
#echo "   Precondition: RILABEL-Line1=\"/dev/sda1:/\" RILABEL-Line2=\"/dev/sda2:SWAP-sda2\""
#echo "          Input: Line1=\"LABEL=/:/\" Line2=\"LABEL=SWAP-sda2\""
#echo "       Expected: Line1=\"/dev/sda1:/\" Line2=\"/dev/sda2\""
#echo "labelsed Output:"
#echo "LABEL=/:/
#LABEL=SWAP-sda2" | DEBUG="" RILABEL="/dev/sda1:/
#/dev/sda2:SWAP-sda2" labelsed
#exit 0

# function: uuidsed -- remove uuids by real devices
# get: stdin -- stream
uuidsed()
{
  local O N i j

  O="$(cat)"
  for i in $(echo "$RIUUID" | sed "s/^[^:]\+://"); do
    j="$(echo "$RIUUID" | sed -n "s/:$i$//p")"
    dbg "i=<$i> j=<$j>"
    N="$(echo "$O" | sed "s|$i|UUID!$j|g")"
    O="$N"
  done
  echo "$O"
}
#riuuid="/dev/sda1:35096edc-998f-4af8-b971-a5195937492f"
#echo "Precondition: RIUUID=\"$riuuid\""
#inp="UUID=35096edc-998f-4af8-b971-a5195937492f:/boot"
#echo "Input=<$inp> Expected:"
#echo "UUID=UUID!/dev/sda1:/boot Output:"
#echo "$inp" | DEBUG="" RIUUID="/dev/sda1:35096edc-998f-4af8-b971-a5195937492f" uuidsed
#inp="search --no-floppy --fs-uuid --set 35096edc-998f-4af8-b971-a5195937492f:/boot"
#echo "Input=<$inp> Expected:"
#echo "search --no-floppy --fs-uuid --set UUID!/dev/sda1:/boot Output:"
#echo "$inp" | DEBUG="" RIUUID="/dev/sda1:35096edc-998f-4af8-b971-a5195937492f" uuidsed
#exit 0

# rmvg()
rmvg()
{
  T="$(cat)"
  dbg "rmvg INPUT=<$T>"
  for i in $CIVG; do
    dbg "rmvg $i"
    # i=vg_rh6 would remove /dev/mapper/vg_rh6-*
    # i=vg00 would remove /dev/vg00/*
    # i=bootcd-lvm-stretch-vg would remove /dev/mapper/bootcd--lvm--stretch--vg-*
    T1="$(echo "$T" | grep -v -e "/dev/$i\>" -e "/dev/mapper/$(echo "$i"| sed "s/-/--/g")-")"
    T="$T1"
  done
  dbg "rmvg OUTPUT=<$T>"
  echo "$T"
}

# readinfo <system-mount-point> - define RIxxx
# readinfo - Read Information from system and write it in RIxxx variables
#   <SRCDISK>  If set, Read Information from the system mounted on <SRCDISK>.
readinfo()
{
  local MNT
  [ "$1" = "/" ] && MNT="" || MNT="$1"

  RIFSTAB="$(cat $MNT/etc/fstab|ia_easy_backslash)"
  RIGRUB="$(for i in $MNT/boot/grub/menu.lst $MNT/boot/grub/grub.conf $MNT/boot/boot/grub/menu.lst \
    $MNT/boot/boot/grub/grub.conf; do if [ -s $i ]; then cat $i|ia_easy_backslash; break; fi; done)"
  RIGRUB2="$(for i in $MNT/boot/grub/grub.cfg $MNT/boot/boot/grub/grub.cfg \
    $MNT/boot/grub2/grub.cfg $MNT/boot/boot/grub2/grub.cfg ; do \
    if [ -s $i ]; then cat $i|ia_easy_backslash; break; fi; done)"
  RILV="$([ "$(type lvdisplay 2>&1 | grep "not found")" ] ||
    (lvdisplay --ignorelockingfailure --units m -C | tail -n +2 |
    sed "s/^[[:space:]]*//" | gawk '{printf("%s:%s:%d\n",$1,$2,$4)}'))"
  RIPV="$([ "$(pvdisplay --ignorelockingfailure 2>/dev/null)" ] &&
    (pvdisplay --ignorelockingfailure -C | tail -n +2 |
    gawk '{printf("%s:%s\n",$1,$2)}'))"
  # read from df
  RIDF_EXCLUDES="-e ^/dev/shm.*/dev/shm" # exclude this filesystems from RIDF (readinfo from df)
  RIDF="$(df -lPm | grep -e "^/dev/" -e "^LABEL=" | grep -v $RIDF_EXCLUDES |
    gawk '{printf("%s:%s\n",$1,$2)}')"
  RILABEL="$(for i in $(echo "$RIFSTAB" |
    sed -n "s/.*LABEL=\([^[:space:]]\+\).*/\1/p" | sort -n); do
      echo "$(label2dev $i):$i"
    done)"
  # RIUUID="/dev/sda1:35096ed...5492f<RETURN>/dev/sda2:1PTfZ5...ZARL1"
  RIUUID="$(for i in $(echo "$RIFSTAB" |
    sed -n "s/.*UUID=\([^[:space:]]\+\).*/\1/p" | sort -n); do
      echo "$(blkid -U $i):$i"
    done)"
  RIPARTITION="$(cat /proc/partitions | tail -n +3|
    gawk '{printf("/dev/%s:%d\n",$4,$3/1024)}';
    sfdisk -s | grep -v "^total" |
    gawk '{printf("%s%d\n",$1,$2/1024)}') | sort -u)"
  # actually only raid1 is supported
  RIMD="$(if [ -f /proc/mdstat ]; then cat /proc/mdstat |
    sed -n "s/^\(\S\+\)\s\+:\s*active\s\+raid1\s/\1 raid1 /p" |
    sed "s/[[0-9]\+]//g"; else :; fi)"
}

uuidcut()
{
   sed "s/UUID=UUID!//g"
}

# calcinfo - calculate CIxxx from RIxxx
# Calculate Information variables CIxxx from Read Information variables RIxxx
calcinfo()
{
  local i j

  dbg 1 RI "RIFSTAB=\"$RIFSTAB\""
  dbg 3 RI "RIGRUB=\"$RIGRUB\""
  dbg 3 RI "RIGRUB2=\"$RIGRUB2\""
  dbg 1 RI "RILV=\"$RILV\""
  dbg 1 RI "RIPV=\"$RIPV\""
  dbg 1 RI "RIDF=\"$RIDF\""
  dbg 1 RI "RILABEL=\"$RILABEL\""
  dbg 1 RI "RIUUID=\"$RIUUID\""
  dbg 1 RI "RIPARTITION=\"$RIPARTITION\""
  dbg 1 RI "RIMD=\"$RIMD\""

  CIVG="$(echo "$RILV" | gawk -F: '{print $2}' | sort -u)"

  CISWAP="$(echo "$RIFSTAB" | grep -e "^/dev/" -e "^LABEL=" -e "^UUID=" |
    grep "\<swap\>" |gawk '{print $1}' | labelsed | uuidsed | uuidcut )"

  CIFS="$(echo "$RIFSTAB"| eval "$MOUNTGREP" | gawk '{printf("%s:%s:%s\n",$1,$2,$3)}' | labelsed | uuidsed | uuidcut)"

  # CIPART calculation
  #
  # Exp1: CIFS="/dev/hda2:/:ext4<RETURN>/dev/hda5:/home:ext2" CISWAP="/dev/hda3" RIPV=""
  #       => CIPART=</dev/hda2<RETURN>/dev/hda3<RETURN>/dev/hda5>
  # Exp2: CIFS="/dev/VolGroup00/LogVol00:/:ext4<RETURN>/dev/sda1:/boot:ext4"
  #       CISWAP="/dev/VolGroup00/LogVol01" RIPV="/dev/sda2:VolGroup00"
  #       => CIPART="/dev/sda1<RETURN>/dev/sda2"
  # Exp3: CIFS="/dev/sda1:/:ext4" CISWAP="/dev/sda2" RIPV=""
  #       => CIPART="/dev/sda1<RETURN>/dev/sda2"
  # Exp4: CIFS="/dev/VolGroup01/LogVol00:/:ext4<RETURN>/dev/sda1:/boot:ext4"
  #       CISWAP="/dev/VolGroup01/LogVol01"
  #       RIPV="/dev/sda2:VolGroup01<RETURN>/dev/sdb1:VolGroup01<RETURN>/dev/sdc1:VolGroup01"
  #       => CIPART="/dev/sda1<RETURN>/dev/sda2<RETURN>/dev/sdb1<RETURN>/dev/sdc1"
  #
  # Exp5: CIFS="/dev/mapper/vg_rh6-lv_root:/:ext4<RETURN>/dev/sda1:/boot:ext4"
  #       CISWAP="/dev/mapper/vg_rh6-lv_swap"
  #       RIPV="/dev/sda2:vg_rh6<RETURN>/dev/sda2"
  #       => CIPART="/dev/sda1<RETURN>/dev/sda2"
  #
  # Exp6: DEBUG CIFS="/dev/mapper/bootcd--lvm--stretch--vg-root:/:ext4<RETURN>/dev/vda1:/boot:ext2"
  #       CISWAP="/dev/mapper/bootcd--lvm--stretch--vg-swap_1"
  #       RIPV="/dev/vda5:bootcd-lvm-stretch-vg"
  #       => CIPART="/dev/vda1<RETURN>/dev/vda5"
  #
  # add   space  for dash ;-)


  CIPART="$( (echo "$CIFS" | gawk -F: '{print $1}'; echo "$CISWAP";
    echo "$RIPV" | gawk -F: '{print $1}') | rmvg | sort -u)"

  # CIDISK calculation
  #
  # Exp1: CIPART=</dev/hda2<RETURN>/dev/hda3<RETURN>/dev/hda5>
  #       CIDISK=</dev/hda:DISK0>
  # Exp2: CIPART=</dev/sda1<RETURN>/dev/sda2>
  #       CIDISK=</dev/sda:DISK0>
  # Exp3: CIPART=</dev/sda1<RETURN>/dev/sda2<RETURN>/dev/sdb1<RETURN>/dev/sdc1>
  #       CIDISK=</dev/sda:DISK0<RETURN>/dev/sdb:DISK1<RETURN>/dev/sdc:DISK2>
  # Exp4: CIPART=</dev/mapper/3600508b1001c9e14b850ec3afd0d1fccp1<RETURN>
  #               /dev/mapper/3600508b1001c9e14b850ec3afd0d1fccp2<RETURN>
  #               /dev/mapper/nnm-pkg>
  #       CIDISK=</dev/mapper/3600508b1001c9e14b850ec3afd0d1fcc:DISK0<RETURN>
  #               /dev/mapper/nnm-pkg:DISK1>
  # Exp5: CIPART=</dev/md0>
  #       RIMD=<md0 raid1 sda1 sdb1>
  #       CIDISK=</dev/sda:DISK0<RETURN>/dev/sdb:DISK1>
  #       CIMD="md0:raid1:sda1:sdb1:MD0"

  CIDISK=""
  CIMD=""
  for i in $(echo "$CIPART" | sed "s/p*[123456789][[:digit:]]*$//"|uniq); do
    t="$(echo "$RIMD" | grep "^$(basename $i) ")"
    if [ "$t" ]; then
      CIDISK="$(echo "$CIDISK"; echo "$t" | gawk '{printf("/dev/%s\n/dev/%s\n",$3,$4)}')"
      CIMD="$(echo "$CIMD"; echo "$t" | sed "s/ /:/g")"
    else
      CIDISK="$(echo "$CIDISK" ; echo "$i")"
    fi
  done

  CIDISK="$(
    j=0
    for i in $(echo "$CIDISK" | uniq); do
      echo "$i:DISK$j"
      j=$(($j+1))
    done
  )"

  CIMD="$(
    j=0
    for i in $(echo "$CIMD" | uniq); do
      echo "$i:MD$j"
      j=$(($j+1))
    done
  )"

  dbg 1 CI "CIVG=\"$CIVG\""
  dbg 1 CI "CISWAP=\"$CISWAP\""
  dbg 1 CI "CIFS=\"$CIFS\""
  dbg 1 CI "CIPART=\"$CIPART\""
  dbg 1 CI "CIDISK=\"$CIDISK\""
  dbg 1 CI "CIMD=\"$CIMD\""
}

parttrans()
{
  local i dev dsk b_g T T1

  b_g=""
  if [ "${1:-}" = "--bootcd_global" ]; then
    b_g=" "
    shift
  fi

  T="$(cat)"
  dbg 5 parttrans "parttrans start T=<$T>"

  if [ ! "$no_parttrans" ]; then
    for i in $CIDISK; do
      # i=/dev/sda:DISK1 -> dev=/dev/sda dsk=DISK1
      dev="$(echo "$i" | gawk -F: '{print $1}')"
      dsk="$(echo "$i" | gawk -F: '{print $2}')"

      T1="$(echo "$T" | sed "s|${dev}p*\>|$dsk|")"
      if [ "$b_g" ]; then
        b_g="$b_g $(echo "$T1" | sed -n "s|.*${dev}p*\([[:digit:]]\+\).*|${dsk}P\1|p")"
        T="$(echo "$T1" | sed "s|${dev}p*\([[:digit:]]\+\)|\$${dsk}P\1|")"
      else
        T="$(echo "$T1" | sed "s|${dev}p*\([[:digit:]]\+\)|${dsk}P\1|")"
      fi
    done
  fi
  b_g="$(for i in $b_g; do echo "$i"; done | sort -u)"
  if [ "$b_g" ]; then
    T1="  bootcd_global"
    for i in $b_g; do T1="$T1 $i"; done
    T="$(echo "$T1"; echo "$T")"
  fi
  [ "$T" ] && echo "$T"
  dbg 5 parttrans "parttrans end T=<$T>"
}

trans()
{
  echo "$1"  | sed "$PARTTRANS"
}

mapperlv2lv()
{
  T="$1"
  for i in $VG; do
    T1="$(echo "$T" | sed "s|/dev/mapper/$i-|/dev/$i/|")"
    T="$T1"
  done
  echo "$T"
}

template()
{
  [ -f ./bootcd2disk.conf ] && cat bootcd2disk.conf || cat /usr/share/bootcd/bootcdmk2disk.conf
}

# sfdisk4grub2
# change sfdisk created by print2diskconf and
# insert space for MBR before first partition
sfdisk4grub2()
{
  local line position megabytes sectors a b r

  a="$(cat)"
  # only change primitive configs
  # do not change if unit is already specified
  # do only change if every line start with "," or ";"
  r="
"
  b="unit: sectors$r$r$(
    position=2048
    echo "$a" | while read line; do
      if [ "$line" = "" ]; then
        :
      elif [ $(echo "$line" | grep "^,[[:digit:]]\+$") ]; then
        megabytes="$(echo "$line" | sed "s/^,\([[:digit:]]\+\)$/\1/")"
        sectors="$(($megabytes * 2048))"
        echo "$position,$sectors"
        position="$(($position + $sectors))"
      elif [ "$line" = ",,E" ]; then
        echo "$position,,E"
        position="$(($position + 1))"
      elif [ "$line" = ";" -o "$line" = "0,0" ]; then
        echo "$line"
      else
        echo "sfdisk4grub2: no change because of line=<$line>"
        return
      fi
    done
  )"

  if [ "$(echo "$b" | grep "no change")" ]; then
    dbg "$(echo "$b" | grep "no change")"
    echo "$a"
  else
    echo "$b"
  fi
}
#. ./bootcd-run.lib
#a="$(echo -e ",18026\n,14998\n,1027\n,,E\n;")"
#b="$(echo -e "unit: sectors\n\n2048,36917248\n36919296,30715904\n67635200,2103296\n69738496,,E\n;")"
#c="$(echo "$a" | sfdisk4grub2)"
#[ "$b" = "$c" ] && echo "ok" || echo "Error: output=<$c> expected=<$b>"
#a="$(echo -e "unchangeable")"
#b="$(echo -e "unchangeable")"
#c="$(echo "$a" | sfdisk4grub2)"
#[ "$b" = "$c" ] && echo "ok" || echo "Error: output=<$c> expected=<$b>"
#a="$(echo -e ",101\n;")"
#b="$(echo -e "unit: sectors\n\n2048,206848\n;")"
#c="$(echo "$a" | sfdisk4grub2)"
#[ "$b" = "$c" ] && echo "ok" || echo "Error: output=<$c> expected=<$b>"
#a="$(echo -e ",19711\n,,E\n0,0\n0,0\n;")"
#b="$(echo -e "unit: sectors\n\n2048,40368128\n40370176,,E\n0,0\n0,0\n;")"
#c="$(echo "$a" | sfdisk4grub2)"
#[ "$b" = "$c" ] && echo "ok" || echo "Error: output=<$c> expected=<$b>"
#exit 0

# calcprint - calculate variables for printing: PIMOUNT, PIUMOUNT
calcprint()
{
  local SORTCIFS

  # CIFS="<devpath>:<mountpoint>:<fstyp>\n..."
  # Sort it with length of <mountpoint> for right mount order
  SORTCIFS=$(for i in $CIFS; do
    echo "$(echo "$i" | gawk -F: '{print $2}'|wc -c):$i" | sort -n
  done)

  # SORTCIFS="<mountpointlen>:<devpath>:<mountpoint>\n..."
  PIMOUNT="bootcd_mount()
{
$(for i in $SORTCIFS; do
  x="$(echo "$i" | gawk -F: '{print $2}')"
  y="$(echo "$i" | gawk -F: '{print $3}')"
  [ "$y" != "/" ] || y=""
  echo "  mkdir -p \$1$y; mount $x \$1$y"
done | parttrans --bootcd_global)
}"

  PIUMOUNT="bootcd_umount()
{
$(for i in $(echo "$SORTCIFS" | sort -nr); do
  x="$(echo "$i" | gawk -F: '{print $3}')"
  [ "$x" != "/" ] || x=""
  echo "  umount \$1$x"
done)
}"

  dbg "PIMOUNT=\"$PIMOUNT\""
  dbg "PIUMOUNT=\"$PIUMOUNT\""
}

print2diskconf()
{
  cat <<END
# bootcd2disk.conf - automatically created by bootcdmk2diskconf
END

  printbefore_bootcd2disk_DISKhash
  for i in $CIDISK; do
    # i=/dev/sda:DISK1 -> dev=/dev/sda dsk=DISK1
    dev="$(echo "$i" | gawk -F: '{print $1}')"
    dsk="$(echo "$i" | gawk -F: '{print $2}')"
    echo "ORIG_$dsk=\"$dev\""
  done

  for i in $CIDISK; do
    # i=/dev/sda:DISK1 -> dev=/dev/sda dsk=DISK1
    dev="$(echo "$i" | gawk -F: '{print $1}')"
    dsk="$(echo "$i" | gawk -F: '{print $2}')"
    if [ "$exactdisks" ]; then
      echo "$dsk=\"$dev\""
    else
      echo "$dsk=\"auto\""
    fi
  done

  printbefore_bootcd2disk_LVMGRP
  echo "LVMGRP=\"$(
  for i in $(echo "$RIPV" | gawk -F: '{print $2}' | sort -u); do
    echo "$i$(echo "$RIPV" | grep ":$i$" | gawk -F: '{printf(" %s",$1)}' |
      parttrans)"
  done)\""

  printbefore_bootcd2disk_LVMVOL
  echo "LVMVOL=\"$(
  for i in $RILV; do
    echo "$(echo "$i" | gawk -F: '{printf("%s %s %s\n", $1,$3,$2)}')"
  done)\""

  printbefore_bootcd2disk_ALLOWEDDISKS
  cat <<END
ALLOWEDDISKS=""
END

  printbefore_bootcd2disk_SFDISKhash
  for i in $CIDISK; do
    # i=/dev/cciss/c0d0:DISK0 -> x=/dev/cciss/c0d0 y=0
    x="$(echo "$i" | gawk -F: '{print $1}')"
    y="$(echo "$i" | gawk -F: '{print $2}' | sed "s/DISK//")"
    echo "SFDISK$y=\"$(
    # n is number of partition, pn is the size of partition n
    # m and pm are the same info for the following partition
    n=0
    while :; do
      # RIPARTITION="/dev/cciss/c0d0p1:101\n/dev/cciss/c0d0p2:34624"
      # -> n=1, m=2, pn=101, pm=34624  -> n=2, m=3, pn=34624 pm=
      n=$(($n+1))
      m=$(($n+1))
      pn="$(echo "$RIPARTITION" | grep "^${x}p*${n}:" | gawk -F: '{print $2}')"
      if [ ! "$pn" ]; then
        if [ "$n" = "1" ]; then
          pn=0 # if a disk is used as a whole we set size of partition1 to 0
          echo ",0"
          break
        else
          echo "bootcdmk2diskconf: FATAL Unknown Error" >&2
          exit 1
        fi
      fi
      # Extended Partition
      if [ "$pn" -eq 0 -a "$n" -lt 5 ]; then
        echo ",,E"
        n=$(($n+1))
        m=$(($n+1))
        # if there are unsed first four partitions fill them
        while [ $n -lt 5 ]; do
          echo "0,0"
          n=$(($n+1))
          m=$(($n+1))
        done
        pn="$(echo "$RIPARTITION" | grep "^${x}p*${n}:" | gawk -F: '{print $2}')"
      fi
      pm="$(echo "$RIPARTITION" | grep "^${x}p*${m}:" | gawk -F: '{print $2}')"
      if [ "$pm" ]; then
        echo ",$pn"
      else
        if [ "$samesize" ]; then
          echo ",$pn"
        else
          echo ";"
        fi
        break
      fi
    done |
    if [ "$RIGRUB2" ]; then
      sfdisk4grub2
    else
      cat
    fi)\""
  done

  printbefore_bootcd2disk_VFAT
  cat <<END
VFAT=""
END

  printbefore_bootcd2disk_EXT2FS
  # Catch everything not ext3, ext4 and not xfs
  echo "EXT2FS=\"$(echo "$CIFS" | grep -v -e ":ext3" -e ":ext4" -e ":xfs" | gawk -F: '{print $1}' | parttrans)\""

  printbefore_bootcd2disk_EXT3FS
  echo "EXT3FS=\"$(echo "$CIFS" | grep ":ext3" | gawk -F: '{print $1}' | parttrans)\""

  printbefore_bootcd2disk_EXT4FS
  echo "EXT4FS=\"$(echo "$CIFS" | grep ":ext4" | gawk -F: '{print $1}' | parttrans)\""

  printbefore_bootcd2disk_XFS
  echo "XFS=\"$(echo "$CIFS" | grep ":xfs" | gawk -F: '{print $1}' | parttrans)\""

  printbefore_bootcd2disk_SWAP
  echo "SWAP=\"$(echo "$CISWAP" | parttrans)\""

  printbefore_bootcd2disk_bootcd_mount
  echo "$PIMOUNT"

  printbefore_bootcd2disk_bootcd_umount
  echo "$PIUMOUNT"

  # Always use "uuidsed", because a disk may be
  # changed at restore time which would make old UUIDs unusable

  printbefore_bootcd2disk_FSTAB
  echo "FSTAB=\"$(
  echo "$RIFSTAB" | uuidsed | parttrans)\""

  printbefore_bootcd2disk_GRUB2
  # It is most often better to use the default: GRUB2=auto when running bootcd2disk,
  # but we make it easy to rename the following ORIG_GRUB2 definition to GRUB2.
  echo "ORIG_GRUB2=\"$(
  echo "$RIGRUB2" | uuidsed | parttrans)\""

  printbefore_bootcd2disk_GRUB
  echo "GRUB=\"$(
  echo "$RIGRUB" | uuidsed | parttrans)\""

  printbefore_bootcd2disk_GRUBBOOTDISK
  printbefore_bootcd2disk_GRUBBOOTDIR
  printbefore_bootcd2disk_GRUBDEVICEMAP
  cat <<END
GRUBDEVICEMAP="auto"
END

  printbefore_bootcd2disk_LILO
  printbefore_bootcd2disk_SSHHOSTKEY
  cat <<END
SSHHOSTKEY="no"
# SSHHOSTKEY="no".
# But if you want to recreate it, use the following
# line instead:
#SSHHOSTKEY="yes"
END

  printbefore_bootcd2disk_UDEV_FIXNET
  cat <<END
UDEV_FIXNET="no"
END

  printbefore_bootcd2disk_IMAGEURL

  printbefore_bootcd2disk_PARTITIONLABEL
  echo "PARTITIONLABEL=\"$(
  echo "$RILABEL" | parttrans)\""
}

bootcdmk2diskconf()
{
  eval "$ia_init"
  fakeroot_err="^libfakeroot internal error: payload not recognized!$"

  if [ "$testdata" ]; then

    for i in RILV RIPV RIDF RILABEL RIUUID RIPARTITION; do
      if [ ! "$(set | grep "^$i=")" ]; then
        err "bootcdmk2diskconf: testdata $i not defined"
      fi
    done

  else
    ia_ignore "^File descriptor \S+ \(\S+\) leaked on (lvdisplay|pvdisplay) invocation\. Parent PID \S+: \S+$"
    ia_ignore "^\s*WARNING: Failed to connect to lvmetad\. Falling back to device scanning\.$"
    ia_ignore "^  WARNING: Device \S+ not initialized in udev database even after waiting \S+ microseconds\.$"
    ia_ignore "^  /dev/\S+: open failed: No medium found$"
    ia_ignore "$fakeroot_err"
    ia_add "readinfo \"$SRCDISK\""
  fi

  ia_ignore "$fakeroot_err"
  ia_add "calcinfo"

  ia_ignore "$fakeroot_err"
  ia_add "calcprint"

  if [ "$only_vars" ]; then
    only_vars="$(echo "$only_vars" | sed "s/,/ /g")"
    for i in $only_vars; do
      ia_ignore "$fakeroot_err"
      ia_stdout "^"
      ia_add "echo \"$i=\\\"\$(echo "\"\$$i\"")\\\"\""
    done
  else
    ia_ignore "$fakeroot_err"
    ia_stdout "^"
    ia_add "print2diskconf"
  fi

  ia -c
}