#!/bin/sh
# Script for complete image backup
# License: GPLv2 or later
Version="1.35 vom 20.01.2024"
Copyright="(C) 2018-2024 DboxOldie / BPanther / Frankenstone / Fritz / DdD"

#
file=$0
model=`cat /proc/stb/info/model`
[ -e /proc/stb/info/vumodel ] && vumodel=`cat /proc/stb/info/vumodel`
[ "$model" == "dm8000" ] && [ "$vumodel" == "solo4k" ] && model=$vumodel
[ "$model" == "dm8000" ] && [ "$vumodel" == "duo4k" ] && model=$vumodel
[ "$model" == "dm8000" ] && [ "$vumodel" == "duo4kse" ] && model=$vumodel
[ "$model" == "dm8000" ] && [ "$vumodel" == "zero4k" ] && model=$vumodel
[ "$model" == "dm8000" ] && [ "$vumodel" == "ultimo4k" ] && model=$vumodel
[ "$model" == "dm8000" ] && [ "$vumodel" == "uno4k" ] && model=$vumodel
[ "$model" == "dm8000" ] && [ "$vumodel" == "uno4kse" ] && model=$vumodel
save_path="/tmp"
tmproot="/tmp/buroot"
multiroot="/tmp/multiroot"
prefix="imgbackup"
destname="${prefix}_$(hostname)_$(date +%Y%m%d_%H%M)"
archive="tgz"
knl=0
klen=0
bz2=$(which bzip2)
hexd=$(which hexdump)
xxdmp=$(which xxd)
prtd=$(which parted)
new_layout=0
multi=0
gui_mode=0
bkp_part=1
magic_number="0x016f2818" # HD51 / BRE2ZE4K / ZGEMMA H7 / VUSOLO4K / VUDUO4K / VUDUO4KSE / VUZERO4K / UTLIMATE4K / UNO4K / UNO4KSE / E4HDULTRA / PROTEK4K
dtb_magic_number="0xd00dfeed"

