#!/bin/bash
#
# Copyright 2022, 2023 Eric Hameleers, Eindhoven, NL
# All rights reserved.
#
# Redistribution and use of this script, with or without modification, is
# permitted provided that the following conditions are met:
#
# 1. Redistributions of this script must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# -----------------------------------------------------------------------------
#
# This script can perform some specific changes on the USB stick
# containing an ISO of Slackware Live Edition,
# when you boot from that ISO using a multi-boot manager.
# - create a directory structure on the USB partition to add more
# functionality to the ISO (e.g. load extra addons/optional modules).
# - create an encrypted container file for storing persistence data.
# - create an encrypted container file to mount on /home .
# - write all the above information into a configuration file for the ISO.
#
# -----------------------------------------------------------------------------
# Be careful:
set -e
# Limit the search path:
export PATH="/usr/sbin:/sbin:/usr/bin:/bin"
# Use of force is sometimes needed:
FORCE=0
# Version is obtained from the ISO metadata:
VERSION=""
# The extension for containerfiles accompanying an ISO is '.icc',
# whereas the persistent USB stick created with iso2usb.sh uses '.img'.
DEFEXT=".icc"
CNTEXT="${DEFEXT}"
# Default filesystem for devices/containers:
DEF_FS="ext4"
FSYS="${DEF_FS}"
# Default mount point for a LUKS container if not specified:
DEFMNT="/home"
LUKSMNT=""
# Values for container sizes:
PERSSIZE=""
LUKSSIZE=""
INCSIZE=""
LUKSVOL=""
# Associative array to capture LUKSVOL definitions:
declare -A CONTAINERS=()
# Values obtained from a pre-existing .cfg file:
ISOPERSISTENCE=""
LUKSCNT=""
LIVESLAKROOT=""
# Define ahead of time, so that cleanup knows about them:
IMGDIR=""
ISOMNT=""
CNTDEV=""
CNTMNT=""
EXTENSION=""
LODEV=""
PERSISTENCE=""
# Minimim free space (in MB) we want to have left in any partition
# after we are done.
# The default value can be changed from the environment:
MINFREE=${MINFREE:-10}
# Compressor used on the initrd ("gzip" or "xz --check=crc32");
# Note that the kernel's XZ decompressor does not understand CRC64:
COMPR="xz --check=crc32"
# These tools are required by the script, we will check for their existence:
REQTOOLS="cpio cryptsetup fsck gzip isoinfo lsblk unsquashfs xz zstd"
#
# -- function definitions --
#
# Clean up in case of failure:
function cleanup() {
# Clean up by unmounting our loopmounts, deleting tempfiles:
echo "--- Cleaning up the staging area..."
# During cleanup, do not abort due to non-zero exit code:
set +e
sync
if [ -n "$CNTDEV" ]; then
# In case of failure, only most recent LUKS mapped device is still open:
if mount | grep -q ${CNTDEV} ; then
umount -f ${CNTDEV}
cryptsetup luksClose $(basename ${CNTDEV})
losetup -d ${LODEV}
fi
fi
[ -n "${ISOMNT}" ] && ( umount -f ${ISOMNT} 2>/dev/null; rmdir $ISOMNT 2>/dev/null )
[ -n "${CNTMNT}" ] && ( umount -f ${CNTMNT} 2>/dev/null; rmdir $CNTMNT 2>/dev/null )
[ -n "${IMGDIR}" ] && ( rm -rf $IMGDIR )
set -e
} # End of cleanup()
trap 'echo "*** $0 FAILED at line $LINENO ***"; cleanup; exit 1' ERR INT TERM
# Show the help text for this script:
function showhelp() {
cat <<EOT
#
# Purpose: enhance the functionality when booting a Slackware Live ISO file.
# When supplying pathnames as parameter values below, use full pathnames in
# your local filesystem. The script will figure out where your USB disk
# partition is mounted and will adjust the path names accordingly
# in the USB configuration.
#
# $(basename $0) accepts the following parameters:
# -d|--directory <path> Create a liveslak directory structure to store
# additional modules. The parameter value is
# used as the root path below which the
# liveslak/{addons,optional} subdirectories
# will be created.
# -e|--examples Show some common usage examples.
# -f|--force Force execution in some cases where the script
# reports an issue.
# -h|--help This help text.
# -i|--iso <fullpath> Full path to your liveslak ISO image.
# -l|--lukscontainer <fullpath> Full path to encrypted container file to be
# created by this script, and to be mounted
# in the live OS under /home
# (or any other mountpoint you supply).
# (filename needs to end in '${CNTEXT}'!).
# -p|--persistence <fullpath > Full path to encrypted persistence container
# file to be created in the filesystem
# (filename extension must be '${CNTEXT}'!).
# -x|--extend <fullpath> Full path to existing (encrypted) container
# file that you want to extend in size
# Limitations:
# - container needs to be LUKS encrypted.
# - filename extension needs to be '${CNTEXT}'.
# Supported filesystems inside container:
# - $(resizefs).
# -F|--filesystem <fs> Specify filesystem to create when formatting
# devices/containers. Defaults to '${DEF_FS}',
# Choices are $(createfs).
# -L|--lcsize <size|perc> Size of LUKS encrypted /home ; value is the
# requested size of the container in kB, MB, GB,
# or as a percentage of free space
# (integer numbers only).
# Examples: '-L 125M', '-L 2G', '-L 20%'.
# -P|--perssize <size|perc> Size of persistence container ; value is the
# requested size of the container in kB, MB, GB,
# or as a percentage of free space
# (integer numbers only).
# Examples: '-P 125M', '-P 2G', '-P 20%'.
# -X|--extendsize <size|perc> Extend size of existing container; value
# is the requested extension of the container
# in kB, MB, GB, or as percentage of free space
# (integer numbers only).
# Examples: '-X 125M', '-X 2G', '-X 20%'.
#
EOT
} # End of showhelp()
# Show some common usage examples:
function showexamples() {
cat <<EOT
#
# Some common usage examples for $(basename $0)
# ---------------------------------------------------------------------------
# First, mount your USB partition, for instance
# a Ventoy disk will be mounted for you at /run/media/<user>/Ventoy/.
# Then:
# ---------------------------------------------------------------------------
# Create a 1GB encrypted persistence container:
# ./$(basename $0) -p /run/media/<user>/Ventoy/myfiles/persistence.icc -P 1G
#
# Create a 4GB encrypted home with btrfs filesystem:
# ./$(basename $0) -l /run/media/<user>/Ventoy/somedir/lukscontainers.icc -L 4000M -F btrfs -i /run/media/<user>/Ventoy/slackware64-live-current.iso
#
# Increase the size of that encrypted home container with another 2GB:
# ./$(basename $0) -x /run/media/<user>/Ventoy/somedir/lukscontainers.icc -X 2G -i /run/media/<user>/Ventoy/slackware64-live-current.iso
#
# Create a 10GB encrypted container to be mounted on /data in the Live OS:
# ./$(basename $0) -l /run/media/<user>/Ventoy/somedir/mydata.icc:/data -L 10G -i /run/media/<user>/Ventoy/slackware64-live-current.iso
#
# Create a liveslak directory structure for adding extra live modules:
# ./$(basename $0) -d /run/media/<user>/Ventoy/myliveslak -i /run/media/<user>/Ventoy/slackware64-live-current.iso
#
EOT
} # End of showexamples()
# Create a filesystem on a partition with optional label:
function createfs () {
MYDEV="${1}"
MYFS="${2:-'ext4'}"
MYLABEL="${3}"
if [ -n "${MYLABEL}" ]; then
case "${MYFS}" in
fs2s) MYLABEL="-l ${MYLABEL}" ;;
*) MYLABEL="-L ${MYLABEL}" ;;
esac
fi
if [ -z "${MYDEV}" ]; then
# Without arguments given, reply with list of supported fs'es:
echo "btrfs,ext2,ext4,f2fs,jfs,xfs"
return
fi
case "${MYFS}" in
btrfs) mkfs.btrfs -f -d single -m single ${MYLABEL} ${MYDEV}
;;
ext2) mkfs.ext2 -F -F ${MYLABEL} ${MYDEV}
# Tune the ext2 filesystem:
tune2fs -m 0 -c 0 -i 0 ${MYDEV}
;;
ext4) mkfs.ext4 -F -F ${MYLABEL} ${MYDEV}
# Tune the ext4 filesystem:
tune2fs -m 0 -c 0 -i 0 ${MYDEV}
;;
f2fs) mkfs.f2fs ${MYLABEL} -f ${MYDEV}
;;
jfs) mkfs.jfs -q ${MYDEV}
;;
xfs) mkfs.xfs -f ${MYDEV}
;;
*) echo "*** Unsupported filesystem '${MYFS}'!"
cleanup
exit 1
;;
esac
} # End of createfs()
# Resize the filesystem on a block device:
function resizefs() {
local MYDEV="${1}"
if [ -z "${MYDEV}" ]; then
# Without arguments given, reply with list of supported fs'es:
echo "btrfs,ext2,ext4,f2fs,jfs,xfs"
return
fi
# Determine the current filesystem for the block device:
local MYFS=$(lsblk -n -o FSTYPE ${MYDEV})
if [ -z "${MYFS}" ]; then
echo "*** Failed to resize filesystem on device '${MYDEV}'!"
echo "*** No filesystem found."
cleanup
exit 1
fi
local TMPMNT=$(mktemp -d -p /tmp -t alienres.XXXXXX)
if [ ! -d $TMPMNT ]; then
echo "*** Failed to create temporary mount for the filesystem resize!"
cleanup
exit 1
else
chmod 711 ${TMPMNT}
fi
# Mount the block device prior to the resize
# (btrfs, jfs and xfs do not support offline resize):
mount -o rw -t ${MYFS} ${MYDEV} ${TMPMNT}
# Resize the filesystem to occupy the full new device capacity:
case "${MYFS}" in
btrfs) btrfs filesystem resize max ${TMPMNT}
;;
ext*) resize2fs ${MYDEV}
;;
f2fs) resize.f2fs ${MYDEV}
;;
jfs) mount -o remount,resize,rw ${TMPMNT}
;;
xfs) xfs_growfs -d ${TMPMNT}
;;
*) echo "*** Unsupported filesystem '${MYFS}'!"; exit 1
;;
esac
if [ ! $? ]; then
echo "*** Failed to resize '${MYFS}'filesystem on device '${MYDEV}'!"
cleanup
exit 1
else
# Un-mount the device again:
sync
umount ${TMPMNT}
rmdir ${TMPMNT}
fi
} # End of checkfs()
# Uncompress the initrd based on the compression algorithm used:
function uncompressfs () {
if $(file "${1}" | grep -qi ": gzip"); then
gzip -cd "${1}"
elif $(file "${1}" | grep -qi ": XZ"); then
xz -cd "${1}"
fi
} # End of uncompressfs()
# Read configuration data from the initrd inside the ISO,
# after it has been extracted into a directory:
function read_initrddir() {
local IMGDIR="$1"
local INITVARS="$2"
cd ${IMGDIR}
# Read the values of liveslak template variables in the init script:
for TEMPLATEVAR in ${INITVARS} ; do
eval $(grep "^ *${TEMPLATEVAR}=" ./init |head -1)
done
} # End of read_initrddir()
# Extract the initrd:
function extract_initrd() {
local IMGFILE="$1"
local IMGDIR=$(mktemp -d -p /tmp -t alienimg.XXXXXX)
if [ ! -d $IMGDIR ]; then
echo "*** Failed to create temporary extraction directory for the initrd!"
cleanup
exit 1
else
chmod 711 $IMGDIR
fi
cd ${IMGDIR}
uncompressfs ${IMGFILE} 2>/dev/null \
| cpio -i -d -m -H newc 2>/dev/null
echo "$IMGDIR"
} # End of extract_initrd()
# Determine size of a mounted partition (in MB):
function get_part_mb_size() {
local MYSIZE
MYSIZE=$(df -P -BM ${1} |tail -n -1 |tr -s '\t' ' ' |cut -d' ' -f2)
echo "${MYSIZE%M}"
} # End of get_part_mb_size()
# Determine free space of a mounted partition (in MB):
function get_part_mb_free() {
local MYSIZE
MYSIZE=$(df -P -BM ${1} |tail -n -1 |tr -s '\t' ' ' |cut -d' ' -f4)
echo "${MYSIZE%M}"
} # End of get_part_mb_free()
# Determine requested container size in MB (allow for '%|k|K|m|M|g|G' suffix):
function cont_mb() {
local MYSIZE="$1"
case "${MYSIZE: -1}" in
"%") MYSIZE="$(( $PARTFREE * ${MYSIZE%\%} / 100 ))" ;;
"k") MYSIZE="$(( ${MYSIZE%k} / 1024 ))" ;;
"K") MYSIZE="$(( ${MYSIZE%K} / 1024 ))" ;;
"m") MYSIZE="${MYSIZE%m}" ;;
"M") MYSIZE="${MYSIZE%M}" ;;
"g") MYSIZE="$(( ${MYSIZE%g} * 1024 ))" ;;
"G") MYSIZE="$(( ${MYSIZE%G} * 1024 ))" ;;
*) MYSIZE=-1 ;;
esac
echo "$MYSIZE"
} # End of cont_mb()
# Expand existing encrypted container file:
function expand_container() {
local MYPART="$1" # disk partition
local MYINC="$2" # requested increase ('%|k|K|m|M|g|G' suffix)
local MYFILE="$3" # full path to ${CNTEXT} containerfile
local MYMAP="" # Name of the device-mapped file
# Determine requested container increase in MB:
MYINC=$(cont_mb ${MYINC})
# Determine size of the target partition (in MB), and the free space:
PARTSIZE=$(get_part_mb_size ${MYPART})
PARTFREE=$(get_part_mb_free ${MYPART})
if [ $PARTFREE -lt $(( ${MYINC} + ${MINFREE} )) ]; then
echo "*** Free space on USB partition after file-resizing would be less than ${MINFREE} MB;"
echo "*** Not resizing the container file!"
cleanup
exit 1
fi
# Append random bytes to the end of the container file:
dd if=/dev/urandom of=${MYFILE} bs=1M count=${MYINC} oflag=append conv=notrunc 2>/dev/null
# Setup a loopback device that we can use with or without cryptsetup:
LODEV=$(losetup -f)
losetup $LODEV ${MYFILE}
if cryptsetup isLuks ${LODEV} ; then
# Unlock LUKS encrypted container first:
MYMAP=$(basename ${MYFILE} ${CNTEXT})
CNTDEV=/dev/mapper/${MYMAP}
echo "--- Unlocking the LUKS container requires your passphrase..."
until cryptsetup luksOpen ${LODEV} ${MYMAP} ; do
echo ">>> Did you type an incorrect passphrases?"
read -p ">>> Press [ENTER] to try again or Ctrl-C to abort ..." REPLY
done
else
# The loopmounted block device for the un-encrypted container:
CNTDEV=${LODEV}
fi
# Run fsck so the filesystem is clean before we resize it:
fsck -fvy ${CNTDEV}
# Resize the filesystem to occupy the full new size:
resizefs ${CNTDEV}
# Just to be safe:
fsck -fvy ${CNTDEV}
# Don't forget to clean up after ourselves:
if cryptsetup isLuks ${LODEV} ; then
cryptsetup luksClose ${MYMAP}
fi
losetup -d ${LODEV} || true
} # End of expand_container()
# Create container file in the empty space of the partition
function create_container() {
local CNTPART=$1 # partition containing the ISO
local CNTSIZE=$2 # size of the container file to create
local CNTFILE=$3 # ${CNTEXT} filename with full path
local CNTENCR=$4 # 'none' or 'luks'
local CNTUSED=$5 # 'persistence', '/home' or custom mountpoint
local MYMAP
# Create a container file or re-use previously created one:
if [ -f ${CNTFILE} ]; then
CNTSIZE=$(( $(du -sk ${CNTFILE} |tr '\t' ' ' |cut -f1 -d' ') / 1024 ))
echo "--- Keeping existing '${CNTFILE}' (size ${CNTSIZE} MB)."
return
fi
# Determine size of the target partition (in MB), and the free space:
PARTSIZE=$(get_part_mb_size ${CNTPART})
PARTFREE=$(get_part_mb_free ${CNTPART})
if [ $PARTFREE -lt ${MINFREE} ]; then
echo "*** Free space on USB partition is less than ${MINFREE} MB;"
echo "*** Not creating a container file!"
cleanup
exit 1
fi
# Determine requested container size in MB (allow for '%|k|K|m|M|g|G' suffix):
CNTSIZE=$(cont_mb ${CNTSIZE})
if [ $CNTSIZE -le 0 ]; then
echo "*** Container size must be larger than ZERO!"
echo "*** Check your commandline parameter."
cleanup
exit 1
elif [ $CNTSIZE -ge $PARTFREE ]; then
echo "*** Not enough free space for container file!"
echo "*** Check your commandline parameter."
cleanup
exit 1
fi
echo "--- Creating ${CNTSIZE} MB container file '$(basename =${CNTFILE})' using 'dd if=/dev/urandom', patience please..."
mkdir -p $(dirname "${CNTFILE}")
if [ $? ]; then
# Create a sparse file (not allocating any space yet):
dd of=${CNTFILE} bs=1M count=0 seek=$CNTSIZE 2>/dev/null
else
echo "*** Failed to create directory for the container file!"
cleanup
exit 1
fi
# Setup a loopback device that we can use with cryptsetup:
LODEV=$(losetup -f)
losetup $LODEV ${CNTFILE}
MYMAP=$(basename ${CNTFILE} ${CNTEXT})
if [ "${CNTENCR}" = "luks" ]; then
# Format the loop device with LUKS:
echo "--- Encrypting the container file with LUKS; takes SOME time..."
echo "--- enter 'YES' and a passphrase:"
until cryptsetup -y luksFormat $LODEV ; do
echo ">>> Did you type two different passphrases?"
read -p ">>> Press [ENTER] to try again or Ctrl-C to abort ..." REPLY
done
# Unlock the LUKS encrypted container:
echo "--- Unlocking the LUKS container requires your passphrase again..."
until cryptsetup luksOpen $LODEV ${MYMAP} ; do
echo ">>> Did you type an incorrect passphrases?"
read -p ">>> Press [ENTER] to try again or Ctrl-C to abort ..." REPLY
done
CNTDEV=/dev/mapper/${MYMAP}
# Now we allocate blocks for the LUKS device. We write encrypted zeroes,
# so that the file looks randomly filled from the outside.
# Take care not to write more bytes than the internal size of the container:
echo "--- Writing ${CNTSIZE} MB of random data to encrypted container; takes LONG time..."
CNTIS=$(( $(lsblk -b -n -o SIZE $(readlink -f ${CNTDEV})) / 512))
dd if=/dev/zero of=${CNTDEV} bs=512 count=${CNTIS} status=progress || true
else
# Un-encrypted container files remain sparse.
CNTDEV=$LODEV
fi
# Format the now available block device with a linux fs:
createfs ${CNTDEV} ${FSYS}
if [ "${CNTUSED}" == "${DEFMNT}" ]; then
# Copy the original /home content into the container.
# NOTE: we only do this for /home, not for any other mountpoint!
# Create a mount point for the unlocked container:
CNTMNT=$(mktemp -d -p /var/tmp -t aliencnt.XXXXXX)
if [ ! -d $CNTMNT ]; then
echo "*** Failed to create temporary mount point for the LUKS container!"
cleanup
exit 1
else
chmod 711 $CNTMNT
fi
echo "--- Copying '${CNTUSED}' from ISO to container..."
HOMESRC=$(find ${ISOMNT} -name "0099-slackware_zzzconf*" |tail -1)
mount ${CNTDEV} ${CNTMNT}
unsquashfs -n -d ${CNTMNT}/temp ${HOMESRC} ${CNTUSED}
mv ${CNTMNT}/temp/${CNTUSED}/* ${CNTMNT}/
rm -rf ${CNTMNT}/temp
umount ${CNTDEV}
fi
# Don't forget to clean up after ourselves:
if [ "${CNTENCR}" = "luks" ]; then
cryptsetup luksClose $(basename ${CNTFILE} ${CNTEXT})
fi
losetup -d ${LODEV} || true
} # End of create_container()
function read_isoconfig() {
local MYISO="${1}"
# Read ISO customization from the .cfg file if it exists:
if [ -f "${MYISO%.iso}.cfg" ]; then
for LIVEPARM in \
BLACKLIST KEYMAP LIVE_HOSTNAME LIVESLAKROOT LOAD LOCALE LUKSVOL \
NOLOAD ISOPERSISTENCE RUNLEVEL TWEAKS TZ XKB ;
do
# Read values from disk only if the variable has not been set yet:
if [ -z "$(eval echo \$${LIVEPARM})" ]; then
eval $(grep -w ^${LIVEPARM} ${MYISO%.iso}.cfg)
fi
done
fi
} # End of read_isoconfig()
function write_isoconfig() {
local MYISO="${1}"
# Write updated customization into the ISO .cfg:
echo "# Liveslak ISO configuration file for ${VERSION}" > ${MYISO%.iso}.cfg 2>/dev/null
echo "# Generated by $(basename $0) on $(date +%Y%m%d_%H%M)" >> ${MYISO%.iso}.cfg 2>/dev/null
if [ $? -ne 0 ]; then
echo "*** Media '${USBPART}' read-only, cannot write config file."
else
for LIVEPARM in \
BLACKLIST KEYMAP LIVE_HOSTNAME LIVESLAKROOT LOAD LOCALE LUKSVOL \
NOLOAD ISOPERSISTENCE RUNLEVEL TWEAKS TZ XKB ;
do
if [ -n "$(eval echo \$$LIVEPARM)" ]; then
echo $LIVEPARM=$(eval echo \$$LIVEPARM) >> ${MYISO%.iso}.cfg
fi
done
fi
} # End of write_isoconfig()
#
# -- end of function definitions --
#
# ===========================================================================
# Parse the commandline parameters:
if [ -z "$1" ]; then
showhelp
exit 1
fi
while [ ! -z "$1" ]; do
case $1 in
-d|--directory)
LIVESLAKROOT="$2"
[[ ${LIVESLAKROOT::1} != "/" ]] && LIVESLAKROOT="$(pwd)/${LIVESLAKROOT}"
shift 2
;;
-e|--examples)
showexamples
exit
;;
-f|--force)
FORCE=1
shift
;;
-h|--help)
showhelp
exit
;;
-i|--iso)
SLISO="$(cd "$(dirname "$2")"; pwd)/$(basename "$2")"
shift 2
;;
-l|--lukscontainer)
LUKSMNT="$(echo "$2" |cut -f2 -d:)"
LUKSCNT="$(echo "$2" |cut -f1 -d:)"
# If no mountpoint was specified, use the default mountpoint (/home):
[ "$LUKSMNT" == "$LUKSCNT" ] && LUKSMNT=${DEFMNT}
LUKSCNT="$(cd "$(dirname "$LUKSCNT")"; pwd)/$(basename "$LUKSCNT")"
shift 2
;;
-p|--persistence)
PERSISTENCE="$(cd "$(dirname "$2")"; pwd)/$(basename "$2")"
shift 2
;;
-x|--extend)
EXTENSION="$(cd "$(dirname "$2")"; pwd)/$(basename "$2")"
shift 2
;;
-F|--filesystem)
FSYS="$2"
shift 2
;;
-L|--lcsize)
LUKSSIZE="$2"
shift 2
;;
-P|--perssize)
PERSSIZE="$2"
shift 2
;;
-X|--extendsize)
INCSIZE="$2"
shift 2
;;
*)
echo "*** Unknown parameter '$1'!"
exit 1
;;
esac
done
#
# Sanity checks:
#
if [ "$(id -u)" != "0" ]; then
echo "*** You need to be root to run $(basename $0)."
exit 1
fi
# Add required filesystem tools:
REQTOOLS="${REQTOOLS} mkfs.${FSYS}"
# Are all the required tools present?
PROG_MISSING=""
for PROGN in ${REQTOOLS} ; do
if ! which $PROGN 1>/dev/null 2>/dev/null ; then
PROG_MISSING="${PROG_MISSING}-- $PROGN\n"
fi
done
if [ ! -z "$PROG_MISSING" ] ; then
echo "--- Required program(s) not found in search path '$PATH'!"
echo -e ${PROG_MISSING}
if [ $FORCE -eq 0 ]; then
echo "--- Exiting."
exit 1
fi
fi
if [ -z "${SLISO}" ]; then
echo "*** You must specify the path to the Live ISO (option '-i')!"
exit 1
fi
if [ ! -f "$SLISO" ]; then
echo "*** This is not a useable file: '$SLISO' !"
exit 1
fi
if [ -z "${LIVESLAKROOT}${LUKSCNT}${PERSISTENCE}${EXTENSION}" ]; then
echo "*** No action requested!"
exit 1
fi
if [ -n "${PERSISTENCE}" ]; then
if [ -z "${PERSSIZE}" ]; then
echo "*** Persistence filename '${PERSISTENCE}' defined but no filesize provided!"
echo "*** Not enabling persistence, please use '-P' parameter."
exit 1
elif [ "$(basename ${PERSISTENCE} ${CNTEXT})" == "$(basename ${PERSISTENCE})" ]; then
echo "*** File '${PERSISTENCE}' does not have an '${CNTEXT}' extension!"
if [ $FORCE -eq 0 ]; then
exit 1
else
CNTEXT=$(basename ${PERSISTENCE})
if [ "${CNTEXT}" != "${CNTEXT##*.}" ]; then
# File has a different extension:
echo "--- Accepting '${CNTEXT##*.}' extension for '${PERSISTENCE}'."
CNTEXT=${CNTEXT##*.}
else
# File does not have an extension at all, so we add one:
echo "--- Adding '${DEFEXT}' extension to '${PERSISTENCE}'."
PERSISTENCE="${PERSISTENCE}${DEFEXT}"
fi
fi
fi
fi
if [ -n "${LUKSCNT}" ]; then
if [ -z "${LUKSSIZE}" ]; then
echo "*** LUKS container '${LUKSCNT}' defined but no filesize provided!"
echo "*** Not adding encrypted ${LUKSMNT}, please use '-L' parameter."
exit 1
elif [ "$(basename ${LUKSCNT} ${CNTEXT})" == "$(basename ${LUKSCNT})" ]; then
echo "*** File '${LUKSCNT}' does not have an '${CNTEXT}' extension!"
if [ $FORCE -eq 0 ]; then
exit 1
else
CNTEXT=$(basename ${LUKSCNT})
if [ "${CNTEXT}" != "${CNTEXT##*.}" ]; then
# File has a different extension:
echo "--- Accepting '${CNTEXT##*.}' extension for '${LUKSCNT}'."
CNTEXT=${CNTEXT##*.}
else
# File does not have an extension at all, so we add one:
echo "--- Adding '${DEFEXT}' extension to '${LUKSCNT}'."
LUKSCNT="${LUKSCNT}${DEFEXT}"
fi
fi
fi
fi
if [ -n "${EXTENSION}" ]; then
if [ -z "${INCSIZE}" ]; then
echo "*** LUKS container '${EXTENSION}' defined but no extansion size provided!"
echo "*** Not extending encrypted ${EXTENSION}, please use '-X' parameter."
exit 1
elif [ "$(basename ${EXTENSION} ${CNTEXT})" == "$(basename ${EXTENSION})" ]; then
echo "*** File '${EXTENSION}' does not have an '${CNTEXT}' extension!"
if [ $FORCE -eq 0 ]; then
exit 1
else
CNTEXT=$(basename ${EXTENSION})
if [ "${CNTEXT}" != "${CNTEXT##*.}" ]; then
# File has a different extension:
echo "--- Accepting '${CNTEXT##*.}' extension for '${EXTENSION}'."
CNTEXT=${CNTEXT##*.}
else
# File does not have an extension at all, so we add one:
echo "--- Adding '${DEFEXT}' extension to '${EXTENSION}'."
EXTENSION="${EXTENSION}${DEFEXT}"
fi
fi
fi
fi
# Determine name and mountpoint of the partition containing the ISO:
USBPART=$(cd $(dirname ${SLISO}) ; df . |tail -n -1 |tr -s ' ' |cut -d' ' -f1)
USBMNT=$(cd $(dirname ${SLISO}) ; df . |tail -n -1 |tr -s ' ' |cut -d' ' -f6)
# Determine size of the USB partition (in MB), and the free space:
USBPSIZE=$(get_part_mb_size ${USBMNT})
USBPFREE=$(get_part_mb_free ${USBMNT})
# Report the Slackware Live version:
VERSION=$(isoinfo -d -i "${SLISO}" 2>/dev/null |grep Application |cut -d: -f2-)
echo "--- The ISO on medium '${USBPART}' is '${VERSION}'"
# Try a write to the partition:
if touch ${USBMNT}/.rwtest 2>/dev/null && rm ${USBMNT}/.rwtest 2>/dev/null
then
echo "--- The medium '${USBPART}' is writable."
else
echo "--- Trying to remount readonly medium '${USBPART}' as writable..."
mount -o remount,rw ${USBMNT}
if [ $? -ne 0 ]; then
echo "*** Failed to remount '${USBPART}' writable, unable to continue!"
cleanup
exit 1
fi
fi
# Create a mount point for the ISO:
ISOMNT=$(mktemp -d -p /var/tmp -t alieniso.XXXXXX)
if [ ! -d $ISOMNT ]; then
echo "*** Failed to create temporary mount point for the ISO!"
cleanup
exit 1
else
chmod 711 $ISOMNT
mount -o loop ${SLISO} ${ISOMNT}
fi
# Collect data from the USB initrd:
IMGDIR=$(extract_initrd ${ISOMNT}/boot/initrd.img)
read_initrddir ${IMGDIR} "DISTRO LIVEMAIN MARKER MEDIALABEL"
# Collect customization parameters for the ISO:
read_isoconfig ${SLISO}
# Determine where in LUKSVOL the /home is defined.
# The LUKSVOL value looks like:
# "/path/to/cntner1.icc:/mountpoint1,[/path/to/cntner2.icc:/mountpoint2,[...]]"
# Break down the LUKSVOL value into container/mountpoint combo's:
if [ -n "$LUKSVOL" ]; then
_container=""
_mount=""
for _luksvol in $(echo $LUKSVOL |tr ',' ' '); do
_container="$(echo $_luksvol |cut -d: -f1)"
_mount="$(echo $_luksvol |cut -d: -f2)"
if [ "$_mount" == "$_container" ]; then
# No optional mount point specified, so we use the default:
CONTAINERS["${DEFMNT}"]="$_container"
else
CONTAINERS["$_mount"]="$_container"
fi
done
fi
# Normalize paths on USB partition (remove mountpoint):
if [ -n "${PERSISTENCE}" ]; then
PERSISTENCE="${PERSISTENCE#$USBMNT}"
fi
if [ -n "${LUKSCNT}" ]; then
LUKSCNT="${LUKSCNT#$USBMNT}"
fi
if [ -n "${EXTENSION}" ]; then
EXTENSION="${EXTENSION#$USBMNT}"
fi
# Should we create a liveslak root directory?
if [ -n "${LIVESLAKROOT}" ]; then
# The directory may already exist, in which case we obtained its name
# from the configfile. But creating directory tree is harmless:
mkdir -p ${LIVESLAKROOT}/${LIVEMAIN}/{addons,optional,core2ram}
# Normalize the path, removing the mount point:
LIVESLAKROOT="$(cd "$(dirname "$LIVESLAKROOT")"; pwd)$(basename "$LIVESLAKROOT")"
LIVESLAKROOT="${LIVESLAKROOT#$USBMNT}"
fi
# Should we create a persistence container?
if [ -n "${PERSISTENCE}" ]; then
# Create LUKS persistence container file (or re-use it if existing):
create_container ${USBPART} ${PERSSIZE} ${USBMNT}${PERSISTENCE} luks persistence
ISOPERSISTENCE="${PERSISTENCE}"
fi
# Should we add a LUKS container to mount at /home or specified other mount?
if [ -n "${LUKSCNT}" ]; then
if [ -v 'CONTAINERS["${LUKSMNT}"]' ] && [ "${LUKSCNT}" != "${CONTAINERS["${LUKSMNT}"]}" ]; then
# The configfile specifies a different mount for container:
echo "*** On-disk configuration defines an existing mountpoint ${LUKSMNT}"
echo "*** at '${USBMNT}${CONTAINERS["${LUKSMNT}"]}',"
echo "*** which is different from your '-l ${USBMNT}${LUKSCNT}'."
if [ $FORCE -eq 0 ]; then
echo "*** Not adding encrypted container for ${LUKSMNT} , please fix the entry"
echo "*** in '${SLISO%.iso}.cfg',"
echo "*** or supply the correct value for the '-l' parameter!"
cleanup
exit 1
else
echo "--- Accepting new mountpoint '${LUKSMNT}' for encrypted container ${LUKSMNT}"
fi
fi
# Create LUKS container file for the mount point (or re-use it if existing):
create_container ${USBPART} ${LUKSSIZE} ${USBMNT}${LUKSCNT} luks ${LUKSMNT}
CONTAINERS["${LUKSMNT}"]="${LUKSCNT}"
fi
# Should we extend the size of a container?
if [ -n "${EXTENSION}" ]; then
# Expand existing container file:
expand_container ${USBPART} ${INCSIZE} ${USBMNT}/${EXTENSION}
fi
if [ ${#CONTAINERS[@]} -gt 0 ]; then
# CONTAINERS array is non-empty; (re-)assemble the LUKSVOL variable.
# First zap the LUKSVOL value:
LUKSVOL=""
# Write the CONTAINERS array back into LUKSVOL in the correct format:
for _mount in "${!CONTAINERS[@]}"; do
LUKSVOL="${LUKSVOL}${CONTAINERS[$_mount]}:${_mount},"
done
# Remove the trailing ',':
LUKSVOL="${LUKSVOL::-1}"
fi
# Write customization parameters for the ISO to disk:
write_isoconfig ${SLISO}
# Write ISO version to the liveslak rootdir if that exists:
if [ -d "${USBMNT}/${LIVESLAKROOT}" ]; then
echo "$VERSION" > ${USBMNT}/${LIVESLAKROOT}/.isoversion
fi
# Unmount/remove stuff:
cleanup
# THE END
