#!/bin/bash
#-t --tmpfs path to temporary save file
#-r --root Parent directory to the new rootfs. Only applied to options which are to the right of this option.
#-f --fake-root This is the location where the fake (or new) rootfs will be mounted.
#-n --new-root See: -f --fake-root
# This is a subdirectory of the -r|--root option when the -r --root option is applied to the left of this argument
unset SANDBOX_ID
unset rwbranch
unset FAKEROOT
unset SANDBOX_TMPFS
unset FAKEROOT_dir
unset SANDBOX_IMG
FAKEROOT_SET=false
#SANDBOX_ROOT=/mnt/sb
unset SANDBOX_ROOT
# [ -z "$TMPFILE" ] && TMPFILE=$(mktemp -p /tmp)
TMPFILE=$(mktemp -p /tmp)
trap 'umountall' 1
function log(){
local logfile="${2}"
local trace="$3"
#[ -z "$logfile" ] && LOGFILE
#[ -z "$trace" ] && trace=TRACE
if [ ! -z "$LOGFILE" ]; then
case "$1" in
init)
[ "$TRACE" = true ] && set -x
[ ! -z "$LOGFILE" ] && rm "$LOGFILE"
exec 6>&1 # Link file descriptor #6 with stdout.
#exec &1> >(tee -a "$LOGFILE")
#exec &2> >(tee -a "$LOGFILE")
exec &> >(tee -a "$LOGFILE")
;;
start)
[ "$TRACE" = true ] && set -x
#exec &1> >(tee -a "$LOGFILE")
#exec &2> >(tee -a "$LOGFILE")
exec &> >(tee -a "$LOGFILE")
;;
stop)
#https://stackoverflow.com/questions/21106465/restoring-stdout-and-stderr-to-default-value
[ "$TRACE" = true ] && set +x
exec 1>&6 #See https://tldp.org/LDP/abs/html/x17974.html
#exec 6>&- # Restore stdout and close file descriptor #6.
exec &2> /dev/stderr
;;
esac
fi
}
declare -a del_rules_filter
declare -a del_rules_action
declare -a umount_rules_filter
declare -a umount_rules_action
safe_delete(){
unset safe_delete_result
POLICY="" #Default action if no rule is found
if [ ! -z "$(cat /proc/mounts | grep -F "$(ls -1d $1 | sed 's:/$::')" - )" ] ||
[ ! -z "$(cat /proc/mounts | grep -F "$(ls -1d $1 | xargs realpath )" - )" ] ; then
#It is not safe to delete a mounted directory
safe_delete_result=1 #This is in case one doesn't want to use the return status right away
return 1
else
PATH_TO_DEL="$(realpath -m $1)"
[ -d "$PATH_TO_DEL" ] && "PATH_TO_DEL=$PATH_TO_DEL/"
for a_rule_key in "${!del_rules_filter[@]}"; do
rule_i="${a_rull_key[$a_rule_key]}"
if [ ! -z "$(echo $PATH_TO_DEL | grep "$rule_i")" ] ||
[[ "$PATH_TO_DEL" = $rule_i ]]; then
action="${del_rules_action[$a_rule_key]}"
case $action in
DELETE)
safe_delete_result=0 #This is in case one doesn't want to use the return status right away
return 0
break #This is probably redundant
;;
KEEP)
safe_delete_result=1 #This is in case one doesn't want to use the return status right away
return 1
break #This is probably redundant
;;
POLICY_KEEP)
POLICY=KEEP
;;
POLICY_DELETE)
POLICY=DELETE
;;
esac
fi
done
if [ -z ${safe_delete_result+x} ]; then #If we don't have a result yet set result based on policy
case "$POLICY" in
KEEP)
safe_delete_result=1
return 1; ;;
DELETE)
safe_delete_result=0
return 0; ;;
*)
echo "No Delete policy set, so keeping file/dir $1"
safe_delete_result=1
return 1
esac
fi
fi
}
safe_umount(){
unset safe_umount_result
POLICY="" #Default action if no rule is found
PATH_TO_UMOUNT="$(realpath -m $1)"
[ -d "$PATH_TO_UMOUNT" ] && PATH_TO_UMOUNT="$PATH_TO_UMOUNT/" #TODO, this should always be true so add error if it is not.
for a_rule_key in "${!umount_rules_filter[@]}"; do
rule_i="${a_rull_key[$a_rule_key]}"
if [ ! -z "$(echo $1 | grep "$rule_i")" ] ||
[[ "$PATH_TO_UMOUNT" = $rule_i ]]; then
action="${umount_rules_action[$a_rule_key]}"
case $action in
DELETE)
safe_umount_result=0 #This is in case one doesn't want to use the return status right away
return 0
break #This is probably redundant
;;
UMOUNT)
safe_umount_result=1 #This is in case one doesn't want to use the return status right away
return 1
break #This is probably redundant
;;
POLICY_KEEP)
POLICY=KEEP
;;
POLICY_UMOUNT)
POLICY=UMOUNT
;;
esac
fi
done
if [ -z ${safe_umount_result+x} ]; then #If we don't have a result yet set result based on policy
case "$POLICY" in
KEEP)
safe_umount_result=1
return 1; ;;
UMOUNT)
safe_umount_result=0
return 0; ;;
*)
echo "No Delete policy set, so keeping file/dir $1"
safe_umount_result=1
return 1
esac
fi
}
umountall() {
{
log start
set -x
#R_FR=$(realpath -m "$FAKEROOT")
#[ ${#R_FR} -lt 2 ] && exit
safe_umount $SANDBOX_TMPFS
[ $safe_umount_result -eq 0 ] && umount -l $SANDBOX_TMPFS
if [ PUPMODE = 2 ]; then #Full Install
safe_umount $FAKEROOT/tmp
umount -l $FAKEROOT/tmp
else
safe_umount $FAKEROOT/initrd/mnt/tmpfs
[ $safe_umount_result -eq 0 ] && umount -l $FAKEROOT/initrd/mnt/tmpfs
fi
for layer_name in "pup_ro2" "pup_ro3" "pup_ro4" "pup_ro5" "pup_z"; do
layer="$(eval 'echo $'$layer_name)"
if [ ! -z "$layer" ] ; then
safe_umount "$FAKEROOT/initrd/$layer_name"
[ $safe_umount_result -eq 0 ] && umount -l "$FAKEROOT/initrd/$layer_name"
fi
done
for aFolder in /proc /sys /dev ""; do
safe_umount $FAKEROOT"/$aFolder"
[ $safe_umount_result -eq 0 ] && umount -l $FAKEROOT$aFolder
done
if [ -z "$RW_LAYER" ]; then
safe_umount "$SANDBOX_TMPFS"
[ $safe_umount_result -eq 0 ] && umount -l $SANDBOX_TMPFS
safe_delete "$SANDBOX_TMPFS"
[ $safe_delete_result -eq 0 ] && rmdir $SANDBOX_TMPFS
fi
safe_delete $FAKEROOT
[ $safe_delete_result -eq 0 ] && rmdir $FAKEROOT
} # 2> /dev/null
}
function choose_save(){
# location not specified - then ask
log stop
dialog --backtitle "rw image sandbox" --title "choose rw image" \
--extra-button --extra-label "Create" --ok-label "Locate" \
--yesno "You didn't specify the location of the rw image file. Do you want to locate existing file, or do you want to create a new one?" 0 0
chosen=$?
log start
case $chosen in
0) # ok - locate
log stop
dialog --backtitle "rw image sandbox" --title "Specify location of existing rw image" --fselect `pwd` 8 60 2> $TMPFILE
savebranch=`cat $TMPFILE`
log start
rm $TMPFILE
if [ -n "$savebranch" ]; then
if [ -d "$savebranch" ]; then
case "$savebranch" in
"/mnt"|"/mnt/"|"/mnt/home"|"/mnt/home/"|"/")
log stop
echo "warning chose the following savebranch $savebranch"
read -p "Press enter to continue"
log start
set_sandbox_img ""
;;
esac
SANDBOX_IMG=$savebranch
elif [ ! -f "$savebranch" ]; then
echo "$savebranch doesn't exist - exiting."
echo "will use tmpfs instead"
log stop
read -p "Press enter to continue"
log start
savebranch=""
else
set_sandbox_img ""
fi
else
echo "You didn't specify any file or you pressed cancel. Exiting."
exit
fi
;;
3) # create
echo "create"
log stop
dialog --backtitle "save image sandbox" --title "Specify name and path of new the file" --fselect `pwd` 8 60 2> $TMPFILE
savebranch=`cat $TMPFILE`
log start
rm $TMPFILE
if [ -n "$savebranch" ]; then
if [ -f "$savebranch" ]; then
echo "$savebranch already exist - exiting."
exit
else
# get the size
log stop
dialog --title "Create new save image" --inputbox "Specify size (in megabytes)" 0 40 100 2> $TMPFILE
size=`cat $TMPFILE`
log start
rm $TMPFILE
if [ -n "$size" ]; then
if dd if=/dev/zero of="$savebranch" bs=1 count=0 seek="$size"M; then
if ! mke2fs -F "$savebranch"; then
echo "I fail to make an ext2 filesystem at $savebranch, exiting."
exit
fi
else
echo "I fail to create a ${size}M file at $savebranch,, exiting."
exit
fi
else
echo "You didn't specify the size or your press cancel. Exiting."
exit
fi
fi
else
echo "You didn't specify any file or you pressed cancel. Exiting."
exit
fi
;;
1 | 255) # 1 is cancel, 255 is Escape
;&
*) # invalid input - treat as cancel
echo "Cancelled - exiting."
exit
;;
esac
}
function find_save(){
if [ ! -z "SANDBOX_IMG" ]; then
FULL_SAVE_PATH=$SANDBOX_IMG
else
for prefix in '${DISTRO_FILE_PREFIX}save' '.*save'; do
for dir in "$PDRV/${PSUBDIR}" "PDRV"; do
ONE_SAVE="$(ls $dir -1 | grep -m "${prefix}save")"
if [ -z "$ONE_SAVE" ]; then
continue
else
SAVE_FILE="$ONE_SAVE"
FULL_SAVE_PATH="$dir"/ONE_SAVE
break
fi
done
done
echo "PSAVE"mount_items
fi
}
function find_bk_folders(){
for a_PDRV in "$PDRV" sr0 sr1; do #Consider adding /mnt/home here
for a_psubdir in "${PSUBDIR}" ""; do
MT_PT_of_Folder="$(mount_fn2 "$PDRV" "${PSUBDIR}")"
#https://github.com/puppylinux-woof-CE/woof-CE/blob/c483d010a8402c5a1711517c2dce782b3551a0b8/initrd-progs/0initrd/init#L981
BKFOLDERS="$(find $MT_PT_of_Folder -maxdepth 1 -xdev -type d -name '20[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]' | sed -e s%^${SAVE_MP}/%% | sort -r)"
[ ! -z "#BKFOLDERS" ] && break
done
done
}
function mk_initrd_dir(){
mkdir -p "$FAKEROOT"/initrd
if [ -z "$PUPMODE" ] ; then
if [ -z "$PMEDIA" ]; then
#if [ "$PUPMODE" = 5 ] ; then
# #aufs layers: RW (top) RO1 RO2 PUPMODE
# #First boot (or pfix=ram): tmpfs pup_xxx.sfs 5
PUPMODE=5 #MAYBE PUPMODE=2 would be better
elif [ PMEDIA = 'atahd' ] || [ "$PMEDIA" = 'usbhd' ]; then
find_save
if [ -f "$FULL_SAVE_PATH" ] || [ -d "$FULL_SAVE_PATH" ]; then
#aufs layers: RW (top) RO1 RO2 PUPMODE
#Normal running puppy: pup_save.3fs pup_xxx.sfs 12
PUPMODE=12
else
echo "Invalid SAVE_PATH=$SAVE_PATH does not exist"
PUMPMODE=2
#TODO, prompt to either search for save file/folder or alternatively create it.
fi
elif [ PMEDIA = 'usbflash' ] || [ pmedia = 'ideflash' ]; then
find_save
#aufs layers: RW (top) RO1 RO2 PUPMODE
#ditto, but flash drive: tmpfs pup_save.3fs pup_xxx.sfs 13
if [ -f "$SAVE_PATH" ] || [ -d "$SAVE_PATH" ]; then
#aufs layers: RW (top) RO1 RO2 PUPMODE
#ditto, but flash drive: tmpfs pup_save.3fs pup_xxx.sfs 13
PUPMODE=13
else
echo "Invalid SAVE_PATH=$SAVE_PATH does not exist"
PUPMODE=5
fi
elif [ "$PMEDIA" = usbcd ] || [ "$PMEDIA" = idecd ] || [ "$PMEDIA" = satacd ] ; then
find_bk_folders
if [ ! -z "$BKFOLDERS" ]; then
PUPMODE=77 #MULTI-Session CD
else #First Boot
find_save
if [ -f "$FULL_SAVE_PATH" ] || [ -d "$FULL_SAVE_PATH" ]; then
PUPMODE=13
else
PUPMODE=5
fi
fi
#aufs layers: RW (top) RO1 RO2 PUPMODE
#Multisession cd/dvd: tmpfs folders pup_xxx.sfs 77
else #[PUPMODE=2 -> full install
PUPMODE=2
fi
if [ "$PUPMODE" = 2 ] && [ 1 -ne 1 ]; then #Full install
echo "Full install has no initrd"
else
mkdir -p "$FAKEROOT/initrd"
cd $FAKEROOT/initrd
if [ "$PUPMODE" = 12 ]; then # Usually [ PMEDIA = 'atahd' ] || [ "$PMEDIA" = usbhd ]
ln -s mnt/dev_save/"${SAVE_PATH}" pup_rw
elif [ "$PUPMODE" = 13 ] || [ "$PUPMODE" = 5 ] || [ "$PUPMODE" = 77 ]; then
ln -s mnt/tmpfs/pup_rw pup_rw
if [ "$PUPMODE" = 13 ]; then # Usually [ PMEDIA = 'usbflash' ] || [ pmedia = 'ideflash' ]
ln -s "mnt/tmpfs/dev_save/${SAVE_PATH}" pup_ro1
elif [ "$PUPMODE" = 77 ]; then
ln -s mnt/tmpfs/pup_ro1/"${SAVE_PATH}" pup_ro1 #Usually [ "$PMEDIA" = usbcd ] || [ "$PMEDIA" = idecd ] || [ "$PMEDIA" = satacd ]
fi
fi
mkdir -p "$FAKEROOT/initrd/mnt/dev_save"
mount -o bind /mnt/home "$FAKEROOT/initrd/mnt/dev_save"
mkdir $FAKEROOT/mnt
cd $FAKEROOT/mnt
ln -s ../initrd/mnt/dev_save
cd $FAKEROOT
mount -o bind $SANDBOX_IMG initrd/mnt/tmpfs/pup_rw #not sure if this applies to all pupmodes.
fi
fi
}
function set_fakeroot(){
unset CLEANUP_SANDBOX_ROOT
# if SANDBOX_ROOT is set to null then set it in this function
# if FAKEROOT is null then this implies "/"
if [ -z ${FAKEROOT+x} ] && [ $FAKEROOT_SET = false ]; then
FAKEROOT=fakeroot
CLEANUP_SANDBOX_ROOT=yes
fi
if [ ! -z ${SANDBOX_ROOT+x} ] || [ ${#FAKEROOT} -gt 1 ]; then
if [ "${CLEANUP_SANDBOX_ROOT}" = yes ]; then
SANDBOX_ROOT=/mnt/sb
else
FAKEROOT_SET
fi
if [ ${#SANDBOX_ROOT} -gt 1 ] && [ $FAKEROOT_SET = false ]; then
FAKEROOT=$SANDBOX_ROOT/$FAKEROOT
FAKEROOT_SET=true
elif [ ! -z ${FAKEROOT+x} ]; then
FAKEROOT_SET=true
fi
FAKEROOT_dir="${FAKEROOT%/*}"
[ -z "${SANDBOX_ROOT}" ] && SANDBOX_ROOT=${FAKEROOT_dir}
if grep -q $FAKEROOT /proc/mounts; then
if [ ! "$SANDBOX_ROOT" = /mnt/sb ]; then
log stop
dialog --backtitle "rename root" --title "already mounted" \
--extra-button --extra-label "Rename" --ok-label "Keep" \
--yesno "FAKEROOTI is already a mount point. Rename Root?" 0 0
chosen=$?
log start
case "#chosen" in
1)
RENAME_ROOT=yes; ;;
0)
RENAME_ROOT=no; ;;
esac
else
RENAME_ROOT=yes
fi
if [ "${RENAME_ROOT}" = yes ]; then
FAKEROOT=$(mktemp -d -p ${FAKEROOT%/*}/ ${FAKEROOT##*/}.XXXXXXX)
SANDBOX_ID=".${FAKEROOT##*.}"
if [ -z "$SANDBOX_IMG" ]; then
[ -z "$savebranch" ] && choose_save
savebranch="$(realpath -m $savebranch)"
if [ -d "$savebranch" ]; then
#TODO: verify this works if savebranch is a mounted directory.
SANDBOX_IMG="$savebranch"
else
[ ! -z "$savebranch" ] && loop=$(losetup-FULL -a | grep "$savebranch" | sed "s/:.*$//" )
if [ ! -z "$loop" ]; then
SANDBOX_IMG=$(cat /proc/mounts | grep $loop | cut -d " " -f2)
fi
if [ -z "$SANDBOX_IMG" ] ; then
SANDBOX_IMG=$FAKEROOT_dir/sandbox_img${SANDBOX_ID}
mkdir -p $SANDBOX_IMG
fi
fi
rmdir $FAKEROOT
else
log stop
echo "Warning chose to remount over existing mount! $FAKEROOT"
echo "ctrl-c to quote"
read -p "Press enter to continue"
log start
fi
fi
else
echo "This is our first sandbox"
fi
else
echo "Warning sandbox root not defined"
#[ -z "$FAKEROOT" ] && FAKEROOT=/
fi
if [ $CLEANUP_SANDBOX_ROOT = yes ]; then
if [ ${#del_rules_filter} -eq 0 ]; then
del_rules_filter+=( $SANDBOX_ROOT"/*" )
del_rules_filter+=( POLICY_DELETE )
fi
if [ ${#umount_rules_filter} -eq 0 ]; then
umount_rules_filter+=( $SANDBOX_ROOT"/*" )
umount_rules_filter+=( POLICY_UMOUNT )
fi
fi
mkdir -p "$SANDBOX_ROOT"
mkdir -p "$FAKEROOT"
}
function set_sandbox_img(){
[ -z ${FAKEROOT_dir+x} ] && set_fakeroot
if [ ! -z ${SANDBOX_IMG+x} ] && [ -z "${SANDBOX_IMG}" ] || [ ! -z ${1+x} ]; then
SANDBOX_IMG=sandbox_img
SANDBOX_IMG=${SANDBOX_IMG}${SANDBOX_ID}
[ ! -z "$FAKEROOT_dir" ] && SANDBOX_IMG=$FAKEROOT_dir/$SANDBOX_IMG
elif [ -z "${FAKEROOT_dir}" ] ; then
SANDBOX_IMG=$FAKEROOT_dir/$SANDBOX_IMG
fi
}
function set_sandbox_tmpfs(){
[ -z ${FAKEROOT_dir+x} ] && set_fakeroot
if [ ! -z ${SANDBOX_TMPFS+x} ] && [ -z "${SANDBOX_TMPFS}" ]; then
SANDBOX_TMPFS=sandbox_tmpfs
SANDBOX_TMPFS=${SANDBOX_TMPFS}${SANDBOX_ID}
[ -z "$FAKEROOT_dir" ] && SANDBOX_TMPFS=$FAKEROOT_dir/$SANDBOX_TMPFS
elif [ -z "${FAKEROOT_dir}" ] ; then
SANDBOX_TMPFS=$FAKEROOT_dir/$SANDBOX_TMPFS
fi
}
declare -a options="$(getopt -o t::,r::,s:,d:,l: --long input-file:tmpfs::,root::,save:,pupmode::,pmedia:,pdrv:,psubdir:,distro-specs:,logfile:,trace: -- "$@")"
eval set --"$options"
while [ $# -gt 0 ]; do
case "$1" in
-t|--tmpfs)
if [ $# -gt 1 ] && [[ ! "$2" = --* ]] && [ ! -z "$2" ]; then
SANDBOX_TMPFS="$2"
set_sandbox_tmpfs
shift 2
else
SANDBOX_TMPFS="" #Later we use [ -z ${SANDBOX_TMPFS+x} ] to check that this is set
set_sandbox_tmpfs
shift 1
fi; ;;
-r|--root)
if [ $# -gt 1 ] && [[ ! "$2" = --* ]] && [ ! -z "$2" ]; then
SANDBOX_ROOT="$2"
shift 2
else
SANDBOX_ROOT="" #Later we use [ -z ${SANDBOX_ROOT+x} ] to check that this is set
shift 1
fi; ;;
-f|-n|--fake-root|--new-root)
if [ $# -gt 1 ] && [[ ! "$2" = --* ]] && [ ! -z "$2" ]; then
FAKEROOT="$2"
set_fakeroot
shift 2
else
FAKEROOT="" #Later we use [ -z ${FAKEROOT+x} ] to check that this is set
set_fakeroot
shift 1
fi; ;;
-s|--save) #$SANDBOX_IMG
#if [ $# -gt 1 ] && [[ ! "$2" = --* ]] && [ ! -z "$2" ]; then
if [ -d "$2" ]; then
SANDBOX_IMG=$2
savebranch=$2
else [ -f "$2" ]
#mnt_sb_immage
#mount -o loop "$rwbranch" $SANDBOX_IMG;
savebranch=$1
loop=$(losetup-FULL -a | grep "$savebranch" | sed "s/:.*$//")
if [ ! -z "$loop" ]; then
SANDBOX_IMG=$(/proc/mounts | grep $loop | cut -d " " -f2)
else
SANDBOX_IMG=""
set_sandbox_img
fi
shift 2;
fi; ;;
--pupmode)
if [ $# -gt 1 ] && [[ ! "$2" = --* ]] && [ ! -z "$2" ]; then
PUPMODE=$2
shift 2
else
PUPMODE=2
shift
fi
;;
--pmedia) PMEDIA=$2; shift 2; ;;
-d| --pdrv) PDRV=$2; shift 2; ;;
--psubdir) PSUBDIR=$2;
shift 2; ;;
--distro-specs)
DISTRO_SPECS=$2;
. "$DISTRO_SPECS"
shift 2
;;
-l|--logfile)
LOGFILE=$2
[ -z "$TRACE" ] && TRACE=true
shift 2
log init
;;
-t|--trace)
TRACE=$2
if [ $# -gt 1 ] && [[ ! "$2" = --* ]] && [ ! -z "$2" ]; then
TRACE="$2"
shift 2
else
TRACE=true
shift 1
fi
log init
;;
--)
shift 1
options2+=( "$@" )
break; ;;
*)
options2+=( "$1" )
shift 1; ;;
esac
done
if [ -z ${SANDBOX_ROOT+x} ] && [ -z ${FAKEROOT+x} ]; then
SANDBOX_ROOT="" #Later this will change to SANDBOX_ROOT=/mnt/sb
set_fakeroot
[ -z $SANDBOX_IMG ] && set_sandbox_img
fi
#SANDBOX_TMPFS=$SANDBOX_ROOT/sandbox # mounted rw location of
#SANDBOX_TMPFS=$SANDBOX_ROOT/initrd/mnt/tmpfs/pup_rw
#tmpfs used for sandbox
#SANDBOX_ID=
TMPFILE=$(mktemp -p /tmp)
# use namespaces if available
#[ -e /proc/1/ns/pid ] && [ -e /proc/1/ns/mnt ] && type unshare >/dev/null && USE_NS=1
# umount all if we are accidentally killed
#trap 'umountall' 1
#s243a don't unmount on error
# 0.1 must be root
if [ $(id -u) -ne 0 ]; then
echo "You must be root to use sandbox."
exit
fi
## 0.2 cannot launch sandbox within sandbox
#if [ "$AUFS_ROOT_ID" != "" ] ; then
# grep -q $SANDBOX_ROOT /sys/fs/aufs/$AUFS_ROOT_ID/br0 &&
# echo "Cannot launch sandbox within sandbox." && exit
#fi
# s243a we are remounting everything rather then creating a sandbox.
# 0.3 help
case "$1" in
--help|-h)
echo "Usage: ${0##*/}"
echo "Starts an in-memory (throwaway) sandbox. Type 'exit' to leave."
exit
esac
## 0.4 if not running from terminal but in Xorg, then launch via terminal
#! [ -t 0 ] && [ -n "$DISPLAY" ] && exec $XTERM -e "$0" "$@"
#! [ -t 0 ] && exit
## 0.5 is this the first sandbox? If not, then create another name for mountpoints
#if grep -q $FAKEROOT /proc/mounts; then
# FAKEROOT=$(mktemp -d -p $SANDBOX_ROOT ${FAKEROOT##*/}.XXXXXXX)
# SANDBOX_ID=".${FAKEROOT##*.}"
# SANDBOX_TMPFS=$SANDBOX_ROOT/${SANDBOX_TMPFS##*/}${SANDBOX_ID}
# rmdir $FAKEROOT
#fi
# 1. get aufs system-id for the root filesystem
if [ -z "$AUFS_ROOT_ID" ] ; then
AUFS_ROOT_ID=$(
awk '{ if ($2 == "/" && $3 == "aufs") { match($4,/si=[0-9a-f]*/); print "si_" substr($4,RSTART+3,RLENGTH-3) } }' /proc/mounts
)
fi
# 2. get branches, then map branches to mount types or loop devices
items=$(
{ echo ==mount==; cat /proc/mounts;
echo ==losetup==; losetup-FULL -a;
echo ==branches==; ls -v /sys/fs/aufs/$AUFS_ROOT_ID/br[0-9]* | xargs sed 's/=.*//'; } | \
awk '
/==mount==/ { mode=1 }
/==losetup==/ { mode=2 }
/==branches==/ { mode=3 }
{
if (mode == 1) {
# get list of mount points, types, and devices - index is $3 (mount points)
mountdev[$2]=$1
mounttypes[$2]=$3
} else if (mode == 2) {
# get list of loop devices and files - index is $1 (loop devs)
sub(/:/,"",$1)
sub(/.*\//,"",$3); sub(/)/,"",$3)
loopdev[$1]=$3
} else if (mode == 3) {
# map mount types to loop files if mount devices is a loop
for (m in mountdev) {
if ( loopdev[mountdev[m]] != "" ) mounttypes[m]=loopdev[mountdev[m]]
}
# for (m in mountdev) print m " on " mountdev[m] " type " mounttypes[m]
mode=4
} else if (mode==4) {
# print the branches and its mappings
if ($0 in mounttypes){
print $0, mounttypes[$0], "on"
}
else {
MNT_PATH=$0
sub(/^.*[\/]/,"")
print MNT_PATH, $0, "on"
}
}
}
'
)
# '
# 3. Ask user to choose the SFS
log stop
dialog --separate-output --backtitle "tmpfs sandbox" --title "sandbox config" \
--checklist "Choose which SFS you want to use" 0 0 0 $items 2> $TMPFILE
chosen="$(cat $TMPFILE)"
log start
clear
if [ -z "$chosen" ]; then
echo "Cancelled or no SFS is chosen - exiting."
exit 1
fi
# 4. convert chosen SFS to robranches
robranches=""
for a in $(cat $TMPFILE) ; do
robranches=$robranches:$a=ro
done
rm $TMPFILE
# 5. get location of rw image
[ -z ${savebranch+x} ] && choose_save
mkdir -p $SANDBOX_IMG
[ ${#SANDBOX_IMG} -gt 1 ] || echo "Pathlenth too short SANDBOX_IMG='$SANDBOX_IMG'"
if [ ! -z "$savebranch" ]; then
if [ -f "$savebranch" ]; then
loop=$(losetup-FULL -a | grep "$savebranch" | sed "s/:.*$//" )
if [ ! -z "$loop" ]; then
SANDBOX_IMG=$(cat /proc/mounts | grep $loop | cut -d " " -f2)
else
mount -o loop "$savebranch" $SANDBOX_IMG
fi
fi
fi
#[ ${#SANDBOX_IMG} -gt 1 ] || echo "Pathlenth too short SANDBOX_IMG='$SANDBOX_IMG'"
#if [ -z "$rwdir" ] ; then #savebranch
if [ ! -z "$PUPMODE" ]; then
if [ $PUPMODE -ne 5 ] && [ $PUPMODE -ne 13 ] && [ $PUPMODE -ne 77 ]; then
if [ -z ${SANDBOX_TMPFS+x} ]; then
SANDBOX_TMPFS="" #Later we use [ -z ${SANDBOX_TMPFS+x} ] to check that this is set
fi
fi
fi
#fi
# # 4. make the mountpoints if not exist yet
# if [ ! -z "$SANDBOX_IMG" ]; then
# mkdir -p $SANDBOX_IMG
# mount -o loop "$savebranch" $SANDBOX_IMG || {
# echo "Failed to mount '$savebranch' at '$SANDBOX_IMG'"
# exit
# }
#fi
if [ ! -z "$SANDBOX_ROOT" ]; then
DEV_SAVE=$SANDBOX_ROOT/dev_save
mkdir -p "$DEV_SAVE"
if [ -z "$PDRV" ]; then
if [[ "$SANDBOX_IMG" = *"/mnt/"* ]]; then
PSUBDIR=${SANDBOX_IMG#/mnt/*/}
PDRV=${SANDBOX_IMG%"/$PSUBDIR"}
PDRV_real=$(cat /proc/mounts | grep $(realpath $PDRV) | cut -d " " -f1)
PSUBDIR_i=${PSUBDIR}
PDRV_i=${PDRV}
PDRV_real_i=${PDRV_real}
while (true); do
if [[ PDRV_real_i = /dev/loop* ]]; then
PDRV_real_i=$(losetup-FULL -a | grep "$(basename PDRV_real)")
PDRV_real_i=${PDRV_real#*(}
PDRV_real_i=${PDRV_real%)}
PSUBDIR_i=${PDRV_real_i#/mnt/*/}
PDRV_real=$PSUBDIR_i/$PDRV_real
PDRV_real_i=${SANDBOX_IMG%"/$PSUBDIR_i"}
PDRV_real_i=$(cat /proc/mounts | grep $(realpath $PDRV_real_i) | cut -d " " -f1)
elif [[ PDRV_real_i = /dev/* ]]; then
PDRV_real=$(blkid | grep $PDRV_real)
break
else
echo "could not identify PDRV_real"
break
fi
done
fi
fi
fi
#if [ -z $PDRV ]; then
# case "$(uname -a)"
#fi
[ -z $PDRV ] && PDRV=/mnt/home
if [ -z "$SANDBOX_IMG" ] || [ ! -z ${SANDBOX_TMPFS+x} ]; then
if [ -z "$SANDBOX_TMPFS" ] ; then
#SANDBOX_TMPFS=$SANDBOX_ROOT/sandbox
set_sandbox_tmpfs
#if grep -q $SANDBOX_TMPFS /proc/mounts; then
# #FAKEROOT=$(mktemp -d -p $SANDBOX_ROOT ${FAKEROOT##*/}.XXXXXXX)
# #SANDBOX_ID=".${FAKEROOT##*.}"
# SANDBOX_TMPFS=$SANDBOX_ROOT/${SANDBOX_ID/}${SANDBOX_ID}
# mkdir -p -f SANDBOX_TMPFS
# mount -t tmpfs none $SANDBOX_TMPFS; #We could exit if this fails but we don't need to becuase we can still write to SANDBOX_TMPFS even if it isn't tmpfs.
# rmdir $FAKEROOT
#fi
fi
if [ ! -z "${SANDBOX_TMPFS}" ] && [ ! -z "$(grep -q ${SANDBOX_TMPFS} /proc/mounts)" ]; then
mount -t tmpfs none $SANDBOX_TMPFS;
fi
elif [ ! -z "${SANDBOX_TMPFS}" ]; then
if [ ! -z "${SANDBOX_TMPFS}" ] && [ ! -z "$(grep -q ${SANDBOX_TMPFS} /proc/mounts)" ]; then
mount -t tmpfs none $SANDBOX_TMPFS;
fi
fi
if [ -z "$SANDBOX_TMPFS" ]; then
SANDBOX_TMPFS=$SANDBOX_IMG
else
if [ $robranches ~= ** ]; then
robranches=$SANDBOX_IMG=rr:$robranches
fi
fi
mkdir -p $FAKEROOT
#mk_initrd_dir
# 5. do the magic - mount the rw image first, and then the rest with aufs
#if mount -o loop "$rwbranch" $SANDBOX_IMG; then
if [ ${#FAKEROOT} -gt 1 ] && ! grep -q $FAKEROOT /proc/mounts; then
echo "mount -t aufs -o \"br:$SANDBOX_TMPFS=rw$robranches\" aufs ${FAKEROOT}"
echo "About to mount FAKEROOT at $FAKEROOT"
read -p "Press enter to continue"
mount -t aufs -o "br:$SANDBOX_TMPFS=rw$robranches" aufs ${FAKEROOT}
# 5. record our new aufs-root-id so tools don't hack real filesystem
SANDBOX_AUFS_ID=$(grep $FAKEROOT /proc/mounts | sed 's/.*si=/si_/; s/ .*//') #'
sed -i -e '/AUFS_ROOT_ID/ d' $FAKEROOT/etc/BOOTSTATE 2> /dev/null
echo AUFS_ROOT_ID=$SANDBOX_AUFS_ID >> $FAKEROOT/etc/BOOTSTATE
# 7. sandbox is ready, now just need to mount other supports - pts, proc, sysfs, usb and tmp
mkdir -p $FAKEROOT/dev $FAKEROOT/sys $FAKEROOT/proc $FAKEROOT/tmp
mkdir -p "$DEV_SAVE/${PSUBDIR}"
mount -o bind "$PDRV/${PSUBDIR}" "$DEV_SAVE/${PSUBDIR}"
#mount -o bind "$DEV_SAVE/${PSUBDIR}" "$FAKEROOT/initrd/mnt/dev_save"
mount -o bind "$DEV_SAVE" "$FAKEROOT/initrd/mnt/dev_save"
#Maybe optionally do this based on some input paramater:
#Also pull these layers from an array
for layer_name in "pup_ro2" "pup_ro3" "pup_ro4" "pup_ro5" "pup_z"; do
layer="$(eval 'echo $'$layer_name)"
if [ ! -z "$layer" ] ; then
mount -o bind "$layer" "$FAKEROOT/initrd/$layer_name"
fi
done
case "$(uname -a)" in
*fatdog*)
mkdir -p "$FAKEROOT/aufs"
#mount -o bind "$DEV_SAVE/${PSUBDIR}" "$FAKEROOT/aufs/dev_save"
mkdir -p "$FAKEROOT/aufs/dev_save"
mount -o bind /mnt/home "$FAKEROOT/aufs/dev_save"
cd $FAKEROOT
#mkdir -p mnt/home
cd mnt
ln -s home ../aufs/dev_save
pup_save="$SANDBOX_IMG"
mount -o bind "$pup_save" "$FAKEROOT/aufs/pup_save"
base_sfs=/aufs/pup_ro
mount -o bind "$base_sfs" "$FAKEROOT/aufs/pup_ro"
if [ "$SANDBOX_TMPFS" != "$SANDBOX_IMG" ]; then
pup_rw="$SANDBOX_TMPFS"
mount -o bind "$pup_rw" "$FAKEROOT/aufs/pup_rw"
fi
;;
*) #assume this is puppy
mk_initrd_dir
#mkdir -p "$FAKEROOT/initrd/mnt/dev_save"
#mount -o bind /mnt/home "$FAKEROOT/initrd/mnt/dev_save"
#mkdir $FAKEROOT/mnt
#cd $FAKEROOT/mnt
#ln -s ../initrd/mnt/dev_save
;;
esac
mkdir -p $FAKEROOT/mnt/home
mount -o rbind /dev $FAKEROOT/dev
mount -t sysfs none $FAKEROOT/sys
mount -t proc none $FAKEROOT/proc
if [ PUPMODE = 2 ] || [[ "$(uname -a)" = *fatdog* ]]; then #Full Install #Maybe don't base this on PUPMODE
tmp_des=$FAKEROOT/tmp
tmp_source=/tmp
else
#case "$(uname -a)" in
#*fadog*)
#
#*) #assume this is puppy
mkdir -p $FAKEROOT/initrd/mnt/tmpfs
tmp_des=$FAKEROOT/initrd/mnt/tmpfs
tmp_source=/initrd/mnt/tmpfs
cd $FAKEROOT
rm tmp
ln -s initrd/mnt/tmpfs tmp
fi
mount -o bind $tmp_source $tmp_des
cd $FAKEROOT
case "$(uname -a)" in
*fatdog*)
mkdir -p $FAKEROOT/aufs
mount -o bind $SANDBOX_TMPFS $FAKEROOT/$SANDBOX_TMPFS
;;
*) #assume this is puppy
mk_initrd_dir
#ln -s initrd/mnt/tmpfs tmp
#mkdir -p $FAKEROOT/$SANDBOX_TMPFS
#mount -o bind $SANDBOX_TMPFS $FAKEROOT/$SANDBOX_TMPFS # so we can access it within sandbox
;;
esac
# #mkdir -p $FAKEROOT/$SANDBOX_TMPFS
# mkdir -p $FAKEROOT/$SANDBOX_IMG
# mount -o bind $SANDBOX_IMG $FAKEROOT/$SANDBOX_IMG # so we can access it within sandbox
cp /usr/share/sandbox/* $FAKEROOT/usr/bin 2> /dev/null
# 8. optional copy, to enable running sandbox-ed xwin
cp /usr/share/sandbox/* $FAKEROOT/usr/bin 2> /dev/null
# 9. make sure we identify ourself as in sandbox - and we're good to go!
echo -e '\nexport PS1="sandbox'${SANDBOX_ID}'# "' >> $FAKEROOT/etc/shinit #fatdog 600
sed -i -e '/^PS1/ s/^.*$/PS1="sandbox'${SANDBOX_ID}'# "/' $FAKEROOT/etc/profile # earlier fatdog
if [ -d "$FULL_SAVE_PATH" ]; then #TODO verify that this works with a save file
if [ $PUPMODE -eq 13 ] && [ $PUPMODE -eq 77 ]; then
#TODO: when PUPMODE=77 (multisession cd) we need to copy folders. See: https://github.com/puppylinux-woof-CE/woof-CE/blob/c483d010a8402c5a1711517c2dce782b3551a0b8/initrd-progs/0initrd/init#L1084
#and copy_folders() https://github.com/puppylinux-woof-CE/woof-CE/blob/c483d010a8402c5a1711517c2dce782b3551a0b8/initrd-progs/0initrd/init#L482
#https://github.com/puppylinux-woof-CE/woof-CE/blob/c483d010a8402c5a1711517c2dce782b3551a0b8/initrd-progs/0initrd/init#L1091
mount -o remount,prepend:"$FULL_SAVE_PATH"=rw,mod:"$SANDBOX_TMPFS"=ro,del:"$SANDBOX_TMPFS" "$FAKEROOT"
#mount -o remount,add:1:"$FULL_SAVE_PATH"=ro+wh "$FAKEROOT"
fi
fi
echo "Starting sandbox now."
log stop
if [ $USE_NS ]; then
unshare -f -p --mount-proc=$FAKEROOT/proc chroot $FAKEROOT
else
chroot $FAKEROOT
fi
log start
# 8. done - clean up everything
umountall
echo "Leaving sandbox."
elif [ "${FAKEROOT:-/}" = "/" ]; then
#[ -z "$FAKEROOT" ] && $FAKEROOT="/"
echo "mount -t aufs -o \"remount,br:$SANDBOX_TMPFS=rw$robranches\" aufs ${FAKEROOT:-/}"
echo "Warning! about to remount rootfs at $FAKEROOT"
read -p "Press enter to continue"
trap - 1 #Clear traps
trap
mount -t aufs -o "br:$SANDBOX_TMPFS=rw$robranches" aufs ${FAKEROOT:-/};
mkdir -p /dev /sys /proc /tmp #These probably already exist
[[ "`mountpoint /dev`" != *"is a mountpoint"* ]] && mount -t devtmpfs devtmpfs /dev
mkdir -p /initrd/mnt/tmpfs
[[ "`mountpoint /initrd/mnt/tmpfs`" != *"is a mountpoint"* ]] && mount -t tmpfs none /initrd/mnt/tmpfs
mkdir -p /initrd/mnt/tmpfs/tmp
if [[ "`mountpoint /tmp`" != *"is a mountpoint"* ]]; then
if [[ "`mountpoint /initrd/mnt/tmpfs`" != *"is a mountpoint"* ]]; then
mount -o bind /initrd/mnt/tmpfs/tmp /tmp
else
mount -t tmpfs none /tmp
fi
fi
else
echo "not implemented for FAKEROOT=${FAKEROOT:-/}}"
exit
fi
#else
# echo "Unable to mount aufs br:$SANDBOX_IMG=rw$robranches"
# umount -l $SANDBOX_IMG
#fi
#else
# echo "unable to mount rw image: $rwbranch"
#fi
Comments