#
# Subroutine für VUSOLO4K / VUDUO4K / VUDUO4KSE / VUZERO4K / UTLIMATE4K / UNO4K / UNO4KSE
#
read_bootargs_vu()
{
	rootmtd=`readlink /dev/root`
	if [ -z "$prtd" ]; then
		echo "  parted nicht gefunden - Abbruch!" && exit
	else
		PARTS=`parted /dev/mmcblk0 print free -s`
	fi
	[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_1 | awk '{print $1}'`" ] && bkp_part=1
	[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_2 | awk '{print $1}'`" ] && bkp_part=2
	[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_3 | awk '{print $1}'`" ] && bkp_part=3
	[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_4 | awk '{print $1}'`" ] && bkp_part=4
}

#
# Subroutine für AX HD51 / Bre2ze 4K / Zgemma H7 / E4HD 4K Ultra / Protek 4K UHD
#
read_bootargs()
{
	rootsubdir=""
	kdev=""
	[ -e /sys/firmware/devicetree/base/chosen/bootargs ] && bootargs="/sys/firmware/devicetree/base/chosen/bootargs" || bootargs="/proc/cmdline"
	for i in $(cat $bootargs);do
		[ -n "$(echo $i | grep 'root=')" ] && rootmtd=$(echo $i | cut -d '=' -f2 | cut -d '/' -f3)
		[ -n "$(echo $i | grep 'rootsubdir=')" ] && rootsubdir=$(echo $i | cut -d '=' -f2)
		[ -n "$(echo $i | grep 'kernel=')" ] && kdev=$(echo $i | cut -d '=' -f2)
	done
	[ -n "$rootsubdir" -a -n "$kdev" ] && new_layout=1
	if [ $new_layout == 1 ];then
		multidev=$(readlink /dev/block/by-name/userdata | cut -d "/" -f 3)
		kernelnumber=$(echo ${kdev:13:1})
		[ $kernelnumber == 2 ] && bkp_part=1
		[ $kernelnumber == 4 ] && bkp_part=2
		[ $kernelnumber == 5 ] && bkp_part=3
		[ $kernelnumber == 6 ] && bkp_part=4
	else
		[ "$rootmtd" == "mmcblk0p3" ] && bkp_part=1
		[ "$rootmtd" == "mmcblk0p5" ] && bkp_part=2
		[ "$rootmtd" == "mmcblk0p7" ] && bkp_part=3
		[ "$rootmtd" == "mmcblk0p9" ] && bkp_part=4
	fi
}

select_backup_dir() {
	IFS_OLD=$IFS
	IFS=$'\n'
	msgb=0
	loop=0
	OPT="$save_path",`echo "" && mount | grep /dev/sd | awk '{print $3.","}' && mount | grep /mnt | awk '{print $3.","}'`
	OPT=`echo "$OPT" | grep -v "/tmp/mnt"`
	while [ "$msgb" != "1" -o $loop -lt 2 ]; do
		OPT_TMP=`echo "$OPT" | sed 's/"//g'`
		msgbox title="Backupverzeichnis auswählen" msg="" select="$OPT_TMP" order=2
		msgb=$?
		if [ "$msgb" != "0" ]; then
			cnt=0
			for DIR in $OPT; do
				cnt=$((cnt + 1))
				DIR=`echo "$DIR" | sed 's/,//g' | sed 's/"//g'`
				[ "$cnt" == "$msgb" ] && save_path="$DIR" && break
			done
		else
			echo "  Abbruch!" && exit
		fi
		OPT=`echo "" && find "$save_path" -type d -maxdepth 1 | awk '{print "\""$0"\","}'`
		OPT_SYM=`find "$save_path" -type l -maxdepth 1`
		for datei in $OPT_SYM; do
			if [[ -L "$datei" && -d "$datei" ]]; then
				OPT=`echo "$OPT" && echo "$datei" | awk '{print "\""$0"\","}'`
			fi
		done
		OPT=`echo "$OPT" | grep -v "/tmp/mnt"`
		loop=$((loop + 1))
	done
	IFS=$IFS_OLD
}

#
# Root und Kernel Partition bestimmen
#
if [ "$model" == "hd51" -o "$model" == "h7" -o "$model" == "bre2ze4k" -o "$model" == "e4hd" -o "$model" == "protek4k" ]; then
	read_bootargs
else
	read_bootargs_vu
fi

#
# Parameter auslesen
#
while [ $# -gt 0 ]
do
	parm=$1
	[ "$parm" == "none" ] && archive=$parm
	[ "$(echo ${parm:0:1})" == "/" ] && save_path=$parm
	[ "$parm" == "select_dir" ] && select_dir=1

	if [ "$parm" == "gui" ] && [ "$model" == "solo4k" -o "$model" == "ultimo4k" -o "$model" == "uno4k" -o "$model" == "uno4kse" ] && [ "$rootmtd" == "mmcblk0p4" ]; then
		parm="nogui" && select_dir=1
	elif [ "$parm" == "gui" ] && [ "$model" == "zero4k" ] && [ "$rootmtd" == "mmcblk0p7" ]; then
		parm="nogui" && select_dir=1
	elif [ "$parm" == "gui" ] && [ "$model" == "duo4k" -o "$model" == "duo4kse" ] && [ "$rootmtd" == "mmcblk0p9" ]; then
		parm="nogui" && select_dir=1
	fi

	if [ "$parm" == "gui" ]; then
		gui_mode=1
		if [ -z "$prtd" ]; then
			msgbox title="parted nicht gefunden" msg="~cPartitionen auf 4 gesetzt." icon="error"
			part_count=4
		else
			[ $new_layout == 1 ] && part_count=`$prtd /dev/mmcblk0 print | grep -c linuxkernel` || part_count=`$prtd /dev/mmcblk0 print | grep -c rootfs`
		fi
		[ $part_count -gt 2 ] && PART_3=", Partition 3"
		[ $part_count -gt 3 ] && PART_4=", Partition 4"
		msgbox title="Partitions-Backup erstellen" msg="~cDiese Partitionen stehen zur Auswahl:" select="Partition 1, Partition 2 $PART_3 $PART_4" order=4 default=$bkp_part
		parm=-m$?
		[ "$parm" == "-m0" ] && echo "  Abbruch!" && exit
		B_PART=`echo "Backup Partition: ${parm:2:3}"`
	fi
	if [ "$parm" == "-m1" ]; then
		if [ "$model" == "hd51" -o "$model" == "h7" -o "$model" == "bre2ze4k" -o "$model" == "e4hd" -o "$model" == "protek4k" ]; then
			[ $new_layout == 0 ] && rootmtd=mmcblk0p3 && multi=1
			[ $new_layout == 1 ] && kernelnumber=2 && rootsubdir="linuxrootfs1" && rootmtd=mmcblk0p3 && multi=1
		elif [ "$model" == "solo4k" -o "$model" == "ultimo4k" -o "$model" == "uno4k" -o "$model" == "uno4kse" -o "$model" == "zero4k" -o "$model" == "duo4k" -o "$model" == "duo4kse" ]; then
			rootmtd=`echo -n "mmcblk0p" && echo "$PARTS" | grep rootfs_1 | awk '{print $1}'` && multi=1
		fi
		destname=${destname/${prefix}/${prefix}-${parm:1:2}}
		B_PART=`echo "Backup Partition: ${parm:2:3}"`
	elif [ "$parm" == "-m2" ]; then
		if [ "$model" == "hd51" -o "$model" == "h7" -o "$model" == "bre2ze4k" -o "$model" == "e4hd" -o "$model" == "protek4k" ]; then
			[ $new_layout == 0 ] && rootmtd=mmcblk0p5 && multi=1
			[ $new_layout == 1 ] && kernelnumber=4 && rootsubdir="linuxrootfs2" && rootmtd=$multidev && multi=1
		elif [ "$model" == "solo4k" -o "$model" == "ultimo4k" -o "$model" == "uno4k" -o "$model" == "uno4kse" -o "$model" == "zero4k" -o "$model" == "duo4k" -o "$model" == "duo4kse" ]; then
			rootmtd=`echo -n "mmcblk0p" && echo "$PARTS" | grep rootfs_2 | awk '{print $1}'` && multi=1
		fi
		destname=${destname/${prefix}/${prefix}-${parm:1:2}}
		B_PART=`echo "Backup Partition: ${parm:2:3}"`
	elif [ "$parm" == "-m3" ]; then
		if [ "$model" == "hd51" -o "$model" == "h7" -o "$model" == "bre2ze4k" -o "$model" == "e4hd" -o "$model" == "protek4k" ]; then
			[ $new_layout == 0 ] && rootmtd=mmcblk0p7 && multi=1
			[ $new_layout == 1 ] && kernelnumber=5 && rootsubdir="linuxrootfs3" && rootmtd=$multidev && multi=1
		elif [ "$model" == "solo4k" -o "$model" == "ultimo4k" -o "$model" == "uno4k" -o "$model" == "uno4kse" -o "$model" == "zero4k" -o "$model" == "duo4k" -o "$model" == "duo4kse" ]; then
			rootmtd=`echo -n "mmcblk0p" && echo "$PARTS" | grep rootfs_3 | awk '{print $1}'` && multi=1
		fi
		destname=${destname/${prefix}/${prefix}-${parm:1:2}}
		B_PART=`echo "Backup Partition: ${parm:2:3}"`
	elif [ "$parm" == "-m4" ]; then
		if [ "$model" == "hd51" -o "$model" == "h7" -o "$model" == "bre2ze4k" -o "$model" == "e4hd" -o "$model" == "protek4k" ]; then
			[ $new_layout == 0 ] && rootmtd=mmcblk0p9 && multi=1
			[ $new_layout == 1 ] && kernelnumber=6 && rootsubdir="linuxrootfs4" && rootmtd=$multidev && multi=1
		elif [ "$model" == "solo4k" -o "$model" == "ultimo4k" -o "$model" == "uno4k" -o "$model" == "uno4kse" -o "$model" == "zero4k" -o "$model" == "duo4k" -o "$model" == "duo4kse" ]; then
			rootmtd=`echo -n "mmcblk0p" && echo "$PARTS" | grep rootfs_4 | awk '{print $1}'` && multi=1
		fi
		destname=${destname/${prefix}/${prefix}-${parm:1:2}}
		B_PART=`echo "Backup Partition: ${parm:2:3}"`
	fi
	shift
done

[ "$gui_mode" == "1" -o "$select_dir" == "1" ] && select_backup_dir

[ "$archive" == "none" ] && save_path="$save_path/$destname"

rootnumber=`echo ${rootmtd:8:2}`
mmcprefix=`echo ${rootmtd:0:8}`

B_DIR=`echo "Backup Verzeichnis: $save_path"`
if [ $new_layout == 1 ]; then
	mkdir -p $multiroot
	mount /dev/$rootmtd $multiroot
	rootfs_size=$(du -s $multiroot/$rootsubdir | tail -n1 | awk '{print $1}')
	umount -f $multiroot
	[ -z "$(mount | grep $multiroot)" ] && rmdir $multiroot
else
	rootfs_size=`df /dev/$rootmtd | tail -n1 | awk '{print $3}'`
fi
rootfs_size=$((rootfs_size * 2 + 5038080 / 1024))
check_df=`df "$save_path" | tail -n1 | wc -w`
[ $check_df -eq 5 ] && save_path_size=`df "$save_path" | tail -n1 | awk '{print $3}'` || save_path_size=`df "$save_path" | tail -n1 | awk '{print $4}'`

echo "  Image Backup (Version: $Version)"
echo "  $Copyright"
echo "  AX HD51 4K, Bre2ze 4K, ZGEMMA H7, AXAS E4HD 4K ULTRA, PROTEK 4K UHD"
echo "  VU+ DUO 4K, VU+ DUO 4K SE, VU+ UNO 4K, VU+ UNO 4K SE, VU+ ZERO 4K, VU+ ULTIMO 4K und VU+ SOLO 4K"
echo
echo "  $B_PART"
echo "  $B_DIR"
echo
echo "  Imagegröße (x2) inkl. Kernel: $((rootfs_size / 1024)) MB"
echo "  Backup Verzeichnisgröße: $((save_path_size / 1024)) MB"

[ $(($save_path_size / 1024)) -lt $(($rootfs_size / 1024)) ] && echo "  Platz im Zielverzeichnis: FEHLER, zu klein -> ABBRUCH." && exit
echo "  Platz im Zielverzeichnis: OK"
echo

df "$save_path" | grep -q tmpfs && DIR_CHECK=$? || DIR_CHECK=$?
[ "$DIR_CHECK" == "0" ] && [ "${save_path:0:4}" != "/tmp" ] && echo "  Das gewählte Verzeichnis ist ungültig !" && exit

if [ "$model" == "hd51" -o "$model" == "h7" -o "$model" == "bre2ze4k" -o "$model" == "e4hd" -o "$model" == "protek4k" ]; then
	echo "  Image Backup für Boxmodel '$model' startet..."
	[ $new_layout == 0 ] && kernelnumber=$((rootnumber - 1))
elif [ "$model" == "solo4k" -o "$model" == "ultimo4k" -o "$model" == "uno4k" -o "$model" == "uno4kse" ]; then
	case $rootmtd in
		mmcblk0p4)
			kernelnumber=$((rootnumber - 3));;
		*)
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_1 | awk '{print $1}'`" ] && multipart=1
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_2 | awk '{print $1}'`" ] && multipart=2
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_3 | awk '{print $1}'`" ] && multipart=3
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_4 | awk '{print $1}'`" ] && multipart=4
			kernelnumber=$((rootnumber - 1));;
	esac
	echo "  Image Backup für Boxmodel '$model' startet..."
elif [ "$model" == "zero4k" ]; then
	case $rootmtd in
		mmcblk0p7)
			kernelnumber=$((rootnumber - 3));;
		*)
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_1 | awk '{print $1}'`" ] && multipart=1
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_2 | awk '{print $1}'`" ] && multipart=2
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_3 | awk '{print $1}'`" ] && multipart=3
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_4 | awk '{print $1}'`" ] && multipart=4
			kernelnumber=$((rootnumber - 1));;
	esac
	echo "  Image Backup für Boxmodel '$model' startet..."
