Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #!/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
Add Comment
Please, Sign In to add comment