elif [ "$model" == "duo4k" -o "$model" == "duo4kse" ]; then
	case $rootmtd in
		mmcblk0p9)
			kernelnumber=$((rootnumber - 3));;
		*)
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_1 | awk '{print $1}'`" ] && multipart=1
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_2 | awk '{print $1}'`" ] && multipart=2
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_3 | awk '{print $1}'`" ] && multipart=3
			[ "$rootmtd" == "`echo -n "mmcblk0p" && echo \"$PARTS\" | grep rootfs_4 | awk '{print $1}'`" ] && multipart=4
			kernelnumber=$((rootnumber - 1));;
	esac
	echo "  Image Backup für Boxmodel '$model' startet..."
else
	echo "  Box nicht unterstützt - Abbruch!"
	exit
fi
kernelmtd=$mmcprefix$kernelnumber

if [ -z "$bz2" ]; then
	echo "  Kein 'bzip2' im Image."
	echo "  Packen von 'rootfs${multipart}.tar.bz2' nicht möglich."
	echo "  Abbruch!"
	exit
fi

if [ $kernelnumber -lt 17 -a $kernelnumber -gt 0 ]; then
	echo
	echo "  Kerneldevice = $kernelmtd"
	if [ $new_layout == 1 ]; then
		echo "  -$model neues Flashlayout-"
		echo "  Rootdevice   = $rootsubdir auf $rootmtd"
	else
		echo "  Rootdevice   = $rootmtd"
	fi
else
	echo "  Kernel MTD nicht im Bereich (1..16)! > $kernelnumber"
	echo "  Abbruch!"
	exit
fi

k_backup()
{
	if [ -z "$hexd" -a -z "$xxdmp" ]; then
		echo "  Busybox Applets 'hexdump' und 'xxd' fehlen."
		klen=5038080
		echo "  Standard Kernel Länge wird benutzt > $klen Bytes werden ausgelesen."
		k_read
		knl=0
	else
		knl=1
		k_check
	fi
}

k_check()
{
# 16 Bytes ( 33 bis 49 ) aus Kernel Partition lesen
#
	if [ ! -z "$hexd" ]; then
		line=`dd if=/dev/$kernelmtd bs=1 skip=32 count=16 2> /dev/null | hexdump -C`
	elif [ ! -z "$xxdmp" ]; then
		line=`dd if=/dev/$kernelmtd bs=1 skip=32 count=16 2> /dev/null | xxd -g 1`
	fi

# Kernelmagic für zImage prüfen
#
	kmagic="0x"
	kmagic=$kmagic`echo $line | cut -d " " -f9`
	kmagic=$kmagic`echo $line | cut -d " " -f8`
	kmagic=$kmagic`echo $line | cut -d " " -f7`
	kmagic=$kmagic`echo $line | cut -d " " -f6`

	echo
	if [ "$kmagic" == "$magic_number" ]; then
		echo "  Magic für zImage gefunden > $kmagic == $magic_number"
	else
		echo "  Keine Magic für zImage gefunden > $kmagic != $magic_number"
		echo "  Kernel Backup übersprungen."
		knl=0
	fi
	if [ "$knl" == "1" ]; then
# zImage Länge bestimmen
#
		zimage_len="0x"
		zimage_len=$zimage_len`echo $line | cut -d " " -f17`
		zimage_len=$zimage_len`echo $line | cut -d " " -f16`
		zimage_len=$zimage_len`echo $line | cut -d " " -f15`
		zimage_len=$zimage_len`echo $line | cut -d " " -f14`
		echo "  zImage Länge = $((zimage_len)) Bytes"

# Prüfung auf DTB
#
# 16 Bytes ( ab zImage Länge ) aus Kernel Partition lesen
#
		if [ ! -z "$hexd" ]; then
			line=`dd if=/dev/$kernelmtd bs=1 skip=$((zimage_len)) count=16 2> /dev/null | hexdump -C`
		elif [ ! -z "$xxdmp" ]; then
			line=`dd if=/dev/$kernelmtd bs=1 skip=$((zimage_len)) count=16 2> /dev/null | xxd -g 1`
		fi

		dtb_magic="0x"
		dtb_magic=$dtb_magic`echo $line | cut -d " " -f2`
		dtb_magic=$dtb_magic`echo $line | cut -d " " -f3`
		dtb_magic=$dtb_magic`echo $line | cut -d " " -f4`
		dtb_magic=$dtb_magic`echo $line | cut -d " " -f5`

		if [ "$dtb_magic" == "$dtb_magic_number" ]; then
			echo "  DTB Bereich vorhanden."
# DTB Länge bestimmen
#
			dtb_len="0x"
			dtb_len=$dtb_len`echo $line | cut -d " " -f6`
			dtb_len=$dtb_len`echo $line | cut -d " " -f7`
			dtb_len=$dtb_len`echo $line | cut -d " " -f8`
			dtb_len=$dtb_len`echo $line | cut -d " " -f9`
			echo "  DTB Länge = $((dtb_len)) Bytes"
		else
			echo "  Kein DTB Bereich vorhanden."
			dtb_len=0
		fi

# Endgültige Kernellänge
#
		klen=$((zimage_len + dtb_len))
		echo "  Gesamt Kernel Länge = $klen Bytes"
		k_read
	fi
}
#
k_read()
{
# Kernel aus Partition auslesen
#
	count=`echo $((klen / 4096))`
	len1=`echo $((count * 4096))`
	rest=`echo $((klen - len1))`

	dd if=/dev/$kernelmtd of="$save_path"/kernel_1.bin bs=4096 count=$count 2> /dev/null
	dd if=/dev/$kernelmtd of="$save_path"/kernel_2.bin bs=1 count=$rest skip=$len1 2> /dev/null

	[ "$model" == "duo4k" -o "$model" == "duo4kse" -o "$model" == "uno4k" -o "$model" == "uno4kse" -o "$model" == "zero4k" -o "$model" == "ultimo4k" -o "$model" == "solo4k" ] && extname=${multipart}_auto
	cat "$save_path"/kernel_?.bin > "$save_path"/kernel$extname.bin

	rm -f "$save_path"/kernel_?.bin

	echo
	echo "  'kernel$extname.bin' in '$save_path' gespeichert."
}
#
r_backup()
{
	mkdir -p $tmproot
	if [ $multi == 1 ]; then
		if [ $new_layout == 1 ]; then
			mkdir -p $multiroot
			mount /dev/$rootmtd $multiroot
			mount --bind $multiroot/$rootsubdir $tmproot
			umount -f $multiroot
			[ -z "$(mount | grep $multiroot)" ] && rmdir $multiroot
		else
			mount /dev/$rootmtd $tmproot
		fi
	else
		mount --bind / $tmproot
	fi

	echo
	echo "  Erstelle 'rootfs${multipart}.tar.bz2'..."
	echo "  Dauer ca. 2-10 Minuten (je nach Imagegröße)..."
	tar -cjf "$save_path"/rootfs${multipart}.tar.bz2 -C $tmproot ./ 2> /dev/null

	umount -f $tmproot
	[ -z "$(mount | grep $tmproot)" ] && rmdir $tmproot

	if [ "$archive" == "tgz" ]; then
		echo "  Erstelle Image Archiv '$destname.tgz' in '$save_path'..."
		tar -czf "$save_path"/$destname.tgz -C "$save_path" kernel$extname.bin rootfs${multipart}.tar.bz2
		rm -f "$save_path"/kernel$extname.bin
		rm -f "$save_path"/rootfs${multipart}.tar.bz2
		echo
		echo "  Image Archiv '$destname.tgz' gespeichert in '$save_path'."
	else
		echo
		echo "  'rootfs${multipart}.tar.bz2' in '$save_path' gespeichert."
	fi
}

# main
mkdir -p "$save_path"
k_backup
r_backup

exit
